#include <iostream>
#include <vector>
#include <map>
#include <string>
using namespace std ;

#include <boost/variant.hpp>
#include <boost/variant/variant_fwd.hpp>

#include <boost/mpl/vector.hpp>
#include <boost/mpl/contains.hpp>
#include <boost/mpl/if.hpp>

namespace mpl = boost::mpl;

struct NoneType : public mpl::na { };
struct boost::recursive_variant_{};

class fioVariant;

namespace
{
	typedef mpl::vector <
		NoneType
		, int
		, double
		, string
		, boost::recursive_wrapper < vector<fioVariant> >
		, boost::recursive_wrapper < map<string, fioVariant> >
		, bool
		> VariantTypes;

  typedef boost::make_recursive_variant_over <
		VariantTypes
      > :: type fioVariant_;
}

typedef vector<fioVariant> VariantVec;
typedef VariantVec::iterator VariantVecIter;
typedef VariantVec::const_iterator VariantVecIterC;

typedef map<string, fioVariant> VariantMap;
typedef VariantMap::iterator VariantMapIter;
typedef VariantMap::const_iterator VariantMapIterC;

class fioVariant
{
#define TYPE_CHECKER(name, type)                                             \
	struct name : public boost::static_visitor<bool>                           \
	{                                                                          \
		template <class T> bool operator() (const T&) const { return false ; }   \
		template <> bool operator() (const type&) const { return true ; }        \
	};                                                                         \
	                                                                           \
	template<>                                                                 \
	struct typeCheckerTag<type> { typedef name tag ; }

	private:
		template<class T>
		struct typeCheckerTag 
		{ };

		TYPE_CHECKER(none_type_checker, NoneType);
		TYPE_CHECKER(int_type_checker, int);
		TYPE_CHECKER(vec_type_checker, VariantVec);
		TYPE_CHECKER(map_type_checker, VariantMap);
		TYPE_CHECKER(string_type_checker, std::string);
		TYPE_CHECKER(double_type_checker, double);
		TYPE_CHECKER(bool_type_checker, bool);

		template <class T>
			struct invalid_type
			{
				static bool check_type_of(const fioVariant_& p_var) { return false ; }
			};

		template <class T>
			struct valid_type
			{
				static bool check_type_of(const fioVariant_& p_var)
				{
					typedef typename typeCheckerTag<T>::tag tag;
					return boost::apply_visitor(tag(), p_var);
				}
			};

		template <class T>
			struct variant_type 
			: public mpl::if_ < 
					 typename mpl::contains<VariantTypes, T>::type
				 , valid_type<T>
				 , invalid_type<T>
				 >::type {};

	public:
		explicit fioVariant () : m_var (NoneType()) { }
		explicit fioVariant (int p_i) : m_var(p_i) { }
		explicit fioVariant (const string& p_s) : m_var(p_s) { }
		explicit fioVariant (const char* p_s) : m_var(string(p_s)) { }
		explicit fioVariant (bool p_b) : m_var(p_b) { }
		explicit fioVariant (const VariantMap& p_vm) : m_var(p_vm) { }

		template<class T>
			bool isType() 
			{
				return variant_type<T>::check_type_of(m_var);
			}

		bool empty()
		{
			return isType<NoneType>();
		}

	private:
		fioVariant_ m_var;
};

int main (void)
{
	VariantMap vm;
	vm.insert (make_pair ("Some String", 10));
	vm.insert (make_pair ("Some Other String", 5));

	fioVariant fio (vm);

	if (fio.isType<VariantMap>())
		cout << "Map Type" << endl ;
	else
		cout << "Not a Map type" << endl;

	if (fio.empty())
		cout << "Empty Type" << endl ;
}