| 
                 | 
                Serialization
                Release Notes | 
    - Differences from version 1.58
- Differences from version 1.48
- Differences from version 1.45
- Differences from version 1.43
- Differences from version 1.42
- Differences from version 1.41
- Differences from version 1.40
- Differences from version 1.39
- Differences from version 1.37
- Differences from version 1.35
- Differences from version 1.34
- Differences from version 1.33
- Differences from version 1.32
- Pending Issues
As of this writing, there are no known bugs. However, due to compiler/library 
quirks and or bugs, some tests fail with some combinations of compilers and 
libraries.Differences from Boost 1.58
- Eliminated support for Borland compilers and Microsoft compilers prior to version
7.1.
- Eliminated support for compilers which do not support Partial Function Template
Ordering (pfto).
- Added support for "visibility hidden" for GCC compilers.  Shared libraries
will only expose symbols actually needed rather than all sympols in the library.  This
should result in smaller shared libraries which are faster to load.
Differences from Boost 1.48
- Added support for C++11 types such as std::shared_ptr, std::array, and others.
- Implemented the concept of a "Helper" which can be used to implement serialization of types which are otherwise not serializable."
- Made library compatible with C++11,  Compatibility with C++03 has been maintained.
Differences from Boost 1.45
Since the release of version 1.42, it has been discovered that binary
archives created by versions 1.42-1.44 cannot always be read by the
recent binary archive code.  Work has proceeded in detecting the source
of these anomolies and those which have been reported with test cases
have been fixed.  As of this writing, it is not known whether all
binary archives created with these versions can be loaded.
Differences from Boost 1.43
Differences from Boost 1.42
    - fixed failure of shared_ptr serialization when serializing pointers
created from enable_shared_from_this.
    
- added example for a simple archive which can be used as a debug log.
This example illustrates the implemenation of the archive concept to aid
understanding required to create one's own archive classes. The resulting
archive is useful for debugging in that it only 160 lines of code and is
header only - that is, it doesn't required linking to the serialization library.
    
- replaced example used to show how to derive from an existing archive.
This example creates an XML archive class which doesn't include serialization
traits such as class_id, class_version, etc.  It might be useful for exporting
one's class information to osme XML processor and/or debugging programs.
    
- compile time warnings have been implemented to detect practices which
    though correct, will result in operation or side effects different than
    a user probably intends.
    
- Some memory leaks associated with void_cast have been fixed.
Differences from Boost 1.41
    - adjustments have been made to minimize compile time warnings.
    
- compile time warnings have been implemented to detect practices which
    though correct, will result in operation or side effects different than
    a user probably intends.
    
- Some memory leaks associated with void_cast have been fixed.
Differences from Boost 1.40
This library has been tested against Boost version 1.39 and 1.40.
    Changes have been made to archive classes included with the library. Users who 
    have used these a guide to making their own archive classes will find that 
    these will likely no longer compile. This can be remedied by making the 
    following changes in the code which instantiates these archive classes.
Old Code:
...
#include <boost/archive/impl/archive_pointer_iserializer.ipp>
...
template class detail::archive_pointer_iserializer<naked_text_iarchive> ;
...
template class detail::archive_pointer_iserializer<text_iarchive> ;
#include <boost/archive/impl/archive_serializer_map.ipp>
...
template class detail::archive_serializer_map<naked_text_iarchive> ;
...
template class detail::archive_serializer_map<text_iarchive> ;
Differences from Boost 1.39
    - 
        It is now possible to serialize an object through a pointer to a class which 
        implements its own new/deleteoperators. This functionaly is not available on some compilers.
- 
    serialization of polymorphic objects has been sped up considerably.
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.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::streambufinterface. This should result in noticeably faster execution in many cases.
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 constcorrectness 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 ofshared_ptr<T>so it should be more robust and not have to change in the future. The 
        implementation optionally includes code to loadshared_ptr<T>stored in archives created with boost 1.32. This code is stored in 'he 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 ofboost/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
    
- 
        It's possible that std::stringand
            std::wstringcontain 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::mapis fixed in this version. Unfortunately, the fix breaks 
        serialization ofstd::mapfor those compilers which do not support partial template specialization. Also, 
    types which contain pointers or tracked types might not work correctly.
- 
        Serialization of virtual base classes relies upon RTTI.  It will fail when used on
        systems which don't have RTTI enabled.
    Aside from the above, there are a number of issues related to specific 
    platforms. These are listed in Specific 
        Compiler/Library Issues.
    
    © Copyright Robert Ramey 2002-2009. 
        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)