libstdc++-v3/testsuite/25_algorithms/headers/algorithm/synopsis.cc

   1 // { dg-do compile }
   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 #include <algorithm>
  22
  23 namespace std {
  24   // 25.1, non-modifying sequence operations:
  25   template<class InputIterator, class Function>
  26     Function for_each(InputIterator first, InputIterator last, Function f);
  27   template<class InputIterator, class T>
  28     InputIterator find(InputIterator first, InputIterator last,
  29                                const T& value);
  30   template<class InputIterator, class Predicate>
  31     InputIterator find_if(InputIterator first, InputIterator last,
  32                                    Predicate pred);
  33   template<class ForwardIterator1, class ForwardIterator2>
  34     ForwardIterator1
  35        find_end(ForwardIterator1 first1, ForwardIterator1 last1,
  36                     ForwardIterator2 first2, ForwardIterator2 last2);
  37   template<class ForwardIterator1, class ForwardIterator2,
  38                class BinaryPredicate>
  39     ForwardIterator1
  40        find_end(ForwardIterator1 first1, ForwardIterator1 last1,
  41                     ForwardIterator2 first2, ForwardIterator2 last2,
  42                     BinaryPredicate pred);
  43   template<class ForwardIterator1, class ForwardIterator2>
  44     ForwardIterator1
  45        find_first_of(ForwardIterator1 first1, ForwardIterator1 last1,
  46                            ForwardIterator2 first2, ForwardIterator2 last2);
  47   template<class ForwardIterator1, class ForwardIterator2,
  48                class BinaryPredicate>
  49     ForwardIterator1
  50        find_first_of(ForwardIterator1 first1, ForwardIterator1 last1,
  51                     ForwardIterator2 first2, ForwardIterator2 last2,
  52                     BinaryPredicate pred);
  53
  54 template<class ForwardIterator>
  55   ForwardIterator adjacent_find(ForwardIterator first,
  56                                 ForwardIterator last);
  57
  58 template<class ForwardIterator, class BinaryPredicate>
  59   ForwardIterator adjacent_find(ForwardIterator first,
  60       ForwardIterator last, BinaryPredicate pred);
  61
  62 template<class InputIterator, class T>
  63   typename iterator_traits<InputIterator>::difference_type
  64     count(InputIterator first, InputIterator last, const T& value);
  65
  66 template<class InputIterator, class Predicate>
  67   typename iterator_traits<InputIterator>::difference_type
  68     count_if(InputIterator first, InputIterator last, Predicate pred);
  69 template<class InputIterator1, class InputIterator2>
  70   pair<InputIterator1, InputIterator2>
  71     mismatch(InputIterator1 first1, InputIterator1 last1,
  72              InputIterator2 first2);
  73 template
  74  <class InputIterator1, class InputIterator2, class BinaryPredicate>
  75   pair<InputIterator1, InputIterator2>
  76     mismatch(InputIterator1 first1, InputIterator1 last1,
  77       InputIterator2 first2, BinaryPredicate pred);
  78 template<class InputIterator1, class InputIterator2>
  79   bool equal(InputIterator1 first1, InputIterator1 last1,
  80              InputIterator2 first2);
  81 template
  82  <class InputIterator1, class InputIterator2, class BinaryPredicate>
  83   bool equal(InputIterator1 first1, InputIterator1 last1,
  84              InputIterator2 first2, BinaryPredicate pred);
  85
  86 template<class ForwardIterator1, class ForwardIterator2>
  87   ForwardIterator1 search
  88     (ForwardIterator1 first1, ForwardIterator1 last1,
  89      ForwardIterator2 first2, ForwardIterator2 last2);
  90
  91 template<class ForwardIterator1, class ForwardIterator2,
  92          class BinaryPredicate>
  93   ForwardIterator1 search
  94     (ForwardIterator1 first1, ForwardIterator1 last1,
  95      ForwardIterator2 first2, ForwardIterator2 last2,
  96                           BinaryPredicate pred);
  97
  98 template<class ForwardIterator, class Size, class T>
  99   ForwardIterator search_n(ForwardIterator first, ForwardIterator last,
 100                           Size count, const T& value);
 101
 102 template <class ForwardIterator, class Size, class T, class BinaryPredicate>
 103   ForwardIterator search_n(ForwardIterator first, ForwardIterator last,
 104                           Size count, const T& value,
 105                           BinaryPredicate pred);
 106
 107 // 25.2, modifying sequence operations:
 108 // 25.2.1, copy:
 109 template<class InputIterator, class OutputIterator>
 110   OutputIterator copy(InputIterator first, InputIterator last,
 111                                OutputIterator result);
 112 template<class BidirectionalIterator1, class BidirectionalIterator2>
 113   BidirectionalIterator2
 114      copy_backward
 115          (BidirectionalIterator1 first, BidirectionalIterator1 last,
 116           BidirectionalIterator2 result);
 117 // 25.2.2, swap:
 118 template<class T> void swap(T& a, T& b);
 119 template<class ForwardIterator1, class ForwardIterator2>
 120   ForwardIterator2 swap_ranges(ForwardIterator1 first1,
 121          ForwardIterator1 last1, ForwardIterator2 first2);
 122 template<class ForwardIterator1, class ForwardIterator2>
 123   void iter_swap(ForwardIterator1 a, ForwardIterator2 b);
 124 template<class InputIterator, class OutputIterator, class UnaryOperation>
 125   OutputIterator transform(InputIterator first, InputIterator last,
 126                                       OutputIterator result, UnaryOperation op);
 127 template<class InputIterator1, class InputIterator2, class OutputIterator,
 128              class BinaryOperation>
 129   OutputIterator transform(InputIterator1 first1, InputIterator1 last1,
 130                                       InputIterator2 first2, OutputIterator result,
 131                                       BinaryOperation binary_op);
 132 template<class ForwardIterator, class T>
 133   void replace(ForwardIterator first, ForwardIterator last,
 134                      const T& old_value, const T& new_value);
 135 template<class ForwardIterator, class Predicate, class T>
 136   void replace_if(ForwardIterator first, ForwardIterator last,
 137                          Predicate pred, const T& new_value);
 138 template<class InputIterator, class OutputIterator, class T>
 139   OutputIterator replace_copy(InputIterator first, InputIterator last,
 140                                          OutputIterator result,
 141                                          const T& old_value, const T& new_value);
 142 template<class Iterator, class OutputIterator, class Predicate, class T>
 143   OutputIterator replace_copy_if(Iterator first, Iterator last,
 144                                             OutputIterator result,
 145                                             Predicate pred, const T& new_value);
 146 template<class ForwardIterator, class T>
 147   void fill(ForwardIterator first, ForwardIterator last, const T& value);
 148 template<class OutputIterator, class Size, class T>
 149   void fill_n(OutputIterator first, Size n, const T& value);
 150 template<class ForwardIterator, class Generator>
 151   void generate(ForwardIterator first, ForwardIterator last,
 152                        Generator gen);
 153 template<class OutputIterator, class Size, class Generator>
 154   void generate_n(OutputIterator first, Size n, Generator gen);
 155
 156 template<class ForwardIterator, class T>
 157   ForwardIterator remove(ForwardIterator first, ForwardIterator last,
 158                                 const T& value);
 159 template<class ForwardIterator, class Predicate>
 160   ForwardIterator remove_if(ForwardIterator first, ForwardIterator last,
 161                                    Predicate pred);
 162 template<class InputIterator, class OutputIterator, class T>
 163   OutputIterator remove_copy(InputIterator first, InputIterator last,
 164                                     OutputIterator result, const T& value);
 165 template<class InputIterator, class OutputIterator, class Predicate>
 166   OutputIterator remove_copy_if(InputIterator first, InputIterator last,
 167                                        OutputIterator result, Predicate pred);
 168 template<class ForwardIterator>
 169   ForwardIterator unique(ForwardIterator first, ForwardIterator last);
 170 template<class ForwardIterator, class BinaryPredicate>
 171   ForwardIterator unique(ForwardIterator first, ForwardIterator last,
 172                                 BinaryPredicate pred);
 173 template<class InputIterator, class OutputIterator>
 174   OutputIterator unique_copy(InputIterator first, InputIterator last,
 175                                     OutputIterator result);
 176 template<class InputIterator, class OutputIterator, class BinaryPredicate>
 177   OutputIterator unique_copy(InputIterator first, InputIterator last,
 178                                     OutputIterator result, BinaryPredicate pred);
 179 template<class BidirectionalIterator>
 180   void reverse(BidirectionalIterator first, BidirectionalIterator last);
 181 template<class BidirectionalIterator, class OutputIterator>
 182   OutputIterator reverse_copy(BidirectionalIterator first,
 183                                      BidirectionalIterator last,
 184                                      OutputIterator result);
 185 template<class ForwardIterator>
 186   void rotate(ForwardIterator first, ForwardIterator middle,
 187                      ForwardIterator last);
 188 template<class ForwardIterator, class OutputIterator>
 189   OutputIterator rotate_copy
 190      (ForwardIterator first, ForwardIterator middle,
 191        ForwardIterator last, OutputIterator result);
 192 template<class RandomAccessIterator>
 193   void random_shuffle(RandomAccessIterator first,
 194                              RandomAccessIterator last);
 195 template<class RandomAccessIterator, class RandomNumberGenerator>
 196   void random_shuffle(RandomAccessIterator first,
 197                              RandomAccessIterator last,
 198                              RandomNumberGenerator& rand);
 199 // 25.2.12, partitions:
 200 template<class BidirectionalIterator, class Predicate>
 201   BidirectionalIterator partition(BidirectionalIterator first,
 202                                          BidirectionalIterator last,
 203                                          Predicate pred);
 204 template<class BidirectionalIterator, class Predicate>
 205   BidirectionalIterator stable_partition(BidirectionalIterator first,
 206                                                  BidirectionalIterator last,
 207                                                 Predicate pred);
 208 // 25.3, sorting and related operations:
 209 // 25.3.1, sorting:
 210 template<class RandomAccessIterator>
 211   void sort(RandomAccessIterator first, RandomAccessIterator last);
 212 template<class RandomAccessIterator, class Compare>
 213   void sort(RandomAccessIterator first, RandomAccessIterator last,
 214                   Compare comp);
 215 template<class RandomAccessIterator>
 216   void stable_sort(RandomAccessIterator first, RandomAccessIterator last);
 217 template<class RandomAccessIterator, class Compare>
 218   void stable_sort(RandomAccessIterator first, RandomAccessIterator last,
 219                             Compare comp);
 220 template<class RandomAccessIterator>
 221   void partial_sort(RandomAccessIterator first,
 222                               RandomAccessIterator middle,
 223                               RandomAccessIterator last);
 224 template<class RandomAccessIterator, class Compare>
 225   void partial_sort(RandomAccessIterator first,
 226                               RandomAccessIterator middle,
 227                               RandomAccessIterator last, Compare comp);
 228 template<class InputIterator, class RandomAccessIterator>
 229   RandomAccessIterator
 230      partial_sort_copy(InputIterator first, InputIterator last,
 231                                 RandomAccessIterator result_first,
 232                                 RandomAccessIterator result_last);
 233 template<class InputIterator, class RandomAccessIterator, class Compare>
 234   RandomAccessIterator
 235      partial_sort_copy(InputIterator first, InputIterator last,
 236                                 RandomAccessIterator result_first,
 237                                 RandomAccessIterator result_last,
 238                                 Compare comp);
 239 template<class RandomAccessIterator>
 240   void nth_element(RandomAccessIterator first, RandomAccessIterator nth,
 241                             RandomAccessIterator last);
 242 template<class RandomAccessIterator, class Compare>
 243   void nth_element(RandomAccessIterator first, RandomAccessIterator nth,
 244                             RandomAccessIterator last, Compare comp);
 245 // 25.3.3, binary search:
 246 template<class ForwardIterator, class T>
 247   ForwardIterator lower_bound(ForwardIterator first, ForwardIterator last,
 248                                          const T& value);
 249 template<class ForwardIterator, class T, class Compare>
 250   ForwardIterator lower_bound(ForwardIterator first, ForwardIterator last,
 251                                          const T& value, Compare comp);
 252 template<class ForwardIterator, class T>
 253   ForwardIterator upper_bound(ForwardIterator first, ForwardIterator last,
 254                                          const T& value);
 255 template<class ForwardIterator, class T, class Compare>
 256   ForwardIterator upper_bound(ForwardIterator first, ForwardIterator last,
 257                                          const T& value, Compare comp);
 258 template<class ForwardIterator, class T>
 259   pair<ForwardIterator, ForwardIterator>
 260      equal_range(ForwardIterator first, ForwardIterator last,
 261                         const T& value);
 262 template<class ForwardIterator, class T, class Compare>
 263   pair<ForwardIterator, ForwardIterator>
 264      equal_range(ForwardIterator first, ForwardIterator last,
 265                         const T& value, Compare comp);
 266 template<class ForwardIterator, class T>
 267   bool binary_search(ForwardIterator first, ForwardIterator last,
 268                              const T& value);
 269 template<class ForwardIterator, class T, class Compare>
 270   bool binary_search(ForwardIterator first, ForwardIterator last,
 271                              const T& value, Compare comp);
 272 // 25.3.4, merge:
 273 template<class InputIterator1, class InputIterator2, class OutputIterator>
 274   OutputIterator merge(InputIterator1 first1, InputIterator1 last1,
 275                                InputIterator2 first2, InputIterator2 last2,
 276                                OutputIterator result);
 277 template<class InputIterator1, class InputIterator2, class OutputIterator,
 278              class Compare>
 279   OutputIterator merge(InputIterator1 first1, InputIterator1 last1,
 280                                InputIterator2 first2, InputIterator2 last2,
 281                                OutputIterator result, Compare comp);
 282 template<class BidirectionalIterator>
 283   void inplace_merge(BidirectionalIterator first,
 284                              BidirectionalIterator middle,
 285                              BidirectionalIterator last);
 286 template<class BidirectionalIterator, class Compare>
 287   void inplace_merge(BidirectionalIterator first,
 288                              BidirectionalIterator middle,
 289                              BidirectionalIterator last, Compare comp);
 290 // 25.3.5, set operations:
 291 template<class InputIterator1, class InputIterator2>
 292   bool includes(InputIterator1 first1, InputIterator1 last1,
 293                         InputIterator2 first2, InputIterator2 last2);
 294 template<class InputIterator1, class InputIterator2, class Compare>
 295   bool includes
 296      (InputIterator1 first1, InputIterator1 last1,
 297        InputIterator2 first2, InputIterator2 last2, Compare comp);
 298 template<class InputIterator1, class InputIterator2, class OutputIterator>
 299   OutputIterator set_union(InputIterator1 first1, InputIterator1 last1,
 300                                    InputIterator2 first2, InputIterator2 last2,
 301                                    OutputIterator result);
 302 template<class InputIterator1, class InputIterator2, class OutputIterator,
 303              class Compare>
 304   OutputIterator set_union(InputIterator1 first1, InputIterator1 last1,
 305                                    InputIterator2 first2, InputIterator2 last2,
 306                                    OutputIterator result, Compare comp);
 307 template<class InputIterator1, class InputIterator2, class OutputIterator>
 308   OutputIterator set_intersection
 309         (InputIterator1 first1, InputIterator1 last1,
 310           InputIterator2 first2, InputIterator2 last2,
 311           OutputIterator result);
 312 template<class InputIterator1, class InputIterator2, class OutputIterator,
 313              class Compare>
 314   OutputIterator set_intersection
 315         (InputIterator1 first1, InputIterator1 last1,
 316           InputIterator2 first2, InputIterator2 last2,
 317           OutputIterator result, Compare comp);
 318 template<class InputIterator1, class InputIterator2, class OutputIterator>
 319   OutputIterator set_difference
 320         (InputIterator1 first1, InputIterator1 last1,
 321           InputIterator2 first2, InputIterator2 last2,
 322           OutputIterator result);
 323 template<class InputIterator1, class InputIterator2, class OutputIterator,
 324              class Compare>
 325   OutputIterator set_difference
 326         (InputIterator1 first1, InputIterator1 last1,
 327           InputIterator2 first2, InputIterator2 last2,
 328           OutputIterator result, Compare comp);
 329 template<class InputIterator1, class InputIterator2, class OutputIterator>
 330   OutputIterator
 331      set_symmetric_difference(InputIterator1 first1, InputIterator1 last1,
 332                                     InputIterator2 first2, InputIterator2 last2,
 333                                     OutputIterator result);
 334 template<class InputIterator1, class InputIterator2, class OutputIterator,
 335               class Compare>
 336   OutputIterator
 337      set_symmetric_difference(InputIterator1 first1, InputIterator1 last1,
 338                                     InputIterator2 first2, InputIterator2 last2,
 339                                     OutputIterator result, Compare comp);
 340 // 25.3.6, heap operations:
 341 template<class RandomAccessIterator>
 342   void push_heap(RandomAccessIterator first, RandomAccessIterator last);
 343 template<class RandomAccessIterator, class Compare>
 344   void push_heap(RandomAccessIterator first, RandomAccessIterator last,
 345                         Compare comp);
 346 template<class RandomAccessIterator>
 347   void pop_heap(RandomAccessIterator first, RandomAccessIterator last);
 348 template<class RandomAccessIterator, class Compare>
 349   void pop_heap(RandomAccessIterator first, RandomAccessIterator last,
 350                        Compare comp);
 351 template<class RandomAccessIterator>
 352   void make_heap(RandomAccessIterator first, RandomAccessIterator last);
 353 template<class RandomAccessIterator, class Compare>
 354   void make_heap(RandomAccessIterator first, RandomAccessIterator last,
 355                         Compare comp);
 356 template<class RandomAccessIterator>
 357   void sort_heap(RandomAccessIterator first, RandomAccessIterator last);
 358 template<class RandomAccessIterator, class Compare>
 359   void sort_heap(RandomAccessIterator first, RandomAccessIterator last,
 360                         Compare comp);
 361
 362   // 25.3.7, minimum and maximum:
 363   template<class T> const T& min(const T& a, const T& b);
 364   template<class T, class Compare>
 365     const T& min(const T& a, const T& b, Compare comp);
 366   template<class T> const T& max(const T& a, const T& b);
 367   template<class T, class Compare>
 368     const T& max(const T& a, const T& b, Compare comp);
 369   template<class ForwardIterator>
 370     ForwardIterator min_element
 371        (ForwardIterator first, ForwardIterator last);
 372   template<class ForwardIterator, class Compare>
 373     ForwardIterator min_element(ForwardIterator first, ForwardIterator last,
 374                                      Compare comp);
 375   template<class ForwardIterator>
 376     ForwardIterator max_element
 377        (ForwardIterator first, ForwardIterator last);
 378   template<class ForwardIterator, class Compare>
 379     ForwardIterator max_element(ForwardIterator first, ForwardIterator last,
 380                                      Compare comp);
 381   template<class InputIterator1, class InputIterator2>
 382     bool lexicographical_compare
 383           (InputIterator1 first1, InputIterator1 last1,
 384             InputIterator2 first2, InputIterator2 last2);
 385   template<class InputIterator1, class InputIterator2, class Compare>
 386     bool lexicographical_compare
 387           (InputIterator1 first1, InputIterator1 last1,
 388             InputIterator2 first2, InputIterator2 last2,
 389             Compare comp);
 390
 391   // 25.3.9, permutations
 392   template<class BidirectionalIterator>
 393     bool next_permutation(BidirectionalIterator first,
 394                                  BidirectionalIterator last);
 395   template<class BidirectionalIterator, class Compare>
 396     bool next_permutation(BidirectionalIterator first,
 397                                  BidirectionalIterator last, Compare comp);
 398   template<class BidirectionalIterator>
 399     bool prev_permutation(BidirectionalIterator first,
 400                                  BidirectionalIterator last);
 401   template<class BidirectionalIterator, class Compare>
 402     bool prev_permutation(BidirectionalIterator first,
 403                                  BidirectionalIterator last, Compare comp);
 404 }