mp_utils.hpp

Go to the documentation of this file.

// Copyright 2024 Man Group Operations Limited
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
 
#pragma once
 
#include <concepts>
#include <cstdint>
#include <iterator>
#include <memory>
#include <ranges>
#include <span>
#include <tuple>
#include <type_traits>
 
namespace sparrow::mpl
{

    template <class... T>
    struct dependent_false : std::false_type
    {
    };
 
    template <class L, template <class...> class U>
    struct is_type_instance_of : std::false_type
    {
    };
 
    template <template <class...> class L, template <class...> class U, class... T>
        requires std::is_same_v<L<T...>, U<T...>>
    struct is_type_instance_of<L<T...>, U> : std::true_type
    {
    };

    template <class T, template <class...> class U>
    constexpr bool is_type_instance_of_v = is_type_instance_of<T, U>::value;

    template <class... T>
    struct typelist
    {
    };

    template <class... Ts, class... Us>
        requires(!is_type_instance_of_v<Us, typelist> && ...)
    consteval auto append(typelist<Ts...>, Us...)
    {
        return typelist<Ts..., Us...>{};
    }

    template <class... Ts, class... Us>
    consteval auto append(typelist<Ts...>, typelist<Us...>)  // TODO: Handle several typelists
    {
        return typelist<Ts..., Us...>{};
    }
 

    template <class TypeList, class... Us>
        requires mpl::is_type_instance_of_v<TypeList, typelist>
    using append_t = decltype(append(TypeList{}, Us{}...));

    template <class... T>
    constexpr std::size_t size(typelist<T...> = {})
    {
        return sizeof...(T);
    }

    template <typename TList>
    concept any_typelist = is_type_instance_of_v<TList, typelist>;
 
    namespace impl
    {
        template <class From, template <class...> class To>
        struct rename_impl;
 
        template <template <class...> class From, template <class...> class To, class... T>
        struct rename_impl<From<T...>, To>
        {
            using type = To<T...>;
        };
    }

    template <class From, template <class...> class To>
    using rename = typename impl::rename_impl<From, To>::type;


    template <template <class...> class W, class T>
    concept type_wrapper = std::same_as<W<T>, typelist<T>> or std::same_as<W<T>, std::type_identity_t<T>>;

    template <template <class> class P, class T>
    concept ct_type_predicate = requires {
        { P<T>::value } -> std::convertible_to<bool>;
    };

    template< class P, class T >
    concept callable_type_predicate = std::semiregular<std::decay_t<P>>
        and (
                requires(std::decay_t<P> predicate)
                {
                    { predicate(typelist<T>{}) } -> std::convertible_to<bool>;
                }
            or
                requires(std::decay_t<P> predicate)
                {
                    { predicate(std::type_identity_t<T>{}) } -> std::convertible_to<bool>;
                }
            )
        ;

    template <class T, template <class> class P>
        requires ct_type_predicate<P, T>
    consteval bool evaluate(P<T>)
    {
        return P<T>::value;
    }

    template <class T, callable_type_predicate<T> P>
    [[nodiscard]] consteval bool evaluate(P predicate)
    {
        if constexpr (requires(std::decay_t<P> p) {
                          { p(typelist<T>{}) } -> std::same_as<bool>;
                      })
        {
            return predicate(typelist<T>{});
        }
        else
        {
            return predicate(std::type_identity_t<T>{});
        }
    }
 
    namespace predicate
    {

        template <class T>
        struct same_as
        {
            template <template <class...> class W, class X>
                requires type_wrapper<W, X>
            consteval bool operator()(W<X>) const
            {
                return std::same_as<T, X>;
            }
        };
    }
 
    template <template <class> class P>
    struct ct_type_predicate_to_callable
    {
        template <template <class...> class W, class T>
            requires ct_type_predicate<P, T> and type_wrapper<W, T>
        consteval bool operator()(W<T>) const
        {
            return P<T>::value;
        }
    };

    template <template <class> class P>
    consteval auto as_predicate()
    {
        return ct_type_predicate_to_callable<P>{};
    };


    template <class Predicate, template <class...> class L, class... T>
        requires any_typelist<L<T...>> and (callable_type_predicate<Predicate, T> && ...)
    [[nodiscard]] consteval bool any_of(L<T...>, [[maybe_unused]] Predicate predicate = {})
    {
        return (evaluate<T>(predicate) || ... || false);
    }

