> Hello again,
>
> I have started using your serialization library. It is working pretty
> well, but I have run into a few small problems:
>
> 1) No serialization for bitset: No big deal, because I can just
> convert to ulong, but I was surprised it wasn't there.
Feel free to add it in along with a test. I would like to see people adding
serialization bit by bit to the existing data structures as the need becomes
apparent. We're coming to the view that these things should be added to the
data structures themselves rather than the serialization library. I'm
trying to get myself out of the business of serializing things.
>
> 2) I have a text archive with a bunch of pairs of strings. I want to
> append another pair. There doesn't seem to a way to append items
> to an archive.
LOL - an interesting question that only recently - (in the last couple of
months) occurred to me.
There is no reason that you can't create an archive and just append to it as
many times as you see fit.
Oa << t;
...
Oa << t;
EXCEPT that the t (and its constituents) should have its serialization trait
set so that memory tracking is turned off. Otherwise, copies subsequent to
the first one won't copy any data - just a pointer to the original.
I have considered making and testing an example of such a thing, but I've
been busy. To support this and make a good example what is really needed
is:
a) another archve construction flag - "no_tracking" to suppress memory
tracking for the archive regardless of the setting for each individual type.
b) serialization added to boost::any and/or boost::variant. Probably doable
but maybe a little tricky.
In this way one could just save willy-nilly anything to the archive and load
later. This would be very interesting for things like database transaction
logs which want to implement rollback/rollforward and things like that. It
would also make a dynamite log for debugging.
Again, feel free to explore this at your leisure.
> 3) similarly, if I'm reading items from an archive, there is no simple
> way to keep reading until the end of the file. I have to catch the
> exception, which seems wrong for such an unexceptional
> circumstance. Setting a fail bit as with streams would be nicer.
Checking the fail bit on the stream before reading the next archived item
should work. It's intended to anyway. If it doesn't work it's a bug. There
might be a little tweaking required as I didn't test for this specifically.
If you try this and it doesn't work and you find the oversight let me know
and I'll add the fix. Better yet, make and test a small test and submit it
to me and I'll add it into the test suite.
> However, you could take the view that you should always know what
> is in the archive, and to have a method of failure that does not
> throw an exception would invite errors. That suggests that a
> constructor flag might work (e.g. throw_on_eof default to true).
I recently discovered that one can set a flag on an input stream so that an
attempt to read past eof will throw an exception. This would leave all
options open. After learning ths I'm considering removing the code that
checks the fail bit as I would like to leave the flexibility for the user
and make the serialization library smaller. BTW the fail bit means - "the
next operation is expected to fail", NOT "the last operation failed". This
confused me for quite a while until I actually carefully read the
documentation for stream rather than presuming what I thought was obvious.
> 4) A minor point: It would be nice to be able to construct an archive
> with a boost::filesystem::path, instead of creating an fstream and
> then using that to create the archive. It is certainly nice that I
> can attach an existing stream to an archive, but directly using a
> path would reduce some clutter. It would also make it a little
> safer, because I couldn't accidently insert something into the
> stream that was not serialized.
Feel free to make your own - it should be trivial exercise. It should be
easy to do deriving from any of the current archives. Polymorhphic archive
works this way. Its one template that "adapts" any archive it's applied to.
Also the current setup is specifically designed to permit serialized data to
be embedded within some other data stream if the user requires it. I haven't
specifically tested this either.
> I have read large parts of the discussions when you were submitting
> your library, but not all. If I have missed something, you can just
> point me to it.
Seems like you've pretty much got it. The thing that takes special care is
the serialization of pointers through abstract base pointers. This works
fine but there are a couple of non-intuitive aspects that can trip you up.
The manual is pretty complete. This is mostly because I kept adding to it
as questions kept coming up on the list. So I would hope that one can
understand and use the package without going back and trolling through the
list.
If you don't mind, I'm posting this to the list. Your questions are
interesting, good grist for the list, and help diminish the frequency of the
same questions getting asked multiple times.
Robert Ramey
