Boost logo

Boost :

From: troy d. straszheim (troy_at_[hidden])
Date: 2005-03-01 07:22:51

Hey all, Robert specifically --

I've got fascinated with all the uses for this serialize() method, and
I'm kicking around ideas for a couple archive types. The use case is an
"Event" that occurs in a neutrino detector. This event is very big, it
contains containers of smart pointers to containers of maps of smart
pointers to... you get the idea. 15k lines of just containers of data.

First notion is a pretty_oarchive. Currently I have people implementing
operator<<() which calls a member function virtual ToStream() (so
reference-to-base works) for debugging/hacking purposes, and if
everything has a serialize method anyway, it would be a big savings to
forget the ToStream() stuff and say

pretty_oarchive(cout) << my_class;

where pretty_oarchive is something like xml_oarchive, but with the
formatting somehow factored out and modified. I admit that other than
the header and start/end tags I haven't looked at this too closely
because I assumed it had been discussed, thought I'd check for
showstoppers first.

random_iarchive (written already):

The other issue is that with such a large event, you'd want to be able
to verify that it makes the round trip to/from the archive intact.
Obviously boost::serialization has thorough test suites, but with people
constantly tinkering around in these classes, I was hoping to get a test
suite going that does exactly what we're doing. You'd like to be able
to just

Event written_e, read_e;
binary_oarchive oa;
binary_iarchive ia;
random_iarchive ria;
ria >> written_e;
oa << written_e;
// close, open as input
ia >> read_e;

assert(written_e == read_e);

where random_iarchive sets fundamental types to random values, expands
containers to some random length (random() % MAX_RANDOM_LENGTH), and
creates a T when it sees shared_ptr<T>. I've written this already.
Of course you have to write your operator==()'s so that they have value
semantics, that is they compare what is on the ends of their component
shared_ptrs, not whether these pointers point to the same object or not.
   The original idea was to set the serialize() method and the
operator==() against one another for verification... but if people
forget to modify both, there's no way to tell from the test suites, it
seems. It kind of started as an experiment and now that it is written
it looks like there's no way to keep users from shooting themselves in
the foot like this.

Another problem is that if a class contains vector<shared_ptr<Base> >,
you'd like to be able to populate this with shared_ptr<Derived>, where
Derived is randomly selected from the set of classes that inherit from
Base. Since serialization requires these classes to be registered, it
seemed to me there might be a way to do this. But maybe its all overkill.

Anyhow, this random_iarchive exists (except for the Base/Derived thing,
above), maybe it would make a good tutorial case for custom
serialization archives, maybe people want to use it for something. I'd
be more than glad to write up some tutorial material, I'm sure I'd get a
lot out of it.

As usual, thanks for your time and for a killer library...


Boost list run by bdawes at, gregod at, cpdaniel at, john at