#include <iostream>
#include <sstream>
#include <boost/shared_ptr.hpp>
#include <boost/archive/text_oarchive.hpp>
#include <boost/serialization/serialization.hpp>
#include <boost/serialization/shared_ptr.hpp>

class base
{
public:
    base(std::string type_)
        : type(type_)
    {
    }

    // Make this polymorphic
    virtual ~base() {}

    virtual const boost::shared_ptr<base> clone() const
    {
        const boost::shared_ptr<base> object(new base(type));
        return object;
    }

    std::string type;
};

class derived : public base
{
public:
    derived(std::string type_, std::string string_)
        : base(type_)
        , string(string_)
    {
    }

    virtual const boost::shared_ptr<base> clone() const
    {
        const boost::shared_ptr<derived> object(new derived(type, string));
        return object;
    }

    std::string string;
};

template<class Archive>
void serialize(Archive & ar, base& t,
               const unsigned int file_version)
{
    std::cout << "serialized base " << t.type << std::endl;
    ar & t.type;
}

BOOST_SERIALIZATION_SHARED_PTR(base)

template<class Archive>
void serialize(Archive & ar, derived& t,
               const unsigned int file_version)
{
    std::cout << "serialize derived " << t.string << std::endl;
    ar & boost::serialization::base_object<base>(t);
    ar & t.string;
}

BOOST_SERIALIZATION_SHARED_PTR(derived)

#include <boost/serialization/export.hpp>

BOOST_CLASS_EXPORT(base)
// This statement causes a compiler error
//BOOST_CLASS_TRACKING(base, boost::serialization::track_never)
BOOST_CLASS_EXPORT(derived)
BOOST_CLASS_TRACKING(derived, boost::serialization::track_never)

void write(boost::archive::text_oarchive& archive, boost::shared_ptr<base> t)
{
    const boost::shared_ptr<base> clone = t->clone();
    archive << clone;
}

int main()
{
    std::stringstream sstream;
    {
        boost::archive::text_oarchive archive(sstream, boost::archive::no_tracking);
        
        boost::shared_ptr<derived> d1(new derived("first", "first"));
        boost::shared_ptr<derived> d2(new derived("second", "second"));
        
        // Writes the first object properly
        std::cout << "write first object" << std::endl;
        write(archive, d1);
        // If track_never is active, this will serialize only the derived class
        // It will NOT serialize the base class with it
        // If BOOST_CLASS_TRACKING is not used, this gets serialized as the
        // first object.
        std::cout << "write second object" << std::endl;
        write(archive, d2);
    }
    std::cout << "archive contents: " << sstream.str() << std::endl;

    return 0;
}