epoc32/include/stdapis/stlportv5/stl/_algobase.h
branchSymbian2
changeset 3 e1b950c65cb4
parent 2 2fe1408b6811
child 4 837f303aceeb
     1.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
     1.2 +++ b/epoc32/include/stdapis/stlportv5/stl/_algobase.h	Wed Mar 31 12:27:01 2010 +0100
     1.3 @@ -0,0 +1,583 @@
     1.4 +/*
     1.5 + *
     1.6 + * Copyright (c) 1994
     1.7 + * Hewlett-Packard Company
     1.8 + *
     1.9 + * Copyright (c) 1996,1997
    1.10 + * Silicon Graphics Computer Systems, Inc.
    1.11 + *
    1.12 + * Copyright (c) 1997
    1.13 + * Moscow Center for SPARC Technology
    1.14 + *
    1.15 + * Copyright (c) 1999 
    1.16 + * Boris Fomitchev
    1.17 + *
    1.18 + * This material is provided "as is", with absolutely no warranty expressed
    1.19 + * or implied. Any use is at your own risk.
    1.20 + *
    1.21 + * Permission to use or copy this software for any purpose is hereby granted 
    1.22 + * without fee, provided the above notices are retained on all copies.
    1.23 + * Permission to modify the code and to distribute modified code is granted,
    1.24 + * provided the above notices are retained, and a notice that the code was
    1.25 + * modified is included with the above copyright notice.
    1.26 + *
    1.27 + */
    1.28 +
    1.29 +/* NOTE: This is an internal header file, included by other STL headers.
    1.30 + *   You should not attempt to use it directly.
    1.31 + */
    1.32 +
    1.33 +
    1.34 +#ifndef _STLP_INTERNAL_ALGOBASE_H
    1.35 +#define _STLP_INTERNAL_ALGOBASE_H
    1.36 +
    1.37 +# if ! defined (_STLP_CSTDDEF)
    1.38 +#  include <cstddef>
    1.39 +# endif
    1.40 +
    1.41 +#ifndef _STLP_CSTRING
    1.42 +# include <cstring>
    1.43 +#endif
    1.44 +
    1.45 +#ifndef _STLP_CLIMITS
    1.46 +# include <climits>
    1.47 +#endif
    1.48 +
    1.49 +# if ! defined (_STLP_CSTDLIB)
    1.50 +#  include <cstdlib>
    1.51 +# endif
    1.52 +
    1.53 +# ifndef _STLP_INTERNAL_PAIR_H
    1.54 +#  include <stl/_pair.h>
    1.55 +# endif
    1.56 +
    1.57 +#ifndef _STLP_INTERNAL_ITERATOR_BASE_H
    1.58 +# include <stl/_iterator_base.h>
    1.59 +#endif
    1.60 +
    1.61 +_STLP_BEGIN_NAMESPACE
    1.62 +// swap and iter_swap
    1.63 +template <class _Tp>
    1.64 +inline void swap(_Tp& __a, _Tp& __b) {
    1.65 +  _Tp __tmp = __a;
    1.66 +  __a = __b;
    1.67 +  __b = __tmp;
    1.68 +}
    1.69 +
    1.70 +template <class _ForwardIter1, class _ForwardIter2>
    1.71 +inline void iter_swap(_ForwardIter1 __i1, _ForwardIter2 __i2) {
    1.72 +  swap(*__i1, *__i2);
    1.73 +}
    1.74 +
    1.75 +//--------------------------------------------------
    1.76 +// min and max
    1.77 +
    1.78 +# if !defined (__BORLANDC__) || defined (_STLP_USE_OWN_NAMESPACE)
    1.79 +template <class _Tp>
    1.80 +inline const _Tp& (min)(const _Tp& __a, const _Tp& __b) { return __b < __a ? __b : __a; }
    1.81 +template <class _Tp>
    1.82 +inline const _Tp& (max)(const _Tp& __a, const _Tp& __b) {  return  __a < __b ? __b : __a; }
    1.83 +#endif /* __BORLANDC__ */
    1.84 +
    1.85 +# if defined (__BORLANDC__) && ( __BORLANDC__ < 0x530 || defined (_STLP_USE_OWN_NAMESPACE))
    1.86 +inline unsigned long (min) (unsigned long __a, unsigned long __b) { return __b < __a ? __b : __a; }
    1.87 +inline unsigned long (max) (unsigned long __a, unsigned long __b) {  return  __a < __b ? __b : __a; }
    1.88 +# endif
    1.89 +
    1.90 +template <class _Tp, class _Compare>
    1.91 +inline const _Tp& (min)(const _Tp& __a, const _Tp& __b, _Compare __comp) { 
    1.92 +  return __comp(__b, __a) ? __b : __a;
    1.93 +}
    1.94 +
    1.95 +template <class _Tp, class _Compare>
    1.96 +inline const _Tp& (max)(const _Tp& __a, const _Tp& __b, _Compare __comp) {
    1.97 +  return __comp(__a, __b) ? __b : __a;
    1.98 +}
    1.99 +
   1.100 +//--------------------------------------------------
   1.101 +// copy
   1.102 +
   1.103 +// All of these auxiliary functions serve two purposes.  (1) Replace
   1.104 +// calls to copy with memmove whenever possible.  (Memmove, not memcpy,
   1.105 +// because the input and output ranges are permitted to overlap.)
   1.106 +// (2) If we're using random access iterators, then write the loop as
   1.107 +// a for loop with an explicit count.
   1.108 +
   1.109 +template <class _InputIter, class _OutputIter, class _Distance>
   1.110 +inline _OutputIter __copy(_InputIter __first, _InputIter __last,
   1.111 +                          _OutputIter __result,
   1.112 +                          const input_iterator_tag &, _Distance*) {
   1.113 +  for ( ; __first != __last; ++__result, ++__first)
   1.114 +    *__result = *__first;
   1.115 +  return __result;
   1.116 +}
   1.117 +
   1.118 +# if defined (_STLP_NONTEMPL_BASE_MATCH_BUG) 
   1.119 +template <class _InputIter, class _OutputIter, class _Distance>
   1.120 +inline _OutputIter __copy(_InputIter __first, _InputIter __last,
   1.121 +			  _OutputIter __result, const forward_iterator_tag &, _Distance* ) {
   1.122 +  for ( ; __first != __last; ++__result, ++__first)
   1.123 +    *__result = *__first;
   1.124 +  return __result;
   1.125 +}
   1.126 +
   1.127 +
   1.128 +template <class _InputIter, class _OutputIter, class _Distance>
   1.129 +inline _OutputIter __copy(_InputIter __first, _InputIter __last,
   1.130 +			  _OutputIter __result, const bidirectional_iterator_tag &, _Distance* __dis) {
   1.131 +  for ( ; __first != __last; ++__result, ++__first)
   1.132 +    *__result = *__first;
   1.133 +  return __result;
   1.134 +}
   1.135 +# endif 
   1.136 +
   1.137 +template <class _RandomAccessIter, class _OutputIter, class _Distance>
   1.138 +inline _OutputIter
   1.139 +__copy(_RandomAccessIter __first, _RandomAccessIter __last,
   1.140 +       _OutputIter __result, const random_access_iterator_tag &, _Distance*) {
   1.141 +  for (_Distance __n = __last - __first; __n > 0; --__n) {
   1.142 +    *__result = *__first;
   1.143 +    ++__first;
   1.144 +    ++__result;
   1.145 +  }
   1.146 +  return __result;
   1.147 +}
   1.148 +
   1.149 +inline void*
   1.150 +__copy_trivial(const void* __first, const void* __last, void* __result) {
   1.151 +  return (__last == __first) ? __result : 
   1.152 +    ((char*)memmove(__result, __first, ((const char*)__last - (const char*)__first))) + 
   1.153 +    ((const char*)__last - (const char*)__first);
   1.154 +}
   1.155 +
   1.156 +//--------------------------------------------------
   1.157 +// copy_backward auxiliary functions
   1.158 +
   1.159 +template <class _BidirectionalIter1, class _BidirectionalIter2, 
   1.160 +          class _Distance>
   1.161 +inline _BidirectionalIter2 __copy_backward(_BidirectionalIter1 __first, 
   1.162 +                                           _BidirectionalIter1 __last, 
   1.163 +                                           _BidirectionalIter2 __result,
   1.164 +                                           const bidirectional_iterator_tag &,
   1.165 +                                           _Distance*) 
   1.166 +{
   1.167 +  while (__first != __last)
   1.168 +    *--__result = *--__last;
   1.169 +  return __result;
   1.170 +}
   1.171 +
   1.172 +template <class _RandomAccessIter, class _BidirectionalIter, class _Distance>
   1.173 +inline _BidirectionalIter __copy_backward(_RandomAccessIter __first, 
   1.174 +                                          _RandomAccessIter __last, 
   1.175 +                                          _BidirectionalIter __result,
   1.176 +                                          const random_access_iterator_tag &,
   1.177 +                                          _Distance*)
   1.178 +{
   1.179 +  for (_Distance __n = __last - __first; __n > 0; --__n)
   1.180 +    *--__result = *--__last;
   1.181 +  return __result;
   1.182 +}
   1.183 +
   1.184 +inline void*
   1.185 +__copy_trivial_backward(const void* __first, const void* __last, void* __result) {
   1.186 +  const ptrdiff_t _Num = (const char*)__last - (const char*)__first;
   1.187 +  return (_Num > 0) ? memmove((char*)__result - _Num, __first, _Num) : __result ;
   1.188 +}
   1.189 +
   1.190 +template <class _InputIter, class _OutputIter>
   1.191 +inline _OutputIter __copy_ptrs(_InputIter __first, _InputIter __last, _OutputIter __result, const __false_type&) {
   1.192 +  return __copy(__first, __last, __result, 
   1.193 +                _STLP_ITERATOR_CATEGORY(__first, _InputIter), 
   1.194 +                _STLP_DISTANCE_TYPE(__first, _InputIter));
   1.195 +}
   1.196 +template <class _InputIter, class _OutputIter>
   1.197 +inline _OutputIter __copy_ptrs(_InputIter __first, _InputIter __last, _OutputIter __result, const __true_type&) {
   1.198 +// we know they all pointers, so this cast is OK 
   1.199 +  //  return (_OutputIter)__copy_trivial(&(*__first), &(*__last), &(*__result));
   1.200 +  return (_OutputIter)__copy_trivial(__first, __last, __result);
   1.201 +}
   1.202 +
   1.203 +template <class _InputIter, class _OutputIter>
   1.204 +inline _OutputIter __copy_aux(_InputIter __first, _InputIter __last, _OutputIter __result, const __true_type&) {
   1.205 +  return __copy_ptrs(__first, __last, __result, 
   1.206 +                     _IsOKToMemCpy(_STLP_VALUE_TYPE(__first, _InputIter), 
   1.207 +                                   _STLP_VALUE_TYPE(__result, _OutputIter))._Ret());
   1.208 +}
   1.209 +
   1.210 +template <class _InputIter, class _OutputIter>
   1.211 +inline _OutputIter __copy_aux(_InputIter __first, _InputIter __last, _OutputIter __result, const __false_type&) {
   1.212 +  return __copy(__first, __last, __result, 
   1.213 +		_STLP_ITERATOR_CATEGORY(__first, _InputIter), _STLP_DISTANCE_TYPE(__first, _InputIter));
   1.214 +}
   1.215 +
   1.216 +template <class _InputIter, class _OutputIter>
   1.217 +inline _OutputIter copy(_InputIter __first, _InputIter __last, _OutputIter __result) {
   1.218 +  _STLP_DEBUG_CHECK(__check_range(__first, __last))
   1.219 +    return __copy_aux(__first, __last, __result, _BothPtrType< _InputIter, _OutputIter> :: _Ret());
   1.220 +}
   1.221 +
   1.222 +template <class _InputIter, class _OutputIter>
   1.223 +inline _OutputIter __copy_backward_ptrs(_InputIter __first, _InputIter __last, _OutputIter __result, const __false_type&) {
   1.224 +  return __copy_backward(__first, __last, __result, _STLP_ITERATOR_CATEGORY(__first, _InputIter), _STLP_DISTANCE_TYPE(__first, _InputIter));
   1.225 +}
   1.226 +template <class _InputIter, class _OutputIter>
   1.227 +inline _OutputIter __copy_backward_ptrs(_InputIter __first, _InputIter __last, _OutputIter __result, const __true_type&) {
   1.228 +  return (_OutputIter)__copy_trivial_backward(__first, __last, __result);  
   1.229 +}
   1.230 +
   1.231 +template <class _InputIter, class _OutputIter>
   1.232 +inline _OutputIter __copy_backward_aux(_InputIter __first, _InputIter __last, _OutputIter __result, const __false_type&) {
   1.233 +  return __copy_backward(__first, __last, __result, _STLP_ITERATOR_CATEGORY(__first,_InputIter), _STLP_DISTANCE_TYPE(__first, _InputIter));
   1.234 +}
   1.235 +
   1.236 +template <class _InputIter, class _OutputIter>
   1.237 +inline _OutputIter __copy_backward_aux(_InputIter __first, _InputIter __last, _OutputIter __result, const __true_type&) {
   1.238 +  return __copy_backward_ptrs(__first, __last, __result,  
   1.239 +                              _IsOKToMemCpy(_STLP_VALUE_TYPE(__first, _InputIter), 
   1.240 +                                            _STLP_VALUE_TYPE(__result, _OutputIter))._Ret());
   1.241 +}
   1.242 +
   1.243 +template <class _InputIter, class _OutputIter>
   1.244 +inline _OutputIter copy_backward(_InputIter __first, _InputIter __last, _OutputIter __result) {
   1.245 +  _STLP_DEBUG_CHECK(__check_range(__first, __last))
   1.246 +    return __copy_backward_aux(__first, __last, __result, _BothPtrType< _InputIter, _OutputIter> :: _Ret() );
   1.247 +}
   1.248 +
   1.249 +#if ! defined (_STLP_CLASS_PARTIAL_SPECIALIZATION) && ! defined ( _STLP_SIMULATE_PARTIAL_SPEC_FOR_TYPE_TRAITS )
   1.250 +#define _STLP_DECLARE_COPY_TRIVIAL(_Tp)                                \
   1.251 +inline _Tp* copy(const _Tp* __first, const _Tp* __last, _Tp* __result) \
   1.252 +{ return (_Tp*)__copy_trivial(__first, __last, __result); } \
   1.253 +inline _Tp* copy_backward(const _Tp* __first, const _Tp* __last, _Tp* __result) \
   1.254 +{ return (_Tp*)__copy_trivial_backward(__first, __last, __result); }
   1.255 +
   1.256 +_STLP_DECLARE_COPY_TRIVIAL(char)
   1.257 +# ifndef _STLP_NO_SIGNED_BUILTINS
   1.258 +_STLP_DECLARE_COPY_TRIVIAL(signed char)
   1.259 +# endif
   1.260 +_STLP_DECLARE_COPY_TRIVIAL(unsigned char)
   1.261 +_STLP_DECLARE_COPY_TRIVIAL(short)
   1.262 +_STLP_DECLARE_COPY_TRIVIAL(unsigned short)
   1.263 +_STLP_DECLARE_COPY_TRIVIAL(int)
   1.264 +_STLP_DECLARE_COPY_TRIVIAL(unsigned int)
   1.265 +_STLP_DECLARE_COPY_TRIVIAL(long)
   1.266 +_STLP_DECLARE_COPY_TRIVIAL(unsigned long)
   1.267 +#if !defined(_STLP_NO_WCHAR_T) && !defined (_STLP_WCHAR_T_IS_USHORT) 
   1.268 +_STLP_DECLARE_COPY_TRIVIAL(wchar_t)
   1.269 +#endif
   1.270 +#ifdef _STLP_LONG_LONG
   1.271 +_STLP_DECLARE_COPY_TRIVIAL(long long)
   1.272 +_STLP_DECLARE_COPY_TRIVIAL(unsigned long long)
   1.273 +#endif 
   1.274 +_STLP_DECLARE_COPY_TRIVIAL(float)
   1.275 +_STLP_DECLARE_COPY_TRIVIAL(double)
   1.276 +# ifndef _STLP_NO_LONG_DOUBLE
   1.277 +_STLP_DECLARE_COPY_TRIVIAL(long double)
   1.278 +# endif
   1.279 +#undef _STLP_DECLARE_COPY_TRIVIAL
   1.280 +#endif /* _STLP_CLASS_PARTIAL_SPECIALIZATION */
   1.281 +
   1.282 +//--------------------------------------------------
   1.283 +// copy_n (not part of the C++ standard)
   1.284 +
   1.285 +template <class _InputIter, class _Size, class _OutputIter>
   1.286 +_STLP_INLINE_LOOP 
   1.287 +pair<_InputIter, _OutputIter> __copy_n(_InputIter __first, _Size __count,
   1.288 +                                       _OutputIter __result,
   1.289 +                                       const input_iterator_tag &) {
   1.290 +  for ( ; __count > 0; --__count) {
   1.291 +    *__result = *__first;
   1.292 +    ++__first;
   1.293 +    ++__result;
   1.294 +  }
   1.295 +  return pair<_InputIter, _OutputIter>(__first, __result);
   1.296 +}
   1.297 +
   1.298 +template <class _RAIter, class _Size, class _OutputIter>
   1.299 +inline pair<_RAIter, _OutputIter>
   1.300 +__copy_n(_RAIter __first, _Size __count,
   1.301 +         _OutputIter __result,
   1.302 +         const random_access_iterator_tag &) {
   1.303 +  _RAIter __last = __first + __count;
   1.304 +  return pair<_RAIter, _OutputIter>(__last, copy(__first, __last, __result));
   1.305 +}
   1.306 +
   1.307 +template <class _InputIter, class _Size, class _OutputIter>
   1.308 +inline pair<_InputIter, _OutputIter>
   1.309 +__copy_n(_InputIter __first, _Size __count, _OutputIter __result) {
   1.310 +  _STLP_FIX_LITERAL_BUG(__first)
   1.311 +  return __copy_n(__first, __count, __result, _STLP_ITERATOR_CATEGORY(__first, _InputIter));
   1.312 +}
   1.313 +
   1.314 +template <class _InputIter, class _Size, class _OutputIter>
   1.315 +inline pair<_InputIter, _OutputIter>
   1.316 +copy_n(_InputIter __first, _Size __count, _OutputIter __result) {
   1.317 +  _STLP_FIX_LITERAL_BUG(__first)
   1.318 +  return __copy_n(__first, __count, __result, _STLP_ITERATOR_CATEGORY(__first, _InputIter));
   1.319 +}
   1.320 +
   1.321 +//--------------------------------------------------
   1.322 +// fill and fill_n
   1.323 +
   1.324 +
   1.325 +template <class _ForwardIter, class _Tp>
   1.326 +_STLP_INLINE_LOOP
   1.327 +void fill(_ForwardIter __first, _ForwardIter __last, const _Tp& __val) {
   1.328 +  _STLP_DEBUG_CHECK(__check_range(__first, __last))
   1.329 +  for ( ; __first != __last; ++__first)
   1.330 +    *__first = __val;
   1.331 +}
   1.332 +
   1.333 +template <class _OutputIter, class _Size, class _Tp>
   1.334 +_STLP_INLINE_LOOP
   1.335 +_OutputIter fill_n(_OutputIter __first, _Size __n, const _Tp& __val) {
   1.336 +  _STLP_FIX_LITERAL_BUG(__first)
   1.337 +  for ( ; __n > 0; --__n, ++__first)
   1.338 +    *__first = __val;
   1.339 +  return __first;
   1.340 +}
   1.341 +
   1.342 +
   1.343 +// Specialization: for one-byte types we can use memset.
   1.344 +
   1.345 +inline void fill(unsigned char* __first, unsigned char* __last,
   1.346 +                 const unsigned char& __val) {
   1.347 +  unsigned char __tmp = __val;
   1.348 +  memset(__first, __tmp, __last - __first);
   1.349 +}
   1.350 +# ifndef _STLP_NO_SIGNED_BUILTINS
   1.351 +inline void fill(signed char* __first, signed char* __last,
   1.352 +                 const signed char& __val) {
   1.353 +  signed char __tmp = __val;
   1.354 +  memset(__first, __STATIC_CAST(unsigned char,__tmp), __last - __first);
   1.355 +}
   1.356 +# endif
   1.357 +inline void fill(char* __first, char* __last, const char& __val) {
   1.358 +  char __tmp = __val;
   1.359 +  memset(__first, __STATIC_CAST(unsigned char,__tmp), __last - __first);
   1.360 +}
   1.361 +
   1.362 +#ifdef _STLP_FUNCTION_TMPL_PARTIAL_ORDER
   1.363 +
   1.364 +template <class _Size>
   1.365 +inline unsigned char* fill_n(unsigned char* __first, _Size __n,
   1.366 +                             const unsigned char& __val) {
   1.367 +  fill(__first, __first + __n, __val);
   1.368 +  return __first + __n;
   1.369 +}
   1.370 +
   1.371 +template <class _Size>
   1.372 +inline signed char* fill_n(char* __first, _Size __n,
   1.373 +                           const signed char& __val) {
   1.374 +  fill(__first, __first + __n, __val);
   1.375 +  return __first + __n;
   1.376 +}
   1.377 +
   1.378 +template <class _Size>
   1.379 +inline char* fill_n(char* __first, _Size __n, const char& __val) {
   1.380 +  fill(__first, __first + __n, __val);
   1.381 +  return __first + __n;
   1.382 +}
   1.383 +
   1.384 +#endif /* _STLP_FUNCTION_TMPL_PARTIAL_ORDER */
   1.385 +
   1.386 +
   1.387 +//--------------------------------------------------
   1.388 +// equal and mismatch
   1.389 +
   1.390 +template <class _InputIter1, class _InputIter2>
   1.391 +_STLP_INLINE_LOOP
   1.392 +pair<_InputIter1, _InputIter2> mismatch(_InputIter1 __first1,
   1.393 +                                        _InputIter1 __last1,
   1.394 +                                        _InputIter2 __first2) {
   1.395 +  _STLP_FIX_LITERAL_BUG(__first2)
   1.396 +  _STLP_DEBUG_CHECK(__check_range(__first1, __last1))
   1.397 +  while (__first1 != __last1 && *__first1 == *__first2) {
   1.398 +    ++__first1;
   1.399 +    ++__first2;
   1.400 +  }
   1.401 +  return pair<_InputIter1, _InputIter2>(__first1, __first2);
   1.402 +}
   1.403 +
   1.404 +template <class _InputIter1, class _InputIter2, class _BinaryPredicate>
   1.405 +_STLP_INLINE_LOOP
   1.406 +pair<_InputIter1, _InputIter2> mismatch(_InputIter1 __first1,
   1.407 +                                        _InputIter1 __last1,
   1.408 +                                        _InputIter2 __first2,
   1.409 +                                        _BinaryPredicate __binary_pred) {
   1.410 +  _STLP_FIX_LITERAL_BUG(__first2)
   1.411 +  _STLP_DEBUG_CHECK(__check_range(__first1, __last1))
   1.412 +  while (__first1 != __last1 && __binary_pred(*__first1, *__first2)) {
   1.413 +    ++__first1;
   1.414 +    ++__first2;
   1.415 +  }
   1.416 +  return pair<_InputIter1, _InputIter2>(__first1, __first2);
   1.417 +}
   1.418 +
   1.419 +template <class _InputIter1, class _InputIter2>
   1.420 +_STLP_INLINE_LOOP
   1.421 +bool equal(_InputIter1 __first1, _InputIter1 __last1,
   1.422 +                  _InputIter2 __first2) {
   1.423 +  _STLP_FIX_LITERAL_BUG(__first1) _STLP_FIX_LITERAL_BUG(__last1)  _STLP_FIX_LITERAL_BUG(__first2)
   1.424 +  _STLP_DEBUG_CHECK(__check_range(__first1, __last1))
   1.425 +  for ( ; __first1 != __last1; ++__first1, ++__first2)
   1.426 +    if (!(*__first1 == *__first2))
   1.427 +      return false;
   1.428 +  return true;
   1.429 +}
   1.430 +
   1.431 +template <class _InputIter1, class _InputIter2, class _BinaryPredicate>
   1.432 +_STLP_INLINE_LOOP
   1.433 +bool equal(_InputIter1 __first1, _InputIter1 __last1,
   1.434 +                  _InputIter2 __first2, _BinaryPredicate __binary_pred) {
   1.435 +  _STLP_FIX_LITERAL_BUG(__first2)
   1.436 +  _STLP_DEBUG_CHECK(__check_range(__first1, __last1))
   1.437 +  for ( ; __first1 != __last1; ++__first1, ++__first2)
   1.438 +    if (!__binary_pred(*__first1, *__first2))
   1.439 +      return false;
   1.440 +  return true;
   1.441 +}
   1.442 +
   1.443 +//--------------------------------------------------
   1.444 +// lexicographical_compare and lexicographical_compare_3way.
   1.445 +// (the latter is not part of the C++ standard.)
   1.446 +
   1.447 +template <class _InputIter1, class _InputIter2>
   1.448 +bool lexicographical_compare(_InputIter1 __first1, _InputIter1 __last1,
   1.449 +                             _InputIter2 __first2, _InputIter2 __last2);
   1.450 +
   1.451 +template <class _InputIter1, class _InputIter2, class _Compare>
   1.452 +bool lexicographical_compare(_InputIter1 __first1, _InputIter1 __last1,
   1.453 +                             _InputIter2 __first2, _InputIter2 __last2,
   1.454 +                             _Compare __comp);
   1.455 +
   1.456 +inline bool 
   1.457 +lexicographical_compare(const unsigned char* __first1,
   1.458 +                        const unsigned char* __last1,
   1.459 +                        const unsigned char* __first2,
   1.460 +                        const unsigned char* __last2)
   1.461 +{
   1.462 +  const size_t __len1 = __last1 - __first1;
   1.463 +  const size_t __len2 = __last2 - __first2;
   1.464 +  _STLP_DEBUG_CHECK(__check_range(__first1, __last1))
   1.465 +  _STLP_DEBUG_CHECK(__check_range(__first2, __last2))
   1.466 +
   1.467 +  const int __result = memcmp(__first1, __first2, (min) (__len1, __len2));
   1.468 +  return __result != 0 ? (__result < 0) : (__len1 < __len2);
   1.469 +}
   1.470 +
   1.471 +
   1.472 +# if !(CHAR_MAX == SCHAR_MAX)
   1.473 +inline bool lexicographical_compare(const char* __first1, const char* __last1,
   1.474 +                                    const char* __first2, const char* __last2)
   1.475 +{
   1.476 +  _STLP_DEBUG_CHECK(__check_range(__first1, __last1)) 
   1.477 +  _STLP_DEBUG_CHECK(__check_range(__first2, __last2))
   1.478 +
   1.479 +  return lexicographical_compare((const unsigned char*) __first1,
   1.480 +                                 (const unsigned char*) __last1,
   1.481 +                                 (const unsigned char*) __first2,
   1.482 +                                 (const unsigned char*) __last2);
   1.483 +}
   1.484 +#endif /* CHAR_MAX == SCHAR_MAX */
   1.485 +
   1.486 +template <class _InputIter1, class _InputIter2>
   1.487 +int __lexicographical_compare_3way(_InputIter1 __first1, _InputIter1 __last1,
   1.488 +                                   _InputIter2 __first2, _InputIter2 __last2);
   1.489 +
   1.490 +inline int
   1.491 +__lexicographical_compare_3way(const unsigned char* __first1,
   1.492 +                               const unsigned char* __last1,
   1.493 +                               const unsigned char* __first2,
   1.494 +                               const unsigned char* __last2)
   1.495 +{
   1.496 +  const ptrdiff_t __len1 = __last1 - __first1;
   1.497 +  const ptrdiff_t __len2 = __last2 - __first2;
   1.498 +  const int __result = memcmp(__first1, __first2, (min) (__len1, __len2));
   1.499 +  return __result != 0 ? __result 
   1.500 +                       : (__len1 == __len2 ? 0 : (__len1 < __len2 ? -1 : 1));
   1.501 +}
   1.502 +
   1.503 +
   1.504 +# if !(CHAR_MAX == SCHAR_MAX)
   1.505 +inline int 
   1.506 +__lexicographical_compare_3way(const char* __first1, const char* __last1,
   1.507 +                               const char* __first2, const char* __last2)
   1.508 +{
   1.509 +  return __lexicographical_compare_3way((const unsigned char*) __first1,
   1.510 +                                        (const unsigned char*) __last1,
   1.511 +                                        (const unsigned char*) __first2,
   1.512 +                                        (const unsigned char*) __last2);
   1.513 +}
   1.514 +# endif
   1.515 +
   1.516 +# ifndef _STLP_NO_EXTENSIONS
   1.517 +
   1.518 +template <class _InputIter1, class _InputIter2>
   1.519 +int lexicographical_compare_3way(_InputIter1 __first1, _InputIter1 __last1,
   1.520 +                                 _InputIter2 __first2, _InputIter2 __last2);
   1.521 +
   1.522 +# endif /* EXTENSIONS */
   1.523 +
   1.524 +// count
   1.525 +template <class _InputIter, class _Tp>
   1.526 +_STLP_INLINE_LOOP _STLP_DIFFERENCE_TYPE(_InputIter)
   1.527 +count(_InputIter __first, _InputIter __last, const _Tp& __val) {
   1.528 +  _STLP_DEBUG_CHECK(__check_range(__first, __last))
   1.529 +  _STLP_DIFFERENCE_TYPE(_InputIter) __n = 0;
   1.530 +  for ( ; __first != __last; ++__first)
   1.531 +    if (*__first == __val)
   1.532 +      ++__n;
   1.533 +  return __n;
   1.534 +}
   1.535 +
   1.536 +// find and find_if. Note find may be expressed in terms of find_if if appropriate binder was available.
   1.537 +template <class _InputIter, class _Tp>
   1.538 +_InputIter find(_InputIter __first, _InputIter __last, const _Tp& __val);
   1.539 +template <class _InputIter, class _Predicate>
   1.540 +_InputIter find_if(_InputIter __first, _InputIter __last, _Predicate __pred);
   1.541 +
   1.542 +// search.
   1.543 +template <class _ForwardIter1, class _ForwardIter2, class _BinaryPred>
   1.544 +_ForwardIter1 search(_ForwardIter1 __first1, _ForwardIter1 __last1,
   1.545 +                     _ForwardIter2 __first2, _ForwardIter2 __last2, _BinaryPred  __predicate);
   1.546 +
   1.547 +// find_first_of
   1.548 +template <class _InputIter, class _ForwardIter, class _BinaryPredicate>
   1.549 +_InputIter __find_first_of(_InputIter __first1, _InputIter __last1,
   1.550 +                           _ForwardIter __first2, _ForwardIter __last2,
   1.551 +                           _BinaryPredicate __comp);
   1.552 +
   1.553 +template <class _ForwardIter1, class _ForwardIter2, 
   1.554 +          class _BinaryPredicate>
   1.555 +_ForwardIter1 
   1.556 +find_end(_ForwardIter1 __first1, _ForwardIter1 __last1, 
   1.557 +         _ForwardIter2 __first2, _ForwardIter2 __last2,
   1.558 +         _BinaryPredicate __comp);
   1.559 +
   1.560 +// replace
   1.561 +template <class _ForwardIter, class _Tp>
   1.562 +_STLP_INLINE_LOOP void 
   1.563 +replace(_ForwardIter __first, _ForwardIter __last,
   1.564 +        const _Tp& __old_value, const _Tp& __new_value) {
   1.565 +  _STLP_DEBUG_CHECK(__check_range(__first, __last))
   1.566 +  for ( ; __first != __last; ++__first)
   1.567 +    if (*__first == __old_value)
   1.568 +      *__first = __new_value;
   1.569 +}
   1.570 +
   1.571 +template <class _ForwardIter, class _Tp, class _Compare, class _Distance>
   1.572 +_ForwardIter __lower_bound(_ForwardIter __first, _ForwardIter __last,
   1.573 +                              const _Tp& __val, _Compare __comp, _Distance*);
   1.574 +
   1.575 +_STLP_END_NAMESPACE
   1.576 +
   1.577 +# if !defined (_STLP_LINK_TIME_INSTANTIATION)
   1.578 +#  include <stl/_algobase.c>
   1.579 +# endif
   1.580 +
   1.581 +#endif /* _STLP_INTERNAL_ALGOBASE_H */
   1.582 +
   1.583 +// Local Variables:
   1.584 +// mode:C++
   1.585 +// End:
   1.586 +