SeqAn3  3.0.2
The Modern C++ library for sequence analysis.
enforce_random_access.hpp
Go to the documentation of this file.
1 // -----------------------------------------------------------------------------------------------------
2 // Copyright (c) 2006-2020, Knut Reinert & Freie Universität Berlin
3 // Copyright (c) 2016-2020, Knut Reinert & MPI für molekulare Genetik
4 // This file may be used, modified and/or redistributed under the terms of the 3-clause BSD-License
5 // shipped with this file and also available at: https://github.com/seqan/seqan3/blob/master/LICENSE.md
6 // -----------------------------------------------------------------------------------------------------
7 
13 #pragma once
14 
17 #include <seqan3/range/concept.hpp>
18 #include <seqan3/std/iterator>
19 #include <seqan3/std/ranges>
20 
21 namespace seqan3::detail
22 {
23 
24 // ============================================================================
25 // view_pseudo_random_access
26 // ============================================================================
27 
39 template <std::ranges::view urng_t>
43 class view_enforce_random_access : public std::ranges::view_interface<view_enforce_random_access<urng_t>>
44 {
45 private:
46 
47  // Iterator declaration.
48  template <typename underlying_iter_t>
49  class basic_iterator;
50 
51 public:
52 
56  constexpr view_enforce_random_access() = default;
57  constexpr view_enforce_random_access(view_enforce_random_access const &) = default;
58  constexpr view_enforce_random_access(view_enforce_random_access &&) = default;
59  constexpr view_enforce_random_access & operator=(view_enforce_random_access const &) = default;
60  constexpr view_enforce_random_access & operator=(view_enforce_random_access &&) = default;
61  ~view_enforce_random_access() = default;
62 
64  explicit constexpr view_enforce_random_access(urng_t range) : urng{std::move(range)}
65  {}
66 
68  template <typename viewable_rng_t>
70  requires (!std::same_as<std::remove_cvref_t<viewable_rng_t>, view_enforce_random_access>) &&
71  std::ranges::viewable_range<viewable_rng_t> &&
72  std::constructible_from<urng_t, std::ranges::ref_view<std::remove_reference_t<viewable_rng_t>>>
74  explicit constexpr view_enforce_random_access(viewable_rng_t range) :
75  view_enforce_random_access{std::views::all(range)}
76  {}
78 
82  constexpr auto begin() noexcept
84  {
85  return basic_iterator<decltype(std::ranges::begin(urng))>{std::ranges::begin(urng)};
86  }
87 
89  constexpr auto begin() const noexcept
91  requires const_iterable_range<urng_t>
93  {
94  return basic_iterator<decltype(std::ranges::cbegin(urng))>{std::ranges::cbegin(urng)};
95  }
96 
105  constexpr auto end() noexcept
106  {
107  if constexpr (std::ranges::common_range<urng_t>)
108  return basic_iterator<decltype(std::ranges::end(urng))>{std::ranges::end(urng)};
109  else
110  return urng.end();
111  }
112 
114  constexpr auto end() const noexcept
116  requires const_iterable_range<urng_t>
118  {
119  if constexpr (std::ranges::common_range<urng_t>)
120  return basic_iterator<decltype(std::ranges::cend(urng))>{std::ranges::cend(urng)};
121  else
122  return std::ranges::cend(urng);
123  }
125 
126  urng_t urng;
127 };
128 
137 template <std::ranges::view urng_t>
141 template <typename underlying_iter_t>
142 class view_enforce_random_access<urng_t>::basic_iterator :
143  public inherited_iterator_base<basic_iterator<underlying_iter_t>, underlying_iter_t>
144 {
145 private:
147  using base_t = inherited_iterator_base<basic_iterator<underlying_iter_t>, underlying_iter_t>;
148 
149 public:
150 
152  using iterator_category = std::random_access_iterator_tag;
154  using iterator_concept = iterator_category;
155 
159  // Importing base's constructors.
160  using base_t::base_t;
162  constexpr basic_iterator() = default;
164  constexpr basic_iterator(basic_iterator const &) = default;
166  constexpr basic_iterator(basic_iterator &&) = default;
168  constexpr basic_iterator & operator=(basic_iterator const &) = default;
170  constexpr basic_iterator & operator=(basic_iterator &&) = default;
172  ~basic_iterator() = default;
174 
179  // Importing base's equality operators
180  using base_t::operator==;
181  using base_t::operator!=;
183  friend constexpr bool operator==(basic_iterator const & lhs, std::ranges::sentinel_t<urng_t> const & rhs)
184  noexcept(noexcept(std::declval<underlying_iter_t const &>() ==
185  std::declval<std::ranges::sentinel_t<urng_t> const &>()))
186  {
187  return static_cast<underlying_iter_t const &>(lhs) == rhs;
188  }
189 
191  friend constexpr bool operator==(std::ranges::sentinel_t<urng_t> const & lhs, basic_iterator const & rhs)
192  noexcept(noexcept(std::declval<underlying_iter_t const &>() ==
193  std::declval<std::ranges::sentinel_t<urng_t> const &>()))
194  {
195  return rhs == lhs;
196  }
197 
199  friend constexpr bool operator!=(basic_iterator const & lhs, std::ranges::sentinel_t<urng_t> const & rhs)
200  noexcept(noexcept(std::declval<underlying_iter_t const &>() !=
201  std::declval<std::ranges::sentinel_t<urng_t> const &>()))
202  {
203  return !(lhs == rhs);
204  }
205 
207  friend constexpr bool operator!=(std::ranges::sentinel_t<urng_t> const & lhs, basic_iterator const & rhs)
208  noexcept(noexcept(std::declval<underlying_iter_t const &>() !=
209  std::declval<std::ranges::sentinel_t<urng_t> const &>()))
210  {
211  return rhs != lhs;
212  }
214 
218  // Import operator from base.
219  using base_t::operator-;
220 
222  constexpr typename base_t::difference_type operator-(std::ranges::sentinel_t<urng_t> const & rhs) const
223  noexcept(noexcept(std::declval<underlying_iter_t const &>() -
224  std::declval<std::ranges::sentinel_t<urng_t> const &>()))
225  requires std::sized_sentinel_for<std::ranges::sentinel_t<urng_t>, underlying_iter_t>
226  {
227  return static_cast<underlying_iter_t const &>(*this) - rhs;
228  }
229 
231  constexpr friend typename base_t::difference_type operator-(std::ranges::sentinel_t<urng_t> const & lhs,
232  basic_iterator const & rhs)
233  noexcept(noexcept(std::declval<std::ranges::sentinel_t<urng_t> const &>() -
234  std::declval<underlying_iter_t const &>()))
235  requires std::sized_sentinel_for<std::ranges::sentinel_t<urng_t>, underlying_iter_t>
236  {
237  return lhs - static_cast<underlying_iter_t const &>(rhs);
238  }
240 };
241 
246 template <std::ranges::viewable_range rng_t>
248 view_enforce_random_access(rng_t &&) -> view_enforce_random_access<std::views::all_t<rng_t>>;
250 
251 // ============================================================================
252 // pseudo_random_access_fn (adaptor definition)
253 // ============================================================================
254 
256 struct pseudo_random_access_fn : public adaptor_base<pseudo_random_access_fn>
257 {
258 private:
260  using base_t = adaptor_base<pseudo_random_access_fn>;
261 
262 public:
264  using base_t::base_t;
265 
266 private:
268  friend base_t;
269 
273  template <std::ranges::viewable_range urng_t>
274  static constexpr auto impl(urng_t && urange)
275  {
276  static_assert(std::ranges::random_access_range<urng_t> || pseudo_random_access_range<urng_t>,
277  "The adapted range must either model std::ranges::random_access_range or must be "
278  "a specific SeqAn range type that supports pseudo random access.");
279  static_assert(std::ranges::forward_range<urng_t>,
280  "The underlying range must model std::ranges::forward_range.");
281 
282  if constexpr (std::ranges::random_access_range<urng_t>)
283  { // Nothing to do, just return as ref_view or original view.
284  return std::views::all(std::forward<urng_t>(urange));
285  }
286  else
287  { // Get a subrange using the random access iterators of the container.
288  return view_enforce_random_access{std::forward<urng_t>(urange)};
289  }
290  }
291 };
292 
293 } // namespace seqan3::detail
294 
295 namespace seqan3::views
296 {
297 
368 inline constexpr auto enforce_random_access = detail::pseudo_random_access_fn{};
370 } // namespace seqan3::views
seqan3::views
The SeqAn namespace for views.
Definition: view_iota_simd.hpp:218
std::rel_ops::operator!=
T operator!=(T... args)
iterator
Provides C++20 additions to the <iterator> header.
std::random_access_iterator_tag
concept.hpp
Additional non-standard concepts for ranges.
seqan3::views::move
auto const move
A view that turns lvalue-references into rvalue-references.
Definition: move.hpp:68
const_iterable_range
Specifies requirements of an input range type for which the const version of that type satisfies the ...
seqan3::views::enforce_random_access
constexpr auto enforce_random_access
A view adaptor that converts a pseudo random access range to a std::random_access_range.
Definition: enforce_random_access.hpp:368
pseudo_random_access_range
This concept checks if a type models a pseudo random access range.
ranges
Adaptations of concepts from the Ranges TS.
std::begin
T begin(T... args)
std
SeqAn specific customisations in the standard namespace.
std::remove_cvref_t
std::end
T end(T... args)
inherited_iterator_base.hpp
Provides the seqan3::detail::inherited_iterator_base template.
detail.hpp
Auxiliary header for the views submodule .
std::declval
T declval(T... args)