ndk/sources/cxx-stl/stlport/stlport/stl/_algobase.h

   1 /*
   2  *
   3  * Copyright (c) 1994
   4  * Hewlett-Packard Company
   5  *
   6  * Copyright (c) 1996,1997
   7  * Silicon Graphics Computer Systems, Inc.
   8  *
   9  * Copyright (c) 1997
  10  * Moscow Center for SPARC Technology
  11  *
  12  * Copyright (c) 1999
  13  * Boris Fomitchev
  14  *
  15  * This material is provided "as is", with absolutely no warranty expressed
  16  * or implied. Any use is at your own risk.
  17  *
  18  * Permission to use or copy this software for any purpose is hereby granted
  19  * without fee, provided the above notices are retained on all copies.
  20  * Permission to modify the code and to distribute modified code is granted,
  21  * provided the above notices are retained, and a notice that the code was
  22  * modified is included with the above copyright notice.
  23  *
  24  */
  25
  26 /* NOTE: This is an internal header file, included by other STL headers.
  27  *   You should not attempt to use it directly.
  28  */
  29
  30 #ifndef _STLP_INTERNAL_ALGOBASE_H
  31 #define _STLP_INTERNAL_ALGOBASE_H
  32
  33 #ifndef _STLP_INTERNAL_CSTDDEF
  34 #  include <stl/_cstddef.h>
  35 #endif
  36
  37 #ifndef _STLP_INTERNAL_CSTRING
  38 #  include <stl/_cstring.h>
  39 #endif
  40
  41 #ifndef _STLP_CLIMITS
  42 #  include <climits>
  43 #endif
  44
  45 #ifndef _STLP_INTERNAL_CSTDLIB
  46 #  include <stl/_cstdlib.h>
  47 #endif
  48
  49 #ifndef _STLP_INTERNAL_PAIR_H
  50 #  include <stl/_pair.h>
  51 #endif
  52
  53 #ifndef _STLP_INTERNAL_ITERATOR_BASE_H
  54 #  include <stl/_iterator_base.h>
  55 #endif
  56
  57 #ifndef _STLP_TYPE_TRAITS_H
  58 #  include <stl/type_traits.h>
  59 #endif
  60
  61 _STLP_BEGIN_NAMESPACE
  62
  63 #if defined (_STLP_USE_PARTIAL_SPEC_WORKAROUND) && !defined (_STLP_FUNCTION_TMPL_PARTIAL_ORDER)
  64 _STLP_MOVE_TO_PRIV_NAMESPACE
  65 template <class _Tp>
  66 inline void __swap_aux(_Tp& __a, _Tp& __b, const __true_type& /*SwapImplemented*/) {
  67   __a._M_swap_workaround(__b);
  68 }
  69
  70 template <class _Tp>
  71 inline void __swap_aux(_Tp& __a, _Tp& __b, const __false_type& /*SwapImplemented*/) {
  72   _Tp __tmp = __a;
  73   __a = __b;
  74   __b = __tmp;
  75 }
  76 _STLP_MOVE_TO_STD_NAMESPACE
  77 #endif
  78
  79 // swap and iter_swap
  80 template <class _Tp>
  81 inline void swap(_Tp& __a, _Tp& __b) {
  82 #if defined (_STLP_USE_PARTIAL_SPEC_WORKAROUND) && !defined (_STLP_FUNCTION_TMPL_PARTIAL_ORDER)
  83 #  if !defined(__BORLANDC__)
  84   typedef typename _SwapImplemented<_Tp>::_Ret _Implemented;
  85 #  else
  86   enum { _Is = _SwapImplemented<_Tp>::_Is };
  87   typedef typename __bool2type<_Is>::_Ret _Implemented;
  88 #  endif
  89   _STLP_PRIV __swap_aux(__a, __b, _Implemented());
  90 #else
  91   _Tp __tmp = __a;
  92   __a = __b;
  93   __b = __tmp;
  94 #endif
  95 }
  96
  97 _STLP_MOVE_TO_PRIV_NAMESPACE
  98
  99 template <class _ForwardIter1, class _ForwardIter2, class _Value>
 100 inline void __iter_swap_aux_aux(_ForwardIter1& __i1, _ForwardIter2& __i2, _Value *) {
 101   _Value tmp = *__i1;
 102   *__i1 = *__i2;
 103   *__i2 = tmp;
 104 }
 105
 106 template <class _ForwardIter1, class _ForwardIter2>
 107 inline void __iter_swap_aux(_ForwardIter1& __i1, _ForwardIter2& __i2, const __true_type& /*OKToSwap*/) {
 108   /* namespace specification breaks access to the right swap template overload (at least for gcc) */
 109   /*_STLP_STD::*/ swap(*__i1, *__i2);
 110 }
 111
 112 template <class _ForwardIter1, class _ForwardIter2>
 113 inline void __iter_swap_aux(_ForwardIter1& __i1, _ForwardIter2& __i2, const __false_type& /*OKToSwap*/) {
 114   _STLP_PRIV __iter_swap_aux_aux( __i1, __i2, _STLP_VALUE_TYPE(__i1,_ForwardIter1) );
 115 }
 116
 117 _STLP_MOVE_TO_STD_NAMESPACE
 118
 119 template <class _ForwardIter1, class _ForwardIter2>
 120 inline void iter_swap(_ForwardIter1 __i1, _ForwardIter2 __i2) {
 121   _STLP_PRIV __iter_swap_aux( __i1, __i2, _IsOKToSwap(_STLP_VALUE_TYPE(__i1, _ForwardIter1), _STLP_VALUE_TYPE(__i2, _ForwardIter2),
 122                                                       _STLP_IS_REF_TYPE_REAL_REF(__i1, _ForwardIter1),
 123                                                       _STLP_IS_REF_TYPE_REAL_REF(__i2, _ForwardIter2))._Answer());
 124 }
 125
 126 //--------------------------------------------------
 127 // min and max
 128
 129 #if !defined (__BORLANDC__) || defined (_STLP_USE_OWN_NAMESPACE)
 130 #  if (defined (__BORLANDC__) && (__BORLANDC__ < 0x580)) && !defined (__STDC__)
 131 //In not ANSI mode Borland import min/max in global namespace which conflict
 132 //with STLport min/max when user does a 'using namespace std' in its code
 133 //(see test/unit/alg_test.cpp). To avoid this clash we simply import Borland min/max
 134 //in STLport namespace.
 135 using _STLP_VENDOR_STD::min;
 136 using _STLP_VENDOR_STD::max;
 137 #  else
 138 template <class _Tp>
 139 inline const _Tp& (min)(const _Tp& __a, const _Tp& __b) { return __b < __a ? __b : __a; }
 140 template <class _Tp>
 141 inline const _Tp& (max)(const _Tp& __a, const _Tp& __b) {  return  __a < __b ? __b : __a; }
 142 #  endif
 143 #endif
 144
 145 # if defined (__BORLANDC__) && defined (_STLP_USE_OWN_NAMESPACE)
 146 inline unsigned long (min) (unsigned long __a, unsigned long __b) { return __b < __a ? __b : __a; }
 147 inline unsigned long (max) (unsigned long __a, unsigned long __b) {  return  __a < __b ? __b : __a; }
 148 # endif
 149
 150 #  if !defined (__BORLANDC__) || (__BORLANDC__ < 0x590)
 151 template <class _Tp, class _Compare>
 152 inline const _Tp& (min)(const _Tp& __a, const _Tp& __b, _Compare __comp) {
 153   return __comp(__b, __a) ? __b : __a;
 154 }
 155
 156 template <class _Tp, class _Compare>
 157 inline const _Tp& (max)(const _Tp& __a, const _Tp& __b, _Compare __comp) {
 158   return __comp(__a, __b) ? __b : __a;
 159 }
 160 #  else
 161 template <class _Tp, class _Compare>
 162 inline const _Tp (min)(const _Tp __a, const _Tp __b, _Compare __comp) {
 163   return __comp(__b, __a) ? __b : __a;
 164 }
 165
 166 template <class _Tp, class _Compare>
 167 inline const _Tp (max)(const _Tp __a, const _Tp __b, _Compare __comp) {
 168   return __comp(__a, __b) ? __b : __a;
 169 }
 170 #  endif
 171
 172 //--------------------------------------------------
 173 // copy
 174
 175 // All of these auxiliary functions serve two purposes.  (1) Replace
 176 // calls to copy with memmove whenever possible.  (Memmove, not memcpy,
 177 // because the input and output ranges are permitted to overlap.)
 178 // (2) If we're using random access iterators, then write the loop as
 179 // a for loop with an explicit count.
 180
 181 _STLP_MOVE_TO_PRIV_NAMESPACE
 182
 183 template <class _InputIter, class _OutputIter, class _Distance>
 184 inline _OutputIter __copy(_InputIter __first, _InputIter __last,
 185                           _OutputIter __result, const input_iterator_tag &, _Distance*) {
 186   for ( ; __first != __last; ++__result, ++__first)
 187     *__result = *__first;
 188   return __result;
 189 }
 190
 191 #if defined (_STLP_NONTEMPL_BASE_MATCH_BUG)
 192 template <class _InputIter, class _OutputIter, class _Distance>
 193 inline _OutputIter __copy(_InputIter __first, _InputIter __last,
 194                           _OutputIter __result, const forward_iterator_tag &, _Distance* ) {
 195   for ( ; __first != __last; ++__result, ++__first)
 196     *__result = *__first;
 197   return __result;
 198 }
 199
 200 template <class _InputIter, class _OutputIter, class _Distance>
 201 inline _OutputIter __copy(_InputIter __first, _InputIter __last,
 202                           _OutputIter __result, const bidirectional_iterator_tag &, _Distance* ) {
 203   for ( ; __first != __last; ++__result, ++__first)
 204     *__result = *__first;
 205   return __result;
 206 }
 207 #endif
 208
 209 template <class _RandomAccessIter, class _OutputIter, class _Distance>
 210 inline _OutputIter
 211 __copy(_RandomAccessIter __first, _RandomAccessIter __last,
 212        _OutputIter __result, const random_access_iterator_tag &, _Distance*) {
 213   for (_Distance __n = __last - __first; __n > 0; --__n) {
 214     *__result = *__first;
 215     ++__first;
 216     ++__result;
 217   }
 218   return __result;
 219 }
 220
 221 inline void*
 222 __copy_trivial(const void* __first, const void* __last, void* __result) {
 223   size_t __n = (const char*)__last - (const char*)__first;
 224   return __n ? (void *)((char*)memmove(__result, __first, __n) + __n) : __result;
 225 }
 226
 227 //--------------------------------------------------
 228 // copy_backward auxiliary functions
 229
 230 template <class _BidirectionalIter1, class _BidirectionalIter2,
 231           class _Distance>
 232 inline _BidirectionalIter2 __copy_backward(_BidirectionalIter1 __first,
 233                                            _BidirectionalIter1 __last,
 234                                            _BidirectionalIter2 __result,
 235                                            const bidirectional_iterator_tag &,
 236                                            _Distance*) {
 237   while (__first != __last)
 238     *--__result = *--__last;
 239   return __result;
 240 }
 241
 242 template <class _RandomAccessIter, class _BidirectionalIter, class _Distance>
 243 inline _BidirectionalIter __copy_backward(_RandomAccessIter __first,
 244                                           _RandomAccessIter __last,
 245                                           _BidirectionalIter __result,
 246                                           const random_access_iterator_tag &,
 247                                           _Distance*) {
 248   for (_Distance __n = __last - __first; __n > 0; --__n)
 249     *--__result = *--__last;
 250   return __result;
 251 }
 252
 253 inline void*
 254 __copy_trivial_backward(const void* __first, const void* __last, void* __result) {
 255   const ptrdiff_t _Num = (const char*)__last - (const char*)__first;
 256   return (_Num > 0) ? memmove((char*)__result - _Num, __first, _Num) : __result ;
 257 }
 258
 259 template <class _InputIter, class _OutputIter>
 260 inline _OutputIter __copy_ptrs(_InputIter __first, _InputIter __last, _OutputIter __result,
 261                                const __false_type& /*IsOKToMemCpy*/) {
 262   return _STLP_PRIV __copy(__first, __last, __result, random_access_iterator_tag(), (ptrdiff_t*)0);
 263 }
 264 template <class _InputIter, class _OutputIter>
 265 inline _OutputIter __copy_ptrs(_InputIter __first, _InputIter __last, _OutputIter __result,
 266                                const __true_type& /*IsOKToMemCpy*/) {
 267   // we know they all pointers, so this cast is OK
 268   //  return (_OutputIter)__copy_trivial(&(*__first), &(*__last), &(*__result));
 269   return (_OutputIter)_STLP_PRIV __copy_trivial(__first, __last, __result);
 270 }
 271
 272 template <class _InputIter, class _OutputIter>
 273 inline _OutputIter __copy_aux(_InputIter __first, _InputIter __last, _OutputIter __result,
 274                               const __true_type& /*BothPtrType*/) {
 275   return _STLP_PRIV __copy_ptrs(__first, __last, __result,
 276                                 _UseTrivialCopy(_STLP_VALUE_TYPE(__first, _InputIter),
 277                                                 _STLP_VALUE_TYPE(__result, _OutputIter))._Answer());
 278 }
 279
 280 template <class _InputIter, class _OutputIter>
 281 inline _OutputIter __copy_aux(_InputIter __first, _InputIter __last, _OutputIter __result,
 282                               const __false_type& /*BothPtrType*/) {
 283   return _STLP_PRIV __copy(__first, __last, __result,
 284                            _STLP_ITERATOR_CATEGORY(__first, _InputIter),
 285                            _STLP_DISTANCE_TYPE(__first, _InputIter));
 286 }
 287
 288 _STLP_MOVE_TO_STD_NAMESPACE
 289
 290 template <class _InputIter, class _OutputIter>
 291 inline _OutputIter copy(_InputIter __first, _InputIter __last, _OutputIter __result) {
 292   _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first, __last))
 293   return _STLP_PRIV __copy_aux(__first, __last, __result, _BothPtrType< _InputIter, _OutputIter>::_Answer());
 294 }
 295
 296 _STLP_MOVE_TO_PRIV_NAMESPACE
 297
 298 template <class _InputIter, class _OutputIter>
 299 inline _OutputIter __copy_backward_ptrs(_InputIter __first, _InputIter __last,
 300                                         _OutputIter __result, const __false_type& /*TrivialAssignment*/) {
 301   return _STLP_PRIV __copy_backward(__first, __last, __result,
 302                                     _STLP_ITERATOR_CATEGORY(__first, _InputIter),
 303                                     _STLP_DISTANCE_TYPE(__first, _InputIter));
 304 }
 305 template <class _InputIter, class _OutputIter>
 306 inline _OutputIter __copy_backward_ptrs(_InputIter __first, _InputIter __last,
 307                                         _OutputIter __result, const __true_type& /*TrivialAssignment*/) {
 308   return (_OutputIter)_STLP_PRIV __copy_trivial_backward(__first, __last, __result);
 309 }
 310
 311 template <class _InputIter, class _OutputIter>
 312 inline _OutputIter __copy_backward_aux(_InputIter __first, _InputIter __last, _OutputIter __result, const __false_type&) {
 313   return _STLP_PRIV __copy_backward(__first, __last, __result,
 314                                     _STLP_ITERATOR_CATEGORY(__first,_InputIter),
 315                                     _STLP_DISTANCE_TYPE(__first, _InputIter));
 316 }
 317
 318 template <class _InputIter, class _OutputIter>
 319 inline _OutputIter __copy_backward_aux(_InputIter __first, _InputIter __last, _OutputIter __result, const __true_type&) {
 320   return _STLP_PRIV __copy_backward_ptrs(__first, __last, __result,
 321                                          _UseTrivialCopy(_STLP_VALUE_TYPE(__first, _InputIter),
 322                                                          _STLP_VALUE_TYPE(__result, _OutputIter))._Answer());
 323 }
 324
 325 _STLP_MOVE_TO_STD_NAMESPACE
 326
 327 template <class _InputIter, class _OutputIter>
 328 inline _OutputIter copy_backward(_InputIter __first, _InputIter __last, _OutputIter __result) {
 329   _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first, __last))
 330   return _STLP_PRIV __copy_backward_aux(__first, __last, __result, _BothPtrType< _InputIter, _OutputIter>::_Answer() );
 331 }
 332
 333 #if !defined (_STLP_CLASS_PARTIAL_SPECIALIZATION) && !defined (_STLP_SIMULATE_PARTIAL_SPEC_FOR_TYPE_TRAITS)
 334 #  define _STLP_DECLARE_COPY_TRIVIAL(_Tp)                                       \
 335 inline _Tp* copy(const _Tp* __first, const _Tp* __last, _Tp* __result)          \
 336 { return (_Tp*)_STLP_PRIV __copy_trivial(__first, __last, __result); }          \
 337 inline _Tp* copy_backward(const _Tp* __first, const _Tp* __last, _Tp* __result) \
 338 { return (_Tp*)_STLP_PRIV __copy_trivial_backward(__first, __last, __result); }
 339
 340 #  if !defined (_STLP_NO_BOOL)
 341 _STLP_DECLARE_COPY_TRIVIAL(bool)
 342 #  endif
 343 _STLP_DECLARE_COPY_TRIVIAL(char)
 344 #  if !defined (_STLP_NO_SIGNED_BUILTINS)
 345 _STLP_DECLARE_COPY_TRIVIAL(signed char)
 346 #  endif
 347 _STLP_DECLARE_COPY_TRIVIAL(unsigned char)
 348 _STLP_DECLARE_COPY_TRIVIAL(short)
 349 _STLP_DECLARE_COPY_TRIVIAL(unsigned short)
 350 _STLP_DECLARE_COPY_TRIVIAL(int)
 351 _STLP_DECLARE_COPY_TRIVIAL(unsigned int)
 352 _STLP_DECLARE_COPY_TRIVIAL(long)
 353 _STLP_DECLARE_COPY_TRIVIAL(unsigned long)
 354 #  if !defined(_STLP_NO_WCHAR_T) && !defined (_STLP_WCHAR_T_IS_USHORT)
 355 _STLP_DECLARE_COPY_TRIVIAL(wchar_t)
 356 #  endif
 357 #  if defined (_STLP_LONG_LONG)
 358 _STLP_DECLARE_COPY_TRIVIAL(_STLP_LONG_LONG)
 359 _STLP_DECLARE_COPY_TRIVIAL(unsigned _STLP_LONG_LONG)
 360 #  endif
 361 _STLP_DECLARE_COPY_TRIVIAL(float)
 362 _STLP_DECLARE_COPY_TRIVIAL(double)
 363 #  if !defined (_STLP_NO_LONG_DOUBLE)
 364 _STLP_DECLARE_COPY_TRIVIAL(long double)
 365 #  endif
 366 #  undef _STLP_DECLARE_COPY_TRIVIAL
 367 #endif
 368
 369 //--------------------------------------------------
 370 // copy_n (not part of the C++ standard)
 371
 372 #if !defined (_STLP_NO_EXTENSIONS)
 373 _STLP_MOVE_TO_PRIV_NAMESPACE
 374
 375 template <class _InputIter, class _Size, class _OutputIter>
 376 _STLP_INLINE_LOOP _STLP_STD::pair<_InputIter, _OutputIter>
 377 __copy_n(_InputIter __first, _Size __count, _OutputIter __result,
 378          const input_iterator_tag &) {
 379   for ( ; __count > 0; --__count) {
 380     *__result = *__first;
 381     ++__first;
 382     ++__result;
 383   }
 384   return _STLP_STD::pair<_InputIter, _OutputIter>(__first, __result);
 385 }
 386
 387 template <class _RAIter, class _Size, class _OutputIter>
 388 inline _STLP_STD::pair<_RAIter, _OutputIter>
 389 __copy_n(_RAIter __first, _Size __count, _OutputIter __result,
 390          const random_access_iterator_tag &) {
 391   _RAIter __last = __first + __count;
 392   return _STLP_STD::pair<_RAIter, _OutputIter>(__last, _STLP_STD::copy(__first, __last, __result));
 393 }
 394
 395 _STLP_MOVE_TO_STD_NAMESPACE
 396
 397 template <class _InputIter, class _Size, class _OutputIter>
 398 inline pair<_InputIter, _OutputIter>
 399 copy_n(_InputIter __first, _Size __count, _OutputIter __result) {
 400   _STLP_FIX_LITERAL_BUG(__first)
 401   return _STLP_PRIV __copy_n(__first, __count, __result, _STLP_ITERATOR_CATEGORY(__first, _InputIter));
 402 }
 403 #endif
 404
 405 //--------------------------------------------------
 406 // fill and fill_n
 407 _STLP_MOVE_TO_PRIV_NAMESPACE
 408
 409 template <class _ForwardIter, class _Tp>
 410 _STLP_INLINE_LOOP
 411 void __fill_fwd(_ForwardIter __first, _ForwardIter __last, const _Tp& __val) {
 412   for ( ; __first != __last; ++__first)
 413     *__first = __val;
 414 }
 415
 416 template <class _ForwardIter, class _Tp, class _Distance>
 417 inline void __fill(_ForwardIter __first, _ForwardIter __last, const _Tp& __val,
 418                    const input_iterator_tag &, _Distance*) {
 419   _STLP_PRIV __fill_fwd(__first, __last, __val);
 420 }
 421
 422 #if defined (_STLP_NONTEMPL_BASE_MATCH_BUG)
 423 template <class _ForwardIter, class _Tp, class _Distance>
 424 _STLP_INLINE_LOOP
 425 void __fill(_ForwardIter __first, _ForwardIter __last, const _Tp& __val,
 426             const forward_iterator_tag &, _Distance*) {
 427   _STLP_PRIV __fill_fwd(__first, __last, __val);
 428 }
 429
 430 template <class _ForwardIter, class _Tp, class _Distance>
 431 _STLP_INLINE_LOOP
 432 void __fill(_ForwardIter __first, _ForwardIter __last, const _Tp& __val,
 433             const bidirectional_iterator_tag &, _Distance*) {
 434   _STLP_PRIV __fill_fwd(__first, __last, __val);
 435 }
 436 #endif
 437
 438 template <class _RandomAccessIter, class _Tp, class _Distance>
 439 _STLP_INLINE_LOOP
 440 void __fill(_RandomAccessIter __first, _RandomAccessIter __last, const _Tp& __val,
 441             const random_access_iterator_tag &, _Distance*) {
 442   for (_Distance __n = __last - __first ; __n > 0; ++__first, --__n)
 443     *__first = __val;
 444 }
 445
 446 _STLP_MOVE_TO_STD_NAMESPACE
 447
 448 template <class _ForwardIter, class _Tp>
 449 inline void fill(_ForwardIter __first, _ForwardIter __last, const _Tp& __val) {
 450   _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first, __last))
 451   _STLP_PRIV __fill(__first, __last, __val,
 452                     _STLP_ITERATOR_CATEGORY(__first, _ForwardIter),
 453                     _STLP_DISTANCE_TYPE(__first, _ForwardIter));
 454 }
 455
 456 // Specialization: for one-byte types we can use memset.
 457 inline void fill(unsigned char* __first, unsigned char* __last,
 458                  const unsigned char& __val) {
 459   unsigned char __tmp = __val;
 460   memset(__first, __tmp, __last - __first);
 461 }
 462 #if !defined (_STLP_NO_SIGNED_BUILTINS)
 463 inline void fill(signed char* __first, signed char* __last,
 464                  const signed char& __val) {
 465   signed char __tmp = __val;
 466   memset(__first, __STATIC_CAST(unsigned char,__tmp), __last - __first);
 467 }
 468 #endif
 469 inline void fill(char* __first, char* __last, const char& __val) {
 470   char __tmp = __val;
 471   memset(__first, __STATIC_CAST(unsigned char,__tmp), __last - __first);
 472 }
 473
 474 _STLP_MOVE_TO_PRIV_NAMESPACE
 475
 476 template <class _OutputIter, class _Size, class _Tp>
 477 _STLP_INLINE_LOOP
 478 _OutputIter __fill_n(_OutputIter __first, _Size __n, const _Tp& __val) {
 479   _STLP_FIX_LITERAL_BUG(__first)
 480   for ( ; __n > 0; --__n, ++__first)
 481     *__first = __val;
 482   return __first;
 483 }
 484
 485 #if defined (_STLP_FUNCTION_TMPL_PARTIAL_ORDER)
 486 template <class _Size>
 487 inline unsigned char* __fill_n(unsigned char* __first, _Size __n,
 488                                const unsigned char& __val) {
 489   _STLP_STD::fill(__first, __first + __n, __val);
 490   return __first + __n;
 491 }
 492 #if !defined (_STLP_NO_SIGNED_BUILTINS)
 493 template <class _Size>
 494 inline signed char* __fill_n(signed char* __first, _Size __n,
 495                              const signed char& __val) {
 496   _STLP_STD::fill(__first, __first + __n, __val);
 497   return __first + __n;
 498 }
 499 #endif
 500 template <class _Size>
 501 inline char* __fill_n(char* __first, _Size __n,
 502                       const char& __val) {
 503   _STLP_STD::fill(__first, __first + __n, __val);
 504   return __first + __n;
 505 }
 506 #endif
 507
 508 _STLP_MOVE_TO_STD_NAMESPACE
 509
 510 template <class _OutputIter, class _Size, class _Tp>
 511 inline void fill_n(_OutputIter __first, _Size __n, const _Tp& __val) {
 512   _STLP_FIX_LITERAL_BUG(__first)
 513   _STLP_PRIV __fill_n(__first, __n, __val);
 514 }
 515
 516
 517 //--------------------------------------------------
 518 // equal and mismatch
 519
 520 template <class _InputIter1, class _InputIter2>
 521 _STLP_INLINE_LOOP
 522 _STLP_STD::pair<_InputIter1, _InputIter2> mismatch(_InputIter1 __first1,
 523                                                    _InputIter1 __last1,
 524                                                    _InputIter2 __first2) {
 525   _STLP_FIX_LITERAL_BUG(__first2)
 526   _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first1, __last1))
 527   while (__first1 != __last1 && *__first1 == *__first2) {
 528     ++__first1;
 529     ++__first2;
 530   }
 531   return _STLP_STD::pair<_InputIter1, _InputIter2>(__first1, __first2);
 532 }
 533
 534 template <class _InputIter1, class _InputIter2, class _BinaryPredicate>
 535 _STLP_INLINE_LOOP
 536 _STLP_STD::pair<_InputIter1, _InputIter2> mismatch(_InputIter1 __first1,
 537                                                    _InputIter1 __last1,
 538                                                    _InputIter2 __first2,
 539                                                    _BinaryPredicate __binary_pred) {
 540   _STLP_FIX_LITERAL_BUG(__first2)
 541   _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first1, __last1))
 542   while (__first1 != __last1 && __binary_pred(*__first1, *__first2)) {
 543     ++__first1;
 544     ++__first2;
 545   }
 546   return _STLP_STD::pair<_InputIter1, _InputIter2>(__first1, __first2);
 547 }
 548
 549 template <class _InputIter1, class _InputIter2>
 550 _STLP_INLINE_LOOP
 551 bool equal(_InputIter1 __first1, _InputIter1 __last1,
 552            _InputIter2 __first2) {
 553   _STLP_FIX_LITERAL_BUG(__first1) _STLP_FIX_LITERAL_BUG(__last1)  _STLP_FIX_LITERAL_BUG(__first2)
 554   _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first1, __last1))
 555   for ( ; __first1 != __last1; ++__first1, ++__first2)
 556     if (!(*__first1 == *__first2))
 557       return false;
 558   return true;
 559 }
 560
 561 template <class _InputIter1, class _InputIter2, class _BinaryPredicate>
 562 _STLP_INLINE_LOOP
 563 bool equal(_InputIter1 __first1, _InputIter1 __last1,
 564            _InputIter2 __first2, _BinaryPredicate __binary_pred) {
 565   _STLP_FIX_LITERAL_BUG(__first2)
 566   _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first1, __last1))
 567   for ( ; __first1 != __last1; ++__first1, ++__first2)
 568     if (!__binary_pred(*__first1, *__first2))
 569       return false;
 570   return true;
 571 }
 572
 573 //--------------------------------------------------
 574 // lexicographical_compare and lexicographical_compare_3way.
 575 // (the latter is not part of the C++ standard.)
 576
 577 template <class _InputIter1, class _InputIter2>
 578 bool lexicographical_compare(_InputIter1 __first1, _InputIter1 __last1,
 579                              _InputIter2 __first2, _InputIter2 __last2);
 580
 581 template <class _InputIter1, class _InputIter2, class _Compare>
 582 bool lexicographical_compare(_InputIter1 __first1, _InputIter1 __last1,
 583                              _InputIter2 __first2, _InputIter2 __last2,
 584                              _Compare __comp);
 585
 586 inline bool
 587 lexicographical_compare(const unsigned char* __first1,
 588                         const unsigned char* __last1,
 589                         const unsigned char* __first2,
 590                         const unsigned char* __last2) {
 591   const size_t __len1 = __last1 - __first1;
 592   const size_t __len2 = __last2 - __first2;
 593   _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first1, __last1))
 594   _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first2, __last2))
 595
 596   const int __result = memcmp(__first1, __first2, (min) (__len1, __len2));
 597   return __result != 0 ? (__result < 0) : (__len1 < __len2);
 598 }
 599
 600
 601 #if !(CHAR_MAX == SCHAR_MAX)
 602 inline bool lexicographical_compare(const char* __first1, const char* __last1,
 603                                     const char* __first2, const char* __last2) {
 604   _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first1, __last1))
 605   _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first2, __last2))
 606
 607   return lexicographical_compare((const unsigned char*) __first1,
 608                                  (const unsigned char*) __last1,
 609                                  (const unsigned char*) __first2,
 610                                  (const unsigned char*) __last2);
 611 }
 612 #endif /* CHAR_MAX == SCHAR_MAX */
 613
 614 _STLP_MOVE_TO_PRIV_NAMESPACE
 615
 616 template <class _InputIter1, class _InputIter2>
 617 int __lexicographical_compare_3way(_InputIter1 __first1, _InputIter1 __last1,
 618                                    _InputIter2 __first2, _InputIter2 __last2);
 619
 620 inline int
 621 __lexicographical_compare_3way(const unsigned char* __first1,
 622                                const unsigned char* __last1,
 623                                const unsigned char* __first2,
 624                                const unsigned char* __last2) {
 625   const ptrdiff_t __len1 = __last1 - __first1;
 626   const ptrdiff_t __len2 = __last2 - __first2;
 627   const int __result = memcmp(__first1, __first2, (min) (__len1, __len2));
 628   return __result != 0 ? __result
 629                        : (__len1 == __len2 ? 0 : (__len1 < __len2 ? -1 : 1));
 630 }
 631
 632
 633 #if !(CHAR_MAX == SCHAR_MAX)
 634 inline int
 635 __lexicographical_compare_3way(const char* __first1, const char* __last1,
 636                                const char* __first2, const char* __last2) {
 637   return __lexicographical_compare_3way((const unsigned char*) __first1,
 638                                         (const unsigned char*) __last1,
 639                                         (const unsigned char*) __first2,
 640                                         (const unsigned char*) __last2);
 641 }
 642 #endif
 643
 644 _STLP_MOVE_TO_STD_NAMESPACE
 645
 646 #if !defined (_STLP_NO_EXTENSIONS)
 647 template <class _InputIter1, class _InputIter2>
 648 int lexicographical_compare_3way(_InputIter1 __first1, _InputIter1 __last1,
 649                                  _InputIter2 __first2, _InputIter2 __last2);
 650
 651 #endif
 652
 653 // count
 654 template <class _InputIter, class _Tp>
 655 _STLP_INLINE_LOOP _STLP_DIFFERENCE_TYPE(_InputIter)
 656 count(_InputIter __first, _InputIter __last, const _Tp& __val) {
 657   _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first, __last))
 658   _STLP_DIFFERENCE_TYPE(_InputIter) __n = 0;
 659   for ( ; __first != __last; ++__first)
 660     if (*__first == __val)
 661       ++__n;
 662   return __n;
 663 }
 664
 665 // find and find_if. Note find may be expressed in terms of find_if if appropriate binder was available.
 666 template <class _InputIter, class _Tp>
 667 _InputIter find(_InputIter __first, _InputIter __last, const _Tp& __val);
 668
 669 template <class _InputIter, class _Predicate>
 670 _InputIter find_if(_InputIter __first, _InputIter __last, _Predicate __pred);
 671
 672 // search.
 673 template <class _ForwardIter1, class _ForwardIter2, class _BinaryPred>
 674 _ForwardIter1 search(_ForwardIter1 __first1, _ForwardIter1 __last1,
 675                      _ForwardIter2 __first2, _ForwardIter2 __last2, _BinaryPred  __predicate);
 676
 677 _STLP_MOVE_TO_PRIV_NAMESPACE
 678
 679 // find_first_of
 680 template <class _InputIter, class _ForwardIter>
 681 _InputIter __find_first_of(_InputIter __first1, _InputIter __last1,
 682                            _ForwardIter __first2, _ForwardIter __last2);
 683
 684 template <class _InputIter, class _ForwardIter, class _BinaryPredicate>
 685 _InputIter __find_first_of(_InputIter __first1, _InputIter __last1,
 686                            _ForwardIter __first2, _ForwardIter __last2,
 687                            _BinaryPredicate __comp);
 688
 689 _STLP_MOVE_TO_STD_NAMESPACE
 690
 691 template <class _ForwardIter1, class _ForwardIter2,
 692           class _BinaryPredicate>
 693 _ForwardIter1
 694 find_end(_ForwardIter1 __first1, _ForwardIter1 __last1,
 695          _ForwardIter2 __first2, _ForwardIter2 __last2,
 696          _BinaryPredicate __comp);
 697
 698 // replace
 699 template <class _ForwardIter, class _Tp>
 700 _STLP_INLINE_LOOP void
 701 replace(_ForwardIter __first, _ForwardIter __last,
 702         const _Tp& __old_value, const _Tp& __new_value) {
 703   _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first, __last))
 704   for ( ; __first != __last; ++__first)
 705     if (*__first == __old_value)
 706       *__first = __new_value;
 707 }
 708
 709 _STLP_MOVE_TO_PRIV_NAMESPACE
 710
 711 template <class _ForwardIter, class _Tp, class _Compare1, class _Compare2, class _Distance>
 712 _ForwardIter __lower_bound(_ForwardIter __first, _ForwardIter __last,
 713                            const _Tp& __val, _Compare1 __comp1, _Compare2 __comp2, _Distance*);
 714
 715 _STLP_MOVE_TO_STD_NAMESPACE
 716
 717 _STLP_END_NAMESPACE
 718
 719 #if !defined (_STLP_LINK_TIME_INSTANTIATION)
 720 #  include <stl/_algobase.c>
 721 #endif
 722
 723 #endif /* _STLP_INTERNAL_ALGOBASE_H */
 724
 725 // Local Variables:
 726 // mode:C++
 727 // End:
 728