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 <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)
    {
        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 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 <class L, class T>
        struct contains_impl;
 
        template <template <class...> class L, class T>
        struct contains_impl<L<>, T> : std::false_type
        {
        };
 
        template <template <class...> class L, class T, class... U>
        struct contains_impl<L<T, U...>, T> : std::true_type
        {
        };
 
        template <template <class...> class L, class V, class... U, class T>
        struct contains_impl<L<V, U...>, T> : contains_impl<L<U...>, T>
        {
        };
    }

    template <any_typelist L, class V>
    [[nodiscard]] consteval bool contains()
    {
        return impl::contains_impl<L, V>::value;
    }
 
    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;
 
    namespace impl
    {
        template <class S1, class S2>
        struct merge_set_impl;
 
        template <template <class...> class L, class... T>
        struct merge_set_impl<L<T...>, L<>>
        {
            using type = L<T...>;
        };
 
        template <template <class...> class L, class... T, class U, class... V>
        struct merge_set_impl<L<T...>, L<U, V...>>
        {
            using first_arg = std::conditional_t<contains<L<T...>, U>(), L<T...>, L<T..., U>>;
            using type = typename merge_set_impl<first_arg, L<V...>>::type;
        };
    }

    template <class L1, class L2>
    using merge_set = typename impl::merge_set_impl<L1, L2>::type;
 
    namespace impl
    {
        template <class L>
        struct unique_impl;
 
        template <template <class...> class L, class... T>
        struct unique_impl<L<T...>>
        {
            using type = merge_set<L<>, L<T...>>;
        };
    }

    template <class L>
    using unique = typename impl::unique_impl<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&>;
    };

    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>>;

    template <typename T>
    concept unique_ptr = mpl::is_type_instance_of_v<std::remove_reference_t<T>, std::unique_ptr>;

    template <typename T>
    concept unique_ptr_or_derived = unique_ptr<T>
                                    || std::derived_from<T, std::unique_ptr<typename T::element_type>>;

    template <typename T>
    concept shared_ptr = mpl::is_type_instance_of_v<std::remove_reference_t<T>, std::shared_ptr>;

    template <typename T>
    concept shared_ptr_or_derived = shared_ptr<T>
                                    || std::derived_from<T, std::shared_ptr<typename T::element_type>>;

    template <typename T>
    concept smart_ptr = unique_ptr<T> || shared_ptr<T>;

    template <typename T>
    concept smart_ptr_and_derived = shared_ptr_or_derived<T> || unique_ptr_or_derived<T>;

    template <class T>
    concept testable = requires(T t) { t ? true : false; };

    template <typename T, typename Y, template <typename> typename Qualifier>
    concept T_matches_qualifier_if_Y_is = Qualifier<T>::value || !Qualifier<Y>::value;

    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>;

    template <class T>
    concept char_like = std::same_as<T, char> || std::same_as<T, std::byte> || std::same_as<T, uint8_t>;

    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 to check if the instances of two types can be compared with operator==.
    // Notice that this concept is less restrictive than std::equality_comparable_with,
    // which requires the existence of a common refefenrece type for T and U. This additional
    // restriction makes it impossible to use it in the context of sparrow, where we want to
    // compare objects that are logically similar while being "physically" different.
    template <class T, class U>
    concept weakly_equality_comparable_with = requires(
        const std::remove_reference_t<T>& t,
        const std::remove_reference_t<U>& u
    ) {
        { t == u } -> std::convertible_to<bool>;
        { t != u } -> std::convertible_to<bool>;
        { u == t } -> std::convertible_to<bool>;
        { u != t } -> std::convertible_to<bool>;
    };
}