    template <template <class> class Predicate, template <class...> class L, class... T>
        requires any_typelist<L<T...>> and (ct_type_predicate<Predicate, T> && ...)
    [[nodiscard]] consteval bool any_of(L<T...> list)
    {
        return any_of(list, as_predicate<Predicate>());
    }

    template <class Predicate, template <class...> class L, class... T>
        requires any_typelist<L<T...>> and (callable_type_predicate<Predicate, T> && ...)
    [[nodiscard]] consteval bool all_of(L<T...>, [[maybe_unused]] Predicate predicate)  // predicate is used
                                                                                        // but GCC does not
                                                                                        // see it, that's why
                                                                                        // we use
                                                                                        // [[maybe_unused]]
    {
        return (evaluate<T>(predicate) && ... && true);
    }

    template <template <class> class Predicate, template <class...> class L, class... T>
        requires any_typelist<L<T...>> and (ct_type_predicate<Predicate, T> && ...)
    [[nodiscard]] consteval bool all_of(L<T...> list)
    {
        return all_of(list, as_predicate<Predicate>());
    }

    template <class V, any_typelist L>
    [[nodiscard]] consteval bool contains(L list)
    {
        return any_of(list, predicate::same_as<V>{});
    }

    template <class Predicate, template <class...> class L, class... T>
        requires any_typelist<L<T...>> and (callable_type_predicate<Predicate, T> && ...)
    [[nodiscard]] consteval std::size_t find_if(L<T...>, Predicate predicate)
    {
        std::size_t idx = 0;
        auto check = [&](bool match_success)
        {
            if (match_success)
            {
                return true;
            }
            else
            {
                ++idx;
                return false;
            }
        };
 
        (check(evaluate<T>(predicate)) || ...);
 
        return idx;
    }

    template <template <class> class Predicate, template <class...> class L, class... T>
        requires any_typelist<L<T...>> and (ct_type_predicate<Predicate, T> && ...)
    [[nodiscard]] consteval std::size_t find_if(L<T...> list)
    {
        return find_if(list, as_predicate<Predicate>());
    }

    template <class TypeToFind, any_typelist L>
    [[nodiscard]] consteval std::size_t find(L list)
    {
        return find_if(list, predicate::same_as<TypeToFind>{});
    }
 
    namespace impl
    {
        template <template <class...> class F, class... L>
        struct transform_impl
        {
            static_assert(dependent_false<L...>::value, "transform can apply to typelist-like types only");
        };
 
        template <template <class...> class F, template <class...> class L, class... T>
        struct transform_impl<F, L<T...>>
        {
            using type = L<F<T>...>;
        };
 
        template <template <class...> class F, template <class...> class L1, class... T1, template <class...> class L2, class... T2>
        struct transform_impl<F, L1<T1...>, L2<T2...>>
        {
            using type = L1<F<T1, T2>...>;
        };
    }

    template <template <class> class F, class... L>
    using transform = typename impl::transform_impl<F, L...>::type;

 
    template <class T>
    struct add_const_lvalue_reference : std::add_lvalue_reference<std::add_const_t<T>>
    {
    };
 
    template <class T>
    using add_const_lvalue_reference_t = typename add_const_lvalue_reference<T>::type;
 
    template <typename T, bool is_const>
    struct constify
    {
        using type = std::conditional_t<is_const, const T, T>;
    };
 
    template <typename T, bool is_const>
    struct constify<T&, is_const>
    {
        using type = std::conditional_t<is_const, const T&, T&>;
    };
 
    // `constify_t` is required since `std::add_const_t<T&>`
    // is not `const T&` but `T&`.
    template <class T, bool is_const>
    using constify_t = typename constify<T, is_const>::type;

    template <class T>
    using iter_const_reference_t = std::common_reference_t<const std::iter_value_t<T>&&, std::iter_reference_t<T>>;

    template <class T>
    concept constant_iterator = std::input_iterator<T>
                                && std::same_as<iter_const_reference_t<T>, std::iter_reference_t<T>>;

    template <class T>
    concept constant_range = std::ranges::input_range<T> && constant_iterator<std::ranges::iterator_t<T>>;

