#ifndef TEST_THREAD_WITH_EXCEPTIONS_H_
#define TEST_THREAD_WITH_EXCEPTIONS_H_

#include "exception_transporter.h"

#include <boost/thread.hpp>

namespace test {

	namespace detail {

		struct throw_ : boost::static_visitor<> {

			template <typename T> void operator()(const T& t) const {
			
				throw t;
			}
		};
	}

	template <typename ExceptionList, typename Result = void> struct thread_with_exceptions {		

		template <typename Fun> thread_with_exceptions(Fun f) :	thread(transporter_wrapper(f, result)) {
		}

		Result join() {			

			thread.join();

			return boost::mpl::if_<
				boost::is_same<Result, void>,
				void_return,
				non_void_return>::type::return_(*result);
		}
	
		typedef exception_transporter<ExceptionList, Result> transporter;
		typedef typename transporter::result_type result_type;

	private:

		struct transporter_wrapper {

			transporter_wrapper(
				boost::function<Result ()> f_,
				boost::optional<result_type>& result_)
				: f(f_), result(result_) {
			}

			void operator()() {

				result.reset(transporter(f)());
			}

		private:

			boost::function<Result ()> f;

			boost::optional<result_type>& result;
		};

		struct void_return {

			static void return_(const result_type& result) {

				if(result) {

					boost::apply_visitor(detail::throw_(), *result);

					assert(0);
				}
			}
		};

		struct non_void_return {

			static Result return_(const result_type& result) {
			
				return boost::apply_visitor(local_visitor(), result);
			}

		private:

			struct local_visitor : boost::static_visitor<Result> {

				Result operator()(const Result& r) const {

					return r;
				}

				Result operator()(
					const typename transporter::exception_variant_type& exceptions) const {
				
					boost::apply_visitor(detail::throw_(), exceptions);

						//shouldn't be able to get here.
						//this is to avoid warning
					throw 0;
				}
			};
		};

		boost::optional<result_type> result;

		boost::thread thread;		
	};
}

#endif /* TEST_THREAD_WITH_EXCEPTIONS_H_ */