algorithm_result_generator_range.hpp

Go to the documentation of this file.

// -----------------------------------------------------------------------------------------------------
// Copyright (c) 2006-2020, Knut Reinert & Freie Universität Berlin
// Copyright (c) 2016-2020, Knut Reinert & MPI für molekulare Genetik
// This file may be used, modified and/or redistributed under the terms of the 3-clause BSD-License
// shipped with this file and also available at: https://github.com/seqan/seqan3/blob/master/LICENSE.md
// -----------------------------------------------------------------------------------------------------
 
#pragma once
 
#include <seqan3/std/concepts>
#include <seqan3/std/ranges>
 
#include <seqan3/core/platform.hpp>
 
namespace seqan3
{
 
template <typename algorithm_executor_type>
class algorithm_result_generator_range
{
    static_assert(!std::is_const_v<algorithm_executor_type>,
                  "Cannot create an algorithm stream over a const buffer.");
 
    using optional_type = decltype(std::declval<algorithm_executor_type>().next_result());
    using algorithm_result_type = typename optional_type::value_type;
 
    class algorithm_range_iterator;
 
    friend class algorithm_range_iterator;
 
public:
    algorithm_result_generator_range() = default; 
    algorithm_result_generator_range(algorithm_result_generator_range const &) = delete; 
    algorithm_result_generator_range(algorithm_result_generator_range &&) = default; 
    algorithm_result_generator_range & operator=(algorithm_result_generator_range const &) = delete; 
    algorithm_result_generator_range & operator=(algorithm_result_generator_range &&) = default; 
    ~algorithm_result_generator_range() = default; 
 
    explicit algorithm_result_generator_range(algorithm_executor_type const & algorithm_executor) = delete;
 
    explicit algorithm_result_generator_range(algorithm_executor_type && algorithm_executor) :
        algorithm_executor_ptr{std::make_unique<algorithm_executor_type>(std::move(algorithm_executor))}
    {}
 
    constexpr algorithm_range_iterator begin()
    {
        return algorithm_range_iterator{*this};
    }
 
    algorithm_range_iterator begin() const = delete;
 
    constexpr std::default_sentinel_t end() noexcept
    {
        return std::default_sentinel;
    }
 
    constexpr std::default_sentinel_t end() const = delete;
 
protected:
    bool next()
    {
        if (!algorithm_executor_ptr)
            throw std::runtime_error{"No algorithm execution buffer available."};
 
        if (auto opt = algorithm_executor_ptr->next_result(); opt.has_value())
        {
            cache = std::move(*opt);
            return true;
        }
 
        return false;
    }
 
private:
    std::unique_ptr<algorithm_executor_type> algorithm_executor_ptr{};
    algorithm_result_type cache{};
};
 
template <typename algorithm_executor_type>
algorithm_result_generator_range(algorithm_executor_type &&)
    -> algorithm_result_generator_range<std::remove_reference_t<algorithm_executor_type>>;
 
template <typename algorithm_executor_type>
class algorithm_result_generator_range<algorithm_executor_type>::algorithm_range_iterator
{
public:
    using difference_type = std::ptrdiff_t;
    using value_type = algorithm_result_type;
    using reference = std::add_lvalue_reference_t<value_type>;
    using pointer = std::add_pointer_t<value_type>;
    using iterator_category = std::input_iterator_tag;
 
    constexpr algorithm_range_iterator() noexcept = default; 
    constexpr algorithm_range_iterator(algorithm_range_iterator const &) noexcept = default; 
    constexpr algorithm_range_iterator(algorithm_range_iterator &&) noexcept = default; 
    constexpr algorithm_range_iterator & operator=(algorithm_range_iterator const &) noexcept = default; 
    constexpr algorithm_range_iterator & operator=(algorithm_range_iterator &&) noexcept = default; 
    ~algorithm_range_iterator() = default; 
 
    explicit constexpr algorithm_range_iterator(algorithm_result_generator_range & range) : range_ptr(std::addressof(range))
    {
        ++(*this); // Fetch the next element.
    }
 
    reference operator*() const noexcept
    {
        return range_ptr->cache;
    }
 
    pointer operator->() const noexcept
    {
        return &range_ptr->cache;
    }
 
    algorithm_range_iterator & operator++(/*pre*/)
    {
        assert(range_ptr != nullptr);
 
        at_end = !range_ptr->next();
        return *this;
    }
 
    void operator++(int /*post*/)
    {
        ++(*this);
    }
 
    friend constexpr bool operator==(algorithm_range_iterator const & lhs,
                                     std::default_sentinel_t const &) noexcept
    {
        return lhs.at_end;
    }
 
    friend constexpr bool operator==(std::default_sentinel_t const & lhs,
                                     algorithm_range_iterator const & rhs) noexcept
    {
        return rhs == lhs;
    }
 
    friend constexpr bool operator!=(algorithm_range_iterator const & lhs,
                                     std::default_sentinel_t const & rhs) noexcept
    {
        return !(lhs == rhs);
    }
 
    friend constexpr bool operator!=(std::default_sentinel_t const & lhs,
                                     algorithm_range_iterator const & rhs) noexcept
    {
        return rhs != lhs;
    }
 
private:
    algorithm_result_generator_range * range_ptr{};
    bool at_end{true};
};
 
} // namespace seqan3