repeat.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 <algorithm>
#include <ranges>
 
#include <bio/ranges/detail/random_access_iterator.hpp>
#include <bio/ranges/type_traits.hpp>
 
namespace bio::ranges::detail
{
 
// ---------------------------------------------------------------------------------------------------------------------
// repeat_view class
// ---------------------------------------------------------------------------------------------------------------------
 
template <typename 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 = 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, template <typename...> typename>
    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 &&) noexcept             = default; 
    repeat_view & operator=(repeat_view &&) noexcept = default; 
    ~repeat_view()                                   = default; 
 
    constexpr explicit repeat_view(value_t const & value)
        requires std::copy_constructible<value_t>
      : 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 BIOCPP_DOXYGEN_ONLY(n)) const noexcept
    {
        return single_value;
    }
 
    constexpr reference operator[](difference_type const BIOCPP_DOXYGEN_ONLY(n)) noexcept { return single_value; }
 
private:
    single_value_t single_value;
};
 
template <typename 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 &&) noexcept             = default; 
    basic_iterator & operator=(basic_iterator &&) noexcept = 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}
    {}
 
    friend constexpr bool operator==(basic_iterator const &, std::default_sentinel_t const &) noexcept { return false; }
};
 
// ---------------------------------------------------------------------------------------------------------------------
// repeat (factory)
// ---------------------------------------------------------------------------------------------------------------------
 
struct repeat_fn
{
    template <typename value_t>
    constexpr auto operator()(value_t && value) const
    {
        static_assert(std::constructible_from<std::remove_cvref_t<value_t>, value_t>,
                      "The value passed to views::repeat must be (1) an lvalue and its type copy constructible; or "
                      "(2) an rvalue and its type move constructible.");
 
        return detail::repeat_view{std::forward<value_t>(value)};
    }
};
 
} // namespace bio::ranges::detail
 
namespace bio::ranges::views
{
 
// ---------------------------------------------------------------------------------------------------------------------
// views::repeat (factory instance)
// ---------------------------------------------------------------------------------------------------------------------
 
inline constexpr detail::repeat_fn repeat{};
 
} // namespace bio::ranges::views