Skip to content

R
riscv-gcc-1
Commit f6592a9e by Paolo Carlini Committed by Paolo Carlini
Options

deque.tcc: Wrap overlong lines... 

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

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

From-SVN: r77077
parent e0a24727
Showing with 1412 additions and 984 deletions
libstdc++-v3/ChangeLog
2004-02-01 Paolo Carlini <pcarlini@suse.de>
* include/bits/deque.tcc: Wrap overlong lines, constify
a few variables, reformat according to the coding standards.
* include/bits/list.tcc: Likewise.
* include/bits/stl_deque.h: Likewise.
* include/bits/stl_function.h: Likewise.
* include/bits/stl_iterator.h: Likewise.
* include/bits/stl_iterator_base_funcs.h: Likewise.
* include/bits/stl_iterator_base_types.h: Likewise.
* include/bits/stl_list.h: Likewise.
* include/bits/stl_map.h: Likewise.
* include/bits/stl_multimap.h: Likewise.
* include/bits/stl_multiset.h: Likewise.
* include/bits/stl_relops.h: Likewise.
* include/bits/stl_set.h: Likewise.
2004-02-01 Paolo Carlini <pcarlini@suse.de>
* include/bits/stl_bvector.h: Wrap overlong lines, constify
a few variables, reformat according to the coding standards.
* include/bits/stl_tree.h: Likewise.
......
libstdc++-v3/include/bits/deque.tcc
// Deque implementation (out of line) -*- C++ -*-
// Copyright (C) 2001, 2002, 2003 Free Software Foundation, Inc.
// Copyright (C) 2001, 2002, 2003, 2004 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
......@@ -72,7 +72,8 @@ namespace __gnu_norm
if (&__x != this)
{
if (__len >= __x.size())
erase(std::copy(__x.begin(), __x.end(), this->_M_start), this->_M_finish);
erase(std::copy(__x.begin(), __x.end(), this->_M_start),
this->_M_finish);
else
{
const_iterator __mid = __x.begin() + difference_type(__len);
......@@ -137,8 +138,8 @@ namespace __gnu_norm
}
else
{
difference_type __n = __last - __first;
difference_type __elems_before = __first - this->_M_start;
const difference_type __n = __last - __first;
const difference_type __elems_before = __first - this->_M_start;
if (static_cast<size_type>(__elems_before) < (size() - __n) / 2)
{
std::copy_backward(this->_M_start, __first, __last);
......@@ -189,7 +190,8 @@ namespace __gnu_norm
template <typename _InputIterator>
void
deque<_Tp,_Alloc>
::_M_assign_aux(_InputIterator __first, _InputIterator __last, input_iterator_tag)
::_M_assign_aux(_InputIterator __first, _InputIterator __last,
input_iterator_tag)
{
iterator __cur = begin();
for ( ; __first != __last && __cur != end(); ++__cur, ++__first)
......@@ -288,7 +290,7 @@ namespace __gnu_norm
_M_range_initialize(_ForwardIterator __first, _ForwardIterator __last,
forward_iterator_tag)
{
size_type __n = std::distance(__first, __last);
const size_type __n = std::distance(__first, __last);
this->_M_initialize_map(__n);
_Map_pointer __cur_node;
......@@ -389,9 +391,7 @@ namespace __gnu_norm
_M_range_insert_aux(iterator __pos,
_InputIterator __first, _InputIterator __last,
input_iterator_tag)
{
std::copy(__first, __last, std::inserter(*this, __pos));
}
{ std::copy(__first, __last, std::inserter(*this, __pos)); }
template <typename _Tp, typename _Alloc>
template <typename _ForwardIterator>
......@@ -486,14 +486,16 @@ namespace __gnu_norm
if (__elems_before >= difference_type(__n))
{
iterator __start_n = this->_M_start + difference_type(__n);
std::uninitialized_copy(this->_M_start, __start_n, __new_start);
std::uninitialized_copy(this->_M_start, __start_n,
__new_start);
this->_M_start = __new_start;
std::copy(__start_n, __pos, __old_start);
fill(__pos - difference_type(__n), __pos, __x_copy);
}
else
{
std::__uninitialized_copy_fill(this->_M_start, __pos, __new_start,
std::__uninitialized_copy_fill(this->_M_start, __pos,
__new_start,
this->_M_start, __x_copy);
this->_M_start = __new_start;
std::fill(__old_start, __pos, __x_copy);
......@@ -517,7 +519,8 @@ namespace __gnu_norm
if (__elems_after > difference_type(__n))
{
iterator __finish_n = this->_M_finish - difference_type(__n);
std::uninitialized_copy(__finish_n, this->_M_finish, this->_M_finish);
std::uninitialized_copy(__finish_n, this->_M_finish,
this->_M_finish);
this->_M_finish = __new_finish;
std::copy_backward(__pos, __finish_n, __old_finish);
std::fill(__pos, __pos + difference_type(__n), __x_copy);
......@@ -526,7 +529,8 @@ namespace __gnu_norm
{
std::__uninitialized_fill_copy(this->_M_finish,
__pos + difference_type(__n),
__x_copy, __pos, this->_M_finish);
__x_copy, __pos,
this->_M_finish);
this->_M_finish = __new_finish;
std::fill(__pos, __old_finish, __x_copy);
}
......@@ -560,7 +564,8 @@ namespace __gnu_norm
if (__elemsbefore >= difference_type(__n))
{
iterator __start_n = this->_M_start + difference_type(__n);
std::uninitialized_copy(this->_M_start, __start_n, __new_start);
std::uninitialized_copy(this->_M_start, __start_n,
__new_start);
this->_M_start = __new_start;
std::copy(__start_n, __pos, __old_start);
std::copy(__first, __last, __pos - difference_type(__n));
......@@ -605,7 +610,8 @@ namespace __gnu_norm
_ForwardIterator __mid = __first;
std::advance(__mid, __elemsafter);
std::__uninitialized_copy_copy(__mid, __last, __pos,
this->_M_finish, this->_M_finish);
this->_M_finish,
this->_M_finish);
this->_M_finish = __new_finish;
std::copy(__first, __mid, __pos);
}
......@@ -675,8 +681,8 @@ namespace __gnu_norm
_Map_pointer __new_nstart;
if (this->_M_map_size > 2 * __new_num_nodes)
{
__new_nstart
= this->_M_map + (this->_M_map_size - __new_num_nodes) / 2
__new_nstart = this->_M_map + (this->_M_map_size
- __new_num_nodes) / 2
+ (__add_at_front ? __nodes_to_add : 0);
if (__new_nstart < this->_M_start._M_node)
std::copy(this->_M_start._M_node,
......@@ -689,8 +695,9 @@ namespace __gnu_norm
}
else
{
size_type __new_map_size =
this->_M_map_size + std::max(this->_M_map_size, __nodes_to_add) + 2;
size_type __new_map_size = this->_M_map_size
+ std::max(this->_M_map_size,
__nodes_to_add) + 2;
_Map_pointer __new_map = this->_M_allocate_map(__new_map_size);
__new_nstart = __new_map + (__new_map_size - __new_num_nodes) / 2
......
libstdc++-v3/include/bits/list.tcc
// List implementation (out of line) -*- C++ -*-
// Copyright (C) 2001, 2002, 2003 Free Software Foundation, Inc.
// Copyright (C) 2001, 2002, 2003, 2004 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
......@@ -191,7 +191,8 @@ namespace __gnu_norm
{
iterator __first = begin();
iterator __last = end();
if (__first == __last) return;
if (__first == __last)
return;
iterator __next = __first;
while (++__next != __last)
{
......@@ -256,8 +257,10 @@ namespace __gnu_norm
__carry.swap(*__counter);
}
__carry.swap(*__counter);
if (__counter == __fill) ++__fill;
} while ( !empty() );
if (__counter == __fill)
++__fill;
}
while ( !empty() );
for (__counter = &__tmp[1]; __counter != __fill; ++__counter)
__counter->merge( *(__counter-1) );
......@@ -277,7 +280,8 @@ namespace __gnu_norm
{
iterator __next = __first;
++__next;
if (__pred(*__first)) _M_erase(__first);
if (__pred(*__first))
_M_erase(__first);
__first = __next;
}
}
......@@ -337,8 +341,8 @@ namespace __gnu_norm
sort(_StrictWeakOrdering __comp)
{
// Do nothing if the list has length 0 or 1.
if (this->_M_node._M_next != &this->_M_node &&
this->_M_node._M_next->_M_next != &this->_M_node)
if (this->_M_node._M_next != &this->_M_node
&& this->_M_node._M_next->_M_next != &this->_M_node)
{
list __carry;
list __tmp[64];
......@@ -357,8 +361,10 @@ namespace __gnu_norm
__carry.swap(*__counter);
}
__carry.swap(*__counter);
if (__counter == __fill) ++__fill;
} while ( !empty() );
if (__counter == __fill)
++__fill;
}
while ( !empty() );
for (__counter = &__tmp[1]; __counter != __fill; ++__counter)
__counter->merge( *(__counter-1), __comp );
......
libstdc++-v3/include/bits/stl_deque.h
// Deque implementation -*- C++ -*-
// Copyright (C) 2001, 2002, 2003 Free Software Foundation, Inc.
// Copyright (C) 2001, 2002, 2003, 2004 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
......@@ -101,7 +101,9 @@ namespace __gnu_norm
{
typedef _Deque_iterator<_Tp, _Tp&, _Tp*> iterator;
typedef _Deque_iterator<_Tp, const _Tp&, const _Tp*> const_iterator;
static size_t _S_buffer_size() { return __deque_buf_size(sizeof(_Tp)); }
static size_t _S_buffer_size()
{ return __deque_buf_size(sizeof(_Tp)); }
typedef random_access_iterator_tag iterator_category;
typedef _Tp value_type;
......@@ -120,72 +122,101 @@ namespace __gnu_norm
_Deque_iterator(_Tp* __x, _Map_pointer __y)
: _M_cur(__x), _M_first(*__y),
_M_last(*__y + _S_buffer_size()), _M_node(__y) {}
_Deque_iterator() : _M_cur(0), _M_first(0), _M_last(0), _M_node(0) {}
_Deque_iterator(const iterator& __x)
: _M_cur(__x._M_cur), _M_first(__x._M_first),
_M_last(__x._M_last), _M_node(__x._M_node) {}
reference operator*() const { return *_M_cur; }
pointer operator->() const { return _M_cur; }
reference
operator*() const
{ return *_M_cur; }
pointer
operator->() const
{ return _M_cur; }
_Self& operator++() {
_Self&
operator++()
{
++_M_cur;
if (_M_cur == _M_last) {
if (_M_cur == _M_last)
{
_M_set_node(_M_node + 1);
_M_cur = _M_first;
}
return *this;
}
_Self operator++(int) {
_Self
operator++(int)
{
_Self __tmp = *this;
++*this;
return __tmp;
}
_Self& operator--() {
if (_M_cur == _M_first) {
_Self&
operator--()
{
if (_M_cur == _M_first)
{
_M_set_node(_M_node - 1);
_M_cur = _M_last;
}
--_M_cur;
return *this;
}
_Self operator--(int) {
_Self
operator--(int)
{
_Self __tmp = *this;
--*this;
return __tmp;
}
_Self& operator+=(difference_type __n)
_Self&
operator+=(difference_type __n)
{
difference_type __offset = __n + (_M_cur - _M_first);
const difference_type __offset = __n + (_M_cur - _M_first);
if (__offset >= 0 && __offset < difference_type(_S_buffer_size()))
_M_cur += __n;
else {
difference_type __node_offset =
else
{
const difference_type __node_offset =
__offset > 0 ? __offset / difference_type(_S_buffer_size())
: -difference_type((-__offset - 1) / _S_buffer_size()) - 1;
: -difference_type((-__offset - 1)
/ _S_buffer_size()) - 1;
_M_set_node(_M_node + __node_offset);
_M_cur = _M_first +
(__offset - __node_offset * difference_type(_S_buffer_size()));
_M_cur = _M_first + (__offset - __node_offset
* difference_type(_S_buffer_size()));
}
return *this;
}
_Self operator+(difference_type __n) const
_Self
operator+(difference_type __n) const
{
_Self __tmp = *this;
return __tmp += __n;
}
_Self& operator-=(difference_type __n) { return *this += -__n; }
_Self&
operator-=(difference_type __n)
{ return *this += -__n; }
_Self operator-(difference_type __n) const {
_Self
operator-(difference_type __n) const
{
_Self __tmp = *this;
return __tmp -= __n;
}
reference operator[](difference_type __n) const { return *(*this + __n); }
reference
operator[](difference_type __n) const
{ return *(*this + __n); }
/** @if maint
* Prepares to traverse new_node. Sets everything except _M_cur, which
......@@ -209,105 +240,81 @@ namespace __gnu_norm
inline bool
operator==(const _Deque_iterator<_Tp, _Ref, _Ptr>& __x,
const _Deque_iterator<_Tp, _Ref, _Ptr>& __y)
{
return __x._M_cur == __y._M_cur;
}
{ return __x._M_cur == __y._M_cur; }
template<typename _Tp, typename _RefL, typename _PtrL,
typename _RefR, typename _PtrR>
inline bool
operator==(const _Deque_iterator<_Tp, _RefL, _PtrL>& __x,
const _Deque_iterator<_Tp, _RefR, _PtrR>& __y)
{
return __x._M_cur == __y._M_cur;
}
{ return __x._M_cur == __y._M_cur; }
template<typename _Tp, typename _Ref, typename _Ptr>
inline bool
operator!=(const _Deque_iterator<_Tp, _Ref, _Ptr>& __x,
const _Deque_iterator<_Tp, _Ref, _Ptr>& __y)
{
return !(__x == __y);
}
{ return !(__x == __y); }
template<typename _Tp, typename _RefL, typename _PtrL,
typename _RefR, typename _PtrR>
inline bool
operator!=(const _Deque_iterator<_Tp, _RefL, _PtrL>& __x,
const _Deque_iterator<_Tp, _RefR, _PtrR>& __y)
{
return !(__x == __y);
}
{ return !(__x == __y); }
template<typename _Tp, typename _Ref, typename _Ptr>
inline bool
operator<(const _Deque_iterator<_Tp, _Ref, _Ptr>& __x,
const _Deque_iterator<_Tp, _Ref, _Ptr>& __y)
{
return (__x._M_node == __y._M_node) ?
(__x._M_cur < __y._M_cur) : (__x._M_node < __y._M_node);
}
{ return (__x._M_node == __y._M_node) ? (__x._M_cur < __y._M_cur)
: (__x._M_node < __y._M_node); }
template<typename _Tp, typename _RefL, typename _PtrL,
typename _RefR, typename _PtrR>
inline bool
operator<(const _Deque_iterator<_Tp, _RefL, _PtrL>& __x,
const _Deque_iterator<_Tp, _RefR, _PtrR>& __y)
{
return (__x._M_node == __y._M_node) ?
(__x._M_cur < __y._M_cur) : (__x._M_node < __y._M_node);
}
{ return (__x._M_node == __y._M_node) ? (__x._M_cur < __y._M_cur)
: (__x._M_node < __y._M_node); }
template<typename _Tp, typename _Ref, typename _Ptr>
inline bool
operator>(const _Deque_iterator<_Tp, _Ref, _Ptr>& __x,
const _Deque_iterator<_Tp, _Ref, _Ptr>& __y)
{
return __y < __x;
}
{ return __y < __x; }
template<typename _Tp, typename _RefL, typename _PtrL,
typename _RefR, typename _PtrR>
inline bool
operator>(const _Deque_iterator<_Tp, _RefL, _PtrL>& __x,
const _Deque_iterator<_Tp, _RefR, _PtrR>& __y)
{
return __y < __x;
}
{ return __y < __x; }
template<typename _Tp, typename _Ref, typename _Ptr>
inline bool
operator<=(const _Deque_iterator<_Tp, _Ref, _Ptr>& __x,
const _Deque_iterator<_Tp, _Ref, _Ptr>& __y)
{
return !(__y < __x);
}
{ return !(__y < __x); }
template<typename _Tp, typename _RefL, typename _PtrL,
typename _RefR, typename _PtrR>
inline bool
operator<=(const _Deque_iterator<_Tp, _RefL, _PtrL>& __x,
const _Deque_iterator<_Tp, _RefR, _PtrR>& __y)
{
return !(__y < __x);
}
{ return !(__y < __x); }
template<typename _Tp, typename _Ref, typename _Ptr>
inline bool
operator>=(const _Deque_iterator<_Tp, _Ref, _Ptr>& __x,
const _Deque_iterator<_Tp, _Ref, _Ptr>& __y)
{
return !(__x < __y);
}
{ return !(__x < __y); }
template<typename _Tp, typename _RefL, typename _PtrL,
typename _RefR, typename _PtrR>
inline bool
operator>=(const _Deque_iterator<_Tp, _RefL, _PtrL>& __x,
const _Deque_iterator<_Tp, _RefR, _PtrR>& __y)
{
return !(__x < __y);
}
{ return !(__x < __y); }
// _GLIBCXX_RESOLVE_LIB_DEFECTS
// According to the resolution of DR179 not only the various comparison
......@@ -320,17 +327,15 @@ namespace __gnu_norm
const _Deque_iterator<_Tp, _RefR, _PtrR>& __y)
{
return typename _Deque_iterator<_Tp, _RefL, _PtrL>::difference_type
(_Deque_iterator<_Tp, _RefL, _PtrL>::_S_buffer_size()) *
(__x._M_node - __y._M_node - 1) + (__x._M_cur - __x._M_first) +
(__y._M_last - __y._M_cur);
(_Deque_iterator<_Tp, _RefL, _PtrL>::_S_buffer_size())
* (__x._M_node - __y._M_node - 1) + (__x._M_cur - __x._M_first)
+ (__y._M_last - __y._M_cur);
}
template<typename _Tp, typename _Ref, typename _Ptr>
inline _Deque_iterator<_Tp, _Ref, _Ptr>
operator+(ptrdiff_t __n, const _Deque_iterator<_Tp, _Ref, _Ptr>& __x)
{
return __x + __n;
}
{ return __x + __n; }
/**
* @if maint
......@@ -350,7 +355,9 @@ namespace __gnu_norm
{
public:
typedef _Alloc allocator_type;
allocator_type get_allocator() const
allocator_type
get_allocator() const
{ return *static_cast<const _Alloc*>(this); }
typedef _Deque_iterator<_Tp,_Tp&,_Tp*> iterator;
......@@ -359,8 +366,10 @@ namespace __gnu_norm
_Deque_base(const allocator_type& __a, size_t __num_elements)
: _Alloc(__a), _M_start(), _M_finish()
{ _M_initialize_map(__num_elements); }
_Deque_base(const allocator_type& __a)
: _Alloc(__a), _M_start(), _M_finish() {}
: _Alloc(__a), _M_start(), _M_finish() { }
~_Deque_base();
protected:
......@@ -370,15 +379,11 @@ namespace __gnu_norm
_Tp*
_M_allocate_node()
{
return _Alloc::allocate(__deque_buf_size(sizeof(_Tp)));
}
{ return _Alloc::allocate(__deque_buf_size(sizeof(_Tp))); }
void
_M_deallocate_node(_Tp* __p)
{
_Alloc::deallocate(__p, __deque_buf_size(sizeof(_Tp)));
}
{ _Alloc::deallocate(__p, __deque_buf_size(sizeof(_Tp))); }
_Tp**
_M_allocate_map(size_t __n)
......@@ -400,7 +405,6 @@ namespace __gnu_norm
iterator _M_finish;
};
template<typename _Tp, typename _Alloc>
_Deque_base<_Tp,_Alloc>::~_Deque_base()
{
......@@ -425,16 +429,16 @@ namespace __gnu_norm
void
_Deque_base<_Tp,_Alloc>::_M_initialize_map(size_t __num_elements)
{
size_t __num_nodes =
__num_elements / __deque_buf_size(sizeof(_Tp)) + 1;
size_t __num_nodes = __num_elements / __deque_buf_size(sizeof(_Tp)) + 1;
this->_M_map_size
= std::max((size_t) _S_initial_map_size, __num_nodes + 2);
this->_M_map_size = std::max((size_t) _S_initial_map_size,
__num_nodes + 2);
this->_M_map = _M_allocate_map(this->_M_map_size);
// For "small" maps (needing less than _M_map_size nodes), allocation
// starts in the middle elements and grows outwards. So nstart may be the
// beginning of _M_map, but for small maps it may be as far in as _M_map+3.
// starts in the middle elements and grows outwards. So nstart may be
// the beginning of _M_map, but for small maps it may be as far in as
// _M_map+3.
_Tp** __nstart = this->_M_map + (this->_M_map_size - __num_nodes) / 2;
_Tp** __nfinish = __nstart + __num_nodes;
......@@ -452,12 +456,13 @@ namespace __gnu_norm
_M_start._M_set_node(__nstart);
_M_finish._M_set_node(__nfinish - 1);
_M_start._M_cur = _M_start._M_first;
_M_finish._M_cur = _M_finish._M_first +
__num_elements % __deque_buf_size(sizeof(_Tp));
_M_finish._M_cur = _M_finish._M_first + __num_elements
% __deque_buf_size(sizeof(_Tp));
}
template<typename _Tp, typename _Alloc>
void _Deque_base<_Tp,_Alloc>::_M_create_nodes(_Tp** __nstart, _Tp** __nfinish)
void
_Deque_base<_Tp,_Alloc>::_M_create_nodes(_Tp** __nstart, _Tp** __nfinish)
{
_Tp** __cur;
try
......@@ -480,7 +485,6 @@ namespace __gnu_norm
_M_deallocate_node(*__n);
}
/**
* @brief A standard container using fixed-size memory allocation and
* constant-time manipulation of elements at either end.
......@@ -589,7 +593,9 @@ namespace __gnu_norm
protected:
typedef pointer* _Map_pointer;
static size_t _S_buffer_size() { return __deque_buf_size(sizeof(_Tp)); }
static size_t _S_buffer_size()
{ return __deque_buf_size(sizeof(_Tp)); }
// Functions controlling memory layout, and nothing else.
using _Base::_M_initialize_map;
......@@ -659,7 +665,8 @@ namespace __gnu_norm
* @param first An input iterator.
* @param last An input iterator.
*
* Create a %deque consisting of copies of the elements from [first,last).
* Create a %deque consisting of copies of the elements from [first,
* last).
*
* If the iterators are forward, bidirectional, or random-access, then
* this will call the elements' copy constructor N times (where N is
......@@ -682,7 +689,8 @@ namespace __gnu_norm
* themselves are pointers, the pointed-to memory is not touched in any
* way. Managing the pointer is the user's responsibilty.
*/
~deque() { std::_Destroy(this->_M_start, this->_M_finish); }
~deque()
{ std::_Destroy(this->_M_start, this->_M_finish); }
/**
* @brief %Deque assignment operator.
......@@ -705,7 +713,8 @@ namespace __gnu_norm
* Old data may be lost.
*/
void
assign(size_type __n, const value_type& __val) { _M_fill_assign(__n, __val); }
assign(size_type __n, const value_type& __val)
{ _M_fill_assign(__n, __val); }
/**
* @brief Assigns a range to a %deque.
......@@ -716,8 +725,8 @@ namespace __gnu_norm
* range [first,last).
*
* Note that the assignment completely changes the %deque and that the
* resulting %deque's size is the same as the number of elements assigned.
* Old data may be lost.
* resulting %deque's size is the same as the number of elements
* assigned. Old data may be lost.
*/
template<typename _InputIterator>
void
......@@ -729,7 +738,8 @@ namespace __gnu_norm
/// Get a copy of the memory allocation object.
allocator_type
get_allocator() const { return _Base::get_allocator(); }
get_allocator() const
{ return _Base::get_allocator(); }
// iterators
/**
......@@ -737,42 +747,49 @@ namespace __gnu_norm
* %deque. Iteration is done in ordinary element order.
*/
iterator
begin() { return this->_M_start; }
begin()
{ return this->_M_start; }
/**
* Returns a read-only (constant) iterator that points to the first element
* in the %deque. Iteration is done in ordinary element order.
* Returns a read-only (constant) iterator that points to the first
* element in the %deque. Iteration is done in ordinary element order.
*/
const_iterator
begin() const { return this->_M_start; }
begin() const
{ return this->_M_start; }
/**
* Returns a read/write iterator that points one past the last element in
* the %deque. Iteration is done in ordinary element order.
*/
iterator
end() { return this->_M_finish; }
end()
{ return this->_M_finish; }
/**
* Returns a read-only (constant) iterator that points one past the last
* element in the %deque. Iteration is done in ordinary element order.
*/
const_iterator
end() const { return this->_M_finish; }
end() const
{ return this->_M_finish; }
/**
* Returns a read/write reverse iterator that points to the last element in
* the %deque. Iteration is done in reverse element order.
* Returns a read/write reverse iterator that points to the last element
* in the %deque. Iteration is done in reverse element order.
*/
reverse_iterator
rbegin() { return reverse_iterator(this->_M_finish); }
rbegin()
{ return reverse_iterator(this->_M_finish); }
/**
* Returns a read-only (constant) reverse iterator that points to the last
* element in the %deque. Iteration is done in reverse element order.
* Returns a read-only (constant) reverse iterator that points to the
* last element in the %deque. Iteration is done in reverse element
* order.
*/
const_reverse_iterator
rbegin() const { return const_reverse_iterator(this->_M_finish); }
rbegin() const
{ return const_reverse_iterator(this->_M_finish); }
/**
* Returns a read/write reverse iterator that points to one before the
......@@ -788,16 +805,19 @@ namespace __gnu_norm
* element order.
*/
const_reverse_iterator
rend() const { return const_reverse_iterator(this->_M_start); }
rend() const
{ return const_reverse_iterator(this->_M_start); }
// [23.2.1.2] capacity
/** Returns the number of elements in the %deque. */
size_type
size() const { return this->_M_finish - this->_M_start; }
size() const
{ return this->_M_finish - this->_M_start; }
/** Returns the size() of the largest possible %deque. */
size_type
max_size() const { return size_type(-1); }
max_size() const
{ return size_type(-1); }
/**
* @brief Resizes the %deque to the specified number of elements.
......@@ -829,12 +849,15 @@ namespace __gnu_norm
* are default-constructed.
*/
void
resize(size_type new_size) { resize(new_size, value_type()); }
resize(size_type new_size)
{ resize(new_size, value_type()); }
/**
* Returns true if the %deque is empty. (Thus begin() would equal end().)
*/
bool empty() const { return this->_M_finish == this->_M_start; }
bool
empty() const
{ return this->_M_finish == this->_M_start; }
// element access
/**
......@@ -847,7 +870,8 @@ namespace __gnu_norm
* lookups are not defined. (For checked lookups see at().)
*/
reference
operator[](size_type __n) { return this->_M_start[difference_type(__n)]; }
operator[](size_type __n)
{ return this->_M_start[difference_type(__n)]; }
/**
* @brief Subscript access to the data contained in the %deque.
......@@ -859,9 +883,8 @@ namespace __gnu_norm
* lookups are not defined. (For checked lookups see at().)
*/
const_reference
operator[](size_type __n) const {
return this->_M_start[difference_type(__n)];
}
operator[](size_type __n) const
{ return this->_M_start[difference_type(__n)]; }
protected:
/// @if maint Safety check used only from at(). @endif
......@@ -884,7 +907,8 @@ namespace __gnu_norm
* out_of_range if the check fails.
*/
reference
at(size_type __n) { _M_range_check(__n); return (*this)[__n]; }
at(size_type __n)
{ _M_range_check(__n); return (*this)[__n]; }
/**
* @brief Provides access to the data contained in the %deque.
......@@ -897,21 +921,27 @@ namespace __gnu_norm
* out_of_range if the check fails.
*/
const_reference
at(size_type __n) const { _M_range_check(__n); return (*this)[__n]; }
at(size_type __n) const
{
_M_range_check(__n);
return (*this)[__n];
}
/**
* Returns a read/write reference to the data at the first element of the
* %deque.
*/
reference
front() { return *this->_M_start; }
front()
{ return *this->_M_start; }
/**
* Returns a read-only (constant) reference to the data at the first
* element of the %deque.
*/
const_reference
front() const { return *this->_M_start; }
front() const
{ return *this->_M_start; }
/**
* Returns a read/write reference to the data at the last element of the
......@@ -949,7 +979,8 @@ namespace __gnu_norm
void
push_front(const value_type& __x)
{
if (this->_M_start._M_cur != this->_M_start._M_first) {
if (this->_M_start._M_cur != this->_M_start._M_first)
{
std::_Construct(this->_M_start._M_cur - 1, __x);
--this->_M_start._M_cur;
}
......@@ -968,7 +999,8 @@ namespace __gnu_norm
void
push_back(const value_type& __x)
{
if (this->_M_finish._M_cur != this->_M_finish._M_last - 1) {
if (this->_M_finish._M_cur != this->_M_finish._M_last - 1)
{
std::_Construct(this->_M_finish._M_cur, __x);
++this->_M_finish._M_cur;
}
......@@ -987,7 +1019,8 @@ namespace __gnu_norm
void
pop_front()
{
if (this->_M_start._M_cur != this->_M_start._M_last - 1) {
if (this->_M_start._M_cur != this->_M_start._M_last - 1)
{
std::_Destroy(this->_M_start._M_cur);
++this->_M_start._M_cur;
}
......@@ -1006,7 +1039,8 @@ namespace __gnu_norm
void
pop_back()
{
if (this->_M_finish._M_cur != this->_M_finish._M_first) {
if (this->_M_finish._M_cur != this->_M_finish._M_first)
{
--this->_M_finish._M_cur;
std::_Destroy(this->_M_finish._M_cur);
}
......@@ -1020,8 +1054,8 @@ namespace __gnu_norm
* @param x Data to be inserted.
* @return An iterator that points to the inserted data.
*
* This function will insert a copy of the given value before the specified
* location.
* This function will insert a copy of the given value before the
* specified location.
*/
iterator
insert(iterator position, const value_type& __x);
......@@ -1032,8 +1066,8 @@ namespace __gnu_norm
* @param n Number of elements to be inserted.
* @param x Data to be inserted.
*
* This function will insert a specified number of copies of the given data
* before the location specified by @a position.
* This function will insert a specified number of copies of the given
* data before the location specified by @a position.
*/
void
insert(iterator __position, size_type __n, const value_type& __x)
......@@ -1051,7 +1085,8 @@ namespace __gnu_norm
*/
template<typename _InputIterator>
void
insert(iterator __position, _InputIterator __first, _InputIterator __last)
insert(iterator __position, _InputIterator __first,
_InputIterator __last)
{
// Check whether it's an integral type. If so, it's not an iterator.
typedef typename _Is_integer<_InputIterator>::_Integral _Integral;
......@@ -1067,9 +1102,9 @@ namespace __gnu_norm
* shorten the %deque by one.
*
* The user is cautioned that
* this function only erases the element, and that if the element is itself
* a pointer, the pointed-to memory is not touched in any way. Managing
* the pointer is the user's responsibilty.
* this function only erases the element, and that if the element is
* itself a pointer, the pointed-to memory is not touched in any way.
* Managing the pointer is the user's responsibilty.
*/
iterator
erase(iterator __position);
......@@ -1183,7 +1218,6 @@ namespace __gnu_norm
void
_M_fill_initialize(const value_type& __value);
// Internal assign functions follow. The *_aux functions do the actual
// assignment work for the range versions.
......@@ -1199,7 +1233,8 @@ namespace __gnu_norm
// called by the range assign to implement [23.1.1]/9
template<typename _InputIterator>
void
_M_assign_dispatch(_InputIterator __first, _InputIterator __last, __false_type)
_M_assign_dispatch(_InputIterator __first, _InputIterator __last,
__false_type)
{
typedef typename iterator_traits<_InputIterator>::iterator_category
_IterCategory;
......@@ -1218,8 +1253,9 @@ namespace __gnu_norm
_M_assign_aux(_ForwardIterator __first, _ForwardIterator __last,
forward_iterator_tag)
{
size_type __len = std::distance(__first, __last);
if (__len > size()) {
const size_type __len = std::distance(__first, __last);
if (__len > size())
{
_ForwardIterator __mid = __first;
std::advance(__mid, size());
std::copy(__first, __mid, begin());
......@@ -1246,7 +1282,6 @@ namespace __gnu_norm
}
}
//@{
/**
* @if maint
......@@ -1259,7 +1294,6 @@ namespace __gnu_norm
void _M_pop_front_aux();
//@}
// Internal insert functions follow. The *_aux functions do the actual
// insertion work when all shortcuts fail.
......@@ -1298,8 +1332,8 @@ namespace __gnu_norm
_ForwardIterator __last, forward_iterator_tag);
// Called by insert(p,n,x), and the range insert when it turns out to be
// the same thing. Can use fill functions in optimal situations, otherwise
// passes off to insert_aux(p,n,x).
// the same thing. Can use fill functions in optimal situations,
// otherwise passes off to insert_aux(p,n,x).
void
_M_fill_insert(iterator __pos, size_type __n, const value_type& __x);
......@@ -1328,7 +1362,8 @@ namespace __gnu_norm
iterator
_M_reserve_elements_at_front(size_type __n)
{
size_type __vacancies = this->_M_start._M_cur - this->_M_start._M_first;
const size_type __vacancies = this->_M_start._M_cur
- this->_M_start._M_first;
if (__n > __vacancies)
_M_new_elements_at_front(__n - __vacancies);
return this->_M_start - difference_type(__n);
......@@ -1337,8 +1372,8 @@ namespace __gnu_norm
iterator
_M_reserve_elements_at_back(size_type __n)
{
size_type __vacancies
= (this->_M_finish._M_last - this->_M_finish._M_cur) - 1;
const size_type __vacancies = (this->_M_finish._M_last
- this->_M_finish._M_cur) - 1;
if (__n > __vacancies)
_M_new_elements_at_back(__n - __vacancies);
return this->_M_finish + difference_type(__n);
......@@ -1365,8 +1400,8 @@ namespace __gnu_norm
void
_M_reserve_map_at_back (size_type __nodes_to_add = 1)
{
if (__nodes_to_add + 1
> this->_M_map_size - (this->_M_finish._M_node - this->_M_map))
if (__nodes_to_add + 1 > this->_M_map_size
- (this->_M_finish._M_node - this->_M_map))
_M_reallocate_map(__nodes_to_add, false);
}
......@@ -1394,12 +1429,11 @@ namespace __gnu_norm
* and if corresponding elements compare equal.
*/
template<typename _Tp, typename _Alloc>
inline bool operator==(const deque<_Tp, _Alloc>& __x,
inline bool
operator==(const deque<_Tp, _Alloc>& __x,
const deque<_Tp, _Alloc>& __y)
{
return __x.size() == __y.size() &&
std::equal(__x.begin(), __x.end(), __y.begin());
}
{ return __x.size() == __y.size()
&& std::equal(__x.begin(), __x.end(), __y.begin()); }
/**
* @brief Deque ordering relation.
......@@ -1413,47 +1447,45 @@ namespace __gnu_norm
* See std::lexicographical_compare() for how the determination is made.
*/
template<typename _Tp, typename _Alloc>
inline bool operator<(const deque<_Tp, _Alloc>& __x,
inline bool
operator<(const deque<_Tp, _Alloc>& __x,
const deque<_Tp, _Alloc>& __y)
{
return lexicographical_compare(__x.begin(), __x.end(),
__y.begin(), __y.end());
}
{ return lexicographical_compare(__x.begin(), __x.end(),
__y.begin(), __y.end()); }
/// Based on operator==
template<typename _Tp, typename _Alloc>
inline bool operator!=(const deque<_Tp, _Alloc>& __x,
const deque<_Tp, _Alloc>& __y) {
return !(__x == __y);
}
inline bool
operator!=(const deque<_Tp, _Alloc>& __x,
const deque<_Tp, _Alloc>& __y)
{ return !(__x == __y); }
/// Based on operator<
template<typename _Tp, typename _Alloc>
inline bool operator>(const deque<_Tp, _Alloc>& __x,
const deque<_Tp, _Alloc>& __y) {
return __y < __x;
}
inline bool
operator>(const deque<_Tp, _Alloc>& __x,
const deque<_Tp, _Alloc>& __y)
{ return __y < __x; }
/// Based on operator<
template<typename _Tp, typename _Alloc>
inline bool operator<=(const deque<_Tp, _Alloc>& __x,
const deque<_Tp, _Alloc>& __y) {
return !(__y < __x);
}
inline bool
operator<=(const deque<_Tp, _Alloc>& __x,
const deque<_Tp, _Alloc>& __y)
{ return !(__y < __x); }
/// Based on operator<
template<typename _Tp, typename _Alloc>
inline bool operator>=(const deque<_Tp, _Alloc>& __x,
const deque<_Tp, _Alloc>& __y) {
return !(__x < __y);
}
inline bool
operator>=(const deque<_Tp, _Alloc>& __x,
const deque<_Tp, _Alloc>& __y)
{ return !(__x < __y); }
/// See std::deque::swap().
template<typename _Tp, typename _Alloc>
inline void swap(deque<_Tp,_Alloc>& __x, deque<_Tp,_Alloc>& __y)
{
__x.swap(__y);
}
inline void
swap(deque<_Tp,_Alloc>& __x, deque<_Tp,_Alloc>& __y)
{ __x.swap(__y); }
} // namespace __gnu_norm
#endif /* _DEQUE_H */
libstdc++-v3/include/bits/stl_function.h
// Functor implementations -*- C++ -*-
// Copyright (C) 2001, 2002 Free Software Foundation, Inc.
// Copyright (C) 2001, 2002, 2004 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
......@@ -63,8 +63,8 @@
namespace std
{
// 20.3.1 base classes
/** @defgroup s20_3_1_base Functor Base Classes
// 20.3.1 base classes
/** @defgroup s20_3_1_base Functor Base Classes
* Function objects, or @e functors, are objects with an @c operator()
* defined and accessible. They can be passed as arguments to algorithm
* templates and used in place of a function pointer. Not only is the
......@@ -94,154 +94,194 @@ namespace std
* functors, you might consider doing the same.
*
* @{
*/
/**
*/
/**
* This is one of the @link s20_3_1_base functor base classes@endlink.
*/
template <class _Arg, class _Result>
struct unary_function {
typedef _Arg argument_type; ///< @c argument_type is the type of the argument (no surprises here)
*/
template <class _Arg, class _Result>
struct unary_function
{
typedef _Arg argument_type; ///< @c argument_type is the type of the
/// argument (no surprises here)
typedef _Result result_type; ///< @c result_type is the return type
};
};
/**
/**
* This is one of the @link s20_3_1_base functor base classes@endlink.
*/
template <class _Arg1, class _Arg2, class _Result>
struct binary_function {
typedef _Arg1 first_argument_type; ///< the type of the first argument (no surprises here)
*/
template <class _Arg1, class _Arg2, class _Result>
struct binary_function
{
typedef _Arg1 first_argument_type; ///< the type of the first argument
/// (no surprises here)
typedef _Arg2 second_argument_type; ///< the type of the second argument
typedef _Result result_type; ///< type of the return type
};
/** @} */
};
/** @} */
// 20.3.2 arithmetic
/** @defgroup s20_3_2_arithmetic Arithmetic Classes
// 20.3.2 arithmetic
/** @defgroup s20_3_2_arithmetic Arithmetic Classes
* Because basic math often needs to be done during an algorithm, the library
* provides functors for those operations. See the documentation for
* @link s20_3_1_base the base classes@endlink for examples of their use.
*
* @{
*/
/// One of the @link s20_3_2_arithmetic math functors@endlink.
template <class _Tp>
struct plus : public binary_function<_Tp,_Tp,_Tp> {
_Tp operator()(const _Tp& __x, const _Tp& __y) const { return __x + __y; }
};
/// One of the @link s20_3_2_arithmetic math functors@endlink.
template <class _Tp>
struct minus : public binary_function<_Tp,_Tp,_Tp> {
_Tp operator()(const _Tp& __x, const _Tp& __y) const { return __x - __y; }
};
/// One of the @link s20_3_2_arithmetic math functors@endlink.
template <class _Tp>
struct multiplies : public binary_function<_Tp,_Tp,_Tp> {
_Tp operator()(const _Tp& __x, const _Tp& __y) const { return __x * __y; }
};
/// One of the @link s20_3_2_arithmetic math functors@endlink.
template <class _Tp>
struct divides : public binary_function<_Tp,_Tp,_Tp> {
_Tp operator()(const _Tp& __x, const _Tp& __y) const { return __x / __y; }
};
/// One of the @link s20_3_2_arithmetic math functors@endlink.
template <class _Tp>
struct modulus : public binary_function<_Tp,_Tp,_Tp>
{
_Tp operator()(const _Tp& __x, const _Tp& __y) const { return __x % __y; }
};
/// One of the @link s20_3_2_arithmetic math functors@endlink.
template <class _Tp>
struct negate : public unary_function<_Tp,_Tp>
{
_Tp operator()(const _Tp& __x) const { return -__x; }
};
/** @} */
// 20.3.3 comparisons
/** @defgroup s20_3_3_comparisons Comparison Classes
*/
/// One of the @link s20_3_2_arithmetic math functors@endlink.
template <class _Tp>
struct plus : public binary_function<_Tp,_Tp,_Tp>
{
_Tp
operator()(const _Tp& __x, const _Tp& __y) const
{ return __x + __y; }
};
/// One of the @link s20_3_2_arithmetic math functors@endlink.
template <class _Tp>
struct minus : public binary_function<_Tp,_Tp,_Tp>
{
_Tp
operator()(const _Tp& __x, const _Tp& __y) const
{ return __x - __y; }
};
/// One of the @link s20_3_2_arithmetic math functors@endlink.
template <class _Tp>
struct multiplies : public binary_function<_Tp,_Tp,_Tp>
{
_Tp
operator()(const _Tp& __x, const _Tp& __y) const
{ return __x * __y; }
};
/// One of the @link s20_3_2_arithmetic math functors@endlink.
template <class _Tp>
struct divides : public binary_function<_Tp,_Tp,_Tp>
{
_Tp
operator()(const _Tp& __x, const _Tp& __y) const
{ return __x / __y; }
};
/// One of the @link s20_3_2_arithmetic math functors@endlink.
template <class _Tp>
struct modulus : public binary_function<_Tp,_Tp,_Tp>
{
_Tp
operator()(const _Tp& __x, const _Tp& __y) const
{ return __x % __y; }
};
/// One of the @link s20_3_2_arithmetic math functors@endlink.
template <class _Tp>
struct negate : public unary_function<_Tp,_Tp>
{
_Tp
operator()(const _Tp& __x) const
{ return -__x; }
};
/** @} */
// 20.3.3 comparisons
/** @defgroup s20_3_3_comparisons Comparison Classes
* The library provides six wrapper functors for all the basic comparisons
* in C++, like @c <.
*
* @{
*/
/// One of the @link s20_3_3_comparisons comparison functors@endlink.
template <class _Tp>
struct equal_to : public binary_function<_Tp,_Tp,bool>
{
bool operator()(const _Tp& __x, const _Tp& __y) const { return __x == __y; }
};
/// One of the @link s20_3_3_comparisons comparison functors@endlink.
template <class _Tp>
struct not_equal_to : public binary_function<_Tp,_Tp,bool>
{
bool operator()(const _Tp& __x, const _Tp& __y) const { return __x != __y; }
};
/// One of the @link s20_3_3_comparisons comparison functors@endlink.
template <class _Tp>
struct greater : public binary_function<_Tp,_Tp,bool>
{
bool operator()(const _Tp& __x, const _Tp& __y) const { return __x > __y; }
};
/// One of the @link s20_3_3_comparisons comparison functors@endlink.
template <class _Tp>
struct less : public binary_function<_Tp,_Tp,bool>
{
bool operator()(const _Tp& __x, const _Tp& __y) const { return __x < __y; }
};
/// One of the @link s20_3_3_comparisons comparison functors@endlink.
template <class _Tp>
struct greater_equal : public binary_function<_Tp,_Tp,bool>
{
bool operator()(const _Tp& __x, const _Tp& __y) const { return __x >= __y; }
};
/// One of the @link s20_3_3_comparisons comparison functors@endlink.
template <class _Tp>
struct less_equal : public binary_function<_Tp,_Tp,bool>
{
bool operator()(const _Tp& __x, const _Tp& __y) const { return __x <= __y; }
};
/** @} */
// 20.3.4 logical operations
/** @defgroup s20_3_4_logical Boolean Operations Classes
*/
/// One of the @link s20_3_3_comparisons comparison functors@endlink.
template <class _Tp>
struct equal_to : public binary_function<_Tp,_Tp,bool>
{
bool
operator()(const _Tp& __x, const _Tp& __y) const
{ return __x == __y; }
};
/// One of the @link s20_3_3_comparisons comparison functors@endlink.
template <class _Tp>
struct not_equal_to : public binary_function<_Tp,_Tp,bool>
{
bool
operator()(const _Tp& __x, const _Tp& __y) const
{ return __x != __y; }
};
/// One of the @link s20_3_3_comparisons comparison functors@endlink.
template <class _Tp>
struct greater : public binary_function<_Tp,_Tp,bool>
{
bool
operator()(const _Tp& __x, const _Tp& __y) const
{ return __x > __y; }
};
/// One of the @link s20_3_3_comparisons comparison functors@endlink.
template <class _Tp>
struct less : public binary_function<_Tp,_Tp,bool>
{
bool
operator()(const _Tp& __x, const _Tp& __y) const
{ return __x < __y; }
};
/// One of the @link s20_3_3_comparisons comparison functors@endlink.
template <class _Tp>
struct greater_equal : public binary_function<_Tp,_Tp,bool>
{
bool
operator()(const _Tp& __x, const _Tp& __y) const
{ return __x >= __y; }
};
/// One of the @link s20_3_3_comparisons comparison functors@endlink.
template <class _Tp>
struct less_equal : public binary_function<_Tp,_Tp,bool>
{
bool
operator()(const _Tp& __x, const _Tp& __y) const
{ return __x <= __y; }
};
/** @} */
// 20.3.4 logical operations
/** @defgroup s20_3_4_logical Boolean Operations Classes
* Here are wrapper functors for Boolean operations: @c &&, @c ||, and @c !.
*
* @{
*/
/// One of the @link s20_3_4_logical Boolean operations functors@endlink.
template <class _Tp>
struct logical_and : public binary_function<_Tp,_Tp,bool>
{
bool operator()(const _Tp& __x, const _Tp& __y) const { return __x && __y; }
};
/// One of the @link s20_3_4_logical Boolean operations functors@endlink.
template <class _Tp>
struct logical_or : public binary_function<_Tp,_Tp,bool>
{
bool operator()(const _Tp& __x, const _Tp& __y) const { return __x || __y; }
};
/// One of the @link s20_3_4_logical Boolean operations functors@endlink.
template <class _Tp>
struct logical_not : public unary_function<_Tp,bool>
{
bool operator()(const _Tp& __x) const { return !__x; }
};
/** @} */
// 20.3.5 negators
/** @defgroup s20_3_5_negators Negators
*/
/// One of the @link s20_3_4_logical Boolean operations functors@endlink.
template <class _Tp>
struct logical_and : public binary_function<_Tp,_Tp,bool>
{
bool
operator()(const _Tp& __x, const _Tp& __y) const
{ return __x && __y; }
};
/// One of the @link s20_3_4_logical Boolean operations functors@endlink.
template <class _Tp>
struct logical_or : public binary_function<_Tp,_Tp,bool>
{
bool
operator()(const _Tp& __x, const _Tp& __y) const
{ return __x || __y; }
};
/// One of the @link s20_3_4_logical Boolean operations functors@endlink.
template <class _Tp>
struct logical_not : public unary_function<_Tp,bool>
{
bool
operator()(const _Tp& __x) const
{ return !__x; }
};
/** @} */
// 20.3.5 negators
/** @defgroup s20_3_5_negators Negators
* The functions @c not1 and @c not2 each take a predicate functor
* and return an instance of @c unary_negate or
* @c binary_negate, respectively. These classes are functors whose
......@@ -266,61 +306,61 @@ struct logical_not : public unary_function<_Tp,bool>
* take two arguments.
*
* @{
*/
/// One of the @link s20_3_5_negators negation functors@endlink.
template <class _Predicate>
class unary_negate
: public unary_function<typename _Predicate::argument_type, bool> {
protected:
*/
/// One of the @link s20_3_5_negators negation functors@endlink.
template <class _Predicate>
class unary_negate
: public unary_function<typename _Predicate::argument_type, bool>
{
protected:
_Predicate _M_pred;
public:
public:
explicit unary_negate(const _Predicate& __x) : _M_pred(__x) {}
bool operator()(const typename _Predicate::argument_type& __x) const {
return !_M_pred(__x);
}
};
/// One of the @link s20_3_5_negators negation functors@endlink.
template <class _Predicate>
inline unary_negate<_Predicate>
not1(const _Predicate& __pred)
{
return unary_negate<_Predicate>(__pred);
}
bool
operator()(const typename _Predicate::argument_type& __x) const
{ return !_M_pred(__x); }
};
/// One of the @link s20_3_5_negators negation functors@endlink.
template <class _Predicate>
class binary_negate
/// One of the @link s20_3_5_negators negation functors@endlink.
template <class _Predicate>
inline unary_negate<_Predicate>
not1(const _Predicate& __pred)
{ return unary_negate<_Predicate>(__pred); }
/// One of the @link s20_3_5_negators negation functors@endlink.
template <class _Predicate>
class binary_negate
: public binary_function<typename _Predicate::first_argument_type,
typename _Predicate::second_argument_type,
bool> {
protected:
_Predicate _M_pred;
public:
explicit binary_negate(const _Predicate& __x) : _M_pred(__x) {}
bool operator()(const typename _Predicate::first_argument_type& __x,
const typename _Predicate::second_argument_type& __y) const
bool>
{
return !_M_pred(__x, __y);
}
};
/// One of the @link s20_3_5_negators negation functors@endlink.
template <class _Predicate>
inline binary_negate<_Predicate>
not2(const _Predicate& __pred)
{
return binary_negate<_Predicate>(__pred);
}
/** @} */
protected:
_Predicate _M_pred;
public:
explicit binary_negate(const _Predicate& __x)
: _M_pred(__x) { }
// 20.3.6 binders
/** @defgroup s20_3_6_binder Binder Classes
bool
operator()(const typename _Predicate::first_argument_type& __x,
const typename _Predicate::second_argument_type& __y) const
{ return !_M_pred(__x, __y); }
};
/// One of the @link s20_3_5_negators negation functors@endlink.
template <class _Predicate>
inline binary_negate<_Predicate>
not2(const _Predicate& __pred)
{ return binary_negate<_Predicate>(__pred); }
/** @} */
// 20.3.6 binders
/** @defgroup s20_3_6_binder Binder Classes
* Binders turn functions/functors with two arguments into functors with
* a single argument, storing an argument to be applied later. For
* example, an variable @c B of type @c binder1st is constructed from a functor
* @c f and an argument @c x. Later, B's @c operator() is called with a
* single argument @c y. The return value is the value of @c f(x,y).
* example, an variable @c B of type @c binder1st is constructed from a
* functor @c f and an argument @c x. Later, B's @c operator() is called
* with a single argument @c y. The return value is the value of @c f(x,y).
* @c B can be "called" with various arguments (y1, y2, ...) and will in
* turn call @c f(x,y1), @c f(x,y2), ...
*
......@@ -344,76 +384,78 @@ not2(const _Predicate& __pred)
* These become more useful when combined with the composition functions.
*
* @{
*/
/// One of the @link s20_3_6_binder binder functors@endlink.
template <class _Operation>
class binder1st
*/
/// One of the @link s20_3_6_binder binder functors@endlink.
template <class _Operation>
class binder1st
: public unary_function<typename _Operation::second_argument_type,
typename _Operation::result_type> {
protected:
typename _Operation::result_type>
{
protected:
_Operation op;
typename _Operation::first_argument_type value;
public:
public:
binder1st(const _Operation& __x,
const typename _Operation::first_argument_type& __y)
: op(__x), value(__y) {}
typename _Operation::result_type
operator()(const typename _Operation::second_argument_type& __x) const {
return op(value, __x);
}
operator()(const typename _Operation::second_argument_type& __x) const
{ return op(value, __x); }
// _GLIBCXX_RESOLVE_LIB_DEFECTS
// 109. Missing binders for non-const sequence elements
typename _Operation::result_type
operator()(typename _Operation::second_argument_type& __x) const {
return op(value, __x);
}
};
/// One of the @link s20_3_6_binder binder functors@endlink.
template <class _Operation, class _Tp>
inline binder1st<_Operation>
bind1st(const _Operation& __fn, const _Tp& __x)
{
operator()(typename _Operation::second_argument_type& __x) const
{ return op(value, __x); }
};
/// One of the @link s20_3_6_binder binder functors@endlink.
template <class _Operation, class _Tp>
inline binder1st<_Operation>
bind1st(const _Operation& __fn, const _Tp& __x)
{
typedef typename _Operation::first_argument_type _Arg1_type;
return binder1st<_Operation>(__fn, _Arg1_type(__x));
}
}
/// One of the @link s20_3_6_binder binder functors@endlink.
template <class _Operation>
class binder2nd
/// One of the @link s20_3_6_binder binder functors@endlink.
template <class _Operation>
class binder2nd
: public unary_function<typename _Operation::first_argument_type,
typename _Operation::result_type> {
protected:
typename _Operation::result_type>
{
protected:
_Operation op;
typename _Operation::second_argument_type value;
public:
public:
binder2nd(const _Operation& __x,
const typename _Operation::second_argument_type& __y)
: op(__x), value(__y) {}
typename _Operation::result_type
operator()(const typename _Operation::first_argument_type& __x) const {
return op(__x, value);
}
operator()(const typename _Operation::first_argument_type& __x) const
{ return op(__x, value); }
// _GLIBCXX_RESOLVE_LIB_DEFECTS
// 109. Missing binders for non-const sequence elements
typename _Operation::result_type
operator()(typename _Operation::first_argument_type& __x) const {
return op(__x, value);
}
};
/// One of the @link s20_3_6_binder binder functors@endlink.
template <class _Operation, class _Tp>
inline binder2nd<_Operation>
bind2nd(const _Operation& __fn, const _Tp& __x)
{
operator()(typename _Operation::first_argument_type& __x) const
{ return op(__x, value); }
};
/// One of the @link s20_3_6_binder binder functors@endlink.
template <class _Operation, class _Tp>
inline binder2nd<_Operation>
bind2nd(const _Operation& __fn, const _Tp& __x)
{
typedef typename _Operation::second_argument_type _Arg2_type;
return binder2nd<_Operation>(__fn, _Arg2_type(__x));
}
/** @} */
}
/** @} */
// 20.3.7 adaptors pointers functions
/** @defgroup s20_3_7_adaptors Adaptors for pointers to functions
// 20.3.7 adaptors pointers functions
/** @defgroup s20_3_7_adaptors Adaptors for pointers to functions
* The advantage of function objects over pointers to functions is that
* the objects in the standard library declare nested typedefs describing
* their argument and result types with uniform names (e.g., @c result_type
......@@ -421,87 +463,105 @@ bind2nd(const _Operation& __fn, const _Tp& __x)
* Sometimes those typedefs are required, not just optional.
*
* Adaptors are provided to turn pointers to unary (single-argument) and
* binary (double-argument) functions into function objects. The long-winded
* functor @c pointer_to_unary_function is constructed with a function
* pointer @c f, and its @c operator() called with argument @c x returns
* @c f(x). The functor @c pointer_to_binary_function does the same thing,
* but with a double-argument @c f and @c operator().
* binary (double-argument) functions into function objects. The
* long-winded functor @c pointer_to_unary_function is constructed with a
* function pointer @c f, and its @c operator() called with argument @c x
* returns @c f(x). The functor @c pointer_to_binary_function does the same
* thing, but with a double-argument @c f and @c operator().
*
* The function @c ptr_fun takes a pointer-to-function @c f and constructs
* an instance of the appropriate functor.
*
* @{
*/
/// One of the @link s20_3_7_adaptors adaptors for function pointers@endlink.
template <class _Arg, class _Result>
class pointer_to_unary_function : public unary_function<_Arg, _Result> {
protected:
*/
/// One of the @link s20_3_7_adaptors adaptors for function pointers@endlink.
template <class _Arg, class _Result>
class pointer_to_unary_function : public unary_function<_Arg, _Result>
{
protected:
_Result (*_M_ptr)(_Arg);
public:
public:
pointer_to_unary_function() {}
explicit pointer_to_unary_function(_Result (*__x)(_Arg)) : _M_ptr(__x) {}
_Result operator()(_Arg __x) const { return _M_ptr(__x); }
};
/// One of the @link s20_3_7_adaptors adaptors for function pointers@endlink.
template <class _Arg, class _Result>
inline pointer_to_unary_function<_Arg, _Result> ptr_fun(_Result (*__x)(_Arg))
{
return pointer_to_unary_function<_Arg, _Result>(__x);
}
/// One of the @link s20_3_7_adaptors adaptors for function pointers@endlink.
template <class _Arg1, class _Arg2, class _Result>
class pointer_to_binary_function :
public binary_function<_Arg1,_Arg2,_Result> {
protected:
explicit pointer_to_unary_function(_Result (*__x)(_Arg))
: _M_ptr(__x) {}
_Result
operator()(_Arg __x) const
{ return _M_ptr(__x); }
};
/// One of the @link s20_3_7_adaptors adaptors for function pointers@endlink.
template <class _Arg, class _Result>
inline pointer_to_unary_function<_Arg, _Result>
ptr_fun(_Result (*__x)(_Arg))
{ return pointer_to_unary_function<_Arg, _Result>(__x); }
/// One of the @link s20_3_7_adaptors adaptors for function pointers@endlink.
template <class _Arg1, class _Arg2, class _Result>
class pointer_to_binary_function
: public binary_function<_Arg1, _Arg2, _Result>
{
protected:
_Result (*_M_ptr)(_Arg1, _Arg2);
public:
public:
pointer_to_binary_function() {}
explicit pointer_to_binary_function(_Result (*__x)(_Arg1, _Arg2))
: _M_ptr(__x) {}
_Result operator()(_Arg1 __x, _Arg2 __y) const {
return _M_ptr(__x, __y);
}
};
/// One of the @link s20_3_7_adaptors adaptors for function pointers@endlink.
template <class _Arg1, class _Arg2, class _Result>
inline pointer_to_binary_function<_Arg1,_Arg2,_Result>
ptr_fun(_Result (*__x)(_Arg1, _Arg2)) {
return pointer_to_binary_function<_Arg1,_Arg2,_Result>(__x);
}
/** @} */
template <class _Tp>
struct _Identity : public unary_function<_Tp,_Tp> {
_Tp& operator()(_Tp& __x) const { return __x; }
const _Tp& operator()(const _Tp& __x) const { return __x; }
};
template <class _Pair>
struct _Select1st : public unary_function<_Pair, typename _Pair::first_type> {
typename _Pair::first_type& operator()(_Pair& __x) const {
return __x.first;
}
const typename _Pair::first_type& operator()(const _Pair& __x) const {
return __x.first;
}
};
template <class _Pair>
struct _Select2nd : public unary_function<_Pair, typename _Pair::second_type>
{
typename _Pair::second_type& operator()(_Pair& __x) const {
return __x.second;
}
const typename _Pair::second_type& operator()(const _Pair& __x) const {
return __x.second;
}
};
_Result
operator()(_Arg1 __x, _Arg2 __y) const
{ return _M_ptr(__x, __y); }
};
// 20.3.8 adaptors pointers members
/** @defgroup s20_3_8_memadaptors Adaptors for pointers to members
/// One of the @link s20_3_7_adaptors adaptors for function pointers@endlink.
template <class _Arg1, class _Arg2, class _Result>
inline pointer_to_binary_function<_Arg1, _Arg2, _Result>
ptr_fun(_Result (*__x)(_Arg1, _Arg2))
{ return pointer_to_binary_function<_Arg1, _Arg2, _Result>(__x); }
/** @} */
template <class _Tp>
struct _Identity : public unary_function<_Tp,_Tp>
{
_Tp&
operator()(_Tp& __x) const
{ return __x; }
const _Tp&
operator()(const _Tp& __x) const
{ return __x; }
};
template <class _Pair>
struct _Select1st : public unary_function<_Pair,
typename _Pair::first_type>
{
typename _Pair::first_type&
operator()(_Pair& __x) const
{ return __x.first; }
const typename _Pair::first_type&
operator()(const _Pair& __x) const
{ return __x.first; }
};
template <class _Pair>
struct _Select2nd : public unary_function<_Pair,
typename _Pair::second_type>
{
typename _Pair::second_type&
operator()(_Pair& __x) const
{ return __x.second; }
const typename _Pair::second_type&
operator()(const _Pair& __x) const
{ return __x.second; }
};
// 20.3.8 adaptors pointers members
/** @defgroup s20_3_8_memadaptors Adaptors for pointers to members
* There are a total of 16 = 2^4 function objects in this family.
* (1) Member functions taking no arguments vs member functions taking
* one argument.
......@@ -521,209 +581,293 @@ struct _Select2nd : public unary_function<_Pair, typename _Pair::second_type>
* which create whichever type of adaptor is appropriate.
*
* @{
*/
/// One of the @link s20_3_8_memadaptors adaptors for member pointers@endlink.
template <class _Ret, class _Tp>
class mem_fun_t : public unary_function<_Tp*,_Ret> {
public:
explicit mem_fun_t(_Ret (_Tp::*__pf)()) : _M_f(__pf) {}
_Ret operator()(_Tp* __p) const { return (__p->*_M_f)(); }
private:
*/
/// One of the @link s20_3_8_memadaptors adaptors for member pointers@endlink.
template <class _Ret, class _Tp>
class mem_fun_t : public unary_function<_Tp*, _Ret>
{
public:
explicit mem_fun_t(_Ret (_Tp::*__pf)())
: _M_f(__pf) {}
_Ret
operator()(_Tp* __p) const
{ return (__p->*_M_f)(); }
private:
_Ret (_Tp::*_M_f)();
};
/// One of the @link s20_3_8_memadaptors adaptors for member pointers@endlink.
template <class _Ret, class _Tp>
class const_mem_fun_t : public unary_function<const _Tp*,_Ret> {
public:
explicit const_mem_fun_t(_Ret (_Tp::*__pf)() const) : _M_f(__pf) {}
_Ret operator()(const _Tp* __p) const { return (__p->*_M_f)(); }
private:
};
/// One of the @link s20_3_8_memadaptors adaptors for member pointers@endlink.
template <class _Ret, class _Tp>
class const_mem_fun_t : public unary_function<const _Tp*, _Ret>
{
public:
explicit const_mem_fun_t(_Ret (_Tp::*__pf)() const)
: _M_f(__pf) {}
_Ret
operator()(const _Tp* __p) const
{ return (__p->*_M_f)(); }
private:
_Ret (_Tp::*_M_f)() const;
};
/// One of the @link s20_3_8_memadaptors adaptors for member pointers@endlink.
template <class _Ret, class _Tp>
class mem_fun_ref_t : public unary_function<_Tp,_Ret> {
public:
explicit mem_fun_ref_t(_Ret (_Tp::*__pf)()) : _M_f(__pf) {}
_Ret operator()(_Tp& __r) const { return (__r.*_M_f)(); }
private:
};
/// One of the @link s20_3_8_memadaptors adaptors for member pointers@endlink.
template <class _Ret, class _Tp>
class mem_fun_ref_t : public unary_function<_Tp, _Ret>
{
public:
explicit mem_fun_ref_t(_Ret (_Tp::*__pf)())
: _M_f(__pf) {}
_Ret
operator()(_Tp& __r) const
{ return (__r.*_M_f)(); }
private:
_Ret (_Tp::*_M_f)();
};
/// One of the @link s20_3_8_memadaptors adaptors for member pointers@endlink.
template <class _Ret, class _Tp>
class const_mem_fun_ref_t : public unary_function<_Tp,_Ret> {
public:
explicit const_mem_fun_ref_t(_Ret (_Tp::*__pf)() const) : _M_f(__pf) {}
_Ret operator()(const _Tp& __r) const { return (__r.*_M_f)(); }
private:
};
/// One of the @link s20_3_8_memadaptors adaptors for member pointers@endlink.
template <class _Ret, class _Tp>
class const_mem_fun_ref_t : public unary_function<_Tp, _Ret>
{
public:
explicit const_mem_fun_ref_t(_Ret (_Tp::*__pf)() const)
: _M_f(__pf) {}
_Ret
operator()(const _Tp& __r) const
{ return (__r.*_M_f)(); }
private:
_Ret (_Tp::*_M_f)() const;
};
/// One of the @link s20_3_8_memadaptors adaptors for member pointers@endlink.
template <class _Ret, class _Tp, class _Arg>
class mem_fun1_t : public binary_function<_Tp*,_Arg,_Ret> {
public:
explicit mem_fun1_t(_Ret (_Tp::*__pf)(_Arg)) : _M_f(__pf) {}
_Ret operator()(_Tp* __p, _Arg __x) const { return (__p->*_M_f)(__x); }
private:
};
/// One of the @link s20_3_8_memadaptors adaptors for member pointers@endlink.
template <class _Ret, class _Tp, class _Arg>
class mem_fun1_t : public binary_function<_Tp*, _Arg, _Ret>
{
public:
explicit mem_fun1_t(_Ret (_Tp::*__pf)(_Arg))
: _M_f(__pf) {}
_Ret
operator()(_Tp* __p, _Arg __x) const
{ return (__p->*_M_f)(__x); }
private:
_Ret (_Tp::*_M_f)(_Arg);
};
/// One of the @link s20_3_8_memadaptors adaptors for member pointers@endlink.
template <class _Ret, class _Tp, class _Arg>
class const_mem_fun1_t : public binary_function<const _Tp*,_Arg,_Ret> {
public:
explicit const_mem_fun1_t(_Ret (_Tp::*__pf)(_Arg) const) : _M_f(__pf) {}
_Ret operator()(const _Tp* __p, _Arg __x) const
};
/// One of the @link s20_3_8_memadaptors adaptors for member pointers@endlink.
template <class _Ret, class _Tp, class _Arg>
class const_mem_fun1_t : public binary_function<const _Tp*, _Arg, _Ret>
{
public:
explicit const_mem_fun1_t(_Ret (_Tp::*__pf)(_Arg) const)
: _M_f(__pf) {}
_Ret
operator()(const _Tp* __p, _Arg __x) const
{ return (__p->*_M_f)(__x); }
private:
private:
_Ret (_Tp::*_M_f)(_Arg) const;
};
/// One of the @link s20_3_8_memadaptors adaptors for member pointers@endlink.
template <class _Ret, class _Tp, class _Arg>
class mem_fun1_ref_t : public binary_function<_Tp,_Arg,_Ret> {
public:
explicit mem_fun1_ref_t(_Ret (_Tp::*__pf)(_Arg)) : _M_f(__pf) {}
_Ret operator()(_Tp& __r, _Arg __x) const { return (__r.*_M_f)(__x); }
private:
};
/// One of the @link s20_3_8_memadaptors adaptors for member pointers@endlink.
template <class _Ret, class _Tp, class _Arg>
class mem_fun1_ref_t : public binary_function<_Tp, _Arg, _Ret>
{
public:
explicit mem_fun1_ref_t(_Ret (_Tp::*__pf)(_Arg))
: _M_f(__pf) {}
_Ret
operator()(_Tp& __r, _Arg __x) const
{ return (__r.*_M_f)(__x); }
private:
_Ret (_Tp::*_M_f)(_Arg);
};
/// One of the @link s20_3_8_memadaptors adaptors for member pointers@endlink.
template <class _Ret, class _Tp, class _Arg>
class const_mem_fun1_ref_t : public binary_function<_Tp,_Arg,_Ret> {
public:
explicit const_mem_fun1_ref_t(_Ret (_Tp::*__pf)(_Arg) const) : _M_f(__pf) {}
_Ret operator()(const _Tp& __r, _Arg __x) const { return (__r.*_M_f)(__x); }
private:
};
/// One of the @link s20_3_8_memadaptors adaptors for member pointers@endlink.
template <class _Ret, class _Tp, class _Arg>
class const_mem_fun1_ref_t : public binary_function<_Tp, _Arg, _Ret>
{
public:
explicit const_mem_fun1_ref_t(_Ret (_Tp::*__pf)(_Arg) const)
: _M_f(__pf) {}
_Ret
operator()(const _Tp& __r, _Arg __x) const
{ return (__r.*_M_f)(__x); }
private:
_Ret (_Tp::*_M_f)(_Arg) const;
};
/// One of the @link s20_3_8_memadaptors adaptors for member pointers@endlink.
template <class _Tp>
class mem_fun_t<void, _Tp> : public unary_function<_Tp*,void> {
public:
explicit mem_fun_t(void (_Tp::*__pf)()) : _M_f(__pf) {}
void operator()(_Tp* __p) const { (__p->*_M_f)(); }
private:
};
/// One of the @link s20_3_8_memadaptors adaptors for member pointers@endlink.
template <class _Tp>
class mem_fun_t<void, _Tp> : public unary_function<_Tp*, void>
{
public:
explicit mem_fun_t(void (_Tp::*__pf)())
: _M_f(__pf) {}
void
operator()(_Tp* __p) const
{ (__p->*_M_f)(); }
private:
void (_Tp::*_M_f)();
};
/// One of the @link s20_3_8_memadaptors adaptors for member pointers@endlink.
template <class _Tp>
class const_mem_fun_t<void, _Tp> : public unary_function<const _Tp*,void> {
public:
explicit const_mem_fun_t(void (_Tp::*__pf)() const) : _M_f(__pf) {}
void operator()(const _Tp* __p) const { (__p->*_M_f)(); }
private:
};
/// One of the @link s20_3_8_memadaptors adaptors for member pointers@endlink.
template <class _Tp>
class const_mem_fun_t<void, _Tp> : public unary_function<const _Tp*, void>
{
public:
explicit const_mem_fun_t(void (_Tp::*__pf)() const)
: _M_f(__pf) {}
void
operator()(const _Tp* __p) const
{ (__p->*_M_f)(); }
private:
void (_Tp::*_M_f)() const;
};
/// One of the @link s20_3_8_memadaptors adaptors for member pointers@endlink.
template <class _Tp>
class mem_fun_ref_t<void, _Tp> : public unary_function<_Tp,void> {
public:
explicit mem_fun_ref_t(void (_Tp::*__pf)()) : _M_f(__pf) {}
void operator()(_Tp& __r) const { (__r.*_M_f)(); }
private:
};
/// One of the @link s20_3_8_memadaptors adaptors for member pointers@endlink.
template <class _Tp>
class mem_fun_ref_t<void, _Tp> : public unary_function<_Tp, void>
{
public:
explicit mem_fun_ref_t(void (_Tp::*__pf)())
: _M_f(__pf) {}
void
operator()(_Tp& __r) const
{ (__r.*_M_f)(); }
private:
void (_Tp::*_M_f)();
};
/// One of the @link s20_3_8_memadaptors adaptors for member pointers@endlink.
template <class _Tp>
class const_mem_fun_ref_t<void, _Tp> : public unary_function<_Tp,void> {
public:
explicit const_mem_fun_ref_t(void (_Tp::*__pf)() const) : _M_f(__pf) {}
void operator()(const _Tp& __r) const { (__r.*_M_f)(); }
private:
};
/// One of the @link s20_3_8_memadaptors adaptors for member pointers@endlink.
template <class _Tp>
class const_mem_fun_ref_t<void, _Tp> : public unary_function<_Tp, void>
{
public:
explicit const_mem_fun_ref_t(void (_Tp::*__pf)() const)
: _M_f(__pf) {}
void
operator()(const _Tp& __r)
const { (__r.*_M_f)(); }
private:
void (_Tp::*_M_f)() const;
};
/// One of the @link s20_3_8_memadaptors adaptors for member pointers@endlink.
template <class _Tp, class _Arg>
class mem_fun1_t<void, _Tp, _Arg> : public binary_function<_Tp*,_Arg,void> {
public:
explicit mem_fun1_t(void (_Tp::*__pf)(_Arg)) : _M_f(__pf) {}
void operator()(_Tp* __p, _Arg __x) const { (__p->*_M_f)(__x); }
private:
void (_Tp::*_M_f)(_Arg);
};
/// One of the @link s20_3_8_memadaptors adaptors for member pointers@endlink.
template <class _Tp, class _Arg>
class const_mem_fun1_t<void, _Tp, _Arg>
: public binary_function<const _Tp*,_Arg,void> {
public:
explicit const_mem_fun1_t(void (_Tp::*__pf)(_Arg) const) : _M_f(__pf) {}
void operator()(const _Tp* __p, _Arg __x) const { (__p->*_M_f)(__x); }
private:
void (_Tp::*_M_f)(_Arg) const;
};
/// One of the @link s20_3_8_memadaptors adaptors for member pointers@endlink.
template <class _Tp, class _Arg>
class mem_fun1_ref_t<void, _Tp, _Arg>
: public binary_function<_Tp,_Arg,void> {
public:
explicit mem_fun1_ref_t(void (_Tp::*__pf)(_Arg)) : _M_f(__pf) {}
void operator()(_Tp& __r, _Arg __x) const { (__r.*_M_f)(__x); }
private:
};
/// One of the @link s20_3_8_memadaptors adaptors for member pointers@endlink.
template <class _Tp, class _Arg>
class mem_fun1_t<void, _Tp, _Arg> : public binary_function<_Tp*, _Arg, void>
{
public:
explicit mem_fun1_t(void (_Tp::*__pf)(_Arg))
: _M_f(__pf) {}
void
operator()(_Tp* __p, _Arg __x) const
{ (__p->*_M_f)(__x); }
private:
void (_Tp::*_M_f)(_Arg);
};
/// One of the @link s20_3_8_memadaptors adaptors for member pointers@endlink.
template <class _Tp, class _Arg>
class const_mem_fun1_ref_t<void, _Tp, _Arg>
: public binary_function<_Tp,_Arg,void> {
public:
explicit const_mem_fun1_ref_t(void (_Tp::*__pf)(_Arg) const) : _M_f(__pf) {}
void operator()(const _Tp& __r, _Arg __x) const { (__r.*_M_f)(__x); }
private:
};
/// One of the @link s20_3_8_memadaptors adaptors for member pointers@endlink.
template <class _Tp, class _Arg>
class const_mem_fun1_t<void, _Tp, _Arg>
: public binary_function<const _Tp*, _Arg, void>
{
public:
explicit const_mem_fun1_t(void (_Tp::*__pf)(_Arg) const)
: _M_f(__pf) {}
void
operator()(const _Tp* __p, _Arg __x) const
{ (__p->*_M_f)(__x); }
private:
void (_Tp::*_M_f)(_Arg) const;
};
};
/// One of the @link s20_3_8_memadaptors adaptors for member pointers@endlink.
template <class _Tp, class _Arg>
class mem_fun1_ref_t<void, _Tp, _Arg>
: public binary_function<_Tp, _Arg, void>
{
public:
explicit mem_fun1_ref_t(void (_Tp::*__pf)(_Arg))
: _M_f(__pf) {}
void
operator()(_Tp& __r, _Arg __x) const
{ (__r.*_M_f)(__x); }
private:
void (_Tp::*_M_f)(_Arg);
};
// Mem_fun adaptor helper functions. There are only two:
// mem_fun and mem_fun_ref.
/// One of the @link s20_3_8_memadaptors adaptors for member pointers@endlink.
template <class _Tp, class _Arg>
class const_mem_fun1_ref_t<void, _Tp, _Arg>
: public binary_function<_Tp, _Arg, void>
{
public:
explicit const_mem_fun1_ref_t(void (_Tp::*__pf)(_Arg) const)
: _M_f(__pf) {}
void
operator()(const _Tp& __r, _Arg __x) const
{ (__r.*_M_f)(__x); }
private:
void (_Tp::*_M_f)(_Arg) const;
};
template <class _Ret, class _Tp>
inline mem_fun_t<_Ret,_Tp> mem_fun(_Ret (_Tp::*__f)())
// Mem_fun adaptor helper functions. There are only two:
// mem_fun and mem_fun_ref.
template <class _Ret, class _Tp>
inline mem_fun_t<_Ret,_Tp>
mem_fun(_Ret (_Tp::*__f)())
{ return mem_fun_t<_Ret,_Tp>(__f); }
template <class _Ret, class _Tp>
inline const_mem_fun_t<_Ret,_Tp> mem_fun(_Ret (_Tp::*__f)() const)
template <class _Ret, class _Tp>
inline const_mem_fun_t<_Ret,_Tp>
mem_fun(_Ret (_Tp::*__f)() const)
{ return const_mem_fun_t<_Ret,_Tp>(__f); }
template <class _Ret, class _Tp>
inline mem_fun_ref_t<_Ret,_Tp> mem_fun_ref(_Ret (_Tp::*__f)())
template <class _Ret, class _Tp>
inline mem_fun_ref_t<_Ret,_Tp>
mem_fun_ref(_Ret (_Tp::*__f)())
{ return mem_fun_ref_t<_Ret,_Tp>(__f); }
template <class _Ret, class _Tp>
inline const_mem_fun_ref_t<_Ret,_Tp> mem_fun_ref(_Ret (_Tp::*__f)() const)
template <class _Ret, class _Tp>
inline const_mem_fun_ref_t<_Ret,_Tp>
mem_fun_ref(_Ret (_Tp::*__f)() const)
{ return const_mem_fun_ref_t<_Ret,_Tp>(__f); }
template <class _Ret, class _Tp, class _Arg>
inline mem_fun1_t<_Ret,_Tp,_Arg> mem_fun(_Ret (_Tp::*__f)(_Arg))
template <class _Ret, class _Tp, class _Arg>
inline mem_fun1_t<_Ret,_Tp,_Arg>
mem_fun(_Ret (_Tp::*__f)(_Arg))
{ return mem_fun1_t<_Ret,_Tp,_Arg>(__f); }
template <class _Ret, class _Tp, class _Arg>
inline const_mem_fun1_t<_Ret,_Tp,_Arg> mem_fun(_Ret (_Tp::*__f)(_Arg) const)
template <class _Ret, class _Tp, class _Arg>
inline const_mem_fun1_t<_Ret,_Tp,_Arg>
mem_fun(_Ret (_Tp::*__f)(_Arg) const)
{ return const_mem_fun1_t<_Ret,_Tp,_Arg>(__f); }
template <class _Ret, class _Tp, class _Arg>
inline mem_fun1_ref_t<_Ret,_Tp,_Arg> mem_fun_ref(_Ret (_Tp::*__f)(_Arg))
template <class _Ret, class _Tp, class _Arg>
inline mem_fun1_ref_t<_Ret,_Tp,_Arg>
mem_fun_ref(_Ret (_Tp::*__f)(_Arg))
{ return mem_fun1_ref_t<_Ret,_Tp,_Arg>(__f); }
template <class _Ret, class _Tp, class _Arg>
inline const_mem_fun1_ref_t<_Ret,_Tp,_Arg>
mem_fun_ref(_Ret (_Tp::*__f)(_Arg) const)
template <class _Ret, class _Tp, class _Arg>
inline const_mem_fun1_ref_t<_Ret,_Tp,_Arg>
mem_fun_ref(_Ret (_Tp::*__f)(_Arg) const)
{ return const_mem_fun1_ref_t<_Ret,_Tp,_Arg>(__f); }
/** @} */
/** @} */
} // namespace std
......
libstdc++-v3/include/bits/stl_iterator.h
// Iterators -*- C++ -*-
// Copyright (C) 2001, 2002 Free Software Foundation, Inc.
// Copyright (C) 2001, 2002, 2004 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
......@@ -137,7 +137,8 @@ namespace std
* @return @c current, the %iterator used for underlying work.
*/
iterator_type
base() const { return current; }
base() const
{ return current; }
/**
* @return TODO
......@@ -157,7 +158,8 @@ namespace std
* @doctodo
*/
pointer
operator->() const { return &(operator*()); }
operator->() const
{ return &(operator*()); }
/**
* @return TODO
......@@ -256,7 +258,8 @@ namespace std
* @doctodo
*/
reference
operator[](difference_type __n) const { return *(*this + __n); }
operator[](difference_type __n) const
{ return *(*this + __n); }
};
//@{
......@@ -364,15 +367,18 @@ namespace std
/// Simply returns *this.
back_insert_iterator&
operator*() { return *this; }
operator*()
{ return *this; }
/// Simply returns *this. (This %iterator does not "move".)
back_insert_iterator&
operator++() { return *this; }
operator++()
{ return *this; }
/// Simply returns *this. (This %iterator does not "move".)
back_insert_iterator
operator++(int) { return *this; }
operator++(int)
{ return *this; }
};
/**
......@@ -435,15 +441,18 @@ namespace std
/// Simply returns *this.
front_insert_iterator&
operator*() { return *this; }
operator*()
{ return *this; }
/// Simply returns *this. (This %iterator does not "move".)
front_insert_iterator&
operator++() { return *this; }
operator++()
{ return *this; }
/// Simply returns *this. (This %iterator does not "move".)
front_insert_iterator
operator++(int) { return *this; }
operator++(int)
{ return *this; }
};
/**
......@@ -528,15 +537,18 @@ namespace std
/// Simply returns *this.
insert_iterator&
operator*() { return *this; }
operator*()
{ return *this; }
/// Simply returns *this. (This %iterator does not "move".)
insert_iterator&
operator++() { return *this; }
operator++()
{ return *this; }
/// Simply returns *this. (This %iterator does not "move".)
insert_iterator&
operator++(int) { return *this; }
operator++(int)
{ return *this; }
};
/**
......@@ -592,28 +604,41 @@ namespace __gnu_cxx
// Allow iterator to const_iterator conversion
template<typename _Iter>
inline __normal_iterator(const __normal_iterator<_Iter, _Container>& __i)
inline __normal_iterator(const __normal_iterator<_Iter,
_Container>& __i)
: _M_current(__i.base()) { }
// Forward iterator requirements
reference
operator*() const { return *_M_current; }
operator*() const
{ return *_M_current; }
pointer
operator->() const { return _M_current; }
operator->() const
{ return _M_current; }
__normal_iterator&
operator++() { ++_M_current; return *this; }
operator++()
{
++_M_current;
return *this;
}
__normal_iterator
operator++(int) { return __normal_iterator(_M_current++); }
operator++(int)
{ return __normal_iterator(_M_current++); }
// Bidirectional iterator requirements
__normal_iterator&
operator--() { --_M_current; return *this; }
operator--()
{
--_M_current;
return *this;
}
__normal_iterator
operator--(int) { return __normal_iterator(_M_current--); }
operator--(int)
{ return __normal_iterator(_M_current--); }
// Random access iterator requirements
reference
......@@ -637,7 +662,8 @@ namespace __gnu_cxx
{ return __normal_iterator(_M_current - __n); }
const _Iterator&
base() const { return _M_current; }
base() const
{ return _M_current; }
};
// Note: In what follows, the left- and right-hand-side iterators are
......@@ -734,8 +760,8 @@ namespace __gnu_cxx
template<typename _Iterator, typename _Container>
inline __normal_iterator<_Iterator, _Container>
operator+(typename __normal_iterator<_Iterator, _Container>::difference_type __n,
const __normal_iterator<_Iterator, _Container>& __i)
operator+(typename __normal_iterator<_Iterator, _Container>::difference_type
__n, const __normal_iterator<_Iterator, _Container>& __i)
{ return __normal_iterator<_Iterator, _Container>(__i.base() + __n); }
} // namespace __gnu_cxx
......
libstdc++-v3/include/bits/stl_iterator_base_funcs.h
// Functions used by iterators -*- C++ -*-
// Copyright (C) 2001, 2002, 2003 Free Software Foundation, Inc.
// Copyright (C) 2001, 2002, 2003, 2004 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
......@@ -78,8 +78,10 @@ namespace std
__glibcxx_function_requires(_InputIteratorConcept<_InputIterator>)
typename iterator_traits<_InputIterator>::difference_type __n = 0;
while (__first != __last) {
++__first; ++__n;
while (__first != __last)
{
++__first;
++__n;
}
return __n;
}
......@@ -90,7 +92,8 @@ namespace std
random_access_iterator_tag)
{
// concept requirements
__glibcxx_function_requires(_RandomAccessIteratorConcept<_RandomAccessIterator>)
__glibcxx_function_requires(_RandomAccessIteratorConcept<
_RandomAccessIterator>)
return __last - __first;
}
......@@ -111,7 +114,8 @@ namespace std
distance(_InputIterator __first, _InputIterator __last)
{
// concept requirements -- taken care of in __distance
return std::__distance(__first, __last, std::__iterator_category(__first));
return std::__distance(__first, __last,
std::__iterator_category(__first));
}
template<typename _InputIterator, typename _Distance>
......@@ -120,7 +124,8 @@ namespace std
{
// concept requirements
__glibcxx_function_requires(_InputIteratorConcept<_InputIterator>)
while (__n--) ++__i;
while (__n--)
++__i;
}
template<typename _BidirectionalIterator, typename _Distance>
......@@ -129,8 +134,8 @@ namespace std
bidirectional_iterator_tag)
{
// concept requirements
__glibcxx_function_requires(_BidirectionalIteratorConcept<_BidirectionalIterator>)
__glibcxx_function_requires(_BidirectionalIteratorConcept<
_BidirectionalIterator>)
if (__n > 0)
while (__n--) ++__i;
else
......@@ -143,7 +148,8 @@ namespace std
random_access_iterator_tag)
{
// concept requirements
__glibcxx_function_requires(_RandomAccessIteratorConcept<_RandomAccessIterator>)
__glibcxx_function_requires(_RandomAccessIteratorConcept<
_RandomAccessIterator>)
__i += __n;
}
......
libstdc++-v3/include/bits/stl_iterator_base_types.h
// Types used in iterator implementation -*- C++ -*-
// Copyright (C) 2001, 2002 Free Software Foundation, Inc.
// Copyright (C) 2001, 2002, 2004 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
......@@ -82,9 +82,11 @@ namespace std
struct output_iterator_tag {};
/// Forward iterators support a superset of input iterator operations.
struct forward_iterator_tag : public input_iterator_tag {};
/// Bidirectional iterators support a superset of forward iterator operations.
/// Bidirectional iterators support a superset of forward iterator
/// operations.
struct bidirectional_iterator_tag : public forward_iterator_tag {};
/// Random-access iterators support a superset of bidirectional iterator operations.
/// Random-access iterators support a superset of bidirectional iterator
/// operations.
struct random_access_iterator_tag : public bidirectional_iterator_tag {};
//@}
......
libstdc++-v3/include/bits/stl_list.h
......@@ -94,7 +94,6 @@ namespace __gnu_norm
_Tp _M_data; ///< User's data.
};
/**
* @brief A list::iterator.
*
......@@ -325,7 +324,6 @@ namespace __gnu_norm
}
};
/**
* @brief A standard container with linear time access to elements,
* and fixed time insertion/deletion at any point in the sequence.
......@@ -573,7 +571,8 @@ namespace __gnu_norm
/// Get a copy of the memory allocation object.
allocator_type
get_allocator() const { return _Base::get_allocator(); }
get_allocator() const
{ return _Base::get_allocator(); }
// iterators
/**
......@@ -581,7 +580,8 @@ namespace __gnu_norm
* %list. Iteration is done in ordinary element order.
*/
iterator
begin() { return this->_M_node._M_next; }
begin()
{ return this->_M_node._M_next; }
/**
* Returns a read-only (constant) iterator that points to the
......@@ -589,7 +589,8 @@ namespace __gnu_norm
* element order.
*/
const_iterator
begin() const { return this->_M_node._M_next; }
begin() const
{ return this->_M_node._M_next; }
/**
* Returns a read/write iterator that points one past the last
......@@ -605,7 +606,8 @@ namespace __gnu_norm
* element order.
*/
const_iterator
end() const { return &this->_M_node; }
end() const
{ return &this->_M_node; }
/**
* Returns a read/write reverse iterator that points to the last
......@@ -613,7 +615,8 @@ namespace __gnu_norm
* order.
*/
reverse_iterator
rbegin() { return reverse_iterator(end()); }
rbegin()
{ return reverse_iterator(end()); }
/**
* Returns a read-only (constant) reverse iterator that points to
......@@ -621,7 +624,8 @@ namespace __gnu_norm
* element order.
*/
const_reverse_iterator
rbegin() const { return const_reverse_iterator(end()); }
rbegin() const
{ return const_reverse_iterator(end()); }
/**
* Returns a read/write reverse iterator that points to one
......@@ -629,7 +633,8 @@ namespace __gnu_norm
* reverse element order.
*/
reverse_iterator
rend() { return reverse_iterator(begin()); }
rend()
{ return reverse_iterator(begin()); }
/**
* Returns a read-only (constant) reverse iterator that points to one
......@@ -646,15 +651,18 @@ namespace __gnu_norm
* end().)
*/
bool
empty() const { return this->_M_node._M_next == &this->_M_node; }
empty() const
{ return this->_M_node._M_next == &this->_M_node; }
/** Returns the number of elements in the %list. */
size_type
size() const { return std::distance(begin(), end()); }
size() const
{ return std::distance(begin(), end()); }
/** Returns the size() of the largest possible %list. */
size_type
max_size() const { return size_type(-1); }
max_size() const
{ return size_type(-1); }
/**
* @brief Resizes the %list to the specified number of elements.
......@@ -679,7 +687,8 @@ namespace __gnu_norm
* and new elements are default-constructed.
*/
void
resize(size_type __new_size) { this->resize(__new_size, value_type()); }
resize(size_type __new_size)
{ this->resize(__new_size, value_type()); }
// element access
/**
......@@ -687,28 +696,32 @@ namespace __gnu_norm
* element of the %list.
*/
reference
front() { return *begin(); }
front()
{ return *begin(); }
/**
* Returns a read-only (constant) reference to the data at the first
* element of the %list.
*/
const_reference
front() const { return *begin(); }
front() const
{ return *begin(); }
/**
* Returns a read/write reference to the data at the last element
* of the %list.
*/
reference
back() { return *(--end()); }
back()
{ return *(--end()); }
/**
* Returns a read-only (constant) reference to the data at the last
* element of the %list.
*/
const_reference
back() const { return *(--end()); }
back() const
{ return *(--end()); }
// [23.2.2.3] modifiers
/**
......@@ -722,7 +735,8 @@ namespace __gnu_norm
* references.
*/
void
push_front(const value_type& __x) { this->_M_insert(begin(), __x); }
push_front(const value_type& __x)
{ this->_M_insert(begin(), __x); }
/**
* @brief Removes first element.
......@@ -737,7 +751,8 @@ namespace __gnu_norm
* called.
*/
void
pop_front() { this->_M_erase(begin()); }
pop_front()
{ this->_M_erase(begin()); }
/**
* @brief Add data to the end of the %list.
......@@ -750,7 +765,8 @@ namespace __gnu_norm
* references.
*/
void
push_back(const value_type& __x) { this->_M_insert(end(), __x); }
push_back(const value_type& __x)
{ this->_M_insert(end(), __x); }
/**
* @brief Removes last element.
......@@ -764,7 +780,8 @@ namespace __gnu_norm
* is needed, it should be retrieved before pop_back() is called.
*/
void
pop_back() { this->_M_erase(this->_M_node._M_prev); }
pop_back()
{ this->_M_erase(this->_M_node._M_prev); }
/**
* @brief Inserts given value into %list before specified iterator.
......@@ -876,7 +893,8 @@ namespace __gnu_norm
* function.
*/
void
swap(list& __x) { _List_node_base::swap(this->_M_node,__x._M_node); }
swap(list& __x)
{ _List_node_base::swap(this->_M_node,__x._M_node); }
/**
* Erases all the elements. Note that this function only erases
......@@ -922,7 +940,8 @@ namespace __gnu_norm
{
iterator __j = __i;
++__j;
if (__position == __i || __position == __j) return;
if (__position == __i || __position == __j)
return;
this->_M_transfer(__position, __i, __j);
}
......@@ -1037,7 +1056,8 @@ namespace __gnu_norm
* Reverse the order of elements in the list in linear time.
*/
void
reverse() { this->_M_node.reverse(); }
reverse()
{ this->_M_node.reverse(); }
/**
* @brief Sort the elements.
......@@ -1118,16 +1138,13 @@ namespace __gnu_norm
// Moves the elements from [first,last) before position.
void
_M_transfer(iterator __position, iterator __first, iterator __last)
{
__position._M_node->transfer(__first._M_node,__last._M_node);
}
{ __position._M_node->transfer(__first._M_node,__last._M_node); }
// Inserts new element at position given and with value given.
void
_M_insert(iterator __position, const value_type& __x)
{
_Node* __tmp = _M_create_node(__x);
__tmp->hook(__position._M_node);
}
......@@ -1142,7 +1159,6 @@ namespace __gnu_norm
}
};
/**
* @brief List equality comparison.
* @param x A %list.
......@@ -1185,10 +1201,8 @@ namespace __gnu_norm
template<typename _Tp, typename _Alloc>
inline bool
operator<(const list<_Tp,_Alloc>& __x, const list<_Tp,_Alloc>& __y)
{
return std::lexicographical_compare(__x.begin(), __x.end(),
__y.begin(), __y.end());
}
{ return std::lexicographical_compare(__x.begin(), __x.end(),
__y.begin(), __y.end()); }
/// Based on operator==
template<typename _Tp, typename _Alloc>
......
libstdc++-v3/include/bits/stl_map.h
// Map implementation -*- C++ -*-
// Copyright (C) 2001, 2002 Free Software Foundation, Inc.
// Copyright (C) 2001, 2002, 2004 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
......@@ -92,7 +92,8 @@ namespace __gnu_norm
{
// concept requirements
__glibcxx_class_requires(_Tp, _SGIAssignableConcept)
__glibcxx_class_requires4(_Compare, bool, _Key, _Key, _BinaryFunctionConcept)
__glibcxx_class_requires4(_Compare, bool, _Key, _Key,
_BinaryFunctionConcept)
public:
typedef _Key key_type;
......@@ -106,7 +107,10 @@ namespace __gnu_norm
friend class map<_Key,_Tp,_Compare,_Alloc>;
protected:
_Compare comp;
value_compare(_Compare __c) : comp(__c) {}
value_compare(_Compare __c)
: comp(__c) { }
public:
bool operator()(const value_type& __x, const value_type& __y) const
{ return comp(__x.first, __y.first); }
......@@ -134,14 +138,14 @@ namespace __gnu_norm
typedef typename _Rep_type::reverse_iterator reverse_iterator;
typedef typename _Rep_type::const_reverse_iterator const_reverse_iterator;
// [23.3.1.1] construct/copy/destroy
// (get_allocator() is normally listed in this section, but seems to have
// been accidentally omitted in the printed standard)
/**
* @brief Default constructor creates no elements.
*/
map() : _M_t(_Compare(), allocator_type()) { }
map()
: _M_t(_Compare(), allocator_type()) { }
// for some reason this was made a separate function
/**
......@@ -217,15 +221,18 @@ namespace __gnu_norm
/// Get a copy of the memory allocation object.
allocator_type
get_allocator() const { return _M_t.get_allocator(); }
get_allocator() const
{ return _M_t.get_allocator(); }
// iterators
/**
* Returns a read/write iterator that points to the first pair in the %map.
* Returns a read/write iterator that points to the first pair in the
* %map.
* Iteration is done in ascending order according to the keys.
*/
iterator
begin() { return _M_t.begin(); }
begin()
{ return _M_t.begin(); }
/**
* Returns a read-only (constant) iterator that points to the first pair
......@@ -233,45 +240,52 @@ namespace __gnu_norm
* keys.
*/
const_iterator
begin() const { return _M_t.begin(); }
begin() const
{ return _M_t.begin(); }
/**
* Returns a read/write iterator that points one past the last pair in the
* %map. Iteration is done in ascending order according to the keys.
* Returns a read/write iterator that points one past the last pair in
* the %map. Iteration is done in ascending order according to the keys.
*/
iterator
end() { return _M_t.end(); }
end()
{ return _M_t.end(); }
/**
* Returns a read-only (constant) iterator that points one past the last
* pair in the %map. Iteration is done in ascending order according to the
* keys.
* pair in the %map. Iteration is done in ascending order according to
* the keys.
*/
const_iterator
end() const { return _M_t.end(); }
end() const
{ return _M_t.end(); }
/**
* Returns a read/write reverse iterator that points to the last pair in
* the %map. Iteration is done in descending order according to the keys.
* the %map. Iteration is done in descending order according to the
* keys.
*/
reverse_iterator
rbegin() { return _M_t.rbegin(); }
rbegin()
{ return _M_t.rbegin(); }
/**
* Returns a read-only (constant) reverse iterator that points to the last
* pair in the %map. Iteration is done in descending order according to
* the keys.
* Returns a read-only (constant) reverse iterator that points to the
* last pair in the %map. Iteration is done in descending order
* according to the keys.
*/
const_reverse_iterator
rbegin() const { return _M_t.rbegin(); }
rbegin() const
{ return _M_t.rbegin(); }
/**
* Returns a read/write reverse iterator that points to one before the
* first pair in the %map. Iteration is done in descending order according
* to the keys.
* first pair in the %map. Iteration is done in descending order
* according to the keys.
*/
reverse_iterator
rend() { return _M_t.rend(); }
rend()
{ return _M_t.rend(); }
/**
* Returns a read-only (constant) reverse iterator that points to one
......@@ -279,20 +293,26 @@ namespace __gnu_norm
* order according to the keys.
*/
const_reverse_iterator
rend() const { return _M_t.rend(); }
rend() const
{ return _M_t.rend(); }
// capacity
/** Returns true if the %map is empty. (Thus begin() would equal end().) */
/** Returns true if the %map is empty. (Thus begin() would equal
* end().)
*/
bool
empty() const { return _M_t.empty(); }
empty() const
{ return _M_t.empty(); }
/** Returns the size of the %map. */
size_type
size() const { return _M_t.size(); }
size() const
{ return _M_t.size(); }
/** Returns the maximum size of the %map. */
size_type
max_size() const { return _M_t.max_size(); }
max_size() const
{ return _M_t.max_size(); }
// [23.3.1.2] element access
/**
......@@ -380,13 +400,14 @@ namespace __gnu_norm
* @brief Erases an element from a %map.
* @param position An iterator pointing to the element to be erased.
*
* This function erases an element, pointed to by the given iterator, from
* a %map. Note that this function only erases the element, and that if
* the element is itself a pointer, the pointed-to memory is not touched
* in any way. Managing the pointer is the user's responsibilty.
* This function erases an element, pointed to by the given iterator,
* from a %map. Note that this function only erases the element, and
* that if the element is itself a pointer, the pointed-to memory is not
* touched in any way. Managing the pointer is the user's responsibilty.
*/
void
erase(iterator __position) { _M_t.erase(__position); }
erase(iterator __position)
{ _M_t.erase(__position); }
/**
* @brief Erases elements according to the provided key.
......@@ -400,11 +421,13 @@ namespace __gnu_norm
* in any way. Managing the pointer is the user's responsibilty.
*/
size_type
erase(const key_type& __x) { return _M_t.erase(__x); }
erase(const key_type& __x)
{ return _M_t.erase(__x); }
/**
* @brief Erases a [first,last) range of elements from a %map.
* @param first Iterator pointing to the start of the range to be erased.
* @param first Iterator pointing to the start of the range to be
* erased.
* @param last Iterator pointing to the end of the range to be erased.
*
* This function erases a sequence of elements from a %map.
......@@ -413,7 +436,8 @@ namespace __gnu_norm
* in any way. Managing the pointer is the user's responsibilty.
*/
void
erase(iterator __first, iterator __last) { _M_t.erase(__first, __last); }
erase(iterator __first, iterator __last)
{ _M_t.erase(__first, __last); }
/**
* @brief Swaps data with another %map.
......@@ -427,7 +451,8 @@ namespace __gnu_norm
* std::swap(m1,m2) will feed to this function.
*/
void
swap(map& __x) { _M_t.swap(__x._M_t); }
swap(map& __x)
{ _M_t.swap(__x._M_t); }
/**
* Erases all elements in a %map. Note that this function only erases
......@@ -436,21 +461,25 @@ namespace __gnu_norm
* the user's responsibilty.
*/
void
clear() { _M_t.clear(); }
clear()
{ _M_t.clear(); }
// observers
/**
* Returns the key comparison object out of which the %map was constructed.
* Returns the key comparison object out of which the %map was
* constructed.
*/
key_compare
key_comp() const { return _M_t.key_comp(); }
key_comp() const
{ return _M_t.key_comp(); }
/**
* Returns a value comparison object, built from the key comparison
* object out of which the %map was constructed.
*/
value_compare
value_comp() const { return value_compare(_M_t.key_comp()); }
value_comp() const
{ return value_compare(_M_t.key_comp()); }
// [23.3.1.3] map operations
/**
......@@ -465,7 +494,8 @@ namespace __gnu_norm
* past-the-end ( @c end() ) iterator.
*/
iterator
find(const key_type& __x) { return _M_t.find(__x); }
find(const key_type& __x)
{ return _M_t.find(__x); }
/**
* @brief Tries to locate an element in a %map.
......@@ -474,12 +504,13 @@ namespace __gnu_norm
* element, or end() if not found.
*
* This function takes a key and tries to locate the element with which
* the key matches. If successful the function returns a constant iterator
* pointing to the sought after %pair. If unsuccessful it returns the
* past-the-end ( @c end() ) iterator.
* the key matches. If successful the function returns a constant
* iterator pointing to the sought after %pair. If unsuccessful it
* returns the past-the-end ( @c end() ) iterator.
*/
const_iterator
find(const key_type& __x) const { return _M_t.find(__x); }
find(const key_type& __x) const
{ return _M_t.find(__x); }
/**
* @brief Finds the number of elements with given key.
......@@ -505,7 +536,8 @@ namespace __gnu_norm
* or end() if no such element exists.
*/
iterator
lower_bound(const key_type& __x) { return _M_t.lower_bound(__x); }
lower_bound(const key_type& __x)
{ return _M_t.lower_bound(__x); }
/**
* @brief Finds the beginning of a subsequence matching given key.
......@@ -519,7 +551,8 @@ namespace __gnu_norm
* or end() if no such element exists.
*/
const_iterator
lower_bound(const key_type& __x) const { return _M_t.lower_bound(__x); }
lower_bound(const key_type& __x) const
{ return _M_t.lower_bound(__x); }
/**
* @brief Finds the end of a subsequence matching given key.
......@@ -528,7 +561,8 @@ namespace __gnu_norm
* greater than key, or end().
*/
iterator
upper_bound(const key_type& __x) { return _M_t.upper_bound(__x); }
upper_bound(const key_type& __x)
{ return _M_t.upper_bound(__x); }
/**
* @brief Finds the end of a subsequence matching given key.
......@@ -562,8 +596,8 @@ namespace __gnu_norm
/**
* @brief Finds a subsequence matching given key.
* @param x Key of (key, value) pairs to be located.
* @return Pair of read-only (constant) iterators that possibly points to
* the subsequence matching given key.
* @return Pair of read-only (constant) iterators that possibly points
* to the subsequence matching given key.
*
* This function is equivalent to
* @code
......@@ -586,7 +620,6 @@ namespace __gnu_norm
const map<_K1,_T1,_C1,_A1>&);
};
/**
* @brief Map equality comparison.
* @param x A %map.
......
libstdc++-v3/include/bits/stl_multimap.h
// Multimap implementation -*- C++ -*-
// Copyright (C) 2001, 2002 Free Software Foundation, Inc.
// Copyright (C) 2001, 2002, 2004 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
......@@ -106,7 +106,8 @@ namespace __gnu_norm
{
// concept requirements
__glibcxx_class_requires(_Tp, _SGIAssignableConcept)
__glibcxx_class_requires4(_Compare, bool, _Key, _Key, _BinaryFunctionConcept)
__glibcxx_class_requires4(_Compare, bool, _Key, _Key,
_BinaryFunctionConcept)
public:
typedef _Key key_type;
......@@ -120,7 +121,10 @@ namespace __gnu_norm
friend class multimap<_Key,_Tp,_Compare,_Alloc>;
protected:
_Compare comp;
value_compare(_Compare __c) : comp(__c) {}
value_compare(_Compare __c)
: comp(__c) { }
public:
bool operator()(const value_type& __x, const value_type& __y) const
{ return comp(__x.first, __y.first); }
......@@ -154,14 +158,16 @@ namespace __gnu_norm
/**
* @brief Default constructor creates no elements.
*/
multimap() : _M_t(_Compare(), allocator_type()) { }
multimap()
: _M_t(_Compare(), allocator_type()) { }
// for some reason this was made a separate function
/**
* @brief Default constructor creates no elements.
*/
explicit
multimap(const _Compare& __comp, const allocator_type& __a = allocator_type())
multimap(const _Compare& __comp,
const allocator_type& __a = allocator_type())
: _M_t(__comp, __a) { }
/**
......@@ -231,30 +237,36 @@ namespace __gnu_norm
/// Get a copy of the memory allocation object.
allocator_type
get_allocator() const { return _M_t.get_allocator(); }
get_allocator() const
{ return _M_t.get_allocator(); }
// iterators
/**
* Returns a read/write iterator that points to the first pair in the
* %multimap. Iteration is done in ascending order according to the keys.
* %multimap. Iteration is done in ascending order according to the
* keys.
*/
iterator
begin() { return _M_t.begin(); }
begin()
{ return _M_t.begin(); }
/**
* Returns a read-only (constant) iterator that points to the first pair
* in the %multimap. Iteration is done in ascending order according to the
* keys.
* in the %multimap. Iteration is done in ascending order according to
* the keys.
*/
const_iterator
begin() const { return _M_t.begin(); }
begin() const
{ return _M_t.begin(); }
/**
* Returns a read/write iterator that points one past the last pair in the
* %multimap. Iteration is done in ascending order according to the keys.
* Returns a read/write iterator that points one past the last pair in
* the %multimap. Iteration is done in ascending order according to the
* keys.
*/
iterator
end() { return _M_t.end(); }
end()
{ return _M_t.end(); }
/**
* Returns a read-only (constant) iterator that points one past the last
......@@ -262,7 +274,8 @@ namespace __gnu_norm
* to the keys.
*/
const_iterator
end() const { return _M_t.end(); }
end() const
{ return _M_t.end(); }
/**
* Returns a read/write reverse iterator that points to the last pair in
......@@ -270,15 +283,17 @@ namespace __gnu_norm
* keys.
*/
reverse_iterator
rbegin() { return _M_t.rbegin(); }
rbegin()
{ return _M_t.rbegin(); }
/**
* Returns a read-only (constant) reverse iterator that points to the last
* pair in the %multimap. Iteration is done in descending order according
* to the keys.
* Returns a read-only (constant) reverse iterator that points to the
* last pair in the %multimap. Iteration is done in descending order
* according to the keys.
*/
const_reverse_iterator
rbegin() const { return _M_t.rbegin(); }
rbegin() const
{ return _M_t.rbegin(); }
/**
* Returns a read/write reverse iterator that points to one before the
......@@ -286,56 +301,62 @@ namespace __gnu_norm
* according to the keys.
*/
reverse_iterator
rend() { return _M_t.rend(); }
rend()
{ return _M_t.rend(); }
/**
* Returns a read-only (constant) reverse iterator that points to one
* before the first pair in the %multimap. Iteration is done in descending
* order according to the keys.
* before the first pair in the %multimap. Iteration is done in
* descending order according to the keys.
*/
const_reverse_iterator
rend() const { return _M_t.rend(); }
rend() const
{ return _M_t.rend(); }
// capacity
/** Returns true if the %multimap is empty. */
bool
empty() const { return _M_t.empty(); }
empty() const
{ return _M_t.empty(); }
/** Returns the size of the %multimap. */
size_type
size() const { return _M_t.size(); }
size() const
{ return _M_t.size(); }
/** Returns the maximum size of the %multimap. */
size_type
max_size() const { return _M_t.max_size(); }
max_size() const
{ return _M_t.max_size(); }
// modifiers
/**
* @brief Inserts a std::pair into the %multimap.
* @param x Pair to be inserted (see std::make_pair for easy creation of
* pairs).
* @param x Pair to be inserted (see std::make_pair for easy creation
* of pairs).
* @return An iterator that points to the inserted (key,value) pair.
*
* This function inserts a (key, value) pair into the %multimap. Contrary
* to a std::map the %multimap does not rely on unique keys and thus
* multiple pairs with the same key can be inserted.
* This function inserts a (key, value) pair into the %multimap.
* Contrary to a std::map the %multimap does not rely on unique keys and
* thus multiple pairs with the same key can be inserted.
*
* Insertion requires logarithmic time.
*/
iterator
insert(const value_type& __x) { return _M_t.insert_equal(__x); }
insert(const value_type& __x)
{ return _M_t.insert_equal(__x); }
/**
* @brief Inserts a std::pair into the %multimap.
* @param position An iterator that serves as a hint as to where the
* pair should be inserted.
* @param x Pair to be inserted (see std::make_pair for easy creation of
* pairs).
* @param x Pair to be inserted (see std::make_pair for easy creation
* of pairs).
* @return An iterator that points to the inserted (key,value) pair.
*
* This function inserts a (key, value) pair into the %multimap. Contrary
* to a std::map the %multimap does not rely on unique keys and thus
* multiple pairs with the same key can be inserted.
* This function inserts a (key, value) pair into the %multimap.
* Contrary to a std::map the %multimap does not rely on unique keys and
* thus multiple pairs with the same key can be inserted.
* Note that the first parameter is only a hint and can potentially
* improve the performance of the insertion process. A bad hint would
* cause no gains in efficiency.
......@@ -366,13 +387,15 @@ namespace __gnu_norm
* @brief Erases an element from a %multimap.
* @param position An iterator pointing to the element to be erased.
*
* This function erases an element, pointed to by the given iterator, from
* a %multimap. Note that this function only erases the element, and that
* if the element is itself a pointer, the pointed-to memory is not
* touched in any way. Managing the pointer is the user's responsibilty.
* This function erases an element, pointed to by the given iterator,
* from a %multimap. Note that this function only erases the element,
* and that if the element is itself a pointer, the pointed-to memory is
* not touched in any way. Managing the pointer is the user's
* responsibilty.
*/
void
erase(iterator __position) { _M_t.erase(__position); }
erase(iterator __position)
{ _M_t.erase(__position); }
/**
* @brief Erases elements according to the provided key.
......@@ -386,11 +409,13 @@ namespace __gnu_norm
* in any way. Managing the pointer is the user's responsibilty.
*/
size_type
erase(const key_type& __x) { return _M_t.erase(__x); }
erase(const key_type& __x)
{ return _M_t.erase(__x); }
/**
* @brief Erases a [first,last) range of elements from a %multimap.
* @param first Iterator pointing to the start of the range to be erased.
* @param first Iterator pointing to the start of the range to be
* erased.
* @param last Iterator pointing to the end of the range to be erased.
*
* This function erases a sequence of elements from a %multimap.
......@@ -399,7 +424,8 @@ namespace __gnu_norm
* touched in any way. Managing the pointer is the user's responsibilty.
*/
void
erase(iterator __first, iterator __last) { _M_t.erase(__first, __last); }
erase(iterator __first, iterator __last)
{ _M_t.erase(__first, __last); }
/**
* @brief Swaps data with another %multimap.
......@@ -413,16 +439,18 @@ namespace __gnu_norm
* std::swap(m1,m2) will feed to this function.
*/
void
swap(multimap& __x) { _M_t.swap(__x._M_t); }
swap(multimap& __x)
{ _M_t.swap(__x._M_t); }
/**
* Erases all elements in a %multimap. Note that this function only erases
* the elements, and that if the elements themselves are pointers, the
* pointed-to memory is not touched in any way. Managing the pointer is
* the user's responsibilty.
* Erases all elements in a %multimap. Note that this function only
* erases the elements, and that if the elements themselves are pointers,
* the pointed-to memory is not touched in any way. Managing the pointer
* is the user's responsibilty.
*/
void
clear() { _M_t.clear(); }
clear()
{ _M_t.clear(); }
// observers
/**
......@@ -430,14 +458,16 @@ namespace __gnu_norm
* was constructed.
*/
key_compare
key_comp() const { return _M_t.key_comp(); }
key_comp() const
{ return _M_t.key_comp(); }
/**
* Returns a value comparison object, built from the key comparison
* object out of which the %multimap was constructed.
*/
value_compare
value_comp() const { return value_compare(_M_t.key_comp()); }
value_comp() const
{ return value_compare(_M_t.key_comp()); }
// multimap operations
/**
......@@ -452,7 +482,8 @@ namespace __gnu_norm
* past-the-end ( @c end() ) iterator.
*/
iterator
find(const key_type& __x) { return _M_t.find(__x); }
find(const key_type& __x)
{ return _M_t.find(__x); }
/**
* @brief Tries to locate an element in a %multimap.
......@@ -461,12 +492,13 @@ namespace __gnu_norm
* element, or end() if not found.
*
* This function takes a key and tries to locate the element with which
* the key matches. If successful the function returns a constant iterator
* pointing to the sought after %pair. If unsuccessful it returns the
* past-the-end ( @c end() ) iterator.
* the key matches. If successful the function returns a constant
* iterator pointing to the sought after %pair. If unsuccessful it
* returns the past-the-end ( @c end() ) iterator.
*/
const_iterator
find(const key_type& __x) const { return _M_t.find(__x); }
find(const key_type& __x) const
{ return _M_t.find(__x); }
/**
* @brief Finds the number of elements with given key.
......@@ -474,7 +506,8 @@ namespace __gnu_norm
* @return Number of elements with specified key.
*/
size_type
count(const key_type& __x) const { return _M_t.count(__x); }
count(const key_type& __x) const
{ return _M_t.count(__x); }
/**
* @brief Finds the beginning of a subsequence matching given key.
......@@ -488,7 +521,8 @@ namespace __gnu_norm
* or end() if no such element exists.
*/
iterator
lower_bound(const key_type& __x) { return _M_t.lower_bound(__x); }
lower_bound(const key_type& __x)
{ return _M_t.lower_bound(__x); }
/**
* @brief Finds the beginning of a subsequence matching given key.
......@@ -502,7 +536,8 @@ namespace __gnu_norm
* end().
*/
const_iterator
lower_bound(const key_type& __x) const { return _M_t.lower_bound(__x); }
lower_bound(const key_type& __x) const
{ return _M_t.lower_bound(__x); }
/**
* @brief Finds the end of a subsequence matching given key.
......@@ -511,7 +546,8 @@ namespace __gnu_norm
* greater than key, or end().
*/
iterator
upper_bound(const key_type& __x) { return _M_t.upper_bound(__x); }
upper_bound(const key_type& __x)
{ return _M_t.upper_bound(__x); }
/**
* @brief Finds the end of a subsequence matching given key.
......@@ -520,7 +556,8 @@ namespace __gnu_norm
* greater than key, or end().
*/
const_iterator
upper_bound(const key_type& __x) const { return _M_t.upper_bound(__x); }
upper_bound(const key_type& __x) const
{ return _M_t.upper_bound(__x); }
/**
* @brief Finds a subsequence matching given key.
......@@ -536,13 +573,14 @@ namespace __gnu_norm
* (but is faster than making the calls separately).
*/
pair<iterator,iterator>
equal_range(const key_type& __x) { return _M_t.equal_range(__x); }
equal_range(const key_type& __x)
{ return _M_t.equal_range(__x); }
/**
* @brief Finds a subsequence matching given key.
* @param x Key of (key, value) pairs to be located.
* @return Pair of read-only (constant) iterators that possibly points to
* the subsequence matching given key.
* @return Pair of read-only (constant) iterators that possibly points
* to the subsequence matching given key.
*
* This function is equivalent to
* @code
......@@ -552,17 +590,20 @@ namespace __gnu_norm
* (but is faster than making the calls separately).
*/
pair<const_iterator,const_iterator>
equal_range(const key_type& __x) const { return _M_t.equal_range(__x); }
equal_range(const key_type& __x) const
{ return _M_t.equal_range(__x); }
template <typename _K1, typename _T1, typename _C1, typename _A1>
friend bool operator== (const multimap<_K1,_T1,_C1,_A1>&,
friend bool
operator== (const multimap<_K1,_T1,_C1,_A1>&,
const multimap<_K1,_T1,_C1,_A1>&);
template <typename _K1, typename _T1, typename _C1, typename _A1>
friend bool operator< (const multimap<_K1,_T1,_C1,_A1>&,
friend bool
operator< (const multimap<_K1,_T1,_C1,_A1>&,
const multimap<_K1,_T1,_C1,_A1>&);
};
/**
* @brief Multimap equality comparison.
* @param x A %multimap.
......@@ -577,9 +618,7 @@ namespace __gnu_norm
inline bool
operator==(const multimap<_Key,_Tp,_Compare,_Alloc>& __x,
const multimap<_Key,_Tp,_Compare,_Alloc>& __y)
{
return __x._M_t == __y._M_t;
}
{ return __x._M_t == __y._M_t; }
/**
* @brief Multimap ordering relation.
......
libstdc++-v3/include/bits/stl_multiset.h
......@@ -66,18 +66,17 @@
namespace __gnu_norm
{
// Forward declaration of operators < and ==, needed for friend declaration.
template <class _Key, class _Compare = less<_Key>,
// Forward declaration of operators < and ==, needed for friend declaration.
template <class _Key, class _Compare = less<_Key>,
class _Alloc = allocator<_Key> >
class multiset;
class multiset;
template <class _Key, class _Compare, class _Alloc>
inline bool operator==(const multiset<_Key,_Compare,_Alloc>& __x,
template <class _Key, class _Compare, class _Alloc>
inline bool operator==(const multiset<_Key,_Compare,_Alloc>& __x,
const multiset<_Key,_Compare,_Alloc>& __y);
template <class _Key, class _Compare, class _Alloc>
inline bool operator<(const multiset<_Key,_Compare,_Alloc>& __x,
template <class _Key, class _Compare, class _Alloc>
inline bool operator<(const multiset<_Key,_Compare,_Alloc>& __x,
const multiset<_Key,_Compare,_Alloc>& __y);
/**
......@@ -105,12 +104,11 @@ inline bool operator<(const multiset<_Key,_Compare,_Alloc>& __x,
{
// concept requirements
__glibcxx_class_requires(_Key, _SGIAssignableConcept)
__glibcxx_class_requires4(_Compare, bool, _Key, _Key, _BinaryFunctionConcept)
__glibcxx_class_requires4(_Compare, bool, _Key, _Key,
_BinaryFunctionConcept)
public:
// typedefs:
typedef _Key key_type;
typedef _Key value_type;
typedef _Compare key_compare;
......@@ -141,10 +139,12 @@ inline bool operator<(const multiset<_Key,_Compare,_Alloc>& __x,
/**
* @brief Default constructor creates no elements.
*/
multiset() : _M_t(_Compare(), allocator_type()) {}
multiset()
: _M_t(_Compare(), allocator_type()) { }
explicit multiset(const _Compare& __comp,
const allocator_type& __a = allocator_type())
: _M_t(__comp, __a) {}
: _M_t(__comp, __a) { }
/**
* @brief Builds a %multiset from a range.
......@@ -175,7 +175,8 @@ inline bool operator<(const multiset<_Key,_Compare,_Alloc>& __x,
multiset(_InputIterator __first, _InputIterator __last,
const _Compare& __comp,
const allocator_type& __a = allocator_type())
: _M_t(__comp, __a) { _M_t.insert_equal(__first, __last); }
: _M_t(__comp, __a)
{ _M_t.insert_equal(__first, __last); }
/**
* @brief %Multiset copy constructor.
......@@ -184,7 +185,8 @@ inline bool operator<(const multiset<_Key,_Compare,_Alloc>& __x,
* The newly-created %multiset uses a copy of the allocation object used
* by @a x.
*/
multiset(const multiset<_Key,_Compare,_Alloc>& __x) : _M_t(__x._M_t) {}
multiset(const multiset<_Key,_Compare,_Alloc>& __x)
: _M_t(__x._M_t) { }
/**
* @brief %Multiset assignment operator.
......@@ -194,7 +196,8 @@ inline bool operator<(const multiset<_Key,_Compare,_Alloc>& __x,
* the allocator object is not copied.
*/
multiset<_Key,_Compare,_Alloc>&
operator=(const multiset<_Key,_Compare,_Alloc>& __x) {
operator=(const multiset<_Key,_Compare,_Alloc>& __x)
{
_M_t = __x._M_t;
return *this;
}
......@@ -202,48 +205,68 @@ inline bool operator<(const multiset<_Key,_Compare,_Alloc>& __x,
// accessors:
/// Returns the comparison object.
key_compare key_comp() const { return _M_t.key_comp(); }
key_compare
key_comp() const
{ return _M_t.key_comp(); }
/// Returns the comparison object.
value_compare value_comp() const { return _M_t.key_comp(); }
value_compare
value_comp() const
{ return _M_t.key_comp(); }
/// Returns the memory allocation object.
allocator_type get_allocator() const { return _M_t.get_allocator(); }
allocator_type
get_allocator() const
{ return _M_t.get_allocator(); }
/**
* Returns a read/write iterator that points to the first element in the
* %multiset. Iteration is done in ascending order according to the
* keys.
*/
iterator begin() const { return _M_t.begin(); }
iterator
begin() const
{ return _M_t.begin(); }
/**
* Returns a read/write iterator that points one past the last element in
* the %multiset. Iteration is done in ascending order according to the
* keys.
*/
iterator end() const { return _M_t.end(); }
iterator
end() const
{ return _M_t.end(); }
/**
* Returns a read/write reverse iterator that points to the last element
* in the %multiset. Iteration is done in descending order according to
* the keys.
*/
reverse_iterator rbegin() const { return _M_t.rbegin(); }
reverse_iterator
rbegin() const
{ return _M_t.rbegin(); }
/**
* Returns a read/write reverse iterator that points to the last element
* in the %multiset. Iteration is done in descending order according to
* the keys.
*/
reverse_iterator rend() const { return _M_t.rend(); }
reverse_iterator
rend() const
{ return _M_t.rend(); }
/// Returns true if the %set is empty.
bool empty() const { return _M_t.empty(); }
bool
empty() const
{ return _M_t.empty(); }
/// Returns the size of the %set.
size_type size() const { return _M_t.size(); }
size_type
size() const
{ return _M_t.size(); }
/// Returns the maximum size of the %set.
size_type max_size() const { return _M_t.max_size(); }
size_type
max_size() const
{ return _M_t.max_size(); }
/**
* @brief Swaps data with another %multiset.
......@@ -256,7 +279,9 @@ inline bool operator<(const multiset<_Key,_Compare,_Alloc>& __x,
* Note that the global std::swap() function is specialized such that
* std::swap(s1,s2) will feed to this function.
*/
void swap(multiset<_Key,_Compare,_Alloc>& __x) { _M_t.swap(__x._M_t); }
void
swap(multiset<_Key,_Compare,_Alloc>& __x)
{ _M_t.swap(__x._M_t); }
// insert/erase
/**
......@@ -270,9 +295,9 @@ inline bool operator<(const multiset<_Key,_Compare,_Alloc>& __x,
*
* Insertion requires logarithmic time.
*/
iterator insert(const value_type& __x) {
return _M_t.insert_equal(__x);
}
iterator
insert(const value_type& __x)
{ return _M_t.insert_equal(__x); }
/**
* @brief Inserts an element into the %multiset.
......@@ -294,7 +319,9 @@ inline bool operator<(const multiset<_Key,_Compare,_Alloc>& __x,
*
* Insertion requires logarithmic time (if the hint is not taken).
*/
iterator insert(iterator __position, const value_type& __x) {
iterator
insert(iterator __position, const value_type& __x)
{
typedef typename _Rep_type::iterator _Rep_iterator;
return _M_t.insert_equal((_Rep_iterator&)__position, __x);
}
......@@ -308,9 +335,9 @@ inline bool operator<(const multiset<_Key,_Compare,_Alloc>& __x,
* Complexity similar to that of the range constructor.
*/
template <class _InputIterator>
void insert(_InputIterator __first, _InputIterator __last) {
_M_t.insert_equal(__first, __last);
}
void
insert(_InputIterator __first, _InputIterator __last)
{ _M_t.insert_equal(__first, __last); }
/**
* @brief Erases an element from a %multiset.
......@@ -322,7 +349,9 @@ inline bool operator<(const multiset<_Key,_Compare,_Alloc>& __x,
* not touched in any way. Managing the pointer is the user's
* responsibilty.
*/
void erase(iterator __position) {
void
erase(iterator __position)
{
typedef typename _Rep_type::iterator _Rep_iterator;
_M_t.erase((_Rep_iterator&)__position);
}
......@@ -338,13 +367,14 @@ inline bool operator<(const multiset<_Key,_Compare,_Alloc>& __x,
* the element is itself a pointer, the pointed-to memory is not touched
* in any way. Managing the pointer is the user's responsibilty.
*/
size_type erase(const key_type& __x) {
return _M_t.erase(__x);
}
size_type
erase(const key_type& __x)
{ return _M_t.erase(__x); }
/**
* @brief Erases a [first,last) range of elements from a %multiset.
* @param first Iterator pointing to the start of the range to be erased.
* @param first Iterator pointing to the start of the range to be
* erased.
* @param last Iterator pointing to the end of the range to be erased.
*
* This function erases a sequence of elements from a %multiset.
......@@ -352,7 +382,9 @@ inline bool operator<(const multiset<_Key,_Compare,_Alloc>& __x,
* the elements themselves are pointers, the pointed-to memory is not
* touched in any way. Managing the pointer is the user's responsibilty.
*/
void erase(iterator __first, iterator __last) {
void
erase(iterator __first, iterator __last)
{
typedef typename _Rep_type::iterator _Rep_iterator;
_M_t.erase((_Rep_iterator&)__first, (_Rep_iterator&)__last);
}
......@@ -363,7 +395,9 @@ inline bool operator<(const multiset<_Key,_Compare,_Alloc>& __x,
* the pointed-to memory is not touched in any way. Managing the pointer
* is the user's responsibilty.
*/
void clear() { _M_t.clear(); }
void
clear()
{ _M_t.clear(); }
// multiset operations:
......@@ -372,7 +406,9 @@ inline bool operator<(const multiset<_Key,_Compare,_Alloc>& __x,
* @param x Key of elements to be located.
* @return Number of elements with specified key.
*/
size_type count(const key_type& __x) const { return _M_t.count(__x); }
size_type
count(const key_type& __x) const
{ return _M_t.count(__x); }
// _GLIBCXX_RESOLVE_LIB_DEFECTS
// 214. set::find() missing const overload
......@@ -388,8 +424,13 @@ inline bool operator<(const multiset<_Key,_Compare,_Alloc>& __x,
* pointing to the sought after element. If unsuccessful it returns the
* past-the-end ( @c end() ) iterator.
*/
iterator find(const key_type& __x) { return _M_t.find(__x); }
const_iterator find(const key_type& __x) const { return _M_t.find(__x); }
iterator
find(const key_type& __x)
{ return _M_t.find(__x); }
const_iterator
find(const key_type& __x) const
{ return _M_t.find(__x); }
//@}
//@{
......@@ -404,12 +445,13 @@ inline bool operator<(const multiset<_Key,_Compare,_Alloc>& __x,
* pointing to the first element that has a greater value than given key
* or end() if no such element exists.
*/
iterator lower_bound(const key_type& __x) {
return _M_t.lower_bound(__x);
}
const_iterator lower_bound(const key_type& __x) const {
return _M_t.lower_bound(__x);
}
iterator
lower_bound(const key_type& __x)
{ return _M_t.lower_bound(__x); }
const_iterator
lower_bound(const key_type& __x) const
{ return _M_t.lower_bound(__x); }
//@}
//@{
......@@ -419,12 +461,13 @@ inline bool operator<(const multiset<_Key,_Compare,_Alloc>& __x,
* @return Iterator pointing to the first element
* greater than key, or end().
*/
iterator upper_bound(const key_type& __x) {
return _M_t.upper_bound(__x);
}
const_iterator upper_bound(const key_type& __x) const {
return _M_t.upper_bound(__x);
}
iterator
upper_bound(const key_type& __x)
{ return _M_t.upper_bound(__x); }
const_iterator
upper_bound(const key_type& __x) const
{ return _M_t.upper_bound(__x); }
//@}
//@{
......@@ -443,18 +486,22 @@ inline bool operator<(const multiset<_Key,_Compare,_Alloc>& __x,
*
* This function probably only makes sense for multisets.
*/
pair<iterator,iterator> equal_range(const key_type& __x) {
return _M_t.equal_range(__x);
}
pair<const_iterator,const_iterator> equal_range(const key_type& __x) const {
return _M_t.equal_range(__x);
}
pair<iterator,iterator>
equal_range(const key_type& __x)
{ return _M_t.equal_range(__x); }
pair<const_iterator,const_iterator>
equal_range(const key_type& __x) const
{ return _M_t.equal_range(__x); }
template <class _K1, class _C1, class _A1>
friend bool operator== (const multiset<_K1,_C1,_A1>&,
friend bool
operator== (const multiset<_K1,_C1,_A1>&,
const multiset<_K1,_C1,_A1>&);
template <class _K1, class _C1, class _A1>
friend bool operator< (const multiset<_K1,_C1,_A1>&,
friend bool
operator< (const multiset<_K1,_C1,_A1>&,
const multiset<_K1,_C1,_A1>&);
};
......@@ -464,7 +511,8 @@ inline bool operator<(const multiset<_Key,_Compare,_Alloc>& __x,
* @param y A %multiset of the same type as @a x.
* @return True iff the size and elements of the multisets are equal.
*
* This is an equivalence relation. It is linear in the size of the multisets.
* This is an equivalence relation. It is linear in the size of the
* multisets.
* Multisets are considered equivalent if their sizes are equal, and if
* corresponding elements compare equal.
*/
......
libstdc++-v3/include/bits/stl_relops.h
// std::rel_ops implementation -*- C++ -*-
// Copyright (C) 2001, 2002 Free Software Foundation, Inc.
// Copyright (C) 2001, 2002, 2004 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
......@@ -79,57 +79,57 @@ namespace std
* @brief The generated relational operators are sequestered here.
*/
/**
/**
* @brief Defines @c != for arbitrary types, in terms of @c ==.
* @param x A thing.
* @param y Another thing.
* @return x != y
*
* This function uses @c == to determine its result.
*/
template <class _Tp>
inline bool operator!=(const _Tp& __x, const _Tp& __y) {
return !(__x == __y);
}
*/
template <class _Tp>
inline bool
operator!=(const _Tp& __x, const _Tp& __y)
{ return !(__x == __y); }
/**
/**
* @brief Defines @c > for arbitrary types, in terms of @c <.
* @param x A thing.
* @param y Another thing.
* @return x > y
*
* This function uses @c < to determine its result.
*/
template <class _Tp>
inline bool operator>(const _Tp& __x, const _Tp& __y) {
return __y < __x;
}
*/
template <class _Tp>
inline bool
operator>(const _Tp& __x, const _Tp& __y)
{ return __y < __x; }
/**
/**
* @brief Defines @c <= for arbitrary types, in terms of @c <.
* @param x A thing.
* @param y Another thing.
* @return x <= y
*
* This function uses @c < to determine its result.
*/
template <class _Tp>
inline bool operator<=(const _Tp& __x, const _Tp& __y) {
return !(__y < __x);
}
*/
template <class _Tp>
inline bool
operator<=(const _Tp& __x, const _Tp& __y)
{ return !(__y < __x); }
/**
/**
* @brief Defines @c >= for arbitrary types, in terms of @c <.
* @param x A thing.
* @param y Another thing.
* @return x >= y
*
* This function uses @c < to determine its result.
*/
template <class _Tp>
inline bool operator>=(const _Tp& __x, const _Tp& __y) {
return !(__x < __y);
}
*/
template <class _Tp>
inline bool
operator>=(const _Tp& __x, const _Tp& __y)
{ return !(__x < __y); }
} // namespace rel_ops
} // namespace std
......
libstdc++-v3/include/bits/stl_set.h
......@@ -108,7 +108,8 @@ namespace __gnu_norm
{
// concept requirements
__glibcxx_class_requires(_Key, _SGIAssignableConcept)
__glibcxx_class_requires4(_Compare, bool, _Key, _Key, _BinaryFunctionConcept)
__glibcxx_class_requires4(_Compare, bool, _Key, _Key,
_BinaryFunctionConcept)
public:
// typedefs:
......@@ -142,7 +143,8 @@ namespace __gnu_norm
// allocation/deallocation
/// Default constructor creates no elements.
set() : _M_t(_Compare(), allocator_type()) {}
set()
: _M_t(_Compare(), allocator_type()) {}
/**
* @brief Default constructor creates no elements.
......@@ -180,7 +182,8 @@ namespace __gnu_norm
* otherwise (where N is distance(first,last)).
*/
template<class _InputIterator>
set(_InputIterator __first, _InputIterator __last, const _Compare& __comp,
set(_InputIterator __first, _InputIterator __last,
const _Compare& __comp,
const allocator_type& __a = allocator_type())
: _M_t(__comp, __a)
{ _M_t.insert_unique(__first, __last); }
......@@ -192,7 +195,8 @@ namespace __gnu_norm
* The newly-created %set uses a copy of the allocation object used
* by @a x.
*/
set(const set<_Key,_Compare,_Alloc>& __x) : _M_t(__x._M_t) {}
set(const set<_Key,_Compare,_Alloc>& __x)
: _M_t(__x._M_t) { }
/**
* @brief Set assignment operator.
......@@ -201,7 +205,8 @@ namespace __gnu_norm
* All the elements of @a x are copied, but unlike the copy constructor,
* the allocator object is not copied.
*/
set<_Key,_Compare,_Alloc>& operator=(const set<_Key, _Compare, _Alloc>& __x)
set<_Key,_Compare,_Alloc>&
operator=(const set<_Key, _Compare, _Alloc>& __x)
{
_M_t = __x._M_t;
return *this;
......@@ -210,45 +215,66 @@ namespace __gnu_norm
// accessors:
/// Returns the comparison object with which the %set was constructed.
key_compare key_comp() const { return _M_t.key_comp(); }
key_compare
key_comp() const
{ return _M_t.key_comp(); }
/// Returns the comparison object with which the %set was constructed.
value_compare value_comp() const { return _M_t.key_comp(); }
value_compare
value_comp() const
{ return _M_t.key_comp(); }
/// Returns the allocator object with which the %set was constructed.
allocator_type get_allocator() const { return _M_t.get_allocator(); }
allocator_type
get_allocator() const
{ return _M_t.get_allocator(); }
/**
* Returns a read/write iterator that points to the first element in the
* %set. Iteration is done in ascending order according to the keys.
*/
iterator begin() const { return _M_t.begin(); }
iterator
begin() const
{ return _M_t.begin(); }
/**
* Returns a read/write iterator that points one past the last element in
* the %set. Iteration is done in ascending order according to the keys.
*/
iterator end() const { return _M_t.end(); }
iterator
end() const
{ return _M_t.end(); }
/**
* Returns a read/write reverse iterator that points to the last element in
* the %set. Iteration is done in descending order according to the keys.
* Returns a read/write reverse iterator that points to the last element
* in the %set. Iteration is done in descending order according to the
* keys.
*/
reverse_iterator rbegin() const { return _M_t.rbegin(); }
reverse_iterator
rbegin() const
{ return _M_t.rbegin(); }
/**
* Returns a read-only (constant) reverse iterator that points to the last
* pair in the %map. Iteration is done in descending order according to
* the keys.
* Returns a read-only (constant) reverse iterator that points to the
* last pair in the %map. Iteration is done in descending order
* according to the keys.
*/
reverse_iterator rend() const { return _M_t.rend(); }
reverse_iterator
rend() const
{ return _M_t.rend(); }
/// Returns true if the %set is empty.
bool empty() const { return _M_t.empty(); }
bool
empty() const
{ return _M_t.empty(); }
/// Returns the size of the %set.
size_type size() const { return _M_t.size(); }
size_type
size() const
{ return _M_t.size(); }
/// Returns the maximum size of the %set.
size_type max_size() const { return _M_t.max_size(); }
size_type
max_size() const
{ return _M_t.max_size(); }
/**
* @brief Swaps data with another %set.
......@@ -261,15 +287,17 @@ namespace __gnu_norm
* Note that the global std::swap() function is specialized such that
* std::swap(s1,s2) will feed to this function.
*/
void swap(set<_Key,_Compare,_Alloc>& __x) { _M_t.swap(__x._M_t); }
void
swap(set<_Key,_Compare,_Alloc>& __x)
{ _M_t.swap(__x._M_t); }
// insert/erase
/**
* @brief Attempts to insert an element into the %set.
* @param x Element to be inserted.
* @return A pair, of which the first element is an iterator that points
* to the possibly inserted element, and the second is a bool that
* is true if the element was actually inserted.
* to the possibly inserted element, and the second is a bool
* that is true if the element was actually inserted.
*
* This function attempts to insert an element into the %set. A %set
* relies on unique keys and thus an element is only inserted if it is
......@@ -277,7 +305,8 @@ namespace __gnu_norm
*
* Insertion requires logarithmic time.
*/
pair<iterator,bool> insert(const value_type& __x)
pair<iterator,bool>
insert(const value_type& __x)
{
pair<typename _Rep_type::iterator, bool> __p = _M_t.insert_unique(__x);
return pair<iterator, bool>(__p.first, __p.second);
......@@ -302,7 +331,8 @@ namespace __gnu_norm
*
* Insertion requires logarithmic time (if the hint is not taken).
*/
iterator insert(iterator __position, const value_type& __x)
iterator
insert(iterator __position, const value_type& __x)
{
typedef typename _Rep_type::iterator _Rep_iterator;
return _M_t.insert_unique((_Rep_iterator&)__position, __x);
......@@ -317,7 +347,8 @@ namespace __gnu_norm
* Complexity similar to that of the range constructor.
*/
template<class _InputIterator>
void insert(_InputIterator __first, _InputIterator __last)
void
insert(_InputIterator __first, _InputIterator __last)
{ _M_t.insert_unique(__first, __last); }
/**
......@@ -329,7 +360,8 @@ namespace __gnu_norm
* that if the element is itself a pointer, the pointed-to memory is not
* touched in any way. Managing the pointer is the user's responsibilty.
*/
void erase(iterator __position)
void
erase(iterator __position)
{
typedef typename _Rep_type::iterator _Rep_iterator;
_M_t.erase((_Rep_iterator&)__position);
......@@ -346,11 +378,13 @@ namespace __gnu_norm
* the element is itself a pointer, the pointed-to memory is not touched
* in any way. Managing the pointer is the user's responsibilty.
*/
size_type erase(const key_type& __x) { return _M_t.erase(__x); }
size_type
erase(const key_type& __x) { return _M_t.erase(__x); }
/**
* @brief Erases a [first,last) range of elements from a %set.
* @param first Iterator pointing to the start of the range to be erased.
* @param first Iterator pointing to the start of the range to be
* erased.
* @param last Iterator pointing to the end of the range to be erased.
*
* This function erases a sequence of elements from a %set.
......@@ -358,7 +392,8 @@ namespace __gnu_norm
* the element is itself a pointer, the pointed-to memory is not touched
* in any way. Managing the pointer is the user's responsibilty.
*/
void erase(iterator __first, iterator __last)
void
erase(iterator __first, iterator __last)
{
typedef typename _Rep_type::iterator _Rep_iterator;
_M_t.erase((_Rep_iterator&)__first, (_Rep_iterator&)__last);
......@@ -370,7 +405,9 @@ namespace __gnu_norm
* pointed-to memory is not touched in any way. Managing the pointer is
* the user's responsibilty.
*/
void clear() { _M_t.clear(); }
void
clear()
{ _M_t.clear(); }
// set operations:
......@@ -382,7 +419,8 @@ namespace __gnu_norm
* This function only makes sense for multisets; for set the result will
* either be 0 (not present) or 1 (present).
*/
size_type count(const key_type& __x) const
size_type
count(const key_type& __x) const
{ return _M_t.find(__x) == _M_t.end() ? 0 : 1; }
// _GLIBCXX_RESOLVE_LIB_DEFECTS
......@@ -399,8 +437,13 @@ namespace __gnu_norm
* pointing to the sought after element. If unsuccessful it returns the
* past-the-end ( @c end() ) iterator.
*/
iterator find(const key_type& __x) { return _M_t.find(__x); }
const_iterator find(const key_type& __x) const { return _M_t.find(__x); }
iterator
find(const key_type& __x)
{ return _M_t.find(__x); }
const_iterator
find(const key_type& __x) const
{ return _M_t.find(__x); }
//@}
//@{
......@@ -415,9 +458,12 @@ namespace __gnu_norm
* pointing to the first element that has a greater value than given key
* or end() if no such element exists.
*/
iterator lower_bound(const key_type& __x)
iterator
lower_bound(const key_type& __x)
{ return _M_t.lower_bound(__x); }
const_iterator lower_bound(const key_type& __x) const
const_iterator
lower_bound(const key_type& __x) const
{ return _M_t.lower_bound(__x); }
//@}
......@@ -428,9 +474,12 @@ namespace __gnu_norm
* @return Iterator pointing to the first element
* greater than key, or end().
*/
iterator upper_bound(const key_type& __x)
iterator
upper_bound(const key_type& __x)
{ return _M_t.upper_bound(__x); }
const_iterator upper_bound(const key_type& __x) const
const_iterator
upper_bound(const key_type& __x) const
{ return _M_t.upper_bound(__x); }
//@}
......@@ -450,16 +499,22 @@ namespace __gnu_norm
*
* This function probably only makes sense for multisets.
*/
pair<iterator,iterator> equal_range(const key_type& __x)
pair<iterator,iterator>
equal_range(const key_type& __x)
{ return _M_t.equal_range(__x); }
pair<const_iterator,const_iterator> equal_range(const key_type& __x) const
pair<const_iterator,const_iterator>
equal_range(const key_type& __x) const
{ return _M_t.equal_range(__x); }
//@}
template<class _K1, class _C1, class _A1>
friend bool operator== (const set<_K1,_C1,_A1>&, const set<_K1,_C1,_A1>&);
friend bool
operator== (const set<_K1,_C1,_A1>&, const set<_K1,_C1,_A1>&);
template<class _K1, class _C1, class _A1>
friend bool operator< (const set<_K1,_C1,_A1>&, const set<_K1,_C1,_A1>&);
friend bool
operator< (const set<_K1,_C1,_A1>&, const set<_K1,_C1,_A1>&);
};
......@@ -510,7 +565,6 @@ namespace __gnu_norm
const set<_Key,_Compare,_Alloc>& __y)
{ return __y < __x; }
/// Returns !(y < x)
template<class _Key, class _Compare, class _Alloc>
inline bool
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment