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> 2004-02-01 Paolo Carlini <pcarlini@suse.de>
* include/bits/stl_bvector.h: Wrap overlong lines, constify * 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++ -*- // 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 // 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 // software; you can redistribute it and/or modify it under the
@ -72,7 +72,8 @@ namespace __gnu_norm
if (&__x != this) if (&__x != this)
{ {
if (__len >= __x.size()) 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 else
{ {
const_iterator __mid = __x.begin() + difference_type(__len); const_iterator __mid = __x.begin() + difference_type(__len);
@ -137,8 +138,8 @@ namespace __gnu_norm
} }
else else
{ {
difference_type __n = __last - __first; const difference_type __n = __last - __first;
difference_type __elems_before = __first - this->_M_start; const difference_type __elems_before = __first - this->_M_start;
if (static_cast<size_type>(__elems_before) < (size() - __n) / 2) if (static_cast<size_type>(__elems_before) < (size() - __n) / 2)
{ {
std::copy_backward(this->_M_start, __first, __last); std::copy_backward(this->_M_start, __first, __last);
@ -189,7 +190,8 @@ namespace __gnu_norm
template <typename _InputIterator> template <typename _InputIterator>
void void
deque<_Tp,_Alloc> 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(); iterator __cur = begin();
for ( ; __first != __last && __cur != end(); ++__cur, ++__first) for ( ; __first != __last && __cur != end(); ++__cur, ++__first)
@ -288,7 +290,7 @@ namespace __gnu_norm
_M_range_initialize(_ForwardIterator __first, _ForwardIterator __last, _M_range_initialize(_ForwardIterator __first, _ForwardIterator __last,
forward_iterator_tag) forward_iterator_tag)
{ {
size_type __n = std::distance(__first, __last); const size_type __n = std::distance(__first, __last);
this->_M_initialize_map(__n); this->_M_initialize_map(__n);
_Map_pointer __cur_node; _Map_pointer __cur_node;
@ -389,9 +391,7 @@ namespace __gnu_norm
_M_range_insert_aux(iterator __pos, _M_range_insert_aux(iterator __pos,
_InputIterator __first, _InputIterator __last, _InputIterator __first, _InputIterator __last,
input_iterator_tag) 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 _Tp, typename _Alloc>
template <typename _ForwardIterator> template <typename _ForwardIterator>
@ -486,14 +486,16 @@ namespace __gnu_norm
if (__elems_before >= difference_type(__n)) if (__elems_before >= difference_type(__n))
{ {
iterator __start_n = this->_M_start + 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; this->_M_start = __new_start;
std::copy(__start_n, __pos, __old_start); std::copy(__start_n, __pos, __old_start);
fill(__pos - difference_type(__n), __pos, __x_copy); fill(__pos - difference_type(__n), __pos, __x_copy);
} }
else 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, __x_copy);
this->_M_start = __new_start; this->_M_start = __new_start;
std::fill(__old_start, __pos, __x_copy); std::fill(__old_start, __pos, __x_copy);
@ -517,7 +519,8 @@ namespace __gnu_norm
if (__elems_after > difference_type(__n)) if (__elems_after > difference_type(__n))
{ {
iterator __finish_n = this->_M_finish - 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; this->_M_finish = __new_finish;
std::copy_backward(__pos, __finish_n, __old_finish); std::copy_backward(__pos, __finish_n, __old_finish);
std::fill(__pos, __pos + difference_type(__n), __x_copy); std::fill(__pos, __pos + difference_type(__n), __x_copy);
@ -526,7 +529,8 @@ namespace __gnu_norm
{ {
std::__uninitialized_fill_copy(this->_M_finish, std::__uninitialized_fill_copy(this->_M_finish,
__pos + difference_type(__n), __pos + difference_type(__n),
__x_copy, __pos, this->_M_finish); __x_copy, __pos,
this->_M_finish);
this->_M_finish = __new_finish; this->_M_finish = __new_finish;
std::fill(__pos, __old_finish, __x_copy); std::fill(__pos, __old_finish, __x_copy);
} }
@ -560,7 +564,8 @@ namespace __gnu_norm
if (__elemsbefore >= difference_type(__n)) if (__elemsbefore >= difference_type(__n))
{ {
iterator __start_n = this->_M_start + 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; this->_M_start = __new_start;
std::copy(__start_n, __pos, __old_start); std::copy(__start_n, __pos, __old_start);
std::copy(__first, __last, __pos - difference_type(__n)); std::copy(__first, __last, __pos - difference_type(__n));
@ -605,7 +610,8 @@ namespace __gnu_norm
_ForwardIterator __mid = __first; _ForwardIterator __mid = __first;
std::advance(__mid, __elemsafter); std::advance(__mid, __elemsafter);
std::__uninitialized_copy_copy(__mid, __last, __pos, std::__uninitialized_copy_copy(__mid, __last, __pos,
this->_M_finish, this->_M_finish); this->_M_finish,
this->_M_finish);
this->_M_finish = __new_finish; this->_M_finish = __new_finish;
std::copy(__first, __mid, __pos); std::copy(__first, __mid, __pos);
} }
@ -675,8 +681,8 @@ namespace __gnu_norm
_Map_pointer __new_nstart; _Map_pointer __new_nstart;
if (this->_M_map_size > 2 * __new_num_nodes) if (this->_M_map_size > 2 * __new_num_nodes)
{ {
__new_nstart __new_nstart = this->_M_map + (this->_M_map_size
= this->_M_map + (this->_M_map_size - __new_num_nodes) / 2 - __new_num_nodes) / 2
+ (__add_at_front ? __nodes_to_add : 0); + (__add_at_front ? __nodes_to_add : 0);
if (__new_nstart < this->_M_start._M_node) if (__new_nstart < this->_M_start._M_node)
std::copy(this->_M_start._M_node, std::copy(this->_M_start._M_node,
@ -689,8 +695,9 @@ namespace __gnu_norm
} }
else else
{ {
size_type __new_map_size = size_type __new_map_size = this->_M_map_size
this->_M_map_size + std::max(this->_M_map_size, __nodes_to_add) + 2; + std::max(this->_M_map_size,
__nodes_to_add) + 2;
_Map_pointer __new_map = this->_M_allocate_map(__new_map_size); _Map_pointer __new_map = this->_M_allocate_map(__new_map_size);
__new_nstart = __new_map + (__new_map_size - __new_num_nodes) / 2 __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++ -*- // 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 // 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 // software; you can redistribute it and/or modify it under the
@ -191,7 +191,8 @@ namespace __gnu_norm
{ {
iterator __first = begin(); iterator __first = begin();
iterator __last = end(); iterator __last = end();
if (__first == __last) return; if (__first == __last)
return;
iterator __next = __first; iterator __next = __first;
while (++__next != __last) while (++__next != __last)
{ {
@ -256,8 +257,10 @@ namespace __gnu_norm
__carry.swap(*__counter); __carry.swap(*__counter);
} }
__carry.swap(*__counter); __carry.swap(*__counter);
if (__counter == __fill) ++__fill; if (__counter == __fill)
} while ( !empty() ); ++__fill;
}
while ( !empty() );
for (__counter = &__tmp[1]; __counter != __fill; ++__counter) for (__counter = &__tmp[1]; __counter != __fill; ++__counter)
__counter->merge( *(__counter-1) ); __counter->merge( *(__counter-1) );
@ -277,7 +280,8 @@ namespace __gnu_norm
{ {
iterator __next = __first; iterator __next = __first;
++__next; ++__next;
if (__pred(*__first)) _M_erase(__first); if (__pred(*__first))
_M_erase(__first);
__first = __next; __first = __next;
} }
} }
@ -337,8 +341,8 @@ namespace __gnu_norm
sort(_StrictWeakOrdering __comp) sort(_StrictWeakOrdering __comp)
{ {
// Do nothing if the list has length 0 or 1. // Do nothing if the list has length 0 or 1.
if (this->_M_node._M_next != &this->_M_node && if (this->_M_node._M_next != &this->_M_node
this->_M_node._M_next->_M_next != &this->_M_node) && this->_M_node._M_next->_M_next != &this->_M_node)
{ {
list __carry; list __carry;
list __tmp[64]; list __tmp[64];
@ -357,8 +361,10 @@ namespace __gnu_norm
__carry.swap(*__counter); __carry.swap(*__counter);
} }
__carry.swap(*__counter); __carry.swap(*__counter);
if (__counter == __fill) ++__fill; if (__counter == __fill)
} while ( !empty() ); ++__fill;
}
while ( !empty() );
for (__counter = &__tmp[1]; __counter != __fill; ++__counter) for (__counter = &__tmp[1]; __counter != __fill; ++__counter)
__counter->merge( *(__counter-1), __comp ); __counter->merge( *(__counter-1), __comp );

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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