_algo.h File Reference

#include <stl/_algobase.h>
#include <stl/_heap.h>
#include <stl/_iterator.h>
#include <stl/_function_base.h>
#include <stl/_algo.c>

Include dependency graph for _algo.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes
struct	__less_2< _T1, _T2 >

Functions
template<class _InputIter , class _Function >
_STLP_BEGIN_NAMESPACE _STLP_INLINE_LOOP _Function	for_each (_InputIter __first, _InputIter __last, _Function __f)
template<class _InputIter , class _Predicate >
_STLP_INLINE_LOOP	_STLP_DIFFERENCE_TYPE (_InputIter) count_if(_InputIter __first
	for (;__first !=__last;++__first)
template<class _ForwardIter , class _BinaryPredicate >
_STLP_INLINE_LOOP _ForwardIter	adjacent_find (_ForwardIter __first, _ForwardIter __last, _BinaryPredicate __binary_pred)
template<class _ForwardIter >
_STLP_INLINE_LOOP _ForwardIter	adjacent_find (_ForwardIter __first, _ForwardIter __last)
template<class _InputIter , class _Tp , class _Size >
_STLP_INLINE_LOOP void	count (_InputIter __first, _InputIter __last, const _Tp &__val, _Size &__n)
template<class _InputIter , class _Predicate , class _Size >
_STLP_INLINE_LOOP void	count_if (_InputIter __first, _InputIter __last, _Predicate __pred, _Size &__n)
template<class _ForwardIter1 , class _ForwardIter2 >
_ForwardIter1	search (_ForwardIter1 __first1, _ForwardIter1 __last1, _ForwardIter2 __first2, _ForwardIter2 __last2)
template<class _ForwardIter , class _Integer , class _Tp >
_ForwardIter	search_n (_ForwardIter __first, _ForwardIter __last, _Integer __count, const _Tp &__val)
template<class _ForwardIter , class _Integer , class _Tp , class _BinaryPred >
_ForwardIter	search_n (_ForwardIter __first, _ForwardIter __last, _Integer __count, const _Tp &__val, _BinaryPred __binary_pred)
template<class _InputIter , class _ForwardIter >
_InputIter	find_first_of (_InputIter __first1, _InputIter __last1, _ForwardIter __first2, _ForwardIter __last2)
template<class _InputIter , class _ForwardIter , class _BinaryPredicate >
_InputIter	find_first_of (_InputIter __first1, _InputIter __last1, _ForwardIter __first2, _ForwardIter __last2, _BinaryPredicate __comp)
template<class _ForwardIter1 , class _ForwardIter2 >
_ForwardIter1	find_end (_ForwardIter1 __first1, _ForwardIter1 __last1, _ForwardIter2 __first2, _ForwardIter2 __last2)
template<class _ForwardIter1 , class _ForwardIter2 >
_STLP_INLINE_LOOP _ForwardIter2	swap_ranges (_ForwardIter1 __first1, _ForwardIter1 __last1, _ForwardIter2 __first2)
template<class _InputIter , class _OutputIter , class _UnaryOperation >
_STLP_INLINE_LOOP _OutputIter	transform (_InputIter __first, _InputIter __last, _OutputIter __result, _UnaryOperation __opr)
template<class _InputIter1 , class _InputIter2 , class _OutputIter , class _BinaryOperation >
_STLP_INLINE_LOOP _OutputIter	transform (_InputIter1 __first1, _InputIter1 __last1, _InputIter2 __first2, _OutputIter __result, _BinaryOperation __binary_op)
template<class _ForwardIter , class _Predicate , class _Tp >
_STLP_INLINE_LOOP void	replace_if (_ForwardIter __first, _ForwardIter __last, _Predicate __pred, const _Tp &__new_value)
template<class _InputIter , class _OutputIter , class _Tp >
_STLP_INLINE_LOOP _OutputIter	replace_copy (_InputIter __first, _InputIter __last, _OutputIter __result, const _Tp &__old_value, const _Tp &__new_value)
template<class _Iterator , class _OutputIter , class _Predicate , class _Tp >
_STLP_INLINE_LOOP _OutputIter	replace_copy_if (_Iterator __first, _Iterator __last, _OutputIter __result, _Predicate __pred, const _Tp &__new_value)
template<class _ForwardIter , class _Generator >
_STLP_INLINE_LOOP void	generate (_ForwardIter __first, _ForwardIter __last, _Generator __gen)
template<class _OutputIter , class _Size , class _Generator >
_STLP_INLINE_LOOP void	generate_n (_OutputIter __first, _Size __n, _Generator __gen)
template<class _InputIter , class _OutputIter , class _Tp >
_STLP_INLINE_LOOP _OutputIter	remove_copy (_InputIter __first, _InputIter __last, _OutputIter __result, const _Tp &__val)
template<class _InputIter , class _OutputIter , class _Predicate >
_STLP_INLINE_LOOP _OutputIter	remove_copy_if (_InputIter __first, _InputIter __last, _OutputIter __result, _Predicate __pred)
template<class _ForwardIter , class _Tp >
_STLP_INLINE_LOOP _ForwardIter	remove (_ForwardIter __first, _ForwardIter __last, const _Tp &__val)
template<class _ForwardIter , class _Predicate >
_STLP_INLINE_LOOP _ForwardIter	remove_if (_ForwardIter __first, _ForwardIter __last, _Predicate __pred)
template<class _InputIter , class _OutputIter >
_OutputIter	unique_copy (_InputIter __first, _InputIter __last, _OutputIter __result)
template<class _InputIter , class _OutputIter , class _BinaryPredicate >
_OutputIter	unique_copy (_InputIter __first, _InputIter __last, _OutputIter __result, _BinaryPredicate __binary_pred)
template<class _ForwardIter >
_ForwardIter	unique (_ForwardIter __first, _ForwardIter __last)
template<class _ForwardIter , class _BinaryPredicate >
_ForwardIter	unique (_ForwardIter __first, _ForwardIter __last, _BinaryPredicate __binary_pred)
template<class _BidirectionalIter >
_STLP_MOVE_TO_PRIV_NAMESPACE _STLP_INLINE_LOOP void	__reverse (_BidirectionalIter __first, _BidirectionalIter __last, const bidirectional_iterator_tag &)
template<class _RandomAccessIter >
_STLP_INLINE_LOOP void	__reverse (_RandomAccessIter __first, _RandomAccessIter __last, const random_access_iterator_tag &)
template<class _BidirectionalIter >
_STLP_MOVE_TO_STD_NAMESPACE void	reverse (_BidirectionalIter __first, _BidirectionalIter __last)
template<class _BidirectionalIter , class _OutputIter >
_STLP_INLINE_LOOP _OutputIter	reverse_copy (_BidirectionalIter __first, _BidirectionalIter __last, _OutputIter __result)
template<class _ForwardIter >
void	rotate (_ForwardIter __first, _ForwardIter __middle, _ForwardIter __last)
template<class _ForwardIter , class _OutputIter >
_OutputIter	rotate_copy (_ForwardIter __first, _ForwardIter __middle, _ForwardIter __last, _OutputIter __result)
template<class _RandomAccessIter >
void	random_shuffle (_RandomAccessIter __first, _RandomAccessIter __last)
template<class _RandomAccessIter , class _RandomNumberGenerator >
void	random_shuffle (_RandomAccessIter __first, _RandomAccessIter __last, _RandomNumberGenerator &__rand)
template<class _ForwardIter , class _OutputIter , class _Distance >
_OutputIter	random_sample_n (_ForwardIter __first, _ForwardIter __last, _OutputIter __out_ite, const _Distance __n)
template<class _ForwardIter , class _OutputIter , class _Distance , class _RandomNumberGenerator >
_OutputIter	random_sample_n (_ForwardIter __first, _ForwardIter __last, _OutputIter __out_ite, const _Distance __n, _RandomNumberGenerator &__rand)
template<class _InputIter , class _RandomAccessIter >
_RandomAccessIter	random_sample (_InputIter __first, _InputIter __last, _RandomAccessIter __out_first, _RandomAccessIter __out_last)
template<class _InputIter , class _RandomAccessIter , class _RandomNumberGenerator >
_RandomAccessIter	random_sample (_InputIter __first, _InputIter __last, _RandomAccessIter __out_first, _RandomAccessIter __out_last, _RandomNumberGenerator &__rand)
template<class _ForwardIter , class _Predicate >
_ForwardIter	partition (_ForwardIter __first, _ForwardIter __last, _Predicate __pred)
template<class _ForwardIter , class _Predicate >
_ForwardIter	stable_partition (_ForwardIter __first, _ForwardIter __last, _Predicate __pred)
template<class _Size >
_STLP_MOVE_TO_PRIV_NAMESPACE _Size	__lg (_Size __n)
template<class _RandomAccessIter >
_STLP_MOVE_TO_STD_NAMESPACE void	sort (_RandomAccessIter __first, _RandomAccessIter __last)
template<class _RandomAccessIter , class _Compare >
void	sort (_RandomAccessIter __first, _RandomAccessIter __last, _Compare __comp)
template<class _RandomAccessIter >
void	stable_sort (_RandomAccessIter __first, _RandomAccessIter __last)
template<class _RandomAccessIter , class _Compare >
void	stable_sort (_RandomAccessIter __first, _RandomAccessIter __last, _Compare __comp)
template<class _RandomAccessIter >
void	partial_sort (_RandomAccessIter __first, _RandomAccessIter __middle, _RandomAccessIter __last)
template<class _RandomAccessIter , class _Compare >
void	partial_sort (_RandomAccessIter __first, _RandomAccessIter __middle, _RandomAccessIter __last, _Compare __comp)
template<class _InputIter , class _RandomAccessIter >
_RandomAccessIter	partial_sort_copy (_InputIter __first, _InputIter __last, _RandomAccessIter __result_first, _RandomAccessIter __result_last)
template<class _InputIter , class _RandomAccessIter , class _Compare >
_RandomAccessIter	partial_sort_copy (_InputIter __first, _InputIter __last, _RandomAccessIter __result_first, _RandomAccessIter __result_last, _Compare __comp)
template<class _RandomAccessIter >
void	nth_element (_RandomAccessIter __first, _RandomAccessIter __nth, _RandomAccessIter __last)
template<class _RandomAccessIter , class _Compare >
void	nth_element (_RandomAccessIter __first, _RandomAccessIter __nth, _RandomAccessIter __last, _Compare __comp)
template<class _T1 , class _T2 >
__less_2< _T1, _T2 >	__less2 (_T1 *, _T2 *)
template<class _ForwardIter , class _Tp >
_STLP_MOVE_TO_STD_NAMESPACE _ForwardIter	lower_bound (_ForwardIter __first, _ForwardIter __last, const _Tp &__val)
template<class _ForwardIter , class _Tp , class _Compare >
_ForwardIter	lower_bound (_ForwardIter __first, _ForwardIter __last, const _Tp &__val, _Compare __comp)
template<class _ForwardIter , class _Tp , class _Compare1 , class _Compare2 , class _Distance >
_STLP_MOVE_TO_PRIV_NAMESPACE _ForwardIter	__upper_bound (_ForwardIter __first, _ForwardIter __last, const _Tp &__val, _Compare1 __comp1, _Compare2 __comp2, _Distance *)
template<class _ForwardIter , class _Tp >
_STLP_MOVE_TO_STD_NAMESPACE _ForwardIter	upper_bound (_ForwardIter __first, _ForwardIter __last, const _Tp &__val)
template<class _ForwardIter , class _Tp , class _Compare >
_ForwardIter	upper_bound (_ForwardIter __first, _ForwardIter __last, const _Tp &__val, _Compare __comp)
template<class _ForwardIter , class _Tp , class _Compare1 , class _Compare2 , class _Distance >
_STLP_MOVE_TO_PRIV_NAMESPACE pair< _ForwardIter, _ForwardIter >	__equal_range (_ForwardIter __first, _ForwardIter __last, const _Tp &__val, _Compare1 __comp1, _Compare2 __comp2, _Distance *)
template<class _ForwardIter , class _Tp >
_STLP_MOVE_TO_STD_NAMESPACE pair< _ForwardIter, _ForwardIter >	equal_range (_ForwardIter __first, _ForwardIter __last, const _Tp &__val)
template<class _ForwardIter , class _Tp , class _Compare >
pair< _ForwardIter, _ForwardIter >	equal_range (_ForwardIter __first, _ForwardIter __last, const _Tp &__val, _Compare __comp)
template<class _ForwardIter , class _Tp >
bool	binary_search (_ForwardIter __first, _ForwardIter __last, const _Tp &__val)
template<class _ForwardIter , class _Tp , class _Compare >
bool	binary_search (_ForwardIter __first, _ForwardIter __last, const _Tp &__val, _Compare __comp)
template<class _InputIter1 , class _InputIter2 , class _OutputIter >
_OutputIter	merge (_InputIter1 __first1, _InputIter1 __last1, _InputIter2 __first2, _InputIter2 __last2, _OutputIter __result)
template<class _InputIter1 , class _InputIter2 , class _OutputIter , class _Compare >
_OutputIter	merge (_InputIter1 __first1, _InputIter1 __last1, _InputIter2 __first2, _InputIter2 __last2, _OutputIter __result, _Compare __comp)
template<class _BidirectionalIter >
void	inplace_merge (_BidirectionalIter __first, _BidirectionalIter __middle, _BidirectionalIter __last)
template<class _BidirectionalIter , class _Compare >
void	inplace_merge (_BidirectionalIter __first, _BidirectionalIter __middle, _BidirectionalIter __last, _Compare __comp)
template<class _InputIter1 , class _InputIter2 >
bool	includes (_InputIter1 __first1, _InputIter1 __last1, _InputIter2 __first2, _InputIter2 __last2)
template<class _InputIter1 , class _InputIter2 , class _Compare >
bool	includes (_InputIter1 __first1, _InputIter1 __last1, _InputIter2 __first2, _InputIter2 __last2, _Compare __comp)
template<class _InputIter1 , class _InputIter2 , class _OutputIter >
_OutputIter	set_union (_InputIter1 __first1, _InputIter1 __last1, _InputIter2 __first2, _InputIter2 __last2, _OutputIter __result)
template<class _InputIter1 , class _InputIter2 , class _OutputIter , class _Compare >
_OutputIter	set_union (_InputIter1 __first1, _InputIter1 __last1, _InputIter2 __first2, _InputIter2 __last2, _OutputIter __result, _Compare __comp)
template<class _InputIter1 , class _InputIter2 , class _OutputIter >
_OutputIter	set_intersection (_InputIter1 __first1, _InputIter1 __last1, _InputIter2 __first2, _InputIter2 __last2, _OutputIter __result)
template<class _InputIter1 , class _InputIter2 , class _OutputIter , class _Compare >
_OutputIter	set_intersection (_InputIter1 __first1, _InputIter1 __last1, _InputIter2 __first2, _InputIter2 __last2, _OutputIter __result, _Compare __comp)
template<class _InputIter1 , class _InputIter2 , class _OutputIter >
_OutputIter	set_difference (_InputIter1 __first1, _InputIter1 __last1, _InputIter2 __first2, _InputIter2 __last2, _OutputIter __result)
template<class _InputIter1 , class _InputIter2 , class _OutputIter , class _Compare >
_OutputIter	set_difference (_InputIter1 __first1, _InputIter1 __last1, _InputIter2 __first2, _InputIter2 __last2, _OutputIter __result, _Compare __comp)
template<class _InputIter1 , class _InputIter2 , class _OutputIter >
_OutputIter	set_symmetric_difference (_InputIter1 __first1, _InputIter1 __last1, _InputIter2 __first2, _InputIter2 __last2, _OutputIter __result)
template<class _InputIter1 , class _InputIter2 , class _OutputIter , class _Compare >
_OutputIter	set_symmetric_difference (_InputIter1 __first1, _InputIter1 __last1, _InputIter2 __first2, _InputIter2 __last2, _OutputIter __result, _Compare __comp)
template<class _ForwardIter >
_ForwardIter	max_element (_ForwardIter __first, _ForwardIter __last)
template<class _ForwardIter , class _Compare >
_ForwardIter	max_element (_ForwardIter __first, _ForwardIter __last, _Compare __comp)
template<class _ForwardIter >
_ForwardIter	min_element (_ForwardIter __first, _ForwardIter __last)
template<class _ForwardIter , class _Compare >
_ForwardIter	min_element (_ForwardIter __first, _ForwardIter __last, _Compare __comp)
template<class _BidirectionalIter >
bool	next_permutation (_BidirectionalIter __first, _BidirectionalIter __last)
template<class _BidirectionalIter , class _Compare >
bool	next_permutation (_BidirectionalIter __first, _BidirectionalIter __last, _Compare __comp)
template<class _BidirectionalIter >
bool	prev_permutation (_BidirectionalIter __first, _BidirectionalIter __last)
template<class _BidirectionalIter , class _Compare >
bool	prev_permutation (_BidirectionalIter __first, _BidirectionalIter __last, _Compare __comp)
template<class _RandomAccessIter >
bool	is_heap (_RandomAccessIter __first, _RandomAccessIter __last)
template<class _RandomAccessIter , class _StrictWeakOrdering >
bool	is_heap (_RandomAccessIter __first, _RandomAccessIter __last, _StrictWeakOrdering __comp)
template<class _ForwardIter , class _StrictWeakOrdering >
_STLP_MOVE_TO_PRIV_NAMESPACE bool	__is_sorted (_ForwardIter __first, _ForwardIter __last, _StrictWeakOrdering __comp)
template<class _ForwardIter >
_STLP_MOVE_TO_STD_NAMESPACE bool	is_sorted (_ForwardIter __first, _ForwardIter __last)
template<class _ForwardIter , class _StrictWeakOrdering >
bool	is_sorted (_ForwardIter __first, _ForwardIter __last, _StrictWeakOrdering __comp)

Variables
_STLP_INLINE_LOOP _InputIter	__last { return _STLP_PRIV __distance(__first, __last, _STLP_ITERATOR_CATEGORY(__first, _InputIterator))
_STLP_INLINE_LOOP _InputIter _Predicate	__pred
return	__n

Function Documentation

__equal_range()

template<class _ForwardIter , class _Tp , class _Compare1 , class _Compare2 , class _Distance >

_STLP_MOVE_TO_PRIV_NAMESPACE pair< _ForwardIter, _ForwardIter > __equal_range	(	_ForwardIter	__first,
		_ForwardIter	__last,
		const _Tp &	__val,
		_Compare1	__comp1,
		_Compare2	__comp2,
		_Distance *	__dist
	)

Definition at line 1381 of file _algo.c.

                                                                       {
  _Distance __len = _STLP_STD::distance(__first, __last);
  _Distance __half;
 
  while (__len > 0) {
    __half = __len >> 1;
    _ForwardIter __middle = __first;
    _STLP_STD::advance(__middle, __half);
    if (__comp1(*__middle, __val)) {
      _STLP_VERBOSE_ASSERT(!__comp2(__val, *__middle), _StlMsg_INVALID_STRICT_WEAK_PREDICATE)
      __first = __middle;
      ++__first;
      __len = __len - __half - 1;
    }
    else if (__comp2(__val, *__middle)) {
      _STLP_VERBOSE_ASSERT(!__comp1(*__middle, __val), _StlMsg_INVALID_STRICT_WEAK_PREDICATE)
      __len = __half;
    }
    else {
      _ForwardIter __left = _STLP_PRIV __lower_bound(__first, __middle, __val, __comp1, __comp2, __dist);
      //Small optim: If lower_bound haven't found an equivalent value
      //there is no need to call upper_bound.
      if (__comp1(*__left, __val)) {
        _STLP_VERBOSE_ASSERT(!__comp2(__val, *__left), _StlMsg_INVALID_STRICT_WEAK_PREDICATE)
        return pair<_ForwardIter, _ForwardIter>(__left, __left);
      }
      _STLP_STD::advance(__first, __len);
      _ForwardIter __right = _STLP_PRIV __upper_bound(++__middle, __first, __val, __comp1, __comp2, __dist);
      return pair<_ForwardIter, _ForwardIter>(__left, __right);
    }
  }
  return pair<_ForwardIter, _ForwardIter>(__first, __first);
}

Referenced by equal_range().

__is_sorted()

template<class _ForwardIter , class _StrictWeakOrdering >

_STLP_MOVE_TO_PRIV_NAMESPACE bool __is_sorted	(	_ForwardIter	__first,
		_ForwardIter	__last,
		_StrictWeakOrdering	__comp
	)

Definition at line 2001 of file _algo.c.

                                             {
  _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first, __last))
  if (__first == __last)
    return true;
 
  _ForwardIter __next = __first;
  for (++__next; __next != __last; __first = __next, ++__next) {
    if (__comp(*__next, *__first)) {
      _STLP_VERBOSE_ASSERT(!__comp(*__first, *__next), _StlMsg_INVALID_STRICT_WEAK_PREDICATE)
      return false;
    }
  }
 
  return true;
}

