libcxx/modules/std/ranges.inc

   1 // -*- C++ -*-
   2 //===----------------------------------------------------------------------===//
   3 //
   4 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
   5 // See https://llvm.org/LICENSE.txt for license information.
   6 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
   7 //
   8 //===----------------------------------------------------------------------===//
   9
  10 export namespace std {
  11   namespace ranges {
  12     inline namespace __cpo {
  13       // [range.access], range access
  14       using std::ranges::__cpo::begin;
  15       using std::ranges::__cpo::cbegin;
  16       using std::ranges::__cpo::cend;
  17       using std::ranges::__cpo::crbegin;
  18       using std::ranges::__cpo::crend;
  19       using std::ranges::__cpo::end;
  20       using std::ranges::__cpo::rbegin;
  21       using std::ranges::__cpo::rend;
  22
  23       using std::ranges::__cpo::cdata;
  24       using std::ranges::__cpo::data;
  25       using std::ranges::__cpo::empty;
  26       using std::ranges::__cpo::size;
  27       using std::ranges::__cpo::ssize;
  28     } // namespace __cpo
  29
  30     // [range.range], ranges
  31     using std::ranges::range;
  32
  33     using std::ranges::enable_borrowed_range;
  34
  35     using std::ranges::borrowed_range;
  36
  37     // using std::ranges::const_iterator_t;
  38     // using std::ranges::const_sentinel_t;
  39     using std::ranges::iterator_t;
  40     // using std::ranges::range_const_reference_t;
  41     using std::ranges::range_common_reference_t;
  42     using std::ranges::range_difference_t;
  43     using std::ranges::range_reference_t;
  44     using std::ranges::range_rvalue_reference_t;
  45     using std::ranges::range_size_t;
  46     using std::ranges::range_value_t;
  47     using std::ranges::sentinel_t;
  48
  49     // [range.sized], sized ranges
  50     using std::ranges::disable_sized_range;
  51     using std::ranges::sized_range;
  52
  53     // [range.view], views
  54     using std::ranges::enable_view;
  55     using std::ranges::view;
  56     using std::ranges::view_base;
  57
  58     // [range.refinements], other range refinements
  59     using std::ranges::bidirectional_range;
  60     using std::ranges::common_range;
  61     // using std::ranges::constant_range;
  62     using std::ranges::contiguous_range;
  63     using std::ranges::forward_range;
  64     using std::ranges::input_range;
  65     using std::ranges::output_range;
  66     using std::ranges::random_access_range;
  67     using std::ranges::viewable_range;
  68
  69     // [view.interface], class template view_interface
  70     using std::ranges::view_interface;
  71
  72     // [range.subrange], sub-ranges
  73     using std::ranges::subrange;
  74     using std::ranges::subrange_kind;
  75
  76     using std::ranges::get;
  77   } // namespace ranges
  78
  79   using std::ranges::get;
  80
  81   namespace ranges {
  82
  83     // [range.dangling], dangling iterator handling
  84     using std::ranges::dangling;
  85
  86     // [range.elementsof], class template elements_of
  87     // using std::ranges::elements_of;
  88
  89     using std::ranges::borrowed_iterator_t;
  90
  91     using std::ranges::borrowed_subrange_t;
  92
  93 #if _LIBCPP_STD_VER >= 23
  94     // [range.utility.conv], range conversions
  95     using std::ranges::to;
  96 #endif
  97
  98     // [range.empty], empty view
  99     using std::ranges::empty_view;
 100
 101     namespace views {
 102       using std::ranges::views::empty;
 103     }
 104
 105     // [range.single], single view
 106     using std::ranges::single_view;
 107
 108     namespace views {
 109       using std::ranges::views::single;
 110     } // namespace views
 111
 112     // [range.iota], iota view
 113     using std::ranges::iota_view;
 114
 115     namespace views {
 116       using std::ranges::views::iota;
 117     } // namespace views
 118
 119 #if _LIBCPP_STD_VER >= 23
 120     // [range.repeat], repeat view
 121     using std::ranges::repeat_view;
 122
 123     namespace views {
 124       using std::ranges::views::repeat;
 125     } // namespace views
 126 #endif // _LIBCPP_STD_VER >= 23
 127
 128 #ifndef _LIBCPP_HAS_NO_LOCALIZATION
 129     // [range.istream], istream view
 130     using std::ranges::basic_istream_view;
 131     using std::ranges::istream_view;
 132 #  ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
 133     using std::ranges::wistream_view;
 134 #  endif
 135
 136     namespace views {
 137       using std::ranges::views::istream;
 138     }
 139 #endif // _LIBCPP_HAS_NO_LOCALIZATION
 140
 141     // Note: This declaration not in the synopsis or explicitly in the wording.
 142     // However it is needed for the range adaptors.
 143     // [range.adaptor.object]/3
 144     //   The template parameter D for range_adaptor_closure may be an
 145     //   incomplete type. If an expression of type cv D is used as an operand
 146     //   to the | operator, D shall be complete and model
 147     //   derived_from<range_adaptor_closure<D>>. The behavior of an expression
 148     //   involving an object of type cv D as an operand to the | operator is
 149     //   undefined if overload resolution selects a program-defined operator|
 150     //   function.
 151     // This is used internally in C++20 mode.
 152     using std::ranges::operator|;
 153 #if _LIBCPP_STD_VER >= 23
 154     // [range.adaptor.object], range adaptor objects
 155     using std::ranges::range_adaptor_closure;
 156 #endif
 157
 158     // [range.all], all view
 159     namespace views {
 160       using std::ranges::views::all;
 161       using std::ranges::views::all_t;
 162     } // namespace views
 163
 164     // [range.ref.view], ref view
 165     using std::ranges::ref_view;
 166
 167     // [range.owning.view], owning view
 168     using std::ranges::owning_view;
 169
 170 #if _LIBCPP_STD_VER >= 23
 171     // [range.as.rvalue], as rvalue view
 172     using std::ranges::as_rvalue_view;
 173
 174     namespace views {
 175       using std::ranges::views::as_rvalue;
 176     } // namespace views
 177 #endif // _LIBCPP_STD_VER >= 23
 178
 179     // [range.filter], filter view
 180     using std::ranges::filter_view;
 181
 182     namespace views {
 183       using std::ranges::views::filter;
 184     } // namespace views
 185
 186     // [range.transform], transform view
 187     using std::ranges::transform_view;
 188
 189     namespace views {
 190       using std::ranges::views::transform;
 191     } // namespace views
 192
 193     // [range.take], take view
 194     using std::ranges::take_view;
 195
 196     namespace views {
 197       using std::ranges::views::take;
 198     } // namespace views
 199
 200     // [range.take.while], take while view
 201     using std::ranges::take_while_view;
 202
 203     namespace views {
 204       using std::ranges::views::take_while;
 205     } // namespace views
 206
 207     // [range.drop], drop view
 208     using std::ranges::drop_view;
 209
 210     namespace views {
 211       using std::ranges::views::drop;
 212     } // namespace views
 213
 214     // [range.drop.while], drop while view
 215     using std::ranges::drop_while_view;
 216
 217     namespace views {
 218       using std::ranges::views::drop_while;
 219     } // namespace views
 220
 221     using std::ranges::join_view;
 222
 223     namespace views {
 224       using std::ranges::views::join;
 225     } // namespace views
 226 #if 0
 227     using std::ranges::join_with_view;
 228
 229     namespace views {
 230       using std::ranges::views::join_with;
 231     } // namespace views
 232 #endif
 233     using std::ranges::lazy_split_view;
 234
 235     // [range.split], split view
 236     using std::ranges::split_view;
 237
 238     namespace views {
 239       using std::ranges::views::lazy_split;
 240       using std::ranges::views::split;
 241     } // namespace views
 242
 243     // [range.counted], counted view
 244     namespace views {
 245       using std::ranges::views::counted;
 246     } // namespace views
 247
 248     // [range.common], common view
 249     using std::ranges::common_view;
 250
 251     namespace views {
 252       using std::ranges::views::common;
 253     } // namespace views
 254
 255     // [range.reverse], reverse view
 256     using std::ranges::reverse_view;
 257
 258     namespace views {
 259       using std::ranges::views::reverse;
 260     } // namespace views
 261
 262     // [range.as.const], as const view
 263 #if 0
 264     using std::ranges::as_const_view;
 265
 266     namespace views {
 267       using std::ranges::views::as_const;
 268     } // namespace views
 269 #endif
 270     // [range.elements], elements view
 271     using std::ranges::elements_view;
 272
 273     using std::ranges::keys_view;
 274     using std::ranges::values_view;
 275
 276     namespace views {
 277       using std::ranges::views::elements;
 278       using std::ranges::views::keys;
 279       using std::ranges::views::values;
 280     } // namespace views
 281
 282 #if _LIBCPP_STD_VER >= 23
 283     // [range.zip], zip view
 284     using std::ranges::zip_view;
 285
 286     namespace views {
 287       using std::ranges::views::zip;
 288     } // namespace views
 289 #endif // _LIBCPP_STD_VER >= 23
 290
 291 #if 0
 292     // [range.zip.transform], zip transform view
 293     using std::ranges::zip_transform_view;
 294
 295     namespace views {
 296       using std::ranges::views::zip_transform;
 297     }
 298
 299     using std::ranges::adjacent_view;
 300
 301     namespace views {
 302       using std::ranges::views::adjacent;
 303       using std::ranges::views::pairwise;
 304     } // namespace views
 305
 306     using std::ranges::adjacent_transform_view;
 307
 308     namespace views {
 309       using std::ranges::views::adjacent_transform;
 310       using std::ranges::views::pairwise_transform;
 311     } // namespace views
 312
 313     using std::ranges::chunk_view;
 314
 315     using std::ranges::chunk_view<V>;
 316
 317     namespace views {
 318       using std::ranges::views::chunk;
 319     }
 320
 321     using std::ranges::slide_view;
 322
 323     namespace views {
 324       using std::ranges::views::slide;
 325     }
 326 #endif
 327
 328 #if _LIBCPP_STD_VER >= 23
 329     // [range.chunk.by], chunk by view
 330     using std::ranges::chunk_by_view;
 331
 332     namespace views {
 333       using std::ranges::views::chunk_by;
 334     }
 335 #endif // _LIBCPP_STD_VER >= 23
 336
 337 #if 0
 338     // [range.stride], stride view
 339     using std::ranges::stride_view;
 340
 341     namespace views {
 342       using std::ranges::views::stride;
 343     }
 344
 345     using std::ranges::cartesian_product_view;
 346
 347     namespace views {
 348       using std::ranges::views::cartesian_product;
 349     }
 350 #endif
 351   } // namespace ranges
 352
 353   namespace views = ranges::views;
 354
 355   using std::tuple_element;
 356   using std::tuple_size;
 357
 358 #if _LIBCPP_STD_VER >= 23
 359   using std::from_range;
 360   using std::from_range_t;
 361 #endif // _LIBCPP_STD_VER >= 23
 362 } // namespace std