Re: [Boost-users] [serialization] save_construct_data problem

From: Robert Ramey (ramey_at_[hidden])
Date: 2006-07-10 00:24:14

In your test case you serialize SimpleNode instance
rather than a pointer.  So I would ne expect
save_construct_data to be called in this case.

A couple of things don't look right to me.

a0 Node has a serialize function.   But the program
also includes

boost::serialization::void_cast_register<SimpleNode, Node>(NULL,
> NULL);

which I believe should be necessary only if the
SimpleNode serialize function doesn't invoke
base_object ...

b) Of course I'm wondering what CORE_DATA_API
might expand to - and if this might prevent the
compiler from finding the specializaton.

Robert Ramey

Hubert Hoover wrote:
> On Jul 9, 2006, at 15:02, Robert Ramey wrote:
>
>> without seeing the code I'm not sure what to day.
>>
>> Double check that namespace in which save_construct_data is
>> declared/defined.
>
> the save/load construct_data code is all in boost::serialization.
>
> The declarations look like:
>
> in node.h:
> class Node {
> // normal stuff
>     virtual ~Node();
>
>     virtual void some_function() = 0;
>
> private:
>     template <class Archive> void serialize(Archive& ar, const
> unsigned int version);
> };
>
> in simplenode.h:
> class SimpleNode : public Node {
> // normal stuff
> private:
>     template <class Archive> void serialize(Archive& ar, const
> unsigned int version);
> };
>
> in node.hh:
> BOOST_CLASS_TRACKING(Node, boost::serialization::track_always)
> BOOST_IS_ABSTRACT(Node)
>
> in simplenode.hh:
> BOOST_CLASS_TRACKING(CSimpleNode, boost::serialization::track_always)
>
> namespace boost {
>     namespace serialization {
>         template <class Archive>
>             CORE_DATA_API void load_construct_data(Archive& ar,
>                                                    SimpleNode * sn,
>                                                    const unsigned
> int version);
>         template <class Archive>
>             CORE_DATA_API void save_construct_data(Archive& ar,
>                                                    const SimpleNode*
> sn,
>                                                    const unsigned
> int version);
>
> // I've also tried the save with all combinations of Node and
> SimpleNode, * and &, and const/nonconst.
>     }
> }
>
> In another header (nodeset.h) I have:
> #include "node.h"
>
> class NodeSet {
>     typedef std::vector<Node*> NodeVector;
>     NodeVector m_nodes;
>
>     // other stuff to make this useful
>
> private:
>     template <class Archive>
>     void serialize(Archive& ar, const unsigned int version);
> }
>
> template <class Archive> void register_my_types(Archive& ar);
>
>
> The definitions and template instantiations (for serialization) are
> in *.s.cpp.  I'm not sure they're pertinent here, the compiler
> doesn't see them when it's dealing with the code that calls what's in
> the headers.
>
> in nodeset.s.cpp I have:
>
> #include <boost/archive/xml_oarchive.hpp>
> #include <boost/archive/xml_iarchive.hpp>
>
> #include <boost/serialization/ ... several serialization headers
> included>
>
> #include "node.hh"
> #include "simplenode.hh"
>
> template <class Archive>
> void NodeSet::serialize(Archive& ar, const unsigned int version)
> {
>     ar & BOOST_SERIALIZATION_NVP(m_nodes);
> }
>
> template <class Archive>
> void register_my_types(Archive& ar)
> {
>     ar.register_type(static_cast<SimpleNode*>(NULL));
>     ar.register_type(static_cast<NodeSet*>(NULL));
>
>     boost::serialization::void_cast_register<SimpleNode, Node>(NULL,
> NULL);
> }
>
> In the test (calling) code, I have:
>
> #include "node.hh"
> #include "simplenode.hh"
>
> std::string calling_function(NodeSet& ns)
> {
>     std::ostringstream oss;
>     boost::archive::xml_oarchive oar(oss);
>     register_my_types(oar);
>     oar << ns;
>     std::string res = oss.str();
>     return str;
> }
>
> There's other code for readback, but it (so far) appears to be ok.
> There's obviously a LOT of actual detail missing, but I think I've
> included the essential bits.  My actual test case is slightly more
> complex, as it includes several other classes - however, I have
> already gotten THOSE classes to properly serialize.  I only ran into
> the problem when I added the Node and SimpleNode classes (NodeSet is
> actually represented by a different class, but it holds an m_nodes
> member exactly as shown here.
> I'd include more, but what with my other cruft and classes, my
> current test case is actually over 2000 lines...
> But again, I only ran into the problem with the addition of the above
> Node and SimpleNode classes.
>
>> I have a structure I'm trying to serialize that contains an STL
>> vector of
>> pointers to an abstract base type.  When I serialize it, the
>> save_construct_data free function is NOT called - the inline
>> default version
>> is always used.  On de-serializing, the load_construct_data IS
>> called!  but,
>> of course, fails because the data for it isn't there (although it
>> throws
>> archive_exception(archive_exception::unregistered_class) when it
>> fails).