contrib/gcc-4.4/libstdc++-v3/include/bits/algorithmfwd.h

   1 // <algorithm> declarations  -*- C++ -*-
   2
   3 // Copyright (C) 2007, 2008, 2009 Free Software Foundation, Inc.
   4 //
   5 // This file is part of the GNU ISO C++ Library.  This library is free
   6 // software; you can redistribute it and/or modify it under the
   7 // terms of the GNU General Public License as published by the
   8 // Free Software Foundation; either version 3, or (at your option)
   9 // any later version.
  10
  11 // This library is distributed in the hope that it will be useful,
  12 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14 // GNU General Public License for more details.
  15
  16 // Under Section 7 of GPL version 3, you are granted additional
  17 // permissions described in the GCC Runtime Library Exception, version
  18 // 3.1, as published by the Free Software Foundation.
  19
  20 // You should have received a copy of the GNU General Public License and
  21 // a copy of the GCC Runtime Library Exception along with this program;
  22 // see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
  23 // <http://www.gnu.org/licenses/>.
  24
  25 /** @file bits/algorithmfwd.h
  26  *  This is an internal header file, included by other library headers.
  27  *  You should not attempt to use it directly.
  28  */
  29
  30 #ifndef _GLIBCXX_ALGORITHMFWD_H
  31 #define _GLIBCXX_ALGORITHMFWD_H 1
  32
  33 #pragma GCC system_header
  34
  35 #include <bits/c++config.h>
  36 #include <bits/stl_pair.h>
  37 #include <bits/stl_iterator_base_types.h>
  38 #include <initializer_list>
  39
  40 _GLIBCXX_BEGIN_NAMESPACE(std)
  41
  42   /*
  43     adjacent_find
  44     all_of (C++0x)
  45     any_of (C++0x)
  46     binary_search
  47     copy
  48     copy_backward
  49     copy_if (C++0x)
  50     copy_n (C++0x)
  51     count
  52     count_if
  53     equal
  54     equal_range
  55     fill
  56     fill_n
  57     find
  58     find_end
  59     find_first_of
  60     find_if
  61     find_if_not (C++0x)
  62     for_each
  63     generate
  64     generate_n
  65     includes
  66     inplace_merge
  67     is_heap (C++0x)
  68     is_heap_until (C++0x)
  69     is_partitioned (C++0x)
  70     is_sorted (C++0x)
  71     is_sorted_until (C++0x)
  72     iter_swap
  73     lexicographical_compare
  74     lower_bound
  75     make_heap
  76     max
  77     max_element
  78     merge
  79     min
  80     min_element
  81     minmax (C++0x)
  82     minmax_element (C++0x)
  83     mismatch
  84     next_permutation
  85     none_of (C++0x)
  86     nth_element
  87     partial_sort
  88     partial_sort_copy
  89     partition
  90     partition_copy (C++0x)
  91     partition_point (C++0x)
  92     pop_heap
  93     prev_permutation
  94     push_heap
  95     random_shuffle
  96     remove
  97     remove_copy
  98     remove_copy_if
  99     remove_if
 100     replace
 101     replace_copy
 102     replace_copy_if
 103     replace_if
 104     reverse
 105     reverse_copy
 106     rotate
 107     rotate_copy
 108     search
 109     search_n
 110     set_difference
 111     set_intersection
 112     set_symmetric_difference
 113     set_union
 114     sort
 115     sort_heap
 116     stable_partition
 117     stable_sort
 118     swap
 119     swap_ranges
 120     transform
 121     unique
 122     unique_copy
 123     upper_bound
 124   */
 125
 126   /**
 127    * @defgroup algorithms Algorithms
 128    *
 129    * Components for performing algorithmic operations. Includes
 130    * non-modifying sequence, modifying (mutating) sequence, sorting,
 131    * searching, merge, partition, heap, set, minima, maxima, and
 132    * permutation operations.
 133    */
 134
 135   /**
 136    * @defgroup mutating_algorithms Mutating Algorithms
 137    * @ingroup algorithms
 138    */
 139
 140   /**
 141    * @defgroup non_mutating_algorithms Non-Mutating Algorithms
 142    * @ingroup algorithms
 143    */
 144
 145   /**
 146    * @defgroup sorting_algorithms Sorting Algorithms
 147    * @ingroup algorithms
 148    */
 149
 150   /**
 151    * @defgroup set_algorithms Set Operation Algorithms
 152    * @ingroup sorting_algorithms
 153    *
 154    * These algorithms are common set operations performed on sequences
 155    * that are already sorted. The number of comparisons will be
 156    * linear.
 157    */
 158
 159   /**
 160    * @defgroup binary_search_algorithms Binary Search Algorithms
 161    * @ingroup sorting_algorithms
 162    *
 163    * These algorithms are variations of a classic binary search, and
 164    * all assume that the sequence being searched is already sorted.
 165    *
 166    * The number of comparisons will be logarithmic (and as few as
 167    * possible).  The number of steps through the sequence will be
 168    * logarithmic for random-access iterators (e.g., pointers), and
 169    * linear otherwise.
 170    *
 171    * The LWG has passed Defect Report 270, which notes: <em>The
 172    * proposed resolution reinterprets binary search. Instead of
 173    * thinking about searching for a value in a sorted range, we view
 174    * that as an important special case of a more general algorithm:
 175    * searching for the partition point in a partitioned range.  We
 176    * also add a guarantee that the old wording did not: we ensure that
 177    * the upper bound is no earlier than the lower bound, that the pair
 178    * returned by equal_range is a valid range, and that the first part
 179    * of that pair is the lower bound.</em>
 180    *
 181    * The actual effect of the first sentence is that a comparison
 182    * functor passed by the user doesn't necessarily need to induce a
 183    * strict weak ordering relation.  Rather, it partitions the range.
 184    */
 185
 186   // adjacent_find
 187
 188 #ifdef __GXX_EXPERIMENTAL_CXX0X__
 189   template<typename _IIter, typename _Predicate>
 190     bool
 191     all_of(_IIter, _IIter, _Predicate);
 192
 193   template<typename _IIter, typename _Predicate>
 194     bool
 195     any_of(_IIter, _IIter, _Predicate);
 196 #endif
 197
 198   template<typename _FIter, typename _Tp>
 199     bool
 200     binary_search(_FIter, _FIter, const _Tp&);
 201
 202   template<typename _FIter, typename _Tp, typename _Compare>
 203     bool
 204     binary_search(_FIter, _FIter, const _Tp&, _Compare);
 205
 206   template<typename _IIter, typename _OIter>
 207     _OIter
 208     copy(_IIter, _IIter, _OIter);
 209
 210   template<typename _BIter1, typename _BIter2>
 211     _BIter2
 212     copy_backward(_BIter1, _BIter1, _BIter2);
 213
 214 #ifdef __GXX_EXPERIMENTAL_CXX0X__
 215   template<typename _IIter, typename _OIter, typename _Predicate>
 216     _OIter
 217     copy_if(_IIter, _IIter, _OIter, _Predicate);
 218
 219   template<typename _IIter, typename _Size, typename _OIter>
 220     _OIter
 221     copy_n(_IIter, _Size, _OIter);
 222 #endif
 223
 224   // count
 225   // count_if
 226
 227   template<typename _FIter, typename _Tp>
 228     pair<_FIter, _FIter>
 229     equal_range(_FIter, _FIter, const _Tp&);
 230
 231   template<typename _FIter, typename _Tp, typename _Compare>
 232     pair<_FIter, _FIter>
 233     equal_range(_FIter, _FIter, const _Tp&, _Compare);
 234
 235   template<typename _FIter, typename _Tp>
 236     void
 237     fill(_FIter, _FIter, const _Tp&);
 238
 239 /*
 240   XXX NB: return type different from ISO C++.
 241   template<typename _OIter, typename _Size, typename _Tp>
 242     void
 243     fill_n(_OIter, _Size, const _Tp&);
 244 */
 245
 246   template<typename _OIter, typename _Size, typename _Tp>
 247     _OIter
 248     fill_n(_OIter, _Size, const _Tp&);
 249
 250   // find
 251
 252   template<typename _FIter1, typename _FIter2>
 253     _FIter1
 254     find_end(_FIter1, _FIter1, _FIter2, _FIter2);
 255
 256   template<typename _FIter1, typename _FIter2, typename _BinaryPredicate>
 257     _FIter1
 258     find_end(_FIter1, _FIter1, _FIter2, _FIter2, _BinaryPredicate);
 259
 260   // find_first_of
 261   // find_if
 262
 263 #ifdef __GXX_EXPERIMENTAL_CXX0X__
 264   template<typename _IIter, typename _Predicate>
 265     _IIter
 266     find_if_not(_IIter, _IIter, _Predicate);
 267 #endif
 268
 269   // for_each
 270   // generate
 271   // generate_n
 272
 273   template<typename _IIter1, typename _IIter2>
 274     bool
 275     includes(_IIter1, _IIter1, _IIter2, _IIter2);
 276
 277   template<typename _IIter1, typename _IIter2, typename _Compare>
 278     bool
 279     includes(_IIter1, _IIter1, _IIter2, _IIter2, _Compare);
 280
 281   template<typename _BIter>
 282     void
 283     inplace_merge(_BIter, _BIter, _BIter);
 284
 285   template<typename _BIter, typename _Compare>
 286     void
 287     inplace_merge(_BIter, _BIter, _BIter, _Compare);
 288
 289 #ifdef __GXX_EXPERIMENTAL_CXX0X__
 290   template<typename _RAIter>
 291     bool
 292     is_heap(_RAIter, _RAIter);
 293
 294   template<typename _RAIter, typename _Compare>
 295     bool
 296     is_heap(_RAIter, _RAIter, _Compare);
 297
 298   template<typename _RAIter>
 299     _RAIter
 300     is_heap_until(_RAIter, _RAIter);
 301
 302   template<typename _RAIter, typename _Compare>
 303     _RAIter
 304     is_heap_until(_RAIter, _RAIter, _Compare);
 305
 306   template<typename _IIter, typename _Predicate>
 307     bool
 308     is_partitioned(_IIter, _IIter, _Predicate);
 309
 310   template<typename _FIter>
 311     bool
 312     is_sorted(_FIter, _FIter);
 313
 314   template<typename _FIter, typename _Compare>
 315     bool
 316     is_sorted(_FIter, _FIter, _Compare);
 317
 318   template<typename _FIter>
 319     _FIter
 320     is_sorted_until(_FIter, _FIter);
 321
 322   template<typename _FIter, typename _Compare>
 323     _FIter
 324     is_sorted_until(_FIter, _FIter, _Compare);
 325 #endif
 326
 327   template<typename _FIter1, typename _FIter2>
 328     void
 329     iter_swap(_FIter1, _FIter2);
 330
 331   template<typename _FIter, typename _Tp>
 332     _FIter
 333     lower_bound(_FIter, _FIter, const _Tp&);
 334
 335   template<typename _FIter, typename _Tp, typename _Compare>
 336     _FIter
 337     lower_bound(_FIter, _FIter, const _Tp&, _Compare);
 338
 339   template<typename _RAIter>
 340     void
 341     make_heap(_RAIter, _RAIter);
 342
 343   template<typename _RAIter, typename _Compare>
 344     void
 345     make_heap(_RAIter, _RAIter, _Compare);
 346
 347   template<typename _Tp>
 348     const _Tp&
 349     max(const _Tp&, const _Tp&);
 350
 351   template<typename _Tp, typename _Compare>
 352     const _Tp&
 353     max(const _Tp&, const _Tp&, _Compare);
 354
 355   // max_element
 356   // merge
 357
 358   template<typename _Tp>
 359     const _Tp&
 360     min(const _Tp&, const _Tp&);
 361
 362   template<typename _Tp, typename _Compare>
 363     const _Tp&
 364     min(const _Tp&, const _Tp&, _Compare);
 365
 366   // min_element
 367
 368 #ifdef __GXX_EXPERIMENTAL_CXX0X__
 369   template<typename _Tp>
 370     pair<const _Tp&, const _Tp&>
 371     minmax(const _Tp&, const _Tp&);
 372
 373   template<typename _Tp, typename _Compare>
 374     pair<const _Tp&, const _Tp&>
 375     minmax(const _Tp&, const _Tp&, _Compare);
 376
 377   template<typename _FIter>
 378     pair<_FIter, _FIter>
 379     minmax_element(_FIter, _FIter);
 380
 381   template<typename _FIter, typename _Compare>
 382     pair<_FIter, _FIter>
 383     minmax_element(_FIter, _FIter, _Compare);
 384
 385   template<typename _Tp>
 386     _Tp
 387     min(initializer_list<_Tp>);
 388
 389   template<typename _Tp, typename _Compare>
 390     _Tp
 391     min(initializer_list<_Tp>, _Compare);
 392
 393   template<typename _Tp>
 394     _Tp
 395     max(initializer_list<_Tp>);
 396
 397   template<typename _Tp, typename _Compare>
 398     _Tp
 399     max(initializer_list<_Tp>, _Compare);
 400
 401   template<typename _Tp>
 402     pair<_Tp, _Tp>
 403     minmax(initializer_list<_Tp>);
 404
 405   template<typename _Tp, typename _Compare>
 406     pair<_Tp, _Tp>
 407     minmax(initializer_list<_Tp>, _Compare);
 408 #endif
 409
 410   // mismatch
 411
 412   template<typename _BIter>
 413     bool
 414     next_permutation(_BIter, _BIter);
 415
 416   template<typename _BIter, typename _Compare>
 417     bool
 418     next_permutation(_BIter, _BIter, _Compare);
 419
 420 #ifdef __GXX_EXPERIMENTAL_CXX0X__
 421   template<typename _IIter, typename _Predicate>
 422     bool
 423     none_of(_IIter, _IIter, _Predicate);
 424 #endif
 425
 426   // nth_element
 427   // partial_sort
 428
 429   template<typename _IIter, typename _RAIter>
 430     _RAIter
 431     partial_sort_copy(_IIter, _IIter, _RAIter, _RAIter);
 432
 433   template<typename _IIter, typename _RAIter, typename _Compare>
 434     _RAIter
 435     partial_sort_copy(_IIter, _IIter, _RAIter, _RAIter, _Compare);
 436
 437   // partition
 438
 439 #ifdef __GXX_EXPERIMENTAL_CXX0X__
 440   template<typename _IIter, typename _OIter1,
 441            typename _OIter2, typename _Predicate>
 442     pair<_OIter1, _OIter2>
 443     partition_copy(_IIter, _IIter, _OIter1, _OIter2, _Predicate);
 444
 445   template<typename _FIter, typename _Predicate>
 446     _FIter
 447     partition_point(_FIter, _FIter, _Predicate);
 448 #endif
 449
 450   template<typename _RAIter>
 451     void
 452     pop_heap(_RAIter, _RAIter);
 453
 454   template<typename _RAIter, typename _Compare>
 455     void
 456     pop_heap(_RAIter, _RAIter, _Compare);
 457
 458   template<typename _BIter>
 459     bool
 460     prev_permutation(_BIter, _BIter);
 461
 462   template<typename _BIter, typename _Compare>
 463     bool
 464     prev_permutation(_BIter, _BIter, _Compare);
 465
 466   template<typename _RAIter>
 467     void
 468     push_heap(_RAIter, _RAIter);
 469
 470   template<typename _RAIter, typename _Compare>
 471     void
 472     push_heap(_RAIter, _RAIter, _Compare);
 473
 474   // random_shuffle
 475
 476   template<typename _FIter, typename _Tp>
 477     _FIter
 478     remove(_FIter, _FIter, const _Tp&);
 479
 480   template<typename _FIter, typename _Predicate>
 481     _FIter
 482     remove_if(_FIter, _FIter, _Predicate);
 483
 484   template<typename _IIter, typename _OIter, typename _Tp>
 485     _OIter
 486     remove_copy(_IIter, _IIter, _OIter, const _Tp&);
 487
 488   template<typename _IIter, typename _OIter, typename _Predicate>
 489     _OIter
 490     remove_copy_if(_IIter, _IIter, _OIter, _Predicate);
 491
 492   // replace
 493
 494   template<typename _IIter, typename _OIter, typename _Tp>
 495     _OIter
 496     replace_copy(_IIter, _IIter, _OIter, const _Tp&, const _Tp&);
 497
 498   template<typename _Iter, typename _OIter, typename _Predicate, typename _Tp>
 499     _OIter
 500     replace_copy_if(_Iter, _Iter, _OIter, _Predicate, const _Tp&);
 501
 502   // replace_if
 503
 504   template<typename _BIter>
 505     void
 506     reverse(_BIter, _BIter);
 507
 508   template<typename _BIter, typename _OIter>
 509     _OIter
 510     reverse_copy(_BIter, _BIter, _OIter);
 511
 512   template<typename _FIter>
 513     void
 514     rotate(_FIter, _FIter, _FIter);
 515
 516   template<typename _FIter, typename _OIter>
 517     _OIter
 518     rotate_copy(_FIter, _FIter, _FIter, _OIter);
 519
 520   // search
 521   // search_n
 522   // set_difference
 523   // set_intersection
 524   // set_symmetric_difference
 525   // set_union
 526
 527   template<typename _RAIter>
 528     void
 529     sort_heap(_RAIter, _RAIter);
 530
 531   template<typename _RAIter, typename _Compare>
 532     void
 533     sort_heap(_RAIter, _RAIter, _Compare);
 534
 535   template<typename _BIter, typename _Predicate>
 536     _BIter
 537     stable_partition(_BIter, _BIter, _Predicate);
 538
 539   template<typename _Tp>
 540     void
 541     swap(_Tp&, _Tp&);
 542
 543   template<typename _Tp, size_t _Nm>
 544     void
 545     swap(_Tp (&)[_Nm], _Tp (&)[_Nm]);
 546
 547   template<typename _FIter1, typename _FIter2>
 548     _FIter2
 549     swap_ranges(_FIter1, _FIter1, _FIter2);
 550
 551   // transform
 552
 553   template<typename _FIter>
 554     _FIter
 555     unique(_FIter, _FIter);
 556
 557   template<typename _FIter, typename _BinaryPredicate>
 558     _FIter
 559     unique(_FIter, _FIter, _BinaryPredicate);
 560
 561   // unique_copy
 562
 563   template<typename _FIter, typename _Tp>
 564     _FIter
 565     upper_bound(_FIter, _FIter, const _Tp&);
 566
 567   template<typename _FIter, typename _Tp, typename _Compare>
 568     _FIter
 569     upper_bound(_FIter, _FIter, const _Tp&, _Compare);
 570
 571 _GLIBCXX_END_NAMESPACE
 572
 573 _GLIBCXX_BEGIN_NESTED_NAMESPACE(std, _GLIBCXX_STD_P)
 574
 575   template<typename _FIter>
 576     _FIter
 577     adjacent_find(_FIter, _FIter);
 578
 579   template<typename _FIter, typename _BinaryPredicate>
 580     _FIter
 581     adjacent_find(_FIter, _FIter, _BinaryPredicate);
 582
 583   template<typename _IIter, typename _Tp>
 584     typename iterator_traits<_IIter>::difference_type
 585     count(_IIter, _IIter, const _Tp&);
 586
 587   template<typename _IIter, typename _Predicate>
 588     typename iterator_traits<_IIter>::difference_type
 589     count_if(_IIter, _IIter, _Predicate);
 590
 591   template<typename _IIter1, typename _IIter2>
 592     bool
 593     equal(_IIter1, _IIter1, _IIter2);
 594
 595   template<typename _IIter1, typename _IIter2, typename _BinaryPredicate>
 596     bool
 597     equal(_IIter1, _IIter1, _IIter2, _BinaryPredicate);
 598
 599   template<typename _IIter, typename _Tp>
 600     _IIter
 601     find(_IIter, _IIter, const _Tp&);
 602
 603   template<typename _FIter1, typename _FIter2>
 604     _FIter1
 605     find_first_of(_FIter1, _FIter1, _FIter2, _FIter2);
 606
 607   template<typename _FIter1, typename _FIter2, typename _BinaryPredicate>
 608     _FIter1
 609     find_first_of(_FIter1, _FIter1, _FIter2, _FIter2, _BinaryPredicate);
 610
 611   template<typename _IIter, typename _Predicate>
 612     _IIter
 613     find_if(_IIter, _IIter, _Predicate);
 614
 615   template<typename _IIter, typename _Funct>
 616     _Funct
 617     for_each(_IIter, _IIter, _Funct);
 618
 619   template<typename _FIter, typename _Generator>
 620     void
 621     generate(_FIter, _FIter, _Generator);
 622
 623 /*
 624   XXX NB: return type different from ISO C++.
 625   template<typename _OIter, typename _Size, typename _Tp>
 626     void
 627     generate_n(_OIter, _Size, _Generator);
 628 */
 629
 630   template<typename _OIter, typename _Size, typename _Generator>
 631     _OIter
 632     generate_n(_OIter, _Size, _Generator);
 633
 634   template<typename _IIter1, typename _IIter2>
 635     bool
 636     lexicographical_compare(_IIter1, _IIter1, _IIter2, _IIter2);
 637
 638   template<typename _IIter1, typename _IIter2, typename _Compare>
 639     bool
 640     lexicographical_compare(_IIter1, _IIter1, _IIter2, _IIter2, _Compare);
 641
 642   template<typename _FIter>
 643     _FIter
 644     max_element(_FIter, _FIter);
 645
 646   template<typename _FIter, typename _Compare>
 647     _FIter
 648     max_element(_FIter, _FIter, _Compare);
 649
 650   template<typename _IIter1, typename _IIter2, typename _OIter>
 651     _OIter
 652     merge(_IIter1, _IIter1, _IIter2, _IIter2, _OIter);
 653
 654   template<typename _IIter1, typename _IIter2, typename _OIter,
 655            typename _Compare>
 656     _OIter
 657     merge(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, _Compare);
 658
 659   template<typename _FIter>
 660     _FIter
 661     min_element(_FIter, _FIter);
 662
 663   template<typename _FIter, typename _Compare>
 664     _FIter
 665     min_element(_FIter, _FIter, _Compare);
 666
 667   template<typename _IIter1, typename _IIter2>
 668     pair<_IIter1, _IIter2>
 669     mismatch(_IIter1, _IIter1, _IIter2);
 670
 671   template<typename _IIter1, typename _IIter2, typename _BinaryPredicate>
 672     pair<_IIter1, _IIter2>
 673     mismatch(_IIter1, _IIter1, _IIter2, _BinaryPredicate);
 674
 675   template<typename _RAIter>
 676     void
 677     nth_element(_RAIter, _RAIter, _RAIter);
 678
 679   template<typename _RAIter, typename _Compare>
 680     void
 681     nth_element(_RAIter, _RAIter, _RAIter, _Compare);
 682
 683   template<typename _RAIter>
 684     void
 685     partial_sort(_RAIter, _RAIter, _RAIter);
 686
 687   template<typename _RAIter, typename _Compare>
 688     void
 689     partial_sort(_RAIter, _RAIter, _RAIter, _Compare);
 690
 691   template<typename _BIter, typename _Predicate>
 692     _BIter
 693     partition(_BIter, _BIter, _Predicate);
 694
 695   template<typename _RAIter>
 696     void
 697     random_shuffle(_RAIter, _RAIter);
 698
 699   template<typename _RAIter, typename _Generator>
 700     void
 701     random_shuffle(_RAIter, _RAIter, _Generator&);
 702
 703   template<typename _FIter, typename _Tp>
 704     void
 705     replace(_FIter, _FIter, const _Tp&, const _Tp&);
 706
 707   template<typename _FIter, typename _Predicate, typename _Tp>
 708     void
 709     replace_if(_FIter, _FIter, _Predicate, const _Tp&);
 710
 711   template<typename _FIter1, typename _FIter2>
 712     _FIter1
 713     search(_FIter1, _FIter1, _FIter2, _FIter2);
 714
 715   template<typename _FIter1, typename _FIter2, typename _BinaryPredicate>
 716     _FIter1
 717     search(_FIter1, _FIter1, _FIter2, _FIter2, _BinaryPredicate);
 718
 719   template<typename _FIter, typename _Size, typename _Tp>
 720     _FIter
 721     search_n(_FIter, _FIter, _Size, const _Tp&);
 722
 723   template<typename _FIter, typename _Size, typename _Tp,
 724            typename _BinaryPredicate>
 725     _FIter
 726     search_n(_FIter, _FIter, _Size, const _Tp&, _BinaryPredicate);
 727
 728   template<typename _IIter1, typename _IIter2, typename _OIter>
 729     _OIter
 730     set_difference(_IIter1, _IIter1, _IIter2, _IIter2, _OIter);
 731
 732   template<typename _IIter1, typename _IIter2, typename _OIter,
 733            typename _Compare>
 734     _OIter
 735     set_difference(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, _Compare);
 736
 737   template<typename _IIter1, typename _IIter2, typename _OIter>
 738     _OIter
 739     set_intersection(_IIter1, _IIter1, _IIter2, _IIter2, _OIter);
 740
 741   template<typename _IIter1, typename _IIter2, typename _OIter,
 742            typename _Compare>
 743     _OIter
 744     set_intersection(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, _Compare);
 745
 746   template<typename _IIter1, typename _IIter2, typename _OIter>
 747     _OIter
 748     set_symmetric_difference(_IIter1, _IIter1, _IIter2, _IIter2, _OIter);
 749
 750   template<typename _IIter1, typename _IIter2, typename _OIter,
 751            typename _Compare>
 752     _OIter
 753     set_symmetric_difference(_IIter1, _IIter1, _IIter2, _IIter2,
 754                              _OIter, _Compare);
 755
 756   template<typename _IIter1, typename _IIter2, typename _OIter>
 757     _OIter
 758     set_union(_IIter1, _IIter1, _IIter2, _IIter2, _OIter);
 759
 760   template<typename _IIter1, typename _IIter2, typename _OIter,
 761            typename _Compare>
 762     _OIter
 763     set_union(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, _Compare);
 764
 765   template<typename _RAIter>
 766     void
 767     sort(_RAIter, _RAIter);
 768
 769   template<typename _RAIter, typename _Compare>
 770     void
 771     sort(_RAIter, _RAIter, _Compare);
 772
 773   template<typename _RAIter>
 774     void
 775     stable_sort(_RAIter, _RAIter);
 776
 777   template<typename _RAIter, typename _Compare>
 778     void
 779     stable_sort(_RAIter, _RAIter, _Compare);
 780
 781   template<typename _IIter, typename _OIter, typename _UnaryOperation>
 782     _OIter
 783     transform(_IIter, _IIter, _OIter, _UnaryOperation);
 784
 785   template<typename _IIter1, typename _IIter2, typename _OIter,
 786            typename _BinaryOperation>
 787     _OIter
 788     transform(_IIter1, _IIter1, _IIter2, _OIter, _BinaryOperation);
 789
 790   template<typename _IIter, typename _OIter>
 791     _OIter
 792     unique_copy(_IIter, _IIter, _OIter);
 793
 794   template<typename _IIter, typename _OIter, typename _BinaryPredicate>
 795     _OIter
 796     unique_copy(_IIter, _IIter, _OIter, _BinaryPredicate);
 797
 798 _GLIBCXX_END_NESTED_NAMESPACE
 799
 800 #ifdef _GLIBCXX_NAMESPACE_ASSOCIATION_PARALLEL
 801 # include <parallel/algorithmfwd.h>
 802 #endif
 803
 804 #endif
 805