single_pass_input.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/core/type_traits/all.hpp>
#include <seqan3/range/shortcuts.hpp>
#include <seqan3/range/view/detail.hpp>
#include <seqan3/std/concepts>
#include <seqan3/std/iterator>
#include <seqan3/std/ranges>

//-----------------------------------------------------------------------------
// Implementation of single pass input view.
//-----------------------------------------------------------------------------

namespace seqan3::detail
{

template <typename view_t>
class single_pass_input_iterator;

template <std::ranges::View urng_t>
class single_pass_input_view : public std::ranges::view_interface<single_pass_input_view<urng_t>>
{
private:

    using urng_iterator_type = std::ranges::iterator_t<urng_t>;

    template <typename view_t>
    friend class single_pass_input_iterator;

    struct state
    {
        urng_t             urng;
        urng_iterator_type cached_urng_iter = std::ranges::begin(urng);
    };

    std::shared_ptr<state> state_ptr{};

public:
    using iterator          = single_pass_input_iterator<single_pass_input_view>;
    using const_iterator    = void;
    using sentinel          = std::ranges::sentinel_t<urng_t>;
    using value_type        = typename iterator::value_type;
    using reference         = typename iterator::reference;
    using const_reference   = void;
    //\}

    constexpr single_pass_input_view() = default;
    constexpr single_pass_input_view(single_pass_input_view const &) = default;
    constexpr single_pass_input_view(single_pass_input_view &&) = default;
    constexpr single_pass_input_view & operator=(single_pass_input_view const &) = default;
    constexpr single_pass_input_view & operator=(single_pass_input_view &&) = default;
    ~single_pass_input_view() = default;

    explicit single_pass_input_view(urng_t _urng) :
        state_ptr{new state{std::move(_urng)}}
    {}

    template <typename other_urng_t>
    requires !std::Same<remove_cvref_t<other_urng_t>, single_pass_input_view> &&
             std::ranges::ViewableRange<other_urng_t> &&  // Must come after self type check to avoid conflicts with the move constructor.
             std::Constructible<urng_t, ranges::ref_view<std::remove_reference_t<other_urng_t>>>
    explicit single_pass_input_view(other_urng_t && _urng) :
        single_pass_input_view{std::view::all(_urng)}
    {}

    iterator begin()
    {
        return iterator{*this};
    }

    const_iterator begin() const = delete;

    const_iterator cbegin() const = delete;

    sentinel end()
    {
        return {seqan3::end(state_ptr->urng)};
    }

    sentinel end() const = delete;

    sentinel cend() const = delete;
};

template <std::ranges::ViewableRange urng_t>
single_pass_input_view(urng_t &&) ->
    single_pass_input_view<std::ranges::all_view<urng_t>>;
} // seqan3::detail

//-----------------------------------------------------------------------------
// Iterator for single pass input view.
//-----------------------------------------------------------------------------

namespace seqan3::detail
{
template <typename view_type>
class single_pass_input_iterator<single_pass_input_view<view_type>>
{
    using base_iterator_type = typename single_pass_input_view<view_type>::urng_iterator_type;
    using sentinel_type      = typename single_pass_input_view<view_type>::sentinel;

    single_pass_input_view<view_type> * view_ptr{};

    template <typename input_view_type>
    friend class single_pass_input_iterator;

    static_assert(std::Sentinel<sentinel_type, base_iterator_type>);

public:

    using difference_type   = difference_type_t<base_iterator_type>;
    using value_type        = value_type_t<base_iterator_type>;
    using pointer           = typename std::iterator_traits<base_iterator_type>::pointer;
    using reference         = reference_t<base_iterator_type>;
    using iterator_category = std::input_iterator_tag;

    single_pass_input_iterator() = default;
    constexpr single_pass_input_iterator(single_pass_input_iterator const & rhs) = default;
    constexpr single_pass_input_iterator(single_pass_input_iterator && rhs) = default;
    constexpr single_pass_input_iterator & operator=(single_pass_input_iterator const & rhs) = default;
    constexpr single_pass_input_iterator & operator=(single_pass_input_iterator && rhs) = default;
    ~single_pass_input_iterator() = default;

    single_pass_input_iterator(single_pass_input_view<view_type> & view) noexcept : view_ptr{&view}
    {}

    reference operator*() const noexcept
    {
        return *cached();
    }

    pointer operator->() const noexcept
        requires !std::is_void_v<pointer>
    {
        return std::addressof(*cached());
    }

    single_pass_input_iterator & operator++() noexcept
    {
        ++cached();
        return *this;
    }

    auto operator++(int) noexcept
    {
        if constexpr (std::OutputIterator<base_iterator_type, reference> &&
                      std::CopyConstructible<base_iterator_type>)
        {
            single_pass_input_iterator tmp{*this};
            ++(*this);
            return tmp;
        }
        else
        {
            ++(*this);
        }
    }

    constexpr bool operator==(sentinel_type const & s) const noexcept
    {
        return cached() == s;
    }

    friend constexpr bool
    operator==(sentinel_type const & s,
               single_pass_input_iterator<single_pass_input_view<view_type>> const & rhs) noexcept
    {
        return rhs == s;
    }

    constexpr bool operator!=(sentinel_type const & rhs) const noexcept
    {
        return !(*this == rhs);
    }

    friend constexpr bool
    operator!=(sentinel_type const & s,
               single_pass_input_iterator<single_pass_input_view<view_type>> const & rhs) noexcept
    {
        return rhs != s;
    }

protected:
    base_iterator_type & cached() const noexcept
    {
        return view_ptr->state_ptr->cached_urng_iter;
    }
};
}  // seqan3::detail

//-----------------------------------------------------------------------------
// View shortcut for functor.
//-----------------------------------------------------------------------------

namespace seqan3::view
{
inline constexpr auto single_pass_input = detail::adaptor_for_view_without_args<detail::single_pass_input_view>{};

} // namespace seqan3::view