| /* |
| * |
| * Copyright (c) 1994 |
| * Hewlett-Packard Company |
| * |
| * Copyright (c) 1996,1997 |
| * Silicon Graphics Computer Systems, Inc. |
| * |
| * Copyright (c) 1997 |
| * Moscow Center for SPARC Technology |
| * |
| * Copyright (c) 1999 |
| * Boris Fomitchev |
| * |
| * This material is provided "as is", with absolutely no warranty expressed |
| * or implied. Any use is at your own risk. |
| * |
| * Permission to use or copy this software for any purpose is hereby granted |
| * without fee, provided the above notices are retained on all copies. |
| * Permission to modify the code and to distribute modified code is granted, |
| * provided the above notices are retained, and a notice that the code was |
| * modified is included with the above copyright notice. |
| * |
| */ |
| |
| /* NOTE: This is an internal header file, included by other STL headers. |
| * You should not attempt to use it directly. |
| */ |
| |
| #ifndef _STLP_INTERNAL_ALGO_H |
| #define _STLP_INTERNAL_ALGO_H |
| |
| #ifndef _STLP_INTERNAL_ALGOBASE_H |
| # include <stl/_algobase.h> |
| #endif |
| |
| #ifndef _STLP_INTERNAL_HEAP_H |
| # include <stl/_heap.h> |
| #endif |
| |
| #ifndef _STLP_INTERNAL_ITERATOR_H |
| # include <stl/_iterator.h> |
| #endif |
| |
| #ifndef _STLP_INTERNAL_FUNCTION_BASE_H |
| # include <stl/_function_base.h> |
| #endif |
| |
| #if defined (__SUNPRO_CC) && !defined (_STLP_INTERNAL_CSTDIO) |
| // remove() conflict |
| # include <stl/_cstdio.h> |
| #endif |
| |
| _STLP_BEGIN_NAMESPACE |
| |
| // for_each. Apply a function to every element of a range. |
| template <class _InputIter, class _Function> |
| _STLP_INLINE_LOOP _Function |
| for_each(_InputIter __first, _InputIter __last, _Function __f) { |
| for ( ; __first != __last; ++__first) |
| __f(*__first); |
| return __f; |
| } |
| |
| // count_if |
| template <class _InputIter, class _Predicate> |
| _STLP_INLINE_LOOP _STLP_DIFFERENCE_TYPE(_InputIter) |
| count_if(_InputIter __first, _InputIter __last, _Predicate __pred) { |
| _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first, __last)) |
| _STLP_DIFFERENCE_TYPE(_InputIter) __n = 0; |
| for ( ; __first != __last; ++__first) { |
| if (__pred(*__first)) |
| ++__n; |
| } |
| return __n; |
| } |
| |
| // adjacent_find. |
| |
| template <class _ForwardIter, class _BinaryPredicate> |
| _STLP_INLINE_LOOP _ForwardIter |
| adjacent_find(_ForwardIter __first, _ForwardIter __last, |
| _BinaryPredicate __binary_pred) { |
| _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; |
| } |
| |
| template <class _ForwardIter> |
| _STLP_INLINE_LOOP _ForwardIter |
| adjacent_find(_ForwardIter __first, _ForwardIter __last) { |
| return adjacent_find(__first, __last, |
| _STLP_PRIV __equal_to(_STLP_VALUE_TYPE(__first, _ForwardIter))); |
| } |
| |
| #if !defined (_STLP_NO_ANACHRONISMS) |
| template <class _InputIter, class _Tp, class _Size> |
| _STLP_INLINE_LOOP void |
| count(_InputIter __first, _InputIter __last, const _Tp& __val, _Size& __n) { |
| _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first, __last)) |
| for ( ; __first != __last; ++__first) |
| if (*__first == __val) |
| ++__n; |
| } |
| |
| template <class _InputIter, class _Predicate, class _Size> |
| _STLP_INLINE_LOOP void |
| count_if(_InputIter __first, _InputIter __last, _Predicate __pred, _Size& __n) { |
| _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first, __last)) |
| for ( ; __first != __last; ++__first) |
| if (__pred(*__first)) |
| ++__n; |
| } |
| #endif |
| |
| template <class _ForwardIter1, class _ForwardIter2> |
| _ForwardIter1 search(_ForwardIter1 __first1, _ForwardIter1 __last1, |
| _ForwardIter2 __first2, _ForwardIter2 __last2); |
| |
| // search_n. Search for __count consecutive copies of __val. |
| 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> |
| inline _InputIter find_first_of(_InputIter __first1, _InputIter __last1, |
| _ForwardIter __first2, _ForwardIter __last2) { |
| _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); |
| } |
| |
| template <class _InputIter, class _ForwardIter, class _BinaryPredicate> |
| inline _InputIter |
| find_first_of(_InputIter __first1, _InputIter __last1, |
| _ForwardIter __first2, _ForwardIter __last2, _BinaryPredicate __comp) { |
| _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); |
| } |
| |
| template <class _ForwardIter1, class _ForwardIter2> |
| _ForwardIter1 |
| find_end(_ForwardIter1 __first1, _ForwardIter1 __last1, |
| _ForwardIter2 __first2, _ForwardIter2 __last2); |
| |
| // swap_ranges |
| template <class _ForwardIter1, class _ForwardIter2> |
| _STLP_INLINE_LOOP _ForwardIter2 |
| swap_ranges(_ForwardIter1 __first1, _ForwardIter1 __last1, _ForwardIter2 __first2) { |
| _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first1, __last1)) |
| for ( ; __first1 != __last1; ++__first1, ++__first2) |
| iter_swap(__first1, __first2); |
| return __first2; |
| } |
| |
| // transform |
| template <class _InputIter, class _OutputIter, class _UnaryOperation> |
| _STLP_INLINE_LOOP _OutputIter |
| transform(_InputIter __first, _InputIter __last, _OutputIter __result, _UnaryOperation __opr) { |
| _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first, __last)) |
| for ( ; __first != __last; ++__first, ++__result) |
| *__result = __opr(*__first); |
| return __result; |
| } |
| 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) { |
| _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first1, __last1)) |
| for ( ; __first1 != __last1; ++__first1, ++__first2, ++__result) |
| *__result = __binary_op(*__first1, *__first2); |
| return __result; |
| } |
| |
| // replace_if, replace_copy, replace_copy_if |
| |
| template <class _ForwardIter, class _Predicate, class _Tp> |
| _STLP_INLINE_LOOP void |
| replace_if(_ForwardIter __first, _ForwardIter __last, _Predicate __pred, const _Tp& __new_value) { |
| _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first, __last)) |
| for ( ; __first != __last; ++__first) |
| if (__pred(*__first)) |
| *__first = __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) { |
| _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first, __last)) |
| for ( ; __first != __last; ++__first, ++__result) |
| *__result = *__first == __old_value ? __new_value : *__first; |
| return __result; |
| } |
| |
| 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) { |
| _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first, __last)) |
| for ( ; __first != __last; ++__first, ++__result) |
| *__result = __pred(*__first) ? __new_value : *__first; |
| return __result; |
| } |
| |
| // generate and generate_n |
| |
| template <class _ForwardIter, class _Generator> |
| _STLP_INLINE_LOOP void |
| generate(_ForwardIter __first, _ForwardIter __last, _Generator __gen) { |
| _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first, __last)) |
| for ( ; __first != __last; ++__first) |
| *__first = __gen(); |
| } |
| |
| template <class _OutputIter, class _Size, class _Generator> |
| _STLP_INLINE_LOOP void |
| generate_n(_OutputIter __first, _Size __n, _Generator __gen) { |
| for ( ; __n > 0; --__n, ++__first) |
| *__first = __gen(); |
| } |
| |
| // remove, remove_if, remove_copy, remove_copy_if |
| |
| template <class _InputIter, class _OutputIter, class _Tp> |
| _STLP_INLINE_LOOP _OutputIter |
| remove_copy(_InputIter __first, _InputIter __last,_OutputIter __result, const _Tp& __val) { |
| _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first, __last)) |
| for ( ; __first != __last; ++__first) { |
| if (!(*__first == __val)) { |
| *__result = *__first; |
| ++__result; |
| } |
| } |
| return __result; |
| } |
| |
| template <class _InputIter, class _OutputIter, class _Predicate> |
| _STLP_INLINE_LOOP _OutputIter |
| remove_copy_if(_InputIter __first, _InputIter __last, _OutputIter __result, _Predicate __pred) { |
| _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first, __last)) |
| for ( ; __first != __last; ++__first) { |
| if (!__pred(*__first)) { |
| *__result = *__first; |
| ++__result; |
| } |
| } |
| return __result; |
| } |
| |
| template <class _ForwardIter, class _Tp> |
| _STLP_INLINE_LOOP _ForwardIter |
| remove(_ForwardIter __first, _ForwardIter __last, const _Tp& __val) { |
| _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); |
| } |
| } |
| |
| template <class _ForwardIter, class _Predicate> |
| _STLP_INLINE_LOOP _ForwardIter |
| remove_if(_ForwardIter __first, _ForwardIter __last, _Predicate __pred) { |
| _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); |
| } |
| } |
| |
| // unique and unique_copy |
| 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> |
| inline _ForwardIter unique(_ForwardIter __first, _ForwardIter __last) { |
| __first = adjacent_find(__first, __last); |
| return unique_copy(__first, __last, __first); |
| } |
| |
| template <class _ForwardIter, class _BinaryPredicate> |
| inline _ForwardIter unique(_ForwardIter __first, _ForwardIter __last, |
| _BinaryPredicate __binary_pred) { |
| __first = adjacent_find(__first, __last, __binary_pred); |
| return unique_copy(__first, __last, __first, __binary_pred); |
| } |
| |
| // reverse and reverse_copy, and their auxiliary functions |
| |
| _STLP_MOVE_TO_PRIV_NAMESPACE |
| |
| template <class _BidirectionalIter> |
| _STLP_INLINE_LOOP void |
| __reverse(_BidirectionalIter __first, _BidirectionalIter __last, const bidirectional_iterator_tag &) { |
| for (; __first != __last && __first != --__last; ++__first) |
| _STLP_STD::iter_swap(__first,__last); |
| } |
| |
| template <class _RandomAccessIter> |
| _STLP_INLINE_LOOP void |
| __reverse(_RandomAccessIter __first, _RandomAccessIter __last, const random_access_iterator_tag &) { |
| for (; __first < __last; ++__first) |
| _STLP_STD::iter_swap(__first, --__last); |
| } |
| |
| _STLP_MOVE_TO_STD_NAMESPACE |
| |
| template <class _BidirectionalIter> |
| inline void |
| reverse(_BidirectionalIter __first, _BidirectionalIter __last) { |
| _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first, __last)) |
| _STLP_PRIV __reverse(__first, __last, _STLP_ITERATOR_CATEGORY(__first, _BidirectionalIter)); |
| } |
| |
| template <class _BidirectionalIter, class _OutputIter> |
| _STLP_INLINE_LOOP |
| _OutputIter reverse_copy(_BidirectionalIter __first, |
| _BidirectionalIter __last, |
| _OutputIter __result) { |
| _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first, __last)) |
| while (__first != __last) { |
| --__last; |
| *__result = *__last; |
| ++__result; |
| } |
| return __result; |
| } |
| |
| template <class _ForwardIter> |
| void rotate(_ForwardIter __first, _ForwardIter __middle, _ForwardIter __last); |
| |
| template <class _ForwardIter, class _OutputIter> |
| inline _OutputIter rotate_copy(_ForwardIter __first, _ForwardIter __middle, |
| _ForwardIter __last, _OutputIter __result) { |
| return _STLP_STD::copy(__first, __middle, copy(__middle, __last, __result)); |
| } |
| |
| // random_shuffle |
| |
| template <class _RandomAccessIter> |
| void random_shuffle(_RandomAccessIter __first, _RandomAccessIter __last); |
| |
| template <class _RandomAccessIter, class _RandomNumberGenerator> |
| void random_shuffle(_RandomAccessIter __first, _RandomAccessIter __last, |
| _RandomNumberGenerator& __rand); |
| |
| #if !defined (_STLP_NO_EXTENSIONS) |
| // random_sample and random_sample_n (extensions, not part of the standard). |
| |
| 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); |
| |
| #endif /* _STLP_NO_EXTENSIONS */ |
| |
| // partition, stable_partition, and their auxiliary functions |
| |
| 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); |
| |
| // sort() and its auxiliary functions. |
| _STLP_MOVE_TO_PRIV_NAMESPACE |
| |
| template <class _Size> |
| inline _Size __lg(_Size __n) { |
| _Size __k; |
| for (__k = 0; __n != 1; __n >>= 1) ++__k; |
| return __k; |
| } |
| |
| _STLP_MOVE_TO_STD_NAMESPACE |
| |
| template <class _RandomAccessIter> |
| void sort(_RandomAccessIter __first, _RandomAccessIter __last); |
| template <class _RandomAccessIter, class _Compare> |
| void sort(_RandomAccessIter __first, _RandomAccessIter __last, _Compare __comp); |
| |
| // stable_sort() and its auxiliary functions. |
| template <class _RandomAccessIter> |
| void stable_sort(_RandomAccessIter __first, |
| _RandomAccessIter __last); |
| |
| template <class _RandomAccessIter, class _Compare> |
| void stable_sort(_RandomAccessIter __first, |
| _RandomAccessIter __last, _Compare __comp); |
| |
| // partial_sort, partial_sort_copy, and auxiliary functions. |
| |
| 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); |
| |
| // nth_element() and its auxiliary functions. |
| 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); |
| |
| // auxiliary class for lower_bound, etc. |
| _STLP_MOVE_TO_PRIV_NAMESPACE |
| |
| template <class _T1, class _T2> |
| struct __less_2 { |
| bool operator() (const _T1& __x, const _T2& __y) const { return __x < __y ; } |
| }; |
| |
| template <class _T1, class _T2> |
| __less_2<_T1,_T2> __less2(_T1*, _T2* ) { return __less_2<_T1, _T2>(); } |
| |
| #if defined (_STLP_FUNCTION_PARTIAL_ORDER) |
| template <class _Tp> |
| less<_Tp> __less2(_Tp*, _Tp* ) { return less<_Tp>(); } |
| #endif |
| |
| _STLP_MOVE_TO_STD_NAMESPACE |
| |
| // Binary search (lower_bound, upper_bound, equal_range, binary_search). |
| template <class _ForwardIter, class _Tp> |
| inline _ForwardIter lower_bound(_ForwardIter __first, _ForwardIter __last, |
| const _Tp& __val) { |
| _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)); |
| } |
| |
| template <class _ForwardIter, class _Tp, class _Compare> |
| inline _ForwardIter lower_bound(_ForwardIter __first, _ForwardIter __last, |
| const _Tp& __val, _Compare __comp) { |
| _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first, __last)) |
| return _STLP_PRIV __lower_bound(__first, __last, __val, __comp, __comp, |
| _STLP_DISTANCE_TYPE(__first, _ForwardIter)); |
| } |
| |
| _STLP_MOVE_TO_PRIV_NAMESPACE |
| |
| template <class _ForwardIter, class _Tp, class _Compare1, class _Compare2, class _Distance> |
| _ForwardIter __upper_bound(_ForwardIter __first, _ForwardIter __last, const _Tp& __val, |
| _Compare1 __comp1, _Compare2 __comp2, _Distance*); |
| |
| _STLP_MOVE_TO_STD_NAMESPACE |
| |
| template <class _ForwardIter, class _Tp> |
| inline _ForwardIter upper_bound(_ForwardIter __first, _ForwardIter __last, |
| const _Tp& __val) { |
| _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)); |
| } |
| |
| template <class _ForwardIter, class _Tp, class _Compare> |
| inline _ForwardIter upper_bound(_ForwardIter __first, _ForwardIter __last, |
| const _Tp& __val, _Compare __comp) { |
| _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first, __last)) |
| return _STLP_PRIV __upper_bound(__first, __last, __val, __comp, __comp, |
| _STLP_DISTANCE_TYPE(__first, _ForwardIter)); |
| } |
| |
| _STLP_MOVE_TO_PRIV_NAMESPACE |
| |
| template <class _ForwardIter, class _Tp, class _Compare1, class _Compare2, class _Distance> |
| pair<_ForwardIter, _ForwardIter> |
| __equal_range(_ForwardIter __first, _ForwardIter __last, const _Tp& __val, |
| _Compare1 __comp1, _Compare2 __comp2, _Distance*); |
| |
| _STLP_MOVE_TO_STD_NAMESPACE |
| |
| template <class _ForwardIter, class _Tp> |
| inline pair<_ForwardIter, _ForwardIter> |
| equal_range(_ForwardIter __first, _ForwardIter __last, const _Tp& __val) { |
| _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)); |
| } |
| |
| template <class _ForwardIter, class _Tp, class _Compare> |
| inline pair<_ForwardIter, _ForwardIter> |
| equal_range(_ForwardIter __first, _ForwardIter __last, const _Tp& __val, |
| _Compare __comp) { |
| _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first, __last)) |
| return _STLP_PRIV __equal_range(__first, __last, __val, __comp, __comp, |
| _STLP_DISTANCE_TYPE(__first, _ForwardIter)); |
| } |
| |
| template <class _ForwardIter, class _Tp> |
| inline bool binary_search(_ForwardIter __first, _ForwardIter __last, |
| const _Tp& __val) { |
| _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); |
| } |
| |
| template <class _ForwardIter, class _Tp, class _Compare> |
| inline bool binary_search(_ForwardIter __first, _ForwardIter __last, |
| const _Tp& __val, |
| _Compare __comp) { |
| _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); |
| } |
| |
| // merge, with and without an explicitly supplied comparison function. |
| |
| 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); |
| |
| |
| // inplace_merge and its auxiliary functions. |
| |
| |
| 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); |
| |
| // Set algorithms: includes, set_union, set_intersection, set_difference, |
| // set_symmetric_difference. All of these algorithms have the precondition |
| // that their input ranges are sorted and the postcondition that their output |
| // ranges are sorted. |
| |
| 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); |
| |
| |
| // min_element and max_element, with and without an explicitly supplied |
| // comparison function. |
| |
| 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); |
| |
| // next_permutation and prev_permutation, with and without an explicitly |
| // supplied comparison function. |
| |
| 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); |
| |
| #if !defined (_STLP_NO_EXTENSIONS) |
| // is_heap, a predicate testing whether or not a range is |
| // a heap. This function is an extension, not part of the C++ |
| // standard. |
| |
| template <class _RandomAccessIter> |
| bool is_heap(_RandomAccessIter __first, _RandomAccessIter __last); |
| |
| template <class _RandomAccessIter, class _StrictWeakOrdering> |
| bool is_heap(_RandomAccessIter __first, _RandomAccessIter __last, |
| _StrictWeakOrdering __comp); |
| |
| // is_sorted, a predicated testing whether a range is sorted in |
| // nondescending order. This is an extension, not part of the C++ |
| // standard. |
| _STLP_MOVE_TO_PRIV_NAMESPACE |
| |
| template <class _ForwardIter, class _StrictWeakOrdering> |
| bool __is_sorted(_ForwardIter __first, _ForwardIter __last, |
| _StrictWeakOrdering __comp); |
| |
| _STLP_MOVE_TO_STD_NAMESPACE |
| template <class _ForwardIter> |
| inline bool is_sorted(_ForwardIter __first, _ForwardIter __last) { |
| return _STLP_PRIV __is_sorted(__first, __last, |
| _STLP_PRIV __less(_STLP_VALUE_TYPE(__first, _ForwardIter))); |
| } |
| |
| template <class _ForwardIter, class _StrictWeakOrdering> |
| inline bool is_sorted(_ForwardIter __first, _ForwardIter __last, |
| _StrictWeakOrdering __comp) { |
| return _STLP_PRIV __is_sorted(__first, __last, __comp); |
| } |
| #endif |
| |
| _STLP_END_NAMESPACE |
| |
| #if !defined (_STLP_LINK_TIME_INSTANTIATION) |
| # include <stl/_algo.c> |
| #endif |
| |
| #endif /* _STLP_INTERNAL_ALGO_H */ |
| |
| // Local Variables: |
| // mode:C++ |
| // End: |
| |
