Add a regression test for cross-library base pointer deserialization

A derived class defined in a shared library is round-tripped through a
`unique_ptr` to its abstract base, across the library boundary, using a
binary-backed polymorphic archive, from an executable built with hidden
symbol visibility. The test reuses the existing `dll_polymorphic_base`
and `dll_polymorphic_derived2` libraries.

On GCC/ELF the per-type serializer singletons were duplicated across the
boundary, so the reader could not map the class id back to the derived
type and recovered the wrong object.

Refs issue #117.

.drone.star

@@ -0,0 +1,28 @@
+# Use, modification, and distribution are
+# subject to the Boost Software License, Version 1.0. (See accompanying
+# file LICENSE.txt)
+#
+# Copyright Rene Rivera 2020.
+
+# For Drone CI we use the Starlark scripting language to reduce duplication.
+# As the yaml syntax for Drone CI is rather limited.
+#
+#
+globalenv={}
+linuxglobalimage="cppalliance/droneubuntu1604:1"
+windowsglobalimage="cppalliance/dronevs2019"
+
+def main(ctx):
+  return [
+  linux_cxx("TOOLSET=gcc LINK=static,shared Job 0", "g++", packages="", buildtype="boost", buildscript="drone", image=linuxglobalimage, environment={'TOOLSET': 'gcc', 'LINK': 'static,shared', 'TRAVIS_COMPILER': 'g++', 'DRONE_JOB_UUID': 'b6589fc6ab'}, globalenv=globalenv),
+  linux_cxx("TOOLSET=gcc LINK=static,shared Job 1", "g++", packages="g++-5", buildtype="boost", buildscript="drone", image=linuxglobalimage, environment={'TOOLSET': 'gcc', 'LINK': 'static,shared', 'TRAVIS_COMPILER': 'g++-5', 'DRONE_JOB_UUID': '356a192b79'}, globalenv=globalenv),
+  linux_cxx("TOOLSET=gcc LINK=static,shared Job 2", "g++", packages="g++-6", buildtype="boost", buildscript="drone", image=linuxglobalimage, environment={'TOOLSET': 'gcc', 'LINK': 'static,shared', 'TRAVIS_COMPILER': 'g++-6', 'DRONE_JOB_UUID': 'da4b9237ba'}, globalenv=globalenv),
+  linux_cxx("TOOLSET=gcc LINK=static,shared Job 3", "g++", packages="g++-7", buildtype="boost", buildscript="drone", image=linuxglobalimage, environment={'TOOLSET': 'gcc', 'LINK': 'static,shared', 'TRAVIS_COMPILER': 'g++-7', 'DRONE_JOB_UUID': '77de68daec'}, globalenv=globalenv),
+  linux_cxx("TOOLSET=clang LINK=static,shared Job 4", "clang++", packages="", buildtype="boost", buildscript="drone", image=linuxglobalimage, environment={'TOOLSET': 'clang', 'LINK': 'static,shared', 'TRAVIS_COMPILER': 'clang++', 'DRONE_JOB_UUID': '1b64538924'}, globalenv=globalenv),
+  linux_cxx("TOOLSET=clang LINK=static,shared Job 5", "clang++", packages="libc++-dev", buildtype="boost", buildscript="drone", image=linuxglobalimage, environment={'TOOLSET': 'clang', 'LINK': 'static,shared', 'TRAVIS_COMPILER': 'clang++-libc++', 'DRONE_JOB_UUID': 'ac3478d69a'}, globalenv=globalenv),
+  osx_cxx("TOOLSET=clang LINK=static,shared Job 6", "clang++", packages="", buildtype="boost", buildscript="drone", environment={'TOOLSET': 'clang', 'LINK': 'static,shared', 'TRAVIS_COMPILER': 'clang++', 'DRONE_JOB_UUID': 'c1dfd96eea'}, globalenv=globalenv),
+  osx_cxx("TOOLSET=clang LINK=static,shared Job 7", "clang++", packages="", buildtype="boost", buildscript="drone", xcode_version="10", environment={'TOOLSET': 'clang', 'LINK': 'static,shared', 'TRAVIS_COMPILER': 'clang++', 'DRONE_JOB_UUID': '902ba3cda1'}, globalenv=globalenv),
+    ]
+
+# from https://github.com/boostorg/boost-ci
+load("@boost_ci//ci/drone/:functions.star", "linux_cxx","windows_cxx","osx_cxx","freebsd_cxx")

.drone/drone.sh

