* @p [first,last). @p f must not modify the order of the sequence.
* If @p f has a return value it is ignored.
*/
- template<typename _InputIter, typename _Function>
+ template<typename _InputIterator, typename _Function>
_Function
- for_each(_InputIter __first, _InputIter __last, _Function __f)
+ for_each(_InputIterator __first, _InputIterator __last, _Function __f)
{
// concept requirements
- __glibcpp_function_requires(_InputIteratorConcept<_InputIter>)
+ __glibcpp_function_requires(_InputIteratorConcept<_InputIterator>)
for ( ; __first != __last; ++__first)
__f(*__first);
return __f;
* This is an overload used by find() for the Input Iterator case.
* @endif
*/
- template<typename _InputIter, typename _Tp>
- inline _InputIter
- find(_InputIter __first, _InputIter __last,
+ template<typename _InputIterator, typename _Tp>
+ inline _InputIterator
+ find(_InputIterator __first, _InputIterator __last,
const _Tp& __val,
input_iterator_tag)
{
* This is an overload used by find_if() for the Input Iterator case.
* @endif
*/
- template<typename _InputIter, typename _Predicate>
- inline _InputIter
- find_if(_InputIter __first, _InputIter __last,
+ template<typename _InputIterator, typename _Predicate>
+ inline _InputIterator
+ find_if(_InputIterator __first, _InputIterator __last,
_Predicate __pred,
input_iterator_tag)
{
* This is an overload used by find() for the RAI case.
* @endif
*/
- template<typename _RandomAccessIter, typename _Tp>
- _RandomAccessIter
- find(_RandomAccessIter __first, _RandomAccessIter __last,
+ template<typename _RandomAccessIterator, typename _Tp>
+ _RandomAccessIterator
+ find(_RandomAccessIterator __first, _RandomAccessIterator __last,
const _Tp& __val,
random_access_iterator_tag)
{
- typename iterator_traits<_RandomAccessIter>::difference_type __trip_count
+ typename iterator_traits<_RandomAccessIterator>::difference_type __trip_count
= (__last - __first) >> 2;
for ( ; __trip_count > 0 ; --__trip_count) {
* This is an overload used by find_if() for the RAI case.
* @endif
*/
- template<typename _RandomAccessIter, typename _Predicate>
- _RandomAccessIter
- find_if(_RandomAccessIter __first, _RandomAccessIter __last,
+ template<typename _RandomAccessIterator, typename _Predicate>
+ _RandomAccessIterator
+ find_if(_RandomAccessIterator __first, _RandomAccessIterator __last,
_Predicate __pred,
random_access_iterator_tag)
{
- typename iterator_traits<_RandomAccessIter>::difference_type __trip_count
+ typename iterator_traits<_RandomAccessIterator>::difference_type __trip_count
= (__last - __first) >> 2;
for ( ; __trip_count > 0 ; --__trip_count) {
* @return The first iterator @c i in the range @p [first,last)
* such that @c *i == @p val, or @p last if no such iterator exists.
*/
- template<typename _InputIter, typename _Tp>
- inline _InputIter
- find(_InputIter __first, _InputIter __last,
+ template<typename _InputIterator, typename _Tp>
+ inline _InputIterator
+ find(_InputIterator __first, _InputIterator __last,
const _Tp& __val)
{
// concept requirements
- __glibcpp_function_requires(_InputIteratorConcept<_InputIter>)
+ __glibcpp_function_requires(_InputIteratorConcept<_InputIterator>)
__glibcpp_function_requires(_EqualOpConcept<
- typename iterator_traits<_InputIter>::value_type, _Tp>)
+ typename iterator_traits<_InputIterator>::value_type, _Tp>)
return find(__first, __last, __val, __iterator_category(__first));
}
* @return The first iterator @c i in the range @p [first,last)
* such that @p pred(*i) is true, or @p last if no such iterator exists.
*/
- template<typename _InputIter, typename _Predicate>
- inline _InputIter
- find_if(_InputIter __first, _InputIter __last,
+ template<typename _InputIterator, typename _Predicate>
+ inline _InputIterator
+ find_if(_InputIterator __first, _InputIterator __last,
_Predicate __pred)
{
// concept requirements
- __glibcpp_function_requires(_InputIteratorConcept<_InputIter>)
+ __glibcpp_function_requires(_InputIteratorConcept<_InputIterator>)
__glibcpp_function_requires(_UnaryPredicateConcept<_Predicate,
- typename iterator_traits<_InputIter>::value_type>)
+ typename iterator_traits<_InputIterator>::value_type>)
return find_if(__first, __last, __pred, __iterator_category(__first));
}
* valid iterators in @p [first,last) and such that @c *i == @c *(i+1),
* or @p last if no such iterator exists.
*/
- template<typename _ForwardIter>
- _ForwardIter
- adjacent_find(_ForwardIter __first, _ForwardIter __last)
+ template<typename _ForwardIterator>
+ _ForwardIterator
+ adjacent_find(_ForwardIterator __first, _ForwardIterator __last)
{
// concept requirements
- __glibcpp_function_requires(_ForwardIteratorConcept<_ForwardIter>)
+ __glibcpp_function_requires(_ForwardIteratorConcept<_ForwardIterator>)
__glibcpp_function_requires(_EqualityComparableConcept<
- typename iterator_traits<_ForwardIter>::value_type>)
+ typename iterator_traits<_ForwardIterator>::value_type>)
if (__first == __last)
return __last;
- _ForwardIter __next = __first;
+ _ForwardIterator __next = __first;
while(++__next != __last) {
if (*__first == *__next)
return __first;
* @p binary_pred(*i,*(i+1)) is true, or @p last if no such iterator
* exists.
*/
- template<typename _ForwardIter, typename _BinaryPredicate>
- _ForwardIter
- adjacent_find(_ForwardIter __first, _ForwardIter __last,
+ template<typename _ForwardIterator, typename _BinaryPredicate>
+ _ForwardIterator
+ adjacent_find(_ForwardIterator __first, _ForwardIterator __last,
_BinaryPredicate __binary_pred)
{
// concept requirements
- __glibcpp_function_requires(_ForwardIteratorConcept<_ForwardIter>)
+ __glibcpp_function_requires(_ForwardIteratorConcept<_ForwardIterator>)
__glibcpp_function_requires(_BinaryPredicateConcept<_BinaryPredicate,
- typename iterator_traits<_ForwardIter>::value_type,
- typename iterator_traits<_ForwardIter>::value_type>)
+ typename iterator_traits<_ForwardIterator>::value_type,
+ typename iterator_traits<_ForwardIterator>::value_type>)
if (__first == __last)
return __last;
- _ForwardIter __next = __first;
+ _ForwardIterator __next = __first;
while(++__next != __last) {
if (__binary_pred(*__first, *__next))
return __first;
* @return The number of iterators @c i in the range @p [first,last)
* for which @c *i == @p value
*/
- template<typename _InputIter, typename _Tp>
- typename iterator_traits<_InputIter>::difference_type
- count(_InputIter __first, _InputIter __last, const _Tp& __value)
+ template<typename _InputIterator, typename _Tp>
+ typename iterator_traits<_InputIterator>::difference_type
+ count(_InputIterator __first, _InputIterator __last, const _Tp& __value)
{
// concept requirements
- __glibcpp_function_requires(_InputIteratorConcept<_InputIter>)
+ __glibcpp_function_requires(_InputIteratorConcept<_InputIterator>)
__glibcpp_function_requires(_EqualityComparableConcept<
- typename iterator_traits<_InputIter>::value_type >)
+ typename iterator_traits<_InputIterator>::value_type >)
__glibcpp_function_requires(_EqualityComparableConcept<_Tp>)
- typename iterator_traits<_InputIter>::difference_type __n = 0;
+ typename iterator_traits<_InputIterator>::difference_type __n = 0;
for ( ; __first != __last; ++__first)
if (*__first == __value)
++__n;
* @return The number of iterators @c i in the range @p [first,last)
* for which @p pred(*i) is true.
*/
- template<typename _InputIter, typename _Predicate>
- typename iterator_traits<_InputIter>::difference_type
- count_if(_InputIter __first, _InputIter __last, _Predicate __pred)
+ template<typename _InputIterator, typename _Predicate>
+ typename iterator_traits<_InputIterator>::difference_type
+ count_if(_InputIterator __first, _InputIterator __last, _Predicate __pred)
{
// concept requirements
- __glibcpp_function_requires(_InputIteratorConcept<_InputIter>)
+ __glibcpp_function_requires(_InputIteratorConcept<_InputIterator>)
__glibcpp_function_requires(_UnaryPredicateConcept<_Predicate,
- typename iterator_traits<_InputIter>::value_type>)
- typename iterator_traits<_InputIter>::difference_type __n = 0;
+ typename iterator_traits<_InputIterator>::value_type>)
+ typename iterator_traits<_InputIterator>::difference_type __n = 0;
for ( ; __first != __last; ++__first)
if (__pred(*__first))
++__n;
* This means that the returned iterator @c i will be in the range
* @p [first1,last1-(last2-first2))
*/
- template<typename _ForwardIter1, typename _ForwardIter2>
- _ForwardIter1
- search(_ForwardIter1 __first1, _ForwardIter1 __last1,
- _ForwardIter2 __first2, _ForwardIter2 __last2)
+ template<typename _ForwardIterator1, typename _ForwardIterator2>
+ _ForwardIterator1
+ search(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
+ _ForwardIterator2 __first2, _ForwardIterator2 __last2)
{
// concept requirements
- __glibcpp_function_requires(_ForwardIteratorConcept<_ForwardIter1>)
- __glibcpp_function_requires(_ForwardIteratorConcept<_ForwardIter2>)
+ __glibcpp_function_requires(_ForwardIteratorConcept<_ForwardIterator1>)
+ __glibcpp_function_requires(_ForwardIteratorConcept<_ForwardIterator2>)
__glibcpp_function_requires(_EqualOpConcept<
- typename iterator_traits<_ForwardIter1>::value_type,
- typename iterator_traits<_ForwardIter2>::value_type>)
+ typename iterator_traits<_ForwardIterator1>::value_type,
+ typename iterator_traits<_ForwardIterator2>::value_type>)
// Test for empty ranges
if (__first1 == __last1 || __first2 == __last2)
return __first1;
// Test for a pattern of length 1.
- _ForwardIter2 __tmp(__first2);
+ _ForwardIterator2 __tmp(__first2);
++__tmp;
if (__tmp == __last2)
return find(__first1, __last1, *__first2);
// General case.
- _ForwardIter2 __p1, __p;
+ _ForwardIterator2 __p1, __p;
__p1 = __first2; ++__p1;
- _ForwardIter1 __current = __first1;
+ _ForwardIterator1 __current = __first1;
while (__first1 != __last1) {
__first1 = find(__first1, __last1, *__first2);
*
* @see search(_ForwardIter1, _ForwardIter1, _ForwardIter2, _ForwardIter2)
*/
- template<typename _ForwardIter1, typename _ForwardIter2, typename _BinaryPred>
- _ForwardIter1
- search(_ForwardIter1 __first1, _ForwardIter1 __last1,
- _ForwardIter2 __first2, _ForwardIter2 __last2,
- _BinaryPred __predicate)
+ template<typename _ForwardIterator1, typename _ForwardIterator2, typename _BinaryPredicate>
+ _ForwardIterator1
+ search(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
+ _ForwardIterator2 __first2, _ForwardIterator2 __last2,
+ _BinaryPredicate __predicate)
{
// concept requirements
- __glibcpp_function_requires(_ForwardIteratorConcept<_ForwardIter1>)
- __glibcpp_function_requires(_ForwardIteratorConcept<_ForwardIter2>)
- __glibcpp_function_requires(_BinaryPredicateConcept<_BinaryPred,
- typename iterator_traits<_ForwardIter1>::value_type,
- typename iterator_traits<_ForwardIter2>::value_type>)
+ __glibcpp_function_requires(_ForwardIteratorConcept<_ForwardIterator1>)
+ __glibcpp_function_requires(_ForwardIteratorConcept<_ForwardIterator2>)
+ __glibcpp_function_requires(_BinaryPredicateConcept<_BinaryPredicate,
+ typename iterator_traits<_ForwardIterator1>::value_type,
+ typename iterator_traits<_ForwardIterator2>::value_type>)
// Test for empty ranges
if (__first1 == __last1 || __first2 == __last2)
return __first1;
// Test for a pattern of length 1.
- _ForwardIter2 __tmp(__first2);
+ _ForwardIterator2 __tmp(__first2);
++__tmp;
if (__tmp == __last2) {
while (__first1 != __last1 && !__predicate(*__first1, *__first2))
// General case.
- _ForwardIter2 __p1, __p;
+ _ForwardIterator2 __p1, __p;
__p1 = __first2; ++__p1;
- _ForwardIter1 __current = __first1;
+ _ForwardIterator1 __current = __first1;
while (__first1 != __last1) {
while (__first1 != __last1) {
* Searches the range @p [first,last) for @p count consecutive elements
* equal to @p val.
*/
- template<typename _ForwardIter, typename _Integer, typename _Tp>
- _ForwardIter
- search_n(_ForwardIter __first, _ForwardIter __last,
+ template<typename _ForwardIterator, typename _Integer, typename _Tp>
+ _ForwardIterator
+ search_n(_ForwardIterator __first, _ForwardIterator __last,
_Integer __count, const _Tp& __val)
{
// concept requirements
- __glibcpp_function_requires(_ForwardIteratorConcept<_ForwardIter>)
+ __glibcpp_function_requires(_ForwardIteratorConcept<_ForwardIterator>)
__glibcpp_function_requires(_EqualityComparableConcept<
- typename iterator_traits<_ForwardIter>::value_type>)
+ typename iterator_traits<_ForwardIterator>::value_type>)
__glibcpp_function_requires(_EqualityComparableConcept<_Tp>)
if (__count <= 0)
__first = find(__first, __last, __val);
while (__first != __last) {
_Integer __n = __count - 1;
- _ForwardIter __i = __first;
+ _ForwardIterator __i = __first;
++__i;
while (__i != __last && __n != 0 && *__i == __val) {
++__i;
* Searches the range @p [first,last) for @p count consecutive elements
* for which the predicate returns true.
*/
- template<typename _ForwardIter, typename _Integer, typename _Tp,
- typename _BinaryPred>
- _ForwardIter
- search_n(_ForwardIter __first, _ForwardIter __last,
+ template<typename _ForwardIterator, typename _Integer, typename _Tp,
+ typename _BinaryPredicate>
+ _ForwardIterator
+ search_n(_ForwardIterator __first, _ForwardIterator __last,
_Integer __count, const _Tp& __val,
- _BinaryPred __binary_pred)
+ _BinaryPredicate __binary_pred)
{
// concept requirements
- __glibcpp_function_requires(_ForwardIteratorConcept<_ForwardIter>)
- __glibcpp_function_requires(_BinaryPredicateConcept<_BinaryPred,
- typename iterator_traits<_ForwardIter>::value_type, _Tp>)
+ __glibcpp_function_requires(_ForwardIteratorConcept<_ForwardIterator>)
+ __glibcpp_function_requires(_BinaryPredicateConcept<_BinaryPredicate,
+ typename iterator_traits<_ForwardIterator>::value_type, _Tp>)
if (__count <= 0)
return __first;
}
while (__first != __last) {
_Integer __n = __count - 1;
- _ForwardIter __i = __first;
+ _ForwardIterator __i = __first;
++__i;
while (__i != __last && __n != 0 && __binary_pred(*__i, __val)) {
++__i;
* corresponding element in the range @p [first2,(last1-first1)).
* The ranges must not overlap.
*/
- template<typename _ForwardIter1, typename _ForwardIter2>
- _ForwardIter2
- swap_ranges(_ForwardIter1 __first1, _ForwardIter1 __last1,
- _ForwardIter2 __first2)
+ template<typename _ForwardIterator1, typename _ForwardIterator2>
+ _ForwardIterator2
+ swap_ranges(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
+ _ForwardIterator2 __first2)
{
// concept requirements
- __glibcpp_function_requires(_Mutable_ForwardIteratorConcept<_ForwardIter1>)
- __glibcpp_function_requires(_Mutable_ForwardIteratorConcept<_ForwardIter2>)
+ __glibcpp_function_requires(_Mutable_ForwardIteratorConcept<_ForwardIterator1>)
+ __glibcpp_function_requires(_Mutable_ForwardIteratorConcept<_ForwardIterator2>)
__glibcpp_function_requires(_ConvertibleConcept<
- typename iterator_traits<_ForwardIter1>::value_type,
- typename iterator_traits<_ForwardIter2>::value_type>)
+ typename iterator_traits<_ForwardIterator1>::value_type,
+ typename iterator_traits<_ForwardIterator2>::value_type>)
__glibcpp_function_requires(_ConvertibleConcept<
- typename iterator_traits<_ForwardIter2>::value_type,
- typename iterator_traits<_ForwardIter1>::value_type>)
+ typename iterator_traits<_ForwardIterator2>::value_type,
+ typename iterator_traits<_ForwardIterator1>::value_type>)
for ( ; __first1 != __last1; ++__first1, ++__first2)
iter_swap(__first1, __first2);
*
* @p unary_op must not alter its argument.
*/
- template<typename _InputIter, typename _OutputIter, typename _UnaryOperation>
- _OutputIter
- transform(_InputIter __first, _InputIter __last,
- _OutputIter __result, _UnaryOperation __unary_op)
+ template<typename _InputIterator, typename _OutputIterator, typename _UnaryOperation>
+ _OutputIterator
+ transform(_InputIterator __first, _InputIterator __last,
+ _OutputIterator __result, _UnaryOperation __unary_op)
{
// concept requirements
- __glibcpp_function_requires(_InputIteratorConcept<_InputIter>)
- __glibcpp_function_requires(_OutputIteratorConcept<_OutputIter,
+ __glibcpp_function_requires(_InputIteratorConcept<_InputIterator>)
+ __glibcpp_function_requires(_OutputIteratorConcept<_OutputIterator,
// "the type returned by a _UnaryOperation"
__typeof__(__unary_op(*__first))>)
*
* @p binary_op must not alter either of its arguments.
*/
- template<typename _InputIter1, typename _InputIter2, typename _OutputIter,
+ template<typename _InputIterator1, typename _InputIterator2, typename _OutputIterator,
typename _BinaryOperation>
- _OutputIter
- transform(_InputIter1 __first1, _InputIter1 __last1,
- _InputIter2 __first2, _OutputIter __result,
+ _OutputIterator
+ transform(_InputIterator1 __first1, _InputIterator1 __last1,
+ _InputIterator2 __first2, _OutputIterator __result,
_BinaryOperation __binary_op)
{
// concept requirements
- __glibcpp_function_requires(_InputIteratorConcept<_InputIter1>)
- __glibcpp_function_requires(_InputIteratorConcept<_InputIter2>)
- __glibcpp_function_requires(_OutputIteratorConcept<_OutputIter,
+ __glibcpp_function_requires(_InputIteratorConcept<_InputIterator1>)
+ __glibcpp_function_requires(_InputIteratorConcept<_InputIterator2>)
+ __glibcpp_function_requires(_OutputIteratorConcept<_OutputIterator,
// "the type returned by a _BinaryOperation"
__typeof__(__binary_op(*__first1,*__first2))>)
* For each iterator @c i in the range @p [first,last) if @c *i ==
* @p old_value then the assignment @c *i = @p new_value is performed.
*/
- template<typename _ForwardIter, typename _Tp>
+ template<typename _ForwardIterator, typename _Tp>
void
- replace(_ForwardIter __first, _ForwardIter __last,
+ replace(_ForwardIterator __first, _ForwardIterator __last,
const _Tp& __old_value, const _Tp& __new_value)
{
// concept requirements
- __glibcpp_function_requires(_Mutable_ForwardIteratorConcept<_ForwardIter>)
+ __glibcpp_function_requires(_Mutable_ForwardIteratorConcept<_ForwardIterator>)
__glibcpp_function_requires(_EqualOpConcept<
- typename iterator_traits<_ForwardIter>::value_type, _Tp>)
+ typename iterator_traits<_ForwardIterator>::value_type, _Tp>)
__glibcpp_function_requires(_ConvertibleConcept<_Tp,
- typename iterator_traits<_ForwardIter>::value_type>)
+ typename iterator_traits<_ForwardIterator>::value_type>)
for ( ; __first != __last; ++__first)
if (*__first == __old_value)
* For each iterator @c i in the range @p [first,last) if @p pred(*i)
* is true then the assignment @c *i = @p new_value is performed.
*/
- template<typename _ForwardIter, typename _Predicate, typename _Tp>
+ template<typename _ForwardIterator, typename _Predicate, typename _Tp>
void
- replace_if(_ForwardIter __first, _ForwardIter __last,
+ replace_if(_ForwardIterator __first, _ForwardIterator __last,
_Predicate __pred, const _Tp& __new_value)
{
// concept requirements
- __glibcpp_function_requires(_Mutable_ForwardIteratorConcept<_ForwardIter>)
+ __glibcpp_function_requires(_Mutable_ForwardIteratorConcept<_ForwardIterator>)
__glibcpp_function_requires(_ConvertibleConcept<_Tp,
- typename iterator_traits<_ForwardIter>::value_type>)
+ typename iterator_traits<_ForwardIterator>::value_type>)
__glibcpp_function_requires(_UnaryPredicateConcept<_Predicate,
- typename iterator_traits<_ForwardIter>::value_type>)
+ typename iterator_traits<_ForwardIterator>::value_type>)
for ( ; __first != __last; ++__first)
if (__pred(*__first))
* output range @p [result,result+(last-first)) replacing elements
* equal to @p old_value with @p new_value.
*/
- template<typename _InputIter, typename _OutputIter, typename _Tp>
- _OutputIter
- replace_copy(_InputIter __first, _InputIter __last,
- _OutputIter __result,
+ template<typename _InputIterator, typename _OutputIterator, typename _Tp>
+ _OutputIterator
+ replace_copy(_InputIterator __first, _InputIterator __last,
+ _OutputIterator __result,
const _Tp& __old_value, const _Tp& __new_value)
{
// concept requirements
- __glibcpp_function_requires(_InputIteratorConcept<_InputIter>)
- __glibcpp_function_requires(_OutputIteratorConcept<_OutputIter,
- typename iterator_traits<_InputIter>::value_type>)
+ __glibcpp_function_requires(_InputIteratorConcept<_InputIterator>)
+ __glibcpp_function_requires(_OutputIteratorConcept<_OutputIterator,
+ typename iterator_traits<_InputIterator>::value_type>)
__glibcpp_function_requires(_EqualOpConcept<
- typename iterator_traits<_InputIter>::value_type, _Tp>)
+ typename iterator_traits<_InputIterator>::value_type, _Tp>)
for ( ; __first != __last; ++__first, ++__result)
*__result = *__first == __old_value ? __new_value : *__first;
* @p [result,result+(last-first)) replacing elements for which
* @p pred returns true with @p new_value.
*/
- template<typename _InputIter, typename _OutputIter, typename _Predicate,
+ template<typename _InputIterator, typename _OutputIterator, typename _Predicate,
typename _Tp>
- _OutputIter
- replace_copy_if(_InputIter __first, _InputIter __last,
- _OutputIter __result,
+ _OutputIterator
+ replace_copy_if(_InputIterator __first, _InputIterator __last,
+ _OutputIterator __result,
_Predicate __pred, const _Tp& __new_value)
{
// concept requirements
- __glibcpp_function_requires(_InputIteratorConcept<_InputIter>)
- __glibcpp_function_requires(_OutputIteratorConcept<_OutputIter,
- typename iterator_traits<_InputIter>::value_type>)
+ __glibcpp_function_requires(_InputIteratorConcept<_InputIterator>)
+ __glibcpp_function_requires(_OutputIteratorConcept<_OutputIterator,
+ typename iterator_traits<_InputIterator>::value_type>)
__glibcpp_function_requires(_UnaryPredicateConcept<_Predicate,
- typename iterator_traits<_InputIter>::value_type>)
+ typename iterator_traits<_InputIterator>::value_type>)
for ( ; __first != __last; ++__first, ++__result)
*__result = __pred(*__first) ? __new_value : *__first;
* Performs the assignment @c *i = @p gen() for each @c i in the range
* @p [first,last).
*/
- template<typename _ForwardIter, typename _Generator>
+ template<typename _ForwardIterator, typename _Generator>
void
- generate(_ForwardIter __first, _ForwardIter __last, _Generator __gen)
+ generate(_ForwardIterator __first, _ForwardIterator __last, _Generator __gen)
{
// concept requirements
- __glibcpp_function_requires(_ForwardIteratorConcept<_ForwardIter>)
+ __glibcpp_function_requires(_ForwardIteratorConcept<_ForwardIterator>)
__glibcpp_function_requires(_GeneratorConcept<_Generator,
- typename iterator_traits<_ForwardIter>::value_type>)
+ typename iterator_traits<_ForwardIterator>::value_type>)
for ( ; __first != __last; ++__first)
*__first = __gen();
* Performs the assignment @c *i = @p gen() for each @c i in the range
* @p [first,first+n).
*/
- template<typename _OutputIter, typename _Size, typename _Generator>
- _OutputIter
- generate_n(_OutputIter __first, _Size __n, _Generator __gen)
+ template<typename _OutputIterator, typename _Size, typename _Generator>
+ _OutputIterator
+ generate_n(_OutputIterator __first, _Size __n, _Generator __gen)
{
// concept requirements
- __glibcpp_function_requires(_OutputIteratorConcept<_OutputIter,
+ __glibcpp_function_requires(_OutputIteratorConcept<_OutputIterator,
// "the type returned by a _Generator"
__typeof__(gen())>)
* remove_copy() is stable, so the relative order of elements that are
* copied is unchanged.
*/
- template<typename _InputIter, typename _OutputIter, typename _Tp>
- _OutputIter
- remove_copy(_InputIter __first, _InputIter __last,
- _OutputIter __result, const _Tp& __value)
+ template<typename _InputIterator, typename _OutputIterator, typename _Tp>
+ _OutputIterator
+ remove_copy(_InputIterator __first, _InputIterator __last,
+ _OutputIterator __result, const _Tp& __value)
{
// concept requirements
- __glibcpp_function_requires(_InputIteratorConcept<_InputIter>)
- __glibcpp_function_requires(_OutputIteratorConcept<_OutputIter,
- typename iterator_traits<_InputIter>::value_type>)
+ __glibcpp_function_requires(_InputIteratorConcept<_InputIterator>)
+ __glibcpp_function_requires(_OutputIteratorConcept<_OutputIterator,
+ typename iterator_traits<_InputIterator>::value_type>)
__glibcpp_function_requires(_EqualOpConcept<
- typename iterator_traits<_InputIter>::value_type, _Tp>)
+ typename iterator_traits<_InputIterator>::value_type, _Tp>)
for ( ; __first != __last; ++__first)
if (!(*__first == __value)) {
* remove_copy_if() is stable, so the relative order of elements that are
* copied is unchanged.
*/
- template<typename _InputIter, typename _OutputIter, typename _Predicate>
- _OutputIter
- remove_copy_if(_InputIter __first, _InputIter __last,
- _OutputIter __result, _Predicate __pred)
+ template<typename _InputIterator, typename _OutputIterator, typename _Predicate>
+ _OutputIterator
+ remove_copy_if(_InputIterator __first, _InputIterator __last,
+ _OutputIterator __result, _Predicate __pred)
{
// concept requirements
- __glibcpp_function_requires(_InputIteratorConcept<_InputIter>)
- __glibcpp_function_requires(_OutputIteratorConcept<_OutputIter,
- typename iterator_traits<_InputIter>::value_type>)
+ __glibcpp_function_requires(_InputIteratorConcept<_InputIterator>)
+ __glibcpp_function_requires(_OutputIteratorConcept<_OutputIterator,
+ typename iterator_traits<_InputIterator>::value_type>)
__glibcpp_function_requires(_UnaryPredicateConcept<_Predicate,
- typename iterator_traits<_InputIter>::value_type>)
+ typename iterator_traits<_InputIterator>::value_type>)
for ( ; __first != __last; ++__first)
if (!__pred(*__first)) {
* Elements between the end of the resulting sequence and @p last
* are still present, but their value is unspecified.
*/
- template<typename _ForwardIter, typename _Tp>
- _ForwardIter
- remove(_ForwardIter __first, _ForwardIter __last,
+ template<typename _ForwardIterator, typename _Tp>
+ _ForwardIterator
+ remove(_ForwardIterator __first, _ForwardIterator __last,
const _Tp& __value)
{
// concept requirements
- __glibcpp_function_requires(_Mutable_ForwardIteratorConcept<_ForwardIter>)
+ __glibcpp_function_requires(_Mutable_ForwardIteratorConcept<_ForwardIterator>)
__glibcpp_function_requires(_ConvertibleConcept<_Tp,
- typename iterator_traits<_ForwardIter>::value_type>)
+ typename iterator_traits<_ForwardIterator>::value_type>)
__glibcpp_function_requires(_EqualOpConcept<
- typename iterator_traits<_ForwardIter>::value_type, _Tp>)
+ typename iterator_traits<_ForwardIterator>::value_type, _Tp>)
__first = find(__first, __last, __value);
- _ForwardIter __i = __first;
+ _ForwardIterator __i = __first;
return __first == __last ? __first
: remove_copy(++__i, __last, __first, __value);
}
* Elements between the end of the resulting sequence and @p last
* are still present, but their value is unspecified.
*/
- template<typename _ForwardIter, typename _Predicate>
- _ForwardIter
- remove_if(_ForwardIter __first, _ForwardIter __last,
+ template<typename _ForwardIterator, typename _Predicate>
+ _ForwardIterator
+ remove_if(_ForwardIterator __first, _ForwardIterator __last,
_Predicate __pred)
{
// concept requirements
- __glibcpp_function_requires(_Mutable_ForwardIteratorConcept<_ForwardIter>)
+ __glibcpp_function_requires(_Mutable_ForwardIteratorConcept<_ForwardIterator>)
__glibcpp_function_requires(_UnaryPredicateConcept<_Predicate,
- typename iterator_traits<_ForwardIter>::value_type>)
+ typename iterator_traits<_ForwardIterator>::value_type>)
__first = find_if(__first, __last, __pred);
- _ForwardIter __i = __first;
+ _ForwardIterator __i = __first;
return __first == __last ? __first
: remove_copy_if(++__i, __last, __first, __pred);
}
/**
* @if maint
- * This is an uglified unique_copy(_InputIter, _InputIter, _OutputIter)
+ * This is an uglified unique_copy(_InputIterator, _InputIterator, _OutputIterator)
* overloaded for output iterators.
* @endif
*/
- template<typename _InputIter, typename _OutputIter>
- _OutputIter
- __unique_copy(_InputIter __first, _InputIter __last,
- _OutputIter __result,
+ template<typename _InputIterator, typename _OutputIterator>
+ _OutputIterator
+ __unique_copy(_InputIterator __first, _InputIterator __last,
+ _OutputIterator __result,
output_iterator_tag)
{
// concept requirements -- taken care of in dispatching function
- typename iterator_traits<_InputIter>::value_type __value = *__first;
+ typename iterator_traits<_InputIterator>::value_type __value = *__first;
*__result = __value;
while (++__first != __last)
if (!(__value == *__first)) {
/**
* @if maint
- * This is an uglified unique_copy(_InputIter, _InputIter, _OutputIter)
+ * This is an uglified unique_copy(_InputIterator, _InputIterator, _OutputIterator)
* overloaded for forward iterators.
* @endif
*/
- template<typename _InputIter, typename _ForwardIter>
- _ForwardIter
- __unique_copy(_InputIter __first, _InputIter __last,
- _ForwardIter __result,
+ template<typename _InputIterator, typename _ForwardIterator>
+ _ForwardIterator
+ __unique_copy(_InputIterator __first, _InputIterator __last,
+ _ForwardIterator __result,
forward_iterator_tag)
{
// concept requirements -- taken care of in dispatching function
* unique_copy() is stable, so the relative order of elements that are
* copied is unchanged.
*/
- template<typename _InputIter, typename _OutputIter>
- inline _OutputIter
- unique_copy(_InputIter __first, _InputIter __last,
- _OutputIter __result)
+ template<typename _InputIterator, typename _OutputIterator>
+ inline _OutputIterator
+ unique_copy(_InputIterator __first, _InputIterator __last,
+ _OutputIterator __result)
{
// concept requirements
- __glibcpp_function_requires(_InputIteratorConcept<_InputIter>)
- __glibcpp_function_requires(_OutputIteratorConcept<_OutputIter,
- typename iterator_traits<_InputIter>::value_type>)
+ __glibcpp_function_requires(_InputIteratorConcept<_InputIterator>)
+ __glibcpp_function_requires(_OutputIteratorConcept<_OutputIterator,
+ typename iterator_traits<_InputIterator>::value_type>)
__glibcpp_function_requires(_EqualityComparableConcept<
- typename iterator_traits<_InputIter>::value_type>)
+ typename iterator_traits<_InputIterator>::value_type>)
- typedef typename iterator_traits<_OutputIter>::iterator_category _IterType;
+ typedef typename iterator_traits<_OutputIterator>::iterator_category _IterType;
if (__first == __last) return __result;
return __unique_copy(__first, __last, __result, _IterType());
/**
* @if maint
* This is an uglified
- * unique_copy(_InputIter, _InputIter, _OutputIter, _BinaryPredicate)
+ * unique_copy(_InputIterator, _InputIterator, _OutputIterator, _BinaryPredicate)
* overloaded for output iterators.
* @endif
*/
- template<typename _InputIter, typename _OutputIter, typename _BinaryPredicate>
- _OutputIter
- __unique_copy(_InputIter __first, _InputIter __last,
- _OutputIter __result,
+ template<typename _InputIterator, typename _OutputIterator, typename _BinaryPredicate>
+ _OutputIterator
+ __unique_copy(_InputIterator __first, _InputIterator __last,
+ _OutputIterator __result,
_BinaryPredicate __binary_pred,
output_iterator_tag)
{
// concept requirements -- iterators already checked
__glibcpp_function_requires(_BinaryPredicateConcept<_BinaryPredicate,
- typename iterator_traits<_InputIter>::value_type,
- typename iterator_traits<_InputIter>::value_type>)
+ typename iterator_traits<_InputIterator>::value_type,
+ typename iterator_traits<_InputIterator>::value_type>)
- typename iterator_traits<_InputIter>::value_type __value = *__first;
+ typename iterator_traits<_InputIterator>::value_type __value = *__first;
*__result = __value;
while (++__first != __last)
if (!__binary_pred(__value, *__first)) {
/**
* @if maint
* This is an uglified
- * unique_copy(_InputIter, _InputIter, _OutputIter, _BinaryPredicate)
+ * unique_copy(_InputIterator, _InputIterator, _OutputIterator, _BinaryPredicate)
* overloaded for forward iterators.
* @endif
*/
- template<typename _InputIter, typename _ForwardIter, typename _BinaryPredicate>
- _ForwardIter
- __unique_copy(_InputIter __first, _InputIter __last,
- _ForwardIter __result,
+ template<typename _InputIterator, typename _ForwardIterator, typename _BinaryPredicate>
+ _ForwardIterator
+ __unique_copy(_InputIterator __first, _InputIterator __last,
+ _ForwardIterator __result,
_BinaryPredicate __binary_pred,
forward_iterator_tag)
{
// concept requirements -- iterators already checked
__glibcpp_function_requires(_BinaryPredicateConcept<_BinaryPredicate,
- typename iterator_traits<_ForwardIter>::value_type,
- typename iterator_traits<_InputIter>::value_type>)
+ typename iterator_traits<_ForwardIterator>::value_type,
+ typename iterator_traits<_InputIterator>::value_type>)
*__result = *__first;
while (++__first != __last)
* unique_copy() is stable, so the relative order of elements that are
* copied is unchanged.
*/
- template<typename _InputIter, typename _OutputIter, typename _BinaryPredicate>
- inline _OutputIter
- unique_copy(_InputIter __first, _InputIter __last,
- _OutputIter __result,
+ template<typename _InputIterator, typename _OutputIterator, typename _BinaryPredicate>
+ inline _OutputIterator
+ unique_copy(_InputIterator __first, _InputIterator __last,
+ _OutputIterator __result,
_BinaryPredicate __binary_pred)
{
// concept requirements -- predicates checked later
- __glibcpp_function_requires(_InputIteratorConcept<_InputIter>)
- __glibcpp_function_requires(_OutputIteratorConcept<_OutputIter,
- typename iterator_traits<_InputIter>::value_type>)
+ __glibcpp_function_requires(_InputIteratorConcept<_InputIterator>)
+ __glibcpp_function_requires(_OutputIteratorConcept<_OutputIterator,
+ typename iterator_traits<_InputIterator>::value_type>)
- typedef typename iterator_traits<_OutputIter>::iterator_category _IterType;
+ typedef typename iterator_traits<_OutputIterator>::iterator_category _IterType;
if (__first == __last) return __result;
return __unique_copy(__first, __last,
* Elements between the end of the resulting sequence and @p last
* are still present, but their value is unspecified.
*/
- template<typename _ForwardIter>
- _ForwardIter
- unique(_ForwardIter __first, _ForwardIter __last)
+ template<typename _ForwardIterator>
+ _ForwardIterator
+ unique(_ForwardIterator __first, _ForwardIterator __last)
{
// concept requirements
- __glibcpp_function_requires(_Mutable_ForwardIteratorConcept<_ForwardIter>)
+ __glibcpp_function_requires(_Mutable_ForwardIteratorConcept<_ForwardIterator>)
__glibcpp_function_requires(_EqualityComparableConcept<
- typename iterator_traits<_ForwardIter>::value_type>)
+ typename iterator_traits<_ForwardIterator>::value_type>)
__first = adjacent_find(__first, __last);
return unique_copy(__first, __last, __first);
* Elements between the end of the resulting sequence and @p last
* are still present, but their value is unspecified.
*/
- template<typename _ForwardIter, typename _BinaryPredicate>
- _ForwardIter
- unique(_ForwardIter __first, _ForwardIter __last,
+ template<typename _ForwardIterator, typename _BinaryPredicate>
+ _ForwardIterator
+ unique(_ForwardIterator __first, _ForwardIterator __last,
_BinaryPredicate __binary_pred)
{
// concept requirements
- __glibcpp_function_requires(_Mutable_ForwardIteratorConcept<_ForwardIter>)
+ __glibcpp_function_requires(_Mutable_ForwardIteratorConcept<_ForwardIterator>)
__glibcpp_function_requires(_BinaryPredicateConcept<_BinaryPredicate,
- typename iterator_traits<_ForwardIter>::value_type,
- typename iterator_traits<_ForwardIter>::value_type>)
+ typename iterator_traits<_ForwardIterator>::value_type,
+ typename iterator_traits<_ForwardIterator>::value_type>)
__first = adjacent_find(__first, __last, __binary_pred);
return unique_copy(__first, __last, __first, __binary_pred);
/**
* @if maint
- * This is an uglified reverse(_BidirectionalIter, _BidirectionalIter)
+ * This is an uglified reverse(_BidirectionalIterator, _BidirectionalIterator)
* overloaded for bidirectional iterators.
* @endif
*/
- template<typename _BidirectionalIter>
+ template<typename _BidirectionalIterator>
void
- __reverse(_BidirectionalIter __first, _BidirectionalIter __last,
+ __reverse(_BidirectionalIterator __first, _BidirectionalIterator __last,
bidirectional_iterator_tag)
{
while (true)
/**
* @if maint
- * This is an uglified reverse(_BidirectionalIter, _BidirectionalIter)
+ * This is an uglified reverse(_BidirectionalIterator, _BidirectionalIterator)
* overloaded for bidirectional iterators.
* @endif
*/
- template<typename _RandomAccessIter>
+ template<typename _RandomAccessIterator>
void
- __reverse(_RandomAccessIter __first, _RandomAccessIter __last,
+ __reverse(_RandomAccessIterator __first, _RandomAccessIterator __last,
random_access_iterator_tag)
{
while (__first < __last)
* For every @c i such that @p 0<=i<=(last-first)/2), @p reverse()
* swaps @p *(first+i) and @p *(last-(i+1))
*/
- template<typename _BidirectionalIter>
+ template<typename _BidirectionalIterator>
inline void
- reverse(_BidirectionalIter __first, _BidirectionalIter __last)
+ reverse(_BidirectionalIterator __first, _BidirectionalIterator __last)
{
// concept requirements
__glibcpp_function_requires(_Mutable_BidirectionalIteratorConcept<
- _BidirectionalIter>)
+ _BidirectionalIterator>)
__reverse(__first, __last, __iterator_category(__first));
}
* The ranges @p [first,last) and @p [result,result+(last-first))
* must not overlap.
*/
- template<typename _BidirectionalIter, typename _OutputIter>
- _OutputIter
- reverse_copy(_BidirectionalIter __first, _BidirectionalIter __last,
- _OutputIter __result)
+ template<typename _BidirectionalIterator, typename _OutputIterator>
+ _OutputIterator
+ reverse_copy(_BidirectionalIterator __first, _BidirectionalIterator __last,
+ _OutputIterator __result)
{
// concept requirements
- __glibcpp_function_requires(_BidirectionalIteratorConcept<_BidirectionalIter>)
- __glibcpp_function_requires(_OutputIteratorConcept<_OutputIter,
- typename iterator_traits<_BidirectionalIter>::value_type>)
+ __glibcpp_function_requires(_BidirectionalIteratorConcept<_BidirectionalIterator>)
+ __glibcpp_function_requires(_OutputIteratorConcept<_OutputIterator,
+ typename iterator_traits<_BidirectionalIterator>::value_type>)
while (__first != __last) {
--__last;
* This is a helper function for the rotate algorithm.
* @endif
*/
- template<typename _ForwardIter>
+ template<typename _ForwardIterator>
void
- __rotate(_ForwardIter __first,
- _ForwardIter __middle,
- _ForwardIter __last,
+ __rotate(_ForwardIterator __first,
+ _ForwardIterator __middle,
+ _ForwardIterator __last,
forward_iterator_tag)
{
if ((__first == __middle) || (__last == __middle))
return;
- _ForwardIter __first2 = __middle;
+ _ForwardIterator __first2 = __middle;
do {
swap(*__first++, *__first2++);
if (__first == __middle)
* This is a helper function for the rotate algorithm.
* @endif
*/
- template<typename _BidirectionalIter>
+ template<typename _BidirectionalIterator>
void
- __rotate(_BidirectionalIter __first,
- _BidirectionalIter __middle,
- _BidirectionalIter __last,
+ __rotate(_BidirectionalIterator __first,
+ _BidirectionalIterator __middle,
+ _BidirectionalIterator __last,
bidirectional_iterator_tag)
{
// concept requirements
__glibcpp_function_requires(_Mutable_BidirectionalIteratorConcept<
- _BidirectionalIter>)
+ _BidirectionalIterator>)
if ((__first == __middle) || (__last == __middle))
return;
* This is a helper function for the rotate algorithm.
* @endif
*/
- template<typename _RandomAccessIter>
+ template<typename _RandomAccessIterator>
void
- __rotate(_RandomAccessIter __first,
- _RandomAccessIter __middle,
- _RandomAccessIter __last,
+ __rotate(_RandomAccessIterator __first,
+ _RandomAccessIterator __middle,
+ _RandomAccessIterator __last,
random_access_iterator_tag)
{
// concept requirements
__glibcpp_function_requires(_Mutable_RandomAccessIteratorConcept<
- _RandomAccessIter>)
+ _RandomAccessIterator>)
if ((__first == __middle) || (__last == __middle))
return;
- typedef typename iterator_traits<_RandomAccessIter>::difference_type _Distance;
- typedef typename iterator_traits<_RandomAccessIter>::value_type _ValueType;
+ typedef typename iterator_traits<_RandomAccessIterator>::difference_type _Distance;
+ typedef typename iterator_traits<_RandomAccessIterator>::value_type _ValueType;
_Distance __n = __last - __first;
_Distance __k = __middle - __first;
for (_Distance __i = 0; __i < __d; __i++) {
_ValueType __tmp = *__first;
- _RandomAccessIter __p = __first;
+ _RandomAccessIterator __p = __first;
if (__k < __l) {
for (_Distance __j = 0; __j < __l/__d; __j++) {
* Performs @p *(first+(n+(last-middle))%(last-first))=*(first+n) for
* each @p n in the range @p [0,last-first).
*/
- template<typename _ForwardIter>
+ template<typename _ForwardIterator>
inline void
- rotate(_ForwardIter __first, _ForwardIter __middle, _ForwardIter __last)
+ rotate(_ForwardIterator __first, _ForwardIterator __middle, _ForwardIterator __last)
{
// concept requirements
- __glibcpp_function_requires(_Mutable_ForwardIteratorConcept<_ForwardIter>)
+ __glibcpp_function_requires(_Mutable_ForwardIteratorConcept<_ForwardIterator>)
- typedef typename iterator_traits<_ForwardIter>::iterator_category _IterType;
+ typedef typename iterator_traits<_ForwardIterator>::iterator_category _IterType;
__rotate(__first, __middle, __last, _IterType());
}
* Performs @p *(result+(n+(last-middle))%(last-first))=*(first+n) for
* each @p n in the range @p [0,last-first).
*/
- template<typename _ForwardIter, typename _OutputIter>
- _OutputIter
- rotate_copy(_ForwardIter __first, _ForwardIter __middle,
- _ForwardIter __last, _OutputIter __result)
+ template<typename _ForwardIterator, typename _OutputIterator>
+ _OutputIterator
+ rotate_copy(_ForwardIterator __first, _ForwardIterator __middle,
+ _ForwardIterator __last, _OutputIterator __result)
{
// concept requirements
- __glibcpp_function_requires(_ForwardIteratorConcept<_ForwardIter>)
- __glibcpp_function_requires(_OutputIteratorConcept<_OutputIter,
- typename iterator_traits<_ForwardIter>::value_type>)
+ __glibcpp_function_requires(_ForwardIteratorConcept<_ForwardIterator>)
+ __glibcpp_function_requires(_OutputIteratorConcept<_OutputIterator,
+ typename iterator_traits<_ForwardIterator>::value_type>)
return copy(__first, __middle, copy(__middle, __last, __result));
}
* distribution, so that every possible ordering of the sequence is
* equally likely.
*/
- template<typename _RandomAccessIter>
+ template<typename _RandomAccessIterator>
inline void
- random_shuffle(_RandomAccessIter __first, _RandomAccessIter __last)
+ random_shuffle(_RandomAccessIterator __first, _RandomAccessIterator __last)
{
// concept requirements
__glibcpp_function_requires(_Mutable_RandomAccessIteratorConcept<
- _RandomAccessIter>)
+ _RandomAccessIterator>)
if (__first == __last) return;
- for (_RandomAccessIter __i = __first + 1; __i != __last; ++__i)
+ for (_RandomAccessIterator __i = __first + 1; __i != __last; ++__i)
iter_swap(__i, __first + __random_number((__i - __first) + 1));
}
* integer @p N should return a randomly chosen integer from the
* range [0,N).
*/
- template<typename _RandomAccessIter, typename _RandomNumberGenerator>
+ template<typename _RandomAccessIterator, typename _RandomNumberGenerator>
void
- random_shuffle(_RandomAccessIter __first, _RandomAccessIter __last,
+ random_shuffle(_RandomAccessIterator __first, _RandomAccessIterator __last,
_RandomNumberGenerator& __rand)
{
// concept requirements
__glibcpp_function_requires(_Mutable_RandomAccessIteratorConcept<
- _RandomAccessIter>)
+ _RandomAccessIterator>)
if (__first == __last) return;
- for (_RandomAccessIter __i = __first + 1; __i != __last; ++__i)
+ for (_RandomAccessIterator __i = __first + 1; __i != __last; ++__i)
iter_swap(__i, __first + __rand((__i - __first) + 1));
}
* This is a helper function...
* @endif
*/
- template<typename _ForwardIter, typename _Predicate>
- _ForwardIter
- __partition(_ForwardIter __first, _ForwardIter __last,
+ template<typename _ForwardIterator, typename _Predicate>
+ _ForwardIterator
+ __partition(_ForwardIterator __first, _ForwardIterator __last,
_Predicate __pred,
forward_iterator_tag)
{
while (__pred(*__first))
if (++__first == __last) return __first;
- _ForwardIter __next = __first;
+ _ForwardIterator __next = __first;
while (++__next != __last)
if (__pred(*__next)) {
* This is a helper function...
* @endif
*/
- template<typename _BidirectionalIter, typename _Predicate>
- _BidirectionalIter
- __partition(_BidirectionalIter __first, _BidirectionalIter __last,
+ template<typename _BidirectionalIterator, typename _Predicate>
+ _BidirectionalIterator
+ __partition(_BidirectionalIterator __first, _BidirectionalIterator __last,
_Predicate __pred,
bidirectional_iterator_tag)
{
* the relative ordering of elements in each group, use
* @p stable_partition() if this is needed.
*/
- template<typename _ForwardIter, typename _Predicate>
- inline _ForwardIter
- partition(_ForwardIter __first, _ForwardIter __last,
+ template<typename _ForwardIterator, typename _Predicate>
+ inline _ForwardIterator
+ partition(_ForwardIterator __first, _ForwardIterator __last,
_Predicate __pred)
{
// concept requirements
- __glibcpp_function_requires(_Mutable_ForwardIteratorConcept<_ForwardIter>)
+ __glibcpp_function_requires(_Mutable_ForwardIteratorConcept<_ForwardIterator>)
__glibcpp_function_requires(_UnaryPredicateConcept<_Predicate,
- typename iterator_traits<_ForwardIter>::value_type>)
+ typename iterator_traits<_ForwardIterator>::value_type>)
return __partition(__first, __last, __pred, __iterator_category(__first));
}
* This is a helper function...
* @endif
*/
- template<typename _ForwardIter, typename _Predicate, typename _Distance>
- _ForwardIter
- __inplace_stable_partition(_ForwardIter __first, _ForwardIter __last,
+ template<typename _ForwardIterator, typename _Predicate, typename _Distance>
+ _ForwardIterator
+ __inplace_stable_partition(_ForwardIterator __first, _ForwardIterator __last,
_Predicate __pred, _Distance __len)
{
if (__len == 1)
return __pred(*__first) ? __last : __first;
- _ForwardIter __middle = __first;
+ _ForwardIterator __middle = __first;
advance(__middle, __len / 2);
- _ForwardIter __begin = __inplace_stable_partition(__first, __middle,
+ _ForwardIterator __begin = __inplace_stable_partition(__first, __middle,
__pred,
__len / 2);
- _ForwardIter __end = __inplace_stable_partition(__middle, __last,
+ _ForwardIterator __end = __inplace_stable_partition(__middle, __last,
__pred,
__len - __len / 2);
rotate(__begin, __middle, __end);
* This is a helper function...
* @endif
*/
- template<typename _ForwardIter, typename _Pointer, typename _Predicate,
+ template<typename _ForwardIterator, typename _Pointer, typename _Predicate,
typename _Distance>
- _ForwardIter
- __stable_partition_adaptive(_ForwardIter __first, _ForwardIter __last,
+ _ForwardIterator
+ __stable_partition_adaptive(_ForwardIterator __first, _ForwardIterator __last,
_Predicate __pred, _Distance __len,
_Pointer __buffer,
_Distance __buffer_size)
{
if (__len <= __buffer_size) {
- _ForwardIter __result1 = __first;
+ _ForwardIterator __result1 = __first;
_Pointer __result2 = __buffer;
for ( ; __first != __last ; ++__first)
if (__pred(*__first)) {
return __result1;
}
else {
- _ForwardIter __middle = __first;
+ _ForwardIterator __middle = __first;
advance(__middle, __len / 2);
- _ForwardIter __begin = __stable_partition_adaptive(__first, __middle,
+ _ForwardIterator __begin = __stable_partition_adaptive(__first, __middle,
__pred,
__len / 2,
__buffer, __buffer_size);
- _ForwardIter __end = __stable_partition_adaptive( __middle, __last,
+ _ForwardIterator __end = __stable_partition_adaptive( __middle, __last,
__pred,
__len - __len / 2,
__buffer, __buffer_size);
* @p [first,last) such that @p pred(x)==pred(y) will have the same
* relative ordering after calling @p stable_partition().
*/
- template<typename _ForwardIter, typename _Predicate>
- _ForwardIter
- stable_partition(_ForwardIter __first, _ForwardIter __last,
+ template<typename _ForwardIterator, typename _Predicate>
+ _ForwardIterator
+ stable_partition(_ForwardIterator __first, _ForwardIterator __last,
_Predicate __pred)
{
// concept requirements
- __glibcpp_function_requires(_Mutable_ForwardIteratorConcept<_ForwardIter>)
+ __glibcpp_function_requires(_Mutable_ForwardIteratorConcept<_ForwardIterator>)
__glibcpp_function_requires(_UnaryPredicateConcept<_Predicate,
- typename iterator_traits<_ForwardIter>::value_type>)
+ typename iterator_traits<_ForwardIterator>::value_type>)
if (__first == __last)
return __first;
else
{
- typedef typename iterator_traits<_ForwardIter>::value_type _ValueType;
- typedef typename iterator_traits<_ForwardIter>::difference_type _DistanceType;
+ typedef typename iterator_traits<_ForwardIterator>::value_type _ValueType;
+ typedef typename iterator_traits<_ForwardIterator>::difference_type _DistanceType;
- _Temporary_buffer<_ForwardIter, _ValueType> __buf(__first, __last);
+ _Temporary_buffer<_ForwardIterator, _ValueType> __buf(__first, __last);
if (__buf.size() > 0)
return __stable_partition_adaptive(__first, __last, __pred,
_DistanceType(__buf.requested_size()),
* This is a helper function...
* @endif
*/
- template<typename _RandomAccessIter, typename _Tp>
- _RandomAccessIter
- __unguarded_partition(_RandomAccessIter __first, _RandomAccessIter __last,
+ template<typename _RandomAccessIterator, typename _Tp>
+ _RandomAccessIterator
+ __unguarded_partition(_RandomAccessIterator __first, _RandomAccessIterator __last,
_Tp __pivot)
{
while (true) {
* This is a helper function...
* @endif
*/
- template<typename _RandomAccessIter, typename _Tp, typename _Compare>
- _RandomAccessIter
- __unguarded_partition(_RandomAccessIter __first, _RandomAccessIter __last,
+ template<typename _RandomAccessIterator, typename _Tp, typename _Compare>
+ _RandomAccessIterator
+ __unguarded_partition(_RandomAccessIterator __first, _RandomAccessIterator __last,
_Tp __pivot, _Compare __comp)
{
while (true) {
* This is a helper function for the sort routine.
* @endif
*/
- template<typename _RandomAccessIter, typename _Tp>
+ template<typename _RandomAccessIterator, typename _Tp>
void
- __unguarded_linear_insert(_RandomAccessIter __last, _Tp __val)
+ __unguarded_linear_insert(_RandomAccessIterator __last, _Tp __val)
{
- _RandomAccessIter __next = __last;
+ _RandomAccessIterator __next = __last;
--__next;
while (__val < *__next) {
*__last = *__next;
* This is a helper function for the sort routine.
* @endif
*/
- template<typename _RandomAccessIter, typename _Tp, typename _Compare>
+ template<typename _RandomAccessIterator, typename _Tp, typename _Compare>
void
- __unguarded_linear_insert(_RandomAccessIter __last, _Tp __val, _Compare __comp)
+ __unguarded_linear_insert(_RandomAccessIterator __last, _Tp __val, _Compare __comp)
{
- _RandomAccessIter __next = __last;
+ _RandomAccessIterator __next = __last;
--__next;
while (__comp(__val, *__next)) {
*__last = *__next;
* This is a helper function for the sort routine.
* @endif
*/
- template<typename _RandomAccessIter>
+ template<typename _RandomAccessIterator>
void
- __insertion_sort(_RandomAccessIter __first, _RandomAccessIter __last)
+ __insertion_sort(_RandomAccessIterator __first, _RandomAccessIterator __last)
{
if (__first == __last) return;
- for (_RandomAccessIter __i = __first + 1; __i != __last; ++__i)
+ for (_RandomAccessIterator __i = __first + 1; __i != __last; ++__i)
{
- typename iterator_traits<_RandomAccessIter>::value_type __val = *__i;
+ typename iterator_traits<_RandomAccessIterator>::value_type __val = *__i;
if (__val < *__first) {
copy_backward(__first, __i, __i + 1);
*__first = __val;
* This is a helper function for the sort routine.
* @endif
*/
- template<typename _RandomAccessIter, typename _Compare>
+ template<typename _RandomAccessIterator, typename _Compare>
void
- __insertion_sort(_RandomAccessIter __first, _RandomAccessIter __last,
+ __insertion_sort(_RandomAccessIterator __first, _RandomAccessIterator __last,
_Compare __comp)
{
if (__first == __last) return;
- for (_RandomAccessIter __i = __first + 1; __i != __last; ++__i)
+ for (_RandomAccessIterator __i = __first + 1; __i != __last; ++__i)
{
- typename iterator_traits<_RandomAccessIter>::value_type __val = *__i;
+ typename iterator_traits<_RandomAccessIterator>::value_type __val = *__i;
if (__comp(__val, *__first)) {
copy_backward(__first, __i, __i + 1);
*__first = __val;
* This is a helper function for the sort routine.
* @endif
*/
- template<typename _RandomAccessIter>
+ template<typename _RandomAccessIterator>
inline void
- __unguarded_insertion_sort(_RandomAccessIter __first, _RandomAccessIter __last)
+ __unguarded_insertion_sort(_RandomAccessIterator __first, _RandomAccessIterator __last)
{
- typedef typename iterator_traits<_RandomAccessIter>::value_type _ValueType;
+ typedef typename iterator_traits<_RandomAccessIterator>::value_type _ValueType;
- for (_RandomAccessIter __i = __first; __i != __last; ++__i)
+ for (_RandomAccessIterator __i = __first; __i != __last; ++__i)
__unguarded_linear_insert(__i, _ValueType(*__i));
}
* This is a helper function for the sort routine.
* @endif
*/
- template<typename _RandomAccessIter, typename _Compare>
+ template<typename _RandomAccessIterator, typename _Compare>
inline void
- __unguarded_insertion_sort(_RandomAccessIter __first, _RandomAccessIter __last,
+ __unguarded_insertion_sort(_RandomAccessIterator __first, _RandomAccessIterator __last,
_Compare __comp)
{
- typedef typename iterator_traits<_RandomAccessIter>::value_type _ValueType;
+ typedef typename iterator_traits<_RandomAccessIterator>::value_type _ValueType;
- for (_RandomAccessIter __i = __first; __i != __last; ++__i)
+ for (_RandomAccessIterator __i = __first; __i != __last; ++__i)
__unguarded_linear_insert(__i, _ValueType(*__i), __comp);
}
* This is a helper function for the sort routine.
* @endif
*/
- template<typename _RandomAccessIter>
+ template<typename _RandomAccessIterator>
void
- __final_insertion_sort(_RandomAccessIter __first, _RandomAccessIter __last)
+ __final_insertion_sort(_RandomAccessIterator __first, _RandomAccessIterator __last)
{
if (__last - __first > _S_threshold) {
__insertion_sort(__first, __first + _S_threshold);
* This is a helper function for the sort routine.
* @endif
*/
- template<typename _RandomAccessIter, typename _Compare>
+ template<typename _RandomAccessIterator, typename _Compare>
void
- __final_insertion_sort(_RandomAccessIter __first, _RandomAccessIter __last,
+ __final_insertion_sort(_RandomAccessIterator __first, _RandomAccessIterator __last,
_Compare __comp)
{
if (__last - __first > _S_threshold) {
* This is a helper function for the sort routine.
* @endif
*/
- template<typename _RandomAccessIter, typename _Size>
+ template<typename _RandomAccessIterator, typename _Size>
void
- __introsort_loop(_RandomAccessIter __first, _RandomAccessIter __last,
+ __introsort_loop(_RandomAccessIterator __first, _RandomAccessIterator __last,
_Size __depth_limit)
{
- typedef typename iterator_traits<_RandomAccessIter>::value_type _ValueType;
+ typedef typename iterator_traits<_RandomAccessIterator>::value_type _ValueType;
while (__last - __first > _S_threshold) {
if (__depth_limit == 0) {
return;
}
--__depth_limit;
- _RandomAccessIter __cut =
+ _RandomAccessIterator __cut =
__unguarded_partition(__first, __last,
_ValueType(__median(*__first,
*(__first + (__last - __first)/2),
* This is a helper function for the sort routine.
* @endif
*/
- template<typename _RandomAccessIter, typename _Size, typename _Compare>
+ template<typename _RandomAccessIterator, typename _Size, typename _Compare>
void
- __introsort_loop(_RandomAccessIter __first, _RandomAccessIter __last,
+ __introsort_loop(_RandomAccessIterator __first, _RandomAccessIterator __last,
_Size __depth_limit, _Compare __comp)
{
- typedef typename iterator_traits<_RandomAccessIter>::value_type _ValueType;
+ typedef typename iterator_traits<_RandomAccessIterator>::value_type _ValueType;
while (__last - __first > _S_threshold) {
if (__depth_limit == 0) {
return;
}
--__depth_limit;
- _RandomAccessIter __cut =
+ _RandomAccessIterator __cut =
__unguarded_partition(__first, __last,
_ValueType(__median(*__first,
*(__first + (__last - __first)/2),
* The relative ordering of equivalent elements is not preserved, use
* @p stable_sort() if this is needed.
*/
- template<typename _RandomAccessIter>
+ template<typename _RandomAccessIterator>
inline void
- sort(_RandomAccessIter __first, _RandomAccessIter __last)
+ sort(_RandomAccessIterator __first, _RandomAccessIterator __last)
{
- typedef typename iterator_traits<_RandomAccessIter>::value_type _ValueType;
+ typedef typename iterator_traits<_RandomAccessIterator>::value_type _ValueType;
// concept requirements
__glibcpp_function_requires(_Mutable_RandomAccessIteratorConcept<
- _RandomAccessIter>)
+ _RandomAccessIterator>)
__glibcpp_function_requires(_LessThanComparableConcept<_ValueType>)
if (__first != __last) {
* The relative ordering of equivalent elements is not preserved, use
* @p stable_sort() if this is needed.
*/
- template<typename _RandomAccessIter, typename _Compare>
+ template<typename _RandomAccessIterator, typename _Compare>
inline void
- sort(_RandomAccessIter __first, _RandomAccessIter __last, _Compare __comp)
+ sort(_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp)
{
- typedef typename iterator_traits<_RandomAccessIter>::value_type _ValueType;
+ typedef typename iterator_traits<_RandomAccessIterator>::value_type _ValueType;
// concept requirements
__glibcpp_function_requires(_Mutable_RandomAccessIteratorConcept<
- _RandomAccessIter>)
+ _RandomAccessIterator>)
__glibcpp_function_requires(_BinaryPredicateConcept<_Compare, _ValueType, _ValueType>)
if (__first != __last) {
* This is a helper function for the stable sorting routines.
* @endif
*/
- template<typename _RandomAccessIter>
+ template<typename _RandomAccessIterator>
void
- __inplace_stable_sort(_RandomAccessIter __first, _RandomAccessIter __last)
+ __inplace_stable_sort(_RandomAccessIterator __first, _RandomAccessIterator __last)
{
if (__last - __first < 15) {
__insertion_sort(__first, __last);
return;
}
- _RandomAccessIter __middle = __first + (__last - __first) / 2;
+ _RandomAccessIterator __middle = __first + (__last - __first) / 2;
__inplace_stable_sort(__first, __middle);
__inplace_stable_sort(__middle, __last);
__merge_without_buffer(__first, __middle, __last,
* This is a helper function for the stable sorting routines.
* @endif
*/
- template<typename _RandomAccessIter, typename _Compare>
+ template<typename _RandomAccessIterator, typename _Compare>
void
- __inplace_stable_sort(_RandomAccessIter __first, _RandomAccessIter __last,
+ __inplace_stable_sort(_RandomAccessIterator __first, _RandomAccessIterator __last,
_Compare __comp)
{
if (__last - __first < 15) {
__insertion_sort(__first, __last, __comp);
return;
}
- _RandomAccessIter __middle = __first + (__last - __first) / 2;
+ _RandomAccessIterator __middle = __first + (__last - __first) / 2;
__inplace_stable_sort(__first, __middle, __comp);
__inplace_stable_sort(__middle, __last, __comp);
__merge_without_buffer(__first, __middle, __last,
__comp);
}
- template<typename _RandomAccessIter1, typename _RandomAccessIter2,
+ template<typename _RandomAccessIterator1, typename _RandomAccessIterator2,
typename _Distance>
void
- __merge_sort_loop(_RandomAccessIter1 __first, _RandomAccessIter1 __last,
- _RandomAccessIter2 __result, _Distance __step_size)
+ __merge_sort_loop(_RandomAccessIterator1 __first, _RandomAccessIterator1 __last,
+ _RandomAccessIterator2 __result, _Distance __step_size)
{
_Distance __two_step = 2 * __step_size;
__result);
}
- template<typename _RandomAccessIter1, typename _RandomAccessIter2,
+ template<typename _RandomAccessIterator1, typename _RandomAccessIterator2,
typename _Distance, typename _Compare>
void
- __merge_sort_loop(_RandomAccessIter1 __first, _RandomAccessIter1 __last,
- _RandomAccessIter2 __result, _Distance __step_size,
+ __merge_sort_loop(_RandomAccessIterator1 __first, _RandomAccessIterator1 __last,
+ _RandomAccessIterator2 __result, _Distance __step_size,
_Compare __comp)
{
_Distance __two_step = 2 * __step_size;
enum { _S_chunk_size = 7 };
- template<typename _RandomAccessIter, typename _Distance>
+ template<typename _RandomAccessIterator, typename _Distance>
void
- __chunk_insertion_sort(_RandomAccessIter __first, _RandomAccessIter __last,
+ __chunk_insertion_sort(_RandomAccessIterator __first, _RandomAccessIterator __last,
_Distance __chunk_size)
{
while (__last - __first >= __chunk_size) {
__insertion_sort(__first, __last);
}
- template<typename _RandomAccessIter, typename _Distance, typename _Compare>
+ template<typename _RandomAccessIterator, typename _Distance, typename _Compare>
void
- __chunk_insertion_sort(_RandomAccessIter __first, _RandomAccessIter __last,
+ __chunk_insertion_sort(_RandomAccessIterator __first, _RandomAccessIterator __last,
_Distance __chunk_size, _Compare __comp)
{
while (__last - __first >= __chunk_size) {
__insertion_sort(__first, __last, __comp);
}
- template<typename _RandomAccessIter, typename _Pointer>
+ template<typename _RandomAccessIterator, typename _Pointer>
void
- __merge_sort_with_buffer(_RandomAccessIter __first, _RandomAccessIter __last,
+ __merge_sort_with_buffer(_RandomAccessIterator __first, _RandomAccessIterator __last,
_Pointer __buffer)
{
- typedef typename iterator_traits<_RandomAccessIter>::difference_type _Distance;
+ typedef typename iterator_traits<_RandomAccessIterator>::difference_type _Distance;
_Distance __len = __last - __first;
_Pointer __buffer_last = __buffer + __len;
}
}
- template<typename _RandomAccessIter, typename _Pointer, typename _Compare>
+ template<typename _RandomAccessIterator, typename _Pointer, typename _Compare>
void
- __merge_sort_with_buffer(_RandomAccessIter __first, _RandomAccessIter __last,
+ __merge_sort_with_buffer(_RandomAccessIterator __first, _RandomAccessIterator __last,
_Pointer __buffer, _Compare __comp)
{
- typedef typename iterator_traits<_RandomAccessIter>::difference_type _Distance;
+ typedef typename iterator_traits<_RandomAccessIterator>::difference_type _Distance;
_Distance __len = __last - __first;
_Pointer __buffer_last = __buffer + __len;
}
}
- template<typename _RandomAccessIter, typename _Pointer, typename _Distance>
+ template<typename _RandomAccessIterator, typename _Pointer, typename _Distance>
void
- __stable_sort_adaptive(_RandomAccessIter __first, _RandomAccessIter __last,
+ __stable_sort_adaptive(_RandomAccessIterator __first, _RandomAccessIterator __last,
_Pointer __buffer, _Distance __buffer_size)
{
_Distance __len = (__last - __first + 1) / 2;
- _RandomAccessIter __middle = __first + __len;
+ _RandomAccessIterator __middle = __first + __len;
if (__len > __buffer_size) {
__stable_sort_adaptive(__first, __middle, __buffer, __buffer_size);
__stable_sort_adaptive(__middle, __last, __buffer, __buffer_size);
_Distance(__last - __middle), __buffer, __buffer_size);
}
- template<typename _RandomAccessIter, typename _Pointer, typename _Distance,
+ template<typename _RandomAccessIterator, typename _Pointer, typename _Distance,
typename _Compare>
void
- __stable_sort_adaptive(_RandomAccessIter __first, _RandomAccessIter __last,
+ __stable_sort_adaptive(_RandomAccessIterator __first, _RandomAccessIterator __last,
_Pointer __buffer, _Distance __buffer_size,
_Compare __comp)
{
_Distance __len = (__last - __first + 1) / 2;
- _RandomAccessIter __middle = __first + __len;
+ _RandomAccessIterator __middle = __first + __len;
if (__len > __buffer_size) {
__stable_sort_adaptive(__first, __middle, __buffer, __buffer_size,
__comp);
* @p x<y is false and @p y<x is false will have the same relative
* ordering after calling @p stable_sort().
*/
- template<typename _RandomAccessIter>
+ template<typename _RandomAccessIterator>
inline void
- stable_sort(_RandomAccessIter __first, _RandomAccessIter __last)
+ stable_sort(_RandomAccessIterator __first, _RandomAccessIterator __last)
{
- typedef typename iterator_traits<_RandomAccessIter>::value_type _ValueType;
- typedef typename iterator_traits<_RandomAccessIter>::difference_type _DistanceType;
+ typedef typename iterator_traits<_RandomAccessIterator>::value_type _ValueType;
+ typedef typename iterator_traits<_RandomAccessIterator>::difference_type _DistanceType;
// concept requirements
__glibcpp_function_requires(_Mutable_RandomAccessIteratorConcept<
- _RandomAccessIter>)
+ _RandomAccessIterator>)
__glibcpp_function_requires(_LessThanComparableConcept<_ValueType>)
- _Temporary_buffer<_RandomAccessIter, _ValueType> buf(__first, __last);
+ _Temporary_buffer<_RandomAccessIterator, _ValueType> buf(__first, __last);
if (buf.begin() == 0)
__inplace_stable_sort(__first, __last);
else
* @p comp(x,y) is false and @p comp(y,x) is false will have the same
* relative ordering after calling @p stable_sort().
*/
- template<typename _RandomAccessIter, typename _Compare>
+ template<typename _RandomAccessIterator, typename _Compare>
inline void
- stable_sort(_RandomAccessIter __first, _RandomAccessIter __last, _Compare __comp)
+ stable_sort(_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp)
{
- typedef typename iterator_traits<_RandomAccessIter>::value_type _ValueType;
- typedef typename iterator_traits<_RandomAccessIter>::difference_type _DistanceType;
+ typedef typename iterator_traits<_RandomAccessIterator>::value_type _ValueType;
+ typedef typename iterator_traits<_RandomAccessIterator>::difference_type _DistanceType;
// concept requirements
__glibcpp_function_requires(_Mutable_RandomAccessIteratorConcept<
- _RandomAccessIter>)
+ _RandomAccessIterator>)
__glibcpp_function_requires(_BinaryPredicateConcept<_Compare,
_ValueType, _ValueType>)
- _Temporary_buffer<_RandomAccessIter, _ValueType> buf(__first, __last);
+ _Temporary_buffer<_RandomAccessIterator, _ValueType> buf(__first, __last);
if (buf.begin() == 0)
__inplace_stable_sort(__first, __last, __comp);
else
* @p [first,middle) such that @i precedes @j and @k is an iterator in
* the range @p [middle,last) then @p *j<*i and @p *k<*i are both false.
*/
- template<typename _RandomAccessIter>
+ template<typename _RandomAccessIterator>
void
- partial_sort(_RandomAccessIter __first,
- _RandomAccessIter __middle,
- _RandomAccessIter __last)
+ partial_sort(_RandomAccessIterator __first,
+ _RandomAccessIterator __middle,
+ _RandomAccessIterator __last)
{
- typedef typename iterator_traits<_RandomAccessIter>::value_type _ValueType;
+ typedef typename iterator_traits<_RandomAccessIterator>::value_type _ValueType;
// concept requirements
__glibcpp_function_requires(_Mutable_RandomAccessIteratorConcept<
- _RandomAccessIter>)
+ _RandomAccessIterator>)
__glibcpp_function_requires(_LessThanComparableConcept<_ValueType>)
make_heap(__first, __middle);
- for (_RandomAccessIter __i = __middle; __i < __last; ++__i)
+ for (_RandomAccessIterator __i = __middle; __i < __last; ++__i)
if (*__i < *__first)
__pop_heap(__first, __middle, __i, _ValueType(*__i));
sort_heap(__first, __middle);
* the range @p [middle,last) then @p *comp(j,*i) and @p comp(*k,*i)
* are both false.
*/
- template<typename _RandomAccessIter, typename _Compare>
+ template<typename _RandomAccessIterator, typename _Compare>
void
- partial_sort(_RandomAccessIter __first,
- _RandomAccessIter __middle,
- _RandomAccessIter __last,
+ partial_sort(_RandomAccessIterator __first,
+ _RandomAccessIterator __middle,
+ _RandomAccessIterator __last,
_Compare __comp)
{
- typedef typename iterator_traits<_RandomAccessIter>::value_type _ValueType;
+ typedef typename iterator_traits<_RandomAccessIterator>::value_type _ValueType;
// concept requirements
__glibcpp_function_requires(_Mutable_RandomAccessIteratorConcept<
- _RandomAccessIter>)
+ _RandomAccessIterator>)
__glibcpp_function_requires(_BinaryPredicateConcept<_Compare,
_ValueType, _ValueType>)
make_heap(__first, __middle, __comp);
- for (_RandomAccessIter __i = __middle; __i < __last; ++__i)
+ for (_RandomAccessIterator __i = __middle; __i < __last; ++__i)
if (__comp(*__i, *__first))
__pop_heap(__first, __middle, __i, _ValueType(*__i), __comp);
sort_heap(__first, __middle, __comp);
* @p *j<*i is false.
* The value returned is @p result_first+N.
*/
- template<typename _InputIter, typename _RandomAccessIter>
- _RandomAccessIter
- partial_sort_copy(_InputIter __first, _InputIter __last,
- _RandomAccessIter __result_first,
- _RandomAccessIter __result_last)
+ template<typename _InputIterator, typename _RandomAccessIterator>
+ _RandomAccessIterator
+ partial_sort_copy(_InputIterator __first, _InputIterator __last,
+ _RandomAccessIterator __result_first,
+ _RandomAccessIterator __result_last)
{
- typedef typename iterator_traits<_InputIter>::value_type _InputValueType;
- typedef typename iterator_traits<_RandomAccessIter>::value_type _OutputValueType;
- typedef typename iterator_traits<_RandomAccessIter>::difference_type _DistanceType;
+ typedef typename iterator_traits<_InputIterator>::value_type _InputValueType;
+ typedef typename iterator_traits<_RandomAccessIterator>::value_type _OutputValueType;
+ typedef typename iterator_traits<_RandomAccessIterator>::difference_type _DistanceType;
// concept requirements
- __glibcpp_function_requires(_InputIteratorConcept<_InputIter>)
+ __glibcpp_function_requires(_InputIteratorConcept<_InputIterator>)
__glibcpp_function_requires(_ConvertibleConcept<_InputValueType, _OutputValueType>)
__glibcpp_function_requires(_LessThanComparableConcept<_OutputValueType>)
__glibcpp_function_requires(_LessThanComparableConcept<_InputValueType>)
if (__result_first == __result_last) return __result_last;
- _RandomAccessIter __result_real_last = __result_first;
+ _RandomAccessIterator __result_real_last = __result_first;
while(__first != __last && __result_real_last != __result_last) {
*__result_real_last = *__first;
++__result_real_last;
* @p comp(*j,*i) is false.
* The value returned is @p result_first+N.
*/
- template<typename _InputIter, typename _RandomAccessIter, typename _Compare>
- _RandomAccessIter
- partial_sort_copy(_InputIter __first, _InputIter __last,
- _RandomAccessIter __result_first,
- _RandomAccessIter __result_last,
+ template<typename _InputIterator, typename _RandomAccessIterator, typename _Compare>
+ _RandomAccessIterator
+ partial_sort_copy(_InputIterator __first, _InputIterator __last,
+ _RandomAccessIterator __result_first,
+ _RandomAccessIterator __result_last,
_Compare __comp)
{
- typedef typename iterator_traits<_InputIter>::value_type _InputValueType;
- typedef typename iterator_traits<_RandomAccessIter>::value_type _OutputValueType;
- typedef typename iterator_traits<_RandomAccessIter>::difference_type _DistanceType;
+ typedef typename iterator_traits<_InputIterator>::value_type _InputValueType;
+ typedef typename iterator_traits<_RandomAccessIterator>::value_type _OutputValueType;
+ typedef typename iterator_traits<_RandomAccessIterator>::difference_type _DistanceType;
// concept requirements
- __glibcpp_function_requires(_InputIteratorConcept<_InputIter>)
- __glibcpp_function_requires(_Mutable_RandomAccessIteratorConcept<_RandomAccessIter>)
+ __glibcpp_function_requires(_InputIteratorConcept<_InputIterator>)
+ __glibcpp_function_requires(_Mutable_RandomAccessIteratorConcept<_RandomAccessIterator>)
__glibcpp_function_requires(_ConvertibleConcept<_InputValueType, _OutputValueType>)
__glibcpp_function_requires(_BinaryPredicateConcept<_Compare,
_OutputValueType, _OutputValueType>)
if (__result_first == __result_last) return __result_last;
- _RandomAccessIter __result_real_last = __result_first;
+ _RandomAccessIterator __result_real_last = __result_first;
while(__first != __last && __result_real_last != __result_last) {
*__result_real_last = *__first;
++__result_real_last;
* @p [first,nth) and any iterator @j in the range @p [nth,last) it
* holds that @p *j<*i is false.
*/
- template<typename _RandomAccessIter>
+ template<typename _RandomAccessIterator>
void
- nth_element(_RandomAccessIter __first,
- _RandomAccessIter __nth,
- _RandomAccessIter __last)
+ nth_element(_RandomAccessIterator __first,
+ _RandomAccessIterator __nth,
+ _RandomAccessIterator __last)
{
- typedef typename iterator_traits<_RandomAccessIter>::value_type _ValueType;
+ typedef typename iterator_traits<_RandomAccessIterator>::value_type _ValueType;
// concept requirements
- __glibcpp_function_requires(_Mutable_RandomAccessIteratorConcept<_RandomAccessIter>)
+ __glibcpp_function_requires(_Mutable_RandomAccessIteratorConcept<_RandomAccessIterator>)
__glibcpp_function_requires(_LessThanComparableConcept<_ValueType>)
while (__last - __first > 3) {
- _RandomAccessIter __cut =
+ _RandomAccessIterator __cut =
__unguarded_partition(__first, __last,
_ValueType(__median(*__first,
*(__first + (__last - __first)/2),
* @p [first,nth) and any iterator @j in the range @p [nth,last) it
* holds that @p comp(*j,*i) is false.
*/
- template<typename _RandomAccessIter, typename _Compare>
+ template<typename _RandomAccessIterator, typename _Compare>
void
- nth_element(_RandomAccessIter __first,
- _RandomAccessIter __nth,
- _RandomAccessIter __last,
+ nth_element(_RandomAccessIterator __first,
+ _RandomAccessIterator __nth,
+ _RandomAccessIterator __last,
_Compare __comp)
{
- typedef typename iterator_traits<_RandomAccessIter>::value_type _ValueType;
+ typedef typename iterator_traits<_RandomAccessIterator>::value_type _ValueType;
// concept requirements
- __glibcpp_function_requires(_Mutable_RandomAccessIteratorConcept<_RandomAccessIter>)
+ __glibcpp_function_requires(_Mutable_RandomAccessIteratorConcept<_RandomAccessIterator>)
__glibcpp_function_requires(_BinaryPredicateConcept<_Compare,
_ValueType, _ValueType>)
while (__last - __first > 3) {
- _RandomAccessIter __cut =
+ _RandomAccessIterator __cut =
__unguarded_partition(__first, __last,
_ValueType(__median(*__first,
*(__first + (__last - __first)/2),
* @param first An iterator.
* @param last Another iterator.
* @param val The search term.
- * @return An iterator pointing to the first element "not less than" @a val.
+ * @return An iterator pointing to the first element "not less than" @a val,
+ * or end() if every element is less than @a val.
* @ingroup binarysearch
*/
- template<typename _ForwardIter, typename _Tp>
- _ForwardIter
- lower_bound(_ForwardIter __first, _ForwardIter __last, const _Tp& __val)
+ template<typename _ForwardIterator, typename _Tp>
+ _ForwardIterator
+ lower_bound(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __val)
{
- typedef typename iterator_traits<_ForwardIter>::value_type _ValueType;
- typedef typename iterator_traits<_ForwardIter>::difference_type _DistanceType;
+ typedef typename iterator_traits<_ForwardIterator>::value_type _ValueType;
+ typedef typename iterator_traits<_ForwardIterator>::difference_type _DistanceType;
// concept requirements
// Note that these are slightly stricter than those of the 4-argument
// version, defined next. The difference is in the strictness of the
// comparison operations... so for looser checking, define your own
// comparison function, as was intended.
- __glibcpp_function_requires(_ForwardIteratorConcept<_ForwardIter>)
+ __glibcpp_function_requires(_ForwardIteratorConcept<_ForwardIterator>)
__glibcpp_function_requires(_SameTypeConcept<_Tp, _ValueType>)
__glibcpp_function_requires(_LessThanComparableConcept<_Tp>)
_DistanceType __len = std::distance(__first, __last);
_DistanceType __half;
- _ForwardIter __middle;
+ _ForwardIterator __middle;
while (__len > 0) {
__half = __len >> 1;
* @param last Another iterator.
* @param val The search term.
* @param comp A functor to use for comparisons.
- * @return An iterator pointing to the first element "not less than" @a val.
+ * @return An iterator pointing to the first element "not less than" @a val,
+ * or end() if every element is less than @a val.
* @ingroup binarysearch
*
* The comparison function should have the same effects on ordering as
* the function used for the initial sort.
*/
- template<typename _ForwardIter, typename _Tp, typename _Compare>
- _ForwardIter
- lower_bound(_ForwardIter __first, _ForwardIter __last,
+ template<typename _ForwardIterator, typename _Tp, typename _Compare>
+ _ForwardIterator
+ lower_bound(_ForwardIterator __first, _ForwardIterator __last,
const _Tp& __val, _Compare __comp)
{
- typedef typename iterator_traits<_ForwardIter>::value_type _ValueType;
- typedef typename iterator_traits<_ForwardIter>::difference_type _DistanceType;
+ typedef typename iterator_traits<_ForwardIterator>::value_type _ValueType;
+ typedef typename iterator_traits<_ForwardIterator>::difference_type _DistanceType;
// concept requirements
- __glibcpp_function_requires(_ForwardIteratorConcept<_ForwardIter>)
+ __glibcpp_function_requires(_ForwardIteratorConcept<_ForwardIterator>)
__glibcpp_function_requires(_BinaryPredicateConcept<_Compare, _ValueType, _Tp>)
_DistanceType __len = std::distance(__first, __last);
_DistanceType __half;
- _ForwardIter __middle;
+ _ForwardIterator __middle;
while (__len > 0) {
__half = __len >> 1;
* @param first An iterator.
* @param last Another iterator.
* @param val The search term.
- * @return An iterator pointing to the first element greater than @a val.
+ * @return An iterator pointing to the first element greater than @a val,
+ * or end() if no elements are greater than @a val.
* @ingroup binarysearch
*/
- template<typename _ForwardIter, typename _Tp>
- _ForwardIter
- upper_bound(_ForwardIter __first, _ForwardIter __last, const _Tp& __val)
+ template<typename _ForwardIterator, typename _Tp>
+ _ForwardIterator
+ upper_bound(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __val)
{
- typedef typename iterator_traits<_ForwardIter>::value_type _ValueType;
- typedef typename iterator_traits<_ForwardIter>::difference_type _DistanceType;
+ typedef typename iterator_traits<_ForwardIterator>::value_type _ValueType;
+ typedef typename iterator_traits<_ForwardIterator>::difference_type _DistanceType;
// concept requirements
// See comments on lower_bound.
- __glibcpp_function_requires(_ForwardIteratorConcept<_ForwardIter>)
+ __glibcpp_function_requires(_ForwardIteratorConcept<_ForwardIterator>)
__glibcpp_function_requires(_SameTypeConcept<_Tp, _ValueType>)
__glibcpp_function_requires(_LessThanComparableConcept<_Tp>)
_DistanceType __len = std::distance(__first, __last);
_DistanceType __half;
- _ForwardIter __middle;
+ _ForwardIterator __middle;
while (__len > 0) {
__half = __len >> 1;
* @param last Another iterator.
* @param val The search term.
* @param comp A functor to use for comparisons.
- * @return An iterator pointing to the first element greater than @a val.
+ * @return An iterator pointing to the first element greater than @a val,
+ * or end() if no elements are greater than @a val.
* @ingroup binarysearch
*
* The comparison function should have the same effects on ordering as
* the function used for the initial sort.
*/
- template<typename _ForwardIter, typename _Tp, typename _Compare>
- _ForwardIter
- upper_bound(_ForwardIter __first, _ForwardIter __last,
+ template<typename _ForwardIterator, typename _Tp, typename _Compare>
+ _ForwardIterator
+ upper_bound(_ForwardIterator __first, _ForwardIterator __last,
const _Tp& __val, _Compare __comp)
{
- typedef typename iterator_traits<_ForwardIter>::value_type _ValueType;
- typedef typename iterator_traits<_ForwardIter>::difference_type _DistanceType;
+ typedef typename iterator_traits<_ForwardIterator>::value_type _ValueType;
+ typedef typename iterator_traits<_ForwardIterator>::difference_type _DistanceType;
// concept requirements
- __glibcpp_function_requires(_ForwardIteratorConcept<_ForwardIter>)
+ __glibcpp_function_requires(_ForwardIteratorConcept<_ForwardIterator>)
__glibcpp_function_requires(_BinaryPredicateConcept<_Compare, _Tp, _ValueType>)
_DistanceType __len = std::distance(__first, __last);
_DistanceType __half;
- _ForwardIter __middle;
+ _ForwardIterator __middle;
while (__len > 0) {
__half = __len >> 1;
* @endcode
* but does not actually call those functions.
*/
- template<typename _ForwardIter, typename _Tp>
- pair<_ForwardIter, _ForwardIter>
- equal_range(_ForwardIter __first, _ForwardIter __last, const _Tp& __val)
+ template<typename _ForwardIterator, typename _Tp>
+ pair<_ForwardIterator, _ForwardIterator>
+ equal_range(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __val)
{
- typedef typename iterator_traits<_ForwardIter>::value_type _ValueType;
- typedef typename iterator_traits<_ForwardIter>::difference_type _DistanceType;
+ typedef typename iterator_traits<_ForwardIterator>::value_type _ValueType;
+ typedef typename iterator_traits<_ForwardIterator>::difference_type _DistanceType;
// concept requirements
// See comments on lower_bound.
- __glibcpp_function_requires(_ForwardIteratorConcept<_ForwardIter>)
+ __glibcpp_function_requires(_ForwardIteratorConcept<_ForwardIterator>)
__glibcpp_function_requires(_SameTypeConcept<_Tp, _ValueType>)
__glibcpp_function_requires(_LessThanComparableConcept<_Tp>)
_DistanceType __len = std::distance(__first, __last);
_DistanceType __half;
- _ForwardIter __middle, __left, __right;
+ _ForwardIterator __middle, __left, __right;
while (__len > 0) {
__half = __len >> 1;
__left = lower_bound(__first, __middle, __val);
advance(__first, __len);
__right = upper_bound(++__middle, __first, __val);
- return pair<_ForwardIter, _ForwardIter>(__left, __right);
+ return pair<_ForwardIterator, _ForwardIterator>(__left, __right);
}
}
- return pair<_ForwardIter, _ForwardIter>(__first, __first);
+ return pair<_ForwardIterator, _ForwardIterator>(__first, __first);
}
/**
* @endcode
* but does not actually call those functions.
*/
- template<typename _ForwardIter, typename _Tp, typename _Compare>
- pair<_ForwardIter, _ForwardIter>
- equal_range(_ForwardIter __first, _ForwardIter __last, const _Tp& __val,
+ template<typename _ForwardIterator, typename _Tp, typename _Compare>
+ pair<_ForwardIterator, _ForwardIterator>
+ equal_range(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __val,
_Compare __comp)
{
- typedef typename iterator_traits<_ForwardIter>::value_type _ValueType;
- typedef typename iterator_traits<_ForwardIter>::difference_type _DistanceType;
+ typedef typename iterator_traits<_ForwardIterator>::value_type _ValueType;
+ typedef typename iterator_traits<_ForwardIterator>::difference_type _DistanceType;
// concept requirements
- __glibcpp_function_requires(_ForwardIteratorConcept<_ForwardIter>)
+ __glibcpp_function_requires(_ForwardIteratorConcept<_ForwardIterator>)
__glibcpp_function_requires(_BinaryPredicateConcept<_Compare, _ValueType, _Tp>)
__glibcpp_function_requires(_BinaryPredicateConcept<_Compare, _Tp, _ValueType>)
_DistanceType __len = std::distance(__first, __last);
_DistanceType __half;
- _ForwardIter __middle, __left, __right;
+ _ForwardIterator __middle, __left, __right;
while (__len > 0) {
__half = __len >> 1;
__left = lower_bound(__first, __middle, __val, __comp);
advance(__first, __len);
__right = upper_bound(++__middle, __first, __val, __comp);
- return pair<_ForwardIter, _ForwardIter>(__left, __right);
+ return pair<_ForwardIterator, _ForwardIterator>(__left, __right);
}
}
- return pair<_ForwardIter, _ForwardIter>(__first, __first);
+ return pair<_ForwardIterator, _ForwardIterator>(__first, __first);
}
/**
* Note that this does not actually return an iterator to @a val. For
* that, use std::find or a container's specialized find member functions.
*/
- template<typename _ForwardIter, typename _Tp>
+ template<typename _ForwardIterator, typename _Tp>
bool
- binary_search(_ForwardIter __first, _ForwardIter __last,
+ binary_search(_ForwardIterator __first, _ForwardIterator __last,
const _Tp& __val)
{
// concept requirements
// See comments on lower_bound.
- __glibcpp_function_requires(_ForwardIteratorConcept<_ForwardIter>)
+ __glibcpp_function_requires(_ForwardIteratorConcept<_ForwardIterator>)
__glibcpp_function_requires(_SameTypeConcept<_Tp,
- typename iterator_traits<_ForwardIter>::value_type>)
+ typename iterator_traits<_ForwardIterator>::value_type>)
__glibcpp_function_requires(_LessThanComparableConcept<_Tp>)
- _ForwardIter __i = lower_bound(__first, __last, __val);
+ _ForwardIterator __i = lower_bound(__first, __last, __val);
return __i != __last && !(__val < *__i);
}
* The comparison function should have the same effects on ordering as
* the function used for the initial sort.
*/
- template<typename _ForwardIter, typename _Tp, typename _Compare>
+ template<typename _ForwardIterator, typename _Tp, typename _Compare>
bool
- binary_search(_ForwardIter __first, _ForwardIter __last,
+ binary_search(_ForwardIterator __first, _ForwardIterator __last,
const _Tp& __val, _Compare __comp)
{
// concept requirements
- __glibcpp_function_requires(_ForwardIteratorConcept<_ForwardIter>)
+ __glibcpp_function_requires(_ForwardIteratorConcept<_ForwardIterator>)
__glibcpp_function_requires(_BinaryPredicateConcept<_Compare,
- typename iterator_traits<_ForwardIter>::value_type, _Tp>)
+ typename iterator_traits<_ForwardIterator>::value_type, _Tp>)
__glibcpp_function_requires(_BinaryPredicateConcept<_Compare, _Tp,
- typename iterator_traits<_ForwardIter>::value_type>)
+ typename iterator_traits<_ForwardIterator>::value_type>)
- _ForwardIter __i = lower_bound(__first, __last, __val, __comp);
+ _ForwardIterator __i = lower_bound(__first, __last, __val, __comp);
return __i != __last && !__comp(__val, *__i);
}
* elements in the two ranges, elements from the first range will always
* come before elements from the second.
*/
- template<typename _InputIter1, typename _InputIter2, typename _OutputIter>
- _OutputIter
- merge(_InputIter1 __first1, _InputIter1 __last1,
- _InputIter2 __first2, _InputIter2 __last2,
- _OutputIter __result)
+ template<typename _InputIterator1, typename _InputIterator2, typename _OutputIterator>
+ _OutputIterator
+ merge(_InputIterator1 __first1, _InputIterator1 __last1,
+ _InputIterator2 __first2, _InputIterator2 __last2,
+ _OutputIterator __result)
{
// concept requirements
- __glibcpp_function_requires(_InputIteratorConcept<_InputIter1>)
- __glibcpp_function_requires(_InputIteratorConcept<_InputIter2>)
- __glibcpp_function_requires(_OutputIteratorConcept<_OutputIter,
- typename iterator_traits<_InputIter1>::value_type>)
+ __glibcpp_function_requires(_InputIteratorConcept<_InputIterator1>)
+ __glibcpp_function_requires(_InputIteratorConcept<_InputIterator2>)
+ __glibcpp_function_requires(_OutputIteratorConcept<_OutputIterator,
+ typename iterator_traits<_InputIterator1>::value_type>)
__glibcpp_function_requires(_SameTypeConcept<
- typename iterator_traits<_InputIter1>::value_type,
- typename iterator_traits<_InputIter2>::value_type>)
+ typename iterator_traits<_InputIterator1>::value_type,
+ typename iterator_traits<_InputIterator2>::value_type>)
__glibcpp_function_requires(_LessThanComparableConcept<
- typename iterator_traits<_InputIter1>::value_type>)
+ typename iterator_traits<_InputIterator1>::value_type>)
while (__first1 != __last1 && __first2 != __last2) {
if (*__first2 < *__first1) {
* The comparison function should have the same effects on ordering as
* the function used for the initial sort.
*/
- template<typename _InputIter1, typename _InputIter2, typename _OutputIter,
+ template<typename _InputIterator1, typename _InputIterator2, typename _OutputIterator,
typename _Compare>
- _OutputIter
- merge(_InputIter1 __first1, _InputIter1 __last1,
- _InputIter2 __first2, _InputIter2 __last2,
- _OutputIter __result, _Compare __comp)
+ _OutputIterator
+ merge(_InputIterator1 __first1, _InputIterator1 __last1,
+ _InputIterator2 __first2, _InputIterator2 __last2,
+ _OutputIterator __result, _Compare __comp)
{
// concept requirements
- __glibcpp_function_requires(_InputIteratorConcept<_InputIter1>)
- __glibcpp_function_requires(_InputIteratorConcept<_InputIter2>)
+ __glibcpp_function_requires(_InputIteratorConcept<_InputIterator1>)
+ __glibcpp_function_requires(_InputIteratorConcept<_InputIterator2>)
__glibcpp_function_requires(_SameTypeConcept<
- typename iterator_traits<_InputIter1>::value_type,
- typename iterator_traits<_InputIter2>::value_type>)
- __glibcpp_function_requires(_OutputIteratorConcept<_OutputIter,
- typename iterator_traits<_InputIter1>::value_type>)
+ typename iterator_traits<_InputIterator1>::value_type,
+ typename iterator_traits<_InputIterator2>::value_type>)
+ __glibcpp_function_requires(_OutputIteratorConcept<_OutputIterator,
+ typename iterator_traits<_InputIterator1>::value_type>)
__glibcpp_function_requires(_BinaryPredicateConcept<_Compare,
- typename iterator_traits<_InputIter1>::value_type,
- typename iterator_traits<_InputIter2>::value_type>)
+ typename iterator_traits<_InputIterator1>::value_type,
+ typename iterator_traits<_InputIterator2>::value_type>)
while (__first1 != __last1 && __first2 != __last2) {
if (__comp(*__first2, *__first1)) {
* This is a helper function for the merge routines.
* @endif
*/
- template<typename _BidirectionalIter, typename _Distance>
+ template<typename _BidirectionalIterator, typename _Distance>
void
- __merge_without_buffer(_BidirectionalIter __first,
- _BidirectionalIter __middle,
- _BidirectionalIter __last,
+ __merge_without_buffer(_BidirectionalIterator __first,
+ _BidirectionalIterator __middle,
+ _BidirectionalIterator __last,
_Distance __len1, _Distance __len2)
{
if (__len1 == 0 || __len2 == 0)
iter_swap(__first, __middle);
return;
}
- _BidirectionalIter __first_cut = __first;
- _BidirectionalIter __second_cut = __middle;
+ _BidirectionalIterator __first_cut = __first;
+ _BidirectionalIterator __second_cut = __middle;
_Distance __len11 = 0;
_Distance __len22 = 0;
if (__len1 > __len2) {
__len11 = std::distance(__first, __first_cut);
}
rotate(__first_cut, __middle, __second_cut);
- _BidirectionalIter __new_middle = __first_cut;
+ _BidirectionalIterator __new_middle = __first_cut;
advance(__new_middle, std::distance(__middle, __second_cut));
__merge_without_buffer(__first, __first_cut, __new_middle,
__len11, __len22);
* This is a helper function for the merge routines.
* @endif
*/
- template<typename _BidirectionalIter, typename _Distance, typename _Compare>
+ template<typename _BidirectionalIterator, typename _Distance, typename _Compare>
void
- __merge_without_buffer(_BidirectionalIter __first,
- _BidirectionalIter __middle,
- _BidirectionalIter __last,
+ __merge_without_buffer(_BidirectionalIterator __first,
+ _BidirectionalIterator __middle,
+ _BidirectionalIterator __last,
_Distance __len1, _Distance __len2,
_Compare __comp)
{
iter_swap(__first, __middle);
return;
}
- _BidirectionalIter __first_cut = __first;
- _BidirectionalIter __second_cut = __middle;
+ _BidirectionalIterator __first_cut = __first;
+ _BidirectionalIterator __second_cut = __middle;
_Distance __len11 = 0;
_Distance __len22 = 0;
if (__len1 > __len2) {
__len11 = std::distance(__first, __first_cut);
}
rotate(__first_cut, __middle, __second_cut);
- _BidirectionalIter __new_middle = __first_cut;
+ _BidirectionalIterator __new_middle = __first_cut;
advance(__new_middle, std::distance(__middle, __second_cut));
__merge_without_buffer(__first, __first_cut, __new_middle,
__len11, __len22, __comp);
* This is a helper function for the merge routines.
* @endif
*/
- template<typename _BidirectionalIter1, typename _BidirectionalIter2,
+ template<typename _BidirectionalIterator1, typename _BidirectionalIterator2,
typename _Distance>
- _BidirectionalIter1
- __rotate_adaptive(_BidirectionalIter1 __first,
- _BidirectionalIter1 __middle,
- _BidirectionalIter1 __last,
+ _BidirectionalIterator1
+ __rotate_adaptive(_BidirectionalIterator1 __first,
+ _BidirectionalIterator1 __middle,
+ _BidirectionalIterator1 __last,
_Distance __len1, _Distance __len2,
- _BidirectionalIter2 __buffer,
+ _BidirectionalIterator2 __buffer,
_Distance __buffer_size)
{
- _BidirectionalIter2 __buffer_end;
+ _BidirectionalIterator2 __buffer_end;
if (__len1 > __len2 && __len2 <= __buffer_size) {
__buffer_end = copy(__middle, __last, __buffer);
copy_backward(__first, __middle, __last);
* This is a helper function for the merge routines.
* @endif
*/
- template<typename _BidirectionalIter1, typename _BidirectionalIter2,
- typename _BidirectionalIter3>
- _BidirectionalIter3
- __merge_backward(_BidirectionalIter1 __first1, _BidirectionalIter1 __last1,
- _BidirectionalIter2 __first2, _BidirectionalIter2 __last2,
- _BidirectionalIter3 __result)
+ template<typename _BidirectionalIterator1, typename _BidirectionalIterator2,
+ typename _BidirectionalIterator3>
+ _BidirectionalIterator3
+ __merge_backward(_BidirectionalIterator1 __first1, _BidirectionalIterator1 __last1,
+ _BidirectionalIterator2 __first2, _BidirectionalIterator2 __last2,
+ _BidirectionalIterator3 __result)
{
if (__first1 == __last1)
return copy_backward(__first2, __last2, __result);
* This is a helper function for the merge routines.
* @endif
*/
- template<typename _BidirectionalIter1, typename _BidirectionalIter2,
- typename _BidirectionalIter3, typename _Compare>
- _BidirectionalIter3
- __merge_backward(_BidirectionalIter1 __first1, _BidirectionalIter1 __last1,
- _BidirectionalIter2 __first2, _BidirectionalIter2 __last2,
- _BidirectionalIter3 __result,
+ template<typename _BidirectionalIterator1, typename _BidirectionalIterator2,
+ typename _BidirectionalIterator3, typename _Compare>
+ _BidirectionalIterator3
+ __merge_backward(_BidirectionalIterator1 __first1, _BidirectionalIterator1 __last1,
+ _BidirectionalIterator2 __first2, _BidirectionalIterator2 __last2,
+ _BidirectionalIterator3 __result,
_Compare __comp)
{
if (__first1 == __last1)
* This is a helper function for the merge routines.
* @endif
*/
- template<typename _BidirectionalIter, typename _Distance, typename _Pointer>
+ template<typename _BidirectionalIterator, typename _Distance, typename _Pointer>
void
- __merge_adaptive(_BidirectionalIter __first,
- _BidirectionalIter __middle,
- _BidirectionalIter __last,
+ __merge_adaptive(_BidirectionalIterator __first,
+ _BidirectionalIterator __middle,
+ _BidirectionalIterator __last,
_Distance __len1, _Distance __len2,
_Pointer __buffer, _Distance __buffer_size)
{
__merge_backward(__first, __middle, __buffer, __buffer_end, __last);
}
else {
- _BidirectionalIter __first_cut = __first;
- _BidirectionalIter __second_cut = __middle;
+ _BidirectionalIterator __first_cut = __first;
+ _BidirectionalIterator __second_cut = __middle;
_Distance __len11 = 0;
_Distance __len22 = 0;
if (__len1 > __len2) {
__first_cut = upper_bound(__first, __middle, *__second_cut);
__len11 = std::distance(__first, __first_cut);
}
- _BidirectionalIter __new_middle =
+ _BidirectionalIterator __new_middle =
__rotate_adaptive(__first_cut, __middle, __second_cut,
__len1 - __len11, __len22, __buffer,
__buffer_size);
* This is a helper function for the merge routines.
* @endif
*/
- template<typename _BidirectionalIter, typename _Distance, typename _Pointer,
+ template<typename _BidirectionalIterator, typename _Distance, typename _Pointer,
typename _Compare>
void
- __merge_adaptive(_BidirectionalIter __first,
- _BidirectionalIter __middle,
- _BidirectionalIter __last,
+ __merge_adaptive(_BidirectionalIterator __first,
+ _BidirectionalIterator __middle,
+ _BidirectionalIterator __last,
_Distance __len1, _Distance __len2,
_Pointer __buffer, _Distance __buffer_size,
_Compare __comp)
__comp);
}
else {
- _BidirectionalIter __first_cut = __first;
- _BidirectionalIter __second_cut = __middle;
+ _BidirectionalIterator __first_cut = __first;
+ _BidirectionalIterator __second_cut = __middle;
_Distance __len11 = 0;
_Distance __len22 = 0;
if (__len1 > __len2) {
__first_cut = upper_bound(__first, __middle, *__second_cut, __comp);
__len11 = std::distance(__first, __first_cut);
}
- _BidirectionalIter __new_middle =
+ _BidirectionalIterator __new_middle =
__rotate_adaptive(__first_cut, __middle, __second_cut,
__len1 - __len11, __len22, __buffer,
__buffer_size);
* comparisons. Otherwise an NlogN algorithm is used, where N is
* distance(first,last).
*/
- template<typename _BidirectionalIter>
+ template<typename _BidirectionalIterator>
void
- inplace_merge(_BidirectionalIter __first,
- _BidirectionalIter __middle,
- _BidirectionalIter __last)
+ inplace_merge(_BidirectionalIterator __first,
+ _BidirectionalIterator __middle,
+ _BidirectionalIterator __last)
{
- typedef typename iterator_traits<_BidirectionalIter>::value_type
+ typedef typename iterator_traits<_BidirectionalIterator>::value_type
_ValueType;
- typedef typename iterator_traits<_BidirectionalIter>::difference_type
+ typedef typename iterator_traits<_BidirectionalIterator>::difference_type
_DistanceType;
// concept requirements
__glibcpp_function_requires(_Mutable_BidirectionalIteratorConcept<
- _BidirectionalIter>)
+ _BidirectionalIterator>)
__glibcpp_function_requires(_LessThanComparableConcept<_ValueType>)
if (__first == __middle || __middle == __last)
_DistanceType __len1 = std::distance(__first, __middle);
_DistanceType __len2 = std::distance(__middle, __last);
- _Temporary_buffer<_BidirectionalIter, _ValueType> __buf(__first, __last);
+ _Temporary_buffer<_BidirectionalIterator, _ValueType> __buf(__first, __last);
if (__buf.begin() == 0)
__merge_without_buffer(__first, __middle, __last, __len1, __len2);
else
* The comparison function should have the same effects on ordering as
* the function used for the initial sort.
*/
- template<typename _BidirectionalIter, typename _Compare>
+ template<typename _BidirectionalIterator, typename _Compare>
void
- inplace_merge(_BidirectionalIter __first,
- _BidirectionalIter __middle,
- _BidirectionalIter __last,
+ inplace_merge(_BidirectionalIterator __first,
+ _BidirectionalIterator __middle,
+ _BidirectionalIterator __last,
_Compare __comp)
{
- typedef typename iterator_traits<_BidirectionalIter>::value_type
+ typedef typename iterator_traits<_BidirectionalIterator>::value_type
_ValueType;
- typedef typename iterator_traits<_BidirectionalIter>::difference_type
+ typedef typename iterator_traits<_BidirectionalIterator>::difference_type
_DistanceType;
// concept requirements
__glibcpp_function_requires(_Mutable_BidirectionalIteratorConcept<
- _BidirectionalIter>)
+ _BidirectionalIterator>)
__glibcpp_function_requires(_BinaryPredicateConcept<_Compare,
_ValueType, _ValueType>)
_DistanceType __len1 = std::distance(__first, __middle);
_DistanceType __len2 = std::distance(__middle, __last);
- _Temporary_buffer<_BidirectionalIter, _ValueType> __buf(__first, __last);
+ _Temporary_buffer<_BidirectionalIterator, _ValueType> __buf(__first, __last);
if (__buf.begin() == 0)
__merge_without_buffer(__first, __middle, __last, __len1, __len2, __comp);
else
// that their input ranges are sorted and the postcondition that their output
// ranges are sorted.
- template<typename _InputIter1, typename _InputIter2>
+ template<typename _InputIterator1, typename _InputIterator2>
bool
- includes(_InputIter1 __first1, _InputIter1 __last1,
- _InputIter2 __first2, _InputIter2 __last2)
+ includes(_InputIterator1 __first1, _InputIterator1 __last1,
+ _InputIterator2 __first2, _InputIterator2 __last2)
{
// concept requirements
- __glibcpp_function_requires(_InputIteratorConcept<_InputIter1>)
- __glibcpp_function_requires(_InputIteratorConcept<_InputIter2>)
+ __glibcpp_function_requires(_InputIteratorConcept<_InputIterator1>)
+ __glibcpp_function_requires(_InputIteratorConcept<_InputIterator2>)
__glibcpp_function_requires(_SameTypeConcept<
- typename iterator_traits<_InputIter1>::value_type,
- typename iterator_traits<_InputIter2>::value_type>)
+ typename iterator_traits<_InputIterator1>::value_type,
+ typename iterator_traits<_InputIterator2>::value_type>)
__glibcpp_function_requires(_LessThanComparableConcept<
- typename iterator_traits<_InputIter1>::value_type>)
+ typename iterator_traits<_InputIterator1>::value_type>)
while (__first1 != __last1 && __first2 != __last2)
if (*__first2 < *__first1)
return __first2 == __last2;
}
- template<typename _InputIter1, typename _InputIter2, typename _Compare>
+ template<typename _InputIterator1, typename _InputIterator2, typename _Compare>
bool
- includes(_InputIter1 __first1, _InputIter1 __last1,
- _InputIter2 __first2, _InputIter2 __last2, _Compare __comp)
+ includes(_InputIterator1 __first1, _InputIterator1 __last1,
+ _InputIterator2 __first2, _InputIterator2 __last2, _Compare __comp)
{
// concept requirements
- __glibcpp_function_requires(_InputIteratorConcept<_InputIter1>)
- __glibcpp_function_requires(_InputIteratorConcept<_InputIter2>)
+ __glibcpp_function_requires(_InputIteratorConcept<_InputIterator1>)
+ __glibcpp_function_requires(_InputIteratorConcept<_InputIterator2>)
__glibcpp_function_requires(_SameTypeConcept<
- typename iterator_traits<_InputIter1>::value_type,
- typename iterator_traits<_InputIter2>::value_type>)
+ typename iterator_traits<_InputIterator1>::value_type,
+ typename iterator_traits<_InputIterator2>::value_type>)
__glibcpp_function_requires(_BinaryPredicateConcept<_Compare,
- typename iterator_traits<_InputIter1>::value_type,
- typename iterator_traits<_InputIter2>::value_type>)
+ typename iterator_traits<_InputIterator1>::value_type,
+ typename iterator_traits<_InputIterator2>::value_type>)
while (__first1 != __last1 && __first2 != __last2)
if (__comp(*__first2, *__first1))
return __first2 == __last2;
}
- template<typename _InputIter1, typename _InputIter2, typename _OutputIter>
- _OutputIter
- set_union(_InputIter1 __first1, _InputIter1 __last1,
- _InputIter2 __first2, _InputIter2 __last2,
- _OutputIter __result)
+ template<typename _InputIterator1, typename _InputIterator2, typename _OutputIterator>
+ _OutputIterator
+ set_union(_InputIterator1 __first1, _InputIterator1 __last1,
+ _InputIterator2 __first2, _InputIterator2 __last2,
+ _OutputIterator __result)
{
// concept requirements
- __glibcpp_function_requires(_InputIteratorConcept<_InputIter1>)
- __glibcpp_function_requires(_InputIteratorConcept<_InputIter2>)
- __glibcpp_function_requires(_OutputIteratorConcept<_OutputIter,
- typename iterator_traits<_InputIter1>::value_type>)
+ __glibcpp_function_requires(_InputIteratorConcept<_InputIterator1>)
+ __glibcpp_function_requires(_InputIteratorConcept<_InputIterator2>)
+ __glibcpp_function_requires(_OutputIteratorConcept<_OutputIterator,
+ typename iterator_traits<_InputIterator1>::value_type>)
__glibcpp_function_requires(_SameTypeConcept<
- typename iterator_traits<_InputIter1>::value_type,
- typename iterator_traits<_InputIter2>::value_type>)
+ typename iterator_traits<_InputIterator1>::value_type,
+ typename iterator_traits<_InputIterator2>::value_type>)
__glibcpp_function_requires(_LessThanComparableConcept<
- typename iterator_traits<_InputIter1>::value_type>)
+ typename iterator_traits<_InputIterator1>::value_type>)
while (__first1 != __last1 && __first2 != __last2) {
if (*__first1 < *__first2) {
return copy(__first2, __last2, copy(__first1, __last1, __result));
}
- template<typename _InputIter1, typename _InputIter2, typename _OutputIter,
+ template<typename _InputIterator1, typename _InputIterator2, typename _OutputIterator,
typename _Compare>
- _OutputIter
- set_union(_InputIter1 __first1, _InputIter1 __last1,
- _InputIter2 __first2, _InputIter2 __last2,
- _OutputIter __result, _Compare __comp)
+ _OutputIterator
+ set_union(_InputIterator1 __first1, _InputIterator1 __last1,
+ _InputIterator2 __first2, _InputIterator2 __last2,
+ _OutputIterator __result, _Compare __comp)
{
// concept requirements
- __glibcpp_function_requires(_InputIteratorConcept<_InputIter1>)
- __glibcpp_function_requires(_InputIteratorConcept<_InputIter2>)
+ __glibcpp_function_requires(_InputIteratorConcept<_InputIterator1>)
+ __glibcpp_function_requires(_InputIteratorConcept<_InputIterator2>)
__glibcpp_function_requires(_SameTypeConcept<
- typename iterator_traits<_InputIter1>::value_type,
- typename iterator_traits<_InputIter2>::value_type>)
- __glibcpp_function_requires(_OutputIteratorConcept<_OutputIter,
- typename iterator_traits<_InputIter1>::value_type>)
+ typename iterator_traits<_InputIterator1>::value_type,
+ typename iterator_traits<_InputIterator2>::value_type>)
+ __glibcpp_function_requires(_OutputIteratorConcept<_OutputIterator,
+ typename iterator_traits<_InputIterator1>::value_type>)
__glibcpp_function_requires(_BinaryPredicateConcept<_Compare,
- typename iterator_traits<_InputIter1>::value_type,
- typename iterator_traits<_InputIter2>::value_type>)
+ typename iterator_traits<_InputIterator1>::value_type,
+ typename iterator_traits<_InputIterator2>::value_type>)
while (__first1 != __last1 && __first2 != __last2) {
if (__comp(*__first1, *__first2)) {
return copy(__first2, __last2, copy(__first1, __last1, __result));
}
- template<typename _InputIter1, typename _InputIter2, typename _OutputIter>
- _OutputIter
- set_intersection(_InputIter1 __first1, _InputIter1 __last1,
- _InputIter2 __first2, _InputIter2 __last2,
- _OutputIter __result)
+ template<typename _InputIterator1, typename _InputIterator2, typename _OutputIterator>
+ _OutputIterator
+ set_intersection(_InputIterator1 __first1, _InputIterator1 __last1,
+ _InputIterator2 __first2, _InputIterator2 __last2,
+ _OutputIterator __result)
{
// concept requirements
- __glibcpp_function_requires(_InputIteratorConcept<_InputIter1>)
- __glibcpp_function_requires(_InputIteratorConcept<_InputIter2>)
- __glibcpp_function_requires(_OutputIteratorConcept<_OutputIter,
- typename iterator_traits<_InputIter1>::value_type>)
+ __glibcpp_function_requires(_InputIteratorConcept<_InputIterator1>)
+ __glibcpp_function_requires(_InputIteratorConcept<_InputIterator2>)
+ __glibcpp_function_requires(_OutputIteratorConcept<_OutputIterator,
+ typename iterator_traits<_InputIterator1>::value_type>)
__glibcpp_function_requires(_SameTypeConcept<
- typename iterator_traits<_InputIter1>::value_type,
- typename iterator_traits<_InputIter2>::value_type>)
+ typename iterator_traits<_InputIterator1>::value_type,
+ typename iterator_traits<_InputIterator2>::value_type>)
__glibcpp_function_requires(_LessThanComparableConcept<
- typename iterator_traits<_InputIter1>::value_type>)
+ typename iterator_traits<_InputIterator1>::value_type>)
while (__first1 != __last1 && __first2 != __last2)
if (*__first1 < *__first2)
return __result;
}
- template<typename _InputIter1, typename _InputIter2, typename _OutputIter,
+ template<typename _InputIterator1, typename _InputIterator2, typename _OutputIterator,
typename _Compare>
- _OutputIter
- set_intersection(_InputIter1 __first1, _InputIter1 __last1,
- _InputIter2 __first2, _InputIter2 __last2,
- _OutputIter __result, _Compare __comp)
+ _OutputIterator
+ set_intersection(_InputIterator1 __first1, _InputIterator1 __last1,
+ _InputIterator2 __first2, _InputIterator2 __last2,
+ _OutputIterator __result, _Compare __comp)
{
// concept requirements
- __glibcpp_function_requires(_InputIteratorConcept<_InputIter1>)
- __glibcpp_function_requires(_InputIteratorConcept<_InputIter2>)
+ __glibcpp_function_requires(_InputIteratorConcept<_InputIterator1>)
+ __glibcpp_function_requires(_InputIteratorConcept<_InputIterator2>)
__glibcpp_function_requires(_SameTypeConcept<
- typename iterator_traits<_InputIter1>::value_type,
- typename iterator_traits<_InputIter2>::value_type>)
- __glibcpp_function_requires(_OutputIteratorConcept<_OutputIter,
- typename iterator_traits<_InputIter1>::value_type>)
+ typename iterator_traits<_InputIterator1>::value_type,
+ typename iterator_traits<_InputIterator2>::value_type>)
+ __glibcpp_function_requires(_OutputIteratorConcept<_OutputIterator,
+ typename iterator_traits<_InputIterator1>::value_type>)
__glibcpp_function_requires(_BinaryPredicateConcept<_Compare,
- typename iterator_traits<_InputIter1>::value_type,
- typename iterator_traits<_InputIter2>::value_type>)
+ typename iterator_traits<_InputIterator1>::value_type,
+ typename iterator_traits<_InputIterator2>::value_type>)
while (__first1 != __last1 && __first2 != __last2)
if (__comp(*__first1, *__first2))
return __result;
}
- template<typename _InputIter1, typename _InputIter2, typename _OutputIter>
- _OutputIter
- set_difference(_InputIter1 __first1, _InputIter1 __last1,
- _InputIter2 __first2, _InputIter2 __last2,
- _OutputIter __result)
+ template<typename _InputIterator1, typename _InputIterator2, typename _OutputIterator>
+ _OutputIterator
+ set_difference(_InputIterator1 __first1, _InputIterator1 __last1,
+ _InputIterator2 __first2, _InputIterator2 __last2,
+ _OutputIterator __result)
{
// concept requirements
- __glibcpp_function_requires(_InputIteratorConcept<_InputIter1>)
- __glibcpp_function_requires(_InputIteratorConcept<_InputIter2>)
- __glibcpp_function_requires(_OutputIteratorConcept<_OutputIter,
- typename iterator_traits<_InputIter1>::value_type>)
+ __glibcpp_function_requires(_InputIteratorConcept<_InputIterator1>)
+ __glibcpp_function_requires(_InputIteratorConcept<_InputIterator2>)
+ __glibcpp_function_requires(_OutputIteratorConcept<_OutputIterator,
+ typename iterator_traits<_InputIterator1>::value_type>)
__glibcpp_function_requires(_SameTypeConcept<
- typename iterator_traits<_InputIter1>::value_type,
- typename iterator_traits<_InputIter2>::value_type>)
+ typename iterator_traits<_InputIterator1>::value_type,
+ typename iterator_traits<_InputIterator2>::value_type>)
__glibcpp_function_requires(_LessThanComparableConcept<
- typename iterator_traits<_InputIter1>::value_type>)
+ typename iterator_traits<_InputIterator1>::value_type>)
while (__first1 != __last1 && __first2 != __last2)
if (*__first1 < *__first2) {
return copy(__first1, __last1, __result);
}
- template<typename _InputIter1, typename _InputIter2, typename _OutputIter,
+ template<typename _InputIterator1, typename _InputIterator2, typename _OutputIterator,
typename _Compare>
- _OutputIter
- set_difference(_InputIter1 __first1, _InputIter1 __last1,
- _InputIter2 __first2, _InputIter2 __last2,
- _OutputIter __result, _Compare __comp)
+ _OutputIterator
+ set_difference(_InputIterator1 __first1, _InputIterator1 __last1,
+ _InputIterator2 __first2, _InputIterator2 __last2,
+ _OutputIterator __result, _Compare __comp)
{
// concept requirements
- __glibcpp_function_requires(_InputIteratorConcept<_InputIter1>)
- __glibcpp_function_requires(_InputIteratorConcept<_InputIter2>)
+ __glibcpp_function_requires(_InputIteratorConcept<_InputIterator1>)
+ __glibcpp_function_requires(_InputIteratorConcept<_InputIterator2>)
__glibcpp_function_requires(_SameTypeConcept<
- typename iterator_traits<_InputIter1>::value_type,
- typename iterator_traits<_InputIter2>::value_type>)
- __glibcpp_function_requires(_OutputIteratorConcept<_OutputIter,
- typename iterator_traits<_InputIter1>::value_type>)
+ typename iterator_traits<_InputIterator1>::value_type,
+ typename iterator_traits<_InputIterator2>::value_type>)
+ __glibcpp_function_requires(_OutputIteratorConcept<_OutputIterator,
+ typename iterator_traits<_InputIterator1>::value_type>)
__glibcpp_function_requires(_BinaryPredicateConcept<_Compare,
- typename iterator_traits<_InputIter1>::value_type,
- typename iterator_traits<_InputIter2>::value_type>)
+ typename iterator_traits<_InputIterator1>::value_type,
+ typename iterator_traits<_InputIterator2>::value_type>)
while (__first1 != __last1 && __first2 != __last2)
if (__comp(*__first1, *__first2)) {
return copy(__first1, __last1, __result);
}
- template<typename _InputIter1, typename _InputIter2, typename _OutputIter>
- _OutputIter
- set_symmetric_difference(_InputIter1 __first1, _InputIter1 __last1,
- _InputIter2 __first2, _InputIter2 __last2,
- _OutputIter __result)
+ template<typename _InputIterator1, typename _InputIterator2, typename _OutputIterator>
+ _OutputIterator
+ set_symmetric_difference(_InputIterator1 __first1, _InputIterator1 __last1,
+ _InputIterator2 __first2, _InputIterator2 __last2,
+ _OutputIterator __result)
{
// concept requirements
- __glibcpp_function_requires(_InputIteratorConcept<_InputIter1>)
- __glibcpp_function_requires(_InputIteratorConcept<_InputIter2>)
- __glibcpp_function_requires(_OutputIteratorConcept<_OutputIter,
- typename iterator_traits<_InputIter1>::value_type>)
+ __glibcpp_function_requires(_InputIteratorConcept<_InputIterator1>)
+ __glibcpp_function_requires(_InputIteratorConcept<_InputIterator2>)
+ __glibcpp_function_requires(_OutputIteratorConcept<_OutputIterator,
+ typename iterator_traits<_InputIterator1>::value_type>)
__glibcpp_function_requires(_SameTypeConcept<
- typename iterator_traits<_InputIter1>::value_type,
- typename iterator_traits<_InputIter2>::value_type>)
+ typename iterator_traits<_InputIterator1>::value_type,
+ typename iterator_traits<_InputIterator2>::value_type>)
__glibcpp_function_requires(_LessThanComparableConcept<
- typename iterator_traits<_InputIter1>::value_type>)
+ typename iterator_traits<_InputIterator1>::value_type>)
while (__first1 != __last1 && __first2 != __last2)
if (*__first1 < *__first2) {
return copy(__first2, __last2, copy(__first1, __last1, __result));
}
- template<typename _InputIter1, typename _InputIter2, typename _OutputIter,
+ template<typename _InputIterator1, typename _InputIterator2, typename _OutputIterator,
typename _Compare>
- _OutputIter
- set_symmetric_difference(_InputIter1 __first1, _InputIter1 __last1,
- _InputIter2 __first2, _InputIter2 __last2,
- _OutputIter __result,
+ _OutputIterator
+ set_symmetric_difference(_InputIterator1 __first1, _InputIterator1 __last1,
+ _InputIterator2 __first2, _InputIterator2 __last2,
+ _OutputIterator __result,
_Compare __comp)
{
// concept requirements
- __glibcpp_function_requires(_InputIteratorConcept<_InputIter1>)
- __glibcpp_function_requires(_InputIteratorConcept<_InputIter2>)
+ __glibcpp_function_requires(_InputIteratorConcept<_InputIterator1>)
+ __glibcpp_function_requires(_InputIteratorConcept<_InputIterator2>)
__glibcpp_function_requires(_SameTypeConcept<
- typename iterator_traits<_InputIter1>::value_type,
- typename iterator_traits<_InputIter2>::value_type>)
- __glibcpp_function_requires(_OutputIteratorConcept<_OutputIter,
- typename iterator_traits<_InputIter1>::value_type>)
+ typename iterator_traits<_InputIterator1>::value_type,
+ typename iterator_traits<_InputIterator2>::value_type>)
+ __glibcpp_function_requires(_OutputIteratorConcept<_OutputIterator,
+ typename iterator_traits<_InputIterator1>::value_type>)
__glibcpp_function_requires(_BinaryPredicateConcept<_Compare,
- typename iterator_traits<_InputIter1>::value_type,
- typename iterator_traits<_InputIter2>::value_type>)
+ typename iterator_traits<_InputIterator1>::value_type,
+ typename iterator_traits<_InputIterator2>::value_type>)
while (__first1 != __last1 && __first2 != __last2)
if (__comp(*__first1, *__first2)) {
// min_element and max_element, with and without an explicitly supplied
// comparison function.
- template<typename _ForwardIter>
- _ForwardIter
- max_element(_ForwardIter __first, _ForwardIter __last)
+ template<typename _ForwardIterator>
+ _ForwardIterator
+ max_element(_ForwardIterator __first, _ForwardIterator __last)
{
// concept requirements
- __glibcpp_function_requires(_ForwardIteratorConcept<_ForwardIter>)
+ __glibcpp_function_requires(_ForwardIteratorConcept<_ForwardIterator>)
__glibcpp_function_requires(_LessThanComparableConcept<
- typename iterator_traits<_ForwardIter>::value_type>)
+ typename iterator_traits<_ForwardIterator>::value_type>)
if (__first == __last) return __first;
- _ForwardIter __result = __first;
+ _ForwardIterator __result = __first;
while (++__first != __last)
if (*__result < *__first)
__result = __first;
return __result;
}
- template<typename _ForwardIter, typename _Compare>
- _ForwardIter
- max_element(_ForwardIter __first, _ForwardIter __last,
+ template<typename _ForwardIterator, typename _Compare>
+ _ForwardIterator
+ max_element(_ForwardIterator __first, _ForwardIterator __last,
_Compare __comp)
{
// concept requirements
- __glibcpp_function_requires(_ForwardIteratorConcept<_ForwardIter>)
+ __glibcpp_function_requires(_ForwardIteratorConcept<_ForwardIterator>)
__glibcpp_function_requires(_BinaryPredicateConcept<_Compare,
- typename iterator_traits<_ForwardIter>::value_type,
- typename iterator_traits<_ForwardIter>::value_type>)
+ typename iterator_traits<_ForwardIterator>::value_type,
+ typename iterator_traits<_ForwardIterator>::value_type>)
if (__first == __last) return __first;
- _ForwardIter __result = __first;
+ _ForwardIterator __result = __first;
while (++__first != __last)
if (__comp(*__result, *__first)) __result = __first;
return __result;
}
- template<typename _ForwardIter>
- _ForwardIter
- min_element(_ForwardIter __first, _ForwardIter __last)
+ template<typename _ForwardIterator>
+ _ForwardIterator
+ min_element(_ForwardIterator __first, _ForwardIterator __last)
{
// concept requirements
- __glibcpp_function_requires(_ForwardIteratorConcept<_ForwardIter>)
+ __glibcpp_function_requires(_ForwardIteratorConcept<_ForwardIterator>)
__glibcpp_function_requires(_LessThanComparableConcept<
- typename iterator_traits<_ForwardIter>::value_type>)
+ typename iterator_traits<_ForwardIterator>::value_type>)
if (__first == __last) return __first;
- _ForwardIter __result = __first;
+ _ForwardIterator __result = __first;
while (++__first != __last)
if (*__first < *__result)
__result = __first;
return __result;
}
- template<typename _ForwardIter, typename _Compare>
- _ForwardIter
- min_element(_ForwardIter __first, _ForwardIter __last,
+ template<typename _ForwardIterator, typename _Compare>
+ _ForwardIterator
+ min_element(_ForwardIterator __first, _ForwardIterator __last,
_Compare __comp)
{
// concept requirements
- __glibcpp_function_requires(_ForwardIteratorConcept<_ForwardIter>)
+ __glibcpp_function_requires(_ForwardIteratorConcept<_ForwardIterator>)
__glibcpp_function_requires(_BinaryPredicateConcept<_Compare,
- typename iterator_traits<_ForwardIter>::value_type,
- typename iterator_traits<_ForwardIter>::value_type>)
+ typename iterator_traits<_ForwardIterator>::value_type,
+ typename iterator_traits<_ForwardIterator>::value_type>)
if (__first == __last) return __first;
- _ForwardIter __result = __first;
+ _ForwardIterator __result = __first;
while (++__first != __last)
if (__comp(*__first, *__result))
__result = __first;
// next_permutation and prev_permutation, with and without an explicitly
// supplied comparison function.
- template<typename _BidirectionalIter>
+ template<typename _BidirectionalIterator>
bool
- next_permutation(_BidirectionalIter __first, _BidirectionalIter __last)
+ next_permutation(_BidirectionalIterator __first, _BidirectionalIterator __last)
{
// concept requirements
- __glibcpp_function_requires(_BidirectionalIteratorConcept<_BidirectionalIter>)
+ __glibcpp_function_requires(_BidirectionalIteratorConcept<_BidirectionalIterator>)
__glibcpp_function_requires(_LessThanComparableConcept<
- typename iterator_traits<_BidirectionalIter>::value_type>)
+ typename iterator_traits<_BidirectionalIterator>::value_type>)
if (__first == __last)
return false;
- _BidirectionalIter __i = __first;
+ _BidirectionalIterator __i = __first;
++__i;
if (__i == __last)
return false;
--__i;
for(;;) {
- _BidirectionalIter __ii = __i;
+ _BidirectionalIterator __ii = __i;
--__i;
if (*__i < *__ii) {
- _BidirectionalIter __j = __last;
+ _BidirectionalIterator __j = __last;
while (!(*__i < *--__j))
{}
iter_swap(__i, __j);
}
}
- template<typename _BidirectionalIter, typename _Compare>
+ template<typename _BidirectionalIterator, typename _Compare>
bool
- next_permutation(_BidirectionalIter __first, _BidirectionalIter __last,
+ next_permutation(_BidirectionalIterator __first, _BidirectionalIterator __last,
_Compare __comp)
{
// concept requirements
- __glibcpp_function_requires(_BidirectionalIteratorConcept<_BidirectionalIter>)
+ __glibcpp_function_requires(_BidirectionalIteratorConcept<_BidirectionalIterator>)
__glibcpp_function_requires(_BinaryPredicateConcept<_Compare,
- typename iterator_traits<_BidirectionalIter>::value_type,
- typename iterator_traits<_BidirectionalIter>::value_type>)
+ typename iterator_traits<_BidirectionalIterator>::value_type,
+ typename iterator_traits<_BidirectionalIterator>::value_type>)
if (__first == __last)
return false;
- _BidirectionalIter __i = __first;
+ _BidirectionalIterator __i = __first;
++__i;
if (__i == __last)
return false;
--__i;
for(;;) {
- _BidirectionalIter __ii = __i;
+ _BidirectionalIterator __ii = __i;
--__i;
if (__comp(*__i, *__ii)) {
- _BidirectionalIter __j = __last;
+ _BidirectionalIterator __j = __last;
while (!__comp(*__i, *--__j))
{}
iter_swap(__i, __j);
}
}
- template<typename _BidirectionalIter>
+ template<typename _BidirectionalIterator>
bool
- prev_permutation(_BidirectionalIter __first, _BidirectionalIter __last)
+ prev_permutation(_BidirectionalIterator __first, _BidirectionalIterator __last)
{
// concept requirements
- __glibcpp_function_requires(_BidirectionalIteratorConcept<_BidirectionalIter>)
+ __glibcpp_function_requires(_BidirectionalIteratorConcept<_BidirectionalIterator>)
__glibcpp_function_requires(_LessThanComparableConcept<
- typename iterator_traits<_BidirectionalIter>::value_type>)
+ typename iterator_traits<_BidirectionalIterator>::value_type>)
if (__first == __last)
return false;
- _BidirectionalIter __i = __first;
+ _BidirectionalIterator __i = __first;
++__i;
if (__i == __last)
return false;
--__i;
for(;;) {
- _BidirectionalIter __ii = __i;
+ _BidirectionalIterator __ii = __i;
--__i;
if (*__ii < *__i) {
- _BidirectionalIter __j = __last;
+ _BidirectionalIterator __j = __last;
while (!(*--__j < *__i))
{}
iter_swap(__i, __j);
}
}
- template<typename _BidirectionalIter, typename _Compare>
+ template<typename _BidirectionalIterator, typename _Compare>
bool
- prev_permutation(_BidirectionalIter __first, _BidirectionalIter __last,
+ prev_permutation(_BidirectionalIterator __first, _BidirectionalIterator __last,
_Compare __comp)
{
// concept requirements
- __glibcpp_function_requires(_BidirectionalIteratorConcept<_BidirectionalIter>)
+ __glibcpp_function_requires(_BidirectionalIteratorConcept<_BidirectionalIterator>)
__glibcpp_function_requires(_BinaryPredicateConcept<_Compare,
- typename iterator_traits<_BidirectionalIter>::value_type,
- typename iterator_traits<_BidirectionalIter>::value_type>)
+ typename iterator_traits<_BidirectionalIterator>::value_type,
+ typename iterator_traits<_BidirectionalIterator>::value_type>)
if (__first == __last)
return false;
- _BidirectionalIter __i = __first;
+ _BidirectionalIterator __i = __first;
++__i;
if (__i == __last)
return false;
--__i;
for(;;) {
- _BidirectionalIter __ii = __i;
+ _BidirectionalIterator __ii = __i;
--__i;
if (__comp(*__ii, *__i)) {
- _BidirectionalIter __j = __last;
+ _BidirectionalIterator __j = __last;
while (!__comp(*--__j, *__i))
{}
iter_swap(__i, __j);
// find_first_of, with and without an explicitly supplied comparison function.
- template<typename _InputIter, typename _ForwardIter>
- _InputIter
- find_first_of(_InputIter __first1, _InputIter __last1,
- _ForwardIter __first2, _ForwardIter __last2)
+ template<typename _InputIterator, typename _ForwardIterator>
+ _InputIterator
+ find_first_of(_InputIterator __first1, _InputIterator __last1,
+ _ForwardIterator __first2, _ForwardIterator __last2)
{
// concept requirements
- __glibcpp_function_requires(_InputIteratorConcept<_InputIter>)
- __glibcpp_function_requires(_ForwardIteratorConcept<_ForwardIter>)
+ __glibcpp_function_requires(_InputIteratorConcept<_InputIterator>)
+ __glibcpp_function_requires(_ForwardIteratorConcept<_ForwardIterator>)
__glibcpp_function_requires(_EqualOpConcept<
- typename iterator_traits<_InputIter>::value_type,
- typename iterator_traits<_ForwardIter>::value_type>)
+ typename iterator_traits<_InputIterator>::value_type,
+ typename iterator_traits<_ForwardIterator>::value_type>)
for ( ; __first1 != __last1; ++__first1)
- for (_ForwardIter __iter = __first2; __iter != __last2; ++__iter)
+ for (_ForwardIterator __iter = __first2; __iter != __last2; ++__iter)
if (*__first1 == *__iter)
return __first1;
return __last1;
}
- template<typename _InputIter, typename _ForwardIter, typename _BinaryPredicate>
- _InputIter
- find_first_of(_InputIter __first1, _InputIter __last1,
- _ForwardIter __first2, _ForwardIter __last2,
+ template<typename _InputIterator, typename _ForwardIterator, typename _BinaryPredicate>
+ _InputIterator
+ find_first_of(_InputIterator __first1, _InputIterator __last1,
+ _ForwardIterator __first2, _ForwardIterator __last2,
_BinaryPredicate __comp)
{
// concept requirements
- __glibcpp_function_requires(_InputIteratorConcept<_InputIter>)
- __glibcpp_function_requires(_ForwardIteratorConcept<_ForwardIter>)
+ __glibcpp_function_requires(_InputIteratorConcept<_InputIterator>)
+ __glibcpp_function_requires(_ForwardIteratorConcept<_ForwardIterator>)
__glibcpp_function_requires(_EqualOpConcept<
- typename iterator_traits<_InputIter>::value_type,
- typename iterator_traits<_ForwardIter>::value_type>)
+ typename iterator_traits<_InputIterator>::value_type,
+ typename iterator_traits<_ForwardIterator>::value_type>)
__glibcpp_function_requires(_BinaryPredicateConcept<_BinaryPredicate,
- typename iterator_traits<_InputIter>::value_type,
- typename iterator_traits<_ForwardIter>::value_type>)
+ typename iterator_traits<_InputIterator>::value_type,
+ typename iterator_traits<_ForwardIterator>::value_type>)
for ( ; __first1 != __last1; ++__first1)
- for (_ForwardIter __iter = __first2; __iter != __last2; ++__iter)
+ for (_ForwardIterator __iter = __first2; __iter != __last2; ++__iter)
if (__comp(*__first1, *__iter))
return __first1;
return __last1;
// is much faster than for forward iterators.
// find_end for forward iterators.
- template<typename _ForwardIter1, typename _ForwardIter2>
- _ForwardIter1
- __find_end(_ForwardIter1 __first1, _ForwardIter1 __last1,
- _ForwardIter2 __first2, _ForwardIter2 __last2,
+ template<typename _ForwardIterator1, typename _ForwardIterator2>
+ _ForwardIterator1
+ __find_end(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
+ _ForwardIterator2 __first2, _ForwardIterator2 __last2,
forward_iterator_tag, forward_iterator_tag)
{
if (__first2 == __last2)
return __last1;
else {
- _ForwardIter1 __result = __last1;
+ _ForwardIterator1 __result = __last1;
while (1) {
- _ForwardIter1 __new_result
+ _ForwardIterator1 __new_result
= search(__first1, __last1, __first2, __last2);
if (__new_result == __last1)
return __result;
}
}
- template<typename _ForwardIter1, typename _ForwardIter2,
+ template<typename _ForwardIterator1, typename _ForwardIterator2,
typename _BinaryPredicate>
- _ForwardIter1
- __find_end(_ForwardIter1 __first1, _ForwardIter1 __last1,
- _ForwardIter2 __first2, _ForwardIter2 __last2,
+ _ForwardIterator1
+ __find_end(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
+ _ForwardIterator2 __first2, _ForwardIterator2 __last2,
forward_iterator_tag, forward_iterator_tag,
_BinaryPredicate __comp)
{
if (__first2 == __last2)
return __last1;
else {
- _ForwardIter1 __result = __last1;
+ _ForwardIterator1 __result = __last1;
while (1) {
- _ForwardIter1 __new_result
+ _ForwardIterator1 __new_result
= search(__first1, __last1, __first2, __last2, __comp);
if (__new_result == __last1)
return __result;
}
// find_end for bidirectional iterators. Requires partial specialization.
- template<typename _BidirectionalIter1, typename _BidirectionalIter2>
- _BidirectionalIter1
- __find_end(_BidirectionalIter1 __first1, _BidirectionalIter1 __last1,
- _BidirectionalIter2 __first2, _BidirectionalIter2 __last2,
+ template<typename _BidirectionalIterator1, typename _BidirectionalIterator2>
+ _BidirectionalIterator1
+ __find_end(_BidirectionalIterator1 __first1, _BidirectionalIterator1 __last1,
+ _BidirectionalIterator2 __first2, _BidirectionalIterator2 __last2,
bidirectional_iterator_tag, bidirectional_iterator_tag)
{
// concept requirements
- __glibcpp_function_requires(_BidirectionalIteratorConcept<_BidirectionalIter1>)
- __glibcpp_function_requires(_BidirectionalIteratorConcept<_BidirectionalIter2>)
+ __glibcpp_function_requires(_BidirectionalIteratorConcept<_BidirectionalIterator1>)
+ __glibcpp_function_requires(_BidirectionalIteratorConcept<_BidirectionalIterator2>)
- typedef reverse_iterator<_BidirectionalIter1> _RevIter1;
- typedef reverse_iterator<_BidirectionalIter2> _RevIter2;
+ typedef reverse_iterator<_BidirectionalIterator1> _RevIterator1;
+ typedef reverse_iterator<_BidirectionalIterator2> _RevIterator2;
- _RevIter1 __rlast1(__first1);
- _RevIter2 __rlast2(__first2);
- _RevIter1 __rresult = search(_RevIter1(__last1), __rlast1,
- _RevIter2(__last2), __rlast2);
+ _RevIterator1 __rlast1(__first1);
+ _RevIterator2 __rlast2(__first2);
+ _RevIterator1 __rresult = search(_RevIterator1(__last1), __rlast1,
+ _RevIterator2(__last2), __rlast2);
if (__rresult == __rlast1)
return __last1;
else {
- _BidirectionalIter1 __result = __rresult.base();
+ _BidirectionalIterator1 __result = __rresult.base();
advance(__result, -std::distance(__first2, __last2));
return __result;
}
}
- template<typename _BidirectionalIter1, typename _BidirectionalIter2,
+ template<typename _BidirectionalIterator1, typename _BidirectionalIterator2,
typename _BinaryPredicate>
- _BidirectionalIter1
- __find_end(_BidirectionalIter1 __first1, _BidirectionalIter1 __last1,
- _BidirectionalIter2 __first2, _BidirectionalIter2 __last2,
+ _BidirectionalIterator1
+ __find_end(_BidirectionalIterator1 __first1, _BidirectionalIterator1 __last1,
+ _BidirectionalIterator2 __first2, _BidirectionalIterator2 __last2,
bidirectional_iterator_tag, bidirectional_iterator_tag,
_BinaryPredicate __comp)
{
// concept requirements
- __glibcpp_function_requires(_BidirectionalIteratorConcept<_BidirectionalIter1>)
- __glibcpp_function_requires(_BidirectionalIteratorConcept<_BidirectionalIter2>)
+ __glibcpp_function_requires(_BidirectionalIteratorConcept<_BidirectionalIterator1>)
+ __glibcpp_function_requires(_BidirectionalIteratorConcept<_BidirectionalIterator2>)
- typedef reverse_iterator<_BidirectionalIter1> _RevIter1;
- typedef reverse_iterator<_BidirectionalIter2> _RevIter2;
+ typedef reverse_iterator<_BidirectionalIterator1> _RevIterator1;
+ typedef reverse_iterator<_BidirectionalIterator2> _RevIterator2;
- _RevIter1 __rlast1(__first1);
- _RevIter2 __rlast2(__first2);
- _RevIter1 __rresult = search(_RevIter1(__last1), __rlast1,
- _RevIter2(__last2), __rlast2,
+ _RevIterator1 __rlast1(__first1);
+ _RevIterator2 __rlast2(__first2);
+ _RevIterator1 __rresult = search(_RevIterator1(__last1), __rlast1,
+ _RevIterator2(__last2), __rlast2,
__comp);
if (__rresult == __rlast1)
return __last1;
else {
- _BidirectionalIter1 __result = __rresult.base();
+ _BidirectionalIterator1 __result = __rresult.base();
advance(__result, -std::distance(__first2, __last2));
return __result;
}
// Dispatching functions for find_end.
- template<typename _ForwardIter1, typename _ForwardIter2>
- inline _ForwardIter1
- find_end(_ForwardIter1 __first1, _ForwardIter1 __last1,
- _ForwardIter2 __first2, _ForwardIter2 __last2)
+ template<typename _ForwardIterator1, typename _ForwardIterator2>
+ inline _ForwardIterator1
+ find_end(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
+ _ForwardIterator2 __first2, _ForwardIterator2 __last2)
{
// concept requirements
- __glibcpp_function_requires(_ForwardIteratorConcept<_ForwardIter1>)
- __glibcpp_function_requires(_ForwardIteratorConcept<_ForwardIter2>)
+ __glibcpp_function_requires(_ForwardIteratorConcept<_ForwardIterator1>)
+ __glibcpp_function_requires(_ForwardIteratorConcept<_ForwardIterator2>)
__glibcpp_function_requires(_EqualOpConcept<
- typename iterator_traits<_ForwardIter1>::value_type,
- typename iterator_traits<_ForwardIter2>::value_type>)
+ typename iterator_traits<_ForwardIterator1>::value_type,
+ typename iterator_traits<_ForwardIterator2>::value_type>)
return __find_end(__first1, __last1, __first2, __last2,
__iterator_category(__first1),
__iterator_category(__first2));
}
- template<typename _ForwardIter1, typename _ForwardIter2,
+ template<typename _ForwardIterator1, typename _ForwardIterator2,
typename _BinaryPredicate>
- inline _ForwardIter1
- find_end(_ForwardIter1 __first1, _ForwardIter1 __last1,
- _ForwardIter2 __first2, _ForwardIter2 __last2,
+ inline _ForwardIterator1
+ find_end(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
+ _ForwardIterator2 __first2, _ForwardIterator2 __last2,
_BinaryPredicate __comp)
{
// concept requirements
- __glibcpp_function_requires(_ForwardIteratorConcept<_ForwardIter1>)
- __glibcpp_function_requires(_ForwardIteratorConcept<_ForwardIter2>)
+ __glibcpp_function_requires(_ForwardIteratorConcept<_ForwardIterator1>)
+ __glibcpp_function_requires(_ForwardIteratorConcept<_ForwardIterator2>)
__glibcpp_function_requires(_BinaryPredicateConcept<_BinaryPredicate,
- typename iterator_traits<_ForwardIter1>::value_type,
- typename iterator_traits<_ForwardIter2>::value_type>)
+ typename iterator_traits<_ForwardIterator1>::value_type,
+ typename iterator_traits<_ForwardIterator2>::value_type>)
return __find_end(__first1, __last1, __first2, __last2,
__iterator_category(__first1),
projects / thirdparty / gcc.git / commitdiff
