alignment_range.hpp

Go to the documentation of this file.

// -----------------------------------------------------------------------------------------------------
// Copyright (c) 2006-2019, Knut Reinert & Freie Universität Berlin
// Copyright (c) 2016-2019, 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>
//TODO requires alignment_executor_concept<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 iterator_type
    {
    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 iterator_type() noexcept = default;                                  
        constexpr iterator_type(iterator_type const &) noexcept = default;             
        constexpr iterator_type(iterator_type &&) noexcept = default;                  
        constexpr iterator_type & operator=(iterator_type const &) noexcept = default; 
        constexpr iterator_type & operator=(iterator_type &&) noexcept = default;      
        ~iterator_type() = default;                                                    

        constexpr iterator_type(alignment_range & range) noexcept : range_ptr(&range)
        {}

        reference operator*() const noexcept
        {
            return range_ptr->cache;
        }

        iterator_type & operator++(/*pre*/) noexcept
        {
            range_ptr->next();
            return *this;
        }

        void operator++(int /*post*/) noexcept
        {
            ++(*this);
        }

        constexpr bool operator==(std::ranges::default_sentinel_t const &) const noexcept
        {
            return range_ptr->eof();
        }

        friend constexpr bool operator==(std::ranges::default_sentinel_t const & lhs,
                                         iterator_type const & rhs) noexcept
        {
            return rhs == lhs;
        }

        constexpr bool operator!=(std::ranges::default_sentinel_t const & rhs) const noexcept
        {
            return !(*this == rhs);
        }

        friend constexpr bool operator!=(std::ranges::default_sentinel_t const & lhs,
                                         iterator_type const & rhs) noexcept
        {
            return rhs != lhs;
        }
    private:
        alignment_range * range_ptr{};
    };

    // Befriend the iterator with this class.
    // TODO Check if this is necessary.
    friend class iterator_type;

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        = iterator_type;
    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)}},
        eof_flag(false)
    {}

    constexpr iterator begin()
    {
        if (!eof_flag)
            next();
        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:

    void next()
    {
        assert(!eof());

        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);
        else
            eof_flag = true;
    }

    constexpr bool eof() const noexcept
    {
        return eof_flag;
    }

private:
    std::unique_ptr<alignment_executor_type> alignment_executor{};
    value_type cache{};
    bool eof_flag{true};
};

template <typename alignment_executor_type>
alignment_range(alignment_executor_type &&) -> alignment_range<std::remove_reference_t<alignment_executor_type>>;

} // namespace seqan3