l4/pkg/libstdc++-v3/contrib/libstdc++-v3-4.3.3/include/bits/algorithmfwd.h

   1 // <algorithm> declarations  -*- C++ -*-
   2
   3 // Copyright (C) 2007 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 2, 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 // You should have received a copy of the GNU General Public License along
  17 // with this library; see the file COPYING.  If not, write to the Free
  18 // Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
  19 // USA.
  20
  21 /** @file bits/algorithmfwd.h
  22  *  This is an internal header file, included by other library headers.
  23  *  You should not attempt to use it directly.
  24  */
  25
  26 /*
  27   adjacent_find
  28   binary_search
  29   copy
  30   copy_backward
  31   count
  32   count_if
  33   equal
  34   equal_range
  35   fill
  36   fill_n
  37   find
  38   find_end
  39   find_first_of
  40   find_if
  41   for_each
  42   generate
  43   generate_n
  44   includes
  45   inplace_merge
  46   is_heap (C++0x)
  47   is_heap_until (C++0x)
  48   is_sorted (C++0x)
  49   is_sorted_until (C++0x)
  50   iter_swap
  51   lexicographical_compare
  52   lower_bound
  53   make_heap
  54   max
  55   max_element
  56   merge
  57   min
  58   min_element
  59   minmax (C++0x)
  60   minmax_element (C++0x)
  61   mismatch
  62   next_permutation
  63   nth_element
  64   partial_sort
  65   partial_sort_copy
  66   partition
  67   pop_heap
  68   prev_permutation
  69   push_heap
  70   random_shuffle
  71   remove
  72   remove_copy
  73   remove_copy_if
  74   remove_if
  75   replace
  76   replace_copy
  77   replace_copy_if
  78   replace_if
  79   reverse
  80   reverse_copy
  81   rotate
  82   rotate_copy
  83   search
  84   search_n
  85   set_difference
  86   set_intersection
  87   set_symmetric_difference
  88   set_union
  89   sort
  90   sort_heap
  91   stable_partition
  92   stable_sort
  93   swap
  94   swap_ranges
  95   transform
  96   unique
  97   unique_copy
  98   upper_bound
  99 */
 100
 101 #ifndef _GLIBCXX_ALGORITHMFWD_H
 102 #define _GLIBCXX_ALGORITHMFWD_H 1
 103
 104 #pragma GCC system_header
 105
 106 #include <bits/c++config.h>
 107 #include <bits/stl_pair.h>
 108 #include <bits/stl_iterator_base_types.h>
 109
 110 _GLIBCXX_BEGIN_NAMESPACE(std)
 111
 112   // adjacent_find
 113
 114   template<typename _FIter, typename _Tp>
 115     bool
 116     binary_search(_FIter, _FIter, const _Tp&);
 117
 118   template<typename _FIter, typename _Tp, typename _Compare>
 119     bool
 120     binary_search(_FIter, _FIter, const _Tp&, _Compare);
 121
 122   template<typename _IIter, typename _OIter>
 123     _OIter
 124     copy(_IIter, _IIter, _OIter);
 125
 126   template<typename _BIter1, typename _BIter2>
 127     _BIter2
 128     copy_backward(_BIter1, _BIter1, _BIter2);
 129
 130   // count
 131   // count_if
 132
 133   template<typename _FIter, typename _Tp>
 134     pair<_FIter, _FIter>
 135     equal_range(_FIter, _FIter, const _Tp&);
 136
 137   template<typename _FIter, typename _Tp, typename _Compare>
 138     pair<_FIter, _FIter>
 139     equal_range(_FIter, _FIter, const _Tp&, _Compare);
 140
 141   template<typename _FIter, typename _Tp>
 142     void
 143     fill(_FIter, _FIter, const _Tp&);
 144
 145 /*
 146   XXX NB: return type different from ISO C++.
 147   template<typename _OIter, typename _Size, typename _Tp>
 148     void
 149     fill_n(_OIter, _Size, const _Tp&);
 150 */
 151
 152   template<typename _OIter, typename _Size, typename _Tp>
 153     _OIter
 154     fill_n(_OIter, _Size, const _Tp&);
 155
 156   // find
 157
 158   template<typename _FIter1, typename _FIter2>
 159     _FIter1
 160     find_end(_FIter1, _FIter1, _FIter2, _FIter2);
 161
 162   template<typename _FIter1, typename _FIter2, typename _BinaryPredicate>
 163     _FIter1
 164     find_end(_FIter1, _FIter1, _FIter2, _FIter2, _BinaryPredicate);
 165
 166   // find_first_of
 167   // find_if
 168   // for_each
 169   // generate
 170   // generate_n
 171
 172   template<typename _IIter1, typename _IIter2>
 173     bool
 174     includes(_IIter1, _IIter1, _IIter2, _IIter2);
 175
 176   template<typename _IIter1, typename _IIter2, typename _Compare>
 177     bool
 178     includes(_IIter1, _IIter1, _IIter2, _IIter2, _Compare);
 179
 180   template<typename _BIter>
 181     void
 182     inplace_merge(_BIter, _BIter, _BIter);
 183
 184   template<typename _BIter, typename _Compare>
 185     void
 186     inplace_merge(_BIter, _BIter, _BIter, _Compare);
 187
 188 #ifdef __GXX_EXPERIMENTAL_CXX0X__
 189   template<typename _RAIter>
 190     bool
 191     is_heap(_RAIter, _RAIter);
 192
 193   template<typename _RAIter, typename _Compare>
 194     bool
 195     is_heap(_RAIter, _RAIter, _Compare);
 196
 197   template<typename _RAIter>
 198     _RAIter
 199     is_heap_until(_RAIter, _RAIter);
 200
 201   template<typename _RAIter, typename _Compare>
 202     _RAIter
 203     is_heap_until(_RAIter, _RAIter, _Compare);
 204
 205   template<typename _FIter>
 206     bool
 207     is_sorted(_FIter, _FIter);
 208
 209   template<typename _FIter, typename _Compare>
 210     bool
 211     is_sorted(_FIter, _FIter, _Compare);
 212
 213   template<typename _FIter>
 214     _FIter
 215     is_sorted_until(_FIter, _FIter);
 216
 217   template<typename _FIter, typename _Compare>
 218     _FIter
 219     is_sorted_until(_FIter, _FIter, _Compare);
 220 #endif
 221
 222   template<typename _FIter1, typename _FIter2>
 223     void
 224     iter_swap(_FIter1, _FIter2);
 225
 226   template<typename _FIter, typename _Tp>
 227     _FIter
 228     lower_bound(_FIter, _FIter, const _Tp&);
 229
 230   template<typename _FIter, typename _Tp, typename _Compare>
 231     _FIter
 232     lower_bound(_FIter, _FIter, const _Tp&, _Compare);
 233
 234   template<typename _RAIter>
 235     void
 236     make_heap(_RAIter, _RAIter);
 237
 238   template<typename _RAIter, typename _Compare>
 239     void
 240     make_heap(_RAIter, _RAIter, _Compare);
 241
 242   template<typename _Tp>
 243     const _Tp&
 244     max(const _Tp&, const _Tp&);
 245
 246   template<typename _Tp, typename _Compare>
 247     const _Tp&
 248     max(const _Tp&, const _Tp&, _Compare);
 249
 250   // max_element
 251   // merge
 252
 253   template<typename _Tp>
 254     const _Tp&
 255     min(const _Tp&, const _Tp&);
 256
 257   template<typename _Tp, typename _Compare>
 258     const _Tp&
 259     min(const _Tp&, const _Tp&, _Compare);
 260
 261   // min_element
 262
 263 #ifdef __GXX_EXPERIMENTAL_CXX0X__
 264   template<typename _Tp>
 265     pair<const _Tp&, const _Tp&>
 266     minmax(const _Tp&, const _Tp&);
 267
 268   template<typename _Tp, typename _Compare>
 269     pair<const _Tp&, const _Tp&>
 270     minmax(const _Tp&, const _Tp&, _Compare);
 271
 272   template<typename _FIter>
 273     pair<_FIter, _FIter>
 274     minmax_element(_FIter, _FIter);
 275
 276   template<typename _FIter, typename _Compare>
 277     pair<_FIter, _FIter>
 278     minmax_element(_FIter, _FIter, _Compare);
 279 #endif
 280
 281   // mismatch
 282
 283   template<typename _BIter>
 284     bool
 285     next_permutation(_BIter, _BIter);
 286
 287   template<typename _BIter, typename _Compare>
 288     bool
 289     next_permutation(_BIter, _BIter, _Compare);
 290
 291   // nth_element
 292   // partial_sort
 293
 294   template<typename _IIter, typename _RAIter>
 295     _RAIter
 296     partial_sort_copy(_IIter, _IIter, _RAIter, _RAIter);
 297
 298   template<typename _IIter, typename _RAIter, typename _Compare>
 299     _RAIter
 300     partial_sort_copy(_IIter, _IIter, _RAIter, _RAIter, _Compare);
 301
 302   template<typename _RAIter>
 303     void
 304     pop_heap(_RAIter, _RAIter);
 305
 306   template<typename _RAIter, typename _Compare>
 307     void
 308     pop_heap(_RAIter, _RAIter, _Compare);
 309
 310   template<typename _BIter>
 311     bool
 312     prev_permutation(_BIter, _BIter);
 313
 314   template<typename _BIter, typename _Compare>
 315     bool
 316     prev_permutation(_BIter, _BIter, _Compare);
 317
 318   template<typename _RAIter>
 319     void
 320     push_heap(_RAIter, _RAIter);
 321
 322   template<typename _RAIter, typename _Compare>
 323     void
 324     push_heap(_RAIter, _RAIter, _Compare);
 325
 326   // random_shuffle
 327
 328   template<typename _FIter, typename _Tp>
 329     _FIter
 330     remove(_FIter, _FIter, const _Tp&);
 331
 332   template<typename _FIter, typename _Predicate>
 333     _FIter
 334     remove_if(_FIter, _FIter, _Predicate);
 335
 336   template<typename _IIter, typename _OIter, typename _Tp>
 337     _OIter
 338     remove_copy(_IIter, _IIter, _OIter, const _Tp&);
 339
 340   template<typename _IIter, typename _OIter, typename _Predicate>
 341     _OIter
 342     remove_copy_if(_IIter, _IIter, _OIter, _Predicate);
 343
 344   // replace
 345
 346   template<typename _IIter, typename _OIter, typename _Tp>
 347     _OIter
 348     replace_copy(_IIter, _IIter, _OIter, const _Tp&, const _Tp&);
 349
 350   template<typename _Iter, typename _OIter, typename _Predicate, typename _Tp>
 351     _OIter
 352     replace_copy_if(_Iter, _Iter, _OIter, _Predicate, const _Tp&);
 353
 354   // replace_if
 355
 356   template<typename _BIter>
 357     void
 358     reverse(_BIter, _BIter);
 359
 360   template<typename _BIter, typename _OIter>
 361     _OIter
 362     reverse_copy(_BIter, _BIter, _OIter);
 363
 364   template<typename _FIter>
 365     void
 366     rotate(_FIter, _FIter, _FIter);
 367
 368   template<typename _FIter, typename _OIter>
 369     _OIter
 370     rotate_copy(_FIter, _FIter, _FIter, _OIter);
 371
 372   // search
 373   // search_n
 374   // set_difference
 375   // set_intersection
 376   // set_symmetric_difference
 377   // set_union
 378
 379   template<typename _RAIter>
 380     void
 381     sort_heap(_RAIter, _RAIter);
 382
 383   template<typename _RAIter, typename _Compare>
 384     void
 385     sort_heap(_RAIter, _RAIter, _Compare);
 386
 387   template<typename _BIter, typename _Predicate>
 388     _BIter
 389     stable_partition(_BIter, _BIter, _Predicate);
 390
 391   template<typename _Tp>
 392     void
 393     swap(_Tp&, _Tp&);
 394
 395   template<typename _FIter1, typename _FIter2>
 396     _FIter2
 397     swap_ranges(_FIter1, _FIter1, _FIter2);
 398
 399   // transform
 400
 401   template<typename _FIter>
 402     _FIter
 403     unique(_FIter, _FIter);
 404
 405   template<typename _FIter, typename _BinaryPredicate>
 406     _FIter
 407     unique(_FIter, _FIter, _BinaryPredicate);
 408
 409   // unique_copy
 410
 411   template<typename _FIter, typename _Tp>
 412     _FIter
 413     upper_bound(_FIter, _FIter, const _Tp&);
 414
 415   template<typename _FIter, typename _Tp, typename _Compare>
 416     _FIter
 417     upper_bound(_FIter, _FIter, const _Tp&, _Compare);
 418
 419 _GLIBCXX_END_NAMESPACE
 420
 421 _GLIBCXX_BEGIN_NESTED_NAMESPACE(std, _GLIBCXX_STD_P)
 422
 423   template<typename _FIter>
 424     _FIter
 425     adjacent_find(_FIter, _FIter);
 426
 427   template<typename _FIter, typename _BinaryPredicate>
 428     _FIter
 429     adjacent_find(_FIter, _FIter, _BinaryPredicate);
 430
 431   template<typename _IIter, typename _Tp>
 432     typename iterator_traits<_IIter>::difference_type
 433     count(_IIter, _IIter, const _Tp&);
 434
 435   template<typename _IIter, typename _Predicate>
 436     typename iterator_traits<_IIter>::difference_type
 437     count_if(_IIter, _IIter, _Predicate);
 438
 439   template<typename _IIter1, typename _IIter2>
 440     bool
 441     equal(_IIter1, _IIter1, _IIter2);
 442
 443   template<typename _IIter1, typename _IIter2, typename _BinaryPredicate>
 444     bool
 445     equal(_IIter1, _IIter1, _IIter2, _BinaryPredicate);
 446
 447   template<typename _IIter, typename _Tp>
 448     _IIter
 449     find(_IIter, _IIter, const _Tp&);
 450
 451   template<typename _FIter1, typename _FIter2>
 452     _FIter1
 453     find_first_of(_FIter1, _FIter1, _FIter2, _FIter2);
 454
 455   template<typename _FIter1, typename _FIter2, typename _BinaryPredicate>
 456     _FIter1
 457     find_first_of(_FIter1, _FIter1, _FIter2, _FIter2, _BinaryPredicate);
 458
 459   template<typename _IIter, typename _Predicate>
 460     _IIter
 461     find_if(_IIter, _IIter, _Predicate);
 462
 463   template<typename _IIter, typename _Funct>
 464     _Funct
 465     for_each(_IIter, _IIter, _Funct);
 466
 467   template<typename _FIter, typename _Generator>
 468     void
 469     generate(_FIter, _FIter, _Generator);
 470
 471 /*
 472   XXX NB: return type different from ISO C++.
 473   template<typename _OIter, typename _Size, typename _Tp>
 474     void
 475     generate_n(_OIter, _Size, _Generator);
 476 */
 477
 478   template<typename _OIter, typename _Size, typename _Generator>
 479     _OIter
 480     generate_n(_OIter, _Size, _Generator);
 481
 482   template<typename _IIter1, typename _IIter2>
 483     bool
 484     lexicographical_compare(_IIter1, _IIter1, _IIter2, _IIter2);
 485
 486   template<typename _IIter1, typename _IIter2, typename _Compare>
 487     bool
 488     lexicographical_compare(_IIter1, _IIter1, _IIter2, _IIter2, _Compare);
 489
 490   template<typename _FIter>
 491     _FIter
 492     max_element(_FIter, _FIter);
 493
 494   template<typename _FIter, typename _Compare>
 495     _FIter
 496     max_element(_FIter, _FIter, _Compare);
 497
 498   template<typename _IIter1, typename _IIter2, typename _OIter>
 499     _OIter
 500     merge(_IIter1, _IIter1, _IIter2, _IIter2, _OIter);
 501
 502   template<typename _IIter1, typename _IIter2, typename _OIter,
 503            typename _Compare>
 504     _OIter
 505     merge(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, _Compare);
 506
 507   template<typename _FIter>
 508     _FIter
 509     min_element(_FIter, _FIter);
 510
 511   template<typename _FIter, typename _Compare>
 512     _FIter
 513     min_element(_FIter, _FIter, _Compare);
 514
 515   template<typename _IIter1, typename _IIter2>
 516     pair<_IIter1, _IIter2>
 517     mismatch(_IIter1, _IIter1, _IIter2);
 518
 519   template<typename _IIter1, typename _IIter2, typename _BinaryPredicate>
 520     pair<_IIter1, _IIter2>
 521     mismatch(_IIter1, _IIter1, _IIter2, _BinaryPredicate);
 522
 523   template<typename _RAIter>
 524     void
 525     nth_element(_RAIter, _RAIter, _RAIter);
 526
 527   template<typename _RAIter, typename _Compare>
 528     void
 529     nth_element(_RAIter, _RAIter, _RAIter, _Compare);
 530
 531   template<typename _RAIter>
 532     void
 533     partial_sort(_RAIter, _RAIter, _RAIter);
 534
 535   template<typename _RAIter, typename _Compare>
 536     void
 537     partial_sort(_RAIter, _RAIter, _RAIter, _Compare);
 538
 539   template<typename _BIter, typename _Predicate>
 540     _BIter
 541     partition(_BIter, _BIter, _Predicate);
 542
 543   template<typename _RAIter>
 544     void
 545     random_shuffle(_RAIter, _RAIter);
 546
 547   template<typename _RAIter, typename _Generator>
 548     void
 549     random_shuffle(_RAIter, _RAIter, _Generator&);
 550
 551   template<typename _FIter, typename _Tp>
 552     void
 553     replace(_FIter, _FIter, const _Tp&, const _Tp&);
 554
 555   template<typename _FIter, typename _Predicate, typename _Tp>
 556     void
 557     replace_if(_FIter, _FIter, _Predicate, const _Tp&);
 558
 559   template<typename _FIter1, typename _FIter2>
 560     _FIter1
 561     search(_FIter1, _FIter1, _FIter2, _FIter2);
 562
 563   template<typename _FIter1, typename _FIter2, typename _BinaryPredicate>
 564     _FIter1
 565     search(_FIter1, _FIter1, _FIter2, _FIter2, _BinaryPredicate);
 566
 567   template<typename _FIter, typename _Size, typename _Tp>
 568     _FIter
 569     search_n(_FIter, _FIter, _Size, const _Tp&);
 570
 571   template<typename _FIter, typename _Size, typename _Tp,
 572            typename _BinaryPredicate>
 573     _FIter
 574     search_n(_FIter, _FIter, _Size, const _Tp&, _BinaryPredicate);
 575
 576   template<typename _IIter1, typename _IIter2, typename _OIter>
 577     _OIter
 578     set_difference(_IIter1, _IIter1, _IIter2, _IIter2, _OIter);
 579
 580   template<typename _IIter1, typename _IIter2, typename _OIter,
 581            typename _Compare>
 582     _OIter
 583     set_difference(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, _Compare);
 584
 585   template<typename _IIter1, typename _IIter2, typename _OIter>
 586     _OIter
 587     set_intersection(_IIter1, _IIter1, _IIter2, _IIter2, _OIter);
 588
 589   template<typename _IIter1, typename _IIter2, typename _OIter,
 590            typename _Compare>
 591     _OIter
 592     set_intersection(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, _Compare);
 593
 594   template<typename _IIter1, typename _IIter2, typename _OIter>
 595     _OIter
 596     set_symmetric_difference(_IIter1, _IIter1, _IIter2, _IIter2, _OIter);
 597
 598   template<typename _IIter1, typename _IIter2, typename _OIter,
 599            typename _Compare>
 600     _OIter
 601     set_symmetric_difference(_IIter1, _IIter1, _IIter2, _IIter2,
 602                              _OIter, _Compare);
 603
 604   template<typename _IIter1, typename _IIter2, typename _OIter>
 605     _OIter
 606     set_union(_IIter1, _IIter1, _IIter2, _IIter2, _OIter);
 607
 608   template<typename _IIter1, typename _IIter2, typename _OIter,
 609            typename _Compare>
 610     _OIter
 611     set_union(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, _Compare);
 612
 613   template<typename _RAIter>
 614     void
 615     sort(_RAIter, _RAIter);
 616
 617   template<typename _RAIter, typename _Compare>
 618     void
 619     sort(_RAIter, _RAIter, _Compare);
 620
 621   template<typename _RAIter>
 622     void
 623     stable_sort(_RAIter, _RAIter);
 624
 625   template<typename _RAIter, typename _Compare>
 626     void
 627     stable_sort(_RAIter, _RAIter, _Compare);
 628
 629   template<typename _IIter, typename _OIter, typename _UnaryOperation>
 630     _OIter
 631     transform(_IIter, _IIter, _OIter, _UnaryOperation);
 632
 633   template<typename _IIter1, typename _IIter2, typename _OIter,
 634            typename _BinaryOperation>
 635     _OIter
 636     transform(_IIter1, _IIter1, _IIter2, _OIter, _BinaryOperation);
 637
 638   template<typename _IIter, typename _OIter>
 639     _OIter
 640     unique_copy(_IIter, _IIter, _OIter);
 641
 642   template<typename _IIter, typename _OIter, typename _BinaryPredicate>
 643     _OIter
 644     unique_copy(_IIter, _IIter, _OIter, _BinaryPredicate);
 645
 646 _GLIBCXX_END_NESTED_NAMESPACE
 647
 648 #ifdef _GLIBCXX_NAMESPACE_ASSOCIATION_PARALLEL
 649 # include <parallel/algorithmfwd.h>
 650 #endif
 651
 652 #endif
 653