関数オブジェクトから関数のシグネチャを取得する

関数オブジェクトから関数のシグネチャを取得するテンプレートクラスを作ってみました
戻り値、引数や修飾子情報を取れます

# 1.シグネチャ取得
```cpp:FuncSignature.h

template<class _RetType, class... _Args>
struct FuncSignatureAbstract
{
	//!<@brief	戻り値の型
	using RetType = _RetType;
	//!<@brief	引数群の型(tuple型)
	using ArgsType = std::tuple<_Args...>;

	//	インデックス指定の型
	template <size_t index>
	struct Arg
	{
	using Type = typename std::tuple_element<index, 
               std::tuple<_Args...>>::type;
	};

	//!<@brief	引数の数を取得
	static	constexpr size_t ArgsLength() { return sizeof...(_Args); }

	//!<@brief	引数群のサイズを取得
	static	constexpr size_t ArgsSize() {
		constexpr ArgsType args;
		size_t size = 0ULL;
		TupleForEach(args, [&size](auto it) {
		size += sizeof(decltype(it));
		});
		return size;
		}

		//!<@brief	戻り値の型サイズを取得
		static	constexpr size_t RetTypeSize()
		{
			return SizeOf<RetType>::GetSize();
		}

	
	private:
		template<class T>
		struct SizeOfDefault {
			static constexpr size_t	GetSize() { return sizeof(T); }
		};

		template<class T>
		struct SizeOf : SizeOfDefault<T> {};

		template<>
		struct SizeOf<void>
		{
			static constexpr size_t	GetSize() { return 0; }
		};

　　　　　template<class... Types, typename FuncType>
　　　　　constexpr void TupleForEach(const std::tuple<Types...>& _tuple, FuncType func)
	　　　{
			std::apply([&](auto... args) constexpr {
				(func(args), ...);
				}, _tuple);
	　　　}
};

		
template<class _ClassType, class _RetType, class... _Args>
		struct FuncSignatureMemberFunc : public FuncSignatureAbstract<_RetType, _Args...>
		{
			//!<@brief	クラス型
			using ClassType = _ClassType;

			//!<@brief	メンバ関数か
			static	constexpr	bool	IsMemberFunc() { return false; }
		};



template<typename T>
struct FuncSignatureSignature;

template<class _RetType, class... _ArgsType>
struct FuncSignature<_RetType(*)(_ArgsType...)> : 
	public Detail::FuncSignatureAbstract<_RetType, _ArgsType...>
{
	//	修飾子情報
	//!<@brief	constか
	static	constexpr	bool	IsConst() { return false; }
	//!<@brief	volatileか
	static	constexpr	bool	IsVolatile() { return false; }
	//!<@brief	メンバ関数か
	static	constexpr	bool	IsMemberFunction() { return false; }
};

template<class ClassType, class _RetType, class... _ArgsType>
struct FuncSignature<_RetType(ClassType::*)(_ArgsType...)> :
	public Detail::FuncSignatureMemberFunc<ClassType, _RetType, _ArgsType...>
{
	//	修飾子情報
	//!<@brief	constか
	static	constexpr	bool	IsConst() { return false; }
	//!<@brief	volatileか
	static	constexpr	bool	IsVolatile() { return false; }
};

template<class ClassType, class _RetType, class... _ArgsType>
struct FuncSignature<_RetType(ClassType::*)(_ArgsType...)const> :
	public Detail::FuncSignatureMemberFunc<ClassType, _RetType, _ArgsType...>
{
	//	修飾子情報
	//!<@brief	constか
	static	constexpr	bool	IsConst() { return true; }
	//!<@brief	volatileか
	static	constexpr	bool	IsVolatile() { return false; }
};

template<class ClassType, class _RetType, class... _ArgsType>
struct FuncSignature<_RetType(ClassType::*)(_ArgsType...)volatile> :
	public Detail::FuncSignatureMemberFunc<ClassType, _RetType, _ArgsType...>
{
	//	修飾子情報
	//!<@brief	constか
	static	constexpr	bool	IsConst() { return false; }
	//!<@brief	volatileか
	static	constexpr	bool	IsVolatile() { return true; }
};

template<class ClassType, class _RetType, class... _ArgsType>
struct FuncSignature<_RetType(ClassType::*)(_ArgsType...)const volatile> :
	public Detail::FuncSignatureMemberFunc<ClassType, _RetType, _ArgsType...>
{
	//	修飾子情報
	//!<@brief	constか
	static	constexpr	bool	IsConst() { return true; }
	//!<@brief	volatileか
	static	constexpr	bool	IsVolatile() { return true; }
};

```

```cpp:main.cpp

class Test
{
public:
 int Func(int, float)const{return 0}
}

int main()
{

// 引数の数
constexpr auto argsLength = FuncSignature<decltype(&Test::Func)>::ArgsLength();

return 0;
}
```
# 2.おまけ
これを使って任意の関数を実行できるクラスも適当に作ってみました

```cpp:anyFunc
class AnyFunc
{
public:
	constexpr AnyFunc()noexcept :
		mObjectPtr(nullptr),
		mIsConst(false),
		mIsVolatile(false),
		mIsMemberFunc(false),
		mArgsLength(0U),
		mArgsSize(0ULL),
		mClassSize(0ULL){}

	template<class _ClassType, class _RetType, class... _ArgsType>
	AnyFunc(_RetType(_ClassType::*objPtr)(_ArgsType...)const):
		mObjectPtr(force_cast<void*>(objPtr)),
		mIsConst(true),
		mIsVolatile(false),
		mIsMemberFunc(true),
		mArgsLength(GetSignature<decltype(objPtr)>::ArgsLength()),
                mArgsSize(GetSignature<decltype(objPtr)>::ArgsSize()),
		mClassSize(sizeof(GetSignature<decltype(objPtr)>::ClassType ))
	{

	}

	template<class RetType = void, class ClassType, class... Args>
	RetType	Invoke(ClassType* classPtr, Args... args) const
	{
		using ObjPtrType = RetType(ClassType::*)(Args...);
		ObjPtrType ptr = force_cast<ObjPtrType>(mObjectPtr);

                _wassert(mClassSize == sizeof(ClassType), L"");
		_wassert(mArgsLength == GetSignature<decltype(ptr )>::ArgsSize(), L"");
                _wassert(mArgsSize == sizeof...(Args), L"");

		if constexpr (std::is_same<void, RetType>::value == false)
		{
			return (classPtr->*ptr)(args...);
		}
		else
		{
			(classPtr->*ptr)(args...);
		}
	}

	inline	bool	IsConst()const { return mIsConst; }
	inline	bool	IsVolatile()const { return mIsVolatile; }
	inline	bool	IsMemberFunc()const { return mIsMemberFunc; }
	inline	u32	IsArgsLength()const { return mArgsLength; }

private:
	//!<@brief	オブジェクト
	void* mObjectPtr;
	//!<@brief	const型か
	bool	mIsConst;
	//!<@brief	volatile型か
	bool	mIsVolatile;
	//!<@brief	メンバ関数か
	bool	mIsMemberFunc;
	//!<@brief	引数の数
	u32		mArgsLength;
	//!<@brief	引数群のサイズ
	size_t	mArgsSize;
	//!<@brief	クラスのサイズ
	size_t	mClassSize;
};

```

```cpp:main.cpp

class Test
{
public:
 int Func(int, float)const{return 0}
}

int main()
{

AnyFunc anyFunc(&Test::Func);
anyFunc.Invoke<int>(testObj, 1, 2.0f);

return 0;
}
```
色々とガバガバです
使いどころもわかりません