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

deque.tcc: Wrap overlong lines...

Browse Source 
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

557
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
@ -70,16 +70,17 @@ namespace __gnu_norm
{ {
const size_type __len = size(); const size_type __len = size();
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),
else this->_M_finish);
{ else
const_iterator __mid = __x.begin() + difference_type(__len); {
std::copy(__x.begin(), __mid, this->_M_start); const_iterator __mid = __x.begin() + difference_type(__len);
insert(this->_M_finish, __mid, __x.end()); std::copy(__x.begin(), __mid, this->_M_start);
} insert(this->_M_finish, __mid, __x.end());
} }
}
return *this; return *this;
} }
@ -89,17 +90,17 @@ namespace __gnu_norm
insert(iterator position, const value_type& __x) insert(iterator position, const value_type& __x)
{ {
if (position._M_cur == this->_M_start._M_cur) if (position._M_cur == this->_M_start._M_cur)
{ {
push_front(__x); push_front(__x);
return this->_M_start; return this->_M_start;
} }
else if (position._M_cur == this->_M_finish._M_cur) else if (position._M_cur == this->_M_finish._M_cur)
{ {
push_back(__x); push_back(__x);
iterator __tmp = this->_M_finish; iterator __tmp = this->_M_finish;
--__tmp; --__tmp;
return __tmp; return __tmp;
} }
else else
return _M_insert_aux(position, __x); return _M_insert_aux(position, __x);
} }
@ -113,15 +114,15 @@ namespace __gnu_norm
++__next; ++__next;
size_type __index = __position - this->_M_start; size_type __index = __position - this->_M_start;
if (__index < (size() >> 1)) if (__index < (size() >> 1))
{ {
std::copy_backward(this->_M_start, __position, __next); std::copy_backward(this->_M_start, __position, __next);
pop_front(); pop_front();
} }
else else
{ {
std::copy(__next, this->_M_finish, __position); std::copy(__next, this->_M_finish, __position);
pop_back(); pop_back();
} }
return this->_M_start + __index; return this->_M_start + __index;
} }
@ -131,33 +132,33 @@ namespace __gnu_norm
erase(iterator __first, iterator __last) erase(iterator __first, iterator __last)
{ {
if (__first == this->_M_start && __last == this->_M_finish) if (__first == this->_M_start && __last == this->_M_finish)
{ {
clear(); clear();
return this->_M_finish; return this->_M_finish;
} }
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);
iterator __new_start = this->_M_start + __n; iterator __new_start = this->_M_start + __n;
std::_Destroy(this->_M_start, __new_start); std::_Destroy(this->_M_start, __new_start);
_M_destroy_nodes(this->_M_start._M_node, __new_start._M_node); _M_destroy_nodes(this->_M_start._M_node, __new_start._M_node);
this->_M_start = __new_start; this->_M_start = __new_start;
} }
else else
{ {
std::copy(__last, this->_M_finish, __first); std::copy(__last, this->_M_finish, __first);
iterator __new_finish = this->_M_finish - __n; iterator __new_finish = this->_M_finish - __n;
std::_Destroy(__new_finish, this->_M_finish); std::_Destroy(__new_finish, this->_M_finish);
_M_destroy_nodes(__new_finish._M_node + 1, _M_destroy_nodes(__new_finish._M_node + 1,
this->_M_finish._M_node + 1); this->_M_finish._M_node + 1);
this->_M_finish = __new_finish; this->_M_finish = __new_finish;
} }
return this->_M_start + __elems_before; return this->_M_start + __elems_before;
} }
} }
template <typename _Tp, typename _Alloc> template <typename _Tp, typename _Alloc>
@ -168,17 +169,17 @@ namespace __gnu_norm
for (_Map_pointer __node = this->_M_start._M_node + 1; for (_Map_pointer __node = this->_M_start._M_node + 1;
__node < this->_M_finish._M_node; __node < this->_M_finish._M_node;
++__node) ++__node)
{ {
std::_Destroy(*__node, *__node + _S_buffer_size()); std::_Destroy(*__node, *__node + _S_buffer_size());
_M_deallocate_node(*__node); _M_deallocate_node(*__node);
} }
if (this->_M_start._M_node != this->_M_finish._M_node) if (this->_M_start._M_node != this->_M_finish._M_node)
{ {
std::_Destroy(this->_M_start._M_cur, this->_M_start._M_last); std::_Destroy(this->_M_start._M_cur, this->_M_start._M_last);
std::_Destroy(this->_M_finish._M_first, this->_M_finish._M_cur); std::_Destroy(this->_M_finish._M_first, this->_M_finish._M_cur);
_M_deallocate_node(this->_M_finish._M_first); _M_deallocate_node(this->_M_finish._M_first);
} }
else else
std::_Destroy(this->_M_start._M_cur, this->_M_finish._M_cur); std::_Destroy(this->_M_start._M_cur, this->_M_finish._M_cur);
@ -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)
@ -206,34 +208,34 @@ namespace __gnu_norm
_M_fill_insert(iterator __pos, size_type __n, const value_type& __x) _M_fill_insert(iterator __pos, size_type __n, const value_type& __x)
{ {
if (__pos._M_cur == this->_M_start._M_cur) if (__pos._M_cur == this->_M_start._M_cur)
{ {
iterator __new_start = _M_reserve_elements_at_front(__n); iterator __new_start = _M_reserve_elements_at_front(__n);
try try
{ {
std::uninitialized_fill(__new_start, this->_M_start, __x); std::uninitialized_fill(__new_start, this->_M_start, __x);
this->_M_start = __new_start; this->_M_start = __new_start;
} }
catch(...) catch(...)
{ {
_M_destroy_nodes(__new_start._M_node, this->_M_start._M_node); _M_destroy_nodes(__new_start._M_node, this->_M_start._M_node);
__throw_exception_again; __throw_exception_again;
} }
} }
else if (__pos._M_cur == this->_M_finish._M_cur) else if (__pos._M_cur == this->_M_finish._M_cur)
{ {
iterator __new_finish = _M_reserve_elements_at_back(__n); iterator __new_finish = _M_reserve_elements_at_back(__n);
try try
{ {
std::uninitialized_fill(this->_M_finish, __new_finish, __x); std::uninitialized_fill(this->_M_finish, __new_finish, __x);
this->_M_finish = __new_finish; this->_M_finish = __new_finish;
} }
catch(...) catch(...)
{ {
_M_destroy_nodes(this->_M_finish._M_node + 1, _M_destroy_nodes(this->_M_finish._M_node + 1,
__new_finish._M_node + 1); __new_finish._M_node + 1);
__throw_exception_again; __throw_exception_again;
} }
} }
else else
_M_insert_aux(__pos, __n, __x); _M_insert_aux(__pos, __n, __x);
} }
@ -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>
@ -403,34 +403,34 @@ namespace __gnu_norm
{ {
size_type __n = std::distance(__first, __last); size_type __n = std::distance(__first, __last);
if (__pos._M_cur == this->_M_start._M_cur) if (__pos._M_cur == this->_M_start._M_cur)
{ {
iterator __new_start = _M_reserve_elements_at_front(__n); iterator __new_start = _M_reserve_elements_at_front(__n);
try try
{ {
std::uninitialized_copy(__first, __last, __new_start); std::uninitialized_copy(__first, __last, __new_start);
this->_M_start = __new_start; this->_M_start = __new_start;
} }
catch(...) catch(...)
{ {
_M_destroy_nodes(__new_start._M_node, this->_M_start._M_node); _M_destroy_nodes(__new_start._M_node, this->_M_start._M_node);
__throw_exception_again; __throw_exception_again;
} }
} }
else if (__pos._M_cur == this->_M_finish._M_cur) else if (__pos._M_cur == this->_M_finish._M_cur)
{ {
iterator __new_finish = _M_reserve_elements_at_back(__n); iterator __new_finish = _M_reserve_elements_at_back(__n);
try try
{ {
std::uninitialized_copy(__first, __last, this->_M_finish); std::uninitialized_copy(__first, __last, this->_M_finish);
this->_M_finish = __new_finish; this->_M_finish = __new_finish;
} }
catch(...) catch(...)
{ {
_M_destroy_nodes(this->_M_finish._M_node + 1, _M_destroy_nodes(this->_M_finish._M_node + 1,
__new_finish._M_node + 1); __new_finish._M_node + 1);
__throw_exception_again; __throw_exception_again;
} }
} }
else else
_M_insert_aux(__pos, __first, __last, __n); _M_insert_aux(__pos, __first, __last, __n);
} }
@ -443,27 +443,27 @@ namespace __gnu_norm
difference_type __index = __pos - this->_M_start; difference_type __index = __pos - this->_M_start;
value_type __x_copy = __x; // XXX copy value_type __x_copy = __x; // XXX copy
if (static_cast<size_type>(__index) < size() / 2) if (static_cast<size_type>(__index) < size() / 2)
{ {
push_front(front()); push_front(front());
iterator __front1 = this->_M_start; iterator __front1 = this->_M_start;
++__front1; ++__front1;
iterator __front2 = __front1; iterator __front2 = __front1;
++__front2; ++__front2;
__pos = this->_M_start + __index; __pos = this->_M_start + __index;
iterator __pos1 = __pos; iterator __pos1 = __pos;
++__pos1; ++__pos1;
std::copy(__front2, __pos1, __front1); std::copy(__front2, __pos1, __front1);
} }
else else
{ {
push_back(back()); push_back(back());
iterator __back1 = this->_M_finish; iterator __back1 = this->_M_finish;
--__back1; --__back1;
iterator __back2 = __back1; iterator __back2 = __back1;
--__back2; --__back2;
__pos = this->_M_start + __index; __pos = this->_M_start + __index;
std::copy_backward(__pos, __back2, __back1); std::copy_backward(__pos, __back2, __back1);
} }
*__pos = __x_copy; *__pos = __x_copy;
return __pos; return __pos;
} }
@ -477,67 +477,71 @@ namespace __gnu_norm
size_type __length = this->size(); size_type __length = this->size();
value_type __x_copy = __x; value_type __x_copy = __x;
if (__elems_before < difference_type(__length / 2)) if (__elems_before < difference_type(__length / 2))
{ {
iterator __new_start = _M_reserve_elements_at_front(__n); iterator __new_start = _M_reserve_elements_at_front(__n);
iterator __old_start = this->_M_start; iterator __old_start = this->_M_start;
__pos = this->_M_start + __elems_before; __pos = this->_M_start + __elems_before;
try try
{ {
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,
this->_M_start = __new_start; __new_start);
std::copy(__start_n, __pos, __old_start); this->_M_start = __new_start;
fill(__pos - difference_type(__n), __pos, __x_copy); std::copy(__start_n, __pos, __old_start);
} fill(__pos - difference_type(__n), __pos, __x_copy);
else }
{ else
std::__uninitialized_copy_fill(this->_M_start, __pos, __new_start, {
this->_M_start, __x_copy); std::__uninitialized_copy_fill(this->_M_start, __pos,
this->_M_start = __new_start; __new_start,
std::fill(__old_start, __pos, __x_copy); this->_M_start, __x_copy);
} this->_M_start = __new_start;
} std::fill(__old_start, __pos, __x_copy);
catch(...) }
{ }
_M_destroy_nodes(__new_start._M_node, this->_M_start._M_node); catch(...)
__throw_exception_again; {
} _M_destroy_nodes(__new_start._M_node, this->_M_start._M_node);
} __throw_exception_again;
}
}
else else
{ {
iterator __new_finish = _M_reserve_elements_at_back(__n); iterator __new_finish = _M_reserve_elements_at_back(__n);
iterator __old_finish = this->_M_finish; iterator __old_finish = this->_M_finish;
const difference_type __elems_after = const difference_type __elems_after =
difference_type(__length) - __elems_before; difference_type(__length) - __elems_before;
__pos = this->_M_finish - __elems_after; __pos = this->_M_finish - __elems_after;
try try
{ {
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 = __new_finish; this->_M_finish);
std::copy_backward(__pos, __finish_n, __old_finish); this->_M_finish = __new_finish;
std::fill(__pos, __pos + difference_type(__n), __x_copy); std::copy_backward(__pos, __finish_n, __old_finish);
} std::fill(__pos, __pos + difference_type(__n), __x_copy);
else }
{ else
std::__uninitialized_fill_copy(this->_M_finish, {
__pos + difference_type(__n), std::__uninitialized_fill_copy(this->_M_finish,
__x_copy, __pos, this->_M_finish); __pos + difference_type(__n),
this->_M_finish = __new_finish; __x_copy, __pos,
std::fill(__pos, __old_finish, __x_copy); this->_M_finish);
} this->_M_finish = __new_finish;
} std::fill(__pos, __old_finish, __x_copy);
catch(...) }
{ }
_M_destroy_nodes(this->_M_finish._M_node + 1, catch(...)
__new_finish._M_node + 1); {
__throw_exception_again; _M_destroy_nodes(this->_M_finish._M_node + 1,
} __new_finish._M_node + 1);
} __throw_exception_again;
}
}
} }
template <typename _Tp, typename _Alloc> template <typename _Tp, typename _Alloc>
@ -551,36 +555,37 @@ namespace __gnu_norm
const difference_type __elemsbefore = __pos - this->_M_start; const difference_type __elemsbefore = __pos - this->_M_start;
size_type __length = size(); size_type __length = size();
if (static_cast<size_type>(__elemsbefore) < __length / 2) if (static_cast<size_type>(__elemsbefore) < __length / 2)
{ {
iterator __new_start = _M_reserve_elements_at_front(__n); iterator __new_start = _M_reserve_elements_at_front(__n);
iterator __old_start = this->_M_start; iterator __old_start = this->_M_start;
__pos = this->_M_start + __elemsbefore; __pos = this->_M_start + __elemsbefore;
try try
{ {
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,
this->_M_start = __new_start; __new_start);
std::copy(__start_n, __pos, __old_start); this->_M_start = __new_start;
std::copy(__first, __last, __pos - difference_type(__n)); std::copy(__start_n, __pos, __old_start);
} std::copy(__first, __last, __pos - difference_type(__n));
else }
{ else
_ForwardIterator __mid = __first; {
std::advance(__mid, difference_type(__n) - __elemsbefore); _ForwardIterator __mid = __first;
std::__uninitialized_copy_copy(this->_M_start, __pos, std::advance(__mid, difference_type(__n) - __elemsbefore);
__first, __mid, __new_start); std::__uninitialized_copy_copy(this->_M_start, __pos,
this->_M_start = __new_start; __first, __mid, __new_start);
std::copy(__mid, __last, __old_start); this->_M_start = __new_start;
} std::copy(__mid, __last, __old_start);
} }
catch(...) }
{ catch(...)
_M_destroy_nodes(__new_start._M_node, this->_M_start._M_node); {
__throw_exception_again; _M_destroy_nodes(__new_start._M_node, this->_M_start._M_node);
} __throw_exception_again;
} }
}
else else
{ {
iterator __new_finish = _M_reserve_elements_at_back(__n); iterator __new_finish = _M_reserve_elements_at_back(__n);
@ -591,24 +596,25 @@ namespace __gnu_norm
try try
{ {
if (__elemsafter > difference_type(__n)) if (__elemsafter > 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, std::uninitialized_copy(__finish_n,
this->_M_finish, this->_M_finish,
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::copy(__first, __last, __pos); std::copy(__first, __last, __pos);
} }
else else
{ {
_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 = __new_finish; this->_M_finish);
std::copy(__first, __mid, __pos); this->_M_finish = __new_finish;
} std::copy(__first, __mid, __pos);
}
} }
catch(...) catch(...)
{ {
@ -625,7 +631,7 @@ namespace __gnu_norm
_M_new_elements_at_front(size_type __new_elems) _M_new_elements_at_front(size_type __new_elems)
{ {
size_type __new_nodes size_type __new_nodes
= (__new_elems + _S_buffer_size() - 1) / _S_buffer_size(); = (__new_elems + _S_buffer_size() - 1) / _S_buffer_size();
_M_reserve_map_at_front(__new_nodes); _M_reserve_map_at_front(__new_nodes);
size_type __i; size_type __i;
try try
@ -674,35 +680,36 @@ 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,
this->_M_finish._M_node + 1, this->_M_finish._M_node + 1,
__new_nstart); __new_nstart);
else else
std::copy_backward(this->_M_start._M_node, std::copy_backward(this->_M_start._M_node,
this->_M_finish._M_node + 1, this->_M_finish._M_node + 1,
__new_nstart + __old_num_nodes); __new_nstart + __old_num_nodes);
} }
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
+ (__add_at_front ? __nodes_to_add : 0); + (__add_at_front ? __nodes_to_add : 0);
std::copy(this->_M_start._M_node, std::copy(this->_M_start._M_node,
this->_M_finish._M_node + 1, this->_M_finish._M_node + 1,
__new_nstart); __new_nstart);
_M_deallocate_map(this->_M_map, this->_M_map_size); _M_deallocate_map(this->_M_map, this->_M_map_size);
this->_M_map = __new_map; this->_M_map = __new_map;
this->_M_map_size = __new_map_size; this->_M_map_size = __new_map_size;
} }
this->_M_start._M_set_node(__new_nstart); this->_M_start._M_set_node(__new_nstart);
this->_M_finish._M_set_node(__new_nstart + __old_num_nodes - 1); this->_M_finish._M_set_node(__new_nstart + __old_num_nodes - 1);

