Registering user-provided derived types with Boost Serialization

Question

I am writing a library that will handle storing and serializing user-defined types. The user-defined types are required to be themselves serializable.

However the library uses templates to create containers of user types. I don't know how to export the container types to boost::serialization through the templates. The only way I can do it is to force the user of the library to BOOST_CLASS_EXPORT_GUID() every container type.

I've tried unpacking the macro by looking at boost/serialization/export.hpp, but it is slightly complex... Is there a way to export a class as part of the template instantiation? Or another way to write the library to easily serialize containers of user-defined types?

#include <iostream>
#include <vector>

#include <boost/foreach.hpp>
#include <boost/serialization/access.hpp>
#include <boost/serialization/vector.hpp>
#include <boost/serialization/base_object.hpp>
#include <boost/serialization/export.hpp>

#include <boost/archive/text_oarchive.hpp>

//////////////////////////////////////////////////////////////////////////////
// Example code that would reside in the library
//////////////////////////////////////////////////////////////////////////////

struct type_container_base {
private:
    virtual void make_abstract() const {}
    friend class ::boost::serialization::access;
    template <typename ARCHIVE>
    void serialize(ARCHIVE &, const unsigned int) {}    
};

BOOST_SERIALIZATION_ASSUME_ABSTRACT(type_container_base)

template <typename USER_TYPE>
struct type_container : type_container_base {
    void add(const USER_TYPE& d) { _vector.push_back(d); }
private:
    std::vector<USER_TYPE> _vector;
    friend class ::boost::serialization::access;
    template <typename ARCHIVE>
    void serialize(ARCHIVE & ar, const unsigned int) {
        ar & ::boost::serialization::base_object<type_container_base>(*this);
        ar & _vector;
    }
};

//////////////////////////////////////////////////////////////////////////////
// Example user code that would use the library
//////////////////////////////////////////////////////////////////////////////

struct user_type {
    user_type(int i) : _val(i) {}
private:
    int _val;
    friend class ::boost::serialization::access;
    template <typename ARCHIVE>
    void serialize(ARCHIVE & ar, const unsigned int) {
        ar & _val;
    }
};

// *** Is there a better way than forcing the user to do this for every
// *** user_type they want to use with the library?
BOOST_CLASS_EXPORT_GUID(type_container<user_type>, "type_container<user_type>")

int main() {
    std::vector<type_container_base*> containers;
    type_container<user_type>* tc = new type_container<user_type>();
    tc->add(user_type(7));
    tc->add(user_type(42));
    tc->add(user_type(1776));
    containers.push_back(tc);
    {
        boost::archive::text_oarchive ar(std::cout);
        const std::size_t size = containers.size();
        ar << size;
        BOOST_FOREACH(type_container_base* p, containers)
            ar << p;
    }
    return 0;
}

Answer 1

Maybe something along those lines:

#define BOOST_CLASS_TEMPLATE_EXPORT_IMPLEMENT(T)             \
    namespace boost {                                        \
    namespace archive {                                      \
    namespace detail {                                       \
    namespace {                                              \
    template<typename U>                                     \
    struct init_guid< T<U> > {                               \
        static guid_initializer< T<U> > const & g;           \
    };                                                       \
    template<typename U>                                     \
    guid_initializer< T<U> > const & init_guid< T<U> >::g =  \
        ::boost::serialization::singleton<                   \
            guid_initializer< T<U> >                         \
        >::get_mutable_instance().export_guid();             \
    }}}}                                                     \
/**/

#define BOOST_CLASS_TEMPLATE_EXPORT_KEY2(T, K) \
namespace boost {                              \
namespace serialization {                      \
template<typename U>                           \
struct guid_defined< T<U> > : boost::mpl::true_ {}; \
template<typename U>                           \
inline const char * guid< T<U> >(){            \
    return K + "<" + guid<U>() + ">"; //this doesn't work, I know! \
}                                              \
} /* serialization */                          \
} /* boost */                                  \
/**/

#define BOOST_CLASS_TEMPLATE_EXPORT_KEY(T)                             \
    BOOST_CLASS_TEMPLATE_EXPORT_KEY2(T, BOOST_PP_STRINGIZE(T))                                                         \
/**/

#define BOOST_CLASS_TEMPLATE_EXPORT_GUID(T, K)                         \
BOOST_CLASS_TEMPLATE_EXPORT_KEY2(T, K)                                 \
BOOST_CLASS_TEMPLATE_EXPORT_IMPLEMENT(T)                               \
/**/

It might work with some additional tweaks to it. Of course, it would probably assume that the user_type is also exported already. But still, it would reduce the combinatorial dimension, all you need is one export per class and one export per class template, not one export per template instantiation (number of classes X number of class templates).

This is probably the kind of thing that should be asked / requested / proposed to the guy in charge of the Boost.Serialization library (I guess that would be Robert Ramey).