detail.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 <ranges>
#include <tuple>
 
#include <bio/meta/type_traits/basic.hpp>
#include <bio/ranges/type_traits.hpp>
 
namespace bio::ranges::detail
{
 
// ============================================================================
//  forwards
// ============================================================================
 
template <typename left_adaptor_t, typename right_adaptor_t>
class combined_adaptor;
 
// ============================================================================
//  adaptor_base
// ============================================================================
 
template <typename derived_type, typename... stored_args_ts>
class adaptor_base
{
private:
    std::tuple<stored_args_ts...> arguments;
 
    template <typename urng_t, size_t... Is>
    constexpr auto pass_args_to_impl(urng_t && urange, std::index_sequence<Is...> const &) const &
    {
        // std::get returns lvalue-reference to value, but we need to copy the values
        // so that the view does not depend on the functor
        return static_cast<derived_type const &>(*this).impl(
          std::forward<urng_t>(urange),
          std::tuple_element_t<Is, std::tuple<stored_args_ts...>>(std::get<Is>(arguments))...);
    }
 
    template <typename urng_t, size_t... Is>
    constexpr auto pass_args_to_impl(urng_t && urange, std::index_sequence<Is...> const &) &&
    {
        // move out values, because we don't need them anymore (*this is temporary)
        return static_cast<derived_type &&>(*this).impl(
          std::forward<urng_t>(urange),
          std::tuple_element_t<Is, std::tuple<stored_args_ts...>>(std::get<Is>(std::move(arguments)))...);
    }
 
    friend derived_type;
 
public:
    // a default constructor is not provided, however the constructor below might be one.
    constexpr adaptor_base(adaptor_base const &) noexcept             = default; 
    constexpr adaptor_base(adaptor_base &&) noexcept                  = default; 
    constexpr adaptor_base & operator=(adaptor_base const &) noexcept = default; 
    constexpr adaptor_base & operator=(adaptor_base &&) noexcept      = default; 
    ~adaptor_base() noexcept                                          = default; 
 
    constexpr adaptor_base(stored_args_ts... args) noexcept(
      noexcept(std::tuple<stored_args_ts...>{std::forward<stored_args_ts>(args)...})) :
      arguments{std::forward<stored_args_ts>(args)...}
    {}
 
    template <std::ranges::input_range urng_t>
    constexpr auto operator()(urng_t && urange) const &
    {
        return pass_args_to_impl(std::forward<urng_t>(urange), std::make_index_sequence<sizeof...(stored_args_ts)>{});
    }
 
    template <std::ranges::input_range urng_t>
    constexpr auto operator()(urng_t && urange) &&
    {
        return std::move(*this).pass_args_to_impl(std::forward<urng_t>(urange),
                                                  std::make_index_sequence<sizeof...(stored_args_ts)>{});
    }
 
    template <typename arg_t>
    constexpr friend auto operator|(arg_t && arg, derived_type const & me)
    {
        if constexpr (std::ranges::input_range<arg_t>)
            return me(std::forward<arg_t>(arg));
        else
            return combined_adaptor{std::forward<arg_t>(arg), me};
    }
 
    template <typename arg_t>
    constexpr friend auto operator|(arg_t && arg, derived_type && me)
    {
        if constexpr (std::ranges::input_range<arg_t>)
            return std::move(me)(std::forward<arg_t>(arg));
        else
            return combined_adaptor{std::forward<arg_t>(arg), std::move(me)};
    }
 
    template <typename arg_t>
    constexpr friend auto operator|(adaptor_base const & me, arg_t && arg)
    {
        return combined_adaptor{static_cast<derived_type const &>(me), std::forward<arg_t>(arg)};
    }
 
