SeqAn3  3.2.0-rc.1
The Modern C++ library for sequence analysis.
algorithm_result_generator_range.hpp
Go to the documentation of this file.
1 // -----------------------------------------------------------------------------------------------------
2 // Copyright (c) 2006-2022, Knut Reinert & Freie Universität Berlin
3 // Copyright (c) 2016-2022, 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 <concepts>
16 #include <memory>
17 #include <ranges>
18 
19 #include <seqan3/core/platform.hpp>
20 
21 namespace seqan3
22 {
23 
45 template <typename algorithm_executor_type>
47 {
48  static_assert(!std::is_const_v<algorithm_executor_type>, "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:
71 
73  explicit algorithm_result_generator_range(algorithm_executor_type const & algorithm_executor) = delete;
74 
83  explicit algorithm_result_generator_range(algorithm_executor_type && algorithm_executor) :
84  algorithm_executor_ptr{std::make_unique<algorithm_executor_type>(std::move(algorithm_executor))}
85  {}
87 
100  {
101  return algorithm_range_iterator{*this};
102  }
103 
105  algorithm_range_iterator begin() const = delete;
106 
115  constexpr std::default_sentinel_t end() noexcept
116  {
117  return std::default_sentinel;
118  }
119 
121  constexpr std::default_sentinel_t end() const = delete;
123 
124 protected:
133  bool next()
134  {
135  if (!algorithm_executor_ptr)
136  throw std::runtime_error{"No algorithm execution buffer available."};
137 
138  if (auto opt = algorithm_executor_ptr->next_result(); opt.has_value())
139  {
140  cache = std::move(*opt);
141  return true;
142  }
143 
144  return false;
145  }
146 
147 private:
149  std::unique_ptr<algorithm_executor_type> algorithm_executor_ptr{};
151  algorithm_result_type cache{};
152 };
153 
160 template <typename algorithm_executor_type>
161 algorithm_result_generator_range(algorithm_executor_type &&)
164 
168 template <typename algorithm_executor_type>
170 {
171 public:
178  using value_type = algorithm_result_type;
186 
190  constexpr algorithm_range_iterator() noexcept = default;
191  constexpr algorithm_range_iterator(algorithm_range_iterator const &) noexcept = default;
192  constexpr algorithm_range_iterator(algorithm_range_iterator &&) noexcept = default;
193  constexpr algorithm_range_iterator & operator=(algorithm_range_iterator const &) noexcept = default;
194  constexpr algorithm_range_iterator & operator=(algorithm_range_iterator &&) noexcept = default;
196 
199  range_ptr(std::addressof(range))
200  {
201  ++(*this); // Fetch the next element.
202  }
204 
213  reference operator*() const noexcept
214  {
215  return range_ptr->cache;
216  }
217 
219  pointer operator->() const noexcept
220  {
221  return &range_ptr->cache;
222  }
224 
230  {
231  assert(range_ptr != nullptr);
232 
233  at_end = !range_ptr->next();
234  return *this;
235  }
236 
238  void operator++(int /*post*/)
239  {
240  ++(*this);
241  }
243 
248  friend constexpr bool operator==(algorithm_range_iterator const & lhs, std::default_sentinel_t const &) noexcept
249  {
250  return lhs.at_end;
251  }
252 
254  friend constexpr bool operator==(std::default_sentinel_t const & lhs, algorithm_range_iterator const & rhs) noexcept
255  {
256  return rhs == lhs;
257  }
258 
260  friend constexpr bool operator!=(algorithm_range_iterator const & lhs, std::default_sentinel_t const & rhs) noexcept
261  {
262  return !(lhs == rhs);
263  }
264 
266  friend constexpr bool operator!=(std::default_sentinel_t const & lhs, algorithm_range_iterator const & rhs) noexcept
267  {
268  return rhs != lhs;
269  }
271 
272 private:
274  algorithm_result_generator_range * range_ptr{};
276  bool at_end{true};
277 };
278 
279 } // namespace seqan3
The iterator of seqan3::detail::algorithm_result_generator_range.
Definition: algorithm_result_generator_range.hpp:170
constexpr algorithm_range_iterator() noexcept=default
Defaulted.
void operator++(int)
Returns an iterator incremented by one.
Definition: algorithm_result_generator_range.hpp:238
algorithm_range_iterator & operator++()
Increments the iterator by one.
Definition: algorithm_result_generator_range.hpp:229
reference operator*() const noexcept
Access the pointed-to element.
Definition: algorithm_result_generator_range.hpp:213
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:248
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:178
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:254
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:266
pointer operator->() const noexcept
Returns a pointer to the current algorithm result.
Definition: algorithm_result_generator_range.hpp:219
An input range over the algorithm results generated by the underlying algorithm executor.
Definition: algorithm_result_generator_range.hpp:47
constexpr std::default_sentinel_t end() noexcept
Returns a sentinel signaling the end of the algorithm range.
Definition: algorithm_result_generator_range.hpp:115
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:133
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:99
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:83
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.