traits.hpp

Go to the documentation of this file.

#pragma once
#include <iostream>
#include <functional>


namespace templa::traits
{

    template <typename T>
    struct strip
    {
        using type = T;
    };
 
    template <typename T>
    struct strip<const T>
    {
        using type = strip<T>::type;
    };
 
    template <typename T>
    struct strip<volatile T>
    {
        using type = strip<T>::type;
    };
 
    template <typename T>
    struct strip<const volatile T>
    {
        using type = strip<T>::type;
    };
 
    template <typename T>
    struct strip<T *>
    {
        using type = strip<T>::type;
    };
 
    template <typename T>
    struct strip<const T *>
    {
        using type = strip<T>::type;
    };
 
    template <typename T>
    struct strip<volatile T *>
    {
        using type = strip<T>::type;
    };
 
    template <typename T>
    struct strip<const volatile T *>
    {
        using type = strip<T>::type;
    };

    template <typename T>
    using strip_t = strip<T>::type;



    template <class F>
    struct function_traits
    {
    private:
        using call_type = function_traits<decltype(&F::type::operator())>;
 
    public:
        using return_type = typename call_type::return_type;

        static constexpr std::size_t arity = call_type::arity - 1;

        template <std::size_t N>
        struct argument
        {
            static_assert(N < arity, "error: invalid parameter index.");
            using type = typename call_type::template argument<N + 1>::type;
        };
    };

    template <typename R, typename... Args>
    struct function_traits<R(Args...)>
    {
        using return_type = R;

        static constexpr std::size_t arity = sizeof...(Args);

        template <std::size_t N>
        struct argument
        {
            static_assert(N < arity, "error: invalid parameter index.");
            using type = typename std::tuple_element<N, std::tuple<Args...>>::type;
        };
    };

    template <class R, class... Args>
    struct function_traits<R (*)(Args...)> : public function_traits<R(Args...)>
    {
    };

    template <class C, class R, class... Args>
    struct function_traits<R (C::*)(Args...)> : public function_traits<R(C &, Args...)>
    {
    };

    template <class C, class R, class... Args>
    struct function_traits<R (C::*)(Args...) const> : public function_traits<R(C &, Args...)>
    {
    };

    template <class C, class R>
    struct function_traits<R(C::*)> : public function_traits<R(C &)>
    {
    };

    template <class F>
    struct function_traits<F &> : public function_traits<F>
    {
    };

    template <class F>
    struct function_traits<F &&> : public function_traits<F>
    {
    };

 
}