detail.hpp

Go to the documentation of this file.

// -----------------------------------------------------------------------------------------------------
// Copyright (c) 2006-2019, Knut Reinert & Freie Universität Berlin
// Copyright (c) 2016-2019, 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 <tuple>

#include <seqan3/core/type_traits/basic.hpp>
#include <seqan3/core/type_traits/range.hpp>
#include <seqan3/std/ranges>

namespace seqan3::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) :
        arguments{std::forward<stored_args_ts>(args)...}
    {}

    template <std::ranges::InputRange 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::InputRange 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::InputRange<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::InputRange<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::InputRange 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:
    using base_type::base_type;

    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:
    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::InputRange 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(functor_type f, stored_args_ts ... args) :
        base_type{std::forward<stored_args_ts>(args)...}, fun{std::move(f)}
    {}
};

} // namespace seqan3::detail