//----------------------------------------------------------------------------
//  Serializer.h
//  Copyright (c) 2006 Move Interactive
//	
//  
//----------------------------------------------------------------------------
#ifndef _FLOWENGINE_CORE_SERIALIZER_XMLSERIALIZER_H_
#define _FLOWENGINE_CORE_SERIALIZER_XMLSERIALIZER_H_

#include "core/serialization/Serializer.h"

#include <sstream>

#include <boost/static_assert.hpp>
#include <boost/type_traits/is_array.hpp>
#include <boost/pfto.hpp>

#include <boost/archive/xml_oarchive.hpp>
#include <boost/archive/xml_iarchive.hpp>

//#include <boost/archive/impl/basic_xml_oprimitive.ipp>
//#include <boost/archive/impl/basic_xml_iprimitive.ipp>
#include <boost/archive/impl/basic_xml_oarchive.ipp>
#include <boost/archive/impl/basic_xml_iarchive.ipp>

#include <boost/archive/impl/archive_pointer_iserializer.ipp>
#include <boost/archive/impl/archive_pointer_oserializer.ipp>


namespace FlowEngine
{
	class XMLArchiveO : public IArchive,
		// don't derive from xml_oarchive !!!
		public boost::archive::xml_oarchive_impl<XMLArchiveO>
	{
		typedef XMLArchiveO derived_t;
#ifndef BOOST_NO_MEMBER_TEMPLATE_FRIENDS
	public:
#else
		friend class boost::archive::detail::interface_oarchive<derived_t>;
		friend class boost::archive::basic_xml_oarchive<derived_t>;		
		friend class boost::archive::save_access;
#endif
		// add base class to the places considered when matching
		// save function to a specific set of arguments.  Note, this didn't
		// work on my MSVC 7.0 system 
		//        using boost::archive::xml_oarchive_impl<derived_t>::load_override;
		// so we use the sure-fire method below.  This failed to work as well
		template<class T>
		void save_override(T & t, BOOST_PFTO int){
			boost::archive::xml_oarchive_impl<XMLArchiveO>::save_override(t, 0);
			// verify that this program is in fact working by making sure
			// that arrays are getting passed here
			BOOST_STATIC_ASSERT(! (boost::is_array<T>::value) );
		}
		template<int N>
		void save_override(const int (& t)[N] , int){
			save_binary(t, sizeof(t));
		}
		template<int N>
		void save_override(const unsigned int (& t)[N], int){
			save_binary(t, sizeof(t));
		}
		template<int N>
		void save_override(const long (& t)[N], int){
			save_binary(t, sizeof(t));
		}
		template<int N>
		void save_override(const unsigned long (& t)[N], int){
			save_binary(t, sizeof(t));
		}
	public:
		XMLArchiveO(std::ostream & os, unsigned flags = 0) :
		  boost::archive::xml_oarchive_impl<derived_t>(os, flags)
		  {}

		  virtual void Serialize(int& t) { *this & BOOST_SERIALIZATION_NVP(t); }
		  virtual void Serialize(bool& t) { *this & BOOST_SERIALIZATION_NVP(t); }
	};
	
		class XMLArchiveI : public IArchive,
		// don't derive from xml_oarchive !!!
		public boost::archive::xml_iarchive_impl<XMLArchiveI>
	{
		typedef XMLArchiveI derived_t;
#ifndef BOOST_NO_MEMBER_TEMPLATE_FRIENDS
	public:
#else
		friend class boost::archive::detail::interface_iarchive<derived_t>;
		friend class boost::archive::basic_xml_iarchive<derived_t>;		
		friend class boost::archive::load_access;
#endif
		// add base class to the places considered when matching
		// save function to a specific set of arguments.  Note, this didn't
		// work on my MSVC 7.0 system 
		//        using xml_oarchive_impl<derived_t>::load_override;
		// so we use the sure-fire method below.  This failed to work as well
		template<class T>
		void load_override(T & t, BOOST_PFTO int){
			boost::archive::xml_iarchive_impl<derived_t>::load_override(t, 0);
			BOOST_STATIC_ASSERT(! (boost::is_array<T>::value) );
		}
		template<int N>
		void load_override(int (& t)[N], int){
			load_binary(t, sizeof(t));
		}
		template<int N>
		void load_override(unsigned int (& t)[N], int){
			load_binary(t, sizeof(t));
		}
		template<int N>
		void load_override(long (& t)[N], int){
			load_binary(t, sizeof(t));
		}
		template<int N>
		void load_override(unsigned long (& t)[N], int){
			load_binary(t, sizeof(t));
		}
	public:
		XMLArchiveI(std::istream & is, unsigned flags = 0) :
		  boost::archive::xml_iarchive_impl<derived_t>(is,flags)
		  {}

		  virtual void Serialize(int& t) { *this & BOOST_SERIALIZATION_NVP(t); }
		  virtual void Serialize(bool& t) { *this & BOOST_SERIALIZATION_NVP(t); }
	};
}

#endif