Serialization

Release Notes

Requirements
Differences from version 1.32
Pending Issues

This is the Boost 1.33 Serialization Library. There are currently 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 requires Boost version 1.33 or later.

The serialization library uses the boost spirit package to load XML archives. We have found that all tests pass using spirit 1.6x. Spirit 1.8 and higher does not work with older compilers - specificallly MSVC 6, Borland and GCC < 3.0. If you are using one of these compilers, you may download a version of spirit 1.6 here. Choose the latest 1.6.x Spirit only version available. To use this downloaded version rather than the one included with boost, you have two options: either replace the boost/spirit and libs/spirit directories, as well as the boost/spirit.hpp header, with those in the downloaded version, or extract Spirit 1.6 to a different directory and add the corresponding include directive to your tools/build/v2/user-config.jam file for all the compilers that need it, as in the following example:


using borland : 5.6.4 : "C:/Program Files/Borland/CBuilder6/Bin/bcc32" : 
        <cxxflags>-IC:/spirit1.6 ;

If you're not using bjam and the Jamfile to build the library, be sure that the directory which contains the version of spirit you plan to use is placed at the front of the list of include paths.

Differences from Boost 1.32

Dynamic Linking Library (DLLs and shared libraries) for platforms which support them. See Automatic Linking on Windows.
Implementation of auto-link for compilers which can support this.
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 serializaton 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.
Miscelleanous bug fixes.

Differences from Boost 1.33

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

Pending issues

Compile, and test on more platforms
implement is_virtual_base<T> to automatically eliminate redundancy in virtual base class serialization.
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' which cannot be rendered in XML without an escape mechanism. Currently there is no such escape mechanism implemented.
A subtle error in the implementation of serialiaton 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.
Floating point values which are number cannot be serialized to text base archives.

Aside from the above, there are a number of issus related to specific platforms. These are listed in Specific Compiler/Library Issues.