alignment_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>
 
namespace seqan3
{
 
template <typename alignment_executor_type>
class alignment_range
{
    static_assert(!std::is_const_v<alignment_executor_type>,
                  "Cannot create an alignment stream over a const buffer.");
 
    class alignment_range_iterator;
 
    friend class alignment_range_iterator;
 
public:
    using difference_type = typename alignment_executor_type::difference_type;
    using value_type      = typename alignment_executor_type::value_type;
    using reference       = typename alignment_executor_type::reference;
    using iterator        = alignment_range_iterator;
    using const_iterator  = void;
    using sentinel        = std::ranges::default_sentinel_t;
 
    alignment_range() = default; 
    alignment_range(alignment_range const &) = delete; 
    alignment_range(alignment_range &&) = default; 
    alignment_range & operator=(alignment_range const &) = delete; 
    alignment_range & operator=(alignment_range &&) = default; 
    ~alignment_range() = default; 
 
    explicit alignment_range(alignment_executor_type const & _alignment_executor) = delete;
 
    explicit alignment_range(alignment_executor_type && _alignment_executor) :
        alignment_executor{new alignment_executor_type{std::move(_alignment_executor)}}
    {}
 
    constexpr iterator begin()
    {
        return iterator{*this};
    }
 
    const_iterator begin() const = delete;
    const_iterator cbegin() const = delete;
 
    constexpr sentinel end() noexcept
    {
        return {};
    }
 
    constexpr sentinel end() const = delete;
    constexpr sentinel cend() const = delete;
 
protected:
    bool next()
    {
        if (!alignment_executor)
            throw std::runtime_error{"No alignment execution buffer available."};
 
        if (auto opt = alignment_executor->bump(); opt.has_value())
        {
            cache = std::move(*opt);
            return true;
        }
 
        return false;
    }
 
private:
    std::unique_ptr<alignment_executor_type> alignment_executor{};
    value_type cache{};
};
 
template <typename alignment_executor_type>
alignment_range(alignment_executor_type &&) -> alignment_range<std::remove_reference_t<alignment_executor_type>>;
 
template <typename alignment_executor_type>
class alignment_range<alignment_executor_type>::alignment_range_iterator
{
public:
    using difference_type = typename alignment_range::difference_type;
    using value_type = typename alignment_range::value_type;
    using reference = typename alignment_range::reference;
    using pointer = std::add_pointer_t<value_type>;
    using iterator_category = std::input_iterator_tag;
 
    constexpr alignment_range_iterator() noexcept = default; 
    constexpr alignment_range_iterator(alignment_range_iterator const &) noexcept = default; 
    constexpr alignment_range_iterator(alignment_range_iterator &&) noexcept = default; 
    constexpr alignment_range_iterator & operator=(alignment_range_iterator const &) noexcept = default; 
    constexpr alignment_range_iterator & operator=(alignment_range_iterator &&) noexcept = default; 
    ~alignment_range_iterator() = default; 
 
    constexpr alignment_range_iterator(alignment_range & range) : range_ptr(& range)
    {
        ++(*this); // Fetch the next element.
    }
 
    reference operator*() const noexcept
    {
        return range_ptr->cache;
    }
 
    pointer operator->() const noexcept
    {
        return &range_ptr->cache;
    }
 
    alignment_range_iterator & operator++(/*pre*/)
    {
        assert(range_ptr != nullptr);
 
        at_end = !range_ptr->next();
        return *this;
    }
 
    void operator++(int /*post*/)
    {
        ++(*this);
    }
 
    friend constexpr bool operator==(alignment_range_iterator const & lhs,
                                     std::ranges::default_sentinel_t const &) noexcept
    {
        return lhs.at_end;
    }
 
    friend constexpr bool operator==(std::ranges::default_sentinel_t const & lhs,
                                     alignment_range_iterator const & rhs) noexcept
    {
        return rhs == lhs;
    }
 
    friend constexpr bool operator!=(alignment_range_iterator const & lhs,
                                     std::ranges::default_sentinel_t const & rhs) noexcept
    {
        return !(lhs == rhs);
    }
 
    friend constexpr bool operator!=(std::ranges::default_sentinel_t const & lhs,
                                     alignment_range_iterator const & rhs) noexcept
    {
        return rhs != lhs;
    }
 
private:
    alignment_range * range_ptr{};
    bool at_end{true};
};
 
} // namespace seqan3