Simplify no wstreambuf support.

See https://github.com/boostorg/serialization/pull/224.
fix address sanitizer exception when loading corrupted XML archive. GitHub issue #257
2026-07-23 13:54:08 +00:00 · 2023-04-29 13:38:11 +01:00 · 2022-09-16 16:15:50 -07:00 · 2022-09-15 15:34:25 -07:00 · 2022-09-15 14:08:31 -07:00 · 2022-09-15 13:43:28 -07:00
140 changed files with 568 additions and 686 deletions
@@ -20,41 +20,47 @@ jobs:
        include:
          - toolset: gcc-4.7
            cxxstd: "03,11"
-            os: ubuntu-16.04
+            os: ubuntu-18.04
            install: g++-4.7
          - toolset: gcc-4.8
            cxxstd: "03,11"
-            os: ubuntu-16.04
+            os: ubuntu-18.04
            install: g++-4.8
          - toolset: gcc-4.9
            cxxstd: "03,11"
-            os: ubuntu-16.04
+            os: ubuntu-18.04
            install: g++-4.9
          - toolset: gcc-5
            cxxstd: "03,11,14,1z"
-            os: ubuntu-16.04
+            os: ubuntu-18.04
          - toolset: gcc-6
            cxxstd: "03,11,14,1z"
-            os: ubuntu-16.04
+            os: ubuntu-18.04
            install: g++-6
          - toolset: gcc-7
            cxxstd: "03,11,14,17"
            os: ubuntu-18.04
+            install: g++-7
          - toolset: gcc-8
            cxxstd: "03,11,14,17,2a"
            os: ubuntu-18.04
+            install: g++-8
          - toolset: gcc-9
            cxxstd: "03,11,14,17,2a"
            os: ubuntu-18.04
+            install: g++-9
          - toolset: gcc-10
            cxxstd: "03,11,14,17,2a"
            os: ubuntu-18.04
+            install: g++-10
          - toolset: clang
            cxxstd: "03,11,14,17,2a"
            os: ubuntu-18.04
+            install: clang
          - toolset: clang
            cxxstd: "03,11,14,17,2a"
            os: macos-10.15
+            install: clang

    runs-on: ${{matrix.os}}

@@ -12,6 +12,8 @@ project boost/serialization
      <conditional>@include-spirit
 ;

