[boost] serialization archive types: random_iarchive, pretty_oarchive

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...

-t