repeat.hpp

Go to the documentation of this file.

// -----------------------------------------------------------------------------------------------------
// Copyright (c) 2006-2021, Knut Reinert & Freie Universität Berlin
// Copyright (c) 2016-2021, 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/algorithm>
#include <seqan3/std/ranges>
 
#include <seqan3/core/detail/iterator_traits.hpp>
#include <seqan3/core/range/detail/random_access_iterator.hpp>
#include <seqan3/core/range/type_traits.hpp>
 
namespace seqan3::detail
{
 
// ---------------------------------------------------------------------------------------------------------------------
// repeat_view class
// ---------------------------------------------------------------------------------------------------------------------
 
template <std::copy_constructible value_t>
class repeat_view : public std::ranges::view_interface<repeat_view<value_t>>
{
private:
    using base_t = std::ranges::view_interface<repeat_view<value_t>>;
 
    using sentinel_type = std::default_sentinel_t;
 
    using single_value_t = decltype(std::views::single(std::declval<value_t>()));
 
    using value_type = std::remove_reference_t<value_t>;
    using reference  = value_type &;
    using const_reference = value_type const &;
    using difference_type = ptrdiff_t;
 
    template <typename parent_type>
    class basic_iterator;
 
    using iterator = basic_iterator<repeat_view>;
    using const_iterator = basic_iterator<repeat_view const>;
 
    template <typename parent_type, typename crtp_base>
    friend class detail::random_access_iterator_base;
 
public:
    repeat_view() = default; 
    repeat_view(repeat_view const &) = default; 
    repeat_view & operator=(repeat_view const &) = default; 
    repeat_view(repeat_view &&) = default; 
    repeat_view & operator=(repeat_view &&) = default; 
    ~repeat_view() = default; 
 
    constexpr explicit repeat_view(value_t const & value) : single_value{value}
    {}
 
    constexpr explicit repeat_view(value_t && value) : single_value{std::move(value)}
    {}
 
    constexpr iterator begin() noexcept
    {
        return iterator{*this};
    }
 
    constexpr const_iterator begin() const noexcept
    {
        return const_iterator{*this};
    }
 
    constexpr sentinel_type end() noexcept
    {
        return {};
    }
 
    constexpr sentinel_type end() const noexcept
    {
        return {};
    }
 
    constexpr const_reference operator[](difference_type const SEQAN3_DOXYGEN_ONLY(n)) const noexcept
    {
        return *single_value.begin();
    }
 
    constexpr reference operator[](difference_type const SEQAN3_DOXYGEN_ONLY(n)) noexcept
    {
        return *single_value.begin();
    }
 
private:
    single_value_t single_value;
};
 
template <std::copy_constructible value_t>
template <typename parent_type>
class repeat_view<value_t>::basic_iterator :
    public detail::random_access_iterator_base<parent_type, basic_iterator>
{
    using base_t = detail::random_access_iterator_base<parent_type, basic_iterator>;
 
    using typename base_t::position_type;
 
public:
    using typename base_t::difference_type;
    using typename base_t::value_type;
    using typename base_t::reference;
    using typename base_t::pointer;
    using typename base_t::iterator_category;
 
    basic_iterator() = default; 
    basic_iterator(basic_iterator const &) = default; 
    basic_iterator & operator=(basic_iterator const &) = default; 
    basic_iterator (basic_iterator &&) = default; 
    basic_iterator & operator=(basic_iterator &&) = default; 
    ~basic_iterator() = default; 
 
    explicit constexpr basic_iterator(parent_type & host) noexcept : base_t{host} {}
 
    template <typename parent_type2>
        requires std::is_const_v<parent_type> && (!std::is_const_v<parent_type2>) &&
                 std::is_same_v<std::remove_const_t<parent_type>, parent_type2>
    constexpr basic_iterator(basic_iterator<parent_type2> const & rhs) noexcept :
        base_t{rhs}
    {}
 
    using base_t::operator==;
    using base_t::operator!=;
 
    constexpr bool operator==(std::default_sentinel_t const &) const noexcept
    {
        return false;
    }
 
    constexpr bool operator!=(std::default_sentinel_t const &) const noexcept
    {
        return true;
    }
 
    friend constexpr bool operator==(std::default_sentinel_t const &,
                                     basic_iterator const &) noexcept
    {
        return false;
    }
 
    friend constexpr bool operator!=(std::default_sentinel_t const &,
                                     basic_iterator const &) noexcept
    {
        return true;
    }
};
 
// ---------------------------------------------------------------------------------------------------------------------
// repeat (factory)
// ---------------------------------------------------------------------------------------------------------------------
 
struct repeat_fn
{
    template <std::copy_constructible value_type>
    constexpr auto operator()(value_type && value) const
    {
        return detail::repeat_view{std::forward<value_type>(value)};
    }
};
 
} // namespace seqan3::detail
 
namespace seqan3::views
{
 
// ---------------------------------------------------------------------------------------------------------------------
// views::repeat (factory instance)
// ---------------------------------------------------------------------------------------------------------------------
 
constexpr inline detail::repeat_fn repeat{};
 
} // namespace seqan3::views