#include <iostream>
#include <string>

#include <boost/serialization/nvp.hpp>
#include <boost/archive/detail/common_oarchive.hpp>

#include <boost/archive/polymorphic_iarchive.hpp>
#include <boost/archive/polymorphic_oarchive.hpp>
#include <boost/archive/detail/polymorphic_oarchive_route.hpp>

class unit
{
  public:

    unit() : id_(0) { }
    unit(int id) : id_(id) { }

#ifndef POLY
    template <typename Archive>
      void serialize(Archive& ar, const unsigned int version)
      {
        ar & BOOST_SERIALIZATION_NVP(id_);
      }
#else
    void serialize(boost::archive::polymorphic_oarchive& ar, const unsigned int version)
    {
      ar & BOOST_SERIALIZATION_NVP(id_);
    }

    void serialize(boost::archive::polymorphic_iarchive& ar, const unsigned int version)
    {
      ar & BOOST_SERIALIZATION_NVP(id_);
    }
#endif

  private:

    int id_;
};

class test_oarchive : public boost::archive::detail::common_oarchive<test_oarchive>
{
  friend class boost::archive::save_access;
  friend class boost::archive::detail::interface_oarchive<test_oarchive>;

  public:

    test_oarchive(std::ostream& out, unsigned int = 0) : out_(out){ }

    void save_binary(const void* address, std::size_t count) { out_.write(static_cast<const char*>(address), count); }

    template <typename T>
      void save(const T& t)
      {
        out_ << t;
      }

#ifdef POLY
    virtual void save(const std::wstring& t)
    {
      // FIXME
    }
#endif

    template <class T>
      void save_override(const boost::serialization::nvp<T>& nvp, int f)
      {
        out_ << "<name=" << nvp.name() << ">";

        typedef boost::archive::detail::common_oarchive<test_oarchive> detail_common_oarchive;
        this->detail_common_oarchive::save_override(nvp.const_value(), f);

        out_ << "</name=" << nvp.name() << ">\n";
      }

    void save_override(const boost::archive::object_id_type & t, int) { }
    void save_override(const boost::archive::object_reference_type & t, int) { }
    void save_override(const boost::archive::version_type & t, int) { }
    void save_override(const boost::archive::class_id_type & t, int) { }
    void save_override(const boost::archive::class_id_optional_type & t, int) { }
    void save_override(const boost::archive::class_id_reference_type & t, int) { }
    void save_override(const boost::archive::class_name_type & t, int) { }
    void save_override(const boost::archive::tracking_type & t, int) { }

  private:

    std::ostream& out_;
};

typedef boost::archive::detail::polymorphic_oarchive_route<test_oarchive> polymorphic_test_oarchive;

namespace boost { namespace archive {

    template class detail::archive_serializer_map<test_oarchive>;
    template class detail::archive_serializer_map<polymorphic_test_oarchive>;

} }

BOOST_SERIALIZATION_REGISTER_ARCHIVE(test_oarchive)
BOOST_SERIALIZATION_REGISTER_ARCHIVE(polymorphic_test_oarchive)

int main()
{
  unit u(42);

#ifndef POLY
  test_oarchive ar(std::cout);
#else
  polymorphic_test_oarchive ar(std::cout);
#endif

  ar << BOOST_SERIALIZATION_NVP(u);
}