Referenced by is_sorted().

__less2()

template<class _T1 , class _T2 >

__less_2< _T1, _T2 > __less2	(	_T1 *	,
		_T2 *
	)

Definition at line 470 of file _algo.h.

{ return __less_2<_T1, _T2>(); }

Referenced by binary_search(), equal_range(), lower_bound(), and upper_bound().

__lg()

template<class _Size >

_STLP_MOVE_TO_PRIV_NAMESPACE _Size __lg ( _Size  __n )

inline

Definition at line 409 of file _algo.h.

                             {
  _Size __k;
  for (__k = 0; __n != 1; __n >>= 1) ++__k;
  return __k;
}

Referenced by sort().

__reverse() [1/2]

template<class _BidirectionalIter >

_STLP_MOVE_TO_PRIV_NAMESPACE _STLP_INLINE_LOOP void __reverse	(	_BidirectionalIter	__first,
		_BidirectionalIter	__last,
		const bidirectional_iterator_tag &
	)

Definition at line 316 of file _algo.h.

                                                                                                     {
  for (; __first != __last && __first != --__last; ++__first)
    _STLP_STD::iter_swap(__first,__last);
}

Referenced by __rotate_aux(), and reverse().

__reverse() [2/2]

template<class _RandomAccessIter >

_STLP_INLINE_LOOP void __reverse	(	_RandomAccessIter	__first,
		_RandomAccessIter	__last,
		const random_access_iterator_tag &
	)

Definition at line 323 of file _algo.h.

                                                                                                   {
  for (; __first < __last; ++__first)
    _STLP_STD::iter_swap(__first, --__last);
}

__upper_bound()

template<class _ForwardIter , class _Tp , class _Compare1 , class _Compare2 , class _Distance >

_STLP_MOVE_TO_PRIV_NAMESPACE _ForwardIter __upper_bound	(	_ForwardIter	__first,
		_ForwardIter	__last,
		const _Tp &	__val,
		_Compare1	__comp1,
		_Compare2	__comp2,
		_Distance *
	)

Definition at line 1356 of file _algo.c.

                                                                             {
  _Distance __len = _STLP_STD::distance(__first, __last);
  _Distance __half;
 
  while (__len > 0) {
    __half = __len >> 1;
    _ForwardIter __middle = __first;
    _STLP_STD::advance(__middle, __half);
    if (__comp2(__val, *__middle)) {
      _STLP_VERBOSE_ASSERT(!__comp1(*__middle, __val), _StlMsg_INVALID_STRICT_WEAK_PREDICATE)
      __len = __half;
    }
    else {
      __first = __middle;
      ++__first;
      __len = __len - __half - 1;
    }
  }
  return __first;
}

Referenced by __equal_range(), and upper_bound().

_STLP_DIFFERENCE_TYPE()

template<class _InputIter , class _Predicate >

_STLP_INLINE_LOOP _STLP_DIFFERENCE_TYPE

(

_InputIter

)

adjacent_find() [1/2]

template<class _ForwardIter >

_STLP_INLINE_LOOP _ForwardIter adjacent_find	(	_ForwardIter	__first,
		_ForwardIter	__last
	)

Definition at line 98 of file _algo.h.

                                                         {
  return adjacent_find(__first, __last,
                       _STLP_PRIV __equal_to(_STLP_VALUE_TYPE(__first, _ForwardIter)));
}

adjacent_find() [2/2]

template<class _ForwardIter , class _BinaryPredicate >

_STLP_INLINE_LOOP _ForwardIter adjacent_find	(	_ForwardIter	__first,
		_ForwardIter	__last,
		_BinaryPredicate	__binary_pred
	)

Definition at line 82 of file _algo.h.

                                              {
  _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first, __last))
  if (__first == __last)
    return __last;
  _ForwardIter __next = __first;
  while(++__next != __last) {
    if (__binary_pred(*__first, *__next))
      return __first;
    __first = __next;
  }
  return __last;
}

