#ifndef _APPLY_TUPLE_H_
#define _APPLY_TUPLE_H_

#include <stddef.h>
#include <tuple>
#include <type_traits>
#include <utility>

namespace qtl
{

	namespace detail
	{

#if ((defined(_MSVC_LANG) && _MSVC_LANG >= 201703L) || __cplusplus >= 201703L)

		template <class F, class Tuple>
		inline constexpr decltype(auto) apply_tuple(F &&f, Tuple &&t)
		{
			return std::apply(std::forward<F>(f), std::forward<Tuple>(t));
		}

#else

		namespace detail
		{
			template <size_t N>
			struct apply
			{
				template <typename F, typename T, typename... A>
				static inline auto apply_tuple(F &&f, T &&t, A &&...a)
					-> decltype(apply<N - 1>::apply_tuple(
						std::forward<F>(f), std::forward<T>(t),
						std::get<N - 1>(std::forward<T>(t)), std::forward<A>(a)...))
				{
					return apply<N - 1>::apply_tuple(std::forward<F>(f), std::forward<T>(t),
													 std::get<N - 1>(std::forward<T>(t)), std::forward<A>(a)...);
				}
			};

			template <>
			struct apply<0>
			{
				template <typename F, typename T, typename... A>
				static inline typename std::result_of<F(A...)>::type apply_tuple(F &&f, T &&, A &&...a)
				{
					return std::forward<F>(f)(std::forward<A>(a)...);
				}
			};
		}

		template <typename F, typename T>
		inline auto apply_tuple(F &&f, T &&t)
			-> decltype(detail::apply<std::tuple_size<
							typename std::decay<T>::type>::value>::apply_tuple(std::forward<F>(f), std::forward<T>(t)))
		{
			return detail::apply<std::tuple_size<
				typename std::decay<T>::type>::value>::apply_tuple(std::forward<F>(f), std::forward<T>(t));
		}

#endif // C++17

	}

}

#endif //_APPLY_TUPLE_H_