libstdc++-v3/include/bits/ranges_algobase.h

   1 // Core algorithmic facilities -*- C++ -*-
   2
   3 // Copyright (C) 2020-2023 Free Software Foundation, Inc.
   4 //
   5 // This file is part of the GNU ISO C++ Library.  This library is free
   6 // software; you can redistribute it and/or modify it under the
   7 // terms of the GNU General Public License as published by the
   8 // Free Software Foundation; either version 3, or (at your option)
   9 // any later version.
  10
  11 // This library is distributed in the hope that it will be useful,
  12 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14 // GNU General Public License for more details.
  15
  16 // Under Section 7 of GPL version 3, you are granted additional
  17 // permissions described in the GCC Runtime Library Exception, version
  18 // 3.1, as published by the Free Software Foundation.
  19
  20 // You should have received a copy of the GNU General Public License and
  21 // a copy of the GCC Runtime Library Exception along with this program;
  22 // see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
  23 // <http://www.gnu.org/licenses/>.
  24
  25 /** @file bits/ranges_algobase.h
  26  *  This is an internal header file, included by other library headers.
  27  *  Do not attempt to use it directly. @headername{algorithm}
  28  */
  29
  30 #ifndef _RANGES_ALGOBASE_H
  31 #define _RANGES_ALGOBASE_H 1
  32
  33 #if __cplusplus > 201703L
  34
  35 #include <compare>
  36 #include <bits/stl_iterator_base_funcs.h>
  37 #include <bits/stl_iterator.h>
  38 #include <bits/ranges_base.h> // ranges::begin, ranges::range etc.
  39 #include <bits/invoke.h>      // __invoke
  40 #include <bits/cpp_type_traits.h> // __is_byte
  41
  42 #if __cpp_lib_concepts
  43 namespace std _GLIBCXX_VISIBILITY(default)
  44 {
  45 _GLIBCXX_BEGIN_NAMESPACE_VERSION
  46 namespace ranges
  47 {
  48   namespace __detail
  49   {
  50     template<typename _Tp>
  51       constexpr inline bool __is_normal_iterator = false;
  52
  53     template<typename _Iterator, typename _Container>
  54       constexpr inline bool
  55         __is_normal_iterator<__gnu_cxx::__normal_iterator<_Iterator,
  56                                                           _Container>> = true;
  57
  58     template<typename _Tp>
  59       constexpr inline bool __is_reverse_iterator = false;
  60
  61     template<typename _Iterator>
  62       constexpr inline bool
  63         __is_reverse_iterator<reverse_iterator<_Iterator>> = true;
  64
  65     template<typename _Tp>
  66       constexpr inline bool __is_move_iterator = false;
  67
  68     template<typename _Iterator>
  69       constexpr inline bool
  70         __is_move_iterator<move_iterator<_Iterator>> = true;
  71   } // namespace __detail
  72
  73   struct __equal_fn
  74   {
  75     template<input_iterator _Iter1, sentinel_for<_Iter1> _Sent1,
  76              input_iterator _Iter2, sentinel_for<_Iter2> _Sent2,
  77              typename _Pred = ranges::equal_to,
  78              typename _Proj1 = identity, typename _Proj2 = identity>
  79       requires indirectly_comparable<_Iter1, _Iter2, _Pred, _Proj1, _Proj2>
  80       constexpr bool
  81       operator()(_Iter1 __first1, _Sent1 __last1,
  82                  _Iter2 __first2, _Sent2 __last2, _Pred __pred = {},
  83                  _Proj1 __proj1 = {}, _Proj2 __proj2 = {}) const
  84       {
  85         // TODO: implement more specializations to at least have parity with
  86         // std::equal.
  87         if constexpr (__detail::__is_normal_iterator<_Iter1>
  88                       && same_as<_Iter1, _Sent1>)
  89           return (*this)(__first1.base(), __last1.base(),
  90                          std::move(__first2), std::move(__last2),
  91                          std::move(__pred),
  92                          std::move(__proj1), std::move(__proj2));
  93         else if constexpr (__detail::__is_normal_iterator<_Iter2>
  94                            && same_as<_Iter2, _Sent2>)
  95           return (*this)(std::move(__first1), std::move(__last1),
  96                          __first2.base(), __last2.base(),
  97                          std::move(__pred),
  98                          std::move(__proj1), std::move(__proj2));
  99         else if constexpr (sized_sentinel_for<_Sent1, _Iter1>
 100                            && sized_sentinel_for<_Sent2, _Iter2>)
 101           {
 102             auto __d1 = ranges::distance(__first1, __last1);
 103             auto __d2 = ranges::distance(__first2, __last2);
 104             if (__d1 != __d2)
 105               return false;
 106
 107             using _ValueType1 = iter_value_t<_Iter1>;
 108             constexpr bool __use_memcmp
 109               = ((is_integral_v<_ValueType1> || is_pointer_v<_ValueType1>)
 110                  && __memcmpable<_Iter1, _Iter2>::__value
 111                  && is_same_v<_Pred, ranges::equal_to>
 112                  && is_same_v<_Proj1, identity>
 113                  && is_same_v<_Proj2, identity>);
 114             if constexpr (__use_memcmp)
 115               {
 116                 if (const size_t __len = (__last1 - __first1))
 117                   return !std::__memcmp(__first1, __first2, __len);
 118                 return true;
 119               }
 120             else
 121               {
 122                 for (; __first1 != __last1; ++__first1, (void)++__first2)
 123                   if (!(bool)std::__invoke(__pred,
 124                                            std::__invoke(__proj1, *__first1),
 125                                            std::__invoke(__proj2, *__first2)))
 126                     return false;
 127                 return true;
 128               }
 129           }
 130         else
 131           {
 132             for (; __first1 != __last1 && __first2 != __last2;
 133                  ++__first1, (void)++__first2)
 134               if (!(bool)std::__invoke(__pred,
 135                                        std::__invoke(__proj1, *__first1),
 136                                        std::__invoke(__proj2, *__first2)))
 137                 return false;
 138             return __first1 == __last1 && __first2 == __last2;
 139           }
 140       }
 141
 142     template<input_range _Range1, input_range _Range2,
 143              typename _Pred = ranges::equal_to,
 144              typename _Proj1 = identity, typename _Proj2 = identity>
 145       requires indirectly_comparable<iterator_t<_Range1>, iterator_t<_Range2>,
 146                                      _Pred, _Proj1, _Proj2>
 147       constexpr bool
 148       operator()(_Range1&& __r1, _Range2&& __r2, _Pred __pred = {},
 149                  _Proj1 __proj1 = {}, _Proj2 __proj2 = {}) const
 150       {
 151         return (*this)(ranges::begin(__r1), ranges::end(__r1),
 152                        ranges::begin(__r2), ranges::end(__r2),
 153                        std::move(__pred),
 154                        std::move(__proj1), std::move(__proj2));
 155       }
 156   };
 157
 158   inline constexpr __equal_fn equal{};
 159
 160   template<typename _Iter, typename _Out>
 161     struct in_out_result
 162     {
 163       [[no_unique_address]] _Iter in;
 164       [[no_unique_address]] _Out out;
 165
 166       template<typename _Iter2, typename _Out2>
 167         requires convertible_to<const _Iter&, _Iter2>
 168           && convertible_to<const _Out&, _Out2>
 169         constexpr
 170         operator in_out_result<_Iter2, _Out2>() const &
 171         { return {in, out}; }
 172
 173       template<typename _Iter2, typename _Out2>
 174         requires convertible_to<_Iter, _Iter2>
 175           && convertible_to<_Out, _Out2>
 176         constexpr
 177         operator in_out_result<_Iter2, _Out2>() &&
 178         { return {std::move(in), std::move(out)}; }
 179     };
 180
 181   template<typename _Iter, typename _Out>
 182     using copy_result = in_out_result<_Iter, _Out>;
 183
 184   template<typename _Iter, typename _Out>
 185     using move_result = in_out_result<_Iter, _Out>;
 186
 187   template<typename _Iter1, typename _Iter2>
 188     using move_backward_result = in_out_result<_Iter1, _Iter2>;
 189
 190   template<typename _Iter1, typename _Iter2>
 191     using copy_backward_result = in_out_result<_Iter1, _Iter2>;
 192
 193   template<bool _IsMove,
 194            bidirectional_iterator _Iter, sentinel_for<_Iter> _Sent,
 195            bidirectional_iterator _Out>
 196     requires (_IsMove
 197               ? indirectly_movable<_Iter, _Out>
 198               : indirectly_copyable<_Iter, _Out>)
 199     constexpr __conditional_t<_IsMove,
 200                               move_backward_result<_Iter, _Out>,
 201                               copy_backward_result<_Iter, _Out>>
 202     __copy_or_move_backward(_Iter __first, _Sent __last, _Out __result);
 203
 204   template<bool _IsMove,
 205            input_iterator _Iter, sentinel_for<_Iter> _Sent,
 206            weakly_incrementable _Out>
 207     requires (_IsMove
 208               ? indirectly_movable<_Iter, _Out>
 209               : indirectly_copyable<_Iter, _Out>)
 210     constexpr __conditional_t<_IsMove,
 211                               move_result<_Iter, _Out>,
 212                               copy_result<_Iter, _Out>>
 213     __copy_or_move(_Iter __first, _Sent __last, _Out __result)
 214     {
 215       // TODO: implement more specializations to be at least on par with
 216       // std::copy/std::move.
 217       using __detail::__is_move_iterator;
 218       using __detail::__is_reverse_iterator;
 219       using __detail::__is_normal_iterator;
 220       if constexpr (__is_move_iterator<_Iter> && same_as<_Iter, _Sent>)
 221         {
 222           auto [__in, __out]
 223             = ranges::__copy_or_move<true>(std::move(__first).base(),
 224                                            std::move(__last).base(),
 225                                            std::move(__result));
 226           return {move_iterator{std::move(__in)}, std::move(__out)};
 227         }
 228       else if constexpr (__is_reverse_iterator<_Iter> && same_as<_Iter, _Sent>
 229                          && __is_reverse_iterator<_Out>)
 230         {
 231           auto [__in,__out]
 232             = ranges::__copy_or_move_backward<_IsMove>(std::move(__last).base(),
 233                                                        std::move(__first).base(),
 234                                                        std::move(__result).base());
 235           return {reverse_iterator{std::move(__in)},
 236                   reverse_iterator{std::move(__out)}};
 237         }
 238       else if constexpr (__is_normal_iterator<_Iter> && same_as<_Iter, _Sent>)
 239         {
 240           auto [__in,__out]
 241             = ranges::__copy_or_move<_IsMove>(__first.base(), __last.base(),
 242                                               std::move(__result));
 243           return {decltype(__first){__in}, std::move(__out)};
 244         }
 245       else if constexpr (__is_normal_iterator<_Out>)
 246         {
 247           auto [__in,__out]
 248             = ranges::__copy_or_move<_IsMove>(std::move(__first), __last, __result.base());
 249           return {std::move(__in), decltype(__result){__out}};
 250         }
 251       else if constexpr (sized_sentinel_for<_Sent, _Iter>)
 252         {
 253           if (!std::__is_constant_evaluated())
 254             {
 255               if constexpr (__memcpyable<_Iter, _Out>::__value)
 256                 {
 257                   using _ValueTypeI = iter_value_t<_Iter>;
 258                   static_assert(_IsMove
 259                       ? is_move_assignable_v<_ValueTypeI>
 260                       : is_copy_assignable_v<_ValueTypeI>);
 261                   auto __num = __last - __first;
 262                   if (__num)
 263                     __builtin_memmove(__result, __first,
 264                         sizeof(_ValueTypeI) * __num);
 265                   return {__first + __num, __result + __num};
 266                 }
 267             }
 268
 269           for (auto __n = __last - __first; __n > 0; --__n)
 270             {
 271               if constexpr (_IsMove)
 272                 *__result = std::move(*__first);
 273               else
 274                 *__result = *__first;
 275               ++__first;
 276               ++__result;
 277             }
 278           return {std::move(__first), std::move(__result)};
 279         }
 280       else
 281         {
 282           while (__first != __last)
 283             {
 284               if constexpr (_IsMove)
 285                 *__result = std::move(*__first);
 286               else
 287                 *__result = *__first;
 288               ++__first;
 289               ++__result;
 290             }
 291           return {std::move(__first), std::move(__result)};
 292         }
 293     }
 294
 295   struct __copy_fn
 296   {
 297     template<input_iterator _Iter, sentinel_for<_Iter> _Sent,
 298              weakly_incrementable _Out>
 299       requires indirectly_copyable<_Iter, _Out>
 300       constexpr copy_result<_Iter, _Out>
 301       operator()(_Iter __first, _Sent __last, _Out __result) const
 302       {
 303         return ranges::__copy_or_move<false>(std::move(__first),
 304                                              std::move(__last),
 305                                              std::move(__result));
 306       }
 307
 308     template<input_range _Range, weakly_incrementable _Out>
 309       requires indirectly_copyable<iterator_t<_Range>, _Out>
 310       constexpr copy_result<borrowed_iterator_t<_Range>, _Out>
 311       operator()(_Range&& __r, _Out __result) const
 312       {
 313         return (*this)(ranges::begin(__r), ranges::end(__r),
 314                        std::move(__result));
 315       }
 316   };
 317
 318   inline constexpr __copy_fn copy{};
 319
 320   struct __move_fn
 321   {
 322     template<input_iterator _Iter, sentinel_for<_Iter> _Sent,
 323              weakly_incrementable _Out>
 324       requires indirectly_movable<_Iter, _Out>
 325       constexpr move_result<_Iter, _Out>
 326       operator()(_Iter __first, _Sent __last, _Out __result) const
 327       {
 328         return ranges::__copy_or_move<true>(std::move(__first),
 329                                             std::move(__last),
 330                                             std::move(__result));
 331       }
 332
 333     template<input_range _Range, weakly_incrementable _Out>
 334       requires indirectly_movable<iterator_t<_Range>, _Out>
 335       constexpr move_result<borrowed_iterator_t<_Range>, _Out>
 336       operator()(_Range&& __r, _Out __result) const
 337       {
 338         return (*this)(ranges::begin(__r), ranges::end(__r),
 339                        std::move(__result));
 340       }
 341   };
 342
 343   inline constexpr __move_fn move{};
 344
 345   template<bool _IsMove,
 346            bidirectional_iterator _Iter, sentinel_for<_Iter> _Sent,
 347            bidirectional_iterator _Out>
 348     requires (_IsMove
 349               ? indirectly_movable<_Iter, _Out>
 350               : indirectly_copyable<_Iter, _Out>)
 351     constexpr __conditional_t<_IsMove,
 352                               move_backward_result<_Iter, _Out>,
 353                               copy_backward_result<_Iter, _Out>>
 354     __copy_or_move_backward(_Iter __first, _Sent __last, _Out __result)
 355     {
 356       // TODO: implement more specializations to be at least on par with
 357       // std::copy_backward/std::move_backward.
 358       using __detail::__is_reverse_iterator;
 359       using __detail::__is_normal_iterator;
 360       if constexpr (__is_reverse_iterator<_Iter> && same_as<_Iter, _Sent>
 361                     && __is_reverse_iterator<_Out>)
 362         {
 363           auto [__in,__out]
 364             = ranges::__copy_or_move<_IsMove>(std::move(__last).base(),
 365                                               std::move(__first).base(),
 366                                               std::move(__result).base());
 367           return {reverse_iterator{std::move(__in)},
 368                   reverse_iterator{std::move(__out)}};
 369         }
 370       else if constexpr (__is_normal_iterator<_Iter> && same_as<_Iter, _Sent>)
 371         {
 372           auto [__in,__out]
 373             = ranges::__copy_or_move_backward<_IsMove>(__first.base(),
 374                                                        __last.base(),
 375                                                        std::move(__result));
 376           return {decltype(__first){__in}, std::move(__out)};
 377         }
 378       else if constexpr (__is_normal_iterator<_Out>)
 379         {
 380           auto [__in,__out]
 381             = ranges::__copy_or_move_backward<_IsMove>(std::move(__first),
 382                                                        std::move(__last),
 383                                                        __result.base());
 384           return {std::move(__in), decltype(__result){__out}};
 385         }
 386       else if constexpr (sized_sentinel_for<_Sent, _Iter>)
 387         {
 388           if (!std::__is_constant_evaluated())
 389             {
 390               if constexpr (__memcpyable<_Out, _Iter>::__value)
 391                 {
 392                   using _ValueTypeI = iter_value_t<_Iter>;
 393                   static_assert(_IsMove
 394                       ? is_move_assignable_v<_ValueTypeI>
 395                       : is_copy_assignable_v<_ValueTypeI>);
 396                   auto __num = __last - __first;
 397                   if (__num)
 398                     __builtin_memmove(__result - __num, __first,
 399                                       sizeof(_ValueTypeI) * __num);
 400                   return {__first + __num, __result - __num};
 401                 }
 402             }
 403
 404           auto __lasti = ranges::next(__first, __last);
 405           auto __tail = __lasti;
 406
 407           for (auto __n = __last - __first; __n > 0; --__n)
 408             {
 409               --__tail;
 410               --__result;
 411               if constexpr (_IsMove)
 412                 *__result = std::move(*__tail);
 413               else
 414                 *__result = *__tail;
 415             }
 416           return {std::move(__lasti), std::move(__result)};
 417         }
 418       else
 419         {
 420           auto __lasti = ranges::next(__first, __last);
 421           auto __tail = __lasti;
 422
 423           while (__first != __tail)
 424             {
 425               --__tail;
 426               --__result;
 427               if constexpr (_IsMove)
 428                 *__result = std::move(*__tail);
 429               else
 430                 *__result = *__tail;
 431             }
 432           return {std::move(__lasti), std::move(__result)};
 433         }
 434     }
 435
 436   struct __copy_backward_fn
 437   {
 438     template<bidirectional_iterator _Iter1, sentinel_for<_Iter1> _Sent1,
 439              bidirectional_iterator _Iter2>
 440       requires indirectly_copyable<_Iter1, _Iter2>
 441       constexpr copy_backward_result<_Iter1, _Iter2>
 442       operator()(_Iter1 __first, _Sent1 __last, _Iter2 __result) const
 443       {
 444         return ranges::__copy_or_move_backward<false>(std::move(__first),
 445                                                       std::move(__last),
 446                                                       std::move(__result));
 447       }
 448
 449     template<bidirectional_range _Range, bidirectional_iterator _Iter>
 450       requires indirectly_copyable<iterator_t<_Range>, _Iter>
 451       constexpr copy_backward_result<borrowed_iterator_t<_Range>, _Iter>
 452       operator()(_Range&& __r, _Iter __result) const
 453       {
 454         return (*this)(ranges::begin(__r), ranges::end(__r),
 455                        std::move(__result));
 456       }
 457   };
 458
 459   inline constexpr __copy_backward_fn copy_backward{};
 460
 461   struct __move_backward_fn
 462   {
 463     template<bidirectional_iterator _Iter1, sentinel_for<_Iter1> _Sent1,
 464              bidirectional_iterator _Iter2>
 465       requires indirectly_movable<_Iter1, _Iter2>
 466       constexpr move_backward_result<_Iter1, _Iter2>
 467       operator()(_Iter1 __first, _Sent1 __last, _Iter2 __result) const
 468       {
 469         return ranges::__copy_or_move_backward<true>(std::move(__first),
 470                                                      std::move(__last),
 471                                                      std::move(__result));
 472       }
 473
 474     template<bidirectional_range _Range, bidirectional_iterator _Iter>
 475       requires indirectly_movable<iterator_t<_Range>, _Iter>
 476       constexpr move_backward_result<borrowed_iterator_t<_Range>, _Iter>
 477       operator()(_Range&& __r, _Iter __result) const
 478       {
 479         return (*this)(ranges::begin(__r), ranges::end(__r),
 480                        std::move(__result));
 481       }
 482   };
 483
 484   inline constexpr __move_backward_fn move_backward{};
 485
 486   template<typename _Iter, typename _Out>
 487     using copy_n_result = in_out_result<_Iter, _Out>;
 488
 489   struct __copy_n_fn
 490   {
 491     template<input_iterator _Iter, weakly_incrementable _Out>
 492       requires indirectly_copyable<_Iter, _Out>
 493       constexpr copy_n_result<_Iter, _Out>
 494       operator()(_Iter __first, iter_difference_t<_Iter> __n,
 495                  _Out __result) const
 496       {
 497         if constexpr (random_access_iterator<_Iter>)
 498           {
 499             if (__n > 0)
 500               return ranges::copy(__first, __first + __n, std::move(__result));
 501           }
 502         else
 503           {
 504             for (; __n > 0; --__n, (void)++__result, (void)++__first)
 505               *__result = *__first;
 506           }
 507         return {std::move(__first), std::move(__result)};
 508       }
 509   };
 510
 511   inline constexpr __copy_n_fn copy_n{};
 512
 513   struct __fill_n_fn
 514   {
 515     template<typename _Tp, output_iterator<const _Tp&> _Out>
 516       constexpr _Out
 517       operator()(_Out __first, iter_difference_t<_Out> __n,
 518                  const _Tp& __value) const
 519       {
 520         // TODO: implement more specializations to be at least on par with
 521         // std::fill_n
 522         if (__n <= 0)
 523           return __first;
 524
 525         if constexpr (is_scalar_v<_Tp>)
 526           {
 527             // TODO: Generalize this optimization to contiguous iterators.
 528             if constexpr (is_pointer_v<_Out>
 529                           // Note that __is_byte already implies !is_volatile.
 530                           && __is_byte<remove_pointer_t<_Out>>::__value
 531                           && integral<_Tp>)
 532               {
 533                 if (!std::__is_constant_evaluated())
 534                   {
 535                     __builtin_memset(__first,
 536                                      static_cast<unsigned char>(__value),
 537                                      __n);
 538                     return __first + __n;
 539                   }
 540               }
 541
 542             const auto __tmp = __value;
 543             for (; __n > 0; --__n, (void)++__first)
 544               *__first = __tmp;
 545             return __first;
 546           }
 547         else
 548           {
 549             for (; __n > 0; --__n, (void)++__first)
 550               *__first = __value;
 551             return __first;
 552           }
 553       }
 554   };
 555
 556   inline constexpr __fill_n_fn fill_n{};
 557
 558   struct __fill_fn
 559   {
 560     template<typename _Tp,
 561              output_iterator<const _Tp&> _Out, sentinel_for<_Out> _Sent>
 562       constexpr _Out
 563       operator()(_Out __first, _Sent __last, const _Tp& __value) const
 564       {
 565         // TODO: implement more specializations to be at least on par with
 566         // std::fill
 567         if constexpr (sized_sentinel_for<_Sent, _Out>)
 568           {
 569             const auto __len = __last - __first;
 570             return ranges::fill_n(__first, __len, __value);
 571           }
 572         else if constexpr (is_scalar_v<_Tp>)
 573           {
 574             const auto __tmp = __value;
 575             for (; __first != __last; ++__first)
 576               *__first = __tmp;
 577             return __first;
 578           }
 579         else
 580           {
 581             for (; __first != __last; ++__first)
 582               *__first = __value;
 583             return __first;
 584           }
 585       }
 586
 587     template<typename _Tp, output_range<const _Tp&> _Range>
 588       constexpr borrowed_iterator_t<_Range>
 589       operator()(_Range&& __r, const _Tp& __value) const
 590       {
 591         return (*this)(ranges::begin(__r), ranges::end(__r), __value);
 592       }
 593   };
 594
 595   inline constexpr __fill_fn fill{};
 596 }
 597 _GLIBCXX_END_NAMESPACE_VERSION
 598 } // namespace std
 599 #endif // concepts
 600 #endif // C++20
 601 #endif // _RANGES_ALGOBASE_H