Referenced by adjacent_find(), AdjTest::adjfind0(), AdjTest::adjfind1(), AdjTest::adjfind2(), and unique().

binary_search() [1/2]

template<class _ForwardIter , class _Tp >

bool binary_search ( _ForwardIter  __first, _ForwardIter  __last, const _Tp &  __val  )

inline

Definition at line 553 of file _algo.h.

                                     {
  _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first, __last))
  _ForwardIter __i = _STLP_PRIV __lower_bound(__first, __last, __val,
                                              _STLP_PRIV __less2(_STLP_VALUE_TYPE(__first, _ForwardIter), (_Tp*)0),
                                              _STLP_PRIV __less2((_Tp*)0, _STLP_VALUE_TYPE(__first, _ForwardIter)),
                                              _STLP_DISTANCE_TYPE(__first, _ForwardIter));
  return __i != __last && !(__val < *__i);
}

Referenced by BsearchTest::bsearch1(), and BsearchTest::bsearch2().

binary_search() [2/2]

template<class _ForwardIter , class _Tp , class _Compare >

bool binary_search ( _ForwardIter  __first, _ForwardIter  __last, const _Tp &  __val, _Compare  __comp  )

inline

Definition at line 564 of file _algo.h.

                                           {
  _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first, __last))
  _ForwardIter __i = _STLP_PRIV __lower_bound(__first, __last, __val, __comp, __comp,
                                              _STLP_DISTANCE_TYPE(__first, _ForwardIter));
  return __i != __last && !__comp(__val, *__i);
}

count()

template<class _InputIter , class _Tp , class _Size >

_STLP_INLINE_LOOP void count	(	_InputIter	__first,
		_InputIter	__last,
		const _Tp &	__val,
		_Size &	__n
	)

Definition at line 106 of file _algo.h.

                                                                           {
  _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first, __last))
    for ( ; __first != __last; ++__first)
      if (*__first == __val)
        ++__n;
}

count_if()

template<class _InputIter , class _Predicate , class _Size >

_STLP_INLINE_LOOP void count_if	(	_InputIter	__first,
		_InputIter	__last,
		_Predicate	__pred,
		_Size &	__n
	)

Definition at line 115 of file _algo.h.

                                                                               {
  _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first, __last))
  for ( ; __first != __last; ++__first)
    if (__pred(*__first))
      ++__n;
}

Referenced by CountTest::countif1(), FuncTest::func1(), and LogicTest::logicnot().

equal_range() [1/2]

template<class _ForwardIter , class _Tp >

_STLP_MOVE_TO_STD_NAMESPACE pair< _ForwardIter, _ForwardIter > equal_range ( _ForwardIter  __first, _ForwardIter  __last, const _Tp &  __val  )

inline

Definition at line 535 of file _algo.h.

                                                                         {
  _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first, __last))
  return _STLP_PRIV __equal_range(__first, __last, __val,
                                  _STLP_PRIV __less2(_STLP_VALUE_TYPE(__first, _ForwardIter), (_Tp*)0),
                                  _STLP_PRIV __less2((_Tp*)0, _STLP_VALUE_TYPE(__first, _ForwardIter)),
                                  _STLP_DISTANCE_TYPE(__first, _ForwardIter));
}

Referenced by EqualTest::equal_range0(), EqualTest::equal_range1(), EqualTest::equal_range2(), and _Rb_tree< _Key, _Compare, _Value, _KeyOfValue, _Traits, >::erase().

equal_range() [2/2]

template<class _ForwardIter , class _Tp , class _Compare >

pair< _ForwardIter, _ForwardIter > equal_range ( _ForwardIter  __first, _ForwardIter  __last, const _Tp &  __val, _Compare  __comp  )

inline

Definition at line 545 of file _algo.h.

                             {
  _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first, __last))
  return _STLP_PRIV __equal_range(__first, __last, __val, __comp, __comp,
                                  _STLP_DISTANCE_TYPE(__first, _ForwardIter));
}

find_end()

template<class _ForwardIter1 , class _ForwardIter2 >

_ForwardIter1 find_end	(	_ForwardIter1	__first1,
		_ForwardIter1	__last1,
		_ForwardIter2	__first2,
		_ForwardIter2	__last2
	)

Definition at line 273 of file _algo.c.

                                                        {
  _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first1, __last1))
  _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first2, __last2))
  return _STLP_PRIV __find_end(__first1, __last1, __first2, __last2,
#if defined (_STLP_CLASS_PARTIAL_SPECIALIZATION)
                               _STLP_ITERATOR_CATEGORY(__first1, _ForwardIter1),
                               _STLP_ITERATOR_CATEGORY(__first2, _ForwardIter2),
#else
                               forward_iterator_tag(),
                               forward_iterator_tag(),
#endif
                               _STLP_PRIV __equal_to(_STLP_VALUE_TYPE(__first1, _ForwardIter1))
    );
}

find_first_of() [1/2]

template<class _InputIter , class _ForwardIter >

_InputIter find_first_of ( _InputIter  __first1, _InputIter  __last1, _ForwardIter  __first2, _ForwardIter  __last2  )

inline

Definition at line 136 of file _algo.h.

                                                                             {
  _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first1, __last1))
  _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first2, __last2))
  return _STLP_PRIV __find_first_of(__first1, __last1, __first2, __last2);
}

Referenced by AlgTest::find_first_of_nsc_test(), and AlgTest::find_first_of_test().

find_first_of() [2/2]

template<class _InputIter , class _ForwardIter , class _BinaryPredicate >

_InputIter find_first_of ( _InputIter  __first1, _InputIter  __last1, _ForwardIter  __first2, _ForwardIter  __last2, _BinaryPredicate  __comp  )

inline

Definition at line 145 of file _algo.h.

                                                                                    {
  _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first1, __last1))
  _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first2, __last2))
  return _STLP_PRIV __find_first_of(__first1, __last1, __first2, __last2, __comp);
}

for()

for

(

;__first !

= __last; ++__first

)

Definition at line 71 of file _algo.h.

                                        {
    if (__pred(*__first))
      ++__n;
  }

for_each()

template<class _InputIter , class _Function >

_STLP_BEGIN_NAMESPACE _STLP_INLINE_LOOP _Function for_each	(	_InputIter	__first,
		_InputIter	__last,
		_Function	__f
	)

Definition at line 59 of file _algo.h.

                                                               {
  for ( ; __first != __last; ++__first)
    __f(*__first);
  return __f;
}

Referenced by _Locale_impl::_Locale_impl(), BindTest::bind1st1(), BindTest::bind_memfn(), ForeachTest::foreach0(), ForeachTest::foreach1(), and _Locale_impl::~_Locale_impl().

generate()

template<class _ForwardIter , class _Generator >

_STLP_INLINE_LOOP void generate	(	_ForwardIter	__first,
		_ForwardIter	__last,
		_Generator	__gen
	)

Definition at line 222 of file _algo.h.

                                                                      {
  _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first, __last))
  for ( ; __first != __last; ++__first)
    *__first = __gen();
}

generate_n()

template<class _OutputIter , class _Size , class _Generator >

_STLP_INLINE_LOOP void generate_n	(	_OutputIter	__first,
		_Size	__n,
		_Generator	__gen
	)

Definition at line 230 of file _algo.h.

                                                             {
  for ( ; __n > 0; --__n, ++__first)
    *__first = __gen();
}

Referenced by GeneratorTest::genern1(), and GeneratorTest::genern2().

includes() [1/2]

template<class _InputIter1 , class _InputIter2 >

bool includes	(	_InputIter1	__first1,
		_InputIter1	__last1,
		_InputIter2	__first2,
		_InputIter2	__last2
	)

Definition at line 1607 of file _algo.c.

                                                         {
  return _STLP_PRIV __includes(__first1, __last1, __first2, __last2,
                               _STLP_PRIV __less(_STLP_VALUE_TYPE(__first1, _InputIter1)));
}

includes() [2/2]

template<class _InputIter1 , class _InputIter2 , class _Compare >

bool includes	(	_InputIter1	__first1,
		_InputIter1	__last1,
		_InputIter2	__first2,
		_InputIter2	__last2,
		_Compare	__comp
	)

Definition at line 1601 of file _algo.c.

                                                                          {
  return _STLP_PRIV __includes(__first1, __last1, __first2, __last2, __comp);
}

inplace_merge() [1/2]

template<class _BidirectionalIter >

void inplace_merge	(	_BidirectionalIter	__first,
		_BidirectionalIter	__middle,
		_BidirectionalIter	__last
	)

Definition at line 1553 of file _algo.c.

                                              {
  _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first, __middle))
  _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__middle, __last))
  if (__first == __middle || __middle == __last)
    return;
  _STLP_PRIV __inplace_merge_aux(__first, __middle, __last,
                                 _STLP_VALUE_TYPE(__first, _BidirectionalIter), _STLP_DISTANCE_TYPE(__first, _BidirectionalIter),
                                 _STLP_PRIV __less(_STLP_VALUE_TYPE(__first, _BidirectionalIter)));
}

Referenced by InplaceTest::inplmrg1(), and InplaceTest::inplmrg2().

inplace_merge() [2/2]

template<class _BidirectionalIter , class _Compare >

void inplace_merge	(	_BidirectionalIter	__first,
		_BidirectionalIter	__middle,
		_BidirectionalIter	__last,
		_Compare	__comp
	)

Definition at line 1566 of file _algo.c.

                                                               {
  _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first, __middle))
  _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__middle, __last))
  if (__first == __middle || __middle == __last)
    return;
  _STLP_PRIV __inplace_merge_aux(__first, __middle, __last,
                                 _STLP_VALUE_TYPE(__first, _BidirectionalIter), _STLP_DISTANCE_TYPE(__first, _BidirectionalIter),
                                 __comp);
}

is_heap() [1/2]

template<class _RandomAccessIter >

bool is_heap	(	_RandomAccessIter	__first,
		_RandomAccessIter	__last
	)

Definition at line 1985 of file _algo.c.

                                                                  {
  _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first, __last))
  return _STLP_PRIV __is_heap(__first, _STLP_PRIV __less(_STLP_VALUE_TYPE(__first, _RandomAccessIter)), __last - __first);
}

is_heap() [2/2]

template<class _RandomAccessIter , class _StrictWeakOrdering >

bool is_heap	(	_RandomAccessIter	__first,
		_RandomAccessIter	__last,
		_StrictWeakOrdering	__comp
	)

Definition at line 1991 of file _algo.c.

                                         {
  _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first, __last))
  return _STLP_PRIV __is_heap(__first, __comp, __last - __first);
}

is_sorted() [1/2]

template<class _ForwardIter >

_STLP_MOVE_TO_STD_NAMESPACE bool is_sorted ( _ForwardIter  __first, _ForwardIter  __last  )

inline

Definition at line 722 of file _algo.h.

                                                                 {
  return _STLP_PRIV __is_sorted(__first, __last,
                                _STLP_PRIV __less(_STLP_VALUE_TYPE(__first, _ForwardIter)));
}

Referenced by LISTVIEW_InsertItemT(), and slist< _Tp, >::merge().

is_sorted() [2/2]

template<class _ForwardIter , class _StrictWeakOrdering >

bool is_sorted ( _ForwardIter  __first, _ForwardIter  __last, _StrictWeakOrdering  __comp  )

inline

Definition at line 728 of file _algo.h.

                                                  {
  return _STLP_PRIV __is_sorted(__first, __last, __comp);
}

lower_bound() [1/2]

template<class _ForwardIter , class _Tp >

_STLP_MOVE_TO_STD_NAMESPACE _ForwardIter lower_bound ( _ForwardIter  __first, _ForwardIter  __last, const _Tp &  __val  )

inline

Definition at line 481 of file _algo.h.

                                                     {
  _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first, __last))
  return _STLP_PRIV __lower_bound(__first, __last, __val,
                                  _STLP_PRIV __less2(_STLP_VALUE_TYPE(__first, _ForwardIter), (_Tp*)0),
                                  _STLP_PRIV __less2((_Tp*)0, _STLP_VALUE_TYPE(__first, _ForwardIter)),
                                  _STLP_DISTANCE_TYPE(__first, _ForwardIter));
}

Referenced by EqualTest::equal_range2(), ExtractArray(), BoundTest::lwrbnd1(), and BoundTest::lwrbnd2().

lower_bound() [2/2]

template<class _ForwardIter , class _Tp , class _Compare >

_ForwardIter lower_bound ( _ForwardIter  __first, _ForwardIter  __last, const _Tp &  __val, _Compare  __comp  )

