#ifndef TEST_EXCEPTION_TRANSPORTER_H_
#define TEST_EXCEPTION_TRANSPORTER_H_

#include <boost/mpl/fold.hpp>

#include <boost/type_traits/is_same.hpp>

#include <boost/function.hpp>
#include <boost/variant.hpp>
#include <boost/optional.hpp>

namespace test {

	namespace detail {

		template <typename FunctionType, typename Result> struct base_transporter {

			typedef typename FunctionType function_type;
			typedef typename Result result_type;

			static void call(function_type f, result_type&) {

				f();
			}

			static result_type call(function_type f) {

				return result_type(f());
			}
		};

		template <typename Base, typename Exception>
		struct one_exception_transporter : Base {

			typedef typename Base::function_type	function_type;
			typedef typename Base::result_type		result_type;

			static void	call(function_type f, result_type& v) {
			
				try {

					Base::call(f, v);
				}
				catch (const Exception& e) {

					v.reset(e);
				}
			}

			static result_type call(function_type f) {

				try {

					return Base::call(f);
				}
				catch (const Exception& e) {

					return result_type(e);
				}
			}
		};
	}

	template <typename ExceptionList, typename Result>
	struct exception_transporter {

		typedef boost::function<Result ()> function_type;

		typedef
			typename boost::make_variant_over<ExceptionList>::type
			exception_variant_type;

		typedef typename boost::is_same<Result,void>::type is_void;

		typedef typename boost::mpl::if_<
			is_void,
			boost::optional<exception_variant_type>,
			boost::variant<Result, exception_variant_type>
		>::type result_type;

		exception_transporter(const function_type& f_) : f(f_) {
		}

		result_type operator()() const {

			return boost::mpl::if_<
				is_void,
				call_void,
				call_non_void
			>::type::call(f);		
		}

		typedef typename boost::mpl::fold<
			ExceptionList,
			detail::base_transporter<function_type, result_type>,
			detail::one_exception_transporter<boost::mpl::_1, boost::mpl::_2>
		>::type exception_handler_type;

	private:

		struct call_void {

			template <typename Fun> static result_type call(Fun f) {

				result_type rval;

				exception_handler_type::call(f, result);

				return rval;
			}
		};

		struct call_non_void {

			template <typename Fun> static result_type call(Fun f) {

				return exception_handler_type::call(f);
			}
		};

		boost::function<Result ()> f;
	};
}

#endif /* TEST_EXCEPTION_TRANSPORTER_H_ */