mirror of
https://github.com/reactos/reactos.git
synced 2024-08-28 22:28:36 +00:00
729 lines
27 KiB
C
729 lines
27 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_ALGOBASE_H
|
||
|
#define _STLP_INTERNAL_ALGOBASE_H
|
||
|
|
||
|
#ifndef _STLP_INTERNAL_CSTDDEF
|
||
|
# include <stl/_cstddef.h>
|
||
|
#endif
|
||
|
|
||
|
#ifndef _STLP_INTERNAL_CSTRING
|
||
|
# include <stl/_cstring.h>
|
||
|
#endif
|
||
|
|
||
|
#ifndef _STLP_CLIMITS
|
||
|
# include <climits>
|
||
|
#endif
|
||
|
|
||
|
#ifndef _STLP_INTERNAL_CSTDLIB
|
||
|
# include <stl/_cstdlib.h>
|
||
|
#endif
|
||
|
|
||
|
#ifndef _STLP_INTERNAL_PAIR_H
|
||
|
# include <stl/_pair.h>
|
||
|
#endif
|
||
|
|
||
|
#ifndef _STLP_INTERNAL_ITERATOR_BASE_H
|
||
|
# include <stl/_iterator_base.h>
|
||
|
#endif
|
||
|
|
||
|
#ifndef _STLP_TYPE_TRAITS_H
|
||
|
# include <stl/type_traits.h>
|
||
|
#endif
|
||
|
|
||
|
_STLP_BEGIN_NAMESPACE
|
||
|
|
||
|
#if defined (_STLP_USE_PARTIAL_SPEC_WORKAROUND) && !defined (_STLP_FUNCTION_TMPL_PARTIAL_ORDER)
|
||
|
_STLP_MOVE_TO_PRIV_NAMESPACE
|
||
|
template <class _Tp>
|
||
|
inline void __swap_aux(_Tp& __a, _Tp& __b, const __true_type& /*SwapImplemented*/) {
|
||
|
__a._M_swap_workaround(__b);
|
||
|
}
|
||
|
|
||
|
template <class _Tp>
|
||
|
inline void __swap_aux(_Tp& __a, _Tp& __b, const __false_type& /*SwapImplemented*/) {
|
||
|
_Tp __tmp = __a;
|
||
|
__a = __b;
|
||
|
__b = __tmp;
|
||
|
}
|
||
|
_STLP_MOVE_TO_STD_NAMESPACE
|
||
|
#endif
|
||
|
|
||
|
// swap and iter_swap
|
||
|
template <class _Tp>
|
||
|
inline void swap(_Tp& __a, _Tp& __b) {
|
||
|
#if defined (_STLP_USE_PARTIAL_SPEC_WORKAROUND) && !defined (_STLP_FUNCTION_TMPL_PARTIAL_ORDER)
|
||
|
# if !defined(__BORLANDC__)
|
||
|
typedef typename _SwapImplemented<_Tp>::_Ret _Implemented;
|
||
|
# else
|
||
|
enum { _Is = _SwapImplemented<_Tp>::_Is };
|
||
|
typedef typename __bool2type<_Is>::_Ret _Implemented;
|
||
|
# endif
|
||
|
_STLP_PRIV __swap_aux(__a, __b, _Implemented());
|
||
|
#else
|
||
|
_Tp __tmp = __a;
|
||
|
__a = __b;
|
||
|
__b = __tmp;
|
||
|
#endif
|
||
|
}
|
||
|
|
||
|
_STLP_MOVE_TO_PRIV_NAMESPACE
|
||
|
|
||
|
template <class _ForwardIter1, class _ForwardIter2, class _Value>
|
||
|
inline void __iter_swap_aux_aux(_ForwardIter1& __i1, _ForwardIter2& __i2, _Value *) {
|
||
|
_Value tmp = *__i1;
|
||
|
*__i1 = *__i2;
|
||
|
*__i2 = tmp;
|
||
|
}
|
||
|
|
||
|
template <class _ForwardIter1, class _ForwardIter2>
|
||
|
inline void __iter_swap_aux(_ForwardIter1& __i1, _ForwardIter2& __i2, const __true_type& /*OKToSwap*/) {
|
||
|
/* namespace specification breaks access to the right swap template overload (at least for gcc) */
|
||
|
/*_STLP_STD::*/ swap(*__i1, *__i2);
|
||
|
}
|
||
|
|
||
|
template <class _ForwardIter1, class _ForwardIter2>
|
||
|
inline void __iter_swap_aux(_ForwardIter1& __i1, _ForwardIter2& __i2, const __false_type& /*OKToSwap*/) {
|
||
|
_STLP_PRIV __iter_swap_aux_aux( __i1, __i2, _STLP_VALUE_TYPE(__i1,_ForwardIter1) );
|
||
|
}
|
||
|
|
||
|
_STLP_MOVE_TO_STD_NAMESPACE
|
||
|
|
||
|
template <class _ForwardIter1, class _ForwardIter2>
|
||
|
inline void iter_swap(_ForwardIter1 __i1, _ForwardIter2 __i2) {
|
||
|
_STLP_PRIV __iter_swap_aux( __i1, __i2, _IsOKToSwap(_STLP_VALUE_TYPE(__i1, _ForwardIter1), _STLP_VALUE_TYPE(__i2, _ForwardIter2),
|
||
|
_STLP_IS_REF_TYPE_REAL_REF(__i1, _ForwardIter1),
|
||
|
_STLP_IS_REF_TYPE_REAL_REF(__i2, _ForwardIter2))._Answer());
|
||
|
}
|
||
|
|
||
|
//--------------------------------------------------
|
||
|
// min and max
|
||
|
|
||
|
#if !defined (__BORLANDC__) || defined (_STLP_USE_OWN_NAMESPACE)
|
||
|
# if (defined (__BORLANDC__) && (__BORLANDC__ < 0x580)) && !defined (__STDC__)
|
||
|
//In not ANSI mode Borland import min/max in global namespace which conflict
|
||
|
//with STLport min/max when user does a 'using namespace std' in its code
|
||
|
//(see test/unit/alg_test.cpp). To avoid this clash we simply import Borland min/max
|
||
|
//in STLport namespace.
|
||
|
using _STLP_VENDOR_STD::min;
|
||
|
using _STLP_VENDOR_STD::max;
|
||
|
# else
|
||
|
template <class _Tp>
|
||
|
inline const _Tp& (min)(const _Tp& __a, const _Tp& __b) { return __b < __a ? __b : __a; }
|
||
|
template <class _Tp>
|
||
|
inline const _Tp& (max)(const _Tp& __a, const _Tp& __b) { return __a < __b ? __b : __a; }
|
||
|
# endif
|
||
|
#endif
|
||
|
|
||
|
# if defined (__BORLANDC__) && defined (_STLP_USE_OWN_NAMESPACE)
|
||
|
inline unsigned long (min) (unsigned long __a, unsigned long __b) { return __b < __a ? __b : __a; }
|
||
|
inline unsigned long (max) (unsigned long __a, unsigned long __b) { return __a < __b ? __b : __a; }
|
||
|
# endif
|
||
|
|
||
|
# if !defined (__BORLANDC__) || (__BORLANDC__ < 0x590)
|
||
|
template <class _Tp, class _Compare>
|
||
|
inline const _Tp& (min)(const _Tp& __a, const _Tp& __b, _Compare __comp) {
|
||
|
return __comp(__b, __a) ? __b : __a;
|
||
|
}
|
||
|
|
||
|
template <class _Tp, class _Compare>
|
||
|
inline const _Tp& (max)(const _Tp& __a, const _Tp& __b, _Compare __comp) {
|
||
|
return __comp(__a, __b) ? __b : __a;
|
||
|
}
|
||
|
# else
|
||
|
template <class _Tp, class _Compare>
|
||
|
inline const _Tp (min)(const _Tp __a, const _Tp __b, _Compare __comp) {
|
||
|
return __comp(__b, __a) ? __b : __a;
|
||
|
}
|
||
|
|
||
|
template <class _Tp, class _Compare>
|
||
|
inline const _Tp (max)(const _Tp __a, const _Tp __b, _Compare __comp) {
|
||
|
return __comp(__a, __b) ? __b : __a;
|
||
|
}
|
||
|
# endif
|
||
|
|
||
|
//--------------------------------------------------
|
||
|
// copy
|
||
|
|
||
|
// All of these auxiliary functions serve two purposes. (1) Replace
|
||
|
// calls to copy with memmove whenever possible. (Memmove, not memcpy,
|
||
|
// because the input and output ranges are permitted to overlap.)
|
||
|
// (2) If we're using random access iterators, then write the loop as
|
||
|
// a for loop with an explicit count.
|
||
|
|
||
|
_STLP_MOVE_TO_PRIV_NAMESPACE
|
||
|
|
||
|
template <class _InputIter, class _OutputIter, class _Distance>
|
||
|
inline _OutputIter __copy(_InputIter __first, _InputIter __last,
|
||
|
_OutputIter __result, const input_iterator_tag &, _Distance*) {
|
||
|
for ( ; __first != __last; ++__result, ++__first)
|
||
|
*__result = *__first;
|
||
|
return __result;
|
||
|
}
|
||
|
|
||
|
#if defined (_STLP_NONTEMPL_BASE_MATCH_BUG)
|
||
|
template <class _InputIter, class _OutputIter, class _Distance>
|
||
|
inline _OutputIter __copy(_InputIter __first, _InputIter __last,
|
||
|
_OutputIter __result, const forward_iterator_tag &, _Distance* ) {
|
||
|
for ( ; __first != __last; ++__result, ++__first)
|
||
|
*__result = *__first;
|
||
|
return __result;
|
||
|
}
|
||
|
|
||
|
template <class _InputIter, class _OutputIter, class _Distance>
|
||
|
inline _OutputIter __copy(_InputIter __first, _InputIter __last,
|
||
|
_OutputIter __result, const bidirectional_iterator_tag &, _Distance* ) {
|
||
|
for ( ; __first != __last; ++__result, ++__first)
|
||
|
*__result = *__first;
|
||
|
return __result;
|
||
|
}
|
||
|
#endif
|
||
|
|
||
|
template <class _RandomAccessIter, class _OutputIter, class _Distance>
|
||
|
inline _OutputIter
|
||
|
__copy(_RandomAccessIter __first, _RandomAccessIter __last,
|
||
|
_OutputIter __result, const random_access_iterator_tag &, _Distance*) {
|
||
|
for (_Distance __n = __last - __first; __n > 0; --__n) {
|
||
|
*__result = *__first;
|
||
|
++__first;
|
||
|
++__result;
|
||
|
}
|
||
|
return __result;
|
||
|
}
|
||
|
|
||
|
inline void*
|
||
|
__copy_trivial(const void* __first, const void* __last, void* __result) {
|
||
|
size_t __n = (const char*)__last - (const char*)__first;
|
||
|
return __n ? (void *)((char*)memmove(__result, __first, __n) + __n) : __result;
|
||
|
}
|
||
|
|
||
|
//--------------------------------------------------
|
||
|
// copy_backward auxiliary functions
|
||
|
|
||
|
template <class _BidirectionalIter1, class _BidirectionalIter2,
|
||
|
class _Distance>
|
||
|
inline _BidirectionalIter2 __copy_backward(_BidirectionalIter1 __first,
|
||
|
_BidirectionalIter1 __last,
|
||
|
_BidirectionalIter2 __result,
|
||
|
const bidirectional_iterator_tag &,
|
||
|
_Distance*) {
|
||
|
while (__first != __last)
|
||
|
*--__result = *--__last;
|
||
|
return __result;
|
||
|
}
|
||
|
|
||
|
template <class _RandomAccessIter, class _BidirectionalIter, class _Distance>
|
||
|
inline _BidirectionalIter __copy_backward(_RandomAccessIter __first,
|
||
|
_RandomAccessIter __last,
|
||
|
_BidirectionalIter __result,
|
||
|
const random_access_iterator_tag &,
|
||
|
_Distance*) {
|
||
|
for (_Distance __n = __last - __first; __n > 0; --__n)
|
||
|
*--__result = *--__last;
|
||
|
return __result;
|
||
|
}
|
||
|
|
||
|
inline void*
|
||
|
__copy_trivial_backward(const void* __first, const void* __last, void* __result) {
|
||
|
const ptrdiff_t _Num = (const char*)__last - (const char*)__first;
|
||
|
return (_Num > 0) ? memmove((char*)__result - _Num, __first, _Num) : __result ;
|
||
|
}
|
||
|
|
||
|
template <class _InputIter, class _OutputIter>
|
||
|
inline _OutputIter __copy_ptrs(_InputIter __first, _InputIter __last, _OutputIter __result,
|
||
|
const __false_type& /*IsOKToMemCpy*/) {
|
||
|
return _STLP_PRIV __copy(__first, __last, __result, random_access_iterator_tag(), (ptrdiff_t*)0);
|
||
|
}
|
||
|
template <class _InputIter, class _OutputIter>
|
||
|
inline _OutputIter __copy_ptrs(_InputIter __first, _InputIter __last, _OutputIter __result,
|
||
|
const __true_type& /*IsOKToMemCpy*/) {
|
||
|
// we know they all pointers, so this cast is OK
|
||
|
// return (_OutputIter)__copy_trivial(&(*__first), &(*__last), &(*__result));
|
||
|
return (_OutputIter)_STLP_PRIV __copy_trivial(__first, __last, __result);
|
||
|
}
|
||
|
|
||
|
template <class _InputIter, class _OutputIter>
|
||
|
inline _OutputIter __copy_aux(_InputIter __first, _InputIter __last, _OutputIter __result,
|
||
|
const __true_type& /*BothPtrType*/) {
|
||
|
return _STLP_PRIV __copy_ptrs(__first, __last, __result,
|
||
|
_UseTrivialCopy(_STLP_VALUE_TYPE(__first, _InputIter),
|
||
|
_STLP_VALUE_TYPE(__result, _OutputIter))._Answer());
|
||
|
}
|
||
|
|
||
|
template <class _InputIter, class _OutputIter>
|
||
|
inline _OutputIter __copy_aux(_InputIter __first, _InputIter __last, _OutputIter __result,
|
||
|
const __false_type& /*BothPtrType*/) {
|
||
|
return _STLP_PRIV __copy(__first, __last, __result,
|
||
|
_STLP_ITERATOR_CATEGORY(__first, _InputIter),
|
||
|
_STLP_DISTANCE_TYPE(__first, _InputIter));
|
||
|
}
|
||
|
|
||
|
_STLP_MOVE_TO_STD_NAMESPACE
|
||
|
|
||
|
template <class _InputIter, class _OutputIter>
|
||
|
inline _OutputIter copy(_InputIter __first, _InputIter __last, _OutputIter __result) {
|
||
|
_STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first, __last))
|
||
|
return _STLP_PRIV __copy_aux(__first, __last, __result, _BothPtrType< _InputIter, _OutputIter>::_Answer());
|
||
|
}
|
||
|
|
||
|
_STLP_MOVE_TO_PRIV_NAMESPACE
|
||
|
|
||
|
template <class _InputIter, class _OutputIter>
|
||
|
inline _OutputIter __copy_backward_ptrs(_InputIter __first, _InputIter __last,
|
||
|
_OutputIter __result, const __false_type& /*TrivialAssignment*/) {
|
||
|
return _STLP_PRIV __copy_backward(__first, __last, __result,
|
||
|
_STLP_ITERATOR_CATEGORY(__first, _InputIter),
|
||
|
_STLP_DISTANCE_TYPE(__first, _InputIter));
|
||
|
}
|
||
|
template <class _InputIter, class _OutputIter>
|
||
|
inline _OutputIter __copy_backward_ptrs(_InputIter __first, _InputIter __last,
|
||
|
_OutputIter __result, const __true_type& /*TrivialAssignment*/) {
|
||
|
return (_OutputIter)_STLP_PRIV __copy_trivial_backward(__first, __last, __result);
|
||
|
}
|
||
|
|
||
|
template <class _InputIter, class _OutputIter>
|
||
|
inline _OutputIter __copy_backward_aux(_InputIter __first, _InputIter __last, _OutputIter __result, const __false_type&) {
|
||
|
return _STLP_PRIV __copy_backward(__first, __last, __result,
|
||
|
_STLP_ITERATOR_CATEGORY(__first,_InputIter),
|
||
|
_STLP_DISTANCE_TYPE(__first, _InputIter));
|
||
|
}
|
||
|
|
||
|
template <class _InputIter, class _OutputIter>
|
||
|
inline _OutputIter __copy_backward_aux(_InputIter __first, _InputIter __last, _OutputIter __result, const __true_type&) {
|
||
|
return _STLP_PRIV __copy_backward_ptrs(__first, __last, __result,
|
||
|
_UseTrivialCopy(_STLP_VALUE_TYPE(__first, _InputIter),
|
||
|
_STLP_VALUE_TYPE(__result, _OutputIter))._Answer());
|
||
|
}
|
||
|
|
||
|
_STLP_MOVE_TO_STD_NAMESPACE
|
||
|
|
||
|
template <class _InputIter, class _OutputIter>
|
||
|
inline _OutputIter copy_backward(_InputIter __first, _InputIter __last, _OutputIter __result) {
|
||
|
_STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first, __last))
|
||
|
return _STLP_PRIV __copy_backward_aux(__first, __last, __result, _BothPtrType< _InputIter, _OutputIter>::_Answer() );
|
||
|
}
|
||
|
|
||
|
#if !defined (_STLP_CLASS_PARTIAL_SPECIALIZATION) && !defined (_STLP_SIMULATE_PARTIAL_SPEC_FOR_TYPE_TRAITS)
|
||
|
# define _STLP_DECLARE_COPY_TRIVIAL(_Tp) \
|
||
|
inline _Tp* copy(const _Tp* __first, const _Tp* __last, _Tp* __result) \
|
||
|
{ return (_Tp*)_STLP_PRIV __copy_trivial(__first, __last, __result); } \
|
||
|
inline _Tp* copy_backward(const _Tp* __first, const _Tp* __last, _Tp* __result) \
|
||
|
{ return (_Tp*)_STLP_PRIV __copy_trivial_backward(__first, __last, __result); }
|
||
|
|
||
|
# if !defined (_STLP_NO_BOOL)
|
||
|
_STLP_DECLARE_COPY_TRIVIAL(bool)
|
||
|
# endif
|
||
|
_STLP_DECLARE_COPY_TRIVIAL(char)
|
||
|
# if !defined (_STLP_NO_SIGNED_BUILTINS)
|
||
|
_STLP_DECLARE_COPY_TRIVIAL(signed char)
|
||
|
# endif
|
||
|
_STLP_DECLARE_COPY_TRIVIAL(unsigned char)
|
||
|
_STLP_DECLARE_COPY_TRIVIAL(short)
|
||
|
_STLP_DECLARE_COPY_TRIVIAL(unsigned short)
|
||
|
_STLP_DECLARE_COPY_TRIVIAL(int)
|
||
|
_STLP_DECLARE_COPY_TRIVIAL(unsigned int)
|
||
|
_STLP_DECLARE_COPY_TRIVIAL(long)
|
||
|
_STLP_DECLARE_COPY_TRIVIAL(unsigned long)
|
||
|
# if !defined(_STLP_NO_WCHAR_T) && !defined (_STLP_WCHAR_T_IS_USHORT)
|
||
|
_STLP_DECLARE_COPY_TRIVIAL(wchar_t)
|
||
|
# endif
|
||
|
# if defined (_STLP_LONG_LONG)
|
||
|
_STLP_DECLARE_COPY_TRIVIAL(_STLP_LONG_LONG)
|
||
|
_STLP_DECLARE_COPY_TRIVIAL(unsigned _STLP_LONG_LONG)
|
||
|
# endif
|
||
|
_STLP_DECLARE_COPY_TRIVIAL(float)
|
||
|
_STLP_DECLARE_COPY_TRIVIAL(double)
|
||
|
# if !defined (_STLP_NO_LONG_DOUBLE)
|
||
|
_STLP_DECLARE_COPY_TRIVIAL(long double)
|
||
|
# endif
|
||
|
# undef _STLP_DECLARE_COPY_TRIVIAL
|
||
|
#endif
|
||
|
|
||
|
//--------------------------------------------------
|
||
|
// copy_n (not part of the C++ standard)
|
||
|
|
||
|
#if !defined (_STLP_NO_EXTENSIONS)
|
||
|
_STLP_MOVE_TO_PRIV_NAMESPACE
|
||
|
|
||
|
template <class _InputIter, class _Size, class _OutputIter>
|
||
|
_STLP_INLINE_LOOP _STLP_STD::pair<_InputIter, _OutputIter>
|
||
|
__copy_n(_InputIter __first, _Size __count, _OutputIter __result,
|
||
|
const input_iterator_tag &) {
|
||
|
for ( ; __count > 0; --__count) {
|
||
|
*__result = *__first;
|
||
|
++__first;
|
||
|
++__result;
|
||
|
}
|
||
|
return _STLP_STD::pair<_InputIter, _OutputIter>(__first, __result);
|
||
|
}
|
||
|
|
||
|
template <class _RAIter, class _Size, class _OutputIter>
|
||
|
inline _STLP_STD::pair<_RAIter, _OutputIter>
|
||
|
__copy_n(_RAIter __first, _Size __count, _OutputIter __result,
|
||
|
const random_access_iterator_tag &) {
|
||
|
_RAIter __last = __first + __count;
|
||
|
return _STLP_STD::pair<_RAIter, _OutputIter>(__last, _STLP_STD::copy(__first, __last, __result));
|
||
|
}
|
||
|
|
||
|
_STLP_MOVE_TO_STD_NAMESPACE
|
||
|
|
||
|
template <class _InputIter, class _Size, class _OutputIter>
|
||
|
inline pair<_InputIter, _OutputIter>
|
||
|
copy_n(_InputIter __first, _Size __count, _OutputIter __result) {
|
||
|
_STLP_FIX_LITERAL_BUG(__first)
|
||
|
return _STLP_PRIV __copy_n(__first, __count, __result, _STLP_ITERATOR_CATEGORY(__first, _InputIter));
|
||
|
}
|
||
|
#endif
|
||
|
|
||
|
//--------------------------------------------------
|
||
|
// fill and fill_n
|
||
|
_STLP_MOVE_TO_PRIV_NAMESPACE
|
||
|
|
||
|
template <class _ForwardIter, class _Tp>
|
||
|
_STLP_INLINE_LOOP
|
||
|
void __fill_fwd(_ForwardIter __first, _ForwardIter __last, const _Tp& __val) {
|
||
|
for ( ; __first != __last; ++__first)
|
||
|
*__first = __val;
|
||
|
}
|
||
|
|
||
|
template <class _ForwardIter, class _Tp, class _Distance>
|
||
|
inline void __fill(_ForwardIter __first, _ForwardIter __last, const _Tp& __val,
|
||
|
const input_iterator_tag &, _Distance*) {
|
||
|
_STLP_PRIV __fill_fwd(__first, __last, __val);
|
||
|
}
|
||
|
|
||
|
#if defined (_STLP_NONTEMPL_BASE_MATCH_BUG)
|
||
|
template <class _ForwardIter, class _Tp, class _Distance>
|
||
|
_STLP_INLINE_LOOP
|
||
|
void __fill(_ForwardIter __first, _ForwardIter __last, const _Tp& __val,
|
||
|
const forward_iterator_tag &, _Distance*) {
|
||
|
_STLP_PRIV __fill_fwd(__first, __last, __val);
|
||
|
}
|
||
|
|
||
|
template <class _ForwardIter, class _Tp, class _Distance>
|
||
|
_STLP_INLINE_LOOP
|
||
|
void __fill(_ForwardIter __first, _ForwardIter __last, const _Tp& __val,
|
||
|
const bidirectional_iterator_tag &, _Distance*) {
|
||
|
_STLP_PRIV __fill_fwd(__first, __last, __val);
|
||
|
}
|
||
|
#endif
|
||
|
|
||
|
template <class _RandomAccessIter, class _Tp, class _Distance>
|
||
|
_STLP_INLINE_LOOP
|
||
|
void __fill(_RandomAccessIter __first, _RandomAccessIter __last, const _Tp& __val,
|
||
|
const random_access_iterator_tag &, _Distance*) {
|
||
|
for (_Distance __n = __last - __first ; __n > 0; ++__first, --__n)
|
||
|
*__first = __val;
|
||
|
}
|
||
|
|
||
|
_STLP_MOVE_TO_STD_NAMESPACE
|
||
|
|
||
|
template <class _ForwardIter, class _Tp>
|
||
|
inline void fill(_ForwardIter __first, _ForwardIter __last, const _Tp& __val) {
|
||
|
_STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first, __last))
|
||
|
_STLP_PRIV __fill(__first, __last, __val,
|
||
|
_STLP_ITERATOR_CATEGORY(__first, _ForwardIter),
|
||
|
_STLP_DISTANCE_TYPE(__first, _ForwardIter));
|
||
|
}
|
||
|
|
||
|
// Specialization: for one-byte types we can use memset.
|
||
|
inline void fill(unsigned char* __first, unsigned char* __last,
|
||
|
const unsigned char& __val) {
|
||
|
unsigned char __tmp = __val;
|
||
|
memset(__first, __tmp, __last - __first);
|
||
|
}
|
||
|
#if !defined (_STLP_NO_SIGNED_BUILTINS)
|
||
|
inline void fill(signed char* __first, signed char* __last,
|
||
|
const signed char& __val) {
|
||
|
signed char __tmp = __val;
|
||
|
memset(__first, __STATIC_CAST(unsigned char,__tmp), __last - __first);
|
||
|
}
|
||
|
#endif
|
||
|
inline void fill(char* __first, char* __last, const char& __val) {
|
||
|
char __tmp = __val;
|
||
|
memset(__first, __STATIC_CAST(unsigned char,__tmp), __last - __first);
|
||
|
}
|
||
|
|
||
|
_STLP_MOVE_TO_PRIV_NAMESPACE
|
||
|
|
||
|
template <class _OutputIter, class _Size, class _Tp>
|
||
|
_STLP_INLINE_LOOP
|
||
|
_OutputIter __fill_n(_OutputIter __first, _Size __n, const _Tp& __val) {
|
||
|
_STLP_FIX_LITERAL_BUG(__first)
|
||
|
for ( ; __n > 0; --__n, ++__first)
|
||
|
*__first = __val;
|
||
|
return __first;
|
||
|
}
|
||
|
|
||
|
#if defined (_STLP_FUNCTION_TMPL_PARTIAL_ORDER)
|
||
|
template <class _Size>
|
||
|
inline unsigned char* __fill_n(unsigned char* __first, _Size __n,
|
||
|
const unsigned char& __val) {
|
||
|
_STLP_STD::fill(__first, __first + __n, __val);
|
||
|
return __first + __n;
|
||
|
}
|
||
|
#if !defined (_STLP_NO_SIGNED_BUILTINS)
|
||
|
template <class _Size>
|
||
|
inline signed char* __fill_n(signed char* __first, _Size __n,
|
||
|
const signed char& __val) {
|
||
|
_STLP_STD::fill(__first, __first + __n, __val);
|
||
|
return __first + __n;
|
||
|
}
|
||
|
#endif
|
||
|
template <class _Size>
|
||
|
inline char* __fill_n(char* __first, _Size __n,
|
||
|
const char& __val) {
|
||
|
_STLP_STD::fill(__first, __first + __n, __val);
|
||
|
return __first + __n;
|
||
|
}
|
||
|
#endif
|
||
|
|
||
|
_STLP_MOVE_TO_STD_NAMESPACE
|
||
|
|
||
|
template <class _OutputIter, class _Size, class _Tp>
|
||
|
inline void fill_n(_OutputIter __first, _Size __n, const _Tp& __val) {
|
||
|
_STLP_FIX_LITERAL_BUG(__first)
|
||
|
_STLP_PRIV __fill_n(__first, __n, __val);
|
||
|
}
|
||
|
|
||
|
|
||
|
//--------------------------------------------------
|
||
|
// equal and mismatch
|
||
|
|
||
|
template <class _InputIter1, class _InputIter2>
|
||
|
_STLP_INLINE_LOOP
|
||
|
_STLP_STD::pair<_InputIter1, _InputIter2> mismatch(_InputIter1 __first1,
|
||
|
_InputIter1 __last1,
|
||
|
_InputIter2 __first2) {
|
||
|
_STLP_FIX_LITERAL_BUG(__first2)
|
||
|
_STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first1, __last1))
|
||
|
while (__first1 != __last1 && *__first1 == *__first2) {
|
||
|
++__first1;
|
||
|
++__first2;
|
||
|
}
|
||
|
return _STLP_STD::pair<_InputIter1, _InputIter2>(__first1, __first2);
|
||
|
}
|
||
|
|
||
|
template <class _InputIter1, class _InputIter2, class _BinaryPredicate>
|
||
|
_STLP_INLINE_LOOP
|
||
|
_STLP_STD::pair<_InputIter1, _InputIter2> mismatch(_InputIter1 __first1,
|
||
|
_InputIter1 __last1,
|
||
|
_InputIter2 __first2,
|
||
|
_BinaryPredicate __binary_pred) {
|
||
|
_STLP_FIX_LITERAL_BUG(__first2)
|
||
|
_STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first1, __last1))
|
||
|
while (__first1 != __last1 && __binary_pred(*__first1, *__first2)) {
|
||
|
++__first1;
|
||
|
++__first2;
|
||
|
}
|
||
|
return _STLP_STD::pair<_InputIter1, _InputIter2>(__first1, __first2);
|
||
|
}
|
||
|
|
||
|
template <class _InputIter1, class _InputIter2>
|
||
|
_STLP_INLINE_LOOP
|
||
|
bool equal(_InputIter1 __first1, _InputIter1 __last1,
|
||
|
_InputIter2 __first2) {
|
||
|
_STLP_FIX_LITERAL_BUG(__first1) _STLP_FIX_LITERAL_BUG(__last1) _STLP_FIX_LITERAL_BUG(__first2)
|
||
|
_STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first1, __last1))
|
||
|
for ( ; __first1 != __last1; ++__first1, ++__first2)
|
||
|
if (!(*__first1 == *__first2))
|
||
|
return false;
|
||
|
return true;
|
||
|
}
|
||
|
|
||
|
template <class _InputIter1, class _InputIter2, class _BinaryPredicate>
|
||
|
_STLP_INLINE_LOOP
|
||
|
bool equal(_InputIter1 __first1, _InputIter1 __last1,
|
||
|
_InputIter2 __first2, _BinaryPredicate __binary_pred) {
|
||
|
_STLP_FIX_LITERAL_BUG(__first2)
|
||
|
_STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first1, __last1))
|
||
|
for ( ; __first1 != __last1; ++__first1, ++__first2)
|
||
|
if (!__binary_pred(*__first1, *__first2))
|
||
|
return false;
|
||
|
return true;
|
||
|
}
|
||
|
|
||
|
//--------------------------------------------------
|
||
|
// lexicographical_compare and lexicographical_compare_3way.
|
||
|
// (the latter is not part of the C++ standard.)
|
||
|
|
||
|
template <class _InputIter1, class _InputIter2>
|
||
|
bool lexicographical_compare(_InputIter1 __first1, _InputIter1 __last1,
|
||
|
_InputIter2 __first2, _InputIter2 __last2);
|
||
|
|
||
|
template <class _InputIter1, class _InputIter2, class _Compare>
|
||
|
bool lexicographical_compare(_InputIter1 __first1, _InputIter1 __last1,
|
||
|
_InputIter2 __first2, _InputIter2 __last2,
|
||
|
_Compare __comp);
|
||
|
|
||
|
inline bool
|
||
|
lexicographical_compare(const unsigned char* __first1,
|
||
|
const unsigned char* __last1,
|
||
|
const unsigned char* __first2,
|
||
|
const unsigned char* __last2) {
|
||
|
const size_t __len1 = __last1 - __first1;
|
||
|
const size_t __len2 = __last2 - __first2;
|
||
|
_STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first1, __last1))
|
||
|
_STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first2, __last2))
|
||
|
|
||
|
const int __result = memcmp(__first1, __first2, (min) (__len1, __len2));
|
||
|
return __result != 0 ? (__result < 0) : (__len1 < __len2);
|
||
|
}
|
||
|
|
||
|
|
||
|
#if !(CHAR_MAX == SCHAR_MAX)
|
||
|
inline bool lexicographical_compare(const char* __first1, const char* __last1,
|
||
|
const char* __first2, const char* __last2) {
|
||
|
_STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first1, __last1))
|
||
|
_STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first2, __last2))
|
||
|
|
||
|
return lexicographical_compare((const unsigned char*) __first1,
|
||
|
(const unsigned char*) __last1,
|
||
|
(const unsigned char*) __first2,
|
||
|
(const unsigned char*) __last2);
|
||
|
}
|
||
|
#endif /* CHAR_MAX == SCHAR_MAX */
|
||
|
|
||
|
_STLP_MOVE_TO_PRIV_NAMESPACE
|
||
|
|
||
|
template <class _InputIter1, class _InputIter2>
|
||
|
int __lexicographical_compare_3way(_InputIter1 __first1, _InputIter1 __last1,
|
||
|
_InputIter2 __first2, _InputIter2 __last2);
|
||
|
|
||
|
inline int
|
||
|
__lexicographical_compare_3way(const unsigned char* __first1,
|
||
|
const unsigned char* __last1,
|
||
|
const unsigned char* __first2,
|
||
|
const unsigned char* __last2) {
|
||
|
const ptrdiff_t __len1 = __last1 - __first1;
|
||
|
const ptrdiff_t __len2 = __last2 - __first2;
|
||
|
const int __result = memcmp(__first1, __first2, (min) (__len1, __len2));
|
||
|
return __result != 0 ? __result
|
||
|
: (__len1 == __len2 ? 0 : (__len1 < __len2 ? -1 : 1));
|
||
|
}
|
||
|
|
||
|
|
||
|
#if !(CHAR_MAX == SCHAR_MAX)
|
||
|
inline int
|
||
|
__lexicographical_compare_3way(const char* __first1, const char* __last1,
|
||
|
const char* __first2, const char* __last2) {
|
||
|
return __lexicographical_compare_3way((const unsigned char*) __first1,
|
||
|
(const unsigned char*) __last1,
|
||
|
(const unsigned char*) __first2,
|
||
|
(const unsigned char*) __last2);
|
||
|
}
|
||
|
#endif
|
||
|
|
||
|
_STLP_MOVE_TO_STD_NAMESPACE
|
||
|
|
||
|
#if !defined (_STLP_NO_EXTENSIONS)
|
||
|
template <class _InputIter1, class _InputIter2>
|
||
|
int lexicographical_compare_3way(_InputIter1 __first1, _InputIter1 __last1,
|
||
|
_InputIter2 __first2, _InputIter2 __last2);
|
||
|
|
||
|
#endif
|
||
|
|
||
|
// count
|
||
|
template <class _InputIter, class _Tp>
|
||
|
_STLP_INLINE_LOOP _STLP_DIFFERENCE_TYPE(_InputIter)
|
||
|
count(_InputIter __first, _InputIter __last, const _Tp& __val) {
|
||
|
_STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first, __last))
|
||
|
_STLP_DIFFERENCE_TYPE(_InputIter) __n = 0;
|
||
|
for ( ; __first != __last; ++__first)
|
||
|
if (*__first == __val)
|
||
|
++__n;
|
||
|
return __n;
|
||
|
}
|
||
|
|
||
|
// find and find_if. Note find may be expressed in terms of find_if if appropriate binder was available.
|
||
|
template <class _InputIter, class _Tp>
|
||
|
_InputIter find(_InputIter __first, _InputIter __last, const _Tp& __val);
|
||
|
|
||
|
template <class _InputIter, class _Predicate>
|
||
|
_InputIter find_if(_InputIter __first, _InputIter __last, _Predicate __pred);
|
||
|
|
||
|
// search.
|
||
|
template <class _ForwardIter1, class _ForwardIter2, class _BinaryPred>
|
||
|
_ForwardIter1 search(_ForwardIter1 __first1, _ForwardIter1 __last1,
|
||
|
_ForwardIter2 __first2, _ForwardIter2 __last2, _BinaryPred __predicate);
|
||
|
|
||
|
_STLP_MOVE_TO_PRIV_NAMESPACE
|
||
|
|
||
|
// find_first_of
|
||
|
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);
|
||
|
|
||
|
_STLP_MOVE_TO_STD_NAMESPACE
|
||
|
|
||
|
template <class _ForwardIter1, class _ForwardIter2,
|
||
|
class _BinaryPredicate>
|
||
|
_ForwardIter1
|
||
|
find_end(_ForwardIter1 __first1, _ForwardIter1 __last1,
|
||
|
_ForwardIter2 __first2, _ForwardIter2 __last2,
|
||
|
_BinaryPredicate __comp);
|
||
|
|
||
|
// replace
|
||
|
template <class _ForwardIter, class _Tp>
|
||
|
_STLP_INLINE_LOOP void
|
||
|
replace(_ForwardIter __first, _ForwardIter __last,
|
||
|
const _Tp& __old_value, const _Tp& __new_value) {
|
||
|
_STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first, __last))
|
||
|
for ( ; __first != __last; ++__first)
|
||
|
if (*__first == __old_value)
|
||
|
*__first = __new_value;
|
||
|
}
|
||
|
|
||
|
_STLP_MOVE_TO_PRIV_NAMESPACE
|
||
|
|
||
|
template <class _ForwardIter, class _Tp, class _Compare1, class _Compare2, class _Distance>
|
||
|
_ForwardIter __lower_bound(_ForwardIter __first, _ForwardIter __last,
|
||
|
const _Tp& __val, _Compare1 __comp1, _Compare2 __comp2, _Distance*);
|
||
|
|
||
|
_STLP_MOVE_TO_STD_NAMESPACE
|
||
|
|
||
|
_STLP_END_NAMESPACE
|
||
|
|
||
|
#if !defined (_STLP_LINK_TIME_INSTANTIATION)
|
||
|
# include <stl/_algobase.c>
|
||
|
#endif
|
||
|
|
||
|
#endif /* _STLP_INTERNAL_ALGOBASE_H */
|
||
|
|
||
|
// Local Variables:
|
||
|
// mode:C++
|
||
|
// End:
|
||
|
|