inline

Definition at line 491 of file _algo.h.

                                                                   {
  _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first, __last))
  return _STLP_PRIV __lower_bound(__first, __last, __val, __comp, __comp,
                                  _STLP_DISTANCE_TYPE(__first, _ForwardIter));
}

max_element() [1/2]

template<class _ForwardIter >

_ForwardIter max_element	(	_ForwardIter	__first,
		_ForwardIter	__last
	)

Definition at line 1800 of file _algo.c.

                                                                    {
  _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first, __last))
  if (__first == __last) return __first;
  _ForwardIter __result = __first;
  while (++__first != __last)
    if (*__result < *__first) {
      _STLP_VERBOSE_ASSERT(!(*__first < *__result), _StlMsg_INVALID_STRICT_WEAK_PREDICATE)
      __result = __first;
    }
  return __result;
}

Referenced by valarray< _Tp >::max(), MaxTest::maxelem1(), and MaxTest::maxelem2().

max_element() [2/2]

template<class _ForwardIter , class _Compare >

_ForwardIter max_element	(	_ForwardIter	__first,
		_ForwardIter	__last,
		_Compare	__comp
	)

Definition at line 1813 of file _algo.c.

                                          {
  _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first, __last))
  if (__first == __last) return __first;
  _ForwardIter __result = __first;
  while (++__first != __last) {
    if (__comp(*__result, *__first)) {
      _STLP_VERBOSE_ASSERT(!__comp(*__first, *__result), _StlMsg_INVALID_STRICT_WEAK_PREDICATE)
      __result = __first;
    }
  }
  return __result;
}

merge() [1/2]

template<class _InputIter1 , class _InputIter2 , class _OutputIter >

_OutputIter merge	(	_InputIter1	__first1,
		_InputIter1	__last1,
		_InputIter2	__first2,
		_InputIter2	__last2,
		_OutputIter	__result
	)

Definition at line 1419 of file _algo.c.

                                        {
  _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first1, __last1))
  _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first2, __last2))
  while (__first1 != __last1 && __first2 != __last2) {
    if (*__first2 < *__first1) {
      *__result = *__first2;
      ++__first2;
    }
    else {
      *__result = *__first1;
      ++__first1;
    }
    ++__result;
  }
  return _STLP_STD::copy(__first2, __last2, _STLP_STD::copy(__first1, __last1, __result));
}

Referenced by __merge_sort_loop(), create_diff_row_query(), ext4_ext_insert_extent(), gather_merge_data(), MergeTest::merge0(), MergeTest::merge1(), MergeTest::merge2(), MergeChmProperties(), MsiDatabaseMergeW(), nsChannel_SetResponseHeader(), parse_obj_node_param(), and test_IImageList_Merge().

merge() [2/2]

template<class _InputIter1 , class _InputIter2 , class _OutputIter , class _Compare >

_OutputIter merge	(	_InputIter1	__first1,
		_InputIter1	__last1,
		_InputIter2	__first2,
		_InputIter2	__last2,
		_OutputIter	__result,
		_Compare	__comp
	)

Definition at line 1440 of file _algo.c.

                                                         {
  _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first1, __last1))
  _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first2, __last2))
  while (__first1 != __last1 && __first2 != __last2) {
    if (__comp(*__first2, *__first1)) {
      _STLP_VERBOSE_ASSERT(!__comp(*__first1, *__first2), _StlMsg_INVALID_STRICT_WEAK_PREDICATE)
      *__result = *__first2;
      ++__first2;
    }
    else {
      *__result = *__first1;
      ++__first1;
    }
    ++__result;
  }
  return _STLP_STD::copy(__first2, __last2, _STLP_STD::copy(__first1, __last1, __result));
}

min_element() [1/2]

template<class _ForwardIter >

_ForwardIter min_element	(	_ForwardIter	__first,
		_ForwardIter	__last
	)

Definition at line 1828 of file _algo.c.

                                                                    {
  _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first, __last))
  if (__first == __last) return __first;
  _ForwardIter __result = __first;
  while (++__first != __last)
    if (*__first < *__result) {
      _STLP_VERBOSE_ASSERT(!(*__result < *__first), _StlMsg_INVALID_STRICT_WEAK_PREDICATE)
      __result = __first;
    }
  return __result;
}

Referenced by valarray< _Tp >::min(), MinTest::minelem1(), and MinTest::minelem2().

min_element() [2/2]

template<class _ForwardIter , class _Compare >

_ForwardIter min_element	(	_ForwardIter	__first,
		_ForwardIter	__last,
		_Compare	__comp
	)

Definition at line 1841 of file _algo.c.

                                          {
  _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first, __last))
  if (__first == __last) return __first;
  _ForwardIter __result = __first;
  while (++__first != __last) {
    if (__comp(*__first, *__result)) {
      _STLP_VERBOSE_ASSERT(!__comp(*__result, *__first), _StlMsg_INVALID_STRICT_WEAK_PREDICATE)
      __result = __first;
    }
  }
  return __result;
}

next_permutation() [1/2]

template<class _BidirectionalIter >

bool next_permutation	(	_BidirectionalIter	__first,
		_BidirectionalIter	__last
	)

Definition at line 1896 of file _algo.c.

                                                                             {
  _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first, __last))
  return _STLP_PRIV __next_permutation(__first, __last,
                                       _STLP_PRIV __less(_STLP_VALUE_TYPE(__first, _BidirectionalIter)));
}

Referenced by PermTest::nextprm0(), PermTest::nextprm1(), and PermTest::nextprm2().

next_permutation() [2/2]

template<class _BidirectionalIter , class _Compare >

bool next_permutation	(	_BidirectionalIter	__first,
		_BidirectionalIter	__last,
		_Compare	__comp
	)

Definition at line 1903 of file _algo.c.

                                       {
  _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first, __last))
  return _STLP_PRIV __next_permutation(__first, __last, __comp);
}

nth_element() [1/2]

template<class _RandomAccessIter >

void nth_element	(	_RandomAccessIter	__first,
		_RandomAccessIter	__nth,
		_RandomAccessIter	__last
	)

Definition at line 1335 of file _algo.c.

                                           {
  _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first, __nth))
  _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__nth, __last))
  _STLP_PRIV __nth_element(__first, __nth, __last, _STLP_VALUE_TYPE(__first, _RandomAccessIter),
                           _STLP_PRIV __less(_STLP_VALUE_TYPE(__first, _RandomAccessIter)));
}

Referenced by NthElemTest::nthelem0(), NthElemTest::nthelem1(), and NthElemTest::nthelem2().

nth_element() [2/2]

template<class _RandomAccessIter , class _Compare >

void nth_element	(	_RandomAccessIter	__first,
		_RandomAccessIter	__nth,
		_RandomAccessIter	__last,
		_Compare	__comp
	)

Definition at line 1344 of file _algo.c.

                                                            {
  _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first, __nth))
  _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__nth, __last))
  _STLP_PRIV __nth_element(__first, __nth, __last, _STLP_VALUE_TYPE(__first, _RandomAccessIter), __comp);
}

partial_sort() [1/2]

template<class _RandomAccessIter >

void partial_sort	(	_RandomAccessIter	__first,
		_RandomAccessIter	__middle,
		_RandomAccessIter	__last
	)

Definition at line 1236 of file _algo.c.

                                            {
  _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first, __middle))
  _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__middle, __last))
  _STLP_PRIV __partial_sort(__first, __middle, __last, _STLP_VALUE_TYPE(__first, _RandomAccessIter),
                            _STLP_PRIV __less(_STLP_VALUE_TYPE(__first, _RandomAccessIter)));
}

Referenced by __introsort_loop(), PartialTest::parsrt0(), PartialTest::parsrt1(), and PartialTest::parsrt2().

partial_sort() [2/2]

template<class _RandomAccessIter , class _Compare >

void partial_sort	(	_RandomAccessIter	__first,
		_RandomAccessIter	__middle,
		_RandomAccessIter	__last,
		_Compare	__comp
	)

Definition at line 1245 of file _algo.c.

                                                             {
  _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first, __middle))
  _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__middle, __last))
  _STLP_PRIV __partial_sort(__first, __middle, __last, _STLP_VALUE_TYPE(__first, _RandomAccessIter), __comp);
}

partial_sort_copy() [1/2]

template<class _InputIter , class _RandomAccessIter >

_RandomAccessIter partial_sort_copy	(	_InputIter	__first,
		_InputIter	__last,
		_RandomAccessIter	__result_first,
		_RandomAccessIter	__result_last
	)

Definition at line 1287 of file _algo.c.

                                                                                     {
  _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first, __last))
  _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__result_first, __result_last))
  return _STLP_PRIV __partial_sort_copy(__first, __last, __result_first, __result_last,
                                        _STLP_PRIV __less(_STLP_VALUE_TYPE(__first, _InputIter)),
                                        _STLP_DISTANCE_TYPE(__result_first, _RandomAccessIter),
                                        _STLP_VALUE_TYPE(__first, _InputIter));
}

Referenced by PartialTest::parsrtc0(), PartialTest::parsrtc1(), and PartialTest::parsrtc2().

partial_sort_copy() [2/2]

template<class _InputIter , class _RandomAccessIter , class _Compare >

_RandomAccessIter partial_sort_copy	(	_InputIter	__first,
		_InputIter	__last,
		_RandomAccessIter	__result_first,
		_RandomAccessIter	__result_last,
		_Compare	__comp
	)

Definition at line 1299 of file _algo.c.

                                                                    {
  _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first, __last))
  _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__result_first, __result_last))
  return _STLP_PRIV __partial_sort_copy(__first, __last, __result_first, __result_last,
                                        __comp,
                                        _STLP_DISTANCE_TYPE(__result_first, _RandomAccessIter),
                                        _STLP_VALUE_TYPE(__first, _InputIter));
}

partition()

template<class _ForwardIter , class _Predicate >

_ForwardIter partition	(	_ForwardIter	__first,
		_ForwardIter	__last,
		_Predicate	__pred
	)

Definition at line 738 of file _algo.c.

                                                                                       {
  _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first, __last))
  return _STLP_PRIV __partition(__first, __last, __pred, _STLP_ITERATOR_CATEGORY(__first, _ForwardIter));
}

prev_permutation() [1/2]

template<class _BidirectionalIter >

bool prev_permutation	(	_BidirectionalIter	__first,
		_BidirectionalIter	__last
	)

Definition at line 1947 of file _algo.c.

                                                                             {
  _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first, __last))
  return _STLP_PRIV __prev_permutation(__first, __last,
                                       _STLP_PRIV __less(_STLP_VALUE_TYPE(__first, _BidirectionalIter)));
}

Referenced by PermTest::prevprm0(), PermTest::prevprm1(), and PermTest::prevprm2().

prev_permutation() [2/2]

template<class _BidirectionalIter , class _Compare >

bool prev_permutation	(	_BidirectionalIter	__first,
		_BidirectionalIter	__last,
		_Compare	__comp
	)

Definition at line 1954 of file _algo.c.

                                       {
  _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first, __last))
  return _STLP_PRIV __prev_permutation(__first, __last, __comp);
}

random_sample() [1/2]

template<class _InputIter , class _RandomAccessIter >

_RandomAccessIter random_sample	(	_InputIter	__first,
		_InputIter	__last,
		_RandomAccessIter	__out_first,
		_RandomAccessIter	__out_last
	)

Definition at line 650 of file _algo.c.

                                                                           {
  _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first, __last))
  _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__out_first, __out_last))
  return _STLP_PRIV __random_sample(__first, __last,
                                    __out_first, __out_last - __out_first);
}

random_sample() [2/2]

template<class _InputIter , class _RandomAccessIter , class _RandomNumberGenerator >

_RandomAccessIter random_sample	(	_InputIter	__first,
		_InputIter	__last,
		_RandomAccessIter	__out_first,
		_RandomAccessIter	__out_last,
		_RandomNumberGenerator &	__rand
	)

Definition at line 660 of file _algo.c.

                                              {
  _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first, __last))
  _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__out_first, __out_last))
  return _STLP_PRIV __random_sample(__first, __last,
                                    __out_first, __rand,
                                    __out_last - __out_first);
}

random_sample_n() [1/2]

template<class _ForwardIter , class _OutputIter , class _Distance >

_OutputIter random_sample_n	(	_ForwardIter	__first,
		_ForwardIter	__last,
		_OutputIter	__out_ite,
		const _Distance	__n
	)

