include/stlport/stl/_algo.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_ALGO_H
  31 #define _STLP_INTERNAL_ALGO_H
  32
  33 #ifndef _STLP_INTERNAL_ALGOBASE_H
  34 #  include <stl/_algobase.h>
  35 #endif
  36
  37 #ifndef _STLP_INTERNAL_HEAP_H
  38 #  include <stl/_heap.h>
  39 #endif
  40
  41 #ifndef _STLP_INTERNAL_ITERATOR_H
  42 #  include <stl/_iterator.h>
  43 #endif
  44
  45 #ifndef _STLP_INTERNAL_FUNCTION_BASE_H
  46 #  include <stl/_function_base.h>
  47 #endif
  48
  49 #if defined (__SUNPRO_CC) && !defined (_STLP_INTERNAL_CSTDIO)
  50 // remove() conflict
  51 #  include <stl/_cstdio.h>
  52 #endif
  53
  54 _STLP_BEGIN_NAMESPACE
  55
  56 // for_each.  Apply a function to every element of a range.
  57 template <class _InputIter, class _Function>
  58 _STLP_INLINE_LOOP _Function
  59 for_each(_InputIter __first, _InputIter __last, _Function __f) {
  60   for ( ; __first != __last; ++__first)
  61     __f(*__first);
  62   return __f;
  63 }
  64
  65 // count_if
  66 template <class _InputIter, class _Predicate>
  67 _STLP_INLINE_LOOP _STLP_DIFFERENCE_TYPE(_InputIter)
  68 count_if(_InputIter __first, _InputIter __last, _Predicate __pred) {
  69   _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first, __last))
  70   _STLP_DIFFERENCE_TYPE(_InputIter) __n = 0;
  71   for ( ; __first != __last; ++__first) {
  72     if (__pred(*__first))
  73       ++__n;
  74   }
  75   return __n;
  76 }
  77
  78 // adjacent_find.
  79
  80 template <class _ForwardIter, class _BinaryPredicate>
  81 _STLP_INLINE_LOOP _ForwardIter
  82 adjacent_find(_ForwardIter __first, _ForwardIter __last,
  83               _BinaryPredicate __binary_pred) {
  84   _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first, __last))
  85   if (__first == __last)
  86     return __last;
  87   _ForwardIter __next = __first;
  88   while(++__next != __last) {
  89     if (__binary_pred(*__first, *__next))
  90       return __first;
  91     __first = __next;
  92   }
  93   return __last;
  94 }
  95
  96 template <class _ForwardIter>
  97 _STLP_INLINE_LOOP _ForwardIter
  98 adjacent_find(_ForwardIter __first, _ForwardIter __last) {
  99   return adjacent_find(__first, __last,
 100                        _STLP_PRIV __equal_to(_STLP_VALUE_TYPE(__first, _ForwardIter)));
 101 }
 102
 103 #if !defined (_STLP_NO_ANACHRONISMS)
 104 template <class _InputIter, class _Tp, class _Size>
 105 _STLP_INLINE_LOOP void
 106 count(_InputIter __first, _InputIter __last, const _Tp& __val, _Size& __n) {
 107   _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first, __last))
 108     for ( ; __first != __last; ++__first)
 109       if (*__first == __val)
 110         ++__n;
 111 }
 112
 113 template <class _InputIter, class _Predicate, class _Size>
 114 _STLP_INLINE_LOOP void
 115 count_if(_InputIter __first, _InputIter __last, _Predicate __pred, _Size& __n) {
 116   _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first, __last))
 117   for ( ; __first != __last; ++__first)
 118     if (__pred(*__first))
 119       ++__n;
 120 }
 121 #endif
 122
 123 template <class _ForwardIter1, class _ForwardIter2>
 124 _ForwardIter1 search(_ForwardIter1 __first1, _ForwardIter1 __last1,
 125                      _ForwardIter2 __first2, _ForwardIter2 __last2);
 126
 127 // search_n.  Search for __count consecutive copies of __val.
 128 template <class _ForwardIter, class _Integer, class _Tp>
 129 _ForwardIter search_n(_ForwardIter __first, _ForwardIter __last,
 130                       _Integer __count, const _Tp& __val);
 131 template <class _ForwardIter, class _Integer, class _Tp, class _BinaryPred>
 132 _ForwardIter search_n(_ForwardIter __first, _ForwardIter __last,
 133                       _Integer __count, const _Tp& __val, _BinaryPred __binary_pred);
 134
 135 template <class _InputIter, class _ForwardIter>
 136 inline _InputIter find_first_of(_InputIter __first1, _InputIter __last1,
 137                                 _ForwardIter __first2, _ForwardIter __last2) {
 138   _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first1, __last1))
 139   _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first2, __last2))
 140   return _STLP_PRIV __find_first_of(__first1, __last1, __first2, __last2);
 141 }
 142
 143 template <class _InputIter, class _ForwardIter, class _BinaryPredicate>
 144 inline _InputIter
 145 find_first_of(_InputIter __first1, _InputIter __last1,
 146               _ForwardIter __first2, _ForwardIter __last2, _BinaryPredicate __comp) {
 147   _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first1, __last1))
 148   _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first2, __last2))
 149   return _STLP_PRIV __find_first_of(__first1, __last1, __first2, __last2, __comp);
 150 }
 151
 152 template <class _ForwardIter1, class _ForwardIter2>
 153 _ForwardIter1
 154 find_end(_ForwardIter1 __first1, _ForwardIter1 __last1,
 155          _ForwardIter2 __first2, _ForwardIter2 __last2);
 156
 157 // swap_ranges
 158 template <class _ForwardIter1, class _ForwardIter2>
 159 _STLP_INLINE_LOOP _ForwardIter2
 160 swap_ranges(_ForwardIter1 __first1, _ForwardIter1 __last1, _ForwardIter2 __first2) {
 161   _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first1, __last1))
 162   for ( ; __first1 != __last1; ++__first1, ++__first2)
 163     iter_swap(__first1, __first2);
 164   return __first2;
 165 }
 166
 167 // transform
 168 template <class _InputIter, class _OutputIter, class _UnaryOperation>
 169 _STLP_INLINE_LOOP _OutputIter
 170 transform(_InputIter __first, _InputIter __last, _OutputIter __result, _UnaryOperation __opr) {
 171   _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first, __last))
 172   for ( ; __first != __last; ++__first, ++__result)
 173     *__result = __opr(*__first);
 174   return __result;
 175 }
 176 template <class _InputIter1, class _InputIter2, class _OutputIter, class _BinaryOperation>
 177 _STLP_INLINE_LOOP _OutputIter
 178 transform(_InputIter1 __first1, _InputIter1 __last1,
 179           _InputIter2 __first2, _OutputIter __result,_BinaryOperation __binary_op) {
 180   _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first1, __last1))
 181   for ( ; __first1 != __last1; ++__first1, ++__first2, ++__result)
 182     *__result = __binary_op(*__first1, *__first2);
 183   return __result;
 184 }
 185
 186 // replace_if, replace_copy, replace_copy_if
 187
 188 template <class _ForwardIter, class _Predicate, class _Tp>
 189 _STLP_INLINE_LOOP void
 190 replace_if(_ForwardIter __first, _ForwardIter __last, _Predicate __pred, const _Tp& __new_value) {
 191   _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first, __last))
 192   for ( ; __first != __last; ++__first)
 193     if (__pred(*__first))
 194       *__first = __new_value;
 195 }
 196
 197 template <class _InputIter, class _OutputIter, class _Tp>
 198 _STLP_INLINE_LOOP  _OutputIter
 199 replace_copy(_InputIter __first, _InputIter __last,_OutputIter __result,
 200              const _Tp& __old_value, const _Tp& __new_value) {
 201   _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first, __last))
 202   for ( ; __first != __last; ++__first, ++__result)
 203     *__result = *__first == __old_value ? __new_value : *__first;
 204   return __result;
 205 }
 206
 207 template <class _Iterator, class _OutputIter, class _Predicate, class _Tp>
 208 _STLP_INLINE_LOOP _OutputIter
 209 replace_copy_if(_Iterator __first, _Iterator __last,
 210                 _OutputIter __result,
 211                 _Predicate __pred, const _Tp& __new_value) {
 212   _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first, __last))
 213   for ( ; __first != __last; ++__first, ++__result)
 214     *__result = __pred(*__first) ? __new_value : *__first;
 215   return __result;
 216 }
 217
 218 // generate and generate_n
 219
 220 template <class _ForwardIter, class _Generator>
 221 _STLP_INLINE_LOOP void
 222 generate(_ForwardIter __first, _ForwardIter __last, _Generator __gen) {
 223   _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first, __last))
 224   for ( ; __first != __last; ++__first)
 225     *__first = __gen();
 226 }
 227
 228 template <class _OutputIter, class _Size, class _Generator>
 229 _STLP_INLINE_LOOP void
 230 generate_n(_OutputIter __first, _Size __n, _Generator __gen) {
 231   for ( ; __n > 0; --__n, ++__first)
 232     *__first = __gen();
 233 }
 234
 235 // remove, remove_if, remove_copy, remove_copy_if
 236
 237 template <class _InputIter, class _OutputIter, class _Tp>
 238 _STLP_INLINE_LOOP _OutputIter
 239 remove_copy(_InputIter __first, _InputIter __last,_OutputIter __result, const _Tp& __val) {
 240   _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first, __last))
 241   for ( ; __first != __last; ++__first) {
 242     if (!(*__first == __val)) {
 243       *__result = *__first;
 244       ++__result;
 245     }
 246   }
 247   return __result;
 248 }
 249
 250 template <class _InputIter, class _OutputIter, class _Predicate>
 251 _STLP_INLINE_LOOP _OutputIter
 252 remove_copy_if(_InputIter __first, _InputIter __last, _OutputIter __result, _Predicate __pred) {
 253   _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first, __last))
 254   for ( ; __first != __last; ++__first) {
 255     if (!__pred(*__first)) {
 256       *__result = *__first;
 257       ++__result;
 258     }
 259   }
 260   return __result;
 261 }
 262
 263 template <class _ForwardIter, class _Tp>
 264 _STLP_INLINE_LOOP _ForwardIter
 265 remove(_ForwardIter __first, _ForwardIter __last, const _Tp& __val) {
 266   _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first, __last))
 267   __first = find(__first, __last, __val);
 268   if (__first == __last)
 269     return __first;
 270   else {
 271     _ForwardIter __next = __first;
 272     return remove_copy(++__next, __last, __first, __val);
 273   }
 274 }
 275
 276 template <class _ForwardIter, class _Predicate>
 277 _STLP_INLINE_LOOP _ForwardIter
 278 remove_if(_ForwardIter __first, _ForwardIter __last, _Predicate __pred) {
 279   _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first, __last))
 280   __first = find_if(__first, __last, __pred);
 281   if ( __first == __last )
 282     return __first;
 283   else {
 284     _ForwardIter __next = __first;
 285     return remove_copy_if(++__next, __last, __first, __pred);
 286   }
 287 }
 288
 289 // unique and unique_copy
 290 template <class _InputIter, class _OutputIter>
 291 _OutputIter unique_copy(_InputIter __first, _InputIter __last, _OutputIter __result);
 292
 293 template <class _InputIter, class _OutputIter, class _BinaryPredicate>
 294 _OutputIter unique_copy(_InputIter __first, _InputIter __last,_OutputIter __result,
 295                         _BinaryPredicate __binary_pred);
 296
 297 template <class _ForwardIter>
 298 inline _ForwardIter unique(_ForwardIter __first, _ForwardIter __last) {
 299   __first = adjacent_find(__first, __last);
 300   return unique_copy(__first, __last, __first);
 301 }
 302
 303 template <class _ForwardIter, class _BinaryPredicate>
 304 inline _ForwardIter unique(_ForwardIter __first, _ForwardIter __last,
 305                            _BinaryPredicate __binary_pred) {
 306   __first = adjacent_find(__first, __last, __binary_pred);
 307   return unique_copy(__first, __last, __first, __binary_pred);
 308 }
 309
 310 // reverse and reverse_copy, and their auxiliary functions
 311
 312 _STLP_MOVE_TO_PRIV_NAMESPACE
 313
 314 template <class _BidirectionalIter>
 315 _STLP_INLINE_LOOP void
 316 __reverse(_BidirectionalIter __first, _BidirectionalIter __last, const bidirectional_iterator_tag &) {
 317   for (; __first != __last && __first != --__last; ++__first)
 318     _STLP_STD::iter_swap(__first,__last);
 319 }
 320
 321 template <class _RandomAccessIter>
 322 _STLP_INLINE_LOOP void
 323 __reverse(_RandomAccessIter __first, _RandomAccessIter __last, const random_access_iterator_tag &) {
 324   for (; __first < __last; ++__first)
 325     _STLP_STD::iter_swap(__first, --__last);
 326 }
 327
 328 _STLP_MOVE_TO_STD_NAMESPACE
 329
 330 template <class _BidirectionalIter>
 331 inline void
 332 reverse(_BidirectionalIter __first, _BidirectionalIter __last) {
 333   _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first, __last))
 334   _STLP_PRIV __reverse(__first, __last, _STLP_ITERATOR_CATEGORY(__first, _BidirectionalIter));
 335 }
 336
 337 template <class _BidirectionalIter, class _OutputIter>
 338 _STLP_INLINE_LOOP
 339 _OutputIter reverse_copy(_BidirectionalIter __first,
 340                          _BidirectionalIter __last,
 341                          _OutputIter __result) {
 342   _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first, __last))
 343   while (__first != __last) {
 344     --__last;
 345     *__result = *__last;
 346     ++__result;
 347   }
 348   return __result;
 349 }
 350
 351 template <class _ForwardIter>
 352 void rotate(_ForwardIter __first, _ForwardIter __middle, _ForwardIter __last);
 353
 354 template <class _ForwardIter, class _OutputIter>
 355 inline _OutputIter rotate_copy(_ForwardIter __first, _ForwardIter __middle,
 356                                _ForwardIter __last, _OutputIter __result) {
 357   return _STLP_STD::copy(__first, __middle, copy(__middle, __last, __result));
 358 }
 359
 360 // random_shuffle
 361
 362 template <class _RandomAccessIter>
 363 void random_shuffle(_RandomAccessIter __first, _RandomAccessIter __last);
 364
 365 template <class _RandomAccessIter, class _RandomNumberGenerator>
 366 void random_shuffle(_RandomAccessIter __first, _RandomAccessIter __last,
 367                     _RandomNumberGenerator& __rand);
 368
 369 #if !defined (_STLP_NO_EXTENSIONS)
 370 // random_sample and random_sample_n (extensions, not part of the standard).
 371
 372 template <class _ForwardIter, class _OutputIter, class _Distance>
 373 _OutputIter random_sample_n(_ForwardIter __first, _ForwardIter __last,
 374                             _OutputIter __out_ite, const _Distance __n);
 375
 376 template <class _ForwardIter, class _OutputIter, class _Distance,
 377           class _RandomNumberGenerator>
 378 _OutputIter random_sample_n(_ForwardIter __first, _ForwardIter __last,
 379                             _OutputIter __out_ite, const _Distance __n,
 380                             _RandomNumberGenerator& __rand);
 381
 382 template <class _InputIter, class _RandomAccessIter>
 383 _RandomAccessIter
 384 random_sample(_InputIter __first, _InputIter __last,
 385               _RandomAccessIter __out_first, _RandomAccessIter __out_last);
 386
 387 template <class _InputIter, class _RandomAccessIter,
 388           class _RandomNumberGenerator>
 389 _RandomAccessIter
 390 random_sample(_InputIter __first, _InputIter __last,
 391               _RandomAccessIter __out_first, _RandomAccessIter __out_last,
 392               _RandomNumberGenerator& __rand);
 393
 394 #endif /* _STLP_NO_EXTENSIONS */
 395
 396 // partition, stable_partition, and their auxiliary functions
 397
 398 template <class _ForwardIter, class _Predicate>
 399 _ForwardIter partition(_ForwardIter __first, _ForwardIter __last, _Predicate   __pred);
 400
 401 template <class _ForwardIter, class _Predicate>
 402 _ForwardIter
 403 stable_partition(_ForwardIter __first, _ForwardIter __last, _Predicate __pred);
 404
 405 // sort() and its auxiliary functions.
 406 _STLP_MOVE_TO_PRIV_NAMESPACE
 407
 408 template <class _Size>
 409 inline _Size __lg(_Size __n) {
 410   _Size __k;
 411   for (__k = 0; __n != 1; __n >>= 1) ++__k;
 412   return __k;
 413 }
 414
 415 _STLP_MOVE_TO_STD_NAMESPACE
 416
 417 template <class _RandomAccessIter>
 418 void sort(_RandomAccessIter __first, _RandomAccessIter __last);
 419 template <class _RandomAccessIter, class _Compare>
 420 void sort(_RandomAccessIter __first, _RandomAccessIter __last, _Compare __comp);
 421
 422 // stable_sort() and its auxiliary functions.
 423 template <class _RandomAccessIter>
 424 void stable_sort(_RandomAccessIter __first,
 425                  _RandomAccessIter __last);
 426
 427 template <class _RandomAccessIter, class _Compare>
 428 void stable_sort(_RandomAccessIter __first,
 429                  _RandomAccessIter __last, _Compare __comp);
 430
 431 // partial_sort, partial_sort_copy, and auxiliary functions.
 432
 433 template <class _RandomAccessIter>
 434 void partial_sort(_RandomAccessIter __first, _RandomAccessIter __middle,
 435                   _RandomAccessIter __last);
 436
 437 template <class _RandomAccessIter, class _Compare>
 438 void partial_sort(_RandomAccessIter __first,_RandomAccessIter __middle,
 439                   _RandomAccessIter __last, _Compare __comp);
 440
 441 template <class _InputIter, class _RandomAccessIter>
 442 _RandomAccessIter
 443 partial_sort_copy(_InputIter __first, _InputIter __last,
 444                   _RandomAccessIter __result_first, _RandomAccessIter __result_last);
 445
 446 template <class _InputIter, class _RandomAccessIter, class _Compare>
 447 _RandomAccessIter
 448 partial_sort_copy(_InputIter __first, _InputIter __last,
 449                   _RandomAccessIter __result_first,
 450                   _RandomAccessIter __result_last, _Compare __comp);
 451
 452 // nth_element() and its auxiliary functions.
 453 template <class _RandomAccessIter>
 454 void nth_element(_RandomAccessIter __first, _RandomAccessIter __nth,
 455                  _RandomAccessIter __last);
 456
 457 template <class _RandomAccessIter, class _Compare>
 458 void nth_element(_RandomAccessIter __first, _RandomAccessIter __nth,
 459                  _RandomAccessIter __last, _Compare __comp);
 460
 461 // auxiliary class for lower_bound, etc.
 462 _STLP_MOVE_TO_PRIV_NAMESPACE
 463
 464 template <class _T1, class _T2>
 465 struct __less_2 {
 466   bool operator() (const _T1& __x, const _T2& __y) const { return __x < __y ; }
 467 };
 468
 469 template <class _T1, class _T2>
 470 __less_2<_T1,_T2> __less2(_T1*, _T2* ) { return __less_2<_T1, _T2>(); }
 471
 472 #if defined (_STLP_FUNCTION_PARTIAL_ORDER)
 473 template <class _Tp>
 474 less<_Tp> __less2(_Tp*, _Tp* ) { return less<_Tp>(); }
 475 #endif
 476
 477 _STLP_MOVE_TO_STD_NAMESPACE
 478
 479 // Binary search (lower_bound, upper_bound, equal_range, binary_search).
 480 template <class _ForwardIter, class _Tp>
 481 inline _ForwardIter lower_bound(_ForwardIter __first, _ForwardIter __last,
 482                                    const _Tp& __val) {
 483   _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first, __last))
 484   return _STLP_PRIV __lower_bound(__first, __last, __val,
 485                                   _STLP_PRIV __less2(_STLP_VALUE_TYPE(__first, _ForwardIter), (_Tp*)0),
 486                                   _STLP_PRIV __less2((_Tp*)0, _STLP_VALUE_TYPE(__first, _ForwardIter)),
 487                                   _STLP_DISTANCE_TYPE(__first, _ForwardIter));
 488 }
 489
 490 template <class _ForwardIter, class _Tp, class _Compare>
 491 inline _ForwardIter lower_bound(_ForwardIter __first, _ForwardIter __last,
 492                                 const _Tp& __val, _Compare __comp) {
 493   _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first, __last))
 494   return _STLP_PRIV __lower_bound(__first, __last, __val, __comp, __comp,
 495                                   _STLP_DISTANCE_TYPE(__first, _ForwardIter));
 496 }
 497
 498 _STLP_MOVE_TO_PRIV_NAMESPACE
 499
 500 template <class _ForwardIter, class _Tp, class _Compare1, class _Compare2, class _Distance>
 501 _ForwardIter __upper_bound(_ForwardIter __first, _ForwardIter __last, const _Tp& __val,
 502                            _Compare1 __comp1, _Compare2 __comp2, _Distance*);
 503
 504 _STLP_MOVE_TO_STD_NAMESPACE
 505
 506 template <class _ForwardIter, class _Tp>
 507 inline _ForwardIter upper_bound(_ForwardIter __first, _ForwardIter __last,
 508                                 const _Tp& __val) {
 509   _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first, __last))
 510   return _STLP_PRIV __upper_bound(__first, __last, __val,
 511                                   _STLP_PRIV __less2(_STLP_VALUE_TYPE(__first, _ForwardIter), (_Tp*)0),
 512                                   _STLP_PRIV __less2((_Tp*)0, _STLP_VALUE_TYPE(__first, _ForwardIter)),
 513                                   _STLP_DISTANCE_TYPE(__first, _ForwardIter));
 514 }
 515
 516 template <class _ForwardIter, class _Tp, class _Compare>
 517 inline _ForwardIter upper_bound(_ForwardIter __first, _ForwardIter __last,
 518                                 const _Tp& __val, _Compare __comp) {
 519   _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first, __last))
 520   return _STLP_PRIV __upper_bound(__first, __last, __val, __comp, __comp,
 521                                   _STLP_DISTANCE_TYPE(__first, _ForwardIter));
 522 }
 523
 524 _STLP_MOVE_TO_PRIV_NAMESPACE
 525
 526 template <class _ForwardIter, class _Tp, class _Compare1, class _Compare2, class _Distance>
 527 pair<_ForwardIter, _ForwardIter>
 528 __equal_range(_ForwardIter __first, _ForwardIter __last, const _Tp& __val,
 529               _Compare1 __comp1, _Compare2 __comp2, _Distance*);
 530
 531 _STLP_MOVE_TO_STD_NAMESPACE
 532
 533 template <class _ForwardIter, class _Tp>
 534 inline pair<_ForwardIter, _ForwardIter>
 535 equal_range(_ForwardIter __first, _ForwardIter __last, const _Tp& __val) {
 536   _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first, __last))
 537   return _STLP_PRIV __equal_range(__first, __last, __val,
 538                                   _STLP_PRIV __less2(_STLP_VALUE_TYPE(__first, _ForwardIter), (_Tp*)0),
 539                                   _STLP_PRIV __less2((_Tp*)0, _STLP_VALUE_TYPE(__first, _ForwardIter)),
 540                                   _STLP_DISTANCE_TYPE(__first, _ForwardIter));
 541 }
 542
 543 template <class _ForwardIter, class _Tp, class _Compare>
 544 inline pair<_ForwardIter, _ForwardIter>
 545 equal_range(_ForwardIter __first, _ForwardIter __last, const _Tp& __val,
 546             _Compare __comp) {
 547   _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first, __last))
 548   return _STLP_PRIV __equal_range(__first, __last, __val, __comp, __comp,
 549                                   _STLP_DISTANCE_TYPE(__first, _ForwardIter));
 550 }
 551
 552 template <class _ForwardIter, class _Tp>
 553 inline bool binary_search(_ForwardIter __first, _ForwardIter __last,
 554                    const _Tp& __val) {
 555   _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first, __last))
 556   _ForwardIter __i = _STLP_PRIV __lower_bound(__first, __last, __val,
 557                                               _STLP_PRIV __less2(_STLP_VALUE_TYPE(__first, _ForwardIter), (_Tp*)0),
 558                                               _STLP_PRIV __less2((_Tp*)0, _STLP_VALUE_TYPE(__first, _ForwardIter)),
 559                                               _STLP_DISTANCE_TYPE(__first, _ForwardIter));
 560   return __i != __last && !(__val < *__i);
 561 }
 562
 563 template <class _ForwardIter, class _Tp, class _Compare>
 564 inline bool binary_search(_ForwardIter __first, _ForwardIter __last,
 565                           const _Tp& __val,
 566                           _Compare __comp) {
 567   _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first, __last))
 568   _ForwardIter __i = _STLP_PRIV __lower_bound(__first, __last, __val, __comp, __comp,
 569                                               _STLP_DISTANCE_TYPE(__first, _ForwardIter));
 570   return __i != __last && !__comp(__val, *__i);
 571 }
 572
 573 // merge, with and without an explicitly supplied comparison function.
 574
 575 template <class _InputIter1, class _InputIter2, class _OutputIter>
 576 _OutputIter merge(_InputIter1 __first1, _InputIter1 __last1,
 577                   _InputIter2 __first2, _InputIter2 __last2,
 578                   _OutputIter __result);
 579
 580 template <class _InputIter1, class _InputIter2, class _OutputIter,
 581           class _Compare>
 582 _OutputIter merge(_InputIter1 __first1, _InputIter1 __last1,
 583                   _InputIter2 __first2, _InputIter2 __last2,
 584                   _OutputIter __result, _Compare __comp);
 585
 586
 587 // inplace_merge and its auxiliary functions.
 588
 589
 590 template <class _BidirectionalIter>
 591 void inplace_merge(_BidirectionalIter __first,
 592                    _BidirectionalIter __middle,
 593                    _BidirectionalIter __last) ;
 594
 595 template <class _BidirectionalIter, class _Compare>
 596 void inplace_merge(_BidirectionalIter __first,
 597                    _BidirectionalIter __middle,
 598                    _BidirectionalIter __last, _Compare __comp);
 599
 600 // Set algorithms: includes, set_union, set_intersection, set_difference,
 601 // set_symmetric_difference.  All of these algorithms have the precondition
 602 // that their input ranges are sorted and the postcondition that their output
 603 // ranges are sorted.
 604
 605 template <class _InputIter1, class _InputIter2>
 606 bool includes(_InputIter1 __first1, _InputIter1 __last1,
 607               _InputIter2 __first2, _InputIter2 __last2);
 608
 609 template <class _InputIter1, class _InputIter2, class _Compare>
 610 bool includes(_InputIter1 __first1, _InputIter1 __last1,
 611               _InputIter2 __first2, _InputIter2 __last2, _Compare __comp);
 612
 613 template <class _InputIter1, class _InputIter2, class _OutputIter>
 614 _OutputIter set_union(_InputIter1 __first1, _InputIter1 __last1,
 615                       _InputIter2 __first2, _InputIter2 __last2,
 616                       _OutputIter __result);
 617
 618 template <class _InputIter1, class _InputIter2, class _OutputIter,
 619           class _Compare>
 620 _OutputIter set_union(_InputIter1 __first1, _InputIter1 __last1,
 621                       _InputIter2 __first2, _InputIter2 __last2,
 622                       _OutputIter __result, _Compare __comp);
 623
 624 template <class _InputIter1, class _InputIter2, class _OutputIter>
 625 _OutputIter set_intersection(_InputIter1 __first1, _InputIter1 __last1,
 626                              _InputIter2 __first2, _InputIter2 __last2,
 627                              _OutputIter __result);
 628
 629 template <class _InputIter1, class _InputIter2, class _OutputIter,
 630           class _Compare>
 631 _OutputIter set_intersection(_InputIter1 __first1, _InputIter1 __last1,
 632                              _InputIter2 __first2, _InputIter2 __last2,
 633                              _OutputIter __result, _Compare __comp);
 634
 635
 636
 637 template <class _InputIter1, class _InputIter2, class _OutputIter>
 638 _OutputIter set_difference(_InputIter1 __first1, _InputIter1 __last1,
 639                            _InputIter2 __first2, _InputIter2 __last2,
 640                            _OutputIter __result);
 641
 642 template <class _InputIter1, class _InputIter2, class _OutputIter,
 643           class _Compare>
 644 _OutputIter set_difference(_InputIter1 __first1, _InputIter1 __last1,
 645                            _InputIter2 __first2, _InputIter2 __last2,
 646                            _OutputIter __result, _Compare __comp);
 647
 648 template <class _InputIter1, class _InputIter2, class _OutputIter>
 649 _OutputIter
 650 set_symmetric_difference(_InputIter1 __first1, _InputIter1 __last1,
 651                          _InputIter2 __first2, _InputIter2 __last2,
 652                          _OutputIter __result);
 653
 654
 655 template <class _InputIter1, class _InputIter2, class _OutputIter,
 656           class _Compare>
 657 _OutputIter
 658 set_symmetric_difference(_InputIter1 __first1, _InputIter1 __last1,
 659                          _InputIter2 __first2, _InputIter2 __last2,
 660                          _OutputIter __result,
 661                          _Compare __comp);
 662
 663
 664 // min_element and max_element, with and without an explicitly supplied
 665 // comparison function.
 666
 667 template <class _ForwardIter>
 668 _ForwardIter max_element(_ForwardIter __first, _ForwardIter __last);
 669 template <class _ForwardIter, class _Compare>
 670 _ForwardIter max_element(_ForwardIter __first, _ForwardIter __last,
 671                             _Compare __comp);
 672
 673 template <class _ForwardIter>
 674 _ForwardIter min_element(_ForwardIter __first, _ForwardIter __last);
 675
 676 template <class _ForwardIter, class _Compare>
 677 _ForwardIter min_element(_ForwardIter __first, _ForwardIter __last,
 678                             _Compare __comp);
 679
 680 // next_permutation and prev_permutation, with and without an explicitly
 681 // supplied comparison function.
 682
 683 template <class _BidirectionalIter>
 684 bool next_permutation(_BidirectionalIter __first, _BidirectionalIter __last);
 685
 686 template <class _BidirectionalIter, class _Compare>
 687 bool next_permutation(_BidirectionalIter __first, _BidirectionalIter __last,
 688                       _Compare __comp);
 689
 690
 691 template <class _BidirectionalIter>
 692 bool prev_permutation(_BidirectionalIter __first, _BidirectionalIter __last);
 693
 694
 695 template <class _BidirectionalIter, class _Compare>
 696 bool prev_permutation(_BidirectionalIter __first, _BidirectionalIter __last,
 697                       _Compare __comp);
 698
 699 #if !defined (_STLP_NO_EXTENSIONS)
 700 // is_heap, a predicate testing whether or not a range is
 701 // a heap.  This function is an extension, not part of the C++
 702 // standard.
 703
 704 template <class _RandomAccessIter>
 705 bool is_heap(_RandomAccessIter __first, _RandomAccessIter __last);
 706
 707 template <class _RandomAccessIter, class _StrictWeakOrdering>
 708 bool is_heap(_RandomAccessIter __first, _RandomAccessIter __last,
 709              _StrictWeakOrdering __comp);
 710
 711 // is_sorted, a predicated testing whether a range is sorted in
 712 // nondescending order.  This is an extension, not part of the C++
 713 // standard.
 714 _STLP_MOVE_TO_PRIV_NAMESPACE
 715
 716 template <class _ForwardIter, class _StrictWeakOrdering>
 717 bool __is_sorted(_ForwardIter __first, _ForwardIter __last,
 718                  _StrictWeakOrdering __comp);
 719
 720 _STLP_MOVE_TO_STD_NAMESPACE
 721 template <class _ForwardIter>
 722 inline bool is_sorted(_ForwardIter __first, _ForwardIter __last) {
 723   return _STLP_PRIV __is_sorted(__first, __last,
 724                                 _STLP_PRIV __less(_STLP_VALUE_TYPE(__first, _ForwardIter)));
 725 }
 726
 727 template <class _ForwardIter, class _StrictWeakOrdering>
 728 inline bool is_sorted(_ForwardIter __first, _ForwardIter __last,
 729                       _StrictWeakOrdering __comp) {
 730   return _STLP_PRIV __is_sorted(__first, __last, __comp);
 731 }
 732 #endif
 733
 734 _STLP_END_NAMESPACE
 735
 736 #if !defined (_STLP_LINK_TIME_INSTANTIATION)
 737 #  include <stl/_algo.c>
 738 #endif
 739
 740 #endif /* _STLP_INTERNAL_ALGO_H */
 741
 742 // Local Variables:
 743 // mode:C++
 744 // End:
 745