Serialization

Release Notes

As of this is written, there are no known bugs. However, due to compiler/library
quirks and or bugs, some tests fail with some combinations of compilers and libraries.

Requirements

This library has been tested against Boost version 1.37.

Differences from Boost 1.37

There are no new features in this version. As of this writing, all bug reports filed
as TRAK tickets have been addressed. There are some TRAK tickets pending which
would best be described as feature requests. See Pending Issues.

Differences from Boost 1.36

There are no new features in this version. As of this writing, all bug reports filed
as TRAK tickets have been addressed.

Differences from Boost 1.35

The library is now thread safe. That is, multiple archives can be open in different
threads. This has been implmented with a lock-free algorithm to avoid any performance
bottlenecks.

Serialization of types defined in shared libraries is now supported. shared libraries
(DLLS) can be loaded/unloaded dynamically at runtime. This includes the serialization
of instances of abstract base classes so that a program can be written so as to
be compatible with as yet undefined and un-implemented code.

The extended type info system has been enhanced to in order to implement the above.
It is now a general purpose system for creating and casting of types about which
is only known a string ID and an abstract base class.

All bug reports filed as TRAK tickets have been addressed.

As of this writing, the library will fail build on older compilers such as MSVC
before version 7.1 and older versions of Borland compilers. This might or might
not change in the future.

Differences from Boost 1.34

Enhanced support for fast serialization for native binary archives. By Mattias Troyer.

Improved implementation of "export" functionality. Removes header ordering requirement
and eliminates the maintenance of a pre-determined list of "known archives" By David
Abrahams.

Improved support for STLPort.

Differences from Boost 1.33

Native Binary archives use the std::streambuf
interface. This should result in noticeably faster execution in many cases.

Differences from Boost 1.32

Better support for Argument Dependent Lookup
and two-phase lookup. This results in simpler rules regarding the placing of serialization
specializations namespaces.

Enhanced documentation to help explain usage of the above.

Adjustments to improve support for less conformant compilers.

Improved const correctness for save/load operators. Note that this
may produce compile time errors in code which compiled without problem in earlier
boost releases. In most cases the fix is trivial. In other cases, code should be
scrutinized to be sure that it doesn't use the serialization system in a way which
may introduce subtle bugs in to the program. A fuller explanation of this issue
can be found here.

A new implementation of serialization for shared_ptr<T>.
This is compatible with public interface of shared_ptr<T>
so it should be more robust and not have to change in the future. The implementation
optionally includes code to load shared_ptr<T>
stored in archives created with boost 1.32. This code is stored in the header: boost/serialization/shared_ptr_132.hpp. If
your application needs to load archives created with boost 1.32 libraries, include
the above header before each inclusion of boost/serialization/shared_ptr.hpp.

More compilers tested and supported.

Miscellaneous bug fixes.

Pending issues

Rvalues cannot be serialized. It would be possible to implement this for
untracked types, but this has not been done.

Pointers to pointers cannot currently be serialized

currently can't serialize through a pointer an object a of class that implements
its own new/delete
operators.

Its possible that std::string and std::wstring
contain characters such as '\0' and -1 (EOF) which cannot be rendered in text and
XML archives without an escape mechanism. Currently there is no such escape mechanism
implemented.

A subtle error in the implementation of serializaton of
std::map is fixed in this version. Unfortunately, the fix breaks serialization
of std::map
for those compilers which do not support partial template specialization. Also,
types which contain pointers or tracked types might not work correctly.