#ifndef BOOST_SERIALIZATION_VARIANT_HPP
#define BOOST_SERIALIZATION_VARIANT_HPP

// MS compatible compilers support #pragma once
#if defined(_MSC_VER) && (_MSC_VER >= 1020)
# pragma once
#endif

#if defined(_MSC_VER) && (_MSC_VER <= 1020)
#  pragma warning (disable : 4786) // too long name, harmless warning
#endif

/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
// variant.hpp - non-intrusive serialization of variant types
//
// copyright (c) 2005   
// troy d. straszheim <troy@resophonic.com>
// http://www.resophonic.com
//
// Use, modification and distribution is subject to the Boost Software
// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
// See http://www.boost.org for updates, documentation, and revision history.
//
// thanks to Robert Ramey, Peter Dimov, and Richard Crossley.
//

#include <boost/config.hpp>

#include <boost/mpl/bool.hpp>
#include <boost/mpl/int.hpp>
#include <boost/mpl/at.hpp>
#include <boost/mpl/size.hpp>
#include <boost/mpl/less.hpp>
#include <boost/mpl/identity.hpp>
#include <boost/mpl/eval_if.hpp>

#include <boost/preprocessor/repetition/repeat.hpp>
#include <boost/preprocessor/arithmetic/dec.hpp>
#include <boost/preprocessor/cat.hpp>

#include <boost/serialization/nvp.hpp>
#include <boost/serialization/split_free.hpp>

#include <boost/throw_exception.hpp>
#include <boost/archive/archive_exception.hpp>

#include <boost/variant.hpp>

namespace boost { 
namespace serialization {

namespace detail {

template<typename OArchive>
struct write_variant_value_to_archive_visitor : boost::static_visitor<>
{
	write_variant_value_to_archive_visitor(OArchive& archive)
		: archive(archive)
	{}
	
	template<typename T>
	void operator() (T const& value) const
	{
		archive << BOOST_SERIALIZATION_NVP(value);
	}

private:
	OArchive& archive;
};

namespace mpl = ::boost::mpl;

/** select type in Types by Index but
 * return int on out-of-range
 */
template<typename Types, unsigned int Index>
struct SelectWithDefault :
	mpl::eval_if<
				//check range
			mpl::less<
					mpl::int_<Index>,
					mpl::size<Types>
				>,
				//if ok, choose by Index
			mpl::at<
					Types,
					mpl::int_<Index>
				>,
				//else return int
			mpl::identity<int>
		>
{};

} //namespace detail

///////////////////////////////////////////////////////////////////////////////
// serialization is split up into save/load

///////////////////////////////////////
// save

template<
		typename OArchive,
		BOOST_VARIANT_ENUM_PARAMS(typename T)
	>
void save(
		OArchive& archive,
		boost::variant<BOOST_VARIANT_ENUM_PARAMS(T)> const &var,
		const unsigned int /*version*/
	)
{
	const unsigned int which = var.which();	
	archive << BOOST_SERIALIZATION_NVP(which);
	
	detail::write_variant_value_to_archive_visitor<OArchive> writer(archive);
	apply_visitor(writer, var);
}

///////////////////////////////////////
// load

template<
		typename IArchive,
		BOOST_VARIANT_ENUM_PARAMS(typename T)
	>
void load(
		IArchive& archive,
		boost::variant<BOOST_VARIANT_ENUM_PARAMS(T)>& var,
		const unsigned int /*version*/
	)
{
	namespace mpl = ::boost::mpl;
	
		//convienient typedefs / constants
	typedef variant<BOOST_VARIANT_ENUM_PARAMS(T)> Variant;
	typedef BOOST_DEDUCED_TYPENAME Variant::types Types;
	const int TypesLen = mpl::size<Types>::value;
		
	unsigned int which;
	archive >> BOOST_SERIALIZATION_NVP(which);
	if( which >= TypesLen )
		boost::throw_exception(
			boost::archive::archive_exception(
				boost::archive::archive_exception::unsupported_version
			)
		);
	
		//dispatch type by 'which'
		//for which>=TypesLen try to read an int;
		//the int type is provided by SelectWithDefault
		//the code for reading these ints should actually
		//  not be executed, since always which<TypesLen
		//  by now
	switch(which) {
#ifdef BOOST_SERIALIZATION_VARIANT_SWITCH_MACRO
#error BOOST_SERIALIZATION_VARIANT_SWITCH_MACRO already defined
#endif
#define BOOST_SERIALIZATION_VARIANT_SWITCH_MACRO(z, state, d) \
	case state: { \
			BOOST_DEDUCED_TYPENAME detail::SelectWithDefault< \
					Types, \
					state \
				>::type value; \
			archive >> boost::serialization::make_nvp("data", t); \
			var = value; \
        	        archive.reset_object_address(&var, &value); \
		} \
		break; \
	/**/
BOOST_PP_REPEAT(
		BOOST_VARIANT_LIMIT_TYPES,
		BOOST_SERIALIZATION_VARIANT_SWITCH_MACRO,
		_
	)
#undef BOOST_SERIALIZATION_VARIANT_SWITCH_MACRO
	};
}

///////////////////////////////////////
// call to split
template<
		typename Archive,
		BOOST_VARIANT_ENUM_PARAMS(typename T)
	>
inline void serialize(
		Archive& archive,
		boost::variant<BOOST_VARIANT_ENUM_PARAMS(T)>& var,
		const unsigned int version
	)
{
	split_free(archive, var, version);
}

}} //namespace boost::serialization

#endif