#pragma warning(disable : 4275)
#pragma warning(disable : 4251)

#include <boost/thread/thread.hpp>
#include <boost/variant/variant.hpp>
#include <boost/variant/apply_visitor.hpp>
#include <boost/variant/get.hpp>
#include <boost/mpl/front.hpp>
#include <boost/mpl/pop_front.hpp>
#include <boost/mpl/empty.hpp>
#include <iostream>

namespace details
{
	template<bool is_empty>
		struct caller_impl
	{
		template<class ExceptionTypeList, class Function, class Result> 
			static void call(Function f, Result *res)
		{
			*res = f();
		}
	};


	template<>
		struct caller_impl<false>
	{
		template<class ExceptionTypeList, class Function, class Result> 
			static void call(Function f, Result *res)
		{
			try
			{
				typedef boost::mpl::pop_front<ExceptionTypeList>::type popped;
				caller_impl<boost::mpl::empty<popped>::value>::call<popped>(f, res);
			}
			catch (boost::mpl::front<ExceptionTypeList>::type e)
			{
				*res = e;
			}
		}
	};
		
	template<class ResultsType, class ThreadFunc>
		class caller
	{
	public:
		caller(ThreadFunc f, ResultsType & res)
			:	f_(f),
				res_(res)
		{
		}
		void operator()()
		{
			try
			{
				// remove the return value type, all of the rest are exception types to be caught
				typedef typename boost::mpl::pop_front<ResultsType::types>::type popped;
				caller_impl<boost::mpl::empty<popped>::value>::call<popped>(f_, &res_);
			}
			catch (...)
			{
				res_ = std::bad_exception();
			}
		}
	private:
		ThreadFunc		f_;
		ResultsType &	res_;
	};

}

template<typename ReturnType,	typename T0 = boost::detail::variant::void_ ,
								typename T1 = boost::detail::variant::void_ ,
								typename T2 = boost::detail::variant::void_ ,
								typename T3 = boost::detail::variant::void_ ,
								typename T4 = boost::detail::variant::void_ ,
								typename T5 = boost::detail::variant::void_ ,
								typename T6 = boost::detail::variant::void_ ,
								typename T7 = boost::detail::variant::void_
							>
	class async_call
{
	typedef typename boost::variant<ReturnType, std::bad_exception, T0, T1, T2, T3, T4, T5, T6, T7 >	result_types_;
public:
	template<class ThreadFunc> 
		async_call(ThreadFunc thread_func)
			:	thr_(details::caller<result_types_, ThreadFunc>(thread_func, res_))
	{
	}

	ReturnType result()
	{
		thr_.join();
		if (const ReturnType* p = boost::get<ReturnType>(&res_))
		{
			return *p;
		}
		boost::apply_visitor(rethrower(), res_);

		// unreachable code, but the compiler isn't so sure and warns us.
		throw std::bad_exception();
	}

private:
	struct rethrower : boost::static_visitor<>
	{
		template<class Exception>
			void operator()(Exception e) const
		{
			throw e;
		}
	};
	result_types_	res_;
	boost::thread	thr_;
};

int do_throw()
{
	throw std::exception("an exception");
}

int dont_throw()
{
	return 42;
}

int throw_unexpected()
{
	throw std::string();
}

template<class Function>
	void test(Function function)
{
	try
	{
		async_call<int, std::exception>	async(function);
		std::cout << "Test Result =  " << async.result() << std::endl;
	}
	catch (std::exception e)
	{
		std::cout << "Exception caught : " << e.what() << std::endl;
	}
}


int main()
{
	test(do_throw);
	test(dont_throw);
	test(throw_unexpected);
}