Definition at line 560 of file _algo.c.

                                                                        {
  _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first, __last))
  _Distance __remaining = _STLP_STD::distance(__first, __last);
  _Distance __m = (min) (__n, __remaining);
 
  while (__m > 0) {
    if (_STLP_PRIV __random_number(__remaining) < __m) {
      *__out_ite = *__first;
      ++__out_ite;
      --__m;
    }
 
    --__remaining;
    ++__first;
  }
  return __out_ite;
}

random_sample_n() [2/2]

template<class _ForwardIter , class _OutputIter , class _Distance , class _RandomNumberGenerator >

_OutputIter random_sample_n	(	_ForwardIter	__first,
		_ForwardIter	__last,
		_OutputIter	__out_ite,
		const _Distance	__n,
		_RandomNumberGenerator &	__rand
	)

Definition at line 582 of file _algo.c.

                                                            {
  _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first, __last))
  _Distance __remaining = _STLP_STD::distance(__first, __last);
  _Distance __m = (min) (__n, __remaining);
 
  while (__m > 0) {
    if (__rand(__remaining) < __m) {
      *__out_ite = *__first;
      ++__out_ite;
      --__m;
    }
 
    --__remaining;
    ++__first;
  }
  return __out_ite;
}

random_shuffle() [1/2]

template<class _RandomAccessIter >

void random_shuffle	(	_RandomAccessIter	__first,
		_RandomAccessIter	__last
	)

Definition at line 540 of file _algo.c.

                                              {
  _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first, __last))
  if (__first == __last) return;
  for (_RandomAccessIter __i = __first + 1; __i != __last; ++__i)
    iter_swap(__i, __first + _STLP_PRIV __random_number((__i - __first) + 1));
}

Referenced by RndShuffleTest::rndshuf0(), and RndShuffleTest::rndshuf2().

random_shuffle() [2/2]

template<class _RandomAccessIter , class _RandomNumberGenerator >

void random_shuffle	(	_RandomAccessIter	__first,
		_RandomAccessIter	__last,
		_RandomNumberGenerator &	__rand
	)

Definition at line 549 of file _algo.c.

                                                    {
  _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first, __last))
  if (__first == __last) return;
  for (_RandomAccessIter __i = __first + 1; __i != __last; ++__i)
    iter_swap(__i, __first + __rand((__i - __first) + 1));
}

remove()

template<class _ForwardIter , class _Tp >

_STLP_INLINE_LOOP _ForwardIter remove	(	_ForwardIter	__first,
		_ForwardIter	__last,
		const _Tp &	__val
	)

Definition at line 265 of file _algo.h.

                                                                    {
  _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first, __last))
  __first = find(__first, __last, __val);
  if (__first == __last)
    return __first;
  else {
    _ForwardIter __next = __first;
    return remove_copy(++__next, __last, __first, __val);
  }
}

remove_copy()

template<class _InputIter , class _OutputIter , class _Tp >

_STLP_INLINE_LOOP _OutputIter remove_copy	(	_InputIter	__first,
		_InputIter	__last,
		_OutputIter	__result,
		const _Tp &	__val
	)

Definition at line 239 of file _algo.h.

                                                                                          {
  _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first, __last))
  for ( ; __first != __last; ++__first) {
    if (!(*__first == __val)) {
      *__result = *__first;
      ++__result;
    }
  }
  return __result;
}

Referenced by RmCpTest::remcopy1(), and remove().

remove_copy_if()

template<class _InputIter , class _OutputIter , class _Predicate >

_STLP_INLINE_LOOP _OutputIter remove_copy_if	(	_InputIter	__first,
		_InputIter	__last,
		_OutputIter	__result,
		_Predicate	__pred
	)

Definition at line 252 of file _algo.h.

                                                                                               {
  _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first, __last))
  for ( ; __first != __last; ++__first) {
    if (!__pred(*__first)) {
      *__result = *__first;
      ++__result;
    }
  }
  return __result;
}

Referenced by RmCpTest::remcpif1(), and remove_if().

remove_if()

template<class _ForwardIter , class _Predicate >

_STLP_INLINE_LOOP _ForwardIter remove_if	(	_ForwardIter	__first,
		_ForwardIter	__last,
		_Predicate	__pred
	)

Definition at line 278 of file _algo.h.

                                                                        {
  _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first, __last))
  __first = find_if(__first, __last, __pred);
  if ( __first == __last )
    return __first;
  else {
    _ForwardIter __next = __first;
    return remove_copy_if(++__next, __last, __first, __pred);
  }
}

Referenced by BindTest::bind1st1(), and RmCpTest::remif1().

replace_copy()

template<class _InputIter , class _OutputIter , class _Tp >

_STLP_INLINE_LOOP _OutputIter replace_copy	(	_InputIter	__first,
		_InputIter	__last,
		_OutputIter	__result,
		const _Tp &	__old_value,
		const _Tp &	__new_value
	)

Definition at line 199 of file _algo.h.

                                                             {
  _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first, __last))
  for ( ; __first != __last; ++__first, ++__result)
    *__result = *__first == __old_value ? __new_value : *__first;
  return __result;
}

Referenced by RmCpTest::replcpy1().

replace_copy_if()

template<class _Iterator , class _OutputIter , class _Predicate , class _Tp >

_STLP_INLINE_LOOP _OutputIter replace_copy_if	(	_Iterator	__first,
		_Iterator	__last,
		_OutputIter	__result,
		_Predicate	__pred,
		const _Tp &	__new_value
	)

Definition at line 209 of file _algo.h.

                                                           {
  _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first, __last))
  for ( ; __first != __last; ++__first, ++__result)
    *__result = __pred(*__first) ? __new_value : *__first;
  return __result;
}

Referenced by RmCpTest::repcpif1().

replace_if()

template<class _ForwardIter , class _Predicate , class _Tp >

_STLP_INLINE_LOOP void replace_if	(	_ForwardIter	__first,
		_ForwardIter	__last,
		_Predicate	__pred,
		const _Tp &	__new_value
	)

Definition at line 190 of file _algo.h.

                                                                                                 {
  _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first, __last))
  for ( ; __first != __last; ++__first)
    if (__pred(*__first))
      *__first = __new_value;
}

Referenced by BindTest::bind2nd1(), BindTest::bind2nd2(), and RmCpTest::replif1().

reverse()

template<class _BidirectionalIter >

_STLP_MOVE_TO_STD_NAMESPACE void reverse ( _BidirectionalIter  __first, _BidirectionalIter  __last  )

inline

Definition at line 332 of file _algo.h.

                                                               {
  _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first, __last))
  _STLP_PRIV __reverse(__first, __last, _STLP_ITERATOR_CATEGORY(__first, _BidirectionalIter));
}

reverse_copy()

template<class _BidirectionalIter , class _OutputIter >

_STLP_INLINE_LOOP _OutputIter reverse_copy	(	_BidirectionalIter	__first,
		_BidirectionalIter	__last,
		_OutputIter	__result
	)

Definition at line 339 of file _algo.h.

                                               {
  _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first, __last))
  while (__first != __last) {
    --__last;
    *__result = *__last;
    ++__result;
  }
  return __result;
}

Referenced by RmCpTest::revcopy1().

rotate()

template<class _ForwardIter >

void rotate	(	_ForwardIter	__first,
		_ForwardIter	__middle,
		_ForwardIter	__last
	)

Definition at line 519 of file _algo.c.

                                                                              {
  _STLP_PRIV __rotate(__first, __middle, __last);
}

Referenced by ft_stroke_border_arcto(), ft_stroker_arcto(), ft_stroker_cap(), FT_Stroker_ConicTo(), FT_Stroker_CubicTo(), ft_stroker_inside(), ft_stroker_outside(), GdipRotateMatrix(), RotateTest::rotate0(), RotateTest::rotate1(), and test_rotate().

rotate_copy()

template<class _ForwardIter , class _OutputIter >

_OutputIter rotate_copy ( _ForwardIter  __first, _ForwardIter  __middle, _ForwardIter  __last, _OutputIter  __result  )

inline

Definition at line 355 of file _algo.h.

                                                                          {
  return _STLP_STD::copy(__first, __middle, copy(__middle, __last, __result));
}

Referenced by RotateTest::rotcopy0(), and RotateTest::rotcopy1().

search()

template<class _ForwardIter1 , class _ForwardIter2 >

_ForwardIter1 search	(	_ForwardIter1	__first1,
		_ForwardIter1	__last1,
		_ForwardIter2	__first2,
		_ForwardIter2	__last2
	)

Definition at line 112 of file _algo.c.

                                                                    {
  _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first1, __last1))
  _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first2, __last2))
  // Test for empty ranges
  if (__first1 == __last1 || __first2 == __last2)
    return __first1;
 
  // Test for a pattern of length 1.
  _ForwardIter2 __p1(__first2);
 
  if ( ++__p1 == __last2 )
    return find(__first1, __last1, *__first2);
 
  // General case.
 
  for ( ; ; ) { // __first1 != __last1 will be checked in find below
    __first1 = find(__first1, __last1, *__first2);
    if (__first1 == __last1)
      return __last1;
 
    _ForwardIter2 __p = __p1;
    _ForwardIter1 __current = __first1;
    if (++__current == __last1)
      return __last1;
 
    while (*__current == *__p) {
      if (++__p == __last2)
        return __first1;
      if (++__current == __last1)
        return __last1;
    }
 
    ++__first1;
  }
  return __first1;
}

search_n() [1/2]

template<class _ForwardIter , class _Integer , class _Tp >

_ForwardIter search_n	(	_ForwardIter	__first,
		_ForwardIter	__last,
		_Integer	__count,
		const _Tp &	__val
	)

Definition at line 246 of file _algo.c.

                                                          {
  _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first, __last))
  if (__count <= 0)
    return __first;
  if (__count == 1)
    //We use find when __count == 1 to use potential find overload.
    return find(__first, __last, __val);
  return _STLP_PRIV __search_n(__first, __last, __count, __val, equal_to<_Tp>(),
                               _STLP_DISTANCE_TYPE(__first, _ForwardIter),
                               _STLP_ITERATOR_CATEGORY(__first, _ForwardIter));
}

Referenced by AlgTest::search_n_test().

search_n() [2/2]

template<class _ForwardIter , class _Integer , class _Tp , class _BinaryPred >

_ForwardIter search_n	(	_ForwardIter	__first,
		_ForwardIter	__last,
		_Integer	__count,
		const _Tp &	__val,
		_BinaryPred	__binary_pred
	)

Definition at line 260 of file _algo.c.

                                                 {
  _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first, __last))
  if (__count <= 0)
    return __first;
  return _STLP_PRIV __search_n(__first, __last, __count, __val, __binary_pred,
                               _STLP_DISTANCE_TYPE(__first, _ForwardIter),
                               _STLP_ITERATOR_CATEGORY(__first, _ForwardIter));
}

set_difference() [1/2]

template<class _InputIter1 , class _InputIter2 , class _OutputIter >

_OutputIter set_difference	(	_InputIter1	__first1,
		_InputIter1	__last1,
		_InputIter2	__first2,
		_InputIter2	__last2,
		_OutputIter	__result
	)

Definition at line 1732 of file _algo.c.

                                                 {
  return _STLP_PRIV __set_difference(__first1, __last1, __first2, __last2, __result,
                                     _STLP_PRIV __less(_STLP_VALUE_TYPE(__first1, _InputIter1)));
}

Referenced by SetDifferenceTest::setdiff0(), SetDifferenceTest::setdiff1(), and SetDifferenceTest::setdiff2().

set_difference() [2/2]

template<class _InputIter1 , class _InputIter2 , class _OutputIter , class _Compare >

_OutputIter set_difference	(	_InputIter1	__first1,
		_InputIter1	__last1,
		_InputIter2	__first2,
		_InputIter2	__last2,
		_OutputIter	__result,
		_Compare	__comp
	)

Definition at line 1741 of file _algo.c.

                                                                  {
  return _STLP_PRIV __set_difference(__first1, __last1, __first2, __last2, __result, __comp);
}

set_intersection() [1/2]

template<class _InputIter1 , class _InputIter2 , class _OutputIter >

_OutputIter set_intersection	(	_InputIter1	__first1,
		_InputIter1	__last1,
		_InputIter2	__first2,
		_InputIter2	__last2,
		_OutputIter	__result
	)

Definition at line 1689 of file _algo.c.

                                                   {
  return _STLP_PRIV __set_intersection(__first1, __last1, __first2, __last2, __result,
                                       _STLP_PRIV __less(_STLP_VALUE_TYPE(__first1, _InputIter1)));
}