+import ../../config/checks/config : requires ;
+
 SPIRIT_ROOT = [ modules.peek : SPIRIT_ROOT ] ;
 rule include-spirit ( properties * )
 {
@@ -88,7 +90,7 @@ SOURCES =
    codecvt_null
 ;

-SOURCES_HAS_STD_LOCALE = 
+SOURCES_HAS_STD_WSTREAMBUF = 
    xml_oarchive
    utf8_codecvt_facet
 ;
@@ -105,51 +107,14 @@ WSOURCES =
    xml_woarchive
    polymorphic_xml_wiarchive
    polymorphic_xml_woarchive
+    $(SOURCES_HAS_STD_WSTREAMBUF)
 ;

-rule has-config-flag ( flag : properties * )
-{
-    if ( "<define>$(flag)" in $(properties) || "<define>$(flag)=1" in $(properties) )
-    {
-        return 1 ;
-    }
-    else
-    {
-        return ;
-    }
-}
-
-rule select-define-specific-sources ( properties * )
-{
-    local result ;
-    if ! [ has-config-flag BOOST_NO_STD_LOCALE : $(properties) ]
-    {
-        result += <source>$(SOURCES_HAS_STD_LOCALE).cpp ;
-    }
-
-    #ECHO additional sources $(result) ;
-
-    return $(result) ;
-}
-
-rule should-build-wserialization ( properties * )
-{
-    local result ;
-    if [ has-config-flag BOOST_NO_STD_LOCALE : $(properties) ]
-    {
-        result += <build>no ;
-    }
-
-    #ECHO should build wserialization $(result) ;
-
-    return $(result) ;
-}
-
 lib boost_serialization 
    : ## sources ##
     $(SOURCES).cpp
    : ## requirements ##
-    <conditional>@select-define-specific-sources
+    [ check-target-builds ../../config/checks//std_wstreambuf : <source>../src/$(SOURCES_HAS_STD_WSTREAMBUF).cpp ]
    <toolset>msvc:<cxxflags>/Gy
    <toolset>msvc:<define>_SCL_SECURE_NO_WARNINGS
    <toolset>msvc:<define>_CRT_SECURE_NO_WARNINGS
@@ -165,7 +130,7 @@ lib boost_serialization
 lib boost_wserialization 
    : $(WSOURCES).cpp boost_serialization 
    : 
-    <conditional>@should-build-wserialization
+    [ requires std_wstreambuf ]
    <toolset>msvc:<cxxflags>/Gy 
    <toolset>msvc:<define>_SCL_SECURE_NO_WARNINGS
    <toolset>msvc:<define>_CRT_SECURE_NO_WARNINGS
@@ -53,7 +53,7 @@ http://www.boost.org/LICENSE_1_0.txt)
  <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.
+  load in one function specification.
  <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="http://www.boost.org/people/william_kempf.htm">William E. Kempf</a>
@@ -41,7 +41,7 @@ class must implement in order to be used to serialize
 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>
+<h4>Minimum Requirements</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:
@@ -58,10 +58,10 @@ public:
    typedef boost::mpl::bool_&lt;true&gt; is_saving; 
    typedef boost::mpl::bool_&lt;false&gt; is_loading;
    template&lt;class T&gt; void register_type(){}
-    template&lt;class T&gt; trivial_oarchive & operator&lt;&lt;(const T & t){
+    template&lt;class T&gt; trivial_oarchive &amp; operator&lt;&lt;(const T &amp; t){
        return *this;
    }
-    template&lt;class T&gt; trivial_oarchive & operator&(const T & t){
+    template&lt;class T&gt; trivial_oarchive &amp; operator&amp;(const T &amp; t){
        return *this &lt;&lt; t;
    }
    void save_binary(void *address, std::size_t count){};
@@ -172,10 +172,10 @@ to be optimised away for archive classes that don't use it.
 <p>
 <dt><h4><code>
 template&lt;class T&gt;
-void save_override(T & t, int);
+void save_override(T &amp; t, int);
 </code></h4></dt>
 <dd>
-<strong>Default</strong>:Invokes <code style="white-space: normal">archive::save(Archive & ar, t)</code><br>
+<strong>Default</strong>:Invokes <code style="white-space: normal">archive::save(Archive &amp; ar, t)</code><br>
 This is the main entry into the serialization library.<br>
 <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
@@ -190,7 +190,7 @@ with one appropriate for XML which writes out the start of an XML tag with the c
 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 save_override(T & t, int);</code>.
+implementation of <code style="white-space: normal">void save_override(T &amp; 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>
@@ -271,7 +271,7 @@ exception.
 Exhaustive testing of the library requires testing the different aspects of object
 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 that don't support wide charactor i/o). 
+(3 in systems that don't support wide character i/o). 
 <p>
 In addition, there are 28 other tests which aren't related to any particular archive class.
 <p>
@@ -323,7 +323,7 @@ library_test --toolset=gcc -sBOOST_ARCHIVE_LIST=portable_binary_archive.hpp

 All archives described so far are implemented as templates.  Code to save and load
 data to archives is regenerated for each combination of archive class and data type.
-Under these cirumstances, a good optimizing compiler that can expand 
+Under these circumstances, a good optimizing compiler that can expand 
 <code>inline</code> functions to enough depth will generate fast code.  
 However:
 <ul>
@@ -400,7 +400,7 @@ dispatch table and there is no possibility for a compiler to <code style="white-
 archive functions.  This will result in a detectable degradation in performance for 
 saving and loading archives.
 <p>
-Note that the concept of polymophic archives is fundamentally incompatible with the
+Note that the concept of polymorphic archives is fundamentally incompatible with the
 serialization of new types that are marked "primitive" by the user with:
 <pre><code> 
 BOOST_CLASS_IMPLEMENTATION(my_primitive_type, boost::serialization::primitive_type)
@@ -408,7 +408,7 @@ BOOST_CLASS_IMPLEMENTATION(my_primitive_type, boost::serialization::primitive_ty

 Code to implement serialization for these types is instantiated "on the fly" in the user's program.
 But this conflicts with the whole purpose of the polymorphic archive. An attempt to
-serialize such a primitive type will result in a compilation error since the common polymorhic
+serialize such a primitive type will result in a compilation error since the common polymorphic
 interface is static and cannot instantiate code for a new type.

 <p>
@@ -232,7 +232,7 @@ equivalent to the original.

 There are archives based on text, binary and XML file
 formats but all have the above interface.  Given that all archives present
-the same public interface, specifcation of serialization is exactly the same
+the same public interface, specification of serialization is exactly the same
 for all archives.  Archive classes have other members not mentioned here.
 However they are related to the internal functioning of the library and
 are not meant to be called by users of an archive.  Implementation of new
@@ -303,7 +303,7 @@ namespace archive {
 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 - igored on saving
+    no_xml_tag_checking = 4 // suppress checking of xml tags - ignored on saving
 };

 } // archive
@@ -319,7 +319,7 @@ class text_oarchive : ...
    ...
 public:
    ... // implementation of the <strong>Saving Archive</strong> concept
-    text_oarchive(std::ostream & os, unsigned int flags = 0);
+    text_oarchive(std::ostream &amp; os, unsigned int flags = 0);
    ~text_oarchive();
 };

@@ -330,7 +330,7 @@ public:
 <dl>

 <dt><h4><code>
-text_oarchive(std::ostream & os, unsigned int flags = 0);
+text_oarchive(std::ostream &amp; os, unsigned int flags = 0);
 </code></h4></dt>
 <dd>
 Constructs an archive given an open <code style="white-space: normal">stream</code> as 
@@ -343,7 +343,7 @@ output with initial data which helps identify them as archives produced by this
 This permits a more graceful handling of the case where an attempt is made to load an archive
 from an invalid file format. In addition to this, each type of archive might have 
 its own information.  For example, native binary archives include information about 
-sizes of native types and endianess to gracefully handle the case where it has been
+sizes of native types and endianness to gracefully handle the case where it has been
 erroneously assumed that such an archive is portable across platforms.  In some cases, 
 where this extra overhead might be considered objectionable, it can be suppressed with the
 <code style="white-space: normal">no_header</code> flag.
@@ -379,7 +379,7 @@ class text_iarchive : ...
    ...
 public:
    ... // implementation of the <strong>Loading Archive</strong> concept
-    text_iarchive(std::istream & is, unsigned int flags = 0);
+    text_iarchive(std::istream &amp; is, unsigned int flags = 0);
    ~text_iarchive();
 };

@@ -391,10 +391,10 @@ public:
 <dl>

 <dt><h4><code>
-text_iarchive(std::istream & is, unsigned int flags = 0);
+text_iarchive(std::istream &amp; is, 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. If flags are used, they should be the same
 as those used when the archive was created. Function and usage of flags is described
 above.
@@ -418,11 +418,11 @@ to the common class interface described above, they include the following
 constructors:
 <dl>
 <dt><h4><code>
-binary_oarchive(std::streambuf & bsb, unsigned int flags = 0);
+binary_oarchive(std::streambuf &amp; bsb, unsigned int flags = 0);
 </code></h4></dt>
 and
 <dt><h4><code>
-binary_iarchive(std::streambuf & bsb, unsigned int flags = 0);
+binary_iarchive(std::streambuf &amp; bsb, unsigned int flags = 0);
 </code></h4></dt>
 </dl>

@@ -42,7 +42,7 @@ http://www.boost.org/LICENSE_1_0.txt)
    <a name="5"></a>
    <li>Scott Meyers, <u>Effective C++</u>, Addison-Wesley, 1992
    <a name="6"></a>
-    <li>Bjarne Stroustrup, <u>The C++ Programming Langage</u>, Addison-Wesley, 1997
+    <li>Bjarne Stroustrup, <u>The C++ Programming Language</u>, Addison-Wesley, 1997
    <a name="7"></a>
    <li>Alexandrescu, Andrei, <u>Modern C++ Design</u>, Addison-Wesley, 2001
    <a name="8"></a>
@@ -29,49 +29,49 @@ http://www.boost.org/LICENSE_1_0.txt)
 <pre><code>


-basic_oarchive <a href="../../../boost/archive/detail/basic_oarchive.hpp">-></a>
+basic_oarchive <a href="../../../boost/archive/detail/basic_oarchive.hpp">-&gt;</a>
      |
      |
-      |      interface_oarchive&lt;text_oarchive&gt; <a href="../../../boost/archive/detail/interface_oarchive.hpp">-></a>
+      |      interface_oarchive&lt;text_oarchive&gt; <a href="../../../boost/archive/detail/interface_oarchive.hpp">-&gt;</a>
      |                     /
      |                   /
      |        _________/
      |      /
      |    /
      |  /
-common_oarchive&lt;text_oarchive&gt; <a href="../../../boost/archive/detail/common_oarchive.hpp">-></a>
+common_oarchive&lt;text_oarchive&gt; <a href="../../../boost/archive/detail/common_oarchive.hpp">-&gt;</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_oarchive&lt;text_oarchive&gt;</font> <a href="../../../boost/archive/basic_text_oarchive.hpp">-&gt;</a>
      |
      |
-      |     <font color="blue">basic_text_oprimitive&lt;basic_ostream&gt;</font> <a href="../../../boost/archive/basic_text_oprimitive.hpp">-></a>
+      |     <font color="blue">basic_text_oprimitive&lt;basic_ostream&gt;</font> <a href="../../../boost/archive/basic_text_oprimitive.hpp">-&gt;</a>
      |                    /
      |                  /
-      |       _________/                  interface_oarchive&lt;polymorphic_oarchive&gt; <a href="../../../boost/archive/detail/interface_oarchive.hpp">-></a>
+      |       _________/                  interface_oarchive&lt;polymorphic_oarchive&gt; <a href="../../../boost/archive/detail/interface_oarchive.hpp">-&gt;</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="blue">text_oarchive_impl&lt;text_oarchive&gt;</font> <a href="../../../boost/archive/text_oarchive.hpp">-&gt;</a>              polymorphic_oarchive_impl <a href="../../../boost/archive/polymorphic_oarchive.hpp">-&gt;</a>
      | \                                                    |
      |   \                                                  |
-      |     \_____________________________________    <font color="red">polymorphic_oarchive</font> <a href="../../../boost/archive/polymorphic_oarchive.hpp">-></a>
+      |     \_____________________________________    <font color="red">polymorphic_oarchive</font> <a href="../../../boost/archive/polymorphic_oarchive.hpp">-&gt;</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">text_oarchive</font> <a href="../../../boost/archive/text_oarchive.hpp">-&gt;</a>                 polymorphic_oarchive_route&lt;text_oarchive_impl&lt;text_oarchive&gt; &gt; <a href="../../../boost/archive/detail/polymorphic_oarchive_route.hpp">-&gt;</a>
                                                       |
                                                       |
                                                       |
-                                             <font color="red">polymorphic_text_oarchive</font> <a href="../../../boost/archive/polymorphic_text_oarchive.hpp">-></a>
+                                             <font color="red">polymorphic_text_oarchive</font> <a href="../../../boost/archive/polymorphic_text_oarchive.hpp">-&gt;</a>


 </code></pre>
 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
+serialization) for text archives.  The hierarchy 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 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
+implement saving for a given archive type. (in this case it's text archives).
+Users include classes in <font color="red">red</font> to save their data from a particular
 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>
@@ -141,7 +141,7 @@ never change.  They are in <code>namespace boost::archive::detail</code>
  <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">save(T &t)</code>
+  A class with a list of virtual <code style="white-space: normal">save(T &amp;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.
  
@@ -157,8 +157,8 @@ never change.  They are in <code>namespace boost::archive::detail</code>
  <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_oarchive_route&lt;text_oarchive_impl&'t;text_oarchive&gt; &gt;</code>
+  this is just a typedef so we can write <code style="white-space: normal">polymorphic_text_archive</code> rather than
+  <code style="white-space: normal">polymorphic_oarchive_route&lt;text_oarchive_impl&lt;text_oarchive&gt; &gt;</code>
  
 </dl>
 <hr>
@@ -186,7 +186,7 @@ function initialize() {
      </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>
+    <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#classinfo">Class Information</a>
@@ -203,7 +203,7 @@ function initialize() {
      <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="dot.gif"><a target="detail" href="special.html#optimizations">Optimizations</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>
@@ -135,7 +135,7 @@ Iterators which fulfill the above requirements should be composable and the abov
 code should implement our binary to base64 conversion.

 <h3>Iterators Included in the Library</h3>
-Dataflow iterators for the serialization library are all defined in the hamespace
+Dataflow iterators for the serialization library are all defined in the namespace
 <code style="white-space: normal">boost::archive::iterators</code> included here are:
 <dl class="index">
  <dt><a target="base64_from_binary" href="../../../boost/archive/iterators/base64_from_binary.hpp">
@@ -99,7 +99,7 @@ that the following equivalent works on more compilers.
 <pre><code>
    // default fall through for any types not specified here
    template&lt;class T&gt;
-    void save(const T & t){
+    void save(const T &amp; t){
        xml_oarchive_impl&lt;derived_t&gt;::save(t);
    }
    void save(const unsigned int t);
@@ -127,14 +127,14 @@ class log_archive_impl :
    public xml_oarchive_impl&lt;Archive&gt;
 {
    ...
-);
+};

 // do not derive from this class !!!
 class log_archive : 
    public log_archive_impl&lt;log_archive&gt;
 {
 public:
-    log_archive(std::ostream & os, unsigned int flags = 0) :
+    log_archive(std::ostream &amp; os, unsigned int flags = 0) :
        log_archive_impl&lt;xml_oarchive&gt;(os, flags)
    {}
 };
@@ -78,7 +78,7 @@ public:
        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
+                            // one used by the program.  This indicates that the program
                            // needs to be rebuilt.
        multiple_code_instantiation, // code for implementing serialization for some
                            // type has been instantiated in more than one module.
@@ -141,23 +141,23 @@ exception will be thrown.
 To understand what this exception means consider the following scenario
 <pre><code>
 template&lt;class Archive&gt;
-void T::save(Archive &ar) const
+void T::save(Archive &amp;ar) const
 {
-    const A * aptr = &a;
-    ar << aptr;          // save an instance of object of class A through a pointer
+    const A * aptr = &amp;a;
+    ar &lt;&lt; aptr;          // save an instance of object of class A through a pointer
    ...
-    ar << a;             // save an instance of an object of class A
-    assert(aptr == &a);  // this must be true
+    ar &lt;&lt; a;             // save an instance of an object of class A
+    assert(aptr == &amp;a);  // this must be true
 }

 template&lt;class Archive&gt;
-void T::load(Archive &ar)
+void T::load(Archive &amp;ar)
 {
    A * aptr;
-    ar >> aptr;          // create and initialize a new instance of class A
+    ar &gt;&gt; aptr;          // create and initialize a new instance of class A
    ...
-    ar >> a;             // restore state of on object of class A
-    assert(aptr == &a);  // this won't be true
+    ar &gt;&gt; a;             // restore state of on object of class A
+    assert(aptr == &amp;a);  // this won't be true
 }
 </pre></code>
 An object is saved first through a pointer then directly.  Upon loading back
@@ -184,7 +184,7 @@ archive has already been created.
 <br>
 <a name="output_stream_error"><code style="white-space: normal">output_stream_error</code></a>
 </h3>
-An error has occured during stream input or ouput.  Aside from the common 
+An error has occurred during stream input or ouput.  Aside from the common 
 situations such as a corrupted or truncated input file, there are 
 several less obvious ones that sometimes occur.
 <p>
@@ -49,7 +49,7 @@ the following functions
    The main function we require - <code style="white-space: normal">std::typeid()</code>
    is not available in all environments. Support for this function depends upon
    runtime typing(RTTI) support from the compiler.  This may be non-existent
-    or not enabled for reasons such as a percieved inefficiency.
+    or not enabled for reasons such as a perceived inefficiency.
  <li>
    <code style="white-space: normal">std::type_info</code> includes a string
    containing type name.  This would seem to satisfy 2) above.
@@ -95,7 +95,7 @@ corresponding type can be found.  This facility is used by the serialization lib
 in order to construct types serialized through a base class pointer.

 <h3><a name="runtime">Runtime Interface</a></h3>
-<pre><code">
+<pre><code>
 namespace boost { 
 namespace serialization {

@@ -114,9 +114,9 @@ protected:
    void key_unregister();
 public:
    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&lt;(const extended_type_info &amp;rhs) const;
+    bool operator==(const extended_type_info &amp;rhs) const;
+    bool operator!=(const extended_type_info &amp;rhs) const {
        return !(operator==(rhs));
    }
    // for plugins
@@ -133,7 +133,7 @@ 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.
+there may be more than one instance of this class corresponding 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 actual information 
 the instances contain.
@@ -188,9 +188,9 @@ instance.  If no key has been associated with the instance, then a NULL is retur
 </dd>

 <dt><h4><pre><code>
-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 &amp; rhs) const;
+bool operator==(const extended_type_info &amp; rhs) const;
+bool operator!=(const extended_type_info &amp; rhs) const;
 </code></pre></h4></dt>
 <dd>
 These functions are used to compare
@@ -261,7 +261,7 @@ and also implement the following:
 <dt><h4><code style="white-space: normal"><pre>
 template&lt;class ETI&gt;
 const extended_type_info *
-ETI::get_derived_extended_type_info(const T & t) const;
+ETI::get_derived_extended_type_info(const T &amp; t) const;
 </pre></code></h4></dt>
 <dd>
 Return a pointer to the 
@@ -275,7 +275,7 @@ with a particular <code style="white-space: normal">extended_type_info</code> im
 </dd>

 <dt><h4><code style="white-space: normal"><pre>
-virtual bool ETI::is_less_than(const extended_type_info &rhs) const;
+virtual bool ETI::is_less_than(const extended_type_info &amp;rhs) const;
 </pre></code></h4></dt>
 <dd>
 Compare this instance to another one using the same
@@ -283,7 +283,7 @@ Compare this instance to another one using the same
 </dd>

 <dt><h4><code style="white-space: normal"><pre>
-virtual bool ETI::is_equal(const extended_type_info &rhs) const;
+virtual bool ETI::is_equal(const extended_type_info &amp;rhs) const;
 </pre></code></h4></dt>
 <dd>
 Compare this instance to another one using the same
@@ -330,7 +330,7 @@ by the compiler.
 <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.
-Instead, it requires that all polymorphic types be explictly exported.
+Instead, it requires that all polymorphic types be explicitly 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:
@@ -354,16 +354,16 @@ inter-operability between two different implementations of
 <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
+templates.  For example, if the type T is to use the <code style="white-space: normal">type_info</code> 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;;
+struct extended_type_info_typeid&lt;T&gt;;
 template
-struct extended_type_info_typeid&gt;const T&gt;;
+struct extended_type_info_typeid&lt;const T&gt;;
 } // serialization
 } // boost
 </pre></code>
@@ -375,7 +375,7 @@ the macro:
 <code style="white-space: normal"><pre>
 BOOST_CLASS_TYPE_INFO(
    my_type, 
-    extended_type_info_typeid&gt;my_class&gt;
+    extended_type_info_typeid&lt;my_class&gt;
 )
 </pre></code>

@@ -399,7 +399,7 @@ struct derived : public base {
 };
 ...
 extended_type_info *eti = extended_type_info::find("my_class")
-base * b = eti->construct(...);
+base * b = eti-&gt;construct(...);
 </pre></code>
 <br>
 The <code>construct</code> takes an argument count and up to
@@ -58,7 +58,7 @@ is included with the following declaration
 <a name="userincludes">
 <h3>Files Included by User Programs</h3>
 Using this library entails including headers listed in this section.
-It should not be necessary to explictly include any other header files.
+It should not be necessary to explicitly include any other header files.

 <a name="archiveimplementations">
 <h4>Archive Implementations</h4>
@@ -185,7 +185,7 @@ boost/serialization/version.hpp
 <dt><a target="level" href="../../../boost/serialization/level.hpp">
 boost/serialization/level.hpp
 </a>
-<dd>To override the default implementaton level trait for a type.</dd>
+<dd>To override the default implementation level trait for a type.</dd>

 <dt><a target="tracking" href="../../../boost/serialization/tracking.hpp">
 boost/serialization/tracking.hpp
@@ -320,7 +320,7 @@ or wide character text streams. These classes specify archive type specific
 behavior on a type by type basis.  For example, <code style="white-space: normal">basic_xml_oarchive.hpp</code>
 includes code to guarantee that any object not attached to a name will 
 trap during compile time. On the other hand, <code style="white-space: normal">basic_text_oarchive.hpp</code>
-contains code to strip out and ingore any names attached to objects.
+contains code to strip out and ignore any names attached to objects.
 <p>
 <dt><a target="common_iarchive" href="../../../boost/archive/detail/common_iarchive.hpp">
 boost/archive/detail/common_iarchive.hpp
@@ -343,7 +343,7 @@ and implementation are factored out into separate classes to minimize code dupli

 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.
+These are included as necessary by the archive class implementations listed above.
 This has the unfortunate side effect of making the implementation less transparent.
 Users should never find it necessary to change these files.
 <p>
@@ -364,19 +364,19 @@ archive class.
 the archive hierarchy.

 <pre><code>
-template<class T>
-void save_override(T & t, BOOST_PFTO int){
+template&lt;class T&gt;
+void save_override(T &amp; 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);
+    this-&gt;base::save_override(t, 0);
 }
-void save_override(const some_type & t, int){
+void save_override(const some_type &amp; t, int){
    // any special handling for some type
    // this will usually entail forwarding some other operation
    // in the most derived class.
-    this->This()->...
+    this-&gt;This()-&gt;...
    // or in one of its parents basic_text_oprimitive
-    this->This()->save(static_cast&lt;int&gt;(t));
+    this-&gt;This()-&gt;save(static_cast&lt;int&gt;(t));
 }
 ... // other special type handling
 </code></pre>
@@ -408,7 +408,7 @@ Building of the library generates and compiles code for all archives implemented
  rather than each time a user's program is recompiled.  This can save much
  development time.
  <li>Headers which solely related to implementation need only be included
-  in the library code modules. This prevents a user program from accidently 
+  in the library code modules. This prevents a user program from accidentally 
  depending on an implementation feature of the serialization library.
  <li>In building the library I came to the conclusions that there can arise
  situations regarding static code/data instantiation that could not be 
@@ -147,7 +147,7 @@ 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 library can be used
-either way - <strong>BUT</strong> - both the libray <strong>AND</strong> the application 
+either way - <strong>BUT</strong> - both the library <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
 <code style="white-space: normal">BJAM</code> builds, you should include this switch
@@ -32,7 +32,7 @@ http://www.boost.org/LICENSE_1_0.txt)
 </dl>

 These are not part of the library itself, but rather
-techiques on how to use the library to address specific situations.
+techniques 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
@@ -127,7 +127,7 @@ XML, or some other created by the user of this library.
      This library has similar goals to this one. Some aspects of the
      implemenation are also similar.  As of this writing, it would seem that:
      <ul>
-          <li>Portability(1) is guarenteed only for recent versions of GCC.
+          <li>Portability(1) is guaranteed only for recent versions of GCC.
          <li>Versioning(3) of class definitions is not explicitly supported by
          the library.
          <li>it doesn't seem to automatically account for shared pointers(5).
@@ -41,7 +41,7 @@ struct A {
    // class a contains a pointer to a "hidden" declaration
    B *pimpl;
    template&lt;class Archive&gt;
-    void serialize(Archive & ar, const unsigned int file_version);
+    void serialize(Archive &amp; ar, const unsigned int file_version);
    A();
 };
 </code></pre>
@@ -59,8 +59,8 @@ by:
 struct B {
    int b;
    template&lt;class Archive&gt;
-    void serialize(Archive & ar, const unsigned int file_version){
-        ar & b;
+    void serialize(Archive &amp; ar, const unsigned int file_version){
+        ar &amp; b;
    }
 };

@@ -74,8 +74,8 @@ A::~A(){

 // now we can define the serialization for class A
 template&lt;class Archive&gt;
-void A::serialize(Archive & ar, const unsigned int file_version){
-    ar & pimpl;
+void A::serialize(Archive &amp; ar, const unsigned int file_version){
+    ar &amp; pimpl;
 }
 </code></pre>
 As described in <a href="bibliography.html#10">[10]</a> this brings the
@@ -88,8 +88,8 @@ following advantages:
 So, we compile the modules and everything is fine.  However when we
 link, we get an error.  Two symbols are undefined:
 <pre><code>
-void A::serialize(boost::archive::text_oarchive & ar, const unsigned int file_version);
-void A::serialize(boost::archive::text_iarchive & ar, const unsigned int file_version);
+void A::serialize(boost::archive::text_oarchive &amp; ar, const unsigned int file_version);
+void A::serialize(boost::archive::text_iarchive &amp; ar, const unsigned int file_version);
 </code></pre>
 The problem is that when compiling the above code, 
 there is no instantiation of the <code style="white-space: normal">serialize</code> template.
@@ -103,11 +103,11 @@ example, including the the following code in any *.cpp file does just that:
 #include &lt;boost/archive/text_oarchive.hpp&gt;

 template void A::serialize&lt;boost::archive::text_iarchive&gt;(
-    boost::archive::text_iarchive & ar, 
+    boost::archive::text_iarchive &amp; ar, 
    const unsigned int file_version
 );
 template void A::serialize&lt;boost::archive::text_oarchive&gt;(
-    boost::archive::text_oarchive & ar, 
+    boost::archive::text_oarchive &amp; ar, 
    const unsigned int file_version
 );
 </code></pre>
@@ -115,7 +115,7 @@ The program should now link as well as compile.
 <p>
 The downside of this is that one has to know which archives are going 
 to be used with hidden serializations.  This is an effect of using template
-driven code.  One can invoke explicity instantiation for all known templates and
+driven code.  One can invoke explicitly instantiation for all known templates and
 presume that the linker will exclude unreferenced code.  This should
 work but is platform dependent.
 <hr>
@@ -37,27 +37,27 @@ classes and types. That is, the following program compiles and runs exactly as o
 // License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
 // http://www.boost.org/LICENSE_1_0.txt)

-#include <fstream>
-#include <boost/config.hpp>
+#include &lt;fstream&gt;
+#include &lt;boost/config.hpp&gt;
 #if defined(BOOST_NO_STDC_NAMESPACE)
 namespace std{ 
    using ::remove;
 }
 #endif

-#include <boost/serialization/access.hpp>
-#include <boost/serialization/base_object.hpp>
-#include <boost/serialization/export.hpp>
+#include &lt;boost/serialization/access.hpp&gt;
+#include &lt;boost/serialization/base_object.hpp&gt;
+#include &lt;boost/serialization/export.hpp&gt;

 class Base {
    friend class boost::serialization::access;
    int m_i;
-    template<class Archive>
-    void serialize(Archive & ar, const unsigned int version){
-        ar & BOOST_SERIALIZATION_NVP(m_i);
+    template&lt;class Archive&gt;
+    void serialize(Archive &amp; ar, const unsigned int version){
+        ar &amp; BOOST_SERIALIZATION_NVP(m_i);
    }
 protected:
-    bool equals(const Base &rhs) const {
+    bool equals(const Base &amp;rhs) const {
        return m_i == rhs.m_i;
    }
    Base(int i = 0) :
@@ -68,16 +68,16 @@ protected:
 class Derived : private Base {
    friend class boost::serialization::access;
 private:
-    Base & base_cast(){
-        return static_cast<Base &>(*this);
+    Base &amp; base_cast(){
+        return static_cast&lt;Base &amp;&gt;(*this);
    }
-    template<class Archive>
-    void serialize(Archive & ar, const unsigned int version){
-        ar & BOOST_SERIALIZATION_BASE_OBJECT_NVP(Base);
+    template&lt;class Archive&gt;
+    void serialize(Archive &amp; ar, const unsigned int version){
+        ar &amp; BOOST_SERIALIZATION_BASE_OBJECT_NVP(Base);
    }
 public:
-    bool operator==(const Derived &rhs) const {
-        return Base::equals(static_cast<const Base &>(rhs));
+    bool operator==(const Derived &amp;rhs) const {
+        return Base::equals(static_cast&lt;const Base &amp;&gt;(rhs));
    }
    Derived(int i = 0) :
        Base(i)
@@ -94,12 +94,12 @@ main( int /* argc */, char* /* argv */[] )
    {   
        test_ostream os(testfile);
        test_oarchive oa(os);
-        oa << boost::serialization::make_nvp("a", a);
+        oa &lt;&lt; boost::serialization::make_nvp("a", a);
    }
    {
        test_istream is(testfile, TEST_STREAM_FLAGS);
        test_iarchive ia(is, TEST_ARCHIVE_FLAGS);
-        ia >> boost::serialization::make_nvp("a", a1);
+        ia &gt;&gt; boost::serialization::make_nvp("a", a1);
    }
    std::remove(testfile);

@@ -107,17 +107,17 @@ main( int /* argc */, char* /* argv */[] )
        return 1;

    // serialize Derived and Base
-    Derived *ta = &a;
+    Derived *ta = &amp;a;
    Derived *ta1 = NULL;
    {   
        test_ostream os(testfile);
        test_oarchive oa(os);
-        oa << boost::serialization::make_nvp("ta", ta);
+        oa &lt;&lt; boost::serialization::make_nvp("ta", ta);
    }
    {
        test_istream is(testfile, TEST_STREAM_FLAGS);
        test_iarchive ia(is, TEST_ARCHIVE_FLAGS);
-        ia >> boost::serialization::make_nvp("ta", ta1);
+        ia &gt;&gt; boost::serialization::make_nvp("ta", ta1);
    }
    std::remove(testfile);
    if(*ta != *ta1)
@@ -134,10 +134,10 @@ a pointer to the base class.  Included in the macro
 BOOST_SERIALIZATION_BASE_OBJECT_NVP
 </code>
 is code which links derived and base class definitions in tables used to serialize
-derived classes through pointers to a polymorphinc base class.  This code requires
+derived classes through pointers to a polymorphic base class.  This code requires
 the ability to invoke
 <code>
-static_cast&lt;Base &&gt;(Derived &)
+static_cast&lt;Base &amp;&gt;(Derived &amp;)
 </code>
 which C++ will only permit from within the derived class if the base class is 
 private or protected. The program will fail to compile with an error message 
@@ -146,18 +146,18 @@ indicating invalid cast.
 In order for this
 code compiler the following alteration must be made:
 <pre><code>
-    template<class Archive>
-    void serialize(Archive & ar, const unsigned int version){
-        //ar & BOOST_SERIALIZATION_BASE_OBJECT_NVP(Base);
-        ar & boost::serialization::make_nvp(
+    template&lt;class Archive&gt;
+    void serialize(Archive &amp; ar, const unsigned int version){
+        //ar &amp; BOOST_SERIALIZATION_BASE_OBJECT_NVP(Base);
+        ar &amp; boost::serialization::make_nvp(
            "Base",
-            static_cast&lt;Base &&gt;(*this)
+            static_cast&lt;Base &amp;&gt;(*this)
        );
    }
 </code></pre>
 With this change the program will now compile.
 <p>
-If we made one of the functions of <code>Base></code> <code>virtual</code>
+If we made one of the functions of <code>Base</code> <code>virtual</code>
 in order to use the "export" functionality of the serialization library and permit serialization through
 a pointer the the base class, we'll be disappointed. Without the ability to
 cast to the base class, we can't use the functionality.
@@ -10,7 +10,7 @@ http://www.boost.org/LICENSE_1_0.txt)
 <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>Seriealization - Rationale</title>
+<title>Serialization - Rationale</title>
 </head>
 <body link="#0000ff" vlink="#800080">
 <table border="0" cellpadding="7" cellspacing="0" width="100%" summary=
@@ -101,8 +101,8 @@ For class/struct types, the template operators &amp;, &lt;&lt;, and &gt;&gt;
 will generate code that invokes the programmer's serialization code for the
 particular data type.  There is no default.  An attempt to serialize a
 class/struct for which no serialization has been explicitly specified
-will result in a compile time error.  The serialiation of a class can
-be specified via either a class member function or a free funcation which
+will result in a compile time error.  The serialization of a class can
+be specified via either a class member function or a free function which
 takes a reference to an instance of the class as an argument.

 <h3><a name="member">Member Function</a></h3>
@@ -180,7 +180,7 @@ possible to serialize them.  So in some instances, minor modifications to the
 class to be serialized will be necessary even when using this "non-intrusive"
 method.  In practice this may not be such a problem as many libraries 
 (E.G. STL) expose enough information to permit implementation of non-intrusive
-serialization with absolutly no changes to the library.
+serialization with absolutely no changes to the library.

 <h4><a name="namespaces">Namespaces for Free Function Overrides</a></h4>
 For maximum portability, include any free functions templates and definitions in the 
@@ -219,7 +219,7 @@ base_object.hpp
 includes the template:
 <pre><code>
 template&lt;class Base, class Derived&gt;
-Base & base_object(Derived &d);
+Base &amp; base_object(Derived &amp;d);
 </code></pre>
 which should be used to create a reference to an object of the base
 which can be used as an argument to the archive serialization operators.
@@ -255,7 +255,7 @@ Loading <code style="white-space: normal">const</code> members can be addressed
    ar &amp; const_cast&lt;T &amp;&gt;(t);
 </code></pre>
 Note that this violates the spirit and intention of the <code style="white-space: normal">const</code>
-keyword. <code style="white-space: normal">const</code> members are intialized when a class instance
+keyword. <code style="white-space: normal">const</code> members are initialized when a class instance
 is constructed and not changed thereafter.  However, this may
 be most appropriate in many cases.  Ultimately, it comes down to 
 the question about what <code style="white-space: normal">const</code> means in the context
@@ -463,7 +463,7 @@ following situations must be addressed:
    be determined and saved. Upon restoration the correct type
    must be created and its address correctly cast to the base
    class. That is, polymorphic pointers have to be considered.
-    <li>NULL pointers must be dectected when saved and restored
+    <li>NULL pointers must be detected when saved and restored
    to NULL when deserialized.
 </ol>

@@ -543,7 +543,7 @@ private:
        ar &amp; m_state;
    }
 public:
-    // no default construct guarentees that no invalid object
+    // no default construct guarantees that no invalid object
    // ever exists
    my_class(int attribute) :
        m_attribute(attribute),
@@ -591,7 +591,7 @@ class derived_one : public base {
 class derived_two : public base {
    ...
 };
-main(){
+int main(){
    ...
    base *b;
    ...
@@ -604,7 +604,7 @@ Should it be an object of class <code style="white-space: normal">derived_one</c
 <code style="white-space: normal">derived_two</code>, or maybe <code style="white-space: normal">base</code>?
 <p>
 It turns out that the kind of object serialized depends upon whether the base class
-(<code style="white-space: normal">base</code> in this case) is polymophic or not.
+(<code style="white-space: normal">base</code> in this case) is polymorphic or not.
 If <code style="white-space: normal">base</code> is not polymorphic, that is if it has no
 virtual functions, then an object of the type <code style="white-space: normal">base</code>
 will be serialized. Information in any derived classes will be lost. If this is what is desired
@@ -630,7 +630,7 @@ the same sequence.  This includes "registration".
 <p>
 Expanding our previous example:
 <pre><code>
-main(){
+int main(){
    derived_one d1;
    derived_two d2:
    ...
@@ -659,11 +659,11 @@ This can be addressed by registering the derived class explicitly.  All archives
 derived from a base class which implements the following template:
 <pre><code>
 template&lt;class T&gt;
-register_type();
+register_type(T * = NULL);
 </code></pre>
 So our problem could just as well be addressed by writing:
 <pre><code>
-main(){
+int main(){
    ...
    ar.template register_type&lt;derived_one&gt;();
    ar.template register_type&lt;derived_two&gt;();
@@ -674,7 +674,7 @@ main(){
 </code></pre>
 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.
+and corresponding load in synchronization.

 <h4><a name="export">Export</a></h4>
 The above will work but may be inconvenient.  We don't always know which derived
@@ -690,7 +690,7 @@ So we have another method:
 BOOST_CLASS_EXPORT_GUID(derived_one, "derived_one")
 BOOST_CLASS_EXPORT_GUID(derived_two, "derived_two")

-main(){
+int main(){
    ...
    base *b;
    ...
@@ -719,7 +719,7 @@ This means that serialization code must be instantiated for each
 combination of archive and data type that is serialized in the program.
 <p>
 Polymorphic pointers of derived classes may never be referred to 
-explictly by the program so normally code to serialize such classes
+explicitly by the program so normally code to serialize such classes
 would never be instantiated.  So in addition to including export key
 strings in an archive, <code style="white-space: normal">BOOST_CLASS_EXPORT_GUID</code> explicitly
 instantiates the class serialization code for all archive classes used 
@@ -755,7 +755,7 @@ can be used.
 In order to properly translate between base and derived pointers
 at runtime, the system requires each base/derived pair be found
 in a table.  A side effect of serializing a base object with
-<code style="white-space: normal">boost::serialization::base_object&lt;Base&gt;(Derived &)</code>
+<code style="white-space: normal">boost::serialization::base_object&lt;Base&gt;(Derived &amp;)</code>
 is to ensure that the base/derived pair is added to the table
 before the <code style="white-space: normal">main</code> function is entered.
 This is very convenient and results in a clean syntax.  The only
@@ -789,7 +789,7 @@ class derived : public base {
    template&lt;class Archive&gt;
    void serialize(Archive &amp; ar, const unsigned int file_version){
        // method 1 : invoke base class serialization
-        ar & boost::serialization::base_object&lt;base&gt;(*this);
+        ar &amp; 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;derived *&gt;(NULL),
@@ -800,7 +800,7 @@ class derived : public base {

 BOOST_CLASS_EXPORT_GUID(derived, "derived")

-main(){
+int main(){
    //...
    std::stringstream ss;
    boost::archive::text_iarchive ar(ss);
@@ -92,32 +92,32 @@ instance of <code style="white-space: normal">sp_counted_base_impl<T, ...></code
 doesn't have a default constructor, serialization requires
 specification of the following overload:
 <pre><code>
-template&lt;class Archive, class P, class D>
+template&lt;class Archive, class P, class D&gt;
 inline void save_construct_data(
    Archive &amp; ar,
-    const boost::detail::sp_counted_base_impl<P, D> * t, 
+    const boost::detail::sp_counted_base_impl&lt;P, D&gt; * t, 
    const unsigned int file_version
 ){
    // variables used for construction
-    ar &lt;&lt; t->ptr;
+    ar &lt;&lt; t-&gt;ptr;
    ar &lt;&lt; *t;
 }

-template<class Archive, class P, class D>
+template&lt;class Archive, class P, class D&gt;
 inline void load_construct_data(
    Archive &amp; ar,
-    boost::detail::sp_counted_base_impl<P, D> * t, 
+    boost::detail::sp_counted_base_impl&lt;P, D&gt; * t, 
    const unsigned int file_version
 ){
    P ptr_;
    ar &gt;&gt; ptr_;
    // placement new
-    ::new(t)boost::detail::sp_counted_base_impl<P, D>(ptr_,  D());
-    ar &gt;&gt;; *t;
+    ::new(t)boost::detail::sp_counted_base_impl&lt;P, D&gt;(ptr_,  D());
+    ar &gt;&gt; *t;
 }
 </code></pre>
 The statement <code style="white-space: normal">ar &gt;&gt; ptr_</code> is key. This deserializes
-the same pointer deserialzed above.  Default object tracking will ensure
+the same pointer deserialized above.  Default object tracking will ensure
 that no more than one instance of the object is created and that the
 pointer returned by multiple deserializations are all the same. Hence,
 regardless of how many instances of <code style="white-space: normal">shared_ptr/shared_count</code>
@@ -135,7 +135,7 @@ inline void serialize(
    const unsigned int file_version,
    int
 ){
-    ar & boost::serialization::base_object&lt;
+    ar &amp; boost::serialization::base_object&lt;
 	boost::detail::sp_counted_base
    &gt;(*this);
 }
@@ -170,7 +170,7 @@ This indicates that we're not quite done.  Due to default object
 tracking, <code style="white-space: normal">sp_counted_base_impl&lt;P, D&gt;</code> is only
 created once regardless of how many shared pointers point to the
 same object.  Of course, it has to be this way. The reference
-count starts at 1 and is never incrememented.  Code must be added
+count starts at 1 and is never incremented.  Code must be added
 to the serialization functions to maintain the proper reference
 count.
 <p>
@@ -191,13 +191,13 @@ In this case we need only the latter function so we can replace the
 base object serialization with:
 <pre><code>
 // register the relationship between each derived class
-// its polymorphic base
+// and its polymorphic base
 void_cast_register&lt;
    boost::detail::sp_counted_base_impl&lt;P, D&gt;
    boost::detail::sp_counted_base, 
 &gt;();
 </code></pre>
-and we don't have to include a trival serializer for <code style="white-space: normal">sp_counted_base</code>.
+and we don't have to include a trivial serializer for <code style="white-space: normal">sp_counted_base</code>.
 <p>
 Finally we need to specify name-value pair wrappers if we want to be able
 to use this serialization with XML archives.
@@ -40,24 +40,24 @@ Unfortunately, this way of doing it suffered from some undesirable features
 <pre><code>
 template&lt;class Archive, class T&gt;
 inline void save(
-    Archive & ar,
-    const boost::shared_ptr&ltT&gt; &t,
+    Archive &amp; ar,
+    const boost::shared_ptr&lt;T&gt; &amp;t,
    const unsigned int /* file_version */
 ){
    const T * t_ptr = t.get();
    // just serialize the underlying raw pointer
-    ar &lt;&lt: boost::serialization::make_nvp("px", t_ptr);
+    ar &lt;&lt; boost::serialization::make_nvp("px", t_ptr);
 }

-template&lt;class Archive, class T&gt
+template&lt;class Archive, class T&gt;
 inline void load(
-    Archive & ar,
-    boost::shared_ptr&lt;T&gt; &t,
+    Archive &amp; ar,
+    boost::shared_ptr&lt;T&gt; &amp;t,
    const unsigned int file_version
 ){
    T* r;
    // recover the underlying raw pointer
-    ar >> boost::serialization::make_nvp("px", r);
+    ar &gt;&gt; boost::serialization::make_nvp("px", r);

    // To Do - match up with other shared pointers which 
    // use this same raw pointer.
@@ -39,7 +39,7 @@ is trivially easy:
 ...
 // display the complete schedule
 simple_log_archive log(std::cout);
-log << schedule;
+log &lt;&lt; schedule;
 </code></pre>

 and it produces the following output
@@ -52,10 +52,10 @@ schedule
   driver bob
   hour 6
   minute 24
-  second -> 
+  second -&gt; 
   stops 
    count 3
-    item -> 
+    item -&gt; 
     latitude 
      degrees 34
      minutes 135
@@ -51,7 +51,7 @@ requires consideration of the following issues:
  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>
+  race condition with unpredictable behavior</li>
 </ul>
 This singleton class addresses all of the above issues.

@@ -94,12 +94,12 @@ This singleton implementation has the following features:
 namespace boost { 
 namespace serialization {

-template <class T>
+template &lt;class T&gt;
 class singleton : public boost::noncopyable
 {
 public:
-    static const T & get_const_instance();
-    static T & get_mutable_instance();
+    static const T &amp; get_const_instance();
+    static T &amp; get_mutable_instance();
    static bool is_destroyed();
 };

@@ -110,14 +110,14 @@ public:
 <dl>

 <dt><h4><pre><code>
-static const T & get_const_instance();
+static const T &amp; 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();
+static T &amp; get_mutable_instance();
 </code></pre></h4></dt>
 <dd>
 Retrieve a mutable reference to the singleton for this type.
@@ -139,7 +139,7 @@ In order to be used as
 <code style="white-space: normal">
 singleton&lt;T&gt;
 </code>
-</a>, the type T must be default constructable. 
+</a>, the type T must be default constructible. 
 It doesn't require static variables - though it may have them.
 Since the library guarantees that only one instance of 
 <a target="singleton.hpp" href = "../../../boost/serialization/singleton.hpp">
@@ -147,7 +147,7 @@ Since the library guarantees that only one instance of
 singleton&lt;T&gt;
 </code>
 </a> 
-exists and all accesss is through the above static interface
+exists and all access 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.
@@ -242,7 +242,7 @@ The <code style="white-space: normal">lock()</code> and
 <code style="white-space: normal">unlock()</code> are "global"
 in that 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
+at the start of the program.  For programs compiled in release
 mode these functions have no effect.

 <hr>
@@ -30,18 +30,18 @@ To cast from one type to another related type, C++ provides the following
 operators:

 <dl>
-  <dt><code>static_cast&lt;T *<&gt;(U *)<br>static_cast&lt;T &<&gt;(U &)</code></dt>
+  <dt><code>static_cast&lt;T *&gt;(U *)<br>static_cast&lt;T &amp;&gt;(U &amp;)</code></dt>
  <dd>
    <ul>
      <li>required if neither T nor U are polymorphic
      <li>permitted in other cases.
-      <li>fails to detect erroneous casts of polymophic pointers/references at runtime.
+      <li>fails to detect erroneous casts of polymorphic pointers/references at runtime.
      <li>does not permit "cross casting"
      <li>inline function calls can be optimized away during compile time.
    </ul>
  </dd>
  <p>
-  <dt><code>dynamic_cast&lt;T *<&gt;(U *)<br>dynamic_cast&lt;T &<&gt;(U &)</code></dt>
+  <dt><code>dynamic_cast&lt;T *&gt;(U *)<br>dynamic_cast&lt;T &amp;&gt;(U &amp;)</code></dt>
  <dd>
    <ul>
      <li>permitted if either T or U are polymorphic
@@ -127,16 +127,16 @@ situation exemplified above.
 The following syntax is supported:
 <pre><code>
 smart_cast&lt;Target *, Source *&gt;(Source * s);
-smart_cast&lt;Target *>(Source * s);
-smart_cast&lt;Target &, Source &amp;&gt(Source &amp; s);
+smart_cast&lt;Target *&gt;(Source * s);
+smart_cast&lt;Target &amp;, Source &amp;&gt;(Source &amp; s);
 </code></pre>
 Note that the above syntax doesn't include 
 <pre><code>
-smart_cast&lt;Target &amp; &gt(Source &amp; s)
+smart_cast&lt;Target &amp; &gt;(Source &amp; s)
 </code></pre>
 but the same functionality is supported with the following special syntax
 <pre><code>
-smart_cast_reference&lt;Target &amp;&gt(Source &amp; s)
+smart_cast_reference&lt;Target &amp;&gt;(Source &amp; s)
 </code></pre>

 <h3>Requirements</h3>
@@ -54,10 +54,10 @@ can also be used to delete objects created during a loading process
 that has been interrupted by throwing of an exception.  
 <p>
 This could cause problems in 
-progams where the copies of different objects are saved from the same address.
+programs where the copies of different objects are saved from the same address.
 <pre><code>
 template&lt;class Archive&gt;
-void save(boost::basic_oarchive  &amp; ar, const unsigned int version) const
+void save(boost::basic_oarchive &amp; ar, const unsigned int version) const
 {
    for(int i = 0; i &lt; 10; ++i){
        A x = a[i];
@@ -101,7 +101,7 @@ A similar problem can occur when different objects are loaded to an address
 which is different from the final location:
 <pre><code>
 template&lt;class Archive&gt;
-void load(boost::basic_oarchive  &amp; ar, const unsigned int version) const
+void load(boost::basic_oarchive &amp; ar, const unsigned int version) const
 {
    for(int i = 0; i &lt; 10; ++i){
        A x;
@@ -118,14 +118,14 @@ addressed by altering the above code thusly:

 <pre><code>
 template&lt;class Archive&gt;
-void load(boost::basic_iarchive  &amp; ar, const unsigned int version) const
+void load(boost::basic_iarchive &amp; ar, const unsigned int version) const
 {
    for(int i = 0; i &lt; 10; ++i){
        A x;
        ar &gt;&gt; x;
        std::pair&lt;std::set::const_iterator, bool&gt; result;
        result = std::m_set.insert(x);
-        ar.reset_object_address(& (*result.first), &x);
+        ar.reset_object_address(&amp; (*result.first), &amp;x);
    }
 }
 </code></pre>
@@ -159,7 +159,7 @@ BOOST_CLASS_TRACKING(my_virtual_base_class, boost::serialization::track_always)
 <h3><a name="helpersupport">Helper Support</a></h3>
 Some types, specially those with complicated lifetime behavior or limited
 access to their internal state, might need or benefit from elaborate serialization
-algorithms.  The prinicple motivating case is that of shared_ptr.  As instances
+algorithms.  The principle motivating case is that of shared_ptr.  As instances
 are loaded, they have to be "matched up" with any other instances which have
 already been loaded.  Thus, a table of previously loaded instances has to be
 maintained while the archive containing the shared_ptr instances is being loaded.
@@ -170,7 +170,7 @@ associated to the current archive that can be used to store contextual
 information relevant to the particular type serialization algorithm.

 <pre><code>
-template<class T>
+template&lt;class T&gt;
 class shared_ptr
 {
   ...
@@ -182,9 +182,9 @@ class shared_ptr_serialization_helper
 {
  // table of previously loaded shared_ptr
  // lookup a shared_ptr from the object address
-  shared_ptr<T> lookup(const T *);
+  shared_ptr&lt;T&gt; lookup(const T *);
  // insert a new shared_ptr
-  void insert<shared_ptr<T> >(const shared_ptr<T> *);
+  void insert&lt;shared_ptr&lt;T&gt; &gt;(const shared_ptr&lt;T&gt; *);
 };

 namespace boost {
@@ -220,7 +220,7 @@ void load(Archive &amp; ar, shared_ptr &amp; x, const unsigned int /* version */
    // if found, return the one from the table

    // load the shared_ptr data
-    shared_ptr<T> sp = ...
+    shared_ptr&lt;T&gt; sp = ...

    // and add it to the table
    hlp.insert(sp);
@@ -322,7 +322,7 @@ Another potential problem is illustrated by the following example:
 template&lt;class T&gt;
 struct my_wrapper {
    template&lt;class Archive&gt;
-    Archive & serialize ...
+    Archive &amp; serialize ...
 };

 ...
@@ -331,9 +331,9 @@ class my_class {
    wchar_t a;
    short unsigned b;
    template&lt;class Archive&gt;
-    Archive & serialize(Archive & ar, unsigned int version){
-        ar & my_wrapper(a);
-        ar & my_wrapper(b);
+    Archive &amp; serialize(Archive &amp; ar, unsigned int version){
+        ar &amp; my_wrapper(a);
+        ar &amp; my_wrapper(b);
    }
 };
 </code></pre>
@@ -379,7 +379,7 @@ XML format has a nested structure that maps well to the "recursive class member
 used by the serialization system. However, XML differs from other formats in that it 
 requires a name for each data member. Our goal is to add this information to the 
 class serialization specification while still permiting the the serialization code to be 
-used with any archive. This is achived by requiring that all data serialized to an XML archive
+used with any archive. This is archived by requiring that all data serialized to an XML archive
 be serialized as a <a target="detail" href="wrappers.html#nvp">name-value pair</a>.
 The first member is the name to be used as the XML tag for the
 data item while the second is a reference to the data item itself. Any attempt to serialize data
@@ -429,7 +429,7 @@ BOOST_CLASS_EXPORT(a)
 </code></pre>
 This will be true regardless of whether the code is part
 of a stand alone executable, a static library or
-a dyanmic or shared library.  
+a dynamic or shared library.  
 <p>
 Including
 <code style="white-space: normal">BOOST_CLASS_EXPORT</code>
@@ -451,12 +451,12 @@ 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>.
+<a href="archive_reference.html#polymorphic">Polymorphic 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 a catastophic error, the library traps ALL serializations through
+what would be a catastrophic error, the library traps ALL serializations through
 a pointer to a polymorphic class 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. 
@@ -507,7 +507,7 @@ 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 in a static library 
+where implementation of serialization is in a static library 
 completely separate from the main program.

 <h3><a name="dlls">DLLS - Serialization and Runtime Linking</a></h3>
@@ -526,7 +526,7 @@ 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
+where implementation of serialization 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 
@@ -552,19 +552,19 @@ needlessly duplicates code.  Worse, it makes is possible for
 different versions of the same code to exist simultaneously.  This
 type of error turns out to be excruciatingly difficult to debug.
 Finally, it opens the possibility that a module being referred to
-might be explictly unloaded which would (hopefully) result in
+might be explicitly 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);
+void serialize(Archive &amp; 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){
+void myclass::serialize(Archive &amp; ar, const unsigned int version){
 	...
 }

@@ -572,8 +572,8 @@ BOOST_CLASS_EXPORT_IMPLEMENT(my_class)

 #include &lt;boost/archive/text_oarchive&gt;
 #include &lt;boost/archive/text_iarchive&gt;
-template myclass::serialize(boost::archive::text_oarchive & ar, const unsigned int version);
-template myclass::serialize(boost::archive::text_iarchive & ar, const unsigned int version);
+template myclass::serialize(boost::archive::text_oarchive &amp; ar, const unsigned int version);
+template myclass::serialize(boost::archive::text_iarchive &amp; 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
@@ -624,7 +624,7 @@ about which is known only the <b>GUID</b> and a base class.
 <h3><a name="multi_threading">Multi-Threading</a></h3>
 The fundamental purpose of serialization would conflict with multiple 
 threads concurrently writing/reading from/to a single open archive instance.
-The library implementation presumes that the application avoids such a situtation.
+The library implementation presumes that the application avoids such a situation.
 <p>
 However, Writing/Reading different archives simultaneously
 in different tasks is permitted as each archive instance is (almost) 
@@ -32,7 +32,7 @@ and resets the object's state at destruction time, undoing any change the object
 may have gone through.  Here is the interface:

 <pre><code>
-template<class T>
+template&lt;class T&gt;
 // T requirements:
 //  - POD or object semantic (cannot be reference, function, ...)
 //  - copy constructor
@@ -43,7 +43,7 @@ private:
    ... // implementation

 public:
-    state_saver(T & object);
+    state_saver(T &amp; object);
    ~state_saver();
 };
 </code></pre>
@@ -56,7 +56,7 @@ The following illustrates how this is expected to be used.
 <pre><code>
 #include &lt;boost/state_saver.hpp&gt;

-void func(A & a)
+void func(A &amp; a)
    boost::state_saver&lt;A&gt; s(a);
    ... // alter state of a by calling non-const functions
    ... // call other functions
@@ -48,7 +48,7 @@ type, the way it is used and specifications of the programmer.
 <p>
 One can alter the manner in which a particular data type is serialized
 by specifying one or more <strong>class serialization traits</strong>.
-It is not generally necessary for the programmer to explictly assign
+It is not generally necessary for the programmer to explicitly assign
 traits to his classes as there are default values for all traits.
 If the default values are not appropriate they can be assigned by the programmer.
 A template is used to associate a typename with a constant.  For example
@@ -196,7 +196,7 @@ Default tracking traits are:
 The default behavior is almost always the most convenient one.  However,
 there a few cases where it would be desirable to override the
 default.  One case is that of a virtual base class. In a diamond
-heritance structure with a virtual base class, object tracking
+inheritance structure with a virtual base class, object tracking
 will prevent redundant save/load invocations.  So here is one
 case where it might be convenient to override the default tracking
 trait. <i>(Note: in a future version the default will be reimplemented
@@ -217,13 +217,13 @@ 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.
+be explicitly 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:
+satisfactory for our purposes for the following reasons:
 <ul>
  <li>There is no guarantee that the string is the same across platforms.
  This would then fail to support portable archives.
@@ -250,7 +250,7 @@ or
 <code style="white-space: normal">BOOST_CLASS_EXPORT_GUID(my_class, "my_class_external_identifier")</code>
 in either the declaration header or definition.  These macros
 expand to invocation 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>
+<i>(<b>GUID</b> stands for <b>G</b>lobally <b>U</b>nique <b>ID</b>entifier.)</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>
@@ -387,9 +387,9 @@ file <a href="../../../boost/serialization/is_bitwise_serializable.hpp" target="
 is used:
 <pre><code>
 namespace boost { namespace serialization {
-    template<class T>
+    template&lt;class T&gt;
    struct is_bitwise_serializable
-     : public is_arithmetic<T>
+     : public is_arithmetic&lt;T&gt;
    {};
 } }
 </code></pre>
@@ -516,7 +516,7 @@ and template parameters should be assigned according to the following table:
 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.  To the extent possible,
+library user which could result in surprising behavior.  To the extent possible,
 these conflicts are detected at compile time and errors (BOOST_STATIC_ASSERT) 
 or warnings (BOOST_STATIC_WARNING) are generated. They are generated in a
 compiler dependent manner which should show a chain of instantiation
@@ -528,7 +528,7 @@ usage.  Here is a list of the conflicts trapped:
 <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.
+implementation level is set to non_serializable.
 </dd>
 <dt><h2><a name="object_versioning">object_versioning</a> - error</h2></dt>
 <dd>
@@ -561,7 +561,7 @@ Likewise, the following code will trap at compile time:

 <code style="white-space: normal"><pre>
 T * t;
-ar >> t;
+ar &gt;&gt; t;
 </pre></code>

 if the tracking_level serialization trait is set to "track_never".
@@ -617,7 +617,7 @@ void main(){
 class K { 
    shared_ptr &lt;construct_from&gt; z; 
    template &lt;class Archive&gt; 
-    void serialize(Archive & ar, const unsigned version){ 
+    void serialize(Archive &amp; ar, const unsigned version){ 
        ar &lt;&lt; z; 
    } 
 }; 
@@ -630,9 +630,9 @@ class K {
  <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, 
+  first. After a series of very long and increasingly acrimonious email exchanges, 
 it's discovered 
-  that programmer(3) accidently broke programmer(2)'s code .This is because by 
+  that programmer(3) accidentally broke programmer(2)'s code .This is because by 
  serializing via a pointer, the "log" object is 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
@@ -683,7 +683,7 @@ ar &lt;&lt; x;
  <p>
  Things work fine and he moves on. 
  <p>
-  <li>Now programer (2) wants to make his change - and again another 
+  <li>Now programmer (2) wants to make his change - and again another 
  annoying const issue; 
 <code style="white-space: normal"><pre>
 Y y; 
@@ -709,7 +709,7 @@ ar &lt;&lt; x
      <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. 
+      and fire off a complaint to the list and maybe 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 
@@ -754,28 +754,28 @@ pay to avoid particularly vexing programming errors.

 <dt><h2><a name="pointer_level">pointer_level</a> - warning</h2></dt>
 <dd>
-This trap addresses the following situaion when serializing 
+This trap addresses the following situation 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.
+level &lt;= 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 absence of the operation ar << T * anywhere else in the 
+or absence of the operation <code style="white-space: normal">ar &lt;&lt; T *</code> 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
+includes the operation <code style="white-space: normal">ar &gt;&gt; T *</code> 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
+creates the archive doesn't include <code style="white-space: normal">ar &lt;&lt; T</code> 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, 
+Though this situation is unlikely for several reasons, 
 it is possible - hence this warning. 
 </ul>
 So if your program traps here, consider changing the 
@@ -136,7 +136,7 @@ int main() {
 <p>For each class to be saved via serialization, there must exist a function to
 save all the class members which define the state of the class.
 For each class to be loaded via serialization, there must exist a function to
-load theese class members in the same sequence as they were saved.
+load these class members in the same sequence as they were saved.
 In the above example, these functions are generated by the
 template member function <code style="white-space: normal">serialize</code>.

@@ -185,7 +185,7 @@ The main application of non-intrusive serialization is to permit serialization
 to be implemented for classes without changing the class definition.
 In order for this to be possible, the class must expose enough information
 to reconstruct the class state.  In this example, we presumed that the
-class had <code style="white-space: normal">public</code> members - not a common occurence.  Only
+class had <code style="white-space: normal">public</code> members - not a common occurrence.  Only
 classes which expose enough information to save and restore the class
 state will be serializable without changing the class definition.
 <h3><a name="serializablemembers">Serializable Members</a></h3>
@@ -290,7 +290,7 @@ class bus_route
    void serialize(Archive &amp; ar, const unsigned int version)
    {
        int i;
-        for(i = 0; i &lt 10; ++i)
+        for(i = 0; i &lt; 10; ++i)
            ar &amp; stops[i];
    }
 public:
@@ -541,7 +541,7 @@ This is described later in the manual.
    <dd>This is a variation the original demo which supports xml archives in addition
    to the others. The extra wrapping macro, BOOST_SERIALIZATION_NVP(name), is 
    needed to associate a data item name with the corresponding xml 
-    tag. It is importanted that 'name' be a valid xml tag, else it 
+    tag. It is important that 'name' be a valid xml tag, else it 
    will be impossible to restore the archive. 
    For more information see
    <a target="detail" href="wrappers.html#nvp">Name-Value Pairs</a>.
@@ -573,7 +573,7 @@ with serialization implementations for the Standard Library, the serialization l
 includes implementation of serialization for 
 <code style="white-space: normal">boost::shared ptr</code>.  Given this, it should be
 easy to alter any of these examples to eliminate the memory leak. This is left 
-as an excercise for the reader.
+as an exercise for the reader.

 <hr>
 <p><i>&copy; Copyright <a href="http://www.rrsd.com">Robert Ramey</a> 2002-2004. 
@@ -29,7 +29,7 @@ http://www.boost.org/LICENSE_1_0.txt)
 C++ includes the operator <code style="white-space: normal">dynamic_cast&lt;T&gt;(U * u)</code>
 for casting a pointer at runtime between two related types. However, this can only be 
 used for polymorphic classes.  That is, it can only be used with related classes which have at least one virtual function.
-Limiting the serializaton of pointers to only such classes would diminish the applicability
+Limiting the serialization of pointers to only such classes would diminish the applicability
 of the library.

 <h3>Usage</h3>
@@ -42,7 +42,7 @@ They are declared in the namespace
 <dl>
 <dt><h4><pre><code>
 template&lt;class Derived, class Base&gt;
-const void_cast_detail::void_caster &
+const void_cast_detail::void_caster &amp;
 void_cast_register(
    Derived const * derived = NULL, 
    Base * const base = NULL
@@ -67,8 +67,8 @@ This function "registers" a pair of related types.  It stores the fact that
 <dt><h4><pre><code>
 void *
 void_upcast(
-    extended_type_info const & derived_type,
-    extended_type_info const & base_type,
+    extended_type_info const &amp; derived_type,
+    extended_type_info const &amp; base_type,
    void * const t 
 );
 </code></pre></h4></dt>
@@ -76,8 +76,8 @@ void_upcast(
 <dt><h4><pre><code>
 void *
 void_downcast(
-    extended_type_info const & derived_type,
-    extended_type_info const & base_type,
+    extended_type_info const &amp; derived_type,
+    extended_type_info const &amp; base_type,
    void * const t 
 );
 </code></pre></h4></dt>
@@ -64,7 +64,7 @@ Its sole purpose is to pass the data size and address as a pair to the archive c

 <h3><a name="arrays">Arrays</a></h3>
 An array is a contiguous sequence of homogeneous data types, such as a builtin
-C-array, a <code>boost::array&lt;T></code> or a <code>std::vector&lt;T></code>. 
+C-array, a <code>boost::array&lt;T&gt;</code> or a <code>std::vector&lt;T&gt;</code>. 
 The purpose of this wrapper is to support archive types (such as binary
 archives) that provide optimized serialization for contiguous sequences of 
 objects of the same type. 
@@ -75,12 +75,12 @@ array.hpp
 </a>
 includes the function
 <pre><code>
-template &lt;T>
+template &lt;T&gt;
 boost::serialization::make_array(T* t, std::size_t size);
 </code></pre>
 which will construct a temporary <code>array</code> object
 <pre><code>
-template<class T>
+template&lt;class T&gt;
 class array
 {
 public:    
@@ -118,7 +118,7 @@ An example of a strong typedef is the <code>collection_size_type</code> in the
 header file
 <a href="../../../boost/serialization/collection_size_type.hpp" target="collection_size_type_hpp">
 collection_size_type.hpp
-</a>. This type should be used for serializaing the size of a C++ collection, so
+</a>. This type should be used for serializing the size of a C++ collection, so
 that the archive can pick the best integral representation for the serialization
 of collection sizes. This is necessary since, although <code>std::size_t</code>
 is guaranteed to be an integral type large enough to represent the size of
@@ -158,27 +158,27 @@ The xml archive classes contain code similar to:
 <pre><code>
 // special treatment for name-value pairs.
 template&lt;class T&gt;
-xml_oarchive & operator&(const boost::serialization::nvp<T> & t)
+xml_oarchive &amp; operator&amp;(const boost::serialization::nvp&lt;T&gt; &amp; t)
 {
    // write an xml start tag
    start_tag(t.name());

    // serialize the data as usual
-    *this & t.value();
+    *this &amp; t.value();

    // write an xml end tag
    end_tag(t.name());
 }
 </code></pre>
-The most obvious and convient name to assign to as the XML data item name
+The most obvious and convenient name to assign to as the XML data item name
 is - surprise! - the name of the C++ class data member.  So our serialization
 code will look like:
 <pre><code>
-ar & make_nvp("my_variable", my_variable);
+ar &amp; make_nvp("my_variable", my_variable);
 </code></pre>
 To simplify typing and enhance readability a macro is defined so we can write:
 <pre><code>
-ar & BOOST_SERIALIZATION_NVP(my_variable);
+ar &amp; BOOST_SERIALIZATION_NVP(my_variable);
 </code></pre>
 Similarly there exists a macro definition that permits us to write:
 <pre><code>
@@ -200,7 +200,7 @@ is example of the XML Archive corresponding to our tutorial example.
 Wrappers should be designed so that they can be composed as necessary.
 For example, to pass binary data as a name value pair use:
 <pre><code>
-ar & make_nvp("named_binary_object", make_binary_object(address, size));
+ar &amp; make_nvp("named_binary_object", make_binary_object(address, size));
 </code></pre>
 </html>
 <hr>
@@ -28,20 +28,20 @@
 // users of the serialization package.  An attempt has been made
 // to illustrate most of the facilities of the package.
 //
-// The intent is to create an example suffciently complete to
+// The intent is to create an example sufficiently complete to
 // illustrate the usage and utility of the package while
 // including a minimum of other code.
 //
 // 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
+// There are different kinds of stops.  Bus stops in general
 // will appear on multiple routes.  A schedule will include
-// muliple trips on the same route.
+// multiple trips on the same route.

 /////////////////////////////////////////////////////////////
 // gps coordinate
 //
-// llustrates serialization for a simple type
+// illustrates serialization for a simple type
 //
 class gps_position
 {
@@ -162,7 +162,7 @@ public:
 //
 // illustrates serialization of STL collection templates.
 //
-// illustrates serialzation of polymorphic pointer (bus stop *);
+// illustrates serialization 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
@@ -233,7 +233,7 @@ public:
            if(file_version >= 2)
                // read the drivers name
                ar & driver;
-            // all versions have the follwing info
+            // all versions have the following info
            ar & hour & minute;
        }

@@ -326,7 +326,7 @@ int main(int argc, char *argv[])
        "Lincoln Memorial"
    );

-    // make a  routes
+    // make a route
    bus_route route0;
    route0.append(bs0);
    route0.append(bs1);
@@ -337,7 +337,7 @@ int main(int argc, char *argv[])
    original_schedule.append("bob", 9, 57, &route0);
    original_schedule.append("alice", 11, 02, &route0);

-    // make aother routes
+    // make another route
    bus_route route1;
    route1.append(bs3);
    route1.append(bs2);
@@ -359,7 +359,7 @@ int main(int argc, char *argv[])
    save_schedule(original_schedule, filename.c_str());

    // ... some time later
-    // make  a new schedule
+    // make a new schedule
    bus_schedule new_schedule;

    restore_schedule(new_schedule, filename.c_str());
@@ -127,7 +127,7 @@ private:
 // case 1:
 template<class Archive>
 void School::serialize(Archive & ar, const unsigned int /* file_version */){
-    // if an exeception occurs while loading courses
+    // if an exception occurs while loading courses
    // the structure courses may have some courses each
    // with students
    ar & all_courses;
@@ -155,7 +155,7 @@ void School::save(Archive & ar, const unsigned int /* file_version */) const {

 template<class Archive>
 void School::load(Archive & ar, const unsigned int /* file_version */){
-    // if an exeception occurs while loading courses
+    // if an exception occurs while loading courses
    // the structure courses may have some courses each
    // with students
    try{
@@ -167,7 +167,7 @@ void School::load(Archive & ar, const unsigned int /* file_version */){
        ar >> all_students; // create students that have no courses
    }
    catch(std::exception){
-        // elminate any dangling references
+        // eliminate any dangling references
        all_courses.clear();
        all_students.clear();
        throw;
@@ -23,14 +23,14 @@

 // 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
+// There are different kinds of stops.  Bus stops in general
 // will appear on multiple routes.  A schedule will include
-// muliple trips on the same route.
+// multiple trips on the same route.

 /////////////////////////////////////////////////////////////
 // gps coordinate
 //
-// llustrates serialization for a simple type
+// illustrates serialization for a simple type
 //
 class gps_position
 {
@@ -159,7 +159,7 @@ public:
 //
 // illustrates serialization of STL collection templates.
 //
-// illustrates serialzation of polymorphic pointer (bus stop *);
+// illustrates serialization 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
@@ -236,7 +236,7 @@ public:
            if(file_version >= 2)
                // read the drivers name
                ar & BOOST_SERIALIZATION_NVP(driver);
-            // all versions have the follwing info
+            // all versions have the following info
            ar  & BOOST_SERIALIZATION_NVP(hour)
                & BOOST_SERIALIZATION_NVP(minute);
        }
@@ -40,7 +40,7 @@ int main(int argc, char *argv[]){
        "Lincoln Memorial"
    );

-    // make a  routes
+    // make a route
    bus_route route0;
    route0.append(bs0);
    route0.append(bs1);
@@ -51,7 +51,7 @@ int main(int argc, char *argv[]){
    schedule.append("bob", 9, 57, &route0);
    schedule.append("alice", 11, 02, &route0);

-    // make aother routes
+    // make another route
    bus_route route1;
    route1.append(bs3);
    route1.append(bs2);
@@ -32,8 +32,8 @@ void A::serialize(Archive & ar, const unsigned int /* file_version */){
    ar & pimpl;
 }

-// without the explicit instantiations below, the program will
-// fail to link for lack of instantiantiation of the above function
+// without the explicit instantiation below, the program will
+// fail to link for lack of instantiation of the above function
 // note: the following failed to fix link errors for vc 7.0 !
 template void A::serialize<boost::archive::text_iarchive>(
    boost::archive::text_iarchive & ar,
@@ -26,7 +26,7 @@ int main(int argc, char* argv[])
        // test with a text archive
        std::stringstream ss;
        {
-            // instantiate archive which inhertis polymorphic interface
+            // instantiate archive which inherits polymorphic interface
            // and the normal text archive implementation
            boost::archive::polymorphic_text_oarchive oa(ss);
            boost::archive::polymorphic_oarchive & oa_interface = oa;
@@ -45,7 +45,7 @@ int main(int argc, char* argv[])
        //test with a binary archive
        std::stringstream ss;
        {
-            // instantiate archive which inhertis polymorphic interface
+            // instantiate archive which inherits polymorphic interface
            // and the normal binary archive implementation
            boost::archive::polymorphic_binary_oarchive oa(ss);
            oa << a;
@@ -41,7 +41,7 @@ int main(int argc, char *argv[])
        "Lincoln Memorial"
    );

-    // make a  routes
+    // make a route
    bus_route route0;
    route0.append(bs0);
    route0.append(bs1);
@@ -52,7 +52,7 @@ int main(int argc, char *argv[])
    schedule.append("bob", 9, 57, &route0);
    schedule.append("alice", 11, 02, &route0);

-    // make aother routes
+    // make another route
    bus_route route1;
    route1.append(bs3);
    route1.append(bs2);
@@ -60,7 +60,7 @@ int main(int argc, char *argv[])
        "Lincoln Memorial"
    );

-    // make a  routes
+    // make a route
    bus_route route0;
    route0.append(bs0);
    route0.append(bs1);
@@ -71,7 +71,7 @@ int main(int argc, char *argv[])
    schedule.append("bob", 9, 57, &route0);
    schedule.append("alice", 11, 02, &route0);

-    // make aother routes
+    // make another route
    bus_route route1;
    route1.append(bs3);
    route1.append(bs2);
@@ -74,7 +74,7 @@ int main(int argc, char *argv[])
        "Lincoln Memorial"
    );

-    // make a  routes
+    // make a route
    bus_route route0;
    route0.append(bs0);
    route0.append(bs1);
@@ -85,7 +85,7 @@ int main(int argc, char *argv[])
    original_schedule.append("bob", 9, 57, &route0);
    original_schedule.append("alice", 11, 02, &route0);

-    // make aother routes
+    // make another route
    bus_route route1;
    route1.append(bs3);
    route1.append(bs2);
@@ -107,7 +107,7 @@ int main(int argc, char *argv[])
    save_schedule(original_schedule, filename.c_str());

    // ... some time later
-    // make  a new schedule
+    // make a new schedule
    bus_schedule new_schedule;

    restore_schedule(new_schedule, filename.c_str());
@@ -23,14 +23,14 @@

 // 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
+// There are different kinds of stops.  Bus stops in general
 // will appear on multiple routes.  A schedule will include
-// muliple trips on the same route.
+// multiple trips on the same route.

 /////////////////////////////////////////////////////////////
 // gps coordinate
 //
-// llustrates serialization for a simple type
+// illustrates serialization for a simple type
 //
 class gps_position
 {
@@ -159,7 +159,7 @@ public:
 //
 // illustrates serialization of STL collection templates.
 //
-// illustrates serialzation of polymorphic pointer (bus stop *);
+// illustrates serialization 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
@@ -236,7 +236,7 @@ public:
            if(file_version >= 2)
                // read the drivers name
                ar & BOOST_SERIALIZATION_NVP(driver);
-            // all versions have the follwing info
+            // all versions have the following info
            ar  & BOOST_SERIALIZATION_NVP(hour)
                & BOOST_SERIALIZATION_NVP(minute);
        }
@@ -51,7 +51,7 @@ int main(int argc, char *argv[])
        "Lincoln Memorial"
    );

-    // make a  routes
+    // make a route
    bus_route route0;
    route0.append(bs0);
    route0.append(bs1);
@@ -62,7 +62,7 @@ int main(int argc, char *argv[])
    original_schedule.append("bob", 9, 57, &route0);
    original_schedule.append("alice", 11, 02, &route0);

-    // make aother routes
+    // make an other route
    bus_route route1;
    route1.append(bs3);
    route1.append(bs2);
@@ -27,7 +27,7 @@ namespace boost {
 } // boost

 /////////////////////////////////////////////////////////////////////////
-// log data to an output stream.  This illustrates a simpler implemenation
+// log data to an output stream.  This illustrates a simpler implementation
 // 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 :
@@ -35,7 +35,7 @@ class log_archive :
    public boost::archive::xml_oarchive_impl<log_archive>
 {
    typedef boost::archive::xml_oarchive_impl<log_archive> base;
-    // give serialization implementation access to this clas
+    // give serialization implementation access to this class
    friend class boost::archive::detail::interface_oarchive<log_archive>;
    friend class boost::archive::basic_xml_oarchive<log_archive>;
    friend class boost::archive::save_access;
@@ -62,7 +62,7 @@ public:
 };

 /////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// "Portable" input binary archive.  It addresses integer size and endienness so
+// "Portable" input binary archive.  It addresses integer size and endianness so
 // that binary archives can be passed across systems. Note:floating point types
 // not addressed here
 class portable_binary_iarchive :
@@ -57,7 +57,7 @@ public:

 /////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
 // "Portable" output binary archive.  This is a variation of the native binary
-// archive. it addresses integer size and endienness so that binary archives can
+// archive. it addresses integer size and endianness so that binary archives can
 // be passed across systems. Note:floating point types not addressed here

 class portable_binary_oarchive :
@@ -37,7 +37,7 @@ namespace std{
 #include <boost/serialization/access.hpp>

 /////////////////////////////////////////////////////////////////////////
-// log data to an output stream.  This illustrates a simpler implemenation
+// log data to an output stream.  This illustrates a simpler implementation
 // 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 {
@@ -91,7 +91,7 @@ class simple_log_archive {
    }
    #ifndef BOOST_NO_STD_WSTRING
    void save(const std::wstring &ws){
-        m_os << "wide string types not suported in log archive";
+        m_os << "wide string types not supported in log archive";
    }
    #endif

@@ -60,7 +60,7 @@ public:
    operator base_type () const {
        return t;
    }
-    // used for text intput
+    // used for text input
    operator base_type  & (){
        return t;
    }
@@ -10,7 +10,7 @@
 // basic_binary_iarchive.hpp
 //
 // archives stored as native binary - this should be the fastest way
-// to archive the state of a group of obects.  It makes no attempt to
+// to archive the state of a group of objects.  It makes no attempt to
 // convert to any canonical form.

 // IN GENERAL, ARCHIVES CREATED WITH THIS CLASS WILL NOT BE READABLE
@@ -69,7 +69,7 @@ protected:
    // intermediate level to support override of operators
    // 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
+    // note extra nonsense to sneak it pass the borland compilers
    typedef detail::common_iarchive<Archive> detail_common_iarchive;
    template<class T>
    void load_override(T & t){
@@ -14,7 +14,7 @@
 // basic_binary_iprimitive.hpp
 //
 // archives stored as native binary - this should be the fastest way
-// to archive the state of a group of obects.  It makes no attempt to
+// to archive the state of a group of objects.  It makes no attempt to
 // convert to any canonical form.

 // IN GENERAL, ARCHIVES CREATED WITH THIS CLASS WILL NOT BE READABLE
@@ -89,7 +89,7 @@ public:
    std::locale archive_locale;
    #endif

-    // main template for serilization of primitive types
+    // main template for serialization of primitive types
    template<class T>
    void load(T & t){
        load_binary(& t, sizeof(T));
@@ -17,7 +17,7 @@
 //  See http://www.boost.org for updates, documentation, and revision history.

 // archives stored as native binary - this should be the fastest way
-// to archive the state of a group of obects.  It makes no attempt to
+// to archive the state of a group of objects.  It makes no attempt to
 // convert to any canonical form.

 // IN GENERAL, ARCHIVES CREATED WITH THIS CLASS WILL NOT BE READABLE
@@ -53,9 +53,9 @@ namespace detail {
 // class basic_binary_oarchive - write serialized objects to a binary output stream
 // note: this archive has no pretensions to portability.  Archive format
 // may vary across machine architectures and compilers.  About the only
-// guarentee is that an archive created with this code will be readable
-// by a program built with the same tools for the same machne.  This class
-// does have the virtue of buiding the smalles archive in the minimum amount
+// guarantee is that an archive created with this code will be readable
+// by a program built with the same tools for the same machine.  This class
+// does have the virtue of building the smallest archive in the minimum amount
 // of time.  So under some circumstances it may be he right choice.
 template<class Archive>
 class BOOST_SYMBOL_VISIBLE basic_binary_oarchive :
@@ -73,7 +73,7 @@ protected:
        friend class detail::interface_oarchive<Archive>;
    #endif
 #endif
-    // any datatype not specifed below will be handled by base class
+    // any datatype not specified below will be handled by base class
    typedef detail::common_oarchive<Archive> detail_common_oarchive;
    template<class T>
    void save_override(const T & t){
@@ -17,7 +17,7 @@
 //  See http://www.boost.org for updates, documentation, and revision history.

 // archives stored as native binary - this should be the fastest way
-// to archive the state of a group of obects.  It makes no attempt to
+// to archive the state of a group of objects.  It makes no attempt to
 // convert to any canonical form.

 // IN GENERAL, ARCHIVES CREATED WITH THIS CLASS WILL NOT BE READABLE
@@ -56,7 +56,7 @@ namespace boost {
 namespace archive {

 /////////////////////////////////////////////////////////////////////////
-// class basic_binary_oprimitive - binary output of prmitives
+// class basic_binary_oprimitive - binary output of primitives

 template<class Archive, class Elem, class Tr>
 class BOOST_SYMBOL_VISIBLE basic_binary_oprimitive {
@@ -156,7 +156,7 @@ basic_binary_oprimitive<Archive, Elem, Tr>::save_binary(
    // BOOST_ASSERT(count <= std::size_t(boost::integer_traits<std::streamsize>::const_max));
    // note: if the following assertions fail
    // a likely cause is that the output stream is set to "text"
-    // mode where by cr characters recieve special treatment.
+    // mode where by cr characters receive special treatment.
    // be sure that the output stream is opened with ios::binary
    //if(os.fail())
    //    boost::serialization::throw_exception(
@@ -61,7 +61,7 @@ namespace boost {
 namespace archive {

 /////////////////////////////////////////////////////////////////////////
-// class basic_text_oprimitive - output of prmitives to stream
+// class basic_text_oprimitive - output of primitives to stream
 template<class OStream>
 class BOOST_SYMBOL_VISIBLE basic_text_oprimitive
 {
@@ -159,17 +159,18 @@ protected:
                archive_exception(archive_exception::output_stream_error)
            );
        }
-        // The formulae for the number of decimla digits required is given in
+        // The formulae for the number of decimal digits required is given in
        // http://www2.open-std.org/JTC1/SC22/WG21/docs/papers/2005/n1822.pdf
        // which is derived from Kahan's paper:
        // www.eecs.berkeley.edu/~wkahan/ieee754status/ieee754.ps
        // const unsigned int digits = (std::numeric_limits<T>::digits * 3010) / 10000;
        // note: I've commented out the above because I didn't get good results.  e.g.
        // in one case I got a difference of 19 units.
+        const unsigned int digits =
        #ifndef BOOST_NO_CXX11_NUMERIC_LIMITS
-            const unsigned int digits = std::numeric_limits<T>::max_digits10;
+            std::numeric_limits<T>::max_digits10;
        #else
-            const unsigned int digits = std::numeric_limits<T>::digits10 + 2;
+            std::numeric_limits<T>::digits10 + 2;
        #endif
        os << std::setprecision(digits) << std::scientific << t;
    }
@@ -29,7 +29,7 @@ namespace boost {
 namespace archive {

 // do not derive from this class.  If you want to extend this functionality
-// via inhertance, derived from binary_iarchive_impl instead.  This will
+// via inheritance, derived from binary_iarchive_impl instead.  This will
 // preserve correct static polymorphism.
 class BOOST_SYMBOL_VISIBLE binary_iarchive :
    public binary_iarchive_impl<
@@ -30,7 +30,7 @@ namespace boost {
 namespace archive {

 // do not derive from this class.  If you want to extend this functionality
-// via inhertance, derived from binary_oarchive_impl instead.  This will
+// via inheritance, derived from binary_oarchive_impl instead.  This will
 // preserve correct static polymorphism.
 class BOOST_SYMBOL_VISIBLE binary_oarchive :
    public binary_oarchive_impl<
@@ -29,7 +29,7 @@ namespace boost {
 namespace archive {

 // do not derive from this class.  If you want to extend this functionality
-// via inhertance, derived from binary_oarchive_impl instead.  This will
+// via inheritance, derived from binary_oarchive_impl instead.  This will
 // preserve correct static polymorphism.
 class binary_woarchive :
    public binary_oarchive_impl<
@@ -52,7 +52,7 @@ class codecvt_null;
 template<>
 class codecvt_null<char> : public std::codecvt<char, char, std::mbstate_t>
 {
-    bool do_always_noconv() const throw() BOOST_OVERRIDE {
+    bool do_always_noconv() const BOOST_NOEXCEPT_OR_NOTHROW BOOST_OVERRIDE {
        return true;
    }
 public:
@@ -88,15 +88,15 @@ class BOOST_SYMBOL_VISIBLE codecvt_null<wchar_t> :
        wchar_t * & next2
    ) const BOOST_OVERRIDE;

-    BOOST_SYMBOL_EXPORT int do_encoding( ) const throw( ) BOOST_OVERRIDE {
+    BOOST_SYMBOL_EXPORT int do_encoding( ) const BOOST_NOEXCEPT_OR_NOTHROW BOOST_OVERRIDE {
        return sizeof(wchar_t) / sizeof(char);
    }

-    BOOST_SYMBOL_EXPORT bool do_always_noconv() const throw() BOOST_OVERRIDE {
+    BOOST_SYMBOL_EXPORT bool do_always_noconv() const BOOST_NOEXCEPT_OR_NOTHROW BOOST_OVERRIDE {
        return false;
    }

-    BOOST_SYMBOL_EXPORT int do_max_length( ) const throw( ) BOOST_OVERRIDE {
+    BOOST_SYMBOL_EXPORT int do_max_length( ) const BOOST_NOEXCEPT_OR_NOTHROW BOOST_OVERRIDE {
        return do_encoding();
    }
 public:
@@ -7,7 +7,7 @@
 #endif

 /////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// archive_serializer_map.hpp: extenstion of type_info required for
+// archive_serializer_map.hpp: extension of type_info required for
 // serialization.

 // (C) Copyright 2009 Robert Ramey - http://www.rrsd.com .
@@ -17,7 +17,7 @@

 //  See http://www.boost.org for updates, documentation, and revision history.

-// note: this is nothing more than the thinest of wrappers around
+// note: this is nothing more than the thinnest of wrappers around
 // basic_serializer_map so we can have a one map / archive type.

 #include <boost/config.hpp>
@@ -7,7 +7,7 @@
 #endif

 /////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// basic_iserializer.hpp: extenstion of type_info required for serialization.
+// basic_iserializer.hpp: extension 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
@@ -78,7 +78,7 @@ public:
    virtual void destroy(/*const*/ void *address) const = 0 ;
 };

-} // namespae detail
+} // namespace detail
 } // namespace archive
 } // namespace boost

@@ -7,7 +7,7 @@
 #endif

 /////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// basic_oserializer.hpp: extenstion of type_info required for serialization.
+// basic_oserializer.hpp: extension 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
@@ -7,7 +7,7 @@
 #endif

 /////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// basic_pointer_oserializer.hpp: extenstion of type_info required for
+// basic_pointer_oserializer.hpp: extension of type_info required for
 // serialization.

 // (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
@@ -7,7 +7,7 @@
 #endif

 /////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// basic_pointer_oserializer.hpp: extenstion of type_info required for
+// basic_pointer_oserializer.hpp: extension of type_info required for
 // serialization.

 // (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
@@ -7,7 +7,7 @@
 #endif

 /////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// basic_serializer.hpp: extenstion of type_info required for serialization.
+// basic_serializer.hpp: extension 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
@@ -7,7 +7,7 @@
 #endif

 /////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// basic_serializer_map.hpp: extenstion of type_info required for serialization.
+// basic_serializer_map.hpp: extension 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
@@ -94,7 +94,7 @@ inline void check_object_tracking(){
    // may be an indicator of an error usage of the
    // serialization library and should be double checked.
    // See documentation on object tracking.  Also, see the
-    // "rationale" section of the documenation
+    // "rationale" section of the documentation
    // for motivation for this checking.

    BOOST_STATIC_WARNING(typex::value);
@@ -169,12 +169,12 @@ BOOST_DLLEXPORT void iserializer<Archive, T>::load_object_data(
    void *x,
    const unsigned int file_version
 ) const {
-    // note: we now comment this out. Before we permited archive
+    // note: we now comment this out. Before we permitted archive
    // version # to be very large.  Now we don't.  To permit
    // readers of these old archives, we have to suppress this
    // code.  Perhaps in the future we might re-enable it but
    // permit its suppression with a runtime switch.
-    #if 0
+    #if 1
    // trap case where the program cannot handle the current version
    if(file_version > static_cast<const unsigned int>(version()))
        boost::serialization::throw_exception(
@@ -184,7 +184,7 @@ BOOST_DLLEXPORT void iserializer<Archive, T>::load_object_data(
            )
        );
    #endif
-    // make sure call is routed through the higest interface that might
+    // make sure call is routed through the highest interface that might
    // be specialized by the user.
    boost::serialization::serialize_adl(
        boost::serialization::smart_cast_reference<Archive &>(ar),
@@ -308,7 +308,7 @@ private:
        const unsigned int file_version
    ) const BOOST_OVERRIDE BOOST_USED;
 public:
-    // this should alway be a singleton so make the constructor protected
+    // this should always be a singleton so make the constructor protected
    pointer_iserializer();
    ~pointer_iserializer() BOOST_OVERRIDE;
 };
@@ -392,7 +392,7 @@ struct load_non_pointer_type {
        template<class T>
        static void invoke(Archive & ar, const T & t){
            // short cut to user's serializer
-            // make sure call is routed through the higest interface that might
+            // make sure call is routed through the highest interface that might
            // be specialized by the user.
            boost::serialization::serialize_adl(
                ar,
@@ -589,7 +589,7 @@ struct load_array_type {
                    boost::archive::archive_exception::array_size_too_short
                )
            );
-        // explict template arguments to pass intel C++ compiler
+        // explicit template arguments to pass intel C++ compiler
        ar >> serialization::make_array<
            value_type,
            boost::serialization::collection_size_type
@@ -509,7 +509,7 @@ struct save_array_type
        );
        boost::serialization::collection_size_type count(c);
        ar << BOOST_SERIALIZATION_NVP(count);
-        // explict template arguments to pass intel C++ compiler
+        // explicit template arguments to pass intel C++ compiler
        ar << serialization::make_array<
            const value_type,
            boost::serialization::collection_size_type
@@ -10,6 +10,7 @@

 #include <boost/assert.hpp>
 #include <cstddef> // NULL
+#include <cstring> // strlen
 #include <algorithm>

 #include <boost/serialization/throw_exception.hpp>
@@ -58,7 +59,10 @@ basic_xml_iarchive<Archive>::load_end(const char *name){
        
    if(0 == (this->get_flags() & no_xml_tag_checking)){
        // double check that the tag matches what is expected - useful for debug
-        if(0 != name[this->This()->gimpl->rv.object_name.size()]
+        std::size_t parameter_name_length = std::strlen(name);
+        std::size_t object_name_length = this->This()->gimpl->rv.object_name.size();
+
+        if(parameter_name_length != object_name_length
        || ! std::equal(
                this->This()->gimpl->rv.object_name.begin(),
                this->This()->gimpl->rv.object_name.end(),
@@ -42,7 +42,7 @@ public:
    base64_exception(exception_code c = other_exception) : code(c)
    {}

-    virtual const char *what( ) const throw( )
+    virtual const char *what( ) const BOOST_NOEXCEPT_OR_NOTHROW
    {
        const char *msg = "unknown exception code";
        switch(code){
@@ -84,7 +84,7 @@ class base64_from_binary :
    > super_t;

 public:
-    // make composible buy using templated constructor
+    // make composable by using templated constructor
    template<class T>
    base64_from_binary(T start) :
        super_t(
@@ -93,7 +93,7 @@ class binary_from_base64 : public
        Base
    > super_t;
 public:
-    // make composible buy using templated constructor
+    // make composable by using templated constructor
    template<class T>
    binary_from_base64(T  start) :
        super_t(
@@ -46,7 +46,7 @@ public:
    dataflow_exception(exception_code c = other_exception) : code(c)
    {}

-    const char *what( ) const throw( ) BOOST_OVERRIDE
+    const char *what( ) const BOOST_NOEXCEPT_OR_NOTHROW BOOST_OVERRIDE
    {
        const char *msg = "unknown exception code";
        switch(code){
@@ -79,7 +79,7 @@ private:
    }
    unsigned int m_count;
 public:
-    // make composible buy using templated constructor
+    // make composable by using templated constructor
    template<class T>
    insert_linebreaks(T  start) :
        super_t(Base(static_cast< T >(start))),
@@ -18,6 +18,7 @@

 #include <boost/assert.hpp>
 #include <cstddef> // size_t
+#include <cstring> // memcpy
 #ifndef BOOST_NO_CWCHAR
 #include <cwchar> //  mbstate_t
 #endif
@@ -25,6 +26,7 @@
 #if defined(BOOST_NO_STDC_NAMESPACE)
 namespace std{
    using ::mbstate_t;
+    using ::memcpy;
 } // namespace std
 #endif

@@ -117,7 +119,7 @@ class mb_from_wchar
    bool m_full;

 public:
-    // make composible buy using templated constructor
+    // make composable by using templated constructor
    template<class T>
    mb_from_wchar(T start) :
        super_t(Base(static_cast< T >(start))),
@@ -129,10 +131,13 @@ public:
    // intel 7.1 doesn't like default copy constructor
    mb_from_wchar(const mb_from_wchar & rhs) :
        super_t(rhs.base_reference()),
+        m_mbs(rhs.m_mbs),
        m_bend(rhs.m_bend),
        m_bnext(rhs.m_bnext),
        m_full(rhs.m_full)
-    {}
+    {
+        std::memcpy(m_buffer, rhs.m_buffer, sizeof(m_buffer));
+    }
 };

 } // namespace iterators
@@ -149,7 +149,7 @@ class remove_whitespace :
    > super_t;
 public:
 //    remove_whitespace(){} // why is this needed?
-    // make composible buy using templated constructor
+    // make composable by using templated constructor
    template<class T>
    remove_whitespace(T start) :
        super_t(Base(static_cast< T >(start)))
@@ -106,7 +106,7 @@ class transform_width :
    bool m_end_of_sequence;

 public:
-    // make composible buy using templated constructor
+    // make composable by using templated constructor
    template<class T>
    transform_width(T start) :
        super_t(Base(static_cast< T >(start))),
@@ -124,7 +124,7 @@ class wchar_from_mb
    sliding_buffer<typename iterator_value<this_t>::type> m_output;

 public:
-    // make composible buy using templated constructor
+    // make composable by using templated constructor
    template<class T>
    wchar_from_mb(T start) :
        super_t(Base(static_cast< T >(start))),
@@ -79,7 +79,7 @@ void xml_unescape<Base>::drain_residue(const char * literal){

 // note key constraint on this function is that can't "look ahead" any
 // more than necessary into base iterator.  Doing so would alter the base
-// iterator refenence which would make subsequent iterator comparisons
+// iterator reference which would make subsequent iterator comparisons
 // incorrect and thereby break the composiblity of iterators.
 template<class Base>
 typename xml_unescape<Base>::value_type
@@ -35,7 +35,7 @@ public:
    xml_unescape_exception()
    {}

-    virtual const char *what( ) const throw( )
+    virtual const char *what( ) const BOOST_NOEXCEPT_OR_NOTHROW
    {
        return "xml contained un-recognized escape code";
    }
@@ -8,7 +8,7 @@

 // for serialization of <array>. If <array> not supported by the standard
 // library - this file becomes empty.  This is to avoid breaking backward
-// compatibiliy for applications which used this header to support
+// compatibility for applications which used this header to support
 // serialization of native arrays.  Code to serialize native arrays is
 // now always include by default.  RR

@@ -52,7 +52,7 @@ public:
    template<class Archive>
    void serialize_optimized(Archive &ar, const unsigned int, mpl::false_ ) const
    {
-      // default implemention does the loop
+      // default implementation does the loop
      std::size_t c = count();
      T * t = address();
      while(0 < c--)
@@ -1,125 +0,0 @@
-#ifndef BOOST_SERIALIZATION_COLLECTION_SIZE_TYPE_HPP
-#define BOOST_SERIALIZATION_COLLECTION_SIZE_TYPE_HPP
-
-// (C) Copyright 2005  Matthias Troyer
-// (C) Copyright 2020  Robert Ramey
-
-// 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> // size_t
-#include <boost/assert.hpp>
-#include <boost/operators.hpp>
-#include <boost/serialization/level.hpp>
-#include <boost/serialization/is_bitwise_serializable.hpp>
-
-namespace boost {
-namespace serialization {
-
-template<typename T> // T is the basic type holding the integer
-struct cardinal_number : private
-    boost::totally_ordered<cardinal_number<T> >,
-    boost::additive<cardinal_number<T> >,
-    boost::unit_steppable<cardinal_number<T> >
-{
-private:
-    template<typename CharType, typename Traits>
-    friend std::basic_ostream<CharType, Traits> & operator<<(
-        const std::basic_ostream<CharType, Traits> & bos,
-        const cardinal_number & rhs
-    );
-    template<typename CharType, typename Traits>
-    friend std::basic_istream<CharType, Traits> & operator>>(
-        std::basic_istream<CharType, Traits> & bis,
-        const cardinal_number & rhs
-    );
-public:
-    T m_t;
-    cardinal_number(T t = 0) :
-        m_t(t)
-    {}
-    cardinal_number(unsigned int t) :
-        m_t(t)
-    {}
-    cardinal_number(int t) :
-        m_t(t)
-    {
-        BOOST_ASSERT(t >= 0);
-    }
-    operator const T (){
-        return m_t;
-    }
-    // assignment operator
-    cardinal_number & operator=(const cardinal_number & rhs){
-        m_t = rhs.m_t;
-        return *this;
-    }
-    // basic operations upon which others depend
-    // totally ordered / less_than_comparable
-    bool operator<(const cardinal_number & rhs) const {
-        return m_t < rhs.m_t;
-    }
-    bool operator==(const cardinal_number & rhs) const {
-        return m_t == rhs.m_t;
-    }
-    // additive
-    cardinal_number & operator+=(const cardinal_number & rhs){
-        m_t += rhs.m_t;
-        return *this;
-    }
-    // subtractive
-    cardinal_number & operator-=(const cardinal_number & rhs){
-        BOOST_ASSERT(m_t >= rhs.m_t);
-        m_t -= rhs.m_t;
-        return *this;
-    }
-    // increment
-    cardinal_number operator++(){
-        ++m_t;
-        return *this;
-     }
-     // decrement
-    cardinal_number operator--(){
-        BOOST_ASSERT(m_t > T(0));
-        --m_t;
-        return *this;
-     }
-};
-
-typedef cardinal_number<std::size_t> collection_size_type;
-
-} } // end namespace boost::serialization
-
-#include <ostream>
-#include <istream>
-
-namespace std {
-
-template<typename CharType, typename Traits>
-basic_ostream<CharType, Traits> & operator<<(
-    std::basic_ostream<CharType, Traits> & bos,
-    const boost::serialization::collection_size_type & rhs
-){
-    bos << rhs.m_t;
-    return bos;
-}
-
-template<typename CharType, typename Traits>
-basic_istream<CharType, Traits> & operator>>(
-    std::basic_istream<CharType, Traits> & bis,
-    boost::serialization::collection_size_type & rhs
-){
-    bis >> rhs.m_t;
-    return bis;
-}
-
-} // std
-
-BOOST_CLASS_IMPLEMENTATION(                     \
-    boost::serialization::collection_size_type, \
-    primitive_type                              \
-)
-BOOST_IS_BITWISE_SERIALIZABLE(boost::serialization::collection_size_type)
-
-#endif //BOOST_SERIALIZATION_COLLECTION_SIZE_TYPE_HPP
@@ -16,7 +16,7 @@

 //  See http://www.boost.org for updates, documentation, and revision history.

-// This header assigns a level implemenation trait to a collection type
+// This header assigns a level implementation trait to a collection type
 // for all primitives.  It is needed so that archives which are meant to be
 // portable don't write class information in the archive.  Since, not all
 // compiles recognize the same set of primitive types, the possibility
@@ -28,7 +28,7 @@
    struct is_default_constructible : public std::is_default_constructible<T> {};

    } // detail
-    } // serializaition
+    } // serialization
    } // boost
 #else
    // we don't have standard library support for is_default_constructible
@@ -45,7 +45,7 @@
    struct is_default_constructible : public boost::has_trivial_constructor<T> {};

    } // detail
-    } // serializaition
+    } // serialization
    } // boost

 #endif
@@ -70,7 +70,7 @@ class bad_weak_ptr: public std::exception
 {
 public:

-    virtual char const * what() const throw()
+    virtual char const * what() const BOOST_NOEXCEPT_OR_NOTHROW
    {
        return "boost::bad_weak_ptr";
    }
@@ -60,7 +60,7 @@ struct stack_construct : public stack_allocate<T>
 };

 } // detail
-} // serializaition
+} // serialization
 } // boost

 #endif //  BOOST_SERIALIZATION_DETAIL_STACH_CONSTRUCTOR_HPP
@@ -125,7 +125,7 @@ struct guid_initializer
    guid_initializer const & export_guid() const {
        BOOST_STATIC_WARNING(boost::is_polymorphic< T >::value);
        // note: exporting an abstract base class will have no effect
-        // and cannot be used to instantitiate serialization code
+        // and cannot be used to instantiate serialization code
        // (one might be using this in a DLL to instantiate code)
        //BOOST_STATIC_WARNING(! boost::serialization::is_abstract< T >::value);
        export_guid(boost::serialization::is_abstract< T >());
@@ -111,8 +111,8 @@ public:
        // find the type that corresponds to the most derived type.
        // this implementation doesn't depend on typeid() but assumes
        // that the specified type has a function of the following signature.
-        // A common implemention of such a function is to define as a virtual
-        // function. So if the is not a polymorphic type it's likely an error
+        // A common implementation of such a function is to define as a virtual
+        // function. So if the type is not a polymorphic type it's likely an error
        BOOST_STATIC_WARNING(boost::is_polymorphic< T >::value);
        const char * derived_key = t.get_key();
        BOOST_ASSERT(NULL != derived_key);
@@ -96,7 +96,7 @@ public:
        type_unregister();
    }
    // get the eti record for the true type of this record
-    // relying upon standard type info implemenation (rtti)
+    // relying upon standard type info implementation (rtti)
    const extended_type_info *
    get_derived_extended_type_info(const T & t) const {
        // note: this implementation - based on usage of typeid (rtti)
@@ -18,7 +18,7 @@

 #include <boost/config.hpp>

-// the following help macro is to guarentee that certain coded
+// the following help macro is to guarantee that certain coded
 // is not removed by over-eager linker optimiser.  In certain cases
 // we create static objects must be created but are actually never
 // referenced - creation has a side-effect such as global registration
@@ -20,8 +20,6 @@
 // helper function templates for serialization of hashed collections
 #include <boost/config.hpp>
 #include <boost/serialization/nvp.hpp>
-#include <boost/serialization/collection_size_type.hpp>
-#include <boost/serialization/item_version_type.hpp>
 #include <boost/serialization/library_version_type.hpp>

 namespace boost{
@@ -126,7 +126,7 @@ struct is_wrapper<nvp<T> > {
 };


-} // seralization
+} // serialization
 } // boost


@@ -27,7 +27,7 @@
 // public interface to serialization.

 /////////////////////////////////////////////////////////////////////////////
-// layer 0 - intrusive verison
+// layer 0 - intrusive version
 // declared and implemented for each user defined class to be serialized
 //
 //  template<Archive>
@@ -7,7 +7,7 @@
 #endif

 /////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// shared_ptr_helper.hpp: serialization for boost shared pointern
+// shared_ptr_helper.hpp: serialization for boost shared pointer

 // (C) Copyright 2004-2009 Robert Ramey, Martin Ecker and Takatoshi Kondo
 // Use, modification and distribution is subject to the Boost Software
@@ -57,7 +57,7 @@ class shared_ptr_helper {
        SPT<const void> // address shared ptr to single instance
    > object_shared_pointer_map;

-    // list of shared_pointers create accessable by raw pointer. This
+    // list of shared_pointers create accessible by raw pointer. This
    // is used to "match up" shared pointers loaded at different
    // points in the archive. Note, we delay construction until
    // it is actually used since this is by default included as
@@ -85,7 +85,7 @@ public:
    // list of loaded pointers.  This is used to be sure that the pointers
    // stay around long enough to be "matched" with other pointers loaded
    // by the same archive.  These are created with a "null_deleter" so that
-    // when this list is destroyed - the underlaying raw pointers are not
+    // when this list is destroyed - the underlying raw pointers are not
    // destroyed.  This has to be done because the pointers are also held by
    // new system which is disjoint from this set.  This is implemented
    // by a change in load_construct_data below.  It makes this file suitable
@@ -132,7 +132,7 @@ public:
                    ::get_const_instance();

        // get pointer to the most derived object's eti.  This is effectively
-        // the object type identifer
+        // the object type identifier
        typedef typename mpl::if_<
            is_polymorphic< T >,
            polymorphic,
@@ -142,7 +142,7 @@ public:
        const boost::serialization::extended_type_info * true_type
            = type::get_object_type(*t);

-        // note:if this exception is thrown, be sure that derived pointern
+        // note:if this exception is thrown, be sure that derived pointer
        // is either registered or exported.
        if(NULL == true_type)
            boost::serialization::throw_exception(
@@ -26,7 +26,7 @@
 // a) Initialize dynamically when used.
 // b) Require that all singletons be initialized before main
 // is called or any entry point into the shared library is invoked.
-// This guarentees no race condition for initialization.
+// This guarantees no race condition for initialization.
 // In debug mode, we assert that no non-const functions are called
 // after main is invoked.
 //
@@ -87,7 +87,7 @@ namespace serialization {
 // 1 (Recommended): Publicly inherit your type T from singleton<T>,
 // make its ctor protected and access it via T::get_const_instance()
 // 2: Simply access singleton<T> without changing T. Note that this only
-// provides a global instance accesible by singleton<T>::get_const_instance()
+// provides a global instance accessible by singleton<T>::get_const_instance()
 // or singleton<T>::get_mutable_instance() to prevent using multiple instances
 // of T make its ctor protected

@@ -130,9 +130,9 @@ namespace detail {
 // for singleton<T> as a class derived from singleton<T> could be
 // instantiated multiple times.
 // It also provides a flag `is_destroyed` which returns true, when the
-// class was destructed. It is static and hence accesible even after
+// class was destructed. It is static and hence accessible even after
 // destruction. This can be used to check, if the singleton is still
-// accesible e.g. in destructors of other singletons.
+// accessible e.g. in destructors of other singletons.
 template<class T>
 class singleton_wrapper : public T
 {
@@ -175,9 +175,9 @@ private:
        // construct the instance at pre-execution time.  This would prevent
        // our usage/implementation of "locking" and introduce uncertainty into
        // the sequence of object initialization.
-        // Unfortunately, this triggers detectors of undefine behavior
-        // and reports an error.  But I've been unable to find a different
-        // of guarenteeing that the the singleton is created at pre-main time.
+        // Unfortunately, this triggers detectors of undefined behavior
+        // and reports an error.  But I've been unable to find a different way
+        // of guaranteeing that the the singleton is created at pre-main time.
        if (m_instance) use(* m_instance);

        return static_cast<T &>(t);
@@ -72,7 +72,7 @@ inline void split_member(
 } // namespace serialization
 } // namespace boost

-// split member function serialize funcition into save/load
+// split member function serialize function into save/load
 #define BOOST_SERIALIZATION_SPLIT_MEMBER()                       \
 template<class Archive>                                          \
 void serialize(                                                  \
@@ -48,8 +48,8 @@
 //    unreferenced variable of this type generates a warning iff B is false.
 // 3. static_warning_impl<B>::type overloads operator& to return a dynamically
 //    allocated int pointer only is B is true, so  returning the address of an
-//    automatic variable of this type generates a warning iff B is fasle.
-// 4. static_warning_impl<B>::STATIC_WARNING is decalred as a struct iff B is
+//    automatic variable of this type generates a warning iff B is false.
+// 4. static_warning_impl<B>::STATIC_WARNING is declared as a struct iff B is
 //    false.
 // 5. static_warning_impl<B>::type is incomplete iff B is false, so deleting a
 //    pointer to this type generates a warning iff B is false.
@@ -18,7 +18,7 @@
 //  See http://www.boost.org/libs/serialization for updates, documentation, and revision history.

 // macro used to implement a strong typedef.  strong typedef
-// guarentees that two types are distinguised even though the
+// guarantees that two types are distinguished even though they
 // share the same underlying implementation.  typedef does not create
 // a new type.  BOOST_STRONG_TYPEDEF(T, D) creates a new type named D
 // that operates as a type T.
@@ -18,7 +18,7 @@
 #include <boost/config.hpp>

 #ifndef BOOST_NO_EXCEPTIONS
-#include <exception>
+#include <boost/throw_exception.hpp>
 #endif

 namespace boost {
@@ -32,7 +32,8 @@ BOOST_NORETURN inline void throw_exception(std::exception const & e) {

 #else

-template<class E> BOOST_NORETURN inline void throw_exception(E const & e){
+template<class E>
+BOOST_NORETURN inline void throw_exception(E const & e){
    throw e;
 }

@@ -107,7 +107,7 @@ struct tracking_level< T >                   \
    /* tracking for a class  */              \
    BOOST_STATIC_ASSERT((                    \
        mpl::greater<                        \
-            /* that is a prmitive */         \
+            /* that is a primitive */        \
            implementation_level< T >,       \
            mpl::int_<primitive_type>        \
        >::value                             \
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
jzmaddock	3a58de12d5	Simplify no wstreambuf support. See https://github.com/boostorg/serialization/pull/224.	2023-04-29 13:38:11 +01:00
Robert Ramey	3f322d4adc	fix address sanitizer exception when loading corrupted XML archive. GitHub issue #257	2022-09-16 16:15:50 -07:00
Robert Ramey	df2e6703c3	iserializer should throw when file_version > version() #258	2022-09-15 15:34:25 -07:00
Robert Ramey	670648f276	Merge pull request #256 from BrianWeed/develop Use rehash(count) instead of rehash(bucket_count), to avoid excessive pre-allocation.	2022-09-15 14:08:31 -07:00
Robert Ramey	88d270543b	Merge pull request #241 from alxrmorozov/mb_from_wchar-copy-ctor Fix mb_from_wchar copy constructor	2022-09-15 13:43:28 -07:00
Robert Ramey	2012f8c184	Merge pull request #245 from jngrad/spellchecker Documentation maintenance	2022-09-15 13:41:36 -07:00
Antony Polukhin	8cdb837bb9	Fix misleading indentation warning (#262 )	2022-09-11 12:46:46 -07:00
Antony Polukhin	b87d54da86	Modernize throw specifications (#263 )	2022-09-11 12:35:48 -07:00
Robert Ramey	473e02755f	updateing git ignore	2022-09-10 14:20:20 -07:00
Robert Ramey	3f46a64ff4	change to CI files to eliminate non working platforms	2022-09-09 10:37:41 -07:00
BrianWeed	532a1c5e26	Update unordered_collections_load_imp.hpp	2022-05-04 15:02:04 -04:00
Robert Ramey	a8bbb11cd2	updated version of ubuntu from 16 to 18 made sure ubuntu versions are installed	2022-03-07 12:22:06 -08:00
Robert Ramey	b7ae64e95c	backout previous change	2022-03-02 10:06:48 -08:00
Robert Ramey	08b257f927	iadjust exception handling :w :q :wq	2022-02-25 12:10:05 -08:00
jzmaddock	b4412f2867	Missing #include in throw_exception.hpp boost/serialization/throw_exception.hpp does not include the header which defines boost::throw_exception leading to compiler errors unless that header just happens to be #included elsewhere. See this message thread: https://lists.boost.org/boost-users/2022/01/91144.php Likewise the std lib header <exception> is not required since we use nothing from that here.	2022-01-12 16:31:16 +00:00
Jean-Noël Grad	358b3e0894	Fix HTML escape codes	2021-12-31 18:17:22 +01:00
Jean-Noël Grad	3fa5669d72	Spellcheck documentation and code comments	2021-12-31 18:16:03 +01:00
Jean-Noël Grad	bef84802a2	Spellcheck help messages	2021-12-28 15:05:06 +01:00
Alexander Morozov	d1390bb7b6	Fix mb_from_wchar copy constructor	2021-09-14 02:28:20 +03:00
Robert Ramey	e4852c641c	remove extraneous b2.log file	2021-08-06 21:51:14 -07:00
Robert Ramey	0fd717cc88	Merge branch 'develop' of https://github.com/boostorg/serialization into develop * 'develop' of https://github.com/boostorg/serialization: Do not define BOOST_SERIALIZATION_SOURCE in CMakeLists.txt remove extraneous b2.log file	2021-08-06 21:50:16 -07:00
Robert Ramey	52fa997bb8	Merge commit '0ca603daf99888bf059c01ae1bab1b27dbc35ebe' into develop * commit '0ca603daf99888bf059c01ae1bab1b27dbc35ebe': Do not define BOOST_SERIALIZATION_SOURCE in CMakeLists.txt Only install under CMake 3.13 or later, otherwise dependencies have no install support Fix boost_install call to install both targets Add CMakeLists.txt # Conflicts: # CMakeLists.txt	2021-08-06 15:41:17 -07:00
Robert Ramey	45b0789b1a	Merge branch 'master' into develop * master: squash merge all changes in develop into master squash merge into next boost release merge into next boost release changes made in the hope of eliminated “stable” error for functions previously defined in the header. Moved those function to codecvt_null.cpp Squash-merge develop # Conflicts: # test/testfile2	2021-06-28 10:08:24 -07:00
Peter Dimov	09e40888f5	Do not define BOOST_SERIALIZATION_SOURCE in CMakeLists.txt	2021-06-09 18:57:02 +03:00
Robert Ramey	78ee5d14a9	Remove accidently loaded temporary files.	2021-06-01 11:52:21 -07:00
Robert Ramey	337b3fbc7c	Merge branch 'develop' of https://github.com/boostorg/serialization into develop * 'develop' of https://github.com/boostorg/serialization: Only install under CMake 3.13 or later, otherwise dependencies have no install support Fix boost_install call to install both targets Add CMakeLists.txt	2021-03-28 23:45:23 -07:00
Robert Ramey	f540ab6c78	Merge commit 'fa6b395b54bf851768a4d91bd73b8ede57deebca' into develop * commit 'fa6b395b54bf851768a4d91bd73b8ede57deebca': still making corrections to floating point tests still making corrections to floating point tests still making corrections to floating point tests still making corrections to floating point tests correct test correction for floating point numbers in the previous update, a couple of #pragmas were not properly suppressed for specific compilers. This fixes this so number of warnings under gcc is now a reasonable number. some tests use math/special functions to compare floating point numbers used generated by test results. math/special functions recently changed so now it requires C++11 or above. That is, usage under C++03 and less is deprecated. In order to continue to support the serialization library in C++03 and later I had to make some changes. After looking at the alternatives, I decide just to suppress some tests related to floating point numbers. Overall, even though it skips over some tests for C++03 platforms, it was the easiest to implement. C++03 is not widely used these days so it wasn’t worth the effort to replace reliance on math/special functions. added flush to a couple of tests which use stringstream Guard MSVC pragmas from clang-cl #230 - once more with feeling. Guard MSVC pragmas from clang-cl #230 # Conflicts: # include/boost/archive/detail/check.hpp # include/boost/archive/detail/iserializer.hpp # include/boost/archive/detail/oserializer.hpp	2021-03-28 23:45:11 -07:00
Robert Ramey	ef69de1981	Merge commit '6bf961f31e7e13c18548b553070e132347d2b58b' into develop * commit '6bf961f31e7e13c18548b553070e132347d2b58b': Guard MSVC pragmas from clang-cl # Conflicts: # include/boost/archive/detail/check.hpp # include/boost/archive/detail/iserializer.hpp # include/boost/archive/detail/oserializer.hpp	2021-03-28 23:36:03 -07:00
Peter Dimov	6ddac39d4b	Only install under CMake 3.13 or later, otherwise dependencies have no install support	2021-03-19 20:15:21 +02:00
Peter Dimov	a34e423069	Fix boost_install call to install both targets	2021-03-18 23:26:04 +02:00
Peter Dimov	9f1fc77d46	Add CMakeLists.txt	2021-03-18 18:41:25 +02:00
Robert Ramey	fa6b395b54	still making corrections to floating point tests	2021-03-11 18:36:48 -08:00
Robert Ramey	63cf849d7f	still making corrections to floating point tests	2021-03-11 15:20:21 -08:00
Robert Ramey	520cf46d31	still making corrections to floating point tests	2021-03-11 11:52:22 -08:00
Robert Ramey	1839f7b37e	still making corrections to floating point tests	2021-03-10 15:35:22 -08:00
Robert Ramey	47119842b7	correct test correction for floating point numbers	2021-03-10 13:43:01 -08:00
Robert Ramey	35ccd63f56	in the previous update, a couple of #pragmas were not properly suppressed for specific compilers. This fixes this so number of warnings under gcc is now a reasonable number.	2021-03-10 11:43:03 -08:00
Robert Ramey	781dd9f0f2	some tests use math/special functions to compare floating point numbers used generated by test results. math/special functions recently changed so now it requires C++11 or above. That is, usage under C++03 and less is deprecated. In order to continue to support the serialization library in C++03 and later I had to make some changes. After looking at the alternatives, I decide just to suppress some tests related to floating point numbers. Overall, even though it skips over some tests for C++03 platforms, it was the easiest to implement. C++03 is not widely used these days so it wasn’t worth the effort to replace reliance on math/special functions.	2021-03-10 11:41:15 -08:00
Robert Ramey	7c2229df8c	added flush to a couple of tests which use stringstream	2021-03-09 10:32:16 -08:00
Robert Ramey	cd7f64e0d7	Guard MSVC pragmas from clang-cl #230 - once more with feeling.	2021-03-02 08:40:01 -08:00
Robert Ramey	4b851994d6	Guard MSVC pragmas from clang-cl #230	2021-03-01 16:10:04 -08:00
Sam Darwin	9b9e21625f	add drone config [ci skip] (#225 )	2021-01-22 11:42:54 -08:00
Edward Diener	aba637361a	[skip ci] Add "cxxstd" json field. The "cxxstd" json field is being added to each Boost library's meta json information for libraries in order to specify the minumum C++ standard compilation level. The value of this field matches one of the values for 'cxxstd' in Boost.Build. The purpose of doing this is to provide information for the Boost website documentation for each library which will specify the minimum C++ standard compilation that an end-user must employ in order to use the particular library. This will aid end-users who want to know if they can successfully use a Boost library based on their C++ compiler's compilation level, without having to search the library's documentation to find this out. (#227 )	2021-01-21 10:45:10 -08:00
Marian Klymov	b7e454f52f	Add missing #pragma warning (pop) (#218 )	2021-01-20 10:42:03 -08:00
Giovanni Mascellani	e4727d0c23	Fix typo in copyright headers. (#223 )	2021-01-20 10:41:17 -08:00
NamaNamazu	886080ef55	Fix typo in include guard. (#226 )	2021-01-20 10:39:41 -08:00
nevilad	11ab51f97c	Correct build errors when building serialization with (#224 ) BOOST_NO_STD_LOCALE defined Signed-off-by: Alexey Romko <nevilad@yahoo.com>	2021-01-19 13:13:50 -08:00
Robert Ramey	e7e5978a54	corrected over zealous trimming of hash_map include files bumped archive version # just in case I broke something cleaned up test set hashed and test map hashed.	2021-01-01 14:00:37 -08:00
Robert Ramey	c5d199837b	minor adjustments to config files in the hopes of passing all git hub actions tests.	2020-12-23 11:27:58 -08:00
Robert Ramey	ddf65a2666	made adjustments to hash set and map testing with the aim of correctly handling elimination of BOOST_HASH …	2020-12-21 19:00:33 -08:00
Robert Ramey	6296d56682	Add support for continuous integration testing via git hub actions.	2020-12-16 09:43:48 -08:00
Robert Ramey	447445837f	remove erroneous added files	2020-11-20 12:08:36 -08:00
Robert Ramey	8899617fba	mixup some pragmas to suppress warnings	2020-11-08 15:16:35 -08:00
Robert Ramey	07c99b8649	removed unused file collection_size_type copy.hpp I have no idea where this came from!	2020-09-30 21:52:04 -07:00
Robert Ramey	6dc1b1be94	Removed obsolete comment describing the workaround for compilers which fail to properly support Partial Template Function Ordering	2020-09-27 10:52:59 -07:00
Robert Ramey	f72b9fc8d9	included library_version.hpp in all appropriate places. This should permit any header to be compiled without including any other headers.	2020-09-26 22:55:18 -07:00
Robert Ramey	1eb86f8c41	loose end from effort to separate serialization from archive.	2020-09-08 11:00:55 -07:00
Vassil Vassilev	e94aebed7a	Add missing include (#211 ) This patch allows the header to be built standalone, as part of clang C++ modules builds.	2020-07-17 12:02:44 -07:00
Vassil Vassilev	bd2b756986	Add missing include (#212 ) This patch allows the header to be built standalone, as part of clang C++ modules builds.	2020-07-17 12:02:18 -07:00
Robert Ramey	8acf32935b	clean up by removing unused headers add version.hpp which might be needed	2020-07-15 15:58:11 -07:00
Robert Ramey	812ef99dea	changes made in the hope of eliminated “stable” error for functions previously defined in the header. Moved those function to codecvt_null.cpp	2020-07-10 11:24:31 -07:00
Robert Ramey	cfed656eb0	removed some in appropriate files made adjustments regarding visibility macros in the hope of pacifying MSVC compilers	2020-06-29 13:40:09 -07:00
Robert Ramey	4dd4895246	remove erroneous added library status html file	2020-06-26 19:07:01 -07:00
Robert Ramey	676722671e	create alias in namespace boost::archive to support older user code. new location is in boost::serialization.	2020-06-26 17:30:44 -07:00
Robert Ramey	b672e87f9d	use boost/uint_least16 rather than the standard one. A previous “fix” fixed this, so now I’m fixing it back. Coincidently, looks like the serialization library is backward compatible to C++98	2020-06-26 14:20:06 -07:00
Robert Ramey	4fb556f9c4	merged in refactoring designed to diminish dependencies	2020-06-25 09:18:38 -07:00
Hans Dembinski	f4c6d58bb5	fix compile error (#208 )	2020-06-24 10:32:33 -07:00
Robert Ramey	6af3783a2c	remove unused headers	2020-06-19 15:53:59 -07:00
Robert Ramey	c7761f2335	improvements in serialization library a) fixed up CMake Build so it does everything the B2 Build does. They give the same results. b) made adjustments so that any code which depends upon serialization depends only upon files in the serialization folder/namespace. This should permit one to add serialization to his library without ending up importing the whole damn world.	2020-06-19 00:04:31 -07:00
Andrey Semashev	4dc4ba018c	Update no_exceptions_support.hpp header location to avoid deprecated warnings. (#204 ) boost/detail/no_exceptions_support.hpp is deprecated and will be removed in a future release.	2020-06-08 16:47:29 -07:00