func_switchのヘッダ

この前のfunc_switch、ヘッダにまとめて使ってたりする。
そのソースコード貼っとくのでテキトーに使って、どうぞ。
使いかた：テキトーにヘッダファイル用意してコピペしてそのヘッダをインクルード
VC++での使用を基本としてるのでpragma onceが使えない環境ではマクロを使った一般的なインクルードガードに差し替えてください。

なんかfunc_switchに関係ない関数見えるけど気にしない

#pragma once
#include<type_traits>
#include<tuple>
#include<stdexcept>

namespace dyz_type_traits
{
	using void_tuple = std::tuple<void*>;
	void_tuple enabler;

	template<class Type, class Type2, class... Types>struct all_type_equal_impl
	{
		static const bool value = std::is_same<Type, Type2>::value
		&& all_type_equal_impl<Type, Types...>::value;
	};
	template<class Type, class Type2>struct all_type_equal_impl<Type, Type2>
	{
		static const bool value = std::is_same<Type, Type2>::value;
	};
	template<class Type, class... Types>class are_same
	{
	public:
		static const bool value = all_type_equal_impl<Type, Types...>::value;
	};

	template<size_t... Num>struct index_tuple{};
	template<size_t Max, size_t... Nums>struct index_count :index_count<Max - 1, Max, Nums...>{};
	template<size_t... Nums>struct index_count<0, Nums...>
	{
		using type = index_tuple<0, Nums...>;
	};

	template<class Type, class... Types>struct type_num
	{
		static const int value = 1 + type_num<Types...>::value;
	};
	template<class Type>struct type_num<Type>
	{
		static const int value = 1;
	};

	template<class Ty>struct tuple_num;
	template<class... Types>struct tuple_num<std::tuple<Types...>>
	{
		static const int value = type_num<Types...>::value;
	};

	template<class RetType, class ArgTupleTy, class FuncTy, class ArgTy>struct func_tuple_impl;
	template<class RetType,class ArgTupleTy,class FuncTy,size_t... Nums>
	struct func_tuple_impl<RetType, ArgTupleTy, FuncTy, index_tuple<Nums...>>
	{
		static RetType run(ArgTupleTy& tup, FuncTy &func)
		{
			return func(std::get<Nums>(tup)...);
		}
	};
	template<class RetType,class ArgTupleTy,class FuncTy>
	using func_tuple = func_tuple_impl<RetType, ArgTupleTy, FuncTy,typename index_count<tuple_num<ArgTupleTy>::value - 1>::type>;
	
	template<class RetType, class ArgTupleTy, class FuncTy, class... FuncTypes>struct func_switch_impl
	{
		static RetType run(size_t switch_on,ArgTupleTy& tup, FuncTy& func, FuncTypes&... funcs)
		{
			return (switch_on == 0 ?
				func_tuple<RetType, ArgTupleTy, FuncTy>::run(tup, func) 
				: func_switch_impl<RetType, ArgTupleTy, FuncTypes...>
					::run(switch_on - 1, tup, funcs...));
		}
	};
	template<class RetType, class ArgTupleTy, class FuncTy>struct func_switch_impl<RetType, ArgTupleTy, FuncTy>
	{
		static RetType run(size_t, ArgTupleTy& tup, FuncTy& func)
		{
			return func_tuple<RetType, ArgTupleTy, FuncTy>::run(tup, func);
		}
	};

	template<class RetType,class ArgTupleTy,class... FuncTypes>
	inline RetType func_switch(size_t switch_on,ArgTupleTy&tup, FuncTypes&... funcs)
	{
		return func_switch_impl<RetType, ArgTupleTy, FuncTypes...>::run(switch_on, tup, funcs...);
	}
	template<class RetTy,class... Types>inline typename std::enable_if<are_same<RetTy,Types...>::value,RetTy>::type
		number_filter(size_t num, Types... nums)
	{
		return func_switch<RetTy>(num, std::tuple<int>(), [=](int){return nums; }...);
	}
	template<class Ty>inline void iterator_shift(Ty& ite, int shift)throw(std::out_of_range)
	{
		if (shift > 0)
		{
			for (int i = 0; i < shift; ++i)
			{
				++ite;
			}
		}
		else
		{
			for (int i = 0; i > shift; --i)
			{
				--ite;
			}
		}
	}

}