Referenced by SetIntersectionTest::setintr0(), SetIntersectionTest::setintr1(), and SetIntersectionTest::setintr2().

set_intersection() [2/2]

template<class _InputIter1 , class _InputIter2 , class _OutputIter , class _Compare >

_OutputIter set_intersection	(	_InputIter1	__first1,
		_InputIter1	__last1,
		_InputIter2	__first2,
		_InputIter2	__last2,
		_OutputIter	__result,
		_Compare	__comp
	)

Definition at line 1698 of file _algo.c.

                                                                    {
  return _STLP_PRIV __set_intersection(__first1, __last1, __first2, __last2, __result, __comp);
}

set_symmetric_difference() [1/2]

template<class _InputIter1 , class _InputIter2 , class _OutputIter >

_OutputIter set_symmetric_difference	(	_InputIter1	__first1,
		_InputIter1	__last1,
		_InputIter2	__first2,
		_InputIter2	__last2,
		_OutputIter	__result
	)

Definition at line 1780 of file _algo.c.

                                               {
  return _STLP_PRIV __set_symmetric_difference(__first1, __last1, __first2, __last2, __result,
                                               _STLP_PRIV __less(_STLP_VALUE_TYPE(__first1, _InputIter1)));
}

Referenced by SetDifferenceTest::setsymd0(), SetDifferenceTest::setsymd1(), and SetDifferenceTest::setsymd2().

set_symmetric_difference() [2/2]

template<class _InputIter1 , class _InputIter2 , class _OutputIter , class _Compare >

_OutputIter set_symmetric_difference	(	_InputIter1	__first1,
		_InputIter1	__last1,
		_InputIter2	__first2,
		_InputIter2	__last2,
		_OutputIter	__result,
		_Compare	__comp
	)

Definition at line 1789 of file _algo.c.

                                          {
  return _STLP_PRIV __set_symmetric_difference(__first1, __last1, __first2, __last2, __result, __comp);
}

set_union() [1/2]

template<class _InputIter1 , class _InputIter2 , class _OutputIter >

_OutputIter set_union	(	_InputIter1	__first1,
		_InputIter1	__last1,
		_InputIter2	__first2,
		_InputIter2	__last2,
		_OutputIter	__result
	)

Definition at line 1646 of file _algo.c.

                                            {
  return _STLP_PRIV __set_union(__first1, __last1, __first2, __last2, __result,
                                _STLP_PRIV __less(_STLP_VALUE_TYPE(__first1, _InputIter1)));
}

Referenced by SetUnionTest::setunon0(), SetUnionTest::setunon1(), and SetUnionTest::setunon2().

set_union() [2/2]

template<class _InputIter1 , class _InputIter2 , class _OutputIter , class _Compare >

_OutputIter set_union	(	_InputIter1	__first1,
		_InputIter1	__last1,
		_InputIter2	__first2,
		_InputIter2	__last2,
		_OutputIter	__result,
		_Compare	__comp
	)

Definition at line 1655 of file _algo.c.

                                                             {
  return _STLP_PRIV __set_union(__first1, __last1, __first2, __last2, __result, __comp);
}

sort() [1/2]

template<class _RandomAccessIter >

_STLP_MOVE_TO_STD_NAMESPACE void sort	(	_RandomAccessIter	__first,
		_RandomAccessIter	__last
	)

Definition at line 993 of file _algo.c.

                                                               {
  _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first, __last))
  if (__first != __last) {
    _STLP_PRIV __introsort_loop(__first, __last,
                                _STLP_VALUE_TYPE(__first, _RandomAccessIter),
                                _STLP_PRIV __lg(__last - __first) * 2,
                                _STLP_PRIV __less(_STLP_VALUE_TYPE(__first, _RandomAccessIter)));
    _STLP_PRIV __final_insertion_sort(__first, __last,
                                      _STLP_PRIV __less(_STLP_VALUE_TYPE(__first, _RandomAccessIter)));
  }
}

Referenced by _Function_class_(), BnegateTest::bnegate1(), BnegateTest::bnegate2(), LocaleTest::collate_by_name(), LocaleTest::collate_facet(), FindProgramDlg::CompareFunc(), FuncTest::func2(), FuncTest::func3(), CDefView::GetArrangeParam(), GreaterTest::greatereq(), GreaterTest::greatert(), IncludesTest::incl2(), LessTest::lesseqt(), LessTest::lesst(), ListView_SortEx(), BtrfsDeviceAdd::populate_device_tree(), psh_hint_table_activate_mask(), psh_hint_table_find_strong_points(), CDefView::Rearrange(), should_balance_chunk(), SortTest::sort1(), SortTest::sort2(), SortTest::sort3(), AlgTest::sort_test(), test_GetDefaultColumn(), test_ldap_parse_sort_control(), UnorderedTest::umap(), UnorderedTest::umultimap(), UnorderedTest::umultiset(), UnorderedTest::uset(), xsltComputeSortResult(), and xsltComputeSortResultInternal().

sort() [2/2]

template<class _RandomAccessIter , class _Compare >

void sort	(	_RandomAccessIter	__first,
		_RandomAccessIter	__last,
		_Compare	__comp
	)

Definition at line 1006 of file _algo.c.

                                                                                {
  _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first, __last))
  if (__first != __last) {
    _STLP_PRIV __introsort_loop(__first, __last,
                                _STLP_VALUE_TYPE(__first, _RandomAccessIter),
                                _STLP_PRIV __lg(__last - __first) * 2, __comp);
    _STLP_PRIV __final_insertion_sort(__first, __last, __comp);
  }
}

stable_partition()

template<class _ForwardIter , class _Predicate >

_ForwardIter stable_partition	(	_ForwardIter	__first,
		_ForwardIter	__last,
		_Predicate	__pred
	)

Definition at line 866 of file _algo.c.

                                                                               {
  _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first, __last))
  for (;;) {
    if (__first == __last)
      return __first;
    else if (__pred(*__first))
      ++__first;
    else
      break;
  }
  return _STLP_PRIV __stable_partition_aux(__first, __last, __pred,
                                           _STLP_ITERATOR_CATEGORY(__first, _ForwardIter));
}

Referenced by PartitionTest::stblptn0(), and PartitionTest::stblptn1().

stable_sort() [1/2]

template<class _RandomAccessIter >

void stable_sort	(	_RandomAccessIter	__first,
		_RandomAccessIter	__last
	)

Definition at line 1197 of file _algo.c.

                                           {
  _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first, __last))
  _STLP_PRIV __stable_sort_aux(__first, __last,
                               _STLP_VALUE_TYPE(__first, _RandomAccessIter),
                               _STLP_DISTANCE_TYPE(__first, _RandomAccessIter),
                               _STLP_PRIV __less(_STLP_VALUE_TYPE(__first, _RandomAccessIter)));
}

Referenced by SortTest::stblsrt1(), and SortTest::stblsrt2().

stable_sort() [2/2]

template<class _RandomAccessIter , class _Compare >

void stable_sort	(	_RandomAccessIter	__first,
		_RandomAccessIter	__last,
		_Compare	__comp
	)

Definition at line 1207 of file _algo.c.

                                                            {
  _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first, __last))
  _STLP_PRIV __stable_sort_aux(__first, __last,
                               _STLP_VALUE_TYPE(__first, _RandomAccessIter),
                               _STLP_DISTANCE_TYPE(__first, _RandomAccessIter),
                               __comp);
}

swap_ranges()

template<class _ForwardIter1 , class _ForwardIter2 >

_STLP_INLINE_LOOP _ForwardIter2 swap_ranges	(	_ForwardIter1	__first1,
		_ForwardIter1	__last1,
		_ForwardIter2	__first2
	)

Definition at line 160 of file _algo.h.

                                                                                   {
  _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first1, __last1))
  for ( ; __first1 != __last1; ++__first1, ++__first2)
    iter_swap(__first1, __first2);
  return __first2;
}

Referenced by SwapTest::swprnge1().

transform() [1/2]

template<class _InputIter , class _OutputIter , class _UnaryOperation >

_STLP_INLINE_LOOP _OutputIter transform	(	_InputIter	__first,
		_InputIter	__last,
		_OutputIter	__result,
		_UnaryOperation	__opr
	)

Definition at line 170 of file _algo.h.

                                                                                              {
  _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first, __last))
  for ( ; __first != __last; ++__first, ++__result)
    *__result = __opr(*__first);
  return __result;
}

transform() [2/2]

template<class _InputIter1 , class _InputIter2 , class _OutputIter , class _BinaryOperation >

_STLP_INLINE_LOOP _OutputIter transform	(	_InputIter1	__first1,
		_InputIter1	__last1,
		_InputIter2	__first2,
		_OutputIter	__result,
		_BinaryOperation	__binary_op
	)

Definition at line 178 of file _algo.h.

                                                                                   {
  _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first1, __last1))
  for ( ; __first1 != __last1; ++__first1, ++__first2, ++__result)
    *__result = __binary_op(*__first1, *__first2);
  return __result;
}

unique() [1/2]

template<class _ForwardIter >

_ForwardIter unique ( _ForwardIter  __first, _ForwardIter  __last  )

inline

Definition at line 298 of file _algo.h.

                                                                      {
  __first = adjacent_find(__first, __last);
  return unique_copy(__first, __last, __first);
}

unique() [2/2]

template<class _ForwardIter , class _BinaryPredicate >

_ForwardIter unique ( _ForwardIter  __first, _ForwardIter  __last, _BinaryPredicate  __binary_pred  )

inline

Definition at line 304 of file _algo.h.

                                                           {
  __first = adjacent_find(__first, __last, __binary_pred);
  return unique_copy(__first, __last, __first, __binary_pred);
}

unique_copy() [1/2]

template<class _InputIter , class _OutputIter >

_OutputIter unique_copy	(	_InputIter	__first,
		_InputIter	__last,
		_OutputIter	__result
	)

Definition at line 348 of file _algo.c.

                                                                         {
  _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first, __last))
  if (__first == __last) return __result;
  return _STLP_PRIV __unique_copy(__first, __last, __result,
                                  _STLP_PRIV __equal_to(_STLP_VALUE_TYPE(__first, _InputIter)),
                                  _STLP_ITERATOR_CATEGORY(__result, _OutputIter));
}

Referenced by UniqueTest::uniqcpy1(), UniqueTest::uniqcpy2(), and unique().

unique_copy() [2/2]

template<class _InputIter , class _OutputIter , class _BinaryPredicate >

_OutputIter unique_copy	(	_InputIter	__first,
		_InputIter	__last,
		_OutputIter	__result,
		_BinaryPredicate	__binary_pred
	)

Definition at line 358 of file _algo.c.

                                            {
  _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first, __last))
  if (__first == __last) return __result;
  return _STLP_PRIV __unique_copy(__first, __last, __result, __binary_pred,
                                  _STLP_ITERATOR_CATEGORY(__result, _OutputIter));
}

upper_bound() [1/2]

template<class _ForwardIter , class _Tp >

_STLP_MOVE_TO_STD_NAMESPACE _ForwardIter upper_bound ( _ForwardIter  __first, _ForwardIter  __last, const _Tp &  __val  )

inline

Definition at line 507 of file _algo.h.

                                                  {
  _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first, __last))
  return _STLP_PRIV __upper_bound(__first, __last, __val,
                                  _STLP_PRIV __less2(_STLP_VALUE_TYPE(__first, _ForwardIter), (_Tp*)0),
                                  _STLP_PRIV __less2((_Tp*)0, _STLP_VALUE_TYPE(__first, _ForwardIter)),
                                  _STLP_DISTANCE_TYPE(__first, _ForwardIter));
}

Referenced by EqualTest::equal_range2(), ExtractArray(), BoundTest::uprbnd1(), and BoundTest::uprbnd2().

upper_bound() [2/2]

template<class _ForwardIter , class _Tp , class _Compare >

_ForwardIter upper_bound ( _ForwardIter  __first, _ForwardIter  __last, const _Tp &  __val, _Compare  __comp  )

inline

Definition at line 517 of file _algo.h.

                                                                   {
  _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first, __last))
  return _STLP_PRIV __upper_bound(__first, __last, __val, __comp, __comp,
                                  _STLP_DISTANCE_TYPE(__first, _ForwardIter));
}

Variable Documentation

__last

