mirror of
https://github.com/reactos/reactos.git
synced 2025-02-24 17:34:57 +00:00
6b0b6cb78f
- move stlport headers to the c++ directory - add a specific _reactos.h configuration file for stlport - add cerrno to c++ headers - __declspec(nothrow) must be placed before calling convention with msvc. GCC doesn't care. We now use our headers with both msvc and gcc. svn path=/branches/cmake-bringup/; revision=49565
745 lines
28 KiB
C++
745 lines
28 KiB
C++
/*
|
|
*
|
|
* 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:
|
|
|