From Jason Turner

[range.elements.view]

C++20 → C++23 2.8 KB 31 lines
Current Draft | LaTeX Source
Archived: C++20 | C++23
Markdown: C++20 | C++23
Explore in Adventure Game

Diff to HTML by rtfpessoa

Files changed (1) hide show
  1. tmp/tmpvpf_c2z0/{from.md → to.md} +14 -13
tmp/tmpvpf_c2z0/{from.md → to.md} RENAMED
@@ -2,39 +2,38 @@
2
 
3
  ``` cpp
4
  namespace std::ranges {
5
  template<class T, size_t N>
6
  concept has-tuple-element = // exposition only
7
- requires(T t) {
8
- typename tuple_size<T>::type;
9
- requires N < tuple_size_v<T>;
10
- typename tuple_element_t<N, T>;
11
- { get<N>(t) } -> convertible_to<const tuple_element_t<N, T>&>;
12
- };
13
 
 
 
 
14
 
15
  template<input_range V, size_t N>
16
  requires view<V> && has-tuple-element<range_value_t<V>, N> &&
17
- has-tuple-element<remove_reference_t<range_reference_t<V>>, N>
 
18
  class elements_view : public view_interface<elements_view<V, N>> {
19
  public:
20
- elements_view() = default;
21
  constexpr explicit elements_view(V base);
22
 
23
  constexpr V base() const & requires copy_constructible<V> { return base_; }
24
  constexpr V base() && { return std::move(base_); }
25
 
26
  constexpr auto begin() requires (!simple-view<V>)
27
  { return iterator<false>(ranges::begin(base_)); }
28
 
29
- constexpr auto begin() const requires simple-view<V>
30
  { return iterator<true>(ranges::begin(base_)); }
31
 
32
- constexpr auto end()
33
  { return sentinel<false>{ranges::end(base_)}; }
34
 
35
- constexpr auto end() requires common_range<V>
36
  { return iterator<false>{ranges::end(base_)}; }
37
 
38
  constexpr auto end() const requires range<const V>
39
  { return sentinel<true>{ranges::end(base_)}; }
40
 
@@ -47,13 +46,15 @@ namespace std::ranges {
47
  constexpr auto size() const requires sized_range<const V>
48
  { return ranges::size(base_); }
49
 
50
  private:
51
  // [range.elements.iterator], class template elements_view::iterator
52
- template<bool> struct iterator; // exposition only
 
53
  // [range.elements.sentinel], class template elements_view::sentinel
54
- template<bool> struct sentinel; // exposition only
 
55
  V base_ = V(); // exposition only
56
  };
57
  }
58
  ```
59
 
 
2
 
3
  ``` cpp
4
  namespace std::ranges {
5
  template<class T, size_t N>
6
  concept has-tuple-element = // exposition only
7
+ tuple-like<T> && N < tuple_size_v<T>;
 
 
 
 
 
8
 
9
+ template<class T, size_t N>
10
+ concept returnable-element = // exposition only
11
+ is_reference_v<T> || move_constructible<tuple_element_t<N, T>>;
12
 
13
  template<input_range V, size_t N>
14
  requires view<V> && has-tuple-element<range_value_t<V>, N> &&
15
+ has-tuple-element<remove_reference_t<range_reference_t<V>>, N> &&
16
+ returnable-element<range_reference_t<V>, N>
17
  class elements_view : public view_interface<elements_view<V, N>> {
18
  public:
19
+ elements_view() requires default_initializable<V> = default;
20
  constexpr explicit elements_view(V base);
21
 
22
  constexpr V base() const & requires copy_constructible<V> { return base_; }
23
  constexpr V base() && { return std::move(base_); }
24
 
25
  constexpr auto begin() requires (!simple-view<V>)
26
  { return iterator<false>(ranges::begin(base_)); }
27
 
28
+ constexpr auto begin() const requires range<const V>
29
  { return iterator<true>(ranges::begin(base_)); }
30
 
31
+ constexpr auto end() requires (!simple-view<V> && !common_range<V>)
32
  { return sentinel<false>{ranges::end(base_)}; }
33
 
34
+ constexpr auto end() requires (!simple-view<V> && common_range<V>)
35
  { return iterator<false>{ranges::end(base_)}; }
36
 
37
  constexpr auto end() const requires range<const V>
38
  { return sentinel<true>{ranges::end(base_)}; }
39
 
 
46
  constexpr auto size() const requires sized_range<const V>
47
  { return ranges::size(base_); }
48
 
49
  private:
50
  // [range.elements.iterator], class template elements_view::iterator
51
+ template<bool> class iterator; // exposition only
52
+
53
  // [range.elements.sentinel], class template elements_view::sentinel
54
+ template<bool> class sentinel; // exposition only
55
+
56
  V base_ = V(); // exposition only
57
  };
58
  }
59
  ```
60