algorithm revision 262801
1227825Stheraven// -*- C++ -*- 2227825Stheraven//===-------------------------- algorithm ---------------------------------===// 3227825Stheraven// 4227825Stheraven// The LLVM Compiler Infrastructure 5227825Stheraven// 6227825Stheraven// This file is dual licensed under the MIT and the University of Illinois Open 7227825Stheraven// Source Licenses. See LICENSE.TXT for details. 8227825Stheraven// 9227825Stheraven//===----------------------------------------------------------------------===// 10227825Stheraven 11227825Stheraven#ifndef _LIBCPP_ALGORITHM 12227825Stheraven#define _LIBCPP_ALGORITHM 13227825Stheraven 14227825Stheraven/* 15227825Stheraven algorithm synopsis 16227825Stheraven 17227825Stheraven#include <initializer_list> 18227825Stheraven 19227825Stheravennamespace std 20227825Stheraven{ 21227825Stheraven 22227825Stheraventemplate <class InputIterator, class Predicate> 23227825Stheraven bool 24227825Stheraven all_of(InputIterator first, InputIterator last, Predicate pred); 25227825Stheraven 26227825Stheraventemplate <class InputIterator, class Predicate> 27227825Stheraven bool 28227825Stheraven any_of(InputIterator first, InputIterator last, Predicate pred); 29227825Stheraven 30227825Stheraventemplate <class InputIterator, class Predicate> 31227825Stheraven bool 32227825Stheraven none_of(InputIterator first, InputIterator last, Predicate pred); 33227825Stheraven 34227825Stheraventemplate <class InputIterator, class Function> 35227825Stheraven Function 36227825Stheraven for_each(InputIterator first, InputIterator last, Function f); 37227825Stheraven 38227825Stheraventemplate <class InputIterator, class T> 39227825Stheraven InputIterator 40227825Stheraven find(InputIterator first, InputIterator last, const T& value); 41227825Stheraven 42227825Stheraventemplate <class InputIterator, class Predicate> 43227825Stheraven InputIterator 44227825Stheraven find_if(InputIterator first, InputIterator last, Predicate pred); 45227825Stheraven 46227825Stheraventemplate<class InputIterator, class Predicate> 47227825Stheraven InputIterator 48227825Stheraven find_if_not(InputIterator first, InputIterator last, Predicate pred); 49227825Stheraven 50227825Stheraventemplate <class ForwardIterator1, class ForwardIterator2> 51227825Stheraven ForwardIterator1 52227825Stheraven find_end(ForwardIterator1 first1, ForwardIterator1 last1, 53227825Stheraven ForwardIterator2 first2, ForwardIterator2 last2); 54227825Stheraven 55227825Stheraventemplate <class ForwardIterator1, class ForwardIterator2, class BinaryPredicate> 56227825Stheraven ForwardIterator1 57227825Stheraven find_end(ForwardIterator1 first1, ForwardIterator1 last1, 58227825Stheraven ForwardIterator2 first2, ForwardIterator2 last2, BinaryPredicate pred); 59227825Stheraven 60227825Stheraventemplate <class ForwardIterator1, class ForwardIterator2> 61227825Stheraven ForwardIterator1 62227825Stheraven find_first_of(ForwardIterator1 first1, ForwardIterator1 last1, 63227825Stheraven ForwardIterator2 first2, ForwardIterator2 last2); 64227825Stheraven 65227825Stheraventemplate <class ForwardIterator1, class ForwardIterator2, class BinaryPredicate> 66227825Stheraven ForwardIterator1 67227825Stheraven find_first_of(ForwardIterator1 first1, ForwardIterator1 last1, 68227825Stheraven ForwardIterator2 first2, ForwardIterator2 last2, BinaryPredicate pred); 69227825Stheraven 70227825Stheraventemplate <class ForwardIterator> 71227825Stheraven ForwardIterator 72227825Stheraven adjacent_find(ForwardIterator first, ForwardIterator last); 73227825Stheraven 74227825Stheraventemplate <class ForwardIterator, class BinaryPredicate> 75227825Stheraven ForwardIterator 76227825Stheraven adjacent_find(ForwardIterator first, ForwardIterator last, BinaryPredicate pred); 77227825Stheraven 78227825Stheraventemplate <class InputIterator, class T> 79227825Stheraven typename iterator_traits<InputIterator>::difference_type 80227825Stheraven count(InputIterator first, InputIterator last, const T& value); 81227825Stheraven 82227825Stheraventemplate <class InputIterator, class Predicate> 83227825Stheraven typename iterator_traits<InputIterator>::difference_type 84227825Stheraven count_if(InputIterator first, InputIterator last, Predicate pred); 85227825Stheraven 86227825Stheraventemplate <class InputIterator1, class InputIterator2> 87227825Stheraven pair<InputIterator1, InputIterator2> 88227825Stheraven mismatch(InputIterator1 first1, InputIterator1 last1, InputIterator2 first2); 89227825Stheraven 90253159Stheraventemplate <class InputIterator1, class InputIterator2> 91253159Stheraven pair<InputIterator1, InputIterator2> 92253159Stheraven mismatch(InputIterator1 first1, InputIterator1 last1, 93253159Stheraven InputIterator2 first2, InputIterator2 last2); // **C++14** 94253159Stheraven 95227825Stheraventemplate <class InputIterator1, class InputIterator2, class BinaryPredicate> 96227825Stheraven pair<InputIterator1, InputIterator2> 97227825Stheraven mismatch(InputIterator1 first1, InputIterator1 last1, 98227825Stheraven InputIterator2 first2, BinaryPredicate pred); 99227825Stheraven 100253159Stheraventemplate <class InputIterator1, class InputIterator2, class BinaryPredicate> 101253159Stheraven pair<InputIterator1, InputIterator2> 102253159Stheraven mismatch(InputIterator1 first1, InputIterator1 last1, 103253159Stheraven InputIterator2 first2, InputIterator2 last2, 104253159Stheraven BinaryPredicate pred); // **C++14** 105253159Stheraven 106227825Stheraventemplate <class InputIterator1, class InputIterator2> 107227825Stheraven bool 108227825Stheraven equal(InputIterator1 first1, InputIterator1 last1, InputIterator2 first2); 109227825Stheraven 110253159Stheraventemplate <class InputIterator1, class InputIterator2> 111253159Stheraven bool 112253159Stheraven equal(InputIterator1 first1, InputIterator1 last1, 113253159Stheraven InputIterator2 first2, InputIterator2 last2); // **C++14** 114253159Stheraven 115227825Stheraventemplate <class InputIterator1, class InputIterator2, class BinaryPredicate> 116227825Stheraven bool 117227825Stheraven equal(InputIterator1 first1, InputIterator1 last1, 118227825Stheraven InputIterator2 first2, BinaryPredicate pred); 119227825Stheraven 120253159Stheraventemplate <class InputIterator1, class InputIterator2, class BinaryPredicate> 121253159Stheraven bool 122253159Stheraven equal(InputIterator1 first1, InputIterator1 last1, 123253159Stheraven InputIterator2 first2, InputIterator2 last2, 124253159Stheraven BinaryPredicate pred); // **C++14** 125253159Stheraven 126227825Stheraventemplate<class ForwardIterator1, class ForwardIterator2> 127227825Stheraven bool 128227825Stheraven is_permutation(ForwardIterator1 first1, ForwardIterator1 last1, 129227825Stheraven ForwardIterator2 first2); 130227825Stheraven 131253159Stheraventemplate<class ForwardIterator1, class ForwardIterator2> 132253159Stheraven bool 133253159Stheraven is_permutation(ForwardIterator1 first1, ForwardIterator1 last1, 134253159Stheraven ForwardIterator2 first2, ForwardIterator2 last2); // **C++14** 135253159Stheraven 136227825Stheraventemplate<class ForwardIterator1, class ForwardIterator2, class BinaryPredicate> 137227825Stheraven bool 138227825Stheraven is_permutation(ForwardIterator1 first1, ForwardIterator1 last1, 139227825Stheraven ForwardIterator2 first2, BinaryPredicate pred); 140227825Stheraven 141253159Stheraventemplate<class ForwardIterator1, class ForwardIterator2, class BinaryPredicate> 142253159Stheraven bool 143253159Stheraven is_permutation(ForwardIterator1 first1, ForwardIterator1 last1, 144253159Stheraven ForwardIterator2 first2, ForwardIterator2 last2, 145253159Stheraven BinaryPredicate pred); // **C++14** 146253159Stheraven 147227825Stheraventemplate <class ForwardIterator1, class ForwardIterator2> 148227825Stheraven ForwardIterator1 149227825Stheraven search(ForwardIterator1 first1, ForwardIterator1 last1, 150227825Stheraven ForwardIterator2 first2, ForwardIterator2 last2); 151227825Stheraven 152227825Stheraventemplate <class ForwardIterator1, class ForwardIterator2, class BinaryPredicate> 153227825Stheraven ForwardIterator1 154227825Stheraven search(ForwardIterator1 first1, ForwardIterator1 last1, 155227825Stheraven ForwardIterator2 first2, ForwardIterator2 last2, BinaryPredicate pred); 156227825Stheraven 157227825Stheraventemplate <class ForwardIterator, class Size, class T> 158227825Stheraven ForwardIterator 159227825Stheraven search_n(ForwardIterator first, ForwardIterator last, Size count, const T& value); 160227825Stheraven 161227825Stheraventemplate <class ForwardIterator, class Size, class T, class BinaryPredicate> 162227825Stheraven ForwardIterator 163227825Stheraven search_n(ForwardIterator first, ForwardIterator last, 164227825Stheraven Size count, const T& value, BinaryPredicate pred); 165227825Stheraven 166227825Stheraventemplate <class InputIterator, class OutputIterator> 167227825Stheraven OutputIterator 168227825Stheraven copy(InputIterator first, InputIterator last, OutputIterator result); 169227825Stheraven 170227825Stheraventemplate<class InputIterator, class OutputIterator, class Predicate> 171227825Stheraven OutputIterator 172227825Stheraven copy_if(InputIterator first, InputIterator last, 173227825Stheraven OutputIterator result, Predicate pred); 174227825Stheraven 175227825Stheraventemplate<class InputIterator, class Size, class OutputIterator> 176227825Stheraven OutputIterator 177227825Stheraven copy_n(InputIterator first, Size n, OutputIterator result); 178227825Stheraven 179227825Stheraventemplate <class BidirectionalIterator1, class BidirectionalIterator2> 180227825Stheraven BidirectionalIterator2 181227825Stheraven copy_backward(BidirectionalIterator1 first, BidirectionalIterator1 last, 182227825Stheraven BidirectionalIterator2 result); 183227825Stheraven 184227825Stheraventemplate <class ForwardIterator1, class ForwardIterator2> 185227825Stheraven ForwardIterator2 186227825Stheraven swap_ranges(ForwardIterator1 first1, ForwardIterator1 last1, ForwardIterator2 first2); 187227825Stheraven 188227825Stheraventemplate <class ForwardIterator1, class ForwardIterator2> 189227825Stheraven void 190227825Stheraven iter_swap(ForwardIterator1 a, ForwardIterator2 b); 191227825Stheraven 192227825Stheraventemplate <class InputIterator, class OutputIterator, class UnaryOperation> 193227825Stheraven OutputIterator 194227825Stheraven transform(InputIterator first, InputIterator last, OutputIterator result, UnaryOperation op); 195227825Stheraven 196227825Stheraventemplate <class InputIterator1, class InputIterator2, class OutputIterator, class BinaryOperation> 197227825Stheraven OutputIterator 198227825Stheraven transform(InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, 199227825Stheraven OutputIterator result, BinaryOperation binary_op); 200227825Stheraven 201227825Stheraventemplate <class ForwardIterator, class T> 202227825Stheraven void 203227825Stheraven replace(ForwardIterator first, ForwardIterator last, const T& old_value, const T& new_value); 204227825Stheraven 205227825Stheraventemplate <class ForwardIterator, class Predicate, class T> 206227825Stheraven void 207227825Stheraven replace_if(ForwardIterator first, ForwardIterator last, Predicate pred, const T& new_value); 208227825Stheraven 209227825Stheraventemplate <class InputIterator, class OutputIterator, class T> 210227825Stheraven OutputIterator 211227825Stheraven replace_copy(InputIterator first, InputIterator last, OutputIterator result, 212227825Stheraven const T& old_value, const T& new_value); 213227825Stheraven 214227825Stheraventemplate <class InputIterator, class OutputIterator, class Predicate, class T> 215227825Stheraven OutputIterator 216227825Stheraven replace_copy_if(InputIterator first, InputIterator last, OutputIterator result, Predicate pred, const T& new_value); 217227825Stheraven 218227825Stheraventemplate <class ForwardIterator, class T> 219227825Stheraven void 220227825Stheraven fill(ForwardIterator first, ForwardIterator last, const T& value); 221227825Stheraven 222227825Stheraventemplate <class OutputIterator, class Size, class T> 223227825Stheraven OutputIterator 224227825Stheraven fill_n(OutputIterator first, Size n, const T& value); 225227825Stheraven 226227825Stheraventemplate <class ForwardIterator, class Generator> 227227825Stheraven void 228227825Stheraven generate(ForwardIterator first, ForwardIterator last, Generator gen); 229227825Stheraven 230227825Stheraventemplate <class OutputIterator, class Size, class Generator> 231227825Stheraven OutputIterator 232227825Stheraven generate_n(OutputIterator first, Size n, Generator gen); 233227825Stheraven 234227825Stheraventemplate <class ForwardIterator, class T> 235227825Stheraven ForwardIterator 236227825Stheraven remove(ForwardIterator first, ForwardIterator last, const T& value); 237227825Stheraven 238227825Stheraventemplate <class ForwardIterator, class Predicate> 239227825Stheraven ForwardIterator 240227825Stheraven remove_if(ForwardIterator first, ForwardIterator last, Predicate pred); 241227825Stheraven 242227825Stheraventemplate <class InputIterator, class OutputIterator, class T> 243227825Stheraven OutputIterator 244227825Stheraven remove_copy(InputIterator first, InputIterator last, OutputIterator result, const T& value); 245227825Stheraven 246227825Stheraventemplate <class InputIterator, class OutputIterator, class Predicate> 247227825Stheraven OutputIterator 248227825Stheraven remove_copy_if(InputIterator first, InputIterator last, OutputIterator result, Predicate pred); 249227825Stheraven 250227825Stheraventemplate <class ForwardIterator> 251227825Stheraven ForwardIterator 252227825Stheraven unique(ForwardIterator first, ForwardIterator last); 253227825Stheraven 254227825Stheraventemplate <class ForwardIterator, class BinaryPredicate> 255227825Stheraven ForwardIterator 256227825Stheraven unique(ForwardIterator first, ForwardIterator last, BinaryPredicate pred); 257227825Stheraven 258227825Stheraventemplate <class InputIterator, class OutputIterator> 259227825Stheraven OutputIterator 260227825Stheraven unique_copy(InputIterator first, InputIterator last, OutputIterator result); 261227825Stheraven 262227825Stheraventemplate <class InputIterator, class OutputIterator, class BinaryPredicate> 263227825Stheraven OutputIterator 264227825Stheraven unique_copy(InputIterator first, InputIterator last, OutputIterator result, BinaryPredicate pred); 265227825Stheraven 266227825Stheraventemplate <class BidirectionalIterator> 267227825Stheraven void 268227825Stheraven reverse(BidirectionalIterator first, BidirectionalIterator last); 269227825Stheraven 270227825Stheraventemplate <class BidirectionalIterator, class OutputIterator> 271227825Stheraven OutputIterator 272227825Stheraven reverse_copy(BidirectionalIterator first, BidirectionalIterator last, OutputIterator result); 273227825Stheraven 274227825Stheraventemplate <class ForwardIterator> 275227825Stheraven ForwardIterator 276227825Stheraven rotate(ForwardIterator first, ForwardIterator middle, ForwardIterator last); 277227825Stheraven 278227825Stheraventemplate <class ForwardIterator, class OutputIterator> 279227825Stheraven OutputIterator 280227825Stheraven rotate_copy(ForwardIterator first, ForwardIterator middle, ForwardIterator last, OutputIterator result); 281227825Stheraven 282227825Stheraventemplate <class RandomAccessIterator> 283227825Stheraven void 284227825Stheraven random_shuffle(RandomAccessIterator first, RandomAccessIterator last); 285227825Stheraven 286227825Stheraventemplate <class RandomAccessIterator, class RandomNumberGenerator> 287227825Stheraven void 288227825Stheraven random_shuffle(RandomAccessIterator first, RandomAccessIterator last, RandomNumberGenerator& rand); 289227825Stheraven 290227825Stheraventemplate<class RandomAccessIterator, class UniformRandomNumberGenerator> 291227825Stheraven void shuffle(RandomAccessIterator first, RandomAccessIterator last, 292227825Stheraven UniformRandomNumberGenerator&& g); 293227825Stheraven 294227825Stheraventemplate <class InputIterator, class Predicate> 295227825Stheraven bool 296227825Stheraven is_partitioned(InputIterator first, InputIterator last, Predicate pred); 297227825Stheraven 298227825Stheraventemplate <class ForwardIterator, class Predicate> 299227825Stheraven ForwardIterator 300227825Stheraven partition(ForwardIterator first, ForwardIterator last, Predicate pred); 301227825Stheraven 302227825Stheraventemplate <class InputIterator, class OutputIterator1, 303227825Stheraven class OutputIterator2, class Predicate> 304227825Stheraven pair<OutputIterator1, OutputIterator2> 305227825Stheraven partition_copy(InputIterator first, InputIterator last, 306227825Stheraven OutputIterator1 out_true, OutputIterator2 out_false, 307227825Stheraven Predicate pred); 308227825Stheraven 309227825Stheraventemplate <class ForwardIterator, class Predicate> 310227825Stheraven ForwardIterator 311227825Stheraven stable_partition(ForwardIterator first, ForwardIterator last, Predicate pred); 312227825Stheraven 313227825Stheraventemplate<class ForwardIterator, class Predicate> 314227825Stheraven ForwardIterator 315227825Stheraven partition_point(ForwardIterator first, ForwardIterator last, Predicate pred); 316227825Stheraven 317227825Stheraventemplate <class ForwardIterator> 318227825Stheraven bool 319227825Stheraven is_sorted(ForwardIterator first, ForwardIterator last); 320227825Stheraven 321227825Stheraventemplate <class ForwardIterator, class Compare> 322227825Stheraven bool 323227825Stheraven is_sorted(ForwardIterator first, ForwardIterator last, Compare comp); 324227825Stheraven 325227825Stheraventemplate<class ForwardIterator> 326227825Stheraven ForwardIterator 327227825Stheraven is_sorted_until(ForwardIterator first, ForwardIterator last); 328227825Stheraven 329227825Stheraventemplate <class ForwardIterator, class Compare> 330227825Stheraven ForwardIterator 331227825Stheraven is_sorted_until(ForwardIterator first, ForwardIterator last, Compare comp); 332227825Stheraven 333227825Stheraventemplate <class RandomAccessIterator> 334227825Stheraven void 335227825Stheraven sort(RandomAccessIterator first, RandomAccessIterator last); 336227825Stheraven 337227825Stheraventemplate <class RandomAccessIterator, class Compare> 338227825Stheraven void 339227825Stheraven sort(RandomAccessIterator first, RandomAccessIterator last, Compare comp); 340227825Stheraven 341227825Stheraventemplate <class RandomAccessIterator> 342227825Stheraven void 343227825Stheraven stable_sort(RandomAccessIterator first, RandomAccessIterator last); 344227825Stheraven 345227825Stheraventemplate <class RandomAccessIterator, class Compare> 346227825Stheraven void 347227825Stheraven stable_sort(RandomAccessIterator first, RandomAccessIterator last, Compare comp); 348227825Stheraven 349227825Stheraventemplate <class RandomAccessIterator> 350227825Stheraven void 351227825Stheraven partial_sort(RandomAccessIterator first, RandomAccessIterator middle, RandomAccessIterator last); 352227825Stheraven 353227825Stheraventemplate <class RandomAccessIterator, class Compare> 354227825Stheraven void 355227825Stheraven partial_sort(RandomAccessIterator first, RandomAccessIterator middle, RandomAccessIterator last, Compare comp); 356227825Stheraven 357227825Stheraventemplate <class InputIterator, class RandomAccessIterator> 358227825Stheraven RandomAccessIterator 359227825Stheraven partial_sort_copy(InputIterator first, InputIterator last, 360227825Stheraven RandomAccessIterator result_first, RandomAccessIterator result_last); 361227825Stheraven 362227825Stheraventemplate <class InputIterator, class RandomAccessIterator, class Compare> 363227825Stheraven RandomAccessIterator 364227825Stheraven partial_sort_copy(InputIterator first, InputIterator last, 365227825Stheraven RandomAccessIterator result_first, RandomAccessIterator result_last, Compare comp); 366227825Stheraven 367227825Stheraventemplate <class RandomAccessIterator> 368227825Stheraven void 369227825Stheraven nth_element(RandomAccessIterator first, RandomAccessIterator nth, RandomAccessIterator last); 370227825Stheraven 371227825Stheraventemplate <class RandomAccessIterator, class Compare> 372227825Stheraven void 373227825Stheraven nth_element(RandomAccessIterator first, RandomAccessIterator nth, RandomAccessIterator last, Compare comp); 374227825Stheraven 375227825Stheraventemplate <class ForwardIterator, class T> 376227825Stheraven ForwardIterator 377227825Stheraven lower_bound(ForwardIterator first, ForwardIterator last, const T& value); 378227825Stheraven 379227825Stheraventemplate <class ForwardIterator, class T, class Compare> 380227825Stheraven ForwardIterator 381227825Stheraven lower_bound(ForwardIterator first, ForwardIterator last, const T& value, Compare comp); 382227825Stheraven 383227825Stheraventemplate <class ForwardIterator, class T> 384227825Stheraven ForwardIterator 385227825Stheraven upper_bound(ForwardIterator first, ForwardIterator last, const T& value); 386227825Stheraven 387227825Stheraventemplate <class ForwardIterator, class T, class Compare> 388227825Stheraven ForwardIterator 389227825Stheraven upper_bound(ForwardIterator first, ForwardIterator last, const T& value, Compare comp); 390227825Stheraven 391227825Stheraventemplate <class ForwardIterator, class T> 392227825Stheraven pair<ForwardIterator, ForwardIterator> 393227825Stheraven equal_range(ForwardIterator first, ForwardIterator last, const T& value); 394227825Stheraven 395227825Stheraventemplate <class ForwardIterator, class T, class Compare> 396227825Stheraven pair<ForwardIterator, ForwardIterator> 397227825Stheraven equal_range(ForwardIterator first, ForwardIterator last, const T& value, Compare comp); 398227825Stheraven 399227825Stheraventemplate <class ForwardIterator, class T> 400227825Stheraven bool 401227825Stheraven binary_search(ForwardIterator first, ForwardIterator last, const T& value); 402227825Stheraven 403227825Stheraventemplate <class ForwardIterator, class T, class Compare> 404227825Stheraven bool 405227825Stheraven binary_search(ForwardIterator first, ForwardIterator last, const T& value, Compare comp); 406227825Stheraven 407227825Stheraventemplate <class InputIterator1, class InputIterator2, class OutputIterator> 408227825Stheraven OutputIterator 409227825Stheraven merge(InputIterator1 first1, InputIterator1 last1, 410227825Stheraven InputIterator2 first2, InputIterator2 last2, OutputIterator result); 411227825Stheraven 412227825Stheraventemplate <class InputIterator1, class InputIterator2, class OutputIterator, class Compare> 413227825Stheraven OutputIterator 414227825Stheraven merge(InputIterator1 first1, InputIterator1 last1, 415227825Stheraven InputIterator2 first2, InputIterator2 last2, OutputIterator result, Compare comp); 416227825Stheraven 417227825Stheraventemplate <class BidirectionalIterator> 418227825Stheraven void 419227825Stheraven inplace_merge(BidirectionalIterator first, BidirectionalIterator middle, BidirectionalIterator last); 420227825Stheraven 421227825Stheraventemplate <class BidirectionalIterator, class Compare> 422227825Stheraven void 423227825Stheraven inplace_merge(BidirectionalIterator first, BidirectionalIterator middle, BidirectionalIterator last, Compare comp); 424227825Stheraven 425227825Stheraventemplate <class InputIterator1, class InputIterator2> 426227825Stheraven bool 427227825Stheraven includes(InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, InputIterator2 last2); 428227825Stheraven 429227825Stheraventemplate <class InputIterator1, class InputIterator2, class Compare> 430227825Stheraven bool 431227825Stheraven includes(InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, InputIterator2 last2, Compare comp); 432227825Stheraven 433227825Stheraventemplate <class InputIterator1, class InputIterator2, class OutputIterator> 434227825Stheraven OutputIterator 435227825Stheraven set_union(InputIterator1 first1, InputIterator1 last1, 436227825Stheraven InputIterator2 first2, InputIterator2 last2, OutputIterator result); 437227825Stheraven 438227825Stheraventemplate <class InputIterator1, class InputIterator2, class OutputIterator, class Compare> 439227825Stheraven OutputIterator 440227825Stheraven set_union(InputIterator1 first1, InputIterator1 last1, 441227825Stheraven InputIterator2 first2, InputIterator2 last2, OutputIterator result, Compare comp); 442227825Stheraven 443227825Stheraventemplate <class InputIterator1, class InputIterator2, class OutputIterator> 444227825Stheraven OutputIterator 445227825Stheraven set_intersection(InputIterator1 first1, InputIterator1 last1, 446227825Stheraven InputIterator2 first2, InputIterator2 last2, OutputIterator result); 447227825Stheraven 448227825Stheraventemplate <class InputIterator1, class InputIterator2, class OutputIterator, class Compare> 449227825Stheraven OutputIterator 450227825Stheraven set_intersection(InputIterator1 first1, InputIterator1 last1, 451227825Stheraven InputIterator2 first2, InputIterator2 last2, OutputIterator result, Compare comp); 452227825Stheraven 453227825Stheraventemplate <class InputIterator1, class InputIterator2, class OutputIterator> 454227825Stheraven OutputIterator 455227825Stheraven set_difference(InputIterator1 first1, InputIterator1 last1, 456227825Stheraven InputIterator2 first2, InputIterator2 last2, OutputIterator result); 457227825Stheraven 458227825Stheraventemplate <class InputIterator1, class InputIterator2, class OutputIterator, class Compare> 459227825Stheraven OutputIterator 460227825Stheraven set_difference(InputIterator1 first1, InputIterator1 last1, 461227825Stheraven InputIterator2 first2, InputIterator2 last2, OutputIterator result, Compare comp); 462227825Stheraven 463227825Stheraventemplate <class InputIterator1, class InputIterator2, class OutputIterator> 464227825Stheraven OutputIterator 465227825Stheraven set_symmetric_difference(InputIterator1 first1, InputIterator1 last1, 466227825Stheraven InputIterator2 first2, InputIterator2 last2, OutputIterator result); 467227825Stheraven 468227825Stheraventemplate <class InputIterator1, class InputIterator2, class OutputIterator, class Compare> 469227825Stheraven OutputIterator 470227825Stheraven set_symmetric_difference(InputIterator1 first1, InputIterator1 last1, 471227825Stheraven InputIterator2 first2, InputIterator2 last2, OutputIterator result, Compare comp); 472227825Stheraven 473227825Stheraventemplate <class RandomAccessIterator> 474227825Stheraven void 475227825Stheraven push_heap(RandomAccessIterator first, RandomAccessIterator last); 476227825Stheraven 477227825Stheraventemplate <class RandomAccessIterator, class Compare> 478227825Stheraven void 479227825Stheraven push_heap(RandomAccessIterator first, RandomAccessIterator last, Compare comp); 480227825Stheraven 481227825Stheraventemplate <class RandomAccessIterator> 482227825Stheraven void 483227825Stheraven pop_heap(RandomAccessIterator first, RandomAccessIterator last); 484227825Stheraven 485227825Stheraventemplate <class RandomAccessIterator, class Compare> 486227825Stheraven void 487227825Stheraven pop_heap(RandomAccessIterator first, RandomAccessIterator last, Compare comp); 488227825Stheraven 489227825Stheraventemplate <class RandomAccessIterator> 490227825Stheraven void 491227825Stheraven make_heap(RandomAccessIterator first, RandomAccessIterator last); 492227825Stheraven 493227825Stheraventemplate <class RandomAccessIterator, class Compare> 494227825Stheraven void 495227825Stheraven make_heap(RandomAccessIterator first, RandomAccessIterator last, Compare comp); 496227825Stheraven 497227825Stheraventemplate <class RandomAccessIterator> 498227825Stheraven void 499227825Stheraven sort_heap(RandomAccessIterator first, RandomAccessIterator last); 500227825Stheraven 501227825Stheraventemplate <class RandomAccessIterator, class Compare> 502227825Stheraven void 503227825Stheraven sort_heap(RandomAccessIterator first, RandomAccessIterator last, Compare comp); 504227825Stheraven 505227825Stheraventemplate <class RandomAccessIterator> 506227825Stheraven bool 507227825Stheraven is_heap(RandomAccessIterator first, RandomAccessiterator last); 508227825Stheraven 509227825Stheraventemplate <class RandomAccessIterator, class Compare> 510227825Stheraven bool 511227825Stheraven is_heap(RandomAccessIterator first, RandomAccessiterator last, Compare comp); 512227825Stheraven 513227825Stheraventemplate <class RandomAccessIterator> 514227825Stheraven RandomAccessIterator 515227825Stheraven is_heap_until(RandomAccessIterator first, RandomAccessiterator last); 516227825Stheraven 517227825Stheraventemplate <class RandomAccessIterator, class Compare> 518227825Stheraven RandomAccessIterator 519227825Stheraven is_heap_until(RandomAccessIterator first, RandomAccessiterator last, Compare comp); 520227825Stheraven 521227825Stheraventemplate <class ForwardIterator> 522227825Stheraven ForwardIterator 523227825Stheraven min_element(ForwardIterator first, ForwardIterator last); 524227825Stheraven 525227825Stheraventemplate <class ForwardIterator, class Compare> 526227825Stheraven ForwardIterator 527227825Stheraven min_element(ForwardIterator first, ForwardIterator last, Compare comp); 528227825Stheraven 529227825Stheraventemplate <class T> 530227825Stheraven const T& 531227825Stheraven min(const T& a, const T& b); 532227825Stheraven 533227825Stheraventemplate <class T, class Compare> 534227825Stheraven const T& 535227825Stheraven min(const T& a, const T& b, Compare comp); 536227825Stheraven 537227825Stheraventemplate<class T> 538227825Stheraven T 539227825Stheraven min(initializer_list<T> t); 540227825Stheraven 541227825Stheraventemplate<class T, class Compare> 542227825Stheraven T 543227825Stheraven min(initializer_list<T> t, Compare comp); 544227825Stheraven 545227825Stheraventemplate <class ForwardIterator> 546227825Stheraven ForwardIterator 547227825Stheraven max_element(ForwardIterator first, ForwardIterator last); 548227825Stheraven 549227825Stheraventemplate <class ForwardIterator, class Compare> 550227825Stheraven ForwardIterator 551227825Stheraven max_element(ForwardIterator first, ForwardIterator last, Compare comp); 552227825Stheraven 553227825Stheraventemplate <class T> 554227825Stheraven const T& 555227825Stheraven max(const T& a, const T& b); 556227825Stheraven 557227825Stheraventemplate <class T, class Compare> 558227825Stheraven const T& 559227825Stheraven max(const T& a, const T& b, Compare comp); 560227825Stheraven 561227825Stheraventemplate<class T> 562227825Stheraven T 563227825Stheraven max(initializer_list<T> t); 564227825Stheraven 565227825Stheraventemplate<class T, class Compare> 566227825Stheraven T 567227825Stheraven max(initializer_list<T> t, Compare comp); 568227825Stheraven 569227825Stheraventemplate<class ForwardIterator> 570227825Stheraven pair<ForwardIterator, ForwardIterator> 571227825Stheraven minmax_element(ForwardIterator first, ForwardIterator last); 572227825Stheraven 573227825Stheraventemplate<class ForwardIterator, class Compare> 574227825Stheraven pair<ForwardIterator, ForwardIterator> 575227825Stheraven minmax_element(ForwardIterator first, ForwardIterator last, Compare comp); 576227825Stheraven 577227825Stheraventemplate<class T> 578227825Stheraven pair<const T&, const T&> 579227825Stheraven minmax(const T& a, const T& b); 580227825Stheraven 581227825Stheraventemplate<class T, class Compare> 582227825Stheraven pair<const T&, const T&> 583227825Stheraven minmax(const T& a, const T& b, Compare comp); 584227825Stheraven 585227825Stheraventemplate<class T> 586227825Stheraven pair<T, T> 587227825Stheraven minmax(initializer_list<T> t); 588227825Stheraven 589227825Stheraventemplate<class T, class Compare> 590227825Stheraven pair<T, T> 591227825Stheraven minmax(initializer_list<T> t, Compare comp); 592227825Stheraven 593227825Stheraventemplate <class InputIterator1, class InputIterator2> 594227825Stheraven bool 595227825Stheraven lexicographical_compare(InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, InputIterator2 last2); 596227825Stheraven 597227825Stheraventemplate <class InputIterator1, class InputIterator2, class Compare> 598227825Stheraven bool 599227825Stheraven lexicographical_compare(InputIterator1 first1, InputIterator1 last1, 600227825Stheraven InputIterator2 first2, InputIterator2 last2, Compare comp); 601227825Stheraven 602227825Stheraventemplate <class BidirectionalIterator> 603227825Stheraven bool 604227825Stheraven next_permutation(BidirectionalIterator first, BidirectionalIterator last); 605227825Stheraven 606227825Stheraventemplate <class BidirectionalIterator, class Compare> 607227825Stheraven bool 608227825Stheraven next_permutation(BidirectionalIterator first, BidirectionalIterator last, Compare comp); 609227825Stheraven 610227825Stheraventemplate <class BidirectionalIterator> 611227825Stheraven bool 612227825Stheraven prev_permutation(BidirectionalIterator first, BidirectionalIterator last); 613227825Stheraven 614227825Stheraventemplate <class BidirectionalIterator, class Compare> 615227825Stheraven bool 616227825Stheraven prev_permutation(BidirectionalIterator first, BidirectionalIterator last, Compare comp); 617227825Stheraven 618227825Stheraven} // std 619227825Stheraven 620227825Stheraven*/ 621227825Stheraven 622227825Stheraven#include <__config> 623227825Stheraven#include <initializer_list> 624227825Stheraven#include <type_traits> 625227825Stheraven#include <cstring> 626227825Stheraven#include <utility> 627227825Stheraven#include <memory> 628227825Stheraven#include <iterator> 629241903Sdim#include <cstddef> 630227825Stheraven 631262801Sdim#if defined(__IBMCPP__) 632262801Sdim#include "support/ibm/support.h" 633262801Sdim#endif 634262801Sdim#if defined(_LIBCPP_MSVCRT) || defined(__MINGW32__) 635262801Sdim#include "support/win32/support.h" 636262801Sdim#endif 637262801Sdim 638232950Stheraven#include <__undef_min_max> 639232950Stheraven 640227825Stheraven#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) 641227825Stheraven#pragma GCC system_header 642227825Stheraven#endif 643227825Stheraven 644227825Stheraven_LIBCPP_BEGIN_NAMESPACE_STD 645227825Stheraven 646227825Stheraventemplate <class _T1, class _T2 = _T1> 647227825Stheravenstruct __equal_to 648227825Stheraven{ 649227825Stheraven _LIBCPP_INLINE_VISIBILITY bool operator()(const _T1& __x, const _T1& __y) const {return __x == __y;} 650227825Stheraven _LIBCPP_INLINE_VISIBILITY bool operator()(const _T1& __x, const _T2& __y) const {return __x == __y;} 651227825Stheraven _LIBCPP_INLINE_VISIBILITY bool operator()(const _T2& __x, const _T1& __y) const {return __x == __y;} 652227825Stheraven _LIBCPP_INLINE_VISIBILITY bool operator()(const _T2& __x, const _T2& __y) const {return __x == __y;} 653227825Stheraven}; 654227825Stheraven 655227825Stheraventemplate <class _T1> 656227825Stheravenstruct __equal_to<_T1, _T1> 657227825Stheraven{ 658227825Stheraven _LIBCPP_INLINE_VISIBILITY bool operator()(const _T1& __x, const _T1& __y) const {return __x == __y;} 659227825Stheraven}; 660227825Stheraven 661227825Stheraventemplate <class _T1> 662227825Stheravenstruct __equal_to<const _T1, _T1> 663227825Stheraven{ 664227825Stheraven _LIBCPP_INLINE_VISIBILITY bool operator()(const _T1& __x, const _T1& __y) const {return __x == __y;} 665227825Stheraven}; 666227825Stheraven 667227825Stheraventemplate <class _T1> 668227825Stheravenstruct __equal_to<_T1, const _T1> 669227825Stheraven{ 670227825Stheraven _LIBCPP_INLINE_VISIBILITY bool operator()(const _T1& __x, const _T1& __y) const {return __x == __y;} 671227825Stheraven}; 672227825Stheraven 673227825Stheraventemplate <class _T1, class _T2 = _T1> 674227825Stheravenstruct __less 675227825Stheraven{ 676227825Stheraven _LIBCPP_INLINE_VISIBILITY bool operator()(const _T1& __x, const _T1& __y) const {return __x < __y;} 677227825Stheraven _LIBCPP_INLINE_VISIBILITY bool operator()(const _T1& __x, const _T2& __y) const {return __x < __y;} 678227825Stheraven _LIBCPP_INLINE_VISIBILITY bool operator()(const _T2& __x, const _T1& __y) const {return __x < __y;} 679227825Stheraven _LIBCPP_INLINE_VISIBILITY bool operator()(const _T2& __x, const _T2& __y) const {return __x < __y;} 680227825Stheraven}; 681227825Stheraven 682227825Stheraventemplate <class _T1> 683227825Stheravenstruct __less<_T1, _T1> 684227825Stheraven{ 685227825Stheraven _LIBCPP_INLINE_VISIBILITY bool operator()(const _T1& __x, const _T1& __y) const {return __x < __y;} 686227825Stheraven}; 687227825Stheraven 688227825Stheraventemplate <class _T1> 689227825Stheravenstruct __less<const _T1, _T1> 690227825Stheraven{ 691227825Stheraven _LIBCPP_INLINE_VISIBILITY bool operator()(const _T1& __x, const _T1& __y) const {return __x < __y;} 692227825Stheraven}; 693227825Stheraven 694227825Stheraventemplate <class _T1> 695227825Stheravenstruct __less<_T1, const _T1> 696227825Stheraven{ 697227825Stheraven _LIBCPP_INLINE_VISIBILITY bool operator()(const _T1& __x, const _T1& __y) const {return __x < __y;} 698227825Stheraven}; 699227825Stheraven 700227825Stheraventemplate <class _Predicate> 701227825Stheravenclass __negate 702227825Stheraven{ 703227825Stheravenprivate: 704227825Stheraven _Predicate __p_; 705227825Stheravenpublic: 706227825Stheraven _LIBCPP_INLINE_VISIBILITY __negate() {} 707227825Stheraven 708227825Stheraven _LIBCPP_INLINE_VISIBILITY 709227825Stheraven explicit __negate(_Predicate __p) : __p_(__p) {} 710227825Stheraven 711227825Stheraven template <class _T1> 712227825Stheraven _LIBCPP_INLINE_VISIBILITY 713227825Stheraven bool operator()(const _T1& __x) {return !__p_(__x);} 714227825Stheraven 715227825Stheraven template <class _T1, class _T2> 716227825Stheraven _LIBCPP_INLINE_VISIBILITY 717227825Stheraven bool operator()(const _T1& __x, const _T2& __y) {return !__p_(__x, __y);} 718227825Stheraven}; 719227825Stheraven 720262801Sdim#ifdef _LIBCPP_DEBUG 721227825Stheraven 722227825Stheraventemplate <class _Compare> 723227825Stheravenstruct __debug_less 724227825Stheraven{ 725227825Stheraven _Compare __comp_; 726227825Stheraven __debug_less(_Compare& __c) : __comp_(__c) {} 727227825Stheraven template <class _Tp, class _Up> 728227825Stheraven bool operator()(const _Tp& __x, const _Up& __y) 729227825Stheraven { 730227825Stheraven bool __r = __comp_(__x, __y); 731227825Stheraven if (__r) 732227825Stheraven _LIBCPP_ASSERT(!__comp_(__y, __x), "Comparator does not induce a strict weak ordering"); 733227825Stheraven return __r; 734227825Stheraven } 735227825Stheraven}; 736227825Stheraven 737262801Sdim#endif // _LIBCPP_DEBUG 738227825Stheraven 739227825Stheraven// Precondition: __x != 0 740232950Stheraveninline _LIBCPP_INLINE_VISIBILITY 741232950Stheravenunsigned 742232950Stheraven__ctz(unsigned __x) 743232950Stheraven{ 744232950Stheraven return static_cast<unsigned>(__builtin_ctz(__x)); 745232950Stheraven} 746227825Stheraven 747232950Stheraveninline _LIBCPP_INLINE_VISIBILITY 748232950Stheravenunsigned long 749232950Stheraven__ctz(unsigned long __x) 750232950Stheraven{ 751232950Stheraven return static_cast<unsigned long>(__builtin_ctzl(__x)); 752232950Stheraven} 753232950Stheraven 754232950Stheraveninline _LIBCPP_INLINE_VISIBILITY 755232950Stheravenunsigned long long 756232950Stheraven__ctz(unsigned long long __x) 757232950Stheraven{ 758232950Stheraven return static_cast<unsigned long long>(__builtin_ctzll(__x)); 759232950Stheraven} 760232950Stheraven 761227825Stheraven// Precondition: __x != 0 762232950Stheraveninline _LIBCPP_INLINE_VISIBILITY 763232950Stheravenunsigned 764232950Stheraven__clz(unsigned __x) 765232950Stheraven{ 766232950Stheraven return static_cast<unsigned>(__builtin_clz(__x)); 767232950Stheraven} 768227825Stheraven 769232950Stheraveninline _LIBCPP_INLINE_VISIBILITY 770232950Stheravenunsigned long 771232950Stheraven__clz(unsigned long __x) 772232950Stheraven{ 773232950Stheraven return static_cast<unsigned long>(__builtin_clzl (__x)); 774232950Stheraven} 775232950Stheraven 776232950Stheraveninline _LIBCPP_INLINE_VISIBILITY 777232950Stheravenunsigned long long 778232950Stheraven__clz(unsigned long long __x) 779232950Stheraven{ 780232950Stheraven return static_cast<unsigned long long>(__builtin_clzll(__x)); 781232950Stheraven} 782232950Stheraven 783227825Stheraveninline _LIBCPP_INLINE_VISIBILITY int __pop_count(unsigned __x) {return __builtin_popcount (__x);} 784227825Stheraveninline _LIBCPP_INLINE_VISIBILITY int __pop_count(unsigned long __x) {return __builtin_popcountl (__x);} 785227825Stheraveninline _LIBCPP_INLINE_VISIBILITY int __pop_count(unsigned long long __x) {return __builtin_popcountll(__x);} 786227825Stheraven 787227825Stheraven// all_of 788227825Stheraven 789227825Stheraventemplate <class _InputIterator, class _Predicate> 790227825Stheraveninline _LIBCPP_INLINE_VISIBILITY 791227825Stheravenbool 792227825Stheravenall_of(_InputIterator __first, _InputIterator __last, _Predicate __pred) 793227825Stheraven{ 794227825Stheraven for (; __first != __last; ++__first) 795227825Stheraven if (!__pred(*__first)) 796227825Stheraven return false; 797227825Stheraven return true; 798227825Stheraven} 799227825Stheraven 800227825Stheraven// any_of 801227825Stheraven 802227825Stheraventemplate <class _InputIterator, class _Predicate> 803227825Stheraveninline _LIBCPP_INLINE_VISIBILITY 804227825Stheravenbool 805227825Stheravenany_of(_InputIterator __first, _InputIterator __last, _Predicate __pred) 806227825Stheraven{ 807227825Stheraven for (; __first != __last; ++__first) 808227825Stheraven if (__pred(*__first)) 809227825Stheraven return true; 810227825Stheraven return false; 811227825Stheraven} 812227825Stheraven 813227825Stheraven// none_of 814227825Stheraven 815227825Stheraventemplate <class _InputIterator, class _Predicate> 816227825Stheraveninline _LIBCPP_INLINE_VISIBILITY 817227825Stheravenbool 818227825Stheravennone_of(_InputIterator __first, _InputIterator __last, _Predicate __pred) 819227825Stheraven{ 820227825Stheraven for (; __first != __last; ++__first) 821227825Stheraven if (__pred(*__first)) 822227825Stheraven return false; 823227825Stheraven return true; 824227825Stheraven} 825227825Stheraven 826227825Stheraven// for_each 827227825Stheraven 828227825Stheraventemplate <class _InputIterator, class _Function> 829227825Stheraveninline _LIBCPP_INLINE_VISIBILITY 830227825Stheraven_Function 831227825Stheravenfor_each(_InputIterator __first, _InputIterator __last, _Function __f) 832227825Stheraven{ 833227825Stheraven for (; __first != __last; ++__first) 834227825Stheraven __f(*__first); 835262801Sdim return _VSTD::move(__f); // explicitly moved for (emulated) C++03 836227825Stheraven} 837227825Stheraven 838227825Stheraven// find 839227825Stheraven 840227825Stheraventemplate <class _InputIterator, class _Tp> 841227825Stheraveninline _LIBCPP_INLINE_VISIBILITY 842227825Stheraven_InputIterator 843227825Stheravenfind(_InputIterator __first, _InputIterator __last, const _Tp& __value_) 844227825Stheraven{ 845227825Stheraven for (; __first != __last; ++__first) 846227825Stheraven if (*__first == __value_) 847227825Stheraven break; 848227825Stheraven return __first; 849227825Stheraven} 850227825Stheraven 851227825Stheraven// find_if 852227825Stheraven 853227825Stheraventemplate <class _InputIterator, class _Predicate> 854227825Stheraveninline _LIBCPP_INLINE_VISIBILITY 855227825Stheraven_InputIterator 856227825Stheravenfind_if(_InputIterator __first, _InputIterator __last, _Predicate __pred) 857227825Stheraven{ 858227825Stheraven for (; __first != __last; ++__first) 859227825Stheraven if (__pred(*__first)) 860227825Stheraven break; 861227825Stheraven return __first; 862227825Stheraven} 863227825Stheraven 864227825Stheraven// find_if_not 865227825Stheraven 866227825Stheraventemplate<class _InputIterator, class _Predicate> 867227825Stheraveninline _LIBCPP_INLINE_VISIBILITY 868227825Stheraven_InputIterator 869227825Stheravenfind_if_not(_InputIterator __first, _InputIterator __last, _Predicate __pred) 870227825Stheraven{ 871227825Stheraven for (; __first != __last; ++__first) 872227825Stheraven if (!__pred(*__first)) 873227825Stheraven break; 874227825Stheraven return __first; 875227825Stheraven} 876227825Stheraven 877227825Stheraven// find_end 878227825Stheraven 879227825Stheraventemplate <class _BinaryPredicate, class _ForwardIterator1, class _ForwardIterator2> 880227825Stheraven_ForwardIterator1 881227825Stheraven__find_end(_ForwardIterator1 __first1, _ForwardIterator1 __last1, 882227825Stheraven _ForwardIterator2 __first2, _ForwardIterator2 __last2, _BinaryPredicate __pred, 883227825Stheraven forward_iterator_tag, forward_iterator_tag) 884227825Stheraven{ 885227825Stheraven // modeled after search algorithm 886227825Stheraven _ForwardIterator1 __r = __last1; // __last1 is the "default" answer 887227825Stheraven if (__first2 == __last2) 888227825Stheraven return __r; 889227825Stheraven while (true) 890227825Stheraven { 891227825Stheraven while (true) 892227825Stheraven { 893227825Stheraven if (__first1 == __last1) // if source exhausted return last correct answer 894227825Stheraven return __r; // (or __last1 if never found) 895227825Stheraven if (__pred(*__first1, *__first2)) 896227825Stheraven break; 897227825Stheraven ++__first1; 898227825Stheraven } 899227825Stheraven // *__first1 matches *__first2, now match elements after here 900227825Stheraven _ForwardIterator1 __m1 = __first1; 901227825Stheraven _ForwardIterator2 __m2 = __first2; 902227825Stheraven while (true) 903227825Stheraven { 904227825Stheraven if (++__m2 == __last2) 905227825Stheraven { // Pattern exhaused, record answer and search for another one 906227825Stheraven __r = __first1; 907227825Stheraven ++__first1; 908227825Stheraven break; 909227825Stheraven } 910227825Stheraven if (++__m1 == __last1) // Source exhausted, return last answer 911227825Stheraven return __r; 912227825Stheraven if (!__pred(*__m1, *__m2)) // mismatch, restart with a new __first 913227825Stheraven { 914227825Stheraven ++__first1; 915227825Stheraven break; 916227825Stheraven } // else there is a match, check next elements 917227825Stheraven } 918227825Stheraven } 919227825Stheraven} 920227825Stheraven 921227825Stheraventemplate <class _BinaryPredicate, class _BidirectionalIterator1, class _BidirectionalIterator2> 922227825Stheraven_BidirectionalIterator1 923227825Stheraven__find_end(_BidirectionalIterator1 __first1, _BidirectionalIterator1 __last1, 924227825Stheraven _BidirectionalIterator2 __first2, _BidirectionalIterator2 __last2, _BinaryPredicate __pred, 925227825Stheraven bidirectional_iterator_tag, bidirectional_iterator_tag) 926227825Stheraven{ 927227825Stheraven // modeled after search algorithm (in reverse) 928227825Stheraven if (__first2 == __last2) 929227825Stheraven return __last1; // Everything matches an empty sequence 930227825Stheraven _BidirectionalIterator1 __l1 = __last1; 931227825Stheraven _BidirectionalIterator2 __l2 = __last2; 932227825Stheraven --__l2; 933227825Stheraven while (true) 934227825Stheraven { 935227825Stheraven // Find last element in sequence 1 that matchs *(__last2-1), with a mininum of loop checks 936227825Stheraven while (true) 937227825Stheraven { 938227825Stheraven if (__first1 == __l1) // return __last1 if no element matches *__first2 939227825Stheraven return __last1; 940227825Stheraven if (__pred(*--__l1, *__l2)) 941227825Stheraven break; 942227825Stheraven } 943227825Stheraven // *__l1 matches *__l2, now match elements before here 944227825Stheraven _BidirectionalIterator1 __m1 = __l1; 945227825Stheraven _BidirectionalIterator2 __m2 = __l2; 946227825Stheraven while (true) 947227825Stheraven { 948227825Stheraven if (__m2 == __first2) // If pattern exhausted, __m1 is the answer (works for 1 element pattern) 949227825Stheraven return __m1; 950227825Stheraven if (__m1 == __first1) // Otherwise if source exhaused, pattern not found 951227825Stheraven return __last1; 952227825Stheraven if (!__pred(*--__m1, *--__m2)) // if there is a mismatch, restart with a new __l1 953227825Stheraven { 954227825Stheraven break; 955227825Stheraven } // else there is a match, check next elements 956227825Stheraven } 957227825Stheraven } 958227825Stheraven} 959227825Stheraven 960227825Stheraventemplate <class _BinaryPredicate, class _RandomAccessIterator1, class _RandomAccessIterator2> 961227825Stheraven_RandomAccessIterator1 962227825Stheraven__find_end(_RandomAccessIterator1 __first1, _RandomAccessIterator1 __last1, 963227825Stheraven _RandomAccessIterator2 __first2, _RandomAccessIterator2 __last2, _BinaryPredicate __pred, 964227825Stheraven random_access_iterator_tag, random_access_iterator_tag) 965227825Stheraven{ 966227825Stheraven // Take advantage of knowing source and pattern lengths. Stop short when source is smaller than pattern 967227825Stheraven typename iterator_traits<_RandomAccessIterator2>::difference_type __len2 = __last2 - __first2; 968227825Stheraven if (__len2 == 0) 969227825Stheraven return __last1; 970227825Stheraven typename iterator_traits<_RandomAccessIterator1>::difference_type __len1 = __last1 - __first1; 971227825Stheraven if (__len1 < __len2) 972227825Stheraven return __last1; 973227825Stheraven const _RandomAccessIterator1 __s = __first1 + (__len2 - 1); // End of pattern match can't go before here 974227825Stheraven _RandomAccessIterator1 __l1 = __last1; 975227825Stheraven _RandomAccessIterator2 __l2 = __last2; 976227825Stheraven --__l2; 977227825Stheraven while (true) 978227825Stheraven { 979227825Stheraven while (true) 980227825Stheraven { 981227825Stheraven if (__s == __l1) 982227825Stheraven return __last1; 983227825Stheraven if (__pred(*--__l1, *__l2)) 984227825Stheraven break; 985227825Stheraven } 986227825Stheraven _RandomAccessIterator1 __m1 = __l1; 987227825Stheraven _RandomAccessIterator2 __m2 = __l2; 988227825Stheraven while (true) 989227825Stheraven { 990227825Stheraven if (__m2 == __first2) 991227825Stheraven return __m1; 992227825Stheraven // no need to check range on __m1 because __s guarantees we have enough source 993227825Stheraven if (!__pred(*--__m1, *--__m2)) 994227825Stheraven { 995227825Stheraven break; 996227825Stheraven } 997227825Stheraven } 998227825Stheraven } 999227825Stheraven} 1000227825Stheraven 1001227825Stheraventemplate <class _ForwardIterator1, class _ForwardIterator2, class _BinaryPredicate> 1002227825Stheraveninline _LIBCPP_INLINE_VISIBILITY 1003227825Stheraven_ForwardIterator1 1004227825Stheravenfind_end(_ForwardIterator1 __first1, _ForwardIterator1 __last1, 1005227825Stheraven _ForwardIterator2 __first2, _ForwardIterator2 __last2, _BinaryPredicate __pred) 1006227825Stheraven{ 1007227825Stheraven return _VSTD::__find_end<typename add_lvalue_reference<_BinaryPredicate>::type> 1008227825Stheraven (__first1, __last1, __first2, __last2, __pred, 1009227825Stheraven typename iterator_traits<_ForwardIterator1>::iterator_category(), 1010227825Stheraven typename iterator_traits<_ForwardIterator2>::iterator_category()); 1011227825Stheraven} 1012227825Stheraven 1013227825Stheraventemplate <class _ForwardIterator1, class _ForwardIterator2> 1014227825Stheraveninline _LIBCPP_INLINE_VISIBILITY 1015227825Stheraven_ForwardIterator1 1016227825Stheravenfind_end(_ForwardIterator1 __first1, _ForwardIterator1 __last1, 1017227825Stheraven _ForwardIterator2 __first2, _ForwardIterator2 __last2) 1018227825Stheraven{ 1019227825Stheraven typedef typename iterator_traits<_ForwardIterator1>::value_type __v1; 1020227825Stheraven typedef typename iterator_traits<_ForwardIterator2>::value_type __v2; 1021227825Stheraven return _VSTD::find_end(__first1, __last1, __first2, __last2, __equal_to<__v1, __v2>()); 1022227825Stheraven} 1023227825Stheraven 1024227825Stheraven// find_first_of 1025227825Stheraven 1026227825Stheraventemplate <class _ForwardIterator1, class _ForwardIterator2, class _BinaryPredicate> 1027227825Stheraven_ForwardIterator1 1028227825Stheravenfind_first_of(_ForwardIterator1 __first1, _ForwardIterator1 __last1, 1029227825Stheraven _ForwardIterator2 __first2, _ForwardIterator2 __last2, _BinaryPredicate __pred) 1030227825Stheraven{ 1031227825Stheraven for (; __first1 != __last1; ++__first1) 1032227825Stheraven for (_ForwardIterator2 __j = __first2; __j != __last2; ++__j) 1033227825Stheraven if (__pred(*__first1, *__j)) 1034227825Stheraven return __first1; 1035227825Stheraven return __last1; 1036227825Stheraven} 1037227825Stheraven 1038227825Stheraventemplate <class _ForwardIterator1, class _ForwardIterator2> 1039227825Stheraveninline _LIBCPP_INLINE_VISIBILITY 1040227825Stheraven_ForwardIterator1 1041227825Stheravenfind_first_of(_ForwardIterator1 __first1, _ForwardIterator1 __last1, 1042227825Stheraven _ForwardIterator2 __first2, _ForwardIterator2 __last2) 1043227825Stheraven{ 1044227825Stheraven typedef typename iterator_traits<_ForwardIterator1>::value_type __v1; 1045227825Stheraven typedef typename iterator_traits<_ForwardIterator2>::value_type __v2; 1046227825Stheraven return _VSTD::find_first_of(__first1, __last1, __first2, __last2, __equal_to<__v1, __v2>()); 1047227825Stheraven} 1048227825Stheraven 1049227825Stheraven// adjacent_find 1050227825Stheraven 1051227825Stheraventemplate <class _ForwardIterator, class _BinaryPredicate> 1052227825Stheraveninline _LIBCPP_INLINE_VISIBILITY 1053227825Stheraven_ForwardIterator 1054227825Stheravenadjacent_find(_ForwardIterator __first, _ForwardIterator __last, _BinaryPredicate __pred) 1055227825Stheraven{ 1056227825Stheraven if (__first != __last) 1057227825Stheraven { 1058227825Stheraven _ForwardIterator __i = __first; 1059227825Stheraven while (++__i != __last) 1060227825Stheraven { 1061227825Stheraven if (__pred(*__first, *__i)) 1062227825Stheraven return __first; 1063227825Stheraven __first = __i; 1064227825Stheraven } 1065227825Stheraven } 1066227825Stheraven return __last; 1067227825Stheraven} 1068227825Stheraven 1069227825Stheraventemplate <class _ForwardIterator> 1070227825Stheraveninline _LIBCPP_INLINE_VISIBILITY 1071227825Stheraven_ForwardIterator 1072227825Stheravenadjacent_find(_ForwardIterator __first, _ForwardIterator __last) 1073227825Stheraven{ 1074227825Stheraven typedef typename iterator_traits<_ForwardIterator>::value_type __v; 1075227825Stheraven return _VSTD::adjacent_find(__first, __last, __equal_to<__v>()); 1076227825Stheraven} 1077227825Stheraven 1078227825Stheraven// count 1079227825Stheraven 1080227825Stheraventemplate <class _InputIterator, class _Tp> 1081227825Stheraveninline _LIBCPP_INLINE_VISIBILITY 1082227825Stheraventypename iterator_traits<_InputIterator>::difference_type 1083227825Stheravencount(_InputIterator __first, _InputIterator __last, const _Tp& __value_) 1084227825Stheraven{ 1085227825Stheraven typename iterator_traits<_InputIterator>::difference_type __r(0); 1086227825Stheraven for (; __first != __last; ++__first) 1087227825Stheraven if (*__first == __value_) 1088227825Stheraven ++__r; 1089227825Stheraven return __r; 1090227825Stheraven} 1091227825Stheraven 1092227825Stheraven// count_if 1093227825Stheraven 1094227825Stheraventemplate <class _InputIterator, class _Predicate> 1095227825Stheraveninline _LIBCPP_INLINE_VISIBILITY 1096227825Stheraventypename iterator_traits<_InputIterator>::difference_type 1097227825Stheravencount_if(_InputIterator __first, _InputIterator __last, _Predicate __pred) 1098227825Stheraven{ 1099227825Stheraven typename iterator_traits<_InputIterator>::difference_type __r(0); 1100227825Stheraven for (; __first != __last; ++__first) 1101227825Stheraven if (__pred(*__first)) 1102227825Stheraven ++__r; 1103227825Stheraven return __r; 1104227825Stheraven} 1105227825Stheraven 1106227825Stheraven// mismatch 1107227825Stheraven 1108227825Stheraventemplate <class _InputIterator1, class _InputIterator2, class _BinaryPredicate> 1109227825Stheraveninline _LIBCPP_INLINE_VISIBILITY 1110227825Stheravenpair<_InputIterator1, _InputIterator2> 1111227825Stheravenmismatch(_InputIterator1 __first1, _InputIterator1 __last1, 1112227825Stheraven _InputIterator2 __first2, _BinaryPredicate __pred) 1113227825Stheraven{ 1114227825Stheraven for (; __first1 != __last1; ++__first1, ++__first2) 1115227825Stheraven if (!__pred(*__first1, *__first2)) 1116227825Stheraven break; 1117227825Stheraven return pair<_InputIterator1, _InputIterator2>(__first1, __first2); 1118227825Stheraven} 1119227825Stheraven 1120227825Stheraventemplate <class _InputIterator1, class _InputIterator2> 1121227825Stheraveninline _LIBCPP_INLINE_VISIBILITY 1122227825Stheravenpair<_InputIterator1, _InputIterator2> 1123227825Stheravenmismatch(_InputIterator1 __first1, _InputIterator1 __last1, _InputIterator2 __first2) 1124227825Stheraven{ 1125227825Stheraven typedef typename iterator_traits<_InputIterator1>::value_type __v1; 1126227825Stheraven typedef typename iterator_traits<_InputIterator2>::value_type __v2; 1127227825Stheraven return _VSTD::mismatch(__first1, __last1, __first2, __equal_to<__v1, __v2>()); 1128227825Stheraven} 1129227825Stheraven 1130253159Stheraven#if _LIBCPP_STD_VER > 11 1131253159Stheraventemplate <class _InputIterator1, class _InputIterator2, class _BinaryPredicate> 1132253159Stheraveninline _LIBCPP_INLINE_VISIBILITY 1133253159Stheravenpair<_InputIterator1, _InputIterator2> 1134253159Stheravenmismatch(_InputIterator1 __first1, _InputIterator1 __last1, 1135253159Stheraven _InputIterator2 __first2, _InputIterator2 __last2, 1136253159Stheraven _BinaryPredicate __pred) 1137253159Stheraven{ 1138253159Stheraven for (; __first1 != __last1 && __first2 != __last2; ++__first1, ++__first2) 1139253159Stheraven if (!__pred(*__first1, *__first2)) 1140253159Stheraven break; 1141253159Stheraven return pair<_InputIterator1, _InputIterator2>(__first1, __first2); 1142253159Stheraven} 1143253159Stheraven 1144253159Stheraventemplate <class _InputIterator1, class _InputIterator2> 1145253159Stheraveninline _LIBCPP_INLINE_VISIBILITY 1146253159Stheravenpair<_InputIterator1, _InputIterator2> 1147253159Stheravenmismatch(_InputIterator1 __first1, _InputIterator1 __last1, 1148253159Stheraven _InputIterator2 __first2, _InputIterator2 __last2) 1149253159Stheraven{ 1150253159Stheraven typedef typename iterator_traits<_InputIterator1>::value_type __v1; 1151253159Stheraven typedef typename iterator_traits<_InputIterator2>::value_type __v2; 1152253159Stheraven return _VSTD::mismatch(__first1, __last1, __first2, __last2, __equal_to<__v1, __v2>()); 1153253159Stheraven} 1154253159Stheraven#endif 1155253159Stheraven 1156227825Stheraven// equal 1157227825Stheraven 1158227825Stheraventemplate <class _InputIterator1, class _InputIterator2, class _BinaryPredicate> 1159227825Stheraveninline _LIBCPP_INLINE_VISIBILITY 1160227825Stheravenbool 1161227825Stheravenequal(_InputIterator1 __first1, _InputIterator1 __last1, _InputIterator2 __first2, _BinaryPredicate __pred) 1162227825Stheraven{ 1163227825Stheraven for (; __first1 != __last1; ++__first1, ++__first2) 1164227825Stheraven if (!__pred(*__first1, *__first2)) 1165227825Stheraven return false; 1166227825Stheraven return true; 1167227825Stheraven} 1168227825Stheraven 1169227825Stheraventemplate <class _InputIterator1, class _InputIterator2> 1170227825Stheraveninline _LIBCPP_INLINE_VISIBILITY 1171227825Stheravenbool 1172227825Stheravenequal(_InputIterator1 __first1, _InputIterator1 __last1, _InputIterator2 __first2) 1173227825Stheraven{ 1174227825Stheraven typedef typename iterator_traits<_InputIterator1>::value_type __v1; 1175227825Stheraven typedef typename iterator_traits<_InputIterator2>::value_type __v2; 1176227825Stheraven return _VSTD::equal(__first1, __last1, __first2, __equal_to<__v1, __v2>()); 1177227825Stheraven} 1178227825Stheraven 1179253159Stheraven#if _LIBCPP_STD_VER > 11 1180253159Stheraventemplate <class _BinaryPredicate, class _InputIterator1, class _InputIterator2> 1181253159Stheraveninline _LIBCPP_INLINE_VISIBILITY 1182253159Stheravenbool 1183253159Stheraven__equal(_InputIterator1 __first1, _InputIterator1 __last1, 1184253159Stheraven _InputIterator2 __first2, _InputIterator2 __last2, _BinaryPredicate __pred, 1185253159Stheraven input_iterator_tag, input_iterator_tag ) 1186253159Stheraven{ 1187253159Stheraven for (; __first1 != __last1 && __first2 != __last2; ++__first1, ++__first2) 1188253159Stheraven if (!__pred(*__first1, *__first2)) 1189253159Stheraven return false; 1190253159Stheraven return __first1 == __last1 && __first2 == __last2; 1191253159Stheraven} 1192253159Stheraven 1193253159Stheraventemplate <class _BinaryPredicate, class _RandomAccessIterator1, class _RandomAccessIterator2> 1194253159Stheraveninline _LIBCPP_INLINE_VISIBILITY 1195253159Stheravenbool 1196253159Stheraven__equal(_RandomAccessIterator1 __first1, _RandomAccessIterator1 __last1, 1197253159Stheraven _RandomAccessIterator2 __first2, _RandomAccessIterator2 __last2, _BinaryPredicate __pred, 1198253159Stheraven random_access_iterator_tag, random_access_iterator_tag ) 1199253159Stheraven{ 1200253159Stheraven if ( _VSTD::distance(__first1, __last1) != _VSTD::distance(__first2, __last2)) 1201253159Stheraven return false; 1202253159Stheraven return _VSTD::equal<_RandomAccessIterator1, _RandomAccessIterator2, 1203253159Stheraven typename add_lvalue_reference<_BinaryPredicate>::type> 1204253159Stheraven (__first1, __last1, __first2, __pred ); 1205253159Stheraven} 1206253159Stheraven 1207253159Stheraventemplate <class _InputIterator1, class _InputIterator2, class _BinaryPredicate> 1208253159Stheraveninline _LIBCPP_INLINE_VISIBILITY 1209253159Stheravenbool 1210253159Stheravenequal(_InputIterator1 __first1, _InputIterator1 __last1, 1211253159Stheraven _InputIterator2 __first2, _InputIterator2 __last2, _BinaryPredicate __pred ) 1212253159Stheraven{ 1213253159Stheraven return _VSTD::__equal<typename add_lvalue_reference<_BinaryPredicate>::type> 1214253159Stheraven (__first1, __last1, __first2, __last2, __pred, 1215253159Stheraven typename iterator_traits<_InputIterator1>::iterator_category(), 1216253159Stheraven typename iterator_traits<_InputIterator2>::iterator_category()); 1217253159Stheraven} 1218253159Stheraven 1219253159Stheraventemplate <class _InputIterator1, class _InputIterator2> 1220253159Stheraveninline _LIBCPP_INLINE_VISIBILITY 1221253159Stheravenbool 1222253159Stheravenequal(_InputIterator1 __first1, _InputIterator1 __last1, 1223253159Stheraven _InputIterator2 __first2, _InputIterator2 __last2) 1224253159Stheraven{ 1225253159Stheraven typedef typename iterator_traits<_InputIterator1>::value_type __v1; 1226253159Stheraven typedef typename iterator_traits<_InputIterator2>::value_type __v2; 1227253159Stheraven return _VSTD::__equal(__first1, __last1, __first2, __last2, __equal_to<__v1, __v2>(), 1228253159Stheraven typename iterator_traits<_InputIterator1>::iterator_category(), 1229253159Stheraven typename iterator_traits<_InputIterator2>::iterator_category()); 1230253159Stheraven} 1231253159Stheraven#endif 1232253159Stheraven 1233227825Stheraven// is_permutation 1234227825Stheraven 1235227825Stheraventemplate<class _ForwardIterator1, class _ForwardIterator2, class _BinaryPredicate> 1236227825Stheravenbool 1237227825Stheravenis_permutation(_ForwardIterator1 __first1, _ForwardIterator1 __last1, 1238227825Stheraven _ForwardIterator2 __first2, _BinaryPredicate __pred) 1239227825Stheraven{ 1240227825Stheraven // shorten sequences as much as possible by lopping of any equal parts 1241227825Stheraven for (; __first1 != __last1; ++__first1, ++__first2) 1242227825Stheraven if (!__pred(*__first1, *__first2)) 1243227825Stheraven goto __not_done; 1244227825Stheraven return true; 1245227825Stheraven__not_done: 1246227825Stheraven // __first1 != __last1 && *__first1 != *__first2 1247227825Stheraven typedef typename iterator_traits<_ForwardIterator1>::difference_type _D1; 1248227825Stheraven _D1 __l1 = _VSTD::distance(__first1, __last1); 1249227825Stheraven if (__l1 == _D1(1)) 1250227825Stheraven return false; 1251227825Stheraven _ForwardIterator2 __last2 = _VSTD::next(__first2, __l1); 1252227825Stheraven // For each element in [f1, l1) see if there are the same number of 1253227825Stheraven // equal elements in [f2, l2) 1254227825Stheraven for (_ForwardIterator1 __i = __first1; __i != __last1; ++__i) 1255227825Stheraven { 1256227825Stheraven // Have we already counted the number of *__i in [f1, l1)? 1257227825Stheraven for (_ForwardIterator1 __j = __first1; __j != __i; ++__j) 1258227825Stheraven if (__pred(*__j, *__i)) 1259227825Stheraven goto __next_iter; 1260227825Stheraven { 1261227825Stheraven // Count number of *__i in [f2, l2) 1262227825Stheraven _D1 __c2 = 0; 1263227825Stheraven for (_ForwardIterator2 __j = __first2; __j != __last2; ++__j) 1264227825Stheraven if (__pred(*__i, *__j)) 1265227825Stheraven ++__c2; 1266227825Stheraven if (__c2 == 0) 1267227825Stheraven return false; 1268227825Stheraven // Count number of *__i in [__i, l1) (we can start with 1) 1269227825Stheraven _D1 __c1 = 1; 1270227825Stheraven for (_ForwardIterator1 __j = _VSTD::next(__i); __j != __last1; ++__j) 1271227825Stheraven if (__pred(*__i, *__j)) 1272227825Stheraven ++__c1; 1273227825Stheraven if (__c1 != __c2) 1274227825Stheraven return false; 1275227825Stheraven } 1276227825Stheraven__next_iter:; 1277227825Stheraven } 1278227825Stheraven return true; 1279227825Stheraven} 1280227825Stheraven 1281227825Stheraventemplate<class _ForwardIterator1, class _ForwardIterator2> 1282227825Stheraveninline _LIBCPP_INLINE_VISIBILITY 1283227825Stheravenbool 1284227825Stheravenis_permutation(_ForwardIterator1 __first1, _ForwardIterator1 __last1, 1285227825Stheraven _ForwardIterator2 __first2) 1286227825Stheraven{ 1287227825Stheraven typedef typename iterator_traits<_ForwardIterator1>::value_type __v1; 1288227825Stheraven typedef typename iterator_traits<_ForwardIterator2>::value_type __v2; 1289227825Stheraven return _VSTD::is_permutation(__first1, __last1, __first2, __equal_to<__v1, __v2>()); 1290227825Stheraven} 1291227825Stheraven 1292253159Stheraven#if _LIBCPP_STD_VER > 11 1293253159Stheraventemplate<class _BinaryPredicate, class _ForwardIterator1, class _ForwardIterator2> 1294253159Stheravenbool 1295253159Stheraven__is_permutation(_ForwardIterator1 __first1, _ForwardIterator1 __last1, 1296253159Stheraven _ForwardIterator2 __first2, _ForwardIterator2 __last2, 1297253159Stheraven _BinaryPredicate __pred, 1298253159Stheraven forward_iterator_tag, forward_iterator_tag ) 1299253159Stheraven{ 1300253159Stheraven // shorten sequences as much as possible by lopping of any equal parts 1301253159Stheraven for (; __first1 != __last1 && __first2 != __last2; ++__first1, ++__first2) 1302253159Stheraven if (!__pred(*__first1, *__first2)) 1303253159Stheraven goto __not_done; 1304253159Stheraven return __first1 == __last1 && __first2 == __last2; 1305253159Stheraven__not_done: 1306253159Stheraven // __first1 != __last1 && __first2 != __last2 && *__first1 != *__first2 1307253159Stheraven typedef typename iterator_traits<_ForwardIterator1>::difference_type _D1; 1308253159Stheraven _D1 __l1 = _VSTD::distance(__first1, __last1); 1309253159Stheraven 1310253159Stheraven typedef typename iterator_traits<_ForwardIterator2>::difference_type _D2; 1311253159Stheraven _D2 __l2 = _VSTD::distance(__first2, __last2); 1312253159Stheraven if (__l1 != __l2) 1313253159Stheraven return false; 1314253159Stheraven 1315253159Stheraven // For each element in [f1, l1) see if there are the same number of 1316253159Stheraven // equal elements in [f2, l2) 1317253159Stheraven for (_ForwardIterator1 __i = __first1; __i != __last1; ++__i) 1318253159Stheraven { 1319253159Stheraven // Have we already counted the number of *__i in [f1, l1)? 1320253159Stheraven for (_ForwardIterator1 __j = __first1; __j != __i; ++__j) 1321253159Stheraven if (__pred(*__j, *__i)) 1322253159Stheraven goto __next_iter; 1323253159Stheraven { 1324253159Stheraven // Count number of *__i in [f2, l2) 1325253159Stheraven _D1 __c2 = 0; 1326253159Stheraven for (_ForwardIterator2 __j = __first2; __j != __last2; ++__j) 1327253159Stheraven if (__pred(*__i, *__j)) 1328253159Stheraven ++__c2; 1329253159Stheraven if (__c2 == 0) 1330253159Stheraven return false; 1331253159Stheraven // Count number of *__i in [__i, l1) (we can start with 1) 1332253159Stheraven _D1 __c1 = 1; 1333253159Stheraven for (_ForwardIterator1 __j = _VSTD::next(__i); __j != __last1; ++__j) 1334253159Stheraven if (__pred(*__i, *__j)) 1335253159Stheraven ++__c1; 1336253159Stheraven if (__c1 != __c2) 1337253159Stheraven return false; 1338253159Stheraven } 1339253159Stheraven__next_iter:; 1340253159Stheraven } 1341253159Stheraven return true; 1342253159Stheraven} 1343253159Stheraven 1344253159Stheraventemplate<class _BinaryPredicate, class _RandomAccessIterator1, class _RandomAccessIterator2> 1345253159Stheravenbool 1346253159Stheraven__is_permutation(_RandomAccessIterator1 __first1, _RandomAccessIterator2 __last1, 1347253159Stheraven _RandomAccessIterator1 __first2, _RandomAccessIterator2 __last2, 1348253159Stheraven _BinaryPredicate __pred, 1349253159Stheraven random_access_iterator_tag, random_access_iterator_tag ) 1350253159Stheraven{ 1351253159Stheraven if ( _VSTD::distance(__first1, __last1) != _VSTD::distance(__first2, __last2)) 1352253159Stheraven return false; 1353253159Stheraven return _VSTD::is_permutation<_RandomAccessIterator1, _RandomAccessIterator2, 1354253159Stheraven typename add_lvalue_reference<_BinaryPredicate>::type> 1355253159Stheraven (__first1, __last1, __first2, __pred ); 1356253159Stheraven} 1357253159Stheraven 1358253159Stheraventemplate<class _ForwardIterator1, class _ForwardIterator2, class _BinaryPredicate> 1359253159Stheraveninline _LIBCPP_INLINE_VISIBILITY 1360253159Stheravenbool 1361253159Stheravenis_permutation(_ForwardIterator1 __first1, _ForwardIterator1 __last1, 1362253159Stheraven _ForwardIterator2 __first2, _ForwardIterator2 __last2, 1363253159Stheraven _BinaryPredicate __pred ) 1364253159Stheraven{ 1365253159Stheraven return _VSTD::__is_permutation<typename add_lvalue_reference<_BinaryPredicate>::type> 1366253159Stheraven (__first1, __last1, __first2, __last2, __pred, 1367253159Stheraven typename iterator_traits<_ForwardIterator1>::iterator_category(), 1368253159Stheraven typename iterator_traits<_ForwardIterator2>::iterator_category()); 1369253159Stheraven} 1370253159Stheraven 1371253159Stheraventemplate<class _ForwardIterator1, class _ForwardIterator2> 1372253159Stheraveninline _LIBCPP_INLINE_VISIBILITY 1373253159Stheravenbool 1374253159Stheravenis_permutation(_ForwardIterator1 __first1, _ForwardIterator1 __last1, 1375253159Stheraven _ForwardIterator2 __first2, _ForwardIterator2 __last2) 1376253159Stheraven{ 1377253159Stheraven typedef typename iterator_traits<_ForwardIterator1>::value_type __v1; 1378253159Stheraven typedef typename iterator_traits<_ForwardIterator2>::value_type __v2; 1379253159Stheraven return _VSTD::__is_permutation(__first1, __last1, __first2, __last2, 1380253159Stheraven __equal_to<__v1, __v2>(), 1381253159Stheraven typename iterator_traits<_ForwardIterator1>::iterator_category(), 1382253159Stheraven typename iterator_traits<_ForwardIterator2>::iterator_category()); 1383253159Stheraven} 1384253159Stheraven#endif 1385253159Stheraven 1386227825Stheraven// search 1387227825Stheraven 1388227825Stheraventemplate <class _BinaryPredicate, class _ForwardIterator1, class _ForwardIterator2> 1389227825Stheraven_ForwardIterator1 1390227825Stheraven__search(_ForwardIterator1 __first1, _ForwardIterator1 __last1, 1391227825Stheraven _ForwardIterator2 __first2, _ForwardIterator2 __last2, _BinaryPredicate __pred, 1392227825Stheraven forward_iterator_tag, forward_iterator_tag) 1393227825Stheraven{ 1394227825Stheraven if (__first2 == __last2) 1395227825Stheraven return __first1; // Everything matches an empty sequence 1396227825Stheraven while (true) 1397227825Stheraven { 1398227825Stheraven // Find first element in sequence 1 that matchs *__first2, with a mininum of loop checks 1399227825Stheraven while (true) 1400227825Stheraven { 1401227825Stheraven if (__first1 == __last1) // return __last1 if no element matches *__first2 1402227825Stheraven return __last1; 1403227825Stheraven if (__pred(*__first1, *__first2)) 1404227825Stheraven break; 1405227825Stheraven ++__first1; 1406227825Stheraven } 1407227825Stheraven // *__first1 matches *__first2, now match elements after here 1408227825Stheraven _ForwardIterator1 __m1 = __first1; 1409227825Stheraven _ForwardIterator2 __m2 = __first2; 1410227825Stheraven while (true) 1411227825Stheraven { 1412227825Stheraven if (++__m2 == __last2) // If pattern exhausted, __first1 is the answer (works for 1 element pattern) 1413227825Stheraven return __first1; 1414227825Stheraven if (++__m1 == __last1) // Otherwise if source exhaused, pattern not found 1415227825Stheraven return __last1; 1416227825Stheraven if (!__pred(*__m1, *__m2)) // if there is a mismatch, restart with a new __first1 1417227825Stheraven { 1418227825Stheraven ++__first1; 1419227825Stheraven break; 1420227825Stheraven } // else there is a match, check next elements 1421227825Stheraven } 1422227825Stheraven } 1423227825Stheraven} 1424227825Stheraven 1425227825Stheraventemplate <class _BinaryPredicate, class _RandomAccessIterator1, class _RandomAccessIterator2> 1426227825Stheraven_RandomAccessIterator1 1427227825Stheraven__search(_RandomAccessIterator1 __first1, _RandomAccessIterator1 __last1, 1428227825Stheraven _RandomAccessIterator2 __first2, _RandomAccessIterator2 __last2, _BinaryPredicate __pred, 1429227825Stheraven random_access_iterator_tag, random_access_iterator_tag) 1430227825Stheraven{ 1431227825Stheraven typedef typename std::iterator_traits<_RandomAccessIterator1>::difference_type _D1; 1432227825Stheraven typedef typename std::iterator_traits<_RandomAccessIterator2>::difference_type _D2; 1433227825Stheraven // Take advantage of knowing source and pattern lengths. Stop short when source is smaller than pattern 1434227825Stheraven _D2 __len2 = __last2 - __first2; 1435227825Stheraven if (__len2 == 0) 1436227825Stheraven return __first1; 1437227825Stheraven _D1 __len1 = __last1 - __first1; 1438227825Stheraven if (__len1 < __len2) 1439227825Stheraven return __last1; 1440227825Stheraven const _RandomAccessIterator1 __s = __last1 - (__len2 - 1); // Start of pattern match can't go beyond here 1441227825Stheraven while (true) 1442227825Stheraven { 1443227825Stheraven#if !_LIBCPP_UNROLL_LOOPS 1444227825Stheraven while (true) 1445227825Stheraven { 1446227825Stheraven if (__first1 == __s) 1447227825Stheraven return __last1; 1448227825Stheraven if (__pred(*__first1, *__first2)) 1449227825Stheraven break; 1450227825Stheraven ++__first1; 1451227825Stheraven } 1452227825Stheraven#else // !_LIBCPP_UNROLL_LOOPS 1453227825Stheraven for (_D1 __loop_unroll = (__s - __first1) / 4; __loop_unroll > 0; --__loop_unroll) 1454227825Stheraven { 1455227825Stheraven if (__pred(*__first1, *__first2)) 1456227825Stheraven goto __phase2; 1457227825Stheraven if (__pred(*++__first1, *__first2)) 1458227825Stheraven goto __phase2; 1459227825Stheraven if (__pred(*++__first1, *__first2)) 1460227825Stheraven goto __phase2; 1461227825Stheraven if (__pred(*++__first1, *__first2)) 1462227825Stheraven goto __phase2; 1463227825Stheraven ++__first1; 1464227825Stheraven } 1465227825Stheraven switch (__s - __first1) 1466227825Stheraven { 1467227825Stheraven case 3: 1468227825Stheraven if (__pred(*__first1, *__first2)) 1469227825Stheraven break; 1470227825Stheraven ++__first1; 1471227825Stheraven case 2: 1472227825Stheraven if (__pred(*__first1, *__first2)) 1473227825Stheraven break; 1474227825Stheraven ++__first1; 1475227825Stheraven case 1: 1476227825Stheraven if (__pred(*__first1, *__first2)) 1477227825Stheraven break; 1478227825Stheraven case 0: 1479227825Stheraven return __last1; 1480227825Stheraven } 1481227825Stheraven __phase2: 1482227825Stheraven#endif // !_LIBCPP_UNROLL_LOOPS 1483227825Stheraven _RandomAccessIterator1 __m1 = __first1; 1484227825Stheraven _RandomAccessIterator2 __m2 = __first2; 1485227825Stheraven#if !_LIBCPP_UNROLL_LOOPS 1486227825Stheraven while (true) 1487227825Stheraven { 1488227825Stheraven if (++__m2 == __last2) 1489227825Stheraven return __first1; 1490227825Stheraven ++__m1; // no need to check range on __m1 because __s guarantees we have enough source 1491227825Stheraven if (!__pred(*__m1, *__m2)) 1492227825Stheraven { 1493227825Stheraven ++__first1; 1494227825Stheraven break; 1495227825Stheraven } 1496227825Stheraven } 1497227825Stheraven#else // !_LIBCPP_UNROLL_LOOPS 1498227825Stheraven ++__m2; 1499227825Stheraven ++__m1; 1500227825Stheraven for (_D2 __loop_unroll = (__last2 - __m2) / 4; __loop_unroll > 0; --__loop_unroll) 1501227825Stheraven { 1502227825Stheraven if (!__pred(*__m1, *__m2)) 1503227825Stheraven goto __continue; 1504227825Stheraven if (!__pred(*++__m1, *++__m2)) 1505227825Stheraven goto __continue; 1506227825Stheraven if (!__pred(*++__m1, *++__m2)) 1507227825Stheraven goto __continue; 1508227825Stheraven if (!__pred(*++__m1, *++__m2)) 1509227825Stheraven goto __continue; 1510227825Stheraven ++__m1; 1511227825Stheraven ++__m2; 1512227825Stheraven } 1513227825Stheraven switch (__last2 - __m2) 1514227825Stheraven { 1515227825Stheraven case 3: 1516227825Stheraven if (!__pred(*__m1, *__m2)) 1517227825Stheraven break; 1518227825Stheraven ++__m1; 1519227825Stheraven ++__m2; 1520227825Stheraven case 2: 1521227825Stheraven if (!__pred(*__m1, *__m2)) 1522227825Stheraven break; 1523227825Stheraven ++__m1; 1524227825Stheraven ++__m2; 1525227825Stheraven case 1: 1526227825Stheraven if (!__pred(*__m1, *__m2)) 1527227825Stheraven break; 1528227825Stheraven case 0: 1529227825Stheraven return __first1; 1530227825Stheraven } 1531227825Stheraven __continue: 1532227825Stheraven ++__first1; 1533227825Stheraven#endif // !_LIBCPP_UNROLL_LOOPS 1534227825Stheraven } 1535227825Stheraven} 1536227825Stheraven 1537227825Stheraventemplate <class _ForwardIterator1, class _ForwardIterator2, class _BinaryPredicate> 1538227825Stheraveninline _LIBCPP_INLINE_VISIBILITY 1539227825Stheraven_ForwardIterator1 1540227825Stheravensearch(_ForwardIterator1 __first1, _ForwardIterator1 __last1, 1541227825Stheraven _ForwardIterator2 __first2, _ForwardIterator2 __last2, _BinaryPredicate __pred) 1542227825Stheraven{ 1543227825Stheraven return _VSTD::__search<typename add_lvalue_reference<_BinaryPredicate>::type> 1544227825Stheraven (__first1, __last1, __first2, __last2, __pred, 1545227825Stheraven typename std::iterator_traits<_ForwardIterator1>::iterator_category(), 1546227825Stheraven typename std::iterator_traits<_ForwardIterator2>::iterator_category()); 1547227825Stheraven} 1548227825Stheraven 1549227825Stheraventemplate <class _ForwardIterator1, class _ForwardIterator2> 1550227825Stheraveninline _LIBCPP_INLINE_VISIBILITY 1551227825Stheraven_ForwardIterator1 1552227825Stheravensearch(_ForwardIterator1 __first1, _ForwardIterator1 __last1, 1553227825Stheraven _ForwardIterator2 __first2, _ForwardIterator2 __last2) 1554227825Stheraven{ 1555227825Stheraven typedef typename std::iterator_traits<_ForwardIterator1>::value_type __v1; 1556227825Stheraven typedef typename std::iterator_traits<_ForwardIterator2>::value_type __v2; 1557227825Stheraven return _VSTD::search(__first1, __last1, __first2, __last2, __equal_to<__v1, __v2>()); 1558227825Stheraven} 1559227825Stheraven 1560227825Stheraven// search_n 1561227825Stheraven 1562227825Stheraventemplate <class _BinaryPredicate, class _ForwardIterator, class _Size, class _Tp> 1563227825Stheraven_ForwardIterator 1564227825Stheraven__search_n(_ForwardIterator __first, _ForwardIterator __last, 1565227825Stheraven _Size __count, const _Tp& __value_, _BinaryPredicate __pred, forward_iterator_tag) 1566227825Stheraven{ 1567227825Stheraven if (__count <= 0) 1568227825Stheraven return __first; 1569227825Stheraven while (true) 1570227825Stheraven { 1571227825Stheraven // Find first element in sequence that matchs __value_, with a mininum of loop checks 1572227825Stheraven while (true) 1573227825Stheraven { 1574227825Stheraven if (__first == __last) // return __last if no element matches __value_ 1575227825Stheraven return __last; 1576227825Stheraven if (__pred(*__first, __value_)) 1577227825Stheraven break; 1578227825Stheraven ++__first; 1579227825Stheraven } 1580227825Stheraven // *__first matches __value_, now match elements after here 1581227825Stheraven _ForwardIterator __m = __first; 1582227825Stheraven _Size __c(0); 1583227825Stheraven while (true) 1584227825Stheraven { 1585227825Stheraven if (++__c == __count) // If pattern exhausted, __first is the answer (works for 1 element pattern) 1586227825Stheraven return __first; 1587227825Stheraven if (++__m == __last) // Otherwise if source exhaused, pattern not found 1588227825Stheraven return __last; 1589227825Stheraven if (!__pred(*__m, __value_)) // if there is a mismatch, restart with a new __first 1590227825Stheraven { 1591227825Stheraven __first = __m; 1592227825Stheraven ++__first; 1593227825Stheraven break; 1594227825Stheraven } // else there is a match, check next elements 1595227825Stheraven } 1596227825Stheraven } 1597227825Stheraven} 1598227825Stheraven 1599227825Stheraventemplate <class _BinaryPredicate, class _RandomAccessIterator, class _Size, class _Tp> 1600227825Stheraven_RandomAccessIterator 1601227825Stheraven__search_n(_RandomAccessIterator __first, _RandomAccessIterator __last, 1602227825Stheraven _Size __count, const _Tp& __value_, _BinaryPredicate __pred, random_access_iterator_tag) 1603227825Stheraven{ 1604227825Stheraven if (__count <= 0) 1605227825Stheraven return __first; 1606227825Stheraven _Size __len = static_cast<_Size>(__last - __first); 1607227825Stheraven if (__len < __count) 1608227825Stheraven return __last; 1609227825Stheraven const _RandomAccessIterator __s = __last - (__count - 1); // Start of pattern match can't go beyond here 1610227825Stheraven while (true) 1611227825Stheraven { 1612227825Stheraven // Find first element in sequence that matchs __value_, with a mininum of loop checks 1613227825Stheraven while (true) 1614227825Stheraven { 1615249998Sdim if (__first >= __s) // return __last if no element matches __value_ 1616227825Stheraven return __last; 1617227825Stheraven if (__pred(*__first, __value_)) 1618227825Stheraven break; 1619227825Stheraven ++__first; 1620227825Stheraven } 1621227825Stheraven // *__first matches __value_, now match elements after here 1622227825Stheraven _RandomAccessIterator __m = __first; 1623227825Stheraven _Size __c(0); 1624227825Stheraven while (true) 1625227825Stheraven { 1626227825Stheraven if (++__c == __count) // If pattern exhausted, __first is the answer (works for 1 element pattern) 1627227825Stheraven return __first; 1628227825Stheraven ++__m; // no need to check range on __m because __s guarantees we have enough source 1629227825Stheraven if (!__pred(*__m, __value_)) // if there is a mismatch, restart with a new __first 1630227825Stheraven { 1631227825Stheraven __first = __m; 1632227825Stheraven ++__first; 1633227825Stheraven break; 1634227825Stheraven } // else there is a match, check next elements 1635227825Stheraven } 1636227825Stheraven } 1637227825Stheraven} 1638227825Stheraven 1639227825Stheraventemplate <class _ForwardIterator, class _Size, class _Tp, class _BinaryPredicate> 1640227825Stheraveninline _LIBCPP_INLINE_VISIBILITY 1641227825Stheraven_ForwardIterator 1642227825Stheravensearch_n(_ForwardIterator __first, _ForwardIterator __last, 1643227825Stheraven _Size __count, const _Tp& __value_, _BinaryPredicate __pred) 1644227825Stheraven{ 1645227825Stheraven return _VSTD::__search_n<typename add_lvalue_reference<_BinaryPredicate>::type> 1646227825Stheraven (__first, __last, __count, __value_, __pred, typename iterator_traits<_ForwardIterator>::iterator_category()); 1647227825Stheraven} 1648227825Stheraven 1649227825Stheraventemplate <class _ForwardIterator, class _Size, class _Tp> 1650227825Stheraveninline _LIBCPP_INLINE_VISIBILITY 1651227825Stheraven_ForwardIterator 1652227825Stheravensearch_n(_ForwardIterator __first, _ForwardIterator __last, _Size __count, const _Tp& __value_) 1653227825Stheraven{ 1654227825Stheraven typedef typename iterator_traits<_ForwardIterator>::value_type __v; 1655227825Stheraven return _VSTD::search_n(__first, __last, __count, __value_, __equal_to<__v, _Tp>()); 1656227825Stheraven} 1657227825Stheraven 1658227825Stheraven// copy 1659227825Stheraven 1660227825Stheraventemplate <class _Iter> 1661227825Stheravenstruct __libcpp_is_trivial_iterator 1662227825Stheraven{ 1663227825Stheraven static const bool value = is_pointer<_Iter>::value; 1664227825Stheraven}; 1665227825Stheraven 1666227825Stheraventemplate <class _Iter> 1667227825Stheravenstruct __libcpp_is_trivial_iterator<move_iterator<_Iter> > 1668227825Stheraven{ 1669227825Stheraven static const bool value = is_pointer<_Iter>::value; 1670227825Stheraven}; 1671227825Stheraven 1672227825Stheraventemplate <class _Iter> 1673227825Stheravenstruct __libcpp_is_trivial_iterator<__wrap_iter<_Iter> > 1674227825Stheraven{ 1675227825Stheraven static const bool value = is_pointer<_Iter>::value; 1676227825Stheraven}; 1677227825Stheraven 1678227825Stheraventemplate <class _Iter> 1679227825Stheraveninline _LIBCPP_INLINE_VISIBILITY 1680227825Stheraven_Iter 1681227825Stheraven__unwrap_iter(_Iter __i) 1682227825Stheraven{ 1683227825Stheraven return __i; 1684227825Stheraven} 1685227825Stheraven 1686227825Stheraventemplate <class _Tp> 1687227825Stheraveninline _LIBCPP_INLINE_VISIBILITY 1688227825Stheraventypename enable_if 1689227825Stheraven< 1690227825Stheraven is_trivially_copy_assignable<_Tp>::value, 1691227825Stheraven _Tp* 1692227825Stheraven>::type 1693227825Stheraven__unwrap_iter(move_iterator<_Tp*> __i) 1694227825Stheraven{ 1695227825Stheraven return __i.base(); 1696227825Stheraven} 1697227825Stheraven 1698262801Sdim#if _LIBCPP_DEBUG_LEVEL < 2 1699262801Sdim 1700227825Stheraventemplate <class _Tp> 1701227825Stheraveninline _LIBCPP_INLINE_VISIBILITY 1702227825Stheraventypename enable_if 1703227825Stheraven< 1704227825Stheraven is_trivially_copy_assignable<_Tp>::value, 1705227825Stheraven _Tp* 1706227825Stheraven>::type 1707227825Stheraven__unwrap_iter(__wrap_iter<_Tp*> __i) 1708227825Stheraven{ 1709227825Stheraven return __i.base(); 1710227825Stheraven} 1711227825Stheraven 1712262801Sdim#endif // _LIBCPP_DEBUG_LEVEL < 2 1713262801Sdim 1714227825Stheraventemplate <class _InputIterator, class _OutputIterator> 1715227825Stheraveninline _LIBCPP_INLINE_VISIBILITY 1716227825Stheraven_OutputIterator 1717227825Stheraven__copy(_InputIterator __first, _InputIterator __last, _OutputIterator __result) 1718227825Stheraven{ 1719227825Stheraven for (; __first != __last; ++__first, ++__result) 1720227825Stheraven *__result = *__first; 1721227825Stheraven return __result; 1722227825Stheraven} 1723227825Stheraven 1724227825Stheraventemplate <class _Tp, class _Up> 1725227825Stheraveninline _LIBCPP_INLINE_VISIBILITY 1726227825Stheraventypename enable_if 1727227825Stheraven< 1728227825Stheraven is_same<typename remove_const<_Tp>::type, _Up>::value && 1729227825Stheraven is_trivially_copy_assignable<_Up>::value, 1730227825Stheraven _Up* 1731227825Stheraven>::type 1732227825Stheraven__copy(_Tp* __first, _Tp* __last, _Up* __result) 1733227825Stheraven{ 1734227825Stheraven const size_t __n = static_cast<size_t>(__last - __first); 1735227825Stheraven _VSTD::memmove(__result, __first, __n * sizeof(_Up)); 1736227825Stheraven return __result + __n; 1737227825Stheraven} 1738227825Stheraven 1739227825Stheraventemplate <class _InputIterator, class _OutputIterator> 1740227825Stheraveninline _LIBCPP_INLINE_VISIBILITY 1741227825Stheraven_OutputIterator 1742227825Stheravencopy(_InputIterator __first, _InputIterator __last, _OutputIterator __result) 1743227825Stheraven{ 1744227825Stheraven return _VSTD::__copy(__unwrap_iter(__first), __unwrap_iter(__last), __unwrap_iter(__result)); 1745227825Stheraven} 1746227825Stheraven 1747227825Stheraven// copy_backward 1748227825Stheraven 1749246487Stheraventemplate <class _BidirectionalIterator, class _OutputIterator> 1750227825Stheraveninline _LIBCPP_INLINE_VISIBILITY 1751227825Stheraven_OutputIterator 1752246487Stheraven__copy_backward(_BidirectionalIterator __first, _BidirectionalIterator __last, _OutputIterator __result) 1753227825Stheraven{ 1754227825Stheraven while (__first != __last) 1755227825Stheraven *--__result = *--__last; 1756227825Stheraven return __result; 1757227825Stheraven} 1758227825Stheraven 1759227825Stheraventemplate <class _Tp, class _Up> 1760227825Stheraveninline _LIBCPP_INLINE_VISIBILITY 1761227825Stheraventypename enable_if 1762227825Stheraven< 1763227825Stheraven is_same<typename remove_const<_Tp>::type, _Up>::value && 1764227825Stheraven is_trivially_copy_assignable<_Up>::value, 1765227825Stheraven _Up* 1766227825Stheraven>::type 1767227825Stheraven__copy_backward(_Tp* __first, _Tp* __last, _Up* __result) 1768227825Stheraven{ 1769227825Stheraven const size_t __n = static_cast<size_t>(__last - __first); 1770227825Stheraven __result -= __n; 1771227825Stheraven _VSTD::memmove(__result, __first, __n * sizeof(_Up)); 1772227825Stheraven return __result; 1773227825Stheraven} 1774227825Stheraven 1775227825Stheraventemplate <class _BidirectionalIterator1, class _BidirectionalIterator2> 1776227825Stheraveninline _LIBCPP_INLINE_VISIBILITY 1777227825Stheraven_BidirectionalIterator2 1778227825Stheravencopy_backward(_BidirectionalIterator1 __first, _BidirectionalIterator1 __last, 1779227825Stheraven _BidirectionalIterator2 __result) 1780227825Stheraven{ 1781227825Stheraven return _VSTD::__copy_backward(__unwrap_iter(__first), __unwrap_iter(__last), __unwrap_iter(__result)); 1782227825Stheraven} 1783227825Stheraven 1784227825Stheraven// copy_if 1785227825Stheraven 1786227825Stheraventemplate<class _InputIterator, class _OutputIterator, class _Predicate> 1787227825Stheraveninline _LIBCPP_INLINE_VISIBILITY 1788227825Stheraven_OutputIterator 1789227825Stheravencopy_if(_InputIterator __first, _InputIterator __last, 1790227825Stheraven _OutputIterator __result, _Predicate __pred) 1791227825Stheraven{ 1792227825Stheraven for (; __first != __last; ++__first) 1793227825Stheraven { 1794227825Stheraven if (__pred(*__first)) 1795227825Stheraven { 1796227825Stheraven *__result = *__first; 1797227825Stheraven ++__result; 1798227825Stheraven } 1799227825Stheraven } 1800227825Stheraven return __result; 1801227825Stheraven} 1802227825Stheraven 1803227825Stheraven// copy_n 1804227825Stheraven 1805227825Stheraventemplate<class _InputIterator, class _Size, class _OutputIterator> 1806227825Stheraveninline _LIBCPP_INLINE_VISIBILITY 1807227825Stheraventypename enable_if 1808227825Stheraven< 1809227825Stheraven __is_input_iterator<_InputIterator>::value && 1810227825Stheraven !__is_random_access_iterator<_InputIterator>::value, 1811227825Stheraven _OutputIterator 1812227825Stheraven>::type 1813227825Stheravencopy_n(_InputIterator __first, _Size __n, _OutputIterator __result) 1814227825Stheraven{ 1815227825Stheraven if (__n > 0) 1816227825Stheraven { 1817227825Stheraven *__result = *__first; 1818227825Stheraven ++__result; 1819227825Stheraven for (--__n; __n > 0; --__n) 1820227825Stheraven { 1821227825Stheraven ++__first; 1822227825Stheraven *__result = *__first; 1823227825Stheraven ++__result; 1824227825Stheraven } 1825227825Stheraven } 1826227825Stheraven return __result; 1827227825Stheraven} 1828227825Stheraven 1829227825Stheraventemplate<class _InputIterator, class _Size, class _OutputIterator> 1830227825Stheraveninline _LIBCPP_INLINE_VISIBILITY 1831227825Stheraventypename enable_if 1832227825Stheraven< 1833227825Stheraven __is_random_access_iterator<_InputIterator>::value, 1834227825Stheraven _OutputIterator 1835227825Stheraven>::type 1836227825Stheravencopy_n(_InputIterator __first, _Size __n, _OutputIterator __result) 1837227825Stheraven{ 1838227825Stheraven return _VSTD::copy(__first, __first + __n, __result); 1839227825Stheraven} 1840227825Stheraven 1841227825Stheraven// move 1842227825Stheraven 1843227825Stheraventemplate <class _InputIterator, class _OutputIterator> 1844227825Stheraveninline _LIBCPP_INLINE_VISIBILITY 1845227825Stheraven_OutputIterator 1846227825Stheraven__move(_InputIterator __first, _InputIterator __last, _OutputIterator __result) 1847227825Stheraven{ 1848227825Stheraven for (; __first != __last; ++__first, ++__result) 1849227825Stheraven *__result = _VSTD::move(*__first); 1850227825Stheraven return __result; 1851227825Stheraven} 1852227825Stheraven 1853227825Stheraventemplate <class _Tp, class _Up> 1854227825Stheraveninline _LIBCPP_INLINE_VISIBILITY 1855227825Stheraventypename enable_if 1856227825Stheraven< 1857227825Stheraven is_same<typename remove_const<_Tp>::type, _Up>::value && 1858227825Stheraven is_trivially_copy_assignable<_Up>::value, 1859227825Stheraven _Up* 1860227825Stheraven>::type 1861227825Stheraven__move(_Tp* __first, _Tp* __last, _Up* __result) 1862227825Stheraven{ 1863227825Stheraven const size_t __n = static_cast<size_t>(__last - __first); 1864227825Stheraven _VSTD::memmove(__result, __first, __n * sizeof(_Up)); 1865227825Stheraven return __result + __n; 1866227825Stheraven} 1867227825Stheraven 1868227825Stheraventemplate <class _InputIterator, class _OutputIterator> 1869227825Stheraveninline _LIBCPP_INLINE_VISIBILITY 1870227825Stheraven_OutputIterator 1871227825Stheravenmove(_InputIterator __first, _InputIterator __last, _OutputIterator __result) 1872227825Stheraven{ 1873227825Stheraven return _VSTD::__move(__unwrap_iter(__first), __unwrap_iter(__last), __unwrap_iter(__result)); 1874227825Stheraven} 1875227825Stheraven 1876227825Stheraven// move_backward 1877227825Stheraven 1878227825Stheraventemplate <class _InputIterator, class _OutputIterator> 1879227825Stheraveninline _LIBCPP_INLINE_VISIBILITY 1880227825Stheraven_OutputIterator 1881227825Stheraven__move_backward(_InputIterator __first, _InputIterator __last, _OutputIterator __result) 1882227825Stheraven{ 1883227825Stheraven while (__first != __last) 1884227825Stheraven *--__result = _VSTD::move(*--__last); 1885227825Stheraven return __result; 1886227825Stheraven} 1887227825Stheraven 1888227825Stheraventemplate <class _Tp, class _Up> 1889227825Stheraveninline _LIBCPP_INLINE_VISIBILITY 1890227825Stheraventypename enable_if 1891227825Stheraven< 1892227825Stheraven is_same<typename remove_const<_Tp>::type, _Up>::value && 1893227825Stheraven is_trivially_copy_assignable<_Up>::value, 1894227825Stheraven _Up* 1895227825Stheraven>::type 1896227825Stheraven__move_backward(_Tp* __first, _Tp* __last, _Up* __result) 1897227825Stheraven{ 1898227825Stheraven const size_t __n = static_cast<size_t>(__last - __first); 1899227825Stheraven __result -= __n; 1900227825Stheraven _VSTD::memmove(__result, __first, __n * sizeof(_Up)); 1901227825Stheraven return __result; 1902227825Stheraven} 1903227825Stheraven 1904227825Stheraventemplate <class _BidirectionalIterator1, class _BidirectionalIterator2> 1905227825Stheraveninline _LIBCPP_INLINE_VISIBILITY 1906227825Stheraven_BidirectionalIterator2 1907227825Stheravenmove_backward(_BidirectionalIterator1 __first, _BidirectionalIterator1 __last, 1908227825Stheraven _BidirectionalIterator2 __result) 1909227825Stheraven{ 1910227825Stheraven return _VSTD::__move_backward(__unwrap_iter(__first), __unwrap_iter(__last), __unwrap_iter(__result)); 1911227825Stheraven} 1912227825Stheraven 1913227825Stheraven// iter_swap 1914227825Stheraven 1915227825Stheraven// moved to <type_traits> for better swap / noexcept support 1916227825Stheraven 1917227825Stheraven// transform 1918227825Stheraven 1919227825Stheraventemplate <class _InputIterator, class _OutputIterator, class _UnaryOperation> 1920227825Stheraveninline _LIBCPP_INLINE_VISIBILITY 1921227825Stheraven_OutputIterator 1922227825Stheraventransform(_InputIterator __first, _InputIterator __last, _OutputIterator __result, _UnaryOperation __op) 1923227825Stheraven{ 1924227825Stheraven for (; __first != __last; ++__first, ++__result) 1925227825Stheraven *__result = __op(*__first); 1926227825Stheraven return __result; 1927227825Stheraven} 1928227825Stheraven 1929227825Stheraventemplate <class _InputIterator1, class _InputIterator2, class _OutputIterator, class _BinaryOperation> 1930227825Stheraveninline _LIBCPP_INLINE_VISIBILITY 1931227825Stheraven_OutputIterator 1932227825Stheraventransform(_InputIterator1 __first1, _InputIterator1 __last1, _InputIterator2 __first2, 1933227825Stheraven _OutputIterator __result, _BinaryOperation __binary_op) 1934227825Stheraven{ 1935227825Stheraven for (; __first1 != __last1; ++__first1, ++__first2, ++__result) 1936227825Stheraven *__result = __binary_op(*__first1, *__first2); 1937227825Stheraven return __result; 1938227825Stheraven} 1939227825Stheraven 1940227825Stheraven// replace 1941227825Stheraven 1942227825Stheraventemplate <class _ForwardIterator, class _Tp> 1943227825Stheraveninline _LIBCPP_INLINE_VISIBILITY 1944227825Stheravenvoid 1945227825Stheravenreplace(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __old_value, const _Tp& __new_value) 1946227825Stheraven{ 1947227825Stheraven for (; __first != __last; ++__first) 1948227825Stheraven if (*__first == __old_value) 1949227825Stheraven *__first = __new_value; 1950227825Stheraven} 1951227825Stheraven 1952227825Stheraven// replace_if 1953227825Stheraven 1954227825Stheraventemplate <class _ForwardIterator, class _Predicate, class _Tp> 1955227825Stheraveninline _LIBCPP_INLINE_VISIBILITY 1956227825Stheravenvoid 1957227825Stheravenreplace_if(_ForwardIterator __first, _ForwardIterator __last, _Predicate __pred, const _Tp& __new_value) 1958227825Stheraven{ 1959227825Stheraven for (; __first != __last; ++__first) 1960227825Stheraven if (__pred(*__first)) 1961227825Stheraven *__first = __new_value; 1962227825Stheraven} 1963227825Stheraven 1964227825Stheraven// replace_copy 1965227825Stheraven 1966227825Stheraventemplate <class _InputIterator, class _OutputIterator, class _Tp> 1967227825Stheraveninline _LIBCPP_INLINE_VISIBILITY 1968227825Stheraven_OutputIterator 1969227825Stheravenreplace_copy(_InputIterator __first, _InputIterator __last, _OutputIterator __result, 1970227825Stheraven const _Tp& __old_value, const _Tp& __new_value) 1971227825Stheraven{ 1972227825Stheraven for (; __first != __last; ++__first, ++__result) 1973227825Stheraven if (*__first == __old_value) 1974227825Stheraven *__result = __new_value; 1975227825Stheraven else 1976227825Stheraven *__result = *__first; 1977227825Stheraven return __result; 1978227825Stheraven} 1979227825Stheraven 1980227825Stheraven// replace_copy_if 1981227825Stheraven 1982227825Stheraventemplate <class _InputIterator, class _OutputIterator, class _Predicate, class _Tp> 1983227825Stheraveninline _LIBCPP_INLINE_VISIBILITY 1984227825Stheraven_OutputIterator 1985227825Stheravenreplace_copy_if(_InputIterator __first, _InputIterator __last, _OutputIterator __result, 1986227825Stheraven _Predicate __pred, const _Tp& __new_value) 1987227825Stheraven{ 1988227825Stheraven for (; __first != __last; ++__first, ++__result) 1989227825Stheraven if (__pred(*__first)) 1990227825Stheraven *__result = __new_value; 1991227825Stheraven else 1992227825Stheraven *__result = *__first; 1993227825Stheraven return __result; 1994227825Stheraven} 1995227825Stheraven 1996227825Stheraven// fill_n 1997227825Stheraven 1998227825Stheraventemplate <class _OutputIterator, class _Size, class _Tp> 1999227825Stheraveninline _LIBCPP_INLINE_VISIBILITY 2000227825Stheraven_OutputIterator 2001262801Sdim__fill_n(_OutputIterator __first, _Size __n, const _Tp& __value_) 2002227825Stheraven{ 2003227825Stheraven for (; __n > 0; ++__first, --__n) 2004227825Stheraven *__first = __value_; 2005227825Stheraven return __first; 2006227825Stheraven} 2007227825Stheraven 2008262801Sdimtemplate <class _Tp, class _Size, class _Up> 2009227825Stheraveninline _LIBCPP_INLINE_VISIBILITY 2010262801Sdimtypename enable_if 2011262801Sdim< 2012262801Sdim is_integral<_Tp>::value && sizeof(_Tp) == 1 && 2013262801Sdim !is_same<_Tp, bool>::value && 2014262801Sdim is_integral<_Up>::value && sizeof(_Up) == 1, 2015262801Sdim _Tp* 2016262801Sdim>::type 2017262801Sdim__fill_n(_Tp* __first, _Size __n,_Up __value_) 2018227825Stheraven{ 2019227825Stheraven if (__n > 0) 2020227825Stheraven _VSTD::memset(__first, (unsigned char)__value_, (size_t)(__n)); 2021227825Stheraven return __first + __n; 2022227825Stheraven} 2023227825Stheraven 2024227825Stheraventemplate <class _OutputIterator, class _Size, class _Tp> 2025227825Stheraveninline _LIBCPP_INLINE_VISIBILITY 2026227825Stheraven_OutputIterator 2027227825Stheravenfill_n(_OutputIterator __first, _Size __n, const _Tp& __value_) 2028227825Stheraven{ 2029262801Sdim return _VSTD::__fill_n(__first, __n, __value_); 2030227825Stheraven} 2031227825Stheraven 2032227825Stheraven// fill 2033227825Stheraven 2034227825Stheraventemplate <class _ForwardIterator, class _Tp> 2035227825Stheraveninline _LIBCPP_INLINE_VISIBILITY 2036227825Stheravenvoid 2037227825Stheraven__fill(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __value_, forward_iterator_tag) 2038227825Stheraven{ 2039227825Stheraven for (; __first != __last; ++__first) 2040227825Stheraven *__first = __value_; 2041227825Stheraven} 2042227825Stheraven 2043227825Stheraventemplate <class _RandomAccessIterator, class _Tp> 2044227825Stheraveninline _LIBCPP_INLINE_VISIBILITY 2045227825Stheravenvoid 2046227825Stheraven__fill(_RandomAccessIterator __first, _RandomAccessIterator __last, const _Tp& __value_, random_access_iterator_tag) 2047227825Stheraven{ 2048227825Stheraven _VSTD::fill_n(__first, __last - __first, __value_); 2049227825Stheraven} 2050227825Stheraven 2051227825Stheraventemplate <class _ForwardIterator, class _Tp> 2052227825Stheraveninline _LIBCPP_INLINE_VISIBILITY 2053227825Stheravenvoid 2054227825Stheravenfill(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __value_) 2055227825Stheraven{ 2056227825Stheraven _VSTD::__fill(__first, __last, __value_, typename iterator_traits<_ForwardIterator>::iterator_category()); 2057227825Stheraven} 2058227825Stheraven 2059227825Stheraven// generate 2060227825Stheraven 2061227825Stheraventemplate <class _ForwardIterator, class _Generator> 2062227825Stheraveninline _LIBCPP_INLINE_VISIBILITY 2063227825Stheravenvoid 2064227825Stheravengenerate(_ForwardIterator __first, _ForwardIterator __last, _Generator __gen) 2065227825Stheraven{ 2066227825Stheraven for (; __first != __last; ++__first) 2067227825Stheraven *__first = __gen(); 2068227825Stheraven} 2069227825Stheraven 2070227825Stheraven// generate_n 2071227825Stheraven 2072227825Stheraventemplate <class _OutputIterator, class _Size, class _Generator> 2073227825Stheraveninline _LIBCPP_INLINE_VISIBILITY 2074227825Stheraven_OutputIterator 2075227825Stheravengenerate_n(_OutputIterator __first, _Size __n, _Generator __gen) 2076227825Stheraven{ 2077227825Stheraven for (; __n > 0; ++__first, --__n) 2078227825Stheraven *__first = __gen(); 2079227825Stheraven return __first; 2080227825Stheraven} 2081227825Stheraven 2082227825Stheraven// remove 2083227825Stheraven 2084227825Stheraventemplate <class _ForwardIterator, class _Tp> 2085227825Stheraven_ForwardIterator 2086227825Stheravenremove(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __value_) 2087227825Stheraven{ 2088227825Stheraven __first = _VSTD::find(__first, __last, __value_); 2089227825Stheraven if (__first != __last) 2090227825Stheraven { 2091227825Stheraven _ForwardIterator __i = __first; 2092227825Stheraven while (++__i != __last) 2093227825Stheraven { 2094227825Stheraven if (!(*__i == __value_)) 2095227825Stheraven { 2096227825Stheraven *__first = _VSTD::move(*__i); 2097227825Stheraven ++__first; 2098227825Stheraven } 2099227825Stheraven } 2100227825Stheraven } 2101227825Stheraven return __first; 2102227825Stheraven} 2103227825Stheraven 2104227825Stheraven// remove_if 2105227825Stheraven 2106227825Stheraventemplate <class _ForwardIterator, class _Predicate> 2107227825Stheraven_ForwardIterator 2108227825Stheravenremove_if(_ForwardIterator __first, _ForwardIterator __last, _Predicate __pred) 2109227825Stheraven{ 2110227825Stheraven __first = _VSTD::find_if<_ForwardIterator, typename add_lvalue_reference<_Predicate>::type> 2111227825Stheraven (__first, __last, __pred); 2112227825Stheraven if (__first != __last) 2113227825Stheraven { 2114227825Stheraven _ForwardIterator __i = __first; 2115227825Stheraven while (++__i != __last) 2116227825Stheraven { 2117227825Stheraven if (!__pred(*__i)) 2118227825Stheraven { 2119227825Stheraven *__first = _VSTD::move(*__i); 2120227825Stheraven ++__first; 2121227825Stheraven } 2122227825Stheraven } 2123227825Stheraven } 2124227825Stheraven return __first; 2125227825Stheraven} 2126227825Stheraven 2127227825Stheraven// remove_copy 2128227825Stheraven 2129227825Stheraventemplate <class _InputIterator, class _OutputIterator, class _Tp> 2130227825Stheraveninline _LIBCPP_INLINE_VISIBILITY 2131227825Stheraven_OutputIterator 2132227825Stheravenremove_copy(_InputIterator __first, _InputIterator __last, _OutputIterator __result, const _Tp& __value_) 2133227825Stheraven{ 2134227825Stheraven for (; __first != __last; ++__first) 2135227825Stheraven { 2136227825Stheraven if (!(*__first == __value_)) 2137227825Stheraven { 2138227825Stheraven *__result = *__first; 2139227825Stheraven ++__result; 2140227825Stheraven } 2141227825Stheraven } 2142227825Stheraven return __result; 2143227825Stheraven} 2144227825Stheraven 2145227825Stheraven// remove_copy_if 2146227825Stheraven 2147227825Stheraventemplate <class _InputIterator, class _OutputIterator, class _Predicate> 2148227825Stheraveninline _LIBCPP_INLINE_VISIBILITY 2149227825Stheraven_OutputIterator 2150227825Stheravenremove_copy_if(_InputIterator __first, _InputIterator __last, _OutputIterator __result, _Predicate __pred) 2151227825Stheraven{ 2152227825Stheraven for (; __first != __last; ++__first) 2153227825Stheraven { 2154227825Stheraven if (!__pred(*__first)) 2155227825Stheraven { 2156227825Stheraven *__result = *__first; 2157227825Stheraven ++__result; 2158227825Stheraven } 2159227825Stheraven } 2160227825Stheraven return __result; 2161227825Stheraven} 2162227825Stheraven 2163227825Stheraven// unique 2164227825Stheraven 2165227825Stheraventemplate <class _ForwardIterator, class _BinaryPredicate> 2166227825Stheraven_ForwardIterator 2167227825Stheravenunique(_ForwardIterator __first, _ForwardIterator __last, _BinaryPredicate __pred) 2168227825Stheraven{ 2169227825Stheraven __first = _VSTD::adjacent_find<_ForwardIterator, typename add_lvalue_reference<_BinaryPredicate>::type> 2170227825Stheraven (__first, __last, __pred); 2171227825Stheraven if (__first != __last) 2172227825Stheraven { 2173227825Stheraven // ... a a ? ... 2174227825Stheraven // f i 2175227825Stheraven _ForwardIterator __i = __first; 2176227825Stheraven for (++__i; ++__i != __last;) 2177227825Stheraven if (!__pred(*__first, *__i)) 2178227825Stheraven *++__first = _VSTD::move(*__i); 2179227825Stheraven ++__first; 2180227825Stheraven } 2181227825Stheraven return __first; 2182227825Stheraven} 2183227825Stheraven 2184227825Stheraventemplate <class _ForwardIterator> 2185227825Stheraveninline _LIBCPP_INLINE_VISIBILITY 2186227825Stheraven_ForwardIterator 2187227825Stheravenunique(_ForwardIterator __first, _ForwardIterator __last) 2188227825Stheraven{ 2189227825Stheraven typedef typename iterator_traits<_ForwardIterator>::value_type __v; 2190227825Stheraven return _VSTD::unique(__first, __last, __equal_to<__v>()); 2191227825Stheraven} 2192227825Stheraven 2193227825Stheraven// unique_copy 2194227825Stheraven 2195227825Stheraventemplate <class _BinaryPredicate, class _InputIterator, class _OutputIterator> 2196227825Stheraven_OutputIterator 2197227825Stheraven__unique_copy(_InputIterator __first, _InputIterator __last, _OutputIterator __result, _BinaryPredicate __pred, 2198227825Stheraven input_iterator_tag, output_iterator_tag) 2199227825Stheraven{ 2200227825Stheraven if (__first != __last) 2201227825Stheraven { 2202227825Stheraven typename iterator_traits<_InputIterator>::value_type __t(*__first); 2203227825Stheraven *__result = __t; 2204227825Stheraven ++__result; 2205227825Stheraven while (++__first != __last) 2206227825Stheraven { 2207227825Stheraven if (!__pred(__t, *__first)) 2208227825Stheraven { 2209227825Stheraven __t = *__first; 2210227825Stheraven *__result = __t; 2211227825Stheraven ++__result; 2212227825Stheraven } 2213227825Stheraven } 2214227825Stheraven } 2215227825Stheraven return __result; 2216227825Stheraven} 2217227825Stheraven 2218227825Stheraventemplate <class _BinaryPredicate, class _ForwardIterator, class _OutputIterator> 2219227825Stheraven_OutputIterator 2220227825Stheraven__unique_copy(_ForwardIterator __first, _ForwardIterator __last, _OutputIterator __result, _BinaryPredicate __pred, 2221227825Stheraven forward_iterator_tag, output_iterator_tag) 2222227825Stheraven{ 2223227825Stheraven if (__first != __last) 2224227825Stheraven { 2225227825Stheraven _ForwardIterator __i = __first; 2226227825Stheraven *__result = *__i; 2227227825Stheraven ++__result; 2228227825Stheraven while (++__first != __last) 2229227825Stheraven { 2230227825Stheraven if (!__pred(*__i, *__first)) 2231227825Stheraven { 2232227825Stheraven *__result = *__first; 2233227825Stheraven ++__result; 2234227825Stheraven __i = __first; 2235227825Stheraven } 2236227825Stheraven } 2237227825Stheraven } 2238227825Stheraven return __result; 2239227825Stheraven} 2240227825Stheraven 2241227825Stheraventemplate <class _BinaryPredicate, class _InputIterator, class _ForwardIterator> 2242227825Stheraven_ForwardIterator 2243227825Stheraven__unique_copy(_InputIterator __first, _InputIterator __last, _ForwardIterator __result, _BinaryPredicate __pred, 2244227825Stheraven input_iterator_tag, forward_iterator_tag) 2245227825Stheraven{ 2246227825Stheraven if (__first != __last) 2247227825Stheraven { 2248227825Stheraven *__result = *__first; 2249227825Stheraven while (++__first != __last) 2250227825Stheraven if (!__pred(*__result, *__first)) 2251227825Stheraven *++__result = *__first; 2252227825Stheraven ++__result; 2253227825Stheraven } 2254227825Stheraven return __result; 2255227825Stheraven} 2256227825Stheraven 2257227825Stheraventemplate <class _InputIterator, class _OutputIterator, class _BinaryPredicate> 2258227825Stheraveninline _LIBCPP_INLINE_VISIBILITY 2259227825Stheraven_OutputIterator 2260227825Stheravenunique_copy(_InputIterator __first, _InputIterator __last, _OutputIterator __result, _BinaryPredicate __pred) 2261227825Stheraven{ 2262227825Stheraven return _VSTD::__unique_copy<typename add_lvalue_reference<_BinaryPredicate>::type> 2263227825Stheraven (__first, __last, __result, __pred, 2264227825Stheraven typename iterator_traits<_InputIterator>::iterator_category(), 2265227825Stheraven typename iterator_traits<_OutputIterator>::iterator_category()); 2266227825Stheraven} 2267227825Stheraven 2268227825Stheraventemplate <class _InputIterator, class _OutputIterator> 2269227825Stheraveninline _LIBCPP_INLINE_VISIBILITY 2270227825Stheraven_OutputIterator 2271227825Stheravenunique_copy(_InputIterator __first, _InputIterator __last, _OutputIterator __result) 2272227825Stheraven{ 2273227825Stheraven typedef typename iterator_traits<_InputIterator>::value_type __v; 2274227825Stheraven return _VSTD::unique_copy(__first, __last, __result, __equal_to<__v>()); 2275227825Stheraven} 2276227825Stheraven 2277227825Stheraven// reverse 2278227825Stheraven 2279227825Stheraventemplate <class _BidirectionalIterator> 2280227825Stheraveninline _LIBCPP_INLINE_VISIBILITY 2281227825Stheravenvoid 2282227825Stheraven__reverse(_BidirectionalIterator __first, _BidirectionalIterator __last, bidirectional_iterator_tag) 2283227825Stheraven{ 2284227825Stheraven while (__first != __last) 2285227825Stheraven { 2286227825Stheraven if (__first == --__last) 2287227825Stheraven break; 2288227825Stheraven swap(*__first, *__last); 2289227825Stheraven ++__first; 2290227825Stheraven } 2291227825Stheraven} 2292227825Stheraven 2293227825Stheraventemplate <class _RandomAccessIterator> 2294227825Stheraveninline _LIBCPP_INLINE_VISIBILITY 2295227825Stheravenvoid 2296227825Stheraven__reverse(_RandomAccessIterator __first, _RandomAccessIterator __last, random_access_iterator_tag) 2297227825Stheraven{ 2298227825Stheraven if (__first != __last) 2299227825Stheraven for (; __first < --__last; ++__first) 2300227825Stheraven swap(*__first, *__last); 2301227825Stheraven} 2302227825Stheraven 2303227825Stheraventemplate <class _BidirectionalIterator> 2304227825Stheraveninline _LIBCPP_INLINE_VISIBILITY 2305227825Stheravenvoid 2306227825Stheravenreverse(_BidirectionalIterator __first, _BidirectionalIterator __last) 2307227825Stheraven{ 2308227825Stheraven _VSTD::__reverse(__first, __last, typename iterator_traits<_BidirectionalIterator>::iterator_category()); 2309227825Stheraven} 2310227825Stheraven 2311227825Stheraven// reverse_copy 2312227825Stheraven 2313227825Stheraventemplate <class _BidirectionalIterator, class _OutputIterator> 2314227825Stheraveninline _LIBCPP_INLINE_VISIBILITY 2315227825Stheraven_OutputIterator 2316227825Stheravenreverse_copy(_BidirectionalIterator __first, _BidirectionalIterator __last, _OutputIterator __result) 2317227825Stheraven{ 2318227825Stheraven for (; __first != __last; ++__result) 2319227825Stheraven *__result = *--__last; 2320227825Stheraven return __result; 2321227825Stheraven} 2322227825Stheraven 2323227825Stheraven// rotate 2324227825Stheraven 2325227825Stheraventemplate <class _ForwardIterator> 2326227825Stheraven_ForwardIterator 2327241903Sdim__rotate_left(_ForwardIterator __first, _ForwardIterator __last) 2328227825Stheraven{ 2329241903Sdim typedef typename iterator_traits<_ForwardIterator>::value_type value_type; 2330241903Sdim value_type __tmp = _VSTD::move(*__first); 2331241903Sdim _ForwardIterator __lm1 = _VSTD::move(_VSTD::next(__first), __last, __first); 2332241903Sdim *__lm1 = _VSTD::move(__tmp); 2333241903Sdim return __lm1; 2334241903Sdim} 2335241903Sdim 2336241903Sdimtemplate <class _BidirectionalIterator> 2337241903Sdim_BidirectionalIterator 2338241903Sdim__rotate_right(_BidirectionalIterator __first, _BidirectionalIterator __last) 2339241903Sdim{ 2340241903Sdim typedef typename iterator_traits<_BidirectionalIterator>::value_type value_type; 2341241903Sdim _BidirectionalIterator __lm1 = _VSTD::prev(__last); 2342241903Sdim value_type __tmp = _VSTD::move(*__lm1); 2343241903Sdim _BidirectionalIterator __fp1 = _VSTD::move_backward(__first, __lm1, __last); 2344241903Sdim *__first = _VSTD::move(__tmp); 2345241903Sdim return __fp1; 2346241903Sdim} 2347241903Sdim 2348241903Sdimtemplate <class _ForwardIterator> 2349241903Sdim_ForwardIterator 2350241903Sdim__rotate_forward(_ForwardIterator __first, _ForwardIterator __middle, _ForwardIterator __last) 2351241903Sdim{ 2352227825Stheraven _ForwardIterator __i = __middle; 2353227825Stheraven while (true) 2354227825Stheraven { 2355227825Stheraven swap(*__first, *__i); 2356227825Stheraven ++__first; 2357227825Stheraven if (++__i == __last) 2358227825Stheraven break; 2359227825Stheraven if (__first == __middle) 2360227825Stheraven __middle = __i; 2361227825Stheraven } 2362227825Stheraven _ForwardIterator __r = __first; 2363227825Stheraven if (__first != __middle) 2364227825Stheraven { 2365227825Stheraven __i = __middle; 2366227825Stheraven while (true) 2367227825Stheraven { 2368227825Stheraven swap(*__first, *__i); 2369227825Stheraven ++__first; 2370227825Stheraven if (++__i == __last) 2371227825Stheraven { 2372227825Stheraven if (__first == __middle) 2373227825Stheraven break; 2374227825Stheraven __i = __middle; 2375227825Stheraven } 2376227825Stheraven else if (__first == __middle) 2377227825Stheraven __middle = __i; 2378227825Stheraven } 2379227825Stheraven } 2380227825Stheraven return __r; 2381227825Stheraven} 2382227825Stheraven 2383227825Stheraventemplate<typename _Integral> 2384227825Stheraveninline _LIBCPP_INLINE_VISIBILITY 2385227825Stheraven_Integral 2386227825Stheraven__gcd(_Integral __x, _Integral __y) 2387227825Stheraven{ 2388227825Stheraven do 2389227825Stheraven { 2390227825Stheraven _Integral __t = __x % __y; 2391227825Stheraven __x = __y; 2392227825Stheraven __y = __t; 2393227825Stheraven } while (__y); 2394227825Stheraven return __x; 2395227825Stheraven} 2396227825Stheraven 2397227825Stheraventemplate<typename _RandomAccessIterator> 2398227825Stheraven_RandomAccessIterator 2399241903Sdim__rotate_gcd(_RandomAccessIterator __first, _RandomAccessIterator __middle, _RandomAccessIterator __last) 2400227825Stheraven{ 2401227825Stheraven typedef typename iterator_traits<_RandomAccessIterator>::difference_type difference_type; 2402227825Stheraven typedef typename iterator_traits<_RandomAccessIterator>::value_type value_type; 2403227825Stheraven 2404227825Stheraven const difference_type __m1 = __middle - __first; 2405227825Stheraven const difference_type __m2 = __last - __middle; 2406227825Stheraven if (__m1 == __m2) 2407227825Stheraven { 2408227825Stheraven _VSTD::swap_ranges(__first, __middle, __middle); 2409227825Stheraven return __middle; 2410227825Stheraven } 2411241903Sdim const difference_type __g = _VSTD::__gcd(__m1, __m2); 2412227825Stheraven for (_RandomAccessIterator __p = __first + __g; __p != __first;) 2413227825Stheraven { 2414241903Sdim value_type __t(_VSTD::move(*--__p)); 2415227825Stheraven _RandomAccessIterator __p1 = __p; 2416227825Stheraven _RandomAccessIterator __p2 = __p1 + __m1; 2417227825Stheraven do 2418227825Stheraven { 2419241903Sdim *__p1 = _VSTD::move(*__p2); 2420227825Stheraven __p1 = __p2; 2421227825Stheraven const difference_type __d = __last - __p2; 2422227825Stheraven if (__m1 < __d) 2423227825Stheraven __p2 += __m1; 2424227825Stheraven else 2425227825Stheraven __p2 = __first + (__m1 - __d); 2426227825Stheraven } while (__p2 != __p); 2427241903Sdim *__p1 = _VSTD::move(__t); 2428227825Stheraven } 2429227825Stheraven return __first + __m2; 2430227825Stheraven} 2431227825Stheraven 2432227825Stheraventemplate <class _ForwardIterator> 2433227825Stheraveninline _LIBCPP_INLINE_VISIBILITY 2434227825Stheraven_ForwardIterator 2435241903Sdim__rotate(_ForwardIterator __first, _ForwardIterator __middle, _ForwardIterator __last, 2436241903Sdim _VSTD::forward_iterator_tag) 2437241903Sdim{ 2438241903Sdim typedef typename _VSTD::iterator_traits<_ForwardIterator>::value_type value_type; 2439241903Sdim if (_VSTD::is_trivially_move_assignable<value_type>::value) 2440241903Sdim { 2441241903Sdim if (_VSTD::next(__first) == __middle) 2442241903Sdim return _VSTD::__rotate_left(__first, __last); 2443241903Sdim } 2444241903Sdim return _VSTD::__rotate_forward(__first, __middle, __last); 2445241903Sdim} 2446241903Sdim 2447241903Sdimtemplate <class _BidirectionalIterator> 2448241903Sdiminline _LIBCPP_INLINE_VISIBILITY 2449241903Sdim_BidirectionalIterator 2450241903Sdim__rotate(_BidirectionalIterator __first, _BidirectionalIterator __middle, _BidirectionalIterator __last, 2451241903Sdim _VSTD::bidirectional_iterator_tag) 2452241903Sdim{ 2453241903Sdim typedef typename _VSTD::iterator_traits<_BidirectionalIterator>::value_type value_type; 2454241903Sdim if (_VSTD::is_trivially_move_assignable<value_type>::value) 2455241903Sdim { 2456241903Sdim if (_VSTD::next(__first) == __middle) 2457241903Sdim return _VSTD::__rotate_left(__first, __last); 2458241903Sdim if (_VSTD::next(__middle) == __last) 2459241903Sdim return _VSTD::__rotate_right(__first, __last); 2460241903Sdim } 2461241903Sdim return _VSTD::__rotate_forward(__first, __middle, __last); 2462241903Sdim} 2463241903Sdim 2464241903Sdimtemplate <class _RandomAccessIterator> 2465241903Sdiminline _LIBCPP_INLINE_VISIBILITY 2466241903Sdim_RandomAccessIterator 2467241903Sdim__rotate(_RandomAccessIterator __first, _RandomAccessIterator __middle, _RandomAccessIterator __last, 2468241903Sdim _VSTD::random_access_iterator_tag) 2469241903Sdim{ 2470241903Sdim typedef typename _VSTD::iterator_traits<_RandomAccessIterator>::value_type value_type; 2471241903Sdim if (_VSTD::is_trivially_move_assignable<value_type>::value) 2472241903Sdim { 2473241903Sdim if (_VSTD::next(__first) == __middle) 2474241903Sdim return _VSTD::__rotate_left(__first, __last); 2475241903Sdim if (_VSTD::next(__middle) == __last) 2476241903Sdim return _VSTD::__rotate_right(__first, __last); 2477241903Sdim return _VSTD::__rotate_gcd(__first, __middle, __last); 2478241903Sdim } 2479241903Sdim return _VSTD::__rotate_forward(__first, __middle, __last); 2480241903Sdim} 2481241903Sdim 2482241903Sdimtemplate <class _ForwardIterator> 2483241903Sdiminline _LIBCPP_INLINE_VISIBILITY 2484241903Sdim_ForwardIterator 2485227825Stheravenrotate(_ForwardIterator __first, _ForwardIterator __middle, _ForwardIterator __last) 2486227825Stheraven{ 2487241903Sdim if (__first == __middle) 2488241903Sdim return __last; 2489241903Sdim if (__middle == __last) 2490241903Sdim return __first; 2491227825Stheraven return _VSTD::__rotate(__first, __middle, __last, 2492241903Sdim typename _VSTD::iterator_traits<_ForwardIterator>::iterator_category()); 2493227825Stheraven} 2494227825Stheraven 2495227825Stheraven// rotate_copy 2496227825Stheraven 2497227825Stheraventemplate <class _ForwardIterator, class _OutputIterator> 2498227825Stheraveninline _LIBCPP_INLINE_VISIBILITY 2499227825Stheraven_OutputIterator 2500227825Stheravenrotate_copy(_ForwardIterator __first, _ForwardIterator __middle, _ForwardIterator __last, _OutputIterator __result) 2501227825Stheraven{ 2502227825Stheraven return _VSTD::copy(__first, __middle, _VSTD::copy(__middle, __last, __result)); 2503227825Stheraven} 2504227825Stheraven 2505227825Stheraven// min_element 2506227825Stheraven 2507227825Stheraventemplate <class _ForwardIterator, class _Compare> 2508227825Stheraveninline _LIBCPP_INLINE_VISIBILITY 2509227825Stheraven_ForwardIterator 2510227825Stheravenmin_element(_ForwardIterator __first, _ForwardIterator __last, _Compare __comp) 2511227825Stheraven{ 2512227825Stheraven if (__first != __last) 2513227825Stheraven { 2514227825Stheraven _ForwardIterator __i = __first; 2515227825Stheraven while (++__i != __last) 2516227825Stheraven if (__comp(*__i, *__first)) 2517227825Stheraven __first = __i; 2518227825Stheraven } 2519227825Stheraven return __first; 2520227825Stheraven} 2521227825Stheraven 2522227825Stheraventemplate <class _ForwardIterator> 2523227825Stheraveninline _LIBCPP_INLINE_VISIBILITY 2524227825Stheraven_ForwardIterator 2525227825Stheravenmin_element(_ForwardIterator __first, _ForwardIterator __last) 2526227825Stheraven{ 2527227825Stheraven return _VSTD::min_element(__first, __last, 2528227825Stheraven __less<typename iterator_traits<_ForwardIterator>::value_type>()); 2529227825Stheraven} 2530227825Stheraven 2531227825Stheraven// min 2532227825Stheraven 2533227825Stheraventemplate <class _Tp, class _Compare> 2534227825Stheraveninline _LIBCPP_INLINE_VISIBILITY 2535227825Stheravenconst _Tp& 2536227825Stheravenmin(const _Tp& __a, const _Tp& __b, _Compare __comp) 2537227825Stheraven{ 2538227825Stheraven return __comp(__b, __a) ? __b : __a; 2539227825Stheraven} 2540227825Stheraven 2541227825Stheraventemplate <class _Tp> 2542227825Stheraveninline _LIBCPP_INLINE_VISIBILITY 2543227825Stheravenconst _Tp& 2544227825Stheravenmin(const _Tp& __a, const _Tp& __b) 2545227825Stheraven{ 2546227825Stheraven return _VSTD::min(__a, __b, __less<_Tp>()); 2547227825Stheraven} 2548227825Stheraven 2549227825Stheraven#ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS 2550227825Stheraven 2551227825Stheraventemplate<class _Tp, class _Compare> 2552227825Stheraveninline _LIBCPP_INLINE_VISIBILITY 2553227825Stheraven_Tp 2554227825Stheravenmin(initializer_list<_Tp> __t, _Compare __comp) 2555227825Stheraven{ 2556227825Stheraven return *_VSTD::min_element(__t.begin(), __t.end(), __comp); 2557227825Stheraven} 2558227825Stheraven 2559227825Stheraventemplate<class _Tp> 2560227825Stheraveninline _LIBCPP_INLINE_VISIBILITY 2561227825Stheraven_Tp 2562227825Stheravenmin(initializer_list<_Tp> __t) 2563227825Stheraven{ 2564227825Stheraven return *_VSTD::min_element(__t.begin(), __t.end()); 2565227825Stheraven} 2566227825Stheraven 2567227825Stheraven#endif // _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS 2568227825Stheraven 2569227825Stheraven// max_element 2570227825Stheraven 2571227825Stheraventemplate <class _ForwardIterator, class _Compare> 2572227825Stheraveninline _LIBCPP_INLINE_VISIBILITY 2573227825Stheraven_ForwardIterator 2574227825Stheravenmax_element(_ForwardIterator __first, _ForwardIterator __last, _Compare __comp) 2575227825Stheraven{ 2576227825Stheraven if (__first != __last) 2577227825Stheraven { 2578227825Stheraven _ForwardIterator __i = __first; 2579227825Stheraven while (++__i != __last) 2580227825Stheraven if (__comp(*__first, *__i)) 2581227825Stheraven __first = __i; 2582227825Stheraven } 2583227825Stheraven return __first; 2584227825Stheraven} 2585227825Stheraven 2586227825Stheraventemplate <class _ForwardIterator> 2587227825Stheraveninline _LIBCPP_INLINE_VISIBILITY 2588227825Stheraven_ForwardIterator 2589227825Stheravenmax_element(_ForwardIterator __first, _ForwardIterator __last) 2590227825Stheraven{ 2591227825Stheraven return _VSTD::max_element(__first, __last, 2592227825Stheraven __less<typename iterator_traits<_ForwardIterator>::value_type>()); 2593227825Stheraven} 2594227825Stheraven 2595227825Stheraven// max 2596227825Stheraven 2597227825Stheraventemplate <class _Tp, class _Compare> 2598227825Stheraveninline _LIBCPP_INLINE_VISIBILITY 2599227825Stheravenconst _Tp& 2600227825Stheravenmax(const _Tp& __a, const _Tp& __b, _Compare __comp) 2601227825Stheraven{ 2602227825Stheraven return __comp(__a, __b) ? __b : __a; 2603227825Stheraven} 2604227825Stheraven 2605227825Stheraventemplate <class _Tp> 2606227825Stheraveninline _LIBCPP_INLINE_VISIBILITY 2607227825Stheravenconst _Tp& 2608227825Stheravenmax(const _Tp& __a, const _Tp& __b) 2609227825Stheraven{ 2610227825Stheraven return _VSTD::max(__a, __b, __less<_Tp>()); 2611227825Stheraven} 2612227825Stheraven 2613227825Stheraven#ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS 2614227825Stheraven 2615227825Stheraventemplate<class _Tp, class _Compare> 2616227825Stheraveninline _LIBCPP_INLINE_VISIBILITY 2617227825Stheraven_Tp 2618227825Stheravenmax(initializer_list<_Tp> __t, _Compare __comp) 2619227825Stheraven{ 2620227825Stheraven return *_VSTD::max_element(__t.begin(), __t.end(), __comp); 2621227825Stheraven} 2622227825Stheraven 2623227825Stheraventemplate<class _Tp> 2624227825Stheraveninline _LIBCPP_INLINE_VISIBILITY 2625227825Stheraven_Tp 2626227825Stheravenmax(initializer_list<_Tp> __t) 2627227825Stheraven{ 2628227825Stheraven return *_VSTD::max_element(__t.begin(), __t.end()); 2629227825Stheraven} 2630227825Stheraven 2631227825Stheraven#endif // _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS 2632227825Stheraven 2633227825Stheraven// minmax_element 2634227825Stheraven 2635227825Stheraventemplate <class _ForwardIterator, class _Compare> 2636227825Stheravenstd::pair<_ForwardIterator, _ForwardIterator> 2637227825Stheravenminmax_element(_ForwardIterator __first, _ForwardIterator __last, _Compare __comp) 2638227825Stheraven{ 2639227825Stheraven std::pair<_ForwardIterator, _ForwardIterator> __result(__first, __first); 2640227825Stheraven if (__first != __last) 2641227825Stheraven { 2642227825Stheraven if (++__first != __last) 2643227825Stheraven { 2644227825Stheraven if (__comp(*__first, *__result.first)) 2645227825Stheraven __result.first = __first; 2646227825Stheraven else 2647227825Stheraven __result.second = __first; 2648227825Stheraven while (++__first != __last) 2649227825Stheraven { 2650227825Stheraven _ForwardIterator __i = __first; 2651227825Stheraven if (++__first == __last) 2652227825Stheraven { 2653227825Stheraven if (__comp(*__i, *__result.first)) 2654227825Stheraven __result.first = __i; 2655227825Stheraven else if (!__comp(*__i, *__result.second)) 2656227825Stheraven __result.second = __i; 2657227825Stheraven break; 2658227825Stheraven } 2659227825Stheraven else 2660227825Stheraven { 2661227825Stheraven if (__comp(*__first, *__i)) 2662227825Stheraven { 2663227825Stheraven if (__comp(*__first, *__result.first)) 2664227825Stheraven __result.first = __first; 2665227825Stheraven if (!__comp(*__i, *__result.second)) 2666227825Stheraven __result.second = __i; 2667227825Stheraven } 2668227825Stheraven else 2669227825Stheraven { 2670227825Stheraven if (__comp(*__i, *__result.first)) 2671227825Stheraven __result.first = __i; 2672227825Stheraven if (!__comp(*__first, *__result.second)) 2673227825Stheraven __result.second = __first; 2674227825Stheraven } 2675227825Stheraven } 2676227825Stheraven } 2677227825Stheraven } 2678227825Stheraven } 2679227825Stheraven return __result; 2680227825Stheraven} 2681227825Stheraven 2682227825Stheraventemplate <class _ForwardIterator> 2683227825Stheraveninline _LIBCPP_INLINE_VISIBILITY 2684227825Stheravenstd::pair<_ForwardIterator, _ForwardIterator> 2685227825Stheravenminmax_element(_ForwardIterator __first, _ForwardIterator __last) 2686227825Stheraven{ 2687227825Stheraven return _VSTD::minmax_element(__first, __last, __less<typename iterator_traits<_ForwardIterator>::value_type>()); 2688227825Stheraven} 2689227825Stheraven 2690227825Stheraven// minmax 2691227825Stheraven 2692227825Stheraventemplate<class _Tp, class _Compare> 2693227825Stheraveninline _LIBCPP_INLINE_VISIBILITY 2694227825Stheravenpair<const _Tp&, const _Tp&> 2695227825Stheravenminmax(const _Tp& __a, const _Tp& __b, _Compare __comp) 2696227825Stheraven{ 2697227825Stheraven return __comp(__b, __a) ? pair<const _Tp&, const _Tp&>(__b, __a) : 2698227825Stheraven pair<const _Tp&, const _Tp&>(__a, __b); 2699227825Stheraven} 2700227825Stheraven 2701227825Stheraventemplate<class _Tp> 2702227825Stheraveninline _LIBCPP_INLINE_VISIBILITY 2703227825Stheravenpair<const _Tp&, const _Tp&> 2704227825Stheravenminmax(const _Tp& __a, const _Tp& __b) 2705227825Stheraven{ 2706227825Stheraven return _VSTD::minmax(__a, __b, __less<_Tp>()); 2707227825Stheraven} 2708227825Stheraven 2709227825Stheraven#ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS 2710227825Stheraven 2711227825Stheraventemplate<class _Tp> 2712227825Stheraveninline _LIBCPP_INLINE_VISIBILITY 2713227825Stheravenpair<_Tp, _Tp> 2714227825Stheravenminmax(initializer_list<_Tp> __t) 2715227825Stheraven{ 2716227825Stheraven pair<const _Tp*, const _Tp*> __p = 2717227825Stheraven _VSTD::minmax_element(__t.begin(), __t.end()); 2718227825Stheraven return pair<_Tp, _Tp>(*__p.first, *__p.second); 2719227825Stheraven} 2720227825Stheraven 2721227825Stheraventemplate<class _Tp, class _Compare> 2722227825Stheraveninline _LIBCPP_INLINE_VISIBILITY 2723227825Stheravenpair<_Tp, _Tp> 2724227825Stheravenminmax(initializer_list<_Tp> __t, _Compare __comp) 2725227825Stheraven{ 2726227825Stheraven pair<const _Tp*, const _Tp*> __p = 2727227825Stheraven _VSTD::minmax_element(__t.begin(), __t.end(), __comp); 2728227825Stheraven return pair<_Tp, _Tp>(*__p.first, *__p.second); 2729227825Stheraven} 2730227825Stheraven 2731227825Stheraven#endif // _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS 2732227825Stheraven 2733227825Stheraven// random_shuffle 2734227825Stheraven 2735227825Stheraven// __independent_bits_engine 2736227825Stheraven 2737232950Stheraventemplate <unsigned long long _Xp, size_t _Rp> 2738227825Stheravenstruct __log2_imp 2739227825Stheraven{ 2740232950Stheraven static const size_t value = _Xp & ((unsigned long long)(1) << _Rp) ? _Rp 2741232950Stheraven : __log2_imp<_Xp, _Rp - 1>::value; 2742227825Stheraven}; 2743227825Stheraven 2744232950Stheraventemplate <unsigned long long _Xp> 2745232950Stheravenstruct __log2_imp<_Xp, 0> 2746227825Stheraven{ 2747227825Stheraven static const size_t value = 0; 2748227825Stheraven}; 2749227825Stheraven 2750232950Stheraventemplate <size_t _Rp> 2751232950Stheravenstruct __log2_imp<0, _Rp> 2752227825Stheraven{ 2753232950Stheraven static const size_t value = _Rp + 1; 2754227825Stheraven}; 2755227825Stheraven 2756232950Stheraventemplate <class _UI, _UI _Xp> 2757227825Stheravenstruct __log2 2758227825Stheraven{ 2759232950Stheraven static const size_t value = __log2_imp<_Xp, 2760227825Stheraven sizeof(_UI) * __CHAR_BIT__ - 1>::value; 2761227825Stheraven}; 2762227825Stheraven 2763227825Stheraventemplate<class _Engine, class _UIntType> 2764227825Stheravenclass __independent_bits_engine 2765227825Stheraven{ 2766227825Stheravenpublic: 2767227825Stheraven // types 2768227825Stheraven typedef _UIntType result_type; 2769227825Stheraven 2770227825Stheravenprivate: 2771227825Stheraven typedef typename _Engine::result_type _Engine_result_type; 2772227825Stheraven typedef typename conditional 2773227825Stheraven < 2774227825Stheraven sizeof(_Engine_result_type) <= sizeof(result_type), 2775227825Stheraven result_type, 2776227825Stheraven _Engine_result_type 2777227825Stheraven >::type _Working_result_type; 2778227825Stheraven 2779227825Stheraven _Engine& __e_; 2780227825Stheraven size_t __w_; 2781227825Stheraven size_t __w0_; 2782227825Stheraven size_t __n_; 2783227825Stheraven size_t __n0_; 2784227825Stheraven _Working_result_type __y0_; 2785227825Stheraven _Working_result_type __y1_; 2786227825Stheraven _Engine_result_type __mask0_; 2787227825Stheraven _Engine_result_type __mask1_; 2788227825Stheraven 2789234976Stheraven#ifdef _LIBCPP_HAS_NO_CONSTEXPR 2790232950Stheraven static const _Working_result_type _Rp = _Engine::_Max - _Engine::_Min 2791234976Stheraven + _Working_result_type(1); 2792234976Stheraven#else 2793234976Stheraven static _LIBCPP_CONSTEXPR const _Working_result_type _Rp = _Engine::max() - _Engine::min() 2794234976Stheraven + _Working_result_type(1); 2795234976Stheraven#endif 2796234976Stheraven static _LIBCPP_CONSTEXPR const size_t __m = __log2<_Working_result_type, _Rp>::value; 2797234976Stheraven static _LIBCPP_CONSTEXPR const size_t _WDt = numeric_limits<_Working_result_type>::digits; 2798234976Stheraven static _LIBCPP_CONSTEXPR const size_t _EDt = numeric_limits<_Engine_result_type>::digits; 2799227825Stheraven 2800227825Stheravenpublic: 2801227825Stheraven // constructors and seeding functions 2802227825Stheraven __independent_bits_engine(_Engine& __e, size_t __w); 2803227825Stheraven 2804227825Stheraven // generating functions 2805232950Stheraven result_type operator()() {return __eval(integral_constant<bool, _Rp != 0>());} 2806227825Stheraven 2807227825Stheravenprivate: 2808227825Stheraven result_type __eval(false_type); 2809227825Stheraven result_type __eval(true_type); 2810227825Stheraven}; 2811227825Stheraven 2812227825Stheraventemplate<class _Engine, class _UIntType> 2813227825Stheraven__independent_bits_engine<_Engine, _UIntType> 2814227825Stheraven ::__independent_bits_engine(_Engine& __e, size_t __w) 2815227825Stheraven : __e_(__e), 2816227825Stheraven __w_(__w) 2817227825Stheraven{ 2818227825Stheraven __n_ = __w_ / __m + (__w_ % __m != 0); 2819227825Stheraven __w0_ = __w_ / __n_; 2820232950Stheraven if (_Rp == 0) 2821232950Stheraven __y0_ = _Rp; 2822227825Stheraven else if (__w0_ < _WDt) 2823232950Stheraven __y0_ = (_Rp >> __w0_) << __w0_; 2824227825Stheraven else 2825227825Stheraven __y0_ = 0; 2826232950Stheraven if (_Rp - __y0_ > __y0_ / __n_) 2827227825Stheraven { 2828227825Stheraven ++__n_; 2829227825Stheraven __w0_ = __w_ / __n_; 2830227825Stheraven if (__w0_ < _WDt) 2831232950Stheraven __y0_ = (_Rp >> __w0_) << __w0_; 2832227825Stheraven else 2833227825Stheraven __y0_ = 0; 2834227825Stheraven } 2835227825Stheraven __n0_ = __n_ - __w_ % __n_; 2836227825Stheraven if (__w0_ < _WDt - 1) 2837232950Stheraven __y1_ = (_Rp >> (__w0_ + 1)) << (__w0_ + 1); 2838227825Stheraven else 2839227825Stheraven __y1_ = 0; 2840227825Stheraven __mask0_ = __w0_ > 0 ? _Engine_result_type(~0) >> (_EDt - __w0_) : 2841227825Stheraven _Engine_result_type(0); 2842227825Stheraven __mask1_ = __w0_ < _EDt - 1 ? 2843227825Stheraven _Engine_result_type(~0) >> (_EDt - (__w0_ + 1)) : 2844227825Stheraven _Engine_result_type(~0); 2845227825Stheraven} 2846227825Stheraven 2847227825Stheraventemplate<class _Engine, class _UIntType> 2848227825Stheraveninline 2849227825Stheraven_UIntType 2850227825Stheraven__independent_bits_engine<_Engine, _UIntType>::__eval(false_type) 2851227825Stheraven{ 2852227825Stheraven return static_cast<result_type>(__e_() & __mask0_); 2853227825Stheraven} 2854227825Stheraven 2855227825Stheraventemplate<class _Engine, class _UIntType> 2856227825Stheraven_UIntType 2857227825Stheraven__independent_bits_engine<_Engine, _UIntType>::__eval(true_type) 2858227825Stheraven{ 2859232950Stheraven result_type _Sp = 0; 2860227825Stheraven for (size_t __k = 0; __k < __n0_; ++__k) 2861227825Stheraven { 2862227825Stheraven _Engine_result_type __u; 2863227825Stheraven do 2864227825Stheraven { 2865227825Stheraven __u = __e_() - _Engine::min(); 2866227825Stheraven } while (__u >= __y0_); 2867227825Stheraven if (__w0_ < _WDt) 2868232950Stheraven _Sp <<= __w0_; 2869227825Stheraven else 2870232950Stheraven _Sp = 0; 2871232950Stheraven _Sp += __u & __mask0_; 2872227825Stheraven } 2873227825Stheraven for (size_t __k = __n0_; __k < __n_; ++__k) 2874227825Stheraven { 2875227825Stheraven _Engine_result_type __u; 2876227825Stheraven do 2877227825Stheraven { 2878227825Stheraven __u = __e_() - _Engine::min(); 2879227825Stheraven } while (__u >= __y1_); 2880227825Stheraven if (__w0_ < _WDt - 1) 2881232950Stheraven _Sp <<= __w0_ + 1; 2882227825Stheraven else 2883232950Stheraven _Sp = 0; 2884232950Stheraven _Sp += __u & __mask1_; 2885227825Stheraven } 2886232950Stheraven return _Sp; 2887227825Stheraven} 2888227825Stheraven 2889227825Stheraven// uniform_int_distribution 2890227825Stheraven 2891227825Stheraventemplate<class _IntType = int> 2892227825Stheravenclass uniform_int_distribution 2893227825Stheraven{ 2894227825Stheravenpublic: 2895227825Stheraven // types 2896227825Stheraven typedef _IntType result_type; 2897227825Stheraven 2898227825Stheraven class param_type 2899227825Stheraven { 2900227825Stheraven result_type __a_; 2901227825Stheraven result_type __b_; 2902227825Stheraven public: 2903227825Stheraven typedef uniform_int_distribution distribution_type; 2904227825Stheraven 2905227825Stheraven explicit param_type(result_type __a = 0, 2906227825Stheraven result_type __b = numeric_limits<result_type>::max()) 2907227825Stheraven : __a_(__a), __b_(__b) {} 2908227825Stheraven 2909227825Stheraven result_type a() const {return __a_;} 2910227825Stheraven result_type b() const {return __b_;} 2911227825Stheraven 2912227825Stheraven friend bool operator==(const param_type& __x, const param_type& __y) 2913227825Stheraven {return __x.__a_ == __y.__a_ && __x.__b_ == __y.__b_;} 2914227825Stheraven friend bool operator!=(const param_type& __x, const param_type& __y) 2915227825Stheraven {return !(__x == __y);} 2916227825Stheraven }; 2917227825Stheraven 2918227825Stheravenprivate: 2919227825Stheraven param_type __p_; 2920227825Stheraven 2921227825Stheravenpublic: 2922227825Stheraven // constructors and reset functions 2923227825Stheraven explicit uniform_int_distribution(result_type __a = 0, 2924227825Stheraven result_type __b = numeric_limits<result_type>::max()) 2925227825Stheraven : __p_(param_type(__a, __b)) {} 2926227825Stheraven explicit uniform_int_distribution(const param_type& __p) : __p_(__p) {} 2927227825Stheraven void reset() {} 2928227825Stheraven 2929227825Stheraven // generating functions 2930227825Stheraven template<class _URNG> result_type operator()(_URNG& __g) 2931227825Stheraven {return (*this)(__g, __p_);} 2932227825Stheraven template<class _URNG> result_type operator()(_URNG& __g, const param_type& __p); 2933227825Stheraven 2934227825Stheraven // property functions 2935227825Stheraven result_type a() const {return __p_.a();} 2936227825Stheraven result_type b() const {return __p_.b();} 2937227825Stheraven 2938227825Stheraven param_type param() const {return __p_;} 2939227825Stheraven void param(const param_type& __p) {__p_ = __p;} 2940227825Stheraven 2941227825Stheraven result_type min() const {return a();} 2942227825Stheraven result_type max() const {return b();} 2943227825Stheraven 2944227825Stheraven friend bool operator==(const uniform_int_distribution& __x, 2945227825Stheraven const uniform_int_distribution& __y) 2946227825Stheraven {return __x.__p_ == __y.__p_;} 2947227825Stheraven friend bool operator!=(const uniform_int_distribution& __x, 2948227825Stheraven const uniform_int_distribution& __y) 2949227825Stheraven {return !(__x == __y);} 2950227825Stheraven}; 2951227825Stheraven 2952227825Stheraventemplate<class _IntType> 2953227825Stheraventemplate<class _URNG> 2954227825Stheraventypename uniform_int_distribution<_IntType>::result_type 2955227825Stheravenuniform_int_distribution<_IntType>::operator()(_URNG& __g, const param_type& __p) 2956227825Stheraven{ 2957227825Stheraven typedef typename conditional<sizeof(result_type) <= sizeof(uint32_t), 2958227825Stheraven uint32_t, uint64_t>::type _UIntType; 2959232950Stheraven const _UIntType _Rp = __p.b() - __p.a() + _UIntType(1); 2960232950Stheraven if (_Rp == 1) 2961227825Stheraven return __p.a(); 2962227825Stheraven const size_t _Dt = numeric_limits<_UIntType>::digits; 2963227825Stheraven typedef __independent_bits_engine<_URNG, _UIntType> _Eng; 2964232950Stheraven if (_Rp == 0) 2965227825Stheraven return static_cast<result_type>(_Eng(__g, _Dt)()); 2966232950Stheraven size_t __w = _Dt - __clz(_Rp) - 1; 2967232950Stheraven if ((_Rp & (_UIntType(~0) >> (_Dt - __w))) != 0) 2968227825Stheraven ++__w; 2969227825Stheraven _Eng __e(__g, __w); 2970227825Stheraven _UIntType __u; 2971227825Stheraven do 2972227825Stheraven { 2973227825Stheraven __u = __e(); 2974232950Stheraven } while (__u >= _Rp); 2975227825Stheraven return static_cast<result_type>(__u + __p.a()); 2976227825Stheraven} 2977227825Stheraven 2978262801Sdimclass _LIBCPP_TYPE_VIS __rs_default; 2979227825Stheraven 2980262801Sdim_LIBCPP_FUNC_VIS __rs_default __rs_get(); 2981227825Stheraven 2982262801Sdimclass _LIBCPP_TYPE_VIS __rs_default 2983227825Stheraven{ 2984227825Stheraven static unsigned __c_; 2985227825Stheraven 2986227825Stheraven __rs_default(); 2987227825Stheravenpublic: 2988249998Sdim typedef uint_fast32_t result_type; 2989227825Stheraven 2990227825Stheraven static const result_type _Min = 0; 2991227825Stheraven static const result_type _Max = 0xFFFFFFFF; 2992227825Stheraven 2993227825Stheraven __rs_default(const __rs_default&); 2994227825Stheraven ~__rs_default(); 2995227825Stheraven 2996227825Stheraven result_type operator()(); 2997227825Stheraven 2998234976Stheraven static _LIBCPP_CONSTEXPR result_type min() {return _Min;} 2999234976Stheraven static _LIBCPP_CONSTEXPR result_type max() {return _Max;} 3000227825Stheraven 3001262801Sdim friend _LIBCPP_FUNC_VIS __rs_default __rs_get(); 3002227825Stheraven}; 3003227825Stheraven 3004262801Sdim_LIBCPP_FUNC_VIS __rs_default __rs_get(); 3005227825Stheraven 3006227825Stheraventemplate <class _RandomAccessIterator> 3007227825Stheravenvoid 3008227825Stheravenrandom_shuffle(_RandomAccessIterator __first, _RandomAccessIterator __last) 3009227825Stheraven{ 3010227825Stheraven typedef typename iterator_traits<_RandomAccessIterator>::difference_type difference_type; 3011232950Stheraven typedef uniform_int_distribution<ptrdiff_t> _Dp; 3012232950Stheraven typedef typename _Dp::param_type _Pp; 3013227825Stheraven difference_type __d = __last - __first; 3014227825Stheraven if (__d > 1) 3015227825Stheraven { 3016232950Stheraven _Dp __uid; 3017227825Stheraven __rs_default __g = __rs_get(); 3018227825Stheraven for (--__last, --__d; __first < __last; ++__first, --__d) 3019227825Stheraven { 3020232950Stheraven difference_type __i = __uid(__g, _Pp(0, __d)); 3021227825Stheraven if (__i != difference_type(0)) 3022227825Stheraven swap(*__first, *(__first + __i)); 3023227825Stheraven } 3024227825Stheraven } 3025227825Stheraven} 3026227825Stheraven 3027227825Stheraventemplate <class _RandomAccessIterator, class _RandomNumberGenerator> 3028227825Stheravenvoid 3029227825Stheravenrandom_shuffle(_RandomAccessIterator __first, _RandomAccessIterator __last, 3030227825Stheraven#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES 3031227825Stheraven _RandomNumberGenerator&& __rand) 3032227825Stheraven#else 3033227825Stheraven _RandomNumberGenerator& __rand) 3034227825Stheraven#endif 3035227825Stheraven{ 3036227825Stheraven typedef typename iterator_traits<_RandomAccessIterator>::difference_type difference_type; 3037227825Stheraven difference_type __d = __last - __first; 3038227825Stheraven if (__d > 1) 3039227825Stheraven { 3040227825Stheraven for (--__last; __first < __last; ++__first, --__d) 3041227825Stheraven { 3042227825Stheraven difference_type __i = __rand(__d); 3043227825Stheraven swap(*__first, *(__first + __i)); 3044227825Stheraven } 3045227825Stheraven } 3046227825Stheraven} 3047227825Stheraven 3048227825Stheraventemplate<class _RandomAccessIterator, class _UniformRandomNumberGenerator> 3049227825Stheraven void shuffle(_RandomAccessIterator __first, _RandomAccessIterator __last, 3050227825Stheraven#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES 3051227825Stheraven _UniformRandomNumberGenerator&& __g) 3052227825Stheraven#else 3053227825Stheraven _UniformRandomNumberGenerator& __g) 3054227825Stheraven#endif 3055227825Stheraven{ 3056227825Stheraven typedef typename iterator_traits<_RandomAccessIterator>::difference_type difference_type; 3057232950Stheraven typedef uniform_int_distribution<ptrdiff_t> _Dp; 3058232950Stheraven typedef typename _Dp::param_type _Pp; 3059227825Stheraven difference_type __d = __last - __first; 3060227825Stheraven if (__d > 1) 3061227825Stheraven { 3062232950Stheraven _Dp __uid; 3063227825Stheraven for (--__last, --__d; __first < __last; ++__first, --__d) 3064227825Stheraven { 3065232950Stheraven difference_type __i = __uid(__g, _Pp(0, __d)); 3066227825Stheraven if (__i != difference_type(0)) 3067227825Stheraven swap(*__first, *(__first + __i)); 3068227825Stheraven } 3069227825Stheraven } 3070227825Stheraven} 3071227825Stheraven 3072227825Stheraventemplate <class _InputIterator, class _Predicate> 3073227825Stheravenbool 3074227825Stheravenis_partitioned(_InputIterator __first, _InputIterator __last, _Predicate __pred) 3075227825Stheraven{ 3076227825Stheraven for (; __first != __last; ++__first) 3077227825Stheraven if (!__pred(*__first)) 3078227825Stheraven break; 3079227825Stheraven for (; __first != __last; ++__first) 3080227825Stheraven if (__pred(*__first)) 3081227825Stheraven return false; 3082227825Stheraven return true; 3083227825Stheraven} 3084227825Stheraven 3085227825Stheraven// partition 3086227825Stheraven 3087227825Stheraventemplate <class _Predicate, class _ForwardIterator> 3088227825Stheraven_ForwardIterator 3089227825Stheraven__partition(_ForwardIterator __first, _ForwardIterator __last, _Predicate __pred, forward_iterator_tag) 3090227825Stheraven{ 3091227825Stheraven while (true) 3092227825Stheraven { 3093227825Stheraven if (__first == __last) 3094227825Stheraven return __first; 3095227825Stheraven if (!__pred(*__first)) 3096227825Stheraven break; 3097227825Stheraven ++__first; 3098227825Stheraven } 3099227825Stheraven for (_ForwardIterator __p = __first; ++__p != __last;) 3100227825Stheraven { 3101227825Stheraven if (__pred(*__p)) 3102227825Stheraven { 3103227825Stheraven swap(*__first, *__p); 3104227825Stheraven ++__first; 3105227825Stheraven } 3106227825Stheraven } 3107227825Stheraven return __first; 3108227825Stheraven} 3109227825Stheraven 3110227825Stheraventemplate <class _Predicate, class _BidirectionalIterator> 3111227825Stheraven_BidirectionalIterator 3112227825Stheraven__partition(_BidirectionalIterator __first, _BidirectionalIterator __last, _Predicate __pred, 3113227825Stheraven bidirectional_iterator_tag) 3114227825Stheraven{ 3115227825Stheraven while (true) 3116227825Stheraven { 3117227825Stheraven while (true) 3118227825Stheraven { 3119227825Stheraven if (__first == __last) 3120227825Stheraven return __first; 3121227825Stheraven if (!__pred(*__first)) 3122227825Stheraven break; 3123227825Stheraven ++__first; 3124227825Stheraven } 3125227825Stheraven do 3126227825Stheraven { 3127227825Stheraven if (__first == --__last) 3128227825Stheraven return __first; 3129227825Stheraven } while (!__pred(*__last)); 3130227825Stheraven swap(*__first, *__last); 3131227825Stheraven ++__first; 3132227825Stheraven } 3133227825Stheraven} 3134227825Stheraven 3135227825Stheraventemplate <class _ForwardIterator, class _Predicate> 3136227825Stheraveninline _LIBCPP_INLINE_VISIBILITY 3137227825Stheraven_ForwardIterator 3138227825Stheravenpartition(_ForwardIterator __first, _ForwardIterator __last, _Predicate __pred) 3139227825Stheraven{ 3140227825Stheraven return _VSTD::__partition<typename add_lvalue_reference<_Predicate>::type> 3141227825Stheraven (__first, __last, __pred, typename iterator_traits<_ForwardIterator>::iterator_category()); 3142227825Stheraven} 3143227825Stheraven 3144227825Stheraven// partition_copy 3145227825Stheraven 3146227825Stheraventemplate <class _InputIterator, class _OutputIterator1, 3147227825Stheraven class _OutputIterator2, class _Predicate> 3148227825Stheravenpair<_OutputIterator1, _OutputIterator2> 3149227825Stheravenpartition_copy(_InputIterator __first, _InputIterator __last, 3150227825Stheraven _OutputIterator1 __out_true, _OutputIterator2 __out_false, 3151227825Stheraven _Predicate __pred) 3152227825Stheraven{ 3153227825Stheraven for (; __first != __last; ++__first) 3154227825Stheraven { 3155227825Stheraven if (__pred(*__first)) 3156227825Stheraven { 3157227825Stheraven *__out_true = *__first; 3158227825Stheraven ++__out_true; 3159227825Stheraven } 3160227825Stheraven else 3161227825Stheraven { 3162227825Stheraven *__out_false = *__first; 3163227825Stheraven ++__out_false; 3164227825Stheraven } 3165227825Stheraven } 3166227825Stheraven return pair<_OutputIterator1, _OutputIterator2>(__out_true, __out_false); 3167227825Stheraven} 3168227825Stheraven 3169227825Stheraven// partition_point 3170227825Stheraven 3171227825Stheraventemplate<class _ForwardIterator, class _Predicate> 3172227825Stheraven_ForwardIterator 3173227825Stheravenpartition_point(_ForwardIterator __first, _ForwardIterator __last, _Predicate __pred) 3174227825Stheraven{ 3175227825Stheraven typedef typename iterator_traits<_ForwardIterator>::difference_type difference_type; 3176227825Stheraven difference_type __len = _VSTD::distance(__first, __last); 3177227825Stheraven while (__len != 0) 3178227825Stheraven { 3179227825Stheraven difference_type __l2 = __len / 2; 3180227825Stheraven _ForwardIterator __m = __first; 3181227825Stheraven _VSTD::advance(__m, __l2); 3182227825Stheraven if (__pred(*__m)) 3183227825Stheraven { 3184227825Stheraven __first = ++__m; 3185227825Stheraven __len -= __l2 + 1; 3186227825Stheraven } 3187227825Stheraven else 3188227825Stheraven __len = __l2; 3189227825Stheraven } 3190227825Stheraven return __first; 3191227825Stheraven} 3192227825Stheraven 3193227825Stheraven// stable_partition 3194227825Stheraven 3195227825Stheraventemplate <class _Predicate, class _ForwardIterator, class _Distance, class _Pair> 3196227825Stheraven_ForwardIterator 3197227825Stheraven__stable_partition(_ForwardIterator __first, _ForwardIterator __last, _Predicate __pred, 3198227825Stheraven _Distance __len, _Pair __p, forward_iterator_tag __fit) 3199227825Stheraven{ 3200227825Stheraven // *__first is known to be false 3201227825Stheraven // __len >= 1 3202227825Stheraven if (__len == 1) 3203227825Stheraven return __first; 3204227825Stheraven if (__len == 2) 3205227825Stheraven { 3206227825Stheraven _ForwardIterator __m = __first; 3207227825Stheraven if (__pred(*++__m)) 3208227825Stheraven { 3209227825Stheraven swap(*__first, *__m); 3210227825Stheraven return __m; 3211227825Stheraven } 3212227825Stheraven return __first; 3213227825Stheraven } 3214227825Stheraven if (__len <= __p.second) 3215227825Stheraven { // The buffer is big enough to use 3216227825Stheraven typedef typename iterator_traits<_ForwardIterator>::value_type value_type; 3217227825Stheraven __destruct_n __d(0); 3218227825Stheraven unique_ptr<value_type, __destruct_n&> __h(__p.first, __d); 3219227825Stheraven // Move the falses into the temporary buffer, and the trues to the front of the line 3220227825Stheraven // Update __first to always point to the end of the trues 3221227825Stheraven value_type* __t = __p.first; 3222227825Stheraven ::new(__t) value_type(_VSTD::move(*__first)); 3223227825Stheraven __d.__incr((value_type*)0); 3224227825Stheraven ++__t; 3225227825Stheraven _ForwardIterator __i = __first; 3226227825Stheraven while (++__i != __last) 3227227825Stheraven { 3228227825Stheraven if (__pred(*__i)) 3229227825Stheraven { 3230227825Stheraven *__first = _VSTD::move(*__i); 3231227825Stheraven ++__first; 3232227825Stheraven } 3233227825Stheraven else 3234227825Stheraven { 3235227825Stheraven ::new(__t) value_type(_VSTD::move(*__i)); 3236227825Stheraven __d.__incr((value_type*)0); 3237227825Stheraven ++__t; 3238227825Stheraven } 3239227825Stheraven } 3240227825Stheraven // All trues now at start of range, all falses in buffer 3241227825Stheraven // Move falses back into range, but don't mess up __first which points to first false 3242227825Stheraven __i = __first; 3243227825Stheraven for (value_type* __t2 = __p.first; __t2 < __t; ++__t2, ++__i) 3244227825Stheraven *__i = _VSTD::move(*__t2); 3245227825Stheraven // __h destructs moved-from values out of the temp buffer, but doesn't deallocate buffer 3246227825Stheraven return __first; 3247227825Stheraven } 3248227825Stheraven // Else not enough buffer, do in place 3249227825Stheraven // __len >= 3 3250227825Stheraven _ForwardIterator __m = __first; 3251227825Stheraven _Distance __len2 = __len / 2; // __len2 >= 2 3252227825Stheraven _VSTD::advance(__m, __len2); 3253227825Stheraven // recurse on [__first, __m), *__first know to be false 3254227825Stheraven // F????????????????? 3255227825Stheraven // f m l 3256227825Stheraven typedef typename add_lvalue_reference<_Predicate>::type _PredRef; 3257227825Stheraven _ForwardIterator __first_false = __stable_partition<_PredRef>(__first, __m, __pred, __len2, __p, __fit); 3258227825Stheraven // TTTFFFFF?????????? 3259227825Stheraven // f ff m l 3260227825Stheraven // recurse on [__m, __last], except increase __m until *(__m) is false, *__last know to be true 3261227825Stheraven _ForwardIterator __m1 = __m; 3262227825Stheraven _ForwardIterator __second_false = __last; 3263227825Stheraven _Distance __len_half = __len - __len2; 3264227825Stheraven while (__pred(*__m1)) 3265227825Stheraven { 3266227825Stheraven if (++__m1 == __last) 3267227825Stheraven goto __second_half_done; 3268227825Stheraven --__len_half; 3269227825Stheraven } 3270227825Stheraven // TTTFFFFFTTTF?????? 3271227825Stheraven // f ff m m1 l 3272227825Stheraven __second_false = __stable_partition<_PredRef>(__m1, __last, __pred, __len_half, __p, __fit); 3273227825Stheraven__second_half_done: 3274227825Stheraven // TTTFFFFFTTTTTFFFFF 3275227825Stheraven // f ff m sf l 3276227825Stheraven return _VSTD::rotate(__first_false, __m, __second_false); 3277227825Stheraven // TTTTTTTTFFFFFFFFFF 3278227825Stheraven // | 3279227825Stheraven} 3280227825Stheraven 3281227825Stheravenstruct __return_temporary_buffer 3282227825Stheraven{ 3283227825Stheraven template <class _Tp> 3284227825Stheraven _LIBCPP_INLINE_VISIBILITY void operator()(_Tp* __p) const {_VSTD::return_temporary_buffer(__p);} 3285227825Stheraven}; 3286227825Stheraven 3287227825Stheraventemplate <class _Predicate, class _ForwardIterator> 3288227825Stheraven_ForwardIterator 3289227825Stheraven__stable_partition(_ForwardIterator __first, _ForwardIterator __last, _Predicate __pred, 3290227825Stheraven forward_iterator_tag) 3291227825Stheraven{ 3292227825Stheraven const unsigned __alloc_limit = 3; // might want to make this a function of trivial assignment 3293227825Stheraven // Either prove all true and return __first or point to first false 3294227825Stheraven while (true) 3295227825Stheraven { 3296227825Stheraven if (__first == __last) 3297227825Stheraven return __first; 3298227825Stheraven if (!__pred(*__first)) 3299227825Stheraven break; 3300227825Stheraven ++__first; 3301227825Stheraven } 3302227825Stheraven // We now have a reduced range [__first, __last) 3303227825Stheraven // *__first is known to be false 3304227825Stheraven typedef typename iterator_traits<_ForwardIterator>::difference_type difference_type; 3305227825Stheraven typedef typename iterator_traits<_ForwardIterator>::value_type value_type; 3306227825Stheraven difference_type __len = _VSTD::distance(__first, __last); 3307227825Stheraven pair<value_type*, ptrdiff_t> __p(0, 0); 3308227825Stheraven unique_ptr<value_type, __return_temporary_buffer> __h; 3309227825Stheraven if (__len >= __alloc_limit) 3310227825Stheraven { 3311227825Stheraven __p = _VSTD::get_temporary_buffer<value_type>(__len); 3312227825Stheraven __h.reset(__p.first); 3313227825Stheraven } 3314227825Stheraven return __stable_partition<typename add_lvalue_reference<_Predicate>::type> 3315227825Stheraven (__first, __last, __pred, __len, __p, forward_iterator_tag()); 3316227825Stheraven} 3317227825Stheraven 3318227825Stheraventemplate <class _Predicate, class _BidirectionalIterator, class _Distance, class _Pair> 3319227825Stheraven_BidirectionalIterator 3320227825Stheraven__stable_partition(_BidirectionalIterator __first, _BidirectionalIterator __last, _Predicate __pred, 3321227825Stheraven _Distance __len, _Pair __p, bidirectional_iterator_tag __bit) 3322227825Stheraven{ 3323227825Stheraven // *__first is known to be false 3324227825Stheraven // *__last is known to be true 3325227825Stheraven // __len >= 2 3326227825Stheraven if (__len == 2) 3327227825Stheraven { 3328227825Stheraven swap(*__first, *__last); 3329227825Stheraven return __last; 3330227825Stheraven } 3331227825Stheraven if (__len == 3) 3332227825Stheraven { 3333227825Stheraven _BidirectionalIterator __m = __first; 3334227825Stheraven if (__pred(*++__m)) 3335227825Stheraven { 3336227825Stheraven swap(*__first, *__m); 3337227825Stheraven swap(*__m, *__last); 3338227825Stheraven return __last; 3339227825Stheraven } 3340227825Stheraven swap(*__m, *__last); 3341227825Stheraven swap(*__first, *__m); 3342227825Stheraven return __m; 3343227825Stheraven } 3344227825Stheraven if (__len <= __p.second) 3345227825Stheraven { // The buffer is big enough to use 3346227825Stheraven typedef typename iterator_traits<_BidirectionalIterator>::value_type value_type; 3347227825Stheraven __destruct_n __d(0); 3348227825Stheraven unique_ptr<value_type, __destruct_n&> __h(__p.first, __d); 3349227825Stheraven // Move the falses into the temporary buffer, and the trues to the front of the line 3350227825Stheraven // Update __first to always point to the end of the trues 3351227825Stheraven value_type* __t = __p.first; 3352227825Stheraven ::new(__t) value_type(_VSTD::move(*__first)); 3353227825Stheraven __d.__incr((value_type*)0); 3354227825Stheraven ++__t; 3355227825Stheraven _BidirectionalIterator __i = __first; 3356227825Stheraven while (++__i != __last) 3357227825Stheraven { 3358227825Stheraven if (__pred(*__i)) 3359227825Stheraven { 3360227825Stheraven *__first = _VSTD::move(*__i); 3361227825Stheraven ++__first; 3362227825Stheraven } 3363227825Stheraven else 3364227825Stheraven { 3365227825Stheraven ::new(__t) value_type(_VSTD::move(*__i)); 3366227825Stheraven __d.__incr((value_type*)0); 3367227825Stheraven ++__t; 3368227825Stheraven } 3369227825Stheraven } 3370227825Stheraven // move *__last, known to be true 3371227825Stheraven *__first = _VSTD::move(*__i); 3372227825Stheraven __i = ++__first; 3373227825Stheraven // All trues now at start of range, all falses in buffer 3374227825Stheraven // Move falses back into range, but don't mess up __first which points to first false 3375227825Stheraven for (value_type* __t2 = __p.first; __t2 < __t; ++__t2, ++__i) 3376227825Stheraven *__i = _VSTD::move(*__t2); 3377227825Stheraven // __h destructs moved-from values out of the temp buffer, but doesn't deallocate buffer 3378227825Stheraven return __first; 3379227825Stheraven } 3380227825Stheraven // Else not enough buffer, do in place 3381227825Stheraven // __len >= 4 3382227825Stheraven _BidirectionalIterator __m = __first; 3383227825Stheraven _Distance __len2 = __len / 2; // __len2 >= 2 3384227825Stheraven _VSTD::advance(__m, __len2); 3385227825Stheraven // recurse on [__first, __m-1], except reduce __m-1 until *(__m-1) is true, *__first know to be false 3386227825Stheraven // F????????????????T 3387227825Stheraven // f m l 3388227825Stheraven _BidirectionalIterator __m1 = __m; 3389227825Stheraven _BidirectionalIterator __first_false = __first; 3390227825Stheraven _Distance __len_half = __len2; 3391227825Stheraven while (!__pred(*--__m1)) 3392227825Stheraven { 3393227825Stheraven if (__m1 == __first) 3394227825Stheraven goto __first_half_done; 3395227825Stheraven --__len_half; 3396227825Stheraven } 3397227825Stheraven // F???TFFF?????????T 3398227825Stheraven // f m1 m l 3399227825Stheraven typedef typename add_lvalue_reference<_Predicate>::type _PredRef; 3400227825Stheraven __first_false = __stable_partition<_PredRef>(__first, __m1, __pred, __len_half, __p, __bit); 3401227825Stheraven__first_half_done: 3402227825Stheraven // TTTFFFFF?????????T 3403227825Stheraven // f ff m l 3404227825Stheraven // recurse on [__m, __last], except increase __m until *(__m) is false, *__last know to be true 3405227825Stheraven __m1 = __m; 3406227825Stheraven _BidirectionalIterator __second_false = __last; 3407227825Stheraven ++__second_false; 3408227825Stheraven __len_half = __len - __len2; 3409227825Stheraven while (__pred(*__m1)) 3410227825Stheraven { 3411227825Stheraven if (++__m1 == __last) 3412227825Stheraven goto __second_half_done; 3413227825Stheraven --__len_half; 3414227825Stheraven } 3415227825Stheraven // TTTFFFFFTTTF?????T 3416227825Stheraven // f ff m m1 l 3417227825Stheraven __second_false = __stable_partition<_PredRef>(__m1, __last, __pred, __len_half, __p, __bit); 3418227825Stheraven__second_half_done: 3419227825Stheraven // TTTFFFFFTTTTTFFFFF 3420227825Stheraven // f ff m sf l 3421227825Stheraven return _VSTD::rotate(__first_false, __m, __second_false); 3422227825Stheraven // TTTTTTTTFFFFFFFFFF 3423227825Stheraven // | 3424227825Stheraven} 3425227825Stheraven 3426227825Stheraventemplate <class _Predicate, class _BidirectionalIterator> 3427227825Stheraven_BidirectionalIterator 3428227825Stheraven__stable_partition(_BidirectionalIterator __first, _BidirectionalIterator __last, _Predicate __pred, 3429227825Stheraven bidirectional_iterator_tag) 3430227825Stheraven{ 3431227825Stheraven typedef typename iterator_traits<_BidirectionalIterator>::difference_type difference_type; 3432227825Stheraven typedef typename iterator_traits<_BidirectionalIterator>::value_type value_type; 3433227825Stheraven const difference_type __alloc_limit = 4; // might want to make this a function of trivial assignment 3434227825Stheraven // Either prove all true and return __first or point to first false 3435227825Stheraven while (true) 3436227825Stheraven { 3437227825Stheraven if (__first == __last) 3438227825Stheraven return __first; 3439227825Stheraven if (!__pred(*__first)) 3440227825Stheraven break; 3441227825Stheraven ++__first; 3442227825Stheraven } 3443227825Stheraven // __first points to first false, everything prior to __first is already set. 3444227825Stheraven // Either prove [__first, __last) is all false and return __first, or point __last to last true 3445227825Stheraven do 3446227825Stheraven { 3447227825Stheraven if (__first == --__last) 3448227825Stheraven return __first; 3449227825Stheraven } while (!__pred(*__last)); 3450227825Stheraven // We now have a reduced range [__first, __last] 3451227825Stheraven // *__first is known to be false 3452227825Stheraven // *__last is known to be true 3453227825Stheraven // __len >= 2 3454227825Stheraven difference_type __len = _VSTD::distance(__first, __last) + 1; 3455227825Stheraven pair<value_type*, ptrdiff_t> __p(0, 0); 3456227825Stheraven unique_ptr<value_type, __return_temporary_buffer> __h; 3457227825Stheraven if (__len >= __alloc_limit) 3458227825Stheraven { 3459227825Stheraven __p = _VSTD::get_temporary_buffer<value_type>(__len); 3460227825Stheraven __h.reset(__p.first); 3461227825Stheraven } 3462227825Stheraven return __stable_partition<typename add_lvalue_reference<_Predicate>::type> 3463227825Stheraven (__first, __last, __pred, __len, __p, bidirectional_iterator_tag()); 3464227825Stheraven} 3465227825Stheraven 3466227825Stheraventemplate <class _ForwardIterator, class _Predicate> 3467227825Stheraveninline _LIBCPP_INLINE_VISIBILITY 3468227825Stheraven_ForwardIterator 3469227825Stheravenstable_partition(_ForwardIterator __first, _ForwardIterator __last, _Predicate __pred) 3470227825Stheraven{ 3471227825Stheraven return __stable_partition<typename add_lvalue_reference<_Predicate>::type> 3472227825Stheraven (__first, __last, __pred, typename iterator_traits<_ForwardIterator>::iterator_category()); 3473227825Stheraven} 3474227825Stheraven 3475227825Stheraven// is_sorted_until 3476227825Stheraven 3477227825Stheraventemplate <class _ForwardIterator, class _Compare> 3478227825Stheraven_ForwardIterator 3479227825Stheravenis_sorted_until(_ForwardIterator __first, _ForwardIterator __last, _Compare __comp) 3480227825Stheraven{ 3481227825Stheraven if (__first != __last) 3482227825Stheraven { 3483227825Stheraven _ForwardIterator __i = __first; 3484227825Stheraven while (++__i != __last) 3485227825Stheraven { 3486227825Stheraven if (__comp(*__i, *__first)) 3487227825Stheraven return __i; 3488227825Stheraven __first = __i; 3489227825Stheraven } 3490227825Stheraven } 3491227825Stheraven return __last; 3492227825Stheraven} 3493227825Stheraven 3494227825Stheraventemplate<class _ForwardIterator> 3495227825Stheraveninline _LIBCPP_INLINE_VISIBILITY 3496227825Stheraven_ForwardIterator 3497227825Stheravenis_sorted_until(_ForwardIterator __first, _ForwardIterator __last) 3498227825Stheraven{ 3499227825Stheraven return _VSTD::is_sorted_until(__first, __last, __less<typename iterator_traits<_ForwardIterator>::value_type>()); 3500227825Stheraven} 3501227825Stheraven 3502227825Stheraven// is_sorted 3503227825Stheraven 3504227825Stheraventemplate <class _ForwardIterator, class _Compare> 3505227825Stheraveninline _LIBCPP_INLINE_VISIBILITY 3506227825Stheravenbool 3507227825Stheravenis_sorted(_ForwardIterator __first, _ForwardIterator __last, _Compare __comp) 3508227825Stheraven{ 3509227825Stheraven return _VSTD::is_sorted_until(__first, __last, __comp) == __last; 3510227825Stheraven} 3511227825Stheraven 3512227825Stheraventemplate<class _ForwardIterator> 3513227825Stheraveninline _LIBCPP_INLINE_VISIBILITY 3514227825Stheravenbool 3515227825Stheravenis_sorted(_ForwardIterator __first, _ForwardIterator __last) 3516227825Stheraven{ 3517227825Stheraven return _VSTD::is_sorted(__first, __last, __less<typename iterator_traits<_ForwardIterator>::value_type>()); 3518227825Stheraven} 3519227825Stheraven 3520227825Stheraven// sort 3521227825Stheraven 3522227825Stheraven// stable, 2-3 compares, 0-2 swaps 3523227825Stheraven 3524227825Stheraventemplate <class _Compare, class _ForwardIterator> 3525227825Stheravenunsigned 3526227825Stheraven__sort3(_ForwardIterator __x, _ForwardIterator __y, _ForwardIterator __z, _Compare __c) 3527227825Stheraven{ 3528227825Stheraven unsigned __r = 0; 3529227825Stheraven if (!__c(*__y, *__x)) // if x <= y 3530227825Stheraven { 3531227825Stheraven if (!__c(*__z, *__y)) // if y <= z 3532227825Stheraven return __r; // x <= y && y <= z 3533227825Stheraven // x <= y && y > z 3534227825Stheraven swap(*__y, *__z); // x <= z && y < z 3535227825Stheraven __r = 1; 3536227825Stheraven if (__c(*__y, *__x)) // if x > y 3537227825Stheraven { 3538227825Stheraven swap(*__x, *__y); // x < y && y <= z 3539227825Stheraven __r = 2; 3540227825Stheraven } 3541227825Stheraven return __r; // x <= y && y < z 3542227825Stheraven } 3543227825Stheraven if (__c(*__z, *__y)) // x > y, if y > z 3544227825Stheraven { 3545227825Stheraven swap(*__x, *__z); // x < y && y < z 3546227825Stheraven __r = 1; 3547227825Stheraven return __r; 3548227825Stheraven } 3549227825Stheraven swap(*__x, *__y); // x > y && y <= z 3550227825Stheraven __r = 1; // x < y && x <= z 3551227825Stheraven if (__c(*__z, *__y)) // if y > z 3552227825Stheraven { 3553227825Stheraven swap(*__y, *__z); // x <= y && y < z 3554227825Stheraven __r = 2; 3555227825Stheraven } 3556227825Stheraven return __r; 3557227825Stheraven} // x <= y && y <= z 3558227825Stheraven 3559227825Stheraven// stable, 3-6 compares, 0-5 swaps 3560227825Stheraven 3561227825Stheraventemplate <class _Compare, class _ForwardIterator> 3562227825Stheravenunsigned 3563227825Stheraven__sort4(_ForwardIterator __x1, _ForwardIterator __x2, _ForwardIterator __x3, 3564227825Stheraven _ForwardIterator __x4, _Compare __c) 3565227825Stheraven{ 3566227825Stheraven unsigned __r = __sort3<_Compare>(__x1, __x2, __x3, __c); 3567227825Stheraven if (__c(*__x4, *__x3)) 3568227825Stheraven { 3569227825Stheraven swap(*__x3, *__x4); 3570227825Stheraven ++__r; 3571227825Stheraven if (__c(*__x3, *__x2)) 3572227825Stheraven { 3573227825Stheraven swap(*__x2, *__x3); 3574227825Stheraven ++__r; 3575227825Stheraven if (__c(*__x2, *__x1)) 3576227825Stheraven { 3577227825Stheraven swap(*__x1, *__x2); 3578227825Stheraven ++__r; 3579227825Stheraven } 3580227825Stheraven } 3581227825Stheraven } 3582227825Stheraven return __r; 3583227825Stheraven} 3584227825Stheraven 3585227825Stheraven// stable, 4-10 compares, 0-9 swaps 3586227825Stheraven 3587227825Stheraventemplate <class _Compare, class _ForwardIterator> 3588227825Stheravenunsigned 3589227825Stheraven__sort5(_ForwardIterator __x1, _ForwardIterator __x2, _ForwardIterator __x3, 3590227825Stheraven _ForwardIterator __x4, _ForwardIterator __x5, _Compare __c) 3591227825Stheraven{ 3592227825Stheraven unsigned __r = __sort4<_Compare>(__x1, __x2, __x3, __x4, __c); 3593227825Stheraven if (__c(*__x5, *__x4)) 3594227825Stheraven { 3595227825Stheraven swap(*__x4, *__x5); 3596227825Stheraven ++__r; 3597227825Stheraven if (__c(*__x4, *__x3)) 3598227825Stheraven { 3599227825Stheraven swap(*__x3, *__x4); 3600227825Stheraven ++__r; 3601227825Stheraven if (__c(*__x3, *__x2)) 3602227825Stheraven { 3603227825Stheraven swap(*__x2, *__x3); 3604227825Stheraven ++__r; 3605227825Stheraven if (__c(*__x2, *__x1)) 3606227825Stheraven { 3607227825Stheraven swap(*__x1, *__x2); 3608227825Stheraven ++__r; 3609227825Stheraven } 3610227825Stheraven } 3611227825Stheraven } 3612227825Stheraven } 3613227825Stheraven return __r; 3614227825Stheraven} 3615227825Stheraven 3616227825Stheraven// Assumes size > 0 3617227825Stheraventemplate <class _Compare, class _BirdirectionalIterator> 3618227825Stheravenvoid 3619227825Stheraven__selection_sort(_BirdirectionalIterator __first, _BirdirectionalIterator __last, _Compare __comp) 3620227825Stheraven{ 3621227825Stheraven _BirdirectionalIterator __lm1 = __last; 3622227825Stheraven for (--__lm1; __first != __lm1; ++__first) 3623227825Stheraven { 3624227825Stheraven _BirdirectionalIterator __i = _VSTD::min_element<_BirdirectionalIterator, 3625227825Stheraven typename add_lvalue_reference<_Compare>::type> 3626227825Stheraven (__first, __last, __comp); 3627227825Stheraven if (__i != __first) 3628227825Stheraven swap(*__first, *__i); 3629227825Stheraven } 3630227825Stheraven} 3631227825Stheraven 3632227825Stheraventemplate <class _Compare, class _BirdirectionalIterator> 3633227825Stheravenvoid 3634227825Stheraven__insertion_sort(_BirdirectionalIterator __first, _BirdirectionalIterator __last, _Compare __comp) 3635227825Stheraven{ 3636227825Stheraven typedef typename iterator_traits<_BirdirectionalIterator>::value_type value_type; 3637227825Stheraven if (__first != __last) 3638227825Stheraven { 3639227825Stheraven _BirdirectionalIterator __i = __first; 3640227825Stheraven for (++__i; __i != __last; ++__i) 3641227825Stheraven { 3642227825Stheraven _BirdirectionalIterator __j = __i; 3643227825Stheraven value_type __t(_VSTD::move(*__j)); 3644227825Stheraven for (_BirdirectionalIterator __k = __i; __k != __first && __comp(__t, *--__k); --__j) 3645227825Stheraven *__j = _VSTD::move(*__k); 3646227825Stheraven *__j = _VSTD::move(__t); 3647227825Stheraven } 3648227825Stheraven } 3649227825Stheraven} 3650227825Stheraven 3651227825Stheraventemplate <class _Compare, class _RandomAccessIterator> 3652227825Stheravenvoid 3653227825Stheraven__insertion_sort_3(_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp) 3654227825Stheraven{ 3655227825Stheraven typedef typename iterator_traits<_RandomAccessIterator>::value_type value_type; 3656227825Stheraven _RandomAccessIterator __j = __first+2; 3657227825Stheraven __sort3<_Compare>(__first, __first+1, __j, __comp); 3658227825Stheraven for (_RandomAccessIterator __i = __j+1; __i != __last; ++__i) 3659227825Stheraven { 3660227825Stheraven if (__comp(*__i, *__j)) 3661227825Stheraven { 3662227825Stheraven value_type __t(_VSTD::move(*__i)); 3663227825Stheraven _RandomAccessIterator __k = __j; 3664227825Stheraven __j = __i; 3665227825Stheraven do 3666227825Stheraven { 3667227825Stheraven *__j = _VSTD::move(*__k); 3668227825Stheraven __j = __k; 3669227825Stheraven } while (__j != __first && __comp(__t, *--__k)); 3670227825Stheraven *__j = _VSTD::move(__t); 3671227825Stheraven } 3672227825Stheraven __j = __i; 3673227825Stheraven } 3674227825Stheraven} 3675227825Stheraven 3676227825Stheraventemplate <class _Compare, class _RandomAccessIterator> 3677227825Stheravenbool 3678227825Stheraven__insertion_sort_incomplete(_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp) 3679227825Stheraven{ 3680227825Stheraven switch (__last - __first) 3681227825Stheraven { 3682227825Stheraven case 0: 3683227825Stheraven case 1: 3684227825Stheraven return true; 3685227825Stheraven case 2: 3686227825Stheraven if (__comp(*--__last, *__first)) 3687227825Stheraven swap(*__first, *__last); 3688227825Stheraven return true; 3689227825Stheraven case 3: 3690227825Stheraven _VSTD::__sort3<_Compare>(__first, __first+1, --__last, __comp); 3691227825Stheraven return true; 3692227825Stheraven case 4: 3693227825Stheraven _VSTD::__sort4<_Compare>(__first, __first+1, __first+2, --__last, __comp); 3694227825Stheraven return true; 3695227825Stheraven case 5: 3696227825Stheraven _VSTD::__sort5<_Compare>(__first, __first+1, __first+2, __first+3, --__last, __comp); 3697227825Stheraven return true; 3698227825Stheraven } 3699227825Stheraven typedef typename iterator_traits<_RandomAccessIterator>::value_type value_type; 3700227825Stheraven _RandomAccessIterator __j = __first+2; 3701227825Stheraven __sort3<_Compare>(__first, __first+1, __j, __comp); 3702227825Stheraven const unsigned __limit = 8; 3703227825Stheraven unsigned __count = 0; 3704227825Stheraven for (_RandomAccessIterator __i = __j+1; __i != __last; ++__i) 3705227825Stheraven { 3706227825Stheraven if (__comp(*__i, *__j)) 3707227825Stheraven { 3708227825Stheraven value_type __t(_VSTD::move(*__i)); 3709227825Stheraven _RandomAccessIterator __k = __j; 3710227825Stheraven __j = __i; 3711227825Stheraven do 3712227825Stheraven { 3713227825Stheraven *__j = _VSTD::move(*__k); 3714227825Stheraven __j = __k; 3715227825Stheraven } while (__j != __first && __comp(__t, *--__k)); 3716227825Stheraven *__j = _VSTD::move(__t); 3717227825Stheraven if (++__count == __limit) 3718227825Stheraven return ++__i == __last; 3719227825Stheraven } 3720227825Stheraven __j = __i; 3721227825Stheraven } 3722227825Stheraven return true; 3723227825Stheraven} 3724227825Stheraven 3725227825Stheraventemplate <class _Compare, class _BirdirectionalIterator> 3726227825Stheravenvoid 3727227825Stheraven__insertion_sort_move(_BirdirectionalIterator __first1, _BirdirectionalIterator __last1, 3728227825Stheraven typename iterator_traits<_BirdirectionalIterator>::value_type* __first2, _Compare __comp) 3729227825Stheraven{ 3730227825Stheraven typedef typename iterator_traits<_BirdirectionalIterator>::value_type value_type; 3731227825Stheraven if (__first1 != __last1) 3732227825Stheraven { 3733227825Stheraven __destruct_n __d(0); 3734227825Stheraven unique_ptr<value_type, __destruct_n&> __h(__first2, __d); 3735227825Stheraven value_type* __last2 = __first2; 3736227825Stheraven ::new(__last2) value_type(_VSTD::move(*__first1)); 3737227825Stheraven __d.__incr((value_type*)0); 3738227825Stheraven for (++__last2; ++__first1 != __last1; ++__last2) 3739227825Stheraven { 3740227825Stheraven value_type* __j2 = __last2; 3741227825Stheraven value_type* __i2 = __j2; 3742227825Stheraven if (__comp(*__first1, *--__i2)) 3743227825Stheraven { 3744227825Stheraven ::new(__j2) value_type(_VSTD::move(*__i2)); 3745227825Stheraven __d.__incr((value_type*)0); 3746227825Stheraven for (--__j2; __i2 != __first2 && __comp(*__first1, *--__i2); --__j2) 3747227825Stheraven *__j2 = _VSTD::move(*__i2); 3748227825Stheraven *__j2 = _VSTD::move(*__first1); 3749227825Stheraven } 3750227825Stheraven else 3751227825Stheraven { 3752227825Stheraven ::new(__j2) value_type(_VSTD::move(*__first1)); 3753227825Stheraven __d.__incr((value_type*)0); 3754227825Stheraven } 3755227825Stheraven } 3756227825Stheraven __h.release(); 3757227825Stheraven } 3758227825Stheraven} 3759227825Stheraven 3760227825Stheraventemplate <class _Compare, class _RandomAccessIterator> 3761227825Stheravenvoid 3762227825Stheraven__sort(_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp) 3763227825Stheraven{ 3764227825Stheraven // _Compare is known to be a reference type 3765227825Stheraven typedef typename iterator_traits<_RandomAccessIterator>::difference_type difference_type; 3766227825Stheraven typedef typename iterator_traits<_RandomAccessIterator>::value_type value_type; 3767227825Stheraven const difference_type __limit = is_trivially_copy_constructible<value_type>::value && 3768227825Stheraven is_trivially_copy_assignable<value_type>::value ? 30 : 6; 3769227825Stheraven while (true) 3770227825Stheraven { 3771227825Stheraven __restart: 3772227825Stheraven difference_type __len = __last - __first; 3773227825Stheraven switch (__len) 3774227825Stheraven { 3775227825Stheraven case 0: 3776227825Stheraven case 1: 3777227825Stheraven return; 3778227825Stheraven case 2: 3779227825Stheraven if (__comp(*--__last, *__first)) 3780227825Stheraven swap(*__first, *__last); 3781227825Stheraven return; 3782227825Stheraven case 3: 3783227825Stheraven _VSTD::__sort3<_Compare>(__first, __first+1, --__last, __comp); 3784227825Stheraven return; 3785227825Stheraven case 4: 3786227825Stheraven _VSTD::__sort4<_Compare>(__first, __first+1, __first+2, --__last, __comp); 3787227825Stheraven return; 3788227825Stheraven case 5: 3789227825Stheraven _VSTD::__sort5<_Compare>(__first, __first+1, __first+2, __first+3, --__last, __comp); 3790227825Stheraven return; 3791227825Stheraven } 3792227825Stheraven if (__len <= __limit) 3793227825Stheraven { 3794227825Stheraven _VSTD::__insertion_sort_3<_Compare>(__first, __last, __comp); 3795227825Stheraven return; 3796227825Stheraven } 3797227825Stheraven // __len > 5 3798227825Stheraven _RandomAccessIterator __m = __first; 3799227825Stheraven _RandomAccessIterator __lm1 = __last; 3800227825Stheraven --__lm1; 3801227825Stheraven unsigned __n_swaps; 3802227825Stheraven { 3803227825Stheraven difference_type __delta; 3804227825Stheraven if (__len >= 1000) 3805227825Stheraven { 3806227825Stheraven __delta = __len/2; 3807227825Stheraven __m += __delta; 3808227825Stheraven __delta /= 2; 3809227825Stheraven __n_swaps = _VSTD::__sort5<_Compare>(__first, __first + __delta, __m, __m+__delta, __lm1, __comp); 3810227825Stheraven } 3811227825Stheraven else 3812227825Stheraven { 3813227825Stheraven __delta = __len/2; 3814227825Stheraven __m += __delta; 3815227825Stheraven __n_swaps = _VSTD::__sort3<_Compare>(__first, __m, __lm1, __comp); 3816227825Stheraven } 3817227825Stheraven } 3818227825Stheraven // *__m is median 3819227825Stheraven // partition [__first, __m) < *__m and *__m <= [__m, __last) 3820227825Stheraven // (this inhibits tossing elements equivalent to __m around unnecessarily) 3821227825Stheraven _RandomAccessIterator __i = __first; 3822227825Stheraven _RandomAccessIterator __j = __lm1; 3823227825Stheraven // j points beyond range to be tested, *__m is known to be <= *__lm1 3824227825Stheraven // The search going up is known to be guarded but the search coming down isn't. 3825227825Stheraven // Prime the downward search with a guard. 3826227825Stheraven if (!__comp(*__i, *__m)) // if *__first == *__m 3827227825Stheraven { 3828227825Stheraven // *__first == *__m, *__first doesn't go in first part 3829227825Stheraven // manually guard downward moving __j against __i 3830227825Stheraven while (true) 3831227825Stheraven { 3832227825Stheraven if (__i == --__j) 3833227825Stheraven { 3834227825Stheraven // *__first == *__m, *__m <= all other elements 3835227825Stheraven // Parition instead into [__first, __i) == *__first and *__first < [__i, __last) 3836227825Stheraven ++__i; // __first + 1 3837227825Stheraven __j = __last; 3838227825Stheraven if (!__comp(*__first, *--__j)) // we need a guard if *__first == *(__last-1) 3839227825Stheraven { 3840227825Stheraven while (true) 3841227825Stheraven { 3842227825Stheraven if (__i == __j) 3843227825Stheraven return; // [__first, __last) all equivalent elements 3844227825Stheraven if (__comp(*__first, *__i)) 3845227825Stheraven { 3846227825Stheraven swap(*__i, *__j); 3847227825Stheraven ++__n_swaps; 3848227825Stheraven ++__i; 3849227825Stheraven break; 3850227825Stheraven } 3851227825Stheraven ++__i; 3852227825Stheraven } 3853227825Stheraven } 3854227825Stheraven // [__first, __i) == *__first and *__first < [__j, __last) and __j == __last - 1 3855227825Stheraven if (__i == __j) 3856227825Stheraven return; 3857227825Stheraven while (true) 3858227825Stheraven { 3859227825Stheraven while (!__comp(*__first, *__i)) 3860227825Stheraven ++__i; 3861227825Stheraven while (__comp(*__first, *--__j)) 3862227825Stheraven ; 3863227825Stheraven if (__i >= __j) 3864227825Stheraven break; 3865227825Stheraven swap(*__i, *__j); 3866227825Stheraven ++__n_swaps; 3867227825Stheraven ++__i; 3868227825Stheraven } 3869227825Stheraven // [__first, __i) == *__first and *__first < [__i, __last) 3870227825Stheraven // The first part is sorted, sort the secod part 3871227825Stheraven // _VSTD::__sort<_Compare>(__i, __last, __comp); 3872227825Stheraven __first = __i; 3873227825Stheraven goto __restart; 3874227825Stheraven } 3875227825Stheraven if (__comp(*__j, *__m)) 3876227825Stheraven { 3877227825Stheraven swap(*__i, *__j); 3878227825Stheraven ++__n_swaps; 3879227825Stheraven break; // found guard for downward moving __j, now use unguarded partition 3880227825Stheraven } 3881227825Stheraven } 3882227825Stheraven } 3883227825Stheraven // It is known that *__i < *__m 3884227825Stheraven ++__i; 3885227825Stheraven // j points beyond range to be tested, *__m is known to be <= *__lm1 3886227825Stheraven // if not yet partitioned... 3887227825Stheraven if (__i < __j) 3888227825Stheraven { 3889227825Stheraven // known that *(__i - 1) < *__m 3890227825Stheraven // known that __i <= __m 3891227825Stheraven while (true) 3892227825Stheraven { 3893227825Stheraven // __m still guards upward moving __i 3894227825Stheraven while (__comp(*__i, *__m)) 3895227825Stheraven ++__i; 3896227825Stheraven // It is now known that a guard exists for downward moving __j 3897227825Stheraven while (!__comp(*--__j, *__m)) 3898227825Stheraven ; 3899227825Stheraven if (__i > __j) 3900227825Stheraven break; 3901227825Stheraven swap(*__i, *__j); 3902227825Stheraven ++__n_swaps; 3903227825Stheraven // It is known that __m != __j 3904227825Stheraven // If __m just moved, follow it 3905227825Stheraven if (__m == __i) 3906227825Stheraven __m = __j; 3907227825Stheraven ++__i; 3908227825Stheraven } 3909227825Stheraven } 3910227825Stheraven // [__first, __i) < *__m and *__m <= [__i, __last) 3911227825Stheraven if (__i != __m && __comp(*__m, *__i)) 3912227825Stheraven { 3913227825Stheraven swap(*__i, *__m); 3914227825Stheraven ++__n_swaps; 3915227825Stheraven } 3916227825Stheraven // [__first, __i) < *__i and *__i <= [__i+1, __last) 3917227825Stheraven // If we were given a perfect partition, see if insertion sort is quick... 3918227825Stheraven if (__n_swaps == 0) 3919227825Stheraven { 3920227825Stheraven bool __fs = _VSTD::__insertion_sort_incomplete<_Compare>(__first, __i, __comp); 3921227825Stheraven if (_VSTD::__insertion_sort_incomplete<_Compare>(__i+1, __last, __comp)) 3922227825Stheraven { 3923227825Stheraven if (__fs) 3924227825Stheraven return; 3925227825Stheraven __last = __i; 3926227825Stheraven continue; 3927227825Stheraven } 3928227825Stheraven else 3929227825Stheraven { 3930227825Stheraven if (__fs) 3931227825Stheraven { 3932227825Stheraven __first = ++__i; 3933227825Stheraven continue; 3934227825Stheraven } 3935227825Stheraven } 3936227825Stheraven } 3937227825Stheraven // sort smaller range with recursive call and larger with tail recursion elimination 3938227825Stheraven if (__i - __first < __last - __i) 3939227825Stheraven { 3940227825Stheraven _VSTD::__sort<_Compare>(__first, __i, __comp); 3941227825Stheraven // _VSTD::__sort<_Compare>(__i+1, __last, __comp); 3942227825Stheraven __first = ++__i; 3943227825Stheraven } 3944227825Stheraven else 3945227825Stheraven { 3946227825Stheraven _VSTD::__sort<_Compare>(__i+1, __last, __comp); 3947227825Stheraven // _VSTD::__sort<_Compare>(__first, __i, __comp); 3948227825Stheraven __last = __i; 3949227825Stheraven } 3950227825Stheraven } 3951227825Stheraven} 3952227825Stheraven 3953227825Stheraven// This forwarder keeps the top call and the recursive calls using the same instantiation, forcing a reference _Compare 3954227825Stheraventemplate <class _RandomAccessIterator, class _Compare> 3955227825Stheraveninline _LIBCPP_INLINE_VISIBILITY 3956227825Stheravenvoid 3957227825Stheravensort(_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp) 3958227825Stheraven{ 3959262801Sdim#ifdef _LIBCPP_DEBUG 3960227825Stheraven typedef typename add_lvalue_reference<__debug_less<_Compare> >::type _Comp_ref; 3961227825Stheraven __debug_less<_Compare> __c(__comp); 3962227825Stheraven __sort<_Comp_ref>(__first, __last, __c); 3963262801Sdim#else // _LIBCPP_DEBUG 3964227825Stheraven typedef typename add_lvalue_reference<_Compare>::type _Comp_ref; 3965227825Stheraven __sort<_Comp_ref>(__first, __last, __comp); 3966262801Sdim#endif // _LIBCPP_DEBUG 3967227825Stheraven} 3968227825Stheraven 3969227825Stheraventemplate <class _RandomAccessIterator> 3970227825Stheraveninline _LIBCPP_INLINE_VISIBILITY 3971227825Stheravenvoid 3972227825Stheravensort(_RandomAccessIterator __first, _RandomAccessIterator __last) 3973227825Stheraven{ 3974227825Stheraven _VSTD::sort(__first, __last, __less<typename iterator_traits<_RandomAccessIterator>::value_type>()); 3975227825Stheraven} 3976227825Stheraven 3977227825Stheraventemplate <class _Tp> 3978227825Stheraveninline _LIBCPP_INLINE_VISIBILITY 3979227825Stheravenvoid 3980227825Stheravensort(_Tp** __first, _Tp** __last) 3981227825Stheraven{ 3982227825Stheraven _VSTD::sort((size_t*)__first, (size_t*)__last, __less<size_t>()); 3983227825Stheraven} 3984227825Stheraven 3985227825Stheraventemplate <class _Tp> 3986227825Stheraveninline _LIBCPP_INLINE_VISIBILITY 3987227825Stheravenvoid 3988227825Stheravensort(__wrap_iter<_Tp*> __first, __wrap_iter<_Tp*> __last) 3989227825Stheraven{ 3990227825Stheraven _VSTD::sort(__first.base(), __last.base()); 3991227825Stheraven} 3992227825Stheraven 3993227825Stheraventemplate <class _Tp, class _Compare> 3994227825Stheraveninline _LIBCPP_INLINE_VISIBILITY 3995227825Stheravenvoid 3996227825Stheravensort(__wrap_iter<_Tp*> __first, __wrap_iter<_Tp*> __last, _Compare __comp) 3997227825Stheraven{ 3998227825Stheraven typedef typename add_lvalue_reference<_Compare>::type _Comp_ref; 3999227825Stheraven _VSTD::sort<_Tp*, _Comp_ref>(__first.base(), __last.base(), __comp); 4000227825Stheraven} 4001227825Stheraven 4002262801Sdim#ifdef _LIBCPP_MSVC 4003227825Stheraven#pragma warning( push ) 4004227825Stheraven#pragma warning( disable: 4231) 4005262801Sdim#endif // _LIBCPP_MSVC 4006262801Sdim_LIBCPP_EXTERN_TEMPLATE(_LIBCPP_FUNC_VIS void __sort<__less<char>&, char*>(char*, char*, __less<char>&)) 4007262801Sdim_LIBCPP_EXTERN_TEMPLATE(_LIBCPP_FUNC_VIS void __sort<__less<wchar_t>&, wchar_t*>(wchar_t*, wchar_t*, __less<wchar_t>&)) 4008262801Sdim_LIBCPP_EXTERN_TEMPLATE(_LIBCPP_FUNC_VIS void __sort<__less<signed char>&, signed char*>(signed char*, signed char*, __less<signed char>&)) 4009262801Sdim_LIBCPP_EXTERN_TEMPLATE(_LIBCPP_FUNC_VIS void __sort<__less<unsigned char>&, unsigned char*>(unsigned char*, unsigned char*, __less<unsigned char>&)) 4010262801Sdim_LIBCPP_EXTERN_TEMPLATE(_LIBCPP_FUNC_VIS void __sort<__less<short>&, short*>(short*, short*, __less<short>&)) 4011262801Sdim_LIBCPP_EXTERN_TEMPLATE(_LIBCPP_FUNC_VIS void __sort<__less<unsigned short>&, unsigned short*>(unsigned short*, unsigned short*, __less<unsigned short>&)) 4012262801Sdim_LIBCPP_EXTERN_TEMPLATE(_LIBCPP_FUNC_VIS void __sort<__less<int>&, int*>(int*, int*, __less<int>&)) 4013262801Sdim_LIBCPP_EXTERN_TEMPLATE(_LIBCPP_FUNC_VIS void __sort<__less<unsigned>&, unsigned*>(unsigned*, unsigned*, __less<unsigned>&)) 4014262801Sdim_LIBCPP_EXTERN_TEMPLATE(_LIBCPP_FUNC_VIS void __sort<__less<long>&, long*>(long*, long*, __less<long>&)) 4015262801Sdim_LIBCPP_EXTERN_TEMPLATE(_LIBCPP_FUNC_VIS void __sort<__less<unsigned long>&, unsigned long*>(unsigned long*, unsigned long*, __less<unsigned long>&)) 4016262801Sdim_LIBCPP_EXTERN_TEMPLATE(_LIBCPP_FUNC_VIS void __sort<__less<long long>&, long long*>(long long*, long long*, __less<long long>&)) 4017262801Sdim_LIBCPP_EXTERN_TEMPLATE(_LIBCPP_FUNC_VIS void __sort<__less<unsigned long long>&, unsigned long long*>(unsigned long long*, unsigned long long*, __less<unsigned long long>&)) 4018262801Sdim_LIBCPP_EXTERN_TEMPLATE(_LIBCPP_FUNC_VIS void __sort<__less<float>&, float*>(float*, float*, __less<float>&)) 4019262801Sdim_LIBCPP_EXTERN_TEMPLATE(_LIBCPP_FUNC_VIS void __sort<__less<double>&, double*>(double*, double*, __less<double>&)) 4020262801Sdim_LIBCPP_EXTERN_TEMPLATE(_LIBCPP_FUNC_VIS void __sort<__less<long double>&, long double*>(long double*, long double*, __less<long double>&)) 4021227825Stheraven 4022262801Sdim_LIBCPP_EXTERN_TEMPLATE(_LIBCPP_FUNC_VIS bool __insertion_sort_incomplete<__less<char>&, char*>(char*, char*, __less<char>&)) 4023262801Sdim_LIBCPP_EXTERN_TEMPLATE(_LIBCPP_FUNC_VIS bool __insertion_sort_incomplete<__less<wchar_t>&, wchar_t*>(wchar_t*, wchar_t*, __less<wchar_t>&)) 4024262801Sdim_LIBCPP_EXTERN_TEMPLATE(_LIBCPP_FUNC_VIS bool __insertion_sort_incomplete<__less<signed char>&, signed char*>(signed char*, signed char*, __less<signed char>&)) 4025262801Sdim_LIBCPP_EXTERN_TEMPLATE(_LIBCPP_FUNC_VIS bool __insertion_sort_incomplete<__less<unsigned char>&, unsigned char*>(unsigned char*, unsigned char*, __less<unsigned char>&)) 4026262801Sdim_LIBCPP_EXTERN_TEMPLATE(_LIBCPP_FUNC_VIS bool __insertion_sort_incomplete<__less<short>&, short*>(short*, short*, __less<short>&)) 4027262801Sdim_LIBCPP_EXTERN_TEMPLATE(_LIBCPP_FUNC_VIS bool __insertion_sort_incomplete<__less<unsigned short>&, unsigned short*>(unsigned short*, unsigned short*, __less<unsigned short>&)) 4028262801Sdim_LIBCPP_EXTERN_TEMPLATE(_LIBCPP_FUNC_VIS bool __insertion_sort_incomplete<__less<int>&, int*>(int*, int*, __less<int>&)) 4029262801Sdim_LIBCPP_EXTERN_TEMPLATE(_LIBCPP_FUNC_VIS bool __insertion_sort_incomplete<__less<unsigned>&, unsigned*>(unsigned*, unsigned*, __less<unsigned>&)) 4030262801Sdim_LIBCPP_EXTERN_TEMPLATE(_LIBCPP_FUNC_VIS bool __insertion_sort_incomplete<__less<long>&, long*>(long*, long*, __less<long>&)) 4031262801Sdim_LIBCPP_EXTERN_TEMPLATE(_LIBCPP_FUNC_VIS bool __insertion_sort_incomplete<__less<unsigned long>&, unsigned long*>(unsigned long*, unsigned long*, __less<unsigned long>&)) 4032262801Sdim_LIBCPP_EXTERN_TEMPLATE(_LIBCPP_FUNC_VIS bool __insertion_sort_incomplete<__less<long long>&, long long*>(long long*, long long*, __less<long long>&)) 4033262801Sdim_LIBCPP_EXTERN_TEMPLATE(_LIBCPP_FUNC_VIS bool __insertion_sort_incomplete<__less<unsigned long long>&, unsigned long long*>(unsigned long long*, unsigned long long*, __less<unsigned long long>&)) 4034262801Sdim_LIBCPP_EXTERN_TEMPLATE(_LIBCPP_FUNC_VIS bool __insertion_sort_incomplete<__less<float>&, float*>(float*, float*, __less<float>&)) 4035262801Sdim_LIBCPP_EXTERN_TEMPLATE(_LIBCPP_FUNC_VIS bool __insertion_sort_incomplete<__less<double>&, double*>(double*, double*, __less<double>&)) 4036262801Sdim_LIBCPP_EXTERN_TEMPLATE(_LIBCPP_FUNC_VIS bool __insertion_sort_incomplete<__less<long double>&, long double*>(long double*, long double*, __less<long double>&)) 4037227825Stheraven 4038262801Sdim_LIBCPP_EXTERN_TEMPLATE(_LIBCPP_FUNC_VIS unsigned __sort5<__less<long double>&, long double*>(long double*, long double*, long double*, long double*, long double*, __less<long double>&)) 4039262801Sdim#ifdef _LIBCPP_MSVC 4040227825Stheraven#pragma warning( pop ) 4041262801Sdim#endif // _LIBCPP_MSVC 4042227825Stheraven 4043227825Stheraven// lower_bound 4044227825Stheraven 4045227825Stheraventemplate <class _Compare, class _ForwardIterator, class _Tp> 4046227825Stheraven_ForwardIterator 4047227825Stheraven__lower_bound(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __value_, _Compare __comp) 4048227825Stheraven{ 4049227825Stheraven typedef typename iterator_traits<_ForwardIterator>::difference_type difference_type; 4050227825Stheraven difference_type __len = _VSTD::distance(__first, __last); 4051227825Stheraven while (__len != 0) 4052227825Stheraven { 4053227825Stheraven difference_type __l2 = __len / 2; 4054227825Stheraven _ForwardIterator __m = __first; 4055227825Stheraven _VSTD::advance(__m, __l2); 4056227825Stheraven if (__comp(*__m, __value_)) 4057227825Stheraven { 4058227825Stheraven __first = ++__m; 4059227825Stheraven __len -= __l2 + 1; 4060227825Stheraven } 4061227825Stheraven else 4062227825Stheraven __len = __l2; 4063227825Stheraven } 4064227825Stheraven return __first; 4065227825Stheraven} 4066227825Stheraven 4067227825Stheraventemplate <class _ForwardIterator, class _Tp, class _Compare> 4068227825Stheraveninline _LIBCPP_INLINE_VISIBILITY 4069227825Stheraven_ForwardIterator 4070227825Stheravenlower_bound(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __value_, _Compare __comp) 4071227825Stheraven{ 4072262801Sdim#ifdef _LIBCPP_DEBUG 4073227825Stheraven typedef typename add_lvalue_reference<__debug_less<_Compare> >::type _Comp_ref; 4074227825Stheraven __debug_less<_Compare> __c(__comp); 4075227825Stheraven return __lower_bound<_Comp_ref>(__first, __last, __value_, __c); 4076262801Sdim#else // _LIBCPP_DEBUG 4077227825Stheraven typedef typename add_lvalue_reference<_Compare>::type _Comp_ref; 4078227825Stheraven return __lower_bound<_Comp_ref>(__first, __last, __value_, __comp); 4079262801Sdim#endif // _LIBCPP_DEBUG 4080227825Stheraven} 4081227825Stheraven 4082227825Stheraventemplate <class _ForwardIterator, class _Tp> 4083227825Stheraveninline _LIBCPP_INLINE_VISIBILITY 4084227825Stheraven_ForwardIterator 4085227825Stheravenlower_bound(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __value_) 4086227825Stheraven{ 4087227825Stheraven return _VSTD::lower_bound(__first, __last, __value_, 4088227825Stheraven __less<typename iterator_traits<_ForwardIterator>::value_type, _Tp>()); 4089227825Stheraven} 4090227825Stheraven 4091227825Stheraven// upper_bound 4092227825Stheraven 4093227825Stheraventemplate <class _Compare, class _ForwardIterator, class _Tp> 4094227825Stheraven_ForwardIterator 4095227825Stheraven__upper_bound(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __value_, _Compare __comp) 4096227825Stheraven{ 4097227825Stheraven typedef typename iterator_traits<_ForwardIterator>::difference_type difference_type; 4098227825Stheraven difference_type __len = _VSTD::distance(__first, __last); 4099227825Stheraven while (__len != 0) 4100227825Stheraven { 4101227825Stheraven difference_type __l2 = __len / 2; 4102227825Stheraven _ForwardIterator __m = __first; 4103227825Stheraven _VSTD::advance(__m, __l2); 4104227825Stheraven if (__comp(__value_, *__m)) 4105227825Stheraven __len = __l2; 4106227825Stheraven else 4107227825Stheraven { 4108227825Stheraven __first = ++__m; 4109227825Stheraven __len -= __l2 + 1; 4110227825Stheraven } 4111227825Stheraven } 4112227825Stheraven return __first; 4113227825Stheraven} 4114227825Stheraven 4115227825Stheraventemplate <class _ForwardIterator, class _Tp, class _Compare> 4116227825Stheraveninline _LIBCPP_INLINE_VISIBILITY 4117227825Stheraven_ForwardIterator 4118227825Stheravenupper_bound(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __value_, _Compare __comp) 4119227825Stheraven{ 4120262801Sdim#ifdef _LIBCPP_DEBUG 4121227825Stheraven typedef typename add_lvalue_reference<__debug_less<_Compare> >::type _Comp_ref; 4122227825Stheraven __debug_less<_Compare> __c(__comp); 4123227825Stheraven return __upper_bound<_Comp_ref>(__first, __last, __value_, __c); 4124262801Sdim#else // _LIBCPP_DEBUG 4125227825Stheraven typedef typename add_lvalue_reference<_Compare>::type _Comp_ref; 4126227825Stheraven return __upper_bound<_Comp_ref>(__first, __last, __value_, __comp); 4127262801Sdim#endif // _LIBCPP_DEBUG 4128227825Stheraven} 4129227825Stheraven 4130227825Stheraventemplate <class _ForwardIterator, class _Tp> 4131227825Stheraveninline _LIBCPP_INLINE_VISIBILITY 4132227825Stheraven_ForwardIterator 4133227825Stheravenupper_bound(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __value_) 4134227825Stheraven{ 4135227825Stheraven return _VSTD::upper_bound(__first, __last, __value_, 4136227825Stheraven __less<_Tp, typename iterator_traits<_ForwardIterator>::value_type>()); 4137227825Stheraven} 4138227825Stheraven 4139227825Stheraven// equal_range 4140227825Stheraven 4141227825Stheraventemplate <class _Compare, class _ForwardIterator, class _Tp> 4142227825Stheravenpair<_ForwardIterator, _ForwardIterator> 4143227825Stheraven__equal_range(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __value_, _Compare __comp) 4144227825Stheraven{ 4145227825Stheraven typedef typename iterator_traits<_ForwardIterator>::difference_type difference_type; 4146227825Stheraven difference_type __len = _VSTD::distance(__first, __last); 4147227825Stheraven while (__len != 0) 4148227825Stheraven { 4149227825Stheraven difference_type __l2 = __len / 2; 4150227825Stheraven _ForwardIterator __m = __first; 4151227825Stheraven _VSTD::advance(__m, __l2); 4152227825Stheraven if (__comp(*__m, __value_)) 4153227825Stheraven { 4154227825Stheraven __first = ++__m; 4155227825Stheraven __len -= __l2 + 1; 4156227825Stheraven } 4157227825Stheraven else if (__comp(__value_, *__m)) 4158227825Stheraven { 4159227825Stheraven __last = __m; 4160227825Stheraven __len = __l2; 4161227825Stheraven } 4162227825Stheraven else 4163227825Stheraven { 4164227825Stheraven _ForwardIterator __mp1 = __m; 4165227825Stheraven return pair<_ForwardIterator, _ForwardIterator> 4166227825Stheraven ( 4167227825Stheraven __lower_bound<_Compare>(__first, __m, __value_, __comp), 4168227825Stheraven __upper_bound<_Compare>(++__mp1, __last, __value_, __comp) 4169227825Stheraven ); 4170227825Stheraven } 4171227825Stheraven } 4172227825Stheraven return pair<_ForwardIterator, _ForwardIterator>(__first, __first); 4173227825Stheraven} 4174227825Stheraven 4175227825Stheraventemplate <class _ForwardIterator, class _Tp, class _Compare> 4176227825Stheraveninline _LIBCPP_INLINE_VISIBILITY 4177227825Stheravenpair<_ForwardIterator, _ForwardIterator> 4178227825Stheravenequal_range(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __value_, _Compare __comp) 4179227825Stheraven{ 4180262801Sdim#ifdef _LIBCPP_DEBUG 4181227825Stheraven typedef typename add_lvalue_reference<__debug_less<_Compare> >::type _Comp_ref; 4182227825Stheraven __debug_less<_Compare> __c(__comp); 4183227825Stheraven return __equal_range<_Comp_ref>(__first, __last, __value_, __c); 4184262801Sdim#else // _LIBCPP_DEBUG 4185227825Stheraven typedef typename add_lvalue_reference<_Compare>::type _Comp_ref; 4186227825Stheraven return __equal_range<_Comp_ref>(__first, __last, __value_, __comp); 4187262801Sdim#endif // _LIBCPP_DEBUG 4188227825Stheraven} 4189227825Stheraven 4190227825Stheraventemplate <class _ForwardIterator, class _Tp> 4191227825Stheraveninline _LIBCPP_INLINE_VISIBILITY 4192227825Stheravenpair<_ForwardIterator, _ForwardIterator> 4193227825Stheravenequal_range(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __value_) 4194227825Stheraven{ 4195227825Stheraven return _VSTD::equal_range(__first, __last, __value_, 4196227825Stheraven __less<typename iterator_traits<_ForwardIterator>::value_type, _Tp>()); 4197227825Stheraven} 4198227825Stheraven 4199227825Stheraven// binary_search 4200227825Stheraven 4201227825Stheraventemplate <class _Compare, class _ForwardIterator, class _Tp> 4202227825Stheraveninline _LIBCPP_INLINE_VISIBILITY 4203227825Stheravenbool 4204227825Stheraven__binary_search(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __value_, _Compare __comp) 4205227825Stheraven{ 4206227825Stheraven __first = __lower_bound<_Compare>(__first, __last, __value_, __comp); 4207227825Stheraven return __first != __last && !__comp(__value_, *__first); 4208227825Stheraven} 4209227825Stheraven 4210227825Stheraventemplate <class _ForwardIterator, class _Tp, class _Compare> 4211227825Stheraveninline _LIBCPP_INLINE_VISIBILITY 4212227825Stheravenbool 4213227825Stheravenbinary_search(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __value_, _Compare __comp) 4214227825Stheraven{ 4215262801Sdim#ifdef _LIBCPP_DEBUG 4216227825Stheraven typedef typename add_lvalue_reference<__debug_less<_Compare> >::type _Comp_ref; 4217227825Stheraven __debug_less<_Compare> __c(__comp); 4218227825Stheraven return __binary_search<_Comp_ref>(__first, __last, __value_, __c); 4219262801Sdim#else // _LIBCPP_DEBUG 4220227825Stheraven typedef typename add_lvalue_reference<_Compare>::type _Comp_ref; 4221227825Stheraven return __binary_search<_Comp_ref>(__first, __last, __value_, __comp); 4222262801Sdim#endif // _LIBCPP_DEBUG 4223227825Stheraven} 4224227825Stheraven 4225227825Stheraventemplate <class _ForwardIterator, class _Tp> 4226227825Stheraveninline _LIBCPP_INLINE_VISIBILITY 4227227825Stheravenbool 4228227825Stheravenbinary_search(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __value_) 4229227825Stheraven{ 4230227825Stheraven return _VSTD::binary_search(__first, __last, __value_, 4231227825Stheraven __less<typename iterator_traits<_ForwardIterator>::value_type, _Tp>()); 4232227825Stheraven} 4233227825Stheraven 4234227825Stheraven// merge 4235227825Stheraven 4236227825Stheraventemplate <class _Compare, class _InputIterator1, class _InputIterator2, class _OutputIterator> 4237227825Stheraven_OutputIterator 4238227825Stheraven__merge(_InputIterator1 __first1, _InputIterator1 __last1, 4239227825Stheraven _InputIterator2 __first2, _InputIterator2 __last2, _OutputIterator __result, _Compare __comp) 4240227825Stheraven{ 4241227825Stheraven for (; __first1 != __last1; ++__result) 4242227825Stheraven { 4243227825Stheraven if (__first2 == __last2) 4244227825Stheraven return _VSTD::copy(__first1, __last1, __result); 4245227825Stheraven if (__comp(*__first2, *__first1)) 4246227825Stheraven { 4247227825Stheraven *__result = *__first2; 4248227825Stheraven ++__first2; 4249227825Stheraven } 4250227825Stheraven else 4251227825Stheraven { 4252227825Stheraven *__result = *__first1; 4253227825Stheraven ++__first1; 4254227825Stheraven } 4255227825Stheraven } 4256227825Stheraven return _VSTD::copy(__first2, __last2, __result); 4257227825Stheraven} 4258227825Stheraven 4259227825Stheraventemplate <class _InputIterator1, class _InputIterator2, class _OutputIterator, class _Compare> 4260227825Stheraveninline _LIBCPP_INLINE_VISIBILITY 4261227825Stheraven_OutputIterator 4262227825Stheravenmerge(_InputIterator1 __first1, _InputIterator1 __last1, 4263227825Stheraven _InputIterator2 __first2, _InputIterator2 __last2, _OutputIterator __result, _Compare __comp) 4264227825Stheraven{ 4265262801Sdim#ifdef _LIBCPP_DEBUG 4266227825Stheraven typedef typename add_lvalue_reference<__debug_less<_Compare> >::type _Comp_ref; 4267227825Stheraven __debug_less<_Compare> __c(__comp); 4268227825Stheraven return _VSTD::__merge<_Comp_ref>(__first1, __last1, __first2, __last2, __result, __c); 4269262801Sdim#else // _LIBCPP_DEBUG 4270227825Stheraven typedef typename add_lvalue_reference<_Compare>::type _Comp_ref; 4271227825Stheraven return _VSTD::__merge<_Comp_ref>(__first1, __last1, __first2, __last2, __result, __comp); 4272262801Sdim#endif // _LIBCPP_DEBUG 4273227825Stheraven} 4274227825Stheraven 4275227825Stheraventemplate <class _InputIterator1, class _InputIterator2, class _OutputIterator> 4276227825Stheraveninline _LIBCPP_INLINE_VISIBILITY 4277227825Stheraven_OutputIterator 4278227825Stheravenmerge(_InputIterator1 __first1, _InputIterator1 __last1, 4279227825Stheraven _InputIterator2 __first2, _InputIterator2 __last2, _OutputIterator __result) 4280227825Stheraven{ 4281227825Stheraven typedef typename iterator_traits<_InputIterator1>::value_type __v1; 4282227825Stheraven typedef typename iterator_traits<_InputIterator2>::value_type __v2; 4283227825Stheraven return merge(__first1, __last1, __first2, __last2, __result, __less<__v1, __v2>()); 4284227825Stheraven} 4285227825Stheraven 4286227825Stheraven// inplace_merge 4287227825Stheraven 4288227825Stheraventemplate <class _Compare, class _BidirectionalIterator> 4289227825Stheravenvoid 4290227825Stheraven__buffered_inplace_merge(_BidirectionalIterator __first, _BidirectionalIterator __middle, _BidirectionalIterator __last, 4291227825Stheraven _Compare __comp, typename iterator_traits<_BidirectionalIterator>::difference_type __len1, 4292227825Stheraven typename iterator_traits<_BidirectionalIterator>::difference_type __len2, 4293227825Stheraven typename iterator_traits<_BidirectionalIterator>::value_type* __buff) 4294227825Stheraven{ 4295227825Stheraven typedef typename iterator_traits<_BidirectionalIterator>::value_type value_type; 4296227825Stheraven typedef typename iterator_traits<_BidirectionalIterator>::difference_type difference_type; 4297227825Stheraven typedef typename iterator_traits<_BidirectionalIterator>::pointer pointer; 4298227825Stheraven __destruct_n __d(0); 4299227825Stheraven unique_ptr<value_type, __destruct_n&> __h2(__buff, __d); 4300227825Stheraven if (__len1 <= __len2) 4301227825Stheraven { 4302227825Stheraven value_type* __p = __buff; 4303227825Stheraven for (_BidirectionalIterator __i = __first; __i != __middle; __d.__incr((value_type*)0), ++__i, ++__p) 4304227825Stheraven ::new(__p) value_type(_VSTD::move(*__i)); 4305227825Stheraven __merge<_Compare>(move_iterator<value_type*>(__buff), 4306227825Stheraven move_iterator<value_type*>(__p), 4307227825Stheraven move_iterator<_BidirectionalIterator>(__middle), 4308227825Stheraven move_iterator<_BidirectionalIterator>(__last), 4309227825Stheraven __first, __comp); 4310227825Stheraven } 4311227825Stheraven else 4312227825Stheraven { 4313227825Stheraven value_type* __p = __buff; 4314227825Stheraven for (_BidirectionalIterator __i = __middle; __i != __last; __d.__incr((value_type*)0), ++__i, ++__p) 4315227825Stheraven ::new(__p) value_type(_VSTD::move(*__i)); 4316227825Stheraven typedef reverse_iterator<_BidirectionalIterator> _RBi; 4317227825Stheraven typedef reverse_iterator<value_type*> _Rv; 4318227825Stheraven __merge(move_iterator<_RBi>(_RBi(__middle)), move_iterator<_RBi>(_RBi(__first)), 4319227825Stheraven move_iterator<_Rv>(_Rv(__p)), move_iterator<_Rv>(_Rv(__buff)), 4320227825Stheraven _RBi(__last), __negate<_Compare>(__comp)); 4321227825Stheraven } 4322227825Stheraven} 4323227825Stheraven 4324227825Stheraventemplate <class _Compare, class _BidirectionalIterator> 4325227825Stheravenvoid 4326227825Stheraven__inplace_merge(_BidirectionalIterator __first, _BidirectionalIterator __middle, _BidirectionalIterator __last, 4327227825Stheraven _Compare __comp, typename iterator_traits<_BidirectionalIterator>::difference_type __len1, 4328227825Stheraven typename iterator_traits<_BidirectionalIterator>::difference_type __len2, 4329227825Stheraven typename iterator_traits<_BidirectionalIterator>::value_type* __buff, ptrdiff_t __buff_size) 4330227825Stheraven{ 4331227825Stheraven typedef typename iterator_traits<_BidirectionalIterator>::value_type value_type; 4332227825Stheraven typedef typename iterator_traits<_BidirectionalIterator>::difference_type difference_type; 4333227825Stheraven while (true) 4334227825Stheraven { 4335227825Stheraven // if __middle == __last, we're done 4336227825Stheraven if (__len2 == 0) 4337227825Stheraven return; 4338227825Stheraven // shrink [__first, __middle) as much as possible (with no moves), returning if it shrinks to 0 4339227825Stheraven for (; true; ++__first, --__len1) 4340227825Stheraven { 4341227825Stheraven if (__len1 == 0) 4342227825Stheraven return; 4343227825Stheraven if (__comp(*__middle, *__first)) 4344227825Stheraven break; 4345227825Stheraven } 4346227825Stheraven if (__len1 <= __buff_size || __len2 <= __buff_size) 4347227825Stheraven { 4348227825Stheraven __buffered_inplace_merge<_Compare>(__first, __middle, __last, __comp, __len1, __len2, __buff); 4349227825Stheraven return; 4350227825Stheraven } 4351227825Stheraven // __first < __middle < __last 4352227825Stheraven // *__first > *__middle 4353227825Stheraven // partition [__first, __m1) [__m1, __middle) [__middle, __m2) [__m2, __last) such that 4354227825Stheraven // all elements in: 4355227825Stheraven // [__first, __m1) <= [__middle, __m2) 4356227825Stheraven // [__middle, __m2) < [__m1, __middle) 4357227825Stheraven // [__m1, __middle) <= [__m2, __last) 4358227825Stheraven // and __m1 or __m2 is in the middle of its range 4359227825Stheraven _BidirectionalIterator __m1; // "median" of [__first, __middle) 4360227825Stheraven _BidirectionalIterator __m2; // "median" of [__middle, __last) 4361227825Stheraven difference_type __len11; // distance(__first, __m1) 4362227825Stheraven difference_type __len21; // distance(__middle, __m2) 4363227825Stheraven // binary search smaller range 4364227825Stheraven if (__len1 < __len2) 4365227825Stheraven { // __len >= 1, __len2 >= 2 4366227825Stheraven __len21 = __len2 / 2; 4367227825Stheraven __m2 = __middle; 4368227825Stheraven _VSTD::advance(__m2, __len21); 4369227825Stheraven __m1 = __upper_bound<_Compare>(__first, __middle, *__m2, __comp); 4370227825Stheraven __len11 = _VSTD::distance(__first, __m1); 4371227825Stheraven } 4372227825Stheraven else 4373227825Stheraven { 4374227825Stheraven if (__len1 == 1) 4375227825Stheraven { // __len1 >= __len2 && __len2 > 0, therefore __len2 == 1 4376227825Stheraven // It is known *__first > *__middle 4377227825Stheraven swap(*__first, *__middle); 4378227825Stheraven return; 4379227825Stheraven } 4380227825Stheraven // __len1 >= 2, __len2 >= 1 4381227825Stheraven __len11 = __len1 / 2; 4382227825Stheraven __m1 = __first; 4383227825Stheraven _VSTD::advance(__m1, __len11); 4384227825Stheraven __m2 = __lower_bound<_Compare>(__middle, __last, *__m1, __comp); 4385227825Stheraven __len21 = _VSTD::distance(__middle, __m2); 4386227825Stheraven } 4387227825Stheraven difference_type __len12 = __len1 - __len11; // distance(__m1, __middle) 4388227825Stheraven difference_type __len22 = __len2 - __len21; // distance(__m2, __last) 4389227825Stheraven // [__first, __m1) [__m1, __middle) [__middle, __m2) [__m2, __last) 4390227825Stheraven // swap middle two partitions 4391227825Stheraven __middle = _VSTD::rotate(__m1, __middle, __m2); 4392227825Stheraven // __len12 and __len21 now have swapped meanings 4393227825Stheraven // merge smaller range with recurisve call and larger with tail recursion elimination 4394227825Stheraven if (__len11 + __len21 < __len12 + __len22) 4395227825Stheraven { 4396227825Stheraven __inplace_merge<_Compare>(__first, __m1, __middle, __comp, __len11, __len21, __buff, __buff_size); 4397227825Stheraven// __inplace_merge<_Compare>(__middle, __m2, __last, __comp, __len12, __len22, __buff, __buff_size); 4398227825Stheraven __first = __middle; 4399227825Stheraven __middle = __m2; 4400227825Stheraven __len1 = __len12; 4401227825Stheraven __len2 = __len22; 4402227825Stheraven } 4403227825Stheraven else 4404227825Stheraven { 4405227825Stheraven __inplace_merge<_Compare>(__middle, __m2, __last, __comp, __len12, __len22, __buff, __buff_size); 4406227825Stheraven// __inplace_merge<_Compare>(__first, __m1, __middle, __comp, __len11, __len21, __buff, __buff_size); 4407227825Stheraven __last = __middle; 4408227825Stheraven __middle = __m1; 4409227825Stheraven __len1 = __len11; 4410227825Stheraven __len2 = __len21; 4411227825Stheraven } 4412227825Stheraven } 4413227825Stheraven} 4414227825Stheraven 4415227825Stheraventemplate <class _Tp> 4416227825Stheravenstruct __inplace_merge_switch 4417227825Stheraven{ 4418227825Stheraven static const unsigned value = is_trivially_copy_assignable<_Tp>::value; 4419227825Stheraven}; 4420227825Stheraven 4421227825Stheraventemplate <class _BidirectionalIterator, class _Compare> 4422227825Stheraveninline _LIBCPP_INLINE_VISIBILITY 4423227825Stheravenvoid 4424227825Stheraveninplace_merge(_BidirectionalIterator __first, _BidirectionalIterator __middle, _BidirectionalIterator __last, 4425227825Stheraven _Compare __comp) 4426227825Stheraven{ 4427227825Stheraven typedef typename iterator_traits<_BidirectionalIterator>::value_type value_type; 4428227825Stheraven typedef typename iterator_traits<_BidirectionalIterator>::difference_type difference_type; 4429227825Stheraven difference_type __len1 = _VSTD::distance(__first, __middle); 4430227825Stheraven difference_type __len2 = _VSTD::distance(__middle, __last); 4431227825Stheraven difference_type __buf_size = _VSTD::min(__len1, __len2); 4432227825Stheraven pair<value_type*, ptrdiff_t> __buf(0, 0); 4433227825Stheraven unique_ptr<value_type, __return_temporary_buffer> __h; 4434227825Stheraven if (__inplace_merge_switch<value_type>::value && __buf_size > 8) 4435227825Stheraven { 4436227825Stheraven __buf = _VSTD::get_temporary_buffer<value_type>(__buf_size); 4437227825Stheraven __h.reset(__buf.first); 4438227825Stheraven } 4439262801Sdim#ifdef _LIBCPP_DEBUG 4440227825Stheraven typedef typename add_lvalue_reference<__debug_less<_Compare> >::type _Comp_ref; 4441227825Stheraven __debug_less<_Compare> __c(__comp); 4442227825Stheraven return _VSTD::__inplace_merge<_Comp_ref>(__first, __middle, __last, __c, __len1, __len2, 4443227825Stheraven __buf.first, __buf.second); 4444262801Sdim#else // _LIBCPP_DEBUG 4445227825Stheraven typedef typename add_lvalue_reference<_Compare>::type _Comp_ref; 4446227825Stheraven return _VSTD::__inplace_merge<_Comp_ref>(__first, __middle, __last, __comp, __len1, __len2, 4447227825Stheraven __buf.first, __buf.second); 4448262801Sdim#endif // _LIBCPP_DEBUG 4449227825Stheraven} 4450227825Stheraven 4451227825Stheraventemplate <class _BidirectionalIterator> 4452227825Stheraveninline _LIBCPP_INLINE_VISIBILITY 4453227825Stheravenvoid 4454227825Stheraveninplace_merge(_BidirectionalIterator __first, _BidirectionalIterator __middle, _BidirectionalIterator __last) 4455227825Stheraven{ 4456227825Stheraven _VSTD::inplace_merge(__first, __middle, __last, 4457227825Stheraven __less<typename iterator_traits<_BidirectionalIterator>::value_type>()); 4458227825Stheraven} 4459227825Stheraven 4460227825Stheraven// stable_sort 4461227825Stheraven 4462227825Stheraventemplate <class _Compare, class _InputIterator1, class _InputIterator2> 4463227825Stheravenvoid 4464227825Stheraven__merge_move_construct(_InputIterator1 __first1, _InputIterator1 __last1, 4465227825Stheraven _InputIterator2 __first2, _InputIterator2 __last2, 4466227825Stheraven typename iterator_traits<_InputIterator1>::value_type* __result, _Compare __comp) 4467227825Stheraven{ 4468227825Stheraven typedef typename iterator_traits<_InputIterator1>::value_type value_type; 4469227825Stheraven __destruct_n __d(0); 4470227825Stheraven unique_ptr<value_type, __destruct_n&> __h(__result, __d); 4471227825Stheraven for (; true; ++__result) 4472227825Stheraven { 4473227825Stheraven if (__first1 == __last1) 4474227825Stheraven { 4475227825Stheraven for (; __first2 != __last2; ++__first2, ++__result, __d.__incr((value_type*)0)) 4476227825Stheraven ::new (__result) value_type(_VSTD::move(*__first2)); 4477227825Stheraven __h.release(); 4478227825Stheraven return; 4479227825Stheraven } 4480227825Stheraven if (__first2 == __last2) 4481227825Stheraven { 4482227825Stheraven for (; __first1 != __last1; ++__first1, ++__result, __d.__incr((value_type*)0)) 4483227825Stheraven ::new (__result) value_type(_VSTD::move(*__first1)); 4484227825Stheraven __h.release(); 4485227825Stheraven return; 4486227825Stheraven } 4487227825Stheraven if (__comp(*__first2, *__first1)) 4488227825Stheraven { 4489227825Stheraven ::new (__result) value_type(_VSTD::move(*__first2)); 4490227825Stheraven __d.__incr((value_type*)0); 4491227825Stheraven ++__first2; 4492227825Stheraven } 4493227825Stheraven else 4494227825Stheraven { 4495227825Stheraven ::new (__result) value_type(_VSTD::move(*__first1)); 4496227825Stheraven __d.__incr((value_type*)0); 4497227825Stheraven ++__first1; 4498227825Stheraven } 4499227825Stheraven } 4500227825Stheraven} 4501227825Stheraven 4502227825Stheraventemplate <class _Compare, class _InputIterator1, class _InputIterator2, class _OutputIterator> 4503227825Stheravenvoid 4504227825Stheraven__merge_move_assign(_InputIterator1 __first1, _InputIterator1 __last1, 4505227825Stheraven _InputIterator2 __first2, _InputIterator2 __last2, 4506227825Stheraven _OutputIterator __result, _Compare __comp) 4507227825Stheraven{ 4508227825Stheraven for (; __first1 != __last1; ++__result) 4509227825Stheraven { 4510227825Stheraven if (__first2 == __last2) 4511227825Stheraven { 4512227825Stheraven for (; __first1 != __last1; ++__first1, ++__result) 4513227825Stheraven *__result = _VSTD::move(*__first1); 4514227825Stheraven return; 4515227825Stheraven } 4516227825Stheraven if (__comp(*__first2, *__first1)) 4517227825Stheraven { 4518227825Stheraven *__result = _VSTD::move(*__first2); 4519227825Stheraven ++__first2; 4520227825Stheraven } 4521227825Stheraven else 4522227825Stheraven { 4523227825Stheraven *__result = _VSTD::move(*__first1); 4524227825Stheraven ++__first1; 4525227825Stheraven } 4526227825Stheraven } 4527227825Stheraven for (; __first2 != __last2; ++__first2, ++__result) 4528227825Stheraven *__result = _VSTD::move(*__first2); 4529227825Stheraven} 4530227825Stheraven 4531227825Stheraventemplate <class _Compare, class _RandomAccessIterator> 4532227825Stheravenvoid 4533227825Stheraven__stable_sort(_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp, 4534227825Stheraven typename iterator_traits<_RandomAccessIterator>::difference_type __len, 4535227825Stheraven typename iterator_traits<_RandomAccessIterator>::value_type* __buff, ptrdiff_t __buff_size); 4536227825Stheraven 4537227825Stheraventemplate <class _Compare, class _RandomAccessIterator> 4538227825Stheravenvoid 4539227825Stheraven__stable_sort_move(_RandomAccessIterator __first1, _RandomAccessIterator __last1, _Compare __comp, 4540227825Stheraven typename iterator_traits<_RandomAccessIterator>::difference_type __len, 4541227825Stheraven typename iterator_traits<_RandomAccessIterator>::value_type* __first2) 4542227825Stheraven{ 4543227825Stheraven typedef typename iterator_traits<_RandomAccessIterator>::value_type value_type; 4544227825Stheraven switch (__len) 4545227825Stheraven { 4546227825Stheraven case 0: 4547227825Stheraven return; 4548227825Stheraven case 1: 4549227825Stheraven ::new(__first2) value_type(_VSTD::move(*__first1)); 4550227825Stheraven return; 4551227825Stheraven case 2: 4552227825Stheraven __destruct_n __d(0); 4553227825Stheraven unique_ptr<value_type, __destruct_n&> __h2(__first2, __d); 4554227825Stheraven if (__comp(*--__last1, *__first1)) 4555227825Stheraven { 4556227825Stheraven ::new(__first2) value_type(_VSTD::move(*__last1)); 4557227825Stheraven __d.__incr((value_type*)0); 4558227825Stheraven ++__first2; 4559227825Stheraven ::new(__first2) value_type(_VSTD::move(*__first1)); 4560227825Stheraven } 4561227825Stheraven else 4562227825Stheraven { 4563227825Stheraven ::new(__first2) value_type(_VSTD::move(*__first1)); 4564227825Stheraven __d.__incr((value_type*)0); 4565227825Stheraven ++__first2; 4566227825Stheraven ::new(__first2) value_type(_VSTD::move(*__last1)); 4567227825Stheraven } 4568227825Stheraven __h2.release(); 4569227825Stheraven return; 4570227825Stheraven } 4571227825Stheraven if (__len <= 8) 4572227825Stheraven { 4573227825Stheraven __insertion_sort_move<_Compare>(__first1, __last1, __first2, __comp); 4574227825Stheraven return; 4575227825Stheraven } 4576227825Stheraven typename iterator_traits<_RandomAccessIterator>::difference_type __l2 = __len / 2; 4577227825Stheraven _RandomAccessIterator __m = __first1 + __l2; 4578227825Stheraven __stable_sort<_Compare>(__first1, __m, __comp, __l2, __first2, __l2); 4579227825Stheraven __stable_sort<_Compare>(__m, __last1, __comp, __len - __l2, __first2 + __l2, __len - __l2); 4580227825Stheraven __merge_move_construct<_Compare>(__first1, __m, __m, __last1, __first2, __comp); 4581227825Stheraven} 4582227825Stheraven 4583227825Stheraventemplate <class _Tp> 4584227825Stheravenstruct __stable_sort_switch 4585227825Stheraven{ 4586227825Stheraven static const unsigned value = 128*is_trivially_copy_assignable<_Tp>::value; 4587227825Stheraven}; 4588227825Stheraven 4589227825Stheraventemplate <class _Compare, class _RandomAccessIterator> 4590227825Stheravenvoid 4591227825Stheraven__stable_sort(_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp, 4592227825Stheraven typename iterator_traits<_RandomAccessIterator>::difference_type __len, 4593227825Stheraven typename iterator_traits<_RandomAccessIterator>::value_type* __buff, ptrdiff_t __buff_size) 4594227825Stheraven{ 4595227825Stheraven typedef typename iterator_traits<_RandomAccessIterator>::value_type value_type; 4596227825Stheraven typedef typename iterator_traits<_RandomAccessIterator>::difference_type difference_type; 4597227825Stheraven switch (__len) 4598227825Stheraven { 4599227825Stheraven case 0: 4600227825Stheraven case 1: 4601227825Stheraven return; 4602227825Stheraven case 2: 4603227825Stheraven if (__comp(*--__last, *__first)) 4604227825Stheraven swap(*__first, *__last); 4605227825Stheraven return; 4606227825Stheraven } 4607227825Stheraven if (__len <= static_cast<difference_type>(__stable_sort_switch<value_type>::value)) 4608227825Stheraven { 4609227825Stheraven __insertion_sort<_Compare>(__first, __last, __comp); 4610227825Stheraven return; 4611227825Stheraven } 4612227825Stheraven typename iterator_traits<_RandomAccessIterator>::difference_type __l2 = __len / 2; 4613227825Stheraven _RandomAccessIterator __m = __first + __l2; 4614227825Stheraven if (__len <= __buff_size) 4615227825Stheraven { 4616227825Stheraven __destruct_n __d(0); 4617227825Stheraven unique_ptr<value_type, __destruct_n&> __h2(__buff, __d); 4618227825Stheraven __stable_sort_move<_Compare>(__first, __m, __comp, __l2, __buff); 4619227825Stheraven __d.__set(__l2, (value_type*)0); 4620227825Stheraven __stable_sort_move<_Compare>(__m, __last, __comp, __len - __l2, __buff + __l2); 4621227825Stheraven __d.__set(__len, (value_type*)0); 4622227825Stheraven __merge_move_assign<_Compare>(__buff, __buff + __l2, __buff + __l2, __buff + __len, __first, __comp); 4623227825Stheraven// __merge<_Compare>(move_iterator<value_type*>(__buff), 4624227825Stheraven// move_iterator<value_type*>(__buff + __l2), 4625227825Stheraven// move_iterator<_RandomAccessIterator>(__buff + __l2), 4626227825Stheraven// move_iterator<_RandomAccessIterator>(__buff + __len), 4627227825Stheraven// __first, __comp); 4628227825Stheraven return; 4629227825Stheraven } 4630227825Stheraven __stable_sort<_Compare>(__first, __m, __comp, __l2, __buff, __buff_size); 4631227825Stheraven __stable_sort<_Compare>(__m, __last, __comp, __len - __l2, __buff, __buff_size); 4632227825Stheraven __inplace_merge<_Compare>(__first, __m, __last, __comp, __l2, __len - __l2, __buff, __buff_size); 4633227825Stheraven} 4634227825Stheraven 4635227825Stheraventemplate <class _RandomAccessIterator, class _Compare> 4636227825Stheraveninline _LIBCPP_INLINE_VISIBILITY 4637227825Stheravenvoid 4638227825Stheravenstable_sort(_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp) 4639227825Stheraven{ 4640227825Stheraven typedef typename iterator_traits<_RandomAccessIterator>::value_type value_type; 4641227825Stheraven typedef typename iterator_traits<_RandomAccessIterator>::difference_type difference_type; 4642227825Stheraven difference_type __len = __last - __first; 4643227825Stheraven pair<value_type*, ptrdiff_t> __buf(0, 0); 4644227825Stheraven unique_ptr<value_type, __return_temporary_buffer> __h; 4645227825Stheraven if (__len > static_cast<difference_type>(__stable_sort_switch<value_type>::value)) 4646227825Stheraven { 4647227825Stheraven __buf = _VSTD::get_temporary_buffer<value_type>(__len); 4648227825Stheraven __h.reset(__buf.first); 4649227825Stheraven } 4650262801Sdim#ifdef _LIBCPP_DEBUG 4651227825Stheraven typedef typename add_lvalue_reference<__debug_less<_Compare> >::type _Comp_ref; 4652227825Stheraven __debug_less<_Compare> __c(__comp); 4653227825Stheraven __stable_sort<_Comp_ref>(__first, __last, __c, __len, __buf.first, __buf.second); 4654262801Sdim#else // _LIBCPP_DEBUG 4655227825Stheraven typedef typename add_lvalue_reference<_Compare>::type _Comp_ref; 4656227825Stheraven __stable_sort<_Comp_ref>(__first, __last, __comp, __len, __buf.first, __buf.second); 4657262801Sdim#endif // _LIBCPP_DEBUG 4658227825Stheraven} 4659227825Stheraven 4660227825Stheraventemplate <class _RandomAccessIterator> 4661227825Stheraveninline _LIBCPP_INLINE_VISIBILITY 4662227825Stheravenvoid 4663227825Stheravenstable_sort(_RandomAccessIterator __first, _RandomAccessIterator __last) 4664227825Stheraven{ 4665227825Stheraven _VSTD::stable_sort(__first, __last, __less<typename iterator_traits<_RandomAccessIterator>::value_type>()); 4666227825Stheraven} 4667227825Stheraven 4668227825Stheraven// is_heap_until 4669227825Stheraven 4670227825Stheraventemplate <class _RandomAccessIterator, class _Compare> 4671227825Stheraven_RandomAccessIterator 4672227825Stheravenis_heap_until(_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp) 4673227825Stheraven{ 4674227825Stheraven typedef typename _VSTD::iterator_traits<_RandomAccessIterator>::difference_type difference_type; 4675227825Stheraven difference_type __len = __last - __first; 4676227825Stheraven difference_type __p = 0; 4677227825Stheraven difference_type __c = 1; 4678227825Stheraven _RandomAccessIterator __pp = __first; 4679227825Stheraven while (__c < __len) 4680227825Stheraven { 4681227825Stheraven _RandomAccessIterator __cp = __first + __c; 4682227825Stheraven if (__comp(*__pp, *__cp)) 4683227825Stheraven return __cp; 4684227825Stheraven ++__c; 4685227825Stheraven ++__cp; 4686227825Stheraven if (__c == __len) 4687227825Stheraven return __last; 4688227825Stheraven if (__comp(*__pp, *__cp)) 4689227825Stheraven return __cp; 4690227825Stheraven ++__p; 4691227825Stheraven ++__pp; 4692227825Stheraven __c = 2 * __p + 1; 4693227825Stheraven } 4694227825Stheraven return __last; 4695227825Stheraven} 4696227825Stheraven 4697227825Stheraventemplate<class _RandomAccessIterator> 4698227825Stheraveninline _LIBCPP_INLINE_VISIBILITY 4699227825Stheraven_RandomAccessIterator 4700227825Stheravenis_heap_until(_RandomAccessIterator __first, _RandomAccessIterator __last) 4701227825Stheraven{ 4702227825Stheraven return _VSTD::is_heap_until(__first, __last, __less<typename iterator_traits<_RandomAccessIterator>::value_type>()); 4703227825Stheraven} 4704227825Stheraven 4705227825Stheraven// is_heap 4706227825Stheraven 4707227825Stheraventemplate <class _RandomAccessIterator, class _Compare> 4708227825Stheraveninline _LIBCPP_INLINE_VISIBILITY 4709227825Stheravenbool 4710227825Stheravenis_heap(_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp) 4711227825Stheraven{ 4712227825Stheraven return _VSTD::is_heap_until(__first, __last, __comp) == __last; 4713227825Stheraven} 4714227825Stheraven 4715227825Stheraventemplate<class _RandomAccessIterator> 4716227825Stheraveninline _LIBCPP_INLINE_VISIBILITY 4717227825Stheravenbool 4718227825Stheravenis_heap(_RandomAccessIterator __first, _RandomAccessIterator __last) 4719227825Stheraven{ 4720227825Stheraven return _VSTD::is_heap(__first, __last, __less<typename iterator_traits<_RandomAccessIterator>::value_type>()); 4721227825Stheraven} 4722227825Stheraven 4723227825Stheraven// push_heap 4724227825Stheraven 4725227825Stheraventemplate <class _Compare, class _RandomAccessIterator> 4726227825Stheravenvoid 4727227825Stheraven__push_heap_front(_RandomAccessIterator __first, _RandomAccessIterator, _Compare __comp, 4728227825Stheraven typename iterator_traits<_RandomAccessIterator>::difference_type __len) 4729227825Stheraven{ 4730227825Stheraven typedef typename iterator_traits<_RandomAccessIterator>::difference_type difference_type; 4731227825Stheraven typedef typename iterator_traits<_RandomAccessIterator>::value_type value_type; 4732227825Stheraven if (__len > 1) 4733227825Stheraven { 4734227825Stheraven difference_type __p = 0; 4735227825Stheraven _RandomAccessIterator __pp = __first; 4736227825Stheraven difference_type __c = 2; 4737227825Stheraven _RandomAccessIterator __cp = __first + __c; 4738227825Stheraven if (__c == __len || __comp(*__cp, *(__cp - 1))) 4739227825Stheraven { 4740227825Stheraven --__c; 4741227825Stheraven --__cp; 4742227825Stheraven } 4743227825Stheraven if (__comp(*__pp, *__cp)) 4744227825Stheraven { 4745227825Stheraven value_type __t(_VSTD::move(*__pp)); 4746227825Stheraven do 4747227825Stheraven { 4748227825Stheraven *__pp = _VSTD::move(*__cp); 4749227825Stheraven __pp = __cp; 4750227825Stheraven __p = __c; 4751227825Stheraven __c = (__p + 1) * 2; 4752227825Stheraven if (__c > __len) 4753227825Stheraven break; 4754227825Stheraven __cp = __first + __c; 4755227825Stheraven if (__c == __len || __comp(*__cp, *(__cp - 1))) 4756227825Stheraven { 4757227825Stheraven --__c; 4758227825Stheraven --__cp; 4759227825Stheraven } 4760227825Stheraven } while (__comp(__t, *__cp)); 4761227825Stheraven *__pp = _VSTD::move(__t); 4762227825Stheraven } 4763227825Stheraven } 4764227825Stheraven} 4765227825Stheraven 4766227825Stheraventemplate <class _Compare, class _RandomAccessIterator> 4767227825Stheravenvoid 4768227825Stheraven__push_heap_back(_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp, 4769227825Stheraven typename iterator_traits<_RandomAccessIterator>::difference_type __len) 4770227825Stheraven{ 4771227825Stheraven typedef typename iterator_traits<_RandomAccessIterator>::difference_type difference_type; 4772227825Stheraven typedef typename iterator_traits<_RandomAccessIterator>::value_type value_type; 4773227825Stheraven if (__len > 1) 4774227825Stheraven { 4775227825Stheraven __len = (__len - 2) / 2; 4776227825Stheraven _RandomAccessIterator __ptr = __first + __len; 4777227825Stheraven if (__comp(*__ptr, *--__last)) 4778227825Stheraven { 4779227825Stheraven value_type __t(_VSTD::move(*__last)); 4780227825Stheraven do 4781227825Stheraven { 4782227825Stheraven *__last = _VSTD::move(*__ptr); 4783227825Stheraven __last = __ptr; 4784227825Stheraven if (__len == 0) 4785227825Stheraven break; 4786227825Stheraven __len = (__len - 1) / 2; 4787227825Stheraven __ptr = __first + __len; 4788227825Stheraven } while (__comp(*__ptr, __t)); 4789227825Stheraven *__last = _VSTD::move(__t); 4790227825Stheraven } 4791227825Stheraven } 4792227825Stheraven} 4793227825Stheraven 4794227825Stheraventemplate <class _RandomAccessIterator, class _Compare> 4795227825Stheraveninline _LIBCPP_INLINE_VISIBILITY 4796227825Stheravenvoid 4797227825Stheravenpush_heap(_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp) 4798227825Stheraven{ 4799262801Sdim#ifdef _LIBCPP_DEBUG 4800227825Stheraven typedef typename add_lvalue_reference<__debug_less<_Compare> >::type _Comp_ref; 4801227825Stheraven __debug_less<_Compare> __c(__comp); 4802227825Stheraven __push_heap_back<_Comp_ref>(__first, __last, __c, __last - __first); 4803262801Sdim#else // _LIBCPP_DEBUG 4804227825Stheraven typedef typename add_lvalue_reference<_Compare>::type _Comp_ref; 4805227825Stheraven __push_heap_back<_Comp_ref>(__first, __last, __comp, __last - __first); 4806262801Sdim#endif // _LIBCPP_DEBUG 4807227825Stheraven} 4808227825Stheraven 4809227825Stheraventemplate <class _RandomAccessIterator> 4810227825Stheraveninline _LIBCPP_INLINE_VISIBILITY 4811227825Stheravenvoid 4812227825Stheravenpush_heap(_RandomAccessIterator __first, _RandomAccessIterator __last) 4813227825Stheraven{ 4814227825Stheraven _VSTD::push_heap(__first, __last, __less<typename iterator_traits<_RandomAccessIterator>::value_type>()); 4815227825Stheraven} 4816227825Stheraven 4817227825Stheraven// pop_heap 4818227825Stheraven 4819227825Stheraventemplate <class _Compare, class _RandomAccessIterator> 4820227825Stheraveninline _LIBCPP_INLINE_VISIBILITY 4821227825Stheravenvoid 4822227825Stheraven__pop_heap(_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp, 4823227825Stheraven typename iterator_traits<_RandomAccessIterator>::difference_type __len) 4824227825Stheraven{ 4825227825Stheraven if (__len > 1) 4826227825Stheraven { 4827227825Stheraven swap(*__first, *--__last); 4828227825Stheraven __push_heap_front<_Compare>(__first, __last, __comp, __len-1); 4829227825Stheraven } 4830227825Stheraven} 4831227825Stheraven 4832227825Stheraventemplate <class _RandomAccessIterator, class _Compare> 4833227825Stheraveninline _LIBCPP_INLINE_VISIBILITY 4834227825Stheravenvoid 4835227825Stheravenpop_heap(_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp) 4836227825Stheraven{ 4837262801Sdim#ifdef _LIBCPP_DEBUG 4838227825Stheraven typedef typename add_lvalue_reference<__debug_less<_Compare> >::type _Comp_ref; 4839227825Stheraven __debug_less<_Compare> __c(__comp); 4840227825Stheraven __pop_heap<_Comp_ref>(__first, __last, __c, __last - __first); 4841262801Sdim#else // _LIBCPP_DEBUG 4842227825Stheraven typedef typename add_lvalue_reference<_Compare>::type _Comp_ref; 4843227825Stheraven __pop_heap<_Comp_ref>(__first, __last, __comp, __last - __first); 4844262801Sdim#endif // _LIBCPP_DEBUG 4845227825Stheraven} 4846227825Stheraven 4847227825Stheraventemplate <class _RandomAccessIterator> 4848227825Stheraveninline _LIBCPP_INLINE_VISIBILITY 4849227825Stheravenvoid 4850227825Stheravenpop_heap(_RandomAccessIterator __first, _RandomAccessIterator __last) 4851227825Stheraven{ 4852227825Stheraven _VSTD::pop_heap(__first, __last, __less<typename iterator_traits<_RandomAccessIterator>::value_type>()); 4853227825Stheraven} 4854227825Stheraven 4855227825Stheraven// make_heap 4856227825Stheraven 4857227825Stheraventemplate <class _Compare, class _RandomAccessIterator> 4858227825Stheravenvoid 4859227825Stheraven__make_heap(_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp) 4860227825Stheraven{ 4861227825Stheraven typedef typename iterator_traits<_RandomAccessIterator>::difference_type difference_type; 4862227825Stheraven difference_type __n = __last - __first; 4863227825Stheraven if (__n > 1) 4864227825Stheraven { 4865227825Stheraven __last = __first; 4866227825Stheraven ++__last; 4867227825Stheraven for (difference_type __i = 1; __i < __n;) 4868227825Stheraven __push_heap_back<_Compare>(__first, ++__last, __comp, ++__i); 4869227825Stheraven } 4870227825Stheraven} 4871227825Stheraven 4872227825Stheraventemplate <class _RandomAccessIterator, class _Compare> 4873227825Stheraveninline _LIBCPP_INLINE_VISIBILITY 4874227825Stheravenvoid 4875227825Stheravenmake_heap(_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp) 4876227825Stheraven{ 4877262801Sdim#ifdef _LIBCPP_DEBUG 4878227825Stheraven typedef typename add_lvalue_reference<__debug_less<_Compare> >::type _Comp_ref; 4879227825Stheraven __debug_less<_Compare> __c(__comp); 4880227825Stheraven __make_heap<_Comp_ref>(__first, __last, __c); 4881262801Sdim#else // _LIBCPP_DEBUG 4882227825Stheraven typedef typename add_lvalue_reference<_Compare>::type _Comp_ref; 4883227825Stheraven __make_heap<_Comp_ref>(__first, __last, __comp); 4884262801Sdim#endif // _LIBCPP_DEBUG 4885227825Stheraven} 4886227825Stheraven 4887227825Stheraventemplate <class _RandomAccessIterator> 4888227825Stheraveninline _LIBCPP_INLINE_VISIBILITY 4889227825Stheravenvoid 4890227825Stheravenmake_heap(_RandomAccessIterator __first, _RandomAccessIterator __last) 4891227825Stheraven{ 4892227825Stheraven _VSTD::make_heap(__first, __last, __less<typename iterator_traits<_RandomAccessIterator>::value_type>()); 4893227825Stheraven} 4894227825Stheraven 4895227825Stheraven// sort_heap 4896227825Stheraven 4897227825Stheraventemplate <class _Compare, class _RandomAccessIterator> 4898227825Stheravenvoid 4899227825Stheraven__sort_heap(_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp) 4900227825Stheraven{ 4901227825Stheraven typedef typename iterator_traits<_RandomAccessIterator>::difference_type difference_type; 4902227825Stheraven for (difference_type __n = __last - __first; __n > 1; --__last, --__n) 4903227825Stheraven __pop_heap<_Compare>(__first, __last, __comp, __n); 4904227825Stheraven} 4905227825Stheraven 4906227825Stheraventemplate <class _RandomAccessIterator, class _Compare> 4907227825Stheraveninline _LIBCPP_INLINE_VISIBILITY 4908227825Stheravenvoid 4909227825Stheravensort_heap(_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp) 4910227825Stheraven{ 4911262801Sdim#ifdef _LIBCPP_DEBUG 4912227825Stheraven typedef typename add_lvalue_reference<__debug_less<_Compare> >::type _Comp_ref; 4913227825Stheraven __debug_less<_Compare> __c(__comp); 4914227825Stheraven __sort_heap<_Comp_ref>(__first, __last, __c); 4915262801Sdim#else // _LIBCPP_DEBUG 4916227825Stheraven typedef typename add_lvalue_reference<_Compare>::type _Comp_ref; 4917227825Stheraven __sort_heap<_Comp_ref>(__first, __last, __comp); 4918262801Sdim#endif // _LIBCPP_DEBUG 4919227825Stheraven} 4920227825Stheraven 4921227825Stheraventemplate <class _RandomAccessIterator> 4922227825Stheraveninline _LIBCPP_INLINE_VISIBILITY 4923227825Stheravenvoid 4924227825Stheravensort_heap(_RandomAccessIterator __first, _RandomAccessIterator __last) 4925227825Stheraven{ 4926227825Stheraven _VSTD::sort_heap(__first, __last, __less<typename iterator_traits<_RandomAccessIterator>::value_type>()); 4927227825Stheraven} 4928227825Stheraven 4929227825Stheraven// partial_sort 4930227825Stheraven 4931227825Stheraventemplate <class _Compare, class _RandomAccessIterator> 4932227825Stheravenvoid 4933227825Stheraven__partial_sort(_RandomAccessIterator __first, _RandomAccessIterator __middle, _RandomAccessIterator __last, 4934227825Stheraven _Compare __comp) 4935227825Stheraven{ 4936227825Stheraven __make_heap<_Compare>(__first, __middle, __comp); 4937227825Stheraven typename iterator_traits<_RandomAccessIterator>::difference_type __len = __middle - __first; 4938227825Stheraven for (_RandomAccessIterator __i = __middle; __i != __last; ++__i) 4939227825Stheraven { 4940227825Stheraven if (__comp(*__i, *__first)) 4941227825Stheraven { 4942227825Stheraven swap(*__i, *__first); 4943227825Stheraven __push_heap_front<_Compare>(__first, __middle, __comp, __len); 4944227825Stheraven } 4945227825Stheraven } 4946227825Stheraven __sort_heap<_Compare>(__first, __middle, __comp); 4947227825Stheraven} 4948227825Stheraven 4949227825Stheraventemplate <class _RandomAccessIterator, class _Compare> 4950227825Stheraveninline _LIBCPP_INLINE_VISIBILITY 4951227825Stheravenvoid 4952227825Stheravenpartial_sort(_RandomAccessIterator __first, _RandomAccessIterator __middle, _RandomAccessIterator __last, 4953227825Stheraven _Compare __comp) 4954227825Stheraven{ 4955262801Sdim#ifdef _LIBCPP_DEBUG 4956227825Stheraven typedef typename add_lvalue_reference<__debug_less<_Compare> >::type _Comp_ref; 4957227825Stheraven __debug_less<_Compare> __c(__comp); 4958227825Stheraven __partial_sort<_Comp_ref>(__first, __middle, __last, __c); 4959262801Sdim#else // _LIBCPP_DEBUG 4960227825Stheraven typedef typename add_lvalue_reference<_Compare>::type _Comp_ref; 4961227825Stheraven __partial_sort<_Comp_ref>(__first, __middle, __last, __comp); 4962262801Sdim#endif // _LIBCPP_DEBUG 4963227825Stheraven} 4964227825Stheraven 4965227825Stheraventemplate <class _RandomAccessIterator> 4966227825Stheraveninline _LIBCPP_INLINE_VISIBILITY 4967227825Stheravenvoid 4968227825Stheravenpartial_sort(_RandomAccessIterator __first, _RandomAccessIterator __middle, _RandomAccessIterator __last) 4969227825Stheraven{ 4970227825Stheraven _VSTD::partial_sort(__first, __middle, __last, 4971227825Stheraven __less<typename iterator_traits<_RandomAccessIterator>::value_type>()); 4972227825Stheraven} 4973227825Stheraven 4974227825Stheraven// partial_sort_copy 4975227825Stheraven 4976227825Stheraventemplate <class _Compare, class _InputIterator, class _RandomAccessIterator> 4977227825Stheraven_RandomAccessIterator 4978227825Stheraven__partial_sort_copy(_InputIterator __first, _InputIterator __last, 4979227825Stheraven _RandomAccessIterator __result_first, _RandomAccessIterator __result_last, _Compare __comp) 4980227825Stheraven{ 4981227825Stheraven _RandomAccessIterator __r = __result_first; 4982227825Stheraven if (__r != __result_last) 4983227825Stheraven { 4984227825Stheraven typename iterator_traits<_RandomAccessIterator>::difference_type __len = 0; 4985227825Stheraven for (; __first != __last && __r != __result_last; ++__first, ++__r, ++__len) 4986227825Stheraven *__r = *__first; 4987227825Stheraven __make_heap<_Compare>(__result_first, __r, __comp); 4988227825Stheraven for (; __first != __last; ++__first) 4989227825Stheraven if (__comp(*__first, *__result_first)) 4990227825Stheraven { 4991227825Stheraven *__result_first = *__first; 4992227825Stheraven __push_heap_front<_Compare>(__result_first, __r, __comp, __len); 4993227825Stheraven } 4994227825Stheraven __sort_heap<_Compare>(__result_first, __r, __comp); 4995227825Stheraven } 4996227825Stheraven return __r; 4997227825Stheraven} 4998227825Stheraven 4999227825Stheraventemplate <class _InputIterator, class _RandomAccessIterator, class _Compare> 5000227825Stheraveninline _LIBCPP_INLINE_VISIBILITY 5001227825Stheraven_RandomAccessIterator 5002227825Stheravenpartial_sort_copy(_InputIterator __first, _InputIterator __last, 5003227825Stheraven _RandomAccessIterator __result_first, _RandomAccessIterator __result_last, _Compare __comp) 5004227825Stheraven{ 5005262801Sdim#ifdef _LIBCPP_DEBUG 5006227825Stheraven typedef typename add_lvalue_reference<__debug_less<_Compare> >::type _Comp_ref; 5007227825Stheraven __debug_less<_Compare> __c(__comp); 5008227825Stheraven return __partial_sort_copy<_Comp_ref>(__first, __last, __result_first, __result_last, __c); 5009262801Sdim#else // _LIBCPP_DEBUG 5010227825Stheraven typedef typename add_lvalue_reference<_Compare>::type _Comp_ref; 5011227825Stheraven return __partial_sort_copy<_Comp_ref>(__first, __last, __result_first, __result_last, __comp); 5012262801Sdim#endif // _LIBCPP_DEBUG 5013227825Stheraven} 5014227825Stheraven 5015227825Stheraventemplate <class _InputIterator, class _RandomAccessIterator> 5016227825Stheraveninline _LIBCPP_INLINE_VISIBILITY 5017227825Stheraven_RandomAccessIterator 5018227825Stheravenpartial_sort_copy(_InputIterator __first, _InputIterator __last, 5019227825Stheraven _RandomAccessIterator __result_first, _RandomAccessIterator __result_last) 5020227825Stheraven{ 5021227825Stheraven return _VSTD::partial_sort_copy(__first, __last, __result_first, __result_last, 5022227825Stheraven __less<typename iterator_traits<_RandomAccessIterator>::value_type>()); 5023227825Stheraven} 5024227825Stheraven 5025227825Stheraven// nth_element 5026227825Stheraven 5027227825Stheraventemplate <class _Compare, class _RandomAccessIterator> 5028227825Stheravenvoid 5029227825Stheraven__nth_element(_RandomAccessIterator __first, _RandomAccessIterator __nth, _RandomAccessIterator __last, _Compare __comp) 5030227825Stheraven{ 5031227825Stheraven // _Compare is known to be a reference type 5032227825Stheraven typedef typename iterator_traits<_RandomAccessIterator>::difference_type difference_type; 5033227825Stheraven const difference_type __limit = 7; 5034227825Stheraven while (true) 5035227825Stheraven { 5036227825Stheraven __restart: 5037232950Stheraven if (__nth == __last) 5038232950Stheraven return; 5039227825Stheraven difference_type __len = __last - __first; 5040227825Stheraven switch (__len) 5041227825Stheraven { 5042227825Stheraven case 0: 5043227825Stheraven case 1: 5044227825Stheraven return; 5045227825Stheraven case 2: 5046227825Stheraven if (__comp(*--__last, *__first)) 5047227825Stheraven swap(*__first, *__last); 5048227825Stheraven return; 5049227825Stheraven case 3: 5050227825Stheraven { 5051227825Stheraven _RandomAccessIterator __m = __first; 5052227825Stheraven _VSTD::__sort3<_Compare>(__first, ++__m, --__last, __comp); 5053227825Stheraven return; 5054227825Stheraven } 5055227825Stheraven } 5056227825Stheraven if (__len <= __limit) 5057227825Stheraven { 5058227825Stheraven __selection_sort<_Compare>(__first, __last, __comp); 5059227825Stheraven return; 5060227825Stheraven } 5061227825Stheraven // __len > __limit >= 3 5062227825Stheraven _RandomAccessIterator __m = __first + __len/2; 5063227825Stheraven _RandomAccessIterator __lm1 = __last; 5064227825Stheraven unsigned __n_swaps = _VSTD::__sort3<_Compare>(__first, __m, --__lm1, __comp); 5065227825Stheraven // *__m is median 5066227825Stheraven // partition [__first, __m) < *__m and *__m <= [__m, __last) 5067227825Stheraven // (this inhibits tossing elements equivalent to __m around unnecessarily) 5068227825Stheraven _RandomAccessIterator __i = __first; 5069227825Stheraven _RandomAccessIterator __j = __lm1; 5070227825Stheraven // j points beyond range to be tested, *__lm1 is known to be <= *__m 5071227825Stheraven // The search going up is known to be guarded but the search coming down isn't. 5072227825Stheraven // Prime the downward search with a guard. 5073227825Stheraven if (!__comp(*__i, *__m)) // if *__first == *__m 5074227825Stheraven { 5075227825Stheraven // *__first == *__m, *__first doesn't go in first part 5076227825Stheraven // manually guard downward moving __j against __i 5077227825Stheraven while (true) 5078227825Stheraven { 5079227825Stheraven if (__i == --__j) 5080227825Stheraven { 5081227825Stheraven // *__first == *__m, *__m <= all other elements 5082227825Stheraven // Parition instead into [__first, __i) == *__first and *__first < [__i, __last) 5083227825Stheraven ++__i; // __first + 1 5084227825Stheraven __j = __last; 5085227825Stheraven if (!__comp(*__first, *--__j)) // we need a guard if *__first == *(__last-1) 5086227825Stheraven { 5087227825Stheraven while (true) 5088227825Stheraven { 5089227825Stheraven if (__i == __j) 5090227825Stheraven return; // [__first, __last) all equivalent elements 5091227825Stheraven if (__comp(*__first, *__i)) 5092227825Stheraven { 5093227825Stheraven swap(*__i, *__j); 5094227825Stheraven ++__n_swaps; 5095227825Stheraven ++__i; 5096227825Stheraven break; 5097227825Stheraven } 5098227825Stheraven ++__i; 5099227825Stheraven } 5100227825Stheraven } 5101227825Stheraven // [__first, __i) == *__first and *__first < [__j, __last) and __j == __last - 1 5102227825Stheraven if (__i == __j) 5103227825Stheraven return; 5104227825Stheraven while (true) 5105227825Stheraven { 5106227825Stheraven while (!__comp(*__first, *__i)) 5107227825Stheraven ++__i; 5108227825Stheraven while (__comp(*__first, *--__j)) 5109227825Stheraven ; 5110227825Stheraven if (__i >= __j) 5111227825Stheraven break; 5112227825Stheraven swap(*__i, *__j); 5113227825Stheraven ++__n_swaps; 5114227825Stheraven ++__i; 5115227825Stheraven } 5116227825Stheraven // [__first, __i) == *__first and *__first < [__i, __last) 5117227825Stheraven // The first part is sorted, 5118227825Stheraven if (__nth < __i) 5119227825Stheraven return; 5120227825Stheraven // __nth_element the secod part 5121227825Stheraven // __nth_element<_Compare>(__i, __nth, __last, __comp); 5122227825Stheraven __first = __i; 5123227825Stheraven goto __restart; 5124227825Stheraven } 5125227825Stheraven if (__comp(*__j, *__m)) 5126227825Stheraven { 5127227825Stheraven swap(*__i, *__j); 5128227825Stheraven ++__n_swaps; 5129227825Stheraven break; // found guard for downward moving __j, now use unguarded partition 5130227825Stheraven } 5131227825Stheraven } 5132227825Stheraven } 5133227825Stheraven ++__i; 5134227825Stheraven // j points beyond range to be tested, *__lm1 is known to be <= *__m 5135227825Stheraven // if not yet partitioned... 5136227825Stheraven if (__i < __j) 5137227825Stheraven { 5138227825Stheraven // known that *(__i - 1) < *__m 5139227825Stheraven while (true) 5140227825Stheraven { 5141227825Stheraven // __m still guards upward moving __i 5142227825Stheraven while (__comp(*__i, *__m)) 5143227825Stheraven ++__i; 5144227825Stheraven // It is now known that a guard exists for downward moving __j 5145227825Stheraven while (!__comp(*--__j, *__m)) 5146227825Stheraven ; 5147227825Stheraven if (__i >= __j) 5148227825Stheraven break; 5149227825Stheraven swap(*__i, *__j); 5150227825Stheraven ++__n_swaps; 5151227825Stheraven // It is known that __m != __j 5152227825Stheraven // If __m just moved, follow it 5153227825Stheraven if (__m == __i) 5154227825Stheraven __m = __j; 5155227825Stheraven ++__i; 5156227825Stheraven } 5157227825Stheraven } 5158227825Stheraven // [__first, __i) < *__m and *__m <= [__i, __last) 5159227825Stheraven if (__i != __m && __comp(*__m, *__i)) 5160227825Stheraven { 5161227825Stheraven swap(*__i, *__m); 5162227825Stheraven ++__n_swaps; 5163227825Stheraven } 5164227825Stheraven // [__first, __i) < *__i and *__i <= [__i+1, __last) 5165227825Stheraven if (__nth == __i) 5166227825Stheraven return; 5167227825Stheraven if (__n_swaps == 0) 5168227825Stheraven { 5169227825Stheraven // We were given a perfectly partitioned sequence. Coincidence? 5170227825Stheraven if (__nth < __i) 5171227825Stheraven { 5172227825Stheraven // Check for [__first, __i) already sorted 5173227825Stheraven __j = __m = __first; 5174227825Stheraven while (++__j != __i) 5175227825Stheraven { 5176227825Stheraven if (__comp(*__j, *__m)) 5177227825Stheraven // not yet sorted, so sort 5178227825Stheraven goto not_sorted; 5179227825Stheraven __m = __j; 5180227825Stheraven } 5181227825Stheraven // [__first, __i) sorted 5182227825Stheraven return; 5183227825Stheraven } 5184227825Stheraven else 5185227825Stheraven { 5186227825Stheraven // Check for [__i, __last) already sorted 5187227825Stheraven __j = __m = __i; 5188227825Stheraven while (++__j != __last) 5189227825Stheraven { 5190227825Stheraven if (__comp(*__j, *__m)) 5191227825Stheraven // not yet sorted, so sort 5192227825Stheraven goto not_sorted; 5193227825Stheraven __m = __j; 5194227825Stheraven } 5195227825Stheraven // [__i, __last) sorted 5196227825Stheraven return; 5197227825Stheraven } 5198227825Stheraven } 5199227825Stheravennot_sorted: 5200227825Stheraven // __nth_element on range containing __nth 5201227825Stheraven if (__nth < __i) 5202227825Stheraven { 5203227825Stheraven // __nth_element<_Compare>(__first, __nth, __i, __comp); 5204227825Stheraven __last = __i; 5205227825Stheraven } 5206227825Stheraven else 5207227825Stheraven { 5208227825Stheraven // __nth_element<_Compare>(__i+1, __nth, __last, __comp); 5209227825Stheraven __first = ++__i; 5210227825Stheraven } 5211227825Stheraven } 5212227825Stheraven} 5213227825Stheraven 5214227825Stheraventemplate <class _RandomAccessIterator, class _Compare> 5215227825Stheraveninline _LIBCPP_INLINE_VISIBILITY 5216227825Stheravenvoid 5217227825Stheravennth_element(_RandomAccessIterator __first, _RandomAccessIterator __nth, _RandomAccessIterator __last, _Compare __comp) 5218227825Stheraven{ 5219262801Sdim#ifdef _LIBCPP_DEBUG 5220227825Stheraven typedef typename add_lvalue_reference<__debug_less<_Compare> >::type _Comp_ref; 5221227825Stheraven __debug_less<_Compare> __c(__comp); 5222227825Stheraven __nth_element<_Comp_ref>(__first, __nth, __last, __c); 5223262801Sdim#else // _LIBCPP_DEBUG 5224227825Stheraven typedef typename add_lvalue_reference<_Compare>::type _Comp_ref; 5225227825Stheraven __nth_element<_Comp_ref>(__first, __nth, __last, __comp); 5226262801Sdim#endif // _LIBCPP_DEBUG 5227227825Stheraven} 5228227825Stheraven 5229227825Stheraventemplate <class _RandomAccessIterator> 5230227825Stheraveninline _LIBCPP_INLINE_VISIBILITY 5231227825Stheravenvoid 5232227825Stheravennth_element(_RandomAccessIterator __first, _RandomAccessIterator __nth, _RandomAccessIterator __last) 5233227825Stheraven{ 5234227825Stheraven _VSTD::nth_element(__first, __nth, __last, __less<typename iterator_traits<_RandomAccessIterator>::value_type>()); 5235227825Stheraven} 5236227825Stheraven 5237227825Stheraven// includes 5238227825Stheraven 5239227825Stheraventemplate <class _Compare, class _InputIterator1, class _InputIterator2> 5240227825Stheravenbool 5241227825Stheraven__includes(_InputIterator1 __first1, _InputIterator1 __last1, _InputIterator2 __first2, _InputIterator2 __last2, 5242227825Stheraven _Compare __comp) 5243227825Stheraven{ 5244227825Stheraven for (; __first2 != __last2; ++__first1) 5245227825Stheraven { 5246227825Stheraven if (__first1 == __last1 || __comp(*__first2, *__first1)) 5247227825Stheraven return false; 5248227825Stheraven if (!__comp(*__first1, *__first2)) 5249227825Stheraven ++__first2; 5250227825Stheraven } 5251227825Stheraven return true; 5252227825Stheraven} 5253227825Stheraven 5254227825Stheraventemplate <class _InputIterator1, class _InputIterator2, class _Compare> 5255227825Stheraveninline _LIBCPP_INLINE_VISIBILITY 5256227825Stheravenbool 5257227825Stheravenincludes(_InputIterator1 __first1, _InputIterator1 __last1, _InputIterator2 __first2, _InputIterator2 __last2, 5258227825Stheraven _Compare __comp) 5259227825Stheraven{ 5260262801Sdim#ifdef _LIBCPP_DEBUG 5261227825Stheraven typedef typename add_lvalue_reference<__debug_less<_Compare> >::type _Comp_ref; 5262227825Stheraven __debug_less<_Compare> __c(__comp); 5263227825Stheraven return __includes<_Comp_ref>(__first1, __last1, __first2, __last2, __c); 5264262801Sdim#else // _LIBCPP_DEBUG 5265227825Stheraven typedef typename add_lvalue_reference<_Compare>::type _Comp_ref; 5266227825Stheraven return __includes<_Comp_ref>(__first1, __last1, __first2, __last2, __comp); 5267262801Sdim#endif // _LIBCPP_DEBUG 5268227825Stheraven} 5269227825Stheraven 5270227825Stheraventemplate <class _InputIterator1, class _InputIterator2> 5271227825Stheraveninline _LIBCPP_INLINE_VISIBILITY 5272227825Stheravenbool 5273227825Stheravenincludes(_InputIterator1 __first1, _InputIterator1 __last1, _InputIterator2 __first2, _InputIterator2 __last2) 5274227825Stheraven{ 5275227825Stheraven return _VSTD::includes(__first1, __last1, __first2, __last2, 5276227825Stheraven __less<typename iterator_traits<_InputIterator1>::value_type, 5277227825Stheraven typename iterator_traits<_InputIterator2>::value_type>()); 5278227825Stheraven} 5279227825Stheraven 5280227825Stheraven// set_union 5281227825Stheraven 5282227825Stheraventemplate <class _Compare, class _InputIterator1, class _InputIterator2, class _OutputIterator> 5283227825Stheraven_OutputIterator 5284227825Stheraven__set_union(_InputIterator1 __first1, _InputIterator1 __last1, 5285227825Stheraven _InputIterator2 __first2, _InputIterator2 __last2, _OutputIterator __result, _Compare __comp) 5286227825Stheraven{ 5287227825Stheraven for (; __first1 != __last1; ++__result) 5288227825Stheraven { 5289227825Stheraven if (__first2 == __last2) 5290227825Stheraven return _VSTD::copy(__first1, __last1, __result); 5291227825Stheraven if (__comp(*__first2, *__first1)) 5292227825Stheraven { 5293227825Stheraven *__result = *__first2; 5294227825Stheraven ++__first2; 5295227825Stheraven } 5296227825Stheraven else 5297227825Stheraven { 5298227825Stheraven *__result = *__first1; 5299227825Stheraven if (!__comp(*__first1, *__first2)) 5300227825Stheraven ++__first2; 5301227825Stheraven ++__first1; 5302227825Stheraven } 5303227825Stheraven } 5304227825Stheraven return _VSTD::copy(__first2, __last2, __result); 5305227825Stheraven} 5306227825Stheraven 5307227825Stheraventemplate <class _InputIterator1, class _InputIterator2, class _OutputIterator, class _Compare> 5308227825Stheraveninline _LIBCPP_INLINE_VISIBILITY 5309227825Stheraven_OutputIterator 5310227825Stheravenset_union(_InputIterator1 __first1, _InputIterator1 __last1, 5311227825Stheraven _InputIterator2 __first2, _InputIterator2 __last2, _OutputIterator __result, _Compare __comp) 5312227825Stheraven{ 5313262801Sdim#ifdef _LIBCPP_DEBUG 5314227825Stheraven typedef typename add_lvalue_reference<__debug_less<_Compare> >::type _Comp_ref; 5315227825Stheraven __debug_less<_Compare> __c(__comp); 5316227825Stheraven return __set_union<_Comp_ref>(__first1, __last1, __first2, __last2, __result, __c); 5317262801Sdim#else // _LIBCPP_DEBUG 5318227825Stheraven typedef typename add_lvalue_reference<_Compare>::type _Comp_ref; 5319227825Stheraven return __set_union<_Comp_ref>(__first1, __last1, __first2, __last2, __result, __comp); 5320262801Sdim#endif // _LIBCPP_DEBUG 5321227825Stheraven} 5322227825Stheraven 5323227825Stheraventemplate <class _InputIterator1, class _InputIterator2, class _OutputIterator> 5324227825Stheraveninline _LIBCPP_INLINE_VISIBILITY 5325227825Stheraven_OutputIterator 5326227825Stheravenset_union(_InputIterator1 __first1, _InputIterator1 __last1, 5327227825Stheraven _InputIterator2 __first2, _InputIterator2 __last2, _OutputIterator __result) 5328227825Stheraven{ 5329227825Stheraven return _VSTD::set_union(__first1, __last1, __first2, __last2, __result, 5330227825Stheraven __less<typename iterator_traits<_InputIterator1>::value_type, 5331227825Stheraven typename iterator_traits<_InputIterator2>::value_type>()); 5332227825Stheraven} 5333227825Stheraven 5334227825Stheraven// set_intersection 5335227825Stheraven 5336227825Stheraventemplate <class _Compare, class _InputIterator1, class _InputIterator2, class _OutputIterator> 5337227825Stheraven_OutputIterator 5338227825Stheraven__set_intersection(_InputIterator1 __first1, _InputIterator1 __last1, 5339227825Stheraven _InputIterator2 __first2, _InputIterator2 __last2, _OutputIterator __result, _Compare __comp) 5340227825Stheraven{ 5341227825Stheraven while (__first1 != __last1 && __first2 != __last2) 5342227825Stheraven { 5343227825Stheraven if (__comp(*__first1, *__first2)) 5344227825Stheraven ++__first1; 5345227825Stheraven else 5346227825Stheraven { 5347227825Stheraven if (!__comp(*__first2, *__first1)) 5348227825Stheraven { 5349227825Stheraven *__result = *__first1; 5350227825Stheraven ++__result; 5351227825Stheraven ++__first1; 5352227825Stheraven } 5353227825Stheraven ++__first2; 5354227825Stheraven } 5355227825Stheraven } 5356227825Stheraven return __result; 5357227825Stheraven} 5358227825Stheraven 5359227825Stheraventemplate <class _InputIterator1, class _InputIterator2, class _OutputIterator, class _Compare> 5360227825Stheraveninline _LIBCPP_INLINE_VISIBILITY 5361227825Stheraven_OutputIterator 5362227825Stheravenset_intersection(_InputIterator1 __first1, _InputIterator1 __last1, 5363227825Stheraven _InputIterator2 __first2, _InputIterator2 __last2, _OutputIterator __result, _Compare __comp) 5364227825Stheraven{ 5365262801Sdim#ifdef _LIBCPP_DEBUG 5366227825Stheraven typedef typename add_lvalue_reference<__debug_less<_Compare> >::type _Comp_ref; 5367227825Stheraven __debug_less<_Compare> __c(__comp); 5368227825Stheraven return __set_intersection<_Comp_ref>(__first1, __last1, __first2, __last2, __result, __c); 5369262801Sdim#else // _LIBCPP_DEBUG 5370227825Stheraven typedef typename add_lvalue_reference<_Compare>::type _Comp_ref; 5371227825Stheraven return __set_intersection<_Comp_ref>(__first1, __last1, __first2, __last2, __result, __comp); 5372262801Sdim#endif // _LIBCPP_DEBUG 5373227825Stheraven} 5374227825Stheraven 5375227825Stheraventemplate <class _InputIterator1, class _InputIterator2, class _OutputIterator> 5376227825Stheraveninline _LIBCPP_INLINE_VISIBILITY 5377227825Stheraven_OutputIterator 5378227825Stheravenset_intersection(_InputIterator1 __first1, _InputIterator1 __last1, 5379227825Stheraven _InputIterator2 __first2, _InputIterator2 __last2, _OutputIterator __result) 5380227825Stheraven{ 5381227825Stheraven return _VSTD::set_intersection(__first1, __last1, __first2, __last2, __result, 5382227825Stheraven __less<typename iterator_traits<_InputIterator1>::value_type, 5383227825Stheraven typename iterator_traits<_InputIterator2>::value_type>()); 5384227825Stheraven} 5385227825Stheraven 5386227825Stheraven// set_difference 5387227825Stheraven 5388227825Stheraventemplate <class _Compare, class _InputIterator1, class _InputIterator2, class _OutputIterator> 5389227825Stheraven_OutputIterator 5390227825Stheraven__set_difference(_InputIterator1 __first1, _InputIterator1 __last1, 5391227825Stheraven _InputIterator2 __first2, _InputIterator2 __last2, _OutputIterator __result, _Compare __comp) 5392227825Stheraven{ 5393227825Stheraven while (__first1 != __last1) 5394227825Stheraven { 5395227825Stheraven if (__first2 == __last2) 5396227825Stheraven return _VSTD::copy(__first1, __last1, __result); 5397227825Stheraven if (__comp(*__first1, *__first2)) 5398227825Stheraven { 5399227825Stheraven *__result = *__first1; 5400227825Stheraven ++__result; 5401227825Stheraven ++__first1; 5402227825Stheraven } 5403227825Stheraven else 5404227825Stheraven { 5405227825Stheraven if (!__comp(*__first2, *__first1)) 5406227825Stheraven ++__first1; 5407227825Stheraven ++__first2; 5408227825Stheraven } 5409227825Stheraven } 5410227825Stheraven return __result; 5411227825Stheraven} 5412227825Stheraven 5413227825Stheraventemplate <class _InputIterator1, class _InputIterator2, class _OutputIterator, class _Compare> 5414227825Stheraveninline _LIBCPP_INLINE_VISIBILITY 5415227825Stheraven_OutputIterator 5416227825Stheravenset_difference(_InputIterator1 __first1, _InputIterator1 __last1, 5417227825Stheraven _InputIterator2 __first2, _InputIterator2 __last2, _OutputIterator __result, _Compare __comp) 5418227825Stheraven{ 5419262801Sdim#ifdef _LIBCPP_DEBUG 5420227825Stheraven typedef typename add_lvalue_reference<__debug_less<_Compare> >::type _Comp_ref; 5421227825Stheraven __debug_less<_Compare> __c(__comp); 5422227825Stheraven return __set_difference<_Comp_ref>(__first1, __last1, __first2, __last2, __result, __c); 5423262801Sdim#else // _LIBCPP_DEBUG 5424227825Stheraven typedef typename add_lvalue_reference<_Compare>::type _Comp_ref; 5425227825Stheraven return __set_difference<_Comp_ref>(__first1, __last1, __first2, __last2, __result, __comp); 5426262801Sdim#endif // _LIBCPP_DEBUG 5427227825Stheraven} 5428227825Stheraven 5429227825Stheraventemplate <class _InputIterator1, class _InputIterator2, class _OutputIterator> 5430227825Stheraveninline _LIBCPP_INLINE_VISIBILITY 5431227825Stheraven_OutputIterator 5432227825Stheravenset_difference(_InputIterator1 __first1, _InputIterator1 __last1, 5433227825Stheraven _InputIterator2 __first2, _InputIterator2 __last2, _OutputIterator __result) 5434227825Stheraven{ 5435227825Stheraven return _VSTD::set_difference(__first1, __last1, __first2, __last2, __result, 5436227825Stheraven __less<typename iterator_traits<_InputIterator1>::value_type, 5437227825Stheraven typename iterator_traits<_InputIterator2>::value_type>()); 5438227825Stheraven} 5439227825Stheraven 5440227825Stheraven// set_symmetric_difference 5441227825Stheraven 5442227825Stheraventemplate <class _Compare, class _InputIterator1, class _InputIterator2, class _OutputIterator> 5443227825Stheraven_OutputIterator 5444227825Stheraven__set_symmetric_difference(_InputIterator1 __first1, _InputIterator1 __last1, 5445227825Stheraven _InputIterator2 __first2, _InputIterator2 __last2, _OutputIterator __result, _Compare __comp) 5446227825Stheraven{ 5447227825Stheraven while (__first1 != __last1) 5448227825Stheraven { 5449227825Stheraven if (__first2 == __last2) 5450227825Stheraven return _VSTD::copy(__first1, __last1, __result); 5451227825Stheraven if (__comp(*__first1, *__first2)) 5452227825Stheraven { 5453227825Stheraven *__result = *__first1; 5454227825Stheraven ++__result; 5455227825Stheraven ++__first1; 5456227825Stheraven } 5457227825Stheraven else 5458227825Stheraven { 5459227825Stheraven if (__comp(*__first2, *__first1)) 5460227825Stheraven { 5461227825Stheraven *__result = *__first2; 5462227825Stheraven ++__result; 5463227825Stheraven } 5464227825Stheraven else 5465227825Stheraven ++__first1; 5466227825Stheraven ++__first2; 5467227825Stheraven } 5468227825Stheraven } 5469227825Stheraven return _VSTD::copy(__first2, __last2, __result); 5470227825Stheraven} 5471227825Stheraven 5472227825Stheraventemplate <class _InputIterator1, class _InputIterator2, class _OutputIterator, class _Compare> 5473227825Stheraveninline _LIBCPP_INLINE_VISIBILITY 5474227825Stheraven_OutputIterator 5475227825Stheravenset_symmetric_difference(_InputIterator1 __first1, _InputIterator1 __last1, 5476227825Stheraven _InputIterator2 __first2, _InputIterator2 __last2, _OutputIterator __result, _Compare __comp) 5477227825Stheraven{ 5478262801Sdim#ifdef _LIBCPP_DEBUG 5479227825Stheraven typedef typename add_lvalue_reference<__debug_less<_Compare> >::type _Comp_ref; 5480227825Stheraven __debug_less<_Compare> __c(__comp); 5481227825Stheraven return __set_symmetric_difference<_Comp_ref>(__first1, __last1, __first2, __last2, __result, __c); 5482262801Sdim#else // _LIBCPP_DEBUG 5483227825Stheraven typedef typename add_lvalue_reference<_Compare>::type _Comp_ref; 5484227825Stheraven return __set_symmetric_difference<_Comp_ref>(__first1, __last1, __first2, __last2, __result, __comp); 5485262801Sdim#endif // _LIBCPP_DEBUG 5486227825Stheraven} 5487227825Stheraven 5488227825Stheraventemplate <class _InputIterator1, class _InputIterator2, class _OutputIterator> 5489227825Stheraveninline _LIBCPP_INLINE_VISIBILITY 5490227825Stheraven_OutputIterator 5491227825Stheravenset_symmetric_difference(_InputIterator1 __first1, _InputIterator1 __last1, 5492227825Stheraven _InputIterator2 __first2, _InputIterator2 __last2, _OutputIterator __result) 5493227825Stheraven{ 5494227825Stheraven return _VSTD::set_symmetric_difference(__first1, __last1, __first2, __last2, __result, 5495227825Stheraven __less<typename iterator_traits<_InputIterator1>::value_type, 5496227825Stheraven typename iterator_traits<_InputIterator2>::value_type>()); 5497227825Stheraven} 5498227825Stheraven 5499227825Stheraven// lexicographical_compare 5500227825Stheraven 5501227825Stheraventemplate <class _Compare, class _InputIterator1, class _InputIterator2> 5502227825Stheravenbool 5503227825Stheraven__lexicographical_compare(_InputIterator1 __first1, _InputIterator1 __last1, 5504227825Stheraven _InputIterator2 __first2, _InputIterator2 __last2, _Compare __comp) 5505227825Stheraven{ 5506227825Stheraven for (; __first2 != __last2; ++__first1, ++__first2) 5507227825Stheraven { 5508227825Stheraven if (__first1 == __last1 || __comp(*__first1, *__first2)) 5509227825Stheraven return true; 5510227825Stheraven if (__comp(*__first2, *__first1)) 5511227825Stheraven return false; 5512227825Stheraven } 5513227825Stheraven return false; 5514227825Stheraven} 5515227825Stheraven 5516227825Stheraventemplate <class _InputIterator1, class _InputIterator2, class _Compare> 5517227825Stheraveninline _LIBCPP_INLINE_VISIBILITY 5518227825Stheravenbool 5519227825Stheravenlexicographical_compare(_InputIterator1 __first1, _InputIterator1 __last1, 5520227825Stheraven _InputIterator2 __first2, _InputIterator2 __last2, _Compare __comp) 5521227825Stheraven{ 5522262801Sdim#ifdef _LIBCPP_DEBUG 5523227825Stheraven typedef typename add_lvalue_reference<__debug_less<_Compare> >::type _Comp_ref; 5524227825Stheraven __debug_less<_Compare> __c(__comp); 5525227825Stheraven return __lexicographical_compare<_Comp_ref>(__first1, __last1, __first2, __last2, __c); 5526262801Sdim#else // _LIBCPP_DEBUG 5527227825Stheraven typedef typename add_lvalue_reference<_Compare>::type _Comp_ref; 5528227825Stheraven return __lexicographical_compare<_Comp_ref>(__first1, __last1, __first2, __last2, __comp); 5529262801Sdim#endif // _LIBCPP_DEBUG 5530227825Stheraven} 5531227825Stheraven 5532227825Stheraventemplate <class _InputIterator1, class _InputIterator2> 5533227825Stheraveninline _LIBCPP_INLINE_VISIBILITY 5534227825Stheravenbool 5535227825Stheravenlexicographical_compare(_InputIterator1 __first1, _InputIterator1 __last1, 5536227825Stheraven _InputIterator2 __first2, _InputIterator2 __last2) 5537227825Stheraven{ 5538227825Stheraven return _VSTD::lexicographical_compare(__first1, __last1, __first2, __last2, 5539227825Stheraven __less<typename iterator_traits<_InputIterator1>::value_type, 5540227825Stheraven typename iterator_traits<_InputIterator2>::value_type>()); 5541227825Stheraven} 5542227825Stheraven 5543227825Stheraven// next_permutation 5544227825Stheraven 5545227825Stheraventemplate <class _Compare, class _BidirectionalIterator> 5546227825Stheravenbool 5547227825Stheraven__next_permutation(_BidirectionalIterator __first, _BidirectionalIterator __last, _Compare __comp) 5548227825Stheraven{ 5549227825Stheraven _BidirectionalIterator __i = __last; 5550227825Stheraven if (__first == __last || __first == --__i) 5551227825Stheraven return false; 5552227825Stheraven while (true) 5553227825Stheraven { 5554227825Stheraven _BidirectionalIterator __ip1 = __i; 5555227825Stheraven if (__comp(*--__i, *__ip1)) 5556227825Stheraven { 5557227825Stheraven _BidirectionalIterator __j = __last; 5558227825Stheraven while (!__comp(*__i, *--__j)) 5559227825Stheraven ; 5560227825Stheraven swap(*__i, *__j); 5561227825Stheraven _VSTD::reverse(__ip1, __last); 5562227825Stheraven return true; 5563227825Stheraven } 5564227825Stheraven if (__i == __first) 5565227825Stheraven { 5566227825Stheraven _VSTD::reverse(__first, __last); 5567227825Stheraven return false; 5568227825Stheraven } 5569227825Stheraven } 5570227825Stheraven} 5571227825Stheraven 5572227825Stheraventemplate <class _BidirectionalIterator, class _Compare> 5573227825Stheraveninline _LIBCPP_INLINE_VISIBILITY 5574227825Stheravenbool 5575227825Stheravennext_permutation(_BidirectionalIterator __first, _BidirectionalIterator __last, _Compare __comp) 5576227825Stheraven{ 5577262801Sdim#ifdef _LIBCPP_DEBUG 5578227825Stheraven typedef typename add_lvalue_reference<__debug_less<_Compare> >::type _Comp_ref; 5579227825Stheraven __debug_less<_Compare> __c(__comp); 5580227825Stheraven return __next_permutation<_Comp_ref>(__first, __last, __c); 5581262801Sdim#else // _LIBCPP_DEBUG 5582227825Stheraven typedef typename add_lvalue_reference<_Compare>::type _Comp_ref; 5583227825Stheraven return __next_permutation<_Comp_ref>(__first, __last, __comp); 5584262801Sdim#endif // _LIBCPP_DEBUG 5585227825Stheraven} 5586227825Stheraven 5587227825Stheraventemplate <class _BidirectionalIterator> 5588227825Stheraveninline _LIBCPP_INLINE_VISIBILITY 5589227825Stheravenbool 5590227825Stheravennext_permutation(_BidirectionalIterator __first, _BidirectionalIterator __last) 5591227825Stheraven{ 5592227825Stheraven return _VSTD::next_permutation(__first, __last, 5593227825Stheraven __less<typename iterator_traits<_BidirectionalIterator>::value_type>()); 5594227825Stheraven} 5595227825Stheraven 5596227825Stheraven// prev_permutation 5597227825Stheraven 5598227825Stheraventemplate <class _Compare, class _BidirectionalIterator> 5599227825Stheravenbool 5600227825Stheraven__prev_permutation(_BidirectionalIterator __first, _BidirectionalIterator __last, _Compare __comp) 5601227825Stheraven{ 5602227825Stheraven _BidirectionalIterator __i = __last; 5603227825Stheraven if (__first == __last || __first == --__i) 5604227825Stheraven return false; 5605227825Stheraven while (true) 5606227825Stheraven { 5607227825Stheraven _BidirectionalIterator __ip1 = __i; 5608227825Stheraven if (__comp(*__ip1, *--__i)) 5609227825Stheraven { 5610227825Stheraven _BidirectionalIterator __j = __last; 5611227825Stheraven while (!__comp(*--__j, *__i)) 5612227825Stheraven ; 5613227825Stheraven swap(*__i, *__j); 5614227825Stheraven _VSTD::reverse(__ip1, __last); 5615227825Stheraven return true; 5616227825Stheraven } 5617227825Stheraven if (__i == __first) 5618227825Stheraven { 5619227825Stheraven _VSTD::reverse(__first, __last); 5620227825Stheraven return false; 5621227825Stheraven } 5622227825Stheraven } 5623227825Stheraven} 5624227825Stheraven 5625227825Stheraventemplate <class _BidirectionalIterator, class _Compare> 5626227825Stheraveninline _LIBCPP_INLINE_VISIBILITY 5627227825Stheravenbool 5628227825Stheravenprev_permutation(_BidirectionalIterator __first, _BidirectionalIterator __last, _Compare __comp) 5629227825Stheraven{ 5630262801Sdim#ifdef _LIBCPP_DEBUG 5631227825Stheraven typedef typename add_lvalue_reference<__debug_less<_Compare> >::type _Comp_ref; 5632227825Stheraven __debug_less<_Compare> __c(__comp); 5633227825Stheraven return __prev_permutation<_Comp_ref>(__first, __last, __c); 5634262801Sdim#else // _LIBCPP_DEBUG 5635227825Stheraven typedef typename add_lvalue_reference<_Compare>::type _Comp_ref; 5636227825Stheraven return __prev_permutation<_Comp_ref>(__first, __last, __comp); 5637262801Sdim#endif // _LIBCPP_DEBUG 5638227825Stheraven} 5639227825Stheraven 5640227825Stheraventemplate <class _BidirectionalIterator> 5641227825Stheraveninline _LIBCPP_INLINE_VISIBILITY 5642227825Stheravenbool 5643227825Stheravenprev_permutation(_BidirectionalIterator __first, _BidirectionalIterator __last) 5644227825Stheraven{ 5645227825Stheraven return _VSTD::prev_permutation(__first, __last, 5646227825Stheraven __less<typename iterator_traits<_BidirectionalIterator>::value_type>()); 5647227825Stheraven} 5648227825Stheraven 5649227825Stheraventemplate <class _Tp> 5650227825Stheraveninline _LIBCPP_INLINE_VISIBILITY 5651227825Stheraventypename enable_if 5652227825Stheraven< 5653227825Stheraven is_integral<_Tp>::value, 5654227825Stheraven _Tp 5655227825Stheraven>::type 5656227825Stheraven__rotate_left(_Tp __t, _Tp __n = 1) 5657227825Stheraven{ 5658227825Stheraven const unsigned __bits = static_cast<unsigned>(sizeof(_Tp) * __CHAR_BIT__ - 1); 5659227825Stheraven __n &= __bits; 5660227825Stheraven return static_cast<_Tp>((__t << __n) | (static_cast<typename make_unsigned<_Tp>::type>(__t) >> (__bits - __n))); 5661227825Stheraven} 5662227825Stheraven 5663227825Stheraventemplate <class _Tp> 5664227825Stheraveninline _LIBCPP_INLINE_VISIBILITY 5665227825Stheraventypename enable_if 5666227825Stheraven< 5667227825Stheraven is_integral<_Tp>::value, 5668227825Stheraven _Tp 5669227825Stheraven>::type 5670227825Stheraven__rotate_right(_Tp __t, _Tp __n = 1) 5671227825Stheraven{ 5672227825Stheraven const unsigned __bits = static_cast<unsigned>(sizeof(_Tp) * __CHAR_BIT__ - 1); 5673227825Stheraven __n &= __bits; 5674227825Stheraven return static_cast<_Tp>((__t << (__bits - __n)) | (static_cast<typename make_unsigned<_Tp>::type>(__t) >> __n)); 5675227825Stheraven} 5676227825Stheraven 5677227825Stheraven_LIBCPP_END_NAMESPACE_STD 5678227825Stheraven 5679227825Stheraven#endif // _LIBCPP_ALGORITHM 5680