Release 1.43.0

[SVN r61817]

borland6ide/test_simple_class.bpf

@@ -1,3 +0,0 @@
-This file is used by the project manager only and should be treated like the project file
-
-

borland6ide/test_simple_class.bpr

@@ -1,147 +0,0 @@
-<?xml version='1.0' encoding='utf-8' ?>
-<!-- C++Builder XML Project -->
-<PROJECT>
-  <MACROS>
-    <VERSION value="BCB.06.00"/>
-    <PROJECT value="test_simple_class.exe"/>
-    <OBJFILES value="..\test\test_simple_class.obj"/>
-    <RESFILES value="test_simple_class.res"/>
-    <IDLFILES value=""/>
-    <IDLGENFILES value=""/>
-    <DEFFILE value=""/>
-    <RESDEPEN value="$(RESFILES)"/>
-    <LIBFILES value="..\..\..\bin\boost\libs\serialization\build\libboost_serialization.lib\borland\debug\runtime-link-static\libboost_serialization.lib 
-      ..\..\..\bin\boost\libs\serialization\build\libboost_wserialization.lib\borland\debug\runtime-link-static\libboost_wserialization.lib 
-      ..\..\..\bin\boost\libs\test\build\libboost_test_exec_monitor.lib\borland\debug\runtime-link-static\libboost_test_exec_monitor.lib"/>
-    <LIBRARIES value=""/>
-    <SPARELIBS value=""/>
-    <PACKAGES value="vcl.bpi rtl.bpi dbrtl.bpi adortl.bpi vcldb.bpi vclx.bpi bdertl.bpi 
-      vcldbx.bpi ibxpress.bpi dsnap.bpi cds.bpi bdecds.bpi qrpt.bpi teeui.bpi 
-      teedb.bpi tee.bpi dss.bpi teeqr.bpi visualclx.bpi visualdbclx.bpi 
-      dsnapcrba.bpi dsnapcon.bpi bcbsmp.bpi vclie.bpi xmlrtl.bpi inet.bpi 
-      inetdbbde.bpi inetdbxpress.bpi inetdb.bpi nmfast.bpi webdsnap.bpi 
-      bcbie.bpi websnap.bpi soaprtl.bpi dclocx.bpi dbexpress.bpi dbxcds.bpi 
-      indy.bpi bcb2kaxserver.bpi"/>
-    <PATHCPP value=".;..\test"/>
-    <PATHPAS value=".;"/>
-    <PATHRC value=".;"/>
-    <PATHASM value=".;"/>
-    <DEBUGLIBPATH value="$(BCB)\lib\debug"/>
-    <RELEASELIBPATH value="$(BCB)\lib\release"/>
-    <LINKER value="ilink32"/>
-    <USERDEFINES value="_DEBUG;BOOST_ARCHIVE_TEST=xml_warchive.hpp"/>
-    <SYSDEFINES value="NO_STRICT;_NO_VCL;USEPACKAGES"/>
-    <MAINSOURCE value="test_simple_class.bpf"/>
-    <INCLUDEPATH value="..\test;C:\boost_1_31_0;$(BCB)\include;$(BCB)\include\vcl"/>
-    <LIBPATH value="..\test;$(BCB)\lib\obj;$(BCB)\lib"/>
-    <WARNINGS value="-w-par"/>
-    <OTHERFILES value=""/>
-  </MACROS>
-  <OPTIONS>
-    <IDLCFLAGS value="-I..\test -IC:\boost_1_31_0 -I$(BCB)\include -I$(BCB)\include\vcl 
-      -src_suffix cpp -D_DEBUG -DBOOST_ARCHIVE_TEST=xml_warchive.hpp -boa"/>
-    <CFLAG1 value="-Od -Vx -Ve -X- -r- -a8 -b- -k -y -v -vi- -tWC -tWM -c"/>
-    <PFLAGS value="-$YD -$W -$O- -$A8 -v -JPHNE -M"/>
-    <RFLAGS value=""/>
-    <AFLAGS value="/mx /w2 /zd"/>
-    <LFLAGS value="-D&quot;&quot; -ap -Tpe -x -Gn -v"/>
-    <OTHERFILES value=""/>
-  </OPTIONS>
-  <LINKER>
-    <ALLOBJ value="c0x32.obj $(PACKAGES) $(OBJFILES)"/>
-    <ALLRES value="$(RESFILES)"/>
-    <ALLLIB value="$(LIBFILES) $(LIBRARIES) import32.lib cw32mt.lib"/>
-    <OTHERFILES value=""/>
-  </LINKER>
-  <FILELIST>
-      <FILE FILENAME="test_simple_class.res" FORMNAME="" UNITNAME="test_simple_class.res" CONTAINERID="ResTool" DESIGNCLASS="" LOCALCOMMAND=""/>
-      <FILE FILENAME="test_simple_class.bpf" FORMNAME="" UNITNAME="test_simple_class" CONTAINERID="BPF" DESIGNCLASS="" LOCALCOMMAND=""/>
-      <FILE FILENAME="..\test\test_simple_class.cpp" FORMNAME="" UNITNAME="test_simple_class" CONTAINERID="CCompiler" DESIGNCLASS="" LOCALCOMMAND=""/>
-      <FILE FILENAME="..\..\..\bin\boost\libs\serialization\build\libboost_serialization.lib\borland\debug\runtime-link-static\libboost_serialization.lib" FORMNAME="" UNITNAME="libboost_serialization.lib" CONTAINERID="LibTool" DESIGNCLASS="" LOCALCOMMAND=""/>
-      <FILE FILENAME="..\..\..\bin\boost\libs\serialization\build\libboost_wserialization.lib\borland\debug\runtime-link-static\libboost_wserialization.lib" FORMNAME="" UNITNAME="libboost_wserialization.lib" CONTAINERID="LibTool" DESIGNCLASS="" LOCALCOMMAND=""/>
-      <FILE FILENAME="..\..\..\bin\boost\libs\test\build\libboost_test_exec_monitor.lib\borland\debug\runtime-link-static\libboost_test_exec_monitor.lib" FORMNAME="" UNITNAME="libboost_test_exec_monitor.lib" CONTAINERID="LibTool" DESIGNCLASS="" LOCALCOMMAND=""/>
-  </FILELIST>
-  <BUILDTOOLS>
-  </BUILDTOOLS>
-
-  <IDEOPTIONS>
-[Version Info]
-IncludeVerInfo=0
-AutoIncBuild=0
-MajorVer=1
-MinorVer=0
-Release=0
-Build=0
-Debug=0
-PreRelease=0
-Special=0
-Private=0
-DLL=0
-Locale=1033
-CodePage=1252
-
-[Version Info Keys]
-CompanyName=
-FileDescription=
-FileVersion=1.0.0.0
-InternalName=
-LegalCopyright=
-LegalTrademarks=
-OriginalFilename=
-ProductName=
-ProductVersion=1.0.0.0
-Comments=
-
-[HistoryLists\hlIncludePath]
-Count=5
-Item0=..\test;C:\boost_1_31_0\libs\serialization\test;C:\boost_1_31_0;$(BCB)\include;$(BCB)\include\vcl
-Item1=C:\boost_1_31_0\libs\serialization\test;C:\boost_1_31_0;$(BCB)\include;$(BCB)\include\vcl
-Item2=C:\boost_1_31_0\libs;C:\boost_1_31_0\libs\serialization\test;$(BCB)\include;$(BCB)\include\vcl
-Item3=C:\boost_1_31_0\libs\;C:\boost_1_31_0\libs\serialization\test;$(BCB)\include;$(BCB)\include\vcl
-Item4=C:\boost_1_31_0\libs\serialization\test;$(BCB)\include;$(BCB)\include\vcl
-
-[HistoryLists\hlLibraryPath]
-Count=2
-Item0=..\test;C:\boost_1_31_0\libs\serialization\test;$(BCB)\lib\obj;$(BCB)\lib
-Item1=C:\boost_1_31_0\libs\serialization\test;$(BCB)\lib\obj;$(BCB)\lib
-
-[HistoryLists\hlDebugSourcePath]
-Count=1
-Item0=$(BCB)\source\vcl
-
-[HistoryLists\hlConditionals]
-Count=2
-Item0=_DEBUG;BOOST_ARCHIVE_TEST=xml_warchive.hpp
-Item1=_DEBUG
-
-[Debugging]
-DebugSourceDirs=$(BCB)\source\vcl
-
-[Parameters]
-RunParams=
-Launcher=
-UseLauncher=0
-DebugCWD=
-HostApplication=
-RemoteHost=
-RemotePath=
-RemoteLauncher=
-RemoteCWD=
-RemoteDebug=0
-
-[Compiler]
-ShowInfoMsgs=0
-LinkDebugVcl=1
-LinkCGLIB=0
-
-[CORBA]
-AddServerUnit=1
-AddClientUnit=1
-PrecompiledHeaders=1
-
-[Language]
-ActiveLang=
-ProjectLang=
-RootDir=
-  </IDEOPTIONS>
-</PROJECT>

build/Jamfile.v2

@@ -8,28 +8,50 @@
 
 project boost/serialization
     : source-location ../src
-    ;
+    : requirements
+      <conditional>@include-spirit
+;
 
+SPIRIT_ROOT = [ modules.peek : SPIRIT_ROOT ] ;
 rule include-spirit ( properties * )
 {
-    local result ;
-    local SPIRIT_ROOT = [ modules.peek : SPIRIT_ROOT ] ;
-    for local tset in borland { # vc iw
-        if ( <toolset>$(tset) in $(properties) ) {
-            if ( $(SPIRIT_ROOT) ) {
-                result = <cxxflags>-I$(SPIRIT_ROOT) ;
-            }
-            else {
-                echo **** spirit 1.6x required to build library with this compiler **** ;
-                result = <build>no ;
+    local old-compiler ;
+    if <toolset>borland in $(properties)
+    {
+        if ! <toolset-borland:version>6.1.0 in $(properties)  
+        {  
+            old-compiler = true ;  
+        }  
 
-            }
-        }
     }
+    else if <toolset>msvc in $(properties)
+    {
+        if <toolset-msvc:version>6.5 in $(properties)
+          || <toolset-msvc:version>7.0 in $(properties)
+        {            
+            old-compiler = true ;
+        }        
+    }
+        
+    local result ;
+    if $(old-compiler)
+    {        
+        if $(SPIRIT_ROOT)
+        {
+            # note - we can't use <include>$(SPIRIT_ROOT) because 
+            # it puts -I$(SPIRIT_ROOT) AFTER the "../../.." in the command line.
+            # so use these instead 
+            result = <cxxflags>-I$(SPIRIT_ROOT) ;
+        }
+        else 
+        {
+            echo **** spirit 1.6x required to build library with this compiler **** ;
+            result = <build>no ;
+        }
+    }    
     return $(result) ;
 }
 
-
 SOURCES = 
     basic_archive
     basic_iarchive
@@ -44,44 +66,48 @@ SOURCES =
     basic_xml_archive
     binary_iarchive
     binary_oarchive
-    codecvt_null
     extended_type_info
-    extended_type_info_no_rtti
     extended_type_info_typeid
+    extended_type_info_no_rtti
     polymorphic_iarchive
     polymorphic_oarchive
     stl_port
     text_iarchive
     text_oarchive
     void_cast
+    archive_exception
     xml_grammar
     xml_iarchive
     xml_oarchive
+    xml_archive_exception
+    shared_ptr_helper
 ;
     
 WSOURCES = 
     basic_text_wiprimitive
     basic_text_woprimitive
-    binary_wiarchive
-    binary_woarchive
     text_wiarchive
     text_woarchive
     utf8_codecvt_facet
     xml_wgrammar
     xml_wiarchive
     xml_woarchive
+    codecvt_null
 ;
 
+
 lib boost_serialization 
-        : $(SOURCES).cpp
-	: <toolset>msvc:<cxxflags>/Gy 
-	  <link>shared:<define>BOOST_SERIALIZATION_DYN_LINK=1
-          <conditional>@include-spirit
-	;
+    : $(SOURCES).cpp
+    : 
+    <toolset>msvc:<cxxflags>/Gy
+    <link>shared:<define>BOOST_SERIALIZATION_DYN_LINK=1
+    ;
 
 lib boost_wserialization 
-        : $(WSOURCES).cpp boost_serialization 
-        : <toolset>msvc:<cxxflags>/Gy 
-	  <link>shared:<define>BOOST_SERIALIZATION_DYN_LINK=1	
-          <conditional>@include-spirit
-	;
+    : $(WSOURCES).cpp boost_serialization 
+    :     
+    <toolset>msvc:<cxxflags>/Gy 
+    <link>shared:<define>BOOST_SERIALIZATION_DYN_LINK=1
+    ;
+
+boost-install boost_serialization boost_wserialization ;

build/serialization.jam

@@ -1,126 +0,0 @@
-# Boost serialization Library Build Jamfile
-#  (C) Copyright Robert Ramey 2002-2004.
-#  Use, modification, and distribution are subject to 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)
-#
-#  See http://www.boost.org/libs/serialization for the library home page.
-
-# building this library needs a working version of spirit
-rule toolset::require-boost-spirit-support ( toolset variant : subvariant-path properties * )
-{
-    local requires-spirit = false ;
-    switch $(toolset) {
-    case "borland*" :
-        requires-spirit = true ;
-    case "msvc*" :
-        requires-spirit = true ;
-    case "iw*" :
-        requires-spirit = true ;
-    case "vc-6*" :
-        requires-spirit = true ;
-    case "vc7*" :
-        requires-spirit = true ;
-    case "vc-7_0*" :
-        requires-spirit = true ;
-    case "gcc-2*" :
-        requires-spirit = true ;
-    }
-    if $(requires-spirit) = true {
-        if  $(SPIRIT_ROOT) # && ( exist $(SPIRIT_ROOT) )
-        {
-            properties += <include>$(SPIRIT_ROOT) ;
-        }
-        else {
-            echo **** spirit 1.6x required to build library with this compiler **** ;
-            properties = [ impose-requirements $(properties) : <build>no ] ;
-        }
-    }
-    return $(subvariant-path) $(properties) ;
-}
-
-# certain tool sets are known apriori not to support wide char i/o
-rule toolset::require-wide-char-io-support ( toolset variant : subvariant-path properties * )
-{
-    switch $(toolset) {
-    case "*cygwin" :
-        echo **** wide char i/o not supported by cygwin gcc library **** ;
-        properties = [ impose-requirements $(properties) : <build>no ] ;
-
-    case "como*" :
-        echo **** wide char i/o not supported by libcomo standard library **** ;
-        properties = [ impose-requirements $(properties) : <build>no ] ;
-    case "mingw*" :
-        if ! [ MATCH "^([5][.][0])$" : [ get-values <stlport-version> : $(properties) ] ]
-        {
-            echo **** wide char i/o not supported by the mingw standard library **** ;
-            properties = [ impose-requirements $(properties) : <build>no ] ;
-        }
-    }
-    return $(subvariant-path) $(properties) ;
-}
-
-# certain tool sets are known apriori not to support creation of DLLS
-rule toolset::require-shared-libraries-support ( toolset variant : subvariant-path properties * )
-{
-    switch $(toolset) {
-    case "como*" :
-        echo **** DLLs cannot be built with this compiler **** ;
-        properties = [ impose-requirements $(properties) : <build>no ] ;
-    case "msvc-stlport*" :
-        echo **** DLLs cannot be built with this compiler and stlport 4.x **** ;
-        properties = [ impose-requirements $(properties) : <build>no ] ;
-    case "vc-6_5-stlport*" :
-        echo **** DLLs cannot be built with this compiler and stlport 4.x **** ;
-        properties = [ impose-requirements $(properties) : <build>no ] ;
-    case "cw*" :
-        local runtime-link = [ get-values <runtime-link> : $(properties) ] ;
-        if static in $(runtime-link) {
-            echo **** DLLS cannot be built with static runtime linking **** ;
-            properties = [ impose-requirements $(properties) : <build>no ] ;
-        }
-
-    }
-    return $(subvariant-path) $(properties) ;
-}
-
-# certain tool sets display warnings which are not applicable to the serialization library
-rule toolset::suppress-warnings ( toolset variant : subvariant-path properties * )
-{
-    switch $(toolset) {
-    case "vc-8*" :
-        properties = [ impose-requirements $(properties) : <cxxflags>"-wd4996" ] ;    
-    case "*cygwin*" :
-        properties = [ impose-requirements $(properties) : <cxxflags>"-Wno-non-virtual-dtor -Wno-ctor-dtor-privacy" ] ;
-    case "gcc*" :
-        properties = [ impose-requirements $(properties) : <cxxflags>"-Wno-non-virtual-dtor -Wno-ctor-dtor-privacy" ] ;
-    case "mingw*" :
-        properties = [ impose-requirements $(properties) : <cxxflags>"-Wno-non-virtual-dtor -Wno-ctor-dtor-privacy" ] ;
-    case "borland*" :
-        properties = [ impose-requirements $(properties) : <cxxflags>"-w-8080 -w-8071 -w-8057 -w-8062 -w-8008 -w-0018 -w-8066" ] ;
-    }
-    return $(subvariant-path) $(properties) ;
-}
-
-# set optimization switches for certain toolsets. We do it here rather than in the
-# Jamfile requirements because here we can use a regex for the compiler name.
-rule toolset::optimizations ( toolset variant : subvariant-path properties * )
-{
-    switch $(toolset) {
-    case "vc*" :
-        properties = [ impose-requirements $(properties) : <cxxflags>"-Gy" ] ;    
-    case "msvc*" :
-        properties = [ impose-requirements $(properties) : <cxxflags>"-Gy" ] ;
-    case "gcc*" :
-        properties = [ impose-requirements $(properties) : <cxxflags>"-ftemplate-depth-255" ] ;
-    case "qcc*" :
-        properties = [ impose-requirements $(properties) : <cxxflags>"-ftemplate-depth-255" ] ;
-    case "QCC*" :
-        properties = [ impose-requirements $(properties) : <cxxflags>"-ftemplate-depth-255" ] ;
-    case "mingw*" :
-        properties = [ impose-requirements $(properties) : <cxxflags>"-ftemplate-depth-255" ] ;
-    }
-    return $(subvariant-path) $(properties) ;
-}
-
-

doc/acknowledgments.html

@@ -1,4 +1,4 @@
-<!doctype HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
+<!doctype HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
 <html>
 <!--
 (C) Copyright 2002-4 Robert Ramey - http://www.rrsd.com . 
@@ -27,30 +27,34 @@ http://www.boost.org/LICENSE_1_0.txt)
 </table>
 <hr>
 <ul>
+  <li><a href="http://www.autoform.com">AutoForm Engineering GmbH</a> supported
+  development efforts to extend correct serialization to objects stored in DLLS.
+  <li><a href"http://www.cadence.com/il">Cadence Israel</a> supported enhancement
+  and testing of the portable binary archive.
   <li>David Abrahams improved implementation of "export" functionality.  This not
   only eliminated an annoying header sequencing requirement, but also the need to maintain
   a list of "known archives".
-  <li>Mattias Troyer ehnanced the implementation of native binary archives.  This includes
+  <li>Mattias Troyer enhanced the implementation of native binary archives.  This includes
   enhancement and generalization of the library itself including generalization of
   the wrapper concept.
-  <li>Markus Schöpflin tracked down issues with TRU64 compiler resulting in 100% passing.
+  <li>Markus Sch&ouml;pflin tracked down issues with TRU64 compiler resulting in 100% passing.
   <li><a href="mailto::troy@resophonic.com"> Troy D. Straszheim</a> made the initial version of variant serialization.
   <li>Tonko Juricic helped refine and complete project files for VC 7.1 ide
-  <li><a href="../../../people/rene_rivera.htm">Rene Rivera</a> tracked down several issues related to 
+  <li><a href="http://www.boost.org/people/rene_rivera.htm">Rene Rivera</a> tracked down several issues related to 
   Code Warrior, toolset configuration and bjam and much else.
   <li>Martin Ecker detected (and fixed!) a number of sublte errors regarding cyclic
   pointers, shared pointers.  He also built the library as a DLL and raised some issues
   <li>Pavel Vozenilek invested much effort in review of code and documentation
   resulting in many improvements.  In addition he help a lot with porting to other
   platforms including VC 6.0, Intel, and especially Borland.
-  <li><a href="../../../people/jens_maurer.htm">Jens Maurer</a> and
-  <a href="../../../people/beman_dawes.html">Beman Dawes</a> who got the boost
+  <li><a href="http://www.boost.org/people/jens_maurer.htm">Jens Maurer</a> and
+  <a href="http://www.boost.org/people/beman_dawes.html">Beman Dawes</a> who got the boost
   serialization ball rolling.  It was one or both of these two that invented
   the much beloved <code>&amp;</code> syntax used to implement both save and
   load in one fuction specification.
-  <li><a href="../../../people/vladimir_prus.htm">Vladimir Prus</a> for evaluating an
+  <li><a href="http://www.boost.org/people/vladimir_prus.htm">Vladimir Prus</a> for evaluating an
   early draft and contributing the diamond inheritance example.
-  <li><a href="../../../people/william_kempf.htm">William E. Kempf</a>
+  <li><a href="http://www.boost.org/people/william_kempf.htm">William E. Kempf</a>
   who made the templates for this and other boost manuals.  This relieved
   me of much aggravation.
   <li><a href="mailto:vahan@unicad.am">Vahan Margaryan</a> and

doc/archive_reference.html

@@ -1,7 +1,7 @@
 <!doctype HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
 <html>
 <!--
-(C) Copyright 2002-4 Robert Ramey - http://www.rrsd.com . 
+(C) Copyright 2002-10 Robert Ramey - http://www.rrsd.com . 
 Use, modification and distribution is subject to 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)
@@ -26,75 +26,96 @@ http://www.boost.org/LICENSE_1_0.txt)
 </table>
 <hr>
 <dl class="page-index">
-  <dt><a href="#implementation">Implementation</a>
+  <dt><a href="#trivial">Trivial Archive</a>
+  <dt><a href="#implementation">More Useful Archive Classes</a>
   <dt><a href="#usage">Usage</a>
   <dt><a href="#testing">Testing</a>
   <dt><a href="#polymorphic">Polymorphic Archives</a>
 </dl>
-<h3><a name="implementation">Implementation</a></h3>
+
+<h3><a name="trivial">Trivial Archive</a></h3>
 The <a href="archives.html"><strong>Archive</strong></a> concept specifies the functions that a
 class must implement to in order to be used to serialize 
-<a href="serialization.html"><strong>Serializable</strong></a> types. 
-The library implements a family of archives appropriate for different purposes.  
-This section describes how they have been implemented and how one can implement his own archive class.
-Our discussion will focus on archives used for loading as the hierarchy is exactly analogous
-for archives used for saving data.
+<a href="serialization.html"><strong>Serializable</strong></a> types.
+
+Our discussion will focus on archives used for saving as the hierarchy is exactly analogous
+for archives used for loading data.
+
+<h4>Minimum Requirments</h4>
+
+The simplest class which will model the <a href="archives.html"><strong>Archive</strong></a> concept specifies the functions that a
+class will look like:
+
+<pre><code>
+#include &lt;cstddef&gt; // std::size_t
+//////////////////////////////////////////////////////////////
+// class trivial_oarchive
+class trivial_oarchive {
+public:
+    //////////////////////////////////////////////////////////
+    // public interface used by programs that use the
+    // serialization library
+    typedef boost::mpl::bool_&lt;true&gt; is_saving; 
+    typedef boost::mpl::bool_&lt;false&gt; is_loading;
+    template&lt;class T&gt; register_type(){}
+    template&lt;class T&gt; trivial_oarchive & operator&lt;&lt;(const T & t){
+        return *this;
+    }
+    template&lt;class T&gt; trivial_oarchive & operator&(const T & t){
+        return *this &lt;&lt; t;
+    }
+    void save_binary(void *address, std::size_t count){};
+};
+</code></pre>
+The simplest possible input archive class is analogous to the above.
+In the following discussion, only output archives will be addressed.
+Input archives are exactly symmetrical to output archives.
+<p>
+This archive will compile and execute with any types which implement the
+<a href="serialization.html"><strong>Serializable</strong></a> concept.
+For an example see
+<a href="../example/demo_trivial_archive.cpp" target="demo_trivial_archive">
+<code style="white-space: normal">demo_trivial_archive.cpp</code></a>.
+Of course this program won't produce any output as it is.  But it provides
+the starting point for a simple class which can be used to log formated
+output.  See the implementation of a <a href="simple_log.html">simple
+log archive</a> to how this has been done.
+
+<h3><a name="implementation">More Useful Archive Classes</a></h3>
+The above example is fine as far as it goes.  But it doesn't implement
+useful features such as serialization of pointers, class versioning
+and others. This library implements a family of full featuared archive
+classes appropriate for a variety of purposes.  
+
 <p>
 Our archives have been factored in to a tree of classes in order to minimize
 repetition of code.  This is shown in the accompanying 
 <a target="class_diagram" href="class_diagram.html">class diagram</a>.
-All input archives should be derived from the following template:
-<pre><code>
-template&lt;class Archive&gt;
-detail::common_iarchive;
-</code></pre>
-<h4>Minimum Requirments</h4>
-An instance of the this template handles all the "bookkeeping" associated
-with serialization. In order to be a functional only the following additional
-functions <strong>must</strong> be defined:
-<dl>
-<dt><h4><code>void load(T &t);</code></h4></dt>
-<dd>
-This function must be implemented for all primitive data types.  This can be
-accomplished through the use of a member template or explict declarations
-for all prmititive types.
-</dd>
 
-<dt><h4><code>void load_binary(void *address, std::size_t size);</code></h4></dt>
-<dd>
-This function should <code style="white-space: normal">size</code> bytes from the archive, and 
-copy them in to memory starting at address <code style="white-space: normal">address</code>.
-</dd>
-
-<dt><h4><code>friend class boost::archive::load_access;</code></h4></dt>
-<dd>
-In addition, such a class <strong>must</strong> provide a the following
-friend declaration grant access to the core serialization library to the functions
-of this class.
-</dd>
-
-</dl>
-
-So, the most trivial implementation of an input archive would look like this:
+Any class which fullfills the following requirements will fit into
+this hierarchy and implement all the features we require.  Deriving from
+the base class <a href="../../../boost/archive/detail/common_oarchive.hpp" target="common_oarchive_hpp">
+common_oarchive.hpp</a> provides all features we desire which
+are missing from trivial_oarchive above.
 
 <pre><code>
-<a href="../../../boost/archive/detail/common_iarchive.hpp" target="common_iarchive_hpp">
-#include &lt;boost/archive/detail/common_iarchive.hpp&gt;
+<a href="../../../boost/archive/detail/common_oarchive.hpp" target="common_oarchive_hpp">
+#include &lt;cstddef&gt; // std::size_t
+#include &lt;boost/archive/detail/common_oarchive.hpp&gt;
 </a>
-
 /////////////////////////////////////////////////////////////////////////
-// class trivial_iarchive - read serialized objects from a input text stream
-class trivial_iarchive : 
-    public boost::archive::detail::common_iarchive&lt;trivial_iarchive&gt;
+// class complete_oarchive
+class complete_oarchive : 
+    public boost::archive::detail::common_oarchive&lt;complete_oarchive&gt;
 {
-    // permit serialization system priviledged access to permit
+    // permit serialization system privileged access to permit
     // implementation of inline templates for maximum speed.
-    friend class boost::archive::load_access;
+    friend class boost::archive::save_access;
 
-    // member template for loading primitive types.
-    // Override for any types/templates that special treatment
+    // member template for saving primitive types.
+    // Specialize for any types/templates that special treatment
     template&lt;class T&gt;
-    void load(T &amp; t);
+    void save(T &amp; t);
 
 public:
     //////////////////////////////////////////////////////////
@@ -102,28 +123,24 @@ public:
     // serialization library
 
     // archives are expected to support this function
-    void load_binary(void *address, std::size_t count);
+    void save_binary(void *address, std::size_t count);
 };
-
 </code></pre>
-The simplest possible output archive class is exactly analogous to the above.
-In the following discussion, only input archives will be addressed.
-Output archives are exactly symmetrical to input archives.
-<p>
-Given a suitable definitions of <code style="white-space: normal">load</code>
-and <code style="white-space: normal">load_binary</code>, 
+
+Given a suitable definitions of <code style="white-space: normal">save</code>
+and <code style="white-space: normal">save_binary</code>, 
 any program using serialization with a conforming C++ compiler should compile 
 and run with this archive class.
 
 <h4>Optional Overrides</h4>
 
-The <code style="white-space: normal">detail::common_iarchive</code> class contains
+The <code style="white-space: normal">detail::common_oarchive</code> class contains
 a number of functions that are used by various parts of the serialization library
 to help render the archive in a particular form.
 
 <dl>
 
-<dt><h4><code>void load_start()</code></h4></dt>
+<dt><h4><code>void save_start()</code></h4></dt>
 <dd>
 <strong>Default</strong>:Does nothing.<br>
 <strong>Purpose</strong>:To inject/retrieve an object name into the archive.  Used
@@ -131,7 +148,7 @@ by XML archive to inject "&lt;name " before data.
 </dd>
 <p>
 
-<dt><h4><code>void load_end()</code></h4></dt>
+<dt><h4><code>void save_end()</code></h4></dt>
 <dd>
 <strong>Default</strong>:Does nothing.<br>
 <strong>Purpose</strong>:To inject/retrieve an object name into the archive. Used
@@ -143,7 +160,7 @@ by XML archive to inject "&lt;/name&gt;" after data.
 <dd>
 <strong>Default</strong>:Does nothing.<br>
 <strong>Purpose</strong>:Called <strong>each time</strong> user data is saved. 
-Its not called when archive book keeping data is saved.  This is used by XML archives 
+It's not called when archive bookkeeping data is saved.  This is used by XML archives 
 to determine  when to inject a "&gt;" character at end of XML header. XML output archives 
 keep their own internal flag indicating that data being written is header data. This
 internal flag is reset when an object start tag is written. When 
@@ -155,12 +172,12 @@ to be optimised away for archive classes that don't use it.
 <p>
 <dt><h4><code>
 template&lt;class T&gt;
-void load_override(T & t, int);
+void save_override(T & t, int);
 </code></h4></dt>
 <dd>
-<strong>Default</strong>:Invokes <code style="white-space: normal">archive::load(Archive & ar, t)</code><br>
+<strong>Default</strong>:Invokes <code style="white-space: normal">archive::save(Archive & ar, t)</code><br>
 This is the main entry into the serialization library.<br>
-<strong>Purpose</strong>:This can be overridden in cases where the data is to be written 
+<strong>Purpose</strong>:This can be specialized in cases where the data is to be written 
 to the archive in some special way.  For example, XML archives implement special handling for
 name-value pairs by overriding this function template for name-value pairs.  
 This replaces the default name-value pair handling, which is just to throw away the name,
@@ -178,14 +195,14 @@ implement partial function template ordering.  For more information see
 The serialization library injects bookkeeping data into the serialization archive.
 This data includes things like object ids, version numbers, class names etc.  Each
 of these objects is included in a wrapper so that the archive class can override the
-implementation of <code style="white-space: normal">void load_override(T & t, int);</code>.
+implementation of <code style="white-space: normal">void save_override(T & t, int);</code>.
 For example, in the XML archive, the override for this type renders an object_id equal to 23 as
 "object_id=_23".  The following table lists the types defined in the 
 <code style="white-space: normal">boost::archive namespace</code>
 used internally by the serialization library:
 <p>
 <table border>
-<tr><th align=left>type</th><th align=left><code style="white-space: normal">default<br>serialed as</code></th>
+<tr><th align=left>type</th><th align=left><code style="white-space: normal">default<br>serialized as</code></th>
 <tr><td><code style="white-space: normal">version_type</code></td><td><code style="white-space: normal">unsigned int</code></td>             
 <tr><td><code style="white-space: normal">object_id_type</code></td><td><code style="white-space: normal">unsigned int</code></td>   
 <tr><td><code style="white-space: normal">object_id_reference_type</code></td><td><code style="white-space: normal">unsigned int</code></td>   
@@ -197,7 +214,7 @@ used internally by the serialization library:
 </table>
 <p>
 All of these are associated with a default serialization defined in terms of primitive types
-so it isn't a requirement to define <code style="white-space: normal">load_override</code> 
+so it isn't a requirement to define <code style="white-space: normal">save_override</code> 
 for these types.
 <p>
 These are defined in
@@ -226,7 +243,9 @@ One or more of the following issues may need to be addressed:
     all data objects.
     <li>Addressing any of the above may generate more issues to be addressed.
     <li>The archives included with library are all templates which use a
-    <code style="white-space: normal">stream</code> as a template parameter rather than simple classes.
+    <code style="white-space: normal">stream</code> or
+    <code style="white-space: normal">streambuf</code>
+    as a template parameter rather than simple classes.
     Combined with the above, even more issues arise with non-conforming compilers.
 </ul>
 The attached <a target="class_diagram" href="class_diagram.html">class diagram</a>
@@ -241,17 +260,15 @@ EXCEPT for one special case.
 <ul>
     <li>Instances of a derived class are serialized through a base class pointer.
     <li>Such instances are not "registered" neither implicitly nor explicitly. That
-    is, the macro <code style="white-space: normal">BOOT_CLASS_EXPORT</code> is used to instantiate the serialization
-    code for the included archives.
+    is, the macro <code style="white-space: normal">BOOT_CLASS_EXPORT</code> is used 
+    to instantiate the serialization code for the included archives.
 </ul>
-The problem here is that BOOT_CLASS_EXPORT only generates code for those archives
-included with the library - not those added subsequently.  To generate code for
-newly created archive classes, the following should be used.
+
+To make this work, the following should be included after the archive
+class definition.
 <pre><code>
-#define BOOST_ARCHIVE_CUSTOM_OARCHIVE_TYPES trivial_oarchive
-#define BOOST_ARCHIVE_CUSTOM_IARCHIVE_TYPES trivial_iarchive
+#define BOOST_SERIALIZATION_REGISTER_ARCHIVE(Archive)
 </code></pre>
-before <code style="white-space: normal">BOOST_CLASS_EXPORT</code> is invoked for any serializable class.
 Failure to do this will not inhibit the program from compiling, linking
 and executing properly - except in one case.  If an instance of a derived
 class is serialized through a pointer to its base class, the program
@@ -259,23 +276,20 @@ will throw an
 <a href="exceptions.html#unregistered_class"><code style="white-space: normal">unregistered_class</code></a>
 exception.
 <p>
-Only one of the above statements is permitted, However, any number of new archive
-classes can be specified as list separated by commas.
 
 <h4><a name="testing">Testing</h4>
 Exhaustive testing of the library requires testing the different aspects of object
-serialization with each archive.  There are 36 different tests that can run with any archive.  There are
-5 "standard archives" included with the system. (3 in systems which don't support wide
-charactor i/o). 
+serialization with each archive.  There are 46 different tests that can run with any archive.  
+There are 5 "standard archives" included with the system. 
+(3 in systems don't support wide charactor i/o). 
 <p>
-In addition, there are 22 other tests which aren't related to any particular archive
-class.
+In addition, there are 28 other tests which aren't related to any particular archive class.
 <p>
 The default <code style="white-space: normal">bjam</code> testing setup will run all
-the above described tests.  This will result in as many as 39 archive tests * 5 
-standard archives + 25 general tests = 220 tests. Note that a complete test of the
+the above described tests.  This will result in as many as 46 archive tests * 5 
+standard archives + 28 general tests = 258 tests. Note that a complete test of the
 library would include DLL vs static library, release vs debug so the actual total 
-would be closer to 880 tests.
+would be closer to 1032 tests.
 <p>
 For each archive there is a header file in the test directory similar to the one below.
 The name of this archive is passed to the test program by setting the
@@ -302,16 +316,16 @@ typedef std::ifstream test_istream;
 #define TEST_STREAM_FLAGS (std::ios_base::openmode)0
 </code></pre>
 
-To test a new archive, for example, portable binary archives, make a
-header file <code style="white-space: normal">portable_binary_archive.hpp</code>
+To test a new archive, for example, portable binary archives, with the gcc compiler, 
+make a header file <code style="white-space: normal">portable_binary_archive.hpp</code>
 and invoke <code style="white-space: normal">bjam</code> with
 <pre><code> 
 -sBOOST_ARCHIVE_LIST=portable_binary_archive.hpp
 </code></pre>
-This process in encapsulated in the shell script 
-<code style="white-space: normal">run_archive_test</code> whose command line is
+This process in encapsulated in the shell or cmd script 
+<code style="white-space: normal">library_test</code> whose command line is
 <pre><code>
-run_archive_test &lt;test header file&gt; &lt;toolset&gt; [&lt;boost root&gt;] [&lt;target directory&gt;]
+library_test --toolset=gcc -sBOOST_ARCHIVE_LIST=portable_binary_archive.hpp
 </code></pre>
 <h3><a name="polymorphic">Polymorphic Archives</a></h3>
 
@@ -367,9 +381,9 @@ As can be seen in the
 and the header files, this implementation is just a composition of the polymorphic
 interface and the standard template driven implementation.  This composition is
 accomplished by the templates
-<a target=polymorphic_iarchive_dispatch_hpp href="../../../boost/archive/detail/polymorphic_iarchive_dispatch.hpp"><code style="white-space: normal">polymorphic_iarchive_dispatch.hpp</code></a>
+<a target=polymorphic_iarchive_route_hpp href="../../../boost/archive/detail/polymorphic_iarchive_route.hpp"><code style="white-space: normal">polymorphic_iarchive_route.hpp</code></a>
 and
-<a target=polymorphic_oarchive_dispatch_hpp href="../../../boost/archive/detail/polymorphic_oarchive_dispatch.hpp"><code style="white-space: normal">polymorphic_oarchive_dispatch.hpp</code></a>.
+<a target=polymorphic_oarchive_route_hpp href="../../../boost/archive/detail/polymorphic_oarchive_route.hpp"><code style="white-space: normal">polymorphic_oarchive_route.hpp</code></a>.
 As these contain no code specific to the particular implementation archive, they can be used to create
 a polymorphic archive implementation from any functioning templated archive implementation.
 <p>

doc/archives.html

@@ -41,14 +41,14 @@ In the following descriptions
 <h4><a name="saving_interface">Saving Archive Concept</a></h4>
 <h4>Associated Types</h4>
 Intuitively, a type modeling this concept will generate a sequence of bytes
-correpsonding to an arbitrary set of C++ data structures.  Each type modeling the
+corresponding to an arbitrary set of C++ data structures.  Each type modeling the
 Saving Archive concept (SA) may be associated with another type modeling the
 <a href="#loading_interface">Loading Archive Concept</a>(LA).  
 This associated type will perform the inverse operation.  
 That is, given a sequence of bytes generated by SA, it will generate a set of 
-C++ data structures the is equivalent to the original.  
+C++ data structures that is equivalent to the original.  
 The notion of equivalence is defined by the implementations of the pair of archives and the
-way the data is are rendered <a href="serialization.html">serializable</a>.
+way the data are rendered <a href="serialization.html">serializable</a>.
 <p>
 <h4>Valid Expressions</h4>
 <dl>
@@ -102,7 +102,7 @@ way the data is are rendered <a href="serialization.html">serializable</a>.
     For more information, see <a target="detail" href="implementation.html#tempatesyntax">Template Invocation syntax</a>
   </dd>
   <dt><h4><code>
-    sa.library_version()
+    sa.get_library_version()
   </code></h4></dt>
   <dd>
     Returns an unsigned integer containing the current version number of the serialization
@@ -172,7 +172,7 @@ equivalent to the original.
     For more information, see <a target="detail" href="implementation.html#tempatesyntax">Template Invocation syntax</a>
   </dd>
   <dt><h4><code>
-    la.library_version()
+    la.get_library_version()
   </code></h4></dt>
   <dd>
     Returns an unsigned integer containing the version number of the serialization
@@ -190,8 +190,8 @@ equivalent to the original.
     moved to address v.
     <p>
     When an object is loaded to a temporary variable and later moved to another location,
-    This function must be called in order communicate this fact.  This is permits the
-    the archive to properly implement object tracking.  Object tracking is required in order
+    this function must be called in order communicate this fact.  This permits the
+    archive to properly implement object tracking.  Object tracking is required in order
     to correctly implement serialization of pointers to instances of derived classes.
   </dd>  
   <dt><h4><code>
@@ -215,7 +215,7 @@ archives is discussed in
 
 <p>
 The existence of the <code style="white-space: normal">&lt;&lt;</code> 
-and <code style="white-space: normal">&gt;&gt;</code> suggest
+and <code style="white-space: normal">&gt;&gt;</code> suggests
 a relationship between archives and C++ i/o streams. <strong>Archives are not 
 C++ i/o streams</strong>. All the archives included with this system take a stream
 as an argument in the constructor and that stream is used for output or input.
@@ -224,7 +224,7 @@ archive interface. It just turns out that the archives written so far have
 found it useful to base their implementation on streams.
 
 <h3><a name="archive_models">Archive Models</a></h3>
-This library includes a various implementation of the Archive concept.
+This library includes various implementations of the Archive concept.
 
 An archive is defined by two complementary classes.  One is for saving data while
 the other is for loading it.
@@ -307,7 +307,7 @@ public:
 text_oarchive(std::ostream & os, unsigned int flags = 0);
 </code></h4></dt>
 <dd>
-Contructs an archive given an open <code style="white-space: normal">stream</code> as 
+Constructs an archive given an open <code style="white-space: normal">stream</code> as 
 an argument and optional flags. For most applications there will be no need to use flags. 
 Flags are defined by <code style="white-space: normal">enum archive_flags</code> enumerator. 
 Multiple flags can be combined with the <code style="white-space: normal">|</code> operator. 
@@ -339,7 +339,7 @@ tags, use <code style="white-space: normal">no_xml_tag_checking</code> flag.
 <dd>
 Destructor for an archive.  This should be called before the stream is
 closed.  It restores any altered stream facets to their state before the
-the archive was opened.
+archive was opened.
 </dd>
 
 </dl>
@@ -402,12 +402,12 @@ binary_iarchive(std::streambuf & bsb, unsigned int flags = 0);
 
 <h3><a name="exceptions">Exceptions</h3>
 All of the archive classes included may throw exceptions.  The list of exceptions that might
-be throw can be found in section <a target="detail" href="exceptions.html">Archive Exceptions</a>
+be thrown can be found in section <a target="detail" href="exceptions.html">Archive Exceptions</a>
 of this documentation. 
 
 <h3><a name="charactersets">Character Sets</h3>
 This library includes two archive classes for XML. The wide character
-version (<code style="white-space: normal">xml_w?archive</code>) renders it output as UTF-8 which can
+version (<code style="white-space: normal">xml_w?archive</code>) renders its output as UTF-8 which can
 handle any wide character without loss of information. 
 <code style="white-space: normal">std::string</code> data is converted from multi-byte format to wide
 character format using the current <code style="white-space: normal">

doc/class_diagram.html

@@ -1,4 +1,4 @@
-<!doctype HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
+<!doctype HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
 <!--
 (C) Copyright 2002-4 Robert Ramey - http://www.rrsd.com . 
 Use, modification and distribution is subject to the Boost Software
@@ -29,136 +29,136 @@ http://www.boost.org/LICENSE_1_0.txt)
 <pre><code>
 
 
-basic_iarchive <a href="../../../boost/archive/detail/basic_iarchive.hpp">-></a>
+basic_oarchive <a href="../../../boost/archive/detail/basic_oarchive.hpp">-></a>
       |
       |
-      |      interface_iarchive&lt;text_iarchive&gt; <a href="../../../boost/archive/detail/interface_iarchive.hpp">-></a>
+      |      interface_oarchive&lt;text_oarchive&gt; <a href="../../../boost/archive/detail/interface_oarchive.hpp">-></a>
       |                     /
       |                   /
       |        _________/
       |      /
       |    /
       |  /
-common_iarchive&lt;text_iarchive&gt; <a href="../../../boost/archive/detail/common_iarchive.hpp">-></a>
+common_oarchive&lt;text_oarchive&gt; <a href="../../../boost/archive/detail/common_oarchive.hpp">-></a>
       |
       |
-<font color="blue">basic_text_iarchive&lt;text_iarchive&gt;</font> <a href="../../../boost/archive/basic_text_iarchive.hpp">-></a>
+<font color="blue">basic_text_oarchive&lt;text_oarchive&gt;</font> <a href="../../../boost/archive/basic_text_oarchive.hpp">-></a>
       |
       |
-      |     <font color="blue">basic_text_iprimitive&lt;basic_istream&gt;</font> <a href="../../../boost/archive/basic_text_iprimitive.hpp">-></a>
+      |     <font color="blue">basic_text_oprimitive&lt;basic_ostream&gt;</font> <a href="../../../boost/archive/basic_text_oprimitive.hpp">-></a>
       |                    /
       |                  /
-      |       _________/                  interface_iarchive&lt;polymorphic_iarchive&gt; <a href="../../../boost/archive/detail/interface_iarchive.hpp">-></a>
+      |       _________/                  interface_oarchive&lt;polymorphic_oarchive&gt; <a href="../../../boost/archive/detail/interface_oarchive.hpp">-></a>
       |     /                                                |
       |   /                                                  |
       | /                                                    |
-<font color="blue">text_iarchive_impl&lt;text_iarchive&gt;</font> <a href="../../../boost/archive/text_iarchive.hpp">-></a>                 <font color="red">polymorphic_iarchive</font> <a href="../../../boost/archive/polymorphic_iarchive.hpp">-></a>
+<font color="blue">text_oarchive_impl&lt;text_oarchive&gt;</font> <a href="../../../boost/archive/text_oarchive.hpp">-></a>              polymorphic_oarchive_impl <a href="../../../boost/archive/polymorphic_oarchive.hpp">-></a>
       | \                                                    |
       |   \                                                  |
-      |     \_____________________________________           |
+      |     \_____________________________________    <font color="red">polymorphic_oarchive</font> <a href="../../../boost/archive/polymorphic_oarchive.hpp">-></a>
       |                                           \         /
       |                                             \     /
       |                                               \ /  
-<font color="red">text_iarchive</font> <a href="../../../boost/archive/text_iarchive.hpp">-></a>                 polymorphic_iarchive_dispatch&lt;text_iarchive_impl&lt;text_iarchive&gt; &gt; <a href="../../../boost/archive/detail/polymorphic_iarchive_dispatch.hpp">-></a>
+<font color="red">text_oarchive</font> <a href="../../../boost/archive/text_oarchive.hpp">-></a>                 polymorphic_oarchive_route&lt;text_oarchive_impl&lt;text_oarchive&gt; &gt; <a href="../../../boost/archive/detail/polymorphic_oarchive_route.hpp">-></a>
                                                        |
                                                        |
                                                        |
-                                             <font color="red">polymorphic_text_iarchive</font> <a href="../../../boost/archive/polymorphic_text_iarchive.hpp">-></a>
+                                             <font color="red">polymorphic_text_oarchive</font> <a href="../../../boost/archive/polymorphic_text_oarchive.hpp">-></a>
 
 
 </code></pre>
-This diagram shows the relationship between the various classes that implement loading (input
-serialization) for text files.  The hierachy and organization is identical for saving and for
+This diagram shows the relationship between the various classes that implement saving (output
+serialization) for text archives.  The hierachy and organization is similar for loading and for
 other types of archives as well.  In the diagram, classes written in <font color="blue">blue</font> 
-implement loading for a given archive type. (in this case its text archives).
-Users include classes in <font color="red">red</font> to load their data from a partcular
+implement saving for a given archive type. (in this case its text archives).
+Users include classes in <font color="red">red</font> to save their data from a partcular
 type of archive.  Other classes whose names are in black implement the library and should
 never change.  They are in <code>namespace boost::archive::detail</code>
 <dl>
   <dt><code>
-  <a href="../../../boost/archive/detail/basic_iarchive.hpp">basic_iarchive</a>
+  <a href="../../../boost/archive/detail/basic_oarchive.hpp">basic_oarchive</a>
   </code></dt>
   <dd>
   Implements the core library functions for class export, versioning, and object tracking.  It is compiled
   into the library as it has no template parameters.
   </dd>
   <p><dt><code>
-  <a href="../../../boost/archive/detail/interface_iarchive.hpp">interface_iarchive&lt;text_iarchive&gt;</a>
+  <a href="../../../boost/archive/detail/interface_oarchive.hpp">interface_oarchive&lt;text_oarchive&gt;</a>
   </code></dt>
   <dd>
   A class that declares the standard archive interface.  This has been factored out so that it
-  can be used as a base class for <code style="white-space: normal">polymorphic_iarchive</code>
+  can be used as a base class for <code style="white-space: normal">polymorphic_oarchive</code>
   as well as for archive implementations.
   
   <p><dt><code>
-  <a href="../../../boost/archive/detail/common_iarchive.hpp">common_iarchive&lt;text_iarchive&gt;</a>
+  <a href="../../../boost/archive/detail/common_oarchive.hpp">common_oarchive&lt;text_oarchive&gt;</a>
   </code></dt>
   <dd>
   The function of this class is to make the connection between the virtual function
-  interface used by <code>basic_iarchive</code> and the template interface used by archive
+  interface used by <code>basic_oarchive</code> and the template interface used by archive
   class implementations.
   
   <p><dt><code>
-  <a href="../../../boost/archive/basic_text_iarchive.hpp">basic_text_iarchive&lt;text_iarchive&gt;</a>
+  <a href="../../../boost/archive/basic_text_oarchive.hpp">basic_text_oarchive&lt;text_oarchive&gt;</a>
   </code></dt>
   <dd>
-  Implements the basic functionality for simple text archives.  The primitive load functions have been 
+  Implements the basic functionality for simple text archives.  The primitive save functions have been 
   factored out so it can be used in other text based archives like XML archives.
   
   <p><dt><code>
-  <a href="../../../boost/archive/basic_text_iprimitive.hpp">basic_text_iprimitive&lt;basic_istream&gt;</a>
+  <a href="../../../boost/archive/basic_text_oprimitive.hpp">basic_text_oprimitive&lt;basic_ostream&gt;</a>
   </code></dt>
   <dd>
-  Implements the save overloads for all primitive types.  This is a template with a parameter
+  Implements the save oversaves for all primitive types.  This is a template with a parameter
   which describes the stream.
   
   <p><dt><code>
-  <a href="../../../boost/archive/text_iarchive.hpp">text_iarchive_impl&lt;text_iarchive&gt;</a>                 
+  <a href="../../../boost/archive/text_oarchive.hpp">text_oarchive_impl&lt;text_oarchive&gt;</a>                 
   </code></dt>
   <dd>
   Inherits from the above two classes to implement text archives.
   </dd>
 
   <p><dt><code>
-  <a href="../../../boost/archive/text_iarchive.hpp">text_iarchive</a>
+  <a href="../../../boost/archive/text_oarchive.hpp">text_oarchive</a>
   </code></dt>
   <dd>
-  This is just a short hand for <code style="white-space: normal">text_iarchive_impl&lt;text_iarchive&gt;</code> .
+  This is just a short hand for <code style="white-space: normal">text_oarchive_impl&lt;text_oarchive&gt;</code> .
   We can't use <code style="white-space: normal">typedef</code> because  a 
   <code style="white-space: normal">typedef</code> can't refer to it self in its definition.  
   This is the class name that is used to serialize to a text archive.
   </dd>
 
   <p><dt><code>
-  <a href="../../../boost/archive/detail/interface_iarchive.hpp">interface_iarchive&lt;polymorphic_iarchive&gt;</a>
+  <a href="../../../boost/archive/detail/interface_oarchive.hpp">interface_oarchive&lt;polymorphic_oarchive&gt;</a>
   </code></dt>
   <dd>
   Same template as above.  However, this time the Archive parameter refers to the polymorphic archive
   with a virtual function interface rather than that the template interface that
-  <code style="white-space: normal">common_iarchive</code> uses.
+  <code style="white-space: normal">common_oarchive</code> uses.
   
   <p><dt><code>
-  <a href="../../../boost/archive/polymorphic_iarchive.hpp">polymorphic_iarchive</a>
+  <a href="../../../boost/archive/polymorphic_oarchive.hpp">polymorphic_oarchive</a>
   </code></dt>
   <dd>
-  A class with a list of virtual <code style="white-space: normal">load(T &t)</code>
+  A class with a list of virtual <code style="white-space: normal">save(T &t)</code>
   for all primitive types T. This is the class that is used to do pre-compile serialization of classes
   for all archives present and future.
   
   <p><dt><code>
-  <a href="../../../boost/archive/detail/polymorphic_iarchive_dispatch.hpp">polymorphic_iarchive_dispatch&lt;text_iarchive_impl&lt;text_iarchive&gt; &gt;</a>
+  <a href="../../../boost/archive/detail/polymorphic_oarchive_route.hpp">polymorphic_oarchive_route&lt;text_oarchive_impl&lt;text_oarchive&gt; &gt;</a>
   </code></dt>
   <dd><p>
-  This class implements the <code style="white-space: normal">polymorphic_iarchive</code> in terms of a specific 
-  concrete class.  Virtual function calls are forwarded to the implementing class.  In this example, 
-  that implementing class would be text_iarchive_impl.
+  This class implements the <code style="white-space: normal">polymorphic_oarchive</code> in terms of a specific 
+  concrete class.  Virtual function calls are routed to the implementing class.  In this example, 
+  that implementing class would be text_oarchive_impl.
   
   <p><dt><code>
-  <a href="../../../boost/archive/polymorphic_text_iarchive.hpp">polymorphic_text_iarchive</a>
+  <a href="../../../boost/archive/polymorphic_text_oarchive.hpp">polymorphic_text_oarchive</a>
   </code></dt>
   <dd>
   this is just a typedef so we can write polymorphic_text_archive rather than
-  <code style="white-space: normal">polymorphic_iarchive_dispatch&lt;text_iarchive_impl&lt;text_iarchive&gt; &gt;</code>
+  <code style="white-space: normal">polymorphic_oarchive_route&lt;text_oarchive_impl&'t;text_oarchive&gt; &gt;</code>
   
 </dl>
 <hr>

doc/codecvt.html

@@ -28,7 +28,7 @@ width="277" height="86"> <br clear="all">
 <a name="sec:utf8-codecvt-facet-class"></a>
 
 
-<h1>UTF-8 Codecvt Facet</h1>
+<h1><code>utf8_codecvt_facet</code></h1>
 
 
 <pre>

doc/contents.html

@@ -83,220 +83,270 @@ function initialize() {
 <img src="dot.gif" onclick="collapse_all()">Collapse All
 -->
 <p>
-  <dl class="page-index">
-    <dt><img style="display:none" src="plus.gif" id="release_notes"><a target="detail" href="release.html">Release Notes</a></dt>
-    <dd><div id="release_notes_detail"><dl class="page-index">
-      <dt><img style="display:none" src="dot.gif"><a target="detail"  href="release.html#requirements">Requirements</a></dt>
-      <dt><img style="display:none" src="dot.gif"><a target="detail"  href="release.html#difference_1_32">Differences from version 1.32</a></dt>
-      <dt><img style="display:none" src="dot.gif"><a target="detail"  href="release.html#difference_1_33">Differences from version 1.33</a></dt>
-      <dt><img style="display:none" src="dot.gif"><a target="detail"  href="release.html#difference_1_34">Differences from version 1.34</a></dt>
-      <dt><img style="display:none" src="dot.gif"><a target="detail"  href="release.html#todo">Pending Issues</a></dt>
-    </dl></div></dd>
-    <dt><img style="display:none" src="plus.gif" id="overview"><a target="detail" href="overview.html">Overview</a></dt>
-    <dd><div id="overview_detail"><dl class="page-index">
-      <dt><img style="display:none" src="dot.gif"><a target="detail" href="overview.html#Requirements">Requirements</a></dt>
-      <dt><img style="display:none" src="dot.gif"><a target="detail" href="overview.html#Otherimplementations">Other Implementations</a></dt>
-    </dl></div></dd>
-    <dt><img style="display:none" src="plus.gif" id="tutorial"><a target="detail" href="tutorial.html">Tutorial</a></dt>
-    <dd><div id="tutorial_detail"><dl class="page-index"> 
-      <dt><img style="display:none" src="dot.gif"><a target="detail" href="tutorial.html#simplecase">A Very Simple Case</a>
-      <dt><img style="display:none" src="dot.gif"><a target="detail" href="tutorial.html#nonintrusiveversion">Non Intrusive Version</a>
-      <dt><img style="display:none" src="dot.gif"><a target="detail" href="tutorial.html#serializablemembers">Serializable Members</a>
-      <dt><img style="display:none" src="dot.gif"><a target="detail" href="tutorial.html#derivedclasses">Derived Classes</a>
-      <dt><img style="display:none" src="dot.gif"><a target="detail" href="tutorial.html#pointers">Pointers</a>
-      <dt><img style="display:none" src="dot.gif"><a target="detail" href="tutorial.html#arrays">Arrays</a>
+<dl class="page-index">
+  <dt><img style="display:none" src="plus.gif" id="release_notes"><a target="detail" href="release.html">Release Notes</a></dt>
+  <dd><div id="release_notes_detail"><dl class="page-index">
+    <dt><img style="display:none" src="dot.gif"><a target="detail"  href="release.html#difference_1_41">Differences from version 1.41</a></dt>
+    <dt><img style="display:none" src="dot.gif"><a target="detail"  href="release.html#difference_1_40">Differences from version 1.40</a></dt>
+    <dt><img style="display:none" src="dot.gif"><a target="detail"  href="release.html#difference_1_39">Differences from version 1.39</a></dt>
+    <dt><img style="display:none" src="dot.gif"><a target="detail"  href="release.html#difference_1_37">Differences from version 1.37</a></dt>
+    <dt><img style="display:none" src="dot.gif"><a target="detail"  href="release.html#difference_1_35">Differences from version 1.35</a></dt>
+    <dt><img style="display:none" src="dot.gif"><a target="detail"  href="release.html#difference_1_34">Differences from version 1.34</a></dt>
+    <dt><img style="display:none" src="dot.gif"><a target="detail"  href="release.html#difference_1_33">Differences from version 1.33</a></dt>
+    <dt><img style="display:none" src="dot.gif"><a target="detail"  href="release.html#difference_1_32">Differences from version 1.32</a></dt>
 
-      <dt><img style="display:none" src="dot.gif"><a target="detail" href="tutorial.html#stl">STL Collections</a>
-      <dt><img style="display:none" src="dot.gif"><a target="detail" href="tutorial.html#versioning">Class Versioning</a>
-      <dt><img style="display:none" src="dot.gif"><a target="detail" href="tutorial.html#splitting">Splitting <code>serialize</code> into <code>save/load</code></a>
-      <dt><img style="display:none" src="dot.gif"><a target="detail" href="tutorial.html#archives">Archives</a>
-      <dt><img style="display:none" src="dot.gif"><a target="detail" href="tutorial.html#examples">List of Examples</a>
+    <dt><img style="display:none" src="dot.gif"><a target="detail"  href="release.html#todo">Pending Issues</a></dt>
+  </dl></div></dd>
+  <dt><img style="display:none" src="plus.gif" id="overview"><a target="detail" href="overview.html">Overview</a></dt>
+  <dd><div id="overview_detail"><dl class="page-index">
+    <dt><img style="display:none" src="dot.gif"><a target="detail" href="overview.html#Requirements">Requirements</a></dt>
+    <dt><img style="display:none" src="dot.gif"><a target="detail" href="overview.html#Otherimplementations">Other Implementations</a></dt>
+  </dl></div></dd>
+  <dt><img style="display:none" src="plus.gif" id="tutorial"><a target="detail" href="tutorial.html">Tutorial</a></dt>
+  <dd><div id="tutorial_detail"><dl class="page-index"> 
+    <dt><img style="display:none" src="dot.gif"><a target="detail" href="tutorial.html#simplecase">A Very Simple Case</a>
+    <dt><img style="display:none" src="dot.gif"><a target="detail" href="tutorial.html#nonintrusiveversion">Non Intrusive Version</a>
+    <dt><img style="display:none" src="dot.gif"><a target="detail" href="tutorial.html#serializablemembers">Serializable Members</a>
+    <dt><img style="display:none" src="dot.gif"><a target="detail" href="tutorial.html#derivedclasses">Derived Classes</a>
+    <dt><img style="display:none" src="dot.gif"><a target="detail" href="tutorial.html#pointers">Pointers</a>
+    <dt><img style="display:none" src="dot.gif"><a target="detail" href="tutorial.html#arrays">Arrays</a>
+
+    <dt><img style="display:none" src="dot.gif"><a target="detail" href="tutorial.html#stl">STL Collections</a>
+    <dt><img style="display:none" src="dot.gif"><a target="detail" href="tutorial.html#versioning">Class Versioning</a>
+    <dt><img style="display:none" src="dot.gif"><a target="detail" href="tutorial.html#splitting">Splitting <code>serialize</code> into <code>save/load</code></a>
+    <dt><img style="display:none" src="dot.gif"><a target="detail" href="tutorial.html#archives">Archives</a>
+    <dt><img style="display:none" src="dot.gif"><a target="detail" href="tutorial.html#examples">List of Examples</a>
+  </dl></div></dd>
+
+  <dt><img style="display:none" src="plus.gif" id="reference"><a target="detail" href="reference.html">Reference</a></dt>
+  <dd><div id="reference_detail"><dl class="page-index"> 
+    <dt><img style="display:none" src="plus.gif" id="archive_concept"><a target="detail" href="archives.html">Archive Concepts</a>
+    <dd><div id="archive_concept_detail"><dl class="page-index">
+      <dt><img style="display:none" src="dot.gif"><a target="detail" href="archives.html#saving_interface">Saving Archive Concept</a>
+      <dt><img style="display:none" src="dot.gif"><a target="detail" href="archives.html#loading_interface">Loading Archive Concept</a>
+      <dt><img style="display:none" src="dot.gif"><a target="detail" href="archives.html#archive_models">Archive Models</a>
+      <dt><img style="display:none" src="dot.gif"><a target="detail" href="archives.html#exceptions">Exceptions</a>
+      <dt><img style="display:none" src="dot.gif"><a target="detail" href="archives.html#charactersets">Character Sets</a>
+    </dl></div></dd>
+    <dt><img style="display:none" src="plus.gif" id="serialization"><a target="detail" href="serialization.html">Serializable Concept</a>
+    <dd><div id="serialization_detail"><dl class="page-index">
+      <dt><img style="display:none" src="dot.gif"><a target="detail" href="serialization.html#primitiveoperators">Primitive Types</a>
+      <dt><img style="display:none" src="dot.gif" id="class"><a target="detail" href="serialization.html#classoperators">Class Types</a>
+      <dd><div id="class_detail"><dl class="page-index">
+        <dt><img style="display:none" src="dot.gif"><a target="detail" href="serialization.html#member">Member Function</a>
+        <dt><img style="display:none" src="plus.gif" id="splitfree"><a target="detail" href="serialization.html#free">Free Function</a>
+        <dd><div id="splitfree_detail"><dl class="page-index">
+          <dt><img style="display:none" src="dot.gif"><a target="detail" href="serialization.html#namespaces">Namespaces for Free Function Overrides</a>
+        </dl></div></dd>
+        <dt><img style="display:none" src="plus.gif" id="members"><a target="detail" href="serialization.html#classmembers">Class Members</a>
+        <dd><div id="members_detail"><dl class="page-index">
+          <dt><img style="display:none" src="dot.gif"><a target="detail" href="serialization.html#base">Base Classes</a>
+          <dt><img style="display:none" src="dot.gif"><a target="detail" href="serialization.html#const"><code>const</code> Members</a>
+          <dt><img style="display:none" src="dot.gif"><a target="detail" href="serialization.html#templates">Templates</a>
+        </dl></div></dd>
+        <dt><img style="display:none" src="dot.gif"><a target="detail" href="serialization.html#versioning">Versioning</a>
+        <dt><img style="display:none" s'c="dot.gif"><a target="detail" href="serialization.html#splitting">Splitting <code>serialize</code> into <code>save/load</code></a>
+      </dl></div></dd>
+      <dt><img style="display:none" src="plus.gif" id="pointers"><a target="detail" href="serialization.html#pointeroperators">Pointers</a>
+      <dd><div id="pointers_detail"><dl class="page-index">
+        <dt><img style="display:none" src="dot.gif"><a target="detail" href="serialization.html#constructors">Non-Default Constructors</a>
+        <dt><img style="display:none" src="plus.gif" id="derivedpointers"><a target="detail" href="serialization.html#derivedpointers">Pointers to Objects of Derived Classes</a>
+        <dd><div id="derivedpointers_detail"><dl class="page-index">
+          <dt><img style="display:none" src="dot.gif"><a target="detail" href="serialization.html#registration">Registration</a>
+          <dt><img style="display:none" src="dot.gif"><a target="detail" href="serialization.html#export">Export</a>
+          <dt><img style="display:none" src="dot.gif"><a target="detail" href="serialization.html#instantiation">Instantiation</a>
+          <dt><img style="display:none" src="dot.gif"><a target="detail" href="serialization.html#selectivetracking">Selective Tracking</a>
+          <dt><img style="display:none" src="dot.gif"><a target="detail" href="serialization.html#runtimecasting">Runtime Casting</a>
+        </dl></div></dd>
+      </dl></div></dd>
+      <dt><img style="display:none" src="dot.gif"><a target="detail" href="serialization.html#references">References</a>
+      <dt><img style="display:none" src="plus.gif" id="traits"><a target="detail" href="traits.html">Class Serialization Traits</a>
+      <dd><div id="traits_detail"><dl class="page-index">
+        <dt><img style="display:none" src="dot.gif"><a target="detail" href="traits.html#version">Version</a>
+        <dt><img style="display:none" src="dot.gif"><a target="detail" href="traits.html#level">Implementation Level</a>
+        <dt><img style="display:none" src="dot.gif"><a target="detail" href="traits.html#tracking">Object Tracking</a>
+        <dt><img style="display:none" src="dot.gif"><a target="detail" href="traits.html#export">Export Key</a>
+        <dt><img style="display:none" src="dot.gif"><a target="detail" href="traits.html#Abstract">Abstract</a>
+        <dt><img style="display:none" src="dot.gif"><a target="detail" href="traits.html#typeinfo">Type Information Implementation</a>
+        <dt><img style="display:none" src="dot.gif"><a target="detail" href="traits.html#wrappers">Wrappers</a>
+        <dt><img style="display:none" src="dot.gif"><a target="detail" href="traits.html#bitwise">Bitwise Serialization</a>
+        <dt><img style="display:none" src="dot.gif"><a target="detail" href="traits.html#templates">Template Serialization Traits</a>
+
+        <dt><img style="display:none" src="plus.gif" id="compiletimemessages"><a target="detail" href="traits.html#compiletime_messages">Compile Time Warnings and Errors</a>
+        <dd><div id="compiletimemessages_detail"><dl class="page-index">
+          <dt><img style="display:none" src="dot.gif"><a target="detail" href="traits.html#object_level">object_level</a>
+          <dt><img style="display:none" src="dot.gif"><a target="detail" href="traits.html#object_versioning">object_versioning</a>
+          <dt><img style="display:none" src="dot.gif"><a target="detail" href="traits.html#object_tracking">object_tracking</a>
+          <dt><img style="display:none" src="dot.gif"><a target="detail" href="traits.html#pointer_level">pointer_level</a>
+          <dt><img style="display:none" src="dot.gif"><a target="detail" href="traits.html#pointer_tracking">pointer_tracking</a>
+          <dt><img style="display:none" src="dot.gif"><a target="detail" href="traits.html#const_loading">const_loading</a>
+        </dl></div></dd>
+
+
+
+      </dl></div></dd>
+      <dt><img style="display:none" src="plus.gif" id="wrappers"><a target="detail" href="wrappers.html">Serialization Wrappers</a>
+      <dd><div id="wrappers_detail"><dl class="page-index">
+        <dt><img style="display:none" src="dot.gif"><a target="detail" href="wrappers.html#binaryobjects">Binary Objects</a>
+        <dt><img style="display:none" src="dot.gif"><a target="detail" href="wrappers.html#arrays">Arrays</a>
+        <dt><img style="display:none" src="dot.gif"><a target="detail" href="wrappers.html#strong_type"><code style="white-space: normal">strong_type</code></a>
+        <dt><img style="display:none" src="dot.gif"><a target="detail" href="wrappers.html#collection_size_type">Collection Sizes</a>
+        <dt><img style="display:none" src="dot.gif"><a target="detail" href="wrappers.html#nvp">Name-Value Pairs</a>
+        <dt><img style="display:none" src="dot.gif"><a target="detail" href="wrappers.html#composition">Composition</a>
+      </dl></div></dd>
+      <dt><img style="display:none" src="dot.gif"><a target="detail" href="serialization.html#models">Models - Serialization Implementations Included in the Library</a>
+    </dl></div></dd>
+    <dt><img style="display:none" src="plus.gif" id="special"><a target="detail" 'ref="special.html">Special Considerations</a>
+    <dd><div id="special_detail"><dl class="page-index">
+      <dt><img style="display:none" src="dot.gif"><a target="detail" href="special.html#objecttracking">Object Tracking</a>
+      <dt><img style="display:none" src="dot.gif"><a target="detail" href="special.html#classinfo">Class Information</a>
+      <dt><img style="display:none" src="plus.gif" id="portability"><a target="detail" href="special.html#portability">Archive Portability</a>
+      <dd><div id="portability_detail"><dl class="page-index">
+        <dt><img style="display:none" src="dot.gif"><a target="detail" href="special.html#numerics">Numerics</a>
+        <dt><img style="display:none" src="dot.gif"><a target="detail" href="special.html#traits">Traits</a>
+      </dl></div></dd>
+      <dt><img style="display:none" src="dot.gif"><a target="detail" href="special.html#binary_archives">Binary Archives</a>
+      <dt><img style="display:none" src="dot.gif"><a target="detail" href="special.html#xml_archives">XML Archives</a>
+      <dt><img style="display:none" src="dot.gif"><a target="detail" href="special.html#export">Exporting Class Serialization</a>
+      <dt><img style="display:none" src="dot.gif"><a target="detail" href="special.html#static_libraries">Static Libraries and Serialization</a>
+      <dt><img style="display:none" src="dot.gif"><a target="detail" href="special.html#dlls">DLLS - Serialization and Runtime Linking</a>
+      <dt><img style="display:none" src="dot.gif"><a target="detail" href="special.html#plugins">Plugins</a>
+      <dt><img style="display:none" src="dot.gif"><a target="detail" href="special.html#multi_threading">Multi-Threading</a>
+      <dt><img style="display:none" src="dot.gif"><a target="detail" href="special.html#optimizations">Optimzations</a>
+      <dt><img style="display:none" src="plus.gif" id="exceptions"><a target="detail" href="exceptions.html">Archive Exceptions</a>
+      <dd><div id="exceptions_detail"><dl class="page-index">
+        <dt><img style="display:none" src="dot.gif"><a target="detail" href="exceptions.html#unregistered_class"><code>unregistered_class</code></a>
+        <dt><img style="display:none" src="dot.gif"><a target="detail" href="exceptions.html#invalid_signature"><code>invalid_signature</code></a>
+        <dt><img style="display:none" src="dot.gif"><a target="detail" href="exceptions.html#unsupported_version"><code>unsupported_version</code></a>
+        <dt><img style="display:none" src="dot.gif"><a target="detail" href="exceptions.html#pointer_conflict"><code>pointer_conflict</code></a>
+        <dt><img style="display:none" src="dot.gif"><a target="detail" href="exceptions.html#incompatible_native_format"><code>incompatible_format</code></a>
+        <dt><img style="display:none" src="dot.gif"><a target="detail" href="exceptions.html#array_size_too_short"><code>array_size_too_short</code></a>
+        <dt><img style="display:none" src="dot.gif"><a target="detail" href="exceptions.html#stream_error"><code>stream_error</code></a>
+        <dt><img style="display:none" src="dot.gif"><a target="detail" href="exceptions.html#invalid_class_name"><code>invalid_class_name</code></a>
+        <dt><img style="display:none" src="dot.gif"><a target="detail" href="exceptions.html#unregistered_cast"><code>unregistered_cast</code></a>
+        <dt><img style="display:none" src="dot.gif"><a target="detail" href="exceptions.html#xml_archive_parsing_error"><code>xml_archive_parsing_error</code></a>
+        <dt><img style="display:none" src="dot.gif"><a target="detail" href="exceptions.html#xml_archive_tag_mismatch"><code>xml_archive_tag_mismatch</code></a>
+        <dt><img style="display:none" src="dot.gif"><a target="detail" href="exceptions.html#xml_archive_tag_name_error"><code>xml_archive_tag_name_error</code></a>
+      </dl></div></dd>
+      <dt><img style="display:none" src="dot.gif"><a target="detail" href="exception_safety.html">Exception Safety</a>
+    </dl></div></dd>
+    <dt><img style="display:none" src="plus.gif" id="archive_reference"><a target="detail" href="archive_reference.html">Archive Class Reference</a>
+    <dd><div id="archive_reference_detail"><dl class="page-index">
+      <dt><img style="display:none" src="dot.gif"><a target="detail" href="archive_reference.html#trivial">Trivial Archive</a>
+      <dt><img style="display:none" src="dot.gif"><a target="detail" href="archive_reference.html#implementation">More Useful Archive Classes</a>
+      <dt><img style="display:none" src="dot.gif"><a target="detail" href="archive_reference.html#usage">Usage</a>
+      <dt><img style="display:none" src="dot.gif"><a target="detail" href="archive_reference.html#testing">Testing</a>
+      <dt><img style="display:none" src="dot.gif"><a target="detail" href="archive_reference.html#polymorphic">Polymorphic Archives</a>
+    </dl></div></dd>
+  </dl></div></dd>
+  <dt><img style="display:none" src="plus.gif" id="implementation"><a target="detail" href="implementation.html">Implementation Notes</a>
+  <dd><div id="implementation_detail"><dl class="page-index">
+    <dt><img style="display:none" src="dot.gif"><a target="detail" href="implementation.html#functiontemplateordering">Partial Function Template Ordering</a>
+    <dt><img style="display:none" src="dot.gif"><a target="detail" href="implementation.html#charencoding">Character Encoding</a>
+    <dt><img style="display:none" src="dot.gif"><a target="detail" href="implementation.html#tempatesyntax">Template Invocation syntax</a>
+    <dt><img style="display:none" src="dot.gif"><a target="detail" href="implementation.html#partialtemplatespecialization">Partial Template Specialization</a>
+    <dt><img style="display:none" src="plus.gif" id="othercompilerissues"><a target="detail" href="implementation.html#othercompilerissues">Specific Compiler/Library Issues</a>
+    <dd><div id="othercompilerissues_detail"><dl class="page-index">
+      <dt><img style="display:none" src="dot.gif"><a target="detail" href="implementation.html#gcc3x">GCC 3.X,4.X</a>
+      <dt><img style="display:none" src="dot.gif"><a target="detail" href="implementation.html#gcc295">GCC 2.95</a>
+      <dt><img style="display:none" src="dot.gif"><a target="detail" href="implementation.html#intel80">Intel 8.0</a>
+      <dt><img style="display:none" src="dot.gif"><a target="detail" href="implementation.html#vc80">Visual C++ 8.0</a>
+      <dt><img style="display:none" src="dot.gif"><a target="detail" href="implementation.html#vc71">Visual C++ 7.1</a>
+      <dt><img style="display:none" src="dot.gif"><a target="detail" href="implementation.html#vc70">Visual C++ 7.0</a>
+      <dt><img style="display:none" src="dot.gif"><a target="detail" href="implementation.html#vc6">Visual C++ 6.0</a>
+      <dt><img style="display:none" src="dot.gif"><a target="detail" href="implementation.html#borland">Borland 5.64 and 5.51</a>
+      <dt><img style="display:none" src="dot.gif"><a target="detail" href="implementation.html#comeau">Comeau 4.3.3</a>
+      <dt><img style="display:none" src="dot.gif"><a target="detail" href="implementation.html#codewarrior">Code Warrior 8.3</a>
+      <dt><img style="display:none" src="dot.gif"><a target="detail" href="implementation.html#tru64">TRU64</a>
+      <dt><img style="display:none" src="dot.gif"><a target="detail" href="implementation.html#dinkumware">Dinkumware Library</a>
+      <dt><img style="display:none" src="dot.gif"><a target="detail" href="implementation.html#stlport">STLPort 4.5.3</a>
+    </dl></div></dd>
+    <dt><img style="display:none" src="plus.gif" id="headers"><a target="detail" href="headers.html">Code Structure</a>
+    <dd><div id="headers_detail"><dl class="page-index">
+      <dt><img style="display:none" src="plus.gif" id="userincludes"><a target="detail" href="headers.html#userincludes">Files Included by User Programs</a>
+      <dd><div id="userincludes_detail"><dl class="page-index">
+        <dt><img style="display:none" src="dot.gif"><a target="detail" href="headers.html#archiveimplementations">Archive Implementations</a>
+        <dt><img style="display:none" src="dot.gif"><a target="detail" href="headers.html#serializationdeclarations">Serialization Declarations</a>
+        <dt><img style="display:none" 'rc="dot.gif"><a target="detail" href="headers.html#serializationimplementations">Serialization Implementations</a>
+      </dl></div>
+      <dt><img style="display:none" src="plus.gif" id="libraryimplementation"><a target="detail" href="headers.html#libraryimplementation">Files Which Implement the Library</a>
+      <dd><div id="libraryimplementation_detail"><dl class="page-index">
+        <dt><img style="display:none" src="dot.gif"><a target="detail" href="headers.html#archivedevelopment">Archive Development</a>
+        <dt><img style="display:none" src="dot.gif"><a target="detail" href="headers.html#archiveinternals">Archive Internals</a>
+        <dt><img style="display:none" src="dot.gif"><a target="detail" href="headers.html#codemodules">Archive Library Code Modules</a>
+        <dt><img style="display:none" src="dot.gif"><a target="detail" href="headers.html#dataflowiterators">Dataflow Iterators</a>
+      </dl></div></dd>
+    </dl></div></dd>
+  </dl></div></dd>
+  <dt><img style="display:none" src="plus.gif" id="case_studies">Case Studies
+  <dd><div id="case_studies_detail"><dl class="page-index">
+    <dt><img style="display:none" src="dot.gif"><a target="detail" href="shared_ptr.html">Template serialization - <code>shared_ptr&lt;class T&gt;</code></a>
+    <dt><img style="display:none" src="dot.gif"><a target="detail" href="shared_ptr2.html"><code>shared_ptr&lt;class T&gt;</code>Revisited</a>
+    <dt><img style="display:none" src="dot.gif"><a target="detail" href="pimpl.html">PIMPL</a>
+    <dt><img style="display:none" src="dot.gif"><a target="detail" href="simple_log.html">A Simple Logging Archive Class</a>
+    <dt><img style="display:none" src="dot.gif"><a target="detail" href="derivation.html">Derivation from an Existing Archive Class</a>
+  </dl></div></dd>
+  <dt><img style="display:none" src="plus.gif" id="otherclasses">Other Classes
+  <dd><div id="otherclasses_detail"><dl class="page-index">
+    <dt><img style="display:none" src="plus.gif" id="extended_type_info"><a target="detail" href="extended_type_info.html"><code>extended_type_info</code></a>
+    <dd><div id="extended_type_info_detail"><dl class="page-index">
+      <dt><img style="display:none" src="dot.gif"><a target="detail" href="extended_type_info.html#motivation">Motivation</a>
+      <dt><img style="display:none" src="dot.gif"><a target="detail" href="extended_type_info.html#runtime">Runtime Interface</a>
+      <dt><img style="display:none" src="dot.gif"><a target="detail" href="extended_type_info.html#requirements">Requirements</a>
+      <dt><img style="display:none" src="dot.gif"><a target="detail" href="extended_type_info.html#models">Models</a>
+    </dl></div></dd>
+    <dt><img style="display:none" src="dot.gif"><a target="detail" href="void_cast.html"><code>void_cast</code></a>
+    <dt><img style="display:none" src="dot.gif"><a target="detail" href="codecvt.html"><code>utf8_codecvt_facet</code></a>
+    <dt><img style="display:none" src="dot.gif"><a target="detail" href="strong_typedef.html"><code>BOOST_STRONG_TYPEDEF</code></a>
+    <dt><img style="display:none" src="dot.gif"><a target="detail" href="state_saver.html"><code>state_saver</code></a>
+    <dt><img style="display:none" src="dot.gif"><a target="detail" href="dataflow.html">Dataflow Iterators</a>
+    <dt><img style="display:none" src="dot.gif"><a target="detail" href="smart_cast.html"><code>smart_cast</code></a>
+    <dt><img style="display:none" src="dot.gif"><a target="detail" href="static_warning.html"><code>BOOST_STATIC_WARNING</code></a>
+    <dt><img style="display:none" src="plus.gif" id="singleton"><a target="detail" href="singleton.html"><code>singleton</code></a>
+    <dd><div id="singleton_detail"><dl class="page-index">
+      <dt><img style="display:none" src="dot.gif"><a target="detail" href="singleton.html#motivation">Motivation</a>
+      <dt><img style="display:none" src="dot.gif"><a target="detail" href="singleton.html#features">Features</a>
+      <dt><img style="display:none" src="dot.gif"><a target="detail" href="singleton.html#classinterface">Class Interface</a>
+      <dt><img style="display:none" src="dot.gif"><a target="detail" href="singleton.html#requirements">Requirements</a>
+      <dt><img style="display:none" src="dot.gif"><a target="detail" href="singleton.html#examples">Examples</a>
+      <dt><img style="display:none" src="dot.gif"><a target="detail" href="singleton.html#multithreading">Multi-Threading</a>
+    </dl></div></dd>
+  </dl></div></dd>
+  <!--
+  <dt><img style="display:none" src="dot.gif"><a target="detail" href="configuration.html">Configuration Information</a></dt>
+    -->
+  <dt><img style="display:none" src="dot.gif"><a target="detail" href="faq.html">Tips and Tricks</a>
+  <dt><img style="display:none" src="plus.gif" id="rationale"><a target="detail" href="rationale.html">Rationale</a></dt>
+  <dd><div id="rationale_detail"><dl class="page-index">
+    <dt><img style="display:none" src="dot.gif"><a target="detail" href="rationale.html#serialization">The term "serialization" is preferred to "persistence"</a></dt>
+    <dt><img style="display:none" src="dot.gif"><a target="detail" href="rationale.html#archives">Archives are not streams</a></dt>
+    <dt><img style="display:none" src="dot.gif"><a target="detail" href="rationale.html#typeid"><code style="white-space: normal">typeid</code> information is not included in archives</a></dt>
+  </dl></div></dd>
+
+  <dt><img style="display:none" src="plus.gif" id="todo"><a target="detail" href="todo.html">To Do</a></dt>
+  <dd><div id="todo_detail"><dl class="page-index">
+    <dt><img style="display:none" src="dot.gif"><a target="detail" href="todo.html#portablebinaryarchive">Portable Binary Archive</a></dt>
+    <dt><img style="display:none" src="dot.gif"><a target="detail" href="todo.html#performancetesting">Performance Testing and Profiling</a></dt>
+    <dt><img style="display:none" src="dot.gif"><a target="detail" href="todo.html#backversioning">Back Versioning</a></dt>
+    <dt><img style="display:none" src="dot.gif"><a target="detail" href="todo.html#nortti">Environments without RTTI</a></dt>
+
+    <dt><img style="display:none" src="plus.gif" id="newcasestudies"><a target="detail" href="new_case_studies.html">Proposed Case Studies</a></dt>
+    <dd><div id="newcasestudies_detail"><dl class="page-index">
+      <dt><img style="display:none" src="dot.gif"><a target="detail" href="new_case_studies.html#functionobject">Serializing a Function Object</a></dt>
+      <dt><img style="display:none" src="dot.gif"><a target="detail" href="new_case_studies.html#archiveadaptor">Archive Adaptors</a></dt>
+      <dt><img style="display:none" src="dot.gif"><a target="detail" href="new_case_studies.html#archivehelper">Archive Helpers</a></dt>
     </dl></div></dd>
 
-    <dt><img style="display:none" src="plus.gif" id="reference"><a target="detail" href="reference.html">Reference</a></dt>
-    <dd><div id="reference_detail"><dl class="page-index"> 
-      <dt><img style="display:none" src="plus.gif" id="archive_concept"><a target="detail" href="archives.html">Archive Concepts</a>
-      <dd><div id="archive_concept_detail"><dl class="page-index">
-        <dt><img style="display:none" src="dot.gif"><a target="detail" href="archives.html#saving_interface">Saving Archive Concept</a>
-        <dt><img style="display:none" src="dot.gif"><a target="detail" href="archives.html#loading_interface">Loading Archive Concept</a>
-        <dt><img style="display:none" src="dot.gif"><a target="detail" href="archives.html#archive_models">Archive Models</a>
-        <dt><img style="display:none" src="dot.gif"><a target="detail" href="archives.html#exceptions">Exceptions</a>
-        <dt><img style="display:none" src="dot.gif"><a target="detail" href="archives.html#charactersets">Character Sets</a>
-      </dl></div></dd>
-      <dt><img style="display:none" src="plus.gif" id="serialization"><a target="detail" href="serialization.html">Serializable Concept</a>
-      <dd><div id="serialization_detail"><dl class="page-index">
-        <dt><img style="display:none" src="dot.gif"><a target="detail" href="serialization.html#primitiveoperators">Primitive Types</a>
-        <dt><img style="display:none" src="dot.gif" id="class"><a target="detail" href="serialization.html#classoperators">Class Types</a>
-        <dd><div id="class_detail"><dl class="page-index">
-          <dt><img style="display:none" src="dot.gif"><a target="detail" href="serialization.html#member">Member Function</a>
-          <dt><img style="display:none" src="plus.gif" id="splitfree"><a target="detail" href="serialization.html#free">Free Function</a>
-          <dd><div id="splitfree_detail"><dl class="page-index">
-            <dt><img style="display:none" src="dot.gif"><a target="detail" href="serialization.html#namespaces">Namespaces for Free Function Overrides</a>
-          </dl></div></dd>
-          <dt><img style="display:none" src="plus.gif" id="members"><a target="detail" href="serialization.html#classmembers">Class Members</a>
-          <dd><div id="members_detail"><dl class="page-index">
-            <dt><img style="display:none" src="dot.gif"><a target="detail" href="serialization.html#base">Base Classes</a>
-            <dt><img style="display:none" src="dot.gif"><a target="detail" href="serialization.html#const"><code>const</code> Members</a>
-            <dt><img style="display:none" src="dot.gif"><a target="detail" href="serialization.html#templates">Templates</a>
-          </dl></div></dd>
-          <dt><img style="display:none" src="dot.gif"><a target="detail" href="serialization.html#versioning">Versioning</a>
-          <dt><img style="display:none" src="dot.gif"><a target="detail" href="serialization.html#splitting">Splitting <code>serialize</code> into <code>save/load</code></a>
-        </dl></div></dd>
-        <dt><img style="display:none" src="plus.gif" id="pointers"><a target="detail" href="serialization.html#pointeroperators">Pointers</a>
-        <dd><div id="pointers_detail"><dl class="page-index">
-          <dt><img style="display:none" src="dot.gif"><a target="detail" href="serialization.html#constructors">Non-Default Constructors</a>
-          <dt><img style="display:none" src="plus.gif" id="derivedpointers"><a target="detail" href="serialization.html#derivedpointers">Pointers to Objects of Derived Classes</a>
-          <dd><div id="derivedpointers_detail"><dl class="page-index">
-            <dt><img style="display:none" src="dot.gif"><a target="detail" href="serialization.html#registration">Registration</a>
-            <dt><img style="display:none" src="dot.gif"><a target="detail" href="serialization.html#instantiation">Instantiation</a>
-            <dt><img style="display:none" src="dot.gif"><a target="detail" href="serialization.html#selectivetracking">Selective Tracking</a>
-            <dt><img style="display:none" src="dot.gif"><a target="detail" href="serialization.html#runtimecasting">Runtime Casting</a>
-          </dl></div></dd>
-        </dl></div></dd>
-        <dt><img style="display:none" src="dot.gif"><a target="detail" href="serialization.html#references">References</a>
-        <dt><img style="display:none" src="plus.gif" id="wrappers"><a target="detail" href="wrappers.html">Serialization Wrappers</a>
-        <dd><div id="wrappers_detail"><dl class="page-index">
-          <dt><img style="display:none" src="dot.gif"><a target="detail" href="wrappers.html#binaryobjects">Binary Objects</a>
-          <dt><img style="display:none" src="dot.gif"><a target="detail" href="wrappers.html#arrays">Arrays</a>
-          <dt><img style="display:none" src="dot.gif"><a target="detail" href="wrappers.html#strong_type"><code style="white-space: normal">strong_type</code></a>
-          <dt><img style="display:none" src="dot.gif"><a target="detail" href="wrappers.html#collection_size_type">Collection Sizes</a>
-          <dt><img style="display:none" src="dot.gif"><a target="detail" href="wrappers.html#nvp">Name-Value Pairs</a>
-          <dt><img style="display:none" src="dot.gif"><a target="detail" href="wrappers.html#composition">Composition</a>
-        </dl></div></dd>
-        <dt><img style="display:none" src="plus.gif" id="traits"><a target="detail" href="traits.html">Class Serialization Traits</a>
-        <dd><div id="traits_detail"><dl class="page-index">
-          <dt><img style="display:none" src="dot.gif"><a target="detail" href="traits.html#version">Version</a>
-          <dt><img style="display:none" src="dot.gif"><a target="detail" href="traits.html#level">Implementation Level</a>
-          <dt><img style="display:none" src="dot.gif"><a target="detail" href="traits.html#tracking">Object Tracking</a>
-          <dt><img style="display:none" src="dot.gif"><a target="detail" href="traits.html#export">Export Key</a>
-          <dt><img style="display:none" src="dot.gif"><a target="detail" href="traits.html#Abstract">Abstract</a>
-          <dt><img style="display:none" src="dot.gif"><a target="detail" href="traits.html#typeinfo">Type Information Implementation</a>
-          <dt><img style="display:none" src="dot.gif"><a target="detail" href="traits.html#wrappers">Wrappers</a>
-          <dt><img style="display:none" src="dot.gif"><a target="detail" href="traits.html#templates">Template Serialization Traits</a>
-        </dl></div></dd>
-        <dt><img style="display:none" src="dot.gif"><a target="detail" href="serialization.html#models">Models - Serialization Implementations Included in the Library</a>
-      </dl></div></dd>
-      <dt><img style="display:none" src="plus.gif" id="special"><a target="detail" href="special.html">Special Considerations</a>
-      <dd><div id="special_detail"><dl class="page-index">
-        <dt><img style="display:none" src="dot.gif"><a target="detail" href="special.html#objecttracking">Object Tracking</a>
-        <dt><img style="display:none" src="dot.gif"><a target="detail" href="special.html#export">Exporting Class Serialization</a>
-        <dt><img style="display:none" src="dot.gif"><a target="detail" href="special.html#classinfo">Class Information</a>
-        <dt><img style="display:none" src="plus.gif" id="portability"><a target="detail" href="special.html#portability">Archive Portability</a>
-        <dd><div id="portability_detail"><dl class="page-index">
-          <dt><img style="display:none" src="dot.gif"><a target="detail" href="special.html#numerics">Numerics</a>
-          <dt><img style="display:none" src="dot.gif"><a target="detail" href="special.html#traits">Traits</a>
-        </dl></div></dd>
-        <dt><img style="display:none" src="dot.gif"><a target="detail" href="special.html#binary_archives">Binary Archives</a>
-        <dt><img style="display:none" src="dot.gif"><a target="detail" href="special.html#xml_archives">XML Archives</a>
-        <dt><img style="display:none" src="dot.gif"><a target="detail" href="special.html#dlls">DLLS - Serialization and Runtime Linking</a>
-        <dt><img style="display:none" src="dot.gif"><a target="detail" href="special.html#multi_threading">Multi-Threading</a>
-        <dt><img style="display:none" src="dot.gif"><a target="detail" href="special.html#optimizations">Optimzations</a>
-        <dt><img style="display:none" src="plus.gif" id="exceptions"><a target="detail" href="exceptions.html">Archive Exceptions</a>
-        <dd><div id="exceptions_detail"><dl class="page-index">
-          <dt><img style="display:none" src="dot.gif"><a target="detail" href="exceptions.html#unregistered_class"><code>unregistered_class</code></a>
-          <dt><img style="display:none" src="dot.gif"><a target="detail" href="exceptions.html#invalid_signature"><code>invalid_signature</code></a>
-          <dt><img style="display:none" src="dot.gif"><a target="detail" href="exceptions.html#unsupported_version"><code>unsupported_version</code></a>
-          <dt><img style="display:none" src="dot.gif"><a target="detail" href="exceptions.html#pointer_conflict"><code>pointer_conflict</code></a>
-          <dt><img style="display:none" src="dot.gif"><a target="detail" href="exceptions.html#incompatible_native_format"><code>incompatible_format</code></a>
-          <dt><img style="display:none" src="dot.gif"><a target="detail" href="exceptions.html#array_size_too_short"><code>array_size_too_short</code></a>
-          <dt><img style="display:none" src="dot.gif"><a target="detail" href="exceptions.html#stream_error"><code>stream_error</code></a>
-          <dt><img style="display:none" src="dot.gif"><a target="detail" href="exceptions.html#invalid_class_name"><code>invalid_class_name</code></a>
-          <dt><img style="display:none" src="dot.gif"><a target="detail" href="exceptions.html#unregistered_cast"><code>unregistered_cast</code></a>
-          <dt><img style="display:none" src="dot.gif"><a target="detail" href="exceptions.html#xml_archive_parsing_error"><code>xml_archive_parsing_error</code></a>
-          <dt><img style="display:none" src="dot.gif"><a target="detail" href="exceptions.html#xml_archive_tag_mismatch"><code>xml_archive_tag_mismatch</code></a>
-          <dt><img style="display:none" src="dot.gif"><a target="detail" href="exceptions.html#xml_archive_tag_name_error"><code>xml_archive_tag_name_error</code></a>
-        </dl></div></dd>
-        <dt><img style="display:none" src="dot.gif"><a target="detail" href="exception_safety.html">Exception Safety</a>
-      </dl></div></dd>
-      <dt><img style="display:none" src="plus.gif" id="archive_reference"><a target="detail" href="archive_reference.html">Archive Class Reference</a>
-      <dd><div id="archive_reference_detail"><dl class="page-index">
-        <dt><img style="display:none" src="dot.gif"><a target="detail" href="archive_reference.html#implementation">Implementation</a>
-        <dt><img style="display:none" src="dot.gif"><a target="detail" href="archive_reference.html#usage">Usage</a>
-        <dt><img style="display:none" src="dot.gif"><a target="detail" href="archive_reference.html#testing">Testing</a>
-        <dt><img style="display:none" src="dot.gif"><a target="detail" href="archive_reference.html#polymorphic">Polymorphic Archives</a>
-      </dl></div></dd>
-      <dt><img style="display:none" src="plus.gif" id="implementation"><a target="detail" href="implementation.html">Implementation Notes</a>
-      <dd><div id="implementation_detail"><dl class="page-index">
-        <dt><img style="display:none" src="dot.gif"><a target="detail" href="implementation.html#functiontemplateordering">Partial Function Template Ordering</a>
-        <dt><img style="display:none" src="dot.gif"><a target="detail" href="implementation.html#charencoding">Character Encoding</a>
-        <dt><img style="display:none" src="dot.gif"><a target="detail" href="implementation.html#tempatesyntax">Template Invocation syntax</a>
-        <dt><img style="display:none" src="dot.gif"><a target="detail" href="implementation.html#partialtemplatespecialization">Partial Template Specialization</a>
-        <dt><img style="display:none" src="plus.gif" id="othercompilerissues"><a target="detail" href="implementation.html#othercompilerissues">Specific Compiler/Library Issues</a>
-        <div id="othercompilerissues_detail"><dl class="page-index">
-          <dt><img style="display:none" src="dot.gif"><a target="detail" href="implementation.html#gcc3x">GCC 3.X,4.X</a>
-          <dt><img style="display:none" src="dot.gif"><a target="detail" href="implementation.html#gcc295">GCC 2.95</a>
-          <dt><img style="display:none" src="dot.gif"><a target="detail" href="implementation.html#intel80">Intel 8.0</a>
-          <dt><img style="display:none" src="dot.gif"><a target="detail" href="implementation.html#vc80">Visual C++ 8.0</a>
-          <dt><img style="display:none" src="dot.gif"><a target="detail" href="implementation.html#vc71">Visual C++ 7.1</a>
-          <dt><img style="display:none" src="dot.gif"><a target="detail" href="implementation.html#vc70">Visual C++ 7.0</a>
-          <dt><img style="display:none" src="dot.gif"><a target="detail" href="implementation.html#vc6">Visual C++ 6.0</a>
-          <dt><img style="display:none" src="dot.gif"><a target="detail" href="implementation.html#borland">Borland 5.64 and 5.51</a>
-          <dt><img style="display:none" src="dot.gif"><a target="detail" href="implementation.html#comeau">Comeau 4.3.3</a>
-          <dt><img style="display:none" src="dot.gif"><a target="detail" href="implementation.html#codewarrior">Code Warrior 8.3</a>
-          <dt><img style="display:none" src="dot.gif"><a target="detail" href="implementation.html#tru64">TRU64</a>
-          <dt><img style="display:none" src="dot.gif"><a target="detail" href="implementation.html#dinkumware">Dinkumware Library</a>
-          <dt><img style="display:none" src="dot.gif"><a target="detail" href="implementation.html#stlport">STLPort 4.5.3</a>
-        </dl></div>
-        <dt><img style="display:none" src="plus.gif" id="headers"><a target="detail" href="headers.html">Code Structure</a>
-        <div id="headers_detail"><dl class="page-index">
-          <dt><img style="display:none" src="plus.gif" id="userincludes"><a target="detail" href="headers.html#userincludes">Files Included by User Programs</a>
-          <div id="userincludes_detail"><dl class="page-index">
-            <dt><img style="display:none" src="dot.gif"><a target="detail" href="headers.html#archiveimplementations">Archive Implementations</a>
-            <dt><img style="display:none" src="dot.gif"><a target="detail" href="headers.html#serializationdeclarations">Serialization Declarations</a>
-            <dt><img style="display:none" src="dot.gif"><a target="detail" href="headers.html#serializationimplementations">Serialization Implementations</a>
-          </dl></div>
-          <dt><img style="display:none" src="plus.gif" id="libraryimplementation"><a target="detail" href="headers.html#libraryimplementation">Files Which Implement the Library</a>
-          <div id="libraryimplementation_detail"><dl class="page-index">
-            <dt><img style="display:none" src="dot.gif"><a target="detail" href="headers.html#archivedevelopment">Archive Development</a>
-            <dt><img style="display:none" src="dot.gif"><a target="detail" href="headers.html#archiveinternals">Archive Internals</a>
-            <dt><img style="display:none" src="dot.gif"><a target="detail" href="headers.html#codemodules">Archive Library Code Modules</a>
-            <dt><img style="display:none" src="dot.gif"><a target="detail" href="headers.html#dataflowiterators">Dataflow Iterators</a>
-          </dl></div>
-        </dl></div>
-      </dl></div></dd>
-    </dl></div></dd>
-    <dt><img style="display:none" src="plus.gif" id="case_studies">Case Studies
-    <dd><div id="case_studies_detail"><dl class="page-index">
-      <dt><img style="display:none" src="dot.gif"><a target="detail" href="shared_ptr.html">Template serialization - <code>shared_ptr&lt;class T&gt;</code></a>
-      <dt><img style="display:none" src="dot.gif"><a target="detail" href="shared_ptr2.html"><code>shared_ptr&lt;class T&gt;</code>Revisited</a>
-      <dt><img style="display:none" src="dot.gif"><a target="detail" href="pimpl.html">PIMPL</a>
-      <dt><img style="display:none" src="dot.gif"><a target="detail" href="derivation.html">Derivation from an Existing Archive Class</a>
-    </dl></div></dd>
-    <dt><img style="display:none" src="plus.gif" id="miscellaneous">Miscellaneous
-    <dd><div id="miscellaneous_detail"><dl class="page-index">
-      <dt><img style="display:none" src="plus.gif" id="extended_type_info"><a target="detail" href="extended_type_info.html"><code>extended_type_info</code></a>
-      <dd><div id="extended_type_info_detail"><dl class="page-index">
-        <dt><img style="display:none" src="dot.gif"><a target="detail" href="extended_type_info.html#motivation">Motivation</a>
-        <dt><img style="display:none" src="dot.gif"><a target="detail" href="extended_type_info.html#runtime">Runtime Interface</a>
-        <dt><img style="display:none" src="dot.gif"><a target="detail" href="extended_type_info.html#requirements">Requirements</a>
-        <dt><img style="display:none" src="dot.gif"><a target="detail" href="extended_type_info.html#models">Models</a>
-      </dl></div></dd>
-      <dt><img style="display:none" src="dot.gif"><a target="detail" href="void_cast.html"><code>void_cast</code></a>
-      <dt><img style="display:none" src="dot.gif"><a target="detail" href="codecvt.html">utf-8 code_cvt</a>
-      <dt><img style="display:none" src="dot.gif"><a target="detail" href="strong_typedef.html"><code>BOOST_STRONG_TYPEDEF</code></a>
-      <dt><img style="display:none" src="dot.gif"><a target="detail" href="state_saver.html"><code>state_saver</code></a>
-      <dt><img style="display:none" src="dot.gif"><a target="detail" href="dataflow.html">Dataflow Iterators</a>
-      <dt><img style="display:none" src="dot.gif"><a target="detail" href="smart_cast.html"><code>smart_cast</code></a>
-      <dt><img style="display:none" src="dot.gif"><a target="detail" href="static_warning.html"><code>BOOST_STATIC_WARNING</code></a>
-    </dl></div></dd>
-    <!--
-    <dt><img style="display:none" src="dot.gif"><a target="detail" href="configuration.html">Configuration Information</a></dt>
+  </dl></div></dd>
+
+  <dt><img style="display:none" src="dot.gif"><a target="detail" href="history.html">History</a>
+  <!--
+  <dt><img style="display:none" src="dot.gif"><a target="detail" href="definitions.html">Definitions</a></dt>
+  <dt><img style="display:none" src="dot.gif"><a target="detail" href="faq.html">Frequently Asked Questions (FAQs)</a></dt>
     -->
-    <dt><img style="display:none" src="plus.gif" id="rationale"><a target="detail" href="rationale.html">Rationale</a></dt>
-    <dd><div id="rationale_detail"><dl class="page-index">
-      <dt><img style="display:none" src="dot.gif"><a target="detail" href="rationale.html#serialization">The term "serialization" is preferred to "persistence"</a></dt>
-      <dt><img style="display:none" src="dot.gif"><a target="detail" href="rationale.html#archives">Archives are not streams</a></dt>
-      <dt><img style="display:none" src="dot.gif"><a target="detail" href="rationale.html#typeid"><code style="white-space: normal">typeid</code> information is not included in archives</a></dt>
-      <dt><img style="display:none" src="dot.gif"><a target="detail" href="rationale.html#trap">Compile time trap when saving a non-const value</a></dt>
-    </dl></div></dd>
-    <dt><img style="display:none" src="dot.gif"><a target="detail" href="history.html">History</a>
-    <!--
-    <dt><img style="display:none" src="dot.gif"><a target="detail" href="definitions.html">Definitions</a></dt>
-    <dt><img style="display:none" src="dot.gif"><a target="detail" href="faq.html">Frequently Asked Questions (FAQs)</a></dt>
-    -->
-    <dt><img style="display:none" src="dot.gif"><a target="detail" href="bibliography.html">Bibliography</a></dt>
-    <dt><img style="display:none" src="dot.gif"><a target="detail" href="acknowledgments.html">Acknowledgments</a></dt>
-  </dl></div>
+  <dt><img style="display:none" src="dot.gif"><a target="detail" href="bibliography.html">Bibliography</a></dt>
+  <dt><img style="display:none" src="dot.gif"><a target="detail" href="acknowledgments.html">Acknowledgments</a></dt>
+</dl></div>
 </small>
 </body>
 </html>

doc/dataflow.html

@@ -124,7 +124,7 @@ std::copy(
     ostream_iterator<char>(os)
 );
 </code></pre>
-This macro is defined in <a target="pfto" href="../../../boost/pfto.hpp">&lt;boost/pfto.hpp&gt;</a>.
+This macro is defined in <a target="pfto" href="../../../boost/serialization/pfto.hpp">&lt;boost/serialization/pfto.hpp&gt;</a>.
 For more information about this topic, check the source.
 
 <h4>Dereferencing</h4>

doc/derivation.html

@@ -26,42 +26,48 @@ http://www.boost.org/LICENSE_1_0.txt)
 </table>
 <hr>
 <dl class="page-index">
-  <dt><a target="detail" href="#portable_archives">Portable Binary Archives</a>
-  <dt><a target="detail" href="#fast_archives">Fast Binary Archives</a>
 </dl>
 
-<a name=portable_archives>
-<h3>Portable Binary Archives</h3>
+<h3>Log Archive</h3>
 It may happen that one wants to create a new archive class by derivation from one
 of the included ones. Included is a sample program that shows how to derive a 
 new archive from one of the ones included with the library.  The first example is
-<a href="../example/demo_portable_archive.cpp" target="demo_portable_archive_cpp">demo_portable_archive.cpp</a>.
-This binary archive save/loads integers in a portable format.  To this end
-it is derived from the native binary archive and the save/load functions for
-integers are overridden with special versions which convert to big endian
-format if necessary.  It also implements an exception for the case where an
-integer saved on one platform is too large for the platform which is loading
-the archive.  This example doesn't address floating point types.
-This examples illustrates several issues that have to be addressed when doing
-something like this.  The discussion below refers to the output archive only but it
-applies equally to input archives as well.
+<a href="../example/demo_log.cpp" target="demo_log_cpp">
+demo_log.cpp</a>.
+<p>
+This derivation from the xml archive writes output in xml without the extra
+information required to read the data back into the application.  It might be
+used to export one's data as simple xml for other applications or for logging
+data while debugging.
+<p>
+To this end it is derived from the included xml archive and the save functions for
+some types are specialized for this application.  
+<p>
+The serialization library is
+implemented using the <b>C</b>uriously <b>R</b>ecurring <b>T</b>emplate 
+<b>P</b>attern (<b>CRTP</b>).  Also, all common code is factored out into
+separate modules to minimize code repetition. This makes derivation from
+an existing archive less straight forward than it would otherwise be.
+<p> 
+This example illustrates several issues that have to be addressed when doing
+something like this
 <ol>
-    <li><i>It is derived from</i> <code style="white-space: normal">binary_oarchive_impl<portable_binary_oarchive></code> 
-        <b>NOT</b> <code style="white-space: normal">binary_oarchive</code> <br>
+    <li><i>It is derived from</i> <code style="white-space: normal">xml_oarchive_impl<log_archive></code> 
+        <b>NOT</b> <code style="white-space: normal">xml_oarchive</code> <br>
 As described in the comments in
-<a href="../../../boost/archive/binary_oarchive.hpp" target="binary_oarchive_hpp">binary_oarchive.hpp</a>.
-<code style="white-space: normal">binary_oarchive</code> really a shorthand name for 
-<code style="white-space: normal">binary_oarchive_impl&lt;binary_oarchive&gt;</code>.  So we should derive
-from <code style="white-space: normal">binary_oarchive_impl&lt;portable_binary_oarchive&gt;</code> rather
-than <code style="white-space: normal">binary_oarchive</code>.
+<a href="../../../boost/archive/xml_oarchive.hpp" target="xml_oarchive_hpp">xml_oarchive.hpp</a>.
+<code style="white-space: normal">xml_oarchive</code> really a shorthand name for 
+<code style="white-space: normal">xml_oarchive_impl&lt;xml_oarchive&gt;</code>.  So we should derive
+from <code style="white-space: normal">xml_oarchive_impl&lt;log_archive&gt;</code> rather
+than <code style="white-space: normal">xml_oarchive</code>.
 <pre><code>
-class portable_binary_oarchive :
-    // don't derive from binary_oarchive !!!
-    public binary_oarchive_impl&lt;portable_binary_oarchive&gt;
+class log_archive :
+    // don't derive from xml_oarchive !!!
+    public xml_oarchive_impl&lt;log_archive&gt;
 {
 ...
 </code></pre>
-    <li><i>Note the</i> <code style="white-space: normal">portable_binary_oarchive</code> <i>between the</i> &lt;&gt;
+    <li><i>Note the</i> <code style="white-space: normal">log_archive</code> <i>between the</i> &lt;&gt;
 This is required so that base classes can downcast their <code style="white-space: normal">this</code> pointer
 to the most derived class.  This is referred to as <b>C</b>uriously <b>R</b>ecurring
 <b>T</b>emplate <b>P</b>attern (<b>CRTP</b>) <a href="bibliography.html#11">[11]</a>.  
@@ -70,24 +76,28 @@ It is used to implement static polymorphism.
 This can be done by making members public or by including friend declarations for
 the base classes.
 <pre><code>
-    typedef portable_binary_oarchive derived_t;
-    friend class detail::common_oarchive&lt;derived_t&gt;;
-    friend class basic_binary_oarchive&lt;derived_t&gt;;
-    friend class basic_binary_oprimitive&lt;
-        derived_t, 
-        std::ostream::char_type, 
-        std::ostream::traits_type
-    &gt;;
+    friend class detail::common_oarchive&lt;log_archive&gt;;
+    friend class basic_xml_oarchive&lt;log_archive&gt;;
     friend class boost::serialization::save_access;
 </code></pre>
+
+    <li><i></i>Reread <a target="detail" href="headers.html#archiveinternals">Archive Internals</a>.
+This describes the class hierarchy so that you know what to override.
+    <li><i>Note the usage of PFTO.</i>  Some compilers fail to provide support for
+partial function template ordering.  The serialization library works around by
+using <a target="detail" href="implementation.html#functiontemplateordering">
+<b>P</b>artial <b>F</b>unction <b>T</b>emplate <b>O</b>rdering</a> in several places.
+In archive classes, this takes
+. This is done
+in several places, including the archive classes themselves.
     <li><i>Base class functions will usually need to be explicitly invoked</i>
-We commonly overload the function name <code style="white-space: normal">save</code> for saving primitives.
-This is very convenient.  Usage of a function name in a derived class
+We commonly specialize the function name <code style="white-space: normal">save_override</code> 
+for saving primitives. Usage of a function name in a derived class
 "hides" similarly named functions of the base class.  That is, 
 function name overloading doesn't automatically
 include base classes.  To address this, we can use:
 <pre><code>
-    using binary_oarchive_impl&lt;derived_t&gt;::save;
+    using xml_oarchive_impl&lt;derived_t&gt;::save;
     void save(const unsigned int t);
     ...
 </code></pre>
@@ -97,13 +107,13 @@ that the following equivalent works on more compilers.
     // default fall through for any types not specified here
     template&lt;class T&gt;
     void save(const T & t){
-        binary_oarchive_impl&lt;derived_t&gt;::save(t);
+        xml_oarchive_impl&lt;derived_t&gt;::save(t);
     }
     void save(const unsigned int t);
     ...
 </code></pre>
 so it's what I use.
-    <li><i>Template definitions of base classes may have to be included.</i>
+    <li><i>Template definitions of base classes may have to be explicitly instantiated.</i>
     The demo includes
 <pre><code>
 // explicitly instantiate for this type of binary stream
@@ -115,44 +125,30 @@ will result in undefined symbol errors when the program is linked.
 Base classes using <b>CRTP</b> must be templates with a parameter corresponding to
 the most derived class.  As presented here, this class doesn't qualify, so
 it cannot be used as a base class.  In order to derive further from this class,
-it would have to be reorganized along the lines of the original <code style="white-space: normal">binary_oarchive</code>.
+it would have to be reorganized along the lines of the original <code style="white-space: normal">xml_oarchive</code>.
 Specifically, it would look something like:
 <pre><code>
 template&lt;class Archive&gt;
-class portable_binary_oarchive_impl :
-    // don't derive from binary_oarchive !!!
-    public binary_oarchive_impl&lt;Archive&gt;
+class log_archive_impl :
+    // don't derive from xml_oarchive !!!
+    public xml_oarchive_impl&lt;Archive&gt;
 {
     ...
 );
 
 // do not derived from this class !!!
-class portable_binary_oarchive : 
-    public portable_binary_oarchive_impl&lt;portable_binary_oarchive&gt;
+class log_archive : 
+    public log_archive_impl&lt;log_archive&gt;
 {
 public:
-    portable_binary_oarchive(std::ostream & os, unsigned int flags = 0) :
-        portable_binary_oarchive_impl&lt;binary_oarchive&gt;(os, flags)
+    log_archive(std::ostream & os, unsigned int flags = 0) :
+        log_archive_impl&lt;xml_oarchive&gt;(os, flags)
     {}
 };
 </code></pre>
 
 </ol>  
 
-<a name=fast_archives>
-<h3>Fast Binary Archives</h3>
-The second example 
-<a href="../example/demo_fast_archive.cpp" target="demo_fast_archive_cpp">demo_fast_archive.cpp</a>.
-is similar to the first one.  The difference is that it intercepts the serialization before
-the default serialization is invoked.  In this case we want to replace the default
-serialization of C arrays of integers with a faster one.  The default version
-will invoke serialization of each element of the array.  If its an array of
-integers, and we're not concerned with the archive being portable to another platform
-we can just save/load the whole array as a binary string of bytes.  This should
-be faster than the default element by element method.
-<p>
-The same considerations that applied when overriding the the save/load of primitives
-above apply here, and the code is very similar.
 <hr>
 <p><i>&copy; Copyright <a href="http://www.rrsd.com">Robert Ramey</a> 2002-2004. 
 Distributed under the Boost Software License, Version 1.0. (See

doc/exceptions.html

@@ -29,12 +29,14 @@ http://www.boost.org/LICENSE_1_0.txt)
   <dt><a href="#unregistered_class"><code style="white-space: normal">unregistered_class</code></a>
   <dt><a href="#invalid_signature"><code style="white-space: normal">invalid_signature</code></a>
   <dt><a href="#unsupported_version"><code style="white-space: normal">unsupported_version</code></a>
+  <dt><a href="#unsupported_class_version"><code style="white-space: normal">unsupported_class_version</code></a>
   <dt><a href="#pointer_conflict"><code style="white-space: normal">pointer_conflict</code></a>
   <dt><a href="#incompatible_native_format"><code style="white-space: normal">incompatible_native_format</code></a>
   <dt><a href="#array_size_too_short"><code style="white-space: normal">array_size_too_short</code></a>
   <dt><a href="#stream_error"><code style="white-space: normal">stream_error</code></a>
   <dt><a href="#invalid_class_name"><code style="white-space: normal">invalid_class_name</code></a>
   <dt><a href="#unregistered_class"><code style="white-space: normal">unregistered_class</code></a>
+  <dt><a href="#multiple_code_instantiation"><code style="white-space: normal">multiple_code_instantiation</code></a>
   <dt><a href="#xml_archive_parsing_error"><code style="white-space: normal">xml_archive_parsing_error</code></a>
   <dt><a href="#xml_archive_tag_mismatch"><code style="white-space: normal">xml_archive_tag_mismatch</code></a>
   <dt><a href="#xml_archive_tag_name_error"><code style="white-space: normal">xml_archive_tag_name_error</code></a>
@@ -43,8 +45,9 @@ http://www.boost.org/LICENSE_1_0.txt)
 Archive operators can throw a <code style="white-space: normal">boost::archive_exception</code>
 object which can be caught by an application program.  These exceptions are defined
 in the files <a target="archive_exception_hpp" href="../../../boost/archive/archive_exception.hpp">
-boost/archive/archive_exception.hpp</a> and <a target="archive_xml_exception_hpp" href="../../../boost/archive/archive_exception.hpp">
-boost/archive/archive_xml_exception.hpp</a>.
+archive_exception.hpp</a>
+and <a target="basic_xml_archive_hpp" href="../../../boost/archive/basic_xml_archive.hpp">
+basic_xml_archive.hpp</a>.
 <pre><code>
 namespace boost {
 namespace archive {
@@ -71,8 +74,13 @@ public:
         invalid_class_name,     // class name greater than the maximum permitted.
                                 // most likely a corrupted archive or an attempt
                                 // to insert virus via buffer overrun method.
-        unregistered_cast       // base - derived relationship not registered with 
+        unregistered_cast,      // base - derived relationship not registered with 
                                 // void_cast_register
+        unsupported_class_version, // type saved with a version # greater than the 
+                            // one used by the program.  This indicates that the proggram
+                            // needs to be rebuilt.
+        multiple_code_instantiation // code for implementing serialization for some
+                            // type has been instantiated in more than one module.
     } exception_code;
     exception_code code;
     archive_exception(exception_code c) : code(c) {}
@@ -108,7 +116,7 @@ the archive is opened, It is presumed that this file is not a valid archive and
 exception is thrown.
 
 <h3><a name="unsupported_version"><code style="white-space: normal">unsupported_version</code></a></h3>
-This system assigns a version number of 2 to all archives created.  Note that this is in
+This system assigns a version number of 3 to all archives created.  Note that this is in
 no way related to version number of classes used by application programs. This refers
 to the version of the serialization system used to create the archive. Future versions
 of this serialization system will be able to identify archives created under previous
@@ -119,6 +127,14 @@ incompatible in format with the current one.
 <p>Should it ever occur that an older program attempts to read newer archives whose
 format has changed, this exception is thrown.
 
+<h3><a name="unsupported_class_version"><code style="white-space: normal">unsupported_class_version</code></a></h3>
+An attempt has been made to load a class whose version has been incremented since the
+program was written.  Suppose that a class has been assigned version number 3 and the program
+has been built and sent to third parties.  Now suppose that the definition of that class
+has been altered, the version number has been incremented to 4 and new archives have been
+built.  If one attempts to load these new archives with the original program, this 
+exception will be thrown.
+
 <h3><a name="pointer_conflict"><code style="white-space: normal">pointer_conflict</code></a></h3>
 To understand what this exception means consider the following scenario
 <pre><code>
@@ -215,6 +231,11 @@ is described in <a href="serialization.html#runtimecasting">Runtime Casting</a>.
 This exception is thrown if an attempt is made to convert between two pointers 
 whose relationship has not been registered,
 
+<h3><a name="multiple_code_instantiation"><code style="white-space: normal">multiple_code_instantiation</code></a></h3>
+This exception is thrown when it is detected that the serialization of the same type 
+has been instantiated more that once.  This might occur when
+serialization code is instantiated in both the mainline and one or more DLLS.
+
 <h3><a name="xml_archive_parsing_error"><code style="white-space: normal">xml_archive_parsing_error</code></a></h3>
 The XML generated by the serialization process is intimately coupled to the
 C++ class structure, relationships between objects and the serialization 

doc/extended_type_info.html

@@ -1,4 +1,4 @@
-<!doctype HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
+<!doctype HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
 <html>
 <!--
 (C) Copyright 2002-4 Robert Ramey - http://www.rrsd.com . 
@@ -33,7 +33,6 @@ http://www.boost.org/LICENSE_1_0.txt)
   <dt><a href="#example">Example</a>
 </dl>
 
-
 <h3><a name="motivation">Motivation</a></h3>
 The serialization library needs a system like 
 <code style="white-space: normal">type_info/typeid()</code> to perform
@@ -62,11 +61,6 @@ the following functions
     different applications. In fact, including different headers in different
     name spaces is an accepted method used to avoid name space conflicts.
     Thus the namespace::class_name can't be used as a key.
-  <li>
-    We may want the ability to serialize objects through a base class even though
-    they have no <code style="white-space: normal">virtual</code> function.  That
-    is, objects of classes which are not polymorphic in the strict C++ sense.  This
-    is not supported by the standard system.
   <li>
     There exists the possibility that different classes use different type id 
     mechanism.  The class header might include this information. If we want to 
@@ -74,112 +68,117 @@ the following functions
     mechanism support inter-operability accross different type id systems.
 </ul>
 <h3>Features</h3>
-<code style="white-space: normal"><a target="extended_type_info.hpp" href = "../../../boost/serialization/extended_type_info.hpp">extended_type_info</a></code> is an implementation
+<code style="white-space: normal"><a target="extended_type_info.hpp" href = "../../../boost/serialization/extended_type_info.hpp">
+extended_type_info</a></code> is an implementation
 of <code style="white-space: normal">std::type_info</code> functionality with the 
 following features:
 <ul>
   <li>
-    Maintains a global table of <code style="white-space: normal"><a target="extended_type_info.hpp" href = "../../../boost/serialization/extended_type_info.hpp">extended_type_info</a></code> records - one for each type known
-    to the program.
+    Builds a set of <a target="extended_type_info.hpp" href = "../../../boost/serialization/extended_type_info.hpp">
+    <code style="white-space: normal">extended_type_info</a></code> records - one for each type
+    serialized.
   <li>
-    permits association of an arbitrary key with a type.  Often this key would
+    permits association of an arbitrary string key with a type.  Often this key would
     be the class name - but it doesn't have to be.  This key is referred to as
     a GUID - Globally Unique IDentifier.  Presumably it should be unique in the universe.
     Typically this GUID would be in header files and be used to match type accross
-    applications.
+    applications.  The macro BOOST_CLASS_EXPORT can be invoked to associate a string
+    key with any known type.  We'll refer to these types as "exported types"
   <li>
     permits the "mixing" of type info systems.  For example, one class might use 
     <code style="white-space: normal">typeid()</code> to find the external identifier 
     of a class while another might not.
 </ul>
-The serialization system maintains two global tables.
-<ul>
-  <li>The first is a global type table. it has an entry for each type used.
-  Each entry is an instance of a class derived from 
-  <code style="white-space: normal"><a target="extended_type_info.hpp" href = "../../../boost/serialization/extended_type_info.hpp">extended_type_info</a></code>. This table is used
-  to retrieve the unique <code style="white-space: normal"><a target="extended_type_info.hpp" href = "../../../boost/serialization/extended_type_info.hpp">extended_type_info</a></code>
-  information for any given type.
-  <li>The second is global key table. It has an entry for each type which has been assigned a GUID string key.
-  This table is used to retrieve the unique 
-  <code style="white-space: normal"><a target="extended_type_info.hpp" href = "../../../boost/serialization/extended_type_info.hpp">extended_type_info</a></code> given its GUID.
-</ul>
-This library includes two different type id systems:
-<ul>
-  <li>
-    <code style="white-space: normal"><a target="extended_type_info_typeid.hpp" href = "../../../boost/serialization/extended_type_info_typeid.hpp">extended_type_info_typeid</a></code>
-    which is implemented in terms of the standard
-    <code style="white-space: normal">typeid()</code>.
-  <li>
-    <code style="white-space: normal"><a target="extended_type_info_no_rtti.hpp" href="../../../boost/serialization/extended_type_info_no_rtti.hpp">extended_type_info_no_rtti</a></code>
-    which is implemented in a way that doesn't rely on the existence
-    RTTI.  However, it does require that all classes for which type id is to be used
-    be explictly assigned an external key - which otherwise would be optional.
-</ul>
+
+Exported types are maintained in a global table so that given a string key, the
+corresponding type can be found.  This facility is used by the serialization library
+in order to construct types serialized through a base class pointer.
 
 <h3><a name="runtime">Runtime Interface</a></h3>
 <pre><code">
 namespace boost { 
 namespace serialization {
 
-class BOOST_SERIALIZATION_DECL extended_type_info : 
-    private boost::noncopyable 
+class extended_type_info
 {
 protected:
-    extended_type_info(const char * type_info_key);
+    // this class can't be used as is. It's just the 
+    // common functionality for all type_info replacement
+    // systems.  Hence, make these protected
+    extended_type_info(
+        const unsigned int type_info_key,
+        const char * key
+    );
+    ~extended_type_info();
+    void key_register();
+    void key_unregister();
 public:
-    void self_register();
-    void key_register(const char *key);
     const char * get_key() const;
-
     bool operator<(const extended_type_info &rhs) const;
     bool operator==(const extended_type_info &rhs) const;
-    bool operator!=(const extended_type_info &rhs) const;
-
+    bool operator!=(const extended_type_info &rhs) const {
+        return !(operator==(rhs));
+    }
+    // for plugins
+    virtual void * construct(unsigned int count = 0, ...) const;
+    virtual void destroy(void const * const p) const;
     static const extended_type_info * find(const char *key);
-    static const extended_type_info * find(const extended_type_info * t);
 };
 
 } // namespace serialization 
 } // namespace boost
 </code></pre>
-
-There must be one and only one <code style="white-space: normal"><a target="extended_type_info.hpp" href = "../../../boost/serialization/extended_type_info.hpp">extended_type_info</a></code>
-instance created for each type. For this reason, this class is marked is derived from
-<code style="white-space: normal">boost::noncopyable</code>. 
-
+<p>
+Generally, there will be one and only one
+<code style="white-space: normal"><a target="extended_type_info.hpp" href = "../../../boost/serialization/extended_type_info.hpp">extended_type_info</a></code>
+instance created for each type.  However, this is enforced only at the executable
+module level.  That is, if a program includes some shared libraries or DLLS,
+there may be more than one instance of this class correponding to a particular type.
+For this reason the comparison functions below can't just compare the addresses of 
+this instance but rather must be programmed to compare the the actual information 
+the instances contain.
 <dl>
 
 <dt><h4><pre><code>
-extended_type_info(const char * type_info_key);</code></pre></h4></dt>
-<dd>
-This constructor should be called by all derived classes. It should be passed
-a pointer to a const string which identifies the type id system being used.  This
-type id is used to distinguish among the various type id system that might be used
-and allow them to interoperate.
-</dd>
-
-<dt><h4><pre><code>
-void self_register();
+extended_type_info(unsigned int type_info_key, const char *key);
 </code></pre></h4></dt>
 <dd>
-This function adds entry for an entry to the global type table.  It would usually be 
-called from the constructor of the derived class which implements the 
-<code style="white-space: normal"><a target="extended_type_info.hpp" href = "../../../boost/serialization/extended_type_info.hpp">extended_type_info</a></code> functionality.
-</dd>
-
-<dt><h4><pre><code>
-void key_register(const char *key);
-</code></pre></h4></dt>
-<dd>
-Assign a unique character string identifier to this
-<code style="white-space: normal"><a target="extended_type_info.hpp" href = "../../../boost/serialization/extended_type_info.hpp">extended_type_info</a></code>
-instance and add it to the corresponding global trable. 
-This key is used to identify a type accross different instances of the program.  
-In this way, one instance may know what type to create when necessary.  
-For this purpose, it must be the same in all program instances which
-refer to the same type.
+This constructor should be called by all derived classes.
+The first argument should be the particular implementation. 
+For this default implementation base on typeid(), this is the 
+value 1.  Each system must have its own integer.  This value
+is used to permit the inter-operability of different typeinfo
+systems.
 <p>
+The second argument is a const string which is the external
+name of the type to which this record corresponds.  
 It may sometimes be referred to as a GUID - a <b>G</b>lobal <b>U</b>nique <b>ID</b>entifier.
+It is passed through archives from one program invocation to
+another to uniquely identify the types that the archive contains.
+If the "export" facility is not going to be used, 
+this value may be NULL.
+</dd>
+
+<dt><h4><pre><code>
+void key_register();
+void key_unregister();
+</code></pre></h4></dt>
+<dd>
+This system maintains a global table which relates
+external strings to 
+<code style="white-space: normal">extended_type_info</code> records.
+This table is used when loading pointers to objects serialized
+through a base class pointer.  In this case, the archive 
+contains a string which is looked up in this table to
+determine which <code style="white-space: normal">extended_type_info</code>
+to use for creating a new object.
+<p>
+These functions are called by constructors and
+destructors of classes which implement 
+<code style="white-space: normal">extended_type_info</code>
+to add and remove entries from this table.
+</dd>
+
 <dt><h4><pre><code>
 const char *get_key() const;
 </code></pre></h4></dt>
@@ -189,58 +188,80 @@ instance.  If no key has been associated with the instance, then a NULL is retur
 </dd>
 
 <dt><h4><pre><code>
-bool operator&lt;(const extended_type_info &rhs) const;
-bool operator==(const extended_type_info &rhs) const;
-bool operator!=(const extended_type_info &rhs) const;
+bool operator<(const extended_type_info & rhs) const;
+bool operator==(const extended_type_info & rhs) const;
+bool operator!=(const extended_type_info & rhs) const;
 </code></pre></h4></dt>
 <dd>
-These functions are used to compare two <code style="white-space: normal"><a target="extended_type_info.hpp" href = "../../../boost/serialization/extended_type_info.hpp">extended_type_info</a></code> objects.
-Among other things, these are used for lookup in the tables.
+These functions are used to compare 'wo 
+<a target="extended_type_info.hpp" href = "../../../boost/serialization/extended_type_info.hpp">
+<code style="white-space: normal">
+extended_type_info
+</code> 
+</a>
+objects. They impose a strict total ordering on all
+<code style="white-space: normal">extended_type_info</code> records.
+</dd>
+
+<dt><h4><pre><code>
+virtual void * construct(unsigned int count = 0, ...) const;
+</code></pre></h4></dt>
+<dd>
+Construct a new instance of the type to which this
+<a target="extended_type_info.hpp" href = "../../../boost/serialization/extended_type_info.hpp">
+<code style="white-space: normal">
+extended_type_info
+</code>
+</a>
+record corresponds. This function takes variable list of up to 4 arguments
+of any type.  These arguments are passed to the type's constructor
+at runtime.  In order to use the facility, 
+one must declare a type sequence for the constructor arguments.  
+Arguments for this function must match in number and type
+with those specified when the type was exported.  
+This function permits one to create instances of
+any exported type given only the exported <strong>GUID</strong> assigned
+with BOOST_CLASS_EXPORT.  
+If these types are defined in DLLS or shared libraries.  When these modules
+are loaded at runtime, these constructor can be called until the module
+is unloaded.  These modules are referred to as <b>plugin</b>. 
+</code>
+</dd>
+
+<dt><h4><pre><code>
+virtual void destroy(void const * const p) const;
+</code></pre></h4></dt>
+<dd>
+Destroy an instance created by the above constructor.
+</dd>
 
 <dt><h4><pre><code>
 static const extended_type_info * find(const char *key);
 </code></pre></h4></dt>
 <dd>
-Given a character string key or <strong>GUID</strong>, return the address of the 
-unique corresponding <code style="white-space: normal"><a target="extended_type_info.hpp" href = "../../../boost/serialization/extended_type_info.hpp">extended_type_info</a></code>
+Given a character string key or <strong>GUID</strong>, return the address of a 
+corresponding <code style="white-space: normal"><a target="extended_type_info.hpp" href = "../../../boost/serialization/extended_type_info.hpp">extended_type_info</a></code>
 object. 
 
-<dt><h4><pre><code>
-static const extended_type_info * find(const extended_type_info * t);
-</code></pre></h4></dt>
-<dd>
-Given a pointer to an
-<code style="white-space: normal"><a target="extended_type_info.hpp" href = "../../../boost/serialization/extended_type_info.hpp">extended_type_info</a></code>,
-return the address of the instance of the same type in the main table.
-That is the argument t is used as a search argment to find the main
-table entry for a given type. It would be used like this:
-<code><pre>
-// return the global type entry for our type T
-return find(some_extended_type_info_implementation&lt;T&gt;())
-</pre></code>
-
 </dl>
 
-<h3><a name="requirements">Requirements</a></h3>
+<h3><a name="requirements">Requirements for and Implementation</a></h3>
 In order to be used by the serialization library, an implementation of
 <code style="white-space: normal">extended_type_info</code>, 
-(referred to as ETI here), must implement the following:
+(referred to as ETI here), must be derived from 
+<a target="extended_type_info.hpp" href = "../../../boost/serialization/extended_type_info.hpp">
+<code style="white-space: normal">
+extended_type_info
+</code> 
+</a>
+and also implement the following:
 
 <dl>
 
 <dt><h4><code style="white-space: normal"><pre>
 template&lt;class ETI&gt;
-virtual bool
-ETI::less_than(const extended_type_info &rhs) const;
-</pre></code></h4></dt>
-<dd>
-Impose a strict total ordering on all instances of the class ETI.
-</dd>
-
-<dt><h4><code style="white-space: normal"><pre>
-template&lt;class ETI&gt;
-static const extended_type_info *
-ETI::get_derived_extended_type_info(const T & t);
+const extended_type_info *
+ETI::get_derived_extended_type_info(const T & t) const;
 </pre></code></h4></dt>
 <dd>
 Return a pointer to the 
@@ -250,43 +271,49 @@ the "true type" of the type T.  The "true type" is the lowest type in the
 hierarchy of classes.  The type T can always be cast to the "true type" with
 a static cast.  Implemention of this function will vary among type id systems
 and sometimes will make presumptions about the type T than can be identified
-with a particular <code style="white-space: normal">extended_type_info implementation</code>.
+with a particular <code style="white-space: normal">extended_type_info</code> implementation.
 </dd>
 
 <dt><h4><code style="white-space: normal"><pre>
-template&lt;class ETI&gt;
-static extended_type_info *
-ETI::get_instance();
+virtual bool ETI::is_less_than(const extended_type_info &rhs) const;
 </pre></code></h4></dt>
 <dd>
-Return a pointer to the instance of
-<code style="white-space: normal">extended_type_info</code>
-which corresponds to type T.  Normally these instances are static objects so
-this just amounts to returning the address of this static object.
+Compare this instance to another one using the same
+<code style="white-space: normal">extended_type_info</code> implementation.
 </dd>
 
 <dt><h4><code style="white-space: normal"><pre>
-static void
-template&lt;class ETI&gt;
-ETI::export_register(const char * key);
+virtual bool ETI::is_equal(const extended_type_info &rhs) const;
 </pre></code></h4></dt>
 <dd>
-The main function is to invoke key_register to add the GUID to the
-global table.  Depending on the type id system being used, it might
-perform other initializaition functions as well.
+Compare this instance to another one using the same
+<code style="white-space: normal">extended_type_info</code> implementation.
+Return <code style="white-space: normal">true</code> if the types referred
+to are the same.  Otherwise return 
+<code style="white-space: normal">false</code>
 </dd>
-</dl>
 
-It must define the following 
-<a href="../../mpl/doc/refmanual/integral-constant.html">
-Itegral Constant</a>
-of type 
-<a href="../../mpl/doc/refmanual/bool.html">bool</a>:
-<dl>
 <dt><h4><code style="white-space: normal"><pre>
-ETI::is_polymorphic
+const char ETI::get_key() const;
 </pre></code></h4></dt>
 <dd>
+Retrieve the external key (aka GUID) for this class.
+</dd>
+
+<dt><h4><code style="white-space: normal"><pre>
+virtual void * construct(unsigned int count, ...) const;
+</pre></code></h4></dt>
+<dd>
+Construct an instance of the corresponding type
+with the include argument list.
+</dd>
+
+<dt><h4><code style="white-space: normal"><pre>
+virtual void * destroy(void const * const ptr ) ) const;
+</pre></code></h4></dt>
+<dd>
+Destroy an instance of this type. This calls the
+proper destructor and recovers allocated memory.
 </dd>
 
 </dl>
@@ -294,7 +321,7 @@ ETI::is_polymorphic
 <h3><a name="models">Models</a></h3>
 The serialization library includes two distinct
 <code style="white-space: normal"><a target="extended_type_info.hpp" href="../../../boost/serialization/extended_type_info.hpp">extended_type_info</a></code>
-implementations.
+implementatio's.
 <p>
 <code style="white-space: normal"><h4><a target="extended_type_info_typeid.hpp" href = "../../../boost/serialization/extended_type_info_typeid.hpp">
 extended_type_info_typeid</a></h4></code>is implemented in terms of the standard typeid(). It presumes that RTTI support is enabled
@@ -302,24 +329,88 @@ by the compiler.
 <p>
 <code style="white-space: normal"><h4><a target="extended_type_info_no_rtti.hpp" href="../../../boost/serialization/extended_type_info_no_rtti.hpp">
 extended_type_info_no_rtti</a></h4></code>
-is implemented in a way that doesn't rely on the existence RTTI. 
-However, it does require that all classes for which type id is to be used implement
-a virtual function of the signiture:
+is implemented in a way that doesn't rely on the existence RTTI.
+Instead, it requires that all polymorphic types be explictly exported.
+In addition, if the export facility is to be used to serialize types
+through base class pointers, those types are required to implement
+a virtual function with the signature:
+
 <code><pre>
 virtual const char * get_key();
 </pre></code>
 which returns a unique string the most derived object this class.  
 This function must be virtual in order to implement the functionality required by
 <code style="white-space: normal">ETI::get_derived_extended_type_info</code>
-as described above.  
+as described above.
+
 <h3><a name="example">Example</a></h3>
 The test program <code style="white-space: normal"><a target="test_no_rtti" href="../test/test_no_rtti.cpp">test_no_rtti</a></code>
 implements this function in terms of the <code style="white-space: normal"><a target="extended_type_info_no_rtti.hpp" href="../../../boost/serialization/extended_type_info_no_rtti.hpp">
 extended_type_info</a></code> API above to return the export key associated with the class.  
-This requires that non-abstract types be exported.
+This requires that non-abstract types be exported. It also demonstrates the
+inter-operability with between two different implementations of
+<code style="white-space: normal">extended_type_info</code>.
 
+<h3><a name="type_requirements">Requirements for Each Type</a></h3>
+Each type to be managed by the system must be
+"registered" individually. This is accomplished by instantiating
+templates.  For example, if the type T is to use the type_info system
+one would include the following code:
+
+<code style="white-space: normal"><pre>
+namespace boost {
+namespace serialization {
+template
+struct extended_type_info_typeid&gt;T&gt;;
+template
+struct extended_type_info_typeid&gt;const T&gt;;
+} // serialization
+} // boost
+</pre></code>
+
+For those using the serialization library, this step can be skipped
+as it is done automatically.  The serialization library includes
+the macro:
+
+<code style="white-space: normal"><pre>
+BOOST_CLASS_TYPE_INFO(
+    my_type, 
+    extended_type_info_typeid&gt;my_class&gt;
+)
+</pre></code>
+
+which is used to specify which <code>extended_type_info</code> system is to 
+be used for a given type.
+<p>
+<code>extended_type_info</code> includes a facility for constructing
+instances of types without knowing what the exact types are. This is done
+with the function 
+<code>
+virtual void * extended_type_info::construct(unsigned int count = 0, ...) const;
+</code>
+. For example:
+<br>
+<code><pre>
+struct base {
+...
+};
+struct derived : public base {
+...
+};
+...
+extended_type_info *eti = extended_type_info::find("my_class")
+base * b = eti->construct(...);
+</pre></code>
+<br>
+The <code>construct</code> takes an argument count and up to
+four parameters of any type.  The arguments are passed to the
+constructor of "my_class".
+
+
+A complete example of this can be found
+<a target="test_plugin.cpp" href="test_plugin.cpp">here</a>
 <hr>
-<p><i>&copy; Copyright <a href="http://www.rrsd.com">Robert Ramey</a> 2005. 
+<p><i>&copy; Copyright <a href="http://www.rrsd.com">Robert Ramey</a> 2005-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)
 </i></p>

doc/faq.html

@@ -7,11 +7,47 @@ License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
 http://www.boost.org/LICENSE_1_0.txt)
 -->
 <head>
-<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
-<link rel="stylesheet" type="text/css" href="../../../boost.css">
-<link rel="stylesheet" type="text/css" href="style.css">
-<title>Serialization - FAQ</title>
+    <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
+    <link rel="stylesheet" type="text/css" href="../../../boost.css">
+    <link rel="stylesheet" type="text/css" href="style.css">
+    <title>Serialization - Tips and Tricks</title>
 </head>
 <body link="#0000ff" vlink="#800080">
+    <table border="0" cellpadding="7" cellspacing="0" width="100%" summary="header">
+        <tr>
+            <td valign="top" width="300">
+                <h3>
+                    <a href="../../../index.htm">
+                        <img height="86" width="277" alt="C++ Boost" src="../../../boost.png" border="0"></a></h3>
+            </td>
+            <td valign="top">
+                <h1 align="center">
+                    Serialization</h1>
+                <h2 align="center">
+                    Tips and Tricks</h2>
+            </td>
+        </tr>
+    </table>
+    <hr>
+This section will be used to list answers to questions raise in the mailing
+lists.  Most of these are due to subtle aspects of the library which are
+overlooked even though they might be described in the documenation.  Often,
+these issues are very easy to address - but can be excruciating difficult to
+find.  Should you have such an experience, feel free to vent your frustration
+in a constructive way by adding in your own item.  The best way to do this
+is to create a <a href="http://svn.boost.org/trac/boost/browser">"TRAK" item</a> 
+which includes the text you want to add to this list.
+
+    <ul>
+        <li><h4>
+        <a name="differences_1_37"></a>Differences from Boost 1.37</h2>
+        </h4></li>
+    </ul>
+    <hr>
+    <p>
+        <i>&copy; Copyright <a href="http://www.rrsd.com">Robert Ramey</a> 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) </i>
+    </p>
 </body>
 </html>

doc/headers.html

@@ -1,4 +1,4 @@
-<!doctype HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
+<!doctype HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
 <html>
 <!--
 (C) Copyright 2002-4 Robert Ramey - http://www.rrsd.com . 
@@ -161,13 +161,14 @@ boost/serialization/export.hpp
 </a>
 <dd>For serialization of pointers to derived classes via key export.</dd>
 
-<dt><a target="is_abstract" href="../../../boost/serialization/is_abstract.hpp">
-boost/serialization/is_abstract.hpp
+<dt><a target="assume_abstract" href="../../../boost/serialization/assume_abstract.hpp">
+boost/serialization/assume_abstract.hpp
 </a>
-<dd>For serialization of pointers to abstract base classes.  A generic implementation
-of this is functional only on the most modern compilers.  This one is just
-a thin wrapper which permits one to specify "by hand" whether or not a base class
-is abstract or not.</dd>
+<dd>This is just a thin wrapper which permits one to explicitly specify that a 
+particular type is an abstract base class.  It is necessary to use this
+for compilers which don't support the boost type traits implementation of
+is_abstact.
+</dd>
 
 </dl>
 
@@ -206,7 +207,7 @@ This group of headers includes templates which implement serialization for Stand
 Library or Boost Library templates.  Any program which uses these templates can
 invoke serialization of objects of these types just by including the corresponding header.
 <p>
-By convention, these header files are named:
+By convention' these header files are named:
 
 boost/serialization/xxx.hpp
 
@@ -302,7 +303,7 @@ the rest of the library which aids in understanding.
 <dt><a target="basic_text_oarchive" href="../../../boost/archive/basic_text_oarchive.hpp">
 boost/archive/basic_text_oarchive.hpp
 </a>
-<dt><a target="basic_text_iarchive" href="../../../boost/archive/basic_text_iarchive.hpp">
+<dt><a target="basic_te't_iarchive" href="../../../boost/archive/basic_text_iarchive.hpp">
 boost/archive/basic_text_iarchive.hpp
 </a>
 </dt>
@@ -328,7 +329,7 @@ boost/archive/detail/common_iarchive.hpp
 boost/archive/detail/common_oarchive.hpp
 </a>
 <dd>
-All archive implmentations are derived from these header files.  They provide
+All archive implementations are derived from these header files.  They provide
 the interface to the internal implementation details of the library.
 </dd>
 
@@ -336,11 +337,55 @@ the interface to the internal implementation details of the library.
 
 <a name="archiveinternals">
 <h4>Archive Internals</h4>
-The header files in the directory 
-<a target="basic_xml_iarchive" href="../../../boost/archive/detail">boost/archive/detail</a>
-implement parts of the library itself.  The should never need to be changed by users
+ 
+The interface (see <a target="detail" href="archives.html">Archive Concepts</a>) 
+and implementation are factored out into separate classes to minimize code duplication.
+
+These files are found in the directory
+<a target="boost_archive_detail" href="../../../boost/archive/detail">boost/archive/detail</a>.  
+These are included as necessary by the archive class implemenations listed above.
+This has the unfortunate side effect of making the implementation less transparent.
 of the library in order to implement either a class serialization or a new
-archive type.
+archive type. Users should never find it necessary to change these files.
+<p>
+The following discussion is based on the
+<a target="class_diagram" href="class_diagram.html">class diagram</a>.
+<p>
+<dt><a target="interface_iarchive" href="../../../boost/archive/detail/interface_iarchive.hpp">
+boost/archive/detail/interface_iarchive.hpp</a>
+<dt><a target="interface_iarchive" href="../../../boost/archive/detail/interface_iarchive.hpp">
+boost/archive/detail/interface_iarchive.hpp</a>
+<dd>
+Here are the declarations and definitions which for the 
+<a href="archives.html">archive_concept</a>. This class redirects calls to the 
+archive interface to a function named <code>save_override</code> in the most derived
+archive class. 
+</dd>
+<code>save_override</code> is declared and implemented in each class in
+the archive hierarchy.
+
+<pre><code>
+template<class T>
+void save_override(T & t, BOOST_PFTO int){
+    // All for otherwise unhandled types are forwarded to the base class.
+    // This emulates behavior for function overloading.
+    this->base::save_override(t, 0);
+}
+void save_override(const some_type & t, int){
+    // any special handling for some type
+    // this will usually entail forwarding some other operation
+    // in the most derived class.
+    this->This()->...
+    // or in one of its parents basic_text_oprimitive
+    this->This()->save(static_cast&lt;int&gt;(t));
+}
+... // other special type handling
+</code></pre>
+
+Note the usage of
+<a target="detail" href="implementation.html#functiontemplateordering">Partial Function Template Ordering</a>
+to permit the correct save implementation to be selected.  
+</dd>
 
 <a name="codemodules">
 <h4>Archive Library Code Modules</h4>
@@ -380,7 +425,7 @@ program which uses xml serialization.
 <h4>Dataflow Iterators</h4>
 In the course of developing this library, it became convenient to make a set
 of composable iterator adaptors for handling archive text.  Applications include
-escaping and unescaping xml text, implementing to/from base64 conversion among
+escaping and unescaping xml text, implementi'g to/from base64 conversion among
 others.
 <p>
 This is a ripe topic in itself. Its touched upon by the 

doc/implementation.html

@@ -207,10 +207,10 @@ the syntax described above.
     is added with STLPort, all tests complete successfully.
     <li>This compiler generates long warning messages related to the usage of
     non virtual destructors in polymorphic classes.  These warnings have been
-    carfully considered and the code that generates these warning has been 
+    carefully considered and the code that generates these warning has been 
     unchanged.  In this case the warning should should be ignored as in certain
     usages of the library, making the destructors virtual could lead to problems.
-    As an alternative, base class destructors have been make "protected" to
+    As an alternative, base class destructors have been made "protected" to
     address the concerns that motivate these warning messages.  When building
     the serialization library and tests with bjam, these warnings are suppressed. 
     When building one's own applications, these warnings can be suppressed by
@@ -223,14 +223,15 @@ the syntax described above.
 <h4><a name="gcc295">GCC 2.95</a></h4>
 All of the above plus:<br>
 <ul>
-    <li>The serialization library depends on the templeted stream implemention
+    <li>The serialization library depends on the templated stream 
+    implementation to function properly.
     to function properly.  So STLPort must be used to build the library.
     <li>Polymorphic archive tests fail.
     <li>XML serialization only works with version 1.6x of spirit. In order to build 
     and use this library with this compiler, one must use version 1.6x rather than the 
     latest version shipped with boost. See <a href="release.html">Release Notes</a>. 
 </ul>
-<h4><a name="Intel80">Intel C++ 8.0</a></h4>
+<h4><a name="intel80">Intel C++ 8.0</a></h4>
 No known issues. All tests compile and run in debug and release modes.
 
 <h4><a name="vc80">Visual C++ 8.0</a></h4>
@@ -245,7 +246,7 @@ line by including the following switch:
 
 <h4><a name="vc71">Visual C++ 7.1</a></h4>
 Derivation from an archive class defined in a DLL as described in ... will not work.
-This is due to the way that VC++ handles templeted code with __decl(dllexport) and
+This is due to the way that VC++ handles templated code with __decl(dllexport) and
 __decl(dllimport) specifications.  Basically, this compiler requires that all the
 instantiations have the same specification - even though they have different
 template arguments. The example <code style="white-space: normal">
@@ -255,15 +256,14 @@ similar to the pre-defined archives in order to function.
 This compiler does not have RTTI or exception handling turned on by default.  Although
 they are not strictly necessary to use the serialization package, the example and test
 program presume that they are enabled.  So be sure your command line or IDE settings 
-enable these features if you want
-these switches are enabled if you want to build and run these programs.
+enable these features if you want to build and run these programs.
 <p>
 This compiler can treat <code style="white-space: normal">wchar_t</code> as either
 a short integer or an intrinsic type.
 If <code style="white-space: normal">/Zc:wchar_t</code> is specified on the
 compile command line, <code style="white-space: normal">wchar_t</code> will be 
 considered an intrinsic type - otherwise
-it will be treated as a synonym for a 16 bit integer.  The libary can be used
+it will be treated as a synonym for a 16 bit integer.  The library can be used
 either way - <strong>BUT</strong> - both the libray <strong>AND</strong> the application 
 must be  compiled with the same switch settings.  Note that <code style="white-space: normal">BJAM</code>
 includes this switch by default.  So if want to use the libraries that
@@ -356,11 +356,11 @@ all the above issues for Visual C++ 7.0 plus:
         without a base class.)
     </ul>
     Working around this in the implementation of the library for this compiler
-    entailed a ridiculous amount of effort.  Even so, the effort wasn't entirely succesful.
+    entailed a ridiculous amount of effort.  Even so, the effort wasn't entirely successful.
     With this compiler, this message will still appear under the following conditions:
     <ul>
         <li>When serializing a class with multiple base classes.  This problem causes two 
-        failure in the test suite.  I have been unable to divise a way to work around this.
+        failure in the test suite.  I have been unable to devise a way to work around this.
         <li>Using more than one kind of archive in the same code module. This should be easy 
         to work around in practice.
     </ul>
@@ -372,11 +372,11 @@ all the above issues for Visual C++ 7.0 plus:
 <ul>
     <li><code style="white-space: normal">enum</code> data members cannot be serialized.
     Conversion to/from integers will work around the problem.
-    <li>If class serialize functions are not accessable either by making them public or by
+    <li>If class serialize functions are not accessible either by making them public or by
     including <code style="white-space: normal">friend</code> declarations as described in 
     <a href="serialization.html#member">Class Serialization - Member Function</a>, the
     will compile but fail at runtime.
-    <li>Tests using custom extended type which doesn't use rtti fails. (5.64 only !).
+    <li>Tests using custom extended type which doesn't use RTTI fails. (5.64 only !).
     <li>Tests built in release mode fail. This seems to be an issue with the boost test system
     with this compiler.
     <li>XML serialization only works with version 1.6x of spirit. In order to build 
@@ -428,7 +428,7 @@ These platforms have several issues:
     <li>when built to use dynamic linking versions of C++ runtime code (<runtime-link>dynamic)
     all tests fail to link.  This is due to a missing symbol in the stlport library related
     to custom codecvt facets.
-    <li>the test_set fails to run correctly. It seems the hashed set interator doesn't
+    <li>the test_set fails to run correctly. It seems the hashed set iterator doesn't
     implement the ++ operator correctly.  This causes the test to fail by consuming all available
     memory.  Given this, this test is commented out.
 </ul>

doc/new_case_studies.html

@@ -0,0 +1,91 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
+<html>
+<!--
+(C) Copyright 2002-4 Robert Ramey - http://www.rrsd.com . 
+Use, modification and distribution is subject to 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)
+-->
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
+<link rel="stylesheet" type="text/css" href="../../../boost.css">
+<link rel="stylesheet" type="text/css" href="style.css">
+<title>Serialization - Proposed Case Studies</title>
+</head>
+<body link="#0000ff" vlink="#800080">
+<table border="0" cellpadding="7" cellspacing="0" width="100%" summary="header">
+  <tr> 
+    <td valign="top" width="300"> 
+      <h3><a href="../../../index.htm"><img height="86" width="277" alt="C++ Boost" src="../../../boost.png" border="0"></a></h3>
+    </td>
+    <td valign="top"> 
+      <h1 align="center">Serialization</h1>
+      <h2 align="center">Proposed Case Studies</h2>
+    </td>
+  </tr>
+</table>
+<hr>
+<dl class="index">
+  <dt><a href="#functionobject">Serializing a Function Object</a></dt>
+  <dt><a href="#archiveadaptor">Archive Adaptors</a></dt>
+  <dt><a href="#archivehelper">Archive Helpers</a></dt>
+</dl>
+
+These are not part of the library itself, but rather
+techiques on how to use the library to address specific situations.
+
+<h2><a name="functionobject"></a>Serializing a Function Object</h2>
+An example on how to serialize a function object.  I believe this
+could be done by serializing pointer to the object in question.  Since
+the Serialization library resurrects pointer of the correct type
+this should be easily implementable.
+<p>
+If a group of function objects were all derived from the
+same polymorphic base class - perhaps via multiple inheritance,
+the the function object effectively becomes a "variable" which
+encapsulates code.
+<p>
+This case study would show how to do this.
+
+<h2><a name="archiveadaptor"></a>Archive Adaptors</h2>
+
+Often users want to add their own special functionality to an
+existing archive.  Examples of this are performance enhancements
+for specific types, Adjustment of output syntax for xml archives,
+and logging/debug output as archives are written and/or read.
+If this functionalty is implemented as an "adaptor" template
+which takes the base class as a template argument, such functionality
+appended to any archive for which that funtionality makes sense.
+For example, an adaptor for generating an xml schema could be
+appended to both wide narrow character versions of xml archives.
+<p>
+This case study would show how to make a useful archive adaptor.
+
+<h2><a name="archivehelper"></a>Archive Helpers</h2>
+Some types are not serializable as they stand.  That is - they
+do not fullfill the requirements of the "Serializable Concept".
+The iconic example of this is boost::shared_ptr.  Sometimes
+these types could be made serializable by adding code inside
+the library.  Of course, doing that would create a lifetime
+of unpaid employment for the library author. Rather than
+adding a bunch of special code to the library itself, this
+code can packaged as a "helper" or "mix-in" class.  Then
+a new archive is derived from both the "base" archive class
+AND the "helper" class.  This is how boost::shared_ptr
+has been implemented.
+<p>
+It would also be possible to make a "generic runtime helper"
+which would effectively extend the API of the library.  Previously
+the library included such a helper class.  It was removed
+in favor of the current implementation.  But this functionality
+should be added back in with another adaptor which would
+become part of the library.
+
+<hr>
+<p>Revised 1 November, 2008 
+<p><i>&copy; Copyright <a href="http://www.rrsd.com">Robert Ramey</a> 2002-2008. 
+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)
+</i></p>
+</body>
+</html>

doc/overview.html

@@ -28,9 +28,6 @@ http://www.boost.org/LICENSE_1_0.txt)
 <dl class="index">
   <dt><a href="#Requirements">Requirements</a></dt>
   <dt><a href="#otherimplementations">Other Implementations</a></dt>
-  <!--
-  <dt><a href="#footnotes">Footnotes</a></dt>
-  -->
 </dl>
 <p>Here, we use the term <strong>"serialization"</strong> to mean
 the reversible deconstruction of an arbitrary set of C++ data structures

doc/performance_status.html

@@ -0,0 +1,30 @@
+<html>
+<head>
+<title>Boost Library Status Automatic Test</title>
+</head>
+<body bgcolor="#ffffff" text="#000000">
+<table border="0">
+<tr>
+<td><img border="0" src="../../../boost.png" width="277" height="86"></td>
+<td>
+<h1>Library Status: serialization</h1>
+<b>Run Date:</b> 02:42:48 UTC, Tuesday 10 June 2008
+</td>
+</table>
+<br>
+<table border="1" cellspacing="0" cellpadding="5">
+<tr>
+<td rowspan="2">Test Name</td>
+<td align="center" >gcc-3.4.4</td>
+</tr><tr>
+<td align="center" >profile</td>
+</tr><tr><td>peformance_array_binary_archive</a></td><td align="right">Pass <a href="profile1.txt"><i>Profile</i></a></td></tr>
+<tr><td>peformance_array_text_archive</a></td><td align="right">Pass <a href="profile1.txt"><i>Profile</i></a></td></tr>
+<tr><td>peformance_array_text_warchive</a></td><td align="right"><i>Missing</i></td></tr>
+<tr><td>peformance_array_xml_archive</a></td><td align="right">Pass <a href="profile1.txt"><i>Profile</i></a></td></tr>
+<tr><td>peformance_array_xml_warchive</a></td><td align="right"><i>Missing</i></td></tr>
+<tr><td>performance_iterators</a></td><td align="right">Pass <a href="profile2.txt"><i>Profile</i></a></td></tr>
+<tr><td>performance_iterators_base64</a></td><td align="right">Pass <a href="profile3.txt"><i>Profile</i></a></td></tr>
+</table>
+</body>
+</html>

doc/profile1.txt

@@ -0,0 +1,149 @@
+Flat profile:
+
+Each sample counts as 0.01 seconds.
+ no time accumulated
+
+  %   cumulative   self              self     total           
+ time   seconds   seconds    calls  Ts/call  Ts/call  name    
+  0.00      0.00     0.00      200     0.00     0.00  void accumulate<unsigned long>(unsigned int&, unsigned long const&)
+  0.00      0.00     0.00      150     0.00     0.00  _pei386_runtime_relocator
+  0.00      0.00     0.00        1     0.00     0.00  std::ostream::operator<<(void const*)
+  0.00      0.00     0.00        1     0.00     0.00  __divdi3
+
+ %         the percentage of the total running time of the
+time       program used by this function.
+
+cumulative a running sum of the number of seconds accounted
+ seconds   for by this function and those listed above it.
+
+ self      the number of seconds accounted for by this
+seconds    function alone.  This is the major sort for this
+           listing.
+
+calls      the number of times this function was invoked, if
+           this function is profiled, else blank.
+ 
+ self      the average number of milliseconds spent in this
+ms/call    function per call, if this function is profiled,
+	   else blank.
+
+ total     the average number of milliseconds spent in this
+ms/call    function and its descendents per call, if this 
+	   function is profiled, else blank.
+
+name       the name of the function.  This is the minor sort
+           for this listing. The index shows the location of
+	   the function in the gprof listing. If the index is
+	   in parenthesis it shows where it would appear in
+	   the gprof listing if it were to be printed.
+
+		     Call graph (explanation follows)
+
+
+granularity: each sample hit covers 4 byte(s) no time propagated
+
+index % time    self  children    called     name
+                0.00    0.00     200/200         setvbuf [1286]
+[4]      0.0    0.00    0.00     200         void accumulate<unsigned long>(unsigned int&, unsigned long const&) [4]
+-----------------------------------------------
+                0.00    0.00     150/150         _cygwin_crt0_common@8 [1230]
+[5]      0.0    0.00    0.00     150         _pei386_runtime_relocator [5]
+-----------------------------------------------
+                0.00    0.00       1/1           _lseek64 [1234]
+[6]      0.0    0.00    0.00       1         std::ostream::operator<<(void const*) [6]
+-----------------------------------------------
+                0.00    0.00       1/1           __tcf_1 [1221]
+[7]      0.0    0.00    0.00       1         __divdi3 [7]
+-----------------------------------------------
+                                   2             main [1263]
+[1263]   0.0    0.00    0.00       0+2       main [1263]
+                                   2             main [1263]
+-----------------------------------------------
+
+ This table describes the call tree of the program, and was sorted by
+ the total amount of time spent in each function and its children.
+
+ Each entry in this table consists of several lines.  The line with the
+ index number at the left hand margin lists the current function.
+ The lines above it list the functions that called this function,
+ and the lines below it list the functions this one called.
+ This line lists:
+     index	A unique number given to each element of the table.
+		Index numbers are sorted numerically.
+		The index number is printed next to every function name so
+		it is easier to look up where the function in the table.
+
+     % time	This is the percentage of the `total' time that was spent
+		in this function and its children.  Note that due to
+		different viewpoints, functions excluded by options, etc,
+		these numbers will NOT add up to 100%.
+
+     self	This is the total amount of time spent in this function.
+
+     children	This is the total amount of time propagated into this
+		function by its children.
+
+     called	This is the number of times the function was called.
+		If the function called itself recursively, the number
+		only includes non-recursive calls, and is followed by
+		a `+' and the number of recursive calls.
+
+     name	The name of the current function.  The index number is
+		printed after it.  If the function is a member of a
+		cycle, the cycle number is printed between the
+		function's name and the index number.
+
+
+ For the function's parents, the fields have the following meanings:
+
+     self	This is the amount of time that was propagated directly
+		from the function into this parent.
+
+     children	This is the amount of time that was propagated from
+		the function's children into this parent.
+
+     called	This is the number of times this parent called the
+		function `/' the total number of times the function
+		was called.  Recursive calls to the function are not
+		included in the number after the `/'.
+
+     name	This is the name of the parent.  The parent's index
+		number is printed after it.  If the parent is a
+		member of a cycle, the cycle number is printed between
+		the name and the index number.
+
+ If the parents of the function cannot be determined, the word
+ `<spontaneous>' is printed in the `name' field, and all the other
+ fields are blank.
+
+ For the function's children, the fields have the following meanings:
+
+     self	This is the amount of time that was propagated directly
+		from the child into the function.
+
+     children	This is the amount of time that was propagated from the
+		child's children to the function.
+
+     called	This is the number of times the function called
+		this child `/' the total number of times the child
+		was called.  Recursive calls by the child are not
+		listed in the number after the `/'.
+
+     name	This is the name of the child.  The child's index
+		number is printed after it.  If the child is a
+		member of a cycle, the cycle number is printed
+		between the name and the index number.
+
+ If there are any cycles (circles) in the call graph, there is an
+ entry for the cycle-as-a-whole.  This entry shows who called the
+ cycle (as parents) and the members of the cycle (as children.)
+ The `+' recursive calls entry shows the number of function calls that
+ were internal to the cycle, and the calls entry for each member shows,
+ for that member, how many times it was called from other members of
+ the cycle.
+
+
+Index by function name
+
+   [4] void accumulate<unsigned long>(unsigned int&, unsigned long const&) [7] __divdi3
+   [6] std::ostream::operator<<(void const*) [5] _pei386_runtime_relocator

doc/profile2.txt

@@ -0,0 +1,203 @@
+Flat profile:
+
+Each sample counts as 0.01 seconds.
+  %   cumulative   self              self     total           
+ time   seconds   seconds    calls  Ts/call  Ts/call  name    
+100.00      0.01     0.01                             __gnu_cxx::__atomic_add(int volatile*, int)
+  0.00      0.01     0.00       51     0.00     0.00  boost::archive::iterators::transform_width<char*, 6, 8, char>::fill()
+  0.00      0.01     0.00       36     0.00     0.00  boost::archive::iterators::transform_width<__gnu_cxx::__normal_iterator<char*, std::vector<char, std::allocator<char> > >, 8, 6, char>::fill()
+  0.00      0.01     0.00       30     0.00     0.00  std::vector<char, std::allocator<char> >::_M_insert_aux(__gnu_cxx::__normal_iterator<char*, std::vector<char, std::allocator<char> > >, char const&)
+  0.00      0.01     0.00       11     0.00     0.00  boost::archive::iterators::xml_escape<char const*>::fill(char const*&, char const*&)
+  0.00      0.01     0.00        9     0.00     0.00  void test_transform_width<6, 8>(unsigned int)
+  0.00      0.01     0.00        9     0.00     0.00  boost::archive::iterators::xml_unescape<char const*>::drain()
+  0.00      0.01     0.00        5     0.00     0.00  boost::archive::iterators::xml_unescape<char const*>::drain_residue(char const*)
+  0.00      0.01     0.00        2     0.00     0.00  __static_initialization_and_destruction_0(int, int)
+  0.00      0.01     0.00        1     0.00     0.00  void test_xml_escape<char const>(char const*, char const*, unsigned int)
+  0.00      0.01     0.00        1     0.00     0.00  void test_xml_unescape<char const>(char const*, char const*, unsigned int)
+  0.00      0.01     0.00        1     0.00     0.00  void test_stream_iterators<char>(char const*, unsigned int)
+  0.00      0.01     0.00        1     0.00     0.00  test_main(int, char**)
+  0.00      0.01     0.00        1     0.00     0.00  char* std::string::_S_construct<char*>(char*, char*, std::allocator<char> const&, std::forward_iterator_tag)
+  0.00      0.01     0.00        1     0.00     0.00  std::basic_string<char, std::char_traits<char>, std::allocator<char> >::basic_string<char*>(char*, char*, std::allocator<char> const&)
+
+ %         the percentage of the total running time of the
+time       program used by this function.
+
+cumulative a running sum of the number of seconds accounted
+ seconds   for by this function and those listed above it.
+
+ self      the number of seconds accounted for by this
+seconds    function alone.  This is the major sort for this
+           listing.
+
+calls      the number of times this function was invoked, if
+           this function is profiled, else blank.
+ 
+ self      the average number of milliseconds spent in this
+ms/call    function per call, if this function is profiled,
+	   else blank.
+
+ total     the average number of milliseconds spent in this
+ms/call    function and its descendents per call, if this 
+	   function is profiled, else blank.
+
+name       the name of the function.  This is the minor sort
+           for this listing. The index shows the location of
+	   the function in the gprof listing. If the index is
+	   in parenthesis it shows where it would appear in
+	   the gprof listing if it were to be printed.
+
+		     Call graph (explanation follows)
+
+
+granularity: each sample hit covers 4 byte(s) for 100.00% of 0.01 seconds
+
+index % time    self  children    called     name
+                                                 <spontaneous>
+[1]    100.0    0.01    0.00                 __gnu_cxx::__atomic_add(int volatile*, int) [1]
+-----------------------------------------------
+                0.00    0.00      51/51          void test_transform_width<6, 8>(unsigned int) [9]
+[5]      0.0    0.00    0.00      51         boost::archive::iterators::transform_width<char*, 6, 8, char>::fill() [5]
+-----------------------------------------------
+                0.00    0.00      36/36          void test_transform_width<6, 8>(unsigned int) [9]
+[6]      0.0    0.00    0.00      36         boost::archive::iterators::transform_width<__gnu_cxx::__normal_iterator<char*, std::vector<char, std::allocator<char> > >, 8, 6, char>::fill() [6]
+-----------------------------------------------
+                0.00    0.00      30/30          void test_transform_width<6, 8>(unsigned int) [9]
+[7]      0.0    0.00    0.00      30         std::vector<char, std::allocator<char> >::_M_insert_aux(__gnu_cxx::__normal_iterator<char*, std::vector<char, std::allocator<char> > >, char const&) [7]
+-----------------------------------------------
+                0.00    0.00      11/11          void test_xml_escape<char const>(char const*, char const*, unsigned int) [13]
+[8]      0.0    0.00    0.00      11         boost::archive::iterators::xml_escape<char const*>::fill(char const*&, char const*&) [8]
+-----------------------------------------------
+                0.00    0.00       9/9           test_main(int, char**) [16]
+[9]      0.0    0.00    0.00       9         void test_transform_width<6, 8>(unsigned int) [9]
+                0.00    0.00      51/51          boost::archive::iterators::transform_width<char*, 6, 8, char>::fill() [5]
+                0.00    0.00      36/36          boost::archive::iterators::transform_width<__gnu_cxx::__normal_iterator<char*, std::vector<char, std::allocator<char> > >, 8, 6, char>::fill() [6]
+                0.00    0.00      30/30          std::vector<char, std::allocator<char> >::_M_insert_aux(__gnu_cxx::__normal_iterator<char*, std::vector<char, std::allocator<char> > >, char const&) [7]
+-----------------------------------------------
+                0.00    0.00       9/9           void test_xml_unescape<char const>(char const*, char const*, unsigned int) [14]
+[10]     0.0    0.00    0.00       9         boost::archive::iterators::xml_unescape<char const*>::drain() [10]
+                0.00    0.00       5/5           boost::archive::iterators::xml_unescape<char const*>::drain_residue(char const*) [11]
+-----------------------------------------------
+                0.00    0.00       5/5           boost::archive::iterators::xml_unescape<char const*>::drain() [10]
+[11]     0.0    0.00    0.00       5         boost::archive::iterators::xml_unescape<char const*>::drain_residue(char const*) [11]
+-----------------------------------------------
+                0.00    0.00       1/2           global constructors keyed to main [38]
+                0.00    0.00       1/2           global destructors keyed to main [35]
+[12]     0.0    0.00    0.00       2         __static_initialization_and_destruction_0(int, int) [12]
+-----------------------------------------------
+                0.00    0.00       1/1           test_main(int, char**) [16]
+[13]     0.0    0.00    0.00       1         void test_xml_escape<char const>(char const*, char const*, unsigned int) [13]
+                0.00    0.00      11/11          boost::archive::iterators::xml_escape<char const*>::fill(char const*&, char const*&) [8]
+-----------------------------------------------
+                0.00    0.00       1/1           test_main(int, char**) [16]
+[14]     0.0    0.00    0.00       1         void test_xml_unescape<char const>(char const*, char const*, unsigned int) [14]
+                0.00    0.00       9/9           boost::archive::iterators::xml_unescape<char const*>::drain() [10]
+-----------------------------------------------
+                0.00    0.00       1/1           test_main(int, char**) [16]
+[15]     0.0    0.00    0.00       1         void test_stream_iterators<char>(char const*, unsigned int) [15]
+                0.00    0.00       1/1           std::basic_string<char, std::char_traits<char>, std::allocator<char> >::basic_string<char*>(char*, char*, std::allocator<char> const&) [18]
+-----------------------------------------------
+                0.00    0.00       1/1           main [1211]
+[16]     0.0    0.00    0.00       1         test_main(int, char**) [16]
+                0.00    0.00       9/9           void test_transform_width<6, 8>(unsigned int) [9]
+                0.00    0.00       1/1           void test_xml_escape<char const>(char const*, char const*, unsigned int) [13]
+                0.00    0.00       1/1           void test_xml_unescape<char const>(char const*, char const*, unsigned int) [14]
+                0.00    0.00       1/1           void test_stream_iterators<char>(char const*, unsigned int) [15]
+-----------------------------------------------
+                0.00    0.00       1/1           std::basic_string<char, std::char_traits<char>, std::allocator<char> >::basic_string<char*>(char*, char*, std::allocator<char> const&) [18]
+[17]     0.0    0.00    0.00       1         char* std::string::_S_construct<char*>(char*, char*, std::allocator<char> const&, std::forward_iterator_tag) [17]
+-----------------------------------------------
+                0.00    0.00       1/1           void test_stream_iterators<char>(char const*, unsigned int) [15]
+[18]     0.0    0.00    0.00       1         std::basic_string<char, std::char_traits<char>, std::allocator<char> >::basic_string<char*>(char*, char*, std::allocator<char> const&) [18]
+                0.00    0.00       1/1           char* std::string::_S_construct<char*>(char*, char*, std::allocator<char> const&, std::forward_iterator_tag) [17]
+-----------------------------------------------
+
+ This table describes the call tree of the program, and was sorted by
+ the total amount of time spent in each function and its children.
+
+ Each entry in this table consists of several lines.  The line with the
+ index number at the left hand margin lists the current function.
+ The lines above it list the functions that called this function,
+ and the lines below it list the functions this one called.
+ This line lists:
+     index	A unique number given to each element of the table.
+		Index numbers are sorted numerically.
+		The index number is printed next to every function name so
+		it is easier to look up where the function in the table.
+
+     % time	This is the percentage of the `total' time that was spent
+		in this function and its children.  Note that due to
+		different viewpoints, functions excluded by options, etc,
+		these numbers will NOT add up to 100%.
+
+     self	This is the total amount of time spent in this function.
+
+     children	This is the total amount of time propagated into this
+		function by its children.
+
+     called	This is the number of times the function was called.
+		If the function called itself recursively, the number
+		only includes non-recursive calls, and is followed by
+		a `+' and the number of recursive calls.
+
+     name	The name of the current function.  The index number is
+		printed after it.  If the function is a member of a
+		cycle, the cycle number is printed between the
+		function's name and the index number.
+
+
+ For the function's parents, the fields have the following meanings:
+
+     self	This is the amount of time that was propagated directly
+		from the function into this parent.
+
+     children	This is the amount of time that was propagated from
+		the function's children into this parent.
+
+     called	This is the number of times this parent called the
+		function `/' the total number of times the function
+		was called.  Recursive calls to the function are not
+		included in the number after the `/'.
+
+     name	This is the name of the parent.  The parent's index
+		number is printed after it.  If the parent is a
+		member of a cycle, the cycle number is printed between
+		the name and the index number.
+
+ If the parents of the function cannot be determined, the word
+ `<spontaneous>' is printed in the `name' field, and all the other
+ fields are blank.
+
+ For the function's children, the fields have the following meanings:
+
+     self	This is the amount of time that was propagated directly
+		from the child into the function.
+
+     children	This is the amount of time that was propagated from the
+		child's children to the function.
+
+     called	This is the number of times the function called
+		this child `/' the total number of times the child
+		was called.  Recursive calls by the child are not
+		listed in the number after the `/'.
+
+     name	This is the name of the child.  The child's index
+		number is printed after it.  If the child is a
+		member of a cycle, the cycle number is printed
+		between the name and the index number.
+
+ If there are any cycles (circles) in the call graph, there is an
+ entry for the cycle-as-a-whole.  This entry shows who called the
+ cycle (as parents) and the members of the cycle (as children.)
+ The `+' recursive calls entry shows the number of function calls that
+ were internal to the cycle, and the calls entry for each member shows,
+ for that member, how many times it was called from other members of
+ the cycle.
+
+
+Index by function name
+
+  [13] void test_xml_escape<char const>(char const*, char const*, unsigned int) [16] test_main(int, char**) [5] boost::archive::iterators::transform_width<char*, 6, 8, char>::fill()
+  [14] void test_xml_unescape<char const>(char const*, char const*, unsigned int) [8] boost::archive::iterators::xml_escape<char const*>::fill(char const*&, char const*&) [1] __gnu_cxx::__atomic_add(int volatile*, int)
+   [9] void test_transform_width<6, 8>(unsigned int) [11] boost::archive::iterators::xml_unescape<char const*>::drain_residue(char const*) [17] char* std::string::_S_construct<char*>(char*, char*, std::allocator<char> const&, std::forward_iterator_tag)
+  [15] void test_stream_iterators<char>(char const*, unsigned int) [10] boost::archive::iterators::xml_unescape<char const*>::drain() [18] std::basic_string<char, std::char_traits<char>, std::allocator<char> >::basic_string<char*>(char*, char*, std::allocator<char> const&)
+  [12] __static_initialization_and_destruction_0(int, int) (performance_iterators.cpp) [6] boost::archive::iterators::transform_width<__gnu_cxx::__normal_iterator<char*, std::vector<char, std::allocator<char> > >, 8, 6, char>::fill() [7] std::vector<char, std::allocator<char> >::_M_insert_aux(__gnu_cxx::__normal_iterator<char*, std::vector<char, std::allocator<char> > >, char const&)

doc/profile3.txt

@@ -0,0 +1,153 @@
+Flat profile:
+
+Each sample counts as 0.01 seconds.
+ no time accumulated
+
+  %   cumulative   self              self     total           
+ time   seconds   seconds    calls  Ts/call  Ts/call  name    
+  0.00      0.00     0.00      200     0.00     0.00  boost::archive::iterators::transform_width<char*, 6, 8, char>::fill()
+  0.00      0.00     0.00      150     0.00     0.00  boost::archive::iterators::transform_width<boost::archive::iterators::binary_from_base64<boost::archive::iterators::remove_whitespace<std::_List_iterator<char> >, char>, 8, 6, char>::fill()
+  0.00      0.00     0.00        2     0.00     0.00  __static_initialization_and_destruction_0(int, int)
+  0.00      0.00     0.00        1     0.00     0.00  void test_base64<char>()
+  0.00      0.00     0.00        1     0.00     0.00  std::_List_base<char, std::allocator<char> >::_M_clear()
+
+ %         the percentage of the total running time of the
+time       program used by this function.
+
+cumulative a running sum of the number of seconds accounted
+ seconds   for by this function and those listed above it.
+
+ self      the number of seconds accounted for by this
+seconds    function alone.  This is the major sort for this
+           listing.
+
+calls      the number of times this function was invoked, if
+           this function is profiled, else blank.
+ 
+ self      the average number of milliseconds spent in this
+ms/call    function per call, if this function is profiled,
+	   else blank.
+
+ total     the average number of milliseconds spent in this
+ms/call    function and its descendents per call, if this 
+	   function is profiled, else blank.
+
+name       the name of the function.  This is the minor sort
+           for this listing. The index shows the location of
+	   the function in the gprof listing. If the index is
+	   in parenthesis it shows where it would appear in
+	   the gprof listing if it were to be printed.
+
+		     Call graph (explanation follows)
+
+
+granularity: each sample hit covers 4 byte(s) no time propagated
+
+index % time    self  children    called     name
+                0.00    0.00     200/200         void test_base64<char>() [7]
+[4]      0.0    0.00    0.00     200         boost::archive::iterators::transform_width<char*, 6, 8, char>::fill() [4]
+-----------------------------------------------
+                0.00    0.00     150/150         void test_base64<char>() [7]
+[5]      0.0    0.00    0.00     150         boost::archive::iterators::transform_width<boost::archive::iterators::binary_from_base64<boost::archive::iterators::remove_whitespace<std::_List_iterator<char> >, char>, 8, 6, char>::fill() [5]
+-----------------------------------------------
+                0.00    0.00       1/2           global constructors keyed to main [27]
+                0.00    0.00       1/2           global destructors keyed to main [24]
+[6]      0.0    0.00    0.00       2         __static_initialization_and_destruction_0(int, int) [6]
+-----------------------------------------------
+                0.00    0.00       1/1           main [1156]
+[7]      0.0    0.00    0.00       1         void test_base64<char>() [7]
+                0.00    0.00     200/200         boost::archive::iterators::transform_width<char*, 6, 8, char>::fill() [4]
+                0.00    0.00     150/150         boost::archive::iterators::transform_width<boost::archive::iterators::binary_from_base64<boost::archive::iterators::remove_whitespace<std::_List_iterator<char> >, char>, 8, 6, char>::fill() [5]
+                0.00    0.00       1/1           std::_List_base<char, std::allocator<char> >::_M_clear() [8]
+-----------------------------------------------
+                0.00    0.00       1/1           void test_base64<char>() [7]
+[8]      0.0    0.00    0.00       1         std::_List_base<char, std::allocator<char> >::_M_clear() [8]
+-----------------------------------------------
+
+ This table describes the call tree of the program, and was sorted by
+ the total amount of time spent in each function and its children.
+
+ Each entry in this table consists of several lines.  The line with the
+ index number at the left hand margin lists the current function.
+ The lines above it list the functions that called this function,
+ and the lines below it list the functions this one called.
+ This line lists:
+     index	A unique number given to each element of the table.
+		Index numbers are sorted numerically.
+		The index number is printed next to every function name so
+		it is easier to look up where the function in the table.
+
+     % time	This is the percentage of the `total' time that was spent
+		in this function and its children.  Note that due to
+		different viewpoints, functions excluded by options, etc,
+		these numbers will NOT add up to 100%.
+
+     self	This is the total amount of time spent in this function.
+
+     children	This is the total amount of time propagated into this
+		function by its children.
+
+     called	This is the number of times the function was called.
+		If the function called itself recursively, the number
+		only includes non-recursive calls, and is followed by
+		a `+' and the number of recursive calls.
+
+     name	The name of the current function.  The index number is
+		printed after it.  If the function is a member of a
+		cycle, the cycle number is printed between the
+		function's name and the index number.
+
+
+ For the function's parents, the fields have the following meanings:
+
+     self	This is the amount of time that was propagated directly
+		from the function into this parent.
+
+     children	This is the amount of time that was propagated from
+		the function's children into this parent.
+
+     called	This is the number of times this parent called the
+		function `/' the total number of times the function
+		was called.  Recursive calls to the function are not
+		included in the number after the `/'.
+
+     name	This is the name of the parent.  The parent's index
+		number is printed after it.  If the parent is a
+		member of a cycle, the cycle number is printed between
+		the name and the index number.
+
+ If the parents of the function cannot be determined, the word
+ `<spontaneous>' is printed in the `name' field, and all the other
+ fields are blank.
+
+ For the function's children, the fields have the following meanings:
+
+     self	This is the amount of time that was propagated directly
+		from the child into the function.
+
+     children	This is the amount of time that was propagated from the
+		child's children to the function.
+
+     called	This is the number of times the function called
+		this child `/' the total number of times the child
+		was called.  Recursive calls by the child are not
+		listed in the number after the `/'.
+
+     name	This is the name of the child.  The child's index
+		number is printed after it.  If the child is a
+		member of a cycle, the cycle number is printed
+		between the name and the index number.
+
+ If there are any cycles (circles) in the call graph, there is an
+ entry for the cycle-as-a-whole.  This entry shows who called the
+ cycle (as parents) and the members of the cycle (as children.)
+ The `+' recursive calls entry shows the number of function calls that
+ were internal to the cycle, and the calls entry for each member shows,
+ for that member, how many times it was called from other members of
+ the cycle.
+
+
+Index by function name
+
+   [7] void test_base64<char>() [5] boost::archive::iterators::transform_width<boost::archive::iterators::binary_from_base64<boost::archive::iterators::remove_whitespace<std::_List_iterator<char> >, char>, 8, 6, char>::fill() [8] std::_List_base<char, std::allocator<char> >::_M_clear()
+   [6] __static_initialization_and_destruction_0(int, int) (performance_iterators_base64.cpp) [4] boost::archive::iterators::transform_width<char*, 6, 8, char>::fill()

doc/rationale.html

@@ -31,7 +31,6 @@ http://www.boost.org/LICENSE_1_0.txt)
   <dt><a href="#archives">Archives are not streams</a></dt>
   <dt><a href="#strings">Strings are treated specially in text archives</a></dt>
   <dt><a href="#typeid"><code style="white-space: normal">typeid</code> information is not included in archives</a></dt>
-  <dt><a href="#trap">Compile time trap when saving a non-const value</a></dt>
   <!--
   <dt><a href="#footnotes">Footnotes</a></dt>
   -->
@@ -110,226 +109,6 @@ and/or <code style="white-space: normal">export</code> facilities described in t
 In effect, <code style="white-space: normal">export</code> generates a portable equivalent to
 <code style="white-space: normal">typeid</code> information.
 
-<h2><a name="trap"></a>Compile time trap when saving a non-const value</h2>
-</p>
-The following code will fail to compile.  The failure will occur on a line with a
-<code style="white-space: normal">BOOST_STATIC_ASSERT</code>.  
-Here, we refer to this as a compile time trap.
-<code style="white-space: normal"><pre>
-T t;
-ar &lt;&lt; t;
-</pre></code>
-
-unless the tracking_level serialization trait is set to "track_never". The following
-will compile without problem:
-
-<code style="white-space: normal"><pre>
-const T t
-ar &lt;&lt; t;
-</pre></code>
-
-Likewise, the following code will trap at compile time:
-
-<code style="white-space: normal"><pre>
-T * t;
-ar >> t;
-</pre></code>
-
-if the tracking_level serialization trait is set to "track_never".
-<p>
-
-This behavior has been contraversial and may be revised in the future. The criticism 
-is that it will flag code that is in fact correct and force users to insert
-<code style="white-space: normal">const_cast</code>. My view is that:
-<ul>
-  <li>The trap is useful in detecting a certain class of programming errors.
-  <li>Such errors would otherwise be difficult to detect.
-  <li>The incovenience caused by including this trap is very small in relation
-  to its benefits.
-</ul>
-
-The following case illustrates my position.  It was originally used as an example in the
-mailing list by Peter Dimov.
-
-<code style="white-space: normal"><pre>
-class construct_from 
-{ 
-    ... 
-}; 
-
-void main(){ 
-    ... 
-    Y y; 
-    construct_from x(y); 
-    ar &lt;&lt; x; 
-} 
-</pre></code>
-
-Suppose that there is no trap as described above.
-<ol>
-  <li>this example compiles and executes fine. No tracking is done because 
-  construct_from has never been serialized through a pointer. Now some time 
-  later, the next programmer(2) comes along and makes an enhancement. He 
-  wants the archive to be sort of a log. 
-
-<code style="white-space: normal"><pre>
-void main(){ 
-    ... 
-    Y y; 
-    construct_from x(y); 
-    ar &lt;&lt; x; 
-    ... 
-    x.f(); // change x in some way 
-   ... 
-    ar &lt;&lt; x 
-} 
-</pre></code>
-  <p>
-  Again no problem. He gets two different of copies in the archive, each one is different. 
-  That is he gets exactly what he expects and is naturally delighted. 
-  <p>
-  <li>Now sometime later, a third programmer(3) sees construct_from and says - 
-  oh cool, just what I need. He writes a function in a totally disjoint 
-  module. (The project is so big, he doesn't even realize the existence of 
-  the original usage) and writes something like: 
-
-<code style="white-space: normal"><pre>
-class K { 
-    shared_ptr &lt;construct_from&gt; z; 
-    template &lt;class Archive&gt; 
-    void serialize(Archive & ar, const unsigned version){ 
-        ar &lt;&lt; z; 
-    } 
-}; 
-</pre></code>
-
-  <p>
-  He builds and runs the program and tests his new functionality. It works 
-  great and he's delighted. 
-  <p>
-  <li>Things continue smoothly as before.  A month goes by and it's 
-  discovered that when loading the archives made in the last month (reading the 
-  log). Things don't work. The second log entry is always the same as the 
-  first. After a series of very long and increasingly acrimonius email exchanges, 
-its discovered 
-  that programmer (3) accidently broke programmer(2)'s code .This is because by 
-  serializing via a pointer, the "log" object now being tracked.  This is because
-  the default tracking behavior is "track_selectively".  This means that class
-  instances are tracked only if they are serialized through pointers anywhere in
-  the program. Now multiple saves from the same address result in only the first one 
-  being written to the archive. Subsequent saves only add the address - even though the 
-  data might have been changed.  When it comes time to load the data, all instances of the log record show the same data.
-  In this way, the behavior of a functioning piece of code is changed due the side
-  effect of a change in an otherwise disjoint module.
-  Worse yet, the data has been lost and cannot not be now recovered from the archives.
-  People are really upset and disappointed with boost (at least the serialization system).
-  <p>
-  <li>
-  After a lot of investigation, it's discovered what the source of the problem
-  and class construct_from is marked "track_never" by including:
-<code style="white-space: normal"><pre>
-BOOST_SERIALIZATION_TRACKING(construct_from, track_never) 
-</pre></code>
-  <li>Now everything works again. Or - so it seems.
-  <p>
-  <li><code style="white-space: normal">shared_ptr&lt;construct_from&gt;</code>
-is not going to have a single raw pointer shared amongst the instances. Each loaded 
-<code style="white-space: normal">shared_ptr&lt;construct_from&gt;</code> is going to 
-have its own distinct raw pointer. This will break 
-<code style="white-space: normal">shared_ptr</code> and cause a memory leak.  Again,
-The cause of this problem is very far removed from the point of discovery.  It could 
-well be that the problem is not even discovered until after the archives are loaded.
-Now we not only have difficult to find and fix program bug, but we have a bunch of
-invalid archives and lost data.
-</ol>
-
-Now consider what happens when the trap is enabled:. 
-
-<ol>
-  <p>
-  <li>Right away, the program traps at 
-<code style="white-space: normal"><pre>
-ar &lt;&lt; x; 
-</pre></code>
-  <p>
-  <li>The programmer curses (another %^&*&* hoop to jump through). If he's in a 
-  hurry (and who isn't) and would prefer not to <code style="white-space: normal">const_cast</code>
-  - because it looks bad.  So he'll just make the following change an move on. 
-<code style="white-space: normal"><pre>
-Y y; 
-const construct_from x(y); 
-ar &lt;&lt; x; 
-</pre></code>
-  <p>
-  Things work fine and he moves on. 
-  <p>
-  <li>Now programer (2) wants to make his change - and again another 
-  annoying const issue; 
-<code style="white-space: normal"><pre>
-Y y; 
-const construct_from x(y); 
-... 
-x.f(); // change x in some way ; compile error f() is not const 
-... 
-ar &lt;&lt; x 
-</pre></code>
-  <p>
-  He's mildly annoyed now he tries the following: 
-  <ul>
-    <li>He considers making f() a const - but presumable that shifts the const 
-    error to somewhere else. And his doesn't want to fiddle with "his" code to 
-    work around a quirk in the serializaition system 
-    <p>
-    <li>He removes the <code style="white-space: normal">const</code>
-    from <code style="white-space: normal">const construct_from</code> above - damn now he 
-    gets the trap. If he looks at the comment code where the 
-    <code style="white-space: normal">BOOST_STATIC_ASSERT</code>
-    occurs, he'll do one of two things 
-    <ol>
-      <p>
-      <li>This is just crazy. Its making my life needlessly difficult and flagging 
-      code that is just fine. So I'll fix this with a <code style="white-space: normal">const_cast</code>
-      and fire off a complaint to the list and mabe they will fix it. 
-      In this case, the story branches off to the previous scenario.
-      <p>
-      <li>Oh, this trap is suggesting that the default serialization isn't really 
-      what I want. Of course in this particular program it doesn't matter. But 
-      then the code in the trap can't really evaluate code in other modules (which 
-      might not even be written yet). OK, I'll add the following to my 
-      construct_from.hpp to solve the problem. 
-<code style="white-space: normal"><pre>
-BOOST_SERIALIZATION_TRACKING(construct_from, track_never) 
-</pre></code>
-    </ol>
-  </ul>
-  <p>
-  <li>Now programmer (3) comes along and make his change. The behavior of the 
-  original (and distant module) remains unchanged because the 
-  <code style="white-space: normal">construct_from</code> trait has been set to 
-  "track_never" so he should always get copies and the log should be what we expect.
-  <p>
-  <li>But now he gets another trap - trying to save an object of a 
-  class marked "track_never" through a pointer. So he goes back to 
-  construct_from.hpp and comments out the 
-  <code style="white-space: normal">BOOST_SERIALIZATION_TRACKING</code> that 
-  was inserted. Now the second trap is avoided, But damn - the first trap is 
-  popping up again. Eventually, after some code restructuring, the differing
-  requirements of serializating <code style="white-space: normal">construct_from</code>
-  are reconciled.
-</ol>
-Note that in this second scenario
-<ul>
-  <li>all errors are trapped at compile time.
-  <li>no invalid archives are created.
-  <li>no data is lost.
-  <li>no runtime errors occur.
-</ul>
-
-It's true that these traps may sometimes flag code that is currently correct and
-that this may be annoying to some programmers.  However, this example illustrates
-my view that these traps are useful and that any such annoyance is small price to
-pay to avoid particularly vexing programming errors.
-
 <!--
 <h2><a name="footnotes"></a>Footnotes</h2>
 <dl>

doc/release.html

@@ -1,6 +1,6 @@
 <!doctype HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
 <html>
-<!--
+    <!--
 (C) Copyright 2002-4 Robert Ramey - http://www.rrsd.com . 
 Use, modification and distribution is subject to the Boost Software
 License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
@@ -9,38 +9,94 @@ http://www.boost.org/LICENSE_1_0.txt)
 <head>
 <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
 <link rel="stylesheet" type="text/css" href="../../../boost.css">
-<link rel="stylesheet" type="text/css" href="style.css">
-<title>Serialization - Release Notes</title>
+    <link rel="stylesheet" type="text/css" href="style.css">
+        <title>Serialization - Release Notes</title>
 </head>
 <body link="#0000ff" vlink="#800080">
 <table border="0" cellpadding="7" cellspacing="0" width="100%" summary="header">
-  <tr> 
-    <td valign="top" width="300"> 
-      <h3><a href="../../../index.htm"><img height="86" width="277" alt="C++ Boost" src="../../../boost.png" border="0"></a></h3>
-    </td>
-    <td valign="top"> 
-      <h1 align="center">Serialization</h1>
-      <h2 align="center">Release Notes</h2>
-    </td>
-  </tr>
+    <tr>
+        <td valign="top" width="300">
+            <h3>
+                <a href="../../../index.htm"><img height="86" width="277" alt="C++ Boost" src="../../../boost.png" border="0"></a></h3>
+        </td>
+        <td valign="top">
+            <h1 align="center">
+                Serialization</h1>
+            <h2 align="center">
+                Release Notes</h2>
+        </td>
+    </tr>
 </table>
 <hr>
 <dl class="index">
-  <dt><a href="#requirements">Requirements</a></dt>
-  <dt><a href="#differences_1_32">Differences from version 1.32</a></dt>
-  <dt><a href="#differences_1_33">Differences from version 1.33</a></dt>
-  <dt><a href="#differences_1_34">Differences from version 1.34</a></dt>
-  <dt><a href="#todo">Pending Issues</a></dt>
+    <dt><a href="#differences_1_42">Differences from version 1.42</a></dt> 
+    <dt><a href="#differences_1_41">Differences from version 1.41</a></dt> 
+    <dt><a href="#differences_1_40">Differences from version 1.40</a></dt> 
+    <dt><a href="#differences_1_39">Differences from version 1.39</a></dt> 
+    <dt><a href="#differences_1_37">Differences from version 1.37</a></dt> 
+    <dt><a href="#differences_1_35">Differences from version 1.35</a></dt>
+    <dt><a href="#differences_1_34">Differences from version 1.34</a></dt> 
+    <dt><a href="#differences_1_33">Differences from version 1.33</a></dt> 
+    <dt><a href="#differences_1_32">Differences from version 1.32</a></dt> 
+    <dt><a href="#todo">Pending Issues</a></dt>
 </dl>
-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.
-<h2><a name="requirements"></a>Requirements</h2>
-This library requires Boost version 1.33 or later.
+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.
+<h2><a name="differences_1_42"></a>Differences from Boost 1.42</h2>
+<ul>
+    <li>fixed failure of shared_ptr serialization when serializing pointers
+created from enable_shared_from_this.
+    <li>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.
+    <li>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.
+    <li>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.
+    <li>Some memory leaks associated with void_cast have been fixed.
+</ul>
+<h2><a name="differences_1_41"></a>Differences from Boost 1.41</h2>
+<ul>
+    <li>adjustments have been made to minimize compile time warnings.
+    <li>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.
+    <li>Some memory leaks associated with void_cast have been fixed.
+</ul>
+<h2><a name="differences_1_40"></a>Differences from Boost 1.40</h2>
+This library has been tested against Boost version 1.39 and 1.40.
+<p>
+    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.
+</p>
+Old Code:<br>
+<code><pre>
+...
+#include &lt;boost/archive/impl/archive_pointer_iserializer.ipp&gt;
+...
+template class detail::archive_pointer_iserializer&lt;naked_text_iarchive&gt; ;
+...
+template class detail::archive_pointer_iserializer&lt;text_iarchive&gt; ;
+</pre></code>should be replaced with this new code: <code><pre>
+#include &lt;boost/archive/impl/archive_serializer_map.ipp&gt;
+...
+template class detail::archive_serializer_map&lt;naked_text_iarchive&gt; ;
+...
+template class detail::archive_serializer_map&lt;text_iarchive&gt; ;
+</pre></code>
+<!--
 <p>
 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.
+older compilers - specifically MSVC 6, Borland and GCC < 3.0.
 If you are using one of these compilers, you may download a version
 of spirit 1.6 <a href="http://spirit.sourceforge.net/index.php?doc=download/index.html">here</a>.
 To use this downloaded version rather than the one included with boost,
@@ -52,74 +108,135 @@ 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.
-
-<h2><a name="differences_1_32"></a>Differences from Boost 1.32</h2>
+-->
+<h2><a name="differences_1_39"></a>Differences from Boost 1.39</h2>
 <ul>
-    <li>Dynamic Linking Library (DLLs and shared libraries) for platforms which support them. See
-    <a href="../../../more/getting_started.html#auto-link">Automatic Linking on Windows</a>.
-    <li>Implementation of auto-link for compilers which can support this.
-    <li>Better support for <em>Argument Dependent Lookup</em> and two-phase lookup.
-    This results in simpler rules regarding the placing of serialization specializations
-    namespaces.
-    <li>Enhanced documentation to help explain usage of the above.
-    <li>Adjustments to improve support for less conformant compilers.
-    <li>Improved <code>const</code> 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
-    <a target="detail" href="traits.html#tracking">here</a>.
-    <li>A new implementation of serialization for <code style="white-space: normal">shared_ptr&lt;T&gt;</code>.  This
-    is compatible with public interface of <code style="white-space: normal">shared_ptr&lt;T&gt;</code>
-    so it should be more robust and not have to change in the future.  The implementation optionally
-    includes code to load <code style="white-space: normal">shared_ptr&lt;T&gt;</code> stored in 
-    archives created with boost 1.32.  This code is stored in the header:
-    <code style="white-space: normal">boost/serialization/shared_ptr_132.hpp</code>. If your application
-    needs to load archives created with boost 1.32 libraries, include the above header
-    before each inclusion of <code style="white-space: normal">boost/serialization/shared_ptr.hpp</code>.
-    <li>More compilers tested and supported.
-    <li>Miscelleanous bug fixes.
+    <li>
+        It is now possible to serialize an object through a pointer to a class which 
+        implements its own <code style="white-space: normal">new/delete</code>
+    operators. This functionaly is not available on some compilers.
+    <li>
+    serialization of polymorphic objects has been sped up considerably.
+</ul>
+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 <a href="#todo">Pending Issues</a>.
+<h2><a name="differences_1_37"></a>Differences from Boost 1.37</h2>
+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 <a href="#todo">Pending 
+    Issues</a>.
+<h2><a name="differences_1_36"></a>Differences from Boost 1.36</h2>
+There are no new features in this version. As of this writing, all bug reports 
+filed as TRAK tickets have been addressed.
+<h2><a name="differences_1_35"></a>Differences from Boost 1.35</h2>
+<ul>
+    <li>
+    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.
+    <li>
+    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.
+    <li>
+    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.
+    <li>
+    All bug reports filed as TRAK tickets have been addressed.
+    <li>
+    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.
+</ul>
+<h2><a name="differences_1_34"></a>Differences from Boost 1.34</h2>
+<ul>
+    <li>
+    Enhanced support for fast serialization for native binary archives. By Mattias 
+    Troyer.
+    <li>
+    Improved implementation of "export" functionality. Removes header ordering 
+    requirement and eliminates the maintenance of a pre-determined list of "known 
+    archives" By David Abrahams.
+    <li>
+    Improved support for STLPort.
 </ul>
 <h2><a name="differences_1_33"></a>Differences from Boost 1.33</h2>
 <ul>
-    <li>Native Binary archives use the <code style="white-space: normal">std::streambuf</code> interface.
-    This should result in noticibly faster execution in many cases.
+    <li>
+        Native Binary archives use the <code style="white-space: normal">std::streambuf</code>
+    interface. This should result in noticeably faster execution in many cases.
 </ul>
-
-<h2><a name="differences_1_34"></a>Differences from Boost 1.34</h2>
+<h2><a name="differences_1_32"></a>Differences from Boost 1.32</h2>
 <ul>
-    <li>Ehanced support for fast serialiation for native binary archives. By Mattias Troyer.
-    <li>Improved implementation of "export" functionality.  Removes header ordering
-        requirement and eliminates the maintainence of a pre-determined list of "known archives"
-        By David Abrahams.
-    <li>Improved support for STLPort.
+    <li>
+        Dynamic Linking Library (DLLs and shared libraries) for platforms which support 
+        them. See <a href="../../../more/getting_started/windows.html#auto-linking">Automatic 
+            Linking on Windows</a>.
+    <li>
+    Implementation of auto-link for compilers which can support this.
+    <li>
+        Better support for <em>Argument Dependent Lookup</em>
+    and two-phase lookup. This results in simpler rules regarding the placing of 
+    serialization specializations namespaces.
+    <li>
+    Enhanced documentation to help explain usage of the above.
+    <li>
+    Adjustments to improve support for less conformant compilers.
+    <li>
+        Improved <code>const</code> 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 <a target="detail" href="traits.html#tracking">
+            here</a>.
+    <li>
+        A new implementation of serialization for <code style="white-space: normal">shared_ptr&lt;T&gt;</code>. 
+        This is compatible with public interface of <code style="white-space: normal">shared_ptr&lt;T&gt;</code>
+        so it should be more robust and not have to change in the future. The 
+        implementation optionally includes code to load <code style="white-space: normal">shared_ptr&lt;T&gt;</code>
+        stored in archives created with boost 1.32. This code is stored in 'he header: <code style="white-space: normal">
+            boost/serialization/shared_ptr_132.hpp</code>. If your application needs to 
+        load archives created with boost 1.32 libraries, include the above header 
+        before each inclusion of <code style="white-space: normal">boost/serialization/shared_ptr.hpp</code>.
+    <li>
+    More compilers tested and supported.
+    <li>
+    Miscellaneous bug fixes.
 </ul>
-
 <h2><a name="todo"></a>Pending issues</h2>
 <ul>
-    <li>Compile, and test on more platforms
-    <li>implement <code>is_virtual_base&lt;T&gt;</code> to automatically
-    eliminate redundancy in virtual base class serialization.
-    <li>currently can't serialize through a pointer an object a of class
-    that implements its own <code style="white-space: normal">new/delete</code> operators.
-    <li>Its possible that <code style="white-space: normal">std::string</code>
-    and <code style="white-space: normal">std::wstring</code> contain characters such as
-    '\0' which cannot be rendered in XML without an escape mechanism.  Currently there is 
-    no such escape mechanism implemented.
-    <li>A subtle error in the implementation of serialiaton of <code style="white-space: normal">std::map</code>
-    is fixed in this version.  Unfortunately, the fix breaks serialization of
-    <code style="white-space: normal">std::map</code> for those compilers which do not support
-    partial template specialization.
-    <li>Floating point values which are number cannot be serialized to text base archives.
+    <li>
+    Rvalues cannot be serialized. It would be possible to implement this for 
+    untracked types, but this has not been done.
+    <li>
+    Pointers to pointers cannot currently be serialized
+    <li>
+        Its possible that <code style="white-space: normal">std::string</code> and <code style="white-space: normal">
+            std::wstring</code>
+    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.
+    <li>
+        A subtle error in the implementation of serializaton of <code style="white-space: normal">
+            std::map</code> is fixed in this version. Unfortunately, the fix breaks 
+        serialization of <code style="white-space: normal">std::map</code>
+    for those compilers which do not support partial template specialization. Also, 
+    types which contain pointers or tracked types might not work correctly.
 </ul>
 <p>
-Aside from the above, there are a number of issus related to specific platforms.  
-These are listed in <a href="implementation.html#othercompilerissues">Specific Compiler/Library Issues</a>.
-
-<hr>
-<p><i>&copy; Copyright <a href="http://www.rrsd.com">Robert Ramey</a> 2002-2007. 
-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)
-</i></p>
+    Aside from the above, there are a number of issues related to specific 
+    platforms. These are listed in <a href="implementation.html#othercompilerissues">Specific 
+        Compiler/Library Issues</a>.
+    <hr>
+<p>
+    <i>&copy; Copyright <a href="http://www.rrsd.com">Robert Ramey</a> 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) </i>
+</p>
 </body>
 </html>

doc/serialization.html

@@ -1,4 +1,4 @@
-<!doctype HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
+<!doctype HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
 <html>
 <!--
 (C) Copyright 2002-4 Robert Ramey - http://www.rrsd.com . 
@@ -48,12 +48,13 @@ http://www.boost.org/LICENSE_1_0.txt)
         <dt><a href="#splittingfreefunctions">Free Functions</a>
       </dl>
   </dl>
-  <dt><a href="#pointers">Pointers</a>
+  <dt><a href="#pointeroperators">Pointers</a>
     <dl class="page-index">
       <dt><a href="#constructors">Non-Default Constructors</a>
       <dt><a href="#derivedpointers">Pointers to Objects of Derived Classes</a>
       <dl class="page-index">
         <dt><a href="#registration">Registration</a>
+        <dt><a href="#export">Export</a>
         <dt><a href="#instantiation">Instantiation</a>
         <dt><a href="#selectivetracking">Selective Tracking</a>
         <dt><a href="#runtimecasting">Runtime Casting</a>
@@ -61,8 +62,8 @@ http://www.boost.org/LICENSE_1_0.txt)
     </dl>
   <dt><a href="#references">References</a>
   <dt><a href="#arrays">Arrays</a>
-  <dt><a href="wrappers.html">Serialization Wrappers</a>
   <dt><a href="traits.html">Class Serialization Traits</a>
+  <dt><a href="wrappers.html">Serialization Wrappers</a>
   <dt><a href="#models">Models - Serialization Implementations Included in the Library</a>
 </dl>
 
@@ -77,14 +78,15 @@ if and only if one of the following is true:
     <a target="detail" href="traits.html#Traits">serialization traits</a>,
     any user type can also be designated as "primitive"
     so that it is handled in this way.
-  <li>It is a class type and one of the following has been declared:
+  <li>It is a class type and one of the following has been declared according
+    to the prototypes detailed below:
     <ul>
     <li>a class member function <code style="white-space: normal">serialize</code>
     <li>a global function <code style="white-space: normal">serialize</code>
     </ul>
   <li>it is a pointer to a <strong>Serializable</strong> type.
   <li>it is a reference to a <strong>Serializable</strong> type.
-  <li>it is an native C++ Array of <strong>Serializable</strong> type.
+  <li>it is a native C++ Array of <strong>Serializable</strong> type.
 </ul>
 
 <h2><a name="primitiveoperators">Primitive Types</a></h2>
@@ -675,8 +677,9 @@ main(){
 Note that if the serialization function is split between save and load, both
 functions must include the registration.  This is required to keep the save
 and corresponding load in syncronization.
-<p>
-This will work but may be inconvenient.  We don't always know which derived
+
+<h4><a name="export">Export</a></h4>
+The above will work but may be inconvenient.  We don't always know which derived
 classes we are going to serialize when we write the code to serialize through
 a base class pointer.  Every time a new derived class is written we have to
 go back to all the places where the base class is serialized and update the
@@ -791,8 +794,8 @@ class derived : public base {
         boost::serialization::base_object&lt;base&gt;(*this);
         // method 2 : explicitly register base/derived relationship
         boost::serialization::void_cast_register&lt;derived, base&gt;(
-            static_cast&lt;base *&gt;(NULL),
-            static_cast&lt;derived *&gt;(NULL)
+            static_cast&lt;derived *&gt;=NULL),
+            static_cast&lt;base *&gt;(NULL)
         )
     }
 };
@@ -919,7 +922,7 @@ As of this writing, the library contains serialization of the following boost cl
   <li>auto_ptr (demo)
 </ul>
 Others are being added to the list so check the boost files section and headers for
-new implmentations!
+new implementations!
 <hr>
 <p><i>&copy; Copyright <a href="http://www.rrsd.com">Robert Ramey</a> 2002-2004. 
 Distributed under the Boost Software License, Version 1.0. (See

doc/shared_ptr2.html

@@ -20,7 +20,7 @@ http://www.boost.org/LICENSE_1_0.txt)
     </td>
     <td valign="top"> 
       <h1 align="center">Serialization</h1>
-      <h2 align="center"><code style="white-space: normal">shared_ptr&lt;class T&gt;</code> Revisted</h2>
+      <h2 align="center"><code style="white-space: normal">shared_ptr&lt;class T&gt;</code> Revisited</h2>
     </td>
   </tr>
 </table>
@@ -32,7 +32,7 @@ Unfortunately, this way of doing it suffered from some undesirable features
   <li>It was dependent on the Boost implementation of <code style="white-space: normal">shared_ptr</code>.
   The <code style="white-space: normal">shared_ptr</code> interface has been included
   in <code style="white-space: normal">std::tr1</code> and may someday be included in the standard
-  C++ library. An implementation which depends only on the public interface can be guarenteed to
+  C++ library. An implementation which depends only on the public interface can be guaranteed to
   function with any other future implementation of <code style="white-space: normal">shared_ptr</code>.
   <li>It required extra macros for export.
 </ul>
@@ -45,7 +45,7 @@ inline void save(
     const unsigned int /* file_version */
 ){
     const T * t_ptr = t.get();
-    // just seriailize the underlying raw pointer
+    // just serialize the underlying raw pointer
     ar &lt;&lt: boost::serialization::make_nvp("px", t_ptr);
 }
 
@@ -56,7 +56,7 @@ inline void load(
     const unsigned int file_version
 ){
     T* r;
-    // recover the underlying raw poiter
+    // recover the underlying raw pointer
     ar >> boost::serialization::make_nvp("px", r);
 
     // To Do - match up with other shared pointers which 
@@ -65,13 +65,13 @@ inline void load(
 }
 </code></pre>
 
-In priniciple this is very much simpler than the original implementation.  Completion of
+In principle, this is very much simpler than the original implementation.  Completion of
 this code requires:
 
 <ol>
   <li>Filling in the "To Do".  This required making an extra map for
   <code style="white-space: normal">shared_ptr</code> instances.
-  <li>A method for identifing pointers to the same objects from pointers to their base classes.
+  <li>A method for identifying pointers to the same objects from pointers to their base classes.
   <li>Backward compatibility with pointers serialized by the previous method.  This exploits
   the serialization class versioning.
   <li>Proper handling of <code style="white-space: normal">weak_ptr</code>.

doc/simple_log.html

@@ -0,0 +1,95 @@
+<!doctype HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
+<html>
+<!--
+(C) Copyright 2002-10 Robert Ramey - http://www.rrsd.com .
+Use, modification and distribution is subject to 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)
+-->
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
+<link rel="stylesheet" type="text/css" href="../../../boost.css">
+<link rel="stylesheet" type="text/css" href="style.css">
+<title>Serialization - Derivation from an Existing Archive</title>
+</head>
+<body link="#0000ff" vlink="#800080">
+<table border="0" cellpadding="7" cellspacing="0" width="100%" summary="header">
+  <tr> 
+    <td valign="top" width="300"> 
+      <h3><a href="../../../index.htm"><img height="86" width="277" alt="C++ Boost" src="../../../boost.png" border="0"></a></h3>
+    </td>
+    <td valign="top"> 
+      <h1 align="center">Serialization</h1>
+      <h2 align="center">A Simple Logging Archive Class</h2>
+    </td>
+  </tr>
+</table>
+<hr>
+The purpose of this example help clarify the usage of the
+<a href="archives.html"><strong>Archive Concept</strong></a> 
+so that one can implement his own archive classes.  
+<a href="../example/simple_log_archive.hpp" target="simple_archive_hpp">
+<code>simple_log_archive.hpp</code></a> implements a simple but useful
+archive class. This class can be used to send any serializable types
+on an output text stream in a readable format. Usage of this facility
+is trivially easy:
+
+<pre><code>
+#include "simple_log_archive.hpp"
+...
+// display the complete schedule
+simple_log_archive log(std::cout);
+log << schedule;
+</code></pre>
+
+and it produces the following output
+
+<pre><code>
+schedule 
+ count 6
+ item 
+  first 
+   driver bob
+   hour 6
+   minute 24
+  second -> 
+   stops 
+    count 3
+    item -> 
+     latitude 
+      degrees 34
+      minutes 135
+      seconds 52.56
+     longitude 
+      degrees 134
+      minutes 22
+      seconds 78.3
+...
+</code></pre>
+
+The complete example is <a href="../example/demo_simple_log.cpp" target="demo_simple_log_cpp">
+<code>demo_simple_log.cpp</code></a>.  Look at 
+<a href="archive_reference.html#trivial">Trivial Archive</a> to get a 
+better understanding of how this works.
+
+Also, note the following:
+<ul>
+  <li>Only 160 lines of code.
+  <li>Header only - linking with the serialization library not required.
+  <li>Displays ALL <a href="serialization.html"><strong>Serializable</strong></a> types.
+  <li>Lacks some features.
+  <ul>
+    <li>it will not display the data from the derived type given the pointer to a 
+    polymorphic base class.  That is, only displays the information of the base class.
+    To add that see the next example.
+    <li>doesn't display information serialized as binary data
+  </ul>
+</ul>
+
+<hr>
+<p><i>&copy; Copyright <a href="http://www.rrsd.com">Robert Ramey</a> 2002-2010. 
+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)
+</i></p>
+</body>
+</html>

doc/singleton.html

@@ -0,0 +1,256 @@
+<!doctype HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
+<html>
+<!--
+(C) Copyright 2002-4 Robert Ramey - http://www.rrsd.com . 
+Use, modification and distribution is subject to 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)
+-->
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
+<link rel="stylesheet" type="text/css" href="../../../boost.css">
+<link rel="stylesheet" type="text/css" href="style.css">
+<title>Serialization - singleton</title>
+</head>
+<body link="#0000ff" vlink="#800080">
+<table border="0" cellpadding="7" cellspacing="0" width="100%" summary="header">
+  <tr> 
+    <td valign="top" width="300"> 
+      <h3><a href="../../../index.htm"><img height="86" width="277" alt="C++ Boost" src="../../../boost.png" border="0"></a></h3>
+    </td>
+    <td valign="top"> 
+      <h1 align="center">Serialization</h1>
+      <h2 align="center"><code style="white-space: normal">singleton</code></h2>
+    </td>
+  </tr>
+</table>
+<hr>
+<dl class="page-index">
+  <dt><a href="#motivation">Motivation</a>
+  <dt><a href="#features">Features</a>
+  <dt><a href="#classinterface">Class Interface</a>
+  <dt><a href="#requirements">Requirements</a>
+  <dt><a href="#example">Examples</a>
+  <dt><a href="#multithreading">Multi-Threading</a>
+</dl>
+
+<h3><a name="motivation">Motivation</a></h3>
+The serialization library relies on the existence of a number
+of static variables and tables to store information related
+to runtime types.  Examples are tables which relate exported
+names to types and tables which relate base classes to derived
+classes.  Construction, destruction and usage of these variables
+requires consideration of the following issues:
+<ul>
+  <li>Some static data variables and constants  entries refer to others.  
+  The sequence of initialization cannot be arbitrary but must be in proper
+  sequence.</li>
+  <li>A number of static variables aren't referred explicitly and, without
+  special precautions, will be stripped by most code optimizers</li>
+  <li>Many of these variables are created by templates and special care must
+  be taken to be sure that they are instantiated</li>
+  <li>In a multi-threading system, its possible that these static variables
+  will be accessed concurrently by separate threads.  This would create a
+  race condition with unpredictabe behavior</li>
+</ul>
+This singleton class addresses all of the above issues.
+
+<h3><a name="features">Features</a></h3>
+This singleton implementation has the following features:
+<ul>
+  <li>
+    Any instance will be constructed before any attempt is made to access it.</li>
+  <li>
+    Any instance created with a template is guarenteed to be instantiated.
+  <li>
+    Regardless of whether or not an instance has been explicitly
+    referred to, it will not be stripped by the optimizer when the
+    executable is built in release mode.
+  <li>
+    All instances are constructed before 
+    <code style="white-space: normal">main</code> is called
+    regardless of where they might be referenced within the program.
+    In a multi-tasking system, this guarentees that there will be no 
+    race conditions during the construction of any instance.  No
+    thread locking is required to guarentee this.
+  <li>
+    The above implies that any <code style="white-space: normal">const</code>
+    instances are thread-safe during the whole program.  Again, no
+    thread locking is required.
+  <li>
+    If a mutable instance is created, and such an instance is modified
+    after main is called in a mult-threading system, there exists
+    the possibility that a race condition will occur.  The serialization
+    library takes care that in the few places where a mutable
+    singleton is required, it is not altered after 
+    <code style="white-space: normal">main</code> is called.
+    For a more general purpose usage, thread locking on this
+    singleton could easily be implemented.  But as the serialization
+    library didn't require it, it wasn't implemented.
+</ul>
+
+<h3><a name="classinterface">Class Interface</a></h3>
+<pre><code>
+namespace boost { 
+namespace serialization {
+
+template <class T>
+class singleton : public boost::noncopyable
+{
+public:
+    static const T & get_const_instance();
+    static T & get_mutable_instance();
+    static bool is_destroyed();
+};
+
+} // namespace serialization 
+} // namespace boost
+</code></pre>
+
+<dl>
+
+<dt><h4><pre><code>
+static const T & get_const_instance();
+</code></pre></h4></dt>
+<dd>
+Retrieve a constant reference to the singleton for this type.
+</dd>
+
+<dt><h4><pre><code>
+static T & get_mutable_instance();
+</code></pre></h4></dt>
+<dd>
+Retrieve a mutable reference to the singleton for this type.
+</dd>
+
+<dt><h4><pre><code>
+static bool is_destroyed();
+</code></pre></h4></dt>
+<dd>
+Return <code>true</code> if the destructor on this singleton has been 
+called.  Otherwise, return <code>false</code>.
+</dd>
+
+</dl>
+
+<h3><a name="requirements">Requirements</a></h3>
+In order to be used as 
+<a target="singleton.hpp" href = "../../../boost/serialization/singleton.hpp">
+<code style="white-space: normal">
+singleton&lt;T&gt;
+</code> 
+</a>
+, the type T must be default constructable.
+It doesn't require static variables - though it may have them.
+Since the library guarentees that only one instance of 
+<a target="singleton.hpp" href = "../../../boost/serialization/singleton.hpp">
+<code style="white-space: normal">
+singleton&lt;T&gt;
+</code> 
+</a>
+and all accesss is through the above static interface
+functions, common member functions of T become
+the functional equivalent of 
+<code style="white-space: normal">static</code> functions.
+
+<h3><a name="example">Examples</a></h3>
+There are at least two different ways to use this class template.
+Both are used in the serialization library.
+<p>
+The first way is illustrated by and excerpt from the file
+<code style="white-space: normal"><a target="extended_type_info" href="../src/extended_type_info.cpp">extended_type_info.cpp</a></code>.
+which contains the following code:
+
+<pre><code>
+typedef std::set<const extended_type_info *, key_compare> ktmap;
+...
+void
+extended_type_info::key_register(const char *key) {
+    ...
+    result = singleton<ktmap>::get_mutable_instance().insert(this);
+    ...
+}
+</code></pre>
+Just by referring to the singleton instance anywhere in the program
+will guarentee that one and only one instance for the specified
+type (<code style="white-space: normal">ktmap</code> in this example) 
+will exist throughout the program.  There is no need for anyother
+declaration or definition.
+<p>
+A second way is to use 
+<a target="singleton.hpp" href = "../../../boost/serialization/singleton.hpp">
+<code style="white-space: normal">
+singleton&lt;T&gt;
+</code> 
+</a>
+as one of the base classes of the type.  This is illustrated by a simplified
+excerpt from
+<a target="extended_type_info_typeid.hpp" href = "../../../boost/serialization/extended_type_info_typeid.hpp">
+<code style="white-space: normal">
+extended_type_info_typeid.hpp
+</code> 
+</a>
+
+<pre><code>
+template&lt;class T&gt;
+class extended_type_info_typeid : 
+    public detail::extended_type_info_typeid_0,
+    public singleton&lt;extended_type_info_typeid&lt;const T&gt; &gt;
+{
+    friend class singleton&lt;extended_type_info_typeid&lt;const T&gt; &gt;;
+private:
+    // private constructor to inhibit any existence other than the 
+    // static one.  Note: not all compilers support this !!!
+    extended_type_info_typeid() :
+        detail::extended_type_info_typeid_0()
+    {
+        type_register(typeid(T));
+    }
+    ~extended_type_info_typeid(){}
+    ...
+};
+</code></pre>
+
+This usage will permit a more natural syntax to be used:
+<pre><code>
+extended_type_info_typeid&lt;T&gt;::get_const_instance()
+</code></pre>
+
+Again, including one or more of the above statements anywhere
+in the program will guarentee that one and only one instance
+is created and referred to.
+
+<h3><a name="multithreading">Multi-Threading</a></h3>
+This singleton CAN be safely used in multi-threading applications if one
+is careful follow a simple rule:
+<p>
+<b>Do not call get_mutable_instance when more than one thread is running!</b>
+<'>
+All singletons used in the serialization library follow this rule.  
+In order to help detect accidental violations of this rule there
+exists an singleton lock/unlock functions.
+<pre><code>
+void boost::serialization::singleton_module::lock();
+void boost::serialization::singleton_module::unlock();
+bool boost::serialization::singleton_module::is_locked();
+</code></pre>
+In a program compiled for debug, any invocation of 
+<code style="white-space: normal">get_mutable_instance()</code>
+while the library is in a "locked" state will trap in an assertion.
+The singleton module lock state is initialized as "unlocked" to permit
+alteration of static variables before 
+<code style="white-space: normal">main</code> is called. 
+The <code style="white-space: normal">lock()</code> and
+<code style="white-space: normal">unlock()</code> are "global"
+in they affect ALL the singletons defined by this template.
+All serialization tests invoke <code style="white-space: normal">lock()</code>
+at the start of the progam.  For programs compiled in release
+mode these functions have no effect.
+
+<hr>
+<p><i>&copy; Copyright <a href="http://www.rrsd.com">Robert Ramey</a> 2007. 
+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)
+</i></p>
+</body>
+</html>

doc/smart_cast.html

@@ -58,7 +58,7 @@ These rules can make it difficult to use casting with a function template argume
 Consider the following example:
 
 <pre><code>
-#include &lt;boost/smart_cast.hpp&gt;
+#include &lt;boost/serialization/smart_cast.hpp&gt;
 
 struct top {
 };

doc/special.html

@@ -1,4 +1,4 @@
-<!doctype HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
+<!doctype HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
 <html>
 <!--
 (C) Copyright 2002-4 Robert Ramey - http://www.rrsd.com . 
@@ -27,7 +27,6 @@ http://www.boost.org/LICENSE_1_0.txt)
 <hr>
 <dl class="page-index">
   <dt><a href="#objecttracking">Object Tracking</a>
-  <dt><a href="#export">Exporting Class Serialization</a>
   <dt><a href="#classinfo">Class Information</a>
   <dt><a href="#portability">Archive Portability</a>
   <dl class="page-index">
@@ -36,7 +35,10 @@ http://www.boost.org/LICENSE_1_0.txt)
   </dl>
   <dt><a href="#binary_archives">Binary Archives</a>
   <dt><a href="#xml_archives">XML Archives</a>
+  <dt><a href="#export">Exporting Class Serialization</a>
+  <dt><a href="#static_libraries">Static Libraries and Serialization</a>
   <dt><a href="#dlls">DLLS - Serialization and Runtime Linking</a>
+  <dt><a href="#plugins">Plugins</a>
   <dt><a href="#multi_threading">Multi-Threading</a>
   <dt><a href="#optimizations">Optimizations</a>
   <dt><a href="exceptions.html">Archive Exceptions</a>
@@ -153,55 +155,6 @@ redundant save/load operations.
 BOOST_CLASS_TRACKING(my_virtual_base_class, boost::serialization::track_always)
 </code></pre>
 
-<h3><a name="export">Exporting Class Serialization</a></h3>
-<a target="detail" href="traits.html#export">Elsewhere</a> in this manual, we have described 
-<code style="white-space: normal">BOOST_CLASS_EXPORT</code>. This is used to make the serialization library aware
-that code should be instantiated for serialization of a given class even though the
-class hasn't been otherwise referred to by the program.  This functionality
-is necessary to implement serialization of pointers through a virtual base
-class pointer.  That is, a polymorphic pointer.
-<p>
-This macro specifies a "<b>G</b>lobally <b>U</b>nique <b>ID</b>entifier".  
-This is an string which identifies the class to be created when data is loaded.
-Generally a text representation of the class name is sufficient for this purpose, 
-but in certain cases it maybe necessary to specify a different string by using 
-<code style="white-space: normal">BOOST_CLASS_EXPORT_GUID</code> 
-rather than a simple 
-<code style="white-space: normal">BOOST_CLASS_EXPORT</code>.
-
-<p>
-<code style="white-space: normal">BOOST_CLASS_EXPORT</code> would usually 
-be specified in the same header file as the class declaration to which it 
-corresponds.  That is, <code style="white-space: normal">BOOST_CLASS_EXPORT(T)</code>
-is a "trait" of the class T. So a program using this class will look 
-something like:
-
-<pre><code>
-#include &lt;boost/archive/xml_oarchive.hpp&gt;
-.... // any other archive classes
-#include "my_class.hpp"  // which contains BOOST_CLASS_EXPORT(my_class)
-</code></pre>
-
-These headers can be in any order.  (In boost versions 1.34
-and earlier, the archive headers had to go before any headers which
-contain <code style="white-space: normal">BOOST_CLASS_EXPORT</code>.)
-Any code required to serialize types specified
-by <code style="white-space: normal">BOOST_CLASS_EXPORT</code> will be
-instantiated for each archive whose header is included.  (note that the code 
-is instantiated regardless of whether or not it is actually invoked.) 
-If no archive headers are included - no code should be instantiated. 
-This will permit <code style="white-space: normal">BOOST_CLASS_EXPORT</code> 
-to be a permanent part of the <code style="white-space: normal">my_class.hpp</code> .
-
-<p>
-Note that the implementation of this functionality depends upon vendor
-specific extensions to the C++ language.  So, there is no guarenteed portability
-of programs which use this facility.  However, all C++ compilers which
-are tested with boost provide the required extensions.  The library
-includes the extra declarations required by each of these compilers.
-It's reasonable to expect that future C++ compilers will support
-these extensions or something equivalent.
-
 <h3><a name="classinfo">Class Information</a></h3>
 By default, for each class serialized, class information is written to the archive.
 This information includes version number, implementation level and tracking
@@ -286,7 +239,7 @@ struct my_wrapper {
 class my_class {
     wchar_t a;
     short unsigned b;
-    template<&lt;class Archive&gt;
+    template&lt;class Archive&gt;
     Archive & serialize(Archive & ar, unsigned int version){
         ar & my_wrapper(a);
         ar & my_wrapper(b);
@@ -345,13 +298,114 @@ just the value portion of the data is serialized. The name portion is discarded
 So by always using <a target="detail" href="wrappers.html#nvp">name-value pairs</a>, it will
 be guarenteed that all data can be serialized to all archive classes with maximum efficiency.
 
-<h3><a name="dlls">DLLS - Serialization and Runtime Linking</a></h3>
-Serialization code can be placed in libraries to be linked at runtime.  That is,
-code can be placed in DLLS(Windows) or Shared Libraries(*nix).  
-Along with the "export" facility, this
-permits a program to written without knowledge of the actual types to be serialized.
-This package doesn't include an example of this technique - but coding would be
-very similar to the example 
+<h3><a name="export">Exporting Class Serialization</a></h3>
+<a target="detail" href="traits.html#export">Elsewhere</a> in this manual, we have described 
+<code style="white-space: normal">BOOST_CLASS_EXPORT</code>. 
+Export implies two things:
+<ul>
+<li>Instantiates code which is not otherwise referred to.
+<li>Associates an external identifier with the class to be serialized.
+The fact that the class isn't explicitly referred to implies this
+requirement.
+</ul>
+In C++, usage of code not explicitly referred to is implemented via
+virtual functions.  Hence, the need for export is implied by the 
+usage of a derived class that is manipulated via a pointer or
+reference to it's base class.
+
+<p>
+<code style="white-space: normal">BOOST_CLASS_EXPORT</code> in the same
+source module that includes any of the archive class headers will
+instantiate code required to serialize polymorphic pointers of
+the indicated type to the all those archive classes. If no
+archive class headers are included, then no code will be instantiated.
+
+<p>
+Note that the implemenation of this functionality requires
+that the <code style="white-space: normal">BOOST_CLASS_EXPORT</code>
+macro appear <b>after</b> and the inclusion of any archive
+class headers for which code is to be instantiated.
+So, code that uses <code style="white-space: normal">BOOST_CLASS_EXPORT</code>
+will look like the following:
+<pre><code>
+#include &lt;boost/archive/text_oarchive.hpp&gt;
+#include &lt;boost/archive/text_oarchive.hpp&gt;
+... // other archives
+
+#include "a.hpp" // header declaration for class a
+BOOST_CLASS_EXPORT(a)
+... // other class headers and exports
+</code></pre>
+This will be true regardless of whether the is part
+of a stand alone executable, a static library or
+a dyanmic or shared library.  
+<p>
+Including
+<code style="white-space: normal">BOOST_CLASS_EXPORT</code>
+in the "a.hpp" header itself as one would do with
+other serialization traits will make it difficult
+or impossible to follow the rule above regarding
+inclusion of archive headers before
+<code style="white-space: normal">BOOST_CLASS_EXPORT</code>
+is invoked. This can best be addressed by using
+<code style="white-space: normal">BOOST_CLASS_EXPORT_KEY</code>
+in the header declarations and
+<code style="white-space: normal">BOOST_CLASS_EXPORT_IMPLEMENT</code>
+in the class definition file.
+
+<p>
+This system has certain implications for placing code in static or shared
+libraries.  Placing <code style="white-space: normal">BOOST_CLASS_EXPORT</code>
+in library code will have no effect unless archive class headers are
+also included.  So when building a library, one should include all headers
+for all the archive classes which he anticipates using. Alternatively,
+one can include headers for just the
+<a href="archive_reference.html#polymorphic">Polymoprhic Archives</a>.
+
+<p>
+Strictly speaking, export should not be necessary if all pointer serialization
+occurs through the most derived class.  However, in order to detect
+what would be catastophic error, the library traps ALL serializations through
+a pointer to a polymorphic which are not exported or otherwise registered.
+So, in practice, be prepared to register or export all classes with one
+or more virtual functions which are serialized through a pointer. 
+
+<p>
+Note that the implementation of this functionality depends upon vendor
+specific extensions to the C++ language.  So, there is no guarenteed portability
+of programs which use this facility.  However, all C++ compilers which
+are tested with boost provide the required extensions.  The library
+includes the extra declarations required by each of these compilers.
+It's reasonable to expect that future C++ compilers will support
+these extensions or something equivalent.
+
+<h3><a name="static_libraries">Static Libraries and Serialization</a></h3>
+Code for serialization of data types can be saved in libraries
+just as it can for the rest of the type implementation.
+This works well, and can save huge amount of compilation time.
+<ul>
+<li>Only compile serialization definitions in the library.
+<li>Explicitly instantiate serialization code for ALL
+archive classes you intend to use in the library.
+<li>For exported types, only use <code style="white-space: normal">BOOST_CLASS_EXPORT_KEY</code>
+in headers.
+<li>For exported types, only use <code style="white-space: normal">BOOST_CLASS_EXPORT_IMPLEMENT</code>
+in definitions compiled in the library.  For any particular type,
+there should be only one file which contains
+<code style="white-space: normal">BOOST_CLASS_EXPORT_IMPLEMENT</code>
+for that type.  This ensures that only one copy
+of serialization code will exist within the program.  It avoids
+wasted space and the possibility of having different
+versions of the serialization code in the same program.
+Including
+<code style="white-space: normal">BOOST_CLASS_EXPORT_IMPLEMENT</code>
+in multiple files could result in a failure
+to link due to duplicated symbols or the throwing
+of a runtime exception.
+<li> Code for serialization should be only in the library,
+<li>Familiarize yourself with the <b>PIMPL</b> idiom.
+</ul>
+This is illustrated by
 <a href = "../example/demo_pimpl.cpp" target="demo_pimpl">
 <code style="white-space: normal">demo_pimpl.cpp</code>
 </a>,
@@ -362,52 +416,150 @@ and
 <a href = "../example/demo_pimpl_A.hpp" target="demo_pimpl">
 <code style="white-space: normal">demo_pimpl_A.hpp</code>
 </a>
-where implementation of serializaton is completely separate
-from the main program.
+where implementation of serializaton is in a static library 
+completely separate from the main program.
+
+<h3><a name="dlls">DLLS - Serialization and Runtime Linking</a></h3>
+Serialization code can be placed in libraries to be linked at runtime.  That is,
+code can be placed in DLLS(Windows) Shared Libraries(*nix), or static libraries
+as well as the main executable.  The best technique is the
+same as that described above for libraries.  The serialization
+library test suite includes the following programs
+to illustrate how this works:
+<p>
+
+<a href = "../test/test_dll_simple.cpp" target="test_dll_simple">
+<code style="white-space: normal">test_dll_simple</code>
+</a>,
+and
+<a href = "../test/dll_a.cpp" target="dll_a">
+<code style="white-space: normal">dll_a.cpp</code>
+</a>
+where implementation of serializaton is also completely separate
+from the main program but the code is loaded at runtime.  In this
+example, this code is loaded automatically when the program which
+uses it starts up, but it could just as well be loaded and unloaded 
+with an OS dependent API call.
+<p>
+Also included are
+<a href = "../test/test_dll_exported.cpp" target="test_dll_exported">
+<code style="white-space: normal">test_dll_exported.cpp</code>
+</a>,
+and
+<a href = "../test/polymorphic_derived2.cpp" target="polymorphic_derived2">
+<code style="white-space: normal">polymorphic_derived2.cpp</code>
+</a>
+which are similar to the above but include tests of the export
+and no_rtti facilities in the context of DLLS.
+<p>
+For best results, write your code to conform to the following
+guidelines:
+<ul>
+  <li>Don't include <code>inline</code> code in classes used in DLLS.
+This will generate duplicate code in the DLLS and mainline. This
+needlessly duplicates code.  Worse, it makes is possible for 
+different versions of the same code exist simultaneously.  This
+type of error turns out to be excruciatingly difficult to debug.
+Finally, it opens the possibility that module being referred to
+might be explictly unloaded which would (hopefully) result in
+a runtime error. This is another bug that is not always 
+reproducible or easy to find. For class member templates use something like
+
+<pre><code>
+template&lt;class Archive&gt;
+void serialize(Archive & ar, const unsigned int version);
+</code></pre>
+in the header, and
+
+<pre><code>
+template&lt;class Archive&gt;
+void myclass::serialize(Archive & ar, const unsigned int version){
+	...
+}
+
+BOOST_EXPORT_CLASS_IMPLEMENT(my_class)
+
+#include &lt;boost/archive/text_oarchive&gt;
+#include &lt;boost/archive/text_iarchive&lt;
+template myclass::serialize(boost::archive::text_oarchive & ar, const unsigned int version);
+template myclass::serialize(boost::archive::text_iarchive & ar, const unsigned int version);
+... // repeat for each archive class to be used.
+</code></pre>
+in the implementation file.  This will result in generation of all code
+required in only one place.  The library does not detect this type of error for you.
+  <li>If DLLS are to be loaded an unloaded explicitly (e.g. using <code>dlopen</code> in *nix or 
+<code>LoadLibrary</code> in Windows).  Try to arrange that they are unloaded in the reverse
+sequence.  This should guarentee that problems are avoided even if the
+above guidline hasn't been followed.
+
+</ul>
+
+<h3><a name="plugins">Plugins</a></h3>
+In order to implement the library, various facilities for runtime
+manipulation of types are runtime were required.  These
+are <a target="detail" href="extended_type_info.html"><code>extended_type_info</code></a>
+for associating classes with external identifying strings (<b>GUID</b>)
+and <a target="detail" href="void_cast.html"><code>void_cast</code></a>
+for casting between pointers of related types.
+
+To complete the functionality of 
+<a target="detail" href="extended_type_info.html"><code>extended_type_info</code></a>
+the ability to construct and destroy corresponding types has been
+added.  In order to use this functionality, one must specify
+how each type is created.  This should be done at the time
+a class is exported.  So, a more complete example of the code above would be:
+
+<pre><code>
+#include &lt;boost/archive/text_oarchive.hpp&gt;
+#include &lt;boost/archive/text_oarchive.hpp&gt;
+... // other archives
+
+#include "a.hpp" // header declaration for class a
+
+// this class has a default constructor
+BOOST_SERIALIZATION_FACTORY_0(a)
+// as well as one that takes one integer argument
+BOOST_SERIALIZATION_FACTORY_1(a, int)
+
+// specify the GUID for this class
+BOOST_CLASS_EXPORT(a)
+... // other class headers and exports
+</code></pre>
+
+With this in place, one can construct, serialize and destroy
+about which only is know the <b>GUID</b> and a base class.
+
 
 <h3><a name="multi_threading">Multi-Threading</a></h3>
-The nature of serialization would conflict with multiple thread concurrently
-writing/reading from/to a single open archive.  Since each archive is
-independent from ever other one, there should be no problem
-in having multiple open archives from one or more threads.
+The fundamental purpose of serialization would conflict with multiple 
+thread concurrently writing/reading from/to a single open archive instance.
+The library implementation presumes that the application avoids such an situtation.
 <p>
-Well, not quite.
+However, Writing/Reading different archives simultaneously
+in different tasks is permitted as each archive instance is (almost) 
+completely independent from any other archive instance.  The only shared 
+information are some type tables which have been implemented using a 
+lock-free thread-safe 
+<a target="detail" href="singleton.html">
+<code style="white-space: normal">singleton</code>
+</a>
+described elsewhere in this documentation.
 <p>
-There are a couple of global data structures for holding
-information of serializable types.  These structures are
-used to dispatch to correct code to handle each pair
-of serializable types and archive types.  Since this
-information is shared among all archives, there is 
-potential for problems.  This has been addressed
-carefully implementing the library so that these 
-structures are all initialized before 
-<code style="white-space: normal">main(...)</code>
-is called.  From then on they are never altered.  So
-there SHOULD be no problem having mulitple archives
-open simultaneously - be it from the same or different
-threads.
-<p>
-Well, almost.
-<p>
-With dynamically loaded code - DLLS or Shared Libraries, 
-these global data structures can be altered when a library
-is loaded or unloaded.  That is, in this case, these
-globa data structures can be altered after 
-<code style="white-space: normal">main(...)</code>
-is called.  So if a thread is dynamically loading/unloading
-modules which contain serialization code while an 
-archive is open there could be problems.  Also, if
-such loading/unloading is happening concurrently
-in different threads, there could also be problems.
-<p>
-It might not be easy to control this.  Is possible that
-some systems may not actually load modules until they
-are actually needed.  So even though we think that
-there is not dynamic loading/unloading of such code
-it could be occurring as "help" to manage resources.
-On such systems, access to archive code would have 
-to be syncronized with some multi-threading construct
-in order to be functional.
+This singleton implementation guarentees that all of this shared
+information is initialized when the code module which contains
+them is loaded.  The serialization library takes care to
+ensure that these data structures are not subsequently
+modified. The only time there could be a problem would
+be if code is loaded/unloaded while another task is
+serializing data.  This could only occur for types whose 
+serialization is implemented in a dynamically loaded/unload DLL
+or shared library.  So if the following is avoided:
+<ul>
+    <li>Accessing the same archive instance from different tasks.
+    <li>Loading/Unloading DLLS or shared libraries while any archive
+    instances are open.
+</ul>
+The library should be thread safe.
 
 <h3><a name="optimizations">Optimizations</a></h3>
 In performance critical applications that serialize large sets of contiguous data of homogeneous

doc/state_saver.html

@@ -49,7 +49,7 @@ public:
 </code></pre>
 
 The complete implementation can be found
-<a target="state_saver" href="../../../boost/state_saver.hpp">here</a>
+<a target="state_saver" href="../../../boost/serialization/state_saver.hpp">here</a>
 
 The following illustrates how this is expected to be used.
 

doc/static_warning.html

@@ -25,7 +25,25 @@ http://www.boost.org/LICENSE_1_0.txt)
   </tr>
 </table>
 <hr>
-To do.
+
+The header <code>&lt;boost/serialization/static_warning.hpp&gt;</code> supplies a single macro 
+<code style="white-space: normal">BOOST_STATIC_WARNING(x)</code>, which generates a compile time warning message if 
+the integral-constant-expression x is not true. 
+<p>
+Note that if the condition is true, then the macro will generate neither 
+code nor data - and the macro can also be used at either namespace, 
+class or function scope. When used in a template, the expression x 
+will be evaluated at the time the template is instantiated; this is 
+particularly useful for validating template parameters. 
+<p>
+It is intended that the functioning of <code style="white-space: normal">BOOST_STATIC_WARNING(x)</code>
+be identical to that of <code style="white-space: normal">BOOST_STATIC_ASSERT(x)</code>
+except that rather than resulting in a compilation error, it will result in
+a compiler warning.  In all other respects it should be the same.  So
+for more information on using <code style="white-space: normal">BOOST_STATIC_WARNING(x)</code>
+consult the documentation for <code style="white-space: normal">BOOST_STATIC_ASSERT(x)</code>
+<a href="../../../doc/html/boost_staticassert.html">here</a>.
+
 <hr>
 <p><i>&copy; Copyright <a href="http://www.rrsd.com">Robert Ramey</a> 2002-2004. 
 Distributed under the Boost Software License, Version 1.0. (See

doc/strong_typedef.html

@@ -1,4 +1,4 @@
-<!doctype HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
+<!doctype HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
 <html>
 <!--
 (C) Copyright 2002-4 Robert Ramey - http://www.rrsd.com . 
@@ -48,7 +48,7 @@ Usage of BOOST_STRONG_TYPEDEF
 addresses this.
 <pre></code>
 <a target="strong_typedef" href="../../../boost/strong_typedef.hpp">
-#include &lt;boost/strong_typedef.hpp&gt;
+#include &lt;boost/serialization/strong_typedef.hpp&gt;
 </a>
 
 BOOST_STRONG_TYPEDEF(int, a)

doc/style.css

@@ -6,3 +6,10 @@ pre{
   MARGIN-LEFT: 0pt;
   background-color: #EEEEEE;
 }
+
+/*
+(C) Copyright 2008 Robert Ramey - http://www.rrsd.com . 
+Use, modification and distribution is subject to 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)
+*/

doc/todo.html

@@ -0,0 +1,113 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
+<html>
+<!--
+(C) Copyright 2002-4 Robert Ramey - http://www.rrsd.com . 
+Use, modification and distribution is subject to 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)
+-->
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
+<link rel="stylesheet" type="text/css" href="../../../boost.css">
+<link rel="stylesheet" type="text/css" href="style.css">
+<title>Serialization - To Do</title>
+</head>
+<body link="#0000ff" vlink="#800080">
+<table border="0" cellpadding="7" cellspacing="0" width="100%" summary="header">
+  <tr> 
+    <td valign="top" width="300"> 
+      <h3><a href="../../../index.htm"><img height="86" width="277" alt="C++ Boost" src="../../../boost.png" border="0"></a></h3>
+    </td>
+    <td valign="top"> 
+      <h1 align="center">Serialization</h1>
+      <h2 align="center">To Do</h2>
+    </td>
+  </tr>
+</table>
+<hr>
+<dl class="index">
+  <dt><a href="#portablebinaryarchives">Portable Binary Archives</a></dt>
+  <dt><a href="#performancetesting">Performance Testing and Profiling</a></dt>
+  <dt><a href="#backversioning">Back Versioning</a></dt>
+  <dt><a href="#nortti">Testing for Environments with No RTTI</a></dt>
+  <dt><a href="new_case_studies.html">Additional Case Studies</a></dt>
+</dl>
+
+These are enhancements that the serialization library needs but have not been done.
+Some of these projects, though tricky, are not huge and would be suitable
+for someone who has a limited time to spend on them.  In particular, they
+might be of interest as student projects such as the Google Summer of Code.
+
+<h2><a name="portablebinaryarchives"></a>Portable Binary Archives</h2>
+Currently there is a portable binary archive in the examples directory.
+It is not regularly submitted to the exhaustive boost testing regimen
+but it is tested occasionally and has been used in production code.
+<p>
+Its missing the following:
+<ul>
+  <li>Addition of portable floating point types.  This is not trivial.  In addition to
+  handling floating point types of varying sizes, It requires
+  handling invalid floating point numbers (NaNs) in a portable manner.
+  <li>Some way to test archive portability within the Boost testing regimen.
+  <li>Integration into the Boost testing similar to the other archive classes.
+</ul>
+
+<h2><a name="performancetesting"></a>Performance Testing and Profiling</h2>
+
+I've managed to setup performance profiling using the following:
+<ul>
+  <li>current (as I write this) Boost.Build tools.
+  <li>the gcc compiler.
+  <li>and a shell script - profile.sh
+  <li>library_status program from the tools/regression/src directory
+</ul>
+Invoking profile script produces a 
+<a href="performance_status.html">table</a>
+which shows the results of each test and links to the actual
+profile.
+<p>
+The first thing I did was include some of the serialization library tests.
+It became immediatly apparent that these tests were totally unsuitable
+for performance testing and that new tests needed to be written for this 
+purpose.  These tests would highlight the location of any performance
+bottlenecks in the serialization library.  Whenever I've subjected my
+code in the past to this type of analysis, I've always been suprised
+to find bottlenecks in totally unanticipated places and fixing those
+has always lead to large improvements in performance.  I expect that
+this project would have a huge impact on the utility of the serialization
+library.
+
+<h2><a name="backversioning"></a>Back Versioning</h2>
+
+It has been suggested that a useful feature of the library would be
+the ability to create "older versions" of archives.  Currently,
+the library permits one make programs that are guarenteed
+the ability to load archives with classes of a previous version. 
+But there is not way to save classes in accordance with a
+previous version.  At first I dismissed this a a huge project
+with small demand.  A cursory examination of the code revealed
+that this would not be very difficult.  It would require some
+small changes in code and some additional tests.  Also it
+would require special treatment in the documentation - perhaps
+a case study.
+
+
+<h2><a name="nortti"></a>Environments without RTTI</h2>
+
+I note that some have commented that this library requires RTTI.
+This is not strictly true.  The examples and almost all the
+tests presume the existence of RTTI.  But it should be possible
+to use the library without it.  The example used for testing is an 
+<code style="white-space: normal">extended_typeinfo</code> 
+implemenation which presumes that all classes names have been exported. 
+So, to make this library compatible for platforms without RTTI, 
+a set of tests, examples and new manual section would have to be created
+
+<hr>
+<p>Revised 1 November, 2008 
+<p><i>&copy; Copyright <a href="http://www.rrsd.com">Robert Ramey</a> 2002-2008. 
+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)
+</i></p>
+</body>
+</html>

doc/traits.html

@@ -1,4 +1,4 @@
-<!doctype HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
+<!doctype HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
 <html>
 <!--
 (C) Copyright 2002-4 Robert Ramey - http://www.rrsd.com . 
@@ -33,7 +33,9 @@ http://www.boost.org/LICENSE_1_0.txt)
   <dt><a href="#abstract">Abstract</a>
   <dt><a href="#typeinfo">Type Information Implementation</a>
   <dt><a href="#wrappers">Wrappers</a>
+  <dt><a href="#bitwise">Bitwise Serialization</a>
   <dt><a href="#templates">Template Serialization Traits</a>
+  <dt><a href="#compiletime_messages">Compile Time Warnings and Errors</a>
 </dl>
 Serialization of data depends on the type of the data.  For example, for
 primitive types such as an <code style="white-space: normal">int</code>, it wouldn't make sense to save
@@ -179,7 +181,7 @@ Default tracking traits are:
   That is, addresses of addresses are not tracked by default.
   <li>All current serialization wrappers such as <code style="white-space: normal">boost::serialization::nvp</code>,
   <code style="white-space: normal">track_never</code>.
-  <li>For all other types, <code style="white-space: normal">track_selectivly</code>.
+  <li>For all other types, <code style="white-space: normal">track_selectively</code>.
   That is addresses of serialized objects are tracked if and only if
   one or more of the following is true:
   <ul>
@@ -202,13 +204,23 @@ to automatically track classes used as virtual bases).</i> This
 situation is demonstrated by 
 <a href="../test/test_diamond.cpp" target="test_diamond_cpp">test_diamond.cpp</a>
 included with the library.
+
 <h3><a name="export">Export Key</a></h3>
-When serializing a derived class through a base class pointer, it
-may be convenient to define an external name by which the
-derived class can be identified.  
-<i>(<a target="detail" href="special.html#derivedpointers">Elsewhere</a>
-in this manual, the
-serialization of derived classes is addressed in detail.)</i>
+
+When serializing a derived class through a virtual base class pointer,
+two issues may arise.
+<ul>
+<li> The code in the derived class might never be explicitly
+referred to.  Such code will never be instantiated.
+<p>
+This is addressed by invoking 
+<code style="white-space: normal">BOOST_CLASS_EXPORT_IMPLEMENT(T)</code>
+in the file which defines (implements) the class T.
+This ensures that code for the derived class T will
+be explicity instantiated.
+<li> There needs to be some sort of identifier which can
+be used to select the code to be invoked when the object
+is loaded.
 Standard C++ does implement <code style="white-space: normal">typeid()</code> which can be
 used to return a unique string for the class.  This is not entirely
 statisfactory for our purposes for the following reasons:
@@ -222,43 +234,50 @@ statisfactory for our purposes for the following reasons:
   <li>There might be classes with different names that we want to
   consider equivalent for purposes of of serialization.
 </ul>
-So the header file
-<a href="../../../boost/serialization/export.hpp" target="export_hpp">export.hpp</a>
-includes macro definitions to specify the external string used
-to identify the class. 
-<i>(<b>GUID</b> stands for <b>G</b>lobally <b>U</b>nique <b>ID</b>entfier.)</i>
-<pre><code>
-BOOST_CLASS_EXPORT_GUID(my_class, "my_class_external_identifier")
-</code></pre>
+<p>
+So in the serialization library, this is addressed by invoking
+<code style="white-space: normal">BOOST_CLASS_EXPORT_KEY2(my_class, "my_class_external_identifier")</code>
+in the header file which declares he class.
 In a large majority of applications, the class name works just fine
 for the external identifier string so the following short cut is
-defined
-<pre><code>
-BOOST_CLASS_EXPORT(my_class)
-</code></pre>
-which expands to:
-<pre><code>
-BOOST_CLASS_EXPORT_GUID(my_class, "my_class")
-</code></pre>
-If the an external name is required somewhere in the program and none
-has been assigned, a static assertion will be invoked.
-<h3><a name="abstract">Abstract</a></h3>
-When serializing an object through a pointer to its base class
-and that base class is abstract (i.e. has at least one virtual function
-assigned a value of 0), A compile error will be emitted.  This is
-addressable in one over several ways:
-<ul>
-  <li>remove the =0 in the base classes so that the base class is no
-  longer abstract.
-  <li>implement is_abstract for your compiler. (code written according to
-  the C++ standard is included with this library.  But it is known to fail
-  on several compilers.
-  <li>use the macro <code style="white-space: normal">BOOST_IS_ABSTRACT(my_class)</code> to indicate
-  that the class is an abstract base class.  This will cause the compiler
-  to avoid generating code that causes this error.
-  This macro must be used in the global namespace, with full namespace 
-  qualification of the argument class. 
+defined -
+<code style="white-space: normal">BOOST_CLASS_EXPORT_KEY(my_class)</code>.
 </ul>
+For programs which consist of only one module - that is 
+programs which do not use DLLS, one can specify
+<code style="white-space: normal">BOOST_CLASS_EXPORT(my_class)</code>
+or
+<code style="white-space: normal">BOOST_CLASS_EXPORT_GUID(my_class, "my_class_external_identifier")</code>
+in either he declaration header or definition.  These macros
+expand to invocation of the of both of the macros described above.
+<i>(<b>GUID</b> stands for <b>G</b>lobally <b>U</b>nique <b>ID</b>entfier.)</i>
+<p>
+<i>(<a target="detail" href="special.html#export">Elsewhere</a>
+in this manual, the serialization of derived classes is addressed in detail.)</i>
+<p>
+The header file
+<a href="../../../boost/serialization/export.hpp" target="export_hpp">export.hpp</a>
+contains all macro definitions described here.
+The library will throw a runtime exception if
+<ul>
+<li> A type not explicitly referred to is not exported.
+<li> Serialization code for the same type is instantiated
+in more than one module (or DLL).
+</ul>
+
+<h3><a name="abstract">Abstract</a></h3>
+When serializing an object through a pointer to its base class,
+the library needs to determine whether or not the bas is abstract
+(i.e. has at least one virtual function).  The library uses the
+type trait macro <code style="white-space: normal">BOOST_IS_ABSTRACT(T)</code>
+to do this.  Not all compilers support this type trait and corresponding
+macro.  To address this, the macro <code style="white-space: normal">
+BOOST_SERIALIZATION_ASSUME_ABSTRACT(T)</code> has been
+implemented to permit one to explicitly indicate that a specified
+type is in fact abstract.  This will guarentee that
+<code style="white-space: normal">BOOST_IS_ABSTRACT</code>
+will return the correct value for all compilers.
+
 <h3><a name="typeinfo">Type Information Implementation</a></h3>
 This last trait is also related to the serialization of objects
 through a base class pointer.  The implementation of this facility
@@ -356,7 +375,30 @@ BOOST_CLASS_IS_WRAPPER(my_class)
 </code></pre>
 which expands to the code above.
 
+<h3><a name="bitwise">Bitwise Serialization</a></h3>
+Some simple classes could be serialized just by directly copying all bits
+of the class. This is, in particular, the case for POD data types containing
+no pointer members, and which are neither versioned nor tracked. Some archives, 
+such as non-portable binary archives can make us of this information to 
+substantially speed up serialization.
 
+To indicate the possibility of bitwise serialization the type trait defined 
+in the header
+file <a href="../../../boost/serialization/is_bitwise_serializable.hpp" target="is_bitwise_serializable">is_bitwise_serializable.hpp</a>
+is used:
+<pre><code>
+namespace boost { namespace serialization {
+    template<class T>
+    struct is_bitwise_serializable
+     : public is_arithmetic<T>
+    {};
+} }
+</code></pre>
+is used, and can be specialized for other classes. The specialization
+is made easy by the corresponding macro:
+<pre><code>
+BOOST_IS_BITWISE_SERIALIZABLE(my_class)
+</code></pre>
 
 <h3><a name="templates">Template Serialization Traits</a></h3>
 In some instances it might be convenient to assign serialization traits
@@ -471,6 +513,291 @@ and template parameters should be assigned according to the following table:
 <tr><td><code>IsWrapper</code></td><td><code></code>is the type a wrapper?</td><td><code>mpl::false_<br>mpl::true_</code></td><td><code>mpl::false_</code></td></tr>
 </table>
 
+<h3><a name="compiletime_messages">Compile Time Warnings and Errors</a></h3>
+Some serialization traits can conflict with other ones.  Sometimes these conflicts
+will result in erroneous behavior (E.G. creating of archives which could not be read)
+and other times they represent a probable misconception on the part of the
+library user which could result in suprising behavior.  The extent possible,
+these conflicts are detected at compile time and errors (BOOST_STATIC_ASSERT) 
+or warnings (BOOST_STATIC_WARNING) are generated. The are generated in a
+compiler dependent way manner which should show an chain of instantiation
+to the point where the error/warning is detected.  Without this capability,
+it would be very hard to track down errors or unexpected behavior in library
+usage.  Here is list of the conflicts trapped:
+
+<dl>
+<dt><h2><a name="object_level">object_level</a> - error</h2></dt>
+<dd>
+This error traps attempts to serialize types whose
+implentation level is set to non_serializable.
+</dd>
+<dt><h2><a name="object_versioning">object_versioning</a> - error</h2></dt>
+<dd>
+It's possible that for efficiency reasons, a type can be
+assigned a serialization level which doesn't include type information 
+in the archive.  This would preclude the assignment
+of a new version number to the type.  This error
+traps attempts to assign a version number in this case.
+This has to be a user error.
+</dd>
+
+<dt><h2><a name="object_tracking">object_tracking</a> - warning</h2></dt>
+<dd>
+The following code will display a message when compiled:
+
+<code style="white-space: normal"><pre>
+T t;
+ar &lt;&lt; t;
+</pre></code>
+
+unless the tracking_level serialization trait is set to "track_never". The following
+will compile without problem:
+
+<code style="white-space: normal"><pre>
+const T t
+ar &lt;&lt; t;
+</pre></code>
+
+Likewise, the following code will trap at compile time:
+
+<code style="white-space: normal"><pre>
+T * t;
+ar >> t;
+</pre></code>
+
+if the tracking_level serialization trait is set to "track_never".
+<p>
+
+The following case illustrates the function of this message.
+It was originally used as an example in the
+mailing list by Peter Dimov.
+
+<code style="white-space: normal"><pre>
+class construct_from 
+{ 
+    ... 
+}; 
+
+void main(){ 
+    ... 
+    Y y; 
+    construct_from x(y); 
+    ar &lt;&lt; x; 
+} 
+</pre></code>
+
+Suppose that the above message is not displayed and the code is used as is.
+<ol>
+  <li>this example compiles and executes fine. No tracking is done because 
+  construct_from has never been serialized through a pointer. Now some time 
+  later, the next programmer(2) comes along and makes an enhancement. He 
+  wants the archive to be sort of a log. 
+
+<code style="white-space: normal"><pre>
+void main(){ 
+    ... 
+    Y y; 
+    construct_from x(y); 
+    ar &lt;&lt; x; 
+    ... 
+    x.f(); // change x in some way 
+   ... 
+    ar &lt;&lt; x 
+} 
+</pre></code>
+  <p>
+  Again no problem. He gets two different of copies in the archive, each one is different. 
+  That is he gets exactly what he expects and is naturally delighted. 
+  <p>
+  <li>Now sometime later, a third programmer(3) sees construct_from and says - 
+  oh cool, just what I need. He writes a function in a totally disjoint 
+  module. (The project is so big, he doesn't even realize the existence of 
+  the original usage) and writes something like: 
+
+<code style="white-space: normal"><pre>
+class K { 
+    shared_ptr &lt;construct_from&gt; z; 
+    template &lt;class Archive&gt; 
+    void serialize(Archive & ar, const unsigned version){ 
+        ar &lt;&lt; z; 
+    } 
+}; 
+</pre></code>
+
+  <p>
+  He builds and runs the program and tests his new functionality. It works 
+  great and he's delighted. 
+  <p>
+  <li>Things continue smoothly as before.  A month goes by and it's 
+  discovered that when loading the archives made in the last month (reading the 
+  log). Things don't work. The second log entry is always the same as the 
+  first. After a series of very long and increasingly acrimonius email exchanges, 
+its discovered 
+  that programmer (3) accidently broke programmer(2)'s code .This is because by 
+  serializing via a pointer, the "log" object now being tracked.  This is because
+  the default tracking behavior is "track_selectively".  This means that class
+  instances are tracked only if they are serialized through pointers anywhere in
+  the program. Now multiple saves from the same address result in only the first one 
+  being written to the archive. Subsequent saves only add the address - even though the 
+  data might have been changed.  When it comes time to load the data, all instances of the log record show the same data.
+  In this way, the behavior of a functioning piece of code is changed due the side
+  effect of a change in an otherwise disjoint module.
+  Worse yet, the data has been lost and cannot not be now recovered from the archives.
+  People are really upset and disappointed with boost (at least the serialization system).
+  <p>
+  <li>
+  After a lot of investigation, it's discovered what the source of the problem
+  and class construct_from is marked "track_never" by including:
+<code style="white-space: normal"><pre>
+BOOST_CLASS_TRACKING(construct_from, track_never) 
+</pre></code>
+  <li>Now everything works again. Or - so it seems.
+  <p>
+  <li><code style="white-space: normal">shared_ptr&lt;construct_from&gt;</code>
+is not going to have a single raw pointer shared amongst the instances. Each loaded 
+<code style="white-space: normal">shared_ptr&lt;construct_from&gt;</code> is going to 
+have its own distinct raw pointer. This will break 
+<code style="white-space: normal">shared_ptr</code> and cause a memory leak.  Again,
+The cause of this problem is very far removed from the point of discovery.  It could 
+well be that the problem is not even discovered until after the archives are loaded.
+Now we not only have difficult to find and fix program bug, but we have a bunch of
+invalid archives and lost data.
+</ol>
+
+<p>Now consider what happens when the message is displayed:
+
+<ol>
+  <p>
+  <li>Right away, the program traps at 
+<code style="white-space: normal"><pre>
+ar &lt;&lt; x; 
+</pre></code>
+  <p>
+  <li>The programmer curses (another %^&*&* hoop to jump through). If he's in a 
+  hurry (and who isn't) and would prefer not to <code style="white-space: normal">const_cast</code>
+  - because it looks bad.  So he'll just make the following change an move on. 
+<code style="white-space: normal"><pre>
+Y y; 
+const construct_from x(y); 
+ar &lt;&lt; x; 
+</pre></code>
+  <p>
+  Things work fine and he moves on. 
+  <p>
+  <li>Now programer (2) wants to make his change - and again another 
+  annoying const issue; 
+<code style="white-space: normal"><pre>
+Y y; 
+const construct_from x(y); 
+... 
+x.f(); // change x in some way ; compile error f() is not const 
+... 
+ar &lt;&lt; x 
+</pre></code>
+  <p>
+  He's mildly annoyed now he tries the following: 
+  <ul>
+    <li>He considers making f() a const - but presumable that shifts the const 
+    error to somewhere else. And his doesn't want to fiddle with "his" code to 
+    work around a quirk in the serializaition system 
+    <p>
+    <li>He removes the <code style="white-space: normal">const</code>
+    from <code style="white-space: normal">const construct_from</code> above - damn now he 
+    gets the trap. If he looks at the comment code where the 
+    <code style="white-space: normal">BOOST_STATIC_ASSERT</code>
+    occurs, he'll do one of two things 
+    <ol>
+      <p>
+      <li>This is just crazy. Its making my life needlessly difficult and flagging 
+      code that is just fine. So I'll fix this with a <code style="white-space: normal">const_cast</code>
+      and fire off a complaint to the list and mabe they will fix it. 
+      In this case, the story branches off to the previous scenario.
+      <p>
+      <li>Oh, this trap is suggesting that the default serialization isn't really 
+      what I want. Of course in this particular program it doesn't matter. But 
+      then the code in the trap can't really evaluate code in other modules (which 
+      might not even be written yet). OK, I'll add the following to my 
+      construct_from.hpp to solve the problem. 
+<code style="white-space: normal"><pre>
+BOOST_CLASS_TRACKING(construct_from, track_never) 
+</pre></code>
+    </ol>
+  </ul>
+  <p>
+  <li>Now programmer (3) comes along and make his change. The behavior of the 
+  original (and distant module) remains unchanged because the 
+  <code style="white-space: normal">construct_from</code> trait has been set to 
+  "track_never" so he should always get copies and the log should be what we expect.
+  <p>
+  <li>But now he gets another trap - trying to save an object of a 
+  class marked "track_never" through a pointer. So he goes back to 
+  construct_from.hpp and comments out the 
+  <code style="white-space: normal">BOOST_CLASS_TRACKING</code> that 
+  was inserted. Now the second trap is avoided, But damn - the first trap is 
+  popping up again. Eventually, after some code restructuring, the differing
+  requirements of serializating <code style="white-space: normal">construct_from</code>
+  are reconciled.
+</ol>
+Note that in this second scenario
+<ul>
+  <li>all errors are trapped at compile time.
+  <li>no invalid archives are created.
+  <li>no data is lost.
+  <li>no runtime errors occur.
+</ul>
+
+It's true that these messages may sometimes flag code that is currently correct and
+that this may be annoying to some programmers.  However, this example illustrates
+my view that these messages are useful and that any such annoyance is small price to
+pay to avoid particularly vexing programming errors.
+
+</dd>
+
+<dt><h2><a name="pointer_level">pointer_level</a> - warning</h2></dt>
+<dd>
+This trap addresses the following situaion when serializing 
+a pointer:
+<ul>
+<li>A type doesn't save class information in the
+archive. That is, the serialization trait implementation
+level <= object_serializable.
+<li>Tracking for this type is set to "track selectively"
+in this case, indication that an object is tracked is
+not stored in the archive itself - see level == object_serializable.
+Since class information is not saved in the archive, the existence
+or absense of the operation ar << T * anywhere else in the 
+program is used to infer that an object of this type should be tracked.
+<p>
+A problem arises when a program which reads an archive
+includes the operation ar >> T * so that tracking information
+will be included in the archive. When a program which
+creates the archive doesn't include ar << T it is presumed
+that the archive doesn't include tracking information and
+the archive will fail to load.  Also the reverse situation could 
+trigger a similar problem.
+<p>
+Though this situation is unlikely for several reasones, 
+it is possible - hence this warning. 
+</ul>
+So if your program traps here, consider changing the 
+tracking or implementation level traits - or not
+serializing via a pointer.
+</dd>
+
+<dt><h2><a name="pointer_tracking">pointer_tracking</a> - warning</h2></dt>
+<dd>
+Serializing an object of a type marked "track_never" through a pointer
+could result in creating more objects than were saved! There are cases
+in which a user might really want to do this so we leave it as a warning.
+</dd>
+
+<dt><h2><a name="const_loading">const_loading</a> - error</h2></dt>
+<dd>
+One cannot load data into a "const" object unless it's a
+wrapper around some other non-const object.
+</dd>
+</dl>
+
 <hr>
 <p><i>&copy; Copyright <a href="http://www.rrsd.com">Robert Ramey</a> 2002-2004 and Matthias Troyer 2006. 
 Distributed under the Boost Software License, Version 1.0. (See

doc/tutorial.html

@@ -123,7 +123,7 @@ int main() {
     gps_position newg;
     {
         // create and open an archive for input
-        std::ifstream ifs("filename", std::ios::binary);
+        std::ifstream ifs("filename");
         boost::archive::text_iarchive ia(ifs);
         // read class state from archive
         ia >> newg;

doc/void_cast.html

@@ -44,8 +44,8 @@ They are declared in the namespace
 template<class Derived, class Base>
 const void_cast_detail::void_caster &
 void_cast_register(
-    const Derived * derived = NULL, 
-    const Base * base = NULL
+    Derived const * derived = NULL, 
+    Base * const base = NULL
 )
 </code></pre></h4></dt>
 <dd>

example/Jamfile

@@ -1,41 +0,0 @@
-# Boost serialization Library Build Jamfile
-#  (C) Copyright Robert Ramey 2002-2004.
-#  Use, modification, and distribution are subject to 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)
-#
-#  See http://www.boost.org/libs/serialization for the library home page.
-
-subproject libs/serialization/example ;
-
-rule demo-bsl-build ( demo-name )
-{
-    exe $(demo-name)
-        : # sources
-            $(demo-name).cpp
-            <lib>../build/boost_serialization
-        : # requirements
-            # copy to a path rooted at BOOST_ROOT:
-            <locate>$(BOOST_ROOT)
-            <include>$(BOOST_ROOT)  
-            <sysinclude>$(BOOST_ROOT)
-            <borland><*><cxxflags>-w-8080
-            <msvc><release><cxxflags>-Gy
-            <vc7><release><cxxflags>-Gy
-            <vc-7_0><release><cxxflags>-Gy
-            <vc-7_1><release><cxxflags>-Gy
-        : # default build
-            debug
-    ;
-}
-
-demo-bsl-build demo ;
-demo-bsl-build demo_auto_ptr ;
-demo-bsl-build demo_exception ;
-demo-bsl-build demo_fast_archive ;
-demo-bsl-build demo_pimpl ;
-demo-bsl-build demo_portable_archive ;
-demo-bsl-build demo_shared_ptr ;
-demo-bsl-build demo_xml ;
-demo-bsl-build demo_xml_save ;
-demo-bsl-build demo_xml_load ;

example/Jamfile.v2

@@ -0,0 +1,57 @@
+# Boost serialization Library Build Jamfile
+#  (C) Copyright Robert Ramey 2002-2004.
+#  Use, modification, and distribution are subject to 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)
+#
+#  See http://www.boost.org/libs/serialization for the library home page.
+
+project libs/serialization/example
+    : id serialization_example
+    : requirements <library>../build//boost_serialization
+    ;
+
+rule demo_bsl_run ( demo-name : othersources * : requirements * )
+{
+    return [ run
+        # sources
+            $(demo-name).cpp 
+            $(othersources).cpp
+        : # command
+        : # input files
+        : # requirements
+            # toolset suppress-warnings
+            <toolset>gcc:<cxxflags>"-Wno-non-virtual-dtor -Wno-ctor-dtor-privacy"
+            <toolset>msvc-8.0:<cxxflags>"-wd4996"
+            <toolset>borland:<cxxflags>"-w-8080 -w-8071 -w-8057 -w-8062 -w-8008 -w-0018 -w-8066"
+            # toolset optimizations
+            <toolset>gcc:<cxxflags>"-ftemplate-depth-255"
+            <toolset>msvc:<cxxflags>"-Gy"
+            # toolset shared library support
+            <toolset>como,<runtime-link>shared:<build>no
+            <toolset>msvc,<stdlib>stlport,<runtime-link>shared:<build>no
+            <toolset>cw,<runtime-link>static:<build>no
+            $(requirements)
+         : # test name
+            $(demo-name)
+       ]
+    ;
+}
+
+test-suite "demo-suite" :
+    # demos
+    [ demo_bsl_run demo ]
+    [ demo_bsl_run demo_auto_ptr ]
+    [ demo_bsl_run demo_exception ]
+    [ demo_bsl_run demo_log : log_archive ]
+    [ demo_bsl_run demo_pimpl : demo_pimpl_A ]
+    [ demo_bsl_run demo_polymorphic : demo_polymorphic_A ]
+    [ demo_bsl_run demo_portable_archive : portable_binary_iarchive portable_binary_oarchive ]
+    [ demo_bsl_run demo_shared_ptr ]
+    [ demo_bsl_run demo_simple_log ]
+    [ demo_bsl_run demo_trivial_archive ]
+    [ demo_bsl_run demo_xml ]
+    [ demo_bsl_run demo_xml_save ]
+    [ demo_bsl_run demo_xml_load : : <dependency>demo_xml_save ]
+;
+

example/demo.cpp

@@ -7,6 +7,7 @@
 // http://www.boost.org/LICENSE_1_0.txt)
 
 
+#include <cstddef> // NULL
 #include <iomanip>
 #include <iostream>
 #include <fstream>
@@ -20,7 +21,7 @@
 #include <boost/serialization/base_object.hpp>
 #include <boost/serialization/utility.hpp>
 #include <boost/serialization/list.hpp>
-#include <boost/serialization/is_abstract.hpp>
+#include <boost/serialization/assume_abstract.hpp>
 
 /////////////////////////////////////////////////////////////
 // The intent of this program is to serve as a tutorial for
@@ -93,7 +94,7 @@ public:
     virtual ~bus_stop(){}
 };
 
-BOOST_IS_ABSTRACT(bus_stop)
+BOOST_SERIALIZATION_ASSUME_ABSTRACT(bus_stop)
 
 std::ostream & operator<<(std::ostream &os, const bus_stop &bs)
 {
@@ -264,7 +265,7 @@ public:
     }
     bus_schedule(){}
 };
-BOOST_CLASS_VERSION(bus_schedule, 2)
+BOOST_CLASS_VERSION(bus_schedule::trip_info, 2)
 
 std::ostream & operator<<(std::ostream &os, const bus_schedule::trip_info &ti)
 {

example/demo_dll.cpp

@@ -0,0 +1,50 @@
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// test_derived_class.cpp
+
+// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
+// Use, modification and distribution is subject to 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)
+
+// should pass compilation and execution
+
+#include <cstddef> // NULL
+#include <fstream>
+
+#include <cstdio> // remove
+#include <boost/config.hpp>
+#if defined(BOOST_NO_STDC_NAMESPACE)
+namespace std{ 
+    using ::remove;
+}
+#endif
+
+#include "test_tools.hpp"
+
+#include "B.hpp"
+#include "A.ipp"
+
+int test_main( int argc, char* argv[] )
+{
+  const char * testfile = boost::archive::tmpnam(NULL);
+  
+  BOOST_REQUIRE(NULL != testfile);
+
+    B b, b1;
+
+    {   
+        test_ostream os(testfile, TEST_STREAM_FLAGS);
+        test_oarchive oa(os, TEST_ARCHIVE_FLAGS);
+        oa << boost::serialization::make_nvp("b", b);
+    }
+    {
+        test_istream is(testfile, TEST_STREAM_FLAGS);
+        test_iarchive ia(is, TEST_ARCHIVE_FLAGS);
+        ia >> boost::serialization::make_nvp("b1", b1);
+    }
+    BOOST_CHECK(b == b1);
+    std::remove(testfile);
+    return EXIT_SUCCESS;
+}
+
+// EOF

example/demo_dll_a.hpp

@@ -0,0 +1,321 @@
+#ifndef BOOST_SERIALIZATION_TEST_A_HPP
+#define BOOST_SERIALIZATION_TEST_A_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+# pragma once
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// A.hpp    simple class test
+
+// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
+// Use, modification and distribution is subject to 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)
+
+//  See http://www.boost.org for updates, documentation, and revision history.
+
+#include <cassert>
+#include <cstdlib> // for rand()
+#include <cmath> // for fabs()
+#include <cstddef> // size_t
+
+#include <boost/config.hpp>
+#if defined(BOOST_NO_STDC_NAMESPACE)
+namespace std{
+    using ::rand; 
+    using ::fabs;
+    using ::size_t;
+}
+#endif
+
+//#include <boost/test/test_exec_monitor.hpp>
+#include <boost/limits.hpp>
+#include <boost/cstdint.hpp>
+
+#include <boost/detail/workaround.hpp>
+#if BOOST_WORKAROUND(BOOST_DINKUMWARE_STDLIB, == 1)
+#include <boost/archive/dinkumware.hpp>
+#endif
+
+#include <boost/serialization/nvp.hpp>
+#include <boost/serialization/string.hpp>
+#include <boost/serialization/access.hpp>
+
+class A
+{
+private:
+    friend class boost::serialization::access;
+    // note: from an aesthetic perspective, I would much prefer to have this
+    // defined out of line.  Unfortunately, this trips a bug in the VC 6.0
+    // compiler. So hold our nose and put it her to permit running of tests.
+    template<class Archive>
+    void serialize(
+        Archive &ar,
+        const unsigned int /* file_version */
+    ){
+        ar & BOOST_SERIALIZATION_NVP(b);
+        #ifndef BOOST_NO_INT64_T
+        ar & BOOST_SERIALIZATION_NVP(f);
+        ar & BOOST_SERIALIZATION_NVP(g);
+        #endif
+        #if BOOST_WORKAROUND(__BORLANDC__,  <= 0x551 )
+            int i;
+            if(BOOST_DEDUCED_TYPENAME Archive::is_saving::value){
+                i = l;
+                ar & BOOST_SERIALIZATION_NVP(i);
+            }
+            else{
+                ar & BOOST_SERIALIZATION_NVP(i);
+                l = i;
+            }
+        #else
+            ar & BOOST_SERIALIZATION_NVP(l);
+        #endif
+        ar & BOOST_SERIALIZATION_NVP(m);
+        ar & BOOST_SERIALIZATION_NVP(n);
+        ar & BOOST_SERIALIZATION_NVP(o);
+        ar & BOOST_SERIALIZATION_NVP(p);
+        ar & BOOST_SERIALIZATION_NVP(q);
+        #ifndef BOOST_NO_CWCHAR
+        ar & BOOST_SERIALIZATION_NVP(r);
+        #endif
+        ar & BOOST_SERIALIZATION_NVP(c);
+        ar & BOOST_SERIALIZATION_NVP(s);
+        ar & BOOST_SERIALIZATION_NVP(t);
+        ar & BOOST_SERIALIZATION_NVP(u);
+        ar & BOOST_SERIALIZATION_NVP(v);
+        ar & BOOST_SERIALIZATION_NVP(w);
+        ar & BOOST_SERIALIZATION_NVP(x);
+        ar & BOOST_SERIALIZATION_NVP(y);
+        #ifndef BOOST_NO_STD_WSTRING
+        ar & BOOST_SERIALIZATION_NVP(z);
+        #endif
+    }
+    bool b;
+    #ifndef BOOST_NO_INT64_T
+    boost::int64_t f;
+    boost::uint64_t g;
+    #endif
+    enum h {
+        i = 0,
+        j,
+        k
+    } l;
+    std::size_t m;
+    signed long n;
+    unsigned long o;
+    signed  short p;
+    unsigned short q;
+    #ifndef BOOST_NO_CWCHAR
+    wchar_t r;
+    #endif
+    char c;
+    signed char s;
+    unsigned char t;
+    signed int u;
+    unsigned int v;
+    float w;
+    double x;
+    std::string y;
+    #ifndef BOOST_NO_STD_WSTRING
+    std::wstring z;
+    #endif
+public:
+    A();
+    bool operator==(const A &rhs) const;
+    bool operator!=(const A &rhs) const;
+    bool operator<(const A &rhs) const; // used by less
+    // hash function for class A
+    operator std::size_t () const;
+    friend std::ostream & operator<<(std::ostream & os, A const & a);
+    friend std::istream & operator>>(std::istream & is, A & a);
+};
+
+//BOOST_TEST_DONT_PRINT_LOG_VALUE(A);
+
+template<class S>
+void randomize(S &x)
+{
+    assert(0 == x.size());
+    for(;;){
+        unsigned int i = std::rand() % 27;
+        if(0 == i)
+            break;
+        x += static_cast<BOOST_DEDUCED_TYPENAME S::value_type>('a' - 1 + i);
+    }
+}
+
+template<class T>
+void accumulate(std::size_t & s, const T & t){
+    const char * tptr = (const char *)(& t);
+    unsigned int count = sizeof(t);
+    while(count-- > 0){
+        s += *tptr++;
+    }
+}
+
+A::operator std::size_t () const {
+    std::size_t retval = 0;
+    accumulate(retval, b);
+    #ifndef BOOST_NO_INT64_T
+    accumulate(retval, f);
+    accumulate(retval, g);
+    #endif
+    accumulate(retval, l);
+    accumulate(retval, m);
+    accumulate(retval, n);
+    accumulate(retval, o);
+    accumulate(retval, p);
+    accumulate(retval, q);
+    #ifndef BOOST_NO_CWCHAR
+    accumulate(retval, r);
+    #endif
+    accumulate(retval, c);
+    accumulate(retval, s);
+    accumulate(retval, t);
+    accumulate(retval, u);
+    accumulate(retval, v);
+    return retval;
+}
+
+inline A::A() :
+    b(true),
+    #ifndef BOOST_NO_INT64_T
+    f(std::rand() * std::rand()),
+    g(std::rand() * std::rand()),
+    #endif
+    l(static_cast<enum h>(std::rand() % 3)),
+    m(std::rand()),
+    n(std::rand()),
+    o(std::rand()),
+    p(std::rand()),
+    q(std::rand()),
+    #ifndef BOOST_NO_CWCHAR
+    r(std::rand()),
+    #endif
+    c(std::rand()),
+    s(std::rand()),
+    t(std::rand()),
+    u(std::rand()),
+    v(std::rand()),
+    w((float)std::rand()),
+    x((double)std::rand())
+{
+    randomize(y);
+    #ifndef BOOST_NO_STD_WSTRING
+    randomize(z);
+    #endif
+}
+
+inline bool A::operator==(const A &rhs) const
+{
+    if(b != rhs.b)
+        return false;
+    if(l != rhs.l)
+        return false;
+    #ifndef BOOST_NO_INT64_T
+    if(f != rhs.f)
+        return false;
+    if(g != rhs.g)
+        return false;
+    #endif
+    if(m != rhs.m)
+        return false;
+    if(n != rhs.n)
+        return false;
+    if(o != rhs.o)
+        return false;
+    if(p != rhs.p)
+        return false; 
+    if(q != rhs.q)
+        return false;
+    #ifndef BOOST_NO_CWCHAR
+    if(r != rhs.r)
+        return false; 
+    #endif
+    if(c != rhs.c)
+        return false;
+    if(s != rhs.s)
+        return false;
+    if(t != rhs.t)
+        return false;
+    if(u != rhs.u)
+        return false; 
+    if(v != rhs.v)
+        return false; 
+    if(w == 0 && std::fabs(rhs.w) > std::numeric_limits<float>::epsilon())
+        return false;
+    if(std::fabs(rhs.w/w - 1.0) > std::numeric_limits<float>::epsilon())
+        return false;
+    if(x == 0 && std::fabs(rhs.x - x) > std::numeric_limits<float>::epsilon())
+        return false;
+    if(std::fabs(rhs.x/x - 1.0) > std::numeric_limits<float>::epsilon())
+        return false;
+    if(0 != y.compare(rhs.y))
+        return false;
+    #ifndef BOOST_NO_STD_WSTRING
+    if(0 != z.compare(rhs.z))
+        return false;
+    #endif      
+    return true;
+}
+
+inline bool A::operator!=(const A &rhs) const
+{
+    return ! (*this == rhs);
+}
+
+inline bool A::operator<(const A &rhs) const
+{
+    if(b != rhs.b)
+        return b < rhs.b;
+    #ifndef BOOST_NO_INT64_T
+    if(f != rhs.f)
+        return f < rhs.f;
+    if(g != rhs.g)
+        return g < rhs.g;
+    #endif
+    if(l != rhs.l )
+        return l < rhs.l;
+    if(m != rhs.m )
+        return m < rhs.m;
+    if(n != rhs.n )
+        return n < rhs.n;
+    if(o != rhs.o )
+        return o < rhs.o;
+    if(p != rhs.p )
+        return p < rhs.p;
+    if(q != rhs.q )
+        return q < rhs.q;
+    #ifndef BOOST_NO_CWCHAR
+    if(r != rhs.r )
+        return r < rhs.r;
+    #endif
+    if(c != rhs.c )
+        return c < rhs.c;
+    if(s != rhs.s )
+        return s < rhs.s;
+    if(t != rhs.t )
+        return t < rhs.t;
+    if(u != rhs.u )
+        return u < rhs.u; 
+    if(v != rhs.v )
+        return v < rhs.v;
+    if(w != rhs.w )
+        return w < rhs.w; 
+    if(x != rhs.x )
+        return x < rhs.x;
+    int i = y.compare(rhs.y);
+    if(i !=  0 )
+        return i < 0;
+    #ifndef BOOST_NO_STD_WSTRING
+    int j = z.compare(rhs.z);
+    if(j !=  0 )
+        return j < 0;
+    #endif
+    return false;
+}
+
+#endif // BOOST_SERIALIZATION_TEST_A_HPP

example/demo_dll_a.ipp

@@ -0,0 +1,321 @@
+#ifndef BOOST_SERIALIZATION_TEST_A_HPP
+#define BOOST_SERIALIZATION_TEST_A_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+# pragma once
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// A.hpp    simple class test
+
+// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
+// Use, modification and distribution is subject to 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)
+
+//  See http://www.boost.org for updates, documentation, and revision history.
+
+#include <cassert>
+#include <cstdlib> // for rand()
+#include <cmath> // for fabs()
+#include <cstddef> // size_t
+
+#include <boost/config.hpp>
+#if defined(BOOST_NO_STDC_NAMESPACE)
+namespace std{
+    using ::rand; 
+    using ::fabs;
+    using ::size_t;
+}
+#endif
+
+//#include <boost/test/test_exec_monitor.hpp>
+#include <boost/limits.hpp>
+#include <boost/cstdint.hpp>
+
+#include <boost/detail/workaround.hpp>
+#if BOOST_WORKAROUND(BOOST_DINKUMWARE_STDLIB, == 1)
+#include <boost/archive/dinkumware.hpp>
+#endif
+
+#include <boost/serialization/nvp.hpp>
+#include <boost/serialization/string.hpp>
+#include <boost/serialization/access.hpp>
+
+class A
+{
+private:
+    friend class boost::serialization::access;
+    // note: from an aesthetic perspective, I would much prefer to have this
+    // defined out of line.  Unfortunately, this trips a bug in the VC 6.0
+    // compiler. So hold our nose and put it her to permit running of tests.
+    template<class Archive>
+    void serialize(
+        Archive &ar,
+        const unsigned int /* file_version */
+    ){
+        ar & BOOST_SERIALIZATION_NVP(b);
+        #ifndef BOOST_NO_INT64_T
+        ar & BOOST_SERIALIZATION_NVP(f);
+        ar & BOOST_SERIALIZATION_NVP(g);
+        #endif
+        #if BOOST_WORKAROUND(__BORLANDC__,  <= 0x551 )
+            int i;
+            if(BOOST_DEDUCED_TYPENAME Archive::is_saving::value){
+                i = l;
+                ar & BOOST_SERIALIZATION_NVP(i);
+            }
+            else{
+                ar & BOOST_SERIALIZATION_NVP(i);
+                l = i;
+            }
+        #else
+            ar & BOOST_SERIALIZATION_NVP(l);
+        #endif
+        ar & BOOST_SERIALIZATION_NVP(m);
+        ar & BOOST_SERIALIZATION_NVP(n);
+        ar & BOOST_SERIALIZATION_NVP(o);
+        ar & BOOST_SERIALIZATION_NVP(p);
+        ar & BOOST_SERIALIZATION_NVP(q);
+        #ifndef BOOST_NO_CWCHAR
+        ar & BOOST_SERIALIZATION_NVP(r);
+        #endif
+        ar & BOOST_SERIALIZATION_NVP(c);
+        ar & BOOST_SERIALIZATION_NVP(s);
+        ar & BOOST_SERIALIZATION_NVP(t);
+        ar & BOOST_SERIALIZATION_NVP(u);
+        ar & BOOST_SERIALIZATION_NVP(v);
+        ar & BOOST_SERIALIZATION_NVP(w);
+        ar & BOOST_SERIALIZATION_NVP(x);
+        ar & BOOST_SERIALIZATION_NVP(y);
+        #ifndef BOOST_NO_STD_WSTRING
+        ar & BOOST_SERIALIZATION_NVP(z);
+        #endif
+    }
+    bool b;
+    #ifndef BOOST_NO_INT64_T
+    boost::int64_t f;
+    boost::uint64_t g;
+    #endif
+    enum h {
+        i = 0,
+        j,
+        k
+    } l;
+    std::size_t m;
+    signed long n;
+    unsigned long o;
+    signed  short p;
+    unsigned short q;
+    #ifndef BOOST_NO_CWCHAR
+    wchar_t r;
+    #endif
+    char c;
+    signed char s;
+    unsigned char t;
+    signed int u;
+    unsigned int v;
+    float w;
+    double x;
+    std::string y;
+    #ifndef BOOST_NO_STD_WSTRING
+    std::wstring z;
+    #endif
+public:
+    A();
+    bool operator==(const A &rhs) const;
+    bool operator!=(const A &rhs) const;
+    bool operator<(const A &rhs) const; // used by less
+    // hash function for class A
+    operator std::size_t () const;
+    friend std::ostream & operator<<(std::ostream & os, A const & a);
+    friend std::istream & operator>>(std::istream & is, A & a);
+};
+
+//BOOST_TEST_DONT_PRINT_LOG_VALUE(A);
+
+template<class S>
+void randomize(S &x)
+{
+    assert(0 == x.size());
+    for(;;){
+        unsigned int i = std::rand() % 27;
+        if(0 == i)
+            break;
+        x += static_cast<BOOST_DEDUCED_TYPENAME S::value_type>('a' - 1 + i);
+    }
+}
+
+template<class T>
+void accumulate(std::size_t & s, const T & t){
+    const char * tptr = (const char *)(& t);
+    unsigned int count = sizeof(t);
+    while(count-- > 0){
+        s += *tptr++;
+    }
+}
+
+A::operator std::size_t () const {
+    std::size_t retval = 0;
+    accumulate(retval, b);
+    #ifndef BOOST_NO_INT64_T
+    accumulate(retval, f);
+    accumulate(retval, g);
+    #endif
+    accumulate(retval, l);
+    accumulate(retval, m);
+    accumulate(retval, n);
+    accumulate(retval, o);
+    accumulate(retval, p);
+    accumulate(retval, q);
+    #ifndef BOOST_NO_CWCHAR
+    accumulate(retval, r);
+    #endif
+    accumulate(retval, c);
+    accumulate(retval, s);
+    accumulate(retval, t);
+    accumulate(retval, u);
+    accumulate(retval, v);
+    return retval;
+}
+
+inline A::A() :
+    b(true),
+    #ifndef BOOST_NO_INT64_T
+    f(std::rand() * std::rand()),
+    g(std::rand() * std::rand()),
+    #endif
+    l(static_cast<enum h>(std::rand() % 3)),
+    m(std::rand()),
+    n(std::rand()),
+    o(std::rand()),
+    p(std::rand()),
+    q(std::rand()),
+    #ifndef BOOST_NO_CWCHAR
+    r(std::rand()),
+    #endif
+    c(std::rand()),
+    s(std::rand()),
+    t(std::rand()),
+    u(std::rand()),
+    v(std::rand()),
+    w((float)std::rand()),
+    x((double)std::rand())
+{
+    randomize(y);
+    #ifndef BOOST_NO_STD_WSTRING
+    randomize(z);
+    #endif
+}
+
+inline bool A::operator==(const A &rhs) const
+{
+    if(b != rhs.b)
+        return false;
+    if(l != rhs.l)
+        return false;
+    #ifndef BOOST_NO_INT64_T
+    if(f != rhs.f)
+        return false;
+    if(g != rhs.g)
+        return false;
+    #endif
+    if(m != rhs.m)
+        return false;
+    if(n != rhs.n)
+        return false;
+    if(o != rhs.o)
+        return false;
+    if(p != rhs.p)
+        return false; 
+    if(q != rhs.q)
+        return false;
+    #ifndef BOOST_NO_CWCHAR
+    if(r != rhs.r)
+        return false; 
+    #endif
+    if(c != rhs.c)
+        return false;
+    if(s != rhs.s)
+        return false;
+    if(t != rhs.t)
+        return false;
+    if(u != rhs.u)
+        return false; 
+    if(v != rhs.v)
+        return false; 
+    if(w == 0 && std::fabs(rhs.w) > std::numeric_limits<float>::epsilon())
+        return false;
+    if(std::fabs(rhs.w/w - 1.0) > std::numeric_limits<float>::epsilon())
+        return false;
+    if(x == 0 && std::fabs(rhs.x - x) > std::numeric_limits<float>::epsilon())
+        return false;
+    if(std::fabs(rhs.x/x - 1.0) > std::numeric_limits<float>::epsilon())
+        return false;
+    if(0 != y.compare(rhs.y))
+        return false;
+    #ifndef BOOST_NO_STD_WSTRING
+    if(0 != z.compare(rhs.z))
+        return false;
+    #endif      
+    return true;
+}
+
+inline bool A::operator!=(const A &rhs) const
+{
+    return ! (*this == rhs);
+}
+
+inline bool A::operator<(const A &rhs) const
+{
+    if(b != rhs.b)
+        return b < rhs.b;
+    #ifndef BOOST_NO_INT64_T
+    if(f != rhs.f)
+        return f < rhs.f;
+    if(g != rhs.g)
+        return g < rhs.g;
+    #endif
+    if(l != rhs.l )
+        return l < rhs.l;
+    if(m != rhs.m )
+        return m < rhs.m;
+    if(n != rhs.n )
+        return n < rhs.n;
+    if(o != rhs.o )
+        return o < rhs.o;
+    if(p != rhs.p )
+        return p < rhs.p;
+    if(q != rhs.q )
+        return q < rhs.q;
+    #ifndef BOOST_NO_CWCHAR
+    if(r != rhs.r )
+        return r < rhs.r;
+    #endif
+    if(c != rhs.c )
+        return c < rhs.c;
+    if(s != rhs.s )
+        return s < rhs.s;
+    if(t != rhs.t )
+        return t < rhs.t;
+    if(u != rhs.u )
+        return u < rhs.u; 
+    if(v != rhs.v )
+        return v < rhs.v;
+    if(w != rhs.w )
+        return w < rhs.w; 
+    if(x != rhs.x )
+        return x < rhs.x;
+    int i = y.compare(rhs.y);
+    if(i !=  0 )
+        return i < 0;
+    #ifndef BOOST_NO_STD_WSTRING
+    int j = z.compare(rhs.z);
+    if(j !=  0 )
+        return j < 0;
+    #endif
+    return false;
+}
+
+#endif // BOOST_SERIALIZATION_TEST_A_HPP

example/demo_dll_b.hpp

@@ -0,0 +1,112 @@
+#ifndef BOOST_SERIALIZATION_TEST_B_HPP
+#define BOOST_SERIALIZATION_TEST_B_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+# pragma once
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// B.hpp
+
+// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
+// Use, modification and distribution is subject to 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)
+
+//  See http://www.boost.org for updates, documentation, and revision history.
+
+#include <cstdlib> // for rand()
+
+#include <boost/config.hpp>
+#if defined(BOOST_NO_STDC_NAMESPACE)
+namespace std{
+    using ::rand; 
+}
+#endif
+
+#include <boost/serialization/version.hpp>
+#include <boost/serialization/split_member.hpp>
+#include <boost/serialization/base_object.hpp>
+
+#include "A.hpp"
+
+///////////////////////////////////////////////////////
+// Derived class test
+class B : public A
+{
+private:
+    friend class boost::serialization::access;
+    template<class Archive>
+    void save(Archive &ar, const unsigned int /* file_version */) const
+    {
+        // write any base class info to the archive
+        ar << BOOST_SERIALIZATION_BASE_OBJECT_NVP(A);
+
+        // write out members
+        ar << BOOST_SERIALIZATION_NVP(s);
+        ar << BOOST_SERIALIZATION_NVP(t);
+        ar << BOOST_SERIALIZATION_NVP(u);
+        ar << BOOST_SERIALIZATION_NVP(v);
+        ar << BOOST_SERIALIZATION_NVP(w);
+        ar << BOOST_SERIALIZATION_NVP(x);
+    }
+
+    template<class Archive>
+    void load(Archive & ar, const unsigned int file_version)
+    {
+        // read any base class info to the archive
+        ar >> BOOST_SERIALIZATION_BASE_OBJECT_NVP(A);
+        switch(file_version){
+        case 1:
+        case 2:
+            ar >> BOOST_SERIALIZATION_NVP(s);
+            ar >> BOOST_SERIALIZATION_NVP(t);
+            ar >> BOOST_SERIALIZATION_NVP(u);
+            ar >> BOOST_SERIALIZATION_NVP(v);
+            ar >> BOOST_SERIALIZATION_NVP(w);
+            ar >> BOOST_SERIALIZATION_NVP(x);
+        default:
+            break;
+        }
+    }
+
+    BOOST_SERIALIZATION_SPLIT_MEMBER()
+    signed char s;
+    unsigned char t;
+    signed int u;
+    unsigned int v;
+    float w;
+    double x;
+public:
+    B();
+    virtual ~B(){};
+    bool operator==(const B &rhs) const;
+};
+
+B::B() :
+    s(std::rand()),
+    t(std::rand()),
+    u(std::rand()),
+    v(std::rand()),
+    w((float)std::rand() / std::rand()),
+    x((double)std::rand() / std::rand())
+{
+}
+
+BOOST_CLASS_VERSION(B, 2)
+
+inline bool B::operator==(const B &rhs) const
+{
+    return
+        A::operator==(rhs)
+        && s == rhs.s 
+        && t == rhs.t 
+        && u == rhs.u 
+        && v == rhs.v 
+        && std::fabs(w - rhs.w) <= std::numeric_limits<float>::round_error()
+        && std::fabs(x - rhs.x) <= std::numeric_limits<float>::round_error()
+    ;
+}
+
+#endif // BOOST_SERIALIZATION_TEST_B_HPP

example/demo_dll_b.ipp

@@ -0,0 +1,112 @@
+#ifndef BOOST_SERIALIZATION_TEST_B_HPP
+#define BOOST_SERIALIZATION_TEST_B_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+# pragma once
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// B.hpp
+
+// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
+// Use, modification and distribution is subject to 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)
+
+//  See http://www.boost.org for updates, documentation, and revision history.
+
+#include <cstdlib> // for rand()
+
+#include <boost/config.hpp>
+#if defined(BOOST_NO_STDC_NAMESPACE)
+namespace std{
+    using ::rand; 
+}
+#endif
+
+#include <boost/serialization/version.hpp>
+#include <boost/serialization/split_member.hpp>
+#include <boost/serialization/base_object.hpp>
+
+#include "A.hpp"
+
+///////////////////////////////////////////////////////
+// Derived class test
+class B : public A
+{
+private:
+    friend class boost::serialization::access;
+    template<class Archive>
+    void save(Archive &ar, const unsigned int /* file_version */) const
+    {
+        // write any base class info to the archive
+        ar << BOOST_SERIALIZATION_BASE_OBJECT_NVP(A);
+
+        // write out members
+        ar << BOOST_SERIALIZATION_NVP(s);
+        ar << BOOST_SERIALIZATION_NVP(t);
+        ar << BOOST_SERIALIZATION_NVP(u);
+        ar << BOOST_SERIALIZATION_NVP(v);
+        ar << BOOST_SERIALIZATION_NVP(w);
+        ar << BOOST_SERIALIZATION_NVP(x);
+    }
+
+    template<class Archive>
+    void load(Archive & ar, const unsigned int file_version)
+    {
+        // read any base class info to the archive
+        ar >> BOOST_SERIALIZATION_BASE_OBJECT_NVP(A);
+        switch(file_version){
+        case 1:
+        case 2:
+            ar >> BOOST_SERIALIZATION_NVP(s);
+            ar >> BOOST_SERIALIZATION_NVP(t);
+            ar >> BOOST_SERIALIZATION_NVP(u);
+            ar >> BOOST_SERIALIZATION_NVP(v);
+            ar >> BOOST_SERIALIZATION_NVP(w);
+            ar >> BOOST_SERIALIZATION_NVP(x);
+        default:
+            break;
+        }
+    }
+
+    BOOST_SERIALIZATION_SPLIT_MEMBER()
+    signed char s;
+    unsigned char t;
+    signed int u;
+    unsigned int v;
+    float w;
+    double x;
+public:
+    B();
+    virtual ~B(){};
+    bool operator==(const B &rhs) const;
+};
+
+B::B() :
+    s(std::rand()),
+    t(std::rand()),
+    u(std::rand()),
+    v(std::rand()),
+    w((float)std::rand() / std::rand()),
+    x((double)std::rand() / std::rand())
+{
+}
+
+BOOST_CLASS_VERSION(B, 2)
+
+inline bool B::operator==(const B &rhs) const
+{
+    return
+        A::operator==(rhs)
+        && s == rhs.s 
+        && t == rhs.t 
+        && u == rhs.u 
+        && v == rhs.v 
+        && std::fabs(w - rhs.w) <= std::numeric_limits<float>::round_error()
+        && std::fabs(x - rhs.x) <= std::numeric_limits<float>::round_error()
+    ;
+}
+
+#endif // BOOST_SERIALIZATION_TEST_B_HPP

example/demo_exception.cpp

@@ -19,6 +19,7 @@
 
 #include <algorithm>
 #include <iostream>
+#include <cstddef> // NULL
 #include <fstream>
 #include <string>
 

example/demo_fast_archive.cpp

@@ -11,11 +11,12 @@
 
 #include <boost/static_assert.hpp>
 #include <boost/type_traits/is_array.hpp>
-#include <boost/pfto.hpp>
+#include <boost/serialization/pfto.hpp>
 
 #define BOOST_ARCHIVE_SOURCE
 #include <boost/archive/binary_oarchive_impl.hpp>
 #include <boost/archive/binary_iarchive_impl.hpp>
+#include <boost/archive/detail/register_archive.hpp>
 
 // include template definitions for base classes used.  Otherwise
 // you'll get link failure with undefined symbols
@@ -24,9 +25,6 @@
 #include <boost/archive/impl/basic_binary_oarchive.ipp>
 #include <boost/archive/impl/basic_binary_iarchive.ipp>
 
-#include <boost/archive/impl/archive_pointer_iserializer.ipp>
-#include <boost/archive/impl/archive_pointer_oserializer.ipp>
-
 using namespace boost::archive;
 
 /////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
@@ -94,6 +92,9 @@ public:
     {}
 };
 
+// required by export
+BOOST_SERIALIZATION_REGISTER_ARCHIVE(fast_binary_oarchive)
+
 /////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
 // "Fast" input binary archive.  This is a variation of the native binary 
 class fast_binary_iarchive :
@@ -157,6 +158,9 @@ public:
     {}
 };
 
+// required by export
+BOOST_SERIALIZATION_REGISTER_ARCHIVE(fast_binary_iarchive)
+
 int main( int argc, char* argv[] )
 {
     const int a[3] = {1, 2, 3};

example/demo_gps.hpp

@@ -10,16 +10,16 @@
 // License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
 // http://www.boost.org/LICENSE_1_0.txt)
 
-
-#include <string>
 #include <iomanip>
 #include <iostream>
 #include <fstream>
 
+#include <boost/serialization/string.hpp>
 #include <boost/serialization/nvp.hpp>
 #include <boost/serialization/utility.hpp>
 #include <boost/serialization/list.hpp>
 #include <boost/serialization/version.hpp>
+#include <boost/serialization/assume_abstract.hpp>
 
 // This illustration models the bus system of a small city.
 // This includes, multiple bus stops,  bus routes and schedules.
@@ -91,7 +91,7 @@ public:
     virtual ~bus_stop(){}
 };
 
-BOOST_IS_ABSTRACT(bus_stop)
+BOOST_SERIALIZATION_ASSUME_ABSTRACT(bus_stop)
 
 std::ostream & operator<<(std::ostream &os, const bus_stop &bs)
 {

example/demo_log.cpp

@@ -0,0 +1,76 @@
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+//
+// demo_log.cpp
+//
+// (C) Copyright 2009 Robert Ramey - http://www.rrsd.com .
+// Use, modification and distribution is subject to 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)
+
+#include <iostream>
+#include <cstdio>
+
+#include "demo_gps.hpp"
+#include "log_archive.hpp"
+
+int main(int argc, char *argv[])
+{   
+    // make the schedule
+    bus_schedule schedule;
+
+    // fill in the data
+    // make a few stops
+    bus_stop *bs0 = new bus_stop_corner(
+        gps_position(34, 135, 52.560f),
+        gps_position(134, 22, 78.30f),
+        "24th Street", "10th Avenue"
+    );
+    bus_stop *bs1 = new bus_stop_corner(
+        gps_position(35, 137, 23.456f),
+        gps_position(133, 35, 54.12f),
+        "State street", "Cathedral Vista Lane"
+    );
+    bus_stop *bs2 = new bus_stop_destination(
+        gps_position(35, 136, 15.456f),
+        gps_position(133, 32, 15.300f),
+        "White House"
+    );
+    bus_stop *bs3 = new bus_stop_destination(
+        gps_position(35, 134, 48.789f),
+        gps_position(133, 32, 16.230f),
+        "Lincoln Memorial"
+    );
+
+    // make a  routes
+    bus_route route0;
+    route0.append(bs0);
+    route0.append(bs1);
+    route0.append(bs2);
+
+    // add trips to schedule
+    schedule.append("bob", 6, 24, &route0);
+    schedule.append("bob", 9, 57, &route0);
+    schedule.append("alice", 11, 02, &route0);
+
+    // make aother routes
+    bus_route route1;
+    route1.append(bs3);
+    route1.append(bs2);
+    route1.append(bs1);
+
+    // add trips to schedule
+    schedule.append("ted", 7, 17, &route1);
+    schedule.append("ted", 9, 38, &route1);
+    schedule.append("alice", 11, 47, &route1);
+
+    // display the complete schedule
+    log_archive oa(std::cout);
+    //oa << BOOST_SERIALIZATION_NVP(schedule);
+    oa << schedule;
+
+    delete bs0;
+    delete bs1;
+    delete bs2;
+    delete bs3;
+    return 0;
+}

example/demo_polymorphic_A.cpp

@@ -12,16 +12,15 @@
 
 #include "demo_polymorphic_A.hpp"
 
-// now we can define the serialization for class A
-void A::serialize(
-    boost::archive::polymorphic_iarchive & ar, 
-    const unsigned int file_version
-){
-    ar & data;
-}
-void A::serialize(
-    boost::archive::polymorphic_oarchive & ar, 
-    const unsigned int file_version
-){
-    ar & data;
-}
+// explicitly instantiate templates for polymorphic archives
+// used by this demo.
+template
+void A::serialize<boost::archive::polymorphic_iarchive>(
+    boost::archive::polymorphic_iarchive &, 
+    const unsigned int
+);
+template
+void A::serialize<boost::archive::polymorphic_oarchive>(
+    boost::archive::polymorphic_oarchive &, 
+    const unsigned int
+);

example/demo_polymorphic_A.hpp

@@ -20,8 +20,13 @@ class polymorphic_oarchive;
 
 struct A {
     // class a contains a pointer to a "hidden" declaration
-    void serialize(boost::archive::polymorphic_iarchive & ar, const unsigned int file_version);
-    void serialize(boost::archive::polymorphic_oarchive & ar, const unsigned int file_version);
+    template<class Archive>
+    void serialize(
+        Archive & ar, 
+        const unsigned int file_version
+    ){
+        ar & data;
+    }
     int data;
     bool operator==(const A & rhs) const {
         return data == rhs.data;

example/demo_portable_archive.cpp

@@ -8,9 +8,12 @@
 // http://www.boost.org/LICENSE_1_0.txt)
 
 // should pass compilation and execution
+
+// note:: this example can only be built with the static library
+// (at least with MSVC - due to conflicts related to import of library
+// code and instantiation of templates.
 #include <sstream>
 
-#define BOOST_ARCHIVE_SOURCE
 #include "portable_binary_oarchive.hpp"
 #include "portable_binary_iarchive.hpp"
 
@@ -20,30 +23,36 @@
 namespace std{ using ::rand; }
 #endif
 
-// the following is required to be sure the "EXPORT" works if it is used
-#define CUSTOM_ARCHIVE_TYPES portable_binary_oarchive,portable_binary_iarchive
-
 class A
 {
     friend class boost::serialization::access;
+    char c;
     int i;
+    int i2; // special tricky case to check sign extension
     unsigned int ui;
     long l;
     unsigned long ul;
     template<class Archive>
     void serialize(Archive & ar, const unsigned int /* version */){
-        ar & i & ui & l & ul ;
+        ar & c & i & i2 & ui & l & ul ;
     }
 public:
     bool operator==(const A & rhs) const {
         return
-            i == rhs.i && ui == rhs.ui && l == rhs.l && ul == rhs.ul
+            c == rhs.c
+            && i == rhs.i
+            && i2 == rhs.i2
+            && ui == rhs.ui 
+            && l == rhs.l 
+            && ul == rhs.ul
         ;
     }
     A() :
+        c(0xFF & std::rand()),
         i(std::rand()),
+        i2(0x80),
         ui(std::rand()),
-        l(std::rand()),
+        l(std::rand() * std::rand()),
         ul(std::rand())
     {}
 };
@@ -62,6 +71,31 @@ int main( int /* argc */, char* /* argv */[] )
         portable_binary_iarchive pbia(ss);
         pbia >> a1;
     }
+    if(! (a == a1))
+        return 1;
+
+    ss.clear();
+    {   
+        portable_binary_oarchive pboa(ss, endian_big);
+        pboa << a;
+    }
+    {
+        portable_binary_iarchive pbia(ss, endian_big);
+        pbia >> a1;
+    }
+    if(! (a == a1))
+        return 1;
+
+    ss.clear();
+    {   
+        portable_binary_oarchive pboa(ss, endian_big);
+        pboa << a;
+    }
+    {
+        portable_binary_iarchive pbia(ss, endian_big);
+        pbia >> a1;
+    }
+
     return !(a == a1);
 }
 

example/demo_shared_ptr.cpp

@@ -11,6 +11,7 @@
 
 #include <iomanip>
 #include <iostream>
+#include <cstddef> // NULL
 #include <fstream>
 #include <string>
 
@@ -41,8 +42,8 @@ private:
     }
 public:
     static int count;
-    A::A(){++count;}    // default constructor
-    virtual A::~A(){--count;}   // default destructor
+    A(){++count;}    // default constructor
+    virtual ~A(){--count;}   // default destructor
 };
 
 BOOST_SERIALIZATION_SHARED_PTR(A)
@@ -60,8 +61,8 @@ private:
     }
 public:
     static int count;
-    B::B() : A() {};
-    virtual B::~B() {};
+    B() : A() {};
+    virtual ~B() {};
 };
 
 BOOST_SERIALIZATION_SHARED_PTR(B)
@@ -81,7 +82,7 @@ void display(boost::shared_ptr<A> &spa, boost::shared_ptr<A> &spa1)
     std::cout << "unique element count = " << A::count << std::endl;
 }
 
-int main(int argc, char *argv[])
+int main(int /* argc */, char /* *argv[] */)
 {
     std::string filename(boost::archive::tmpdir());
     filename += "/testfile";

example/demo_simple_log.cpp

@@ -0,0 +1,75 @@
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+//
+// demo_log.cpp
+//
+// (C) Copyright 2009 Robert Ramey - http://www.rrsd.com .
+// Use, modification and distribution is subject to 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)
+
+#include <iostream>
+#include <cstdio>
+
+#include "demo_gps.hpp"
+#include "simple_log_archive.hpp"
+
+int main(int argc, char *argv[])
+{   
+    // make the schedule
+    bus_schedule schedule;
+
+    // fill in the data
+    // make a few stops
+    bus_stop *bs0 = new bus_stop_corner(
+        gps_position(34, 135, 52.560f),
+        gps_position(134, 22, 78.30f),
+        "24th Street", "10th Avenue"
+    );
+    bus_stop *bs1 = new bus_stop_corner(
+        gps_position(35, 137, 23.456f),
+        gps_position(133, 35, 54.12f),
+        "State street", "Cathedral Vista Lane"
+    );
+    bus_stop *bs2 = new bus_stop_destination(
+        gps_position(35, 136, 15.456f),
+        gps_position(133, 32, 15.300f),
+        "White House"
+    );
+    bus_stop *bs3 = new bus_stop_destination(
+        gps_position(35, 134, 48.789f),
+        gps_position(133, 32, 16.230f),
+        "Lincoln Memorial"
+    );
+
+    // make a  routes
+    bus_route route0;
+    route0.append(bs0);
+    route0.append(bs1);
+    route0.append(bs2);
+
+    // add trips to schedule
+    schedule.append("bob", 6, 24, &route0);
+    schedule.append("bob", 9, 57, &route0);
+    schedule.append("alice", 11, 02, &route0);
+
+    // make aother routes
+    bus_route route1;
+    route1.append(bs3);
+    route1.append(bs2);
+    route1.append(bs1);
+
+    // add trips to schedule
+    schedule.append("ted", 7, 17, &route1);
+    schedule.append("ted", 9, 38, &route1);
+    schedule.append("alice", 11, 47, &route1);
+
+    // display the complete schedule
+    simple_log_archive log(std::cout);
+    log << schedule;
+
+    delete bs0;
+    delete bs1;
+    delete bs2;
+    delete bs3;
+    return 0;
+}

example/demo_trivial_archive.cpp

@@ -0,0 +1,94 @@
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+//
+// demo_trivial_archive.cpp
+//
+// (C) Copyright 2009 Robert Ramey - http://www.rrsd.com .
+// Use, modification and distribution is subject to 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)
+
+#include <cstddef> // std::size_t
+#include <boost/mpl/bool.hpp>
+
+/////////////////////////////////////////////////////////////////////////
+// class trivial_oarchive
+class trivial_oarchive {
+
+public:
+    //////////////////////////////////////////////////////////
+    // public interface used by programs that use the
+    // serialization library
+    typedef boost::mpl::bool_<true> is_saving; 
+    typedef boost::mpl::bool_<false> is_loading;
+    template<class T> register_type(){}
+    template<class T> trivial_oarchive & operator<<(const T & t){
+        return *this;
+    }
+    template<class T> trivial_oarchive & operator&(const T & t){
+        return *this << t;
+    }
+    void save_binary(void *address, std::size_t count){};
+};
+
+#include "demo_gps.hpp"
+
+int main(int argc, char *argv[])
+{   
+    // make the schedule
+    bus_schedule schedule;
+
+    // fill in the data
+    // make a few stops
+    bus_stop *bs0 = new bus_stop_corner(
+        gps_position(34, 135, 52.560f),
+        gps_position(134, 22, 78.30f),
+        "24th Street", "10th Avenue"
+    );
+    bus_stop *bs1 = new bus_stop_corner(
+        gps_position(35, 137, 23.456f),
+        gps_position(133, 35, 54.12f),
+        "State street", "Cathedral Vista Lane"
+    );
+    bus_stop *bs2 = new bus_stop_destination(
+        gps_position(35, 136, 15.456f),
+        gps_position(133, 32, 15.300f),
+        "White House"
+    );
+    bus_stop *bs3 = new bus_stop_destination(
+        gps_position(35, 134, 48.789f),
+        gps_position(133, 32, 16.230f),
+        "Lincoln Memorial"
+    );
+
+    // make a  routes
+    bus_route route0;
+    route0.append(bs0);
+    route0.append(bs1);
+    route0.append(bs2);
+
+    // add trips to schedule
+    schedule.append("bob", 6, 24, &route0);
+    schedule.append("bob", 9, 57, &route0);
+    schedule.append("alice", 11, 02, &route0);
+
+    // make aother routes
+    bus_route route1;
+    route1.append(bs3);
+    route1.append(bs2);
+    route1.append(bs1);
+
+    // add trips to schedule
+    schedule.append("ted", 7, 17, &route1);
+    schedule.append("ted", 9, 38, &route1);
+    schedule.append("alice", 11, 47, &route1);
+
+    // display the complete schedule
+    trivial_oarchive ta;
+    ta << schedule;
+
+    delete bs0;
+    delete bs1;
+    delete bs2;
+    delete bs3;
+    return 0;
+}

example/demo_xml.hpp

@@ -0,0 +1,284 @@
+#ifndef BOOST_SERIALIZATION_EXAMPLE_DEMO_XML_HPP
+#define BOOST_SERIALIZATION_EXAMPLE_DEMO_XML_HPP
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+//
+// demo_xml.hpp
+//
+// (C) Copyright 2002-4 Robert Ramey - http://www.rrsd.com .
+// Use, modification and distribution is subject to 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)
+
+
+#include <string>
+#include <iomanip>
+#include <iostream>
+#include <fstream>
+
+#include <boost/serialization/nvp.hpp>
+#include <boost/serialization/utility.hpp>
+#include <boost/serialization/list.hpp>
+#include <boost/serialization/version.hpp>
+
+// This illustration models the bus system of a small city.
+// This includes, multiple bus stops,  bus routes and schedules.
+// There are different kinds of stops.  Bus stops in general will
+// will appear on multiple routes.  A schedule will include
+// muliple trips on the same route.
+
+/////////////////////////////////////////////////////////////
+// gps coordinate
+//
+// llustrates serialization for a simple type
+//
+class gps_position
+{
+    friend class boost::serialization::access;
+    friend std::ostream & operator<<(std::ostream &os, const gps_position &gp);
+
+    int degrees;
+    int minutes;
+    float seconds;
+
+    template<class Archive>
+    void serialize(Archive & ar, const unsigned int /* file_version */){
+        ar  & BOOST_SERIALIZATION_NVP(degrees)
+            & BOOST_SERIALIZATION_NVP(minutes)
+            & BOOST_SERIALIZATION_NVP(seconds);
+    }
+
+public:
+    // every serializable class needs a constructor
+    gps_position(){};
+    gps_position(int _d, int _m, float _s) : 
+        degrees(_d), minutes(_m), seconds(_s)
+    {}
+};
+
+std::ostream & operator<<(std::ostream &os, const gps_position &gp)
+{
+    return os << ' ' << gp.degrees << (unsigned char)186 << gp.minutes << '\'' << gp.seconds << '"';
+}
+
+/////////////////////////////////////////////////////////////
+// One bus stop
+//
+// illustrates serialization of serializable members
+//
+
+class bus_stop
+{
+    friend class boost::serialization::access;
+    virtual std::string description() const = 0;
+    gps_position latitude;
+    gps_position longitude;
+
+    template<class Archive>
+    void serialize(Archive &ar, const unsigned int version)
+    {
+        ar & BOOST_SERIALIZATION_NVP(latitude);
+        ar & BOOST_SERIALIZATION_NVP(longitude);
+    }
+
+protected:
+    bus_stop(const gps_position & _lat, const gps_position & _long) :
+        latitude(_lat), longitude(_long)
+    {}
+public:
+    bus_stop(){}
+    friend std::ostream & operator<<(std::ostream &os, const bus_stop &gp);
+    virtual ~bus_stop(){}
+};
+
+BOOST_IS_ABSTRACT(bus_stop)
+
+std::ostream & operator<<(std::ostream &os, const bus_stop &bs)
+{
+    return os << bs.latitude << bs.longitude << ' ' << bs.description();
+}
+
+/////////////////////////////////////////////////////////////
+// Several kinds of bus stops
+//
+// illustrates serialization of derived types
+//
+class bus_stop_corner : public bus_stop
+{
+    friend class boost::serialization::access;
+    std::string street1;
+    std::string street2;
+    virtual std::string description() const
+    {
+        return street1 + " and " + street2;
+    }
+    template<class Archive>
+    void serialize(Archive &ar, const unsigned int version)
+    {
+        // save/load base class information
+        ar & BOOST_SERIALIZATION_BASE_OBJECT_NVP(bus_stop);
+        ar & BOOST_SERIALIZATION_NVP(street1);
+        ar & BOOST_SERIALIZATION_NVP(street2);
+    }
+public:
+    bus_stop_corner(){}
+    bus_stop_corner(const gps_position & _lat, const gps_position & _long,
+        const std::string & _s1, const std::string & _s2
+    ) :
+        bus_stop(_lat, _long), street1(_s1), street2(_s2)
+    {
+    }
+};
+
+class bus_stop_destination : public bus_stop
+{
+    friend class boost::serialization::access;
+    std::string name;
+    virtual std::string description() const
+    {
+        return name;
+    }
+    template<class Archive>
+    void serialize(Archive &ar, const unsigned int version)
+    {
+        ar  & BOOST_SERIALIZATION_BASE_OBJECT_NVP(bus_stop)
+            & BOOST_SERIALIZATION_NVP(name);
+    }
+public:
+    bus_stop_destination(){}
+    bus_stop_destination(
+        const gps_position & _lat, const gps_position & _long, const std::string & _name
+    ) :
+        bus_stop(_lat, _long), name(_name)
+    {
+    }
+};
+
+/////////////////////////////////////////////////////////////
+// a bus route is a collection of bus stops
+//
+// illustrates serialization of STL collection templates.
+//
+// illustrates serialzation of polymorphic pointer (bus stop *);
+//
+// illustrates storage and recovery of shared pointers is correct
+// and efficient.  That is objects pointed to by more than one
+// pointer are stored only once.  In such cases only one such
+// object is restored and pointers are restored to point to it
+//
+class bus_route
+{
+    friend class boost::serialization::access;
+    friend std::ostream & operator<<(std::ostream &os, const bus_route &br);
+    typedef bus_stop * bus_stop_pointer;
+    std::list<bus_stop_pointer> stops;
+    template<class Archive>
+    void serialize(Archive &ar, const unsigned int version)
+    {
+        // in this program, these classes are never serialized directly but rather
+        // through a pointer to the base class bus_stop. So we need a way to be
+        // sure that the archive contains information about these derived classes.
+        //ar.template register_type<bus_stop_corner>();
+        ar.register_type(static_cast<bus_stop_corner *>(NULL));
+        //ar.template register_type<bus_stop_destination>();
+        ar.register_type(static_cast<bus_stop_destination *>(NULL));
+        // serialization of stl collections is already defined
+        // in the header
+        ar & BOOST_SERIALIZATION_NVP(stops);
+    }
+public:
+    bus_route(){}
+    void append(bus_stop *_bs)
+    {
+        stops.insert(stops.end(), _bs);
+    }
+};
+std::ostream & operator<<(std::ostream &os, const bus_route &br)
+{
+    std::list<bus_stop *>::const_iterator it;
+    // note: we're displaying the pointer to permit verification
+    // that duplicated pointers are properly restored.
+    for(it = br.stops.begin(); it != br.stops.end(); it++){
+        os << '\n' << std::hex << "0x" << *it << std::dec << ' ' << **it;
+    }
+    return os;
+}
+
+/////////////////////////////////////////////////////////////
+// a bus schedule is a collection of routes each with a starting time
+//
+// Illustrates serialization of STL objects(pair) in a non-intrusive way.
+// See definition of operator<< <pair<F, S> >(ar, pair)
+// 
+// illustrates nesting of serializable classes
+//
+// illustrates use of version number to automatically grandfather older
+// versions of the same class.
+
+class bus_schedule
+{
+    friend class boost::serialization::access;
+    friend std::ostream & operator<<(std::ostream &os, const bus_schedule &bs);
+    template<class Archive>
+    void serialize(Archive &ar, const unsigned int version)
+    {
+        ar & BOOST_SERIALIZATION_NVP(schedule);
+    }
+    // note: this structure was made public. because the friend declarations
+    // didn't seem to work as expected.
+public:
+    struct trip_info
+    {
+        template<class Archive>
+        void serialize(Archive &ar, const unsigned int file_version)
+        {
+            // in versions 2 or later
+            if(file_version >= 2)
+                // read the drivers name
+                ar & BOOST_SERIALIZATION_NVP(driver);
+            // all versions have the follwing info
+            ar  & BOOST_SERIALIZATION_NVP(hour)
+                & BOOST_SERIALIZATION_NVP(minute);
+        }
+
+        // starting time
+        int hour;
+        int minute;
+        // only after system shipped was the driver's name added to the class
+        std::string driver;
+
+        trip_info(){}
+        trip_info(int _h, int _m, const std::string &_d) :
+            hour(_h), minute(_m), driver(_d)
+        {}
+        ~trip_info(){
+        }
+    };
+//  friend std::ostream & operator<<(std::ostream &os, const trip_info &ti);
+private:
+    std::list<std::pair<trip_info, bus_route *> > schedule;
+public:
+    void append(const std::string &_d, int _h, int _m, bus_route *_br)
+    {
+        schedule.insert(schedule.end(), std::make_pair(trip_info(_h, _m, _d), _br));
+    }
+    bus_schedule(){}
+};
+
+BOOST_CLASS_VERSION(bus_schedule::trip_info, 3)
+BOOST_CLASS_VERSION(bus_schedule, 2)
+
+std::ostream & operator<<(std::ostream &os, const bus_schedule::trip_info &ti)
+{
+    return os << '\n' << ti.hour << ':' << ti.minute << ' ' << ti.driver << ' ';
+}
+std::ostream & operator<<(std::ostream &os, const bus_schedule &bs)
+{
+    std::list<std::pair<bus_schedule::trip_info, bus_route *> >::const_iterator it;
+    for(it = bs.schedule.begin(); it != bs.schedule.end(); it++){
+        os << it->first << *(it->second);
+    }
+    return os;
+}
+
+#endif // BOOST_SERIALIZATION_EXAMPLE_DEMO_XML_HPP

example/log_archive.cpp

@@ -0,0 +1,32 @@
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// log_archive.cpp:
+
+// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
+// Use, modification and distribution is subject to 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)
+
+//  See http://www.boost.org for updates, documentation, and revision history.
+
+#if (defined _MSC_VER) && (_MSC_VER == 1200)
+#  pragma warning (disable : 4786) // too long name, harmless warning
+#endif
+
+//#define BOOST_ARCHIVE_SOURCE
+#include "log_archive.hpp"
+#include <boost/archive/detail/archive_serializer_map.hpp>
+
+// explicitly instantiate for this type of xml stream
+#include <boost/archive/impl/archive_serializer_map.ipp>
+#include <boost/archive/impl/basic_xml_oarchive.ipp>
+#include <boost/archive/impl/xml_oarchive_impl.ipp>
+
+namespace boost {
+namespace archive {
+
+template class detail::archive_serializer_map<log_archive>;
+template class basic_xml_oarchive<log_archive> ;
+template class xml_oarchive_impl<log_archive> ;
+
+} // namespace archive
+} // namespace boost

example/log_archive.hpp

@@ -0,0 +1,76 @@
+#ifndef LOG_ARCHIVE_HPP
+#define LOG_ARCHIVE_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+# pragma once
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// log_archive.hpp
+
+// (C) Copyright 2010 Robert Ramey - http://www.rrsd.com . 
+// Use, modification and distribution is subject to 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)
+
+//  See http://www.boost.org for updates, documentation, and revision history.
+
+#include <boost/archive/xml_oarchive.hpp>
+
+/////////////////////////////////////////////////////////////////////////
+// log data to an output stream.  This illustrates a simpler implemenation
+// of text output which is useful for getting a formatted display of
+// any serializable class.  Intended to be useful as a debugging aid.
+class log_archive :
+    /* protected ? */ 
+    public boost::archive::xml_oarchive_impl<log_archive>
+{
+    typedef boost::archive::xml_oarchive_impl<log_archive> base;
+    // give serialization implementation access to this clas
+    friend class boost::archive::detail::interface_oarchive<log_archive>;
+    friend class boost::archive::basic_xml_oarchive<log_archive>;
+    friend boost::archive::save_access;
+
+    /////////////////////////////////////////////////////////////////////
+    // Override functions defined in basic_xml_oarchive
+
+    // Anything not an attribute and not a name-value pair is an
+    // error and should be trapped here.  Note the usage of
+    // function argument matching (BOOST_PFTO) to permit usage
+    // with compilers which fail to properly support 
+    // function template ordering
+    template<class T>
+    void save_override(T & t, BOOST_PFTO int){
+        // make it a name-value pair and pass it on.
+        // this permits this to be used even with data types which
+        // are not wrapped with the name
+        base::save_override(boost::serialization::make_nvp(NULL, t), 0);
+    }
+    template<class T>
+    void save_override(const boost::serialization::nvp<T> & t, int){
+        // this is here to remove the "const" requirement.  Since
+        // this class is to be used only for output, it's not required.
+        base::save_override(t, 0);
+    }
+    // specific overrides for attributes - not name value pairs so we
+    // want to trap them before the above "fall through"
+    // since we don't want to see these in the output - make them no-ops.
+    void save_override(const boost::archive::object_id_type & t, int){}
+    void save_override(const boost::archive::object_reference_type & t, int){}
+    void save_override(const boost::archive::version_type & t, int){}
+    void save_override(const boost::archive::class_id_type & t, int){}
+    void save_override(const boost::archive::class_id_optional_type & t, int){}
+    void save_override(const boost::archive::class_id_reference_type & t, int){}
+    void save_override(const boost::archive::class_name_type & t, int){}
+    void save_override(const boost::archive::tracking_type & t, int){}
+public:
+    log_archive(std::ostream & os, unsigned int flags = 0) :
+        boost::archive::xml_oarchive_impl<log_archive>(
+            os, 
+            flags | boost::archive::no_header
+        )
+    {}
+};
+
+#endif // LOG_ARCHIVE_HPP

example/polymorphic_portable_binary_iarchive.cpp

@@ -0,0 +1,34 @@
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// polymorphic_portable_binary_iarchive.cpp
+
+// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
+// Use, modification and distribution is subject to 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)
+
+//  See http://www.boost.org for updates, documentation, and revision history.
+
+#include <istream>
+
+#define BOOST_ARCHIVE_SOURCE
+#include "polymorphic_portable_binary_iarchive.hpp"
+
+// explicitly instantiate for this type of text stream
+#include <boost/archive/impl/basic_binary_iarchive.ipp>
+#include <boost/archive/impl/archive_pointer_iserializer.ipp>
+#include <boost/archive/impl/basic_binary_iprimitive.ipp>
+
+namespace boost {
+namespace archive {
+
+template class binary_iarchive_impl<
+    polymorphic_portable_binary_iarchive, 
+    std::istream::char_type, 
+    std::istream::traits_type
+>;
+template class detail::archive_pointer_iserializer<
+    polymorphic_portable_binary_iarchive
+> ;
+
+} // namespace archive
+} // namespace boost

example/polymorphic_portable_binary_iarchive.hpp

@@ -0,0 +1,35 @@
+#ifndef BOOST_ARCHIVE_POLYMORPHIC_PORTABLE_BINARY_IARCHIVE_HPP
+#define BOOST_ARCHIVE_POLYMORPHIC_PORTABLE_BINARY_IARCHIVE_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+# pragma once
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// polymorphic_portable_binary_iarchive.hpp
+
+// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
+// Use, modification and distribution is subject to 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)
+
+//  See http://www.boost.org for updates, documentation, and revision history.
+
+#include <boost/archive/detail/polymorphic_iarchive_dispatch.hpp>
+#include "portable_binary_iarchive.hpp"
+
+typedef boost::archive::detail::polymorphic_iarchive_dispatch<
+    portable_binary_iarchive
+> polymorphic_portable_binary_iarchive;
+
+#include <boost/version.hpp>
+#if BOOST_VERSION > 103401
+    // required by export
+    BOOST_SERIALIZATION_REGISTER_ARCHIVE(
+        polymorphic_portable_binary_iarchive
+    )
+#endif
+
+#endif // BOOST_ARCHIVE_POLYMORPHIC_PORTABLE_BINARY_OARCHIVE_HPP
+

example/polymorphic_portable_binary_oarchive.cpp

@@ -0,0 +1,35 @@
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// polymorphic_portable_binary_oarchive.cpp
+
+// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
+// Use, modification and distribution is subject to 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)
+
+//  See http://www.boost.org for updates, documentation, and revision history.
+
+#include <ostream>
+
+#define BOOST_ARCHIVE_SOURCE
+#include "polymorphic_portable_binary_oarchive.hpp"
+
+// explicitly instantiate for this type of text stream
+#include <boost/archive/impl/basic_binary_oarchive.ipp>
+#include <boost/archive/impl/archive_pointer_oserializer.ipp>
+#include <boost/archive/impl/basic_binary_oprimitive.ipp>
+
+namespace boost {
+namespace archive {
+
+// explicitly instantiate for this type of binary stream
+template class binary_oarchive_impl<
+    polymorphic_portable_binary_oarchive, 
+    std::ostream::char_type, 
+    std::ostream::traits_type
+>;
+template class detail::archive_pointer_oserializer<
+    polymorphic_portable_binary_oarchive
+> ;
+
+} // namespace archive
+} // namespace boost

example/polymorphic_portable_binary_oarchive.hpp

@@ -0,0 +1,34 @@
+#ifndef BOOST_ARCHIVE_POLYMORPHIC_PORTABLE_BINARY_OARCHIVE_HPP
+#define BOOST_ARCHIVE_POLYMORPHIC_PORTABLE_BINARY_OARCHIVE_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+# pragma once
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// polymorphic_portable_binary_oarchive.hpp
+
+// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
+// Use, modification and distribution is subject to 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)
+
+//  See http://www.boost.org for updates, documentation, and revision history.
+
+#include <boost/archive/detail/polymorphic_oarchive_dispatch.hpp>
+#include "portable_binary_oarchive.hpp"
+
+typedef boost::archive::detail::polymorphic_oarchive_dispatch<
+    portable_binary_oarchive
+ > polymorphic_portable_binary_oarchive;
+
+#include <boost/version.hpp>
+#if BOOST_VERSION > 103401
+    // required by export
+    BOOST_SERIALIZATION_REGISTER_ARCHIVE(
+        polymorphic_portable_binary_oarchive
+    )
+#endif
+
+#endif // BOOST_ARCHIVE_POLYMORPHIC_PORTABLE_BINARY_OARCHIVE_HPP

example/portable_binary_archive.hpp

@@ -0,0 +1,47 @@
+#ifndef PORTABLE_BINARY_ARCHIVE_HPP
+#define PORTABLE_BINARY_ARCHIVE_HPP
+
+// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
+// Use, modification and distribution is subject to 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)
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+# pragma once
+#endif
+
+#include <boost/config.hpp>
+#include <boost/cstdint.hpp>
+#include <boost/serialization/pfto.hpp>
+#include <boost/static_assert.hpp>
+
+#include <climits>
+#if CHAR_BIT != 8
+#error This code assumes an eight-bit byte.
+#endif
+
+#include <boost/archive/basic_archive.hpp>
+#include <boost/detail/endian.hpp>
+
+enum portable_binary_archive_flags {
+    endian_big        = 0x4000,
+    endian_little     = 0x8000
+};
+
+//#if ( endian_big <= boost::archive::flags_last )
+//#error archive flags conflict
+//#endif
+
+inline void
+reverse_bytes(char size, char *address){
+    char * first = address;
+    char * last = first + size - 1;
+    for(;first < last;++first, --last){
+        char x = *last;
+        *last = *first;
+        *first = x;
+    }
+}
+
+#endif // PORTABLE_BINARY_ARCHIVE_HPP

example/portable_binary_iarchive.cpp

@@ -0,0 +1,127 @@
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// portable_binary_iarchive.cpp
+
+// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
+// Use, modification and distribution is subject to 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)
+
+//  See http://www.boost.org for updates, documentation, and revision history.
+
+#include <istream>
+#include <string>
+
+#include <boost/detail/endian.hpp>
+#include <boost/serialization/throw_exception.hpp>
+#include <boost/archive/archive_exception.hpp>
+
+#include "portable_binary_iarchive.hpp"
+
+void 
+portable_binary_iarchive::load_impl(boost::intmax_t & l, char maxsize){
+    char size;
+    l = 0;
+    this->primitive_base_t::load(size);
+
+    if(0 == size){
+        return;
+    }
+
+    bool negative = (size < 0);
+    if(negative)
+        size = -size;
+
+    if(size > maxsize)
+        boost::serialization::throw_exception(
+            portable_binary_iarchive_exception()
+        );
+
+    char * cptr = reinterpret_cast<char *>(& l);
+    #ifdef BOOST_BIG_ENDIAN
+        cptr += (sizeof(boost::intmax_t) - size);
+    #endif
+    this->primitive_base_t::load_binary(cptr, size);
+
+    #ifdef BOOST_BIG_ENDIAN
+        if(m_flags & endian_little)
+    #else
+        if(m_flags & endian_big)
+    #endif
+            reverse_bytes(size, cptr);
+    
+    if(negative)
+        l = -l;
+}
+
+void
+portable_binary_iarchive::load_override(
+    boost::archive::class_name_type & t, int
+){
+    std::string cn;
+    cn.reserve(BOOST_SERIALIZATION_MAX_KEY_SIZE);
+    load_override(cn, 0);
+    if(cn.size() > (BOOST_SERIALIZATION_MAX_KEY_SIZE - 1))
+        boost::serialization::throw_exception(
+            boost::archive::archive_exception(
+                boost::archive::archive_exception::invalid_class_name)
+            );
+    std::memcpy(t, cn.data(), cn.size());
+    // borland tweak
+    t.t[cn.size()] = '\0';
+}
+
+void 
+portable_binary_iarchive::init(unsigned int flags){
+    if(0 == (flags & boost::archive::no_header)){
+        // read signature in an archive version independent manner
+        std::string file_signature;
+        * this >> file_signature;
+        if(file_signature != boost::archive::BOOST_ARCHIVE_SIGNATURE())
+            boost::serialization::throw_exception(
+                boost::archive::archive_exception(
+                    boost::archive::archive_exception::invalid_signature
+                )
+            );
+        // make sure the version of the reading archive library can
+        // support the format of the archive being read
+        boost::archive::version_type input_library_version;
+        * this >> input_library_version;
+
+        // extra little .t is to get around borland quirk
+        if(boost::archive::BOOST_ARCHIVE_VERSION() < input_library_version.t)
+            boost::serialization::throw_exception(
+                boost::archive::archive_exception(
+                    boost::archive::archive_exception::unsupported_version
+                )
+            );
+        
+        #if BOOST_WORKAROUND(__MWERKS__, BOOST_TESTED_AT(0x3205))
+        this->set_library_version(input_library_version);
+        //#else
+        //#if ! BOOST_WORKAROUND(BOOST_MSVC, <= 1200)
+        //detail::
+        //#endif
+        boost::archive::detail::basic_iarchive::set_library_version(
+            input_library_version
+        );
+        #endif
+    }
+    unsigned char x;
+    load(x);
+    m_flags = x << CHAR_BIT;
+}
+
+#include <boost/archive/impl/basic_binary_iprimitive.ipp>
+
+
+namespace boost {
+namespace archive {
+
+template class basic_binary_iprimitive<
+    portable_binary_iarchive,
+    std::istream::char_type, 
+    std::istream::traits_type
+> ;
+
+} // namespace archive
+} // namespace boost

example/portable_binary_iarchive.hpp

@@ -6,31 +6,43 @@
 # pragma once
 #endif
 
+#if defined(_MSC_VER)
+#pragma warning( push )
+#pragma warning( disable : 4244 )
+#endif
+
 /////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
 // portable_binary_iarchive.hpp
 
-// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
+// (C) Copyright 2002-7 Robert Ramey - http://www.rrsd.com . 
 // Use, modification and distribution is subject to 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)
 
 //  See http://www.boost.org for updates, documentation, and revision history.
 
-#include <ostream>
-#include <boost/archive/binary_iarchive.hpp>
-#include <boost/detail/endian.hpp>
+#include <istream>
+#include <boost/serialization/string.hpp>
+#include <boost/archive/archive_exception.hpp>
+#include <boost/archive/basic_binary_iprimitive.hpp>
+#include <boost/archive/detail/common_iarchive.hpp>
+#include <boost/archive/shared_ptr_helper.hpp>
+#include <boost/archive/detail/register_archive.hpp>
+
+#include "portable_binary_archive.hpp"
 
 /////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
 // exception to be thrown if integer read from archive doesn't fit
 // variable being loaded
-class portable_binary_archive_exception : 
+class portable_binary_iarchive_exception : 
     public virtual boost::archive::archive_exception
 {
 public:
     typedef enum {
         incompatible_integer_size 
     } exception_code;
-    portable_binary_archive_exception(exception_code c = incompatible_integer_size )
+    portable_binary_iarchive_exception(exception_code c = incompatible_integer_size ) :
+        boost::archive::archive_exception(boost::archive::archive_exception::other_exception)
     {}
     virtual const char *what( ) const throw( )
     {
@@ -38,136 +50,143 @@ public:
         switch(code){
         case incompatible_integer_size:
             msg = "integer cannot be represented";
+            break;
         default:
-            boost::archive::archive_exception::what();
+            msg = boost::archive::archive_exception::what();
+            assert(false);
+            break;
         }
         return msg;
     }
 };
 
 /////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// "Portable" input binary archive.  This is a variation of the native binary 
-// archive. it addresses integer size and endienness so that binary archives can
-// be passed across systems. Note:floating point types not addressed here
+// "Portable" input binary archive.  It addresses integer size and endienness so 
+// that binary archives can be passed across systems. Note:floating point types
+// not addressed here
 class portable_binary_iarchive :
-    // don't derive from binary_iarchive !!!
-    public boost::archive::binary_iarchive_impl<
-        portable_binary_iarchive, 
+    public boost::archive::basic_binary_iprimitive<
+        portable_binary_iarchive,
         std::istream::char_type, 
         std::istream::traits_type
     >,
+    public boost::archive::detail::common_iarchive<
+        portable_binary_iarchive
+    >
+    ,
     public boost::archive::detail::shared_ptr_helper
-{
-    typedef boost::archive::binary_iarchive_impl<
-        portable_binary_iarchive, 
+    {
+    typedef boost::archive::basic_binary_iprimitive<
+        portable_binary_iarchive,
         std::istream::char_type, 
         std::istream::traits_type
-    > archive_base_t;
-    typedef boost::archive::basic_binary_iprimitive<
-        portable_binary_iarchive, 
-        std::ostream::char_type, 
-        std::ostream::traits_type
     > primitive_base_t;
+    typedef boost::archive::detail::common_iarchive<
+        portable_binary_iarchive
+    > archive_base_t;
 #ifndef BOOST_NO_MEMBER_TEMPLATE_FRIENDS
 public:
 #else
     friend archive_base_t;
     friend primitive_base_t; // since with override load below
-    friend class boost::archive::basic_binary_iarchive<portable_binary_iarchive>;
+    friend class boost::archive::detail::interface_iarchive<
+        portable_binary_iarchive
+    >;
     friend class boost::archive::load_access;
+protected:
 #endif
-    void load_impl(long & l, char maxsize){
-        char size;
-        this->archive_base_t::load(size);
-        if(size > maxsize)
-            throw portable_binary_archive_exception() ;
-        l = 0;
-        load_binary(& l, size);
-        // we choose to use litle endian
-        #ifdef BOOST_BIG_ENDIAN
-            char * first = static_cast<char *>(static_cast<void *>(& l));
-            char * last = first + sizeof(l) - 1;
-            for(;first < last;++first, --last){
-                char x = *last;
-                *last = *first;
-                *first = x;
-            }
-        #endif
+    unsigned int m_flags;
+    void load_impl(boost::intmax_t & l, char maxsize);
 
-        // extend sign if necessary
-        if((l >> (size - 1) * 8) & 0x80){
-            l |= (-1 << (size * 8));
-        }
-    }
     // default fall through for any types not specified here
     template<class T>
     void load(T & t){
+        boost::intmax_t l;
+        load_impl(l, sizeof(T));
+        // use cast to avoid compile time warning
+        t = static_cast<T>(l);
+    }
+    void load(std::string & t){
         this->primitive_base_t::load(t);
     }
-    void load(unsigned short & t){
-        long l;
-        load_impl(l, sizeof(unsigned short));
-        t = l;
+    #ifndef BOOST_NO_STD_WSTRING
+    void load(std::wstring & t){
+        this->primitive_base_t::load(t);
     }
-    void load(short & t){
-        long l;
-        load_impl(l, sizeof(short));
-        t = l;
+    #endif
+    void load(float & t){
+        this->primitive_base_t::load(t);
+        // floats not supported
+        //BOOST_STATIC_ASSERT(false);
     }
-    void load(unsigned int & t){
-        long l;
-        load_impl(l, sizeof(unsigned int));
-        t = l;
+    void load(double & t){
+        this->primitive_base_t::load(t);
+        // doubles not supported
+        //BOOST_STATIC_ASSERT(false);
     }
-    void load(int & t){
-        long l;
-        load_impl(l, sizeof(int));
-        t = l;
+    void load(char & t){
+        this->primitive_base_t::load(t);
     }
-    void load(unsigned long & t){
-        long l;
-        load_impl(l, sizeof(unsigned long));
-        t = l;
+    void load(unsigned char & t){
+        this->primitive_base_t::load(t);
     }
-    void load(long & t){
-        long l;
-        load_impl(l, sizeof(long));
-        t = l;
+    // intermediate level to support override of operators
+    // fot templates in the absence of partial function 
+    // template ordering
+    typedef boost::archive::detail::common_iarchive<portable_binary_iarchive> 
+        detail_common_iarchive;
+    template<class T>
+    void load_override(T & t, BOOST_PFTO int){
+        this->detail_common_iarchive::load_override(t, 0);
     }
+    void load_override(boost::archive::class_name_type & t, int);
+    // binary files don't include the optional information 
+    void load_override(
+        boost::archive::class_id_optional_type & /* t */, 
+        int
+    ){}
+
+    void init(unsigned int flags);
 public:
     portable_binary_iarchive(std::istream & is, unsigned flags = 0) :
-        archive_base_t(
-            is, 
-            flags | boost::archive::no_header // skip default header checking 
-        )
+        primitive_base_t(
+            * is.rdbuf(), 
+            0 != (flags & boost::archive::no_codecvt)
+        ),
+        archive_base_t(flags),
+        m_flags(0)
     {
-        // use our own header checking
-        if(0 != (flags & boost::archive::no_header)){
-            this->archive_base_t::init(flags);
-            // skip the following for "portable" binary archives
-            // boost::archive::basic_binary_oprimitive<derived_t, std::ostream>::init();
-        }
+        init(flags);
+    }
+
+    portable_binary_iarchive(
+        std::basic_streambuf<
+            std::istream::char_type, 
+            std::istream::traits_type
+        > & bsb, 
+        unsigned int flags
+    ) :
+        primitive_base_t(
+            bsb, 
+            0 != (flags & boost::archive::no_codecvt)
+        ),
+        archive_base_t(flags),
+        m_flags(0)
+    {
+        init(flags);
     }
 };
 
-// explicitly instantiate for this type of text stream
-#include <boost/archive/impl/basic_binary_iarchive.ipp>
-#include <boost/archive/impl/archive_pointer_iserializer.ipp>
-#include <boost/archive/impl/basic_binary_iprimitive.ipp>
-
-namespace boost {
-namespace archive {
-
-template class binary_iarchive_impl<
-    portable_binary_iarchive, 
-    std::istream::char_type, 
-    std::istream::traits_type
->;
-template class detail::archive_pointer_iserializer<portable_binary_iarchive> ;
-
-} // namespace archive
-} // namespace boost
+// required by export in boost version > 1.34
+#ifdef BOOST_SERIALIZATION_REGISTER_ARCHIVE
+    BOOST_SERIALIZATION_REGISTER_ARCHIVE(portable_binary_iarchive)
+#endif
 
+// required by export in boost <= 1.34
 #define BOOST_ARCHIVE_CUSTOM_IARCHIVE_TYPES portable_binary_iarchive
 
+#if defined(_MSC_VER)
+#pragma warning( pop )
+#endif
+
 #endif // PORTABLE_BINARY_IARCHIVE_HPP

example/portable_binary_oarchive.cpp

@@ -0,0 +1,93 @@
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// portable_binary_oarchive.cpp
+
+// (C) Copyright 2002-7 Robert Ramey - http://www.rrsd.com . 
+// Use, modification and distribution is subject to 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)
+
+//  See http://www.boost.org for updates, documentation, and revision history.
+
+#include <ostream>
+#include <boost/detail/endian.hpp>
+#include "portable_binary_oarchive.hpp"
+
+void 
+portable_binary_oarchive::save_impl(
+    const boost::intmax_t l,
+    const char maxsize
+){
+    char size = 0;
+
+    if(l == 0){
+        this->primitive_base_t::save(size);
+        return;
+    }
+
+    boost::intmax_t ll;
+    bool negative = (l < 0);
+    if(negative)
+        ll = -l;
+    else
+        ll = l;
+
+    do{
+        ll >>= CHAR_BIT;
+        ++size;
+    }while(ll != 0);
+
+    this->primitive_base_t::save(
+        static_cast<char>(negative ? -size : size)
+    );
+
+    if(negative)
+        ll = -l;
+    else
+        ll = l;
+    char * cptr = reinterpret_cast<char *>(& ll);
+    #ifdef BOOST_BIG_ENDIAN
+        cptr += (sizeof(boost::intmax_t) - size);
+        if(m_flags & endian_little)
+            reverse_bytes(size, cptr);
+    #else
+        if(m_flags & endian_big)
+            reverse_bytes(size, cptr);
+    #endif
+    this->primitive_base_t::save_binary(cptr, size);
+}
+
+void 
+portable_binary_oarchive::init(unsigned int flags) {
+    if(m_flags == (endian_big | endian_little)){
+        boost::serialization::throw_exception(
+            portable_binary_oarchive_exception()
+        );
+    }
+    if(0 == (flags & boost::archive::no_header)){
+        // write signature in an archive version independent manner
+        const std::string file_signature(
+            boost::archive::BOOST_ARCHIVE_SIGNATURE()
+        );
+        * this << file_signature;
+        // write library version
+        const boost::archive::version_type v(
+            boost::archive::BOOST_ARCHIVE_VERSION()
+        );
+        * this << v;
+    }
+    save(static_cast<unsigned char>(m_flags >> CHAR_BIT));
+}
+
+#include <boost/archive/impl/basic_binary_oprimitive.ipp>
+
+namespace boost {
+namespace archive {
+
+template class basic_binary_oprimitive<
+    portable_binary_oarchive,
+    std::ostream::char_type, 
+    std::ostream::traits_type
+> ;
+
+} // namespace archive
+} // namespace boost

example/portable_binary_oarchive.hpp

@@ -6,6 +6,11 @@
 # pragma once
 #endif
 
+#if defined(_MSC_VER)
+#pragma warning( push )
+#pragma warning( disable : 4244 )
+#endif
+
 /////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
 // portable_binary_oarchive.hpp
 
@@ -17,9 +22,38 @@
 //  See http://www.boost.org for updates, documentation, and revision history.
 
 #include <ostream>
+#include <boost/serialization/string.hpp>
 #include <boost/archive/archive_exception.hpp>
-#include <boost/archive/binary_oarchive.hpp>
-#include <boost/detail/endian.hpp>
+#include <boost/archive/basic_binary_oprimitive.hpp>
+#include <boost/archive/detail/common_oarchive.hpp>
+#include <boost/archive/detail/register_archive.hpp>
+
+#include "portable_binary_archive.hpp"
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// exception to be thrown if integer read from archive doesn't fit
+// variable being loaded
+class portable_binary_oarchive_exception : 
+    public virtual boost::archive::archive_exception
+{
+public:
+    typedef enum {
+        invalid_flags 
+    } exception_code;
+    portable_binary_oarchive_exception(exception_code c = invalid_flags )
+    {}
+    virtual const char *what( ) const throw( )
+    {
+        const char *msg = "programmer error";
+        switch(code){
+        case invalid_flags:
+            msg = "cannot be both big and little endian";
+        default:
+            boost::archive::archive_exception::what();
+        }
+        return msg;
+    }
+};
 
 /////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
 // "Portable" output binary archive.  This is a variation of the native binary 
@@ -27,65 +61,36 @@
 // be passed across systems. Note:floating point types not addressed here
 
 class portable_binary_oarchive :
-    // don't derive from binary_oarchive !!!
-    public boost::archive::binary_oarchive_impl<
-        portable_binary_oarchive, 
+    public boost::archive::basic_binary_oprimitive<
+        portable_binary_oarchive,
         std::ostream::char_type, 
         std::ostream::traits_type
+    >,
+    public boost::archive::detail::common_oarchive<
+        portable_binary_oarchive
     >
 {
-    typedef boost::archive::binary_oarchive_impl<
-        portable_binary_oarchive, 
-        std::ostream::char_type, 
-        std::ostream::traits_type
-    > archive_base_t;
     typedef boost::archive::basic_binary_oprimitive<
-        portable_binary_oarchive, 
+        portable_binary_oarchive,
         std::ostream::char_type, 
         std::ostream::traits_type
     > primitive_base_t;
+    typedef boost::archive::detail::common_oarchive<
+        portable_binary_oarchive
+    > archive_base_t;
 #ifndef BOOST_NO_MEMBER_TEMPLATE_FRIENDS
 public:
 #else
     friend archive_base_t;
     friend primitive_base_t; // since with override save below
-    friend class boost::archive::basic_binary_oarchive<portable_binary_oarchive>;
+    friend class boost::archive::detail::interface_oarchive<
+        portable_binary_oarchive
+    >;
     friend class boost::archive::save_access;
+protected:
 #endif
-    void save_impl(const long l){
-        long ll = l;
-        char size = 0;
-        if(l < 0){
-            // make sure that enough of data is output
-            // to include a high order bit indicating the sign
-            char x;
-            do{
-                x = ll;
-                ll >>= 8;
-                ++size;
-            }while(ll != -1 && x < 0);
-        }
-        else{
-            do{
-                ll >>= 8;
-                ++size;
-            }while(ll != 0);
-        }
-
-        this->archive_base_t::save(size);
-
-        // we choose to use litle endian
-        #ifdef BOOST_BIG_ENDIAN
-            char * first = static_cast<char *>(static_cast<void *>(& l));
-            char * last = first + sizeof(l) - 1;
-            for(;first < last;++first, --last){
-                char x = *last;
-                *last = *first;
-                *first = x;
-            }
-        #endif
-        save_binary(& l, size);
-    }
+    unsigned int m_flags;
+    void save_impl(const boost::intmax_t l, const char maxsize);
     // add base class to the places considered when matching
     // save function to a specific set of arguments.  Note, this didn't
     // work on my MSVC 7.0 system so we use the sure-fire method below
@@ -94,60 +99,94 @@ public:
     // default fall through for any types not specified here
     template<class T>
     void save(const T & t){
+        save_impl(t, sizeof(T));
+    }
+    void save(const std::string & t){
         this->primitive_base_t::save(t);
     }
-    void save(const short  t){
-        save_impl(t);
+    #ifndef BOOST_NO_STD_WSTRING
+    void save(const std::wstring & t){
+        this->primitive_base_t::save(t);
     }
-    void save(const unsigned short t){
-        save_impl(t);
+    #endif
+    void save(const float & t){
+        this->primitive_base_t::save(t);
+        // floats not supported
+        //BOOST_STATIC_ASSERT(false);
     }
-    void save(const unsigned int t){
-        save_impl(t);
+    void save(const double & t){
+        this->primitive_base_t::save(t);
+        // doubles not supported
+        //BOOST_STATIC_ASSERT(false);
     }
-    void save(const int t){
-        save_impl(t);
+    void save(const char & t){
+        this->primitive_base_t::save(t);
     }
-    void save(const unsigned long t){
-        save_impl(t);
+    void save(const unsigned char & t){
+        this->primitive_base_t::save(t);
     }
-    void save(const long t){
-        save_impl(t);
+
+    // default processing - kick back to base class.  Note the
+    // extra stuff to get it passed borland compilers
+    typedef boost::archive::detail::common_oarchive<portable_binary_oarchive> 
+        detail_common_oarchive;
+    template<class T>
+    void save_override(T & t, BOOST_PFTO int){
+        this->detail_common_oarchive::save_override(t, 0);
     }
+    // explicitly convert to char * to avoid compile ambiguities
+    void save_override(const boost::archive::class_name_type & t, int){
+        const std::string s(t);
+        * this << s;
+    }
+    // binary files don't include the optional information 
+    void save_override(
+        const boost::archive::class_id_optional_type & /* t */, 
+        int
+    ){}
+
+    void init(unsigned int flags);
 public:
     portable_binary_oarchive(std::ostream & os, unsigned flags = 0) :
-        archive_base_t(
-            os, 
-            flags | boost::archive::no_header // skip default header checking 
-        )
+        primitive_base_t(
+            * os.rdbuf(),
+            0 != (flags & boost::archive::no_codecvt)
+        ),
+        archive_base_t(flags),
+        m_flags(flags & (endian_big | endian_little))
     {
-        // use our own header checking
-        if(0 != (flags & boost::archive::no_header)){
-            this->archive_base_t::init(flags);
-            // skip the following for "portable" binary archives
-            // boost::archive::basic_binary_iprimitive<derived_t, std::ostream>::init();
-        }
+        init(flags);
+    }
+
+    portable_binary_oarchive(
+        std::basic_streambuf<
+            std::ostream::char_type, 
+            std::ostream::traits_type
+        > & bsb, 
+        unsigned int flags
+    ) :
+        primitive_base_t(
+            bsb, 
+            0 != (flags & boost::archive::no_codecvt)
+        ),
+        archive_base_t(flags),
+        m_flags(0)
+    {
+        init(flags);
     }
 };
 
-#include <boost/archive/impl/basic_binary_oarchive.ipp>
-#include <boost/archive/impl/archive_pointer_oserializer.ipp>
-#include <boost/archive/impl/basic_binary_oprimitive.ipp>
 
-namespace boost {
-namespace archive {
-
-// explicitly instantiate for this type of binary stream
-template class binary_oarchive_impl<
-    portable_binary_oarchive, 
-    std::ostream::char_type, 
-    std::ostream::traits_type
->;
-template class detail::archive_pointer_oserializer<portable_binary_oarchive> ;
-
-} // namespace archive
-} // namespace boost
+// required by export in boost version > 1.34
+#ifdef BOOST_SERIALIZATION_REGISTER_ARCHIVE
+    BOOST_SERIALIZATION_REGISTER_ARCHIVE(portable_binary_oarchive)
+#endif
 
+// required by export in boost <= 1.34
 #define BOOST_ARCHIVE_CUSTOM_OARCHIVE_TYPES portable_binary_oarchive
 
+#if defined(_MSC_VER)
+#pragma warning( pop )
+#endif
+
 #endif // PORTABLE_BINARY_OARCHIVE_HPP

example/simple_log_archive.hpp

@@ -0,0 +1,166 @@
+#ifndef BOOST_SIMPLE_LOG_ARCHIVE_HPP
+#define BOOST_SIMPLE_LOG_ARCHIVE_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+# pragma once
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// simple_log_archive.hpp
+
+// (C) Copyright 2010 Robert Ramey - http://www.rrsd.com . 
+// Use, modification and distribution is subject to 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)
+
+//  See http://www.boost.org for updates, documentation, and revision history.
+
+#include <ostream>
+#include <cstddef> // std::size_t
+
+#include <boost/config.hpp>
+#if defined(BOOST_NO_STDC_NAMESPACE)
+namespace std{ 
+    using ::size_t; 
+} // namespace std
+#endif
+
+#include <boost/type_traits/is_enum.hpp>
+#include <boost/mpl/bool.hpp>
+#include <boost/mpl/eval_if.hpp>
+#include <boost/mpl/int.hpp>
+#include <boost/mpl/equal_to.hpp>
+#include <boost/serialization/nvp.hpp>
+#include <boost/serialization/array.hpp>
+#include <boost/serialization/string.hpp>
+#include <boost/serialization/access.hpp>
+
+/////////////////////////////////////////////////////////////////////////
+// log data to an output stream.  This illustrates a simpler implemenation
+// of text output which is useful for getting a formatted display of
+// any serializable class.  Intended to be useful as a debugging aid.
+class simple_log_archive {
+    std::ostream & m_os;
+    unsigned int m_depth;
+
+    template<class Archive>
+    struct save_enum_type {
+        template<class T>
+        static void invoke(Archive &ar, const T &t){
+            ar.m_os << static_cast<int>(t);
+        }
+    };
+    template<class Archive>
+    struct save_primitive {
+        template<class T>
+        static void invoke(Archive & ar, const T & t){
+            ar.m_os << t;
+        }
+    };
+    template<class Archive>
+    struct save_only {
+        template<class T>
+        static void invoke(Archive & ar, const T & t){
+            // make sure call is routed through the highest interface that might
+            // be specialized by the user.
+            boost::serialization::serialize_adl(
+                ar, 
+                const_cast<T &>(t), 
+                ::boost::serialization::version<T>::value
+            );
+        }
+    };
+    template<class T>
+    void save(const T &t){
+        typedef 
+            BOOST_DEDUCED_TYPENAME boost::mpl::eval_if<boost::is_enum<T>,
+                boost::mpl::identity<save_enum_type<simple_log_archive> >,
+            //else
+            BOOST_DEDUCED_TYPENAME boost::mpl::eval_if<
+                // if its primitive
+                    boost::mpl::equal_to<
+                        boost::serialization::implementation_level<T>,
+                        boost::mpl::int_<boost::serialization::primitive_type>
+                    >,
+                    boost::mpl::identity<save_primitive<simple_log_archive> >,
+            // else
+                boost::mpl::identity<save_only<simple_log_archive> >
+            > >::type typex;
+        typex::invoke(*this, t);
+    }    
+    #ifndef BOOST_NO_STD_WSTRING
+    void save(const std::wstring &ws){
+        m_os << "wide string types not suported in log archive";
+    }
+    #endif
+
+public:
+    ///////////////////////////////////////////////////
+    // Implement requirements for archive concept
+
+    typedef boost::mpl::bool_<false> is_loading;
+    typedef boost::mpl::bool_<true> is_saving;
+
+    // this can be a no-op since we ignore pointer polymorphism
+    template<class T>
+    void register_type(const T * = NULL){}
+
+    unsigned int get_library_version(){
+        return 0;
+    }
+
+    void 
+    save_binary(const void *address, std::size_t count){
+        m_os << "save_binary not implemented";
+    }
+
+    // the << operators 
+    template<class T>
+    simple_log_archive & operator<<(T const & t){
+        m_os << ' ';
+        save(t);
+        return * this;
+    }
+    template<class T>
+    simple_log_archive & operator<<(T * const t){
+        m_os << " ->";
+        if(NULL == t)
+            m_os << " null";
+        else
+            *this << * t;
+        return * this;
+    }
+    template<class T, int N>
+    simple_log_archive & operator<<(const T (&t)[N]){
+        ar << serialization::make_array(
+            static_cast<value_type const*>(&t[0]),count
+        );
+    }
+    template<class T>
+    simple_log_archive & operator<<(const ::boost::serialization::nvp<T> & t){
+        m_os << '\n'; // start line with each named object
+        // indent according to object depth
+        for(unsigned int i = 0; i < m_depth; ++i)
+            m_os << ' ';
+        ++m_depth;
+        m_os << t.name(); // output the name of the object
+        * this << t.const_value();
+        --m_depth;
+        return * this;
+    }
+
+    // the & operator 
+    template<class T>
+    simple_log_archive & operator&(const T & t){
+            return * this << t;
+    }
+    ///////////////////////////////////////////////
+
+    simple_log_archive(std::ostream & os) :
+        m_os(os),
+        m_depth(0)
+    {}
+};
+
+#endif // BOOST_SIMPLE_LOG_ARCHIVE_HPP

include/boost/archive/archive_exception.hpp

@@ -18,6 +18,21 @@
 
 #include <exception>
 #include <cassert>
+#include <string>
+
+#include <boost/config.hpp> 
+#include <boost/preprocessor/empty.hpp>
+#include <boost/archive/detail/decl.hpp>
+
+// note: the only reason this is in here is that windows header
+// includes #define exception_code _exception_code (arrrgghhhh!).
+// the most expedient way to address this is be sure that this
+// header is always included whenever this header file is included.
+#if defined(BOOST_WINDOWS) 
+#include <excpt.h> 
+#endif 
+
+#include <boost/archive/detail/abi_prefix.hpp> // must be the last header
 
 namespace boost {
 namespace archive {
@@ -25,7 +40,7 @@ namespace archive {
 //////////////////////////////////////////////////////////////////////
 // exceptions thrown by archives
 //
-class archive_exception : 
+class BOOST_ARCHIVE_DECL(BOOST_PP_EMPTY()) archive_exception : 
     public virtual std::exception
 {
 public:
@@ -39,11 +54,10 @@ public:
         unsupported_version,// archive created with library version
                             // subsequent to this one
         pointer_conflict,   // an attempt has been made to directly
-                            // serialization::detail an object
-                            // after having already serialzed the same
-                            // object through a pointer.  Were this permited,
-                            // it the archive load would result in the
-                            // creation of an extra copy of the obect.
+                            // serialize an object which has
+                            // already been serialzed through a pointer.  
+                            // Were this permited, the archive load would result 
+                            // in the creation of an extra copy of the obect.
         incompatible_native_format, // attempt to read native binary format
                             // on incompatible platform
         array_size_too_short,// array being loaded doesn't fit in array allocated
@@ -51,65 +65,32 @@ public:
         invalid_class_name, // class name greater than the maximum permitted.
                             // most likely a corrupted archive or an attempt
                             // to insert virus via buffer overrun method.
-        unregistered_cast   // base - derived relationship not registered with 
+        unregistered_cast,   // base - derived relationship not registered with 
                             // void_cast_register
+        unsupported_class_version, // type saved with a version # greater than the 
+                            // one used by the program.  This indicates that the proggram
+                            // needs to be rebuilt.
+        multiple_code_instantiation // code for implementing serialization for some
+                            // type has been instantiated in more than one module.
     } exception_code;
-    exception_code code;
-    archive_exception(exception_code c) : 
-        code(c)
-    {}
-    virtual const char *what( ) const throw( )
-    {
-        const char *msg = "programming error";
-        switch(code){
-        case no_exception:
-            msg = "uninitialized exception";
-            break;
-        case unregistered_class:
-            msg = "unregistered class";
-            break;
-        case invalid_signature:
-            msg = "invalid signature";
-            break;
-        case unsupported_version:
-            msg = "unsupported version";
-            break;
-        case pointer_conflict:
-            msg = "pointer conflict";
-            break;
-        case incompatible_native_format:
-            msg = "incompatible native format";
-            break;
-        case array_size_too_short:
-            msg = "array size too short";
-            break;
-        case stream_error:
-            msg = "stream error";
-            break;
-        case invalid_class_name:
-            msg = "class name too long";
-            break;
-        case unregistered_cast:
-            msg = "unregistered void cast";
-            break;
-        case other_exception:
-            // if get here - it indicates a derived exception 
-            // was sliced by passing by value in catch
-            msg = "unknown derived exception";
-            break;
-        default:
-            assert(false);
-            break;
-        }
-        return msg;
-    }
 protected:
-    archive_exception() : 
-         code(no_exception)
-    {}
+    std::string m_msg;
+public:
+    exception_code code;
+    archive_exception(
+        exception_code c, 
+        const char * e1 = NULL,
+        const char * e2 = NULL
+    );
+    ~archive_exception() throw ();
+    virtual const char *what( ) const throw();
+protected:
+    archive_exception();
 };
 
 }// namespace archive
 }// namespace boost
 
+#include <boost/archive/detail/abi_suffix.hpp> // pops abi_suffix.hpp pragmas
+
 #endif //BOOST_ARCHIVE_ARCHIVE_EXCEPTION_HPP

include/boost/archive/array/iarchive.hpp

@@ -1,132 +0,0 @@
-#ifndef BOOST_ARCHIVE_ARRAY_IARCHIVE_HPP
-#define BOOST_ARCHIVE_ARRAY_IARCHIVE_HPP
-
-// (C) Copyright 2005 Matthias Troyer and Dave Abrahams
-// Use, modification and distribution is subject to 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)
-
-
-#include <boost/archive/basic_archive.hpp>
-#include <boost/archive/archive_exception.hpp>
-#include <boost/archive/detail/common_iarchive.hpp>
-#include <boost/serialization/nvp.hpp>
-#include <boost/serialization/array.hpp>
-#include <boost/serialization/collection_size_type.hpp>
-#include <boost/serialization/detail/get_data.hpp>
-#include <boost/type_traits/is_same.hpp>
-#include <boost/mpl/apply.hpp>
-#include <boost/mpl/bool.hpp>
-#include <boost/pfto.hpp>
-
-
-namespace boost { namespace archive { namespace array {
-
-  // To conveniently array-optimize an input archive X:
-  //
-  //   * Derive it from iarchive<X, Impl>, where Impl is an 
-  //     archive implementation base class from 
-  //     Boost.Serialization
-  //
-  //   * add a member function template that implements the
-  //     procedure for serializing arrays of T (for appropriate T)
-  //
-  //       template <class T>
-  //       load_array(serialization::array<T> &, unsigned int)
-  //
-  //   * add a unary MPL lambda expression member called
-  //     use_array_optimization whose result is convertible to
-  //     mpl::true_ iff array elements of type T can be serialized
-  //     with the load_array member function, and to mpl::false_ if
-  //     the unoptimized procedure must be used. 
-
-template <class Archive>
-class iarchive
- : public archive::detail::common_iarchive<Archive>
-{
-  typedef archive::detail::common_iarchive<Archive> Base;
-public:
-  iarchive(unsigned int flags)
-   : archive::detail::common_iarchive<Archive>(flags)
-  {}
-
-
-  // save_override for std::vector and serialization::array dispatches to 
-  // save_optimized with an additional argument.
-  // 
-  // If that argument is of type mpl::true_, an optimized serialization is provided
-  // If it is false, we just forward to the default serialization in the base class
-  
-  //the default version dispatches to the base class
-  template<class T>
-  void load_optimized(T &t, unsigned int version, mpl::false_)
-  {
-    Base::load_override(t, version);
-  }
-
-  // the optimized implementation for vector uses serialization::array
-  template<class U, class Allocator>
-  void load_optimized(
-    std::vector<U, Allocator> &t, unsigned int version, mpl::true_)
-  {
-    t.clear();
-    // retrieve number of elements
-    serialization::collection_size_type count;
-    *this->This() >> BOOST_SERIALIZATION_NVP(count);
-    t.resize(count);
-    if (!t.empty())
-      * this->This() >> serialization::make_array(serialization::detail::get_data(t),t.size());
-  }
-
-  // the optimized implementation for serialization::array uses save_array
-  template<class ValueType>
-  void load_optimized(
-    serialization::array<ValueType> &t, unsigned int version, mpl::true_)
-  {
-    this->This()->load_array(t,version);
-  }
-
-
-  // to load a vector:
-  // if the value type is trivially constructable or an optimized array save exists, 
-  // then we can use the optimized version
-
-  template<class ValueType, class Allocator>
-  void load_override(std::vector<ValueType,Allocator> &x, unsigned int version)
-  {
-    typedef typename mpl::and_<
-      mpl::not_<is_same<ValueType,bool> >,
-      mpl::apply1<
-        BOOST_DEDUCED_TYPENAME Archive::use_array_optimization
-      , ValueType>
-    >::type use_optimized;
-    load_optimized(x,version, use_optimized() );   
-  }
-  
-  
-  // dispatch loading of arrays to the optimized version where supported
-  template<class ValueType>
-  void load_override(serialization::array<ValueType> const& x, unsigned int version)
-  {
-    typedef typename mpl::apply1<
-        BOOST_DEDUCED_TYPENAME Archive::use_array_optimization
-      , ValueType
-    >::type use_optimized;
-    load_optimized(const_cast<serialization::array<ValueType>&>(x),version,use_optimized());
-  }
-
-  // Load everything else in the usual way, forwarding on to the base class
-  template<class T>
-  void load_override(T & x, unsigned BOOST_PFTO int version)
-  {
-    Base::load_override(x, static_cast<unsigned int>(version));
-  }
-};
-
-
-} } } // end namespace boost::archive::array
-
-
-
-#endif // BOOST_ARCHIVE_ARRAY_OARCHIVE_HPP
-

include/boost/archive/array/oarchive.hpp

@@ -1,130 +0,0 @@
-#ifndef BOOST_ARCHIVE_ARRAY_OARCHIVE_HPP
-#define BOOST_ARCHIVE_ARRAY_OARCHIVE_HPP
-
-// (C) Copyright 2005 Matthias Troyer and Dave Abrahams
-// Use, modification and distribution is subject to 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)
-
-
-#include <boost/archive/basic_archive.hpp>
-#include <boost/archive/detail/common_oarchive.hpp>
-#include <boost/serialization/array.hpp>
-#include <boost/serialization/collection_size_type.hpp>
-#include <boost/serialization/nvp.hpp>
-#include <boost/serialization/detail/get_data.hpp>
-#include <boost/type_traits/remove_const.hpp>
-#include <boost/type_traits/is_same.hpp>
-#include <boost/mpl/apply.hpp>
-#include <boost/mpl/bool.hpp>
-#include <boost/pfto.hpp>
-
-namespace boost { namespace archive { namespace array {
-
-  // To conveniently array-optimize an output archive X:
-  //
-  //   * Derive it from oarchive<X, Impl>, where Impl is an 
-  //     archive implementation base class from 
-  //     Boost.Serialization
-  //
-  //   * add a member function template that implements the
-  //     procedure for serializing arrays of T (for appropriate T)
-  //
-  //       template <class T>
-  //       save_array(serialization::array<T> const &, unsigned int)
-  //
-  //   * add a unary MPL lambda expression member called
-  //     use_array_optimization whose result is convertible to
-  //     mpl::true_ iff array elements of type T can be serialized
-  //     with the load_array member function, and to mpl::false_ if
-  //     the unoptimized procedure must be used. 
-
-template <class Archive>
-class oarchive
- : public archive::detail::common_oarchive<Archive>
-{
-  typedef archive::detail::common_oarchive<Archive> Base;
-public:
-
-  oarchive(unsigned int flags)
-   : archive::detail::common_oarchive<Archive>(flags)
-  {}
-  
-  // save_override for std::vector and serialization::array dispatches to 
-  // save_optimized with an additional argument.
-  // 
-  // If that argument is of type mpl::true_, an optimized serialization is provided
-  // If it is false, we just forward to the default serialization in the base class
-  
-  //the default version dispatches to the base class
-  template<class T>
-  void save_optimized(T const &t, unsigned int version, mpl::false_)
-  {
-    Base::save_override(t, version);
-  }
-
-
-  // the optimized implementation for vector uses serialization::array
-  template<class ValueType, class Allocator>
-  void save_optimized(
-    const std::vector<ValueType, Allocator> &t, unsigned int, mpl::true_)
-  {
-    const serialization::collection_size_type count(t.size());
-    * this->This() << BOOST_SERIALIZATION_NVP(count);
-    if (!t.empty())
-      * this->This() << serialization::make_array(serialization::detail::get_data(t),t.size());
-  }
-
-  // the optimized implementation for serialization::array uses save_array
-  template<class ValueType>
-  void save_optimized(
-    const serialization::array<ValueType> &t, unsigned int version, mpl::true_)
-  {
-    this->This()->save_array(t,version);
-  }
-
-
-  // to save a vector:
-  // if the value type is trivially constructable or an optimized array save exists, 
-  // then we can use the optimized version
-
-  template<class ValueType, class Allocator>
-  void save_override(std::vector<ValueType,Allocator> const &x, unsigned int version)
-  {
-    typedef BOOST_DEDUCED_TYPENAME remove_const<ValueType>::type value_type;
-    typedef typename mpl::and_<
-      mpl::not_<is_same<value_type,bool> >,
-      mpl::apply1<
-        BOOST_DEDUCED_TYPENAME Archive::use_array_optimization
-      , value_type>
-    >::type use_optimized;
-    save_optimized(x,version,use_optimized() );   
-  }
-
-  
-  
-  // dispatch saving of arrays to the optimized version where supported
-  template<class ValueType>
-  void save_override(serialization::array<ValueType> const& x, unsigned int version)
-  {
-    typedef typename mpl::apply1<
-        BOOST_DEDUCED_TYPENAME Archive::use_array_optimization
-      , BOOST_DEDUCED_TYPENAME remove_const<ValueType>::type
-    >::type use_optimized;
-    save_optimized(x,version,use_optimized());
-  }
-
-  // Load everything else in the usual way, forwarding on to the
-  // Base class
-  template<class T>
-  void save_override(T const& x, unsigned BOOST_PFTO int version)
-  {
-    Base::save_override(x, static_cast<unsigned int>(version));
-  }
-};
-
-} } } // end namespace boost::archive::array
-
-
-#endif // BOOST_ARCHIVE_ARRAY_OARCHIVE_HPP
-

include/boost/archive/basic_archive.hpp

@@ -17,24 +17,38 @@
 //  See http://www.boost.org for updates, documentation, and revision history.
 
 #include <boost/config.hpp>
-#include <boost/strong_typedef.hpp>
+#include <boost/cstdint.hpp>
 #include <boost/noncopyable.hpp>
+#include <boost/integer_traits.hpp>
+#include <boost/serialization/strong_typedef.hpp>
 
 #include <boost/archive/detail/auto_link_archive.hpp>
 #include <boost/archive/detail/abi_prefix.hpp> // must be the last header
 
+#define BOOST_ARCHIVE_STRONG_TYPEDEF(T, D)        \
+namespace boost {                                 \
+namespace archive {                               \
+BOOST_STRONG_TYPEDEF(T, D)                        \
+} /* archive */                                   \
+template<>                                        \
+class integer_traits<boost::archive::D>  :        \
+    public integer_traits<boost::T>               \
+{};                                               \
+} /* boost */                                     \
+/**/
+
+BOOST_ARCHIVE_STRONG_TYPEDEF(uint_least16_t, version_type)
+BOOST_ARCHIVE_STRONG_TYPEDEF(int_least16_t, class_id_type)
+BOOST_ARCHIVE_STRONG_TYPEDEF(int_least16_t, class_id_optional_type)
+BOOST_ARCHIVE_STRONG_TYPEDEF(int_least16_t, class_id_reference_type)
+BOOST_ARCHIVE_STRONG_TYPEDEF(uint_least32_t, object_id_type)
+BOOST_ARCHIVE_STRONG_TYPEDEF(uint_least32_t, object_reference_type)
+
 namespace boost {
 namespace archive {
 
-BOOST_STRONG_TYPEDEF(unsigned int, version_type)
-BOOST_STRONG_TYPEDEF(int, class_id_type)
-BOOST_STRONG_TYPEDEF(int, class_id_optional_type)
-BOOST_STRONG_TYPEDEF(int, class_id_reference_type)
-BOOST_STRONG_TYPEDEF(unsigned int, object_id_type)
-BOOST_STRONG_TYPEDEF(unsigned int, object_reference_type)
-
 struct tracking_type {
-    typedef bool value_type;
+//    typedef bool value_type;
     bool t;
     explicit tracking_type(const bool t_ = false)
         : t(t_)
@@ -64,7 +78,9 @@ struct tracking_type {
     }
 };
 
-struct class_name_type : private boost::noncopyable {
+struct class_name_type : 
+    private boost::noncopyable 
+{
     char *t;
     operator const char * & () const {
         return const_cast<const char * &>(t);
@@ -86,17 +102,17 @@ enum archive_flags {
     no_header = 1,  // suppress archive header info
     no_codecvt = 2,  // suppress alteration of codecvt facet
     no_xml_tag_checking = 4,   // suppress checking of xml tags
-    no_tracking = 8           // suppress ALL tracking
-//    no_object_creation = 16    // don't create any new objects
+    no_tracking = 8,           // suppress ALL tracking
+    flags_last = 8
 };
 
 #define NULL_POINTER_TAG class_id_type(-1)
 
 BOOST_ARCHIVE_DECL(const char *)
-ARCHIVE_SIGNATURE();
+BOOST_ARCHIVE_SIGNATURE();
 
-BOOST_ARCHIVE_DECL(unsigned char)
-ARCHIVE_VERSION();
+BOOST_ARCHIVE_DECL(version_type)
+BOOST_ARCHIVE_VERSION();
 
 }// namespace archive
 }// namespace boost

include/boost/archive/basic_binary_iarchive.hpp

@@ -22,15 +22,20 @@
 // http://www.boost.org/LICENSE_1_0.txt)
 
 //  See http://www.boost.org for updates, documentation, and revision history.
-//#include <cstring>
 
 #include <boost/config.hpp>
 #include <boost/detail/workaround.hpp>
-#include <boost/pfto.hpp>
+#include <boost/serialization/pfto.hpp>
 
-#include <boost/serialization/string.hpp>
+#include <boost/archive/detail/common_iarchive.hpp>
 #include <boost/serialization/collection_size_type.hpp>
-#include <boost/archive/array/iarchive.hpp>
+#include <boost/serialization/string.hpp>
+
+#ifdef BOOST_MSVC
+#  pragma warning(push)
+#  pragma warning(disable : 4511 4512)
+#endif
+
 #include <boost/archive/detail/abi_prefix.hpp> // must be the last header
 
 namespace boost { 
@@ -40,7 +45,7 @@ namespace archive {
 // class basic_binary_iarchive - read serialized objects from a input binary stream
 template<class Archive>
 class basic_binary_iarchive : 
-    public array::iarchive<Archive>
+    public detail::common_iarchive<Archive>
 {
 protected:
 #if BOOST_WORKAROUND(BOOST_MSVC, <= 1300)
@@ -56,10 +61,10 @@ public:
     // fot templates in the absence of partial function 
     // template ordering. If we get here pass to base class
     // note extra nonsense to sneak it pass the borland compiers
-    typedef array::iarchive<Archive> array_iarchive;
+    typedef detail::common_iarchive<Archive> detail_common_iarchive;
     template<class T>
-    void load_override(T & t, BOOST_PFTO int){
-        this->array_iarchive::load_override(t, 0);
+    void load_override(T & t, BOOST_PFTO int version){
+      this->detail_common_iarchive::load_override(t, static_cast<int>(version));
     }
     // binary files don't include the optional information 
     void load_override(class_id_optional_type & /* t */, int){}
@@ -101,11 +106,18 @@ public:
         * this->This() >> x;
         t = (0 != x);
     }
-  void load_override(serialization::collection_size_type & t, int){
-       unsigned int x=0;
-       * this->This() >> x;
-       t = serialization::collection_size_type(x);
-   }
+    void load_override(serialization::collection_size_type & t, int){
+      if (this->get_library_version() < 6) {
+        unsigned int x=0;
+        * this->This() >> x;
+        t = serialization::collection_size_type(x);
+      } 
+      else {
+        std::size_t x=0;
+        * this->This() >> x;
+        t = serialization::collection_size_type(x);
+      }
+    }
 
     BOOST_ARCHIVE_OR_WARCHIVE_DECL(void)
     load_override(class_name_type & t, int);
@@ -113,13 +125,17 @@ public:
     init();
    
     basic_binary_iarchive(unsigned int flags) :
-        array_iarchive(flags)
+        detail::common_iarchive<Archive>(flags)
     {}
 };
 
 } // namespace archive
 } // namespace boost
 
+#ifdef BOOST_MSVC
+#pragma warning(pop)
+#endif
+
 #include <boost/archive/detail/abi_suffix.hpp> // pops abi_suffix.hpp pragmas
 
 #endif // BOOST_ARCHIVE_BASIC_BINARY_IARCHIVE_HPP

include/boost/archive/basic_binary_iprimitive.hpp

@@ -6,6 +6,10 @@
 # pragma once
 #endif
 
+#if defined(_MSC_VER)
+#pragma warning( disable : 4800 )
+#endif
+
 /////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
 // basic_binary_iprimitive.hpp
 //
@@ -41,15 +45,15 @@ namespace std{
 
 #include <boost/cstdint.hpp>
 #include <boost/scoped_ptr.hpp>
-#include <boost/throw_exception.hpp>
-//#include <boost/limits.hpp>
-//#include <boost/io/ios_state.hpp>
+#include <boost/serialization/throw_exception.hpp>
+#include <boost/integer.hpp>
+#include <boost/integer_traits.hpp>
 
 #include <boost/archive/basic_streambuf_locale_saver.hpp>
 #include <boost/archive/archive_exception.hpp>
 #include <boost/archive/detail/auto_link_archive.hpp>
 #include <boost/mpl/placeholders.hpp>
-#include <boost/type_traits/is_fundamental.hpp>
+#include <boost/serialization/is_bitwise_serializable.hpp>
 #include <boost/serialization/array.hpp>
 #include <boost/archive/detail/abi_prefix.hpp> // must be the last header
 
@@ -72,8 +76,11 @@ public:
     Archive * This(){
         return static_cast<Archive *>(this);
     }
+
+    #ifndef BOOST_NO_STD_LOCALE
     boost::scoped_ptr<std::locale> archive_locale;
     basic_streambuf_locale_saver<Elem, Tr> locale_saver;
+    #endif
 
     // main template for serilization of primitive types
     template<class T>
@@ -113,7 +120,18 @@ public:
     ~basic_binary_iprimitive();
 public:
     // we provide an optimized load for all fundamental types
-    typedef is_fundamental<mpl::_1> use_array_optimization;
+    // typedef serialization::is_bitwise_serializable<mpl::_1> 
+    // use_array_optimization;
+    struct use_array_optimization {  
+        template <class T>  
+        #if defined(BOOST_NO_DEPENDENT_NESTED_DERIVATIONS)  
+            struct apply {  
+                typedef BOOST_DEDUCED_TYPENAME boost::serialization::is_bitwise_serializable<T>::type type;  
+            };
+        #else
+            struct apply : public boost::serialization::is_bitwise_serializable<T> {};  
+        #endif
+    };
 
     // the optimized load_array dispatches to load_binary 
     template <class ValueType>
@@ -132,56 +150,41 @@ basic_binary_iprimitive<Archive, Elem, Tr>::load_binary(
     void *address, 
     std::size_t count
 ){
-#if 0
+    // note: an optimizer should eliminate the following for char files
     assert(
-        static_cast<std::size_t>((std::numeric_limits<std::streamsize>::max)()) >= count
+        static_cast<std::streamsize>(count / sizeof(Elem)) 
+        <= boost::integer_traits<std::streamsize>::const_max
     );
-    //if(is.fail())
-    //    boost::throw_exception(archive_exception(archive_exception::stream_error));
-    // note: an optimizer should eliminate the following for char files
-    std::size_t s = count / sizeof(BOOST_DEDUCED_TYPENAME IStream::char_type);
-    is.read(
-        static_cast<BOOST_DEDUCED_TYPENAME IStream::char_type *>(address), 
-        s
-    );
-    // note: an optimizer should eliminate the following for char files
-    s = count % sizeof(BOOST_DEDUCED_TYPENAME IStream::char_type);
-    if(0 < s){
-        if(is.fail())
-            boost::throw_exception(archive_exception(archive_exception::stream_error));
-        BOOST_DEDUCED_TYPENAME IStream::char_type t;
-        is.read(& t, 1);
-        std::memcpy(address, &t, s);
-    }
-#endif
-    // note: an optimizer should eliminate the following for char files
-    std::streamsize s = count / sizeof(Elem);
+    std::streamsize s = static_cast<std::streamsize>(count / sizeof(Elem));
     std::streamsize scount = m_sb.sgetn(
         static_cast<Elem *>(address), 
         s
     );
-    if(scount != static_cast<std::size_t>(s))
-        boost::throw_exception(
+    if(scount != s)
+        boost::serialization::throw_exception(
             archive_exception(archive_exception::stream_error)
         );
     // note: an optimizer should eliminate the following for char files
-    s = count % sizeof(Elem);
+    assert(count % sizeof(Elem) <= boost::integer_traits<std::streamsize>::const_max);
+    s = static_cast<std::streamsize>(count % sizeof(Elem));
     if(0 < s){
 //        if(is.fail())
-//            boost::throw_exception(archive_exception(archive_exception::stream_error));
+//            boost::serialization::throw_exception(
+//                archive_exception(archive_exception::stream_error)
+//        );
         Elem t;
         scount = m_sb.sgetn(& t, 1);
         if(scount != 1)
-            boost::throw_exception(
+            boost::serialization::throw_exception(
                 archive_exception(archive_exception::stream_error)
             );
-        std::memcpy(address, &t, s);
+        std::memcpy(static_cast<char*>(address) + (count - s), &t, s);
     }
 }
 
 } // namespace archive
 } // namespace boost
 
-#include <boost/archive/detail/abi_suffix.hpp> // pop pragams
+#include <boost/archive/detail/abi_suffix.hpp> // pop pragmas
 
 #endif // BOOST_ARCHIVE_BINARY_IPRIMITIVE_HPP

include/boost/archive/basic_binary_oarchive.hpp

@@ -23,14 +23,24 @@
 // IN GENERAL, ARCHIVES CREATED WITH THIS CLASS WILL NOT BE READABLE
 // ON PLATFORM APART FROM THE ONE THEY ARE CREATE ON
 
+#include <cassert>
+#include <boost/integer.hpp>
+#include <boost/integer_traits.hpp>
+
 #include <boost/config.hpp>
-#include <boost/pfto.hpp>
+#include <boost/serialization/pfto.hpp>
 
 #include <boost/detail/workaround.hpp>
-#include <boost/archive/array/oarchive.hpp>
+#include <boost/archive/detail/common_oarchive.hpp>
 #include <boost/serialization/string.hpp>
 #include <boost/serialization/collection_size_type.hpp>
-#include <boost/archive/array/oarchive.hpp>
+
+#include <boost/archive/detail/abi_prefix.hpp> // must be the last header
+
+#ifdef BOOST_MSVC
+#  pragma warning(push)
+#  pragma warning(disable : 4511 4512)
+#endif
 
 namespace boost {
 namespace archive {
@@ -45,7 +55,7 @@ namespace archive {
 // of time.  So under some circumstances it may be he right choice.
 template<class Archive>
 class basic_binary_oarchive : 
-    public array::oarchive<Archive>
+    public archive::detail::common_oarchive<Archive>
 {
 protected:
 #if BOOST_WORKAROUND(BOOST_MSVC, <= 1300)
@@ -58,42 +68,44 @@ public:
     friend class detail::interface_oarchive<Archive>;
 #endif
     // any datatype not specifed below will be handled by base class
-    typedef array::oarchive<Archive> array_oarchive;
+    typedef detail::common_oarchive<Archive> detail_common_oarchive;
     template<class T>
-    void save_override(const T & t, BOOST_PFTO int){
-        this->array_oarchive::save_override(t, 0);
-    }
-    template<class T>
-    void save_override(T & t, BOOST_PFTO int){
-        this->save_override(const_cast<const T &>(t), 0);
+    void save_override(const T & t, BOOST_PFTO int version){
+      this->detail_common_oarchive::save_override(t, static_cast<int>(version));
     }
+
     // binary files don't include the optional information 
     void save_override(const class_id_optional_type & /* t */, int){}
 
     void save_override(const version_type & t, int){
         // upto 255 versions
         // note:t.t resolves borland ambguity
-        const unsigned char x = t.t;
+        assert(t.t < boost::integer_traits<unsigned char>::const_max);
+        const unsigned char x = static_cast<const unsigned char>(t.t);
         * this->This() << x;
     }
     void save_override(const class_id_type & t, int){
         // upto 32K classes
-        const int_least16_t x = t.t;
+        assert(t.t < boost::integer_traits<boost::int_least16_t>::const_max);
+        const boost::int_least16_t x = static_cast<const boost::int_least16_t>(t.t); 
         * this->This() << x;
     }
     void save_override(const class_id_reference_type & t, int){
         // upto 32K classes
-        const int_least16_t x = t.t;
+        assert(t.t < boost::integer_traits<boost::int_least16_t>::const_max);
+        const boost::int_least16_t x = t.t;
         * this->This() << x;
     }
     void save_override(const object_id_type & t, int){
         // upto 2G objects
-        const uint_least32_t x = t.t;
+        assert(t.t < boost::integer_traits<boost::uint_least32_t>::const_max);
+        const boost::uint_least32_t x = t.t;
         * this->This() << x;
     }
     void save_override(const object_reference_type & t, int){
         // upto 2G objects
-        uint_least32_t x = t.t;
+        assert(t.t < boost::integer_traits<boost::uint_least32_t>::const_max);
+        const boost::uint_least32_t x = t.t;
         * this->This() << x;
     }
     void save_override(const tracking_type & t, int){
@@ -109,7 +121,7 @@ public:
 
     void save_override(const serialization::collection_size_type & t, int){
     // for backward compatibility, 64 bit integer or variable length integer would be preferred
-        unsigned int x = t.t;
+        std::size_t x = t.t;
         * this->This() << x;
    }
 
@@ -117,11 +129,17 @@ public:
     init();
 
     basic_binary_oarchive(unsigned int flags) :
-        array_oarchive(flags)
+        detail::common_oarchive<Archive>(flags)
     {}
 };
 
 } // namespace archive
 } // namespace boost
 
+#ifdef BOOST_MSVC
+#pragma warning(pop)
+#endif
+
+#include <boost/archive/detail/abi_suffix.hpp> // pops abi_suffix.hpp pragmas
+
 #endif // BOOST_ARCHIVE_BASIC_BINARY_OARCHIVE_HPP

include/boost/archive/basic_binary_oprimitive.hpp

@@ -26,9 +26,9 @@
 #include <iosfwd>
 #include <cassert>
 #include <locale>
-#include <cstddef> // size_t
 #include <streambuf> // basic_streambuf
 #include <string>
+#include <cstddef> // size_t
 
 #include <boost/config.hpp>
 #if defined(BOOST_NO_STDC_NAMESPACE)
@@ -38,15 +38,15 @@ namespace std{
 #endif
 
 #include <boost/cstdint.hpp>
-//#include <boost/limits.hpp>
-//#include <boost/io/ios_state.hpp>
+#include <boost/integer.hpp>
+#include <boost/integer_traits.hpp>
 #include <boost/scoped_ptr.hpp>
-#include <boost/throw_exception.hpp>
+#include <boost/serialization/throw_exception.hpp>
 
 #include <boost/archive/basic_streambuf_locale_saver.hpp>
 #include <boost/archive/archive_exception.hpp>
 #include <boost/archive/detail/auto_link_archive.hpp>
-#include <boost/type_traits/is_fundamental.hpp>
+#include <boost/serialization/is_bitwise_serializable.hpp>
 #include <boost/mpl/placeholders.hpp>
 #include <boost/serialization/array.hpp>
 #include <boost/archive/detail/abi_prefix.hpp> // must be the last header
@@ -71,9 +71,10 @@ public:
     Archive * This(){
         return static_cast<Archive *>(this);
     }
+    #ifndef BOOST_NO_STD_LOCALE
     boost::scoped_ptr<std::locale> archive_locale;
     basic_streambuf_locale_saver<Elem, Tr> locale_saver;
-
+    #endif
     // default saving of primitives.
     template<class T>
     void save(const T & t)
@@ -87,8 +88,7 @@ public:
     // trap usage of invalid uninitialized boolean which would
     // otherwise crash on load.
     void save(const bool t){
-        int i = t;
-        assert(0 == i || 1 == i);
+        assert(0 == static_cast<int>(t) || 1 == static_cast<int>(t));
         save_binary(& t, sizeof(t));
     }
     BOOST_ARCHIVE_OR_WARCHIVE_DECL(void)
@@ -113,12 +113,26 @@ public:
     BOOST_ARCHIVE_OR_WARCHIVE_DECL(BOOST_PP_EMPTY()) 
     ~basic_binary_oprimitive();
 public:
+
     // we provide an optimized save for all fundamental types
-    typedef is_fundamental<mpl::_1> use_array_optimization;
+    // typedef serialization::is_bitwise_serializable<mpl::_1> 
+    // use_array_optimization;
+    // workaround without using mpl lambdas
+    struct use_array_optimization {
+        template <class T>  
+        #if defined(BOOST_NO_DEPENDENT_NESTED_DERIVATIONS)  
+            struct apply {  
+                typedef BOOST_DEDUCED_TYPENAME boost::serialization::is_bitwise_serializable<T>::type type;  
+            };
+        #else
+            struct apply : public boost::serialization::is_bitwise_serializable<T> {};  
+        #endif
+    };
+    
 
     // the optimized save_array dispatches to save_binary 
     template <class ValueType>
-    void save_array(serialization::array<ValueType> const& a, unsigned int)
+    void save_array(boost::serialization::array<ValueType> const& a, unsigned int)
     {
       save_binary(a.address(),a.count()*sizeof(ValueType));
     }
@@ -140,16 +154,21 @@ basic_binary_oprimitive<Archive, Elem, Tr>::save_binary(
     // mode where by cr characters recieve special treatment.
     // be sure that the output stream is opened with ios::binary
     //if(os.fail())
-    //    boost::throw_exception(archive_exception(archive_exception::stream_error));
+    //    boost::serialization::throw_exception(
+    //        archive_exception(archive_exception::stream_error)
+    //    );
     // figure number of elements to output - round up
     count = ( count + sizeof(Elem) - 1) 
         / sizeof(Elem);
+    assert(count <= std::size_t(boost::integer_traits<std::streamsize>::const_max));
     std::streamsize scount = m_sb.sputn(
         static_cast<const Elem *>(address), 
-        count
+        static_cast<std::streamsize>(count)
     );
     if(count != static_cast<std::size_t>(scount))
-        boost::throw_exception(archive_exception(archive_exception::stream_error));
+        boost::serialization::throw_exception(
+            archive_exception(archive_exception::stream_error)
+        );
     //os.write(
     //    static_cast<const BOOST_DEDUCED_TYPENAME OStream::char_type *>(address), 
     //    count
@@ -160,6 +179,6 @@ basic_binary_oprimitive<Archive, Elem, Tr>::save_binary(
 } //namespace boost 
 } //namespace archive 
 
-#include <boost/archive/detail/abi_suffix.hpp> // pop pragams
+#include <boost/archive/detail/abi_suffix.hpp> // pop pragmas
 
 #endif // BOOST_ARCHIVE_BASIC_BINARY_OPRIMITIVE_HPP

include/boost/archive/basic_streambuf_locale_saver.hpp

@@ -25,16 +25,24 @@
 //  See <http://www.boost.org/libs/io/> for the library's home page.
 
 #ifndef BOOST_NO_STD_LOCALE
+
 #include <locale>     // for std::locale
-#endif
 #include <streambuf>  // for std::basic_streambuf
 
+#include <boost/config.hpp>
+#include <boost/noncopyable.hpp>
+
+#ifdef BOOST_MSVC
+#  pragma warning(push)
+#  pragma warning(disable : 4511 4512)
+#endif
+
 namespace boost{
 namespace archive{
 
-#ifndef BOOST_NO_STD_LOCALE
 template < typename Ch, class Tr >
-class basic_streambuf_locale_saver
+class basic_streambuf_locale_saver :
+    private boost::noncopyable
 {
 public:
     typedef ::std::basic_streambuf<Ch, Tr> state_type;
@@ -57,5 +65,9 @@ private:
 } // archive
 } // boost
 
+#ifdef BOOST_MSVC
+#pragma warning(pop)
+#endif
+
 #endif // BOOST_NO_STD_LOCALE
 #endif // BOOST_ARCHIVE_BASIC_STREAMBUF_LOCALE_SAVER_HPP

include/boost/archive/basic_text_iarchive.hpp

@@ -25,7 +25,7 @@
 // use two template parameters
 
 #include <boost/config.hpp>
-#include <boost/pfto.hpp>
+#include <boost/serialization/pfto.hpp>
 #include <boost/detail/workaround.hpp>
 
 #include <boost/archive/detail/common_iarchive.hpp>
@@ -33,6 +33,11 @@
 
 #include <boost/archive/detail/abi_prefix.hpp> // must be the last header
 
+#ifdef BOOST_MSVC
+#  pragma warning(push)
+#  pragma warning(disable : 4511 4512)
+#endif
+
 namespace boost {
 namespace archive {
 
@@ -61,16 +66,6 @@ public:
     {
         this->detail_common_iarchive::load_override(t, 0);
     }
-#if 0
-    // Borland compilers has a problem with strong type.  Try to fix this here
-    #if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x582))
-    void load_override(version_type & t, int){ 
-        unsigned int x;
-        * this->This() >> x;
-        t.t = version_type(x);
-    }
-    #endif
-#endif
     // text file don't include the optional information 
     void load_override(class_id_optional_type & /*t*/, int){}
 
@@ -89,6 +84,10 @@ public:
 } // namespace archive
 } // namespace boost
 
+#ifdef BOOST_MSVC
+#pragma warning(pop)
+#endif
+
 #include <boost/archive/detail/abi_suffix.hpp> // pops abi_suffix.hpp pragmas
 
 #endif // BOOST_ARCHIVE_BASIC_TEXT_IARCHIVE_HPP

include/boost/archive/basic_text_iprimitive.hpp

@@ -16,11 +16,11 @@
 
 //  See http://www.boost.org for updates, documentation, and revision history.
 
-// archives stored as text - note these ar templated on the basic
+// archives stored as text - note these are templated on the basic
 // stream templates to accommodate wide (and other?) kind of characters
 //
-// note the fact that on libraries without wide characters, ostream is
-// is not a specialization of basic_ostream which in fact is not defined
+// Note the fact that on libraries without wide characters, ostream is
+// not a specialization of basic_ostream which in fact is not defined
 // in such cases.   So we can't use basic_ostream<IStream::char_type> but rather
 // use two template parameters
 
@@ -43,13 +43,14 @@ namespace std{
 #include <boost/archive/dinkumware.hpp>
 #endif
 
-#include <boost/throw_exception.hpp>
 #include <boost/limits.hpp>
 #include <boost/io/ios_state.hpp>
 #include <boost/scoped_ptr.hpp>
 
+#include <boost/serialization/collection_size_type.hpp>
+#include <boost/serialization/throw_exception.hpp>
 #include <boost/archive/archive_exception.hpp>
-
+#include <boost/archive/basic_streambuf_locale_saver.hpp>
 #include <boost/archive/detail/abi_prefix.hpp> // must be the last header
 
 namespace boost {
@@ -68,21 +69,30 @@ public:
     IStream &is;
     io::ios_flags_saver flags_saver;
     io::ios_precision_saver precision_saver;
+
+    #ifndef BOOST_NO_STD_LOCALE
     boost::scoped_ptr<std::locale> archive_locale;
-    io::basic_ios_locale_saver<
-        BOOST_DEDUCED_TYPENAME IStream::char_type, BOOST_DEDUCED_TYPENAME IStream::traits_type
+    basic_streambuf_locale_saver<
+        BOOST_DEDUCED_TYPENAME IStream::char_type, 
+        BOOST_DEDUCED_TYPENAME IStream::traits_type
     > locale_saver;
+    #endif
+
     template<class T>
     void load(T & t)
     {
         if(is.fail())
-            boost::throw_exception(archive_exception(archive_exception::stream_error));
+            boost::serialization::throw_exception(
+                archive_exception(archive_exception::stream_error)
+            );
         is >> t;
     }
     void load(unsigned char & t)
     {
         if(is.fail())
-            boost::throw_exception(archive_exception(archive_exception::stream_error));
+            boost::serialization::throw_exception(
+                archive_exception(archive_exception::stream_error)
+            );
         unsigned short int i;
         is >> i;
         t = static_cast<unsigned char>(i);
@@ -90,7 +100,9 @@ public:
     void load(signed char & t)
     {
         if(is.fail())
-            boost::throw_exception(archive_exception(archive_exception::stream_error));
+            boost::serialization::throw_exception(
+                archive_exception(archive_exception::stream_error)
+            );
         signed short int i;
         is >> i;
         t = static_cast<signed char>(i);
@@ -98,7 +110,9 @@ public:
     void load(char & t)
     {
         if(is.fail())
-            boost::throw_exception(archive_exception(archive_exception::stream_error));
+            boost::serialization::throw_exception(
+                archive_exception(archive_exception::stream_error)
+            );
         short int i;
         is >> i;
         t = static_cast<char>(i);
@@ -107,7 +121,9 @@ public:
     void load(wchar_t & t)
     {
         if(is.fail())
-            boost::throw_exception(archive_exception(archive_exception::stream_error));
+            boost::serialization::throw_exception(
+                archive_exception(archive_exception::stream_error)
+            );
         unsigned i;
         is >> i;
         t = static_cast<wchar_t>(i);
@@ -125,6 +141,6 @@ public:
 } // namespace archive
 } // namespace boost
 
-#include <boost/archive/detail/abi_suffix.hpp> // pop pragams
+#include <boost/archive/detail/abi_suffix.hpp> // pop pragmas
 
 #endif // BOOST_ARCHIVE_BASIC_TEXT_IPRIMITIVE_HPP

include/boost/archive/basic_text_oarchive.hpp

@@ -26,7 +26,7 @@
 
 #include <cassert>
 #include <boost/config.hpp>
-#include <boost/pfto.hpp>
+#include <boost/serialization/pfto.hpp>
 #include <boost/detail/workaround.hpp>
 
 #include <boost/archive/detail/common_oarchive.hpp>
@@ -34,11 +34,16 @@
 
 #include <boost/archive/detail/abi_prefix.hpp> // must be the last header
 
+#ifdef BOOST_MSVC
+#  pragma warning(push)
+#  pragma warning(disable : 4511 4512)
+#endif
+
 namespace boost {
 namespace archive {
 
 /////////////////////////////////////////////////////////////////////////
-// class basic_text_iarchive - read serialized objects from a input text stream
+// class basic_text_oarchive 
 template<class Archive>
 class basic_text_oarchive : 
     public detail::common_oarchive<Archive>
@@ -129,6 +134,10 @@ public:
 } // namespace archive
 } // namespace boost
 
+#ifdef BOOST_MSVC
+#pragma warning(pop)
+#endif
+
 #include <boost/archive/detail/abi_suffix.hpp> // pops abi_suffix.hpp pragmas
 
 #endif // BOOST_ARCHIVE_BASIC_TEXT_OARCHIVE_HPP

include/boost/archive/basic_text_oprimitive.hpp

@@ -26,9 +26,10 @@
 
 #include <iomanip>
 #include <locale>
-#include <cstddef> // size_t
-#include <cmath> // isnan
+#include <boost/config/no_tr1/cmath.hpp> // isnan
 #include <cassert>
+#include <cstddef> // size_t
+#include <boost/serialization/collection_size_type.hpp>
 
 #include <boost/config.hpp>
 #include <boost/detail/workaround.hpp>
@@ -48,9 +49,9 @@ namespace std{
 #include <boost/limits.hpp>
 #include <boost/io/ios_state.hpp>
 #include <boost/scoped_ptr.hpp>
-#include <boost/throw_exception.hpp>
+#include <boost/serialization/throw_exception.hpp>
 #include <boost/archive/archive_exception.hpp>
-
+#include <boost/archive/basic_streambuf_locale_saver.hpp>
 #include <boost/archive/detail/abi_prefix.hpp> // must be the last header
 
 namespace boost {
@@ -71,16 +72,22 @@ public:
     OStream &os;
     io::ios_flags_saver flags_saver;
     io::ios_precision_saver precision_saver;
+
+    #ifndef BOOST_NO_STD_LOCALE
     boost::scoped_ptr<std::locale> archive_locale;
-    io::basic_ios_locale_saver<
-        BOOST_DEDUCED_TYPENAME OStream::char_type, BOOST_DEDUCED_TYPENAME OStream::traits_type
+    basic_streambuf_locale_saver<
+        BOOST_DEDUCED_TYPENAME OStream::char_type, 
+        BOOST_DEDUCED_TYPENAME OStream::traits_type
     > locale_saver;
+    #endif
 
     // default saving of primitives.
     template<class T>
     void save(const T &t){
         if(os.fail())
-            boost::throw_exception(archive_exception(archive_exception::stream_error));
+            boost::serialization::throw_exception(
+                archive_exception(archive_exception::stream_error)
+            );
         os << t;
     }
 
@@ -89,35 +96,44 @@ public:
     void save(const bool t){
         // trap usage of invalid uninitialized boolean which would
         // otherwise crash on load.
-        int i = t;
-        assert(0 == i || 1 == i);
+        assert(0 == static_cast<int>(t) || 1 == static_cast<int>(t));
         if(os.fail())
-            boost::throw_exception(archive_exception(archive_exception::stream_error));
+            boost::serialization::throw_exception(
+                archive_exception(archive_exception::stream_error)
+            );
         os << t;
     }
     void save(const signed char t)
     {
         if(os.fail())
-            boost::throw_exception(archive_exception(archive_exception::stream_error));
+            boost::serialization::throw_exception(
+                archive_exception(archive_exception::stream_error)
+            );
         os << static_cast<short int>(t);
     }
     void save(const unsigned char t)
     {
         if(os.fail())
-            boost::throw_exception(archive_exception(archive_exception::stream_error));
+            boost::serialization::throw_exception(
+                archive_exception(archive_exception::stream_error)
+            );
         os << static_cast<short unsigned int>(t);
     }
     void save(const char t)
     {
         if(os.fail())
-            boost::throw_exception(archive_exception(archive_exception::stream_error));
+            boost::serialization::throw_exception(
+                archive_exception(archive_exception::stream_error)
+            );
         os << static_cast<short int>(t);
     }
     #ifndef BOOST_NO_INTRINSIC_WCHAR_T
     void save(const wchar_t t)
     {
         if(os.fail())
-            boost::throw_exception(archive_exception(archive_exception::stream_error));
+            boost::serialization::throw_exception(
+                archive_exception(archive_exception::stream_error)
+            );
         os << static_cast<int>(t);
     }
     #endif
@@ -125,7 +141,9 @@ public:
     {
         // must be a user mistake - can't serialize un-initialized data
         if(os.fail())
-            boost::throw_exception(archive_exception(archive_exception::stream_error));
+            boost::serialization::throw_exception(
+                archive_exception(archive_exception::stream_error)
+            );
         os << std::setprecision(std::numeric_limits<float>::digits10 + 2);
         os << t;
     }
@@ -133,7 +151,9 @@ public:
     {
         // must be a user mistake - can't serialize un-initialized data
         if(os.fail())
-            boost::throw_exception(archive_exception(archive_exception::stream_error));
+            boost::serialization::throw_exception(
+                archive_exception(archive_exception::stream_error)
+            );
         os << std::setprecision(std::numeric_limits<double>::digits10 + 2);
         os << t;
     }
@@ -143,15 +163,19 @@ public:
     ~basic_text_oprimitive();
 public:
     // unformatted append of one character
-    void put(int c){
+    void put(BOOST_DEDUCED_TYPENAME OStream::char_type c){
         if(os.fail())
-            boost::throw_exception(archive_exception(archive_exception::stream_error));
+            boost::serialization::throw_exception(
+                archive_exception(archive_exception::stream_error)
+            );
         os.put(c);
     }
     // unformatted append of null terminated string
     void put(const char * s){
         if(os.fail())
-            boost::throw_exception(archive_exception(archive_exception::stream_error));
+            boost::serialization::throw_exception(
+                archive_exception(archive_exception::stream_error)
+            );
         while('\0' != *s)
             os.put(*s++);
     }

include/boost/archive/basic_xml_archive.hpp

@@ -24,74 +24,39 @@
 namespace boost { 
 namespace archive {
 
-//////////////////////////////////////////////////////////////////////
-// exceptions thrown by xml archives
-//
-class xml_archive_exception : 
-    public virtual archive_exception
-{
-public:
-    typedef enum {
-        xml_archive_parsing_error,    // see save_register
-        xml_archive_tag_mismatch,
-        xml_archive_tag_name_error
-    } exception_code;
-    xml_archive_exception(exception_code c)
-    {}
-    virtual const char *what( ) const throw( )
-    {
-        const char *msg;
-        switch(code){
-        case xml_archive_parsing_error:
-            msg = "unrecognized XML syntax";
-            break;
-        case xml_archive_tag_mismatch:
-            msg = "XML start/end tag mismatch";
-            break;
-        case xml_archive_tag_name_error:
-            msg = "Invalid XML tag name";
-            break;
-        default:
-            msg = archive_exception::what();
-            break;
-        }
-        return msg;
-    }
-};
-
 // constant strings used in xml i/o
 
 extern 
 BOOST_ARCHIVE_DECL(const char *)
-OBJECT_ID();
+BOOST_ARCHIVE_XML_OBJECT_ID();
 
 extern 
 BOOST_ARCHIVE_DECL(const char *)
-OBJECT_REFERENCE();
+BOOST_ARCHIVE_XML_OBJECT_REFERENCE();
 
 extern 
 BOOST_ARCHIVE_DECL(const char *)
-CLASS_ID();
+BOOST_ARCHIVE_XML_CLASS_ID();
 
 extern 
 BOOST_ARCHIVE_DECL(const char *)
-CLASS_ID_REFERENCE();
+BOOST_ARCHIVE_XML_CLASS_ID_REFERENCE();
 
 extern 
 BOOST_ARCHIVE_DECL(const char *)
-CLASS_NAME();
+BOOST_ARCHIVE_XML_CLASS_NAME();
 
 extern 
 BOOST_ARCHIVE_DECL(const char *)
-TRACKING();
+BOOST_ARCHIVE_XML_TRACKING();
 
 extern 
 BOOST_ARCHIVE_DECL(const char *)
-VERSION();
+BOOST_ARCHIVE_XML_VERSION();
 
 extern 
 BOOST_ARCHIVE_DECL(const char *)
-SIGNATURE();
+BOOST_ARCHIVE_XML_SIGNATURE();
 
 }// namespace archive
 }// namespace boost

include/boost/archive/basic_xml_iarchive.hpp

@@ -17,7 +17,7 @@
 //  See http://www.boost.org for updates, documentation, and revision history.
 
 #include <boost/config.hpp>
-#include <boost/pfto.hpp>
+#include <boost/serialization/pfto.hpp>
 #include <boost/detail/workaround.hpp>
 
 #include <boost/archive/detail/common_iarchive.hpp>
@@ -29,6 +29,11 @@
 
 #include <boost/archive/detail/abi_prefix.hpp> // must be the last header
 
+#ifdef BOOST_MSVC
+#  pragma warning(push)
+#  pragma warning(disable : 4511 4512)
+#endif
+
 namespace boost {
 namespace archive {
 
@@ -77,9 +82,9 @@ public:
         boost::serialization::nvp<T> & t,
         int
     ){
-        load_start(t.name());
+        this->This()->load_start(t.name());
         this->detail_common_iarchive::load_override(t.value(), 0);
-        load_end(t.name());
+        this->This()->load_end(t.name());
     }
 
     // specific overrides for attributes - handle as
@@ -113,6 +118,10 @@ public:
 } // namespace archive
 } // namespace boost
 
+#ifdef BOOST_MSVC
+#pragma warning(pop)
+#endif
+
 #include <boost/archive/detail/abi_suffix.hpp> // pops abi_suffix.hpp pragmas
 
 #endif // BOOST_ARCHIVE_BASIC_XML_IARCHIVE_HPP

include/boost/archive/basic_xml_oarchive.hpp

@@ -28,6 +28,10 @@
 
 #include <boost/archive/detail/abi_prefix.hpp> // must be the last header
 
+#ifdef BOOST_MSVC
+#  pragma warning(push)
+#  pragma warning(disable : 4511 4512)
+#endif
 
 namespace boost {
 namespace archive {
@@ -99,9 +103,9 @@ public:
         ::boost::serialization::nvp<T> & t,
         int
     ){
-        save_start(t.name());
+        this->This()->save_start(t.name());
         this->detail_common_oarchive::save_override(t.const_value(), 0);
-        save_end(t.name());
+        this->This()->save_end(t.name());
     }
 
     // specific overrides for attributes - not name value pairs so we
@@ -132,6 +136,10 @@ public:
 } // namespace archive
 } // namespace boost
 
+#ifdef BOOST_MSVC
+#pragma warning(pop)
+#endif
+
 #include <boost/archive/detail/abi_suffix.hpp> // pops abi_suffix.hpp pragmas
 
 #endif // BOOST_ARCHIVE_BASIC_XML_OARCHIVE_HPP

include/boost/archive/binary_iarchive.hpp

@@ -18,6 +18,12 @@
 
 #include <istream>
 #include <boost/archive/binary_iarchive_impl.hpp>
+#include <boost/archive/detail/register_archive.hpp>
+
+#ifdef BOOST_MSVC
+#  pragma warning(push)
+#  pragma warning(disable : 4511 4512)
+#endif
 
 namespace boost { 
 namespace archive {
@@ -88,5 +94,10 @@ public:
 
 // required by export
 BOOST_SERIALIZATION_REGISTER_ARCHIVE(boost::archive::binary_iarchive)
+BOOST_SERIALIZATION_USE_ARRAY_OPTIMIZATION(boost::archive::binary_iarchive)
+
+#ifdef BOOST_MSVC
+#pragma warning(pop)
+#endif
 
 #endif // BOOST_ARCHIVE_BINARY_IARCHIVE_HPP

include/boost/archive/binary_iarchive_impl.hpp

@@ -17,10 +17,15 @@
 //  See http://www.boost.org for updates, documentation, and revision history.
 
 #include <istream>
-#include <boost/pfto.hpp>
+#include <boost/serialization/pfto.hpp>
 #include <boost/archive/basic_binary_iprimitive.hpp>
 #include <boost/archive/basic_binary_iarchive.hpp>
 
+#ifdef BOOST_MSVC
+#  pragma warning(push)
+#  pragma warning(disable : 4511 4512)
+#endif
+
 namespace boost { 
 namespace archive {
 
@@ -42,7 +47,7 @@ protected:
     // make this protected so it can be called from a derived archive
     template<class T>
     void load_override(T & t, BOOST_PFTO int){
-        basic_binary_iarchive<Archive>::load_override(t, 0);
+        this->basic_binary_iarchive<Archive>::load_override(t, 0L);
     }
     void init(unsigned int flags){
         if(0 != (flags & no_header))
@@ -84,4 +89,8 @@ protected:
 } // namespace archive
 } // namespace boost
 
+#ifdef BOOST_MSVC
+#pragma warning(pop)
+#endif
+
 #endif // BOOST_ARCHIVE_BINARY_IARCHIVE_IMPL_HPP

include/boost/archive/binary_oarchive.hpp

@@ -17,7 +17,14 @@
 //  See http://www.boost.org for updates, documentation, and revision history.
 
 #include <ostream>
+#include <boost/config.hpp>
 #include <boost/archive/binary_oarchive_impl.hpp>
+#include <boost/archive/detail/register_archive.hpp>
+
+#ifdef BOOST_MSVC
+#  pragma warning(push)
+#  pragma warning(disable : 4511 4512)
+#endif
 
 namespace boost { 
 namespace archive {
@@ -50,5 +57,10 @@ typedef binary_oarchive naked_binary_oarchive;
 
 // required by export
 BOOST_SERIALIZATION_REGISTER_ARCHIVE(boost::archive::binary_oarchive)
+BOOST_SERIALIZATION_USE_ARRAY_OPTIMIZATION(boost::archive::binary_oarchive)
+
+#ifdef BOOST_MSVC
+#pragma warning(pop)
+#endif
 
 #endif // BOOST_ARCHIVE_BINARY_OARCHIVE_HPP

include/boost/archive/binary_oarchive_impl.hpp

@@ -17,10 +17,16 @@
 //  See http://www.boost.org for updates, documentation, and revision history.
 
 #include <ostream>
-#include <boost/pfto.hpp>
+#include <boost/config.hpp>
+#include <boost/serialization/pfto.hpp>
 #include <boost/archive/basic_binary_oprimitive.hpp>
 #include <boost/archive/basic_binary_oarchive.hpp>
 
+#ifdef BOOST_MSVC
+#  pragma warning(push)
+#  pragma warning(disable : 4511 4512)
+#endif
+
 namespace boost { 
 namespace archive {
 
@@ -42,7 +48,7 @@ protected:
     // make this protected so it can be called from a derived archive
     template<class T>
     void save_override(T & t, BOOST_PFTO int){
-        basic_binary_oarchive<Archive>::save_override(t, 0);
+        this->basic_binary_oarchive<Archive>::save_override(t, 0L);
     }
     void init(unsigned int flags) {
         if(0 != (flags & no_header))
@@ -84,4 +90,8 @@ protected:
 } // namespace archive
 } // namespace boost
 
+#ifdef BOOST_MSVC
+#pragma warning(pop)
+#endif
+
 #endif // BOOST_ARCHIVE_BINARY_OARCHIVE_IMPL_HPP

include/boost/archive/binary_wiarchive.hpp

@@ -23,6 +23,7 @@
 
 #include <istream> // wistream
 #include <boost/archive/binary_iarchive_impl.hpp>
+#include <boost/archive/detail/register_archive.hpp>
 
 namespace boost { 
 namespace archive {

include/boost/archive/binary_woarchive.hpp

@@ -23,6 +23,7 @@
 
 #include <ostream>
 #include <boost/archive/binary_oarchive_impl.hpp>
+#include <boost/archive/detail/register_archive.hpp>
 
 namespace boost { 
 namespace archive {

include/boost/archive/codecvt_null.hpp

@@ -17,25 +17,28 @@
 //  See http://www.boost.org for updates, documentation, and revision history.
 
 #include <locale>
-#include <cstddef>
-
+#include <cstddef> // NULL, size_t
+#include <cwchar>   // for mbstate_t
 #include <boost/config.hpp>
+#include <boost/archive/detail/auto_link_archive.hpp>
+#include <boost/archive/detail/abi_prefix.hpp> // must be the last header
 
-namespace std{
-    #if defined(__LIBCOMO__)
-        using ::mbstate_t;
-    #elif defined(__QNXNTO__)
-        //using std::mbstate_t;
-    #elif defined(BOOST_DINKUMWARE_STDLIB) && BOOST_DINKUMWARE_STDLIB == 1
-        using ::mbstate_t;
-    #elif defined(__SGI_STL_PORT)
-    #elif defined(BOOST_NO_STDC_NAMESPACE)
-        using ::codecvt;
-        using ::mbstate_t;
-    #elif defined(BOOST_RWSTD_VER)
-        using ::mbstate_t;
-   #endif
-} // namespace std
+#if defined(BOOST_NO_STDC_NAMESPACE)
+namespace std {
+// For STLport on WinCE, BOOST_NO_STDC_NAMESPACE can get defined if STLport is putting symbols in its own namespace.
+// In the case of codecvt, however, this does not mean that codecvt is in the global namespace (it will be in STLport's namespace)
+#  if !defined(__SGI_STL_PORT) && !defined(_STLPORT_VERSION)
+    using ::codecvt;
+#  endif
+    using ::mbstate_t;
+    using ::size_t;
+} // namespace
+#endif
+
+#ifdef BOOST_MSVC
+#  pragma warning(push)
+#  pragma warning(disable : 4511 4512)
+#endif
 
 namespace boost {
 namespace archive {
@@ -58,7 +61,7 @@ public:
 template<>
 class codecvt_null<wchar_t> : public std::codecvt<wchar_t, char, std::mbstate_t>
 {
-    virtual std::codecvt_base::result
+    virtual BOOST_WARCHIVE_DECL(std::codecvt_base::result)
     do_out(
         std::mbstate_t & state,
         const wchar_t * first1,
@@ -68,7 +71,7 @@ class codecvt_null<wchar_t> : public std::codecvt<wchar_t, char, std::mbstate_t>
         char * last2,
         char * & next2
     ) const;
-    virtual std::codecvt_base::result
+    virtual BOOST_WARCHIVE_DECL(std::codecvt_base::result)
     do_in(
         std::mbstate_t & state,
         const char * first1,
@@ -89,4 +92,9 @@ class codecvt_null<wchar_t> : public std::codecvt<wchar_t, char, std::mbstate_t>
 } // namespace archive
 } // namespace boost
 
+#ifdef BOOST_MSVC
+#  pragma warning(pop)
+#endif
+#include <boost/archive/detail/abi_suffix.hpp> // pop pragmas
+
 #endif //BOOST_ARCHIVE_CODECVT_NULL_HPP

include/boost/archive/detail/archive_pointer_iserializer.hpp

@@ -1,92 +0,0 @@
-#ifndef BOOST_ARCHIVE_ARCHIVE_POINTER_ISERIALIZER_POINTER_HPP
-#define BOOST_ARCHIVE_ARCHIVE_POINTER_ISERIALIZER_POINTER_HPP
-
-// MS compatible compilers support #pragma once
-#if defined(_MSC_VER) && (_MSC_VER >= 1020)
-# pragma once
-#endif
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// archive_pointer_iserializer.hpp
-
-// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
-// Use, modification and distribution is subject to 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)
-
-//  See http://www.boost.org for updates, documentation, and revision history.
-
-#include <cassert>
-#include <boost/config.hpp>
-#include <boost/detail/workaround.hpp>
-
-#include <boost/archive/detail/basic_serializer.hpp>
-#include <boost/archive/detail/basic_pointer_iserializer.hpp>
-
-#include <boost/archive/detail/abi_prefix.hpp> // must be the last header
-
-namespace boost {
-
-namespace serialization {
-    class extended_type_info;
-} // namespace serialization
-
-namespace archive {
-namespace detail {
-
-template<class Archive>
-class archive_pointer_iserializer : 
-    public basic_pointer_iserializer {
-protected:
-    explicit BOOST_ARCHIVE_OR_WARCHIVE_DECL(BOOST_PP_EMPTY()) 
-    archive_pointer_iserializer(
-        const boost::serialization::extended_type_info & eti
-    );
-    BOOST_ARCHIVE_OR_WARCHIVE_DECL(BOOST_PP_EMPTY()) 
-    // account for bogus gcc warning
-    #if defined(__GNUC__)
-    virtual
-    #endif
-    ~archive_pointer_iserializer();
-public:
-    virtual const basic_iserializer & get_basic_serializer() const 
-    // mscvc 6.0 requires template functions to be implemented. For this
-    // reason we can't make abstract.
-    #if BOOST_WORKAROUND(BOOST_MSVC, <= 1300) || defined(__MWERKS__)
-    {
-        assert(false);
-        return *static_cast<const basic_iserializer *>(NULL);
-    }
-    #else
-    = 0;
-    #endif
-    virtual void load_object_ptr(
-        basic_iarchive  & ar, 
-        void * & x,
-        const unsigned int file_version
-    ) const 
-    #if BOOST_WORKAROUND(BOOST_MSVC, <= 1300) || defined(__MWERKS__)
-    {
-        assert(false);
-    }
-    #else
-    = 0;
-    #endif
-    // return the type_extended load pointer corresponding to a given
-    // type_info.  returns NULL if there is no such instance. This
-    // would indicate that the no object of the specified type was loaded
-    // any where in the code.
-    static
-    BOOST_ARCHIVE_OR_WARCHIVE_DECL(const basic_pointer_iserializer *)
-    find(
-        const boost::serialization::extended_type_info & eti
-    );
-};
-
-} // namespace detail
-} // namespace archive
-} // namespace boost
-
-#include <boost/archive/detail/abi_suffix.hpp> // pops abi_suffix.hpp pragmas
-
-#endif // BOOST_ARCHIVE_ARCHIVE_POINTER_ISERIALIZER_POINTER_HPP

include/boost/archive/detail/archive_pointer_oserializer.hpp

@@ -1,67 +0,0 @@
-#ifndef BOOST_ARCHIVE_ARCHIVE_POINTER_OSERIALIZER_POINTER_HPP
-#define BOOST_ARCHIVE_ARCHIVE_POINTER_OSERIALIZER_POINTER_HPP
-
-// MS compatible compilers support #pragma once
-#if defined(_MSC_VER) && (_MSC_VER >= 1020)
-# pragma once
-#endif
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// archive_pointer_oserializer.hpp: extenstion of type_info required for 
-// serialization.
-
-// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
-// Use, modification and distribution is subject to 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)
-
-//  See http://www.boost.org for updates, documentation, and revision history.
-
-#include <boost/config.hpp>
-#include <boost/archive/detail/basic_serializer.hpp>
-#include <boost/archive/detail/basic_pointer_oserializer.hpp>
-
-#include <boost/archive/detail/abi_prefix.hpp> // must be the last header
-
-namespace boost {
-
-namespace serialization {
-    class extended_type_info;
-} // namespace serialization
-
-namespace archive {
-namespace detail {
-
-template<class Archive>
-class archive_pointer_oserializer : 
-    public basic_pointer_oserializer {
-protected:
-    explicit BOOST_ARCHIVE_OR_WARCHIVE_DECL(BOOST_PP_EMPTY()) 
-    archive_pointer_oserializer(
-        const boost::serialization::extended_type_info & eti
-    );
-    BOOST_ARCHIVE_OR_WARCHIVE_DECL(BOOST_PP_EMPTY()) 
-    // account for bogus gcc warning
-    #if defined(__GNUC__)
-    virtual
-    #endif
-    ~archive_pointer_oserializer();
-public:
-    // return the type_extended save pointer corresponding to a give
-    // type_info.  returns NULL, if there is no such instance. This
-    // would indicate that the no object of the specified type was saved
-    // any where in the code.
-    static 
-    BOOST_ARCHIVE_OR_WARCHIVE_DECL(const basic_pointer_oserializer *)
-    find(
-        const boost::serialization::extended_type_info & eti
-    );
-};
-
-} // namespace detail
-} // namespace archive
-} // namespace boost
-
-#include <boost/archive/detail/abi_suffix.hpp> // pops abi_suffix.hpp pragmas
-
-#endif // BOOST_ARCHIVE_ARCHIVE_POINTER_OSERIALIZER_POINTER_HPP

include/boost/archive/detail/archive_serializer_map.hpp

@@ -0,0 +1,55 @@
+#ifndef BOOST_ARCHIVE_SERIALIZER_MAP_HPP
+#define BOOST_ARCHIVE_SERIALIZER_MAP_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+# pragma once
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// archive_serializer_map.hpp: extenstion of type_info required for 
+// serialization.
+
+// (C) Copyright 2009 Robert Ramey - http://www.rrsd.com . 
+// Use, modification and distribution is subject to 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)
+
+//  See http://www.boost.org for updates, documentation, and revision history.
+
+// note: this is nothing more than the thinest of wrappers around
+// basic_serializer_map so we can have a one map / archive type. 
+
+#include <boost/config.hpp>
+#include <boost/archive/detail/auto_link_archive.hpp>
+#include <boost/archive/detail/abi_prefix.hpp> // must be the last header
+
+namespace boost {
+
+namespace serialization {
+    class extended_type_info;
+} // namespace serialization
+
+namespace archive {
+namespace detail {
+
+class basic_serializer;
+
+template<class Archive>
+class BOOST_ARCHIVE_OR_WARCHIVE_DECL(BOOST_PP_EMPTY()) 
+archive_serializer_map {
+public:
+    static bool insert(const basic_serializer * bs);
+    static void erase(const basic_serializer * bs);
+    static const basic_serializer * find(
+        const boost::serialization::extended_type_info & type_
+    );
+};
+
+} // namespace detail
+} // namespace archive
+} // namespace boost
+
+#include <boost/archive/detail/abi_suffix.hpp> // must be the last header
+
+#endif //BOOST_ARCHIVE_SERIALIZER_MAP_HPP

include/boost/archive/detail/auto_link_archive.hpp

@@ -9,7 +9,7 @@
 /////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
 //  auto_link_archive.hpp
 //
-//  © Copyright Robert Ramey 2004
+//  (c) Copyright Robert Ramey 2004
 //  Use, modification, and distribution is subject to 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)
@@ -25,23 +25,24 @@
 
 #include <boost/archive/detail/decl.hpp>
 
-#if !defined(BOOST_ARCHIVE_SOURCE) \
-&& !defined(BOOST_ALL_NO_LIB) && !defined(BOOST_SERIALIZATION_NO_LIB)
+#if !defined(BOOST_ALL_NO_LIB) && !defined(BOOST_SERIALIZATION_NO_LIB) \
+&&  !defined(BOOST_ARCHIVE_SOURCE) && !defined(BOOST_WARCHIVE_SOURCE)  \
+&&  !defined(BOOST_SERIALIZATION_SOURCE)
 
-// Set the name of our library, this will get undef'ed by auto_link.hpp
-// once it's done with it:
-//
-#define BOOST_LIB_NAME boost_serialization
-//
-// If we're importing code from a dll, then tell auto_link.hpp about it:
-//
-#if defined(BOOST_ALL_DYN_LINK) || defined(BOOST_SERIALIZATION_DYN_LINK)
-#  define BOOST_DYN_LINK
-#endif
-//
-// And include the header that does the work:
-//
-#include <boost/config/auto_link.hpp>
+    // Set the name of our library, this will get undef'ed by auto_link.hpp
+    // once it's done with it:
+    //
+    #define BOOST_LIB_NAME boost_serialization
+    //
+    // If we're importing code from a dll, then tell auto_link.hpp about it:
+    //
+    #if defined(BOOST_ALL_DYN_LINK) || defined(BOOST_SERIALIZATION_DYN_LINK)
+    #  define BOOST_DYN_LINK
+    #endif
+    //
+    // And include the header that does the work:
+    //
+    #include <boost/config/auto_link.hpp>
 #endif  // auto-linking disabled
 
 #endif // ARCHIVE_DETAIL_AUTO_LINK_ARCHIVE_HPP

include/boost/archive/detail/auto_link_warchive.hpp

@@ -9,7 +9,7 @@
 /////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
 //  auto_link_warchive.hpp
 //
-//  © Copyright Robert Ramey 2004
+//  (c) Copyright Robert Ramey 2004
 //  Use, modification, and distribution is subject to 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)

include/boost/archive/detail/basic_config.hpp

@@ -8,7 +8,7 @@
 
 //  basic_config.hpp  ---------------------------------------------//
 
-//  © Copyright Robert Ramey 2004
+//  (c) Copyright Robert Ramey 2004
 //  Use, modification, and distribution is subject to 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)