#include <boost/archive/text_oarchive.hpp>
#include <boost/archive/text_iarchive.hpp>
#include <boost/serialization/base_object.hpp>
#include <boost/serialization/export.hpp>

#include <string>
#include <fstream>
#include <sstream>

#include <stdio.h>

using namespace std;


class Protocol {
public:
	Protocol() {}

	Protocol(const string &name) : _name(name) {}

	const string& name() const { return _name; }

private:
	string _name;

	friend class boost::serialization::access;

	template<class Archive>
    void serialize(Archive &ar, const unsigned int version)
	{
		(void) version;
		ar & _name;
	}
};

class Route {
private:
    friend class boost::serialization::access;
	//template<class Archive> friend void save_construct_data(Archive & ar, const Route * t, const unsigned int version);

    int _metric;
    Protocol & _protocol;
    template<class Archive>
	void serialize(Archive &/*ar*/, const unsigned int /*version*/) {}
public:
    Route(int metric, Protocol & protocol) :
        _metric(metric), 
        _protocol(protocol)
    {}

	int metric() const { return _metric; }
	const Protocol& protocol() const { return _protocol; }

	string str() const {
		stringstream ss;
		ss << _metric << ", " << _protocol.name();
		return ss.str();
	}
};

namespace boost { namespace serialization {
template<class Archive>
inline void save_construct_data(Archive & ar, const Route * t, const unsigned int /*version*/)
{
    // save data required to construct instance
	const int x = t->metric();
    ar << x;
    // serialize reference to object as a pointer
    ar << t->protocol();
}

template<class Archive>
inline void load_construct_data(Archive & ar, Route * t, const unsigned int /*version*/)
{
    // retrieve data from archive required to construct new instance
    int metric;
    ar >> metric;
    // create and load data through pointer to object
    // tracking handles issues of duplicates.
    Protocol * protocol;
    ar >> protocol;
    // invoke inplace constructor to initialize instance of my_class
    ::new(t)Route(metric, *protocol);
}
}} // namespace ...

int main()
{
	std::ofstream ofs("snapshot");
	Protocol proto("foobar");
	Route * const route = new Route(456, proto);
	{
		boost::archive::text_oarchive oa(ofs);
		//oa << proto;
		printf("saving Route %s\n", route->str().c_str());
		oa << route;
	}

	Route * loaded_route;
	{
		std::ifstream ifs("snapshot", std::ios::binary);
		boost::archive::text_iarchive ia(ifs);
		ia >> loaded_route;
		printf("loaded Route %s\n", loaded_route->str().c_str());
	}

	return 0;
}