diff -r e1b950c65cb4 -r 837f303aceeb epoc32/include/stdapis/stlportv5/stl/_algobase.h --- a/epoc32/include/stdapis/stlportv5/stl/_algobase.h Wed Mar 31 12:27:01 2010 +0100 +++ b/epoc32/include/stdapis/stlportv5/stl/_algobase.h Wed Mar 31 12:33:34 2010 +0100 @@ -9,13 +9,13 @@ * Copyright (c) 1997 * Moscow Center for SPARC Technology * - * Copyright (c) 1999 + * 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 + * 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 @@ -27,65 +27,128 @@ * You should not attempt to use it directly. */ - #ifndef _STLP_INTERNAL_ALGOBASE_H #define _STLP_INTERNAL_ALGOBASE_H -# if ! defined (_STLP_CSTDDEF) -# include -# endif +#ifndef _STLP_INTERNAL_CSTDDEF +# include +#endif -#ifndef _STLP_CSTRING -# include +#ifndef _STLP_INTERNAL_CSTRING +# include #endif #ifndef _STLP_CLIMITS -# include +# include #endif -# if ! defined (_STLP_CSTDLIB) -# include -# endif +#ifndef _STLP_INTERNAL_CSTDLIB +# include +#endif -# ifndef _STLP_INTERNAL_PAIR_H +#ifndef _STLP_INTERNAL_PAIR_H # include -# endif +#endif #ifndef _STLP_INTERNAL_ITERATOR_BASE_H -# include +# include +#endif + +#ifndef _STLP_TYPE_TRAITS_H +# include #endif _STLP_BEGIN_NAMESPACE -// swap and iter_swap + +#if defined(_STLP_USE_PARTIAL_SPEC_WORKAROUND) && !defined(_STLP_FUNCTION_TMPL_PARTIAL_ORDER) +_STLP_MOVE_TO_PRIV_NAMESPACE template -inline void swap(_Tp& __a, _Tp& __b) { +inline void __swap_aux(_Tp& __a, _Tp& __b, const __true_type& /*SwapImplemented*/) { + __a.swap(__b); +} + +template +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 /* _STLP_USE_PARTIAL_SPEC_WORKAROUND */ + +// swap and iter_swap +template +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_USE_PARTIAL_SPEC_WORKAROUND */ +} + +_STLP_MOVE_TO_PRIV_NAMESPACE + +template +inline void __iter_swap_aux_aux(_ForwardIter1& __i1, _ForwardIter2& __i2, _Value *) { + _Value tmp = *__i1; + *__i1 = *__i2; + *__i2 = tmp; +} + +template +inline void __iter_swap_aux(_ForwardIter1& __i1, _ForwardIter2& __i2, const __true_type& /*OKToSwap*/) { + swap(*__i1, *__i2); +} + +template +inline void __iter_swap_aux(_ForwardIter1& __i1, _ForwardIter2& __i2, const __false_type& /*OKToSwap*/) { + __iter_swap_aux_aux( __i1, __i2, _STLP_VALUE_TYPE(__i1,_ForwardIter1) ); +} + +_STLP_MOVE_TO_STD_NAMESPACE template inline void iter_swap(_ForwardIter1 __i1, _ForwardIter2 __i2) { - swap(*__i1, *__i2); + // swap(*__i1, *__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__) || 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 inline const _Tp& (min)(const _Tp& __a, const _Tp& __b) { return __b < __a ? __b : __a; } template inline const _Tp& (max)(const _Tp& __a, const _Tp& __b) { return __a < __b ? __b : __a; } -#endif /* __BORLANDC__ */ +# endif +#endif -# if defined (__BORLANDC__) && ( __BORLANDC__ < 0x530 || defined (_STLP_USE_OWN_NAMESPACE)) +# 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 template -inline const _Tp& (min)(const _Tp& __a, const _Tp& __b, _Compare __comp) { +inline const _Tp& (min)(const _Tp& __a, const _Tp& __b, _Compare __comp) { return __comp(__b, __a) ? __b : __a; } @@ -103,33 +166,33 @@ // (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 inline _OutputIter __copy(_InputIter __first, _InputIter __last, - _OutputIter __result, - const input_iterator_tag &, _Distance*) { + _OutputIter __result, const input_iterator_tag &, _Distance*) { for ( ; __first != __last; ++__result, ++__first) *__result = *__first; return __result; } -# if defined (_STLP_NONTEMPL_BASE_MATCH_BUG) +#if defined (_STLP_NONTEMPL_BASE_MATCH_BUG) template inline _OutputIter __copy(_InputIter __first, _InputIter __last, - _OutputIter __result, const forward_iterator_tag &, _Distance* ) { + _OutputIter __result, const forward_iterator_tag &, _Distance* ) { for ( ; __first != __last; ++__result, ++__first) *__result = *__first; return __result; } - template inline _OutputIter __copy(_InputIter __first, _InputIter __last, - _OutputIter __result, const bidirectional_iterator_tag &, _Distance* __dis) { + _OutputIter __result, const bidirectional_iterator_tag &, _Distance* ) { for ( ; __first != __last; ++__result, ++__first) *__result = *__first; return __result; } -# endif +#endif template inline _OutputIter @@ -145,34 +208,31 @@ inline void* __copy_trivial(const void* __first, const void* __last, void* __result) { - return (__last == __first) ? __result : - ((char*)memmove(__result, __first, ((const char*)__last - (const char*)__first))) + - ((const char*)__last - (const char*)__first); + size_t __n = (const char*)__last - (const char*)__first; + return __n ? (void *)((char*)memmove(__result, __first, __n) + __n) : __result; } //-------------------------------------------------- // copy_backward auxiliary functions -template -inline _BidirectionalIter2 __copy_backward(_BidirectionalIter1 __first, - _BidirectionalIter1 __last, +inline _BidirectionalIter2 __copy_backward(_BidirectionalIter1 __first, + _BidirectionalIter1 __last, _BidirectionalIter2 __result, const bidirectional_iterator_tag &, - _Distance*) -{ + _Distance*) { while (__first != __last) *--__result = *--__last; return __result; } template -inline _BidirectionalIter __copy_backward(_RandomAccessIter __first, - _RandomAccessIter __last, +inline _BidirectionalIter __copy_backward(_RandomAccessIter __first, + _RandomAccessIter __last, _BidirectionalIter __result, const random_access_iterator_tag &, - _Distance*) -{ + _Distance*) { for (_Distance __n = __last - __first; __n > 0; --__n) *--__result = *--__last; return __result; @@ -185,44 +245,53 @@ } template -inline _OutputIter __copy_ptrs(_InputIter __first, _InputIter __last, _OutputIter __result, const __false_type&) { - return __copy(__first, __last, __result, - _STLP_ITERATOR_CATEGORY(__first, _InputIter), - _STLP_DISTANCE_TYPE(__first, _InputIter)); +inline _OutputIter __copy_ptrs(_InputIter __first, _InputIter __last, _OutputIter __result, + const __false_type& /*IsOKToMemCpy*/) { + return __copy(__first, __last, __result, random_access_iterator_tag(), (ptrdiff_t*)0); } template -inline _OutputIter __copy_ptrs(_InputIter __first, _InputIter __last, _OutputIter __result, const __true_type&) { -// we know they all pointers, so this cast is OK +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)__copy_trivial(__first, __last, __result); } template -inline _OutputIter __copy_aux(_InputIter __first, _InputIter __last, _OutputIter __result, const __true_type&) { - return __copy_ptrs(__first, __last, __result, - _IsOKToMemCpy(_STLP_VALUE_TYPE(__first, _InputIter), - _STLP_VALUE_TYPE(__result, _OutputIter))._Ret()); +inline _OutputIter __copy_aux(_InputIter __first, _InputIter __last, _OutputIter __result, + const __true_type& /*BothPtrType*/) { + return __copy_ptrs(__first, __last, __result, + _UseTrivialCopy(_STLP_VALUE_TYPE(__first, _InputIter), + _STLP_VALUE_TYPE(__result, _OutputIter))._Answer()); } template -inline _OutputIter __copy_aux(_InputIter __first, _InputIter __last, _OutputIter __result, const __false_type&) { - return __copy(__first, __last, __result, - _STLP_ITERATOR_CATEGORY(__first, _InputIter), _STLP_DISTANCE_TYPE(__first, _InputIter)); +inline _OutputIter __copy_aux(_InputIter __first, _InputIter __last, _OutputIter __result, + const __false_type& /*BothPtrType*/) { + return __copy(__first, __last, __result, + _STLP_ITERATOR_CATEGORY(__first, _InputIter), + _STLP_DISTANCE_TYPE(__first, _InputIter)); } +_STLP_MOVE_TO_STD_NAMESPACE + template inline _OutputIter copy(_InputIter __first, _InputIter __last, _OutputIter __result) { - _STLP_DEBUG_CHECK(__check_range(__first, __last)) - return __copy_aux(__first, __last, __result, _BothPtrType< _InputIter, _OutputIter> :: _Ret()); + _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 -inline _OutputIter __copy_backward_ptrs(_InputIter __first, _InputIter __last, _OutputIter __result, const __false_type&) { +inline _OutputIter __copy_backward_ptrs(_InputIter __first, _InputIter __last, + _OutputIter __result, const __false_type& /*TrivialAssignment*/) { return __copy_backward(__first, __last, __result, _STLP_ITERATOR_CATEGORY(__first, _InputIter), _STLP_DISTANCE_TYPE(__first, _InputIter)); } template -inline _OutputIter __copy_backward_ptrs(_InputIter __first, _InputIter __last, _OutputIter __result, const __true_type&) { - return (_OutputIter)__copy_trivial_backward(__first, __last, __result); +inline _OutputIter __copy_backward_ptrs(_InputIter __first, _InputIter __last, + _OutputIter __result, const __true_type& /*TrivialAssignment*/) { + return (_OutputIter)__copy_trivial_backward(__first, __last, __result); } template @@ -232,28 +301,30 @@ template inline _OutputIter __copy_backward_aux(_InputIter __first, _InputIter __last, _OutputIter __result, const __true_type&) { - return __copy_backward_ptrs(__first, __last, __result, - _IsOKToMemCpy(_STLP_VALUE_TYPE(__first, _InputIter), - _STLP_VALUE_TYPE(__result, _OutputIter))._Ret()); + return __copy_backward_ptrs(__first, __last, __result, + _UseTrivialCopy(_STLP_VALUE_TYPE(__first, _InputIter), + _STLP_VALUE_TYPE(__result, _OutputIter))._Answer()); } +_STLP_MOVE_TO_STD_NAMESPACE + template inline _OutputIter copy_backward(_InputIter __first, _InputIter __last, _OutputIter __result) { - _STLP_DEBUG_CHECK(__check_range(__first, __last)) - return __copy_backward_aux(__first, __last, __result, _BothPtrType< _InputIter, _OutputIter> :: _Ret() ); + _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*)__copy_trivial(__first, __last, __result); } \ +#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*)__copy_trivial(__first, __last, __result); } \ inline _Tp* copy_backward(const _Tp* __first, const _Tp* __last, _Tp* __result) \ { return (_Tp*)__copy_trivial_backward(__first, __last, __result); } _STLP_DECLARE_COPY_TRIVIAL(char) -# ifndef _STLP_NO_SIGNED_BUILTINS +# if !defined (_STLP_NO_SIGNED_BUILTINS) _STLP_DECLARE_COPY_TRIVIAL(signed char) -# endif +# endif _STLP_DECLARE_COPY_TRIVIAL(unsigned char) _STLP_DECLARE_COPY_TRIVIAL(short) _STLP_DECLARE_COPY_TRIVIAL(unsigned short) @@ -261,29 +332,32 @@ _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) +# if !defined(_STLP_NO_WCHAR_T) && !defined (_STLP_WCHAR_T_IS_USHORT) _STLP_DECLARE_COPY_TRIVIAL(wchar_t) -#endif -#ifdef _STLP_LONG_LONG -_STLP_DECLARE_COPY_TRIVIAL(long long) -_STLP_DECLARE_COPY_TRIVIAL(unsigned long long) -#endif +# 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) -# ifndef _STLP_NO_LONG_DOUBLE +# if !defined (_STLP_NO_LONG_DOUBLE) _STLP_DECLARE_COPY_TRIVIAL(long double) -# endif -#undef _STLP_DECLARE_COPY_TRIVIAL +# endif +# undef _STLP_DECLARE_COPY_TRIVIAL #endif /* _STLP_CLASS_PARTIAL_SPECIALIZATION */ //-------------------------------------------------- // copy_n (not part of the C++ standard) +#if !defined (_STLP_NO_EXTENSIONS) +_STLP_MOVE_TO_PRIV_NAMESPACE + template -_STLP_INLINE_LOOP -pair<_InputIter, _OutputIter> __copy_n(_InputIter __first, _Size __count, - _OutputIter __result, - const input_iterator_tag &) { +_STLP_INLINE_LOOP pair<_InputIter, _OutputIter> +__copy_n(_InputIter __first, _Size __count, + _OutputIter __result, + const input_iterator_tag &) { for ( ; __count > 0; --__count) { *__result = *__first; ++__first; @@ -301,83 +375,88 @@ return pair<_RAIter, _OutputIter>(__last, copy(__first, __last, __result)); } -template -inline pair<_InputIter, _OutputIter> -__copy_n(_InputIter __first, _Size __count, _OutputIter __result) { - _STLP_FIX_LITERAL_BUG(__first) - return __copy_n(__first, __count, __result, _STLP_ITERATOR_CATEGORY(__first, _InputIter)); -} +_STLP_MOVE_TO_STD_NAMESPACE template inline pair<_InputIter, _OutputIter> copy_n(_InputIter __first, _Size __count, _OutputIter __result) { _STLP_FIX_LITERAL_BUG(__first) - return __copy_n(__first, __count, __result, _STLP_ITERATOR_CATEGORY(__first, _InputIter)); + return _STLP_PRIV __copy_n(__first, __count, __result, _STLP_ITERATOR_CATEGORY(__first, _InputIter)); } +#endif //-------------------------------------------------- // fill and fill_n - - template _STLP_INLINE_LOOP void fill(_ForwardIter __first, _ForwardIter __last, const _Tp& __val) { - _STLP_DEBUG_CHECK(__check_range(__first, __last)) + _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first, __last)) for ( ; __first != __last; ++__first) *__first = __val; } +_STLP_MOVE_TO_PRIV_NAMESPACE + template _STLP_INLINE_LOOP -_OutputIter fill_n(_OutputIter __first, _Size __n, const _Tp& __val) { +_OutputIter __fill_n(_OutputIter __first, _Size __n, const _Tp& __val) { _STLP_FIX_LITERAL_BUG(__first) for ( ; __n > 0; --__n, ++__first) *__first = __val; return __first; } +_STLP_MOVE_TO_STD_NAMESPACE + +template +_STLP_INLINE_LOOP +void fill_n(_OutputIter __first, _Size __n, const _Tp& __val) { + _STLP_FIX_LITERAL_BUG(__first) + _STLP_PRIV __fill_n(__first, __n, __val); +} // 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); } -# ifndef _STLP_NO_SIGNED_BUILTINS +#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 +#endif inline void fill(char* __first, char* __last, const char& __val) { char __tmp = __val; memset(__first, __STATIC_CAST(unsigned char,__tmp), __last - __first); } -#ifdef _STLP_FUNCTION_TMPL_PARTIAL_ORDER +#if defined (_STLP_FUNCTION_TMPL_PARTIAL_ORDER) +_STLP_MOVE_TO_PRIV_NAMESPACE template -inline unsigned char* fill_n(unsigned char* __first, _Size __n, +inline unsigned char* __fill_n(unsigned char* __first, _Size __n, const unsigned char& __val) { fill(__first, __first + __n, __val); return __first + __n; } template -inline signed char* fill_n(char* __first, _Size __n, +inline signed char* __fill_n(char* __first, _Size __n, const signed char& __val) { fill(__first, __first + __n, __val); return __first + __n; } template -inline char* fill_n(char* __first, _Size __n, const char& __val) { +inline char* __fill_n(char* __first, _Size __n, const char& __val) { fill(__first, __first + __n, __val); return __first + __n; } +_STLP_MOVE_TO_STD_NAMESPACE #endif /* _STLP_FUNCTION_TMPL_PARTIAL_ORDER */ @@ -390,7 +469,7 @@ _InputIter1 __last1, _InputIter2 __first2) { _STLP_FIX_LITERAL_BUG(__first2) - _STLP_DEBUG_CHECK(__check_range(__first1, __last1)) + _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first1, __last1)) while (__first1 != __last1 && *__first1 == *__first2) { ++__first1; ++__first2; @@ -405,7 +484,7 @@ _InputIter2 __first2, _BinaryPredicate __binary_pred) { _STLP_FIX_LITERAL_BUG(__first2) - _STLP_DEBUG_CHECK(__check_range(__first1, __last1)) + _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first1, __last1)) while (__first1 != __last1 && __binary_pred(*__first1, *__first2)) { ++__first1; ++__first2; @@ -418,7 +497,7 @@ 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(__check_range(__first1, __last1)) + _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first1, __last1)) for ( ; __first1 != __last1; ++__first1, ++__first2) if (!(*__first1 == *__first2)) return false; @@ -430,7 +509,7 @@ bool equal(_InputIter1 __first1, _InputIter1 __last1, _InputIter2 __first2, _BinaryPredicate __binary_pred) { _STLP_FIX_LITERAL_BUG(__first2) - _STLP_DEBUG_CHECK(__check_range(__first1, __last1)) + _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first1, __last1)) for ( ; __first1 != __last1; ++__first1, ++__first2) if (!__binary_pred(*__first1, *__first2)) return false; @@ -450,28 +529,26 @@ _InputIter2 __first2, _InputIter2 __last2, _Compare __comp); -inline bool +inline bool lexicographical_compare(const unsigned char* __first1, const unsigned char* __last1, const unsigned char* __first2, - const unsigned char* __last2) -{ + const unsigned char* __last2) { const size_t __len1 = __last1 - __first1; const size_t __len2 = __last2 - __first2; - _STLP_DEBUG_CHECK(__check_range(__first1, __last1)) - _STLP_DEBUG_CHECK(__check_range(__first2, __last2)) + _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) +#if !(CHAR_MAX == SCHAR_MAX) inline bool lexicographical_compare(const char* __first1, const char* __last1, - const char* __first2, const char* __last2) -{ - _STLP_DEBUG_CHECK(__check_range(__first1, __last1)) - _STLP_DEBUG_CHECK(__check_range(__first2, __last2)) + 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, @@ -480,6 +557,8 @@ } #endif /* CHAR_MAX == SCHAR_MAX */ +_STLP_MOVE_TO_PRIV_NAMESPACE + template int __lexicographical_compare_3way(_InputIter1 __first1, _InputIter1 __last1, _InputIter2 __first2, _InputIter2 __last2); @@ -488,41 +567,40 @@ __lexicographical_compare_3way(const unsigned char* __first1, const unsigned char* __last1, const unsigned char* __first2, - const unsigned char* __last2) -{ + 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 + return __result != 0 ? __result : (__len1 == __len2 ? 0 : (__len1 < __len2 ? -1 : 1)); } -# if !(CHAR_MAX == SCHAR_MAX) -inline int +#if !(CHAR_MAX == SCHAR_MAX) +inline int __lexicographical_compare_3way(const char* __first1, const char* __last1, - const char* __first2, const char* __last2) -{ + 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 +#endif -# ifndef _STLP_NO_EXTENSIONS +_STLP_MOVE_TO_STD_NAMESPACE +#if !defined (_STLP_NO_EXTENSIONS) template int lexicographical_compare_3way(_InputIter1 __first1, _InputIter1 __last1, _InputIter2 __first2, _InputIter2 __last2); -# endif /* EXTENSIONS */ +#endif /* EXTENSIONS */ // count template _STLP_INLINE_LOOP _STLP_DIFFERENCE_TYPE(_InputIter) count(_InputIter __first, _InputIter __last, const _Tp& __val) { - _STLP_DEBUG_CHECK(__check_range(__first, __last)) + _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first, __last)) _STLP_DIFFERENCE_TYPE(_InputIter) __n = 0; for ( ; __first != __last; ++__first) if (*__first == __val) @@ -533,6 +611,7 @@ // find and find_if. Note find may be expressed in terms of find_if if appropriate binder was available. template _InputIter find(_InputIter __first, _InputIter __last, const _Tp& __val); + template _InputIter find_if(_InputIter __first, _InputIter __last, _Predicate __pred); @@ -541,39 +620,47 @@ _ForwardIter1 search(_ForwardIter1 __first1, _ForwardIter1 __last1, _ForwardIter2 __first2, _ForwardIter2 __last2, _BinaryPred __predicate); +_STLP_MOVE_TO_PRIV_NAMESPACE + // find_first_of template _InputIter __find_first_of(_InputIter __first1, _InputIter __last1, _ForwardIter __first2, _ForwardIter __last2, _BinaryPredicate __comp); -template -_ForwardIter1 -find_end(_ForwardIter1 __first1, _ForwardIter1 __last1, +_ForwardIter1 +find_end(_ForwardIter1 __first1, _ForwardIter1 __last1, _ForwardIter2 __first2, _ForwardIter2 __last2, _BinaryPredicate __comp); // replace template -_STLP_INLINE_LOOP void +_STLP_INLINE_LOOP void replace(_ForwardIter __first, _ForwardIter __last, const _Tp& __old_value, const _Tp& __new_value) { - _STLP_DEBUG_CHECK(__check_range(__first, __last)) + _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first, __last)) for ( ; __first != __last; ++__first) if (*__first == __old_value) *__first = __new_value; } -template +_STLP_MOVE_TO_PRIV_NAMESPACE + +template _ForwardIter __lower_bound(_ForwardIter __first, _ForwardIter __last, - const _Tp& __val, _Compare __comp, _Distance*); + const _Tp& __val, _Compare1 __comp1, _Compare2 __comp2, _Distance*); + +_STLP_MOVE_TO_STD_NAMESPACE _STLP_END_NAMESPACE -# if !defined (_STLP_LINK_TIME_INSTANTIATION) +#if !defined (_STLP_LINK_TIME_INSTANTIATION) # include -# endif +#endif #endif /* _STLP_INTERNAL_ALGOBASE_H */