@@ -0,0 +1,37 @@
+#!/bin/bash
+
+# Copyright 2020 Rene Rivera, Sam Darwin
+# Distributed under the Boost Software License, Version 1.0.
+# (See accompanying file LICENSE.txt or copy at http://boost.org/LICENSE_1_0.txt)
+
+set -e
+export TRAVIS_BUILD_DIR=$(pwd)
+export DRONE_BUILD_DIR=$(pwd)
+export TRAVIS_BRANCH=$DRONE_BRANCH
+export VCS_COMMIT_ID=$DRONE_COMMIT
+export GIT_COMMIT=$DRONE_COMMIT
+export REPO_NAME=$DRONE_REPO
+export PATH=~/.local/bin:/usr/local/bin:$PATH
+
+if [ "$DRONE_JOB_BUILDTYPE" == "boost" ]; then
+
+echo '==================================> INSTALL'
+
+BOOST_BRANCH=develop && [ "$TRAVIS_BRANCH" == "master" ] && BOOST_BRANCH=master || true
+cd ..
+git clone -b $BOOST_BRANCH https://github.com/boostorg/boost.git boost-root
+cd boost-root
+git submodule update --init tools/build
+git submodule update --init libs/config
+git submodule update --init tools/boostdep
+cp -r $TRAVIS_BUILD_DIR/* libs/serialization
+python tools/boostdep/depinst/depinst.py serialization
+./bootstrap.sh
+./b2 headers
+
+echo '==================================> SCRIPT'
+
+echo "using $TOOLSET : : $TRAVIS_COMPILER ;" > ~/user-config.jam
+./b2 -j 3 libs/serialization/test toolset=$TOOLSET link=${LINK:-shared}
+
+fi

.github/workflows/ci.yml

@@ -0,0 +1,651 @@
+name: CI
+
+on:
+  pull_request:
+  push:
+    branches:
+      - master
+      - develop
+      - feature/**
+  merge_group:
+
+env:
+  UBSAN_OPTIONS: print_stacktrace=1
+
+jobs:
+  posix:
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - toolset: gcc-7
+            cxxstd: "11,14,17"
+            container: ubuntu:20.04
+            os: ubuntu-latest
+            install: g++-7-multilib
+            address-model: 32,64
+          - toolset: gcc-8
+            cxxstd: "11,14,17,2a"
+            container: ubuntu:20.04
+            os: ubuntu-latest
+            install: g++-8-multilib
+            address-model: 32,64
+          - toolset: gcc-9
+            cxxstd: "11,14,17,2a"
+            container: ubuntu:20.04
+            os: ubuntu-latest
+            install: g++-9-multilib
+            address-model: 32,64
+          - toolset: gcc-10
+            cxxstd: "11,14,17,2a"
+            container: ubuntu:22.04
+            os: ubuntu-latest
+            install: g++-10-multilib
+            address-model: 32,64
+          - toolset: gcc-11
+            cxxstd: "11,14,17,20"
+            container: ubuntu:22.04
+            os: ubuntu-latest
+            install: g++-11-multilib
+            address-model: 32,64
+          - toolset: gcc-12
+            cxxstd: "11,14,17,20,2b"
+            container: ubuntu:22.04
+            os: ubuntu-latest
+            install: g++-12-multilib
+            address-model: 32,64
+          - toolset: gcc-13
+            cxxstd: "11,14,17,20,2b"
+            container: ubuntu:24.04
+            os: ubuntu-latest
+            install: g++-13-multilib
+            address-model: 32,64
+          - toolset: gcc-14
+            cxxstd: "11,14,17,20,2b"
+            container: ubuntu:24.04
+            os: ubuntu-latest
+            install: g++-14-multilib
+            address-model: 32,64
+          - toolset: gcc-15
+            cxxstd: "11,14,17,20,23,2c"
+            container: ubuntu:26.04
+            os: ubuntu-latest
+            install: g++-15-multilib
+            address-model: 32,64
+          - toolset: gcc-16
+            cxxstd: "11,14,17,20,23,2c"
+            container: ubuntu:26.04
+            os: ubuntu-latest
+            install: g++-16-multilib
+            address-model: 32,64
+          - toolset: clang
+            compiler: clang++-6.0
+            cxxstd: "11,14,17"
+            container: ubuntu:20.04
+            os: ubuntu-latest
+            install: clang-6.0
+          - toolset: clang
+            compiler: clang++-7
+            cxxstd: "11,14,17"
+            container: ubuntu:20.04
+            os: ubuntu-latest
+            install: clang-7
+          - toolset: clang
+            compiler: clang++-8
+            cxxstd: "11,14,17"
+            container: ubuntu:20.04
+            os: ubuntu-latest
+            install: clang-8
+          - toolset: clang
+            compiler: clang++-9
+            cxxstd: "11,14,17,2a"
+            container: ubuntu:20.04
+            os: ubuntu-latest
+            install: clang-9
+          - toolset: clang
+            compiler: clang++-10
+            cxxstd: "11,14,17,2a"
+            container: ubuntu:20.04
+            os: ubuntu-latest
+            install: clang-10
+          - toolset: clang
+            compiler: clang++-11
+            cxxstd: "11,14,17,2a"
+            container: ubuntu:20.04
+            os: ubuntu-latest
+            install: clang-11
+          - toolset: clang
+            compiler: clang++-12
+            cxxstd: "11,14,17,20"
+            container: ubuntu:20.04
+            os: ubuntu-latest
+            install: clang-12
+          - toolset: clang
+            compiler: clang++-13
+            cxxstd: "11,14,17,20,2b"
+            container: ubuntu:22.04
+            os: ubuntu-latest
+            install: clang-13
+          - toolset: clang
+            compiler: clang++-14
+            cxxstd: "11,14,17,20,2b"
+            container: ubuntu:22.04
+            os: ubuntu-latest
+            install: clang-14
+          - toolset: clang
+            compiler: clang++-15
+            cxxstd: "11,14,17,20,2b"
+            container: ubuntu:22.04
+            os: ubuntu-latest
+            install: clang-15
+          - toolset: clang
+            compiler: clang++-16
+            cxxstd: "11,14,17,20,2b"
+            container: ubuntu:24.04
+            os: ubuntu-latest
+            install: clang-16
+          - toolset: clang
+            compiler: clang++-17
+            cxxstd: "11,14,17,20,2b"
+            container: ubuntu:24.04
+            os: ubuntu-latest
+            install: clang-17
+          - toolset: clang
+            compiler: clang++-18
+            cxxstd: "11,14,17,20,2b"
+            container: ubuntu:24.04
+            os: ubuntu-latest
+            install: clang-18
+          - toolset: clang
+            compiler: clang++-19
+            cxxstd: "11,14,17,20,2b"
+            container: ubuntu:24.04
+            os: ubuntu-latest
+            install: clang-19
+          - toolset: clang
+            compiler: clang++-20
+            cxxstd: "11,14,17,20,23,2c"
+            container: ubuntu:24.04
+            os: ubuntu-latest
+            install: clang-20
+          - toolset: clang
+            compiler: clang++-21
+            cxxstd: "11,14,17,20,23,2c"
+            container: ubuntu:26.04
+            os: ubuntu-latest
+            install: clang-21
+          - toolset: clang
+            compiler: clang++-22
+            cxxstd: "11,14,17,20,23,2c"
+            container: ubuntu:26.04
+            os: ubuntu-latest
+            install: clang-22
+          - toolset: clang
+            cxxstd: "11,14,17,20,2b"
+            os: macos-14
+          - toolset: clang
+            cxxstd: "11,14,17,20,23,2c"
+            os: macos-15
+          - toolset: clang
+            cxxstd: "11,14,17,20,23,2c"
+            os: macos-26
+
+    runs-on: ${{matrix.os}}
+    container: ${{matrix.container}}
+
+    defaults:
+      run:
+        shell: bash
+
+    steps:
+      - name: Setup container environment
+        if: matrix.container
+        run: |
+          apt-get update
+          apt-get -y install sudo python3 git g++ curl
+
+      - uses: actions/checkout@v6
+
+      - name: Install packages
+        if: matrix.install
+        run: |
+          sudo apt-get update
+          sudo apt-get -y install ${{matrix.install}}
+
+      - name: Setup Boost
+        run: |
+          echo GITHUB_REPOSITORY: $GITHUB_REPOSITORY
+          LIBRARY=${GITHUB_REPOSITORY#*/}
+          echo LIBRARY: $LIBRARY
+          echo "LIBRARY=$LIBRARY" >> $GITHUB_ENV
+          echo GITHUB_BASE_REF: $GITHUB_BASE_REF
+          echo GITHUB_REF: $GITHUB_REF
+          REF=${GITHUB_BASE_REF:-$GITHUB_REF}
+          REF=${REF#refs/heads/}
+          echo REF: $REF
+          BOOST_BRANCH=develop && [ "$REF" == "master" ] && BOOST_BRANCH=master || true
+          echo BOOST_BRANCH: $BOOST_BRANCH
+          cd ..
+          git clone -b $BOOST_BRANCH --depth 1 https://github.com/boostorg/boost.git boost-root
+          cd boost-root
+          mkdir -p libs/$LIBRARY
+          cp -r $GITHUB_WORKSPACE/* libs/$LIBRARY
+          git submodule update --init tools/boostdep
+          python3 tools/boostdep/depinst/depinst.py -I benchmark --git_args "--jobs 3" $LIBRARY
+          ./bootstrap.sh
+          ./b2 -d0 headers
+
+      - name: Create user-config.jam
+        if: matrix.compiler
+        run: |
+          echo "using ${{matrix.toolset}} : : ${{matrix.compiler}} ;" > ~/user-config.jam
+
+      - name: Run tests
+        run: |
+          cd ../boost-root
+          export ADDRMD=${{matrix.address-model}}
+          ./b2 -j3 libs/$LIBRARY/test toolset=${{matrix.toolset}} cxxstd=${{matrix.cxxstd}} ${ADDRMD:+address-model=$ADDRMD} variant=debug,release
+
+      - name: Run examples
+        run: |
+          cd ../boost-root
+          export ADDRMD=${{matrix.address-model}}
+          # The demos use fixed temp filenames, so run them serially (-j1)
+          # to avoid concurrent runs clobbering each other's archive files.
+          ./b2 -j1 libs/$LIBRARY/example toolset=${{matrix.toolset}} cxxstd=${{matrix.cxxstd}} ${ADDRMD:+address-model=$ADDRMD} variant=debug,release
+
+  windows:
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - toolset: msvc-14.3
+            cxxstd: "14,17,20,latest"
+            addrmd: 32,64
+            os: windows-2022
+          - toolset: msvc-14.5
+            cxxstd: "14,17,20,latest"
+            addrmd: 32,64
+            os: windows-2025-vs2026
+          - toolset: clang-win
+            cxxstd: "14,17,20,latest"
+            addrmd: 32,64
+            os: windows-2025
+          - toolset: gcc
+            cxxstd: "11,14,17,2a"
+            addrmd: 64
+            os: windows-2025
+
+    runs-on: ${{matrix.os}}
+
+    steps:
+      - uses: actions/checkout@v6
+
+      - name: Setup Boost
+        shell: cmd
+        run: |
+          echo GITHUB_REPOSITORY: %GITHUB_REPOSITORY%
+          for /f %%i in ("%GITHUB_REPOSITORY%") do set LIBRARY=%%~nxi
+          echo LIBRARY: %LIBRARY%
+          echo LIBRARY=%LIBRARY%>>%GITHUB_ENV%
+          echo GITHUB_BASE_REF: %GITHUB_BASE_REF%
+          echo GITHUB_REF: %GITHUB_REF%
+          if "%GITHUB_BASE_REF%" == "" set GITHUB_BASE_REF=%GITHUB_REF%
+          set BOOST_BRANCH=develop
+          for /f %%i in ("%GITHUB_BASE_REF%") do if "%%~nxi" == "master" set BOOST_BRANCH=master
+          echo BOOST_BRANCH: %BOOST_BRANCH%
+          cd ..
+          git clone -b %BOOST_BRANCH% --depth 1 https://github.com/boostorg/boost.git boost-root
+          cd boost-root
+          xcopy /s /e /q %GITHUB_WORKSPACE% libs\%LIBRARY%\
+          git submodule update --init tools/boostdep
+          python tools/boostdep/depinst/depinst.py -I benchmark --git_args "--jobs 3" %LIBRARY%
+          cmd /c bootstrap
+          b2 -d0 headers
+
+      - name: Run tests
+        shell: cmd
+        run: |
+          cd ../boost-root
+          b2 -j3 libs/%LIBRARY%/test toolset=${{matrix.toolset}} cxxstd=${{matrix.cxxstd}} address-model=${{matrix.addrmd}} variant=debug,release embed-manifest-via=linker
+
+      - name: Run examples
+        shell: cmd
+        run: |
+          cd ../boost-root
+          rem The demos use fixed temp filenames, so run them serially (-j1)
+          rem to avoid concurrent runs clobbering each other's archive files.
+          b2 -j1 libs/%LIBRARY%/example toolset=${{matrix.toolset}} cxxstd=${{matrix.cxxstd}} address-model=${{matrix.addrmd}} variant=debug,release embed-manifest-via=linker
+
+  posix-cmake-subdir:
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - os: ubuntu-latest
+          - os: macos-latest
+
+    runs-on: ${{matrix.os}}
+
+    steps:
+      - uses: actions/checkout@v6
+
+      - name: Install packages
+        if: matrix.install
+        run: sudo apt-get -y install ${{matrix.install}}
+
+      - name: Setup Boost
+        run: |
+          echo GITHUB_REPOSITORY: $GITHUB_REPOSITORY
+          LIBRARY=${GITHUB_REPOSITORY#*/}
+          echo LIBRARY: $LIBRARY
+          echo "LIBRARY=$LIBRARY" >> $GITHUB_ENV
+          echo GITHUB_BASE_REF: $GITHUB_BASE_REF
+          echo GITHUB_REF: $GITHUB_REF
+          REF=${GITHUB_BASE_REF:-$GITHUB_REF}
+          REF=${REF#refs/heads/}
+          echo REF: $REF
+          BOOST_BRANCH=develop && [ "$REF" == "master" ] && BOOST_BRANCH=master || true
+          echo BOOST_BRANCH: $BOOST_BRANCH
+          cd ..
+          git clone -b $BOOST_BRANCH --depth 1 https://github.com/boostorg/boost.git boost-root
+          cd boost-root
+          mkdir -p libs/$LIBRARY
+          cp -r $GITHUB_WORKSPACE/* libs/$LIBRARY
+          git submodule update --init tools/boostdep
+          python tools/boostdep/depinst/depinst.py --git_args "--jobs 3" $LIBRARY
+
+      - name: Use library with add_subdirectory
+        run: |
+          cd ../boost-root/libs/$LIBRARY/test/cmake_subdir_test
+          mkdir __build__ && cd __build__
+          cmake ..
+          cmake --build .
+          ctest --output-on-failure --no-tests=error
+
+  posix-cmake-install:
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - os: ubuntu-latest
+          - os: macos-latest
+
+    runs-on: ${{matrix.os}}
+
+    steps:
+      - uses: actions/checkout@v6
+
+      - name: Install packages
+        if: matrix.install
+        run: sudo apt-get -y install ${{matrix.install}}
+
+      - name: Setup Boost
+        run: |
+          echo GITHUB_REPOSITORY: $GITHUB_REPOSITORY
+          LIBRARY=${GITHUB_REPOSITORY#*/}
+          echo LIBRARY: $LIBRARY
+          echo "LIBRARY=$LIBRARY" >> $GITHUB_ENV
+          echo GITHUB_BASE_REF: $GITHUB_BASE_REF
+          echo GITHUB_REF: $GITHUB_REF
+          REF=${GITHUB_BASE_REF:-$GITHUB_REF}
+          REF=${REF#refs/heads/}
+          echo REF: $REF
+          BOOST_BRANCH=develop && [ "$REF" == "master" ] && BOOST_BRANCH=master || true
+          echo BOOST_BRANCH: $BOOST_BRANCH
+          cd ..
+          git clone -b $BOOST_BRANCH --depth 1 https://github.com/boostorg/boost.git boost-root
+          cd boost-root
+          mkdir -p libs/$LIBRARY
+          cp -r $GITHUB_WORKSPACE/* libs/$LIBRARY
+          git submodule update --init tools/boostdep
+          python tools/boostdep/depinst/depinst.py --git_args "--jobs 3" $LIBRARY
+
+      - name: Configure
+        run: |
+          cd ../boost-root
+          mkdir __build__ && cd __build__
+          cmake -DBOOST_INCLUDE_LIBRARIES=$LIBRARY -DCMAKE_INSTALL_PREFIX=~/.local ..
+
+      - name: Install
+        run: |
+          cd ../boost-root/__build__
+          cmake --build . --target install
+
+      - name: Use the installed library
+        run: |
+          cd ../boost-root/libs/$LIBRARY/test/cmake_install_test && mkdir __build__ && cd __build__
+          cmake -DCMAKE_INSTALL_PREFIX=~/.local ..
+          cmake --build .
+          ctest --output-on-failure --no-tests=error
+
+  posix-cmake-test:
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - os: ubuntu-latest
+          - os: macos-latest
+
+    runs-on: ${{matrix.os}}
+
+    steps:
+      - uses: actions/checkout@v6
+
+      - name: Install packages
+        if: matrix.install
+        run: sudo apt-get -y install ${{matrix.install}}
+
+      - name: Setup Boost
+        run: |
+          echo GITHUB_REPOSITORY: $GITHUB_REPOSITORY
+          LIBRARY=${GITHUB_REPOSITORY#*/}
+          echo LIBRARY: $LIBRARY
+          echo "LIBRARY=$LIBRARY" >> $GITHUB_ENV
+          echo GITHUB_BASE_REF: $GITHUB_BASE_REF
+          echo GITHUB_REF: $GITHUB_REF
+          REF=${GITHUB_BASE_REF:-$GITHUB_REF}
+          REF=${REF#refs/heads/}
+          echo REF: $REF
+          BOOST_BRANCH=develop && [ "$REF" == "master" ] && BOOST_BRANCH=master || true
+          echo BOOST_BRANCH: $BOOST_BRANCH
+          cd ..
+          git clone -b $BOOST_BRANCH --depth 1 https://github.com/boostorg/boost.git boost-root
+          cd boost-root
+          mkdir -p libs/$LIBRARY
+          cp -r $GITHUB_WORKSPACE/* libs/$LIBRARY
+          git submodule update --init tools/boostdep
+          python tools/boostdep/depinst/depinst.py -I benchmark -I example --git_args "--jobs 3" $LIBRARY
+
+      - name: Configure
+        run: |
+          cd ../boost-root
+          mkdir __build__ && cd __build__
+          cmake -DBOOST_INCLUDE_LIBRARIES=$LIBRARY -DBUILD_TESTING=ON ..
+
+      - name: Build tests
+        run: |
+          cd ../boost-root/__build__
+          cmake --build . --target tests
+
+      - name: Run tests
+        run: |
+          cd ../boost-root/__build__
+          ctest --output-on-failure --no-tests=error
+
+  windows-cmake-subdir:
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - os: windows-latest
+
+    runs-on: ${{matrix.os}}
+
+    steps:
+      - uses: actions/checkout@v6
+
+      - name: Setup Boost
+        shell: cmd
+        run: |
+          echo GITHUB_REPOSITORY: %GITHUB_REPOSITORY%
+          for /f %%i in ("%GITHUB_REPOSITORY%") do set LIBRARY=%%~nxi
+          echo LIBRARY: %LIBRARY%
+          echo LIBRARY=%LIBRARY%>>%GITHUB_ENV%
+          echo GITHUB_BASE_REF: %GITHUB_BASE_REF%
+          echo GITHUB_REF: %GITHUB_REF%
+          if "%GITHUB_BASE_REF%" == "" set GITHUB_BASE_REF=%GITHUB_REF%
+          set BOOST_BRANCH=develop
+          for /f %%i in ("%GITHUB_BASE_REF%") do if "%%~nxi" == "master" set BOOST_BRANCH=master
+          echo BOOST_BRANCH: %BOOST_BRANCH%
+          cd ..
+          git clone -b %BOOST_BRANCH% --depth 1 https://github.com/boostorg/boost.git boost-root
+          cd boost-root
+          xcopy /s /e /q %GITHUB_WORKSPACE% libs\%LIBRARY%\
+          git submodule update --init tools/boostdep
+          python tools/boostdep/depinst/depinst.py --git_args "--jobs 3" %LIBRARY%
+
+      - name: Use library with add_subdirectory (Debug)
+        shell: cmd
+        run: |
+          cd ../boost-root/libs/%LIBRARY%/test/cmake_subdir_test
+          mkdir __build__ && cd __build__
+          cmake ..
+          cmake --build . --config Debug
+          ctest --output-on-failure --no-tests=error -C Debug
+
+      - name: Use library with add_subdirectory (Release)
+        shell: cmd
+        run: |
+          cd ../boost-root/libs/%LIBRARY%/test/cmake_subdir_test/__build__
+          cmake --build . --config Release
+          ctest --output-on-failure --no-tests=error -C Release
+
+  windows-cmake-install:
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - os: windows-latest
+
+    runs-on: ${{matrix.os}}
+
+    steps:
+      - uses: actions/checkout@v6
+
+      - name: Setup Boost
+        shell: cmd
+        run: |
+          echo GITHUB_REPOSITORY: %GITHUB_REPOSITORY%
+          for /f %%i in ("%GITHUB_REPOSITORY%") do set LIBRARY=%%~nxi
+          echo LIBRARY: %LIBRARY%
+          echo LIBRARY=%LIBRARY%>>%GITHUB_ENV%
+          echo GITHUB_BASE_REF: %GITHUB_BASE_REF%
+          echo GITHUB_REF: %GITHUB_REF%
+          if "%GITHUB_BASE_REF%" == "" set GITHUB_BASE_REF=%GITHUB_REF%
+          set BOOST_BRANCH=develop
+          for /f %%i in ("%GITHUB_BASE_REF%") do if "%%~nxi" == "master" set BOOST_BRANCH=master
+          echo BOOST_BRANCH: %BOOST_BRANCH%
+          cd ..
+          git clone -b %BOOST_BRANCH% --depth 1 https://github.com/boostorg/boost.git boost-root
+          cd boost-root
+          xcopy /s /e /q %GITHUB_WORKSPACE% libs\%LIBRARY%\
+          git submodule update --init tools/boostdep
+          python tools/boostdep/depinst/depinst.py --git_args "--jobs 3" %LIBRARY%
+
+      - name: Configure
+        shell: cmd
+        run: |
+          cd ../boost-root
+          mkdir __build__ && cd __build__
+          cmake -DBOOST_INCLUDE_LIBRARIES=%LIBRARY% -DCMAKE_INSTALL_PREFIX=C:/cmake-prefix ..
+
+      - name: Install (Debug)
+        shell: cmd
+        run: |
+          cd ../boost-root/__build__
+          cmake --build . --target install --config Debug
+
+      - name: Install (Release)
+        shell: cmd
+        run: |
+          cd ../boost-root/__build__
+          cmake --build . --target install --config Release
+
+      - name: Use the installed library (Debug)
+        shell: cmd
+        run: |
+          cd ../boost-root/libs/%LIBRARY%/test/cmake_install_test && mkdir __build__ && cd __build__
+          cmake -DCMAKE_INSTALL_PREFIX=C:/cmake-prefix ..
+          cmake --build . --config Debug
+          ctest --output-on-failure --no-tests=error -C Debug
+
+      - name: Use the installed library (Release)
+        shell: cmd
+        run: |
+          cd ../boost-root/libs/%LIBRARY%/test/cmake_install_test/__build__
+          cmake --build . --config Release
+          ctest --output-on-failure --no-tests=error -C Release
+
+  windows-cmake-test:
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - os: windows-latest
+
+    runs-on: ${{matrix.os}}
+
+    steps:
+      - uses: actions/checkout@v6
+
+      - name: Setup Boost
+        shell: cmd
+        run: |
+          echo GITHUB_REPOSITORY: %GITHUB_REPOSITORY%
+          for /f %%i in ("%GITHUB_REPOSITORY%") do set LIBRARY=%%~nxi
+          echo LIBRARY: %LIBRARY%
+          echo LIBRARY=%LIBRARY%>>%GITHUB_ENV%
+          echo GITHUB_BASE_REF: %GITHUB_BASE_REF%
+          echo GITHUB_REF: %GITHUB_REF%
+          if "%GITHUB_BASE_REF%" == "" set GITHUB_BASE_REF=%GITHUB_REF%
+          set BOOST_BRANCH=develop
+          for /f %%i in ("%GITHUB_BASE_REF%") do if "%%~nxi" == "master" set BOOST_BRANCH=master
+          echo BOOST_BRANCH: %BOOST_BRANCH%
+          cd ..
+          git clone -b %BOOST_BRANCH% --depth 1 https://github.com/boostorg/boost.git boost-root
+          cd boost-root
+          xcopy /s /e /q %GITHUB_WORKSPACE% libs\%LIBRARY%\
+          git submodule update --init tools/boostdep
+          python tools/boostdep/depinst/depinst.py -I benchmark -I example --git_args "--jobs 3" %LIBRARY%
+
+      - name: Configure
+        shell: cmd
+        run: |
+          cd ../boost-root
+          mkdir __build__ && cd __build__
+          cmake -DBOOST_INCLUDE_LIBRARIES=%LIBRARY% -DBUILD_TESTING=ON ..
+
+      - name: Build tests (Debug)
+        shell: cmd
+        run: |
+          cd ../boost-root/__build__
+          cmake --build . --target tests --config Debug
+
+      - name: Run tests (Debug)
+        shell: cmd
+        run: |
+          cd ../boost-root/__build__
+          ctest --output-on-failure --no-tests=error -C Debug
+
+      - name: Build tests (Release)
+        shell: cmd
+        run: |
+          cd ../boost-root/__build__
+          cmake --build . --target tests --config Release
+
+      - name: Run tests (Release)
+        shell: cmd
+        run: |
+          cd ../boost-root/__build__
+          ctest --output-on-failure --no-tests=error -C Release

.travis.yml

@@ -0,0 +1,103 @@
+# Copyright 2016, 2017 Peter Dimov
+# Distributed under the Boost Software License, Version 1.0.
+# (See accompanying file LICENSE_1_0.txt or copy at http://boost.org/LICENSE_1_0.txt)
+
+language: cpp
+
+sudo: false
+
+cache:
+  ccache: true
+
+branches:
+  only:
+    - master
+    - develop
+    - /feature\/.*/
+
+env:
+  matrix:
+    - BOGUS_JOB=true
+
+matrix:
+
+  exclude:
+    - env: BOGUS_JOB=true
+
+  include:
+    - os: linux
+      compiler: g++
+      env: TOOLSET=gcc LINK=static,shared
+
+    - os: linux
+      compiler: g++-5
+      env: TOOLSET=gcc LINK=static,shared
+      addons:
+        apt:
+          packages:
+            - g++-5
+          sources:
+            - ubuntu-toolchain-r-test
+
+    - os: linux
+      compiler: g++-6
+      env: TOOLSET=gcc LINK=static,shared
+      addons:
+        apt:
+          packages:
+            - g++-6
+          sources:
+            - ubuntu-toolchain-r-test
+
+    - os: linux
+      compiler: g++-7
+      env: TOOLSET=gcc LINK=static,shared
+      addons:
+        apt:
+          packages:
+            - g++-7
+          sources:
+            - ubuntu-toolchain-r-test
+
+    - os: linux
+      compiler: clang++
+      env: TOOLSET=clang LINK=static,shared
+
+    - os: linux
+      compiler: clang++-libc++
+      env: TOOLSET=clang LINK=static,shared
+      addons:
+        apt:
+          packages:
+            - libc++-dev
+
+    - os: osx
+      compiler: clang++
+      env: TOOLSET=clang LINK=static,shared
+
+    - os: osx
+      osx_image: xcode10
+      compiler: clang++
+      env: TOOLSET=clang LINK=static,shared
+
+install:
+  - BOOST_BRANCH=develop && [ "$TRAVIS_BRANCH" == "master" ] && BOOST_BRANCH=master || true
+  - cd ..
+  - git clone -b $BOOST_BRANCH https://github.com/boostorg/boost.git boost-root
+  - cd boost-root
+  - git submodule update --init tools/build
+  - git submodule update --init libs/config
+  - git submodule update --init tools/boostdep
+  - cp -r $TRAVIS_BUILD_DIR/* libs/serialization
+  - python tools/boostdep/depinst/depinst.py serialization
+  - ./bootstrap.sh
+  - ./b2 headers
+
+script:
+  - |-
+    echo "using $TOOLSET : : $TRAVIS_COMPILER ;" > ~/user-config.jam
+  - ./b2 -j 3 libs/serialization/test toolset=$TOOLSET link=${LINK:-shared}
+
+notifications:
+  email:
+    on_success: always

CMake/CMakeLists.txt

@@ -0,0 +1,413 @@
+# CMake build control file for Serialization Library tests
+
+cmake_minimum_required(VERSION 3.5)
+
+if (POLICY CMP0054)
+  cmake_policy (SET CMP0054 NEW)
+endif (POLICY CMP0054)
+
+if (POLICY CMP0063)
+  cmake_policy (SET CMP0063 NEW)
+endif (POLICY CMP0063)
+
+project("serialization")
+
+#
+# Compiler settings
+#
+
+message(STATUS "C++ compiler is ${CMAKE_CXX_COMPILER_ID}" )
+add_definitions(${Boost_LIB_DIAGNOSTIC_DEFINITIONS})
+message(STATUS "C compiler is ${CMAKE_C_COMPILER_ID}" )
+
+if( CMAKE_CXX_COMPILER_ID STREQUAL "GNU" )
+  add_definitions( -ftemplate-depth=255 )
+  # we use gcc to test for C++03 compatibility
+  set(COMPILER_SUPPORTS_CXX11 FALSE)
+elseif( CMAKE_CXX_COMPILER_ID STREQUAL "MSVC" )
+  add_definitions( /wd4996 )
+  set(COMPILER_SUPPORTS_CXX11 TRUE)
+elseif( CMAKE_CXX_COMPILER_ID STREQUAL "AppleClang" )
+  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -ftemplate-depth=300")
+  set(CMAKE_CXX_FLAGS_DEBUG "-g -O0" )
+  set(CMAKE_CXX_FLAGS_RELWITHDEBINFO "-g -O3" )
+  set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -stdlib=libc++ -dead_strip")
+  set(COMPILER_SUPPORTS_CXX11 TRUE)
+endif()
+
+add_definitions( -std=c++11 )
+#set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++03")
+set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++11")
+#set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++17")
+#set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++11")
+
+#
+# Locate Project Prerequisites 
+#
+
+# Boost
+
+#
+# Project settings
+#
+option(BUILD_SHARED_LIBS "Build Shared Libraries" true)
+
+find_package(Boost 1.82 REQUIRED COMPONENTS system filesystem)
+
+if(NOT Boost_FOUND)
+  message("Boost NOT Found!")
+else()
+  message(STATUS "Boost Found!")
+endif()
+set(CMAKE_CXX_VISIBILITY_PRESET hidden)
+set(VISIBILITY_INLINES_HIDDEN YES)
+
+# enable usage of CHECK_INCLUDE_FILE_CXX
+include(CheckIncludeFileCXX)
+
+# list of archive names for which tests should be generated
+set(archive_list text_archive text_warchive binary_archive xml_archive xml_warchive)
+# set(archive_list xml_warchive)
+
+# list of tests generated by each function call
+set(test_list)
+
+###########################
+# library builds
+
+add_library(serialization
+  ../src/archive_exception.cpp
+  ../src/basic_archive.cpp
+  ../src/basic_iarchive.cpp
+  ../src/basic_iserializer.cpp
+  ../src/basic_oarchive.cpp
+  ../src/basic_oserializer.cpp
+  ../src/basic_pointer_iserializer.cpp
+  ../src/basic_pointer_oserializer.cpp
+  ../src/basic_serializer_map.cpp
+  ../src/basic_text_iprimitive.cpp
+  ../src/basic_text_oprimitive.cpp
+  ../src/basic_xml_archive.cpp
+  ../src/binary_iarchive.cpp
+  ../src/binary_oarchive.cpp
+  ../src/extended_type_info.cpp
+  ../src/extended_type_info_typeid.cpp
+  ../src/extended_type_info_no_rtti.cpp
+  ../src/stl_port.cpp
+  ../src/text_iarchive.cpp
+  ../src/text_oarchive.cpp
+  ../src/polymorphic_iarchive.cpp
+  ../src/polymorphic_oarchive.cpp
+  ../src/polymorphic_text_iarchive.cpp
+  ../src/polymorphic_text_oarchive.cpp
+  ../src/polymorphic_binary_iarchive.cpp
+  ../src/polymorphic_binary_oarchive.cpp
+  ../src/polymorphic_xml_iarchive.cpp
+  ../src/polymorphic_xml_oarchive.cpp
+  ../src/void_cast.cpp
+  ../src/xml_grammar.cpp
+  ../src/xml_iarchive.cpp
+  ../src/xml_oarchive.cpp
+  ../src/xml_archive_exception.cpp
+  ../src/codecvt_null.cpp
+  ../src/utf8_codecvt_facet.cpp
+  ../src/basic_xml_grammar.ipp # doesn't show up in "Source Files" in Xcode"'
+)
+target_include_directories(serialization PUBLIC ${Boost_INCLUDE_DIR})
+
+add_library(wserialization
+  ../src/basic_text_wiprimitive.cpp
+  ../src/basic_text_woprimitive.cpp
+  ../src/text_wiarchive.cpp
+  ../src/text_woarchive.cpp
+  ../src/polymorphic_text_wiarchive.cpp
+  ../src/polymorphic_text_woarchive.cpp
+  ../src/xml_wiarchive.cpp
+  ../src/xml_woarchive.cpp
+  ../src/polymorphic_xml_wiarchive.cpp
+  ../src/polymorphic_xml_woarchive.cpp
+  ../src/xml_wgrammar.cpp
+  ../src/basic_xml_grammar.ipp # doesn't show up in "Source Files" in Xcode"'
+)
+target_include_directories(wserialization PUBLIC ${Boost_INCLUDE_DIR})
+target_link_libraries(wserialization PUBLIC serialization)
+
+# end library build
+###########################
+
+###########################
+# test targets
+
+function( serialization_test test_name)
+  set(arglist)
+  foreach(a IN ITEMS ${ARGN} )
+    set(arglist ${arglist} ../test/${a}.cpp)
+  endforeach()
+  message(STATUS ${test_name})
+  add_executable( ${test_name} ../test/${test_name}.cpp ${arglist} )
+  target_include_directories(${test_name} PUBLIC ${Boost_INCLUDE_DIR})
+  target_link_libraries(${test_name} serialization wserialization Boost::filesystem)
+  add_test( ${test_name} ${test_name} )
+endfunction(serialization_test)
+
+function(archive_test test_name)
+  set(test_listx)
+  set(arglist)
+  foreach(a IN ITEMS ${ARGN} )
+    set(arglist ${arglist} ../test/${a}.cpp)
+  endforeach()
+  foreach(
+    archive-name
+    IN ITEMS ${archive_list}
+  )
+    set(amended_test_name ${test_name}_${archive-name})
+    add_executable(${amended_test_name} ../test/${test_name}.cpp ${arglist})
+    set_property(
+      TARGET ${amended_test_name}
+      PROPERTY COMPILE_DEFINITIONS BOOST_ARCHIVE_TEST=${archive-name}.hpp
+    )
+    target_include_directories(${amended_test_name} PUBLIC ${Boost_INCLUDE_DIR})
+    target_link_libraries(${amended_test_name} serialization wserialization Boost::filesystem)
+    add_test(${amended_test_name} ${amended_test_name})
+    set(test_listx ${test_listx} ${amended_test_name})
+  endforeach()
+  set(test_list ${test_listx} PARENT_SCOPE)
+endfunction(archive_test)
+
+function(polymorphic_archive_test test_name)
+  set(test_listx)
+  set(arglist)
+  foreach(a IN ITEMS ${ARGN} )
+    set(arglist ${arglist} ../test/${a}.cpp)
+  endforeach()
+  foreach(
+    archive-name
+    IN ITEMS ${archive_list}
+  )
+    set(amended_archive_name polymorphic_${archive-name})
+    set(amended_test_name ${test_name}_${amended_archive_name})
+    add_executable(${amended_test_name} ../test/${test_name}.cpp ${arglist})
+    set_property(
+      TARGET ${amended_test_name}
+      PROPERTY COMPILE_DEFINITIONS BOOST_ARCHIVE_TEST=${amended_archive_name}.hpp
+    )
+    message(STATUS ${amended_test_name} " " ${arglist} " " ${amended_archive_name})
+    target_include_directories(${amended_test_name} PUBLIC ${Boost_INCLUDE_DIR})
+    target_link_libraries(${amended_test_name} serialization wserialization Boost::filesystem)
+    add_test(${amended_test_name} ${amended_test_name})
+    set(test_listx ${test_listx} ${amended_test_name})
+endforeach()
+set(test_list ${test_listx} PARENT_SCOPE)
+endfunction(polymorphic_archive_test)
+
+enable_testing()
+
+message(STATUS dll_a)
+add_library(dll_a SHARED ../test/dll_a.cpp)
+target_link_libraries(dll_a serialization)
+
+message(STATUS dll_polymorphic_base)
+add_library(dll_polymorphic_base SHARED ../test/dll_polymorphic_base.cpp)
+target_link_libraries(dll_polymorphic_base serialization)
+
+message(STATUS dll_polymorphic_derived2)
+add_library(dll_polymorphic_derived2 SHARED ../test/dll_polymorphic_derived2.cpp)
+target_link_libraries(dll_polymorphic_derived2 dll_polymorphic_base serialization)
+
+# compile test_dll_plugin.cpp
+# Running the following test requires that the test know the directory 
+# in which the dll is stored. I don't know how to extract this from bjam
+# serialization(test_dll_plugin : : dll_polymorphic_derived2_lib)
+
+if(BUILD_SHARED_LIBS)
+  # this test can only be made to work if we're linking with shared
+  # libraries. Basically the build systems like to have all shared
+  # or all static so if we're building with static C++ libraries
+  # then linking with a shared one - we need multiple C++ libraries
+  # and things get complex.  So just run this test when we're
+  # building with shared libraries (dll in windows speak)
+  serialization_test(test_dll_simple)
+  target_link_libraries(test_dll_simple dll_a serialization)
+endif()
+
+serialization_test(test_private_ctor)
+serialization_test(test_reset_object_address A)
+serialization_test(test_void_cast)
+serialization_test(test_mult_archive_types)
+serialization_test(test_iterators)
+serialization_test(test_iterators_base64)
+serialization_test(test_inclusion)
+serialization_test(test_inclusion2)
+serialization_test(test_smart_cast)
+serialization_test(test_codecvt_null)
+serialization_test(test_strong_typedef)
+serialization_test(test_singleton)
+serialization_test(test_singleton_inherited)
+serialization_test(test_singleton_plain)
+
+archive_test(test_native_array A)
+archive_test(test_boost_array A)
+if(COMPILER_SUPPORTS_CXX11)
+  archive_test(test_array A)
+endif()
+
+archive_test(test_binary)
+archive_test(test_bitset)
+archive_test(test_class_info_save)
+archive_test(test_class_info_load)
+archive_test(test_complex)
+archive_test(test_contained_class A)
+archive_test(test_cyclic_ptrs A)
+archive_test(test_delete_pointer)
+archive_test(test_deque A)
+archive_test(test_derived)
+archive_test(test_derived_class A)
+archive_test(test_diamond)
+archive_test(test_diamond_complex)
+CHECK_INCLUDE_FILE_CXX(forward_list FORWARD_LIST_FOUND)
+if(FORWARD_LIST_FOUND)
+  message(STATUS "forward_list header found")
+  archive_test(test_forward_list A)
+  archive_test(test_forward_list_ptrs A)
+else()
+  message(STATUS "forward_list header NOT found")
+endif()
+
+archive_test(test_helper_support)
+archive_test(test_interrupts)
+archive_test(test_list A)
+archive_test(test_list_ptrs A)
+
+archive_test(test_map A)
+CHECK_INCLUDE_FILE_CXX(hash_map HASH_MAP_FOUND)
+if(HASH_MAP_FOUND)
+  archive_test(test_map_hashed A)
+endif()
+archive_test(test_mi)
+archive_test(test_multiple_ptrs A)
+archive_test(test_multiple_inheritance)
+archive_test(test_new_operator A)
+archive_test(test_non_intrusive)
+archive_test(test_non_default_ctor)
+archive_test(test_non_default_ctor2)
+archive_test(test_null_ptr)
+archive_test(test_nvp A)
+archive_test(test_object)
+archive_test(test_optional)
+archive_test(test_primitive)
+archive_test(test_priority_queue A)
+archive_test(test_private_base)
+archive_test(test_private_base2)
+archive_test(test_queue A)
+archive_test(test_recursion A)
+archive_test(test_registered)
+
+archive_test(test_set A)
+CHECK_INCLUDE_FILE_CXX(hash_set HASH_SET_FOUND)
+if(HASH_SET_FOUND)
+  archive_test(test_set_hashed A)
+endif()
+
+archive_test(test_shared_ptr)
+archive_test(test_shared_ptr_multi_base)
+archive_test(test_shared_ptr_132)
+archive_test(test_simple_class A)
+archive_test(test_simple_class_ptr A)
+CHECK_INCLUDE_FILE_CXX(slist SLIST_FOUND)
+if(SLIST_FOUND)
+  message(STATUS "slist header found")
+  archive_test(test_slist A)
+  archive_test(test_slist_ptr A)
+endif()
+archive_test(test_stack A)
+archive_test(test_split)
+archive_test(test_tracking)
+archive_test(test_unregistered)
+archive_test(test_unique_ptr)
+archive_test(test_valarray)
+archive_test(test_variant A)
+archive_test(test_vector A)
+
+if(BUILD_SHARED_LIBS)
+  polymorphic_archive_test(test_dll_exported polymorphic_derived1)
+  foreach(test_name IN ITEMS ${test_list} )
+    target_link_libraries(${test_name} dll_polymorphic_derived2 dll_polymorphic_base serialization wserialization)
+  endforeach()
+endif()
+
+polymorphic_archive_test(test_no_rtti polymorphic_base polymorphic_derived1 polymorphic_derived2)
+polymorphic_archive_test(test_exported polymorphic_base polymorphic_derived1 polymorphic_derived2)
+polymorphic_archive_test(test_polymorphic test_polymorphic_A A)
+polymorphic_archive_test(test_polymorphic2 test_polymorphic2imp)
+polymorphic_archive_test(test_p_helper)
+
+# end test targets
+####################
+
+####################
+# add headers in IDE
+
+# for serialization
+
+file(GLOB x 
+  RELATIVE "${CMAKE_CURRENT_SOURCE_DIR}" 
+  "${CMAKE_CURRENT_SOURCE_DIR}/../include/boost/archive/*.hpp"
+)
+add_custom_target(archive SOURCES ${x})
+set_property(TARGET archive PROPERTY FOLDER "serialization")
+
+file(GLOB x 
+  RELATIVE "${CMAKE_CURRENT_SOURCE_DIR}" 
+  "${CMAKE_CURRENT_SOURCE_DIR}/../include/boost/archive/detail/*.hpp"
+)
+add_custom_target(archive-detail SOURCES ${x})
+set_property(TARGET archive-detail PROPERTY FOLDER "serialization")
+
+file(GLOB x 
+  RELATIVE "${CMAKE_CURRENT_SOURCE_DIR}" 
+  "${CMAKE_CURRENT_SOURCE_DIR}/../include/boost/archive/impl/*.ipp"
+)
+add_custom_target(archive-impl SOURCES ${x})
+set_property(TARGET archive-impl PROPERTY FOLDER "serialization")
+
+file(GLOB x
+  RELATIVE "${CMAKE_CURRENT_SOURCE_DIR}" 
+  "${CMAKE_CURRENT_SOURCE_DIR}/../include/boost/archive/iterators/*.hpp"
+)
+add_custom_target(archive-iterators SOURCES ${x})
+set_property(TARGET archive-iterators PROPERTY FOLDER "serialization")
+
+file(GLOB x 
+  RELATIVE "${CMAKE_CURRENT_SOURCE_DIR}" 
+  "${CMAKE_CURRENT_SOURCE_DIR}/../include/boost/serialization/*.hpp"
+)
+add_custom_target(serialization-headers SOURCES ${x})
+set_property(TARGET serialization-headers PROPERTY FOLDER "serialization")
+
+file(GLOB x 
+  RELATIVE "${CMAKE_CURRENT_SOURCE_DIR}" 
+  "${CMAKE_CURRENT_SOURCE_DIR}/../include/boost/serialization/detail/*.hpp"
+)
+add_custom_target(serialization-detail SOURCES ${x})
+set_property(TARGET serialization-detail PROPERTY FOLDER "serialization")
+
+# for wserialization
+
+file(GLOB x 
+  RELATIVE "${CMAKE_CURRENT_SOURCE_DIR}" 
+  "${CMAKE_CURRENT_SOURCE_DIR}/../include/boost/archive/*_w*.hpp"
+)
+add_custom_target(wserialization_headers SOURCES ${x})
+set_property(TARGET wserialization_headers PROPERTY FOLDER "wserialization")
+
+# end headers in IDE
+####################
+
+#####################
+# add test project to run misc tests
+
+add_executable( test_z ../test/test_z.cpp)
+target_link_libraries(test_z serialization wserialization ${Boost_LIBRARIES})
+
+# end test project
+#####################

CMakeLists.txt

@@ -0,0 +1,124 @@
+# Copyright 2020, 2021 Peter Dimov
+# Distributed under the Boost Software License, Version 1.0.
+# https://www.boost.org/LICENSE_1_0.txt
+
+cmake_minimum_required(VERSION 3.5...3.16)
+
+project(boost_serialization VERSION "${BOOST_SUPERPROJECT_VERSION}" LANGUAGES CXX)
+
+add_library(boost_serialization
+  src/archive_exception.cpp
+  src/basic_archive.cpp
+  src/basic_iarchive.cpp
+  src/basic_iserializer.cpp
+  src/basic_oarchive.cpp
+  src/basic_oserializer.cpp
+  src/basic_pointer_iserializer.cpp
+  src/basic_pointer_oserializer.cpp
+  src/basic_serializer_map.cpp
+  src/basic_text_iprimitive.cpp
+  src/basic_text_oprimitive.cpp
+  src/basic_xml_archive.cpp
+  src/binary_iarchive.cpp
+  src/binary_oarchive.cpp
+  src/codecvt_null.cpp
+  src/extended_type_info.cpp
+  src/extended_type_info_no_rtti.cpp
+  src/extended_type_info_typeid.cpp
+  src/polymorphic_binary_iarchive.cpp
+  src/polymorphic_binary_oarchive.cpp
+  src/polymorphic_iarchive.cpp
+  src/polymorphic_oarchive.cpp
+  src/polymorphic_text_iarchive.cpp
+  src/polymorphic_text_oarchive.cpp
+  src/polymorphic_xml_iarchive.cpp
+  src/polymorphic_xml_oarchive.cpp
+  src/stl_port.cpp
+  src/text_iarchive.cpp
+  src/text_oarchive.cpp
+  src/utf8_codecvt_facet.cpp
+  src/void_cast.cpp
+  src/xml_archive_exception.cpp
+  src/xml_grammar.cpp
+  src/xml_iarchive.cpp
+  src/xml_oarchive.cpp
+)
+
+add_library(boost_wserialization
+  src/basic_text_wiprimitive.cpp
+  src/basic_text_woprimitive.cpp
+  src/binary_wiarchive.cpp
+  src/binary_woarchive.cpp
+  src/polymorphic_text_wiarchive.cpp
+  src/polymorphic_text_woarchive.cpp
+  src/polymorphic_xml_wiarchive.cpp
+  src/polymorphic_xml_woarchive.cpp
+  src/text_wiarchive.cpp
+  src/text_woarchive.cpp
+  src/xml_wgrammar.cpp
+  src/xml_wiarchive.cpp
+  src/xml_woarchive.cpp
+)
+
+add_library(Boost::serialization ALIAS boost_serialization)
+add_library(Boost::wserialization ALIAS boost_wserialization)
+
+target_include_directories(boost_serialization PUBLIC include)
+target_include_directories(boost_wserialization PUBLIC include)
+
+target_link_libraries(boost_serialization
+  PUBLIC
+    Boost::array
+    Boost::assert
+    Boost::config
+    Boost::core
+    Boost::detail
+    Boost::integer
+    Boost::io
+    Boost::iterator
+    Boost::move
+    Boost::mpl
+    Boost::optional
+    Boost::predef
+    Boost::preprocessor
+    Boost::smart_ptr
+    Boost::spirit
+    Boost::type_traits
+    Boost::unordered
+    Boost::utility
+    Boost::variant
+  PRIVATE
+    Boost::function
+)
+
+target_link_libraries(boost_wserialization PUBLIC boost_serialization)
+
+target_compile_definitions(boost_serialization
+  PUBLIC BOOST_SERIALIZATION_NO_LIB
+  # Source files already define BOOST_SERIALIZATION_SOURCE
+  # PRIVATE BOOST_SERIALIZATION_SOURCE
+)
+
+target_compile_definitions(boost_wserialization
+  PUBLIC BOOST_SERIALIZATION_NO_LIB
+  # Source files already define BOOST_SERIALIZATION_SOURCE
+  # PRIVATE BOOST_SERIALIZATION_SOURCE
+)
+
+if(BUILD_SHARED_LIBS)
+  target_compile_definitions(boost_serialization PUBLIC BOOST_SERIALIZATION_DYN_LINK)
+  target_compile_definitions(boost_wserialization PUBLIC BOOST_SERIALIZATION_DYN_LINK)
+else()
+  target_compile_definitions(boost_serialization PUBLIC BOOST_SERIALIZATION_STATIC_LINK)
+  target_compile_definitions(boost_wserialization PUBLIC BOOST_SERIALIZATION_STATIC_LINK)
+endif()
+
+if(BOOST_SUPERPROJECT_VERSION AND NOT CMAKE_VERSION VERSION_LESS 3.13)
+  boost_install(TARGETS boost_serialization boost_wserialization VERSION ${BOOST_SUPERPROJECT_VERSION} HEADER_DIRECTORY include)
+endif()
+
+if(BUILD_TESTING AND EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/test/CMakeLists.txt")
+
+  add_subdirectory(test)
+
+endif()

LICENSE_1_0.txt

@@ -0,0 +1,23 @@
+Boost Software License - Version 1.0 - August 17th, 2003
+
+Permission is hereby granted, free of charge, to any person or organization
+obtaining a copy of the software and accompanying documentation covered by
+this license (the "Software") to use, reproduce, display, distribute,
+execute, and transmit the Software, and to prepare derivative works of the
+Software, and to permit third-parties to whom the Software is furnished to
+do so, all subject to the following:
+
+The copyright notices in the Software and this entire statement, including
+the above license grant, this restriction and the following disclaimer,
+must be included in all copies of the Software, in whole or in part, and
+all derivative works of the Software, unless such copies or derivative
+works are solely in the form of machine-executable object code generated by
+a source language processor.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT
+SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE
+FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,
+ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+DEALINGS IN THE SOFTWARE.

appveyor.yml

@@ -0,0 +1,82 @@
+# Copyright 2016 Peter Dimov
+# Copyright 2016 Robert Ramey
+# Distributed under the Boost Software License, Version 1.0.
+# (See accompanying file LICENSE_1_0.txt or copy at http://boost.org/LICENSE_1_0.txt)
+
+version: 1.0.{build}-{branch}
+
+shallow_clone: true
+
+branches:
+  only:
+    - develop
+#    - master
+
+environment:
+  matrix:
+    - BUILD_TOOLSET: gcc
+      BUILD_LINK: static
+    - BUILD_TOOLSET: gcc
+      BUILD_LINK: shared
+    - BUILD_TOOLSET: msvc-14.0
+      BUILD_LINK: static
+    - BUILD_TOOLSET: msvc-14.0
+      BUILD_LINK: shared
+
+install:
+  - cd ..
+  - git clone -b %APPVEYOR_REPO_BRANCH%  https://github.com/boostorg/boost.git boost-root
+  - cd boost-root
+  - git submodule init libs/align
+  - git submodule init libs/array
+  - git submodule init libs/assert
+  - git submodule init libs/bind
+  - git submodule init libs/compatibility
+  - git submodule init libs/concept_check
+  - git submodule init libs/config
+  - git submodule init libs/container
+  - git submodule init libs/container_hash
+  - git submodule init libs/core
+  - git submodule init libs/detail
+  - git submodule init libs/filesystem
+  - git submodule init libs/function
+  - git submodule init libs/functional
+  - git submodule init libs/integer
+  - git submodule init libs/intrusive
+  - git submodule init libs/io
+  - git submodule init libs/iterator
+  - git submodule init libs/lexical_cast
+  - git submodule init libs/math
+  - git submodule init libs/move
+  - git submodule init libs/mpl
+  - git submodule init libs/numeric/conversion
+  - git submodule init libs/optional
+  - git submodule init libs/predef
+  - git submodule init libs/preprocessor
+  - git submodule init libs/range
+  - git submodule init libs/smart_ptr
+  - git submodule init libs/spirit
+  - git submodule init libs/system
+  - git submodule init libs/throw_exception
+  - git submodule init libs/tuple
+  - git submodule init libs/type_index
+  - git submodule init libs/type_traits
+  - git submodule init libs/unordered
+  - git submodule init libs/utility
+  - git submodule init libs/variant
+  - git submodule init libs/winapi
+  - git submodule init tools/boost_install
+  - git submodule init libs/headers
+
+  - git submodule init tools/build
+  - git submodule update
+  - xcopy /s /e /q %APPVEYOR_BUILD_FOLDER% libs\serialization
+  - set PATH=C:\mingw-w64\i686-6.3.0-posix-dwarf-rt_v5-rev1\mingw32\bin;%CD%;%PATH%
+  - bootstrap gcc
+  - b2 headers
+
+build: off
+
+test_script:
+  - cd libs/serialization/test
+  - b2 -j2 toolset=%BUILD_TOOLSET% link=%BUILD_LINK%

build.jam

@@ -0,0 +1,45 @@
+# Copyright René Ferdinand Rivera Morell 2023-2024
+# Distributed under the Boost Software License, Version 1.0.
+# (See accompanying file LICENSE_1_0.txt or copy at
+# http://www.boost.org/LICENSE_1_0.txt)
+
+require-b2 5.2 ;
+
+constant boost_dependencies :
+    /boost/array//boost_array
+    /boost/assert//boost_assert
+    /boost/config//boost_config
+    /boost/core//boost_core
+    /boost/detail//boost_detail
+    /boost/integer//boost_integer
+    /boost/io//boost_io
+    /boost/iterator//boost_iterator
+    /boost/move//boost_move
+    /boost/mp11//boost_mp11
+    /boost/mpl//boost_mpl
+    /boost/optional//boost_optional
+    /boost/predef//boost_predef
+    /boost/preprocessor//boost_preprocessor
+    /boost/smart_ptr//boost_smart_ptr
+    /boost/spirit//boost_spirit
+    /boost/throw_exception//boost_throw_exception
+    /boost/type_traits//boost_type_traits
+    /boost/utility//boost_utility
+    /boost/variant//boost_variant
+    /boost/variant2//boost_variant2 ;
+
+project /boost/serialization
+    : common-requirements
+        <include>include
+    ;
+
+explicit
+    [ alias boost_serialization : build//boost_serialization ]
+    [ alias boost_wserialization : build//boost_wserialization ]
+    [ alias all : boost_serialization boost_wserialization example test ]
+    ;
+
+call-if : boost-library serialization
+    : install boost_serialization boost_wserialization
+    ;
+

build/Jamfile.v2

@@ -1,15 +1,27 @@
 # Boost serialization Library Build Jamfile
 #  (C) Copyright Robert Ramey 2002-2004.
-#  Use, modification, and distribution are subject to the 
-#  Boost Software License, Version 1.0. (See accompanying file 
+#  Use, modification, and distribution are subject to the
+#  Boost Software License, Version 1.0. (See accompanying file
 #  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 #
 #  See http://www.boost.org/libs/serialization for the library home page.
 
-project boost/serialization
+require-b2 5.0.1 ;
+import-search /boost/config/checks ;
+import config : requires ;
+
+constant boost_dependencies_private :
+    /boost/function//boost_function
+    ;
+
+project
     : source-location ../src
+    : common-requirements <library>$(boost_dependencies)
     : requirements
       <conditional>@include-spirit
+      <library>$(boost_dependencies_private)
+    : usage-requirements
+        <define>BOOST_SERIALIZATION_NO_LIB=1
 ;
 
 SPIRIT_ROOT = [ modules.peek : SPIRIT_ROOT ] ;
@@ -18,41 +30,42 @@ rule include-spirit ( properties * )
     local old-compiler ;
     if <toolset>borland in $(properties)
     {
-        if ! <toolset-borland:version>6.1.0 in $(properties)  
-        {  
-            old-compiler = true ;  
-        }  
+        if ! <toolset-borland:version>6.1.0 in $(properties)
+        {
+            old-compiler = true ;
+        }
 
     }
     else if <toolset>msvc in $(properties)
     {
         if <toolset-msvc:version>6.5 in $(properties)
           || <toolset-msvc:version>7.0 in $(properties)
-        {            
+        {
             old-compiler = true ;
-        }        
+        }
     }
-        
+
     local result ;
     if $(old-compiler)
-    {        
+    {
         if $(SPIRIT_ROOT)
         {
-            # note - we can't use <include>$(SPIRIT_ROOT) because 
+            # note - we can't use <include>$(SPIRIT_ROOT) because
             # it puts -I$(SPIRIT_ROOT) AFTER the "../../.." in the command line.
-            # so use these instead 
+            # so use these instead
             result = <cxxflags>-I$(SPIRIT_ROOT) ;
         }
-        else 
+        else
         {
             echo **** spirit 1.6x required to build library with this compiler **** ;
             result = <build>no ;
         }
-    }    
+    }
     return $(result) ;
 }
 
-SOURCES = 
+SOURCES =
+    archive_exception
     basic_archive
     basic_iarchive
     basic_iserializer
@@ -74,42 +87,58 @@ SOURCES =
     stl_port
     text_iarchive
     text_oarchive
+    polymorphic_text_iarchive
+    polymorphic_text_oarchive
+    polymorphic_binary_iarchive
+    polymorphic_binary_oarchive
+    polymorphic_xml_iarchive
+    polymorphic_xml_oarchive
     void_cast
-    archive_exception
     xml_grammar
     xml_iarchive
-    xml_oarchive
     xml_archive_exception
-    shared_ptr_helper
+    codecvt_null
+ ;
+
+SOURCES_HAS_STD_WSTREAMBUF =
+    xml_oarchive
+    utf8_codecvt_facet
 ;
-    
-WSOURCES = 
+
+WSOURCES =
     basic_text_wiprimitive
     basic_text_woprimitive
     text_wiarchive
     text_woarchive
-    utf8_codecvt_facet
+    polymorphic_text_wiarchive
+    polymorphic_text_woarchive
     xml_wgrammar
     xml_wiarchive
     xml_woarchive
+    polymorphic_xml_wiarchive
+    polymorphic_xml_woarchive
     codecvt_null
 ;
 
-
-lib boost_serialization 
-    : $(SOURCES).cpp
-    : 
+lib boost_serialization
+    : ## sources ##
+     $(SOURCES).cpp
+    : ## requirements ##
+    [ check-target-builds /boost/config/checks//std_wstreambuf : <source>../src/$(SOURCES_HAS_STD_WSTREAMBUF).cpp ]
     <toolset>msvc:<cxxflags>/Gy
-    #<toolset>gcc:<cxxflags>"-fvisibility=hidden"
+    <toolset>msvc:<define>_SCL_SECURE_NO_WARNINGS
+    <toolset>msvc:<define>_CRT_SECURE_NO_WARNINGS
     <link>shared:<define>BOOST_SERIALIZATION_DYN_LINK=1
     ;
 
-lib boost_wserialization 
-    : $(WSOURCES).cpp boost_serialization 
-    :     
-    <toolset>msvc:<cxxflags>/Gy 
-    #<toolset>gcc:<cxxflags>"-fvisibility=hidden"
+lib boost_wserialization
+    : $(WSOURCES).cpp boost_serialization
+    :
+    [ requires std_wstreambuf ]
+    <toolset>msvc:<cxxflags>/Gy
+    <toolset>msvc:<define>_SCL_SECURE_NO_WARNINGS
+    <toolset>msvc:<define>_CRT_SECURE_NO_WARNINGS
+    # note: both serialization and wserialization are conditioned on the this
+    # switch - don't change it to BOOST_WSERIALIZATION_DYN_LINK
     <link>shared:<define>BOOST_SERIALIZATION_DYN_LINK=1
     ;
-
-boost-install boost_serialization boost_wserialization ;

doc/acknowledgments.html

@@ -2,8 +2,8 @@
 <html>
 <!--
 (C) Copyright 2002-4 Robert Ramey - http://www.rrsd.com . 
-Use, modification and distribution is subject to the Boost Software
-License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+Distributed under the Boost Software License, Version 1.0.
+(See accompanying file LICENSE_1_0.txt or copy at
 http://www.boost.org/LICENSE_1_0.txt)
 -->
 <head>
@@ -44,16 +44,16 @@ http://www.boost.org/LICENSE_1_0.txt)
   <li>Tonko Juricic helped refine and complete project files for VC 7.1 ide
   <li><a href="http://www.boost.org/people/rene_rivera.htm">Rene Rivera</a> tracked down several issues related to 
   Code Warrior, toolset configuration and bjam and much else.
-  <li>Martin Ecker detected (and fixed!) a number of sublte errors regarding cyclic
+  <li>Martin Ecker detected (and fixed!) a number of subtle errors regarding cyclic
   pointers, shared pointers.  He also built the library as a DLL and raised some issues
   <li>Pavel Vozenilek invested much effort in review of code and documentation
-  resulting in many improvements.  In addition he help a lot with porting to other
+  resulting in many improvements.  In addition he helped a lot with porting to other
   platforms including VC 6.0, Intel, and especially Borland.
   <li><a href="http://www.boost.org/people/jens_maurer.htm">Jens Maurer</a> and
   <a href="http://www.boost.org/people/beman_dawes.html">Beman Dawes</a> who got the boost
   serialization ball rolling.  It was one or both of these two that invented
   the much beloved <code>&amp;</code> syntax used to implement both save and
-  load in one fuction specification.
+  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>
@@ -76,7 +76,7 @@ http://www.boost.org/LICENSE_1_0.txt)
   Mr. Rozenthal in particular wrote an incredibly insightful analysis
   that has driven all subsequent development that has resulted in the
   current package.
-  <li>Dave Harris proposal and spirited defense of it lead to a re-thinking
+  <li>Dave Harris proposal and spirited defense of it led to a re-thinking
   of the overrides for serialization of pointers.  This resulted in a simpler
   and more effective method of accounting for non-default constructors
   required by serialization of pointers and STL collections.

doc/archive_reference.html

@@ -2,8 +2,8 @@
 <html>
 <!--
 (C) Copyright 2002-10 Robert Ramey - http://www.rrsd.com . 
-Use, modification and distribution is subject to the Boost Software
-License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+Distributed under the Boost Software License, Version 1.0.
+(See accompanying file LICENSE_1_0.txt or copy at
 http://www.boost.org/LICENSE_1_0.txt)
 -->
 <head>
@@ -35,13 +35,13 @@ http://www.boost.org/LICENSE_1_0.txt)
 
 <h3><a name="trivial">Trivial Archive</a></h3>
 The <a href="archives.html"><strong>Archive</strong></a> concept specifies the functions that a
-class must implement to in order to be used to serialize 
+class must implement in order to be used to serialize 
 <a href="serialization.html"><strong>Serializable</strong></a> types.
 
 Our discussion will focus on archives used for saving as the hierarchy is exactly analogous
 for archives used for loading data.
 
-<h4>Minimum Requirments</h4>
+<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:
@@ -57,11 +57,11 @@ public:
     // serialization library
     typedef boost::mpl::bool_&lt;true&gt; is_saving; 
     typedef boost::mpl::bool_&lt;false&gt; is_loading;
-    template&lt;class T&gt; register_type(){}
-    template&lt;class T&gt; trivial_oarchive & operator&lt;&lt;(const T & t){
+    template&lt;class T&gt; void register_type(){}
+    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){};
@@ -77,22 +77,22 @@ For an example see
 <a href="../example/demo_trivial_archive.cpp" target="demo_trivial_archive">
 <code style="white-space: normal">demo_trivial_archive.cpp</code></a>.
 Of course this program won't produce any output as it is.  But it provides
-the starting point for a simple class which can be used to log formated
+the starting point for a simple class which can be used to log formatted
 output.  See the implementation of a <a href="simple_log.html">simple
 log archive</a> to how this has been done.
 
 <h3><a name="implementation">More Useful Archive Classes</a></h3>
 The above example is fine as far as it goes.  But it doesn't implement
 useful features such as serialization of pointers, class versioning
-and others. This library implements a family of full featuared archive
+and others. This library implements a family of full featured archive
 classes appropriate for a variety of purposes.  
 
 <p>
-Our archives have been factored in to a tree of classes in order to minimize
+Our archives have been factored into a tree of classes in order to minimize
 repetition of code.  This is shown in the accompanying 
 <a target="class_diagram" href="class_diagram.html">class diagram</a>.
 
-Any class which fullfills the following requirements will fit into
+Any class which fulfills the following requirements will fit into
 this hierarchy and implement all the features we require.  Deriving from
 the base class <a href="../../../boost/archive/detail/common_oarchive.hpp" target="common_oarchive_hpp">
 common_oarchive.hpp</a> provides all features we desire which
@@ -113,7 +113,7 @@ class complete_oarchive :
     friend class boost::archive::save_access;
 
     // member template for saving primitive types.
-    // Specialize for any types/templates that special treatment
+    // Specialize for any types/templates that require special treatment
     template&lt;class T&gt;
     void save(T &amp; t);
 
@@ -140,15 +140,15 @@ to help render the archive in a particular form.
 
 <dl>
 
-<dt><h4><code>void save_start()</code></h4></dt>
+<dt><h4><code>void save_start(char const *)</code></h4></dt>
 <dd>
 <strong>Default</strong>:Does nothing.<br>
 <strong>Purpose</strong>:To inject/retrieve an object name into the archive.  Used
-by XML archive to inject "&lt;name " before data.
+by XML archive to inject "&lt;name&gt;" before data.
 </dd>
 <p>
 
-<dt><h4><code>void save_end()</code></h4></dt>
+<dt><h4><code>void save_end(char const *)</code></h4></dt>
 <dd>
 <strong>Default</strong>:Does nothing.<br>
 <strong>Purpose</strong>:To inject/retrieve an object name into the archive. Used
@@ -161,32 +161,27 @@ by XML archive to inject "&lt;/name&gt;" after data.
 <strong>Default</strong>:Does nothing.<br>
 <strong>Purpose</strong>:Called <strong>each time</strong> user data is saved. 
 It's not called when archive bookkeeping data is saved.  This is used by XML archives 
-to determine  when to inject a "&gt;" character at end of XML header. XML output archives 
+to determine  when to inject a "&gt;" character at the end of an XML header. XML output archives 
 keep their own internal flag indicating that data being written is header data. This
 internal flag is reset when an object start tag is written. When 
 <code style="white-space: normal">void end_preamble()</code> is invoked and this internal flag is set
 a "&gt;" character is appended to the output and the internal flag is reset. The default
-implementation for <code style="white-space: normal">void end_preamble()</code> is a no-op there by permitting it
+implementation for <code style="white-space: normal">void end_preamble()</code> is a no-op thereby permitting it
 to be optimised away for archive classes that don't use it.
 </dd>
 <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
 name-value pairs by overriding this function template for name-value pairs.  
 This replaces the default name-value pair handling, which is just to throw away the name,
 with one appropriate for XML which writes out the start of an XML tag with the correct object name.
-<p>
-The second argument must be part of the function signature even this it is not used.
-Its purpose is to be sure that code is portable to compilers which fail to correctly
-implement partial function template ordering.  For more information see
-<a href="implementation.html#functiontemplateordering">this</a>.
 </dd>
 
 </dl>
@@ -195,7 +190,7 @@ implement partial function template ordering.  For more information see
 The serialization library injects bookkeeping data into the serialization archive.
 This data includes things like object ids, version numbers, class names etc.  Each
 of these objects is included in a wrapper so that the archive class can override the
-implementation of <code style="white-space: normal">void 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>
@@ -231,18 +226,13 @@ explicitly provided for these types. For an example see
 In real practice, we probably won't be quite done. 
 One or more of the following issues may need to be addressed:
 <ul>
-    <li>Many compilers fail to implement correct partial ordering of
-    function templates.  The archives included with this library work around
-    this using argument overloading.  This technique is described in
-    <a target="detail" href="implementation.html#functiontemplateordering">
-    another section of this manual</a>
     <li>Even if we are using a conforming compiler, we might want our new archive class
     to be portable to non-conforming compilers.
     <li>Our archive format might require extra information inserted into it.  For
     example, XML archives need &lt;name ... &gt;...&lt;/name&gt; surrounding
     all data objects.
     <li>Addressing any of the above may generate more issues to be addressed.
-    <li>The archives included with library are all templates which use a
+    <li>The archives included with the library are all templates which use a
     <code style="white-space: normal">stream</code> or
     <code style="white-space: normal">streambuf</code>
     as a template parameter rather than simple classes.
@@ -260,14 +250,14 @@ EXCEPT for one special case.
 <ul>
     <li>Instances of a derived class are serialized through a base class pointer.
     <li>Such instances are not "registered" neither implicitly nor explicitly. That
-    is, the macro <code style="white-space: normal">BOOT_CLASS_EXPORT</code> is used 
+    is, the macro <code style="white-space: normal">BOOST_CLASS_EXPORT</code> is used 
     to instantiate the serialization code for the included archives.
 </ul>
 
 To make this work, the following should be included after the archive
 class definition.
 <pre><code>
-#define BOOST_SERIALIZATION_REGISTER_ARCHIVE(Archive)
+BOOST_SERIALIZATION_REGISTER_ARCHIVE(Archive)
 </code></pre>
 Failure to do this will not inhibit the program from compiling, linking
 and executing properly - except in one case.  If an instance of a derived
@@ -281,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 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>
@@ -333,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>
@@ -354,7 +344,7 @@ each time a new archive class is created.
 </ul>
 
 <h4>Implementation</h4>
-The solution is the the pair <code>polymorphic_oarchive</code>
+The solution is the pair <code>polymorphic_oarchive</code>
 and <code>polymorphic_iarchive</code>.  They present a common interface of virtual
 functions - no templates - that is equivalent to the standard templated one.
 
@@ -371,7 +361,7 @@ show how polymorphic archives are to be used. Note the following:
   <li><a target=demo_polymorphic_A_hpp href="../example/demo_polymorphic_A.hpp"><code style="white-space: normal">demo_polymorphic_A.hpp</code></a> and
 <a target=demo_polymorphic_A_cpp href="../example/demo_polymorphic_A.cpp"><code style="white-space: normal">demo_polymorphic_A.cpp</code></a>
 contain no templates and no reference to any specific archive implementation.  That is, they will
-only have to be compiled once for all archive implementations.  The even applies to archives classes
+only have to be compiled once for all archive implementations.  This even applies to archives classes
 created in the future.
   <li>The main program <a target=demo_polymorphic_cp href="../example/demo_polymorphic.cpp"><code style="white-space: normal">demo_polymorphic.cpp</code></a>
 specifies a specific archive implementation.  
@@ -389,7 +379,7 @@ As these contain no code specific to the particular implementation archive, they
 a polymorphic archive implementation from any functioning templated archive implementation.
 <p>
 As a convenience, small header files have been included which contain 
-<code style="white-space: normal">typedef</code> for polymorphic implementation for each corresponding
+a <code style="white-space: normal">typedef</code> for a polymorphic implementation for each corresponding
 templated one.  For example, the headers
 <a target=polymorphic_text_iarchive_hpp href="../../../boost/archive/polymorphic_text_iarchive.hpp"><code style="white-space: normal">polymorphic_text_iarchive.hpp</code></a>
 and
@@ -410,19 +400,19 @@ 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 this the concept and of polymophic archives is fundamentally incompatible with the
-serialization of new types are are marked "primitive" by the user with:
+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)
 </code></pre>
 
 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>
-The main utility of polymorphic archives will be to permit the buiding of class DLLs that will
+The main utility of polymorphic archives will be to permit the building of class DLLs that will
 include serialization code for all present and future archives with no redundant code.
 <hr>
 <p><i>&copy; Copyright <a href="http://www.rrsd.com">Robert Ramey</a> 2002-2004. 

doc/archives.html

@@ -29,13 +29,13 @@
 <h4>Notation</h4>
 In the following descriptions
 <ul>
-  <li><code>SA</code> is an type modeling the <a href="#saving_interface">Saving Archive Concept</a>
+  <li><code>SA</code> is an type modeling the <a href="#saving_interface">Saving Archive Concept</a>.
   <li><code>sa</code> is an instance of type SA.
-  <li><code>LA</code> is an type modeling the <a href="#loading_interface">Loading Archive Concept</a>
+  <li><code>LA</code> is an type modeling the <a href="#loading_interface">Loading Archive Concept</a>.
   <li><code>la</code> is an instance of type LA.
-  <li><code>T</code> is an <a href="serialization.html"><strong>Serializable</strong></a> Type
-  <li><code>x</code> is an instance of type T Type</li>.
-  <li><code>u,v</code> is a pointer to a an instance of type T
+  <li><code>T</code> is an <a href="serialization.html"><strong>Serializable</strong></a> Type.
+  <li><code>x</code> is an instance of type T Type.
+  <li><code>u,v</code> is a pointer to a an instance of type T.
   <li><code>count</code> is an instance of a type that can be converted to <code>std::size_t</code>.
 </ul>
 <h4><a name="saving_interface">Saving Archive Concept</a></h4>
@@ -112,6 +112,14 @@ way the data are rendered <a href="serialization.html">serializable</a>.
     might be conditioned on the library version to make sure that libraries created by 
     previous versions of the library can still be read.
   </dd>
+  <dt><h4><code>
+    sa.get_helper&lt;Helper&gt;(void * const helper_instance_id = 0)
+  </code></h4></dt>
+  <dd>
+    See <code>la.get_helper&lt;Helper&gt;(void * const helper_instance_id = 0)</code>
+    below.
+  </dd>
+
 </dl>
 
 <h4><a name="loading_interface">Loading Archive Concept</a></h4>
@@ -182,6 +190,24 @@ equivalent to the original.
     The code that loads collections might be conditioned on the library version to make 
     sure that libraries created by previous versions of the library can still be read.
   </dd>
+  <dt><h4><code>
+    la.get_helper&lt;Helper&gt;(void * const helper_instance_id)
+  </code></h4></dt>
+  <dd>
+    Some otherwise unserializable types can be made serializable by inclusion of
+    a helper object.  The iconic example of this is shared_ptr which needs this
+    helper object to keep track of previously loaded shared_ptr instances so they
+    can be "matched up" with subsequently loaded ones.
+    The first time <code  style="white-space: normal">la.get_helper&lt;Helper&gt;(void * const helper_instance_id)</code>
+    is invoked for a given helper_instance_id, <code  style="white-space: normal">Helper</code>, a default-constructed
+    <code style="white-space: normal">Helper</code> object is created, attached to
+    <code  style="white-space: normal">la</code> and a reference to it is returned. Subsequent
+    invocations of <code style="white-space: normal">la.get_helper&lt;Helper&gt;(void * const helper_instance_id)</code> with the same id value return
+    a reference to the formerly constructed object. All objects created in this manner are
+    destroyed  upon <code style="white-space: normal">la</code> destruction time. The purpose
+    of helper objects is discussed in
+    <a href="special.html#helpersupport">Special Considerations - Helper Support</a>.
+  </dd>
   <dt><h4><code>
     la.reset_object_address(v, u)
   </code></h4></dt>
@@ -206,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
@@ -266,7 +292,7 @@ included in the code module containing the serialization code.
 
 </code></pre>
 
-All of these archives implement the same inteface. Hence, it should suffice to describe only one
+All of these archives implement the same interface. Hence, it should suffice to describe only one
 of them in detail.  For this purpose we will use the text archive.
 
 
@@ -277,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
@@ -293,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();
 };
 
@@ -304,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 
@@ -317,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.
@@ -353,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();
 };
 
@@ -365,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.
@@ -379,7 +405,7 @@ above.
 </code></h4></dt>
 <dd>
 Destructor for an archive.  This should be called before the stream is
-closed.  It restores any altered stream facets to thier state before the
+closed.  It restores any altered stream facets to their state before the
 the archive was opened.
 </dd>
 </dl>
@@ -392,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>
 

doc/bibliography.html

@@ -2,8 +2,8 @@
 <html>
 <!--
 (C) Copyright 2002-4 Robert Ramey - http://www.rrsd.com . 
-Use, modification and distribution is subject to the Boost Software
-License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+Distributed under the Boost Software License, Version 1.0.
+(See accompanying file LICENSE_1_0.txt or copy at
 http://www.boost.org/LICENSE_1_0.txt)
 -->
 <head>
@@ -42,17 +42,17 @@ 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>
-    <li>Jm Hyslop, and Herb Sutter, "Factory Redux, Part2",
+    <li>Jim Hyslop, and Herb Sutter, "Factory Redux, Part2",
     <u>C/C++ User's Journal</u>, vol 21, No. 8, August 2003
     <a name="9"></a>
     <li>David Vandevoorde and Nicolai M. Josuttis,
     <u>C++ Templates - The Complete Guide</u>, Addison-Wesley, 2003
     <a name="10"></a>
-    <li>Herb Sutter, "Pimples--Beauty Marks You Can Depend On",
+    <li>Herb Sutter, "Pimpls--Beauty Marks You Can Depend On",
     <u>C++ Report</u>, from <u>More C++ Gems</u>, Cambridge University Press, 2000
     <a name="11"></a>
     <li>James Coplien, "Curiously Recurring Template Patterns",
@@ -63,7 +63,7 @@ http://www.boost.org/LICENSE_1_0.txt)
     <a name="13"></a>
     <li>Stephan Beal, "s11n serialization library", <a href="http://www.s11n.net">www.s11n.net</a>
     <a name="14"></a>
-    <li>Vandervoorde and Josuttis, <b>C++ Templates - A Complete Guide</b>, Addison-Wesley, 2003</a>
+    <li>Vandevoorde and Josuttis, <b>C++ Templates - A Complete Guide</b>, Addison-Wesley, 2003</a>
 </ol>
 <hr>
 <p><i>&copy; Copyright <a href="http://www.rrsd.com">Robert Ramey</a> 2002-2004. 

doc/class_diagram.html

@@ -1,8 +1,8 @@
 <!doctype HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
 <!--
 (C) Copyright 2002-4 Robert Ramey - http://www.rrsd.com . 
-Use, modification and distribution is subject to the Boost Software
-License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+Distributed under the Boost Software License, Version 1.0.
+(See accompanying file LICENSE_1_0.txt or copy at
 http://www.boost.org/LICENSE_1_0.txt)
 -->
 <html>
@@ -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>

doc/codecvt.html

@@ -42,7 +42,7 @@ template<
 <h2>Rationale</h2>
 
 
-    UTF-8 is a method of encoding Unicode text in environments where 
+    UTF-8 is a method of encoding Unicode text in environments
     where data is stored as 8-bit characters and some ascii characters 
     are considered special (i.e. Unix filesystem filenames) and tend
     to appear more commonly than other characters.  While
@@ -88,7 +88,7 @@ template&lt;
 <h2>Requirements</h2>
 
     <tt>utf8_codecvt_facet</tt> defaults to using <tt>char</tt> as
-    it's external data type and <tt>wchar_t</tt> as it's internal
+    its external data type and <tt>wchar_t</tt> as its internal
     datatype, but on some architectures <tt>wchar_t</tt> is
     not large enough to hold UCS-4 characters.  In order to use
     another internal type.You must also specialize <tt>std::codecvt</tt>

doc/configuration.html

@@ -2,8 +2,8 @@
 <html>
 <!--
 (C) Copyright 2002-4 Robert Ramey - http://www.rrsd.com . 
-Use, modification and distribution is subject to the Boost Software
-License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+Distributed under the Boost Software License, Version 1.0.
+(See accompanying file LICENSE_1_0.txt or copy at
 http://www.boost.org/LICENSE_1_0.txt)
 -->
 <head>

doc/contents.html

@@ -2,8 +2,8 @@
 <html>
 <!--
 (C) Copyright 2002-4 Robert Ramey - http://www.rrsd.com . 
-Use, modification and distribution is subject to the Boost Software
-License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+Distributed under the Boost Software License, Version 1.0.
+(See accompanying file LICENSE_1_0.txt or copy at
 http://www.boost.org/LICENSE_1_0.txt)
 -->
 <head>
@@ -101,7 +101,10 @@ function initialize() {
 
     <dt><img style="display:none" src="dot.gif"><a target="detail" href="tutorial.html#stl">STL Collections</a>
     <dt><img style="display:none" src="dot.gif"><a target="detail" href="tutorial.html#versioning">Class Versioning</a>
-    <dt><img style="display:none" src="dot.gif"><a target="detail" href="tutorial.html#splitting">Splitting <code>serialize</code> into <code>save/load</code></a>
+    <dt><img style="display:none" src="dot.gif">
+        <a target="detail" href="tutorial.html#splitting">
+            Splitting <code>serialize</code> into <code>save/load</code>
+        </a>
     <dt><img style="display:none" src="dot.gif"><a target="detail" href="tutorial.html#archives">Archives</a>
     <dt><img style="display:none" src="dot.gif"><a target="detail" href="tutorial.html#examples">List of Examples</a>
   </dl></div></dd>
@@ -133,7 +136,9 @@ function initialize() {
           <dt><img style="display:none" src="dot.gif"><a target="detail" href="serialization.html#templates">Templates</a>
         </dl></div></dd>
         <dt><img style="display:none" src="dot.gif"><a target="detail" href="serialization.html#versioning">Versioning</a>
-        <dt><img style="display:none" s'c="dot.gif"><a target="detail" href="serialization.html#splitting">Splitting <code>serialize</code> into <code>save/load</code></a>
+        <dt><img style="display:none" src="dot.gif"><a target="detail" href="tutorial.html#splitting">
+                Splitting <code>serialize</code> into <code>save/load</code>
+            </a>
       </dl></div></dd>
       <dt><img style="display:none" src="plus.gif" id="pointers"><a target="detail" href="serialization.html#pointeroperators">Pointers</a>
       <dd><div id="pointers_detail"><dl class="page-index">
@@ -169,9 +174,6 @@ function initialize() {
           <dt><img style="display:none" src="dot.gif"><a target="detail" href="traits.html#pointer_tracking">pointer_tracking</a>
           <dt><img style="display:none" src="dot.gif"><a target="detail" href="traits.html#const_loading">const_loading</a>
         </dl></div></dd>
-
-
-
       </dl></div></dd>
       <dt><img style="display:none" src="plus.gif" id="wrappers"><a target="detail" href="wrappers.html">Serialization Wrappers</a>
       <dd><div id="wrappers_detail"><dl class="page-index">
@@ -184,10 +186,11 @@ 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>
+      <dt><img style="display:none" src="dot.gif"><a target="detail" href="special.html#helpersupport">Helper Support</a>
       <dt><img style="display:none" src="plus.gif" id="portability"><a target="detail" href="special.html#portability">Archive Portability</a>
       <dd><div id="portability_detail"><dl class="page-index">
         <dt><img style="display:none" src="dot.gif"><a target="detail" href="special.html#numerics">Numerics</a>
@@ -200,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>
@@ -229,7 +232,6 @@ function initialize() {
   </dl></div></dd>
   <dt><img style="display:none" src="plus.gif" id="implementation"><a target="detail" href="implementation.html">Implementation Notes</a>
   <dd><div id="implementation_detail"><dl class="page-index">
-    <dt><img style="display:none" src="dot.gif"><a target="detail" href="implementation.html#functiontemplateordering">Partial Function Template Ordering</a>
     <dt><img style="display:none" src="dot.gif"><a target="detail" href="implementation.html#charencoding">Character Encoding</a>
     <dt><img style="display:none" src="dot.gif"><a target="detail" href="implementation.html#tempatesyntax">Template Invocation syntax</a>
     <dt><img style="display:none" src="dot.gif"><a target="detail" href="implementation.html#partialtemplatespecialization">Partial Template Specialization</a>
@@ -255,7 +257,7 @@ function initialize() {
       <dd><div id="userincludes_detail"><dl class="page-index">
         <dt><img style="display:none" src="dot.gif"><a target="detail" href="headers.html#archiveimplementations">Archive Implementations</a>
         <dt><img style="display:none" src="dot.gif"><a target="detail" href="headers.html#serializationdeclarations">Serialization Declarations</a>
-        <dt><img style="display:none" 'rc="dot.gif"><a target="detail" href="headers.html#serializationimplementations">Serialization Implementations</a>
+        <dt><img style="display:none" src="dot.gif"><a target="detail" href="headers.html#serializationimplementations">Serialization Implementations</a>
       </dl></div>
       <dt><img style="display:none" src="plus.gif" id="libraryimplementation"><a target="detail" href="headers.html#libraryimplementation">Files Which Implement the Library</a>
       <dd><div id="libraryimplementation_detail"><dl class="page-index">
@@ -271,6 +273,7 @@ function initialize() {
     <dt><img style="display:none" src="dot.gif"><a target="detail" href="shared_ptr.html">Template serialization - <code>shared_ptr&lt;class T&gt;</code></a>
     <dt><img style="display:none" src="dot.gif"><a target="detail" href="shared_ptr2.html"><code>shared_ptr&lt;class T&gt;</code>Revisited</a>
     <dt><img style="display:none" src="dot.gif"><a target="detail" href="pimpl.html">PIMPL</a>
+    <dt><img style="display:none" src="dot.gif"><a target="detail" href="private_base.html">Private Base Classes</a>
     <dt><img style="display:none" src="dot.gif"><a target="detail" href="simple_log.html">A Simple Logging Archive Class</a>
     <dt><img style="display:none" src="dot.gif"><a target="detail" href="derivation.html">Derivation from an Existing Archive Class</a>
   </dl></div></dd>

doc/dataflow.html

@@ -2,8 +2,8 @@
 <html>
 <!--
 (C) Copyright 2002-4 Robert Ramey - http://www.rrsd.com . 
-Use, modification and distribution is subject to the Boost Software
-License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+Distributed under the Boost Software License, Version 1.0.
+(See accompanying file LICENSE_1_0.txt or copy at
 http://www.boost.org/LICENSE_1_0.txt)
 -->
 <head>
@@ -35,19 +35,19 @@ We would prefer the solution that is:
 <ul>
   <li>Decomposable. so we can code, test, verify and use each (simple) stage of the conversion 
   independently.
-  <li>Composable. so we can used this composite as a new component somewhere else.
+  <li>Composable. so we can use this composite as a new component somewhere else.
   <li>Efficient, so we're not required to re-implement it again.
   <li>Scalable, so that it works well for short and arbitrarily long sequences.
 </ul>
 The approach that comes closest to meeting these requirements is that described
 and implemented with <a href="../../iterator/doc/index.html">Iterator Adaptors</a>.
-The fundamental feature of an Iterator Adaptor template that makes in interesting to
+The fundamental feature of an Iterator Adaptor template that makes it interesting to
 us is that it takes as a parameter a base iterator from which it derives its
 input. This suggests that something like the following might be possible.
 <pre><code>
 typedef 
-    insert_linebreaks&lt;         // insert line breaks every 72 characters
-        base64_from_binary&lt;    // convert binary values ot base64 characters
+    insert_linebreaks&lt;         // insert line breaks every 76 characters
+        base64_from_binary&lt;    // convert binary values to base64 characters
             transform_width&lt;   // retrieve 6 bit integers from a sequence of 8 bit bytes
                 const char *,
                 6,
@@ -71,12 +71,12 @@ included is <a target="transform_iterator" href="../../iterator/doc/transform_it
 transform_iterator</a>, which can be used to implement 6 bit integer =&gt; base64 code.
 
 <h3>Dataflow Iterators</h3>
-Unfortunately, not all iterators which inherit from Iterator Adaptors are guarenteed
+Unfortunately, not all iterators which inherit from Iterator Adaptors are guaranteed
 to meet the composability goals stated above.  To accomplish this purpose, they have
 to be written with some additional considerations in mind.
 
 We define a Dataflow Iterator as an class inherited from <code style="white-space: normal">iterator_adaptor</code> which
-fulfills as a small set of additional requirements.
+fulfills a small set of additional requirements.
 
 <h4>Templated Constructors</h4>
 <p>
@@ -110,22 +110,8 @@ std::copy(
 The recursive application of this template is what automatically generates the
 constructor <code style="white-space: normal">base64_text(const char *)</code>  in our example above.  The original
 Iterator Adaptors include a <code style="white-space: normal">make_xxx_iterator</code> to fulfill this function.
-However, I believe these are unwieldy to use compared to the above solution usiing
+However, I believe these are unwieldy to use compared to the above solution using
 Templated constructors.
-<p>
-Unfortunately, some systems which fail to properly support partial function template
-ordering cannot support the concept of a templated constructor as implemented above.  
-A special"wrapper"  macro has been created to work around this problem. With this "wrapper" 
-the above example is modified to:
-<pre><code>
-std::copy(
-    base64_text(BOOST_MAKE_PFTO_WRAPPER(address)),
-    base64_text(BOOST_MAKE_PFTO_WRAPPER(address + count)),
-    ostream_iterator&lt;char&gt;(os)
-);
-</code></pre>
-This macro is defined in <a target="pfto" href="../../../boost/serialization/pfto.hpp">&lt;boost/serialization/pfto.hpp&gt;</a>.
-For more information about this topic, check the source.
 
 <h4>Dereferencing</h4>
 Dereferencing some iterators can cause problems.  For example, a natural
@@ -149,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">
@@ -195,7 +181,7 @@ The standard stream iterators don't quite work for us.  On systems which impleme
 as unsigned short integers (E.G. VC 6) they didn't function as I expected. I also made some
 adjustments to be consistent with our concept of Dataflow Iterators.  Like the rest of our
 iterators, they are found in the namespace <code style="white-space: normal">boost::archive::interators</code> to avoid
-conflict the standard library version.
+conflicts with the standard library versions.
 <dl class = "index">
   <dt><a target="istream_iterator" href="../../../boost/archive/iterators/istream_iterator.hpp">
   istream_iterator</a></dt>

doc/definitions.html

@@ -2,8 +2,8 @@
 <html>
 <!--
 (C) Copyright 2002-4 Robert Ramey - http://www.rrsd.com . 
-Use, modification and distribution is subject to the Boost Software
-License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+Distributed under the Boost Software License, Version 1.0.
+(See accompanying file LICENSE_1_0.txt or copy at
 http://www.boost.org/LICENSE_1_0.txt)
 -->
 <head>

doc/derivation.html

@@ -2,8 +2,8 @@
 <html>
 <!--
 (C) Copyright 2002-4 Robert Ramey - http://www.rrsd.com .
-Use, modification and distribution is subject to the Boost Software
-License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+Distributed under the Boost Software License, Version 1.0.
+(See accompanying file LICENSE_1_0.txt or copy at
 http://www.boost.org/LICENSE_1_0.txt)
 -->
 <head>
@@ -47,7 +47,7 @@ The serialization library is
 implemented using the <b>C</b>uriously <b>R</b>ecurring <b>T</b>emplate 
 <b>P</b>attern (<b>CRTP</b>).  Also, all common code is factored out into
 separate modules to minimize code repetition. This makes derivation from
-an existing archive less straight forward than it would otherwise be.
+an existing archive less straightforward than it would otherwise be.
 <p> 
 This example illustrates several issues that have to be addressed when doing
 something like this
@@ -83,14 +83,7 @@ the base classes.
 
     <li><i></i>Reread <a target="detail" href="headers.html#archiveinternals">Archive Internals</a>.
 This describes the class hierarchy so that you know what to override.
-    <li><i>Note the usage of PFTO.</i>  Some compilers fail to provide support for
-partial function template ordering.  The serialization library works around by
-using <a target="detail" href="implementation.html#functiontemplateordering">
-<b>P</b>artial <b>F</b>unction <b>T</b>emplate <b>O</b>rdering</a> in several places.
-In archive classes, this takes
-. This is done
-in several places, including the archive classes themselves.
-    <li><i>Base class functions will usually need to be explicitly invoked</i>
+    <li><i>Base class functions will usually need to be explicitly invoked.</i>
 We commonly specialize the function name <code style="white-space: normal">save_override</code> 
 for saving primitives. Usage of a function name in a derived class
 "hides" similarly named functions of the base class.  That is, 
@@ -106,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);
@@ -121,7 +114,7 @@ so it's what I use.
 </code></pre>
 for just this purpose.  Failure to include required template definitions
 will result in undefined symbol errors when the program is linked.
-    <li><i>Without alteration, this class cannot be further derived from</i><br>
+    <li><i>Without alteration, this class cannot be further derived from.</i><br>
 Base classes using <b>CRTP</b> must be templates with a parameter corresponding to
 the most derived class.  As presented here, this class doesn't qualify, so
 it cannot be used as a base class.  In order to derive further from this class,
@@ -134,14 +127,14 @@ class log_archive_impl :
     public xml_oarchive_impl&lt;Archive&gt;
 {
     ...
-);
+};
 
-// do not derived from this class !!!
+// 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)
     {}
 };

doc/exception_safety.html

@@ -2,8 +2,8 @@
 <html>
 <!--
 (C) Copyright 2002-4 Robert Ramey - http://www.rrsd.com . 
-Use, modification and distribution is subject to the Boost Software
-License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+Distributed under the Boost Software License, Version 1.0.
+(See accompanying file LICENSE_1_0.txt or copy at
 http://www.boost.org/LICENSE_1_0.txt)
 -->
 <head>
@@ -70,7 +70,7 @@ an invalid pointer, or creating a memory leak.
         If an exception occurs, <i>referenced</i> pointers will not need to be deleted
         so there will be no memory leaks. The destructor of this class won't attempt to
         delete these pointers so there will be no problem with dangling references.
-        <i>owned</i> pointers are handled exactly as described above.
+        <i>Owned</i> pointers are handled exactly as described above.
         <p>
         <li><h4>class contains <i>referenced</i> pointers which might be created by load</h4>
         If a <i>referenced</i> pointer is loaded before its corresponding <i>owned</i>
@@ -81,7 +81,7 @@ an invalid pointer, or creating a memory leak.
         <li>Trap exceptions with a <code style="white-space: normal">try/catch</code> block.
         <li>Within the catch part, invoke the archive function 
         <code style="white-space: normal">delete_created_pointers()</code> to delete any pointers
-        created by the class load.  Without out other action, objects created in
+        created by the class load.  Without other action, objects created in
         this way would end up as memory leaks as they are not considered <i>owned</i>
         pointers and hence aren't destroyed.
         <li>The object's destructor won't try

doc/exceptions.html

@@ -2,8 +2,8 @@
 <html>
 <!--
 (C) Copyright 2002-4 Robert Ramey - http://www.rrsd.com .
-Use, modification and distribution is subject to the Boost Software
-License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+Distributed under the Boost Software License, Version 1.0.
+(See accompanying file LICENSE_1_0.txt or copy at
 http://www.boost.org/LICENSE_1_0.txt)
 -->
 <head>
@@ -57,7 +57,7 @@ class archive_exception  : public std::exception
 {
 public:
     typedef enum {
-        unregistered_class,     // attempt to serialize a pointer of an
+        unregistered_class,     // attempt to serialize a pointer of
                                 // an unregistered class
         invalid_signature,      // first line of archive does not contain
                                 // expected string
@@ -66,8 +66,8 @@ public:
         pointer_conflict        // an attempt has been made to directly serialize
                                 // an object after having already serialized the same
                                 // object through a pointer.  Were this permitted, 
-                                // it the archive load would result in the creation
-                                // of extraneous object.
+                                // the archive load would result in the creation
+                                // of an extraneous object.
         incompatible_native_format, // attempt to read native binary format
                                 // on incompatible platform
         array_size_too_short,   // array being loaded doesn't fit in array allocated
@@ -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.
@@ -109,7 +109,7 @@ public:
 <h3><a name="unregistered_class"><code style="white-space: normal">unregistered_class</code></a></h3>
 An attempt has been made to serialize a polymorphic class through a pointer
 without either registering it or associating it with an export key.  This can also occur
-when using a new archive how class name has not been added to the system with the 
+when using a new archive whose class name has not been added to the system with the 
 <code style="white-space: normal">BOOST_ARCHIVE_CUSTOM_ARCHIVE_TYPES</code> macro.
 
 <h3><a name="invalid_signature"><code style="white-space: normal">invalid_signature</code></a></h3>
@@ -121,7 +121,7 @@ exception is thrown.
 This system records the current library version number to all archives created.  Note that this is in
 no way related to version number of classes used by application programs. This refers
 to the version of the serialization system used to create the archive. Future versions
-of this serialization system will be able to identify archives created under previous
+of this serialization system will be able to identify archives created under a previous
 (i.e. this) system and alter the loading procedure accordingly.  Hence, future enhancements
 to this serialization system should not obsolete any existing archive files.  It is only
 necessary to increment this version number when the newer system creates archives
@@ -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>
@@ -225,7 +225,7 @@ This, in turn, can result in the throwing of this exception.
 
 <h3><a name="invalid_class_name"><code style="white-space: normal">invalid_class_name</code></a></h3>
 Class name length greater than the maximum permitted. Most likely cause is a corrupted 
-archive  or an attempt to insert virus via buffer overrun method.
+archive  or an attempt to insert a virus via the buffer overrun method.
 
 <h3><a name="unregistered_cast"><code style="white-space: normal">unregistered_cast</code></a></h3>
 In order to support casting between pointers of base and derived classes
@@ -239,7 +239,7 @@ whose relationship has not been registered,
 
 <h3><a name="multiple_code_instantiation"><code style="white-space: normal">multiple_code_instantiation</code></a></h3>
 This exception is thrown when it is detected that the serialization of the same type 
-has been instantiated more that once.  This might occur when
+has been instantiated more than once.  This might occur when
 serialization code is instantiated in both the mainline and one or more DLLS.
 
 <h3><a name="xml_archive_parsing_error"><code style="white-space: normal">xml_archive_parsing_error</code></a></h3>
@@ -250,8 +250,8 @@ to the loading serialization and this exception might be thrown.  This might
 occur for one of the following reasons:
 <ul>
     <li>The archive has been edited outside the serialization system.  This might
-be possible if only the data is changed and not the XML attributes and nesting
-structure is left unaltered.  But any other editing is likely to render the
+be possible if only the data is changed and the XML attributes and nesting
+structure are left unaltered.  But any other editing is likely to render the
 archive unreadable by the serialization library.
     <li>The serialization has been altered and an archive generated by the old
 code is being read.  That is, versioning has not been properly employed to
@@ -259,7 +259,7 @@ properly deserialize previously created archives.
 </ul>
 
 <h3><a name="xml_archive_tag_mismatch"><code style="white-space: normal">xml_archive_tag_mismatch</code></a></h3>
-This exception will be thrown if the start or end tag of and XML element doesn't match
+This exception will be thrown if the start or end tag of an XML element doesn't match
 the name specified for the object in the program.
 
 <h3><a name="xml_archive_tag_name_error"><code style="white-space: normal">xml_archive_tag_name_error</code></a></h3>

doc/extended_type_info.html

@@ -2,8 +2,8 @@
 <html>
 <!--
 (C) Copyright 2002-4 Robert Ramey - http://www.rrsd.com . 
-Use, modification and distribution is subject to the Boost Software
-License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+Distributed under the Boost Software License, Version 1.0.
+(See accompanying file LICENSE_1_0.txt or copy at
 http://www.boost.org/LICENSE_1_0.txt)
 -->
 <head>
@@ -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.
@@ -57,14 +57,14 @@ the following functions
     and operating systems. This makes it unusable for support of portable archives.
   <li>
     Even if the type name string could somehow be made portable, there is no 
-    guarentee that class headers would be included in the same name space accross 
+    guarantee that class headers would be included in the same namespace accross 
     different applications. In fact, including different headers in different
-    name spaces is an accepted method used to avoid name space conflicts.
+    namespaces is an accepted method used to avoid namespace conflicts.
     Thus the namespace::class_name can't be used as a key.
   <li>
     There exists the possibility that different classes use different type id 
-    mechanism.  The class header might include this information. If we want to 
-    import class headers accross applications, its convenient that the type id
+    mechanisms.  The class header might include this information. If we want to 
+    import class headers accross applications, it's convenient that the type id
     mechanism support inter-operability accross different type id systems.
 </ul>
 <h3>Features</h3>
@@ -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,9 +133,9 @@ 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 the actual information 
+this instance but rather must be programmed to compare the actual information 
 the instances contain.
 <dl>
 
@@ -188,12 +188,12 @@ 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 'wo 
+These functions are used to compare
 <a target="extended_type_info.hpp" href = "../../../boost/serialization/extended_type_info.hpp">
 <code style="white-space: normal">
 extended_type_info
@@ -213,7 +213,7 @@ Construct a new instance of the type to which this
 extended_type_info
 </code>
 </a>
-record corresponds. This function takes variable list of up to 4 arguments
+record corresponds. This function takes a variable list of up to 4 arguments
 of any type.  These arguments are passed to the type's constructor
 at runtime.  In order to use the facility, 
 one must declare a type sequence for the constructor arguments.  
@@ -222,9 +222,9 @@ with those specified when the type was exported.
 This function permits one to create instances of
 any exported type given only the exported <strong>GUID</strong> assigned
 with BOOST_CLASS_EXPORT.  
-If these types are defined in DLLS or shared libraries.  When these modules
-are loaded at runtime, these constructor can be called until the module
-is unloaded.  These modules are referred to as <b>plugin</b>. 
+If these types are defined in DLLS or shared libraries loaded at runtime, 
+these constructors can be called until the module is unloaded.  
+Such modules are referred to as <b>plugins</b>. 
 </code>
 </dd>
 
@@ -245,7 +245,7 @@ object.
 
 </dl>
 
-<h3><a name="requirements">Requirements for and Implementation</a></h3>
+<h3><a name="requirements">Requirements for an Implementation</a></h3>
 In order to be used by the serialization library, an implementation of
 <code style="white-space: normal">extended_type_info</code>, 
 (referred to as ETI here), must be derived from 
@@ -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:
@@ -348,22 +348,22 @@ The test program <code style="white-space: normal"><a target="test_no_rtti" href
 implements this function in terms of the <code style="white-space: normal"><a target="extended_type_info_no_rtti.hpp" href="../../../boost/serialization/extended_type_info_no_rtti.hpp">
 extended_type_info</a></code> API above to return the export key associated with the class.  
 This requires that non-abstract types be exported. It also demonstrates the
-inter-operability with between two different implementations of
+inter-operability between two different implementations of
 <code style="white-space: normal">extended_type_info</code>.
 
 <h3><a name="type_requirements">Requirements for Each Type</a></h3>
 Each type to be managed by the system must be
 "registered" individually. This is accomplished by instantiating
-templates.  For example, if the type T is to use the type_info system
+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

doc/faq.html

@@ -2,8 +2,8 @@
 <html>
 <!--
 (C) Copyright 2002-4 Robert Ramey - http://www.rrsd.com . 
-Use, modification and distribution is subject to the Boost Software
-License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+Distributed under the Boost Software License, Version 1.0.
+(See accompanying file LICENSE_1_0.txt or copy at
 http://www.boost.org/LICENSE_1_0.txt)
 -->
 <head>
@@ -29,10 +29,10 @@ http://www.boost.org/LICENSE_1_0.txt)
         </tr>
     </table>
     <hr>
-This section will be used to list answers to questions raise in the mailing
+This section will be used to list answers to questions raised in the mailing
 lists.  Most of these are due to subtle aspects of the library which are
-overlooked even though they might be described in the documenation.  Often,
-these issues are very easy to address - but can be excruciating difficult to
+overlooked even though they might be described in the documentation.  Often,
+these issues are very easy to address - but can be excruciatingly difficult to
 find.  Should you have such an experience, feel free to vent your frustration
 in a constructive way by adding in your own item.  The best way to do this
 is to create a <a href="http://svn.boost.org/trac/boost/browser">"TRAK" item</a> 

doc/headers.html

@@ -2,8 +2,8 @@
 <html>
 <!--
 (C) Copyright 2002-4 Robert Ramey - http://www.rrsd.com . 
-Use, modification and distribution is subject to the Boost Software
-License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+Distributed under the Boost Software License, Version 1.0.
+(See accompanying file LICENSE_1_0.txt or copy at
 http://www.boost.org/LICENSE_1_0.txt)
 -->
 <head>
@@ -42,10 +42,10 @@ http://www.boost.org/LICENSE_1_0.txt)
   </dl>
 </dl>
 
-This library includes a large number of files. The are organized and classified
-according to purpose listed in the above index. 
+This library includes a large number of files. They are organized and classified
+according to the purposes listed in the above index. 
 <p>
-<code style="white-space: normal">namespace</code> of a classes and templates is syncronized
+<code style="white-space: normal">namespace</code> of classes and templates is synchronized
 with the directory in which the file is found.  For example, the class declaration
 <pre><code>
 boost::archive::text_oarchive
@@ -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>
@@ -95,7 +95,7 @@ boost/archive/text_oarchive.hpp
 <dt><a target="text_wiarchive" href="../../../boost/archive/text_wiarchive.hpp">
 boost/archive/text_wiarchive.hpp
 </a>
-<dd>wide character text input archive used forloading.</dd>
+<dd>wide character text input archive used for loading.</dd>
 
 <dt><a target="text_woarchive" href="../../../boost/archive/text_woarchive.hpp">
 boost/archive/text_woarchive.hpp
@@ -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
@@ -207,7 +207,7 @@ This group of headers includes templates which implement serialization for Stand
 Library or Boost Library templates.  Any program which uses these templates can
 invoke serialization of objects of these types just by including the corresponding header.
 <p>
-By convention' these header files are named:
+By convention these header files are named:
 
 boost/serialization/xxx.hpp
 
@@ -257,7 +257,7 @@ for in all archive implementations.  The serialization system relies on
 certain special types such as <code style="white-space: normal">class_id_type</code> and others to 
 record information in archives that is required to reconstruct the original
 data structure.  These are handled exactly as any other serializable type.
-That is, the can be handled as simple primitives such as they are in simple
+That is, they can be handled as simple primitives such as they are in simple
 text files, or with special code as they are in xml archives.
 </dd>
 
@@ -269,7 +269,7 @@ boost/archive/basic_text_iprimitive.hpp
 </a>
 </dt>
 <dd>
-Implementation of serialization of primitive types in terms of an character
+Implementation of serialization of primitive types in terms of character
 or wide character text streams. This is used in the implementation of text and
 xml archives.  Presumably this would be useful for implementations of other variations
 of text archives such as user friendly text or windows ini files.
@@ -283,7 +283,7 @@ boost/archive/basic_binary_iprimitive.hpp
 </a>
 </dt>
 <dd>
-Implementation of serialization of primitive types in terms of an character
+Implementation of serialization of primitive types in terms of character
 or wide character binary streams. 
 </dd>
 
@@ -294,10 +294,10 @@ boost/archive/basic_binary_oarchive.hpp
 boost/archive/basic_binary_iarchive.hpp
 </a>
 <dd>
-Implementation of serialization of all types in terms of an character
+Implementation of serialization of all types in terms of character
 or wide character binary streams.  This is factored out separately from the
 implementation of binary primitives above.  This may facilitate the creation of
-other types of binary archives in the future. It also preserves analogy and symetry with
+other types of binary archives in the future. It also preserves analogy and symmetry with
 the rest of the library which aids in understanding.
 </dd>
 <dt><a target="basic_text_oarchive" href="../../../boost/archive/basic_text_oarchive.hpp">
@@ -315,12 +315,12 @@ boost/archive/basic_xml_iarchive.hpp
 </a>
 </dt>
 <dd>
-Implementation of serialization of all types in terms of an character
+Implementation of serialization of all types in terms of character
 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 guarentee that any object not attached to a name will 
+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,10 +343,9 @@ 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.
-of the library in order to implement either a class serialization or a new
-archive type. Users should never find it necessary to change these files.
+Users should never find it necessary to change these files.
 <p>
 The following discussion is based on the
 <a target="class_diagram" href="class_diagram.html">class diagram</a>.
@@ -356,7 +355,7 @@ boost/archive/detail/interface_iarchive.hpp</a>
 <dt><a target="interface_iarchive" href="../../../boost/archive/detail/interface_iarchive.hpp">
 boost/archive/detail/interface_iarchive.hpp</a>
 <dd>
-Here are the declarations and definitions which for the 
+Here are the declarations and definitions for the 
 <a href="archives.html">archive_concept</a>. This class redirects calls to the 
 archive interface to a function named <code>save_override</code> in the most derived
 archive class. 
@@ -365,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>
@@ -403,13 +402,13 @@ library code for that part of the code which only depends upon the archive type.
 Building of the library generates and compiles code for all archives implemented.
 
 <ul>
-  <li>Serialization of user and primitive types runs a top speed. This is a noticiable
+  <li>Serialization of user and primitive types runs at top speed. This is a noticeable
   difference with a previous version of the library which did not use templates for archives.
   <li>Library implementation code that never changes need only be compiled once
   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 
@@ -418,22 +417,22 @@ Building of the library generates and compiles code for all archives implemented
 </ul>	
 An example of this is the usage of the spirit library in the library.
 It takes a long time to compile and includes lots of other files. Having this
-only in the library is much more convenient that having to include in every
+only in the library is much more convenient that having to include it in every
 program which uses xml serialization.
 
 <a name="dataflowiterators">
 <h4>Dataflow Iterators</h4>
 In the course of developing this library, it became convenient to make a set
 of composable iterator adaptors for handling archive text.  Applications include
-escaping and unescaping xml text, implementi'g to/from base64 conversion among
+escaping and unescaping xml text and implementing to/from base64 conversion among
 others.
 <p>
-This is a ripe topic in itself. Its touched upon by the 
+This is a ripe topic in itself. It's touched upon by the 
 <a href="../../../libs/iterator/doc/index.html">boost iterator</a> libraries, 
 <a href="http://www.zib.de/weiser/vtl/index.html">View Template Library</a>, and others. 
 <p>
 The code for these iterators is really independent of this library.  But since it
-hasn't been and probably won't be reviewed outside of this context. I've left in a directory 
+hasn't been and probably won't be reviewed outside of this context. I've left it in a directory 
 local to the serialization library:
 <a target="archiveiterators" href="../../../boost/archive/iterators">boost/archive/iterators</a>.
 These iterators are described in 

doc/history.html

@@ -2,8 +2,8 @@
 <html>
 <!--
 (C) Copyright 2002-4 Robert Ramey - http://www.rrsd.com . 
-Use, modification and distribution is subject to the Boost Software
-License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+Distributed under the Boost Software License, Version 1.0.
+(See accompanying file LICENSE_1_0.txt or copy at
 http://www.boost.org/LICENSE_1_0.txt)
 -->
 <head>
@@ -30,24 +30,24 @@ http://www.boost.org/LICENSE_1_0.txt)
   <li>27 Feb 2002
     <ul>
       <li>divide interface from implementation for class 
-          serialization to permit compiliation on gcc
-      <li>improved template instantanciation for type templates
+          serialization to permit compilation on gcc
+      <li>improved template instantantation for type templates
     </ul>
   <li>18 Mar 2002 - draft #2 uploaded to boost
     <ul>
       <li>elminated locale effects on archives
       <li>added signature and library version to archive header
-      <li>improved detection of errors when objects are serializationed 
-          as pointers and subsequently serializationed as objects
+      <li>improved detection of errors when objects are serialized 
+          as pointers and subsequently serialized as objects
       <li>permit non-portable binary archives
-      <li>implement work around for systems such as MSVC 6.0 that
-          don'tsupport partial ordering
+      <li>implement workaround for systems such as MSVC 6.0 that
+          don't support partial ordering
     </ul>
   <li>16 May 2002 - draft #3 uploaded to boost
     <ul>
       <li>Ability to specify serialization of other templates in a
           non-intrusive way.
-      <li>Included and example which uses boost::shared_ptr.
+      <li>Included an example which uses boost::shared_ptr.
       <li>improved documentation
       <li>More test cases
       <li>More testing and documentation of obscure situtations
@@ -65,7 +65,7 @@ http://www.boost.org/LICENSE_1_0.txt)
       <li>minor corrections
       <li>Additions to documentation to explicitly address issues of
           exception safety.
-      <li>More test cases/demos to illustrate handlling of the above issues.
+      <li>More test cases/demos to illustrate handling of the above issues.
       <li>Additions to documentation to include rationale for not depending
           on type_id
       <li>Implementation of serialization of boost::shared_ptr.
@@ -127,8 +127,8 @@ http://www.boost.org/LICENSE_1_0.txt)
     </ul>
   <li>1 November 2004 - final changes for first boost official release 1.32 .
     <ul>
-       <li>Adjustments to address make package compatible with two-phase lookup.
-       <li>Many small adjustments to accomdate quirks of various compilers.
+       <li>Adjustments to address package compatible with two-phase lookup.
+       <li>Many small adjustments to accommodate quirks of various compilers.
        <li>A few bug fixes.
     </ul>
 </ol>

doc/implementation.html

@@ -2,8 +2,8 @@
 <html>
 <!--
 (C) Copyright 2002-4 Robert Ramey - http://www.rrsd.com . 
-Use, modification and distribution is subject to the Boost Software
-License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+Distributed under the Boost Software License, Version 1.0.
+(See accompanying file LICENSE_1_0.txt or copy at
 http://www.boost.org/LICENSE_1_0.txt)
 -->
 <head>
@@ -26,20 +26,13 @@ http://www.boost.org/LICENSE_1_0.txt)
 </table>
 <hr>
 <dl class="page-index">
-  <dt><a href="#functiontemplateordering">Partial Function Template Ordering</a>
   <dt><a href="#charencoding">Character Encoding</a>
-  <dt><a href="#tempatesyntax">Template Invocation syntax</a>
-  <dt><a href="#partialtemplatespecialization">Partial Template Specialization</a>
   <dt><a href="#othercompilerissues">Specific Compiler/Library Issues</a>
   <dl class="page-index">
-    <dt><a href="#gcc3x">GCC 3.X, 4.X</a>
-    <dt><a href="#gcc295">GCC 2.95</a>
+    <dt><a href="#gcc4x">44.X</a>
     <dt><a href="#intel80">Intel 8.0</a>
     <dt><a href="#vc80">Visual C++ 8.0</a>
     <dt><a href="#vc71">Visual C++ 7.1</a>
-    <dt><a href="#vc70">Visual C++ 7.0</a>
-    <dt><a href="#vc6">Visual C++ 6.0</a>
-    <dt><a href="#borland">Borland 5.64 and 5.51</a>
     <dt><a href="#comeau">Comeau 4.3.3</a>
     <dt><a href="#codewarrior9">Code Warrior 9.x</a>
     <dt><a href="#codewarrior">Code Warrior 8.3</a>
@@ -49,86 +42,11 @@ http://www.boost.org/LICENSE_1_0.txt)
   </dl>
 </dl>
 
-<h3><a name="functiontemplateordering">Partial Function Template Ordering</a></h3>
-Not all C++ compilers correctly support partial function template ordering (PFTO).
-For these compilers, the following code will fail to compile:
-<pre><code>
-template&lt;class Archive, class T&gt;
-void serialize(
-    Archive & ar, 
-    T & t, 
-    const unsigned int file_version
-){
-    ...
-}
-
-template&lt;class Archive, class T&gt;
-void serialize(
-    Archive & ar, 
-    my_template&lt;T&gt & t, 
-    const unsigned int file_version
-){
-    ...
-}
-</pre></code>
-The serialization library works around this issue by using a different
-default definition of the first template:
-<pre><code>
-template&lt;class Archive, class T&gt;
-void serialize(
-    Archive & ar, 
-    T & t, 
-    const unsigned long int file_version  // Note: change to long
-){
-    ...
-}
-</pre></code>
-Now, the second template is not matched with the first one so there
-is no PFTO and no compile error.  When the serialization library invokes
-<pre><code>
-serialize(ar, t, 0);
-</pre></code>
-the function declaration is first matched against templates with
-an integer for the third argument.  If there is a match, the matching
-template is instantiated and later invoked.  If there is no match,
-an attempt is made to match other templates by converting arguments to other types.
-In this case the third argument can be converted to long to match
-the first template - which is the default.  So in this case, the first
-template will be instantiated and later invoked.  We have managed to
-use function overloading to achieve the same effect as PFTO
-were it correctly implemented.
-<p>
-This depends upon undefined behavior of a compiler already
-determined to be non-conforming.  In other words, there is no 
-guarantee that this will work on all compilers.  If a compiler does not
-correctly support PFTO and this method cannot be used to workaround
-it, non-intrusive serialization cannot be supported for that compiler.
-As of this writing, such a compiler has not been encountered.
-<p>
-It turns out that using this "trick" can create problems with
-compilers that DO correctly support PFTO.  For this reason we
-define a macro <code style="white-space: normal">BOOST_PTFO</code> which 
-is defined to be <code style="white-space: normal">long</code>
-for non-conforming compilers and nothing for conforming ones. So
-the default definition is really:
-The serialization library works around this issue by using a different
-default definition of the first template:
-<pre><code>
-template&lt;class Archive, class T&gt;
-void serialize(
-    Archive & ar, 
-    T & t, 
-    const unsigned BOOST_PFTO int file_version  // Note: change to BOOST_PFTO
-){
-    ...
-}
-</pre></code>
-
 <h3><a name="charencoding">Character Encoding</a></h3>
 The whole question of character encoding combined with wide characters
 is much more complicated than it would seem to be. The current library
 defines in 3 formats (text, binary, and XML), wide and narrow characters, 
-an attempts to be portable between compiler libraries.  The results of 
+and attempts to be portable between compiler libraries.  The results of 
 a rather long consideration of all these factors has been to set
 default encoding according to the following rules.
 <ul>
@@ -149,7 +67,7 @@ default encoding according to the following rules.
 </ul>
 This character encoding is implemented by changing the <code style="white-space: normal">locale</code> of the
 i/o stream used by an archive when the archive is constructed, the stream
-local is changed back to its original value. This action can be overridden 
+locale is changed back to its original value. This action can be overridden 
 by specifying <code style="white-space: normal">boost::archive::no_codecvt</code>
 when the archive is opened.  In this case, the stream <code style="white-space: normal">locale</code> will
 not be changed by the serialization library.
@@ -175,32 +93,8 @@ do the following.
   <li>Create the archive with the flag <code style="white-space: normal">no_codecvt</code>.
 </ul>
 Naturally, the input process has to be symmetrical.
-<h3><a name="partialtemplatespecialization">Partial Template Specialization</a></h3>
-Compilers which fail to support partial template specialization will fail to compile
-the following code.  To make this compiler, the <code style="white-space: normal">const</code> has to be removed.
-<pre><code>
-void f(A const* a, text_oarchive& oa)
-{
-  oa << a;
-}
-</code></pre>
-<h3><a name="tempatesyntax">Template Invocation syntax</a></h3>
-Some compilers may not recognize the syntax:
-<pre><code>
-ar.template register_type&lt;T&gt;();
-</code></pre>
-for "registering" derived pointers of polymorphic classes.  The actual 
-function prototype is:
-<pre><code>
-template&lt;T&gt;
-void register_type(T * t = NULL);
-</code></pre>
-so that one may write <code style="white-space: normal">ar.register_type(static_cast&lt;T *&gt;(NULL))</code> instead of
-the syntax described above.
-</ul>
 <h3><a name="othercompilerissues">Specific Compiler/Library Issues</a></h3>
-
-<h4><a name="gcc3x">GCC 3.X, 4.X</a></h4>
+<h4><a name="gcc4x">GCC 4.X</a></h4>
 <ul>
     <li>GCC versions for Cygwin and MinGW fail to support wide character I/O.  
     So all tests using wide char I/O fail.  Note that if wide character I/O support
@@ -220,17 +114,6 @@ the syntax described above.
     -Wno-ctor-dtor-privacy
     </code></pre>
 </ul>
-<h4><a name="gcc295">GCC 2.95</a></h4>
-All of the above plus:<br>
-<ul>
-    <li>The serialization library depends on the templated stream 
-    implementation to function properly.
-    So STLPort must be used to build the library.
-    <li>Polymorphic archive tests fail.
-    <li>XML serialization only works with version 1.6x of spirit. In order to build 
-    and use this library with this compiler, one must use version 1.6x rather than the 
-    latest version shipped with boost. See <a href="release.html">Release Notes</a>. 
-</ul>
 <h4><a name="intel80">Intel C++ 8.0</a></h4>
 No known issues. All tests compile and run in debug and release modes.
 
@@ -250,12 +133,12 @@ This is due to the way that VC++ handles templated code with __decl(dllexport) a
 __decl(dllimport) specifications.  Basically, this compiler requires that all the
 instantiations have the same specification - even though they have different
 template arguments. The example <code style="white-space: normal">
-demo_portable_iarchive.cpp</code> would have to reformulated as a library or dll
+demo_portable_iarchive.cpp</code> would have to be reformulated as a library or dll
 similar to the pre-defined archives in order to function.
 <p>
 This compiler does not have RTTI or exception handling turned on by default.  Although
 they are not strictly necessary to use the serialization package, the example and test
-program presume that they are enabled.  So be sure your command line or IDE settings 
+programs presume that they are enabled.  So be sure your command line or IDE settings 
 enable these features if you want to build and run these programs.
 <p>
 This compiler can treat <code style="white-space: normal">wchar_t</code> as either
@@ -264,21 +147,21 @@ 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
 when you compile your own applications.
 <h5>Using the Visual C++ IDE</h5>
 The library includes a VC++ 7.1 "Solution" - <code style="white-space: normal">BoostSerializationLibrary</code>
-along with of a set of project files - one for each demo and test. Consider the following if you
-decided to use these configurations.
+along with a set of project files - one for each demo and test. Consider the following if you
+decide to use these configurations.
 <ul>
     <li>The projects assume that the tests have been built with bjam using the default
     locations.  This will result in a <code style="white-space: normal">bin</code> subdirectory
     within one's main boost directory.  Below this there is a whole structure which maintains 
     object and library files according to the type of build.  The easiest way to build this is to
-    invoke the runtest script which uses bjam. (see below)  If the libraries are not in these locations,
+    invoke the runtest script which uses bjam (see below).  If the libraries are not in these locations,
     the projects will have to be modified accordingly.
     <li>There are project configurations for all the combinations of build variants that boost
     supports. That is for release, debug, static, static multi-threading, etc..
@@ -312,77 +195,6 @@ decided to use these configurations.
     in sync with those included here.
 </ul>
 
-<h4><a name="vc70">Visual C++ 7.0</a></h4>
-<ul>
-    <li>The "pimpl" demo fails to link.  Cause and workaround for this is unknown
-    <li>XML serialization only works with version 1.6x of spirit.  In order to build and use this
-    library with this compiler, one must use version 1.6x rather than the latest version
-    shipped with boost.  See <a href="release.html">Release Notes</a>.
-    <li>This compiler does not support partial template specialization.  
-    The implementation of the new <code>shared_ptr</code> serialization depends upon
-    compiler support for partial template specialization.  This compiler doesn't implement this
-    feature. In order to serialize <code style="white-space: normal">shared_ptr&lt;A&gt;</code>,
-    invoke the macro <code style="white-space: normal">BOOST_SERIALIZATION_SHARED_PTR(A)</code>
-    in the header code.
-    <li>Lack of support for partial template specialization also creates problems for
-    serialization of <code style="white-space: normal">std::map</code>.  In order to serialize
-    instances of this type include the invocation of BOOST_BROKEN_COMPILER_TYPE_TRAITS_SPECIALIZATION
-    for the key type of the map.
-</ul>
-<h4><a name="vc6">Visual C++ 6.5</a></h4>
-all the above issues for Visual C++ 7.0 plus:
-<ul>
-    <li>Out of line template definitions are not recognized and fail with a confusing
-    error message.  To function save/load/serialize member function templates must be defined
-    within the class definition.  This feature is essential to <code style="white-space: normal">demo_pimpl</code>. Hence,
-    this program will fail to compile.  In this case the problem can't be worked around and
-    still demonstrate this facility.
-    <li>This compiler does not support <code style="white-space: normal">wchar_t</code> as a separate type.  It defines
-    <code style="white-space: normal">wchar_t</code> as an alias for <code style="white-space: normal">short int</code>.  In general things will still
-    function.  However certain customization, such as overloading archive operators for
-    saving/loading wide character arrays would produce surprises in this environment.
-    <li>Under certain circumstances, a program will fail to link with the message:
-    LIN1179 - "invalid or corrupt file: duplicate comdat".  According
-    to <a href="http://groups.google.com/groups?th=8a05c82c4ffee280">
-    http://groups.google.com/groups?th=8a05c82c4ffee280
-    </a> (look for P78)
-    A LNK1179 error occurs when:
-    <ul>
-        <li>The template class takes at least two arguments.
-        <li>The template is used at least two times with identical first
-        and different second arguments.
-        <li>The static member variable is of an object type with at least one
-        base class. (In another scenario it also occurred using a member
-        without a base class.)
-    </ul>
-    Working around this in the implementation of the library for this compiler
-    entailed a ridiculous amount of effort.  Even so, the effort wasn't entirely successful.
-    With this compiler, this message will still appear under the following conditions:
-    <ul>
-        <li>When serializing a class with multiple base classes.  This problem causes two 
-        failure in the test suite.  I have been unable to devise a way to work around this.
-        <li>Using more than one kind of archive in the same code module. This should be easy 
-        to work around in practice.
-    </ul>
-    <li>Code modules exceeding some undetermined size that use the library will fail with
-    <i>fatal error C1204: compiler limit : internal structure overflow</i>.  This can be addressed
-    by dividing the module into smaller ones.
-</ul>
-<h4><a name="borland">Borland 5.64 and 5.51</a></h4>
-<ul>
-    <li><code style="white-space: normal">enum</code> data members cannot be serialized.
-    Conversion to/from integers will work around the problem.
-    <li>If class serialize functions are not accessible either by making them public or by
-    including <code style="white-space: normal">friend</code> declarations as described in 
-    <a href="serialization.html#member">Class Serialization - Member Function</a>, the
-    will compile but fail at runtime.
-    <li>Tests using custom extended type which doesn't use RTTI fails. (5.64 only !).
-    <li>Tests built in release mode fail. This seems to be an issue with the boost test system
-    with this compiler.
-    <li>XML serialization only works with version 1.6x of spirit. In order to build 
-    and use this library with this compiler, one must use version 1.6x rather than the 
-    latest version shipped with boost. See <a href="release.html">Release Notes</a>. 
-</ul>
 <h4><a name="comeau">Comeau 4.3.3</a></h4>
 <ul>
     <li>This compiler fails to make a DLL with export under windows.
@@ -393,7 +205,7 @@ all the above issues for Visual C++ 7.0 plus:
 
 <h4><a name="codewarrior9">Code Warrior 9.x</a></h4>
 <ul>
-    <li>Some tests and demos demos fail - still under investigation
+    <li>Some tests and demos fail - still under investigation
 </ul>
 
 <h4><a name="codewarrior">Code Warrior 8.3</a></h4>
@@ -413,7 +225,7 @@ Several compilers, including Visual C++ 6.0, use an older dinkumware library.
 These platforms have several issues: 
 <ul>
     <li>The dinkumware library shipped with this compiler does not change the locale facet
-    of an i/o stream unless the <code style="white-space: normal">imbue</code> function is called before the the
+    of an i/o stream unless the <code style="white-space: normal">imbue</code> function is called before the
     stream is opened.  In order to use this library with this environment to generate UTF-8
     files, one cannot depend on the "automatic" setting of locale that archives implement. The
     stream locale must be set explicitly on the stream before an archive is opened on it.  The
@@ -425,7 +237,7 @@ These platforms have several issues:
 
 <h4><a name="stlport">STLPort 4.5.3</a></h4>
 <ul>
-    <li>when built to use dynamic linking versions of C++ runtime code (<runtime-link>dynamic)
+    <li>when built to use the dynamic linking versions of the C++ runtime code (<runtime-link>dynamic)
     all tests fail to link.  This is due to a missing symbol in the stlport library related
     to custom codecvt facets.
     <li>the test_set fails to run correctly. It seems the hashed set iterator doesn't
@@ -435,7 +247,7 @@ These platforms have several issues:
 
 <hr>
 <p>Revised 1 November, 2004 
-<p><i>&copy; Copyright <a href="http://www.rrsd.com">Robert Ramey</a> 2002-2004. 
+<p><i>&copy; Copyright <a href="http://www.rrsd.com">Robert Ramey</a> 2002-2015.
 Distributed under the Boost Software License, Version 1.0. (See
 accompanying file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 </i></p>

doc/new_case_studies.html

@@ -2,8 +2,8 @@
 <html>
 <!--
 (C) Copyright 2002-4 Robert Ramey - http://www.rrsd.com . 
-Use, modification and distribution is subject to the Boost Software
-License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+Distributed under the Boost Software License, Version 1.0.
+(See accompanying file LICENSE_1_0.txt or copy at
 http://www.boost.org/LICENSE_1_0.txt)
 -->
 <head>
@@ -32,17 +32,17 @@ 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
-could be done by serializing pointer to the object in question.  Since
-the Serialization library resurrects pointer of the correct type
+could be done by serializing a pointer to the object in question.  Since
+the Serialization library resurrects a pointer of the correct type
 this should be easily implementable.
 <p>
 If a group of function objects were all derived from the
 same polymorphic base class - perhaps via multiple inheritance,
-the the function object effectively becomes a "variable" which
+then the function object effectively becomes a "variable" which
 encapsulates code.
 <p>
 This case study would show how to do this.
@@ -51,19 +51,19 @@ This case study would show how to do this.
 
 Often users want to add their own special functionality to an
 existing archive.  Examples of this are performance enhancements
-for specific types, Adjustment of output syntax for xml archives,
+for specific types, adjustment of output syntax for xml archives,
 and logging/debug output as archives are written and/or read.
-If this functionalty is implemented as an "adaptor" template
-which takes the base class as a template argument, such functionality
-appended to any archive for which that funtionality makes sense.
+If this functionality is implemented as an "adaptor" template
+which takes the base class as a template argument, such functionality could be
+appended to any archive for which that functionality makes sense.
 For example, an adaptor for generating an xml schema could be
-appended to both wide narrow character versions of xml archives.
+appended to both wide and narrow character versions of xml archives.
 <p>
 This case study would show how to make a useful archive adaptor.
 
 <h2><a name="archivehelper"></a>Archive Helpers</h2>
 Some types are not serializable as they stand.  That is - they
-do not fullfill the requirements of the "Serializable Concept".
+do not fulfill the requirements of the "Serializable Concept".
 The iconic example of this is boost::shared_ptr.  Sometimes
 these types could be made serializable by adding code inside
 the library.  Of course, doing that would create a lifetime

doc/overview.html

@@ -2,8 +2,8 @@
 <html>
 <!--
 (C) Copyright 2002-4 Robert Ramey - http://www.rrsd.com . 
-Use, modification and distribution is subject to the Boost Software
-License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+Distributed under the Boost Software License, Version 1.0.
+(See accompanying file LICENSE_1_0.txt or copy at
 http://www.boost.org/LICENSE_1_0.txt)
 -->
 <head>
@@ -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).

doc/performance_status.html

@@ -1,4 +1,10 @@
 <html>
+<!--
+Copyright 2008 Matthias Troyer
+Distributed under the Boost Software License, Version 1.0.
+(See accompanying file LICENSE_1_0.txt or copy at
+http://www.boost.org/LICENSE_1_0.txt)
+-->
 <head>
 <title>Boost Library Status Automatic Test</title>
 </head>
@@ -26,5 +32,10 @@
 <tr><td>performance_iterators</a></td><td align="right">Pass <a href="profile2.txt"><i>Profile</i></a></td></tr>
 <tr><td>performance_iterators_base64</a></td><td align="right">Pass <a href="profile3.txt"><i>Profile</i></a></td></tr>
 </table>
+<hr>
+<p><i>&copy; Copyright 2008 Matthias Troyer.
+Distributed under the Boost Software License, Version 1.0. (See
+accompanying file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+</i></p>
 </body>
 </html>

doc/pimpl.html

@@ -2,8 +2,8 @@
 <html>
 <!--
 (C) Copyright 2002-4 Robert Ramey - http://www.rrsd.com . 
-Use, modification and distribution is subject to the Boost Software
-License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+Distributed under the Boost Software License, Version 1.0.
+(See accompanying file LICENSE_1_0.txt or copy at
 http://www.boost.org/LICENSE_1_0.txt)
 -->
 <head>
@@ -31,7 +31,7 @@ the "Handle Body Idiom". Included in this library is a program called
 <a href="../example/demo_pimpl.cpp" target="demo_impl_cpp">demo_pimpl.cpp</a> 
 which illustrates how this is used. The file 
 <a href="../example/demo_pimpl_A.cpp" target="demo_impl__Acpp">demo_pimpl_A.hpp</a>
-contains the declaration of the a class that hides its implementation
+contains the declaration of the A class that hides its implementation
 by including a pointer to struct B that is only defined as a pointer.
 <pre><code>
 // class whose declaration is hidden by a pointer
@@ -41,12 +41,15 @@ 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>
-Serialization of A requires access to the definition of B in order so it
-is defined in the separately compiled module:
+Serialization of A requires access to the definition of B. But that doesn't mean
+that it requires the this access from the header file.  Since B is a pointer,
+a declaration of class B is sufficient.  The implemenation of the serialization
+of A includes the definition of class B defined in the separately compiled module:
+
 <a href="../example/demo_pimpl_A.cpp" target="demo_impl_A_cpp">demo_pimpl_A.cpp</a>
 by:
 <pre><code>
@@ -56,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;
     }
 };
 
@@ -71,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
@@ -85,12 +88,12 @@ 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.
-There can't be as its not "known" what types of archives
+There can't be as it's not "known" what types of archives
 the serialization is going to be used with.  So these functions are "missing"
 when an attempt to link is made.  The solution is to explicitly instantiate
 serialization code for those archives which are going to be used.  In this
@@ -100,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>
@@ -112,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>

doc/private_base.html

@@ -0,0 +1,170 @@
+<!doctype HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
+<html>
+<!--
+(C) Copyright 2002-4 Robert Ramey - http://www.rrsd.com . 
+Distributed under the Boost Software License, Version 1.0.
+(See accompanying file LICENSE_1_0.txt or copy at
+http://www.boost.org/LICENSE_1_0.txt)
+-->
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
+<link rel="stylesheet" type="text/css" href="../../../boost.css">
+<link rel="stylesheet" type="text/css" href="style.css">
+<title>Serialization - Private Base Classes</title>
+</head>
+<body link="#0000ff" vlink="#800080">
+<table border="0" cellpadding="7" cellspacing="0" width="100%" summary="header">
+  <tr> 
+    <td valign="top" width="300"> 
+      <h3><a href="../../../index.htm"><img height="86" width="277" alt="C++ Boost" src="../../../boost.png" border="0"></a></h3>
+    </td>
+    <td valign="top"> 
+      <h1 align="center">Serialization</h1>
+      <h2 align="center">Private Base Classes</h2>
+    </td>
+  </tr>
+</table>
+<hr>
+In many cases, serialization of private or protected base classes present no special problems.
+This is true for both simple classes and types as well as pointers to those
+classes and types. That is, the following program compiles and runs exactly as one would expect.
+<pre><code>
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// test_private_base.cpp
+
+// (C) Copyright 2009 Eric Moyer - http://www.rrsd.com . 
+// Distributed under the Boost Software License, Version 1.0.
+// (See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+
+#include &lt;fstream&gt;
+#include &lt;boost/config.hpp&gt;
+#if defined(BOOST_NO_STDC_NAMESPACE)
+namespace std{ 
+    using ::remove;
+}
+#endif
+
+#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&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 &amp;rhs) const {
+        return m_i == rhs.m_i;
+    }
+    Base(int i = 0) :
+        m_i(i)
+    {}
+};
+
+class Derived : private Base {
+    friend class boost::serialization::access;
+private:
+    Base &amp; base_cast(){
+        return static_cast&lt;Base &amp;&gt;(*this);
+    }
+    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 &amp;rhs) const {
+        return Base::equals(static_cast&lt;const Base &amp;&gt;(rhs));
+    }
+    Derived(int i = 0) :
+        Base(i)
+    {}
+};
+
+int
+main( int /* argc */, char* /* argv */[] )
+{
+    const char * testfile = boost::archive::tmpnam(NULL);
+
+    // serialize Derived and Base
+    Derived a(1), a1(2);
+    {   
+        test_ostream os(testfile);
+        test_oarchive oa(os);
+        oa &lt;&lt; boost::serialization::make_nvp("a", a);
+    }
+    {
+        test_istream is(testfile, TEST_STREAM_FLAGS);
+        test_iarchive ia(is, TEST_ARCHIVE_FLAGS);
+        ia &gt;&gt; boost::serialization::make_nvp("a", a1);
+    }
+    std::remove(testfile);
+
+    if(a != a1)
+        return 1;
+
+    // serialize Derived and Base
+    Derived *ta = &amp;a;
+    Derived *ta1 = NULL;
+    {   
+        test_ostream os(testfile);
+        test_oarchive oa(os);
+        oa &lt;&lt; boost::serialization::make_nvp("ta", ta);
+    }
+    {
+        test_istream is(testfile, TEST_STREAM_FLAGS);
+        test_iarchive ia(is, TEST_ARCHIVE_FLAGS);
+        ia &gt;&gt; boost::serialization::make_nvp("ta", ta1);
+    }
+    std::remove(testfile);
+    if(*ta != *ta1)
+        return 1;
+
+    return 0;
+}
+</code></pre>
+Difficulties start to occur when the base class is made polymorphic by the designation
+of one or more functions as "virtual".  If a class is polymorphic, the library
+presumes that one will want the ability to serialize a derived class through
+a pointer to the base class.  Included in the macro
+<code>
+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 polymorphic base class.  This code requires
+the ability to invoke
+<code>
+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 
+indicating invalid cast.
+<p>
+In order for this
+code compiler the following alteration must be made:
+<pre><code>
+    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 &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>
+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.
+<hr>
+<p><i>&copy; Copyright <a href="http://www.rrsd.com">Robert Ramey</a> 2015.
+Distributed under the Boost Software License, Version 1.0. (See
+accompanying file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+</i></p>
+</body>
+</html>

doc/rationale.html

@@ -2,15 +2,15 @@
 <html>
 <!--
 (C) Copyright 2002-4 Robert Ramey - http://www.rrsd.com . 
-Use, modification and distribution is subject to the Boost Software
-License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+Distributed under the Boost Software License, Version 1.0.
+(See accompanying file LICENSE_1_0.txt or copy at
 http://www.boost.org/LICENSE_1_0.txt)
 -->
 <head>
 <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
 <link rel="stylesheet" type="text/css" href="../../../boost.css">
 <link rel="stylesheet" type="text/css" href="style.css">
-<title>Seriealization - Rationale</title>
+<title>Serialization - Rationale</title>
 </head>
 <body link="#0000ff" vlink="#800080">
 <table border="0" cellpadding="7" cellspacing="0" width="100%" summary=
@@ -49,7 +49,7 @@ streams even though they have similar syntax rules.
 <ul>
     <li>Archive classes are not kinds of streams though they
     are implemented in terms of streams. This
-    distinction is addressed in <a href="bibliography.html#5">[5]</a> item number item 41 .
+    distinction is addressed in <a href="bibliography.html#5">[5]</a> item number 41.
     <li>We don't want users to insert/extract&nbsp;data
     directly into/from &nbsp;the stream .&nbsp; This could
     create a corrupted archive. Were archives

doc/reference.html

@@ -2,8 +2,8 @@
 <html>
 <!--
 (C) Copyright 2002-4 Robert Ramey - http://www.rrsd.com . 
-Use, modification and distribution is subject to the Boost Software
-License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+Distributed under the Boost Software License, Version 1.0.
+(See accompanying file LICENSE_1_0.txt or copy at
 http://www.boost.org/LICENSE_1_0.txt)
 -->
 <head>

doc/release.html

@@ -2,8 +2,8 @@
 <html>
 <!--
 (C) Copyright 2002-4 Robert Ramey - http://www.rrsd.com . 
-Use, modification and distribution is subject to the Boost Software
-License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+Distributed under the Boost Software License, Version 1.0.
+(See accompanying file LICENSE_1_0.txt or copy at
 http://www.boost.org/LICENSE_1_0.txt)
 -->
 <head>
@@ -29,6 +29,8 @@ http://www.boost.org/LICENSE_1_0.txt)
 </table>
 <hr>
 <dl class="index">
+    <dt><a href="#differences_1_59">Differences from version 1.58</a></dt>
+    <dt><a href="#differences_1_58">Differences from version 1.48</a></dt>
     <dt><a href="#differences_1_45">Differences from version 1.45</a></dt> 
     <dt><a href="#differences_1_43">Differences from version 1.43</a></dt> 
     <dt><a href="#differences_1_42">Differences from version 1.42</a></dt> 
@@ -39,12 +41,28 @@ http://www.boost.org/LICENSE_1_0.txt)
     <dt><a href="#differences_1_35">Differences from version 1.35</a></dt>
     <dt><a href="#differences_1_34">Differences from version 1.34</a></dt> 
     <dt><a href="#differences_1_33">Differences from version 1.33</a></dt> 
-    <dt><a href="#differences_1_32">Differences from version 1.32</a></dt> 
+    <dt><a href="#differences_1_32">Differences from version 1.32</a></dt>
     <dt><a href="#todo">Pending Issues</a></dt>
 </dl>
 As of this writing, there are no known bugs. However, due to compiler/library 
 quirks and or bugs, some tests fail with some combinations of compilers and 
 libraries.
+<h2><a name="differences_1_59"></a>Differences from Boost 1.58</h2>
+<ul>
+<li>Eliminated support for Borland compilers and Microsoft compilers prior to version
+7.1.
+<li>Eliminated support for compilers which do not support Partial Function Template
+Ordering (pfto).
+<li>Added support for "visibility hidden" for GCC compilers.  Shared libraries
+will only expose symbols actually needed rather than all sympols in the library.  This
+should result in smaller shared libraries which are faster to load.
+</ul>
+<h2><a name="differences_1_58"></a>Differences from Boost 1.48</h2>
+<ul>
+<li>Added support for C++11 types such as std::shared_ptr, std::array, and others.
+<li>Implemented the concept of a "Helper" which can be used to implement serialization of types which are otherwise not serializable."
+<li>Made library compatible with C++11,  Compatibility with C++03 has been maintained.
+</ul>
 <h2><a name="differences_1_45"></a>Differences from Boost 1.45</h2>
 Since the release of version 1.42, it has been discovered that binary
 archives created by versions 1.42-1.44 cannot always be read by the

doc/serialization.html

@@ -2,8 +2,8 @@
 <html>
 <!--
 (C) Copyright 2002-4 Robert Ramey - http://www.rrsd.com . 
-Use, modification and distribution is subject to the Boost Software
-License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+Distributed under the Boost Software License, Version 1.0.
+(See accompanying file LICENSE_1_0.txt or copy at
 http://www.boost.org/LICENSE_1_0.txt)
 -->
 <head>
@@ -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>
@@ -136,7 +136,7 @@ be made accessible to the serialization library by including:
 friend class boost::serialization::access;
 </code></pre>
 in the class definition.  This latter method should be preferred over the option
-of making member function public. This will prevent serialization functions from 
+of making the member function public. This will prevent serialization functions from 
 being called from outside the library.  This is almost certainly an error.  Unfortunately,
 it may appear to function but fail in a way that is very difficult to find.
 <p>
@@ -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 
@@ -196,7 +196,7 @@ templates can be in any of the following namespaces:
 Note that, at first glance, this suggestion may seem to be wrong for compilers which implement
 two phase lookup.  In fact, the serialization library used a perhaps overly clever 
 method to support this rule even for such compilers.  Those with an interest in studying
-this furter will find more information in 
+this further will find more information in 
 <a target=serialization_hpp href="../../../boost/serialization/serialization.hpp">serialization.hpp</a>
 
 <h3><a name="classmembers">Serialization of Class Members</a></h3>
@@ -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,14 +255,14 @@ 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
 of serialization. 
 
 <h4><a name="templates"></a>Templates</h4>
-Implementation serialization for templates is exactly the same process 
+Implementation of serialization for templates is exactly the same process 
 as for normal classes and requires no additional considerations.  Among
 other things, this implies that serialization of compositions of templates
 are automatically generated when required if serialization of the 
@@ -273,7 +273,7 @@ class <code style="white-space: normal">my_t</code>, then serialization for
 <code style="white-space: normal">std::list&lt; boost::shared_ptr&lt; my_t&gt; &gt;</code> is already available
 for use.
 <p>
-See for an example that shows how this idea might be implemented for your own
+For an example that shows how this idea might be implemented for your own
 class templates, see
 <a href="../example/demo_auto_ptr.cpp" target="demo_auto_ptr.cpp">
 demo_auto_ptr.cpp</a>.
@@ -434,7 +434,7 @@ is preferred.  The key to the serialization implementation is that objects are s
 and loaded in exactly the same sequence.  Using the <code style="white-space: normal">&amp;</code> 
 operator and <code style="white-space: normal">serialize</code>
 function guarantees that this is always the case and will minimize the
-occurence of hard to find errors related to synchronization of 
+occurrence of hard to find errors related to synchronization of 
 <code style="white-space: normal">save</code> and <code style="white-space: normal">load</code> 
 functions.
 <p>
@@ -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>
 
@@ -482,7 +482,7 @@ Loading a pointer:
 <ol>
     <li>read a tag from the archive.
     <li>determine the type of object to be created
-    <li>if the object has already been loaded, return it's address.
+    <li>if the object has already been loaded, return its address.
     <li>otherwise, create a new instance of the object
     <li>read the data back in using the operators described above
     <li>return the address of the newly created object.
@@ -496,7 +496,7 @@ and <code style="white-space: normal">&gt;&gt;</code> operators
     <li>Loading the same pointer object multiple times
     results in only one object being created, thereby replicating
     the original pointer configuration. 
-    <li>Structures such as collections of polymorphic pointers,
+    <li>Structures, such as collections of polymorphic pointers,
     are handled with no special effort on the part of users of this library.
 </ul>
 Serialization of pointers of derived types through a pointer to the
@@ -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,10 +789,10 @@ 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),
+            static_cast&lt;derived *&gt;(NULL),
             static_cast&lt;base *&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);
@@ -907,11 +907,11 @@ rather than
 <pre><code>
 #include &lt;list&gt;
 </code></pre>
-Since the former includes the latter, this all that is necessary.
+Since the former includes the latter, this is all that is necessary.
 The same holds true for all STL collections as well as templates
 required to support them (e.g. <code style="white-space: normal">std::pair</code>).
 <p>
-As of this writing, the library contains serialization of the following boost clases:
+As of this writing, the library contains serialization of the following boost classes:
 <ul>
   <li>optional
   <li>variant
@@ -919,6 +919,7 @@ As of this writing, the library contains serialization of the following boost cl
   <li>shared_ptr
   <li>auto_ptr (demo)
 </ul>
+C++17 <code style="white-space: normal">std::variant is supported as well</code>.
 Others are being added to the list so check the boost files section and headers for
 new implementations!
 <hr>

doc/shared_ptr.html

@@ -2,8 +2,8 @@
 <html>
 <!--
 (C) Copyright 2002-4 Robert Ramey - http://www.rrsd.com . 
-Use, modification and distribution is subject to the Boost Software
-License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+Distributed under the Boost Software License, Version 1.0.
+(See accompanying file LICENSE_1_0.txt or copy at
 http://www.boost.org/LICENSE_1_0.txt)
 -->
 <head>
@@ -92,36 +92,36 @@ 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>
-corresponding to a particular object are created, the will all point
+corresponding to a particular object are created, they will all point
 to the same object.
 <p>
 Since <code style="white-space: normal">sp_counted_base_impl&lt;P, D&gt;</code> is derived from 
@@ -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);
 }
@@ -150,7 +150,7 @@ inline void serialize(
 ){
 }
 </code></pre>
-It would seem we're done, running the test program,
+It would seem we're done, but running the test program,
 <a href="../example/demo_shared_ptr.cpp" target="demo_shared_ptr_cpp">
 demo_shared_ptr.cpp
 </a>,
@@ -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.
@@ -219,9 +219,9 @@ shared pointers:
 BOOST_SHARED_POINTER_EXPORT(T)
 BOOST_SHARED_POINTER_EXPORT_GUID(T, K)
 </pre></code>
-These are specialize versions of the macros used for exporting classes serialized through raw pointers.
+These are specialized versions of the macros used for exporting classes serialized through raw pointers.
 <p>
-Clearly, complete, correct and exception safe serialization of smart pointers is going to
+Clear, complete, correct and exception safe serialization of smart pointers is going to
 be a challenge.  I hope that this implementation provides a useful
 starting point for such an effort.
 <hr>

doc/shared_ptr2.html

@@ -2,8 +2,8 @@
 <html>
 <!--
 (C) Copyright 2002-4 Robert Ramey - http://www.rrsd.com . 
-Use, modification and distribution is subject to the Boost Software
-License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+Distributed under the Boost Software License, Version 1.0.
+(See accompanying file LICENSE_1_0.txt or copy at
 http://www.boost.org/LICENSE_1_0.txt)
 -->
 <head>
@@ -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.

doc/simple_log.html

@@ -2,8 +2,8 @@
 <html>
 <!--
 (C) Copyright 2002-10 Robert Ramey - http://www.rrsd.com .
-Use, modification and distribution is subject to the Boost Software
-License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+Distributed under the Boost Software License, Version 1.0.
+(See accompanying file LICENSE_1_0.txt or copy at
 http://www.boost.org/LICENSE_1_0.txt)
 -->
 <head>
@@ -25,7 +25,7 @@ http://www.boost.org/LICENSE_1_0.txt)
   </tr>
 </table>
 <hr>
-The purpose of this example help clarify the usage of the
+The purpose of this example is to help clarify the usage of the
 <a href="archives.html"><strong>Archive Concept</strong></a> 
 so that one can implement his own archive classes.  
 <a href="../example/simple_log_archive.hpp" target="simple_archive_hpp">
@@ -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

doc/singleton.html

@@ -2,8 +2,8 @@
 <html>
 <!--
 (C) Copyright 2002-4 Robert Ramey - http://www.rrsd.com . 
-Use, modification and distribution is subject to the Boost Software
-License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+Distributed under the Boost Software License, Version 1.0.
+(See accompanying file LICENSE_1_0.txt or copy at
 http://www.boost.org/LICENSE_1_0.txt)
 -->
 <head>
@@ -42,16 +42,16 @@ names to types and tables which relate base classes to derived
 classes.  Construction, destruction and usage of these variables
 requires consideration of the following issues:
 <ul>
-  <li>Some static data variables and constants  entries refer to others.  
+  <li>Some static data variable and constant entries refer to others.  
   The sequence of initialization cannot be arbitrary but must be in proper
   sequence.</li>
-  <li>A number of static variables aren't referred explicitly and, without
+  <li>A number of static variables aren't referred to explicitly and, without
   special precautions, will be stripped by most code optimizers</li>
   <li>Many of these variables are created by templates and special care must
   be taken to be sure that they are instantiated</li>
   <li>In a multi-threading system, its possible that these static variables
   will be accessed concurrently by separate threads.  This would create a
-  race condition with unpredictabe behavior</li>
+  race condition with unpredictable behavior</li>
 </ul>
 This singleton class addresses all of the above issues.
 
@@ -61,7 +61,7 @@ This singleton implementation has the following features:
   <li>
     Any instance will be constructed before any attempt is made to access it.</li>
   <li>
-    Any instance created with a template is guarenteed to be instantiated.
+    Any instance created with a template is guaranteed to be instantiated.
   <li>
     Regardless of whether or not an instance has been explicitly
     referred to, it will not be stripped by the optimizer when the
@@ -70,16 +70,16 @@ This singleton implementation has the following features:
     All instances are constructed before 
     <code style="white-space: normal">main</code> is called
     regardless of where they might be referenced within the program.
-    In a multi-tasking system, this guarentees that there will be no 
+    In a multi-tasking system, this guarantees that there will be no 
     race conditions during the construction of any instance.  No
-    thread locking is required to guarentee this.
+    thread locking is required to guarantee this.
   <li>
     The above implies that any <code style="white-space: normal">const</code>
     instances are thread-safe during the whole program.  Again, no
     thread locking is required.
   <li>
     If a mutable instance is created, and such an instance is modified
-    after main is called in a mult-threading system, there exists
+    after main is called in a multi-threading system, there exists
     the possibility that a race condition will occur.  The serialization
     library takes care that in the few places where a mutable
     singleton is required, it is not altered after 
@@ -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,15 +139,15 @@ 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 guarentees that only one instance of 
+Since the library guarantees that only one instance of 
 <a target="singleton.hpp" href = "../../../boost/serialization/singleton.hpp">
 <code style="white-space: normal">
 singleton&lt;T&gt;
 </code>
 </a> 
-and all accesss is through the above static interface
+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.
@@ -156,7 +156,7 @@ the functional equivalent of
 There are at least two different ways to use this class template.
 Both are used in the serialization library.
 <p>
-The first way is illustrated by and excerpt from the file
+The first way is illustrated by an excerpt from the file
 <code style="white-space: normal"><a target="extended_type_info" href="../src/extended_type_info.cpp">extended_type_info.cpp</a></code>.
 which contains the following code:
 
@@ -171,9 +171,9 @@ extended_type_info::key_register(const char *key) {
 }
 </code></pre>
 Just by referring to the singleton instance anywhere in the program
-will guarentee that one and only one instance for the specified
+will guarantee that one and only one instance for the specified
 type (<code style="white-space: normal">ktmap</code> in this example) 
-will exist throughout the program.  There is no need for anyother
+will exist throughout the program.  There is no need for any other
 declaration or definition.
 <p>
 A second way is to use 
@@ -216,7 +216,7 @@ extended_type_info_typeid&lt;T&gt;::get_const_instance()
 </code></pre>
 
 Again, including one or more of the above statements anywhere
-in the program will guarentee that one and only one instance
+in the program will guarantee that one and only one instance
 is created and referred to.
 
 <h3><a name="multithreading">Multi-Threading</a></h3>
@@ -224,10 +224,9 @@ This singleton CAN be safely used in multi-threading applications if one
 is careful follow a simple rule:
 <p>
 <b>Do not call get_mutable_instance when more than one thread is running!</b>
-<'>
 All singletons used in the serialization library follow this rule.  
 In order to help detect accidental violations of this rule there
-exists an singleton lock/unlock functions.
+exist singleton lock/unlock functions.
 <pre><code>
 void boost::serialization::singleton_module::lock();
 void boost::serialization::singleton_module::unlock();
@@ -241,9 +240,9 @@ alteration of static variables before
 <code style="white-space: normal">main</code> is called. 
 The <code style="white-space: normal">lock()</code> and
 <code style="white-space: normal">unlock()</code> are "global"
-in they affect ALL the singletons defined by this template.
+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>

doc/smart_cast.html

@@ -2,8 +2,8 @@
 <html>
 <!--
 (C) Copyright 2002-4 Robert Ramey - http://www.rrsd.com . 
-Use, modification and distribution is subject to the Boost Software
-License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+Distributed under the Boost Software License, Version 1.0.
+(See accompanying file LICENSE_1_0.txt or copy at
 http://www.boost.org/LICENSE_1_0.txt)
 -->
 <head>
@@ -30,23 +30,23 @@ 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 not polymorphic
+      <li>required if neither T nor U are polymorphic
       <li>permitted in other cases.
-      <li>fails to detect erroneas 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
       <li>prohibited in other cases.
-      <li>throws exception on detecting erroneas casts of polymorphic pointers/references
+      <li>throws exception on detecting erroneous casts of polymorphic pointers/references
           at runtime.
       <li>permits "cross casting"
       <li>cannot optimise inline virtual functions at compile time.
@@ -91,14 +91,14 @@ template&lt;class T&gt;
 bool is_storable(T &amp;t){
     // what type of cast to use here?
 
-    // this fails at compiler time when T == base2
+    // this fails at compile time when T == base2
     // return static_cast&lt;base1 &amp;&gt;(t).is_storable();
 
-    // this fails at compiler time when T == top
+    // this fails at compile time when T == top
     // otherwise it works but cannot optimize inline function call
     // return dynamic_cast&lt;base1 &amp;&gt;(t).is_storable();
 
-    // this always works - and is guarenteed to generate the fastest code !
+    // this always works - and is guaranteed to generate the fastest code !
     return (boost::smart_cast_reference&lt;base1 &amp;&gt;(t)).is_storable();
 }
 
@@ -121,27 +121,27 @@ The serialization library includes a mix of classes which use
 both static polymorphism (<strong>CRTP</strong>) and dynamic
 polymorphism via virtual functions.  <code style="white-space: normal">smart_cast</code> 
 was written to address the more problematic manifestations of the
-situation exmplified above.
+situation exemplified above.
 
 <h3>Usage</h3>
 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 the the following special syntax
+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>
 <code style="white-space: normal">smart_cast</code> can be used only on compilers that support partial
-template specialization or on types for which have be specified with the
+template specialization or on types for which the
 macro <code style="white-space: normal">
 BOOST_BROKEN_COMPILER_TYPE_TRAITS_SPECIALIZATION(&lt;type&gt;)</code>
 has been applied.

doc/special.html

@@ -2,8 +2,8 @@
 <html>
 <!--
 (C) Copyright 2002-4 Robert Ramey - http://www.rrsd.com . 
-Use, modification and distribution is subject to the Boost Software
-License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+Distributed under the Boost Software License, Version 1.0.
+(See accompanying file LICENSE_1_0.txt or copy at
 http://www.boost.org/LICENSE_1_0.txt)
 -->
 <head>
@@ -28,6 +28,7 @@ http://www.boost.org/LICENSE_1_0.txt)
 <dl class="page-index">
   <dt><a href="#objecttracking">Object Tracking</a>
   <dt><a href="#classinfo">Class Information</a>
+  <dt><a href="#helpersupport">Helper Support</a>
   <dt><a href="#portability">Archive Portability</a>
   <dl class="page-index">
     <dt><a href="#numerics">Numerics</a>
@@ -53,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];
@@ -96,11 +97,11 @@ and a likely source of very subtle bugs.
 Unfortunately, implementation issues currently prevent the detection of this kind of
 error when the data item is wrapped as a name-value pair.
 <p>
-A similar problem can occur when different objects are loaded to and address
+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;
@@ -111,20 +112,20 @@ void load(boost::basic_oarchive  &amp; ar, const unsigned int version) const
 </code></pre>
 In this case, the address of <code>x</code> is the one that is tracked rather than
 the address of the new item added to the set.  Left unaddressed
-this will break the features that depend on tracking such as loading object through a pointer.
+this will break the features that depend on tracking such as loading an object through a pointer.
 Subtle bugs will be introduced into the program.  This can be
 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>
@@ -136,7 +137,7 @@ values are duplicated, overhead associated with object tracking can
 be eliminated by setting the object tracking class serialization trait
 appropriately.
 <p>
-By default, data types designated primitive by 
+By default, data types designated primitive by the
 <a target="detail" href="traits.html#level">Implementation Level</a>
 class serialization trait are never tracked. If it is desired to
 track a shared primitive object through a pointer (e.g. a
@@ -155,6 +156,96 @@ redundant save/load operations.
 BOOST_CLASS_TRACKING(my_virtual_base_class, boost::serialization::track_always)
 </code></pre>
 
+<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 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.
+Without maintaining such a table, the shared_ptr would be a serializable type.
+<p>
+To implement this facility, one declares a <i>helper object</i>
+associated to the current archive that can be used to store contextual
+information relevant to the particular type serialization algorithm.
+
+<pre><code>
+template&lt;class T&gt;
+class shared_ptr
+{
+   ...
+};
+
+BOOST_SERIALIZATION_SPLIT_FREE(shared_ptr)
+
+class shared_ptr_serialization_helper
+{
+  // table of previously loaded shared_ptr
+  // lookup a shared_ptr from the object address
+  shared_ptr&lt;T&gt; lookup(const T *);
+  // insert a new shared_ptr
+  void insert&lt;shared_ptr&lt;T&gt; &gt;(const shared_ptr&lt;T&gt; *);
+};
+
+namespace boost {
+namespace serialization {
+
+template&lt;class Archive&gt;
+void save(Archive &amp; ar, const shared_ptr &amp; x, const unsigned int /* version */)
+{
+    // save shared ptr
+    ...
+}
+
+template&lt;class Archive&gt;
+void load(Archive &amp; ar, shared_ptr &amp; x, const unsigned int /* version */)
+{
+    // get a unique identifier.  Using a constant means that all shared pointers
+    // are held in the same set.  Thus we detect handle multiple pointers to the
+    // same value instances in the archive.
+    const void * shared_ptr_helper_id = 0;
+
+    shared_ptr_serialization_helper &amp; hlp =
+        ar.template get_helper&lt;shared_ptr_serialization_helper&gt;(helper_instance_id);
+
+    // load shared pointer object
+    ...
+
+    shared_ptr_serialization_helper &amp; hlp =
+        ar.template get_helper&lt;shared_ptr_serialization_helper&gt;(shared_ptr_helper_id);
+
+    // look up object in helper object
+    T * shared_object hlp.lookup(...);
+
+    // if found, return the one from the table
+
+    // load the shared_ptr data
+    shared_ptr&lt;T&gt; sp = ...
+
+    // and add it to the table
+    hlp.insert(sp);
+    // implement shared_ptr_serialization_helper load algorithm with the aid of hlp
+}
+
+} // namespace serialization
+} // namespace boost
+</code></pre>
+<code style="white-space: normal">get_helper&lt;shared_ptr_serialization_helper&gt;();</code>
+creates a helper object associated to the archive the first time it is invoked;
+subsequent invocations return a reference to the object created in the first
+place, so that <code style="white-space: normal">hlp</code> can effectively be
+used to store contextual information persisting through the serialization
+of different <code style="white-space: normal">complex_type</code> objects on
+the same archive.
+
+<p>
+Helpers may be created for saving and loading archives.
+The same program might have several different helpers or the same helper instantiated
+separately from different parts of the program.  This is what makes the helper_instance_id
+necessary.  In principle it could be any unique integer. In practice it seems
+easiest to use the address of the serialization function which contains it. The
+above example uses this technique.
+
 <h3><a name="classinfo">Class Information</a></h3>
 By default, for each class serialized, class information is written to the archive.
 This information includes version number, implementation level and tracking
@@ -176,7 +267,7 @@ in this manner comes at a cost.  Once archives are released to users, the
 class serialization traits cannot be changed without invalidating the old
 archives.  Including the class information in the archive assures us
 that they will be readable in the future even if the class definition
-is revised.  A light weight structure such as display pixel might be
+is revised.  A light weight structure such as a display pixel might be
 declared in a header like this:
 
 <pre><code>
@@ -204,14 +295,14 @@ BOOST_CLASS_TRACKING(pixel, boost::serialization::track_never)
 </code></pre>
 
 <h3><a name="portability">Archive Portability</a></h3>
-Several archive classes create their data in the form of text or portable a binary format.  
-It should be possible to save such an of such a class on one platform and load it on another.  
+Several archive classes create their data in the form of text or a portable binary format.  
+It should be possible to save such a class on one platform and load it on another.  
 This is subject to a couple of conditions.
 <h4><a name="numerics">Numerics</a></h4>
 The architecture of the machine reading the archive must be able hold the data
 saved.  For example, the gcc compiler reserves 4 bytes to store a variable of type
 <code style="white-space: normal">wchar_t</code> while other compilers reserve only 2 bytes.  
-So its possible that   a value could be written that couldn't be represented by the loading program.  This is a
+So it's possible that   a value could be written that couldn't be represented by the loading program.  This is a
 fairly obvious situation and easily handled by using the numeric types in
 <a target="cstding" href="../../../boost/cstdint.hpp">&lt;boost/cstdint.hpp&gt;</a>
 <P>
@@ -231,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 ...
 };
 
 ...
@@ -240,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>
@@ -288,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
@@ -296,7 +387,7 @@ not wrapped in a in a <a target="detail" href="wrappers.html#nvp">name-value pai
 be trapped at compile time. The system is implemented in such a way that for other archive classes,
 just the value portion of the data is serialized. The name portion is discarded during compilation.
 So by always using <a target="detail" href="wrappers.html#nvp">name-value pairs</a>, it will
-be guarenteed that all data can be serialized to all archive classes with maximum efficiency.
+be guaranteed that all data can be serialized to all archive classes with maximum efficiency.
 
 <h3><a name="export">Exporting Class Serialization</a></h3>
 <a target="detail" href="traits.html#export">Elsewhere</a> in this manual, we have described 
@@ -311,7 +402,7 @@ requirement.
 In C++, usage of code not explicitly referred to is implemented via
 virtual functions.  Hence, the need for export is implied by the 
 usage of a derived class that is manipulated via a pointer or
-reference to it's base class.
+reference to its base class.
 
 <p>
 <code style="white-space: normal">BOOST_CLASS_EXPORT</code> in the same
@@ -323,7 +414,7 @@ archive class headers are included, then no code will be instantiated.
 <p>
 Note that the implemenation of this functionality requires
 that the <code style="white-space: normal">BOOST_CLASS_EXPORT</code>
-macro appear <b>after</b> and the inclusion of any archive
+macro appear <b>after</b> the inclusion of any archive
 class headers for which code is to be instantiated.
 So, code that uses <code style="white-space: normal">BOOST_CLASS_EXPORT</code>
 will look like the following:
@@ -336,9 +427,9 @@ will look like the following:
 BOOST_CLASS_EXPORT(a)
 ... // other class headers and exports
 </code></pre>
-This will be true regardless of whether the is part
+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>
@@ -360,19 +451,19 @@ 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 catastophic error, the library traps ALL serializations through
-a pointer to a polymorphic which are not exported or otherwise registered.
+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. 
 
 <p>
 Note that the implementation of this functionality depends upon vendor
-specific extensions to the C++ language.  So, there is no guarenteed portability
+specific extensions to the C++ language.  So, there is no guaranteed portability
 of programs which use this facility.  However, all C++ compilers which
 are tested with boost provide the required extensions.  The library
 includes the extra declarations required by each of these compilers.
@@ -382,7 +473,7 @@ these extensions or something equivalent.
 <h3><a name="static_libraries">Static Libraries and Serialization</a></h3>
 Code for serialization of data types can be saved in libraries
 just as it can for the rest of the type implementation.
-This works well, and can save huge amount of compilation time.
+This works well, and can save a huge amount of compilation time.
 <ul>
 <li>Only compile serialization definitions in the library.
 <li>Explicitly instantiate serialization code for ALL
@@ -416,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>
@@ -435,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 
@@ -458,45 +549,45 @@ guidelines:
   <li>Don't include <code>inline</code> code in classes used in DLLS.
 This will generate duplicate code in the DLLS and mainline. This
 needlessly duplicates code.  Worse, it makes is possible for 
-different versions of the same code exist simultaneously.  This
+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 module being referred to
-might be explictly unloaded which would (hopefully) result in
+Finally, it opens the possibility that a module being referred to
+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){
 	...
 }
 
-BOOST_EXPORT_CLASS_IMPLEMENT(my_class)
+BOOST_CLASS_EXPORT_IMPLEMENT(my_class)
 
 #include &lt;boost/archive/text_oarchive&gt;
-#include &lt;boost/archive/text_iarchive&lt;
-template myclass::serialize(boost::archive::text_oarchive & ar, const unsigned int version);
-template myclass::serialize(boost::archive::text_iarchive & ar, const unsigned int version);
+#include &lt;boost/archive/text_iarchive&gt;
+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
 required in only one place.  The library does not detect this type of error for you.
-  <li>If DLLS are to be loaded an unloaded explicitly (e.g. using <code>dlopen</code> in *nix or 
+  <li>If DLLS are to be loaded and unloaded explicitly (e.g. using <code>dlopen</code> in *nix or 
 <code>LoadLibrary</code> in Windows).  Try to arrange that they are unloaded in the reverse
-sequence.  This should guarentee that problems are avoided even if the
-above guidline hasn't been followed.
+sequence.  This should guarantee that problems are avoided even if the
+above guideline hasn't been followed.
 
 </ul>
 
 <h3><a name="plugins">Plugins</a></h3>
 In order to implement the library, various facilities for runtime
-manipulation of types are runtime were required.  These
+manipulation of types at runtime were required.  These
 are <a target="detail" href="extended_type_info.html"><code>extended_type_info</code></a>
 for associating classes with external identifying strings (<b>GUID</b>)
 and <a target="detail" href="void_cast.html"><code>void_cast</code></a>
@@ -526,33 +617,33 @@ BOOST_CLASS_EXPORT(a)
 ... // other class headers and exports
 </code></pre>
 
-With this in place, one can construct, serialize and destroy
-about which only is know the <b>GUID</b> and a base class.
+With this in place, one can construct, serialize and destroy a class
+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 
-thread concurrently writing/reading from/to a single open archive instance.
-The library implementation presumes that the application avoids such an situtation.
+threads concurrently writing/reading from/to a single open archive instance.
+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) 
 completely independent from any other archive instance.  The only shared 
-information are some type tables which have been implemented using a 
+information is some type tables which have been implemented using a 
 lock-free thread-safe 
 <a target="detail" href="singleton.html">
 <code style="white-space: normal">singleton</code>
 </a>
 described elsewhere in this documentation.
 <p>
-This singleton implementation guarentees that all of this shared
+This singleton implementation guarantees that all of this shared
 information is initialized when the code module which contains
-them is loaded.  The serialization library takes care to
+it is loaded.  The serialization library takes care to
 ensure that these data structures are not subsequently
 modified. The only time there could be a problem would
 be if code is loaded/unloaded while another task is
 serializing data.  This could only occur for types whose 
-serialization is implemented in a dynamically loaded/unload DLL
+serialization is implemented in a dynamically loaded/unloaded DLL
 or shared library.  So if the following is avoided:
 <ul>
     <li>Accessing the same archive instance from different tasks.

doc/state_saver.html

@@ -2,8 +2,8 @@
 <html>
 <!--
 (C) Copyright 2002-4 Robert Ramey - http://www.rrsd.com . 
-Use, modification and distribution is subject to the Boost Software
-License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+Distributed under the Boost Software License, Version 1.0.
+(See accompanying file LICENSE_1_0.txt or copy at
 http://www.boost.org/LICENSE_1_0.txt)
 -->
 <head>
@@ -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

doc/static_warning.html

@@ -2,8 +2,8 @@
 <html>
 <!--
 (C) Copyright 2002-4 Robert Ramey - http://www.rrsd.com . 
-Use, modification and distribution is subject to the Boost Software
-License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+Distributed under the Boost Software License, Version 1.0.
+(See accompanying file LICENSE_1_0.txt or copy at
 http://www.boost.org/LICENSE_1_0.txt)
 -->
 <head>

doc/strong_typedef.html

@@ -2,8 +2,8 @@
 <html>
 <!--
 (C) Copyright 2002-4 Robert Ramey - http://www.rrsd.com . 
-Use, modification and distribution is subject to the Boost Software
-License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+Distributed under the Boost Software License, Version 1.0.
+(See accompanying file LICENSE_1_0.txt or copy at
 http://www.boost.org/LICENSE_1_0.txt)
 -->
 <head>
@@ -78,7 +78,7 @@ type but still of distinct type.
 
 <h3>Implemenation</h3>
 <code style="white-space: normal">BOOST_STRONG_TYPEDEF</code> is a macro
-which generates a class named "name" wraps and instance of its
+which generates a class named "name" which wraps an instance of its
 primitive type and provides appropriate conversion operators in order
 to make the new type substitutable for the one that it wraps.
 

doc/style.css

@@ -9,7 +9,7 @@ pre{
 
 /*
 (C) Copyright 2008 Robert Ramey - http://www.rrsd.com . 
-Use, modification and distribution is subject to the Boost Software
-License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+Distributed under the Boost Software License, Version 1.0.
+(See accompanying file LICENSE_1_0.txt or copy at
 http://www.boost.org/LICENSE_1_0.txt)
 */

doc/todo.html

@@ -2,8 +2,8 @@
 <html>
 <!--
 (C) Copyright 2002-4 Robert Ramey - http://www.rrsd.com . 
-Use, modification and distribution is subject to the Boost Software
-License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+Distributed under the Boost Software License, Version 1.0.
+(See accompanying file LICENSE_1_0.txt or copy at
 http://www.boost.org/LICENSE_1_0.txt)
 -->
 <head>
@@ -43,13 +43,12 @@ Currently there is a portable binary archive in the examples directory.
 It is not regularly submitted to the exhaustive boost testing regimen
 but it is tested occasionally and has been used in production code.
 <p>
-Its missing the following:
+It's missing the following:
 <ul>
   <li>Addition of portable floating point types.  This is not trivial.  In addition to
   handling floating point types of varying sizes, It requires
   handling invalid floating point numbers (NaNs) in a portable manner.
-  <li>Some way to test archive portability within the Boost testing regimen.
-  <li>Integration into the Boost testing similar to the other archive classes.
+  <li>Integration into the Boost testing regimen similar to the other archive classes.
 </ul>
 
 <h2><a name="performancetesting"></a>Performance Testing and Profiling</h2>
@@ -67,13 +66,13 @@ which shows the results of each test and links to the actual
 profile.
 <p>
 The first thing I did was include some of the serialization library tests.
-It became immediatly apparent that these tests were totally unsuitable
+It became immediately apparent that these tests were totally unsuitable
 for performance testing and that new tests needed to be written for this 
 purpose.  These tests would highlight the location of any performance
 bottlenecks in the serialization library.  Whenever I've subjected my
-code in the past to this type of analysis, I've always been suprised
+code in the past to this type of analysis, I've always been surprised
 to find bottlenecks in totally unanticipated places and fixing those
-has always lead to large improvements in performance.  I expect that
+has always led to large improvements in performance.  I expect that
 this project would have a huge impact on the utility of the serialization
 library.
 
@@ -81,10 +80,10 @@ library.
 
 It has been suggested that a useful feature of the library would be
 the ability to create "older versions" of archives.  Currently,
-the library permits one make programs that are guarenteed
+the library permits one to make programs that are guaranteed
 the ability to load archives with classes of a previous version. 
-But there is not way to save classes in accordance with a
-previous version.  At first I dismissed this a a huge project
+But there is no way to save classes in accordance with a
+previous version.  At first I dismissed this as a huge project
 with small demand.  A cursory examination of the code revealed
 that this would not be very difficult.  It would require some
 small changes in code and some additional tests.  Also it
@@ -101,7 +100,7 @@ to use the library without it.  The example used for testing is an
 <code style="white-space: normal">extended_typeinfo</code> 
 implemenation which presumes that all classes names have been exported. 
 So, to make this library compatible for platforms without RTTI, 
-a set of tests, examples and new manual section would have to be created
+a set of tests, examples and new manual section would have to be created.
 
 <hr>
 <p>Revised 1 November, 2008 

doc/traits.html

@@ -2,8 +2,8 @@
 <html>
 <!--
 (C) Copyright 2002-4 Robert Ramey - http://www.rrsd.com . 
-Use, modification and distribution is subject to the Boost Software
-License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+Distributed under the Boost Software License, Version 1.0.
+(See accompanying file LICENSE_1_0.txt or copy at
 http://www.boost.org/LICENSE_1_0.txt)
 -->
 <head>
@@ -38,7 +38,7 @@ http://www.boost.org/LICENSE_1_0.txt)
   <dt><a href="#compiletime_messages">Compile Time Warnings and Errors</a>
 </dl>
 Serialization of data depends on the type of the data.  For example, for
-primitive types such as an <code style="white-space: normal">int</code>, it wouldn't make sense to save
+primitive types such as <code style="white-space: normal">int</code>, it wouldn't make sense to save
 a version number in the archive. Likewise, for a data type that is never
 serialized through a pointer, it would (almost) never make sense to track
 the address of objects saved to/loaded from the archive as it will never
@@ -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.
@@ -232,12 +232,12 @@ statisfactory for our purposes for the following reasons:
   <li>There might be classes locally defined in different code modules
   that have the same name. 
   <li>There might be classes with different names that we want to
-  consider equivalent for purposes of of serialization.
+  consider equivalent for purposes of serialization.
 </ul>
 <p>
 So in the serialization library, this is addressed by invoking
 <code style="white-space: normal">BOOST_CLASS_EXPORT_KEY2(my_class, "my_class_external_identifier")</code>
-in the header file which declares he class.
+in the header file which declares the class.
 In a large majority of applications, the class name works just fine
 for the external identifier string so the following short cut is
 defined -
@@ -248,9 +248,9 @@ programs which do not use DLLS, one can specify
 <code style="white-space: normal">BOOST_CLASS_EXPORT(my_class)</code>
 or
 <code style="white-space: normal">BOOST_CLASS_EXPORT_GUID(my_class, "my_class_external_identifier")</code>
-in either he declaration header or definition.  These macros
-expand to invocation of the of both of the macros described above.
-<i>(<b>GUID</b> stands for <b>G</b>lobally <b>U</b>nique <b>ID</b>entfier.)</i>
+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>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>
@@ -267,7 +267,7 @@ in more than one module (or DLL).
 
 <h3><a name="abstract">Abstract</a></h3>
 When serializing an object through a pointer to its base class,
-the library needs to determine whether or not the bas is abstract
+the library needs to determine whether or not the base is abstract
 (i.e. has at least one virtual function).  The library uses the
 type trait macro <code style="white-space: normal">BOOST_IS_ABSTRACT(T)</code>
 to do this.  Not all compilers support this type trait and corresponding
@@ -333,10 +333,9 @@ This is illustrated by the test program
 Other implementations are possible and might be necessary for
 certain special cases.
 
-version.hpp</a>.  
 <h3><a name="wrappers">Wrappers</a></h3>
-Archives need to treat wrappers diffently from other types since, for example,
-they usually are non-const object while output archives require that any
+Archives need to treat wrappers differently from other types since, for example,
+they usually are non-const objects while output archives require that any
 serialized object (with the exception of a wrapper) be const. 
 
 This header file <a href="../../../boost/serialization/wrapper.hpp">wrapper.hpp</a>
@@ -388,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>
@@ -471,7 +470,7 @@ struct tracking_level&lt;nvp&lt;T&gt; &gt;
 #endif
 </code></pre>
 This can be problematic when one wants to make his code <strong>and archives</strong>
-portable to other platforms.  It means the she objects will be serialized differently
+portable to other platforms.  It means the objects will be serialized differently
 depending on the platform used.  This implies that objects saved from one platform
 won't be loaded properly on another.  In other words, archives won't be portable.
 <p>
@@ -517,19 +516,19 @@ 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.  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. The are generated in a
-compiler dependent way manner which should show an chain of instantiation
+or warnings (BOOST_STATIC_WARNING) are generated. They are generated in a
+compiler dependent manner which should show a chain of instantiation
 to the point where the error/warning is detected.  Without this capability,
 it would be very hard to track down errors or unexpected behavior in library
-usage.  Here is list of the conflicts trapped:
+usage.  Here is a list of the conflicts trapped:
 
 <dl>
 <dt><h2><a name="object_level">object_level</a> - error</h2></dt>
 <dd>
 This error traps attempts to serialize types whose
-implentation level is set to non_serializable.
+implementation level is set to non_serializable.
 </dd>
 <dt><h2><a name="object_versioning">object_versioning</a> - error</h2></dt>
 <dd>
@@ -562,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".
@@ -618,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; 
     } 
 }; 
@@ -631,10 +630,10 @@ 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, 
-its discovered 
-  that programmer (3) accidently broke programmer(2)'s code .This is because by 
-  serializing via a pointer, the "log" object now being tracked.  This is because
+  first. After a series of very long and increasingly acrimonious email exchanges, 
+it's discovered 
+  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
   the program. Now multiple saves from the same address result in only the first one 
@@ -642,11 +641,11 @@ its discovered
   data might have been changed.  When it comes time to load the data, all instances of the log record show the same data.
   In this way, the behavior of a functioning piece of code is changed due the side
   effect of a change in an otherwise disjoint module.
-  Worse yet, the data has been lost and cannot not be now recovered from the archives.
+  Worse yet, the data has been lost and cannot be recovered from the archives.
   People are really upset and disappointed with boost (at least the serialization system).
   <p>
   <li>
-  After a lot of investigation, it's discovered what the source of the problem
+  After a lot of investigation, it's discovered what the source of the problem is
   and class construct_from is marked "track_never" by including:
 <code style="white-space: normal"><pre>
 BOOST_CLASS_TRACKING(construct_from, track_never) 
@@ -660,7 +659,7 @@ have its own distinct raw pointer. This will break
 <code style="white-space: normal">shared_ptr</code> and cause a memory leak.  Again,
 The cause of this problem is very far removed from the point of discovery.  It could 
 well be that the problem is not even discovered until after the archives are loaded.
-Now we not only have difficult to find and fix program bug, but we have a bunch of
+Now we not only have a difficult to find and fix program bug, but we have a bunch of
 invalid archives and lost data.
 </ol>
 
@@ -673,7 +672,7 @@ invalid archives and lost data.
 ar &lt;&lt; x; 
 </pre></code>
   <p>
-  <li>The programmer curses (another %^&*&* hoop to jump through). If he's in a 
+  <li>The programmer curses (another %^&*&* hoop to jump through). He's in a 
   hurry (and who isn't) and would prefer not to <code style="white-space: normal">const_cast</code>
   - because it looks bad.  So he'll just make the following change an move on. 
 <code style="white-space: normal"><pre>
@@ -684,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; 
@@ -697,8 +696,8 @@ ar &lt;&lt; x
   <p>
   He's mildly annoyed now he tries the following: 
   <ul>
-    <li>He considers making f() a const - but presumable that shifts the const 
-    error to somewhere else. And his doesn't want to fiddle with "his" code to 
+    <li>He considers making f() a const - but presumably that shifts the const 
+    error to somewhere else. And he doesn't want to fiddle with "his" code to 
     work around a quirk in the serializaition system 
     <p>
     <li>He removes the <code style="white-space: normal">const</code>
@@ -710,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 
@@ -748,35 +747,35 @@ Note that in this second scenario
 
 It's true that these messages may sometimes flag code that is currently correct and
 that this may be annoying to some programmers.  However, this example illustrates
-my view that these messages are useful and that any such annoyance is small price to
+my view that these messages are useful and that any such annoyance is a small price to
 pay to avoid particularly vexing programming errors.
 
 </dd>
 
 <dt><h2><a name="pointer_level">pointer_level</a> - warning</h2></dt>
 <dd>
-This trap addresses the following situaion when serializing 
+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 absense 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 

doc/tutorial.html

@@ -2,8 +2,8 @@
 <html>
 <!--
 (C) Copyright 2002-4 Robert Ramey - http://www.rrsd.com .
-Use, modification and distribution is subject to the Boost Software
-License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+Distributed under the Boost Software License, Version 1.0.
+(See accompanying file LICENSE_1_0.txt or copy at
 http://www.boost.org/LICENSE_1_0.txt)
 -->
 <head>
@@ -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>.
@@ -569,11 +569,11 @@ anywhere in the program - a memory leak.
 There are couple of ways of fixing this.  One way is to explicitly manage the bus stops.
 However, a more robust and transparent is to use 
 <code style="white-space: normal">shared_ptr</code> rather than raw pointers. Along
-with serialization implemenations for the Standard Library, the serialization library
+with serialization implementations for the Standard Library, the serialization library
 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. 

doc/void_cast.html

@@ -2,8 +2,8 @@
 <html>
 <!--
 (C) Copyright 2002-4 Robert Ramey - http://www.rrsd.com . 
-Use, modification and distribution is subject to the Boost Software
-License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+Distributed under the Boost Software License, Version 1.0.
+(See accompanying file LICENSE_1_0.txt or copy at
 http://www.boost.org/LICENSE_1_0.txt)
 -->
 <head>
@@ -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 class would diminish the applicability
+Limiting the serialization of pointers to only such classes would diminish the applicability
 of the library.
 
 <h3>Usage</h3>
@@ -42,11 +42,11 @@ 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
-)
+);
 </code></pre></h4></dt>
 <dd>
 This function "registers" a pair of related types.  It stores the fact that
@@ -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>

doc/wrappers.html

@@ -2,8 +2,8 @@
 <html>
 <!--
 (C) Copyright 2002-4 Robert Ramey - http://www.rrsd.com . 
-Use, modification and distribution is subject to the Boost Software
-License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+Distributed under the Boost Software License, Version 1.0.
+(See accompanying file LICENSE_1_0.txt or copy at
 http://www.boost.org/LICENSE_1_0.txt)
 -->
 <head>
@@ -43,7 +43,7 @@ the <A href="traits.html#wrappers"><code>is_wrapper</code></a> trait for
 these wrapper classes is set to true.
 
 <h3><a name="binaryobjects">Binary Objects</a></h3>
-A binary object is just an sequence of bytes stored as raw
+A binary object is just a sequence of bytes stored as raw
 binary data.  This would most likely be used for a large amount
 of "light weight" data such as a pixel map or embedded binary file.
 The header file 
@@ -59,12 +59,12 @@ which will construct a temporary binary object that can be serialized just like
 Its default serialization is to use archive class primitives 
 <code style="white-space: normal">save_binary</code> and <code>load_binary</code>.  
 Note that it doesn't allocated any storage or create any objects.
-Its sole purpose is to pass the data size and address as pair to the archive class.  
+Its sole purpose is to pass the data size and address as a pair to the archive class.  
 
 
 <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:    
@@ -91,7 +91,7 @@ public:
 };
 </code></pre>
 that can be serialized just like any other object.
-Its default serialization is to use serialize each array element.  
+Its default serialization is to serialize each array element.  
 Note that it doesn't allocated any storage or create any objects.
 Its sole purpose is to pass the data type, size and address to the archive class.
 
@@ -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
-is - surpise! - the name of the C++ class data member.  So our serialization
+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>

example/Jamfile.v2

@@ -11,47 +11,37 @@ project libs/serialization/example
     : requirements <library>../build//boost_serialization
     ;
 
-rule demo_bsl_run ( demo-name : othersources * : requirements * )
-{
-    return [ run
-        # sources
-            $(demo-name).cpp 
-            $(othersources).cpp
-        : # command
-        : # input files
-        : # requirements
-            # toolset suppress-warnings
-            <toolset>gcc:<cxxflags>"-Wno-non-virtual-dtor -Wno-ctor-dtor-privacy"
-            <toolset>msvc-8.0:<cxxflags>"-wd4996"
-            <toolset>borland:<cxxflags>"-w-8080 -w-8071 -w-8057 -w-8062 -w-8008 -w-0018 -w-8066"
-            # toolset optimizations
-            <toolset>gcc:<cxxflags>"-ftemplate-depth-255"
-            <toolset>msvc:<cxxflags>"-Gy"
-            # toolset shared library support
-            <toolset>como,<runtime-link>shared:<build>no
-            <toolset>msvc,<stdlib>stlport,<runtime-link>shared:<build>no
-            <toolset>cw,<runtime-link>static:<build>no
-            $(requirements)
-         : # test name
-            $(demo-name)
-       ]
-    ;
-}
+import testing ;
+
+import ../util/test :
+    run-template
+    run-invoke
+    run-winvoke
+    test-bsl-run-no-lib
+    test-bsl-run
+    test-bsl-run_archive
+    test-bsl-run_files
+;
+
+# for [ requires auto_ptr ]
+import-search /boost/config/checks ;
+import config : requires ;
 
 test-suite "demo-suite" :
     # demos
-    [ demo_bsl_run demo ]
-    [ demo_bsl_run demo_auto_ptr ]
-    [ demo_bsl_run demo_exception ]
-    [ demo_bsl_run demo_log : log_archive ]
-    [ demo_bsl_run demo_pimpl : demo_pimpl_A ]
-    [ demo_bsl_run demo_polymorphic : demo_polymorphic_A ]
-    [ demo_bsl_run demo_portable_archive : portable_binary_iarchive portable_binary_oarchive ]
-    [ demo_bsl_run demo_shared_ptr ]
-    [ demo_bsl_run demo_simple_log ]
-    [ demo_bsl_run demo_trivial_archive ]
-    [ demo_bsl_run demo_xml ]
-    [ demo_bsl_run demo_xml_save ]
-    [ demo_bsl_run demo_xml_load : : <dependency>demo_xml_save ]
+    [ test-bsl-run demo ]
+    [ test-bsl-run demo_auto_ptr : : : [ requires auto_ptr ] ]
+    [ test-bsl-run demo_exception ]
+    [ test-bsl-run demo_fast_archive ]
+    [ test-bsl-run demo_log : log_archive : : <link>static ]
+    [ test-bsl-run demo_pimpl : demo_pimpl_A ]
+    [ test-bsl-run demo_polymorphic : demo_polymorphic_A ]
+    [ test-bsl-run demo_portable_archive : portable_binary_iarchive portable_binary_oarchive : : <link>static ]
+    [ test-bsl-run demo_shared_ptr ]
+    [ test-bsl-run demo_simple_log ]
+    [ test-bsl-run demo_trivial_archive ]
+    [ test-bsl-run demo_xml ]
+    [ test-bsl-run demo_xml_save ]
+    [ test-bsl-run demo_xml_load : : : <dependency>demo_xml_save ]
 ;
 

example/demo.cpp

@@ -2,8 +2,8 @@
 // demo.cpp
 //
 // (C) Copyright 2002-4 Robert Ramey - http://www.rrsd.com .
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+// Distributed under the Boost Software License, Version 1.0.
+// (See accompanying file LICENSE_1_0.txt or copy at
 // http://www.boost.org/LICENSE_1_0.txt)
 
 
@@ -17,7 +17,7 @@
 
 #include <boost/archive/text_iarchive.hpp>
 #include <boost/archive/text_oarchive.hpp>
-
+#include <boost/cstdint.hpp>
 #include <boost/serialization/base_object.hpp>
 #include <boost/serialization/utility.hpp>
 #include <boost/serialization/list.hpp>
@@ -26,22 +26,22 @@
 /////////////////////////////////////////////////////////////
 // The intent of this program is to serve as a tutorial for
 // users of the serialization package.  An attempt has been made
-// to illustrate most of the facilities of the package.  
+// 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. 
+// 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
 {
@@ -57,13 +57,13 @@ class gps_position
 public:
     // every serializable class needs a constructor
     gps_position(){};
-    gps_position(int _d, int _m, float _s) : 
+    gps_position(int _d, int _m, float _s) :
         degrees(_d), minutes(_m), seconds(_s)
     {}
 };
 std::ostream & operator<<(std::ostream &os, const gps_position &gp)
 {
-    return os << ' ' << gp.degrees << (unsigned char)186 << gp.minutes << '\'' << gp.seconds << '"';
+    return os << ' ' << gp.degrees << (unsigned char)176 << gp.minutes << '\'' << gp.seconds << '"';
 }
 
 /////////////////////////////////////////////////////////////
@@ -147,7 +147,7 @@ class bus_stop_destination : public bus_stop
         ar & boost::serialization::base_object<bus_stop>(*this) & name;
     }
 public:
-    
+
     bus_stop_destination(){}
     bus_stop_destination(
         const gps_position & _lat, const gps_position & _long, const std::string & _name
@@ -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
@@ -202,7 +202,7 @@ std::ostream & operator<<(std::ostream &os, const bus_route &br)
     // note: we're displaying the pointer to permit verification
     // that duplicated pointers are properly restored.
     for(it = br.stops.begin(); it != br.stops.end(); it++){
-        os << '\n' << std::hex << "0x" << *it << std::dec << ' ' << **it;
+        os << '\n' << "0x" << std::hex << reinterpret_cast<boost::uintptr_t>(*it) << std::dec << ' ' << **it;
     }
     return os;
 }
@@ -213,7 +213,7 @@ std::ostream & operator<<(std::ostream &os, const bus_route &br)
 // Illustrates serialization of STL objects(pair) in a non-intrusive way.
 // See definition of operator<< <pair<F, S> >(ar, pair) and others in
 // serialization.hpp
-// 
+//
 // illustrates nesting of serializable classes
 //
 // illustrates use of version number to automatically grandfather older
@@ -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;
         }
 
@@ -299,7 +299,7 @@ restore_schedule(bus_schedule &s, const char * filename)
 }
 
 int main(int argc, char *argv[])
-{   
+{
     // make the schedule
     bus_schedule original_schedule;
 
@@ -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);
@@ -351,7 +351,7 @@ int main(int argc, char *argv[])
     // display the complete schedule
     std::cout << "original schedule";
     std::cout << original_schedule;
-    
+
     std::string filename(boost::archive::tmpdir());
     filename += "/demofile.txt";
 
@@ -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());

example/demo_auto_ptr.cpp

@@ -1,9 +1,9 @@
 /////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
 // demo_auto_ptr.cpp
 
-// (C) Copyright 2002-4 Robert Ramey - http://www.rrsd.com . 
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+// (C) Copyright 2002-4 Robert Ramey - http://www.rrsd.com .
+// Distributed under the Boost Software License, Version 1.0.
+// (See accompanying file LICENSE_1_0.txt or copy at
 // http://www.boost.org/LICENSE_1_0.txt)
 
 #include <list>
@@ -14,7 +14,7 @@
 #include <cstdio> // remove, std::autoptr inteface wrong in dinkumware
 #include <boost/config.hpp>
 #if defined(BOOST_NO_STDC_NAMESPACE)
-namespace std{ 
+namespace std{
     using ::remove;
 }
 #endif
@@ -25,7 +25,7 @@ namespace std{
 
 #include <boost/serialization/split_free.hpp>
 
-namespace boost { 
+namespace boost {
 namespace serialization {
 
 /////////////////////////////////////////////////////////////

example/demo_dll.cpp

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

example/demo_dll_a.hpp

@@ -2,16 +2,16 @@
 #define BOOST_SERIALIZATION_TEST_A_HPP
 
 // MS compatible compilers support #pragma once
-#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+#if defined(_MSC_VER)
 # pragma once
 #endif
 
 /////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
 // A.hpp    simple class test
 
-// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
+// Distributed under the Boost Software License, Version 1.0.
+// (See accompanying file LICENSE_1_0.txt or copy at
 // http://www.boost.org/LICENSE_1_0.txt)
 
 //  See http://www.boost.org for updates, documentation, and revision history.
@@ -20,11 +20,12 @@
 #include <cstdlib> // for rand()
 #include <cmath> // for fabs()
 #include <cstddef> // size_t
+#include <boost/math/special_functions/next.hpp>
 
 #include <boost/config.hpp>
 #if defined(BOOST_NO_STDC_NAMESPACE)
 namespace std{
-    using ::rand; 
+    using ::rand;
     using ::fabs;
     using ::size_t;
 }
@@ -60,7 +61,7 @@ private:
         ar & BOOST_SERIALIZATION_NVP(f);
         ar & BOOST_SERIALIZATION_NVP(g);
         #endif
-        #if BOOST_WORKAROUND(__BORLANDC__,  <= 0x551 )
+        #if BOOST_WORKAROUND(BOOST_BORLANDC,  <= 0x551 )
             int i;
             if(BOOST_DEDUCED_TYPENAME Archive::is_saving::value){
                 i = l;
@@ -228,12 +229,12 @@ inline bool A::operator==(const A &rhs) const
     if(o != rhs.o)
         return false;
     if(p != rhs.p)
-        return false; 
+        return false;
     if(q != rhs.q)
         return false;
     #ifndef BOOST_NO_CWCHAR
     if(r != rhs.r)
-        return false; 
+        return false;
     #endif
     if(c != rhs.c)
         return false;
@@ -242,23 +243,19 @@ inline bool A::operator==(const A &rhs) const
     if(t != rhs.t)
         return false;
     if(u != rhs.u)
-        return false; 
+        return false;
     if(v != rhs.v)
-        return false; 
-    if(w == 0 && std::fabs(rhs.w) > std::numeric_limits<float>::epsilon())
         return false;
-    if(std::fabs(rhs.w/w - 1.0) > std::numeric_limits<float>::epsilon())
+    if(std::abs( boost::math::float_distance(w, rhs.w)) > 1)
         return false;
-    if(x == 0 && std::fabs(rhs.x - x) > std::numeric_limits<float>::epsilon())
-        return false;
-    if(std::fabs(rhs.x/x - 1.0) > std::numeric_limits<float>::epsilon())
+    if(std::abs( boost::math::float_distance(x, rhs.x)) > 1)
         return false;
     if(0 != y.compare(rhs.y))
         return false;
     #ifndef BOOST_NO_STD_WSTRING
     if(0 != z.compare(rhs.z))
         return false;
-    #endif      
+    #endif
     return true;
 }
 
@@ -300,11 +297,11 @@ inline bool A::operator<(const A &rhs) const
     if(t != rhs.t )
         return t < rhs.t;
     if(u != rhs.u )
-        return u < rhs.u; 
+        return u < rhs.u;
     if(v != rhs.v )
         return v < rhs.v;
     if(w != rhs.w )
-        return w < rhs.w; 
+        return w < rhs.w;
     if(x != rhs.x )
         return x < rhs.x;
     int i = y.compare(rhs.y);

example/demo_dll_a.ipp

@@ -2,7 +2,7 @@
 #define BOOST_SERIALIZATION_TEST_A_HPP
 
 // MS compatible compilers support #pragma once
-#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+#if defined(_MSC_VER)
 # pragma once
 #endif
 
@@ -10,8 +10,8 @@
 // A.hpp    simple class test
 
 // (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+// Distributed under the Boost Software License, Version 1.0.
+// (See accompanying file LICENSE_1_0.txt or copy at
 // http://www.boost.org/LICENSE_1_0.txt)
 
 //  See http://www.boost.org for updates, documentation, and revision history.
@@ -60,7 +60,7 @@ private:
         ar & BOOST_SERIALIZATION_NVP(f);
         ar & BOOST_SERIALIZATION_NVP(g);
         #endif
-        #if BOOST_WORKAROUND(__BORLANDC__,  <= 0x551 )
+        #if BOOST_WORKAROUND(BOOST_BORLANDC,  <= 0x551 )
             int i;
             if(BOOST_DEDUCED_TYPENAME Archive::is_saving::value){
                 i = l;
@@ -244,14 +244,10 @@ inline bool A::operator==(const A &rhs) const
     if(u != rhs.u)
         return false; 
     if(v != rhs.v)
-        return false; 
-    if(w == 0 && std::fabs(rhs.w) > std::numeric_limits<float>::epsilon())
         return false;
-    if(std::fabs(rhs.w/w - 1.0) > std::numeric_limits<float>::epsilon())
+    if(std::abs( boost::math::float_distance(w, rhs.w)) > 1)
         return false;
-    if(x == 0 && std::fabs(rhs.x - x) > std::numeric_limits<float>::epsilon())
-        return false;
-    if(std::fabs(rhs.x/x - 1.0) > std::numeric_limits<float>::epsilon())
+    if(std::abs( boost::math::float_distance(x, rhs.x)) > 1)
         return false;
     if(0 != y.compare(rhs.y))
         return false;

example/demo_dll_b.hpp

@@ -2,26 +2,27 @@
 #define BOOST_SERIALIZATION_TEST_B_HPP
 
 // MS compatible compilers support #pragma once
-#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+#if defined(_MSC_VER)
 # pragma once
 #endif
 
 /////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
 // B.hpp
 
-// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
+// Distributed under the Boost Software License, Version 1.0.
+// (See accompanying file LICENSE_1_0.txt or copy at
 // http://www.boost.org/LICENSE_1_0.txt)
 
 //  See http://www.boost.org for updates, documentation, and revision history.
 
 #include <cstdlib> // for rand()
+#include <boost/math/special_functions/next.hpp>
 
 #include <boost/config.hpp>
 #if defined(BOOST_NO_STDC_NAMESPACE)
 namespace std{
-    using ::rand; 
+    using ::rand;
 }
 #endif
 
@@ -100,12 +101,12 @@ inline bool B::operator==(const B &rhs) const
 {
     return
         A::operator==(rhs)
-        && s == rhs.s 
-        && t == rhs.t 
-        && u == rhs.u 
-        && v == rhs.v 
-        && std::fabs(w - rhs.w) <= std::numeric_limits<float>::round_error()
-        && std::fabs(x - rhs.x) <= std::numeric_limits<float>::round_error()
+        && s == rhs.s
+        && t == rhs.t
+        && u == rhs.u
+        && v == rhs.v
+        && std::abs( boost::math::float_distance(w, rhs.w)) < 2
+        && std::abs( boost::math::float_distance(x, rhs.x)) < 2
     ;
 }
 

example/demo_dll_b.ipp

@@ -2,7 +2,7 @@
 #define BOOST_SERIALIZATION_TEST_B_HPP
 
 // MS compatible compilers support #pragma once
-#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+#if defined(_MSC_VER)
 # pragma once
 #endif
 
@@ -10,8 +10,8 @@
 // B.hpp
 
 // (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+// Distributed under the Boost Software License, Version 1.0.
+// (See accompanying file LICENSE_1_0.txt or copy at
 // http://www.boost.org/LICENSE_1_0.txt)
 
 //  See http://www.boost.org for updates, documentation, and revision history.
@@ -104,8 +104,8 @@ inline bool B::operator==(const B &rhs) const
         && t == rhs.t 
         && u == rhs.u 
         && v == rhs.v 
-        && std::fabs(w - rhs.w) <= std::numeric_limits<float>::round_error()
-        && std::fabs(x - rhs.x) <= std::numeric_limits<float>::round_error()
+        && std::abs( boost::math::float_distance(w, rhs.w)) < 2
+        && std::abs( boost::math::float_distance(x, rhs.x)) < 2
     ;
 }
 

example/demo_exception.cpp

@@ -1,20 +1,20 @@
 /////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
 // demo_exception.cpp
 
-// (C) Copyright 2002-4 Robert Ramey - http://www.rrsd.com . 
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+// (C) Copyright 2002-4 Robert Ramey - http://www.rrsd.com .
+// Distributed under the Boost Software License, Version 1.0.
+// (See accompanying file LICENSE_1_0.txt or copy at
 // http://www.boost.org/LICENSE_1_0.txt)
 
 // Example of safe exception handling for pointer de-serialization
-// 
-// This example was prepared by Robert Ramey to demonstrate and test 
+//
+// This example was prepared by Robert Ramey to demonstrate and test
 // safe exception handling during the de-serialization of pointers in
 // a non-trivial example.
 //
 // Hopefully, this addresses exception issues raised by
 // Vahan Margaryan who spent considerable time and effort
-// in the analysis and testing of issues of exception safety 
+// in the analysis and testing of issues of exception safety
 // of the serialization library.
 
 #include <algorithm>
@@ -26,7 +26,7 @@
 #include <cstdio> // remove
 #include <boost/config.hpp>
 #if defined(BOOST_NO_STDC_NAMESPACE)
-namespace std{ 
+namespace std{
     using ::remove;
 }
 #endif
@@ -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;

example/demo_fast_archive.cpp

@@ -1,9 +1,9 @@
 /////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
 // demo_fast_binary_archive.cpp
 
-// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
+// Distributed under the Boost Software License, Version 1.0.
+// (See accompanying file LICENSE_1_0.txt or copy at
 // http://www.boost.org/LICENSE_1_0.txt)
 
 // should pass compilation and execution
@@ -11,7 +11,6 @@
 
 #include <boost/static_assert.hpp>
 #include <boost/type_traits/is_array.hpp>
-#include <boost/serialization/pfto.hpp>
 
 #define BOOST_ARCHIVE_SOURCE
 #include <boost/archive/binary_oarchive_impl.hpp>
@@ -28,19 +27,19 @@
 using namespace boost::archive;
 
 /////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// "Fast" output binary archive.  This is a variation of the native binary 
+// "Fast" output binary archive.  This is a variation of the native binary
 class fast_binary_oarchive :
     // don't derive from binary_oarchive !!!
     public binary_oarchive_impl<
-        fast_binary_oarchive, 
-        std::ostream::char_type, 
+        fast_binary_oarchive,
+        std::ostream::char_type,
         std::ostream::traits_type
     >
 {
     typedef fast_binary_oarchive derived_t;
     typedef binary_oarchive_impl<
-        fast_binary_oarchive, 
-        std::ostream::char_type, 
+        fast_binary_oarchive,
+        std::ostream::char_type,
         std::ostream::traits_type
     > base_t;
 #ifndef BOOST_NO_MEMBER_TEMPLATE_FRIENDS
@@ -49,38 +48,38 @@ public:
     friend class boost::archive::detail::interface_oarchive<derived_t>;
     friend class basic_binary_oarchive<derived_t>;
     friend class basic_binary_oprimitive<
-        derived_t, 
-        std::ostream::char_type, 
+        derived_t,
+        std::ostream::char_type,
         std::ostream::traits_type
     >;
     friend class boost::archive::save_access;
 #endif
     // add base class to the places considered when matching
     // save function to a specific set of arguments.  Note, this didn't
-    // work on my MSVC 7.0 system using 
+    // work on my MSVC 7.0 system using
     // binary_oarchive_impl<derived_t>::load_override;
     // so we use the sure-fire method below.  This failed to work as well
     template<class T>
-    void save_override(T & t, BOOST_PFTO int){
-        base_t::save_override(t, 0);
+    void save_override(T & t){
+        base_t::save_override(t);
         // verify that this program is in fact working by making sure
         // that arrays are getting passed here
         BOOST_STATIC_ASSERT(! (boost::is_array<T>::value) );
     }
     template<int N>
-    void save_override(const int (& t)[N] , int){
+    void save_override(const int (& t)[N]){
         save_binary(t, sizeof(t));
     }
     template<int N>
-    void save_override(const unsigned int (& t)[N], int){
+    void save_override(const unsigned int (& t)[N]){
         save_binary(t, sizeof(t));
     }
     template<int N>
-    void save_override(const long (& t)[N], int){
+    void save_override(const long (& t)[N]){
         save_binary(t, sizeof(t));
     }
     template<int N>
-    void save_override(const unsigned long (& t)[N], int){
+    void save_override(const unsigned long (& t)[N]){
         save_binary(t, sizeof(t));
     }
 public:
@@ -96,19 +95,19 @@ public:
 BOOST_SERIALIZATION_REGISTER_ARCHIVE(fast_binary_oarchive)
 
 /////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// "Fast" input binary archive.  This is a variation of the native binary 
+// "Fast" input binary archive.  This is a variation of the native binary
 class fast_binary_iarchive :
     // don't derive from binary_oarchive !!!
     public binary_iarchive_impl<
-        fast_binary_iarchive, 
-        std::istream::char_type, 
+        fast_binary_iarchive,
+        std::istream::char_type,
         std::istream::traits_type
     >
 {
     typedef fast_binary_iarchive derived_t;
     typedef binary_iarchive_impl<
-        fast_binary_iarchive, 
-        std::istream::char_type, 
+        fast_binary_iarchive,
+        std::istream::char_type,
         std::istream::traits_type
     > base_t;
 #ifndef BOOST_NO_MEMBER_TEMPLATE_FRIENDS
@@ -117,36 +116,36 @@ public:
     friend class boost::archive::detail::interface_iarchive<derived_t>;
     friend class basic_binary_iarchive<derived_t>;
     friend class basic_binary_iprimitive<
-        derived_t, 
-        std::ostream::char_type, 
+        derived_t,
+        std::ostream::char_type,
         std::ostream::traits_type
     >;
     friend class boost::archive::load_access;
 #endif
     // add base class to the places considered when matching
     // save function to a specific set of arguments.  Note, this didn't
-    // work on my MSVC 7.0 system using 
+    // work on my MSVC 7.0 system using
     // binary_oarchive_impl<derived_t>::load_override;
     // so we use the sure-fire method below.  This failed to work as well
     template<class T>
-    void load_override(T & t, BOOST_PFTO int){
-        base_t::load_override(t, 0);
+    void load_override(T & t){
+        base_t::load_override(t);
         BOOST_STATIC_ASSERT(! (boost::is_array<T>::value) );
     }
     template<int N>
-    void load_override(int (& t)[N], int){
+    void load_override(int (& t)[N]){
         load_binary(t, sizeof(t));
     }
     template<int N>
-    void load_override(unsigned int (& t)[N], int){
+    void load_override(unsigned int (& t)[N]){
         load_binary(t, sizeof(t));
     }
     template<int N>
-    void load_override(long (& t)[N], int){
+    void load_override(long (& t)[N]){
         load_binary(t, sizeof(t));
     }
     template<int N>
-    void load_override(unsigned long (& t)[N], int){
+    void load_override(unsigned long (& t)[N]){
         load_binary(t, sizeof(t));
     }
 public:
@@ -167,7 +166,7 @@ int main( int argc, char* argv[] )
     int a1[3] = {4, 5, 6};
 
     std::stringstream ss;
-    {   
+    {
         fast_binary_oarchive pboa(ss);
         pboa << a;
     }

example/demo_gps.hpp

@@ -6,14 +6,15 @@
 // demo_gps.hpp
 //
 // (C) Copyright 2002-4 Robert Ramey - http://www.rrsd.com .
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+// Distributed under the Boost Software License, Version 1.0.
+// (See accompanying file LICENSE_1_0.txt or copy at
 // http://www.boost.org/LICENSE_1_0.txt)
 
 #include <iomanip>
 #include <iostream>
 #include <fstream>
 
+#include <boost/cstdint.hpp>
 #include <boost/serialization/string.hpp>
 #include <boost/serialization/nvp.hpp>
 #include <boost/serialization/utility.hpp>
@@ -23,14 +24,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
 {
@@ -51,14 +52,14 @@ class gps_position
 public:
     // every serializable class needs a constructor
     gps_position(){};
-    gps_position(int _d, int _m, float _s) : 
+    gps_position(int _d, int _m, float _s) :
         degrees(_d), minutes(_m), seconds(_s)
     {}
 };
 
 std::ostream & operator<<(std::ostream &os, const gps_position &gp)
 {
-    return os << ' ' << gp.degrees << (unsigned char)186 << gp.minutes << '\'' << gp.seconds << '"';
+    return os << ' ' << gp.degrees << (unsigned char)176 << gp.minutes << '\'' << gp.seconds << '"';
 }
 
 /////////////////////////////////////////////////////////////
@@ -159,7 +160,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
@@ -199,7 +200,7 @@ std::ostream & operator<<(std::ostream &os, const bus_route &br)
     // note: we're displaying the pointer to permit verification
     // that duplicated pointers are properly restored.
     for(it = br.stops.begin(); it != br.stops.end(); it++){
-        os << '\n' << std::hex << "0x" << *it << std::dec << ' ' << **it;
+        os << '\n' << "0x" << std::hex << reinterpret_cast<boost::uintptr_t>(*it) << std::dec << ' ' << **it;
     }
     return os;
 }
@@ -209,7 +210,7 @@ std::ostream & operator<<(std::ostream &os, const bus_route &br)
 //
 // Illustrates serialization of STL objects(pair) in a non-intrusive way.
 // See definition of operator<< <pair<F, S> >(ar, pair)
-// 
+//
 // illustrates nesting of serializable classes
 //
 // illustrates use of version number to automatically grandfather older
@@ -236,7 +237,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);
         }

example/demo_log.cpp

@@ -3,8 +3,8 @@
 // demo_log.cpp
 //
 // (C) Copyright 2009 Robert Ramey - http://www.rrsd.com .
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+// Distributed under the Boost Software License, Version 1.0.
+// (See accompanying file LICENSE_1_0.txt or copy at
 // http://www.boost.org/LICENSE_1_0.txt)
 
 #include <iostream>
@@ -13,8 +13,7 @@
 #include "demo_gps.hpp"
 #include "log_archive.hpp"
 
-int main(int argc, char *argv[])
-{   
+int main(int argc, char *argv[]){
     // make the schedule
     bus_schedule schedule;
 
@@ -41,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);
@@ -52,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);
@@ -65,7 +64,7 @@ int main(int argc, char *argv[])
 
     // display the complete schedule
     log_archive oa(std::cout);
-    //oa << BOOST_SERIALIZATION_NVP(schedule);
+    oa << BOOST_SERIALIZATION_NVP(schedule);
     oa << schedule;
 
     delete bs0;
@@ -74,3 +73,4 @@ int main(int argc, char *argv[])
     delete bs3;
     return 0;
 }
+

example/demo_pimpl.cpp

@@ -1,9 +1,9 @@
 /////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
 // demo_pimpl.cpp
 
-// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
+// Distributed under the Boost Software License, Version 1.0.
+// (See accompanying file LICENSE_1_0.txt or copy at
 // http://www.boost.org/LICENSE_1_0.txt)
 
 // should pass compilation and execution

example/demo_pimpl_A.cpp

@@ -1,9 +1,9 @@
 /////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
 // demo_pimpl_A.cpp
 
-// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
+// Distributed under the Boost Software License, Version 1.0.
+// (See accompanying file LICENSE_1_0.txt or copy at
 // http://www.boost.org/LICENSE_1_0.txt)
 
 #include <boost/archive/text_iarchive.hpp>
@@ -31,15 +31,15 @@ template<class Archive>
 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, 
+    boost::archive::text_iarchive & ar,
     const unsigned int file_version
 );
 template void A::serialize<boost::archive::text_oarchive>(
-    boost::archive::text_oarchive & ar, 
+    boost::archive::text_oarchive & ar,
     const unsigned int file_version
 );

example/demo_pimpl_A.hpp

@@ -4,9 +4,9 @@
 /////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
 // demo_pimpl_A.hpp
 
-// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
+// Distributed under the Boost Software License, Version 1.0.
+// (See accompanying file LICENSE_1_0.txt or copy at
 // http://www.boost.org/LICENSE_1_0.txt)
 
 // class whose declaration is hidden by a pointer

example/demo_polymorphic.cpp

@@ -1,9 +1,9 @@
 /////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
 // demo_polymorphic.cpp
 
-// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
+// Distributed under the Boost Software License, Version 1.0.
+// (See accompanying file LICENSE_1_0.txt or copy at
 // http://www.boost.org/LICENSE_1_0.txt)
 
 // should pass compilation and execution
@@ -26,10 +26,10 @@ 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; 
+            boost::archive::polymorphic_oarchive & oa_interface = oa;
             // we can just just the interface for saving
             oa_interface << a;
         }
@@ -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;
@@ -53,7 +53,7 @@ int main(int argc, char* argv[])
         {
             // see above
             boost::archive::polymorphic_binary_iarchive ia(ss);
-            boost::archive::polymorphic_iarchive & ia_interface = ia; 
+            boost::archive::polymorphic_iarchive & ia_interface = ia;
             // use just the polymorphic interface for loading.
             ia_interface >> a1;
         }

example/demo_polymorphic_A.cpp

@@ -1,9 +1,9 @@
 /////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
 // demo_polymorphic_A.cpp
 
-// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
+// Distributed under the Boost Software License, Version 1.0.
+// (See accompanying file LICENSE_1_0.txt or copy at
 // http://www.boost.org/LICENSE_1_0.txt)
 
 
@@ -16,11 +16,11 @@
 // used by this demo.
 template
 void A::serialize<boost::archive::polymorphic_iarchive>(
-    boost::archive::polymorphic_iarchive &, 
+    boost::archive::polymorphic_iarchive &,
     const unsigned int
 );
 template
 void A::serialize<boost::archive::polymorphic_oarchive>(
-    boost::archive::polymorphic_oarchive &, 
+    boost::archive::polymorphic_oarchive &,
     const unsigned int
 );

example/demo_polymorphic_A.hpp

@@ -4,9 +4,9 @@
 /////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
 // demo_polymorphic_A.hpp
 
-// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
+// Distributed under the Boost Software License, Version 1.0.
+// (See accompanying file LICENSE_1_0.txt or copy at
 // http://www.boost.org/LICENSE_1_0.txt)
 
 namespace boost {
@@ -22,7 +22,7 @@ struct A {
     // class a contains a pointer to a "hidden" declaration
     template<class Archive>
     void serialize(
-        Archive & ar, 
+        Archive & ar,
         const unsigned int file_version
     ){
         ar & data;

example/demo_portable_archive.cpp

@@ -3,8 +3,8 @@
 // demo_portable_archive.cpp
 //
 // (C) Copyright 2002-4 Robert Ramey - http://www.rrsd.com .
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+// Distributed under the Boost Software License, Version 1.0.
+// (See accompanying file LICENSE_1_0.txt or copy at
 // http://www.boost.org/LICENSE_1_0.txt)
 
 // should pass compilation and execution
@@ -43,8 +43,8 @@ public:
             c == rhs.c
             && i == rhs.i
             && i2 == rhs.i2
-            && ui == rhs.ui 
-            && l == rhs.l 
+            && ui == rhs.ui
+            && l == rhs.l
             && ul == rhs.ul
         ;
     }
@@ -65,7 +65,7 @@ int main( int /* argc */, char* /* argv */[] )
     A a1;
 
     std::stringstream ss;
-    {   
+    {
         portable_binary_oarchive pboa(ss);
         pboa << a;
     }
@@ -77,7 +77,7 @@ int main( int /* argc */, char* /* argv */[] )
         return 1;
 
     ss.clear();
-    {   
+    {
         portable_binary_oarchive pboa(ss, endian_big);
         pboa << a;
     }
@@ -89,7 +89,7 @@ int main( int /* argc */, char* /* argv */[] )
         return 1;
 
     ss.clear();
-    {   
+    {
         portable_binary_oarchive pboa(ss, endian_big);
         pboa << a;
     }

example/demo_shared_ptr.cpp

@@ -3,8 +3,8 @@
 // (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . Polymorphic
 // derived pointer example by David Tonge.
 
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+// Distributed under the Boost Software License, Version 1.0.
+// (See accompanying file LICENSE_1_0.txt or copy at
 // http://www.boost.org/LICENSE_1_0.txt)
 //
 //  See http://www.boost.org for updates, documentation, and revision history.
@@ -18,7 +18,7 @@
 #include <cstdio> // remove
 #include <boost/config.hpp>
 #if defined(BOOST_NO_STDC_NAMESPACE)
-namespace std{ 
+namespace std{
     using ::remove;
 }
 #endif

example/demo_simple_log.cpp

@@ -3,8 +3,8 @@
 // demo_log.cpp
 //
 // (C) Copyright 2009 Robert Ramey - http://www.rrsd.com .
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+// Distributed under the Boost Software License, Version 1.0.
+// (See accompanying file LICENSE_1_0.txt or copy at
 // http://www.boost.org/LICENSE_1_0.txt)
 
 #include <iostream>
@@ -14,7 +14,7 @@
 #include "simple_log_archive.hpp"
 
 int main(int argc, char *argv[])
-{   
+{
     // make the schedule
     bus_schedule schedule;
 
@@ -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);

example/demo_trivial_archive.cpp

@@ -3,8 +3,8 @@
 // demo_trivial_archive.cpp
 //
 // (C) Copyright 2009 Robert Ramey - http://www.rrsd.com .
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+// Distributed under the Boost Software License, Version 1.0.
+// (See accompanying file LICENSE_1_0.txt or copy at
 // http://www.boost.org/LICENSE_1_0.txt)
 
 #include <cstddef> // std::size_t
@@ -18,7 +18,7 @@ public:
     //////////////////////////////////////////////////////////
     // public interface used by programs that use the
     // serialization library
-    typedef boost::mpl::bool_<true> is_saving; 
+    typedef boost::mpl::bool_<true> is_saving;
     typedef boost::mpl::bool_<false> is_loading;
     template<class T> void register_type(){}
     template<class T> trivial_oarchive & operator<<(const T & t){
@@ -33,7 +33,7 @@ public:
 #include "demo_gps.hpp"
 
 int main(int argc, char *argv[])
-{   
+{
     // make the schedule
     bus_schedule schedule;
 
@@ -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);

example/demo_xml.cpp

@@ -3,8 +3,8 @@
 // demo_xml.cpp
 //
 // (C) Copyright 2002-4 Robert Ramey - http://www.rrsd.com .
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+// Distributed under the Boost Software License, Version 1.0.
+// (See accompanying file LICENSE_1_0.txt or copy at
 // http://www.boost.org/LICENSE_1_0.txt)
 
 #include <iomanip>
@@ -15,7 +15,7 @@
 #include <cstdio> // remove
 #include <boost/config.hpp>
 #if defined(BOOST_NO_STDC_NAMESPACE)
-namespace std{ 
+namespace std{
     using ::remove;
 }
 #endif
@@ -47,7 +47,7 @@ restore_schedule(bus_schedule &s, const char * filename)
 }
 
 int main(int argc, char *argv[])
-{   
+{
     // make the schedule
     bus_schedule original_schedule;
 
@@ -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);
@@ -99,7 +99,7 @@ int main(int argc, char *argv[])
     // display the complete schedule
     std::cout << "original schedule";
     std::cout << original_schedule;
-    
+
     std::string filename(boost::archive::tmpdir());
     filename += "/demo.xml";
 
@@ -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());

example/demo_xml.hpp

@@ -6,8 +6,8 @@
 // demo_xml.hpp
 //
 // (C) Copyright 2002-4 Robert Ramey - http://www.rrsd.com .
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+// Distributed under the Boost Software License, Version 1.0.
+// (See accompanying file LICENSE_1_0.txt or copy at
 // http://www.boost.org/LICENSE_1_0.txt)
 
 
@@ -16,6 +16,7 @@
 #include <iostream>
 #include <fstream>
 
+#include <boost/cstdint.hpp>
 #include <boost/serialization/nvp.hpp>
 #include <boost/serialization/utility.hpp>
 #include <boost/serialization/list.hpp>
@@ -23,14 +24,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
 {
@@ -51,14 +52,14 @@ class gps_position
 public:
     // every serializable class needs a constructor
     gps_position(){};
-    gps_position(int _d, int _m, float _s) : 
+    gps_position(int _d, int _m, float _s) :
         degrees(_d), minutes(_m), seconds(_s)
     {}
 };
 
 std::ostream & operator<<(std::ostream &os, const gps_position &gp)
 {
-    return os << ' ' << gp.degrees << (unsigned char)186 << gp.minutes << '\'' << gp.seconds << '"';
+    return os << ' ' << gp.degrees << (unsigned char)176 << gp.minutes << '\'' << gp.seconds << '"';
 }
 
 /////////////////////////////////////////////////////////////
@@ -159,7 +160,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
@@ -199,7 +200,7 @@ std::ostream & operator<<(std::ostream &os, const bus_route &br)
     // note: we're displaying the pointer to permit verification
     // that duplicated pointers are properly restored.
     for(it = br.stops.begin(); it != br.stops.end(); it++){
-        os << '\n' << std::hex << "0x" << *it << std::dec << ' ' << **it;
+        os << '\n' << "0x" << std::hex << reinterpret_cast<boost::uintptr_t>(*it) << std::dec << ' ' << **it;
     }
     return os;
 }
@@ -209,7 +210,7 @@ std::ostream & operator<<(std::ostream &os, const bus_route &br)
 //
 // Illustrates serialization of STL objects(pair) in a non-intrusive way.
 // See definition of operator<< <pair<F, S> >(ar, pair)
-// 
+//
 // illustrates nesting of serializable classes
 //
 // illustrates use of version number to automatically grandfather older
@@ -236,7 +237,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);
         }

example/demo_xml_load.cpp

@@ -3,8 +3,8 @@
 // demo_xml_load.cpp
 //
 // (C) Copyright 2002-4 Robert Ramey - http://www.rrsd.com .
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+// Distributed under the Boost Software License, Version 1.0.
+// (See accompanying file LICENSE_1_0.txt or copy at
 // http://www.boost.org/LICENSE_1_0.txt)
 
 #include <iostream>
@@ -28,7 +28,7 @@ restore_schedule(bus_schedule &s, const char * filename)
 }
 
 int main(int argc, char *argv[])
-{   
+{
     // make  a new schedule
     bus_schedule new_schedule;
 

example/demo_xml_save.cpp

@@ -3,8 +3,8 @@
 // demo_xml_save.cpp
 //
 // (C) Copyright 2002-4 Robert Ramey - http://www.rrsd.com .
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+// Distributed under the Boost Software License, Version 1.0.
+// (See accompanying file LICENSE_1_0.txt or copy at
 // http://www.boost.org/LICENSE_1_0.txt)
 
 #include <iostream>
@@ -24,7 +24,7 @@ void save_schedule(const bus_schedule &s, const char * filename){
 }
 
 int main(int argc, char *argv[])
-{   
+{
     // make the schedule
     bus_schedule original_schedule;
 
@@ -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);
@@ -76,7 +76,7 @@ int main(int argc, char *argv[])
     // display the complete schedule
     std::cout << "original schedule";
     std::cout << original_schedule;
-    
+
     std::string filename(boost::archive::tmpdir());
     filename += "/demo_save.xml";
 

example/fix_six.cpp

@@ -1,3 +1,11 @@
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// fix_six.cpp
+
+// Copyright 2010 Robert Ramey
+// Distributed under the Boost Software License, Version 1.0.
+// (See accompanying file LICENSE_1_0.txt or copy at
+// https://www.boost.org/LICENSE_1_0.txt)
+
 #include <fstream>
 #include <ios>
 #include <iostream>
@@ -17,7 +25,7 @@ int main(int argc, char *argv[]){
     }
     std::filebuf fb;
     fb.open(
-        argv[1], 
+        argv[1],
         std::ios_base::binary | std::ios_base::in | std::ios_base::out
     );
     if(!fb.is_open()){

example/log_archive.cpp

@@ -1,9 +1,9 @@
 /////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
 // log_archive.cpp:
 
-// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
+// Distributed under the Boost Software License, Version 1.0.
+// (See accompanying file LICENSE_1_0.txt or copy at
 // http://www.boost.org/LICENSE_1_0.txt)
 
 //  See http://www.boost.org for updates, documentation, and revision history.

example/log_archive.hpp

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

example/polymorphic_portable_binary_iarchive.cpp

@@ -1,9 +1,9 @@
 /////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
 // polymorphic_portable_binary_iarchive.cpp
 
-// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
+// Distributed under the Boost Software License, Version 1.0.
+// (See accompanying file LICENSE_1_0.txt or copy at
 // http://www.boost.org/LICENSE_1_0.txt)
 
 //  See http://www.boost.org for updates, documentation, and revision history.
@@ -22,8 +22,8 @@ namespace boost {
 namespace archive {
 
 template class binary_iarchive_impl<
-    polymorphic_portable_binary_iarchive, 
-    std::istream::char_type, 
+    polymorphic_portable_binary_iarchive,
+    std::istream::char_type,
     std::istream::traits_type
 >;
 template class detail::archive_pointer_iserializer<

example/polymorphic_portable_binary_iarchive.hpp

@@ -2,16 +2,16 @@
 #define BOOST_ARCHIVE_POLYMORPHIC_PORTABLE_BINARY_IARCHIVE_HPP
 
 // MS compatible compilers support #pragma once
-#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+#if defined(_MSC_VER)
 # pragma once
 #endif
 
 /////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
 // polymorphic_portable_binary_iarchive.hpp
 
-// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
+// Distributed under the Boost Software License, Version 1.0.
+// (See accompanying file LICENSE_1_0.txt or copy at
 // http://www.boost.org/LICENSE_1_0.txt)
 
 //  See http://www.boost.org for updates, documentation, and revision history.

example/polymorphic_portable_binary_oarchive.cpp

@@ -1,9 +1,9 @@
 /////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
 // polymorphic_portable_binary_oarchive.cpp
 
-// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
+// Distributed under the Boost Software License, Version 1.0.
+// (See accompanying file LICENSE_1_0.txt or copy at
 // http://www.boost.org/LICENSE_1_0.txt)
 
 //  See http://www.boost.org for updates, documentation, and revision history.
@@ -23,8 +23,8 @@ namespace archive {
 
 // explicitly instantiate for this type of binary stream
 template class binary_oarchive_impl<
-    polymorphic_portable_binary_oarchive, 
-    std::ostream::char_type, 
+    polymorphic_portable_binary_oarchive,
+    std::ostream::char_type,
     std::ostream::traits_type
 >;
 template class detail::archive_pointer_oserializer<

example/polymorphic_portable_binary_oarchive.hpp

@@ -2,16 +2,16 @@
 #define BOOST_ARCHIVE_POLYMORPHIC_PORTABLE_BINARY_OARCHIVE_HPP
 
 // MS compatible compilers support #pragma once
-#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+#if defined(_MSC_VER)
 # pragma once
 #endif
 
 /////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
 // polymorphic_portable_binary_oarchive.hpp
 
-// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
+// Distributed under the Boost Software License, Version 1.0.
+// (See accompanying file LICENSE_1_0.txt or copy at
 // http://www.boost.org/LICENSE_1_0.txt)
 
 //  See http://www.boost.org for updates, documentation, and revision history.

example/portable_binary_archive.hpp

@@ -1,19 +1,18 @@
 #ifndef PORTABLE_BINARY_ARCHIVE_HPP
 #define PORTABLE_BINARY_ARCHIVE_HPP
 
-// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
+// Distributed under the Boost Software License, Version 1.0.
+// (See accompanying file LICENSE_1_0.txt or copy at
 // http://www.boost.org/LICENSE_1_0.txt)
 
 // MS compatible compilers support #pragma once
-#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+#if defined(_MSC_VER)
 # pragma once
 #endif
 
 #include <boost/config.hpp>
 #include <boost/cstdint.hpp>
-#include <boost/serialization/pfto.hpp>
 #include <boost/static_assert.hpp>
 
 #include <climits>
@@ -22,7 +21,7 @@
 #endif
 
 #include <boost/archive/basic_archive.hpp>
-#include <boost/detail/endian.hpp>
+#include <boost/predef/other/endian.h>
 
 enum portable_binary_archive_flags {
     endian_big        = 0x4000,

example/portable_binary_iarchive.cpp

@@ -1,9 +1,9 @@
 /////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
 // portable_binary_iarchive.cpp
 
-// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
+// Distributed under the Boost Software License, Version 1.0.
+// (See accompanying file LICENSE_1_0.txt or copy at
 // http://www.boost.org/LICENSE_1_0.txt)
 
 //  See http://www.boost.org for updates, documentation, and revision history.
@@ -11,13 +11,13 @@
 #include <istream>
 #include <string>
 
-#include <boost/detail/endian.hpp>
+#include <boost/predef/other/endian.h>
 #include <boost/serialization/throw_exception.hpp>
 #include <boost/archive/archive_exception.hpp>
 
 #include "portable_binary_iarchive.hpp"
 
-void 
+void
 portable_binary_iarchive::load_impl(boost::intmax_t & l, char maxsize){
     char size;
     l = 0;
@@ -37,29 +37,29 @@ portable_binary_iarchive::load_impl(boost::intmax_t & l, char maxsize){
         );
 
     char * cptr = reinterpret_cast<char *>(& l);
-    #ifdef BOOST_BIG_ENDIAN
+    #if BOOST_ENDIAN_BIG_BYTE
         cptr += (sizeof(boost::intmax_t) - size);
     #endif
     this->primitive_base_t::load_binary(cptr, size);
 
-    #ifdef BOOST_BIG_ENDIAN
+    #if BOOST_ENDIAN_BIG_BYTE
         if(m_flags & endian_little)
     #else
         if(m_flags & endian_big)
     #endif
-            reverse_bytes(size, cptr);
-    
+    reverse_bytes(size, cptr);
+
     if(negative)
         l = -l;
 }
 
 void
 portable_binary_iarchive::load_override(
-    boost::archive::class_name_type & t, int
+    boost::archive::class_name_type & t
 ){
     std::string cn;
     cn.reserve(BOOST_SERIALIZATION_MAX_KEY_SIZE);
-    load_override(cn, 0);
+    load_override(cn);
     if(cn.size() > (BOOST_SERIALIZATION_MAX_KEY_SIZE - 1))
         boost::serialization::throw_exception(
             boost::archive::archive_exception(
@@ -70,7 +70,7 @@ portable_binary_iarchive::load_override(
     t.t[cn.size()] = '\0';
 }
 
-void 
+void
 portable_binary_iarchive::init(unsigned int flags){
     if(0 == (flags & boost::archive::no_header)){
         // read signature in an archive version independent manner
@@ -94,7 +94,7 @@ portable_binary_iarchive::init(unsigned int flags){
                     boost::archive::archive_exception::unsupported_version
                 )
             );
-        
+
         #if BOOST_WORKAROUND(__MWERKS__, BOOST_TESTED_AT(0x3205))
         this->set_library_version(input_library_version);
         //#else
@@ -123,7 +123,7 @@ namespace detail {
 
 template class basic_binary_iprimitive<
     portable_binary_iarchive,
-    std::istream::char_type, 
+    std::istream::char_type,
     std::istream::traits_type
 > ;
 

example/portable_binary_iarchive.hpp

@@ -2,7 +2,7 @@
 #define PORTABLE_BINARY_IARCHIVE_HPP
 
 // MS compatible compilers support #pragma once
-#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+#if defined(_MSC_VER)
 # pragma once
 #endif
 
@@ -14,9 +14,9 @@
 /////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
 // portable_binary_iarchive.hpp
 
-// (C) Copyright 2002-7 Robert Ramey - http://www.rrsd.com . 
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+// (C) Copyright 2002-7 Robert Ramey - http://www.rrsd.com .
+// Distributed under the Boost Software License, Version 1.0.
+// (See accompanying file LICENSE_1_0.txt or copy at
 // http://www.boost.org/LICENSE_1_0.txt)
 
 //  See http://www.boost.org for updates, documentation, and revision history.
@@ -27,7 +27,6 @@
 #include <boost/archive/archive_exception.hpp>
 #include <boost/archive/basic_binary_iprimitive.hpp>
 #include <boost/archive/detail/common_iarchive.hpp>
-#include <boost/archive/shared_ptr_helper.hpp>
 #include <boost/archive/detail/register_archive.hpp>
 
 #include "portable_binary_archive.hpp"
@@ -35,20 +34,21 @@
 /////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
 // exception to be thrown if integer read from archive doesn't fit
 // variable being loaded
-class portable_binary_iarchive_exception : 
+class portable_binary_iarchive_exception :
     public boost::archive::archive_exception
 {
 public:
-    typedef enum {
-        incompatible_integer_size 
-    } exception_code;
+    enum exception_code {
+        incompatible_integer_size
+    } m_exception_code ;
     portable_binary_iarchive_exception(exception_code c = incompatible_integer_size ) :
-        boost::archive::archive_exception(boost::archive::archive_exception::other_exception)
+        boost::archive::archive_exception(boost::archive::archive_exception::other_exception),
+        m_exception_code(c)
     {}
     virtual const char *what( ) const throw( )
     {
         const char *msg = "programmer error";
-        switch(code){
+        switch(m_exception_code){
         case incompatible_integer_size:
             msg = "integer cannot be represented";
             break;
@@ -62,24 +62,22 @@ 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 :
     public boost::archive::basic_binary_iprimitive<
         portable_binary_iarchive,
-        std::istream::char_type, 
+        std::istream::char_type,
         std::istream::traits_type
     >,
     public boost::archive::detail::common_iarchive<
         portable_binary_iarchive
     >
-    ,
-    public boost::archive::detail::shared_ptr_helper
     {
     typedef boost::archive::basic_binary_iprimitive<
         portable_binary_iarchive,
-        std::istream::char_type, 
+        std::istream::char_type,
         std::istream::traits_type
     > primitive_base_t;
     typedef boost::archive::detail::common_iarchive<
@@ -150,27 +148,21 @@ protected:
     void load(unsigned char & t){
         this->primitive_base_t::load(t);
     }
-    // intermediate level to support override of operators
-    // fot templates in the absence of partial function 
-    // template ordering
-    typedef boost::archive::detail::common_iarchive<portable_binary_iarchive> 
+    typedef boost::archive::detail::common_iarchive<portable_binary_iarchive>
         detail_common_iarchive;
     template<class T>
-    void load_override(T & t, BOOST_PFTO int){
-        this->detail_common_iarchive::load_override(t, 0);
+    void load_override(T & t){
+        this->detail_common_iarchive::load_override(t);
     }
-    void load_override(boost::archive::class_name_type & t, int);
-    // binary files don't include the optional information 
-    void load_override(
-        boost::archive::class_id_optional_type & /* t */, 
-        int
-    ){}
+    void load_override(boost::archive::class_name_type & t);
+    // binary files don't include the optional information
+    void load_override(boost::archive::class_id_optional_type &){}
 
     void init(unsigned int flags);
 public:
     portable_binary_iarchive(std::istream & is, unsigned flags = 0) :
         primitive_base_t(
-            * is.rdbuf(), 
+            * is.rdbuf(),
             0 != (flags & boost::archive::no_codecvt)
         ),
         archive_base_t(flags),
@@ -181,13 +173,13 @@ public:
 
     portable_binary_iarchive(
         std::basic_streambuf<
-            std::istream::char_type, 
+            std::istream::char_type,
             std::istream::traits_type
-        > & bsb, 
+        > & bsb,
         unsigned int flags
     ) :
         primitive_base_t(
-            bsb, 
+            bsb,
             0 != (flags & boost::archive::no_codecvt)
         ),
         archive_base_t(flags),

example/portable_binary_oarchive.cpp

@@ -1,18 +1,18 @@
 /////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
 // portable_binary_oarchive.cpp
 
-// (C) Copyright 2002-7 Robert Ramey - http://www.rrsd.com . 
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+// (C) Copyright 2002-7 Robert Ramey - http://www.rrsd.com .
+// Distributed under the Boost Software License, Version 1.0.
+// (See accompanying file LICENSE_1_0.txt or copy at
 // http://www.boost.org/LICENSE_1_0.txt)
 
 //  See http://www.boost.org for updates, documentation, and revision history.
 
 #include <ostream>
-#include <boost/detail/endian.hpp>
+#include <boost/predef/other/endian.h>
 #include "portable_binary_oarchive.hpp"
 
-void 
+void
 portable_binary_oarchive::save_impl(
     const boost::intmax_t l,
     const char maxsize
@@ -45,7 +45,7 @@ portable_binary_oarchive::save_impl(
     else
         ll = l;
     char * cptr = reinterpret_cast<char *>(& ll);
-    #ifdef BOOST_BIG_ENDIAN
+    #if BOOST_ENDIAN_BIG_BYTE
         cptr += (sizeof(boost::intmax_t) - size);
         if(m_flags & endian_little)
             reverse_bytes(size, cptr);
@@ -56,7 +56,7 @@ portable_binary_oarchive::save_impl(
     this->primitive_base_t::save_binary(cptr, size);
 }
 
-void 
+void
 portable_binary_oarchive::init(unsigned int flags) {
     if(m_flags == (endian_big | endian_little)){
         boost::serialization::throw_exception(
@@ -90,7 +90,7 @@ namespace detail {
 
 template class basic_binary_oprimitive<
     portable_binary_oarchive,
-    std::ostream::char_type, 
+    std::ostream::char_type,
     std::ostream::traits_type
 > ;
 

example/portable_binary_oarchive.hpp

@@ -2,7 +2,7 @@
 #define PORTABLE_BINARY_OARCHIVE_HPP
 
 // MS compatible compilers support #pragma once
-#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+#if defined(_MSC_VER)
 # pragma once
 #endif
 
@@ -14,9 +14,9 @@
 /////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
 // portable_binary_oarchive.hpp
 
-// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
+// Distributed under the Boost Software License, Version 1.0.
+// (See accompanying file LICENSE_1_0.txt or copy at
 // http://www.boost.org/LICENSE_1_0.txt)
 
 //  See http://www.boost.org for updates, documentation, and revision history.
@@ -33,12 +33,12 @@
 /////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
 // exception to be thrown if integer read from archive doesn't fit
 // variable being loaded
-class portable_binary_oarchive_exception : 
+class portable_binary_oarchive_exception :
     public boost::archive::archive_exception
 {
 public:
     typedef enum {
-        invalid_flags 
+        invalid_flags
     } exception_code;
     portable_binary_oarchive_exception(exception_code c = invalid_flags )
     {}
@@ -56,14 +56,14 @@ 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
+// "Portable" output binary archive.  This is a variation of the native 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_oarchive :
     public boost::archive::basic_binary_oprimitive<
         portable_binary_oarchive,
-        std::ostream::char_type, 
+        std::ostream::char_type,
         std::ostream::traits_type
     >,
     public boost::archive::detail::common_oarchive<
@@ -72,7 +72,7 @@ class portable_binary_oarchive :
 {
     typedef boost::archive::basic_binary_oprimitive<
         portable_binary_oarchive,
-        std::ostream::char_type, 
+        std::ostream::char_type,
         std::ostream::traits_type
     > primitive_base_t;
     typedef boost::archive::detail::common_oarchive<
@@ -128,21 +128,20 @@ protected:
 
     // default processing - kick back to base class.  Note the
     // extra stuff to get it passed borland compilers
-    typedef boost::archive::detail::common_oarchive<portable_binary_oarchive> 
+    typedef boost::archive::detail::common_oarchive<portable_binary_oarchive>
         detail_common_oarchive;
     template<class T>
-    void save_override(T & t, BOOST_PFTO int){
-        this->detail_common_oarchive::save_override(t, 0);
+    void save_override(T & t){
+        this->detail_common_oarchive::save_override(t);
     }
     // explicitly convert to char * to avoid compile ambiguities
-    void save_override(const boost::archive::class_name_type & t, int){
+    void save_override(const boost::archive::class_name_type & t){
         const std::string s(t);
         * this << s;
     }
-    // binary files don't include the optional information 
+    // binary files don't include the optional information
     void save_override(
-        const boost::archive::class_id_optional_type & /* t */, 
-        int
+        const boost::archive::class_id_optional_type & /* t */
     ){}
 
     void init(unsigned int flags);
@@ -160,13 +159,13 @@ public:
 
     portable_binary_oarchive(
         std::basic_streambuf<
-            std::ostream::char_type, 
+            std::ostream::char_type,
             std::ostream::traits_type
-        > & bsb, 
+        > & bsb,
         unsigned int flags
     ) :
         primitive_base_t(
-            bsb, 
+            bsb,
             0 != (flags & boost::archive::no_codecvt)
         ),
         archive_base_t(flags),

example/simple_log_archive.hpp

@@ -2,16 +2,16 @@
 #define BOOST_SIMPLE_LOG_ARCHIVE_HPP
 
 // MS compatible compilers support #pragma once
-#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+#if defined(_MSC_VER)
 # pragma once
 #endif
 
 /////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
 // simple_log_archive.hpp
 
-// (C) Copyright 2010 Robert Ramey - http://www.rrsd.com . 
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+// (C) Copyright 2010 Robert Ramey - http://www.rrsd.com .
+// Distributed under the Boost Software License, Version 1.0.
+// (See accompanying file LICENSE_1_0.txt or copy at
 // http://www.boost.org/LICENSE_1_0.txt)
 
 //  See http://www.boost.org for updates, documentation, and revision history.
@@ -21,8 +21,8 @@
 
 #include <boost/config.hpp>
 #if defined(BOOST_NO_STDC_NAMESPACE)
-namespace std{ 
-    using ::size_t; 
+namespace std{
+    using ::size_t;
 } // namespace std
 #endif
 
@@ -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 {
@@ -65,15 +65,15 @@ class simple_log_archive {
             // make sure call is routed through the highest interface that might
             // be specialized by the user.
             boost::serialization::serialize_adl(
-                ar, 
-                const_cast<T &>(t), 
+                ar,
+                const_cast<T &>(t),
                 ::boost::serialization::version< T >::value
             );
         }
     };
     template<class T>
     void save(const T &t){
-        typedef 
+        typedef
             BOOST_DEDUCED_TYPENAME boost::mpl::eval_if<boost::is_enum< T >,
                 boost::mpl::identity<save_enum_type<simple_log_archive> >,
             //else
@@ -88,10 +88,10 @@ class simple_log_archive {
                 boost::mpl::identity<save_only<simple_log_archive> >
             > >::type typex;
         typex::invoke(*this, t);
-    }    
+    }
     #ifndef BOOST_NO_STD_WSTRING
     void save(const std::wstring &ws){
-        m_os << "wide string types not suported in log archive";
+        m_os << "wide string types not supported in log archive";
     }
     #endif
 
@@ -110,12 +110,12 @@ public:
         return 0;
     }
 
-    void 
+    void
     save_binary(const void *address, std::size_t count){
         m_os << "save_binary not implemented";
     }
 
-    // the << operators 
+    // the << operators
     template<class T>
     simple_log_archive & operator<<(T const & t){
         m_os << ' ';
@@ -151,7 +151,7 @@ public:
         return * this;
     }
 
-    // the & operator 
+    // the & operator
     template<class T>
     simple_log_archive & operator&(const T & t){
             return * this << t;

include/boost/archive/add_facet.hpp

@@ -1,55 +0,0 @@
-#ifndef BOOST_ARCHIVE_ADD_FACET_HPP
-#define BOOST_ARCHIVE_ADD_FACET_HPP
-
-// MS compatible compilers support #pragma once
-#if defined(_MSC_VER) && (_MSC_VER >= 1020)
-# pragma once
-#endif
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// add_facet.hpp
-
-// (C) Copyright 2003 Robert Ramey - http://www.rrsd.com . 
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
-// http://www.boost.org/LICENSE_1_0.txt)
-
-//  See http://www.boost.org for updates, documentation, and revision history.
-
-#include <locale>
-#include <boost/config.hpp>
-#include <boost/detail/workaround.hpp>
-
-// does STLport uses native STL for locales?
-#if (defined(__SGI_STL_PORT)&& defined(_STLP_NO_OWN_IOSTREAMS))
-// and this native STL lib is old Dinkumware (has not defined _CPPLIB_VER)
-#  if (defined(_YVALS) && !defined(__IBMCPP__)) || !defined(_CPPLIB_VER)
-#    define BOOST_ARCHIVE_OLD_DINKUMWARE_BENEATH_STLPORT
-#  endif
-#endif
-
-namespace boost { 
-namespace archive {
-
-template<class Facet>
-inline std::locale * 
-add_facet(const std::locale &l, Facet * f){
-    return
-        #if defined BOOST_ARCHIVE_OLD_DINKUMWARE_BENEATH_STLPORT 
-            // std namespace used for native locale
-            new std::locale(std::_Addfac(l, f));
-        #elif BOOST_WORKAROUND(BOOST_DINKUMWARE_STDLIB, == 1) // old Dinkumwar
-            // std namespace used for native locale
-            new std::locale(std::_Addfac(l, f));
-        #else
-            // standard compatible
-            new std::locale(l, f);
-        #endif
-}
-
-} // namespace archive
-} // namespace boost
-
-#undef BOOST_ARCHIVE_OLD_DINKUMWARE_BENEATH_STLPORT
-
-#endif // BOOST_ARCHIVE_ADD_FACET_HPP

include/boost/archive/archive_exception.hpp

@@ -2,16 +2,16 @@
 #define BOOST_ARCHIVE_ARCHIVE_EXCEPTION_HPP
 
 // MS compatible compilers support #pragma once
-#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+#if defined(_MSC_VER)
 # pragma once
 #endif
 
 /////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
 // archive/archive_exception.hpp:
 
-// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
+// Distributed under the Boost Software License, Version 1.0.
+// (See accompanying file LICENSE_1_0.txt or copy at
 // http://www.boost.org/LICENSE_1_0.txt)
 
 //  See http://www.boost.org for updates, documentation, and revision history.
@@ -20,17 +20,16 @@
 #include <boost/assert.hpp>
 #include <string>
 
-#include <boost/config.hpp> 
-#include <boost/preprocessor/empty.hpp>
+#include <boost/config.hpp>
 #include <boost/archive/detail/decl.hpp>
 
 // note: the only reason this is in here is that windows header
 // includes #define exception_code _exception_code (arrrgghhhh!).
 // the most expedient way to address this is be sure that this
 // header is always included whenever this header file is included.
-#if defined(BOOST_WINDOWS) 
-#include <excpt.h> 
-#endif 
+#if defined(BOOST_WINDOWS)
+#include <excpt.h>
+#endif
 
 #include <boost/archive/detail/abi_prefix.hpp> // must be the last header
 
@@ -40,16 +39,21 @@ namespace archive {
 //////////////////////////////////////////////////////////////////////
 // exceptions thrown by archives
 //
-class BOOST_ARCHIVE_DECL(BOOST_PP_EMPTY()) archive_exception : 
+class BOOST_SYMBOL_VISIBLE archive_exception :
     public virtual std::exception
 {
-protected:
+private:
     char m_buffer[128];
+protected:
+    BOOST_ARCHIVE_DECL unsigned int
+    append(unsigned int l, const char * a);
+    BOOST_ARCHIVE_DECL
+    archive_exception() BOOST_NOEXCEPT;
 public:
     typedef enum {
         no_exception,       // initialized without code
-        other_exception,    // any excepton not listed below
-        unregistered_class, // attempt to serialize a pointer of an
+        other_exception,    // any exception not listed below
+        unregistered_class, // attempt to serialize a pointer of
                             // an unregistered class
         invalid_signature,  // first line of archive does not contain
                             // expected string
@@ -57,9 +61,9 @@ public:
                             // subsequent to this one
         pointer_conflict,   // an attempt has been made to directly
                             // serialize an object which has
-                            // already been serialzed through a pointer.  
-                            // Were this permited, the archive load would result 
-                            // in the creation of an extra copy of the obect.
+                            // already been serialized through a pointer.
+                            // Were this permitted, the archive load would result
+                            // in the creation of an extra copy of the object.
         incompatible_native_format, // attempt to read native binary format
                             // on incompatible platform
         array_size_too_short,// array being loaded doesn't fit in array allocated
@@ -67,28 +71,25 @@ public:
         invalid_class_name, // class name greater than the maximum permitted.
                             // most likely a corrupted archive or an attempt
                             // to insert virus via buffer overrun method.
-        unregistered_cast,   // base - derived relationship not registered with 
+        unregistered_cast,   // base - derived relationship not registered with
                             // void_cast_register
-        unsupported_class_version, // type saved with a version # greater than the 
-                            // one used by the program.  This indicates that the proggram
+        unsupported_class_version, // type saved with a version # greater than the
+                            // 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.
         output_stream_error // error on input stream
     } exception_code;
-public:
     exception_code code;
-    archive_exception(
-        exception_code c, 
+
+    BOOST_ARCHIVE_DECL archive_exception(
+        exception_code c,
         const char * e1 = NULL,
         const char * e2 = NULL
-    );
-    virtual ~archive_exception() throw();
-    virtual const char *what() const throw();
-protected:
-    unsigned int
-    append(unsigned int l, const char * a);
-    archive_exception();
+    ) BOOST_NOEXCEPT;
+    BOOST_ARCHIVE_DECL archive_exception(archive_exception const &) BOOST_NOEXCEPT;
+    BOOST_ARCHIVE_DECL ~archive_exception() BOOST_NOEXCEPT_OR_NOTHROW BOOST_OVERRIDE;
+    BOOST_ARCHIVE_DECL const char * what() const BOOST_NOEXCEPT_OR_NOTHROW BOOST_OVERRIDE;
 };
 
 }// namespace archive

include/boost/archive/basic_archive.hpp

@@ -2,25 +2,25 @@
 #define BOOST_ARCHIVE_BASIC_ARCHIVE_HPP
 
 // MS compatible compilers support #pragma once
-#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+#if defined(_MSC_VER)
 # pragma once
 #endif
 
 /////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
 // basic_archive.hpp:
 
-// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
+// Distributed under the Boost Software License, Version 1.0.
+// (See accompanying file LICENSE_1_0.txt or copy at
 // http://www.boost.org/LICENSE_1_0.txt)
 
 //  See http://www.boost.org for updates, documentation, and revision history.
-
+#include <cstring> // count
 #include <boost/assert.hpp>
 #include <boost/config.hpp>
-#include <boost/cstdint.hpp> // size_t
-#include <boost/noncopyable.hpp>
 #include <boost/integer_traits.hpp>
+#include <boost/noncopyable.hpp>
+#include <boost/serialization/library_version_type.hpp>
 
 #include <boost/archive/detail/auto_link_archive.hpp>
 #include <boost/archive/detail/abi_prefix.hpp> // must be the last header
@@ -33,76 +33,43 @@ namespace archive {
 #pragma warning( disable : 4244 4267 )
 #endif
 
-/* NOTE : Warning  : Warning : Warning : Warning : Warning
- * Don't ever changes this.  If you do, they previously created
- * binary archives won't be readable !!!
- */
-class library_version_type {
-private:
-    typedef uint_least16_t base_type;
-    base_type t;
-public:
-    library_version_type(): t(0) {};
-    explicit library_version_type(const unsigned int & t_) : t(t_){
-        BOOST_ASSERT(t_ <= boost::integer_traits<base_type>::const_max);
-    }
-    library_version_type(const library_version_type & t_) : 
-        t(t_.t)
-    {}
-    library_version_type & operator=(const library_version_type & rhs){
-        t = rhs.t; 
-        return *this;
-    }
-    // used for text output
-    operator base_type () const {
-        return t;
-    }                
-    // used for text input
-    operator base_type & (){
-        return t;
-    }                
-    bool operator==(const library_version_type & rhs) const {
-        return t == rhs.t;
-    } 
-    bool operator<(const library_version_type & rhs) const {
-        return t < rhs.t;
-    }   
-};
-
-BOOST_ARCHIVE_DECL(library_version_type)
+BOOST_ARCHIVE_DECL boost::serialization::library_version_type
 BOOST_ARCHIVE_VERSION();
 
+// create alias in boost::archive for older user code.
+typedef boost::serialization::library_version_type library_version_type;
+
 class version_type {
 private:
     typedef uint_least32_t base_type;
     base_type t;
 public:
     // should be private - but MPI fails if it's not!!!
-    version_type(): t(0) {};
+    version_type(): t(0) {}
     explicit version_type(const unsigned int & t_) : t(t_){
         BOOST_ASSERT(t_ <= boost::integer_traits<base_type>::const_max);
     }
-    version_type(const version_type & t_) : 
+    version_type(const version_type & t_) :
         t(t_.t)
     {}
     version_type & operator=(const version_type & rhs){
-        t = rhs.t; 
+        t = rhs.t;
         return *this;
     }
     // used for text output
     operator base_type () const {
         return t;
-    }                
-    // used for text intput
+    }
+    // used for text input
     operator base_type  & (){
         return t;
-    }                
+    }
     bool operator==(const version_type & rhs) const {
         return t == rhs.t;
-    } 
+    }
     bool operator<(const version_type & rhs) const {
         return t < rhs.t;
-    }   
+    }
 };
 
 class class_id_type {
@@ -111,70 +78,73 @@ private:
     base_type t;
 public:
     // should be private - but then can't use BOOST_STRONG_TYPE below
-    class_id_type() : t(0) {};
+    class_id_type() : t(0) {}
     explicit class_id_type(const int t_) : t(t_){
         BOOST_ASSERT(t_ <= boost::integer_traits<base_type>::const_max);
     }
     explicit class_id_type(const std::size_t t_) : t(t_){
  //       BOOST_ASSERT(t_ <= boost::integer_traits<base_type>::const_max);
     }
-    class_id_type(const class_id_type & t_) : 
+    class_id_type(const class_id_type & t_) :
         t(t_.t)
     {}
     class_id_type & operator=(const class_id_type & rhs){
-        t = rhs.t; 
+        t = rhs.t;
         return *this;
     }
 
     // used for text output
-    operator int () const {
+    operator base_type () const {
         return t;
-    }                
+    }
     // used for text input
-    operator int_least16_t &() {
+    operator base_type &() {
         return t;
-    }                
+    }
     bool operator==(const class_id_type & rhs) const {
         return t == rhs.t;
-    } 
+    }
     bool operator<(const class_id_type & rhs) const {
         return t < rhs.t;
-    }   
+    }
 };
 
-#define NULL_POINTER_TAG boost::archive::class_id_type(-1)
+#define BOOST_SERIALIZATION_NULL_POINTER_TAG boost::archive::class_id_type(-1)
 
 class object_id_type {
 private:
     typedef uint_least32_t base_type;
     base_type t;
 public:
-    object_id_type(): t(0) {};
+    object_id_type(): t(0) {}
     // note: presumes that size_t >= unsigned int.
-    explicit object_id_type(const std::size_t & t_) : t(t_){
+    // use explicit cast to silence useless warning
+    explicit object_id_type(const std::size_t & t_) : t(static_cast<base_type>(t_)){
+        // make quadruple sure that we haven't lost any real integer
+        // precision
         BOOST_ASSERT(t_ <= boost::integer_traits<base_type>::const_max);
     }
-    object_id_type(const object_id_type & t_) : 
+    object_id_type(const object_id_type & t_) :
         t(t_.t)
     {}
     object_id_type & operator=(const object_id_type & rhs){
-        t = rhs.t; 
+        t = rhs.t;
         return *this;
     }
     // used for text output
-    operator uint_least32_t () const {
+    operator base_type () const {
         return t;
-    }                
+    }
     // used for text input
-    operator uint_least32_t & () {
+    operator base_type & () {
         return t;
-    }                
+    }
     bool operator==(const object_id_type & rhs) const {
         return t == rhs.t;
-    } 
+    }
     bool operator<(const object_id_type & rhs) const {
         return t < rhs.t;
-    }   
+    }
 };
 
 #if defined(_MSC_VER)
@@ -185,16 +155,16 @@ struct tracking_type {
     bool t;
     explicit tracking_type(const bool t_ = false)
         : t(t_)
-    {};
+    {}
     tracking_type(const tracking_type & t_)
         : t(t_.t)
     {}
     operator bool () const {
         return t;
-    };
+    }
     operator bool & () {
         return t;
-    };
+    }
     tracking_type & operator=(const bool t_){
         t = t_;
         return *this;
@@ -211,8 +181,8 @@ struct tracking_type {
     }
 };
 
-struct class_name_type : 
-    private boost::noncopyable 
+struct class_name_type :
+    private boost::noncopyable
 {
     char *t;
     operator const char * & () const {
@@ -221,9 +191,12 @@ struct class_name_type :
     operator char * () {
         return t;
     }
-    explicit class_name_type(const char *key_) 
+    std::size_t size() const {
+        return std::strlen(t);
+    }
+    explicit class_name_type(const char *key_)
     : t(const_cast<char *>(key_)){}
-    explicit class_name_type(char *key_) 
+    explicit class_name_type(char *key_)
     : t(key_){}
     class_name_type & operator=(const class_name_type & rhs){
         t = rhs.t;
@@ -239,11 +212,11 @@ enum archive_flags {
     flags_last = 8
 };
 
-BOOST_ARCHIVE_DECL(const char *)
+BOOST_ARCHIVE_DECL const char *
 BOOST_ARCHIVE_SIGNATURE();
 
 /* NOTE : Warning  : Warning : Warning : Warning : Warning
- * If any of these are changed to different sized types, 
+ * If any of these are changed to different sized types,
  * binary_iarchive won't be able to read older archives
  * unless you rev the library version and include conditional
  * code based on the library version.  There is nothing
@@ -273,7 +246,7 @@ BOOST_ARCHIVE_STRONG_TYPEDEF(object_id_type, object_reference_type)
 // set implementation level to primitive for all types
 // used internally by the serialization library
 
-BOOST_CLASS_IMPLEMENTATION(boost::archive::library_version_type, primitive_type)
+BOOST_CLASS_IMPLEMENTATION(boost::serialization::library_version_type, primitive_type)
 BOOST_CLASS_IMPLEMENTATION(boost::archive::version_type, primitive_type)
 BOOST_CLASS_IMPLEMENTATION(boost::archive::class_id_type, primitive_type)
 BOOST_CLASS_IMPLEMENTATION(boost::archive::class_id_reference_type, primitive_type)
@@ -285,10 +258,10 @@ BOOST_CLASS_IMPLEMENTATION(boost::archive::tracking_type, primitive_type)
 
 #include <boost/serialization/is_bitwise_serializable.hpp>
 
-// set types used internally by the serialization library 
+// set types used internally by the serialization library
 // to be bitwise serializable
 
-BOOST_IS_BITWISE_SERIALIZABLE(boost::archive::library_version_type)
+BOOST_IS_BITWISE_SERIALIZABLE(boost::serialization::library_version_type)
 BOOST_IS_BITWISE_SERIALIZABLE(boost::archive::version_type)
 BOOST_IS_BITWISE_SERIALIZABLE(boost::archive::class_id_type)
 BOOST_IS_BITWISE_SERIALIZABLE(boost::archive::class_id_reference_type)

include/boost/archive/basic_binary_iarchive.hpp

@@ -2,7 +2,7 @@
 #define BOOST_ARCHIVE_BASIC_BINARY_IARCHIVE_HPP
 
 // MS compatible compilers support #pragma once
-#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+#if defined(_MSC_VER)
 # pragma once
 #endif
 
@@ -10,27 +10,27 @@
 // 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
 // ON PLATFORM APART FROM THE ONE THEY ARE CREATED ON
 
-// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
+// Distributed under the Boost Software License, Version 1.0.
+// (See accompanying file LICENSE_1_0.txt or copy at
 // http://www.boost.org/LICENSE_1_0.txt)
 
 //  See http://www.boost.org for updates, documentation, and revision history.
 
 #include <boost/config.hpp>
 #include <boost/detail/workaround.hpp>
-#include <boost/serialization/pfto.hpp>
 
 #include <boost/archive/basic_archive.hpp>
 #include <boost/archive/detail/common_iarchive.hpp>
 #include <boost/serialization/collection_size_type.hpp>
 #include <boost/serialization/string.hpp>
+#include <boost/serialization/library_version_type.hpp>
 #include <boost/serialization/item_version_type.hpp>
 #include <boost/integer_traits.hpp>
 
@@ -41,33 +41,39 @@
 
 #include <boost/archive/detail/abi_prefix.hpp> // must be the last header
 
-namespace boost { 
+namespace boost {
 namespace archive {
 
+namespace detail {
+    template<class Archive> class interface_iarchive;
+} // namespace detail
+
 /////////////////////////////////////////////////////////////////////////
 // class basic_binary_iarchive - read serialized objects from a input binary stream
 template<class Archive>
-class basic_binary_iarchive : 
+class BOOST_SYMBOL_VISIBLE basic_binary_iarchive :
     public detail::common_iarchive<Archive>
 {
-protected:
-#if BOOST_WORKAROUND(BOOST_MSVC, <= 1300)
+#ifdef BOOST_NO_MEMBER_TEMPLATE_FRIENDS
 public:
-#elif defined(BOOST_MSVC)
-    // for some inexplicable reason insertion of "class" generates compile erro
-    // on msvc 7.1
-    friend detail::interface_iarchive<Archive>;
 #else
-    friend class detail::interface_iarchive<Archive>;
+protected:
+    #if BOOST_WORKAROUND(BOOST_MSVC, < 1500)
+        // for some inexplicable reason insertion of "class" generates compile erro
+        // on msvc 7.1
+        friend detail::interface_iarchive<Archive>;
+    #else
+        friend class detail::interface_iarchive<Archive>;
+    #endif
 #endif
     // intermediate level to support override of operators
-    // fot templates in the absence of partial function 
+    // 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, BOOST_PFTO int version){
-      this->detail_common_iarchive::load_override(t, static_cast<int>(version));
+    void load_override(T & t){
+      this->detail_common_iarchive::load_override(t);
     }
 
     // include these to trap a change in binary format which
@@ -79,12 +85,12 @@ public:
     BOOST_STATIC_ASSERT(sizeof(object_id_type) == sizeof(uint_least32_t));
     BOOST_STATIC_ASSERT(sizeof(object_reference_type) == sizeof(uint_least32_t));
 
-    // binary files don't include the optional information 
-    void load_override(class_id_optional_type & /* t */, int){}
+    // binary files don't include the optional information
+    void load_override(class_id_optional_type & /* t */){}
 
     void load_override(tracking_type & t, int /*version*/){
-        library_version_type lvt = this->get_library_version();
-        if(boost::archive::library_version_type(6) < lvt){
+        boost::serialization::library_version_type lv = this->get_library_version();
+        if(boost::serialization::library_version_type(6) < lv){
             int_least8_t x=0;
             * this->This() >> x;
             t = boost::archive::tracking_type(x);
@@ -95,69 +101,58 @@ public:
             t = boost::archive::tracking_type(x);
         }
     }
-    void load_override(class_id_type & t, int version){
-        library_version_type lvt = this->get_library_version();
-        if(boost::archive::library_version_type(7) < lvt){
-            this->detail_common_iarchive::load_override(t, version);
+    void load_override(class_id_type & t){
+        boost::serialization::library_version_type lv = this->get_library_version();
+        /*
+         * library versions:
+         *   boost 1.39 -> 5
+         *   boost 1.43 -> 7
+         *   boost 1.47 -> 9
+         *
+         *
+         * 1) in boost 1.43 and inferior, class_id_type is always a 16bit value, with no check on the library version
+         *   --> this means all archives with version v <= 7 are written with a 16bit class_id_type
+         * 2) in boost 1.44 this load_override has disappeared (and thus boost 1.44 is not backward compatible at all !!)
+         * 3) recent boosts reintroduced load_override with a test on the version :
+         *     - v > 7 : this->detail_common_iarchive::load_override(t, version)
+         *     - v > 6 : 16bit
+         *     - other : 32bit
+         *   --> which is obviously incorrect, see point 1
+         *
+         * the fix here decodes class_id_type on 16bit for all v <= 7, which seems to be the correct behaviour ...
+         */
+        if(boost::serialization::library_version_type (7) < lv){
+            this->detail_common_iarchive::load_override(t);
         }
-        else
-        if(boost::archive::library_version_type(6) < lvt){
+        else{
             int_least16_t x=0;
             * this->This() >> x;
             t = boost::archive::class_id_type(x);
         }
-        else{
-            int x=0;
-            * this->This() >> x;
-            t = boost::archive::class_id_type(x);
-        }
     }
-    void load_override(class_id_reference_type & t, int version){
-        load_override(static_cast<class_id_type &>(t), version);
+    void load_override(class_id_reference_type & t){
+        load_override(static_cast<class_id_type &>(t));
     }
-#if 0
-    void load_override(class_id_reference_type & t, int version){
-        library_version_type lvt = this->get_library_version();
-        if(boost::archive::library_version_type(7) < lvt){
-            this->detail_common_iarchive::load_override(t, version);
-        }
-        else
-        if(boost::archive::library_version_type(6) < lvt){
-            int_least16_t x=0;
-            * this->This() >> x;
-            t = boost::archive::class_id_reference_type(
-                boost::archive::class_id_type(x)
-            );
-        }
-        else{
-            int x=0;
-            * this->This() >> x;
-            t = boost::archive::class_id_reference_type(
-                boost::archive::class_id_type(x)
-            );
-        }
-    }
-#endif
 
-    void load_override(version_type & t, int version){
-        library_version_type lvt = this->get_library_version();
-        if(boost::archive::library_version_type(7) < lvt){
-            this->detail_common_iarchive::load_override(t, version);
+    void load_override(version_type & t){
+        boost::serialization::library_version_type  lv = this->get_library_version();
+        if(boost::serialization::library_version_type(7) < lv){
+            this->detail_common_iarchive::load_override(t);
         }
         else
-        if(boost::archive::library_version_type(6) < lvt){
+        if(boost::serialization::library_version_type(6) < lv){
             uint_least8_t x=0;
             * this->This() >> x;
             t = boost::archive::version_type(x);
         }
         else
-        if(boost::archive::library_version_type(5) < lvt){
+        if(boost::serialization::library_version_type(5) < lv){
             uint_least16_t x=0;
             * this->This() >> x;
             t = boost::archive::version_type(x);
         }
         else
-        if(boost::archive::library_version_type(2) < lvt){
+        if(boost::serialization::library_version_type(2) < lv){
             // upto 255 versions
             unsigned char x=0;
             * this->This() >> x;
@@ -170,14 +165,14 @@ public:
         }
     }
 
-    void load_override(boost::serialization::item_version_type & t, int version){
-        library_version_type lvt = this->get_library_version();
-//        if(boost::archive::library_version_type(7) < lvt){
-        if(boost::archive::library_version_type(6) < lvt){
-            this->detail_common_iarchive::load_override(t, version);
+    void load_override(boost::serialization::item_version_type & t){
+        boost::serialization::library_version_type lv = this->get_library_version();
+//        if(boost::serialization::library_version_type(7) < lvt){
+        if(boost::serialization::library_version_type(6) < lv){
+            this->detail_common_iarchive::load_override(t);
         }
         else
-        if(boost::archive::library_version_type(6) < lvt){
+        if(boost::serialization::library_version_type(6) < lv){
             uint_least16_t x=0;
             * this->This() >> x;
             t = boost::serialization::item_version_type(x);
@@ -189,22 +184,22 @@ public:
         }
     }
 
-    void load_override(serialization::collection_size_type & t, int version){
-        if(boost::archive::library_version_type(5) < this->get_library_version()){
-            this->detail_common_iarchive::load_override(t, version);
+    void load_override(serialization::collection_size_type & t){
+        if(boost::serialization::library_version_type(5) < this->get_library_version()){
+            this->detail_common_iarchive::load_override(t);
         }
         else{
             unsigned int x=0;
             * this->This() >> x;
             t = serialization::collection_size_type(x);
-        } 
+        }
     }
 
-    BOOST_ARCHIVE_OR_WARCHIVE_DECL(void)
-    load_override(class_name_type & t, int);
-    BOOST_ARCHIVE_OR_WARCHIVE_DECL(void)
+    BOOST_ARCHIVE_OR_WARCHIVE_DECL void
+    load_override(class_name_type & t);
+    BOOST_ARCHIVE_OR_WARCHIVE_DECL void
     init();
-   
+
     basic_binary_iarchive(unsigned int flags) :
         detail::common_iarchive<Archive>(flags)
     {}

include/boost/archive/basic_binary_iprimitive.hpp

@@ -2,7 +2,7 @@
 #define BOOST_ARCHIVE_BINARY_IPRIMITIVE_HPP
 
 // MS compatible compilers support #pragma once
-#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+#if defined(_MSC_VER)
 # pragma once
 #endif
 
@@ -14,15 +14,15 @@
 // 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
 // ON PLATFORM APART FROM THE ONE THEY ARE CREATED ON
 
-// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
+// Distributed under the Boost Software License, Version 1.0.
+// (See accompanying file LICENSE_1_0.txt or copy at
 // http://www.boost.org/LICENSE_1_0.txt)
 
 //  See http://www.boost.org for updates, documentation, and revision history.
@@ -37,34 +37,33 @@
 
 #include <boost/config.hpp>
 #if defined(BOOST_NO_STDC_NAMESPACE)
-namespace std{ 
-    using ::memcpy; 
+namespace std{
+    using ::memcpy;
     using ::size_t;
 } // namespace std
 #endif
 
 #include <boost/cstdint.hpp>
-#include <boost/scoped_ptr.hpp>
 #include <boost/serialization/throw_exception.hpp>
 #include <boost/integer.hpp>
 #include <boost/integer_traits.hpp>
 
-#include <boost/archive/basic_streambuf_locale_saver.hpp>
-#include <boost/archive/archive_exception.hpp>
-#include <boost/mpl/placeholders.hpp>
 #include <boost/serialization/is_bitwise_serializable.hpp>
-#include <boost/serialization/array.hpp>
+#include <boost/serialization/array_wrapper.hpp>
+
+#include <boost/archive/basic_streambuf_locale_saver.hpp>
+#include <boost/archive/codecvt_null.hpp>
+#include <boost/archive/archive_exception.hpp>
 #include <boost/archive/detail/auto_link_archive.hpp>
 #include <boost/archive/detail/abi_prefix.hpp> // must be the last header
 
-namespace boost { 
+namespace boost {
 namespace archive {
 
 /////////////////////////////////////////////////////////////////////////////
 // class binary_iarchive - read serialized objects from a input binary stream
 template<class Archive, class Elem, class Tr>
-class basic_binary_iprimitive
-{
+class BOOST_SYMBOL_VISIBLE basic_binary_iprimitive {
 #ifndef BOOST_NO_MEMBER_TEMPLATE_FRIENDS
     friend class load_access;
 protected:
@@ -78,11 +77,19 @@ public:
     }
 
     #ifndef BOOST_NO_STD_LOCALE
-    boost::scoped_ptr<std::locale> archive_locale;
+    // note order! - if you change this, libstd++ will fail!
+    // a) create new locale with new codecvt facet
+    // b) save current locale
+    // c) change locale to new one
+    // d) use stream buffer
+    // e) change locale back to original
+    // f) destroy new codecvt facet
+    boost::archive::codecvt_null<Elem> codecvt_null_facet;
     basic_streambuf_locale_saver<Elem, Tr> locale_saver;
+    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));
@@ -90,52 +97,52 @@ public:
 
     /////////////////////////////////////////////////////////
     // fundamental types that need special treatment
-    
-    // trap usage of invalid uninitialized boolean 
+
+    // trap usage of invalid uninitialized boolean
     void load(bool & t){
         load_binary(& t, sizeof(t));
         int i = t;
         BOOST_ASSERT(0 == i || 1 == i);
         (void)i; // warning suppression for release builds.
     }
-    BOOST_ARCHIVE_OR_WARCHIVE_DECL(void)
+    BOOST_ARCHIVE_OR_WARCHIVE_DECL void
     load(std::string &s);
     #ifndef BOOST_NO_STD_WSTRING
-    BOOST_ARCHIVE_OR_WARCHIVE_DECL(void)
+    BOOST_ARCHIVE_OR_WARCHIVE_DECL void
     load(std::wstring &ws);
     #endif
-    BOOST_ARCHIVE_OR_WARCHIVE_DECL(void)
+    BOOST_ARCHIVE_OR_WARCHIVE_DECL void
     load(char * t);
-    BOOST_ARCHIVE_OR_WARCHIVE_DECL(void)
+    BOOST_ARCHIVE_OR_WARCHIVE_DECL void
     load(wchar_t * t);
 
-    BOOST_ARCHIVE_OR_WARCHIVE_DECL(void)
+    BOOST_ARCHIVE_OR_WARCHIVE_DECL void
     init();
-    BOOST_ARCHIVE_OR_WARCHIVE_DECL(BOOST_PP_EMPTY()) 
+    BOOST_ARCHIVE_OR_WARCHIVE_DECL
     basic_binary_iprimitive(
-        std::basic_streambuf<Elem, Tr> & sb, 
+        std::basic_streambuf<Elem, Tr> & sb,
         bool no_codecvt
     );
-    BOOST_ARCHIVE_OR_WARCHIVE_DECL(BOOST_PP_EMPTY()) 
+    BOOST_ARCHIVE_OR_WARCHIVE_DECL
     ~basic_binary_iprimitive();
 public:
     // we provide an optimized load for all fundamental types
-    // typedef serialization::is_bitwise_serializable<mpl::_1> 
+    // typedef serialization::is_bitwise_serializable<mpl::_1>
     // use_array_optimization;
-    struct use_array_optimization {  
-        template <class T>  
-        #if defined(BOOST_NO_DEPENDENT_NESTED_DERIVATIONS)  
-            struct apply {  
-                typedef BOOST_DEDUCED_TYPENAME boost::serialization::is_bitwise_serializable< T >::type type;  
+    struct use_array_optimization {
+        template <class T>
+        #if defined(BOOST_NO_DEPENDENT_NESTED_DERIVATIONS)
+            struct apply {
+                typedef typename boost::serialization::is_bitwise_serializable< T >::type type;
             };
         #else
-            struct apply : public boost::serialization::is_bitwise_serializable< T > {};  
+            struct apply : public boost::serialization::is_bitwise_serializable< T > {};
         #endif
     };
 
-    // the optimized load_array dispatches to load_binary 
+    // the optimized load_array dispatches to load_binary
     template <class ValueType>
-    void load_array(serialization::array<ValueType>& a, unsigned int)
+    void load_array(serialization::array_wrapper<ValueType>& a, unsigned int)
     {
       load_binary(a.address(),a.count()*sizeof(ValueType));
     }
@@ -147,17 +154,17 @@ public:
 template<class Archive, class Elem, class Tr>
 inline void
 basic_binary_iprimitive<Archive, Elem, Tr>::load_binary(
-    void *address, 
+    void *address,
     std::size_t count
 ){
     // note: an optimizer should eliminate the following for char files
     BOOST_ASSERT(
-        static_cast<std::streamsize>(count / sizeof(Elem)) 
+        static_cast<std::streamsize>(count / sizeof(Elem))
         <= boost::integer_traits<std::streamsize>::const_max
     );
     std::streamsize s = static_cast<std::streamsize>(count / sizeof(Elem));
     std::streamsize scount = m_sb.sgetn(
-        static_cast<Elem *>(address), 
+        static_cast<Elem *>(address),
         s
     );
     if(scount != s)
@@ -178,7 +185,7 @@ basic_binary_iprimitive<Archive, Elem, Tr>::load_binary(
             boost::serialization::throw_exception(
                 archive_exception(archive_exception::input_stream_error)
             );
-        std::memcpy(static_cast<char*>(address) + (count - s), &t, s);
+        std::memcpy(static_cast<char*>(address) + (count - s), &t, static_cast<std::size_t>(s));
     }
 }
 

include/boost/archive/basic_binary_oarchive.hpp

@@ -2,22 +2,22 @@
 #define BOOST_ARCHIVE_BASIC_BINARY_OARCHIVE_HPP
 
 // MS compatible compilers support #pragma once
-#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+#if defined(_MSC_VER)
 # pragma once
 #endif
 
 /////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
 // basic_binary_oarchive.hpp
 
-// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
+// Distributed under the Boost Software License, Version 1.0.
+// (See accompanying file LICENSE_1_0.txt or copy at
 // http://www.boost.org/LICENSE_1_0.txt)
 
 //  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
@@ -26,7 +26,6 @@
 #include <boost/assert.hpp>
 #include <boost/config.hpp>
 #include <boost/detail/workaround.hpp>
-#include <boost/serialization/pfto.hpp>
 
 #include <boost/integer.hpp>
 #include <boost/integer_traits.hpp>
@@ -46,33 +45,39 @@
 namespace boost {
 namespace archive {
 
+namespace detail {
+    template<class Archive> class interface_oarchive;
+} // 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 basic_binary_oarchive : 
-    public archive::detail::common_oarchive<Archive>
+class BOOST_SYMBOL_VISIBLE basic_binary_oarchive :
+    public detail::common_oarchive<Archive>
 {
-protected:
-#if BOOST_WORKAROUND(BOOST_MSVC, <= 1300)
+#ifdef BOOST_NO_MEMBER_TEMPLATE_FRIENDS
 public:
-#elif defined(BOOST_MSVC)
-    // for some inexplicable reason insertion of "class" generates compile erro
-    // on msvc 7.1
-    friend detail::interface_oarchive<Archive>;
 #else
-    friend class detail::interface_oarchive<Archive>;
+protected:
+    #if BOOST_WORKAROUND(BOOST_MSVC, < 1500)
+        // for some inexplicable reason insertion of "class" generates compile erro
+        // on msvc 7.1
+        friend detail::interface_oarchive<Archive>;
+    #else
+        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, BOOST_PFTO int version){
-      this->detail_common_oarchive::save_override(t, static_cast<int>(version));
+    void save_override(const T & t){
+      this->detail_common_oarchive::save_override(t);
     }
 
     // include these to trap a change in binary format which
@@ -85,18 +90,18 @@ public:
     BOOST_STATIC_ASSERT(sizeof(object_id_type) == sizeof(uint_least32_t));
     BOOST_STATIC_ASSERT(sizeof(object_reference_type) == sizeof(uint_least32_t));
 
-    // binary files don't include the optional information 
-    void save_override(const class_id_optional_type & /* t */, int){}
+    // binary files don't include the optional information
+    void save_override(const class_id_optional_type & /* t */){}
 
     // enable this if we decide to support generation of previous versions
     #if 0
-    void save_override(const boost::archive::version_type & t, int version){
+    void save_override(const boost::archive::version_type & t){
         library_version_type lvt = this->get_library_version();
-        if(boost::archive::library_version_type(7) < lvt){
-            this->detail_common_oarchive::save_override(t, version);
+        if(boost::serialization::library_version_type(7) < lvt){
+            this->detail_common_oarchive::save_override(t);
         }
         else
-        if(boost::archive::library_version_type(6) < lvt){
+        if(boost::serialization::library_version_type(6) < lvt){
             const boost::uint_least16_t x = t;
             * this->This() << x;
         }
@@ -105,13 +110,13 @@ public:
             * this->This() << x;
         }
     }
-    void save_override(const boost::serialization::item_version_type & t, int version){
+    void save_override(const boost::serialization::item_version_type & t){
         library_version_type lvt = this->get_library_version();
-        if(boost::archive::library_version_type(7) < lvt){
-            this->detail_common_oarchive::save_override(t, version);
+        if(boost::serialization::library_version_type(7) < lvt){
+            this->detail_common_oarchive::save_override(t);
         }
         else
-        if(boost::archive::library_version_type(6) < lvt){
+        if(boost::serialization::library_version_type(6) < lvt){
             const boost::uint_least16_t x = t;
             * this->This() << x;
         }
@@ -121,13 +126,13 @@ public:
         }
     }
 
-    void save_override(class_id_type & t, int version){
+    void save_override(class_id_type & t){
         library_version_type lvt = this->get_library_version();
-        if(boost::archive::library_version_type(7) < lvt){
-            this->detail_common_oarchive::save_override(t, version);
+        if(boost::serialization::library_version_type(7) < lvt){
+            this->detail_common_oarchive::save_override(t);
         }
         else
-        if(boost::archive::library_version_type(6) < lvt){
+        if(boost::serialization::library_version_type(6) < lvt){
             const boost::int_least16_t x = t;
             * this->This() << x;
         }
@@ -136,31 +141,31 @@ public:
             * this->This() << x;
         }
     }
-    void save_override(class_id_reference_type & t, int version){
-        save_override(static_cast<class_id_type &>(t), version);
+    void save_override(class_id_reference_type & t){
+        save_override(static_cast<class_id_type &>(t));
     }
 
     #endif
 
     // explicitly convert to char * to avoid compile ambiguities
-    void save_override(const class_name_type & t, int){
+    void save_override(const class_name_type & t){
         const std::string s(t);
         * this->This() << s;
     }
 
     #if 0
-    void save_override(const serialization::collection_size_type & t, int){
-        if (get_library_version() < boost::archive::library_version_type(6)){
+    void save_override(const serialization::collection_size_type & t){
+        if (get_library_version() < boost::serialization::library_version_type(6)){
             unsigned int x=0;
             * this->This() >> x;
             t = serialization::collection_size_type(x);
-        } 
+        }
         else{
             * this->This() >> t;
         }
     }
     #endif
-    BOOST_ARCHIVE_OR_WARCHIVE_DECL(void)
+    BOOST_ARCHIVE_OR_WARCHIVE_DECL void
     init();
 
     basic_binary_oarchive(unsigned int flags) :

include/boost/archive/basic_binary_oprimitive.hpp

@@ -2,22 +2,22 @@
 #define BOOST_ARCHIVE_BASIC_BINARY_OPRIMITIVE_HPP
 
 // MS compatible compilers support #pragma once
-#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+#if defined(_MSC_VER)
 # pragma once
 #endif
 
 /////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
 // basic_binary_oprimitive.hpp
 
-// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
+// Distributed under the Boost Software License, Version 1.0.
+// (See accompanying file LICENSE_1_0.txt or copy at
 // http://www.boost.org/LICENSE_1_0.txt)
 
 //  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
@@ -32,8 +32,8 @@
 
 #include <boost/config.hpp>
 #if defined(BOOST_NO_STDC_NAMESPACE)
-namespace std{ 
-    using ::size_t; 
+namespace std{
+    using ::size_t;
 } // namespace std
 #endif
 
@@ -43,11 +43,12 @@ namespace std{
 #include <boost/scoped_ptr.hpp>
 #include <boost/serialization/throw_exception.hpp>
 
-#include <boost/archive/basic_streambuf_locale_saver.hpp>
-#include <boost/archive/archive_exception.hpp>
 #include <boost/serialization/is_bitwise_serializable.hpp>
-#include <boost/mpl/placeholders.hpp>
-#include <boost/serialization/array.hpp>
+#include <boost/serialization/array_wrapper.hpp>
+
+#include <boost/archive/basic_streambuf_locale_saver.hpp>
+#include <boost/archive/codecvt_null.hpp>
+#include <boost/archive/archive_exception.hpp>
 #include <boost/archive/detail/auto_link_archive.hpp>
 #include <boost/archive/detail/abi_prefix.hpp> // must be the last header
 
@@ -55,11 +56,10 @@ 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 basic_binary_oprimitive
-{
+class BOOST_SYMBOL_VISIBLE basic_binary_oprimitive {
 #ifndef BOOST_NO_MEMBER_TEMPLATE_FRIENDS
     friend class save_access;
 protected:
@@ -72,8 +72,16 @@ public:
         return static_cast<Archive *>(this);
     }
     #ifndef BOOST_NO_STD_LOCALE
-    boost::scoped_ptr<std::locale> archive_locale;
+    // note order! - if you change this, libstd++ will fail!
+    // a) create new locale with new codecvt facet
+    // b) save current locale
+    // c) change locale to new one
+    // d) use stream buffer
+    // e) change locale back to original
+    // f) destroy new codecvt facet
+    boost::archive::codecvt_null<Elem> codecvt_null_facet;
     basic_streambuf_locale_saver<Elem, Tr> locale_saver;
+    std::locale archive_locale;
     #endif
     // default saving of primitives.
     template<class T>
@@ -84,55 +92,54 @@ public:
 
     /////////////////////////////////////////////////////////
     // fundamental types that need special treatment
-    
+
     // trap usage of invalid uninitialized boolean which would
     // otherwise crash on load.
     void save(const bool t){
         BOOST_ASSERT(0 == static_cast<int>(t) || 1 == static_cast<int>(t));
         save_binary(& t, sizeof(t));
     }
-    BOOST_ARCHIVE_OR_WARCHIVE_DECL(void)
+    BOOST_ARCHIVE_OR_WARCHIVE_DECL void
     save(const std::string &s);
     #ifndef BOOST_NO_STD_WSTRING
-    BOOST_ARCHIVE_OR_WARCHIVE_DECL(void)
+    BOOST_ARCHIVE_OR_WARCHIVE_DECL void
     save(const std::wstring &ws);
     #endif
-    BOOST_ARCHIVE_OR_WARCHIVE_DECL(void)
+    BOOST_ARCHIVE_OR_WARCHIVE_DECL void
     save(const char * t);
-    BOOST_ARCHIVE_OR_WARCHIVE_DECL(void)
+    BOOST_ARCHIVE_OR_WARCHIVE_DECL void
     save(const wchar_t * t);
 
-    BOOST_ARCHIVE_OR_WARCHIVE_DECL(void)
+    BOOST_ARCHIVE_OR_WARCHIVE_DECL void
     init();
-    
-    BOOST_ARCHIVE_OR_WARCHIVE_DECL(BOOST_PP_EMPTY()) 
+
+    BOOST_ARCHIVE_OR_WARCHIVE_DECL
     basic_binary_oprimitive(
-        std::basic_streambuf<Elem, Tr> & sb, 
+        std::basic_streambuf<Elem, Tr> & sb,
         bool no_codecvt
     );
-    BOOST_ARCHIVE_OR_WARCHIVE_DECL(BOOST_PP_EMPTY()) 
+    BOOST_ARCHIVE_OR_WARCHIVE_DECL
     ~basic_binary_oprimitive();
 public:
 
     // we provide an optimized save for all fundamental types
-    // typedef serialization::is_bitwise_serializable<mpl::_1> 
+    // typedef serialization::is_bitwise_serializable<mpl::_1>
     // use_array_optimization;
     // workaround without using mpl lambdas
     struct use_array_optimization {
-        template <class T>  
-        #if defined(BOOST_NO_DEPENDENT_NESTED_DERIVATIONS)  
-            struct apply {  
-                typedef BOOST_DEDUCED_TYPENAME boost::serialization::is_bitwise_serializable< T >::type type;  
+        template <class T>
+        #if defined(BOOST_NO_DEPENDENT_NESTED_DERIVATIONS)
+            struct apply {
+                typedef typename boost::serialization::is_bitwise_serializable< T >::type type;
             };
         #else
-            struct apply : public boost::serialization::is_bitwise_serializable< T > {};  
+            struct apply : public boost::serialization::is_bitwise_serializable< T > {};
         #endif
     };
-    
 
-    // the optimized save_array dispatches to save_binary 
+    // the optimized save_array dispatches to save_binary
     template <class ValueType>
-    void save_array(boost::serialization::array<ValueType> const& a, unsigned int)
+    void save_array(boost::serialization::array_wrapper<ValueType> const& a, unsigned int)
     {
       save_binary(a.address(),a.count()*sizeof(ValueType));
     }
@@ -141,28 +148,24 @@ public:
 };
 
 template<class Archive, class Elem, class Tr>
-inline void 
+inline void
 basic_binary_oprimitive<Archive, Elem, Tr>::save_binary(
-    const void *address, 
+    const void *address,
     std::size_t count
 ){
-    //BOOST_ASSERT(
-    //    static_cast<std::size_t>((std::numeric_limits<std::streamsize>::max)()) >= count
-    //);
+    // 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(
     //        archive_exception(archive_exception::output_stream_error)
     //    );
     // figure number of elements to output - round up
-    count = ( count + sizeof(Elem) - 1) 
-        / sizeof(Elem);
-    BOOST_ASSERT(count <= std::size_t(boost::integer_traits<std::streamsize>::const_max));
+    count = ( count + sizeof(Elem) - 1) / sizeof(Elem);
     std::streamsize scount = m_sb.sputn(
-        static_cast<const Elem *>(address), 
+        static_cast<const Elem *>(address),
         static_cast<std::streamsize>(count)
     );
     if(count != static_cast<std::size_t>(scount))
@@ -170,14 +173,14 @@ basic_binary_oprimitive<Archive, Elem, Tr>::save_binary(
             archive_exception(archive_exception::output_stream_error)
         );
     //os.write(
-    //    static_cast<const BOOST_DEDUCED_TYPENAME OStream::char_type *>(address), 
+    //    static_cast<const typename OStream::char_type *>(address),
     //    count
     //);
     //BOOST_ASSERT(os.good());
 }
 
-} //namespace boost 
-} //namespace archive 
+} //namespace boost
+} //namespace archive
 
 #include <boost/archive/detail/abi_suffix.hpp> // pop pragmas
 

include/boost/archive/basic_streambuf_locale_saver.hpp

@@ -2,17 +2,17 @@
 #define BOOST_ARCHIVE_BASIC_STREAMBUF_LOCALE_SAVER_HPP
 
 // MS compatible compilers support #pragma once
-#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+#if defined(_MSC_VER)
 # pragma once
 #endif
 
 /////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// basic_streambuf_local_saver.hpp
+// basic_streambuf_locale_saver.hpp
 
 // (C) Copyright 2005 Robert Ramey - http://www.rrsd.com
 
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+// Distributed under the Boost Software License, Version 1.0.
+// (See accompanying file LICENSE_1_0.txt or copy at
 // http://www.boost.org/LICENSE_1_0.txt)
 
 //  See http://www.boost.org for updates, documentation, and revision history.
@@ -27,6 +27,7 @@
 #ifndef BOOST_NO_STD_LOCALE
 
 #include <locale>     // for std::locale
+#include <ios>
 #include <streambuf>  // for std::basic_streambuf
 
 #include <boost/config.hpp>
@@ -45,23 +46,57 @@ class basic_streambuf_locale_saver :
     private boost::noncopyable
 {
 public:
-    typedef ::std::basic_streambuf<Ch, Tr> state_type;
-    typedef ::std::locale aspect_type;
-    explicit basic_streambuf_locale_saver( state_type &s )
-        : s_save_( s ), a_save_( s.getloc() )
-        {}
-    basic_streambuf_locale_saver( state_type &s, aspect_type const &a )
-        : s_save_( s ), a_save_( s.pubimbue(a) )
-        {}
-    ~basic_streambuf_locale_saver()
-        { this->restore(); }
-    void  restore()
-        { s_save_.pubimbue( a_save_ ); }
+    explicit basic_streambuf_locale_saver(std::basic_streambuf<Ch, Tr> &s) :
+        m_streambuf(s),
+        m_locale(s.getloc())
+    {}
+    ~basic_streambuf_locale_saver(){
+        m_streambuf.pubsync();
+        m_streambuf.pubimbue(m_locale);
+    }
 private:
-    state_type &       s_save_;
-    aspect_type const  a_save_;
+    std::basic_streambuf<Ch, Tr> &       m_streambuf;
+    std::locale const  m_locale;
 };
 
+template < typename Ch, class Tr >
+class basic_istream_locale_saver :
+    private boost::noncopyable
+{
+public:
+    explicit basic_istream_locale_saver(std::basic_istream<Ch, Tr> &s) :
+        m_istream(s),
+        m_locale(s.getloc())
+    {}
+    ~basic_istream_locale_saver(){
+        // libstdc++ crashes without this
+        m_istream.sync();
+        m_istream.imbue(m_locale);
+    }
+private:
+    std::basic_istream<Ch, Tr> & m_istream;
+    std::locale const  m_locale;
+};
+
+template < typename Ch, class Tr >
+class basic_ostream_locale_saver :
+    private boost::noncopyable
+{
+public:
+    explicit basic_ostream_locale_saver(std::basic_ostream<Ch, Tr> &s) :
+        m_ostream(s),
+        m_locale(s.getloc())
+    {}
+    ~basic_ostream_locale_saver(){
+        m_ostream.flush();
+        m_ostream.imbue(m_locale);
+    }
+private:
+    std::basic_ostream<Ch, Tr> & m_ostream;
+    std::locale const  m_locale;
+};
+
+
 } // archive
 } // boost