template.hpp

Go to the documentation of this file.

#pragma once
namespace mal_toolkit
{
    namespace _template_detail
    {
        template <typename A>
        constexpr size_t CalculateSize()
        {
            return sizeof(A);
        }
 
        template <typename A, typename B, typename... Args>
        constexpr size_t CalculateSize()
        {
            return sizeof(A) + CalculateSize<B, Args...>();
        }
 
        template <typename T>
        consteval size_t index_of_helper(std::size_t)
        {
            return std::numeric_limits<std::size_t>::max();
        }
 
        template <typename T, typename U>
        consteval size_t index_of_helper(std::size_t index)
        {
            if constexpr (std::is_same_v<T, U>)
            {
                return index;
            }
            return index_of_helper<T>(index + 1);
        }
 
        template <typename T, typename U, typename V, typename... Rest>
        consteval size_t index_of_helper(std::size_t index)
        {
            if constexpr (std::is_same_v<T, U>)
            {
                return index;
            }
            else
            {
                return index_of_helper<T, V, Rest...>(index + 1);
            }
        }
 
        template <typename Func>
        struct function_traits;
 
        template <typename Ret, typename... Args>
        struct function_traits<std::function<Ret(Args...)>>
        {
            using ArgumentTypes = std::tuple<Args...>;
        };
 
        template <typename Func>
        struct index_of_function_arg;
 
        template <typename Ret, typename... Args>
        struct index_of_function_arg<std::function<Ret(Args...)>>
        {
            template <typename T>
            static consteval size_t index_of_type()
            {
                return index_of_helper<T, Args...>(0);
            }
        };
    }  // namespace _template_detail
 
    template <typename... Args>
    struct parameter_pack_info
    {
        static constexpr size_t size = _template_detail::CalculateSize<Args...>();
        static constexpr size_t amount = sizeof...(Args);
 
        template <size_t index>
        struct type_at
        {
            static_assert(index < size);
            using type = std::tuple_element_t<index, std::tuple<Args...>>;
        };
    };
 
    template <typename T, typename... Types>
    consteval size_t index_of_type()
    {
        return _template_detail::index_of_helper<T, Types...>(0);
    }
 
    template <typename T, typename Func>
    consteval std::size_t index_of_function_arg([[maybe_unused]] Func const &func = {})
    {
        return _template_detail::index_of_function_arg<Func>::template index_of_type<T>();
    }
 
    // based on https://artificial-mind.net/blog/2020/10/31/constexpr-for
 
    template <auto begin, auto end, auto inc, class F>
    constexpr void constexpr_for(F &&f)
    {
        f(std::integral_constant<decltype(begin), begin>{});
        if constexpr (begin + inc >= end)
        {
            return;
        }
        else  // else should be constexpr as well
        {
            constexpr_for<begin + inc, end, inc>(std::forward<F>(f));
        }
    }
    template <auto begin, auto end, auto inc, class F>
    constexpr void constexpr_for_break(F &&f)
    {
        if (not f(std::integral_constant<decltype(begin), begin>{}))
        {
            return;
        }
        if constexpr (begin + inc >= end)
        {
            return;
        }
        else  // else should be constexpr as well
        {
            constexpr_for<begin + inc, end, inc>(std::forward<F>(f));
        }
    }
 
    template <class iterator, class F>
    constexpr bool for_each_true(iterator begin, iterator const &end, F &&f)
    {
        bool rv = true;
        for (; begin != end;)
        {
            rv &= f(begin++);
        }
        return rv;
    }
 
    template <typename T>
    concept EnumClassConcept = std::is_enum_v<T> && !std::convertible_to<T, int>;
 
    template <EnumClassConcept Enumeration>
    constexpr auto as_integer(Enumeration const value) -> typename std::underlying_type<Enumeration>::type
    {
        return static_cast<typename std::underlying_type<Enumeration>::type>(value);
    }
 
    template <typename T>
    struct return_type;
 
    template <typename R, typename... Args>
    struct return_type<R(Args...)>
    {
        using type = R;
    };
 
    template <typename R, typename... Args>
    struct return_type<R (*)(Args...)>
    {
        using type = R;
    };
 
    template <typename R, typename C, typename... Args>
    struct return_type<R (C::*)(Args...)>
    {
        using type = R;
    };
 
    template <typename R, typename C, typename... Args>
    struct return_type<R (C::*)(Args...) &>
    {
        using type = R;
    };
 
    template <typename R, typename C, typename... Args>
    struct return_type<R (C::*)(Args...) &&>
    {
        using type = R;
    };
 
    template <typename R, typename C, typename... Args>
    struct return_type<R (C::*)(Args...) const>
    {
        using type = R;
    };
 
    template <typename R, typename C, typename... Args>
    struct return_type<R (C::*)(Args...) const &>
    {
        using type = R;
    };
 
    template <typename R, typename C, typename... Args>
    struct return_type<R (C::*)(Args...) const &&>
    {
        using type = R;
    };
 
    template <typename R, typename C, typename... Args>
    struct return_type<R (C::*)(Args...) volatile>
    {
        using type = R;
    };
 
    template <typename R, typename C, typename... Args>
    struct return_type<R (C::*)(Args...) volatile &>
    {
        using type = R;
    };
 
    template <typename R, typename C, typename... Args>
    struct return_type<R (C::*)(Args...) volatile &&>
    {
        using type = R;
    };
 
    template <typename R, typename C, typename... Args>
    struct return_type<R (C::*)(Args...) const volatile>
    {
        using type = R;
    };
 
    template <typename R, typename C, typename... Args>
    struct return_type<R (C::*)(Args...) const volatile &>
    {
        using type = R;
    };
 
    template <typename R, typename C, typename... Args>
    struct return_type<R (C::*)(Args...) const volatile &&>
    {
        using type = R;
    };
 
    template <typename T>
    using return_type_t = typename return_type<T>::type;
}  // namespace mal_toolkit