    [[noreturn]] inline void unreachable()
    {
        // Uses compiler specific extensions if possible.
        // Even if no extension is used, undefined behavior is still raised by
        // an empty function body and the noreturn attribute.
#if defined(_MSC_VER) && !defined(__clang__)  // MSVC
        __assume(false);
#else  // GCC, Clang
        __builtin_unreachable();
#endif
    }

    template <class BoolRange>
    concept bool_convertible_range = std::ranges::range<BoolRange>
                                     && std::convertible_to<std::ranges::range_value_t<BoolRange>, bool>;

    template <class T>
    concept boolean_like = std::is_assignable_v<std::add_lvalue_reference_t<std::decay_t<T>>, bool>
                           and requires { static_cast<bool>(std::declval<T>()); };

    template <class From, class To>
    concept convertible_ranges = std::convertible_to<std::ranges::range_value_t<From>, std::ranges::range_value_t<To>>;
 
    // Matches any `unique_ptr` instance.
    template <typename T>
    concept unique_ptr = mpl::is_type_instance_of_v<std::remove_reference_t<T>, std::unique_ptr>;
 
    // Matches any `unique_ptr` or derived instance.
    template <typename T>
    concept unique_ptr_or_derived = unique_ptr<T>
                                    || std::derived_from<T, std::unique_ptr<typename T::element_type>>;
 
    // Matches any `shared_ptr` instance.
    template <typename T>
    concept shared_ptr = mpl::is_type_instance_of_v<std::remove_reference_t<T>, std::shared_ptr>;
 
    // Matches any `shared_ptr` or derived instance.
    template <typename T>
    concept shared_ptr_or_derived = shared_ptr<T>
                                    || std::derived_from<T, std::shared_ptr<typename T::element_type>>;
 
    // Matches any `unique_ptr` or `shared_ptr` instance.
    template <typename T>
    concept smart_ptr = unique_ptr<T> || shared_ptr<T>;
 
    // Matches any `unique_ptr` or `shared_ptr` or derived instance.
    template <typename T>
    concept smart_ptr_and_derived = shared_ptr_or_derived<T> || unique_ptr_or_derived<T>;
 
    // Matches any type that is testable
    template <class T>
    concept testable = requires(T t) { t ? true : false; };
 
    // Fails if the Qualifier is true for Y but not for T.
    template <typename T, typename Y, template <typename> typename Qualifier>
    concept T_matches_qualifier_if_Y_is = Qualifier<T>::value || !Qualifier<Y>::value;
 
    // helper class to exclude copy and move constructors beeing routed
    // to a constructor with variadic arguments / perfect forwarding
    template <class CLS, class... ARGS>
    struct excludes_copy_and_move_ctor
    {
        static constexpr bool value = true;
    };
 
    template <class CLS>
    struct excludes_copy_and_move_ctor<CLS>
    {
        static constexpr bool value = true;
    };
 
    template <class CLS, class T>
    struct excludes_copy_and_move_ctor<CLS, T>
    {
        static constexpr bool value = !std::is_same_v<CLS, std::remove_cvref_t<T>>;
    };
 
    template <class CLS, class... ARGS>
    constexpr bool excludes_copy_and_move_ctor_v = excludes_copy_and_move_ctor<CLS, ARGS...>::value;

    template <typename I, typename T>
    concept iterator_of_type = std::input_iterator<I>
                               && std::same_as<typename std::iterator_traits<I>::value_type, T>;
 
 
    // todo...make smth better based on sizeof and is pod
    template <class T>
    concept char_like = std::same_as<T, char> || std::same_as<T, std::byte> || std::same_as<T, uint8_t>;
 
    // Concept for std::array
    template <typename T>
    concept std_array = requires {
        typename std::remove_cvref_t<T>::value_type;
        requires std::same_as<
            std::array<typename std::remove_cvref_t<T>::value_type, std::tuple_size<std::remove_cvref_t<T>>::value>,
            std::remove_cvref_t<T>>;
    };
 
    // Concept for fixed-size std::span
    template <typename T>
    concept fixed_size_span = requires {
        typename std::remove_cvref_t<T>::element_type;
        requires std::tuple_size_v<T> != std::dynamic_extent;
        requires std::same_as<
            std::span<typename std::remove_cvref_t<T>::element_type, std::remove_cvref_t<T>::extent>,
            std::remove_cvref_t<T>>;
    };
 
}