#include <iostream>
#include <string>
#include <sstream>

#include <cstdio> // remove
#include <boost/config.hpp>
#if defined(BOOST_NO_STDC_NAMESPACE)
namespace std{ 
  using ::remove;
}
#endif

#include <boost/archive/xml_oarchive.hpp>
#include <boost/serialization/split_free.hpp>

//////////////////////////////////////////////////////////////////////////
template<class T>
class base
{
  friend class boost::serialization::access;
public:
  T x;

public:
  base()
  {}
};//class base

namespace boost 
{ 
  namespace serialization 
  {
    //Serialize
    template<class Archive, class T>
      inline void serialize(Archive& ar, base<T>& obj, const unsigned int version)
    {
      std::cout<<"base:  Serialize\n";
      boost::serialization::split_free(ar, obj, version);
    }

    //Save Archive - base
    template<class Archive, class T>
      inline void save(Archive& ar, const base<T>& obj, const unsigned int version)
    {
      T temp = obj.x;
      ar << BOOST_SERIALIZATION_NVP(temp);
      std::cout<<"base:  Save\n";
    }

    template<class Archive, class T>
      inline void load(Archive& ar, base<T>& obj, const unsigned int version)
    {
      T temp;
      ar >> BOOST_SERIALIZATION_NVP(temp);
      std::cout<<"base:  Load\n";
    }
  };//namespace serialization
};//namespace boost
//////////////////////////////////////////////////////////////////////////


//////////////////////////////////////////////////////////////////////////
template<class T> 
class derived : public base<T>
{
public:
  T y;
  std::string mString;

public:
  derived(): base<T>()
  {
    mString = "derived serialized!!!";
  }
}; //class derived

namespace boost 
{
  namespace serialization
  {
    template<class Archive, class T>
      inline void serialize(Archive& ar, derived<T>& obj, const unsigned int version)
    {
      boost::serialization::split_free(ar, obj, version);
      //ar << BOOST_SERIALIZATION_NVP(obj.y) << BOOST_SERIALIZATION_NVP(obj.mString);
      std::cout<<"derived<T>::Serialize\n";
    }

    template<class Archive, class T>
      inline void save(Archive& ar,  derived<T>& obj, const unsigned int version)
    {
      std::cout<<"derived<T>::Save - Before\n";
      T tempX = obj.x;
      T tempY = obj.y;
      std::string tempStr = obj.mString;

      ar << boost::serialization::base_object<base<T>>(obj);
      ar << BOOST_SERIALIZATION_NVP(tempY);
      ar << BOOST_SERIALIZATION_NVP(tempStr);
      std::cout<<"derived<T>::Save - After\n";
    }

    template<class Archive, class T>
      inline void load(Archive& ar, derived<T>& obj, const unsigned int version)
    {
      ar >> BOOST_SERIALIZATION_BASE_OBJECT_NVP(obj) >>BOOST_SERIALIZATION_NVP(obj.y)>>BOOST_SERIALIZATION_NVP(obj.mString);
      std::cout<<"derived<T>::Load\n";
    }
  };//namespace serialization
};//namespace boost
//////////////////////////////////////////////////////////////////////////

int main(void)
{
  derived<double> originalObject;
  originalObject.x = 100;
  originalObject.y = 2000.23564;

  std::ostringstream ossx;
  boost::archive::xml_oarchive oa(ossx);
  oa<<BOOST_SERIALIZATION_NVP(originalObject);

  std::cout<<ossx.str()<<"\n\n";
}