    template <typename arg_t>
    constexpr friend auto operator|(adaptor_base && me, arg_t && arg)
    {
        return combined_adaptor{static_cast<derived_type &&>(me), std::forward<arg_t>(arg)};
    }
};
 
// ============================================================================
//  combined_adaptor
// ============================================================================
 
template <typename left_adaptor_t, typename right_adaptor_t>
class combined_adaptor :
  public adaptor_base<combined_adaptor<left_adaptor_t, right_adaptor_t>, left_adaptor_t, right_adaptor_t>
{
private:
    using base_type = adaptor_base<combined_adaptor<left_adaptor_t, right_adaptor_t>, left_adaptor_t, right_adaptor_t>;
 
    friend base_type;
 
    template <std::ranges::input_range urng_t, typename left_adaptor_t_, typename right_adaptor_t_>
    static auto impl(urng_t && urange, left_adaptor_t_ && left_adaptor, right_adaptor_t_ && right_adaptor)
    {
        return std::forward<urng_t>(urange) | std::forward<left_adaptor_t_>(left_adaptor) |
               std::forward<right_adaptor_t_>(right_adaptor);
    }
 
public:
    constexpr combined_adaptor()                                              = default; 
    constexpr combined_adaptor(combined_adaptor const &) noexcept             = default; 
    constexpr combined_adaptor(combined_adaptor &&) noexcept                  = default; 
    constexpr combined_adaptor & operator=(combined_adaptor const &) noexcept = default; 
    constexpr combined_adaptor & operator=(combined_adaptor &&) noexcept      = default; 
    ~combined_adaptor() noexcept                                              = default; 
 
    using base_type::base_type;
 
    constexpr combined_adaptor(left_adaptor_t l, right_adaptor_t r) :
      base_type{std::forward<left_adaptor_t>(l), std::forward<right_adaptor_t>(r)}
    {}
};
 
// ============================================================================
//  adaptor_for_view_without_args
// ============================================================================
 
template <template <typename, typename...> typename view_type>
class adaptor_for_view_without_args : public adaptor_base<adaptor_for_view_without_args<view_type>>
{
private:
    using base_type = adaptor_base<adaptor_for_view_without_args<view_type>>;
 
    friend base_type;
 
    template <typename... arg_types>
    static auto impl(arg_types &&... args)
    {
        return view_type{std::forward<arg_types>(args)...};
    }
 
public:
    constexpr adaptor_for_view_without_args()                                                           = default;
    constexpr adaptor_for_view_without_args(adaptor_for_view_without_args const &) noexcept             = default;
    constexpr adaptor_for_view_without_args(adaptor_for_view_without_args &&) noexcept                  = default;
    constexpr adaptor_for_view_without_args & operator=(adaptor_for_view_without_args const &) noexcept = default;
    constexpr adaptor_for_view_without_args & operator=(adaptor_for_view_without_args &&) noexcept      = default;
    ~adaptor_for_view_without_args() noexcept                                                           = default;
 
    using base_type::base_type;
};
 
// ============================================================================
//  adaptor_from_functor
// ============================================================================
 
template <typename functor_type, typename... stored_args_ts>
class adaptor_from_functor :
  public adaptor_base<adaptor_from_functor<functor_type, stored_args_ts...>, stored_args_ts...>
{
private:
    using base_type = adaptor_base<adaptor_from_functor<functor_type, stored_args_ts...>, stored_args_ts...>;
 
    friend base_type;
 
    functor_type fun;
 
    template <std::ranges::input_range urng_t>
    constexpr auto impl(urng_t && urange, stored_args_ts... args) const
    {
        return fun(std::forward<urng_t>(urange), std::forward<stored_args_ts>(args)...);
    }
 
public:
    constexpr adaptor_from_functor()                                                  = default; 
    constexpr adaptor_from_functor(adaptor_from_functor const &) noexcept             = default; 
    constexpr adaptor_from_functor(adaptor_from_functor &&) noexcept                  = default; 
    constexpr adaptor_from_functor & operator=(adaptor_from_functor const &) noexcept = default; 
    constexpr adaptor_from_functor & operator=(adaptor_from_functor &&) noexcept      = default; 
    ~adaptor_from_functor() noexcept                                                  = default; 
 
    constexpr adaptor_from_functor(functor_type f, stored_args_ts... args) :
      base_type{std::forward<stored_args_ts>(args)...}, fun{std::move(f)}
    {}
};
 
} // namespace bio::ranges::detail