transform_by_pos.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 <utility>
 
#include <bio/ranges/concept.hpp>
#include <bio/ranges/detail/random_access_iterator.hpp>
#include <bio/ranges/views/detail.hpp>
 
namespace bio::ranges::detail
{
 
template <std::ranges::view urng_t, typename transform_by_pos_t>
class view_transform_by_pos : public std::ranges::view_base
{
private:
    urng_t             urange;
    transform_by_pos_t transform_by_pos;
    size_t             _size = 0;
 
    static_assert(std::ranges::sized_range<urng_t>,
                  "The range parameter to views::transform_by_pos must model std::ranges::sized_range.");
    static_assert(std::ranges::random_access_range<urng_t>,
                  "The range parameter to views::transform_by_pos must model std::ranges::random_access_range.");
 
    static constexpr bool invocable = std::invocable<transform_by_pos_t, urng_t &, std::ranges::range_size_t<urng_t>>;
    static_assert(invocable, "Both functors need to be invocable with the range type and an integral as parameters.");
 
    static constexpr bool const_invocable =
      const_iterable_range<urng_t> &&
      std::invocable<transform_by_pos_t const, urng_t const &, std::ranges::range_size_t<urng_t>>;
 
    using reference       = decltype(transform_by_pos(urange, 0ull));
    using const_reference = decltype(std::as_const(transform_by_pos)(std::as_const(urange), 0ull));
    using value_type      = std::remove_cvref_t<reference>;
    using difference_type = std::ranges::range_difference_t<urng_t>;
    using size_type       = size_t;
    using iterator        = detail::random_access_iterator<view_transform_by_pos>;
    using const_iterator  = detail::random_access_iterator<view_transform_by_pos const>;
 
    template <typename, template <typename...> typename>
    friend class detail::random_access_iterator_base;
 
public:
    view_transform_by_pos() noexcept                                                        = default; 
    constexpr view_transform_by_pos(view_transform_by_pos const & rhs) noexcept             = default; 
    constexpr view_transform_by_pos(view_transform_by_pos && rhs) noexcept                  = default; 
    constexpr view_transform_by_pos & operator=(view_transform_by_pos const & rhs) noexcept = default; 
    constexpr view_transform_by_pos & operator=(view_transform_by_pos && rhs) noexcept      = default; 
    ~view_transform_by_pos() noexcept                                                       = default; 
 
    view_transform_by_pos(urng_t _urange, transform_by_pos_t _transform_by_pos, size_t const s) :
      urange{std::move(_urange)}, transform_by_pos{std::move(_transform_by_pos)}, _size{s}
    {}
 
    template <typename rng_t>
        requires(!meta::decays_to<rng_t, view_transform_by_pos> &&
                 (std::ranges::viewable_range<rng_t> &&
                  std::constructible_from<urng_t, std::ranges::ref_view<std::remove_reference_t<rng_t>>>))
    view_transform_by_pos(rng_t && _urange, transform_by_pos_t _transform_by_pos, size_t const s) :
      view_transform_by_pos{std::views::all(std::forward<rng_t>(_urange)), std::move(_transform_by_pos), s}
    {}
 
    auto begin() noexcept { return iterator{*this, 0}; }
    auto begin() const noexcept
        requires const_invocable
    {
        return const_iterator{*this, 0};
    }
 
    auto end() noexcept { return iterator{*this, size()}; }
    auto end() const noexcept
        requires const_invocable
    {
        return const_iterator{*this, size()};
    }
 
    size_t size() const noexcept { return _size; }
 
    decltype(auto) operator[](size_t const n)
    {
        assert(n < size());
        return transform_by_pos(urange, n);
    }
 
    decltype(auto) operator[](size_t const n) const
        requires const_invocable
    {
        assert(n < size());
        return transform_by_pos(urange, n);
    }
};
 
template <typename urng_t, typename transform_by_pos_t>
view_transform_by_pos(urng_t &&, transform_by_pos_t, size_t)
  -> view_transform_by_pos<std::views::all_t<urng_t>, transform_by_pos_t>;
 
// ============================================================================
//  transform_by_pos_fn (adaptor object)
// ============================================================================
 
struct transform_by_pos_fn
{
    template <typename transform_by_pos_t, typename size_transform_t = std::remove_cvref_t<decltype(std::ranges::size)>>
    constexpr auto operator()(transform_by_pos_t transform_by_pos,
                              size_transform_t   size_transform = std::ranges::size) const
    {
        return detail::adaptor_from_functor{*this, std::move(transform_by_pos), std::move(size_transform)};
    }
 
    template <std::ranges::range urng_t,
              typename transform_by_pos_t,
              typename size_transform_t = std::remove_cvref_t<decltype(std::ranges::size)>>
    constexpr auto operator()(urng_t &&          urange,
                              transform_by_pos_t transform_by_pos,
                              size_transform_t   size_transform = std::ranges::size) const
    {
        static_assert(std::ranges::viewable_range<urng_t>,
                      "The range parameter to views::transform_by_pos must viewable.");
        static_assert(std::ranges::sized_range<urng_t>,
                      "The range parameter to views::transform_by_pos must model std::ranges::sized_range.");
        static_assert(std::ranges::random_access_range<urng_t>,
                      "The range parameter to views::transform_by_pos must model std::ranges::random_access_range.");
        static_assert(std::convertible_to<std::invoke_result_t<size_transform_t, urng_t &>, size_t>,
                      "The size_transform must be invocable with `urng_t &` and return sth. convertible to size_t.");
 
        return view_transform_by_pos{std::forward<urng_t>(urange), std::move(transform_by_pos), size_transform(urange)};
    }
};
 
} // namespace bio::ranges::detail
 
// A view that applies a transformation function to an element of a range using its positional index.
namespace bio::ranges::views
{
 
inline constexpr auto transform_by_pos = detail::transform_by_pos_fn{};
} // namespace bio::ranges::views