repeat.hpp

Go to the documentation of this file.

// -----------------------------------------------------------------------------------------------------
// 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/seqan/seqan3/blob/master/LICENSE.md
// -----------------------------------------------------------------------------------------------------
 
#pragma once
 
#include <range/v3/view/single.hpp>
 
#include <seqan3/core/type_traits/iterator.hpp>
#include <seqan3/core/type_traits/range.hpp>
#include <seqan3/range/detail/random_access_iterator.hpp>
#include <seqan3/std/ranges>
 
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::ranges::default_sentinel_t;
 
    template <typename parent_type>
    class repeat_view_iterator : public detail::random_access_iterator_base<parent_type, repeat_view_iterator>
    {
        using base_t = detail::random_access_iterator_base<parent_type, repeat_view_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;
 
        constexpr repeat_view_iterator() = default;                                         
        constexpr repeat_view_iterator(repeat_view_iterator const &) = default;             
        constexpr repeat_view_iterator & operator=(repeat_view_iterator const &) = default; 
        constexpr repeat_view_iterator (repeat_view_iterator &&) = default;                 
        constexpr repeat_view_iterator & operator=(repeat_view_iterator &&) = default;      
        ~repeat_view_iterator() = default;                                                  
 
        explicit constexpr repeat_view_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 repeat_view_iterator(repeat_view_iterator<parent_type2> const & rhs) noexcept :
            base_t{rhs}
        {}
 
        using base_t::operator==;
        using base_t::operator!=;
 
        constexpr bool operator==(std::ranges::default_sentinel_t const &) const noexcept
        {
            return false;
        }
 
        constexpr bool operator!=(std::ranges::default_sentinel_t const &) const noexcept
        {
            return true;
        }
 
        friend constexpr bool operator==(std::ranges::default_sentinel_t const &,
                                         repeat_view_iterator const &) noexcept
        {
            return false;
        }
 
        friend constexpr bool operator!=(std::ranges::default_sentinel_t const &,
                                         repeat_view_iterator const &) noexcept
        {
            return true;
        }
    };
 
public:
    using value_type = std::remove_reference_t<value_t>;
    using reference  = value_type &;
    using const_reference = value_type const &;
    using size_type = void;
    using difference_type = ptrdiff_t;
    using iterator = repeat_view_iterator<repeat_view>;
    using const_iterator = repeat_view_iterator<repeat_view const>;
 
    constexpr repeat_view() = default;                                
    constexpr repeat_view(repeat_view const &) = default;             
    constexpr repeat_view & operator=(repeat_view const &) = default; 
    constexpr repeat_view(repeat_view &&) = default;                  
    constexpr repeat_view & operator=(repeat_view &&) = default;      
    ~repeat_view() = default;                                         
 
    constexpr explicit repeat_view(value_t const & value) : single_value{ranges::single_view{value}}
    {}
 
    constexpr explicit repeat_view(value_t && value) : single_value{ranges::single_view{std::move(value)}}
    {}
 
    constexpr iterator begin() noexcept
    {
        return iterator{*this};
    }
 
    constexpr const_iterator begin() const noexcept
    {
        return const_iterator{*this};
    }
 
    constexpr const_iterator cbegin() const noexcept
    {
        return const_iterator{*this};
    }
 
    constexpr sentinel_type end() noexcept
    {
        return {};
    }
 
    constexpr sentinel_type end() const noexcept
    {
        return {};
    }
 
    constexpr sentinel_type cend() 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:
    decltype(std::views::single(std::declval<value_t &>())) single_value;
};
 
// ---------------------------------------------------------------------------------------------------------------------
// 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