algorithm.hpp

// Copyright (C) 2022-2023 by Camden Mannett.
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE or copy at https://www.boost.org/LICENSE_1_0.txt)
 
#pragma once
 
#include "arg_router/traits.hpp"
 
#include <boost/mp11/bind.hpp>
 
#include <algorithm>
#include <string_view>
 
namespace arg_router::algorithm
{
template <template <typename...> typename T, typename Tuple>
class find_specialisation
{
    template <typename U>
    using fn = traits::is_specialisation_of<U, T>;
 
public:
    constexpr static std::size_t value = boost::mp11::mp_find_if<Tuple, fn>::value;
};
 
template <template <typename...> typename T, typename Tuple>
constexpr auto find_specialisation_v = find_specialisation<T, Tuple>::value;
 
template <template <typename...> typename T, typename Tuple>
class count_specialisation
{
    template <typename U>
    using fn = traits::is_specialisation_of<U, T>;
 
public:
    constexpr static std::size_t value = boost::mp11::mp_count_if<Tuple, fn>::value;
};
 
template <template <typename...> typename T, typename Tuple>
constexpr auto count_specialisation_v = count_specialisation<T, Tuple>::value;
 
template <typename T, typename Tuple>
class count_despecialised
{
    template <typename U>
    using fn = traits::is_same_when_despecialised<U, T>;
 
public:
    constexpr static std::size_t value = boost::mp11::mp_count_if<Tuple, fn>::value;
};
 
template <typename T, typename Tuple>
constexpr auto count_despecialised_v = count_despecialised<T, Tuple>::value;
 
template <template <typename...> typename T, typename Tuple>
struct has_specialisation {
    constexpr static bool value = find_specialisation_v<T, Tuple> < std::tuple_size_v<Tuple>;
};
 
template <template <typename...> typename T, typename Tuple>
constexpr auto has_specialisation_v = has_specialisation<T, Tuple>::value;
 
template <typename First, typename Second>
class zip
{
    static_assert((std::tuple_size_v<First> == std::tuple_size_v<Second>),
                  "First and Second tuples must contain the same number of elements");
 
    template <std::size_t... N>
    [[nodiscard]] constexpr static auto zip_impl_t(
        std::integer_sequence<std::size_t, N...>) noexcept
        -> std::tuple<
            std::pair<std::tuple_element_t<N, First>, std::tuple_element_t<N, Second>>...>;
 
public:
    using type =
        decltype(zip_impl_t(std::declval<std::make_index_sequence<std::tuple_size_v<First>>>()));
};
 
template <typename First, typename Second>
using zip_t = typename zip<First, Second>::type;
 
template <typename T>
struct unzip {
    using first_type = boost::mp11::mp_transform<boost::mp11::mp_first, T>;
 
    using second_type = boost::mp11::mp_transform<boost::mp11::mp_second, T>;
};
 
namespace detail
{
template <typename U, typename... I>
[[nodiscard]] constexpr auto tuple_filter_and_construct_impl(
    U&& input,
    [[maybe_unused]] std::tuple<I...> Is) noexcept
{
    return std::tuple{std::get<I::value>(std::forward<U>(input))...};
}
}  // namespace detail
 
template <template <typename...> typename Fn, typename U>
[[nodiscard]] constexpr auto tuple_filter_and_construct(U&& input) noexcept
{
    // Zip together an index-sequence of U and the elements of it
    using zipped =
        zip_t<boost::mp11::mp_iota_c<std::tuple_size_v<std::decay_t<U>>>, std::decay_t<U>>;
 
    // Filter out types not approved by Fn, we need to wrap Fn so that it only operates on the
    // second type in the pair (the type from U)
    using wrapped_fn =
        boost::mp11::mp_bind<Fn, boost::mp11::mp_bind<boost::mp11::mp_second, boost::mp11::_1>>;
    using filtered = boost::mp11::mp_filter_q<wrapped_fn, zipped>;
 
    // Fold construct the return value using the zip indices as accessors to input
    return detail::tuple_filter_and_construct_impl(input, typename unzip<filtered>::first_type{});
}
 
namespace detail
{
template <template <typename...> typename Tuple,
          typename Insert,
          typename... Args,
          std::size_t... I>
[[nodiscard]] constexpr auto tuple_push_back_impl(
    Tuple<Args...> tuple,
    Insert insert,
    [[maybe_unused]] std::integer_sequence<std::size_t, I...> Is) noexcept
{
    return Tuple{std::move(std::get<I>(tuple))..., std::move(insert)};
}
 
// Empty tuple specialisation
template <template <typename...> typename Tuple, typename Insert>
[[nodiscard]] constexpr auto tuple_push_back_impl(
    [[maybe_unused]] Tuple<> t,
    Insert insert,
    [[maybe_unused]] std::integer_sequence<std::size_t> Is) noexcept
{
    return Tuple{std::move(insert)};
}
}  // namespace detail
 
template <typename Tuple, typename Insert>
[[nodiscard]] constexpr auto tuple_push_back(Tuple tuple, Insert insert) noexcept
{
    // Cannot use std::tuple_cat as it causes infinite compiler loops in MSVC
    return detail::tuple_push_back_impl(std::move(tuple),
                                        std::move(insert),
                                        std::make_index_sequence<std::tuple_size_v<Tuple>>{});
}
 
namespace detail
{
template <std::size_t Count, typename U, std::size_t... I>
[[nodiscard]] constexpr auto tuple_drop_impl(
    U&& input,
    // NOLINTNEXTLINE(*-named-parameter)
    [[maybe_unused]] std::integer_sequence<std::size_t, I...>) noexcept
{
    return std::tuple{std::get<I + Count>(std::forward<U>(input))...};
}
}  // namespace detail
 
template <std::size_t Count, typename Tuple>
[[nodiscard]] constexpr auto tuple_drop(Tuple&& input)
{
    return detail::tuple_drop_impl<Count>(
        std::forward<Tuple>(input),
        std::make_index_sequence<std::tuple_size_v<Tuple> - Count>{});
}
 
template <std::size_t I, typename... T>
[[nodiscard]] constexpr auto& pack_element(const T&... pack) noexcept
{
    static_assert(I < sizeof...(pack), "Index out of bounds for pack");
    return std::get<I>(std::tuple{std::cref(pack)...}).get();
}
}  // namespace arg_router::algorithm