###  | # 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. To use this downloaded version rather than the one included with boost, set an environmental variable SPIRIT_ROOT to be equal to the root directory where the downloaded copy of spirit has been placed. E. G.

    set SPIRIT_ROOT=c:/spirit16

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.

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

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

© Copyright Robert Ramey 2002-2004. Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)