SeqAn3  3.1.0
The Modern C++ library for sequence analysis.
algorithm_result_generator_range.hpp
Go to the documentation of this file.
1 // -----------------------------------------------------------------------------------------------------
2 // Copyright (c) 2006-2021, Knut Reinert & Freie Universität Berlin
3 // Copyright (c) 2016-2021, 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 
15 #include <seqan3/std/concepts>
16 #include <seqan3/std/ranges>
17 
18 #include <seqan3/core/platform.hpp>
19 
20 namespace seqan3
21 {
22 
44 template <typename algorithm_executor_type>
46 {
47  static_assert(!std::is_const_v<algorithm_executor_type>,
48  "Cannot create an algorithm stream over a const buffer.");
49 
51  using optional_type = decltype(std::declval<algorithm_executor_type>().next_result());
53  using algorithm_result_type = typename optional_type::value_type;
54 
56 
59 
60 public:
70 
72  explicit algorithm_result_generator_range(algorithm_executor_type const & algorithm_executor) = delete;
73 
82  explicit algorithm_result_generator_range(algorithm_executor_type && algorithm_executor) :
83  algorithm_executor_ptr{std::make_unique<algorithm_executor_type>(std::move(algorithm_executor))}
84  {}
86 
99  {
100  return algorithm_range_iterator{*this};
101  }
102 
104  algorithm_range_iterator begin() const = delete;
105 
114  constexpr std::default_sentinel_t end() noexcept
115  {
116  return std::default_sentinel;
117  }
118 
120  constexpr std::default_sentinel_t end() const = delete;
122 
123 protected:
132  bool next()
133  {
134  if (!algorithm_executor_ptr)
135  throw std::runtime_error{"No algorithm execution buffer available."};
136 
137  if (auto opt = algorithm_executor_ptr->next_result(); opt.has_value())
138  {
139  cache = std::move(*opt);
140  return true;
141  }
142 
143  return false;
144  }
145 
146 private:
148  std::unique_ptr<algorithm_executor_type> algorithm_executor_ptr{};
150  algorithm_result_type cache{};
151 };
152 
159 template <typename algorithm_executor_type>
160 algorithm_result_generator_range(algorithm_executor_type &&)
163 
167 template <typename algorithm_executor_type>
169 {
170 public:
177  using value_type = algorithm_result_type;
185 
189  constexpr algorithm_range_iterator() noexcept = default;
190  constexpr algorithm_range_iterator(algorithm_range_iterator const &) noexcept = default;
191  constexpr algorithm_range_iterator(algorithm_range_iterator &&) noexcept = default;
192  constexpr algorithm_range_iterator & operator=(algorithm_range_iterator const &) noexcept = default;
193  constexpr algorithm_range_iterator & operator=(algorithm_range_iterator &&) noexcept = default;
195 
197  explicit constexpr algorithm_range_iterator(algorithm_result_generator_range & range) : range_ptr(std::addressof(range))
198  {
199  ++(*this); // Fetch the next element.
200  }
202 
211  reference operator*() const noexcept
212  {
213  return range_ptr->cache;
214  }
215 
217  pointer operator->() const noexcept
218  {
219  return &range_ptr->cache;
220  }
222 
228  {
229  assert(range_ptr != nullptr);
230 
231  at_end = !range_ptr->next();
232  return *this;
233  }
234 
236  void operator++(int /*post*/)
237  {
238  ++(*this);
239  }
241 
246  friend constexpr bool operator==(algorithm_range_iterator const & lhs,
247  std::default_sentinel_t const &) noexcept
248  {
249  return lhs.at_end;
250  }
251 
253  friend constexpr bool operator==(std::default_sentinel_t const & lhs,
254  algorithm_range_iterator const & rhs) noexcept
255  {
256  return rhs == lhs;
257  }
258 
260  friend constexpr bool operator!=(algorithm_range_iterator const & lhs,
261  std::default_sentinel_t const & rhs) noexcept
262  {
263  return !(lhs == rhs);
264  }
265 
267  friend constexpr bool operator!=(std::default_sentinel_t const & lhs,
268  algorithm_range_iterator const & rhs) noexcept
269  {
270  return rhs != lhs;
271  }
273 
274 private:
276  algorithm_result_generator_range * range_ptr{};
278  bool at_end{true};
279 };
280 
281 } // namespace seqan3
The iterator of seqan3::detail::algorithm_result_generator_range.
Definition: algorithm_result_generator_range.hpp:169
constexpr algorithm_range_iterator() noexcept=default
Defaulted.
void operator++(int)
Returns an iterator incremented by one.
Definition: algorithm_result_generator_range.hpp:236
algorithm_range_iterator & operator++()
Increments the iterator by one.
Definition: algorithm_result_generator_range.hpp:227
reference operator*() const noexcept
Access the pointed-to element.
Definition: algorithm_result_generator_range.hpp:211
constexpr friend bool operator==(algorithm_range_iterator const &lhs, std::default_sentinel_t const &) noexcept
Checks whether lhs is equal to the sentinel.
Definition: algorithm_result_generator_range.hpp:246
constexpr friend bool operator!=(algorithm_range_iterator const &lhs, std::default_sentinel_t const &rhs) noexcept
Checks whether *this is not equal to the sentinel.
Definition: algorithm_result_generator_range.hpp:260
algorithm_result_type value_type
Value type of container elements.
Definition: algorithm_result_generator_range.hpp:177
constexpr friend bool operator==(std::default_sentinel_t const &lhs, algorithm_range_iterator const &rhs) noexcept
Checks whether lhs is equal to rhs.
Definition: algorithm_result_generator_range.hpp:253
constexpr friend bool operator!=(std::default_sentinel_t const &lhs, algorithm_range_iterator const &rhs) noexcept
Checks whether lhs is not equal to rhs.
Definition: algorithm_result_generator_range.hpp:267
pointer operator->() const noexcept
Returns a pointer to the current algorithm result.
Definition: algorithm_result_generator_range.hpp:217
An input range over the algorithm results generated by the underlying algorithm executor.
Definition: algorithm_result_generator_range.hpp:46
constexpr std::default_sentinel_t end() noexcept
Returns a sentinel signaling the end of the algorithm range.
Definition: algorithm_result_generator_range.hpp:114
constexpr std::default_sentinel_t end() const =delete
This range is not const-iterable.
algorithm_result_generator_range(algorithm_executor_type const &algorithm_executor)=delete
Explicit deletion to forbid copy construction of the underlying executor.
algorithm_result_generator_range(algorithm_result_generator_range &&)=default
Defaulted.
algorithm_result_generator_range & operator=(algorithm_result_generator_range const &)=delete
This is a move-only type.
algorithm_result_generator_range(algorithm_result_generator_range const &)=delete
This is a move-only type.
bool next()
Receives the next algorithm result from the executor buffer.
Definition: algorithm_result_generator_range.hpp:132
algorithm_range_iterator begin() const =delete
This range is not const-iterable.
algorithm_result_generator_range()=default
Defaulted.
constexpr algorithm_range_iterator begin()
Returns an iterator to the first element of the algorithm range.
Definition: algorithm_result_generator_range.hpp:98
algorithm_result_generator_range(algorithm_executor_type &&) -> algorithm_result_generator_range< std::remove_reference_t< algorithm_executor_type >>
Deduces from the passed algorithm_executor_type.
algorithm_result_generator_range(algorithm_executor_type &&algorithm_executor)
Constructs a new algorithm range by taking ownership over the passed algorithm buffer.
Definition: algorithm_result_generator_range.hpp:82
algorithm_result_generator_range & operator=(algorithm_result_generator_range &&)=default
Defaulted.
~algorithm_result_generator_range()=default
Defaulted.
The <concepts> header from C++20's standard library.
The main SeqAn3 namespace.
Definition: aligned_sequence_concept.hpp:29
SeqAn specific customisations in the standard namespace.
Provides platform and dependency checks.
The <ranges> header from C++20's standard library.