const _RandomAccessIterator const random_access_iterator_tag &_STLP_MOVE_TO_STD_NAMESPACE _InputIterator __last { return _STLP_PRIV __distance(__first, __last, _STLP_ITERATOR_CATEGORY(__first, _InputIterator))

Definition at line 68 of file _algo.h.

Referenced by __adjacent_difference(), __BVECTOR_QUALIFIED::__BVECTOR(), __chunk_insertion_sort(), __copy_buffered(), __copy_digits(), __copy_float_and_fill(), __copy_grouped_digits(), __copy_sign(), __destroy_mv_srcs(), __destroy_range(), __destroy_range_aux(), __equal_range(), __final_insertion_sort(), __find(), __find_if(), __get_decimal_integer(), __get_integer(), __get_monetary_value(), __get_short_or_long_dayname(), __get_short_or_long_monthname(), __get_string(), __inplace_merge_aux(), __inplace_stable_partition(), __inplace_stable_sort(), __insertion_sort(), __introsort_loop(), __iota(), __is_sorted(), __linear_insert(), __lower_bound(), __make_heap(), __match(), __merge_adaptive(), __merge_sort_loop(), __merge_sort_with_buffer(), __merge_without_buffer(), __next_permutation(), __nth_element(), __partial_sort(), __partial_sort_copy(), __partial_sum(), __partition(), __pop_heap(), __pop_heap_aux(), __prev_permutation(), __push_heap_aux(), __random_sample(), __read_buffered(), __reverse(), __rotate(), __rotate_adaptive(), __rotate_aux(), __search_n(), __stable_partition_adaptive(), __stable_partition_aux(), __stable_partition_aux_aux(), __stable_sort_adaptive(), __stable_sort_aux(), __ucopy(), __ucopy_aux(), __ucopy_n(), __ucopy_ptrs(), __ucopy_trivial(), __ufill(), __unguarded_insertion_sort(), __unguarded_insertion_sort_aux(), __unguarded_linear_insert(), __unguarded_partition(), __uninitialized_fill_copy(), __uninitialized_fill_n(), __uninitialized_move(), __unique_copy(), __upper_bound(), _Destroy_Moved_Range(), _Destroy_Range(), hashtable< _Val, _Key, _HF, _Traits, _ExK, _EqK, _All >::_Invalidate_iterators(), deque< _Tp, >::_Invalidate_iterators(), list< _Tp, >::_Invalidate_iterators(), slist< _Tp, >::_Invalidate_iterators(), _Rb_tree< _Key, _Compare, _Value, _KeyOfValue, _Traits, >::_Invalidate_iterators(), vector< _Tp, >::_Invalidate_iterators(), vector< _Tp, >::_M_allocate_and_copy(), basic_string< _CharT, _Traits, _Alloc >::_M_append(), vector< _Tp, >::_M_assign(), _Noconv_output< char_traits< char > >::_M_doit(), deque< _Tp, >::_M_erase(), vector< _Tp, >::_M_erase(), hashtable< _Val, _Key, _HF, _Traits, _ExK, _EqK, _All >::_M_find(), _Filebuf_base::_M_get_offset(), _M_ignore_buffered(), list< _Tp, >::_M_insert(), slist< _Tp, >::_M_insert_after_range(), deque< _Tp, >::_M_insert_range_aux(), vector< _Tp, >::_M_range_insert_aux(), vector< _Tp, >::_M_range_insert_realloc(), hashtable< _Val, _Key, _HF, _Traits, _ExK, _EqK, _All >::_M_rehash(), slist< _Tp, >::_M_splice_after_range(), slist< _Tp, >::_M_splice_range(), _Rope_rotate(), _Bs_G::_S_count(), _S_remove_if(), _S_unique(), _STLP_WEAK(), _Temporary_buffer< _ForwardIterator, _Tp >::_Temporary_buffer(), accumulate(), adjacent_difference(), adjacent_find(), __bstr_sum< _CharT, _Traits, _Alloc, _Left, _Right, _StorageDirection >::append(), rope< _CharT, _Alloc >::append(), list< _Tp, >::assign(), deque< _Tp, >::assign(), vector< _Tp, >::assign(), slist< _Tp, >::assign(), binary_search(), count(), hashtable< _Val, _Key, _HF, _Traits, _ExK, _EqK, _All >::count(), count_if(), deque< _Tp, >::deque(), destroy(), time_get< _Ch, istreambuf_iterator< _Ch, char_traits< _Ch > > >::do_get_time(), equal_range(), hashtable< _Val, _Key, _HF, _Traits, _ExK, _EqK, _All >::equal_range(), hashtable< _Val, _Key, _HF, _Traits, _ExK, _EqK, _All >::erase(), __BVECTOR_QUALIFIED::erase(), deque< _Tp, >::erase(), list< _Tp, >::erase(), map< _Key, _Tp,, >::erase(), multimap< _Key, _Tp,, >::erase(), set< _Key,, >::erase(), multiset< _Key,, >::erase(), slist< _Tp, >::erase(), _Rb_tree< _Key, _Compare, _Value, _KeyOfValue, _Traits, >::erase(), vector< _Tp, >::erase(), slist< _Tp, >::erase_after(), find(), find_if(), basic_string< _CharT, _Traits, _Alloc >::find_last_not_of(), basic_string< _CharT, _Traits, _Alloc >::find_last_of(), for_each(), generate(), inplace_merge(), map< _Key, _Tp,, >::insert(), multimap< _Key, _Tp,, >::insert(), multiset< _Key,, >::insert(), set< _Key,, >::insert(), deque< _Tp, >::insert(), list< _Tp, >::insert(), slist< _Tp, >::insert(), vector< _Tp, >::insert(), __BVECTOR_QUALIFIED::insert(), slist< _Tp, >::insert_after(), _Rb_tree< _Key, _Compare, _Value, _KeyOfValue, _Traits, >::insert_equal(), hashtable< _Val, _Key, _HF, _Traits, _ExK, _EqK, _All >::insert_equal_noresize(), _Rb_tree< _Key, _Compare, _Value, _KeyOfValue, _Traits, >::insert_unique(), hashtable< _Val, _Key, _HF, _Traits, _ExK, _EqK, _All >::insert_unique_noresize(), iota(), is_heap(), is_sorted(), list< _Tp, >::list(), lower_bound(), make_heap(), map< _Key, _Tp,, >::map(), max_element(), min_element(), multimap< _Key, _Tp,, >::multimap(), multiset< _Key,, >::multiset(), next_permutation(), nth_element(), _Scan_for_wspace< _Traits >::operator()(), _Scan_for_not_wspace< _Traits >::operator()(), _Scan_for_char_val< _Traits >::operator()(), deque< wstring >::operator=(), partial_sort(), partial_sort_copy(), partial_sum(), partition(), pop_heap(), prev_permutation(), priority_queue< _Tp, _Sequence, _Compare >::priority_queue(), push_heap(), random_sample(), random_sample_n(), random_shuffle(), remove(), slist< _Tp, >::remove(), list< _Tp, >::remove(), remove_copy(), remove_copy_if(), remove_if(), basic_string< _CharT, _Traits, _Alloc >::replace(), replace_copy(), replace_copy_if(), replace_if(), vector< _Tp, >::resize(), list< _Tp, >::resize(), deque< _Tp, >::resize(), reverse(), reverse_copy(), basic_string< _CharT, _Traits, _Alloc >::rfind(), rotate(), rotate_copy(), search_n(), set< _Key,, >::set(), slist< _Tp, >::slist(), sort(), sort_heap(), list< _Tp, >::splice(), slist< _Tp, >::splice(), slist< _Tp, >::splice_after(), stable_partition(), stable_sort(), transform(), uninitialized_copy(), uninitialized_fill(), list< _Tp, >::unique(), slist< _Tp, >::unique(), unique(), unique_copy(), upper_bound(), and vector< _Tp, >::vector().

__n

return __n

Definition at line 75 of file _algo.h.

Referenced by _DBG_iter_base< _Container >::__advance(), __BVECTOR_QUALIFIED::__BVECTOR(), __copy_buffered(), __do_get_alphabool(), __gcd(), __get_integer(), __is_heap(), __lg(), __match(), __power(), __random_number(), __random_sample(), __read_buffered(), __read_unbuffered(), __rotate_aux(), __search_n(), __stl_new(), __stlp_string_fill(), __ucopy(), __ufill(), __ufill_n(), __uinit_aux(), __uinit_aux_aux(), __uninitialized_fill_n(), __uninitialized_init(), __uninitialized_move(), _Advance(), _Incrementable(), _Bit_iterator_base::_M_advance(), _Deque_iterator_base< _Tp >::_M_advance(), __node_alloc::_M_allocate(), __node_alloc_impl::_M_allocate(), _Valarray_base< _Tp >::_M_allocate(), allocator< _Tp >::_M_allocate(), vector< _Tp, >::_M_allocate_and_copy(), _String_base< _Tp, _Alloc >::_M_allocate_block(), basic_filebuf< _CharT, _Traits >::_M_allocate_buffers(), basic_string< _CharT, _Traits, _Alloc >::_M_append(), basic_string< _CharT, _Traits, _Alloc >::_M_append_dispatch(), _M_append_fast_pos(), _M_append_sum_no_overflow(), _M_append_sum_pos(), basic_string< _CharT, _Traits, _Alloc >::_M_appendT(), basic_string< _CharT, _Traits, _Alloc >::_M_assign(), basic_string< _CharT, _Traits, _Alloc >::_M_assign_dispatch(), hashtable< _Val, _Key, _HF, _Traits, _ExK, _EqK, _All >::_M_before_begin(), _Bvector_base< _Alloc >::_M_bit_alloc(), hashtable< _Val, _Key, _HF, _Traits, _ExK, _EqK, _All >::_M_bkt_num(), hashtable< _Val, _Key, _HF, _Traits, _ExK, _EqK, _All >::_M_bkt_num_key(), vector< _Tp, >::_M_compute_next_size(), bitset< _Nb >::_M_copy_from_string(), __node_alloc::_M_deallocate(), __node_alloc_impl::_M_deallocate(), _Rope_iterator_base< _CharT, _Alloc >::_M_decr(), _Deque_base< _Tp, _Alloc >::_M_destroy_nodes(), _Base_bitset< _Nw >::_M_do_left_shift(), _Base_bitset< _Nw >::_M_do_right_shift(), _Noconv_output< char_traits< char > >::_M_doit(), deque< _Tp, >::_M_erase(), __BVECTOR_QUALIFIED::_M_fill_assign(), deque< _Tp, >::_M_fill_assign(), slist< _Tp, >::_M_fill_assign(), vector< _Tp, >::_M_fill_assign(), list< _Tp, >::_M_fill_assign(), vector< _Tp, >::_M_fill_insert(), deque< _Tp, >::_M_fill_insert(), list< _Tp, >::_M_fill_insert(), __BVECTOR_QUALIFIED::_M_fill_insert(), vector< _Tp, >::_M_fill_insert_aux(), deque< _Tp, >::_M_fill_insert_aux(), hashtable< _Val, _Key, _HF, _Traits, _ExK, _EqK, _All >::_M_find(), basic_istream< _CharT, _Traits >::_M_formatted_get(), basic_streambuf< _CharT, _Traits >::_M_gbump(), _M_ignore_buffered(), _M_ignore_unbuffered(), _Rope_iterator_base< _CharT, _Alloc >::_M_incr(), __BVECTOR_QUALIFIED::_M_initialize(), vector< _Tp, >::_M_initialize(), hashtable< _Val, _Key, _HF, _Traits, _ExK, _EqK, _All >::_M_initialize_buckets(), basic_string< _CharT, _Traits, _Alloc >::_M_initialize_dispatch(), slist< _Tp, >::_M_insert_after_fill(), basic_string< _CharT, _Traits, _Alloc >::_M_insert_dispatch(), hashtable< _Val, _Key, _HF, _Traits, _ExK, _EqK, _All >::_M_insert_noresize(), basic_string< _CharT, _Traits, _Alloc >::_M_insert_overflow(), vector< wchar_t >::_M_insert_overflow_aux(), deque< _Tp, >::_M_insert_range_aux(), basic_string< _CharT, _Traits, _Alloc >::_M_insertT(), basic_ostream< _CharT, _Traits >::_M_put_nowiden(), basic_ostream< _CharT, _Traits >::_M_put_widen(), basic_ostream< _CharT, _Traits >::_M_put_widen_aux(), __BVECTOR_QUALIFIED::_M_range_check(), deque< _Tp, >::_M_range_check(), vector< _Tp, >::_M_range_check(), basic_string< _CharT, _Traits, _Alloc >::_M_range_initialize(), vector< _Tp, >::_M_range_insert_aux(), vector< _Tp, >::_M_range_insert_realloc(), basic_string< _CharT, _Traits, _Alloc >::_M_replace_dispatch(), basic_string< _CharT, _Traits, _Alloc >::_M_reserve(), deque< _Tp, >::_M_reserve_elements_at_back(), deque< _Tp, >::_M_reserve_elements_at_front(), basic_streambuf< _CharT, _Traits >::_M_sputnc(), basic_filebuf< _CharT, _Traits >::_M_underflow_aux(), basic_filebuf< _CharT, _Traits >::_M_write(), basic_stringbuf< _CharT, _Traits, _Alloc >::_M_xsputnc(), basic_streambuf< _CharT, _Traits >::_M_xsputnc(), _mm_extract_pi16(), _mm_insert_pi16(), _mm_maskmove_si64(), _mm_shuffle_pi16(), _Rope_fill(), hashtable< _Val, _Key, _HF, _Traits, _ExK, _EqK, _All >::_S_before_begin(), __node_alloc_impl::_S_refill(), _Rope_RopeRep< _CharT, _Alloc >::_S_rounded_up_size(), rope< _CharT, _Alloc >::_S_rounded_up_size(), _S_string_copy(), _String_base< _Tp, _Alloc >::_String_base(), _Valarray_base< _Tp >::_Valarray_base(), _Vector_base< _Tp, _Alloc >::_Vector_base(), __node_alloc::allocate(), __malloc_alloc::allocate(), __new_alloc::allocate(), __debug_alloc< _Alloc >::allocate(), allocator< _Tp >::allocate(), pthread_allocator< _Tp >::allocate(), per_thread_allocator< _Tp >::allocate(), EH_allocator< _Tp >::allocate(), __iostring_allocator< _CharT >::allocate(), _STLP_alloc_proxy< _Value, _Tp, _MaybeReboundAlloc >::allocate(), __bstr_sum< _CharT, _Traits, _Alloc, _Left, _Right, _StorageDirection >::append(), rope< _CharT, _Alloc >::append(), basic_string< _CharT, _Traits, _Alloc >::append(), char_traits< char >::assign(), __char_traits_base< _CharT, _IntT >::assign(), __bstr_sum< _CharT, _Traits, _Alloc, _Left, _Right, _StorageDirection >::assign(), __BVECTOR_QUALIFIED::assign(), basic_string< _CharT, _Traits, _Alloc >::assign(), deque< _Tp, >::assign(), slist< _Tp, >::assign(), vector< _Tp, >::assign(), list< _Tp, >::assign(), __BVECTOR_QUALIFIED::at(), deque< _Tp, >::at(), vector< _Tp, >::at(), basic_string< _CharT, _Traits, _Alloc >::at(), __bstr_sum< _CharT, _Traits, _Alloc, _Left, _Right, _StorageDirection >::at(), basic_string(), basic_string< _CharT, _Traits, _Alloc >::basic_string(), hashtable< _Val, _Key, _HF, _Traits, _ExK, _EqK, _All >::begin(), unordered_map< _Key, _Tp,,, >::begin(), unordered_multimap< _Key, _Tp,,, >::begin(), unordered_set< _Value,,, >::begin(), unordered_multiset< _Value,,, >::begin(), bitset< _Nb >::bitset(), unordered_map< _Key, _Tp,,, >::bucket_size(), unordered_multimap< _Key, _Tp,,, >::bucket_size(), unordered_set< _Value,,, >::bucket_size(), unordered_multiset< _Value,,, >::bucket_size(), char_traits< char >::compare(), __char_traits_base< _CharT, _IntT >::compare(), basic_string< _CharT, _Traits, _Alloc >::compare(), basic_string< _CharT, _Traits, _Alloc >::copy(), __bstr_sum< _CharT, _Traits, _Alloc, _Left, _Right, _StorageDirection >::copy(), __char_traits_base< _CharT, _IntT >::copy(), rope< _CharT, _Alloc >::copy(), count(), hashtable< _Val, _Key, _HF, _Traits, _ExK, _EqK, _All >::count(), count_if(), allocator< _Tp >::deallocate(), __iostring_allocator< _CharT >::deallocate(), pthread_allocator< _Tp >::deallocate(), per_thread_allocator< _Tp >::deallocate(), EH_allocator< _Tp >::deallocate(), __debug_alloc< _Alloc >::deallocate(), __node_alloc::deallocate(), deque< _Tp, >::deque(), hash_map< _Key, _Tp,,, >::elems_in_bucket(), hash_multimap< _Key, _Tp,,, >::elems_in_bucket(), hash_set< _Value,,, >::elems_in_bucket(), hash_multiset< _Value,,, >::elems_in_bucket(), hashtable< _Val, _Key, _HF, _Traits, _ExK, _EqK, _All >::elems_in_bucket(), hashtable< _Val, _Key, _HF, _Traits, _ExK, _EqK, _All >::end(), unordered_map< _Key, _Tp,,, >::end(), unordered_multimap< _Key, _Tp,,, >::end(), unordered_set< _Value,,, >::end(), unordered_multiset< _Value,,, >::end(), hashtable< _Val, _Key, _HF, _Traits, _ExK, _EqK, _All >::equal_range(), hashtable< _Val, _Key, _HF, _Traits, _ExK, _EqK, _All >::erase(), _Rb_tree< _Key, _Compare, _Value, _KeyOfValue, _Traits, >::erase(), list< _Tp, >::erase(), rope< _CharT, _Alloc >::erase(), __bstr_sum< _CharT, _Traits, _Alloc, _Left, _Right, _StorageDirection >::erase(), basic_string< _CharT, _Traits, _Alloc >::erase(), basic_string< _CharT, _Traits, _Alloc >::find(), __bstr_sum< _CharT, _Traits, _Alloc, _Left, _Right, _StorageDirection >::find(), __char_traits_base< _CharT, _IntT >::find(), basic_string< _CharT, _Traits, _Alloc >::find_first_not_of(), __bstr_sum< _CharT, _Traits, _Alloc, _Left, _Right, _StorageDirection >::find_first_not_of(), basic_string< _CharT, _Traits, _Alloc >::find_first_of(), __bstr_sum< _CharT, _Traits, _Alloc, _Left, _Right, _StorageDirection >::find_first_of(), basic_string< _CharT, _Traits, _Alloc >::find_last_not_of(), __bstr_sum< _CharT, _Traits, _Alloc, _Left, _Right, _StorageDirection >::find_last_not_of(), basic_string< _CharT, _Traits, _Alloc >::find_last_of(), __bstr_sum< _CharT, _Traits, _Alloc, _Left, _Right, _StorageDirection >::find_last_of(), for(), basic_streambuf< _CharT, _Traits >::gbump(), generate_n(), basic_istream< _CharT, _Traits >::get(), basic_istream< _CharT, _Traits >::getline(), hashtable< _Val, _Key, _HF, _Traits, _ExK, _EqK, _All >::hashtable(), basic_istream< _CharT, _Traits >::ignore(), basic_string< _CharT, _Traits, _Alloc >::insert(), vector< _Tp, >::insert(), deque< _Tp, >::insert(), list< _Tp, >::insert(), slist< _Tp, >::insert(), __BVECTOR_QUALIFIED::insert(), rope< _CharT, _Alloc >::insert(), __bstr_sum< _CharT, _Traits, _Alloc, _Left, _Right, _StorageDirection >::insert(), slist< _Tp, >::insert_after(), hashtable< _Val, _Key, _HF, _Traits, _ExK, _EqK, _All >::insert_equal(), hashtable< _Val, _Key, _HF, _Traits, _ExK, _EqK, _All >::insert_equal_noresize(), hashtable< _Val, _Key, _HF, _Traits, _ExK, _EqK, _All >::insert_unique(), hashtable< _Val, _Key, _HF, _Traits, _ExK, _EqK, _All >::insert_unique_noresize(), _Rope_flatten_char_consumer< _CharT >::operator()(), _Rope_find_char_char_consumer< _CharT >::operator()(), _Rope_insert_char_consumer< _CharT, _Traits >::operator()(), reverse_iterator< _RandomAccessIterator, _Tp,, >::operator+(), _Deque_iterator< _Tp, _Traits >::operator+(), _DBG_iter< _Container, _Traits >::operator+(), operator+(), reverse_iterator< _RandomAccessIterator, _Tp,, >::operator+=(), _Deque_iterator< _Tp, _Traits >::operator+=(), _Rope_const_iterator< _CharT, _Alloc >::operator+=(), _Rope_iterator< _CharT, _Alloc >::operator+=(), reverse_iterator< _RandomAccessIterator, _Tp,, >::operator-(), operator-(), _Deque_iterator< _Tp, _Traits >::operator-(), _DBG_iter< _Container, _Traits >::operator-(), reverse_iterator< _RandomAccessIterator, _Tp,, >::operator-=(), _Deque_iterator< _Tp, _Traits >::operator-=(), _Rope_const_iterator< _CharT, _Alloc >::operator-=(), _Rope_iterator< _CharT, _Alloc >::operator-=(), operator<(), operator<<(), operator==(), operator>>(), basic_istream< _CharT, _Traits >::operator>>(), reverse_iterator< _RandomAccessIterator, _Tp,, >::operator[](), _Deque_iterator< _Tp, _Traits >::operator[](), _DBG_iter< _Container, _Traits >::operator[](), _Rope_const_iterator< _CharT, _Alloc >::operator[](), __char_wrapper< _CharT >::operator[](), __cstr_wrapper< _CharT >::operator[](), __bstr_wrapper< _CharT, _Traits, _Alloc >::operator[](), __bstr_sum< _CharT, _Traits, _Alloc, _Left, _Right, _StorageDirection >::operator[](), __sum_storage_elem< _CharT, _Traits, _Alloc >::operator[](), valarray< _Tp >::operator[](), __BVECTOR_QUALIFIED::operator[](), deque< _Tp, >::operator[](), vector< _Tp, >::operator[](), basic_string< _CharT, _Traits, _Alloc >::operator[](), basic_streambuf< _CharT, _Traits >::pbump(), power(), basic_streambuf< _CharT, _Traits >::pubsetbuf(), random_sample_n(), basic_istream< _CharT, _Traits >::read(), basic_string< _CharT, _Traits, _Alloc >::replace(), rope< _CharT, _Alloc >::replace(), __bstr_sum< _CharT, _Traits, _Alloc, _Left, _Right, _StorageDirection >::replace(), __BVECTOR_QUALIFIED::reserve(), vector< _Tp, >::reserve(), basic_string< _CharT, _Traits, _Alloc >::reserve(), basic_string< _CharT, _Traits, _Alloc >::resize(), basic_string< _CharT, _Traits, _Alloc >::rfind(), __bstr_sum< _CharT, _Traits, _Alloc, _Left, _Right, _StorageDirection >::rfind(), rope< _CharT, _Alloc >::rope(), basic_stringbuf< _CharT, _Traits, _Alloc >::seekoff(), basic_stringbuf< _CharT, _Traits, _Alloc >::seekpos(), setbase(), basic_stringbuf< _CharT, _Traits, _Alloc >::setbuf(), basic_filebuf< _CharT, _Traits >::setbuf(), setprecision(), setw(), basic_streambuf< _CharT, _Traits >::sgetn(), slist< _Tp, >::slist(), basic_streambuf< _CharT, _Traits >::sputn(), __bstr_sum< _CharT, _Traits, _Alloc, _Left, _Right, _StorageDirection >::substr(), basic_string< _CharT, _Traits, _Alloc >::substr(), uninitialized_fill_n(), valarray< _Tp >::valarray(), vector< _Tp, >::vector(), basic_ostream< _CharT, _Traits >::write(), basic_streambuf< _CharT, _Traits >::xsgetn(), basic_stringbuf< _CharT, _Traits, _Alloc >::xsputn(), and basic_streambuf< _CharT, _Traits >::xsputn().

__pred

_STLP_INLINE_LOOP _InputIter _Predicate __pred

Initial value:

{
 
  _STLP_DIFFERENCE_TYPE(_InputIter) __n = 0

Definition at line 68 of file _algo.h.

Referenced by __find_first_of_aux2(), __find_if(), __inplace_stable_partition(), __partition(), __search_n(), __stable_partition_adaptive(), __stable_partition_aux(), __stable_partition_aux_aux(), _S_remove_if(), _Slist_unique(), count_if(), find_if(), for(), not1(), not2(), partition(), remove_copy_if(), remove_if(), replace_copy_if(), replace_if(), search(), and stable_partition().