[Boost-users] [Serialization] Why is std::string a primitive type? Tracking for share_ptr

[Jeffrey A. Edlund]

I'm trying to serialize a hierarchical data structure like the
following:

class StorageVar;

typedef std::vector<StorageVar> sv_list;
typedef std::map<std::string, StorageVar > sv_dict;
typedef std::pair<std::string, StorageVar > sv_dict_pair;

typedef boost::variant <
boost::shared_ptr<size_t>,boost::shared_ptr<int>,boost::shared_ptr<double>,boost::shared_ptr<std::string>,
boost::shared_ptr<std::vector<size_t> >,
boost::shared_ptr<std::vector<int> >,
boost::shared_ptr<std::vector<double> >,
boost::recursive_wrapper<boost::shared_ptr< sv_list > >,
boost::recursive_wrapper<boost::shared_ptr< sv_dict > >,
boost::recursive_wrapper<boost::shared_ptr< sv_dict_pair > > > StorageVar_data_imp;

class StorageVar_imp {
public:
StorageVar_imp(): data(new StorageVar_data_imp) {};
boost::shared_ptr<StorageVar_data_imp> data;
boost::shared_ptr<sv_dict> attributes;
};

class StorageVar {
public:
boost::shared_ptr<StorageVar_imp> content;
StorageVar(): content(new StorageVar_imp) {};
/* Further functionality removed for clarity. */
}

I had been hoping to serialize this nonintrustively, but quickly ran
into problems. Here's my understanding of the situation: As has been
mentioned on the list before, Boost.Serialize refuses to serialize
shared_ptrs to primitive types because tracking is turned off for
primitive types and cannot be turned on. Primitive types used in my
example include size_t,int,double, and std::string. I can understand
(sort of) why you wouldn't want to track all the numeric types, but I
don't understand why std::string is considered now considered a
primitive. (Looking at boost/serialization/string.hpp indicates that
it wasn't a primitive type at some point.)

The way that's mentioned in the archive to get around this is to use
BOOST_STRONG_TYPEDEF(int,tracked_int) etc. This would require that I
change the data structure (an intrusive change) and add a static_cast<
T&>(variable) everywhere these wrapped variables are used. (This is
because the "strong" typedef really just makes a new class with your
type inside it with basic methods defined.)

The other possible solution that I've looked at is to define
void serialize(Archive &ar, boost::shared_ptr<T> & arg, const unsigned
int version) myself for all my primitive types. That seems like
the wrong thing to do, but I'll probably do something with that until I
find a better way.

I might be missing something, but couldn't
boost/serialization/shared_ptr.hpp be rewritten to keep track of all the
pointers that it sees without turning tracking on for all primitive
types? Basically just automatically track anything that's inside a
shared_ptr. The programmer shouldn't be storing both a shared_ptr to
memory and a normal pointer to the same memory anyway.

Other info: Boost trunk r44086 (yesterday) built on Ubuntu with
g++. (I had been using 1.33.1 but that seemed to have problems
serializing vector<int>.)

Thanks,

Jeffrey
_______________________________________________
Boost-users mailing list
Boost...@lists.boost.org
http://lists.boost.org/mailman/listinfo.cgi/boost-users

[Robert Ramey]

I didn't want to make std::string a primitive type. It just turned
out I had to do it get out of a corner related to the fact that
std::string type is used in the serialization header. I also felt
that accidently tracking every std::string probably would't
be a good idea in any case - so here we are.

> The way that's mentioned in the archive to get around this is to use
> BOOST_STRONG_TYPEDEF(int,tracked_int) etc. This would require that I
> change the data structure (an intrusive change) and add a static_cast<
> T&>(variable) everywhere these wrapped variables are used. (This is
> because the "strong" typedef really just makes a new class with your
> type inside it with basic methods defined.)

I think you could make a temporary wrapper something like

ar & static_cast<BOOST_STRONG_TYPEDEF(int, tracked_int) &> i

I don't think the follow should be necessary, but maybe it is.

class template<class Archive>
serialize(
Archive &ar,
BOOST_STRONG_TYPEDEF(int, tracked_int) & i,
const unsigned version
){
ar & i;
}

> I might be missing something, but couldn't
> boost/serialization/shared_ptr.hpp be rewritten to keep track of all
> the pointers that it sees without turning tracking on for all primitive
> types?

LOL - be my guest. boost::shared_ptr does not meet the requirements
of the "serializable concept". Hence it has to be turned into something
that does and that is what is serialized. Sure its inefficient - but its
the
only think that can be done under the circumstances.

> Basically just automatically track anything that's inside a
> shared_ptr. The programmer shouldn't be storing both a shared_ptr to
> memory and a normal pointer to the same memory anyway.

Robert Ramey