call_main_template.hpp

Go to the documentation of this file.

// SPDX-License-Identifier: Apache-2.0
// Copyright 2024 XCENA Inc.
 
#pragma once
 
#include <type_traits>
 
#include "mu/access.hpp"
 
namespace mu
{
template <typename T>
class NDArray;
 
template <typename Function>
struct function_traits_helper;
 
template <typename R>
struct function_traits_helper<R (*)(void)>
{
    static constexpr unsigned arity = 0;
    typedef R result_type;
};
 
template <typename R, typename T1>
struct function_traits_helper<R (*)(T1)>
{
    static constexpr unsigned arity = 1;
    typedef R result_type;
    typedef T1 arg1_type;
    typedef T1 argument_type;
};
 
template <typename R, typename T1, typename T2>
struct function_traits_helper<R (*)(T1, T2)>
{
    static constexpr unsigned arity = 2;
    typedef R result_type;
    typedef T1 arg1_type;
    typedef T2 arg2_type;
    typedef T1 first_argument_type;
    typedef T2 second_argument_type;
};
 
template <typename R, typename T1, typename T2, typename T3>
struct function_traits_helper<R (*)(T1, T2, T3)>
{
    static constexpr unsigned arity = 3;
    typedef R result_type;
    typedef T1 arg1_type;
    typedef T2 arg2_type;
    typedef T3 arg3_type;
};
 
template <typename R, typename T1, typename T2, typename T3, typename T4>
struct function_traits_helper<R (*)(T1, T2, T3, T4)>
{
    static constexpr unsigned arity = 4;
    typedef R result_type;
    typedef T1 arg1_type;
    typedef T2 arg2_type;
    typedef T3 arg3_type;
    typedef T4 arg4_type;
};
 
template <typename R, typename T1, typename T2, typename T3, typename T4, typename T5>
struct function_traits_helper<R (*)(T1, T2, T3, T4, T5)>
{
    static constexpr unsigned arity = 5;
    typedef R result_type;
    typedef T1 arg1_type;
    typedef T2 arg2_type;
    typedef T3 arg3_type;
    typedef T4 arg4_type;
    typedef T5 arg5_type;
};
 
template <typename R, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6>
struct function_traits_helper<R (*)(T1, T2, T3, T4, T5, T6)>
{
    static constexpr unsigned arity = 6;
    typedef R result_type;
    typedef T1 arg1_type;
    typedef T2 arg2_type;
    typedef T3 arg3_type;
    typedef T4 arg4_type;
    typedef T5 arg5_type;
    typedef T6 arg6_type;
};
 
template <typename R, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7>
struct function_traits_helper<R (*)(T1, T2, T3, T4, T5, T6, T7)>
{
    static constexpr unsigned arity = 7;
    typedef R result_type;
    typedef T1 arg1_type;
    typedef T2 arg2_type;
    typedef T3 arg3_type;
    typedef T4 arg4_type;
    typedef T5 arg5_type;
    typedef T6 arg6_type;
    typedef T7 arg7_type;
};
 
template <typename R, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8>
struct function_traits_helper<R (*)(T1, T2, T3, T4, T5, T6, T7, T8)>
{
    static constexpr unsigned arity = 8;
    typedef R result_type;
    typedef T1 arg1_type;
    typedef T2 arg2_type;
    typedef T3 arg3_type;
    typedef T4 arg4_type;
    typedef T5 arg5_type;
    typedef T6 arg6_type;
    typedef T7 arg7_type;
    typedef T8 arg8_type;
};
 
template <typename R, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9>
struct function_traits_helper<R (*)(T1, T2, T3, T4, T5, T6, T7, T8, T9)>
{
    static constexpr unsigned arity = 9;
    typedef R result_type;
    typedef T1 arg1_type;
    typedef T2 arg2_type;
    typedef T3 arg3_type;
    typedef T4 arg4_type;
    typedef T5 arg5_type;
    typedef T6 arg6_type;
    typedef T7 arg7_type;
    typedef T8 arg8_type;
    typedef T9 arg9_type;
};
 
template <typename R, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10>
struct function_traits_helper<R (*)(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)>
{
    static constexpr unsigned arity = 10;
    typedef R result_type;
    typedef T1 arg1_type;
    typedef T2 arg2_type;
    typedef T3 arg3_type;
    typedef T4 arg4_type;
    typedef T5 arg5_type;
    typedef T6 arg6_type;
    typedef T7 arg7_type;
    typedef T8 arg8_type;
    typedef T9 arg9_type;
    typedef T10 arg10_type;
};
 
template <typename>
class remove_member_pointer;
 
template <typename R, typename T>
class remove_member_pointer<R T::*>
{
public:
    using member_type = R;
    using class_type = T;
};
 
template <class T>
struct is_reference
{
    static constexpr bool value = false;
};
template <class T>
struct is_reference<T&>
{
    static constexpr bool value = true;
};
template <class T>
struct is_reference<T&&>
{
    static constexpr bool value = true;
};
 
template <typename T>
struct add_pointer
{
    typedef T* type;
};
 
template <class T>
struct remove_reference
{
    typedef T type;
};
template <class T>
struct remove_reference<T&>
{
    typedef T type;
};
template <class T>
struct remove_reference<T&&>
{
    typedef T type;
};
 
template <class T>
struct is_pointer
{
    static constexpr bool value = false;
};
 
template <class T>
struct is_pointer<T*>
{
    static constexpr bool value = true;
};
template <class T>
struct is_pointer<T* const>
{
    static constexpr bool value = true;
};
template <class T>
struct is_pointer<T* volatile>
{
    static constexpr bool value = true;
};
template <class T>
struct is_pointer<T* const volatile>
{
    static constexpr bool value = true;
};
 
template <class T>
struct remove_pointer
{
    typedef T type;
};
template <class T>
struct remove_pointer<T*>
{
    typedef T type;
};
template <class T>
struct remove_pointer<T* const>
{
    typedef T type;
};
template <class T>
struct remove_pointer<T* volatile>
{
    typedef T type;
};
template <class T>
struct remove_pointer<T* const volatile>
{
    typedef T type;
};
 
template <typename T>
struct is_ndarray : std::false_type
{
};
 
template <typename T>
struct is_ndarray<mu::NDArray<T>> : std::true_type
{
};
 
template <typename T>
constexpr bool is_ndarray_v = is_ndarray<T>::value;
 
namespace detail
{
 
template <typename T>
struct directional_pointer_traits_impl : std::false_type
{
};
 
template <typename T>
struct directional_pointer_traits_impl<mu::input_ptr<T>> : std::true_type
{
    using wire_type = const T*;
 
    static mu::input_ptr<T> fromWire(const T* value)
    {
        return mu::input_ptr<T>(value);
    }
};
 
template <typename T>
struct directional_pointer_traits_impl<mu::output_ptr<T>> : std::true_type
{
    using wire_type = T*;
 
    static mu::output_ptr<T> fromWire(T* value)
    {
        return mu::output_ptr<T>(value);
    }
};
 
template <typename T>
using directional_pointer_traits =
    directional_pointer_traits_impl<std::remove_cv_t<std::remove_reference_t<T>>>;
 
template <typename T>
inline constexpr bool supported_directional_parameter_v =
    !directional_pointer_traits<T>::value || !std::is_reference_v<T>;
 
}  // namespace detail
 
}  // namespace mu