single_pass_input.hpp

Go to the documentation of this file.

// -----------------------------------------------------------------------------------------------------
// Copyright (c) 2022 deCODE Genetics
// 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/biocpp/biocpp-core/blob/main/LICENSE.md
// -----------------------------------------------------------------------------------------------------
 
#pragma once
 
#include <cassert>
#include <concepts>
#include <iterator>
#include <memory>
#include <ranges>
 
#include <bio/ranges/views/detail.hpp>
 
//-----------------------------------------------------------------------------
// Implementation of single pass input view.
//-----------------------------------------------------------------------------
 
namespace bio::ranges::detail
{
 
template <typename view_t>
class basic_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 basic_iterator;
 
    struct state
    {
        urng_t             urng;
        urng_iterator_type cached_urng_iter = std::ranges::begin(urng);
    };
 
    std::shared_ptr<state> state_ptr{};
 
    using iterator = basic_iterator<single_pass_input_view>;
    using sentinel = std::ranges::sentinel_t<urng_t>;
    //\}
 
public:
    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 &&) noexcept             = default;
    constexpr single_pass_input_view & operator=(single_pass_input_view const &)     = default;
    constexpr single_pass_input_view & operator=(single_pass_input_view &&) noexcept = default;
    ~single_pass_input_view()                                                        = default;
 
    explicit single_pass_input_view(urng_t _urng) : state_ptr{new state{std::move(_urng)}} {}
 
    template <meta::different_from<single_pass_input_view> other_urng_t>
        requires(std::ranges::viewable_range<other_urng_t> &&
                 std::constructible_from<urng_t, std::ranges::ref_view<std::remove_reference_t<other_urng_t>>>)
    explicit single_pass_input_view(other_urng_t && _urng) : single_pass_input_view{std::views::all(_urng)}
    {}
 
    iterator begin() { return {*this}; }
 
    iterator begin() const = delete;
 
    sentinel end() { return {std::ranges::end(state_ptr->urng)}; }
 
    sentinel end() const = delete;
};
 
template <std::ranges::viewable_range urng_t>
single_pass_input_view(urng_t &&) -> single_pass_input_view<std::views::all_t<urng_t>>;
} // namespace bio::ranges::detail
 
//-----------------------------------------------------------------------------
// Iterator for single pass input view.
//-----------------------------------------------------------------------------
 
namespace bio::ranges::detail
{
template <typename view_type>
class basic_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 basic_iterator;
 
    static_assert(std::sentinel_for<sentinel_type, base_iterator_type>);
 
public:
    using difference_type   = std::iter_difference_t<base_iterator_type>;
    using value_type        = std::iter_value_t<base_iterator_type>;
    using pointer           = detail::iter_pointer_t<base_iterator_type>;
    using reference         = std::iter_reference_t<base_iterator_type>;
    using iterator_category = std::input_iterator_tag;
 
    basic_iterator() noexcept                                                 = default;
    constexpr basic_iterator(basic_iterator const & rhs) noexcept             = default;
    constexpr basic_iterator(basic_iterator && rhs) noexcept                  = default;
    constexpr basic_iterator & operator=(basic_iterator const & rhs) noexcept = default;
    constexpr basic_iterator & operator=(basic_iterator && rhs) noexcept      = default;
    ~basic_iterator() noexcept                                                = default;
 
    basic_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());
    }
 
    basic_iterator & operator++() noexcept
    {
        ++cached();
        return *this;
    }
 
    auto operator++(int) noexcept
    {
        if constexpr (std::output_iterator<base_iterator_type, reference> &&
                      std::copy_constructible<base_iterator_type>)
        {
            basic_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, basic_iterator const & rhs) noexcept { return rhs == s; }
 
protected:
    base_iterator_type & cached() const noexcept
    {
        assert(view_ptr != nullptr);
        assert(view_ptr->state_ptr != nullptr);
        return view_ptr->state_ptr->cached_urng_iter;
    }
};
} // namespace bio::ranges::detail
 
//-----------------------------------------------------------------------------
// View shortcut for functor.
//-----------------------------------------------------------------------------
 
namespace bio::ranges::views
{
inline constexpr auto single_pass_input = detail::adaptor_for_view_without_args<detail::single_pass_input_view>{};
 
} // namespace bio::ranges::views