116
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
@ -120,18 +120,18 @@ namespace __gnu_norm
operator=(const list& __x) operator=(const list& __x)
{ {
if (this != &__x) if (this != &__x)
{ {
iterator __first1 = begin(); iterator __first1 = begin();
iterator __last1 = end(); iterator __last1 = end();
const_iterator __first2 = __x.begin(); const_iterator __first2 = __x.begin();
const_iterator __last2 = __x.end(); const_iterator __last2 = __x.end();
while (__first1 != __last1 && __first2 != __last2) while (__first1 != __last1 && __first2 != __last2)
*__first1++ = *__first2++; *__first1++ = *__first2++;
if (__first2 == __last2) if (__first2 == __last2)
erase(__first1, __last1); erase(__first1, __last1);
else else
insert(__last1, __first2, __last2); insert(__last1, __first2, __last2);
} }
return *this; return *this;
} }
@ -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)
{ {
@ -245,19 +246,21 @@ namespace __gnu_norm
list * __counter; list * __counter;
do do
{ {
__carry.splice(__carry.begin(), *this, begin()); __carry.splice(__carry.begin(), *this, begin());
for(__counter = &__tmp[0]; for(__counter = &__tmp[0];
(__counter != __fill) && !__counter->empty(); (__counter != __fill) && !__counter->empty();
++__counter) ++__counter)
{ {
__counter->merge(__carry); __counter->merge(__carry);
__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;
} }
} }
@ -332,39 +336,41 @@ namespace __gnu_norm
template<typename _Tp, typename _Alloc> template<typename _Tp, typename _Alloc>
template <typename _StrictWeakOrdering> template <typename _StrictWeakOrdering>
void void
list<_Tp,_Alloc>:: list<_Tp,_Alloc>::
sort(_StrictWeakOrdering __comp) sort(_StrictWeakOrdering __comp)
{
// Do nothing if the list has length 0 or 1.
if (this->_M_node._M_next != &this->_M_node &&
this->_M_node._M_next->_M_next != &this->_M_node)
{ {
list __carry; // Do nothing if the list has length 0 or 1.
list __tmp[64]; if (this->_M_node._M_next != &this->_M_node
list * __fill = &__tmp[0]; && this->_M_node._M_next->_M_next != &this->_M_node)
list * __counter; {
list __carry;
list __tmp[64];
list * __fill = &__tmp[0];
list * __counter;
do do
{ {
__carry.splice(__carry.begin(), *this, begin()); __carry.splice(__carry.begin(), *this, begin());
for(__counter = &__tmp[0]; for(__counter = &__tmp[0];
(__counter != __fill) && !__counter->empty(); (__counter != __fill) && !__counter->empty();
++__counter) ++__counter)
{ {
__counter->merge(__carry, __comp); __counter->merge(__carry, __comp);
__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 );
swap( *(__fill-1) ); swap( *(__fill-1) );
}
} }
}
} // namespace __gnu_norm } // namespace __gnu_norm
#endif /* _LIST_TCC */ #endif /* _LIST_TCC */

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

File diff suppressed because it is too large Load Diff

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

File diff suppressed because it is too large Load Diff

188
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; }
}; };
/** /**
@ -578,12 +590,12 @@ namespace __gnu_cxx
public: public:
typedef typename iterator_traits<_Iterator>::iterator_category typedef typename iterator_traits<_Iterator>::iterator_category
iterator_category; iterator_category;
typedef typename iterator_traits<_Iterator>::value_type value_type; typedef typename iterator_traits<_Iterator>::value_type value_type;
typedef typename iterator_traits<_Iterator>::difference_type typedef typename iterator_traits<_Iterator>::difference_type
difference_type; difference_type;
typedef typename iterator_traits<_Iterator>::reference reference; typedef typename iterator_traits<_Iterator>::reference reference;
typedef typename iterator_traits<_Iterator>::pointer pointer; typedef typename iterator_traits<_Iterator>::pointer pointer;
__normal_iterator() : _M_current(_Iterator()) { } __normal_iterator() : _M_current(_Iterator()) { }
@ -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
@ -650,93 +676,93 @@ namespace __gnu_cxx
// Forward iterator requirements // Forward iterator requirements
template<typename _IteratorL, typename _IteratorR, typename _Container> template<typename _IteratorL, typename _IteratorR, typename _Container>
inline bool inline bool
operator==(const __normal_iterator<_IteratorL, _Container>& __lhs, operator==(const __normal_iterator<_IteratorL, _Container>& __lhs,
const __normal_iterator<_IteratorR, _Container>& __rhs) const __normal_iterator<_IteratorR, _Container>& __rhs)
{ return __lhs.base() == __rhs.base(); } { return __lhs.base() == __rhs.base(); }
template<typename _Iterator, typename _Container> template<typename _Iterator, typename _Container>
inline bool inline bool
operator==(const __normal_iterator<_Iterator, _Container>& __lhs, operator==(const __normal_iterator<_Iterator, _Container>& __lhs,
const __normal_iterator<_Iterator, _Container>& __rhs) const __normal_iterator<_Iterator, _Container>& __rhs)
{ return __lhs.base() == __rhs.base(); } { return __lhs.base() == __rhs.base(); }
template<typename _IteratorL, typename _IteratorR, typename _Container> template<typename _IteratorL, typename _IteratorR, typename _Container>
inline bool inline bool
operator!=(const __normal_iterator<_IteratorL, _Container>& __lhs, operator!=(const __normal_iterator<_IteratorL, _Container>& __lhs,
const __normal_iterator<_IteratorR, _Container>& __rhs) const __normal_iterator<_IteratorR, _Container>& __rhs)
{ return __lhs.base() != __rhs.base(); } { return __lhs.base() != __rhs.base(); }
template<typename _Iterator, typename _Container> template<typename _Iterator, typename _Container>
inline bool inline bool
operator!=(const __normal_iterator<_Iterator, _Container>& __lhs, operator!=(const __normal_iterator<_Iterator, _Container>& __lhs,
const __normal_iterator<_Iterator, _Container>& __rhs) const __normal_iterator<_Iterator, _Container>& __rhs)
{ return __lhs.base() != __rhs.base(); } { return __lhs.base() != __rhs.base(); }
// Random access iterator requirements // Random access iterator requirements
template<typename _IteratorL, typename _IteratorR, typename _Container> template<typename _IteratorL, typename _IteratorR, typename _Container>
inline bool inline bool
operator<(const __normal_iterator<_IteratorL, _Container>& __lhs, operator<(const __normal_iterator<_IteratorL, _Container>& __lhs,
const __normal_iterator<_IteratorR, _Container>& __rhs) const __normal_iterator<_IteratorR, _Container>& __rhs)
{ return __lhs.base() < __rhs.base(); } { return __lhs.base() < __rhs.base(); }
template<typename _Iterator, typename _Container> template<typename _Iterator, typename _Container>
inline bool inline bool
operator<(const __normal_iterator<_Iterator, _Container>& __lhs, operator<(const __normal_iterator<_Iterator, _Container>& __lhs,
const __normal_iterator<_Iterator, _Container>& __rhs) const __normal_iterator<_Iterator, _Container>& __rhs)
{ return __lhs.base() < __rhs.base(); } { return __lhs.base() < __rhs.base(); }
template<typename _IteratorL, typename _IteratorR, typename _Container> template<typename _IteratorL, typename _IteratorR, typename _Container>
inline bool inline bool
operator>(const __normal_iterator<_IteratorL, _Container>& __lhs, operator>(const __normal_iterator<_IteratorL, _Container>& __lhs,
const __normal_iterator<_IteratorR, _Container>& __rhs) const __normal_iterator<_IteratorR, _Container>& __rhs)
{ return __lhs.base() > __rhs.base(); } { return __lhs.base() > __rhs.base(); }
template<typename _Iterator, typename _Container> template<typename _Iterator, typename _Container>
inline bool inline bool
operator>(const __normal_iterator<_Iterator, _Container>& __lhs, operator>(const __normal_iterator<_Iterator, _Container>& __lhs,
const __normal_iterator<_Iterator, _Container>& __rhs) const __normal_iterator<_Iterator, _Container>& __rhs)
{ return __lhs.base() > __rhs.base(); } { return __lhs.base() > __rhs.base(); }
template<typename _IteratorL, typename _IteratorR, typename _Container> template<typename _IteratorL, typename _IteratorR, typename _Container>
inline bool inline bool
operator<=(const __normal_iterator<_IteratorL, _Container>& __lhs, operator<=(const __normal_iterator<_IteratorL, _Container>& __lhs,
const __normal_iterator<_IteratorR, _Container>& __rhs) const __normal_iterator<_IteratorR, _Container>& __rhs)
{ return __lhs.base() <= __rhs.base(); } { return __lhs.base() <= __rhs.base(); }
template<typename _Iterator, typename _Container> template<typename _Iterator, typename _Container>
inline bool inline bool
operator<=(const __normal_iterator<_Iterator, _Container>& __lhs, operator<=(const __normal_iterator<_Iterator, _Container>& __lhs,
const __normal_iterator<_Iterator, _Container>& __rhs) const __normal_iterator<_Iterator, _Container>& __rhs)
{ return __lhs.base() <= __rhs.base(); } { return __lhs.base() <= __rhs.base(); }
template<typename _IteratorL, typename _IteratorR, typename _Container> template<typename _IteratorL, typename _IteratorR, typename _Container>
inline bool inline bool
operator>=(const __normal_iterator<_IteratorL, _Container>& __lhs, operator>=(const __normal_iterator<_IteratorL, _Container>& __lhs,
const __normal_iterator<_IteratorR, _Container>& __rhs) const __normal_iterator<_IteratorR, _Container>& __rhs)
{ return __lhs.base() >= __rhs.base(); } { return __lhs.base() >= __rhs.base(); }
template<typename _Iterator, typename _Container> template<typename _Iterator, typename _Container>
inline bool inline bool
operator>=(const __normal_iterator<_Iterator, _Container>& __lhs, operator>=(const __normal_iterator<_Iterator, _Container>& __lhs,
const __normal_iterator<_Iterator, _Container>& __rhs) const __normal_iterator<_Iterator, _Container>& __rhs)
{ return __lhs.base() >= __rhs.base(); } { return __lhs.base() >= __rhs.base(); }
// _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
// operators but also operator- must accept mixed iterator/const_iterator // operators but also operator- must accept mixed iterator/const_iterator
// parameters. // parameters.
template<typename _IteratorL, typename _IteratorR, typename _Container> template<typename _IteratorL, typename _IteratorR, typename _Container>
inline typename __normal_iterator<_IteratorL, _Container>::difference_type inline typename __normal_iterator<_IteratorL, _Container>::difference_type
operator-(const __normal_iterator<_IteratorL, _Container>& __lhs, operator-(const __normal_iterator<_IteratorL, _Container>& __lhs,
const __normal_iterator<_IteratorR, _Container>& __rhs) const __normal_iterator<_IteratorR, _Container>& __rhs)
{ return __lhs.base() - __rhs.base(); } { return __lhs.base() - __rhs.base(); }
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
#endif #endif

26
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,9 +78,11 @@ 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 {};
//@} //@}

82
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.
@ -1167,7 +1183,7 @@ namespace __gnu_norm
{ {
++__i1; ++__i1;
++__i2; ++__i2;
} }
return __i1 == __end1 && __i2 == __end2; return __i1 == __end1 && __i2 == __end2;
} }
@ -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>

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

File diff suppressed because it is too large Load Diff

855
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
@ -103,466 +103,507 @@ namespace __gnu_norm
*/ */
template <typename _Key, typename _Tp, typename _Compare, typename _Alloc> template <typename _Key, typename _Tp, typename _Compare, typename _Alloc>
class multimap class multimap
{ {
// 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;
typedef _Tp mapped_type; typedef _Tp mapped_type;
typedef pair<const _Key, _Tp> value_type; typedef pair<const _Key, _Tp> value_type;
typedef _Compare key_compare; typedef _Compare key_compare;
class value_compare class value_compare
: public binary_function<value_type, value_type, bool> : public binary_function<value_type, value_type, bool>
{ {
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); }
}; };
private: private:
/// @if maint This turns a red-black tree into a [multi]map. @endif /// @if maint This turns a red-black tree into a [multi]map. @endif
typedef _Rb_tree<key_type, value_type, typedef _Rb_tree<key_type, value_type,
_Select1st<value_type>, key_compare, _Alloc> _Rep_type; _Select1st<value_type>, key_compare, _Alloc> _Rep_type;
/// @if maint The actual tree structure. @endif /// @if maint The actual tree structure. @endif
_Rep_type _M_t; _Rep_type _M_t;
public: public:
// many of these are specified differently in ISO, but the following are // many of these are specified differently in ISO, but the following are
// "functionally equivalent" // "functionally equivalent"
typedef typename _Rep_type::allocator_type allocator_type; typedef typename _Rep_type::allocator_type allocator_type;
typedef typename _Rep_type::reference reference; typedef typename _Rep_type::reference reference;
typedef typename _Rep_type::const_reference const_reference; typedef typename _Rep_type::const_reference const_reference;
typedef typename _Rep_type::iterator iterator; typedef typename _Rep_type::iterator iterator;
typedef typename _Rep_type::const_iterator const_iterator; typedef typename _Rep_type::const_iterator const_iterator;
typedef typename _Rep_type::size_type size_type; typedef typename _Rep_type::size_type size_type;
typedef typename _Rep_type::difference_type difference_type; typedef typename _Rep_type::difference_type difference_type;
typedef typename _Rep_type::pointer pointer; typedef typename _Rep_type::pointer pointer;
typedef typename _Rep_type::const_pointer const_pointer; typedef typename _Rep_type::const_pointer const_pointer;
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.2] construct/copy/destroy // [23.3.2] construct/copy/destroy
// (get_allocator() is also listed in this section) // (get_allocator() is also listed in this section)
/** /**
* @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) { }
/** /**
* @brief %Multimap copy constructor. * @brief %Multimap copy constructor.
* @param x A %multimap of identical element and allocator types. * @param x A %multimap of identical element and allocator types.
* *
* The newly-created %multimap uses a copy of the allocation object used * The newly-created %multimap uses a copy of the allocation object used
* by @a x. * by @a x.
*/ */
multimap(const multimap& __x) multimap(const multimap& __x)
: _M_t(__x._M_t) { } : _M_t(__x._M_t) { }
/** /**
* @brief Builds a %multimap from a range. * @brief Builds a %multimap from a range.
* @param first An input iterator. * @param first An input iterator.
* @param last An input iterator. * @param last An input iterator.
* *
* Create a %multimap consisting of copies of the elements from * Create a %multimap consisting of copies of the elements from
* [first,last). This is linear in N if the range is already sorted, * [first,last). This is linear in N if the range is already sorted,
* and NlogN otherwise (where N is distance(first,last)). * and NlogN otherwise (where N is distance(first,last)).
*/ */
template <typename _InputIterator> template <typename _InputIterator>
multimap(_InputIterator __first, _InputIterator __last) multimap(_InputIterator __first, _InputIterator __last)
: _M_t(_Compare(), allocator_type()) : _M_t(_Compare(), allocator_type())
{ _M_t.insert_equal(__first, __last); } { _M_t.insert_equal(__first, __last); }
/** /**
* @brief Builds a %multimap from a range. * @brief Builds a %multimap from a range.
* @param first An input iterator. * @param first An input iterator.
* @param last An input iterator. * @param last An input iterator.
* @param comp A comparison functor. * @param comp A comparison functor.
* @param a An allocator object. * @param a An allocator object.
* *
* Create a %multimap consisting of copies of the elements from * Create a %multimap consisting of copies of the elements from
* [first,last). This is linear in N if the range is already sorted, * [first,last). This is linear in N if the range is already sorted,
* and NlogN otherwise (where N is distance(first,last)). * and NlogN otherwise (where N is distance(first,last)).
*/ */
template <typename _InputIterator> template <typename _InputIterator>
multimap(_InputIterator __first, _InputIterator __last, multimap(_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(__comp, __a)
{ _M_t.insert_equal(__first, __last); } { _M_t.insert_equal(__first, __last); }
// FIXME There is no dtor declared, but we should have something generated // FIXME There is no dtor declared, but we should have something generated
// by Doxygen. I don't know what tags to add to this paragraph to make // by Doxygen. I don't know what tags to add to this paragraph to make
// that happen: // that happen:
/** /**
* The dtor only erases the elements, and note that if the elements * The dtor only erases the elements, and note that if the elements
* 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.
*/ */
/** /**
* @brief %Multimap assignment operator. * @brief %Multimap assignment operator.
* @param x A %multimap of identical element and allocator types. * @param x A %multimap of identical element and allocator types.
* *
* 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.
*/ */
multimap& multimap&
operator=(const multimap& __x) operator=(const multimap& __x)
{ {
_M_t = __x._M_t; _M_t = __x._M_t;
return *this; return *this;
} }
/// 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 */
begin() { return _M_t.begin(); } iterator
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 */
end() { return _M_t.end(); } iterator
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 %multimap. Iteration is done in ascending order according * pair in the %multimap. Iteration is done in ascending order according
* 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
* the %multimap. Iteration is done in descending order according to the * the %multimap. Iteration is done in descending order according to the
* 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
* first pair in the %multimap. Iteration is done in descending order * first pair in the %multimap. Iteration is done in descending order
* 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.
* *
* See http://gcc.gnu.org/onlinedocs/libstdc++/23_containers/howto.html#4 * See http://gcc.gnu.org/onlinedocs/libstdc++/23_containers/howto.html#4
* for more on "hinting". * for more on "hinting".
* *
* Insertion requires logarithmic time (if the hint is not taken). * Insertion requires logarithmic time (if the hint is not taken).
*/ */
iterator iterator
insert(iterator __position, const value_type& __x) insert(iterator __position, const value_type& __x)
{ return _M_t.insert_equal(__position, __x); } { return _M_t.insert_equal(__position, __x); }
/** /**
* @brief A template function that attemps to insert a range of elements. * @brief A template function that attemps to insert a range of elements.
* @param first Iterator pointing to the start of the range to be * @param first Iterator pointing to the start of the range to be
* inserted. * inserted.
* @param last Iterator pointing to the end of the range. * @param last Iterator pointing to the end of the range.
* *
* Complexity similar to that of the range constructor. * Complexity similar to that of the range constructor.
*/ */
template <typename _InputIterator> template <typename _InputIterator>
void
insert(_InputIterator __first, _InputIterator __last)
{ _M_t.insert_equal(__first, __last); }
/**
* @brief Erases an element from a %multimap.
* @param position An iterator pointing to the element to be erased.
*
* This function erases an element, pointed to by the given iterator,
* from a %multimap. Note that this function only erases the element,
* and that if the element is itself a pointer, the pointed-to memory is
* not touched in any way. Managing the pointer is the user's
* responsibilty.
*/
void void
insert(_InputIterator __first, _InputIterator __last) erase(iterator __position)
{ _M_t.insert_equal(__first, __last); } { _M_t.erase(__position); }
/** /**
* @brief Erases an element from a %multimap. * @brief Erases elements according to the provided key.
* @param position An iterator pointing to the element to be erased. * @param x Key of element to be erased.
* * @return The number of elements erased.
* This function erases an element, pointed to by the given iterator, from *
* a %multimap. Note that this function only erases the element, and that * This function erases all elements located by the given key from a
* if the element is itself a pointer, the pointed-to memory is not * %multimap.
* touched in any way. Managing the pointer is the user's responsibilty. * Note that this function only erases the element, and that if
*/ * the element is itself a pointer, the pointed-to memory is not touched
void * in any way. Managing the pointer is the user's responsibilty.
erase(iterator __position) { _M_t.erase(__position); } */
size_type
erase(const key_type& __x)
{ return _M_t.erase(__x); }
/** /**
* @brief Erases elements according to the provided key. * @brief Erases a [first,last) range of elements from a %multimap.
* @param x Key of element to be erased. * @param first Iterator pointing to the start of the range to be
* @return The number of elements erased. * erased.
* * @param last Iterator pointing to the end of the range to be erased.
* This function erases all elements located by the given key from a *
* %multimap. * This function erases a sequence of elements from a %multimap.
* Note that this function only erases the element, and that if * Note that this function only erases the elements, and that if
* the element is itself a pointer, the pointed-to memory is not touched * the elements themselves are pointers, 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.
*/ */
size_type void
erase(const key_type& __x) { return _M_t.erase(__x); } erase(iterator __first, iterator __last)
{ _M_t.erase(__first, __last); }
/** /**
* @brief Erases a [first,last) range of elements from a %multimap. * @brief Swaps data with another %multimap.
* @param first Iterator pointing to the start of the range to be erased. * @param x A %multimap of the same element and allocator types.
* @param last Iterator pointing to the end of the range to be erased. *
* * This exchanges the elements between two multimaps in constant time.
* This function erases a sequence of elements from a %multimap. * (It is only swapping a pointer, an integer, and an instance of
* Note that this function only erases the elements, and that if * the @c Compare type (which itself is often stateless and empty), so it
* the elements themselves are pointers, the pointed-to memory is not * should be quite fast.)
* touched in any way. Managing the pointer is the user's responsibilty. * Note that the global std::swap() function is specialized such that
*/ * std::swap(m1,m2) will feed to this function.
void */
erase(iterator __first, iterator __last) { _M_t.erase(__first, __last); } void
swap(multimap& __x)
{ _M_t.swap(__x._M_t); }
/** /**
* @brief Swaps data with another %multimap. * Erases all elements in a %multimap. Note that this function only
* @param x A %multimap of the same element and allocator types. * erases the elements, and that if the elements themselves are pointers,
* * the pointed-to memory is not touched in any way. Managing the pointer
* This exchanges the elements between two multimaps in constant time. * is the user's responsibilty.
* (It is only swapping a pointer, an integer, and an instance of */
* the @c Compare type (which itself is often stateless and empty), so it void
* should be quite fast.) clear()
* Note that the global std::swap() function is specialized such that { _M_t.clear(); }
* std::swap(m1,m2) will feed to this function.
*/
void
swap(multimap& __x) { _M_t.swap(__x._M_t); }
/** // observers
* Erases all elements in a %multimap. Note that this function only erases /**
* the elements, and that if the elements themselves are pointers, the * Returns the key comparison object out of which the %multimap
* pointed-to memory is not touched in any way. Managing the pointer is * was constructed.
* the user's responsibilty. */
*/ key_compare
void key_comp() const
clear() { _M_t.clear(); } { return _M_t.key_comp(); }
// observers /**
/** * Returns a value comparison object, built from the key comparison
* Returns the key comparison object out of which the %multimap * object out of which the %multimap was constructed.
* was constructed. */
*/ value_compare
key_compare value_comp() const
key_comp() const { return _M_t.key_comp(); } { return value_compare(_M_t.key_comp()); }
/** // multimap operations
* Returns a value comparison object, built from the key comparison /**
* object out of which the %multimap was constructed. * @brief Tries to locate an element in a %multimap.
*/ * @param x Key of (key, value) pair to be located.
value_compare * @return Iterator pointing to sought-after element,
value_comp() const { return value_compare(_M_t.key_comp()); } * or end() if not found.
*
* This function takes a key and tries to locate the element with which
* the key matches. If successful the function returns an iterator
* pointing to the sought after %pair. If unsuccessful it returns the
* past-the-end ( @c end() ) iterator.
*/
iterator
find(const key_type& __x)
{ return _M_t.find(__x); }
// multimap operations /**
/** * @brief Tries to locate an element in a %multimap.
* @brief Tries to locate an element in a %multimap. * @param x Key of (key, value) pair to be located.
* @param x Key of (key, value) pair to be located. * @return Read-only (constant) iterator pointing to sought-after
* @return Iterator pointing to sought-after element, * element, or end() if not found.
* 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
* the key matches. If successful the function returns an iterator * iterator pointing to the sought after %pair. If unsuccessful it
* pointing to the sought after %pair. If unsuccessful it returns the * returns the past-the-end ( @c end() ) iterator.
* past-the-end ( @c end() ) iterator. */
*/ const_iterator
iterator find(const key_type& __x) const
find(const key_type& __x) { return _M_t.find(__x); } { return _M_t.find(__x); }
/** /**
* @brief Tries to locate an element in a %multimap. * @brief Finds the number of elements with given key.
* @param x Key of (key, value) pair to be located. * @param x Key of (key, value) pairs to be located.
* @return Read-only (constant) iterator pointing to sought-after * @return Number of elements with specified key.
* element, or end() if not found. */
* size_type
* This function takes a key and tries to locate the element with which count(const key_type& __x) const
* the key matches. If successful the function returns a constant iterator { return _M_t.count(__x); }
* pointing to the sought after %pair. If unsuccessful it returns the
* past-the-end ( @c end() ) iterator.
*/
const_iterator
find(const key_type& __x) const { return _M_t.find(__x); }
/** /**
* @brief Finds the number of elements with given key. * @brief Finds the beginning of a subsequence matching given key.
* @param x Key of (key, value) pairs to be located. * @param x Key of (key, value) pair to be located.
* @return Number of elements with specified key. * @return Iterator pointing to first element equal to or greater
*/ * than key, or end().
size_type *
count(const key_type& __x) const { return _M_t.count(__x); } * This function returns the first element of a subsequence of elements
* that matches the given key. If unsuccessful it returns an iterator
* pointing to the first element that has a greater value than given key
* or end() if no such element exists.
*/
iterator
lower_bound(const key_type& __x)
{ return _M_t.lower_bound(__x); }
/** /**
* @brief Finds the beginning of a subsequence matching given key. * @brief Finds the beginning of a subsequence matching given key.
* @param x Key of (key, value) pair to be located. * @param x Key of (key, value) pair to be located.
* @return Iterator pointing to first element equal to or greater * @return Read-only (constant) iterator pointing to first element
* than key, or end(). * equal to or greater than key, or end().
* *
* This function returns the first element of a subsequence of elements * This function returns the first element of a subsequence of elements
* that matches the given key. If unsuccessful it returns an iterator * that matches the given key. If unsuccessful the iterator will point
* pointing to the first element that has a greater value than given key * to the next greatest element or, if no such greater element exists, to
* or end() if no such element exists. * end().
*/ */
iterator const_iterator
lower_bound(const key_type& __x) { return _M_t.lower_bound(__x); } lower_bound(const key_type& __x) const
{ return _M_t.lower_bound(__x); }
/** /**
* @brief Finds the beginning of a subsequence matching given key. * @brief Finds the end of a subsequence matching given key.
* @param x Key of (key, value) pair to be located. * @param x Key of (key, value) pair to be located.
* @return Read-only (constant) iterator pointing to first element * @return Iterator pointing to the first element
* equal to or greater than key, or end(). * greater than key, or end().
* */
* This function returns the first element of a subsequence of elements iterator
* that matches the given key. If unsuccessful the iterator will point upper_bound(const key_type& __x)
* to the next greatest element or, if no such greater element exists, to { return _M_t.upper_bound(__x); }
* end().
*/
const_iterator
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.
* @param x Key of (key, value) pair to be located. * @param x Key of (key, value) pair to be located.
* @return Iterator pointing to the first element * @return Read-only (constant) iterator pointing to first iterator
* greater than key, or end(). * greater than key, or end().
*/ */
iterator const_iterator
upper_bound(const key_type& __x) { return _M_t.upper_bound(__x); } upper_bound(const key_type& __x) const
{ return _M_t.upper_bound(__x); }
/** /**
* @brief Finds the end of a subsequence matching given key. * @brief Finds a subsequence matching given key.
* @param x Key of (key, value) pair to be located. * @param x Key of (key, value) pairs to be located.
* @return Read-only (constant) iterator pointing to first iterator * @return Pair of iterators that possibly points to the subsequence
* greater than key, or end(). * matching given key.
*/ *
const_iterator * This function is equivalent to
upper_bound(const key_type& __x) const { return _M_t.upper_bound(__x); } * @code
* std::make_pair(c.lower_bound(val),
* c.upper_bound(val))
* @endcode
* (but is faster than making the calls separately).
*/
pair<iterator,iterator>
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 iterators that possibly points to the subsequence * @return Pair of read-only (constant) iterators that possibly points
* matching given key. * to the subsequence matching given key.
* *
* This function is equivalent to * This function is equivalent to
* @code * @code
* std::make_pair(c.lower_bound(val), * std::make_pair(c.lower_bound(val),
* c.upper_bound(val)) * c.upper_bound(val))
* @endcode * @endcode
* (but is faster than making the calls separately). * (but is faster than making the calls separately).
*/ */
pair<iterator,iterator> pair<const_iterator,const_iterator>
equal_range(const key_type& __x) { 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>
* @brief Finds a subsequence matching given key. friend bool
* @param x Key of (key, value) pairs to be located. operator== (const multimap<_K1,_T1,_C1,_A1>&,
* @return Pair of read-only (constant) iterators that possibly points to const multimap<_K1,_T1,_C1,_A1>&);
* the subsequence matching given key.
*
* This function is equivalent to
* @code
* std::make_pair(c.lower_bound(val),
* c.upper_bound(val))
* @endcode
* (but is faster than making the calls separately).
*/
pair<const_iterator,const_iterator>
equal_range(const key_type& __x) const { return _M_t.equal_range(__x); }
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
const multimap<_K1,_T1,_C1,_A1>&); operator< (const multimap<_K1,_T1,_C1,_A1>&,
template <typename _K1, typename _T1, typename _C1, typename _A1> const multimap<_K1,_T1,_C1,_A1>&);
friend bool operator< (const multimap<_K1,_T1,_C1,_A1>&,
const multimap<_K1,_T1,_C1,_A1>&);
}; };
/** /**
* @brief Multimap equality comparison. * @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.

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

@ -66,19 +66,18 @@
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>,
class _Alloc = allocator<_Key> >
class multiset;
template <class _Key, class _Compare = less<_Key>, template <class _Key, class _Compare, class _Alloc>
class _Alloc = allocator<_Key> > inline bool operator==(const multiset<_Key,_Compare,_Alloc>& __x,
class multiset; 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);
template <class _Key, class _Compare, class _Alloc>
inline bool operator<(const multiset<_Key,_Compare,_Alloc>& __x,
const multiset<_Key,_Compare,_Alloc>& __y);
/** /**
* @brief A standard container made up of elements, which can be retrieved * @brief A standard container made up of elements, which can be retrieved
@ -101,362 +100,410 @@ inline bool operator<(const multiset<_Key,_Compare,_Alloc>& __x,
* @endif * @endif
*/ */
template <class _Key, class _Compare, class _Alloc> template <class _Key, class _Compare, class _Alloc>
class multiset class multiset
{ {
// 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:
typedef _Key key_type;
typedef _Key value_type;
typedef _Compare key_compare;
typedef _Compare value_compare;
// typedefs: private:
/// @if maint This turns a red-black tree into a [multi]set. @endif
typedef _Rb_tree<key_type, value_type,
_Identity<value_type>, key_compare, _Alloc> _Rep_type;
/// @if maint The actual tree structure. @endif
_Rep_type _M_t;
typedef _Key key_type; public:
typedef _Key value_type; typedef typename _Alloc::pointer pointer;
typedef _Compare key_compare; typedef typename _Alloc::const_pointer const_pointer;
typedef _Compare value_compare; typedef typename _Alloc::reference reference;
typedef typename _Alloc::const_reference const_reference;
private: typedef typename _Rep_type::const_iterator iterator;
/// @if maint This turns a red-black tree into a [multi]set. @endif typedef typename _Rep_type::const_iterator const_iterator;
typedef _Rb_tree<key_type, value_type, typedef typename _Rep_type::const_reverse_iterator reverse_iterator;
_Identity<value_type>, key_compare, _Alloc> _Rep_type; typedef typename _Rep_type::const_reverse_iterator const_reverse_iterator;
/// @if maint The actual tree structure. @endif typedef typename _Rep_type::size_type size_type;
_Rep_type _M_t; typedef typename _Rep_type::difference_type difference_type;
typedef typename _Rep_type::allocator_type allocator_type;
public:
typedef typename _Alloc::pointer pointer;
typedef typename _Alloc::const_pointer const_pointer;
typedef typename _Alloc::reference reference;
typedef typename _Alloc::const_reference const_reference;
typedef typename _Rep_type::const_iterator iterator;
typedef typename _Rep_type::const_iterator const_iterator;
typedef typename _Rep_type::const_reverse_iterator reverse_iterator;
typedef typename _Rep_type::const_reverse_iterator const_reverse_iterator;
typedef typename _Rep_type::size_type size_type;
typedef typename _Rep_type::difference_type difference_type;
typedef typename _Rep_type::allocator_type allocator_type;
// allocation/deallocation // allocation/deallocation
/** /**
* @brief Default constructor creates no elements. * @brief Default constructor creates no elements.
*/
multiset() : _M_t(_Compare(), allocator_type()) {}
explicit multiset(const _Compare& __comp,
const allocator_type& __a = allocator_type())
: _M_t(__comp, __a) {}
/**
* @brief Builds a %multiset from a range.
* @param first An input iterator.
* @param last An input iterator.
*
* Create a %multiset consisting of copies of the elements from
* [first,last). This is linear in N if the range is already sorted,
* and NlogN otherwise (where N is distance(first,last)).
*/
template <class _InputIterator>
multiset(_InputIterator __first, _InputIterator __last)
: _M_t(_Compare(), allocator_type())
{ _M_t.insert_equal(__first, __last); }
/**
* @brief Builds a %multiset from a range.
* @param first An input iterator.
* @param last An input iterator.
* @param comp A comparison functor.
* @param a An allocator object.
*
* Create a %multiset consisting of copies of the elements from
* [first,last). This is linear in N if the range is already sorted,
* and NlogN otherwise (where N is distance(first,last)).
*/
template <class _InputIterator>
multiset(_InputIterator __first, _InputIterator __last,
const _Compare& __comp,
const allocator_type& __a = allocator_type())
: _M_t(__comp, __a) { _M_t.insert_equal(__first, __last); }
/**
* @brief %Multiset copy constructor.
* @param x A %multiset of identical element and allocator types.
*
* The newly-created %multiset uses a copy of the allocation object used
* by @a x.
*/
multiset(const multiset<_Key,_Compare,_Alloc>& __x) : _M_t(__x._M_t) {}
/**
* @brief %Multiset assignment operator.
* @param x A %multiset of identical element and allocator types.
*
* All the elements of @a x are copied, but unlike the copy constructor,
* the allocator object is not copied.
*/
multiset<_Key,_Compare,_Alloc>&
operator=(const multiset<_Key,_Compare,_Alloc>& __x) {
_M_t = __x._M_t;
return *this;
}
// accessors:
/// Returns the comparison object.
key_compare key_comp() const { return _M_t.key_comp(); }
/// Returns the comparison object.
value_compare value_comp() const { return _M_t.key_comp(); }
/// Returns the memory allocation object.
allocator_type get_allocator() const { return _M_t.get_allocator(); }
/**
* Returns a read/write iterator that points to the first element in the
* %multiset. Iteration is done in ascending order according to the
* keys.
*/ */
iterator begin() const { return _M_t.begin(); } multiset()
: _M_t(_Compare(), allocator_type()) { }
/** explicit multiset(const _Compare& __comp,
* Returns a read/write iterator that points one past the last element in const allocator_type& __a = allocator_type())
* the %multiset. Iteration is done in ascending order according to the : _M_t(__comp, __a) { }
* keys.
*/
iterator end() const { return _M_t.end(); }
/** /**
* Returns a read/write reverse iterator that points to the last element * @brief Builds a %multiset from a range.
* in the %multiset. Iteration is done in descending order according to * @param first An input iterator.
* the keys. * @param last An input iterator.
*/ *
reverse_iterator rbegin() const { return _M_t.rbegin(); } * Create a %multiset consisting of copies of the elements from
* [first,last). This is linear in N if the range is already sorted,
* and NlogN otherwise (where N is distance(first,last)).
*/
template <class _InputIterator>
multiset(_InputIterator __first, _InputIterator __last)
: _M_t(_Compare(), allocator_type())
{ _M_t.insert_equal(__first, __last); }
/** /**
* Returns a read/write reverse iterator that points to the last element * @brief Builds a %multiset from a range.
* in the %multiset. Iteration is done in descending order according to * @param first An input iterator.
* the keys. * @param last An input iterator.
*/ * @param comp A comparison functor.
reverse_iterator rend() const { return _M_t.rend(); } * @param a An allocator object.
*
* Create a %multiset consisting of copies of the elements from
* [first,last). This is linear in N if the range is already sorted,
* and NlogN otherwise (where N is distance(first,last)).
*/
template <class _InputIterator>
multiset(_InputIterator __first, _InputIterator __last,
const _Compare& __comp,
const allocator_type& __a = allocator_type())
: _M_t(__comp, __a)
{ _M_t.insert_equal(__first, __last); }
/// Returns true if the %set is empty. /**
bool empty() const { return _M_t.empty(); } * @brief %Multiset copy constructor.
* @param x A %multiset of identical element and allocator types.
*
* The newly-created %multiset uses a copy of the allocation object used
* by @a x.
*/
multiset(const multiset<_Key,_Compare,_Alloc>& __x)
: _M_t(__x._M_t) { }
/// Returns the size of the %set. /**
size_type size() const { return _M_t.size(); } * @brief %Multiset assignment operator.
* @param x A %multiset of identical element and allocator types.
*
* All the elements of @a x are copied, but unlike the copy constructor,
* the allocator object is not copied.
*/
multiset<_Key,_Compare,_Alloc>&
operator=(const multiset<_Key,_Compare,_Alloc>& __x)
{
_M_t = __x._M_t;
return *this;
}
/// Returns the maximum size of the %set. // accessors:
size_type max_size() const { return _M_t.max_size(); }
/** /// Returns the comparison object.
* @brief Swaps data with another %multiset. key_compare
* @param x A %multiset of the same element and allocator types. key_comp() const
* { return _M_t.key_comp(); }
* This exchanges the elements between two multisets in constant time. /// Returns the comparison object.
* (It is only swapping a pointer, an integer, and an instance of the @c value_compare
* Compare type (which itself is often stateless and empty), so it should value_comp() const
* be quite fast.) { return _M_t.key_comp(); }
* Note that the global std::swap() function is specialized such that /// Returns the memory allocation object.
* std::swap(s1,s2) will feed to this function. allocator_type
*/ get_allocator() const
void swap(multiset<_Key,_Compare,_Alloc>& __x) { _M_t.swap(__x._M_t); } { return _M_t.get_allocator(); }
// insert/erase /**
/** * Returns a read/write iterator that points to the first element in the
* @brief Inserts an element into the %multiset. * %multiset. Iteration is done in ascending order according to the
* @param x Element to be inserted. * keys.
* @return An iterator that points to the inserted element. */
* iterator
* This function inserts an element into the %multiset. Contrary begin() const
* to a std::set the %multiset does not rely on unique keys and thus { return _M_t.begin(); }
* multiple copies of the same element can be inserted.
*
* Insertion requires logarithmic time.
*/
iterator insert(const value_type& __x) {
return _M_t.insert_equal(__x);
}
/** /**
* @brief Inserts an element into the %multiset. * Returns a read/write iterator that points one past the last element in
* @param position An iterator that serves as a hint as to where the * the %multiset. Iteration is done in ascending order according to the
* element should be inserted. * keys.
* @param x Element to be inserted. */
* @return An iterator that points to the inserted element. iterator
* end() const
* This function inserts an element into the %multiset. Contrary { return _M_t.end(); }
* to a std::set the %multiset does not rely on unique keys and thus
* multiple copies of the same element can be inserted.
*
* Note that the first parameter is only a hint and can potentially
* improve the performance of the insertion process. A bad hint would
* cause no gains in efficiency.
*
* See http://gcc.gnu.org/onlinedocs/libstdc++/23_containers/howto.html#4
* for more on "hinting".
*
* Insertion requires logarithmic time (if the hint is not taken).
*/
iterator insert(iterator __position, const value_type& __x) {
typedef typename _Rep_type::iterator _Rep_iterator;
return _M_t.insert_equal((_Rep_iterator&)__position, __x);
}
/** /**
* @brief A template function that attemps to insert a range of elements. * Returns a read/write reverse iterator that points to the last element
* @param first Iterator pointing to the start of the range to be * in the %multiset. Iteration is done in descending order according to
* inserted. * the keys.
* @param last Iterator pointing to the end of the range. */
* reverse_iterator
* Complexity similar to that of the range constructor. rbegin() const
*/ { return _M_t.rbegin(); }
template <class _InputIterator>
void insert(_InputIterator __first, _InputIterator __last) {
_M_t.insert_equal(__first, __last);
}
/** /**
* @brief Erases an element from a %multiset. * Returns a read/write reverse iterator that points to the last element
* @param position An iterator pointing to the element to be erased. * in the %multiset. Iteration is done in descending order according to
* * the keys.
* This function erases an element, pointed to by the given iterator, */
* from a %multiset. Note that this function only erases the element, reverse_iterator
* and that if the element is itself a pointer, the pointed-to memory is rend() const
* not touched in any way. Managing the pointer is the user's { return _M_t.rend(); }
* responsibilty.
*/
void erase(iterator __position) {
typedef typename _Rep_type::iterator _Rep_iterator;
_M_t.erase((_Rep_iterator&)__position);
}
/** /// Returns true if the %set is empty.
* @brief Erases elements according to the provided key. bool
* @param x Key of element to be erased. empty() const
* @return The number of elements erased. { return _M_t.empty(); }
*
* This function erases all elements located by the given key from a
* %multiset.
* Note that this function only erases the element, and that if
* the element is itself a pointer, the pointed-to memory is not touched
* in any way. Managing the pointer is the user's responsibilty.
*/
size_type erase(const key_type& __x) {
return _M_t.erase(__x);
}
/** /// Returns the size of the %set.
* @brief Erases a [first,last) range of elements from a %multiset. size_type
* @param first Iterator pointing to the start of the range to be erased. size() const
* @param last Iterator pointing to the end of the range to be erased. { return _M_t.size(); }
*
* This function erases a sequence of elements from a %multiset.
* Note that this function only erases the elements, and that if
* the elements themselves are pointers, the pointed-to memory is not
* touched in any way. Managing the pointer is the user's responsibilty.
*/
void erase(iterator __first, iterator __last) {
typedef typename _Rep_type::iterator _Rep_iterator;
_M_t.erase((_Rep_iterator&)__first, (_Rep_iterator&)__last);
}
/** /// Returns the maximum size of the %set.
* Erases all elements in a %multiset. Note that this function only size_type
* erases the elements, and that if the elements themselves are pointers, max_size() const
* the pointed-to memory is not touched in any way. Managing the pointer { return _M_t.max_size(); }
* is the user's responsibilty.
*/
void clear() { _M_t.clear(); }
// multiset operations: /**
* @brief Swaps data with another %multiset.
* @param x A %multiset of the same element and allocator types.
*
* This exchanges the elements between two multisets in constant time.
* (It is only swapping a pointer, an integer, and an instance of the @c
* Compare type (which itself is often stateless and empty), so it should
* be quite fast.)
* Note that the global std::swap() function is specialized such that
* std::swap(s1,s2) will feed to this function.
*/
void
swap(multiset<_Key,_Compare,_Alloc>& __x)
{ _M_t.swap(__x._M_t); }
/** // insert/erase
* @brief Finds the number of elements with given key. /**
* @param x Key of elements to be located. * @brief Inserts an element into the %multiset.
* @return Number of elements with specified key. * @param x Element to be inserted.
*/ * @return An iterator that points to the inserted element.
size_type count(const key_type& __x) const { return _M_t.count(__x); } *
* This function inserts an element into the %multiset. Contrary
* to a std::set the %multiset does not rely on unique keys and thus
* multiple copies of the same element can be inserted.
*
* Insertion requires logarithmic time.
*/
iterator
insert(const value_type& __x)
{ return _M_t.insert_equal(__x); }
// _GLIBCXX_RESOLVE_LIB_DEFECTS /**
// 214. set::find() missing const overload * @brief Inserts an element into the %multiset.
//@{ * @param position An iterator that serves as a hint as to where the
/** * element should be inserted.
* @brief Tries to locate an element in a %set. * @param x Element to be inserted.
* @param x Element to be located. * @return An iterator that points to the inserted element.
* @return Iterator pointing to sought-after element, or end() if not *
* found. * This function inserts an element into the %multiset. Contrary
* * to a std::set the %multiset does not rely on unique keys and thus
* This function takes a key and tries to locate the element with which * multiple copies of the same element can be inserted.
* the key matches. If successful the function returns an iterator *
* pointing to the sought after element. If unsuccessful it returns the * Note that the first parameter is only a hint and can potentially
* past-the-end ( @c end() ) iterator. * improve the performance of the insertion process. A bad hint would
*/ * cause no gains in efficiency.
iterator find(const key_type& __x) { return _M_t.find(__x); } *
const_iterator find(const key_type& __x) const { return _M_t.find(__x); } * See http://gcc.gnu.org/onlinedocs/libstdc++/23_containers/howto.html#4
//@} * for more on "hinting".
*
* Insertion requires logarithmic time (if the hint is not taken).
*/
iterator
insert(iterator __position, const value_type& __x)
{
typedef typename _Rep_type::iterator _Rep_iterator;
return _M_t.insert_equal((_Rep_iterator&)__position, __x);
}
//@{ /**
/** * @brief A template function that attemps to insert a range of elements.
* @brief Finds the beginning of a subsequence matching given key. * @param first Iterator pointing to the start of the range to be
* @param x Key to be located. * inserted.
* @return Iterator pointing to first element equal to or greater * @param last Iterator pointing to the end of the range.
* than key, or end(). *
* * Complexity similar to that of the range constructor.
* This function returns the first element of a subsequence of elements */
* that matches the given key. If unsuccessful it returns an iterator template <class _InputIterator>
* pointing to the first element that has a greater value than given key void
* or end() if no such element exists. insert(_InputIterator __first, _InputIterator __last)
*/ { _M_t.insert_equal(__first, __last); }
iterator lower_bound(const key_type& __x) {
return _M_t.lower_bound(__x);
}
const_iterator lower_bound(const key_type& __x) const {
return _M_t.lower_bound(__x);
}
//@}
//@{ /**
/** * @brief Erases an element from a %multiset.
* @brief Finds the end of a subsequence matching given key. * @param position An iterator pointing to the element to be erased.
* @param x Key to be located. *
* @return Iterator pointing to the first element * This function erases an element, pointed to by the given iterator,
* greater than key, or end(). * from a %multiset. Note that this function only erases the element,
*/ * and that if the element is itself a pointer, the pointed-to memory is
iterator upper_bound(const key_type& __x) { * not touched in any way. Managing the pointer is the user's
return _M_t.upper_bound(__x); * responsibilty.
} */
const_iterator upper_bound(const key_type& __x) const { void
return _M_t.upper_bound(__x); erase(iterator __position)
} {
//@} typedef typename _Rep_type::iterator _Rep_iterator;
_M_t.erase((_Rep_iterator&)__position);
}
//@{ /**
/** * @brief Erases elements according to the provided key.
* @brief Finds a subsequence matching given key. * @param x Key of element to be erased.
* @param x Key to be located. * @return The number of elements erased.
* @return Pair of iterators that possibly points to the subsequence *
* matching given key. * This function erases all elements located by the given key from a
* * %multiset.
* This function is equivalent to * Note that this function only erases the element, and that if
* @code * the element is itself a pointer, the pointed-to memory is not touched
* std::make_pair(c.lower_bound(val), * in any way. Managing the pointer is the user's responsibilty.
* c.upper_bound(val)) */
* @endcode size_type
* (but is faster than making the calls separately). erase(const key_type& __x)
* { return _M_t.erase(__x); }
* This function probably only makes sense for multisets.
*/
pair<iterator,iterator> equal_range(const key_type& __x) {
return _M_t.equal_range(__x);
}
pair<const_iterator,const_iterator> equal_range(const key_type& __x) const {
return _M_t.equal_range(__x);
}
template <class _K1, class _C1, class _A1> /**
friend bool operator== (const multiset<_K1,_C1,_A1>&, * @brief Erases a [first,last) range of elements from a %multiset.
const multiset<_K1,_C1,_A1>&); * @param first Iterator pointing to the start of the range to be
template <class _K1, class _C1, class _A1> * erased.
friend bool operator< (const multiset<_K1,_C1,_A1>&, * @param last Iterator pointing to the end of the range to be erased.
const multiset<_K1,_C1,_A1>&); *
}; * This function erases a sequence of elements from a %multiset.
* Note that this function only erases the elements, and that if
* the elements themselves are pointers, the pointed-to memory is not
* touched in any way. Managing the pointer is the user's responsibilty.
*/
void
erase(iterator __first, iterator __last)
{
typedef typename _Rep_type::iterator _Rep_iterator;
_M_t.erase((_Rep_iterator&)__first, (_Rep_iterator&)__last);
}
/**
* Erases all elements in a %multiset. Note that this function only
* erases the elements, and that if the elements themselves are pointers,
* the pointed-to memory is not touched in any way. Managing the pointer
* is the user's responsibilty.
*/
void
clear()
{ _M_t.clear(); }
// multiset operations:
/**
* @brief Finds the number of elements with given key.
* @param x Key of elements to be located.
* @return Number of elements with specified key.
*/
size_type
count(const key_type& __x) const
{ return _M_t.count(__x); }
// _GLIBCXX_RESOLVE_LIB_DEFECTS
// 214. set::find() missing const overload
//@{
/**
* @brief Tries to locate an element in a %set.
* @param x Element to be located.
* @return Iterator pointing to sought-after element, or end() if not
* found.
*
* This function takes a key and tries to locate the element with which
* the key matches. If successful the function returns an iterator
* pointing to the sought after element. If unsuccessful it returns the
* past-the-end ( @c end() ) iterator.
*/
iterator
find(const key_type& __x)
{ return _M_t.find(__x); }
const_iterator
find(const key_type& __x) const
{ return _M_t.find(__x); }
//@}
//@{
/**
* @brief Finds the beginning of a subsequence matching given key.
* @param x Key to be located.
* @return Iterator pointing to first element equal to or greater
* than key, or end().
*
* This function returns the first element of a subsequence of elements
* that matches the given key. If unsuccessful it returns an iterator
* pointing to the first element that has a greater value than given key
* or end() if no such element exists.
*/
iterator
lower_bound(const key_type& __x)
{ return _M_t.lower_bound(__x); }
const_iterator
lower_bound(const key_type& __x) const
{ return _M_t.lower_bound(__x); }
//@}
//@{
/**
* @brief Finds the end of a subsequence matching given key.
* @param x Key to be located.
* @return Iterator pointing to the first element
* greater than key, or end().
*/
iterator
upper_bound(const key_type& __x)
{ return _M_t.upper_bound(__x); }
const_iterator
upper_bound(const key_type& __x) const
{ return _M_t.upper_bound(__x); }
//@}
//@{
/**
* @brief Finds a subsequence matching given key.
* @param x Key to be located.
* @return Pair of iterators that possibly points to the subsequence
* matching given key.
*
* This function is equivalent to
* @code
* std::make_pair(c.lower_bound(val),
* c.upper_bound(val))
* @endcode
* (but is faster than making the calls separately).
*
* This function probably only makes sense for multisets.
*/
pair<iterator,iterator>
equal_range(const key_type& __x)
{ return _M_t.equal_range(__x); }
pair<const_iterator,const_iterator>
equal_range(const key_type& __x) const
{ return _M_t.equal_range(__x); }
template <class _K1, class _C1, class _A1>
friend bool
operator== (const multiset<_K1,_C1,_A1>&,
const multiset<_K1,_C1,_A1>&);
template <class _K1, class _C1, class _A1>
friend bool
operator< (const multiset<_K1,_C1,_A1>&,
const multiset<_K1,_C1,_A1>&);
};
/** /**
* @brief Multiset equality comparison. * @brief Multiset equality comparison.
@ -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.
*/ */
@ -472,7 +520,7 @@ inline bool operator<(const multiset<_Key,_Compare,_Alloc>& __x,
inline bool inline bool
operator==(const multiset<_Key,_Compare,_Alloc>& __x, operator==(const multiset<_Key,_Compare,_Alloc>& __x,
const multiset<_Key,_Compare,_Alloc>& __y) const multiset<_Key,_Compare,_Alloc>& __y)
{ return __x._M_t == __y._M_t; } { return __x._M_t == __y._M_t; }
/** /**
* @brief Multiset ordering relation. * @brief Multiset ordering relation.
@ -489,42 +537,42 @@ inline bool operator<(const multiset<_Key,_Compare,_Alloc>& __x,
inline bool inline bool
operator<(const multiset<_Key,_Compare,_Alloc>& __x, operator<(const multiset<_Key,_Compare,_Alloc>& __x,
const multiset<_Key,_Compare,_Alloc>& __y) const multiset<_Key,_Compare,_Alloc>& __y)
{ return __x._M_t < __y._M_t; } { return __x._M_t < __y._M_t; }
/// Returns !(x == y). /// Returns !(x == y).
template <class _Key, class _Compare, class _Alloc> template <class _Key, class _Compare, class _Alloc>
inline bool inline bool
operator!=(const multiset<_Key,_Compare,_Alloc>& __x, operator!=(const multiset<_Key,_Compare,_Alloc>& __x,
const multiset<_Key,_Compare,_Alloc>& __y) const multiset<_Key,_Compare,_Alloc>& __y)
{ return !(__x == __y); } { return !(__x == __y); }
/// Returns y < x. /// Returns y < x.
template <class _Key, class _Compare, class _Alloc> template <class _Key, class _Compare, class _Alloc>
inline bool inline bool
operator>(const multiset<_Key,_Compare,_Alloc>& __x, operator>(const multiset<_Key,_Compare,_Alloc>& __x,
const multiset<_Key,_Compare,_Alloc>& __y) const multiset<_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
operator<=(const multiset<_Key,_Compare,_Alloc>& __x, operator<=(const multiset<_Key,_Compare,_Alloc>& __x,
const multiset<_Key,_Compare,_Alloc>& __y) const multiset<_Key,_Compare,_Alloc>& __y)
{ return !(__y < __x); } { return !(__y < __x); }
/// Returns !(x < y) /// Returns !(x < y)
template <class _Key, class _Compare, class _Alloc> template <class _Key, class _Compare, class _Alloc>
inline bool inline bool
operator>=(const multiset<_Key,_Compare,_Alloc>& __x, operator>=(const multiset<_Key,_Compare,_Alloc>& __x,
const multiset<_Key,_Compare,_Alloc>& __y) const multiset<_Key,_Compare,_Alloc>& __y)
{ return !(__x < __y); } { return !(__x < __y); }
/// See std::multiset::swap(). /// See std::multiset::swap().
template <class _Key, class _Compare, class _Alloc> template <class _Key, class _Compare, class _Alloc>
inline void inline void
swap(multiset<_Key,_Compare,_Alloc>& __x, swap(multiset<_Key,_Compare,_Alloc>& __x,
multiset<_Key,_Compare,_Alloc>& __y) multiset<_Key,_Compare,_Alloc>& __y)
{ __x.swap(__y); } { __x.swap(__y); }
} // namespace __gnu_norm } // namespace __gnu_norm

104
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
@ -75,61 +75,61 @@ namespace std
{ {
namespace rel_ops namespace rel_ops
{ {
/** @namespace std::rel_ops /** @namespace std::rel_ops
* @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

154
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.
@ -152,7 +154,7 @@ namespace __gnu_norm
*/ */
explicit set(const _Compare& __comp, explicit set(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 %set from a range. * @brief Builds a %set from a range.
@ -164,9 +166,9 @@ 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) set(_InputIterator __first, _InputIterator __last)
: _M_t(_Compare(), allocator_type()) : _M_t(_Compare(), allocator_type())
{ _M_t.insert_unique(__first, __last); } { _M_t.insert_unique(__first, __last); }
/** /**
* @brief Builds a %set from a range. * @brief Builds a %set from a range.
@ -180,10 +182,11 @@ 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 allocator_type& __a = allocator_type()) const _Compare& __comp,
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); }
/** /**
* @brief Set copy constructor. * @brief Set copy constructor.
@ -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>&);
}; };
@ -508,8 +563,7 @@ namespace __gnu_norm
inline bool inline bool
operator>(const set<_Key,_Compare,_Alloc>& __x, operator>(const set<_Key,_Compare,_Alloc>& __x,
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>