[ { "path": ".drone/drone.sh", "content": "#!/bin/bash\n\n# Copyright 2020 Rene Rivera, Sam Darwin\n# Distributed under the Boost Software License, Version 1.0.\n# (See accompanying file LICENSE.txt or copy at http://boost.org/LICENSE_1_0.txt)\n\nset -e\nexport TRAVIS_BUILD_DIR=$(pwd)\nexport DRONE_BUILD_DIR=$(pwd)\nexport TRAVIS_BRANCH=$DRONE_BRANCH\nexport VCS_COMMIT_ID=$DRONE_COMMIT\nexport GIT_COMMIT=$DRONE_COMMIT\nexport REPO_NAME=$DRONE_REPO\nexport PATH=~/.local/bin:/usr/local/bin:$PATH\n\nif [ \"$DRONE_JOB_BUILDTYPE\" == \"boost\" ]; then\n\necho '==================================> INSTALL'\n\nBOOST_BRANCH=develop && [ \"$TRAVIS_BRANCH\" == \"master\" ] && BOOST_BRANCH=master || true\ncd ..\ngit clone -b $BOOST_BRANCH https://github.com/boostorg/boost.git boost-root\ncd boost-root\ngit submodule update --init tools/build\ngit submodule update --init libs/config\ngit submodule update --init tools/boostdep\ncp -r $TRAVIS_BUILD_DIR/* libs/serialization\npython tools/boostdep/depinst/depinst.py serialization\n./bootstrap.sh\n./b2 headers\n\necho '==================================> SCRIPT'\n\necho \"using $TOOLSET : : $TRAVIS_COMPILER ;\" > ~/user-config.jam\n./b2 -j 3 libs/serialization/test toolset=$TOOLSET link=${LINK:-shared}\n\nfi\n" }, { "path": ".drone.star", "content": "# Use, modification, and distribution are\n# subject to the Boost Software License, Version 1.0. (See accompanying\n# file LICENSE.txt)\n#\n# Copyright Rene Rivera 2020.\n\n# For Drone CI we use the Starlark scripting language to reduce duplication.\n# As the yaml syntax for Drone CI is rather limited.\n#\n#\nglobalenv={}\nlinuxglobalimage=\"cppalliance/droneubuntu1604:1\"\nwindowsglobalimage=\"cppalliance/dronevs2019\"\n\ndef main(ctx):\n return [\n 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),\n 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),\n 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),\n 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),\n 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),\n 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),\n 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),\n 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),\n ]\n\n# from https://github.com/boostorg/boost-ci\nload(\"@boost_ci//ci/drone/:functions.star\", \"linux_cxx\",\"windows_cxx\",\"osx_cxx\",\"freebsd_cxx\")\n" }, { "path": ".gitattributes", "content": "* text=auto !eol svneol=native#text/plain\n*.gitattributes text svneol=native#text/plain\n\n# Scriptish formats\n*.bat text svneol=native#text/plain\n*.bsh text svneol=native#text/x-beanshell\n*.cgi text svneol=native#text/plain\n*.cmd text svneol=native#text/plain\n*.js text svneol=native#text/javascript\n*.php text svneol=native#text/x-php\n*.pl text svneol=native#text/x-perl\n*.pm text svneol=native#text/x-perl\n*.py text svneol=native#text/x-python\n*.sh eol=lf svneol=LF#text/x-sh\nconfigure eol=lf svneol=LF#text/x-sh\n\n# Image formats\n*.bmp binary svneol=unset#image/bmp\n*.gif binary svneol=unset#image/gif\n*.ico binary svneol=unset#image/ico\n*.jpeg binary svneol=unset#image/jpeg\n*.jpg binary svneol=unset#image/jpeg\n*.png binary svneol=unset#image/png\n*.tif binary svneol=unset#image/tiff\n*.tiff binary svneol=unset#image/tiff\n*.svg text svneol=native#image/svg%2Bxml\n\n# Data formats\n*.pdf binary svneol=unset#application/pdf\n*.avi binary svneol=unset#video/avi\n*.doc binary svneol=unset#application/msword\n*.dsp text svneol=crlf#text/plain\n*.dsw text svneol=crlf#text/plain\n*.eps binary svneol=unset#application/postscript\n*.gz binary svneol=unset#application/gzip\n*.mov binary svneol=unset#video/quicktime\n*.mp3 binary svneol=unset#audio/mpeg\n*.ppt binary svneol=unset#application/vnd.ms-powerpoint\n*.ps binary svneol=unset#application/postscript\n*.psd binary svneol=unset#application/photoshop\n*.rdf binary svneol=unset#text/rdf\n*.rss text svneol=unset#text/xml\n*.rtf binary svneol=unset#text/rtf\n*.sln text svneol=native#text/plain\n*.swf binary svneol=unset#application/x-shockwave-flash\n*.tgz binary svneol=unset#application/gzip\n*.vcproj text svneol=native#text/xml\n*.vcxproj text svneol=native#text/xml\n*.vsprops text svneol=native#text/xml\n*.wav binary svneol=unset#audio/wav\n*.xls binary svneol=unset#application/vnd.ms-excel\n*.zip binary svneol=unset#application/zip\n\n# Text formats\n.htaccess text svneol=native#text/plain\n*.bbk text svneol=native#text/xml\n*.cmake text svneol=native#text/plain\n*.css text svneol=native#text/css\n*.dtd text svneol=native#text/xml\n*.htm text svneol=native#text/html\n*.html text svneol=native#text/html\n*.ini text svneol=native#text/plain\n*.log text svneol=native#text/plain\n*.mak text svneol=native#text/plain\n*.qbk text svneol=native#text/plain\n*.rst text svneol=native#text/plain\n*.sql text svneol=native#text/x-sql\n*.txt text svneol=native#text/plain\n*.xhtml text svneol=native#text/xhtml%2Bxml\n*.xml text svneol=native#text/xml\n*.xsd text svneol=native#text/xml\n*.xsl text svneol=native#text/xml\n*.xslt text svneol=native#text/xml\n*.xul text svneol=native#text/xul\n*.yml text svneol=native#text/plain\nboost-no-inspect text svneol=native#text/plain\nCHANGES text svneol=native#text/plain\nCOPYING text svneol=native#text/plain\nINSTALL text svneol=native#text/plain\nJamfile text svneol=native#text/plain\nJamroot text svneol=native#text/plain\nJamfile.v2 text svneol=native#text/plain\nJamrules text svneol=native#text/plain\nMakefile* text svneol=native#text/plain\nREADME text svneol=native#text/plain\nTODO text svneol=native#text/plain\n\n# Code formats\n*.c text svneol=native#text/plain\n*.cpp text svneol=native#text/plain\n*.h text svneol=native#text/plain\n*.hpp text svneol=native#text/plain\n*.ipp text svneol=native#text/plain\n*.tpp text svneol=native#text/plain\n*.jam text svneol=native#text/plain\n*.java text svneol=native#text/plain\n" }, { "path": ".github/workflows/posix.yml", "content": "# Copyright 2020-2021 Peter Dimov\n# Copyright 2021 Andrey Semashev\n# Copyright 2021 Alexander Grund\n# Copyright 2022 James E. King III\n# Copyright 2023 Matt Borland\n#\n# Distributed under the Boost Software License, Version 1.0.\n# (See accompanying file LICENSE_1_0.txt or copy at http://boost.org/LICENSE_1_0.txt)\n\nname: POSIX\n\non:\n pull_request:\n push:\n branches:\n - master\n - develop\n - feature/**\n\nconcurrency:\n group: ${{ github.workflow }}-${{ github.ref }}\n cancel-in-progress: true\n\nenv:\n LIBRARY: serialization\n UBSAN_OPTIONS: print_stacktrace=1\n GIT_FETCH_JOBS: 8\n NET_RETRY_COUNT: 5\n DEFAULT_BUILD_VARIANT: release\n\njobs:\n CI:\n defaults:\n run:\n shell: bash\n strategy:\n fail-fast: false\n matrix:\n include:\n - toolset: gcc-4.8\n cxxstd: \"11\"\n address_model: 64\n os: ubuntu-latest\n container: ubuntu:16.04\n install:\n - g++-4.8\n sources:\n - \"ppa:ubuntu-toolchain-r/test\"\n - toolset: gcc-4.9\n cxxstd: \"11\"\n address_model: 64\n os: ubuntu-latest\n container: ubuntu:16.04\n install:\n - g++-4.9\n sources:\n - \"ppa:ubuntu-toolchain-r/test\"\n - toolset: gcc-5\n cxxstd: \"11,14,1z\"\n address_model: 64\n os: ubuntu-latest\n container: ubuntu:16.04\n install:\n - g++-5-multilib\n - toolset: gcc-5\n cxxstd: \"11-gnu,14-gnu,1z-gnu\"\n address_model: 64\n os: ubuntu-latest\n container: ubuntu:16.04\n install:\n - g++-5-multilib\n - toolset: gcc-6\n cxxstd: \"11,14,1z\"\n address_model: 64\n os: ubuntu-latest\n container: ubuntu:18.04\n install:\n - g++-6-multilib\n - toolset: gcc-7\n cxxstd: \"11,14,17\"\n address_model: 64\n os: ubuntu-latest\n container: ubuntu:18.04\n install:\n - g++-7-multilib\n - toolset: gcc-8\n cxxstd: \"11,14,17,2a\"\n address_model: 64\n os: ubuntu-latest\n container: ubuntu:18.04\n install:\n - g++-8-multilib\n - toolset: gcc-9\n cxxstd: \"11,14,17,2a\"\n address_model: 64\n os: ubuntu-20.04\n install:\n - g++-9-multilib\n - toolset: gcc-9\n cxxstd: \"11-gnu,14-gnu,17-gnu,2a-gnu\"\n address_model: 64\n os: ubuntu-20.04\n install:\n - g++-9-multilib\n - toolset: gcc-10\n cxxstd: \"11,14,17,20\"\n address_model: 64\n os: ubuntu-20.04\n install:\n - g++-10-multilib\n - toolset: gcc-11\n cxxstd: \"11,14,17,20,23\"\n address_model: 64\n os: ubuntu-22.04\n install:\n - g++-11-multilib\n - toolset: gcc-12\n cxxstd: \"11,14,17,20,23\"\n address_model: 64\n os: ubuntu-22.04\n install:\n - g++-12-multilib\n - toolset: gcc-12\n cxxstd: \"11-gnu,14-gnu,17-gnu,20-gnu,23-gnu\"\n address_model: 64\n os: ubuntu-22.04\n install:\n - g++-12-multilib\n - name: UBSAN\n toolset: gcc-12\n cxxstd: \"11,20\"\n address_model: 64\n ubsan: 1\n os: ubuntu-22.04\n install:\n - g++-12-multilib\n\n # Linux, clang\n - toolset: clang\n compiler: clang++-3.7\n cxxstd: \"11,14\"\n os: ubuntu-latest\n container: ubuntu:16.04\n install:\n - clang-3.7\n - toolset: clang\n compiler: clang++-3.8\n cxxstd: \"11,14\"\n os: ubuntu-latest\n container: ubuntu:16.04\n install:\n - clang-3.8\n - toolset: clang\n compiler: clang++-3.9\n cxxstd: \"11,14\"\n os: ubuntu-latest\n container: ubuntu:18.04\n install:\n - clang-3.9\n - toolset: clang\n compiler: clang++-4.0\n cxxstd: \"11,14\"\n os: ubuntu-latest\n container: ubuntu:18.04\n install:\n - clang-4.0\n - toolset: clang\n compiler: clang++-5.0\n cxxstd: \"11,14,1z\"\n os: ubuntu-latest\n container: ubuntu:18.04\n install:\n - clang-5.0\n - toolset: clang\n compiler: clang++-6.0\n cxxstd: \"11,14,17\"\n os: ubuntu-latest\n container: ubuntu:18.04\n install:\n - clang-6.0\n - toolset: clang\n compiler: clang++-7\n cxxstd: \"11,14,17\"\n os: ubuntu-latest\n container: ubuntu:18.04\n install:\n - clang-7\n # Note: clang-8 does not fully support C++20, so it is not compatible with libstdc++-8 in this mode\n - toolset: clang\n compiler: clang++-8\n cxxstd: \"11,14,17,2a\"\n os: ubuntu-latest\n container: ubuntu:18.04\n install:\n - clang-8\n - g++-7\n gcc_toolchain: 7\n - toolset: clang\n compiler: clang++-9\n cxxstd: \"11,14,17,2a\"\n os: ubuntu-20.04\n install:\n - clang-9\n - toolset: clang\n compiler: clang++-10\n cxxstd: \"11,14,17,20\"\n os: ubuntu-20.04\n install:\n - clang-10\n - toolset: clang\n compiler: clang++-11\n cxxstd: \"11,14,17,20\"\n os: ubuntu-22.04\n install:\n - clang-11\n - toolset: clang\n compiler: clang++-12\n cxxstd: \"11,14,17,20,2b\"\n os: ubuntu-22.04\n install:\n - clang-12\n - toolset: clang\n compiler: clang++-13\n cxxstd: \"11,14,17,20,2b\"\n os: ubuntu-22.04\n install:\n - clang-13\n - toolset: clang\n compiler: clang++-14\n cxxstd: \"11,14,17,20,2b\"\n os: ubuntu-22.04\n install:\n - clang-14\n - toolset: clang\n compiler: clang++-14\n cxxstd: \"11-gnu,14-gnu,17-gnu,20-gnu,2b-gnu\"\n os: ubuntu-22.04\n install:\n - clang-14\n - toolset: clang\n compiler: clang++-15\n cxxstd: \"11,14,17,20,2b\"\n os: ubuntu-22.04\n install:\n - clang-15\n sources:\n - \"deb http://apt.llvm.org/jammy/ llvm-toolchain-jammy-15 main\"\n source_keys:\n - \"https://apt.llvm.org/llvm-snapshot.gpg.key\"\n - toolset: clang\n compiler: clang++-15\n cxxstd: \"11,14,17,20,2b\"\n os: ubuntu-22.04\n install:\n - clang-15\n - libc++-15-dev\n - libc++abi-15-dev\n sources:\n - \"deb http://apt.llvm.org/jammy/ llvm-toolchain-jammy-15 main\"\n source_keys:\n - \"https://apt.llvm.org/llvm-snapshot.gpg.key\"\n cxxflags: -stdlib=libc++\n linkflags: -stdlib=libc++\n\n - toolset: clang\n cxxstd: \"11,14,17,2a\"\n os: macos-11\n - toolset: clang\n cxxstd: \"11,14,17,20,2b\"\n os: macos-12\n\n timeout-minutes: 360\n runs-on: ${{matrix.os}}\n container: ${{matrix.container}}\n\n steps:\n - name: Setup environment\n run: |\n if [ -f \"/etc/debian_version\" ]\n then\n echo \"DEBIAN_FRONTEND=noninteractive\" >> $GITHUB_ENV\n export DEBIAN_FRONTEND=noninteractive\n fi\n if [ -n \"${{matrix.container}}\" ]\n then\n echo \"GHA_CONTAINER=${{matrix.container}}\" >> $GITHUB_ENV\n if [ -f \"/etc/debian_version\" ]\n then\n apt-get -o Acquire::Retries=$NET_RETRY_COUNT update\n if [ \"$(apt-cache search \"^python-is-python3$\" | wc -l)\" -ne 0 ]\n then\n PYTHON_PACKAGE=\"python-is-python3\"\n else\n PYTHON_PACKAGE=\"python\"\n fi\n apt-get -o Acquire::Retries=$NET_RETRY_COUNT install -y sudo software-properties-common tzdata wget curl apt-transport-https ca-certificates make build-essential g++ $PYTHON_PACKAGE python3 perl git cmake\n fi\n fi\n git config --global pack.threads 0\n - uses: actions/checkout@v3\n\n - name: Install packages\n if: matrix.install\n run: |\n declare -a SOURCE_KEYS SOURCES\n if [ -n \"${{join(matrix.source_keys, ' ')}}\" ]\n then\n SOURCE_KEYS=(\"${{join(matrix.source_keys, '\" \"')}}\")\n fi\n if [ -n \"${{join(matrix.sources, ' ')}}\" ]\n then\n SOURCES=(\"${{join(matrix.sources, '\" \"')}}\")\n fi\n for key in \"${SOURCE_KEYS[@]}\"\n do\n for i in {1..$NET_RETRY_COUNT}\n do\n echo \"Adding key: $key\"\n wget -O - \"$key\" | sudo apt-key add - && break || sleep 2\n done\n done\n if [ ${#SOURCES[@]} -gt 0 ]\n then\n APT_ADD_REPO_COMMON_ARGS=(\"-y\")\n APT_ADD_REPO_SUPPORTED_ARGS=\"$(apt-add-repository --help | perl -ne 'if (/^\\s*-n/) { print \"n\"; } elsif (/^\\s*-P/) { print \"P\"; } elsif (/^\\s*-S/) { print \"S\"; } elsif (/^\\s*-U/) { print \"U\"; }')\"\n if [ -n \"$APT_ADD_REPO_SUPPORTED_ARGS\" -a -z \"${APT_ADD_REPO_SUPPORTED_ARGS##*n*}\" ]\n then\n APT_ADD_REPO_COMMON_ARGS+=(\"-n\")\n fi\n APT_ADD_REPO_HAS_SOURCE_ARGS=\"$([ -n \"$APT_ADD_REPO_SUPPORTED_ARGS\" -a -z \"${APT_ADD_REPO_SUPPORTED_ARGS##*P*}\" -a -z \"${APT_ADD_REPO_SUPPORTED_ARGS##*S*}\" -a -z \"${APT_ADD_REPO_SUPPORTED_ARGS##*U*}\" ] && echo 1 || echo 0)\"\n for source in \"${SOURCES[@]}\"\n do\n for i in {1..$NET_RETRY_COUNT}\n do\n APT_ADD_REPO_ARGS=(\"${APT_ADD_REPO_COMMON_ARGS[@]}\")\n if [ $APT_ADD_REPO_HAS_SOURCE_ARGS -ne 0 ]\n then\n case \"$source\" in\n \"ppa:\"*)\n APT_ADD_REPO_ARGS+=(\"-P\")\n ;;\n \"deb \"*)\n APT_ADD_REPO_ARGS+=(\"-S\")\n ;;\n *)\n APT_ADD_REPO_ARGS+=(\"-U\")\n ;;\n esac\n fi\n APT_ADD_REPO_ARGS+=(\"$source\")\n echo \"apt-add-repository ${APT_ADD_REPO_ARGS[@]}\"\n sudo -E apt-add-repository \"${APT_ADD_REPO_ARGS[@]}\" && break || sleep 2\n done\n done\n fi\n sudo apt-get -o Acquire::Retries=$NET_RETRY_COUNT update\n sudo apt-get -o Acquire::Retries=$NET_RETRY_COUNT install -y ${{join(matrix.install, ' ')}}\n - name: Setup GCC Toolchain\n if: matrix.gcc_toolchain\n run: |\n GCC_TOOLCHAIN_ROOT=\"$HOME/gcc-toolchain\"\n echo \"GCC_TOOLCHAIN_ROOT=\\\"$GCC_TOOLCHAIN_ROOT\\\"\" >> $GITHUB_ENV\n MULTIARCH_TRIPLET=\"$(dpkg-architecture -qDEB_HOST_MULTIARCH)\"\n mkdir -p \"$GCC_TOOLCHAIN_ROOT\"\n ln -s /usr/include \"$GCC_TOOLCHAIN_ROOT/include\"\n ln -s /usr/bin \"$GCC_TOOLCHAIN_ROOT/bin\"\n mkdir -p \"$GCC_TOOLCHAIN_ROOT/lib/gcc/$MULTIARCH_TRIPLET\"\n ln -s \"/usr/lib/gcc/$MULTIARCH_TRIPLET/${{matrix.gcc_toolchain}}\" \"$GCC_TOOLCHAIN_ROOT/lib/gcc/$MULTIARCH_TRIPLET/${{matrix.gcc_toolchain}}\"\n - name: Setup Boost\n run: |\n echo GITHUB_REPOSITORY: $GITHUB_REPOSITORY\n LIBRARY=${GITHUB_REPOSITORY#*/}\n echo LIBRARY: $LIBRARY\n echo \"LIBRARY=$LIBRARY\" >> $GITHUB_ENV\n echo GITHUB_BASE_REF: $GITHUB_BASE_REF\n echo GITHUB_REF: $GITHUB_REF\n REF=${GITHUB_BASE_REF:-$GITHUB_REF}\n REF=${REF#refs/heads/}\n echo REF: $REF\n BOOST_BRANCH=develop && [ \"$REF\" = \"master\" ] && BOOST_BRANCH=master || true\n echo BOOST_BRANCH: $BOOST_BRANCH\n BUILD_JOBS=$((nproc || sysctl -n hw.ncpu) 2> /dev/null)\n echo \"BUILD_JOBS=$BUILD_JOBS\" >> $GITHUB_ENV\n echo \"CMAKE_BUILD_PARALLEL_LEVEL=$BUILD_JOBS\" >> $GITHUB_ENV\n DEPINST_ARGS=()\n GIT_VERSION=\"$(git --version | sed -e 's/git version //')\"\n GIT_HAS_JOBS=1\n if [ -f \"/etc/debian_version\" ]\n then\n if $(dpkg --compare-versions \"$GIT_VERSION\" lt 2.8.0)\n then\n GIT_HAS_JOBS=0\n fi\n else\n declare -a GIT_VER=(${GIT_VERSION//./ })\n declare -a GIT_MIN_VER=(2 8 0)\n for ((i=0; i<${#GIT_VER[@]}; i++))\n do\n if [ -z \"${GIT_MIN_VER[i]}\" ]\n then\n GIT_MIN_VER[i]=0\n fi\n if [ \"${GIT_VER[i]}\" -lt \"${GIT_MIN_VER[i]}\" ]\n then\n GIT_HAS_JOBS=0\n break\n fi\n done\n fi\n if [ \"$GIT_HAS_JOBS\" -ne 0 ]\n then\n DEPINST_ARGS+=(\"--git_args\" \"--jobs $GIT_FETCH_JOBS\")\n fi\n cd ..\n git clone -b \"$BOOST_BRANCH\" --depth 1 \"https://github.com/boostorg/boost.git\" \"boost-root\"\n cd boost-root\n mkdir -p libs/$LIBRARY\n cp -r $GITHUB_WORKSPACE/* libs/$LIBRARY\n git submodule update --init tools/boostdep\n DEPINST_ARGS+=(\"$LIBRARY\")\n python tools/boostdep/depinst/depinst.py \"${DEPINST_ARGS[@]}\"\n if [ -z \"${{matrix.cmake_tests}}\" ]\n then\n ./bootstrap.sh\n ./b2 headers\n if [ -n \"${{matrix.compiler}}\" -o -n \"$GCC_TOOLCHAIN_ROOT\" ]\n then\n echo -n \"using ${{matrix.toolset}} : : ${{matrix.compiler}}\" > ~/user-config.jam\n if [ -n \"$GCC_TOOLCHAIN_ROOT\" ]\n then\n echo -n \" : \\\"--gcc-toolchain=$GCC_TOOLCHAIN_ROOT\\\" \\\"--gcc-toolchain=$GCC_TOOLCHAIN_ROOT\\\"\" >> ~/user-config.jam\n fi\n echo \" ;\" >> ~/user-config.jam\n fi\n fi\n - name: Run tests\n if: matrix.cmake_tests == ''\n run: |\n cd ../boost-root\n B2_ARGS=(\"-j\" \"$BUILD_JOBS\" \"toolset=${{matrix.toolset}}\" \"cxxstd=${{matrix.cxxstd}}\" \"link=static,shared\")\n if [ -n \"${{matrix.build_variant}}\" ]\n then\n B2_ARGS+=(\"variant=${{matrix.build_variant}}\")\n else\n B2_ARGS+=(\"variant=$DEFAULT_BUILD_VARIANT\")\n fi\n if [ -n \"${{matrix.threading}}\" ]\n then\n B2_ARGS+=(\"threading=${{matrix.threading}}\")\n fi\n if [ -n \"${{matrix.ubsan}}\" ]\n then\n export UBSAN_OPTIONS=\"print_stacktrace=1\"\n B2_ARGS+=(\"cxxflags=-fsanitize=undefined -fno-sanitize-recover=undefined\" \"linkflags=-fsanitize=undefined -fuse-ld=gold\" \"define=UBSAN=1\" \"debug-symbols=on\" \"visibility=global\")\n fi\n if [ -n \"${{matrix.cxxflags}}\" ]\n then\n B2_ARGS+=(\"cxxflags=${{matrix.cxxflags}}\")\n fi\n if [ -n \"${{matrix.linkflags}}\" ]\n then\n B2_ARGS+=(\"linkflags=${{matrix.linkflags}}\")\n fi\n if [ -n \"${{matrix.address_model}}\" ]\n then\n B2_ARGS+=(\"address-model=${{matrix.address_model}}\")\n fi\n B2_ARGS+=(\"libs/$LIBRARY/test\")\n ./b2 \"${B2_ARGS[@]}\"\n" }, { "path": ".github/workflows/windows.yml", "content": "name: Windows\n\non:\n pull_request:\n push:\n branches:\n - master\n - develop\n - feature/**\n\nconcurrency:\n group: ${{ github.workflow }}-${{ github.ref }}\n cancel-in-progress: true\n\nenv:\n LIBRARY: serialization\n\njobs:\n CI:\n strategy:\n fail-fast: false\n matrix:\n include:\n - toolset: msvc-14.0\n cxxstd: \"11,14\"\n addrmd: 32,64\n os: windows-2019\n - toolset: msvc-14.2\n cxxstd: \"14,17,latest\"\n addrmd: 32,64\n os: windows-2019\n - toolset: msvc-14.3\n cxxstd: \"17,20,latest\"\n addrmd: 32,64\n os: windows-2022\n - toolset: clang-win\n cxxstd: \"14,17,latest\"\n addrmd: 32,64\n os: windows-2022\n - toolset: gcc\n cxxstd: \"11,14,17,2a\"\n addrmd: 64\n os: windows-2019\n\n runs-on: ${{matrix.os}}\n\n steps:\n - uses: actions/checkout@v3\n\n - name: Setup Boost\n shell: cmd\n run: |\n echo GITHUB_REPOSITORY: %GITHUB_REPOSITORY%\n for /f %%i in (\"%GITHUB_REPOSITORY%\") do set LIBRARY=%%~nxi\n echo LIBRARY: %LIBRARY%\n echo LIBRARY=%LIBRARY%>>%GITHUB_ENV%\n echo GITHUB_BASE_REF: %GITHUB_BASE_REF%\n echo GITHUB_REF: %GITHUB_REF%\n if \"%GITHUB_BASE_REF%\" == \"\" set GITHUB_BASE_REF=%GITHUB_REF%\n set BOOST_BRANCH=develop\n for /f %%i in (\"%GITHUB_BASE_REF%\") do if \"%%~nxi\" == \"master\" set BOOST_BRANCH=master\n echo BOOST_BRANCH: %BOOST_BRANCH%\n cd ..\n git clone -b %BOOST_BRANCH% --depth 1 https://github.com/boostorg/boost.git boost-root\n cd boost-root\n xcopy /s /e /q %GITHUB_WORKSPACE% libs\\%LIBRARY%\\\n git submodule update --init tools/boostdep\n python tools/boostdep/depinst/depinst.py --git_args \"--jobs 3\" %LIBRARY%\n cmd /c bootstrap\n b2 -d0 headers\n\n - name: Run tests\n shell: cmd\n run: |\n cd ../boost-root\n b2 -j3 libs/%LIBRARY%/test toolset=${{matrix.toolset}} cxxstd=${{matrix.cxxstd}} address-model=${{matrix.addrmd}} variant=release\n" }, { "path": ".gitignore", "content": "" }, { "path": ".travis.yml", "content": "# Copyright 2016, 2017 Peter Dimov\n# Distributed under the Boost Software License, Version 1.0.\n# (See accompanying file LICENSE_1_0.txt or copy at http://boost.org/LICENSE_1_0.txt)\n\nlanguage: cpp\n\nsudo: false\n\ncache:\n ccache: true\n\nbranches:\n only:\n - master\n - develop\n - /feature\\/.*/\n\nenv:\n matrix:\n - BOGUS_JOB=true\n\nmatrix:\n\n exclude:\n - env: BOGUS_JOB=true\n\n include:\n - os: linux\n compiler: g++\n env: TOOLSET=gcc LINK=static,shared\n\n - os: linux\n compiler: g++-5\n env: TOOLSET=gcc LINK=static,shared\n addons:\n apt:\n packages:\n - g++-5\n sources:\n - ubuntu-toolchain-r-test\n\n - os: linux\n compiler: g++-6\n env: TOOLSET=gcc LINK=static,shared\n addons:\n apt:\n packages:\n - g++-6\n sources:\n - ubuntu-toolchain-r-test\n\n - os: linux\n compiler: g++-7\n env: TOOLSET=gcc LINK=static,shared\n addons:\n apt:\n packages:\n - g++-7\n sources:\n - ubuntu-toolchain-r-test\n\n - os: linux\n compiler: clang++\n env: TOOLSET=clang LINK=static,shared\n\n - os: linux\n compiler: clang++-libc++\n env: TOOLSET=clang LINK=static,shared\n addons:\n apt:\n packages:\n - libc++-dev\n\n - os: osx\n compiler: clang++\n env: TOOLSET=clang LINK=static,shared\n\n - os: osx\n osx_image: xcode10\n compiler: clang++\n env: TOOLSET=clang LINK=static,shared\n\ninstall:\n - BOOST_BRANCH=develop && [ \"$TRAVIS_BRANCH\" == \"master\" ] && BOOST_BRANCH=master || true\n - cd ..\n - git clone -b $BOOST_BRANCH https://github.com/boostorg/boost.git boost-root\n - cd boost-root\n - git submodule update --init tools/build\n - git submodule update --init libs/config\n - git submodule update --init tools/boostdep\n - cp -r $TRAVIS_BUILD_DIR/* libs/serialization\n - python tools/boostdep/depinst/depinst.py serialization\n - ./bootstrap.sh\n - ./b2 headers\n\nscript:\n - |-\n echo \"using $TOOLSET : : $TRAVIS_COMPILER ;\" > ~/user-config.jam\n - ./b2 -j 3 libs/serialization/test toolset=$TOOLSET link=${LINK:-shared}\n\nnotifications:\n email:\n on_success: always\n" }, { "path": "CMake/CMakeLists.txt", "content": "# CMake build control file for Serialization Library tests\n\ncmake_minimum_required(VERSION 3.5)\n\nif (POLICY CMP0054)\n cmake_policy (SET CMP0054 NEW)\nendif (POLICY CMP0054)\n\nif (POLICY CMP0063)\n cmake_policy (SET CMP0063 NEW)\nendif (POLICY CMP0063)\n\nproject(\"serialization\")\n\n#\n# Compiler settings\n#\n\nmessage(STATUS \"C++ compiler is ${CMAKE_CXX_COMPILER_ID}\" )\nadd_definitions(${Boost_LIB_DIAGNOSTIC_DEFINITIONS})\nmessage(STATUS \"C compiler is ${CMAKE_C_COMPILER_ID}\" )\n\nif( CMAKE_CXX_COMPILER_ID STREQUAL \"GNU\" )\n add_definitions( -ftemplate-depth=255 )\n # we use gcc to test for C++03 compatibility\n set(COMPILER_SUPPORTS_CXX11 FALSE)\nelseif( CMAKE_CXX_COMPILER_ID STREQUAL \"MSVC\" )\n add_definitions( /wd4996 )\n set(COMPILER_SUPPORTS_CXX11 TRUE)\nelseif( CMAKE_CXX_COMPILER_ID STREQUAL \"AppleClang\" )\n set(CMAKE_CXX_FLAGS \"${CMAKE_CXX_FLAGS} -ftemplate-depth=300\")\n set(CMAKE_CXX_FLAGS_DEBUG \"-g -O0\" )\n set(CMAKE_CXX_FLAGS_RELWITHDEBINFO \"-g -O3\" )\n set(CMAKE_EXE_LINKER_FLAGS \"${CMAKE_EXE_LINKER_FLAGS} -stdlib=libc++ -dead_strip\")\n set(COMPILER_SUPPORTS_CXX11 TRUE)\nendif()\n\nadd_definitions( -std=c++11 )\n#set(CMAKE_CXX_FLAGS \"${CMAKE_CXX_FLAGS} -std=c++03\")\nset(CMAKE_CXX_FLAGS \"${CMAKE_CXX_FLAGS} -std=c++11\")\n#set(CMAKE_CXX_FLAGS \"${CMAKE_CXX_FLAGS} -std=c++17\")\n#set(CMAKE_CXX_FLAGS \"${CMAKE_CXX_FLAGS} -std=c++11\")\n\n#\n# Locate Project Prerequisites \n#\n\n# Boost\n\n#\n# Project settings\n#\noption(BUILD_SHARED_LIBS \"Build Shared Libraries\" true)\n\nfind_package(Boost 1.82 REQUIRED COMPONENTS system filesystem)\n\nif(NOT Boost_FOUND)\n message(\"Boost NOT Found!\")\nelse()\n message(STATUS \"Boost Found!\")\nendif()\nset(CMAKE_CXX_VISIBILITY_PRESET hidden)\nset(VISIBILITY_INLINES_HIDDEN YES)\n\n# enable usage of CHECK_INCLUDE_FILE_CXX\ninclude(CheckIncludeFileCXX)\n\n# list of archive names for which tests should be generated\nset(archive_list text_archive text_warchive binary_archive xml_archive xml_warchive)\n# set(archive_list xml_warchive)\n\n# list of tests generated by each function call\nset(test_list)\n\n###########################\n# library builds\n\nadd_library(serialization\n ../src/archive_exception.cpp\n ../src/basic_archive.cpp\n ../src/basic_iarchive.cpp\n ../src/basic_iserializer.cpp\n ../src/basic_oarchive.cpp\n ../src/basic_oserializer.cpp\n ../src/basic_pointer_iserializer.cpp\n ../src/basic_pointer_oserializer.cpp\n ../src/basic_serializer_map.cpp\n ../src/basic_text_iprimitive.cpp\n ../src/basic_text_oprimitive.cpp\n ../src/basic_xml_archive.cpp\n ../src/binary_iarchive.cpp\n ../src/binary_oarchive.cpp\n ../src/extended_type_info.cpp\n ../src/extended_type_info_typeid.cpp\n ../src/extended_type_info_no_rtti.cpp\n ../src/stl_port.cpp\n ../src/text_iarchive.cpp\n ../src/text_oarchive.cpp\n ../src/polymorphic_iarchive.cpp\n ../src/polymorphic_oarchive.cpp\n ../src/polymorphic_text_iarchive.cpp\n ../src/polymorphic_text_oarchive.cpp\n ../src/polymorphic_binary_iarchive.cpp\n ../src/polymorphic_binary_oarchive.cpp\n ../src/polymorphic_xml_iarchive.cpp\n ../src/polymorphic_xml_oarchive.cpp\n ../src/void_cast.cpp\n ../src/xml_grammar.cpp\n ../src/xml_iarchive.cpp\n ../src/xml_oarchive.cpp\n ../src/xml_archive_exception.cpp\n ../src/codecvt_null.cpp\n ../src/utf8_codecvt_facet.cpp\n ../src/basic_xml_grammar.ipp # doesn't show up in \"Source Files\" in Xcode\"'\n)\ntarget_include_directories(serialization PUBLIC ${Boost_INCLUDE_DIR})\n\nadd_library(wserialization\n ../src/basic_text_wiprimitive.cpp\n ../src/basic_text_woprimitive.cpp\n ../src/text_wiarchive.cpp\n ../src/text_woarchive.cpp\n ../src/polymorphic_text_wiarchive.cpp\n ../src/polymorphic_text_woarchive.cpp\n ../src/xml_wiarchive.cpp\n ../src/xml_woarchive.cpp\n ../src/polymorphic_xml_wiarchive.cpp\n ../src/polymorphic_xml_woarchive.cpp\n ../src/xml_wgrammar.cpp\n ../src/basic_xml_grammar.ipp # doesn't show up in \"Source Files\" in Xcode\"'\n)\ntarget_include_directories(wserialization PUBLIC ${Boost_INCLUDE_DIR})\ntarget_link_libraries(wserialization PUBLIC serialization)\n\n# end library build\n###########################\n\n###########################\n# test targets\n\nfunction( serialization_test test_name)\n set(arglist)\n foreach(a IN ITEMS ${ARGN} )\n set(arglist ${arglist} ../test/${a}.cpp)\n endforeach()\n message(STATUS ${test_name})\n add_executable( ${test_name} ../test/${test_name}.cpp ${arglist} )\n target_include_directories(${test_name} PUBLIC ${Boost_INCLUDE_DIR})\n target_link_libraries(${test_name} serialization wserialization Boost::filesystem)\n add_test( ${test_name} ${test_name} )\nendfunction(serialization_test)\n\nfunction(archive_test test_name)\n set(test_listx)\n set(arglist)\n foreach(a IN ITEMS ${ARGN} )\n set(arglist ${arglist} ../test/${a}.cpp)\n endforeach()\n foreach(\n archive-name\n IN ITEMS ${archive_list}\n )\n set(amended_test_name ${test_name}_${archive-name})\n add_executable(${amended_test_name} ../test/${test_name}.cpp ${arglist})\n set_property(\n TARGET ${amended_test_name}\n PROPERTY COMPILE_DEFINITIONS BOOST_ARCHIVE_TEST=${archive-name}.hpp\n )\n target_include_directories(${amended_test_name} PUBLIC ${Boost_INCLUDE_DIR})\n target_link_libraries(${amended_test_name} serialization wserialization Boost::filesystem)\n add_test(${amended_test_name} ${amended_test_name})\n set(test_listx ${test_listx} ${amended_test_name})\n endforeach()\n set(test_list ${test_listx} PARENT_SCOPE)\nendfunction(archive_test)\n\nfunction(polymorphic_archive_test test_name)\n set(test_listx)\n set(arglist)\n foreach(a IN ITEMS ${ARGN} )\n set(arglist ${arglist} ../test/${a}.cpp)\n endforeach()\n foreach(\n archive-name\n IN ITEMS ${archive_list}\n )\n set(amended_archive_name polymorphic_${archive-name})\n set(amended_test_name ${test_name}_${amended_archive_name})\n add_executable(${amended_test_name} ../test/${test_name}.cpp ${arglist})\n set_property(\n TARGET ${amended_test_name}\n PROPERTY COMPILE_DEFINITIONS BOOST_ARCHIVE_TEST=${amended_archive_name}.hpp\n )\n message(STATUS ${amended_test_name} \" \" ${arglist} \" \" ${amended_archive_name})\n target_include_directories(${amended_test_name} PUBLIC ${Boost_INCLUDE_DIR})\n target_link_libraries(${amended_test_name} serialization wserialization Boost::filesystem)\n add_test(${amended_test_name} ${amended_test_name})\n set(test_listx ${test_listx} ${amended_test_name})\nendforeach()\nset(test_list ${test_listx} PARENT_SCOPE)\nendfunction(polymorphic_archive_test)\n\nenable_testing()\n\nmessage(STATUS dll_a)\nadd_library(dll_a SHARED ../test/dll_a.cpp)\ntarget_link_libraries(dll_a serialization)\n\nmessage(STATUS dll_polymorphic_base)\nadd_library(dll_polymorphic_base SHARED ../test/dll_polymorphic_base.cpp)\ntarget_link_libraries(dll_polymorphic_base serialization)\n\nmessage(STATUS dll_polymorphic_derived2)\nadd_library(dll_polymorphic_derived2 SHARED ../test/dll_polymorphic_derived2.cpp)\ntarget_link_libraries(dll_polymorphic_derived2 dll_polymorphic_base serialization)\n\n# compile test_dll_plugin.cpp\n# Running the following test requires that the test know the directory \n# in which the dll is stored. I don't know how to extract this from bjam\n# serialization(test_dll_plugin : : dll_polymorphic_derived2_lib)\n\nif(BUILD_SHARED_LIBS)\n # this test can only be made to work if we're linking with shared\n # libraries. Basically the build systems like to have all shared\n # or all static so if we're building with static C++ libraries\n # then linking with a shared one - we need multiple C++ libraries\n # and things get complex. So just run this test when we're\n # building with shared libraries (dll in windows speak)\n serialization_test(test_dll_simple)\n target_link_libraries(test_dll_simple dll_a serialization)\nendif()\n\nserialization_test(test_private_ctor)\nserialization_test(test_reset_object_address A)\nserialization_test(test_void_cast)\nserialization_test(test_mult_archive_types)\nserialization_test(test_iterators)\nserialization_test(test_iterators_base64)\nserialization_test(test_inclusion)\nserialization_test(test_inclusion2)\nserialization_test(test_smart_cast)\nserialization_test(test_codecvt_null)\nserialization_test(test_strong_typedef)\nserialization_test(test_singleton)\nserialization_test(test_singleton_inherited)\nserialization_test(test_singleton_plain)\n\narchive_test(test_native_array A)\narchive_test(test_boost_array A)\nif(COMPILER_SUPPORTS_CXX11)\n archive_test(test_array A)\nendif()\n\narchive_test(test_binary)\narchive_test(test_bitset)\narchive_test(test_class_info_save)\narchive_test(test_class_info_load)\narchive_test(test_complex)\narchive_test(test_contained_class A)\narchive_test(test_cyclic_ptrs A)\narchive_test(test_delete_pointer)\narchive_test(test_deque A)\narchive_test(test_derived)\narchive_test(test_derived_class A)\narchive_test(test_diamond)\narchive_test(test_diamond_complex)\nCHECK_INCLUDE_FILE_CXX(forward_list FORWARD_LIST_FOUND)\nif(FORWARD_LIST_FOUND)\n message(STATUS \"forward_list header found\")\n archive_test(test_forward_list A)\n archive_test(test_forward_list_ptrs A)\nelse()\n message(STATUS \"forward_list header NOT found\")\nendif()\n\narchive_test(test_helper_support)\narchive_test(test_interrupts)\narchive_test(test_list A)\narchive_test(test_list_ptrs A)\n\narchive_test(test_map A)\nCHECK_INCLUDE_FILE_CXX(hash_map HASH_MAP_FOUND)\nif(HASH_MAP_FOUND)\n archive_test(test_map_hashed A)\nendif()\narchive_test(test_mi)\narchive_test(test_multiple_ptrs A)\narchive_test(test_multiple_inheritance)\narchive_test(test_new_operator A)\narchive_test(test_non_intrusive)\narchive_test(test_non_default_ctor)\narchive_test(test_non_default_ctor2)\narchive_test(test_null_ptr)\narchive_test(test_nvp A)\narchive_test(test_object)\narchive_test(test_optional)\narchive_test(test_primitive)\narchive_test(test_priority_queue A)\narchive_test(test_private_base)\narchive_test(test_private_base2)\narchive_test(test_queue A)\narchive_test(test_recursion A)\narchive_test(test_registered)\n\narchive_test(test_set A)\nCHECK_INCLUDE_FILE_CXX(hash_set HASH_SET_FOUND)\nif(HASH_SET_FOUND)\n archive_test(test_set_hashed A)\nendif()\n\narchive_test(test_shared_ptr)\narchive_test(test_shared_ptr_multi_base)\narchive_test(test_shared_ptr_132)\narchive_test(test_simple_class A)\narchive_test(test_simple_class_ptr A)\nCHECK_INCLUDE_FILE_CXX(slist SLIST_FOUND)\nif(SLIST_FOUND)\n message(STATUS \"slist header found\")\n archive_test(test_slist A)\n archive_test(test_slist_ptr A)\nendif()\narchive_test(test_stack A)\narchive_test(test_split)\narchive_test(test_tracking)\narchive_test(test_unregistered)\narchive_test(test_unique_ptr)\narchive_test(test_valarray)\narchive_test(test_variant A)\narchive_test(test_vector A)\n\nif(BUILD_SHARED_LIBS)\n polymorphic_archive_test(test_dll_exported polymorphic_derived1)\n foreach(test_name IN ITEMS ${test_list} )\n target_link_libraries(${test_name} dll_polymorphic_derived2 dll_polymorphic_base serialization wserialization)\n endforeach()\nendif()\n\npolymorphic_archive_test(test_no_rtti polymorphic_base polymorphic_derived1 polymorphic_derived2)\npolymorphic_archive_test(test_exported polymorphic_base polymorphic_derived1 polymorphic_derived2)\npolymorphic_archive_test(test_polymorphic test_polymorphic_A A)\npolymorphic_archive_test(test_polymorphic2 test_polymorphic2imp)\npolymorphic_archive_test(test_p_helper)\n\n# end test targets\n####################\n\n####################\n# add headers in IDE\n\n# for serialization\n\nfile(GLOB x \n RELATIVE \"${CMAKE_CURRENT_SOURCE_DIR}\" \n \"${CMAKE_CURRENT_SOURCE_DIR}/../include/boost/archive/*.hpp\"\n)\nadd_custom_target(archive SOURCES ${x})\nset_property(TARGET archive PROPERTY FOLDER \"serialization\")\n\nfile(GLOB x \n RELATIVE \"${CMAKE_CURRENT_SOURCE_DIR}\" \n \"${CMAKE_CURRENT_SOURCE_DIR}/../include/boost/archive/detail/*.hpp\"\n)\nadd_custom_target(archive-detail SOURCES ${x})\nset_property(TARGET archive-detail PROPERTY FOLDER \"serialization\")\n\nfile(GLOB x \n RELATIVE \"${CMAKE_CURRENT_SOURCE_DIR}\" \n \"${CMAKE_CURRENT_SOURCE_DIR}/../include/boost/archive/impl/*.ipp\"\n)\nadd_custom_target(archive-impl SOURCES ${x})\nset_property(TARGET archive-impl PROPERTY FOLDER \"serialization\")\n\nfile(GLOB x\n RELATIVE \"${CMAKE_CURRENT_SOURCE_DIR}\" \n \"${CMAKE_CURRENT_SOURCE_DIR}/../include/boost/archive/iterators/*.hpp\"\n)\nadd_custom_target(archive-iterators SOURCES ${x})\nset_property(TARGET archive-iterators PROPERTY FOLDER \"serialization\")\n\nfile(GLOB x \n RELATIVE \"${CMAKE_CURRENT_SOURCE_DIR}\" \n \"${CMAKE_CURRENT_SOURCE_DIR}/../include/boost/serialization/*.hpp\"\n)\nadd_custom_target(serialization-headers SOURCES ${x})\nset_property(TARGET serialization-headers PROPERTY FOLDER \"serialization\")\n\nfile(GLOB x \n RELATIVE \"${CMAKE_CURRENT_SOURCE_DIR}\" \n \"${CMAKE_CURRENT_SOURCE_DIR}/../include/boost/serialization/detail/*.hpp\"\n)\nadd_custom_target(serialization-detail SOURCES ${x})\nset_property(TARGET serialization-detail PROPERTY FOLDER \"serialization\")\n\n# for wserialization\n\nfile(GLOB x \n RELATIVE \"${CMAKE_CURRENT_SOURCE_DIR}\" \n \"${CMAKE_CURRENT_SOURCE_DIR}/../include/boost/archive/*_w*.hpp\"\n)\nadd_custom_target(wserialization_headers SOURCES ${x})\nset_property(TARGET wserialization_headers PROPERTY FOLDER \"wserialization\")\n\n# end headers in IDE\n####################\n\n#####################\n# add test project to run misc tests\n\nadd_executable( test_z ../test/test_z.cpp)\ntarget_link_libraries(test_z serialization wserialization ${Boost_LIBRARIES})\n\n# end test project\n#####################\n" }, { "path": "CMakeLists.txt", "content": "# Copyright 2020, 2021 Peter Dimov\n# Distributed under the Boost Software License, Version 1.0.\n# https://www.boost.org/LICENSE_1_0.txt\n\ncmake_minimum_required(VERSION 3.5...3.16)\n\nproject(boost_serialization VERSION \"${BOOST_SUPERPROJECT_VERSION}\" LANGUAGES CXX)\n\nadd_library(boost_serialization\n src/archive_exception.cpp\n src/basic_archive.cpp\n src/basic_iarchive.cpp\n src/basic_iserializer.cpp\n src/basic_oarchive.cpp\n src/basic_oserializer.cpp\n src/basic_pointer_iserializer.cpp\n src/basic_pointer_oserializer.cpp\n src/basic_serializer_map.cpp\n src/basic_text_iprimitive.cpp\n src/basic_text_oprimitive.cpp\n src/basic_xml_archive.cpp\n src/binary_iarchive.cpp\n src/binary_oarchive.cpp\n src/codecvt_null.cpp\n src/extended_type_info.cpp\n src/extended_type_info_no_rtti.cpp\n src/extended_type_info_typeid.cpp\n src/polymorphic_binary_iarchive.cpp\n src/polymorphic_binary_oarchive.cpp\n src/polymorphic_iarchive.cpp\n src/polymorphic_oarchive.cpp\n src/polymorphic_text_iarchive.cpp\n src/polymorphic_text_oarchive.cpp\n src/polymorphic_xml_iarchive.cpp\n src/polymorphic_xml_oarchive.cpp\n src/stl_port.cpp\n src/text_iarchive.cpp\n src/text_oarchive.cpp\n src/utf8_codecvt_facet.cpp\n src/void_cast.cpp\n src/xml_archive_exception.cpp\n src/xml_grammar.cpp\n src/xml_iarchive.cpp\n src/xml_oarchive.cpp\n)\n\nadd_library(boost_wserialization\n src/basic_text_wiprimitive.cpp\n src/basic_text_woprimitive.cpp\n src/binary_wiarchive.cpp\n src/binary_woarchive.cpp\n src/polymorphic_text_wiarchive.cpp\n src/polymorphic_text_woarchive.cpp\n src/polymorphic_xml_wiarchive.cpp\n src/polymorphic_xml_woarchive.cpp\n src/text_wiarchive.cpp\n src/text_woarchive.cpp\n src/xml_wgrammar.cpp\n src/xml_wiarchive.cpp\n src/xml_woarchive.cpp\n)\n\nadd_library(Boost::serialization ALIAS boost_serialization)\nadd_library(Boost::wserialization ALIAS boost_wserialization)\n\ntarget_include_directories(boost_serialization PUBLIC include)\ntarget_include_directories(boost_wserialization PUBLIC include)\n\ntarget_link_libraries(boost_serialization\n PUBLIC\n Boost::array\n Boost::assert\n Boost::config\n Boost::core\n Boost::detail\n Boost::integer\n Boost::io\n Boost::iterator\n Boost::move\n Boost::mpl\n Boost::optional\n Boost::predef\n Boost::preprocessor\n Boost::smart_ptr\n Boost::spirit\n Boost::type_traits\n Boost::unordered\n Boost::utility\n Boost::variant\n PRIVATE\n Boost::function\n)\n\ntarget_link_libraries(boost_wserialization PUBLIC boost_serialization)\n\ntarget_compile_definitions(boost_serialization\n PUBLIC BOOST_SERIALIZATION_NO_LIB\n # Source files already define BOOST_SERIALIZATION_SOURCE\n # PRIVATE BOOST_SERIALIZATION_SOURCE\n)\n\ntarget_compile_definitions(boost_wserialization\n PUBLIC BOOST_SERIALIZATION_NO_LIB\n # Source files already define BOOST_SERIALIZATION_SOURCE\n # PRIVATE BOOST_SERIALIZATION_SOURCE\n)\n\nif(BUILD_SHARED_LIBS)\n target_compile_definitions(boost_serialization PUBLIC BOOST_SERIALIZATION_DYN_LINK)\n target_compile_definitions(boost_wserialization PUBLIC BOOST_SERIALIZATION_DYN_LINK)\nelse()\n target_compile_definitions(boost_serialization PUBLIC BOOST_SERIALIZATION_STATIC_LINK)\n target_compile_definitions(boost_wserialization PUBLIC BOOST_SERIALIZATION_STATIC_LINK)\nendif()\n\nif(BOOST_SUPERPROJECT_VERSION AND NOT CMAKE_VERSION VERSION_LESS 3.13)\n boost_install(TARGETS boost_serialization boost_wserialization VERSION ${BOOST_SUPERPROJECT_VERSION} HEADER_DIRECTORY include)\nendif()\n\nif(BUILD_TESTING AND EXISTS \"${CMAKE_CURRENT_SOURCE_DIR}/test/CMakeLists.txt\")\n\n add_subdirectory(test)\n\nendif()\n" }, { "path": "appveyor.yml", "content": "# Copyright 2016 Peter Dimov\n# Copyright 2016 Robert Ramey\n# Distributed under the Boost Software License, Version 1.0.\n# (See accompanying file LICENSE_1_0.txt or copy at http://boost.org/LICENSE_1_0.txt)\n\nversion: 1.0.{build}-{branch}\n\nshallow_clone: true\n\nbranches:\n only:\n - develop\n# - master\n\nenvironment:\n matrix:\n - BUILD_TOOLSET: gcc\n BUILD_LINK: static\n - BUILD_TOOLSET: gcc\n BUILD_LINK: shared\n - BUILD_TOOLSET: msvc-14.0\n BUILD_LINK: static\n - BUILD_TOOLSET: msvc-14.0\n BUILD_LINK: shared\n\ninstall:\n - cd ..\n - git clone -b %APPVEYOR_REPO_BRANCH% https://github.com/boostorg/boost.git boost-root\n - cd boost-root\n - git submodule init libs/align\n - git submodule init libs/array\n - git submodule init libs/assert\n - git submodule init libs/bind\n - git submodule init libs/compatibility\n - git submodule init libs/concept_check\n - git submodule init libs/config\n - git submodule init libs/container\n - git submodule init libs/container_hash\n - git submodule init libs/core\n - git submodule init libs/detail\n - git submodule init libs/filesystem\n - git submodule init libs/function\n - git submodule init libs/functional\n - git submodule init libs/integer\n - git submodule init libs/intrusive\n - git submodule init libs/io\n - git submodule init libs/iterator\n - git submodule init libs/lexical_cast\n - git submodule init libs/math\n - git submodule init libs/move\n - git submodule init libs/mpl\n - git submodule init libs/numeric/conversion\n - git submodule init libs/optional\n - git submodule init libs/predef\n - git submodule init libs/preprocessor\n - git submodule init libs/range\n - git submodule init libs/smart_ptr\n - git submodule init libs/spirit\n - git submodule init libs/system\n - git submodule init libs/throw_exception\n - git submodule init libs/tuple\n - git submodule init libs/type_index\n - git submodule init libs/type_traits\n - git submodule init libs/unordered\n - git submodule init libs/utility\n - git submodule init libs/variant\n - git submodule init libs/winapi\n - git submodule init tools/boost_install\n - git submodule init libs/headers\n\n - git submodule init tools/build\n - git submodule update\n - xcopy /s /e /q %APPVEYOR_BUILD_FOLDER% libs\\serialization\n - set PATH=C:\\mingw-w64\\i686-6.3.0-posix-dwarf-rt_v5-rev1\\mingw32\\bin;%CD%;%PATH%\n - bootstrap gcc\n - b2 headers\n\nbuild: off\n\ntest_script:\n - cd libs/serialization/test\n - b2 -j2 toolset=%BUILD_TOOLSET% link=%BUILD_LINK%\n" }, { "path": "build/Jamfile.v2", "content": "# Boost serialization Library Build Jamfile\n# (C) Copyright Robert Ramey 2002-2004.\n# Use, modification, and distribution are subject to the\n# Boost Software License, Version 1.0. (See accompanying file\n# LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)\n#\n# See http://www.boost.org/libs/serialization for the library home page.\n\nrequire-b2 5.0.1 ;\nimport-search /boost/config/checks ;\nimport config : requires ;\n\nconstant boost_dependencies_private :\n /boost/function//boost_function\n ;\n\nproject\n : source-location ../src\n : common-requirements $(boost_dependencies)\n : requirements\n @include-spirit\n $(boost_dependencies_private)\n : usage-requirements\n BOOST_SERIALIZATION_NO_LIB=1\n;\n\nSPIRIT_ROOT = [ modules.peek : SPIRIT_ROOT ] ;\nrule include-spirit ( properties * )\n{\n local old-compiler ;\n if borland in $(properties)\n {\n if ! 6.1.0 in $(properties)\n {\n old-compiler = true ;\n }\n\n }\n else if msvc in $(properties)\n {\n if 6.5 in $(properties)\n || 7.0 in $(properties)\n {\n old-compiler = true ;\n }\n }\n\n local result ;\n if $(old-compiler)\n {\n if $(SPIRIT_ROOT)\n {\n # note - we can't use $(SPIRIT_ROOT) because\n # it puts -I$(SPIRIT_ROOT) AFTER the \"../../..\" in the command line.\n # so use these instead\n result = -I$(SPIRIT_ROOT) ;\n }\n else\n {\n echo **** spirit 1.6x required to build library with this compiler **** ;\n result = no ;\n }\n }\n return $(result) ;\n}\n\nSOURCES =\n archive_exception\n basic_archive\n basic_iarchive\n basic_iserializer\n basic_oarchive\n basic_oserializer\n basic_pointer_iserializer\n basic_pointer_oserializer\n basic_serializer_map\n basic_text_iprimitive\n basic_text_oprimitive\n basic_xml_archive\n binary_iarchive\n binary_oarchive\n extended_type_info\n extended_type_info_typeid\n extended_type_info_no_rtti\n polymorphic_iarchive\n polymorphic_oarchive\n stl_port\n text_iarchive\n text_oarchive\n polymorphic_text_iarchive\n polymorphic_text_oarchive\n polymorphic_binary_iarchive\n polymorphic_binary_oarchive\n polymorphic_xml_iarchive\n polymorphic_xml_oarchive\n void_cast\n xml_grammar\n xml_iarchive\n xml_archive_exception\n codecvt_null\n ;\n\nSOURCES_HAS_STD_WSTREAMBUF =\n xml_oarchive\n utf8_codecvt_facet\n;\n\nWSOURCES =\n basic_text_wiprimitive\n basic_text_woprimitive\n text_wiarchive\n text_woarchive\n polymorphic_text_wiarchive\n polymorphic_text_woarchive\n xml_wgrammar\n xml_wiarchive\n xml_woarchive\n polymorphic_xml_wiarchive\n polymorphic_xml_woarchive\n codecvt_null\n;\n\nlib boost_serialization\n : ## sources ##\n $(SOURCES).cpp\n : ## requirements ##\n [ check-target-builds /boost/config/checks//std_wstreambuf : ../src/$(SOURCES_HAS_STD_WSTREAMBUF).cpp ]\n msvc:/Gy\n msvc:_SCL_SECURE_NO_WARNINGS\n msvc:_CRT_SECURE_NO_WARNINGS\n shared:BOOST_SERIALIZATION_DYN_LINK=1\n ;\n\nlib boost_wserialization\n : $(WSOURCES).cpp boost_serialization\n :\n [ requires std_wstreambuf ]\n msvc:/Gy\n msvc:_SCL_SECURE_NO_WARNINGS\n msvc:_CRT_SECURE_NO_WARNINGS\n # note: both serialization and wserialization are conditioned on the this\n # switch - don't change it to BOOST_WSERIALIZATION_DYN_LINK\n shared:BOOST_SERIALIZATION_DYN_LINK=1\n ;\n" }, { "path": "build.jam", "content": "# Copyright René Ferdinand Rivera Morell 2023-2024\n# Distributed under the Boost Software License, Version 1.0.\n# (See accompanying file LICENSE_1_0.txt or copy at\n# http://www.boost.org/LICENSE_1_0.txt)\n\nrequire-b2 5.2 ;\n\nconstant boost_dependencies :\n /boost/array//boost_array\n /boost/assert//boost_assert\n /boost/config//boost_config\n /boost/core//boost_core\n /boost/detail//boost_detail\n /boost/integer//boost_integer\n /boost/io//boost_io\n /boost/iterator//boost_iterator\n /boost/move//boost_move\n /boost/mp11//boost_mp11\n /boost/mpl//boost_mpl\n /boost/optional//boost_optional\n /boost/predef//boost_predef\n /boost/preprocessor//boost_preprocessor\n /boost/smart_ptr//boost_smart_ptr\n /boost/spirit//boost_spirit\n /boost/throw_exception//boost_throw_exception\n /boost/type_traits//boost_type_traits\n /boost/utility//boost_utility\n /boost/variant//boost_variant\n /boost/variant2//boost_variant2 ;\n\nproject /boost/serialization\n : common-requirements\n include\n ;\n\nexplicit\n [ alias boost_serialization : build//boost_serialization ]\n [ alias boost_wserialization : build//boost_wserialization ]\n [ alias all : boost_serialization boost_wserialization example test ]\n ;\n\ncall-if : boost-library serialization\n : install boost_serialization boost_wserialization\n ;\n\n" }, { "path": "doc/acknowledgments.html", "content": "\n\n\n\n\n\n\nSerialization - Acknowledgments\n\n\n\n \n \n \n \n
\n

\"C++

\n 		\n

Serialization

\n

Acknowledgments

\n
\n
\n
    \n
  • Takatoshi Kondo found and corrected a very obscure and difficult bug in the \n serialization of virtual base classes.\n
  • AutoForm Engineering GmbH supported\n development efforts to extend correct serialization to objects stored in DLLS.\n
  • Cadence Israel supported enhancement\n and testing of the portable binary archive.\n
  • David Abrahams improved implementation of \"export\" functionality. This not\n only eliminated an annoying header sequencing requirement, but also the need to maintain\n a list of \"known archives\".\n
  • Mattias Troyer enhanced the implementation of native binary archives. This includes\n enhancement and generalization of the library itself including generalization of\n the wrapper concept.\n
  • Markus Schöpflin tracked down issues with TRU64 compiler resulting in 100% passing.\n
  • Troy D. Straszheim made the initial version of variant serialization.\n
  • Tonko Juricic helped refine and complete project files for VC 7.1 ide\n
  • Rene Rivera tracked down several issues related to \n Code Warrior, toolset configuration and bjam and much else.\n
  • Martin Ecker detected (and fixed!) a number of subtle errors regarding cyclic\n pointers, shared pointers. He also built the library as a DLL and raised some issues\n
  • Pavel Vozenilek invested much effort in review of code and documentation\n resulting in many improvements. In addition he helped a lot with porting to other\n platforms including VC 6.0, Intel, and especially Borland.\n
  • Jens Maurer and\n Beman Dawes who got the boost\n serialization ball rolling. It was one or both of these two that invented\n the much beloved & syntax used to implement both save and\n load in one function specification.\n
  • Vladimir Prus for evaluating an\n early draft and contributing the diamond inheritance example.\n
  • William E. Kempf\n who made the templates for this and other boost manuals. This relieved\n me of much aggravation.\n
  • Vahan Margaryan and\n Fredrik Blomqvist for their contributions\n to my understanding of the subtle issues of exception safety in this context.\n
  • all other boost members who responded with feedback during the\n development of this library. Almost all comments resulted in\n tangible changes in the library which made it much better.\n
  • boosters who helped out in porting to other platforms:, Fernando Cacciola (Borland), \n Jeff Flinn (VC 7.1), Vladimir Prus (gcc 3.3), Christoph Ludwig(gcc 3.4),\n Rob Lievaart(mingw), Marshal Clow(gcc-darwin) among others.\n
  • all boost members who participated in the first formal review\n in November 2002. Many of these members invested quite an effort\n to evaluate the library and suggest changes. They are\n Matthias Troyer, Pavel Vozenilek, Vladimir Prus, Fredrik Blomqvist,\n Jeff Garland, Gennadiy Rozental, Alberto Barbati, Dave Harris.\n Mr. Rozenthal in particular wrote an incredibly insightful analysis\n that has driven all subsequent development that has resulted in the\n current package.\n
  • Dave Harris proposal and spirited defense of it led to a re-thinking\n of the overrides for serialization of pointers. This resulted in a simpler\n and more effective method of accounting for non-default constructors\n required by serialization of pointers and STL collections.\n
  • Bryce Lelbach rewrote the XML Serialization grammar using Boost.Spirit 2.x.\n
\n
\n

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

\n\n\n\n" }, { "path": "doc/archive_reference.html", "content": "\n\n\n\n\n\n\nSerialization - More on Archives\n\n\n\n \n \n \n \n
\n

\"C++

\n 		\n

Serialization

\n

Archive Class Reference

\n
\n
\n
\n
Trivial Archive\n
More Useful Archive Classes\n
Usage\n
Testing\n
Polymorphic Archives\n
\n\n

Trivial Archive

\nThe Archive concept specifies the functions that a\nclass must implement in order to be used to serialize \nSerializable types.\n\nOur discussion will focus on archives used for saving as the hierarchy is exactly analogous\nfor archives used for loading data.\n\n

Minimum Requirements

\n\nThe simplest class which will model the Archive concept specifies the functions that a\nclass will look like:\n\n
\n#include <cstddef> // std::size_t\n//////////////////////////////////////////////////////////////\n// class trivial_oarchive\nclass trivial_oarchive {\npublic:\n    //////////////////////////////////////////////////////////\n    // public interface used by programs that use the\n    // serialization library\n    typedef boost::mpl::bool_<true> is_saving; \n    typedef boost::mpl::bool_<false> is_loading;\n    template<class T> void register_type(){}\n    template<class T> trivial_oarchive & operator<<(const T & t){\n        return *this;\n    }\n    template<class T> trivial_oarchive & operator&(const T & t){\n        return *this << t;\n    }\n    void save_binary(void *address, std::size_t count){};\n};\n
\nThe simplest possible input archive class is analogous to the above.\nIn the following discussion, only output archives will be addressed.\nInput archives are exactly symmetrical to output archives.\n

\nThis archive will compile and execute with any types which implement the\nSerializable concept.\nFor an example see\n\ndemo_trivial_archive.cpp.\nOf course this program won't produce any output as it is. But it provides\nthe starting point for a simple class which can be used to log formatted\noutput. See the implementation of a simple\nlog archive to how this has been done.\n\n

More Useful Archive Classes

\nThe above example is fine as far as it goes. But it doesn't implement\nuseful features such as serialization of pointers, class versioning\nand others. This library implements a family of full featured archive\nclasses appropriate for a variety of purposes. \n\n

\nOur archives have been factored into a tree of classes in order to minimize\nrepetition of code. This is shown in the accompanying \nclass diagram.\n\nAny class which fulfills the following requirements will fit into\nthis hierarchy and implement all the features we require. Deriving from\nthe base class \ncommon_oarchive.hpp provides all features we desire which\nare missing from trivial_oarchive above.\n\n

\n\n#include <cstddef> // std::size_t\n#include <boost/archive/detail/common_oarchive.hpp>\n\n/////////////////////////////////////////////////////////////////////////\n// class complete_oarchive\nclass complete_oarchive : \n    public boost::archive::detail::common_oarchive<complete_oarchive>\n{\n    // permit serialization system privileged access to permit\n    // implementation of inline templates for maximum speed.\n    friend class boost::archive::save_access;\n\n    // member template for saving primitive types.\n    // Specialize for any types/templates that require special treatment\n    template<class T>\n    void save(T & t);\n\npublic:\n    //////////////////////////////////////////////////////////\n    // public interface used by programs that use the\n    // serialization library\n\n    // archives are expected to support this function\n    void save_binary(void *address, std::size_t count);\n};\n
\n\nGiven a suitable definitions of save\nand save_binary, \nany program using serialization with a conforming C++ compiler should compile \nand run with this archive class.\n\n

Optional Overrides

\n\nThe detail::common_oarchive class contains\na number of functions that are used by various parts of the serialization library\nto help render the archive in a particular form.\n\n
\n\n

void save_start(char const *)

\n
\nDefault:Does nothing.
\nPurpose:To inject/retrieve an object name into the archive. Used\nby XML archive to inject \"<name>\" before data.\n
\n

\n\n

void save_end(char const *)

\n
\nDefault:Does nothing.
\nPurpose:To inject/retrieve an object name into the archive. Used\nby XML archive to inject \"</name>\" after data.\n
\n
\n

\n

void end_preamble()

\n
\nDefault:Does nothing.
\nPurpose:Called each time user data is saved. \nIt's not called when archive bookkeeping data is saved. This is used by XML archives \nto determine when to inject a \">\" character at the end of an XML header. XML output archives \nkeep their own internal flag indicating that data being written is header data. This\ninternal flag is reset when an object start tag is written. When \nvoid end_preamble() is invoked and this internal flag is set\na \">\" character is appended to the output and the internal flag is reset. The default\nimplementation for void end_preamble() is a no-op thereby permitting it\nto be optimised away for archive classes that don't use it.\n
\n

\n

\ntemplate<class T>\nvoid save_override(T & t, int);\n

\n
\nDefault:Invokes archive::save(Archive & ar, t)
\nThis is the main entry into the serialization library.
\nPurpose:This can be specialized in cases where the data is to be written \nto the archive in some special way. For example, XML archives implement special handling for\nname-value pairs by overriding this function template for name-value pairs. \nThis replaces the default name-value pair handling, which is just to throw away the name,\nwith one appropriate for XML which writes out the start of an XML tag with the correct object name.\n
\n\n
\n\n

Types used by the serialization library

\nThe serialization library injects bookkeeping data into the serialization archive.\nThis data includes things like object ids, version numbers, class names etc. Each\nof these objects is included in a wrapper so that the archive class can override the\nimplementation of void save_override(T & t, int);.\nFor example, in the XML archive, the override for this type renders an object_id equal to 23 as\n\"object_id=_23\". The following table lists the types defined in the \nboost::archive namespace\nused internally by the serialization library:\n

\n\n\n \n \n \n \n \n \n \n \n
typedefault
serialized as
version_typeunsigned int
object_id_typeunsigned int
object_id_reference_typeunsigned int
class_id_typeint
class_id_optional_typenothing
class_id_reference_typeint
tracking_typebool
classname_typestring
\n

\nAll of these are associated with a default serialization defined in terms of primitive types\nso it isn't a requirement to define save_override \nfor these types.\n

\nThese are defined in\nbasic_archive.hpp.\nAll of these types have been assigned an \nimplementation level of\nprimitive and are convertible to types such as int, unsigned int, etc. \nso that they have default implementations. This is illustrated by\nbasic_text_iarchive.hpp.\nwhich relies upon the default. However, in some cases, overrides will have to be\nexplicitly provided for these types. For an example see\nbasic_xml_iarchive.hpp.\n

\nIn real practice, we probably won't be quite done. \nOne or more of the following issues may need to be addressed:\n

    \n
  • Even if we are using a conforming compiler, we might want our new archive class\n to be portable to non-conforming compilers.\n
  • Our archive format might require extra information inserted into it. For\n example, XML archives need <name ... >...</name> surrounding\n all data objects.\n
  • Addressing any of the above may generate more issues to be addressed.\n
  • The archives included with the library are all templates which use a\n stream or\n streambuf\n as a template parameter rather than simple classes.\n Combined with the above, even more issues arise with non-conforming compilers.\n
\nThe attached class diagram\nshows the relationships between classes used to implement the serialization library.\n

\nA close examination of the archives included with the library illustrate\nwhat it takes to make a portable archive that covers all data types.\n

Usage

\nThe newly created archive will usually be stored in its own header module. All\nthat is necessary is to include the header and construct an instance of the new archive.\nEXCEPT for one special case.\n
    \n
  • Instances of a derived class are serialized through a base class pointer.\n
  • Such instances are not \"registered\" neither implicitly nor explicitly. That\n is, the macro BOOST_CLASS_EXPORT is used \n to instantiate the serialization code for the included archives.\n
\n\nTo make this work, the following should be included after the archive\nclass definition.\n
\nBOOST_SERIALIZATION_REGISTER_ARCHIVE(Archive)\n
\nFailure to do this will not inhibit the program from compiling, linking\nand executing properly - except in one case. If an instance of a derived\nclass is serialized through a pointer to its base class, the program\nwill throw an\nunregistered_class\nexception.\n

\n\n

Testing

\nExhaustive testing of the library requires testing the different aspects of object\nserialization with each archive. There are 46 different tests that can run with any archive. \nThere are 5 \"standard archives\" included with the system. \n(3 in systems that don't support wide character i/o). \n

\nIn addition, there are 28 other tests which aren't related to any particular archive class.\n

\nThe default bjam testing setup will run all\nthe above described tests. This will result in as many as 46 archive tests * 5 \nstandard archives + 28 general tests = 258 tests. Note that a complete test of the\nlibrary would include DLL vs static library, release vs debug so the actual total \nwould be closer to 1032 tests.\n

\nFor each archive there is a header file in the test directory similar to the one below.\nThe name of this archive is passed to the test program by setting the\nenvironmental variable BOOST_ARCHIVE_TEST\nto the name of the header. Here is the header file \ntest_archive.hpp . Test header files for\nother archives are similar.\n

\n// text_archive test header\n// include output archive header\n#include <boost/archive/text_oarchive.hpp>\n// set name of test output archive\ntypedef boost::archive::text_oarchive test_oarchive;\n// set name of test output stream\ntypedef std::ofstream test_ostream;\n\n// repeat the above for input archive\n#include <boost/archive/text_iarchive.hpp>\ntypedef boost::archive::text_iarchive test_iarchive;\ntypedef std::ifstream test_istream;\n\n// define open mode for streams\n//   binary archives should use std::ios_base::binary\n#define TEST_STREAM_FLAGS (std::ios_base::openmode)0\n
\n\nTo test a new archive, for example, portable binary archives, with the gcc compiler, \nmake a header file portable_binary_archive.hpp\nand invoke bjam with\n
 \n-sBOOST_ARCHIVE_LIST=portable_binary_archive.hpp\n
\nThis process in encapsulated in the shell or cmd script \nlibrary_test whose command line is\n
\nlibrary_test --toolset=gcc -sBOOST_ARCHIVE_LIST=portable_binary_archive.hpp\n
\n

Polymorphic Archives

\n\n

Motivation

\n\nAll archives described so far are implemented as templates. Code to save and load\ndata to archives is regenerated for each combination of archive class and data type.\nUnder these circumstances, a good optimizing compiler that can expand \ninline functions to enough depth will generate fast code. \nHowever:\n
    \n
  • Much inline code may be replicated.\n
  • If there are several archive classes, code will be regenerated for each archive class.\n
  • If serialization code is placed in a library, that library must be rebuilt \neach time a new archive class is created.\n
  • If serialization code is placed in a DLL,\n
      \n
    • The DLL will contain versions of code for each known archive type. \n This would result in loading of DLLs which contain\n much code that is not used - basically defeating one of the main motivations\n for choosing to use a DLL in the first place.\n
    • If a new archive is created and an application shipped, all DLLs have to be\n rebuilt, and reshipped along with the application which uses the new archive. Thus\n the other main motivation for using a DLL is defeated.\n
    \n
\n\n

Implementation

\nThe solution is the pair polymorphic_oarchive\nand polymorphic_iarchive. They present a common interface of virtual\nfunctions - no templates - that is equivalent to the standard templated one.\n\nThis is shown in the accompanying \nclass diagram\n

\nThe accompanying demo program in files\n\ndemo_polymorphic.cpp, \ndemo_polymorphic_A.hpp, and \ndemo_polymorphic_A\nshow how polymorphic archives are to be used. Note the following:\n

    \n
  • demo_polymorphic_A.hpp and\ndemo_polymorphic_A.cpp\ncontain no templates and no reference to any specific archive implementation. That is, they will\nonly have to be compiled once for all archive implementations. This even applies to archives classes\ncreated in the future.\n
  • The main program demo_polymorphic.cpp\nspecifies a specific archive implementation. \n
\nAs can be seen in the\nclass diagram\nand the header files, this implementation is just a composition of the polymorphic\ninterface and the standard template driven implementation. This composition is\naccomplished by the templates\npolymorphic_iarchive_route.hpp\nand\npolymorphic_oarchive_route.hpp\nwhich redirect calls to the polymorphic archives to the specific archive.\nAs these contain no code specific to the particular implementation archive, they can be used to create\na polymorphic archive implementation from any functioning templated archive implementation.\n

\nAs a convenience, small header files have been included which contain \na typedef for a polymorphic implementation for each corresponding\ntemplated one. For example, the headers\npolymorphic_text_iarchive.hpp\nand\npolymorphic_text_oarchive.hpp.\ncontain the typedef for the polymorphic implementation\nof the standard text archive classes \ntext_iarchive.hpp\nand\ntext_oarchive.hpp\nrespectively. All included polymorphic archives use the same naming scheme.\n\n

Usage

\nPolymorphic archives address the issues raised above regarding templated implementation.\nThat is, there is no replicated code, and no recompilation for new archives. This will\nresult in smaller executables for program which use more than one type of archive, and \nsmaller DLLS. There is a penalty for calling archive functions through a virtual function \ndispatch table and there is no possibility for a compiler to inline \narchive functions. This will result in a detectable degradation in performance for \nsaving and loading archives.\n

\nNote that the concept of polymorphic archives is fundamentally incompatible with the\nserialization of new types that are marked \"primitive\" by the user with:\n

 \nBOOST_CLASS_IMPLEMENTATION(my_primitive_type, boost::serialization::primitive_type)\n
\n\nCode to implement serialization for these types is instantiated \"on the fly\" in the user's program.\nBut this conflicts with the whole purpose of the polymorphic archive. An attempt to\nserialize such a primitive type will result in a compilation error since the common polymorphic\ninterface is static and cannot instantiate code for a new type.\n\n

\nThe main utility of polymorphic archives will be to permit the building of class DLLs that will\ninclude serialization code for all present and future archives with no redundant code.\n

\n

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

\n\n\n" }, { "path": "doc/archives.html", "content": "\n\n\n\n\n\nSerialization - Archives\n\n\n\n \n \n \n \n
\n

\"C++

\n 		\n

Serialization

\n

Archive Concepts

\n
\n
\n
\n
Saving Archive Concept\n
Loading Archive Concept\n
Models\n
Exceptions\n
Character Sets\n
\n

Notation

\nIn the following descriptions\n
    \n
  • SA is an type modeling the Saving Archive Concept.\n
  • sa is an instance of type SA.\n
  • LA is an type modeling the Loading Archive Concept.\n
  • la is an instance of type LA.\n
  • T is an Serializable Type.\n
  • x is an instance of type T Type.\n
  • u,v is a pointer to a an instance of type T.\n
  • count is an instance of a type that can be converted to std::size_t.\n
\n

Saving Archive Concept

\n

Associated Types

\nIntuitively, a type modeling this concept will generate a sequence of bytes\ncorresponding to an arbitrary set of C++ data structures. Each type modeling the\nSaving Archive concept (SA) may be associated with another type modeling the\nLoading Archive Concept(LA). \nThis associated type will perform the inverse operation. \nThat is, given a sequence of bytes generated by SA, it will generate a set of \nC++ data structures that is equivalent to the original. \nThe notion of equivalence is defined by the implementations of the pair of archives and the\nway the data are rendered serializable.\n

\n

Valid Expressions

\n
\n

\n SA::is_saving\n

\n
\n Returns the Boost MPL Integral Constant type boost::mpl::bool_<true>\n
\n

\n SA::is_loading\n

\n
\n Returns the Boost MPL Integral Constant type boost::mpl::bool_<false>\n
\n

\n sa << x\n
\n sa & x\n

\n
\n These expressions must perform exactly the same function. They append the\n value of x along with other information to sa.\n This other information is defined by the implementation of the archive.\n Typically this information is that which is required by a corresponding\n Loading Archive type to properly restore the value of x.\n

\n Returns a reference to sa. \n

\n

\n sa.save_binary(u, count)\n

\n
\n Appends to the archive size_t(count) bytes found at \n u.\n
\n

\n sa.register_type<T>()\n
\n sa.register_type(u)\n

\n
\n Appends information about class T to the archive. This information is used to\n construct the correct class when a derived pointer is loaded by a corresponding\n Loading Archive type. \n Invocation of this member function is referred to as \"class registration\". \n This is explained in detail in\n Special Considerations - Derived Pointers.\n The second syntax is included to permit this function to be called on non-conforming\n compilers when sa is a template argument.\n For more information, see Template Invocation syntax\n
\n

\n sa.get_library_version()\n

\n
\n Returns an unsigned integer containing the current version number of the serialization\n library. This number will be incremented each time the library is altered in such a \n way that serialization could be altered for some type. For example, suppose the type\n used for a count of collection members is changed. The code that loads collections \n might be conditioned on the library version to make sure that libraries created by \n previous versions of the library can still be read.\n
\n

\n sa.get_helper<Helper>(void * const helper_instance_id = 0)\n

\n
\n See la.get_helper<Helper>(void * const helper_instance_id = 0)\n below.\n
\n\n
\n\n

Loading Archive Concept

\n

Associated Types

\nEach model of this concept presumes the\nexistence of a corresponding type modeling the \nSaving Archive Concept.\nThe purpose of an instance of this concept is to convert a sequence of bytes\ngenerated by this corresponding type to a set of C++ data structures \nequivalent to the original. \n

Valid Expressions

\n
\n

\n LA::is_saving\n

\n
\n Returns the Boost MPL Integral Constant type boost::mpl::bool_<false>\n
\n

\n LA::is_loading\n

\n
\n Returns the Boost MPL Integral Constant type boost::mpl::bool_<true>\n
\n

\n la >> x\n
\n la & x\n

\n
\n These expressions must perform exactly the same function. \n Sets x to a value retrieved from la.\n

\n Returns a reference to la. \n

\n

\n la.load_binary(u, count)\n

\n
\n Retrieves from la size_t(count) bytes and stores\n them in memory starting at u.\n
\n
\n

\n la.register_type<T>()\n
\n la.register_type(u)\n

\n
\n Retrieves information about class T from the archive. This information is used to\n construct the correct class when loading a pointer to a derived class not\n otherwise referred to in the program by name.\n Invocation of this member function is referred to as \"class registration\". \n This is explained in detail in\n Special Considerations - Derived Pointers.\n The second syntax is included to permit this function to be called on non-conforming\n compilers when la is a template argument.\n For more information, see Template Invocation syntax\n
\n

\n la.get_library_version()\n

\n
\n Returns an unsigned integer containing the version number of the serialization\n library that created the archive. This number will be incremented each time the \n library is altered in such a way that serialization could be altered for some type. \n For example, suppose the type used for a count of collection members is changed. \n The code that loads collections might be conditioned on the library version to make \n sure that libraries created by previous versions of the library can still be read.\n
\n

\n la.get_helper<Helper>(void * const helper_instance_id)\n

\n
\n Some otherwise unserializable types can be made serializable by inclusion of\n a helper object. The iconic example of this is shared_ptr which needs this\n helper object to keep track of previously loaded shared_ptr instances so they\n can be \"matched up\" with subsequently loaded ones.\n The first time la.get_helper<Helper>(void * const helper_instance_id)\n is invoked for a given helper_instance_id, Helper, a default-constructed\n Helper object is created, attached to\n la and a reference to it is returned. Subsequent\n invocations of la.get_helper<Helper>(void * const helper_instance_id) with the same id value return\n a reference to the formerly constructed object. All objects created in this manner are\n destroyed upon la destruction time. The purpose\n of helper objects is discussed in\n Special Considerations - Helper Support.\n
\n

\n la.reset_object_address(v, u)\n

\n
\n Communicates to the archive that the object originally at address u has been\n moved to address v.\n

\n When an object is loaded to a temporary variable and later moved to another location,\n this function must be called in order communicate this fact. This permits the\n archive to properly implement object tracking. Object tracking is required in order\n to correctly implement serialization of pointers to instances of derived classes.\n

\n

\n la.delete_created_pointers()\n

\n
\n Deletes all objects created by the loading of pointers. This can be used to\n avoid memory leaks that might otherwise occur if pointers are being loaded\n and the archive load encounters an exception.\n
\n
\n\nThere are archives based on text, binary and XML file\nformats but all have the above interface. Given that all archives present\nthe same public interface, specification of serialization is exactly the same\nfor all archives. Archive classes have other members not mentioned here.\nHowever they are related to the internal functioning of the library and\nare not meant to be called by users of an archive. Implementation of new\narchives is discussed in \nNew Archives - Implementation.\n\n

\nThe existence of the << \nand >> suggests\na relationship between archives and C++ i/o streams. Archives are not \nC++ i/o streams. All the archives included with this system take a stream\nas an argument in the constructor and that stream is used for output or input.\nHowever, this is not a requirement of the serialization functions or the\narchive interface. It just turns out that the archives written so far have\nfound it useful to base their implementation on streams.\n\n

Archive Models

\nThis library includes various implementations of the Archive concept.\n\nAn archive is defined by two complementary classes. One is for saving data while\nthe other is for loading it.\n\nThis library includes a number of archive implementations that are \"ready to go\" for the\nmost common requirements. These classes implement the archive concept for differing data formats.\nThey can be used \"as is\" or as a basis for developing one's own particular type of archive. \nAn archive is defined by two complementary classes. One is for saving data while the other is for loading it. \n\nTo invoke serialization using one of\nthese archives, one or more of the following header files must be\nincluded in the code module containing the serialization code.\n
\n// a portable text archive\nboost::archive::text_oarchive // saving\nboost::archive::text_iarchive // loading\n\n// a portable text archive using a wide character stream\nboost::archive::text_woarchive // saving\nboost::archive::text_wiarchive // loading\n\n// a portable XML archive\nboost::archive::xml_oarchive // saving\nboost::archive::xml_iarchive // loading\n\n// a portable XML archive which uses wide characters - use for utf-8 output\nboost::archive::xml_woarchive // saving\nboost::archive::xml_wiarchive // loading\n\n// a non-portable native binary archive\nboost::archive::binary_oarchive // saving\nboost::archive::binary_iarchive // loading\n\n\n\n
\n\nAll of these archives implement the same interface. Hence, it should suffice to describe only one\nof them in detail. For this purpose we will use the text archive.\n\n\n
\nnamespace boost {\nnamespace archive {\n\nenum archive_flags {\n    no_header = 1,          // suppress archive header info\n    no_codecvt = 2,         // suppress alteration of codecvt facet\n    no_xml_tag_checking = 4 // suppress checking of xml tags - ignored on saving\n};\n\n} // archive\n} // boost\n
\n\n
\nnamespace boost {\nnamespace archive {\n\nclass text_oarchive : ...\n{\n    ...\npublic:\n    ... // implementation of the Saving Archive concept\n    text_oarchive(std::ostream & os, unsigned int flags = 0);\n    ~text_oarchive();\n};\n\n} // archive\n} // boost\n
\n\n
\n\n

\ntext_oarchive(std::ostream & os, unsigned int flags = 0);\n

\n
\nConstructs an archive given an open stream as \nan argument and optional flags. For most applications there will be no need to use flags. \nFlags are defined by enum archive_flags enumerator. \nMultiple flags can be combined with the | operator. \n\nBy default, archives prepend \noutput with initial data which helps identify them as archives produced by this system. \nThis permits a more graceful handling of the case where an attempt is made to load an archive\nfrom an invalid file format. In addition to this, each type of archive might have \nits own information. For example, native binary archives include information about \nsizes of native types and endianness to gracefully handle the case where it has been\nerroneously assumed that such an archive is portable across platforms. In some cases, \nwhere this extra overhead might be considered objectionable, it can be suppressed with the\nno_header flag.\n

\nIn some cases, an archive may alter (and later restore)\nthe codecvt facet of the stream locale. To suppress this action,\ninclude the no_codecvt flag.\n

\nXML archives contain nested tags signifying the start and end of data fields.\nThese tags are normally checked for agreement with the object name when\ndata is loaded. If a mismatch occurs an exception is thrown. It's possible\nthat this may not be desired behavior. To suppress this checking of XML\ntags, use no_xml_tag_checking flag.\n

\n\n

\n~text_oarchive();\n

\n
\nDestructor for an archive. This should be called before the stream is\nclosed. It restores any altered stream facets to their state before the\narchive was opened.\n
\n\n
\n\n
\nnamespace boost {\nnamespace archive {\n\nclass text_iarchive : ...\n{\n    ...\npublic:\n    ... // implementation of the Loading Archive concept\n    text_iarchive(std::istream & is, unsigned int flags = 0);\n    ~text_iarchive();\n};\n\n} //namespace archive\n) //namespace boost\n\n
\n\n
\n\n

\ntext_iarchive(std::istream & is, unsigned int flags = 0);\n

\n
\nConstructs an archive given an open stream as \nan argument and optional flags. If flags are used, they should be the same\nas those used when the archive was created. Function and usage of flags is described\nabove.\n
\n\n

\n~text_iarchive();\n

\n
\nDestructor for an archive. This should be called before the stream is\nclosed. It restores any altered stream facets to their state before the\nthe archive was opened.\n
\n
\n

\nThe binary_oarchive and\nbinary_iarchive classes are\nimplemented in terms of the more basic \nstd::streambuf. So, in addition\nto the common class interface described above, they include the following\nconstructors:\n

\n

\nbinary_oarchive(std::streambuf & bsb, unsigned int flags = 0);\n

\nand\n

\nbinary_iarchive(std::streambuf & bsb, unsigned int flags = 0);\n

\n
\n\n

Exceptions

\nAll of the archive classes included may throw exceptions. The list of exceptions that might\nbe thrown can be found in section Archive Exceptions\nof this documentation. \n\n

Character Sets

\nThis library includes two archive classes for XML. The wide character\nversion (xml_w?archive) renders its output as UTF-8 which can\nhandle any wide character without loss of information. \nstd::string data is converted from multi-byte format to wide\ncharacter format using the current \nlocale. Hence this version should give a fair rendering of all\nC++ data for all cases. This could result in some unexpected behavior.\nSuppose an std::string \nis created with the locale character\nset to hebrew characters. On output this is converted to wide characters.\nOn input however, there could be a problem if the locale is\nnot set the same as when the archive is created.\n

\nThe normal character version (xml_?archive) renders \nstd::string output without any conversion. Though this may work \nfine for serialization, it may create difficulties if the XML archive is used\nfor some other purpose.\n

\n

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

\n\n\n" }, { "path": "doc/bibliography.html", "content": "\n\n\n\n\n\n\nSerialization - Bibliography\n\n\n\n \n \n \n \n
\n

\"C++

\n 		\n

Serialization

\n

Bibliography

\n
\n
\n
    \n
  1. David Sugar and Daniel Silverstone, \"CommonC++ Libraries\", http://www.gnu.org/software/commoncpp/\n \n
  2. Nicola Santi, \"Eternity\", www.sourceforge.net/projects/eternity-it/\n \n
  3. Allen Holub, \"Roll Your Own Persistence\", Microsoft\n Systems Journal vol 11, no 6 Jun 1996\n \n
  4. Code Farms, Inc.\n
  5. Tasos Kontogiorgos & Michael Kim, \"A C++\n Template-Based Application Architecture\", C++ Report\n \n
  6. Scott Meyers, Effective C++, Addison-Wesley, 1992\n \n
  7. Bjarne Stroustrup, The C++ Programming Language, Addison-Wesley, 1997\n \n
  8. Alexandrescu, Andrei, Modern C++ Design, Addison-Wesley, 2001\n \n
  9. Jim Hyslop, and Herb Sutter, \"Factory Redux, Part2\",\n C/C++ User's Journal, vol 21, No. 8, August 2003\n \n
  10. David Vandevoorde and Nicolai M. Josuttis,\n C++ Templates - The Complete Guide, Addison-Wesley, 2003\n \n
  11. Herb Sutter, \"Pimpls--Beauty Marks You Can Depend On\",\n C++ Report, from More C++ Gems, Cambridge University Press, 2000\n \n
  12. James Coplien, \"Curiously Recurring Template Patterns\",\n C++ Report, from C++ Gems, Cambridge University Press, 1998\n \n
  13. Erich Gamma, Richard Helm, Ralph Johnson, and John Vlissides, \n Design Patterns, Addison-Wesley Publishing Company, 1995\n \n
  14. Stephan Beal, \"s11n serialization library\", www.s11n.net\n \n
  15. Vandevoorde and Josuttis, C++ Templates - A Complete Guide, Addison-Wesley, 2003\n
\n
\n

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

\n\n\n\n" }, { "path": "doc/class_diagram.html", "content": "\n\n\n\n\n\n\nSerialization - Archive Class Diagram\n\n\n\n \n \n \n \n
\n

\"C++

\n 		\n

Serialization

\n

Text Archive Class Diagram

\n
\n
\n\n
\n\n\nbasic_oarchive ->\n      |\n      |\n      |      interface_oarchive<text_oarchive> ->\n      |                     /\n      |                   /\n      |        _________/\n      |      /\n      |    /\n      |  /\ncommon_oarchive<text_oarchive> ->\n      |\n      |\nbasic_text_oarchive<text_oarchive> ->\n      |\n      |\n      |     basic_text_oprimitive<basic_ostream> ->\n      |                    /\n      |                  /\n      |       _________/                  interface_oarchive<polymorphic_oarchive> ->\n      |     /                                                |\n      |   /                                                  |\n      | /                                                    |\ntext_oarchive_impl<text_oarchive> ->              polymorphic_oarchive_impl ->\n      | \\                                                    |\n      |   \\                                                  |\n      |     \\_____________________________________    polymorphic_oarchive ->\n      |                                           \\         /\n      |                                             \\     /\n      |                                               \\ /  \ntext_oarchive ->                 polymorphic_oarchive_route<text_oarchive_impl<text_oarchive> > ->\n                                                       |\n                                                       |\n                                                       |\n                                             polymorphic_text_oarchive ->\n\n\n
\nThis diagram shows the relationship between the various classes that implement saving (output\nserialization) for text archives. The hierarchy and organization is similar for loading and for\nother types of archives as well. In the diagram, classes written in blue \nimplement saving for a given archive type. (in this case it's text archives).\nUsers include classes in red to save their data from a particular\ntype of archive. Other classes whose names are in black implement the library and should\nnever change. They are in namespace boost::archive::detail\n
\n
\n basic_oarchive\n
\n
\n Implements the core library functions for class export, versioning, and object tracking. It is compiled\n into the library as it has no template parameters.\n
\n

\n interface_oarchive<text_oarchive>\n
\n
\n A class that declares the standard archive interface. This has been factored out so that it\n can be used as a base class for polymorphic_oarchive\n as well as for archive implementations.\n \n

\n common_oarchive<text_oarchive>\n
\n
\n The function of this class is to make the connection between the virtual function\n interface used by basic_oarchive and the template interface used by archive\n class implementations.\n \n

\n basic_text_oarchive<text_oarchive>\n
\n
\n Implements the basic functionality for simple text archives. The primitive save functions have been \n factored out so it can be used in other text based archives like XML archives.\n \n

\n basic_text_oprimitive<basic_ostream>\n
\n
\n Implements the save oversaves for all primitive types. This is a template with a parameter\n which describes the stream.\n \n

\n text_oarchive_impl<text_oarchive> \n
\n
\n Inherits from the above two classes to implement text archives.\n
\n\n

\n text_oarchive\n
\n
\n This is just a short hand for text_oarchive_impl<text_oarchive> .\n We can't use typedef because a \n typedef can't refer to it self in its definition. \n This is the class name that is used to serialize to a text archive.\n
\n\n

\n interface_oarchive<polymorphic_oarchive>\n
\n
\n Same template as above. However, this time the Archive parameter refers to the polymorphic archive\n with a virtual function interface rather than that the template interface that\n common_oarchive uses.\n \n

\n polymorphic_oarchive\n
\n
\n A class with a list of virtual save(T &t)\n for all primitive types T. This is the class that is used to do pre-compile serialization of classes\n for all archives present and future.\n \n

\n polymorphic_oarchive_route<text_oarchive_impl<text_oarchive> >\n
\n

\n This class implements the polymorphic_oarchive in terms of a specific \n concrete class. Virtual function calls are routed to the implementing class. In this example, \n that implementing class would be text_oarchive_impl.\n \n

\n polymorphic_text_oarchive\n
\n
\n this is just a typedef so we can write polymorphic_text_archive rather than\n polymorphic_oarchive_route<text_oarchive_impl<text_oarchive> >\n \n
\n
\n

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

\n\n" }, { "path": "doc/codecvt.html", "content": "\n\n\n\n\n\n\nUTF-8 Codecvt Facet\n\n\n\n\n\"C++
\n\n\n\n\n\n

utf8_codecvt_facet

\n\n\n
\ntemplate<\n    typename InternType = wchar_t, \n    typename ExternType = char\n> utf8_codecvt_facet\n
\n\n\n

Rationale

\n\n\n UTF-8 is a method of encoding Unicode text in environments\n where data is stored as 8-bit characters and some ascii characters \n are considered special (i.e. Unix filesystem filenames) and tend\n to appear more commonly than other characters. While\n UTF-8 is convenient and efficient for storing data on filesystems, \n it was not meant to be manipulated in memory by\n applications. While some applications (such as Unix's 'cat') can\n simply ignore the encoding of data, others should convert \n from UTF-8 to UCS-4 (the more canonical representation of Unicode) \n on reading from file, and reversing the process on writing out to\n file.\n \n

The C++ Standard IOStreams provides the std::codecvt\n facet to handle specifically these cases. On reading from or\n writing to a file, the std::basic_filebuf can call out to\n the codecvt facet to convert data representations from external\n format (ie. UTF-8) to internal format (ie. UCS-4) and\n vice-versa. utf8_codecvt_facet is a specialization of\n std::codecvt specifically designed to handle the case\n of translating between UTF-8 and UCS-4.\n\n\n

Template Parameters

\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n
ParameterDescriptionDefault
InternTypeThe internal type used to represent UCS-4 characters.wchar_t
ExternTypeThe external type used to represent UTF-8 octets.char_t
\n\n\n

Requirements

\n\n utf8_codecvt_facet defaults to using char as\n its external data type and wchar_t as its internal\n datatype, but on some architectures wchar_t is\n not large enough to hold UCS-4 characters. In order to use\n another internal type.You must also specialize std::codecvt\n to handle your internal and external types.\n (std::codecvt<char,wchar_t,std::mbstate_t> is required to be\n supplied by any standard-conforming compiler).\n\n\n

Example Use

\n The following is a simple example of using this facet:\n\n
\n  //...\n  // My encoding type\n  typedef wchar_t ucs4_t;\n\n  std::locale old_locale;\n  std::locale utf8_locale(old_locale,new utf8_codecvt_facet<ucs4_t>);\n\n  // Set a New global locale\n  std::locale::global(utf8_locale);\n\n  // Send the UCS-4 data out, converting to UTF-8\n  {\n    std::wofstream ofs(\"data.ucd\");\n    ofs.imbue(utf8_locale);\n    std::copy(ucs4_data.begin(),ucs4_data.end(),\n          std::ostream_iterator<ucs4_t,ucs4_t>(ofs));\n  }\n\n  // Read the UTF-8 data back in, converting to UCS-4 on the way in\n  std::vector<ucs4_t> from_file;\n  {\n    std::wifstream ifs(\"data.ucd\");\n    ifs.imbue(utf8_locale);\n    ucs4_t item = 0;\n    while (ifs >> item) from_file.push_back(item);\n  }\n  //...\n
\n\n\n

History

\n\n This code was originally written as an iterator adaptor over\n containers for use with UTF-8 encoded strings in memory.\n Dietmar Kuehl suggested that it would be better provided as a\n codecvt facet.\n\n

Resources

\n\n\n\n
\n
\n\n\n\n\n\n
Copyright © 2001Ronald Garcia,\nIndiana University \n(garcia@osl.iu.edu)
\nAndrew Lumsdaine,\nIndiana University\n(lums@osl.iu.edu)
\n

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

\n\n\n\n\n" }, { "path": "doc/configuration.html", "content": "\n\n\n\n\n\n\nSerialization - Configuration\n\n\n\n\n" }, { "path": "doc/contents.html", "content": "\n\n\n\n\n\nSerialization\n\n\n\n\n\n\n

Contents

\n\n\n

\n

\n
Release Notes
\n
Overview
\n
\n
Tutorial
\n
\n\n
Reference
\n
\n
Archive Concepts\n
\n
Serializable Concept\n
\n
Special Considerations\n
\n
Archive Class Reference\n
\n
\n
Implementation Notes\n
\n
Case Studies\n
\n
Other Classes\n
\n \n
Tips and Tricks\n
Rationale
\n
\n\n
To Do
\n
\n\n
History\n \n
Bibliography
\n
Acknowledgments
\n
\n\n\n\n" }, { "path": "doc/dataflow.html", "content": "\n\n\n\n\n\n\nSerialization - Dataflow Iterators\n\n\n\n \n \n \n \n
\n

\"C++

\n 		\n

Serialization

\n

Dataflow Iterators

\n
\n
\n

Motivation

\nConsider the problem of translating an arbitrary length sequence of 8 bit bytes \nto base64 text. Such a process can be summarized as:\n

\nsource => 8 bit bytes => 6 bit integers => encode to base64 characters => insert line breaks => destination\n

\nWe would prefer the solution that is:\n

    \n
  • Decomposable. so we can code, test, verify and use each (simple) stage of the conversion \n independently.\n
  • Composable. so we can use this composite as a new component somewhere else.\n
  • Efficient, so we're not required to re-implement it again.\n
  • Scalable, so that it works well for short and arbitrarily long sequences.\n
\nThe approach that comes closest to meeting these requirements is that described\nand implemented with Iterator Adaptors.\nThe fundamental feature of an Iterator Adaptor template that makes it interesting to\nus is that it takes as a parameter a base iterator from which it derives its\ninput. This suggests that something like the following might be possible.\n
\ntypedef \n    insert_linebreaks<         // insert line breaks every 76 characters\n        base64_from_binary<    // convert binary values to base64 characters\n            transform_width<   // retrieve 6 bit integers from a sequence of 8 bit bytes\n                const char *,\n                6,\n                8\n            >\n        > \n        ,76\n    > \n    base64_text; // compose all the above operations in to a new iterator\n\nstd::copy(\n    base64_text(address),\n    base64_text(address + count),\n    ostream_iterator<CharType>(os)\n);\n
\nIndeed, this seems to be exactly the kind of problem that iterator adaptors are \nintended to address. The Iterator Adaptor library already includes\nmodules which can be configured to implement some of the operations above. For example,\nincluded is \ntransform_iterator, which can be used to implement 6 bit integer => base64 code.\n\n

Dataflow Iterators

\nUnfortunately, not all iterators which inherit from Iterator Adaptors are guaranteed\nto meet the composability goals stated above. To accomplish this purpose, they have\nto be written with some additional considerations in mind.\n\nWe define a Dataflow Iterator as an class inherited from iterator_adaptor which\nfulfills a small set of additional requirements.\n\n

Templated Constructors

\n

\nTemplated constructor have the form:\n

\ntemplate<class T>\ndataflow_iterator(T start) :\n    iterator_adaptor(Base(start))\n{}\n
\nWhen these constructors are applied to our example of above, the following code is generated:\n
\nstd::copy(\n    insert_linebreaks(\n        base64_from_binary(\n            transform_width(\n                address\n            ),\n        )\n    ),\n    insert_linebreaks(\n        base64_from_binary(\n            transform_width(\n                address + count\n            )\n        )\n    )\n    ostream_iterator<char>(os)\n);\n
\nThe recursive application of this template is what automatically generates the\nconstructor base64_text(const char *) in our example above. The original\nIterator Adaptors include a make_xxx_iterator to fulfill this function.\nHowever, I believe these are unwieldy to use compared to the above solution using\nTemplated constructors.\n\n

Dereferencing

\nDereferencing some iterators can cause problems. For example, a natural\nway to write a remove_whitespace iterator is to increment past the initial \nwhitespaces when the iterator is constructed. This will fail if the iterator passed to the\nconstructor \"points\" to the end of a string. The \n\nfilter_iterator is implemented\nin this way so it can't be used in our context. So, for implementation of this iterator, \nspace removal is deferred until the iterator actually is dereferenced.\n\n

Comparison

\nThe default implementation of iterator equality of iterator_adaptor just\ninvokes the equality operator on the base iterators. Generally this is satisfactory.\nHowever, this implies that other operations (E. G. dereference) do not prematurely \nincrement the base iterator. Avoiding this can be surprisingly tricky in some cases.\n(E.G. transform_width)\n\n

\nIterators which fulfill the above requirements should be composable and the above sample\ncode should implement our binary to base64 conversion.\n\n

Iterators Included in the Library

\nDataflow iterators for the serialization library are all defined in the namespace\nboost::archive::iterators included here are:\n
\n
\n base64_from_binary
\n
transforms a sequence of integers to base64 text
\n\n
\n binary_from_base64
\n
transforms a sequence of base64 characters to a sequence of integers
\n\n
\n insert_linebreaks
\n
given a sequence, creates a sequence with newline characters inserted
\n\n
\n mb_from_wchar
\n
transforms a sequence of wide characters to a sequence of multi-byte characters
\n\n
\n remove_whitespace
\n
given a sequence of characters, returns a sequence with the white characters\n removed. This is a derivation from the boost::filter_iterator
\n\n
\n transform_width
\n
transforms a sequence of x bit elements into a sequence of y bit elements. This\n is a key component in iterators which translate to and from base64 text.
\n\n
\n wchar_from_mb
\n
transform a sequence of multi-byte characters in the current locale to wide characters.
\n\n
\n xml_escape
\n
escapes xml meta-characters from xml text
\n\n
\n xml_unescape
\n
unescapes xml escape sequences to create a sequence of normal text
\n
\n

\nThe standard stream iterators don't quite work for us. On systems which implement wchar_t\nas unsigned short integers (E.G. VC 6) they didn't function as I expected. I also made some\nadjustments to be consistent with our concept of Dataflow Iterators. Like the rest of our\niterators, they are found in the namespace boost::archive::interators to avoid\nconflicts with the standard library versions.\n

\n
\n istream_iterator
\n
\n ostream_iterator
\n
\n\n
\n

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

\n\n\n" }, { "path": "doc/definitions.html", "content": "\n\n\n\n\n\n\nSerialization - Definitions\n\n\n\n\n" }, { "path": "doc/derivation.html", "content": "\n\n\n\n\n\n\nSerialization - Derivation from an Existing Archive\n\n\n\n \n \n \n \n
\n

\"C++

\n 		\n

Serialization

\n

Derivation from an Existing Archive

\n
\n
\n
\n
\n\n

Log Archive

\nIt may happen that one wants to create a new archive class by derivation from one\nof the included ones. Included is a sample program that shows how to derive a \nnew archive from one of the ones included with the library. The first example is\n\ndemo_log.cpp.\n

\nThis derivation from the xml archive writes output in xml without the extra\ninformation required to read the data back into the application. It might be\nused to export one's data as simple xml for other applications or for logging\ndata while debugging.\n

\nTo this end it is derived from the included xml archive and the save functions for\nsome types are specialized for this application. \n

\nThe serialization library is\nimplemented using the Curiously Recurring Template \nPattern (CRTP). Also, all common code is factored out into\nseparate modules to minimize code repetition. This makes derivation from\nan existing archive less straightforward than it would otherwise be.\n

\nThis example illustrates several issues that have to be addressed when doing\nsomething like this\n

    \n
  1. It is derived from xml_oarchive_impl \n NOT xml_oarchive
    \nAs described in the comments in\nxml_oarchive.hpp.\nxml_oarchive really a shorthand name for \nxml_oarchive_impl<xml_oarchive>. So we should derive\nfrom xml_oarchive_impl<log_archive> rather\nthan xml_oarchive.\n
    \nclass log_archive :\n    // don't derive from xml_oarchive !!!\n    public xml_oarchive_impl<log_archive>\n{\n...\n
    \n
  2. Note the log_archive between the <>\nThis is required so that base classes can downcast their this pointer\nto the most derived class. This is referred to as Curiously Recurring\nTemplate Pattern (CRTP) [11]. \nIt is used to implement static polymorphism.\n
  3. Base classes need to be explicitly given access to the derived class.\nThis can be done by making members public or by including friend declarations for\nthe base classes.\n
    \n    friend class detail::common_oarchive<log_archive>;\n    friend class basic_xml_oarchive<log_archive>;\n    friend class boost::serialization::save_access;\n
    \n\n
  4. Reread Archive Internals.\nThis describes the class hierarchy so that you know what to override.\n
  5. Base class functions will usually need to be explicitly invoked.\nWe commonly specialize the function name save_override \nfor saving primitives. Usage of a function name in a derived class\n\"hides\" similarly named functions of the base class. That is, \nfunction name overloading doesn't automatically\ninclude base classes. To address this, we can use:\n
    \n    using xml_oarchive_impl<derived_t>::save;\n    void save(const unsigned int t);\n    ...\n
    \nwhich should work on conforming compilers. However, I have found\nthat the following equivalent works on more compilers.\n
    \n    // default fall through for any types not specified here\n    template<class T>\n    void save(const T & t){\n        xml_oarchive_impl<derived_t>::save(t);\n    }\n    void save(const unsigned int t);\n    ...\n
    \nso it's what I use.\n
  6. Template definitions of base classes may have to be explicitly instantiated.\n The demo includes\n
    \n// explicitly instantiate for this type of binary stream\n#include <boost/archive/basic_binary_oprimitive.ipp>\n
    \nfor just this purpose. Failure to include required template definitions\nwill result in undefined symbol errors when the program is linked.\n
  7. Without alteration, this class cannot be further derived from.
    \nBase classes using CRTP must be templates with a parameter corresponding to\nthe most derived class. As presented here, this class doesn't qualify, so\nit cannot be used as a base class. In order to derive further from this class,\nit would have to be reorganized along the lines of the original xml_oarchive.\nSpecifically, it would look something like:\n
    \ntemplate<class Archive>\nclass log_archive_impl :\n    // don't derive from xml_oarchive !!!\n    public xml_oarchive_impl<Archive>\n{\n    ...\n};\n\n// do not derive from this class !!!\nclass log_archive : \n    public log_archive_impl<log_archive>\n{\npublic:\n    log_archive(std::ostream & os, unsigned int flags = 0) :\n        log_archive_impl<xml_oarchive>(os, flags)\n    {}\n};\n
    \n\n
\n\n
\n

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

\n\n\n" }, { "path": "doc/exception_safety.html", "content": "\n\n\n\n\n\n\nSerialization - Reference\n\n\n\n \n \n \n \n
\n

\"C++

\n 		\n

Serialization

\n

Exception Safety

\n
\n
\nThe process of loading an archive may result in the creation of new objects. That\nsame process may throw an exception at some point. In order to prevent memory leaks\nand invalid pointers, these situations must be considered. Unfortunately, there is\nno simple universal solution to this problem. The manner of addressing this must\ndepend on the design of the data structures to be serialized. Below, we discuss\nvarying scenarios in increasing order of difficulty. This discussion presumes that\nthe class member functions are exception safe before considering serialization. \nThat is, the destructor could be called at anytime without referencing \nan invalid pointer, or creating a memory leak.\n
    \n

  1. class contains no pointers

    \n No problem here.\n

    \n

  2. class contains only owned pointers

    \n From here on, we have to make a distinction between pointers used\n to manage heap storage (owned pointers) and pointers used to refer\n to related objects (referenced pointers). Programs containing owned\n pointers must contain code for deleting these objects and returning the\n deallocated storage to the heap. Programs containing referenced pointers\n must be designed to ensure that no such referenced pointers are de-referenced\n after the object pointed to has been destroyed and its storage returned\n to the heap. If a pointer is stored in only one place, it must be an owned\n pointer.\n

    \n The load function traps any exceptions that occur between the time an object\n is created and its pointer is stored. Should an exception occur while\n reading an archive, the created object is deleted and the de-serialized\n pointer is set to NULL. This ensures that there are no memory leaks.\n The fact that there are no other copies of this pointer ensures that\n no pointers are left invalid. The object's destructor should\n be able to delete any other existing objects in the normal manner\n without problem.\n test_delete_pointer.cpp\n illustrates this case.\n

    \n

  3. class contains one or more referenced pointers

    \n This situation can be further subdivided into two cases\n

    \n

      \n

    1. owned pointers are always serialized before referenced pointers

      \n Object tracking will ensure that no new objects will be created\n by the loading of a referenced pointer.\n If an exception occurs, referenced pointers will not need to be deleted\n so there will be no memory leaks. The destructor of this class won't attempt to\n delete these pointers so there will be no problem with dangling references.\n Owned pointers are handled exactly as described above.\n

      \n

    2. class contains referenced pointers which might be created by load

      \n If a referenced pointer is loaded before its corresponding owned\n pointer, the object will be allocated on the heap. In certain cases\n it cannot be known which pointers were created by their owners and which\n were created by the load function. To address this:\n
        \n
      • Trap exceptions with a try/catch block.\n
      • Within the catch part, invoke the archive function \n delete_created_pointers() to delete any pointers\n created by the class load. Without other action, objects created in\n this way would end up as memory leaks as they are not considered owned\n pointers and hence aren't destroyed.\n
      • The object's destructor won't try\n to delete referenced pointers so any dangling references will\n cause no harm.\n
      \n demo_exception.cpp\n is a program that illustrates this case.\n

      \n

    \n

    \n

  4. Other cases

    \n Situations not covered above are pointers for which the classifications of \n referenced and owned are not applicable. This might occur where\n pointers are created by one class but consumed and deleted by another. These\n may be addressed with an ad hoc analysis similar to the above. As the\n situation becomes more complex this becomes more difficult and error prone.\n Eventually, it will be have to addressed by building heap management into the\n pointer itself - that is into boost::shared_ptr. \n The library includes serialization of boost::shared_ptr. As\n previously mentioned, this required a tiny alteration in one of the\n boost::shared_ptr implementation files in order to permit\n access by the serialization system.\n
\n
\n

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

\n\n\n" }, { "path": "doc/exceptions.html", "content": "\n\n\n\n\n\n\nSerialization - Archive Exceptions\n\n\n\n \n \n \n \n
\n

\"C++

\n 		\n

Serialization

\n

Archive Exceptions

\n
\n
\n
\n
unregistered_class\n
invalid_signature\n
unsupported_version\n
unsupported_class_version\n
pointer_conflict\n
incompatible_native_format\n
array_size_too_short\n
input_stream_error\n
output_stream_error\n
invalid_class_name\n
unregistered_class\n
multiple_code_instantiation\n
xml_archive_parsing_error\n
xml_archive_tag_mismatch\n
xml_archive_tag_name_error\n
\n\nArchive operators can throw a boost::archive_exception\nobject which can be caught by an application program. These exceptions are defined\nin the files \narchive_exception.hpp\nand \nbasic_xml_archive.hpp.\n
\nnamespace boost {\nnamespace archive {\n\nclass archive_exception  : public std::exception\n{\npublic:\n    typedef enum {\n        unregistered_class,     // attempt to serialize a pointer of\n                                // an unregistered class\n        invalid_signature,      // first line of archive does not contain\n                                // expected string\n        unsupported_version,    // archive created with library version subsequent\n                                // to this one\n        pointer_conflict        // an attempt has been made to directly serialize\n                                // an object after having already serialized the same\n                                // object through a pointer.  Were this permitted, \n                                // the archive load would result in the creation\n                                // of an extraneous object.\n        incompatible_native_format, // attempt to read native binary format\n                                // on incompatible platform\n        array_size_too_short,   // array being loaded doesn't fit in array allocated\n        input_stream_error      // error on stream input\n        invalid_class_name,     // class name greater than the maximum permitted.\n                                // most likely a corrupted archive or an attempt\n                                // to insert virus via buffer overrun method.\n        unregistered_cast,      // base - derived relationship not registered with \n                                // void_cast_register\n        unsupported_class_version, // type saved with a version # greater than the \n                            // one used by the program.  This indicates that the program\n                            // needs to be rebuilt.\n        multiple_code_instantiation, // code for implementing serialization for some\n                            // type has been instantiated in more than one module.\n        output_stream_error     // error on stream output\n    } exception_code;\n    exception_code code;\n    archive_exception(exception_code c) : code(c) {}\n    virtual const char *what( ) const throw();\n};\n\nclass xml_archive_exception : public virtual archive_exception\n{\npublic:\n    typedef enum {\n        xml_archive_parsing_error,  // archive doesn't contain expected data \n\txml_archive_tag_mismatch,   // start/end tag in archive doesn't match program\n        xml_archive_tag_name_error  // tag name contains invalid characters\n\n    } exception_code;\n    xml_archive_exception(exception_code c){}\n    virtual const char *what( ) const throw();\n};\n\n} // archive\n} // boost\n
\n

\n

unregistered_class

\nAn attempt has been made to serialize a polymorphic class through a pointer\nwithout either registering it or associating it with an export key. This can also occur\nwhen using a new archive whose class name has not been added to the system with the \nBOOST_ARCHIVE_CUSTOM_ARCHIVE_TYPES macro.\n\n

invalid_signature

\nArchives are initiated with a known string. If this string is not found when\nthe archive is opened, It is presumed that this file is not a valid archive and this\nexception is thrown.\n\n

unsupported_version

\nThis system records the current library version number to all archives created. Note that this is in\nno way related to version number of classes used by application programs. This refers\nto the version of the serialization system used to create the archive. Future versions\nof this serialization system will be able to identify archives created under a previous\n(i.e. this) system and alter the loading procedure accordingly. Hence, future enhancements\nto this serialization system should not obsolete any existing archive files. It is only\nnecessary to increment this version number when the newer system creates archives\nincompatible in format with the current one. \n

Should it ever occur that an older program attempts to read newer archives whose\nformat has changed, this exception is thrown.\n\n

unsupported_class_version

\nAn attempt has been made to load a class whose version has been incremented since the\nprogram was written. Suppose that a class has been assigned version number 3 and the program\nhas been built and sent to third parties. Now suppose that the definition of that class\nhas been altered, the version number has been incremented to 4 and new archives have been\nbuilt. If one attempts to load these new archives with the original program, this \nexception will be thrown.\n\n

pointer_conflict

\nTo understand what this exception means consider the following scenario\n
\ntemplate<class Archive>\nvoid T::save(Archive &ar) const\n{\n    const A * aptr = &a;\n    ar << aptr;          // save an instance of object of class A through a pointer\n    ...\n    ar << a;             // save an instance of an object of class A\n    assert(aptr == &a);  // this must be true\n}\n\ntemplate<class Archive>\nvoid T::load(Archive &ar)\n{\n    A * aptr;\n    ar >> aptr;          // create and initialize a new instance of class A\n    ...\n    ar >> a;             // restore state of on object of class A\n    assert(aptr == &a);  // this won't be true\n}\n
\nAn object is saved first through a pointer then directly. Upon loading back\nin the same sequence, we first create an new object and load in its data. Then\nwe load the data into another existing object. Where we started with one\nobject during save, we have two objects after restore. In a more realistic\nsituation, it could be very difficult to find this error. Fortunately, \nthese situations can be detected when the archive is created. When\nthis occurs, this exception is thrown.\n\n

incompatible_native_format

\nThe library currently supports char text, wide char text and native binary\narchive files. At the beginning of every archive, a signature is written indicating\nthe type of archive. This exception is thrown when an attempt is made to read\nan archive written in a different format.\n\n

array_size_too_short

\nAn attempt has been made to read an array that is larger than the array size.\nThis should only occur when the size of an array in code is reduced after an\narchive has already been created.\n\n

\ninput_stream_error\n
\noutput_stream_error\n

\nAn error has occurred during stream input or ouput. Aside from the common \nsituations such as a corrupted or truncated input file, there are \nseveral less obvious ones that sometimes occur.\n

\nThis includes\nan attempt to read past the end of the file. Text files need a terminating\nnew line character at the end of the file which is appended when the\narchive destructor is invoked. Be sure that an output archive on a stream\nis destroyed before opening an input archive on that same stream. That is,\nrather than using something like:\n

\nstd::stringstream ss;\nstd::vector<V> v;\nboost::archive::text_oarchive oa(ss);\noa << v;\nboost::archive::text_iarchive ia(ss);\nia >> v;\n
\nuse\n
\nstd::stringstream ss;\nstd::vector<V> v;\n{\n    boost::archive::text_oarchive oa(ss);\n    oa << v;\n}\n{\n    boost::archive::text_iarchive ia(ss);\n    ia >> v;\n}\n
\n

\nAnother one is the passing of uninitialized data. In general, the behavior\nof the serialization library when passed uninitialized data is undefined.\nIf it can be detected, it will invoke an assertion in debug builds.\nOtherwise, depending on the type of archive, it may pass through without\nincident or it may result in an archive with unexpected data in it.\nThis, in turn, can result in the throwing of this exception.\n\n

invalid_class_name

\nClass name length greater than the maximum permitted. Most likely cause is a corrupted \narchive or an attempt to insert a virus via the buffer overrun method.\n\n

unregistered_cast

\nIn order to support casting between pointers of base and derived classes\nat runtime, a collection of legitimate conversions is maintained by the system.\nNormally this collection is maintained without any explicit action\non the part of the user of the library. However, there are special cases\nwhere this might have to be done explicitly and could be overlooked. This\nis described in Runtime Casting.\nThis exception is thrown if an attempt is made to convert between two pointers \nwhose relationship has not been registered,\n\n

multiple_code_instantiation

\nThis exception is thrown when it is detected that the serialization of the same type \nhas been instantiated more than once. This might occur when\nserialization code is instantiated in both the mainline and one or more DLLS.\n\n

xml_archive_parsing_error

\nThe XML generated by the serialization process is intimately coupled to the\nC++ class structure, relationships between objects and the serialization \nspecifications. If these become out of sync in any way, the XML may not map\nto the loading serialization and this exception might be thrown. This might\noccur for one of the following reasons:\n
    \n
  • The archive has been edited outside the serialization system. This might\nbe possible if only the data is changed and the XML attributes and nesting\nstructure are left unaltered. But any other editing is likely to render the\narchive unreadable by the serialization library.\n
  • The serialization has been altered and an archive generated by the old\ncode is being read. That is, versioning has not been properly employed to\nproperly deserialize previously created archives.\n
\n\n

xml_archive_tag_mismatch

\nThis exception will be thrown if the start or end tag of an XML element doesn't match\nthe name specified for the object in the program.\n\n

xml_archive_tag_name_error

\nThis exception will be thrown if the tag name contains invalid characters. Valid characters\nfor an XML tag are: upper and lower case letters, digits, and the following punctuation: .(period),\n_(underscore), :(colon), and -(hyphen).\n\n
\n

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

\n\n\n" }, { "path": "doc/extended_type_info.html", "content": "\n\n\n\n\n\n\nSerialization - extended_type_info\n\n\n\n \n \n \n \n
\n

\"C++

\n 		\n

Serialization

\n

extended_type_info

\n
\n
\n
\n
Motivation\n
Runtime Interface\n
Requirements\n
Models\n
Example\n
\n\n

Motivation

\nThe serialization library needs a system like \ntype_info/typeid() to perform\nthe following functions\n
    \n
  1. \n given a pointer to a type T discover the true type pointed to.\n
  2. \n given an \"external\" key - determine what type of object to create.\n
\n

The problem with std::type_info

\n
    \n
  • \n The main function we require - std::typeid()\n is not available in all environments. Support for this function depends upon\n runtime typing(RTTI) support from the compiler. This may be non-existent\n or not enabled for reasons such as a perceived inefficiency.\n
  • \n std::type_info includes a string\n containing type name. This would seem to satisfy 2) above.\n But the format of this string is not consistent accross compilers, libraries, \n and operating systems. This makes it unusable for support of portable archives.\n
  • \n Even if the type name string could somehow be made portable, there is no \n guarantee that class headers would be included in the same namespace accross \n different applications. In fact, including different headers in different\n namespaces is an accepted method used to avoid namespace conflicts.\n Thus the namespace::class_name can't be used as a key.\n
  • \n There exists the possibility that different classes use different type id \n mechanisms. The class header might include this information. If we want to \n import class headers accross applications, it's convenient that the type id\n mechanism support inter-operability accross different type id systems.\n
\n

Features

\n\nextended_type_info is an implementation\nof std::type_info functionality with the \nfollowing features:\n
    \n
  • \n Builds a set of \n extended_type_info records - one for each type\n serialized.\n
  • \n permits association of an arbitrary string key with a type. Often this key would\n be the class name - but it doesn't have to be. This key is referred to as\n a GUID - Globally Unique IDentifier. Presumably it should be unique in the universe.\n Typically this GUID would be in header files and be used to match type accross\n applications. The macro BOOST_CLASS_EXPORT can be invoked to associate a string\n key with any known type. We'll refer to these types as \"exported types\"\n
  • \n permits the \"mixing\" of type info systems. For example, one class might use \n typeid() to find the external identifier \n of a class while another might not.\n
\n\nExported types are maintained in a global table so that given a string key, the\ncorresponding type can be found. This facility is used by the serialization library\nin order to construct types serialized through a base class pointer.\n\n

Runtime Interface

\n
\nnamespace boost { \nnamespace serialization {\n\nclass extended_type_info\n{\nprotected:\n    // this class can't be used as is. It's just the \n    // common functionality for all type_info replacement\n    // systems.  Hence, make these protected\n    extended_type_info(\n        const unsigned int type_info_key,\n        const char * key\n    );\n    ~extended_type_info();\n    void key_register();\n    void key_unregister();\npublic:\n    const char * get_key() const;\n    bool operator<(const extended_type_info &rhs) const;\n    bool operator==(const extended_type_info &rhs) const;\n    bool operator!=(const extended_type_info &rhs) const {\n        return !(operator==(rhs));\n    }\n    // for plugins\n    virtual void * construct(unsigned int count = 0, ...) const;\n    virtual void destroy(void const * const p) const;\n    static const extended_type_info * find(const char *key);\n};\n\n} // namespace serialization \n} // namespace boost\n
\n

\nGenerally, there will be one and only one\nextended_type_info\ninstance created for each type. However, this is enforced only at the executable\nmodule level. That is, if a program includes some shared libraries or DLLS,\nthere may be more than one instance of this class corresponding to a particular type.\nFor this reason the comparison functions below can't just compare the addresses of \nthis instance but rather must be programmed to compare the actual information \nthe instances contain.\n

\n\n

\nextended_type_info(unsigned int type_info_key, const char *key);\n

\n
\nThis constructor should be called by all derived classes.\nThe first argument should be the particular implementation. \nFor this default implementation base on typeid(), this is the \nvalue 1. Each system must have its own integer. This value\nis used to permit the inter-operability of different typeinfo\nsystems.\n

\nThe second argument is a const string which is the external\nname of the type to which this record corresponds. \nIt may sometimes be referred to as a GUID - a Global Unique IDentifier.\nIt is passed through archives from one program invocation to\nanother to uniquely identify the types that the archive contains.\nIf the \"export\" facility is not going to be used, \nthis value may be NULL.\n

\n\n

\nvoid key_register();\nvoid key_unregister();\n

\n
\nThis system maintains a global table which relates\nexternal strings to \nextended_type_info records.\nThis table is used when loading pointers to objects serialized\nthrough a base class pointer. In this case, the archive \ncontains a string which is looked up in this table to\ndetermine which extended_type_info\nto use for creating a new object.\n

\nThese functions are called by constructors and\ndestructors of classes which implement \nextended_type_info\nto add and remove entries from this table.\n

\n\n

\nconst char *get_key() const;\n

\n
\nRetrieves the key for extended_type_info\ninstance. If no key has been associated with the instance, then a NULL is returned.\n
\n\n

\nbool operator<(const extended_type_info & rhs) const;\nbool operator==(const extended_type_info & rhs) const;\nbool operator!=(const extended_type_info & rhs) const;\n

\n
\nThese functions are used to compare\n\n\nextended_type_info\n \n\nobjects. They impose a strict total ordering on all\nextended_type_info records.\n
\n\n

\nvirtual void * construct(unsigned int count = 0, ...) const;\n

\n
\nConstruct a new instance of the type to which this\n\n\nextended_type_info\n\n\nrecord corresponds. This function takes a variable list of up to 4 arguments\nof any type. These arguments are passed to the type's constructor\nat runtime. In order to use the facility, \none must declare a type sequence for the constructor arguments. \nArguments for this function must match in number and type\nwith those specified when the type was exported. \nThis function permits one to create instances of\nany exported type given only the exported GUID assigned\nwith BOOST_CLASS_EXPORT. \nIf these types are defined in DLLS or shared libraries loaded at runtime, \nthese constructors can be called until the module is unloaded. \nSuch modules are referred to as plugins. \n\n
\n\n

\nvirtual void destroy(void const * const p) const;\n

\n
\nDestroy an instance created by the above constructor.\n
\n\n

\nstatic const extended_type_info * find(const char *key);\n

\n
\nGiven a character string key or GUID, return the address of a \ncorresponding extended_type_info\nobject. \n\n
\n\n

Requirements for an Implementation

\nIn order to be used by the serialization library, an implementation of\nextended_type_info, \n(referred to as ETI here), must be derived from \n\n\nextended_type_info\n \n\nand also implement the following:\n\n
\n\n

\ntemplate<class ETI>\nconst extended_type_info *\nETI::get_derived_extended_type_info(const T & t) const;\n

\n
\nReturn a pointer to the \nextended_type_info\ninstance that corresponds to\nthe \"true type\" of the type T. The \"true type\" is the lowest type in the\nhierarchy of classes. The type T can always be cast to the \"true type\" with\na static cast. Implementation of this function will vary among type id systems\nand sometimes will make presumptions about the type T than can be identified\nwith a particular extended_type_info implementation.\n
\n\n

\nvirtual bool ETI::is_less_than(const extended_type_info &rhs) const;\n

\n
\nCompare this instance to another one using the same\nextended_type_info implementation.\n
\n\n

\nvirtual bool ETI::is_equal(const extended_type_info &rhs) const;\n

\n
\nCompare this instance to another one using the same\nextended_type_info implementation.\nReturn true if the types referred\nto are the same. Otherwise return \nfalse\n
\n\n

\nconst char ETI::get_key() const;\n

\n
\nRetrieve the external key (aka GUID) for this class.\n
\n\n

\nvirtual void * construct(unsigned int count, ...) const;\n

\n
\nConstruct an instance of the corresponding type\nwith the include argument list.\n
\n\n

\nvirtual void * destroy(void const * const ptr ) const;\n

\n
\nDestroy an instance of this type. This calls the\nproper destructor and recovers allocated memory.\n
\n\n
\n\n

Models

\nThe serialization library includes two distinct\nextended_type_info\nimplementations.\n

\n

\nextended_type_info_typeid

is implemented in terms of the standard typeid(). It presumes that RTTI support is enabled\nby the compiler.\n

\n

\nextended_type_info_no_rtti

\nis implemented in a way that doesn't rely on the existence RTTI.\nInstead, it requires that all polymorphic types be explicitly exported.\nIn addition, if the export facility is to be used to serialize types\nthrough base class pointers, those types are required to implement\na virtual function with the signature:\n\n
\nvirtual const char * get_key();\n
\nwhich returns a unique string the most derived object this class. \nThis function must be virtual in order to implement the functionality required by\nETI::get_derived_extended_type_info\nas described above.\n\n

Example

\nThe test program test_no_rtti\nimplements this function in terms of the \nextended_type_info API above to return the export key associated with the class. \nThis requires that non-abstract types be exported. It also demonstrates the\ninter-operability between two different implementations of\nextended_type_info.\n\n

Requirements for Each Type

\nEach type to be managed by the system must be\n\"registered\" individually. This is accomplished by instantiating\ntemplates. For example, if the type T is to use the type_info system\none would include the following code:\n\n
\nnamespace boost {\nnamespace serialization {\ntemplate\nstruct extended_type_info_typeid<T>;\ntemplate\nstruct extended_type_info_typeid<const T>;\n} // serialization\n} // boost\n
\n\nFor those using the serialization library, this step can be skipped\nas it is done automatically. The serialization library includes\nthe macro:\n\n
\nBOOST_CLASS_TYPE_INFO(\n    my_type, \n    extended_type_info_typeid<my_class>\n)\n
\n\nwhich is used to specify which extended_type_info system is to \nbe used for a given type.\n

\nextended_type_info includes a facility for constructing\ninstances of types without knowing what the exact types are. This is done\nwith the function \n\nvirtual void * extended_type_info::construct(unsigned int count = 0, ...) const;\n\n. For example:\n
\n

\nstruct base {\n...\n};\nstruct derived : public base {\n...\n};\n...\nextended_type_info *eti = extended_type_info::find(\"my_class\")\nbase * b = eti->construct(...);\n
\n
\nThe construct takes an argument count and up to\nfour parameters of any type. The arguments are passed to the\nconstructor of \"my_class\".\n\n\nA complete example of this can be found\nhere\n
\n

© Copyright Robert Ramey 2005-2009. \nDistributed under the Boost Software License, Version 1.0. (See\naccompanying file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)\n

\n\n\n" }, { "path": "doc/faq.html", "content": "\n\n\n\n \n \n \n Serialization - Tips and Tricks\n\n\n \n \n \n \n \n
\n

\n \n \"C++

\n 		\n

\n Serialization

\n

\n Tips and Tricks

\n
\n
\nThis section will be used to list answers to questions raised in the mailing\nlists. Most of these are due to subtle aspects of the library which are\noverlooked even though they might be described in the documentation. Often,\nthese issues are very easy to address - but can be excruciatingly difficult to\nfind. Should you have such an experience, feel free to vent your frustration\nin a constructive way by adding in your own item. The best way to do this\nis to create a \"TRAK\" item \nwhich includes the text you want to add to this list.\n\n
    \n

  • \n

    • \n
\n
\n

\n© Copyright Robert Ramey 2002-2009. Distributed\nunder the Boost Software License, Version 1.0. (See accompanying file LICENSE_1_0.txt\nor copy at http://www.boost.org/LICENSE_1_0.txt)

\n\n\n" }, { "path": "doc/headers.html", "content": "\n\n\n\n\n\n\nSerialization - Code Structure\n\n\n\n \n \n \n \n
\n

\"C++

\n 		\n

Serialization

\n

Code Structure

\n
\n
\n\n
\n
Files Included by User Programs\n
\n
Archive Implementations\n
Serialization Declarations\n
Serialization Implementations\n
\n
Files Which Implement the Library\n
\n
Archive Development\n
Archive Internals\n
Archive Library Code Modules\n
Dataflow Iterators\n
\n
\n\nThis library includes a large number of files. They are organized and classified\naccording to the purposes listed in the above index. \n

\nnamespace of classes and templates is synchronized\nwith the directory in which the file is found. For example, the class declaration\n

\nboost::archive::text_oarchive\n
\nis included with the following declaration\n
\n#include <boost/archive/text_oarchive.hpp>\n
\n\n\n

Files Included by User Programs

\nUsing this library entails including headers listed in this section.\nIt should not be necessary to explicitly include any other header files.\n\n\n

Archive Implementations

\nThese header files contain declarations used to save and restore data to each type\nof archive. Include the archives according to the facilities the code module requires.\n\n
\n\n
\nboost/archive/archive_exception.hpp\n\n
Exceptions which might be invoked by the library.
\n\n
\nboost/archive/binary_iarchive.hpp\n\n
native binary input archive used for loading.
\n\n
\nboost/archive/binary_oarchive.hpp\n\n
native binary output archive used for saving.
\n\n
\nboost/archive/text_iarchive.hpp\n\n
text input archive used for loading.
\n\n
\nboost/archive/text_oarchive.hpp\n\n
text output archive used for saving.
\n\n
\nboost/archive/text_wiarchive.hpp\n\n
wide character text input archive used for loading.
\n\n
\nboost/archive/text_woarchive.hpp\n\n
wide character text input archive used for saving.
\n\n
\nboost/archive/xml_iarchive.hpp\n\n
xml input archive used for loading.
\n\n
\nboost/archive/xml_oarchive.hpp\n\n
xml output archive used for saving.
\n\n
\nboost/archive/xml_wiarchive.hpp\n\n
wide character xml input archive used for loading.
\n\n
\nboost/archive/xml_woarchive.hpp\n\n
wide character xml output archive used for saving.
\n\n
\n\n\n

Serialization Declarations

\nTo specify how a type is serialized, one codes templates for serialization functions.\nIn the simplest cases, this does not require the inclusion of any header files for this purpose.\nIn most cases one or more of the following header files will have to be included in order\nto complete or refine the description of the serializaition implementation for a given class.\n\n
\n\n
\nboost/serialization/base_object.hpp\n\n
For serialization of base classes.
\n\n
\nboost/serialization/nvp.hpp\n\n
To associate a name tag with a serializable object. This is necessary to\nproperly render an xml archive which includes the object name.
\n\n
\nboost/serialization/split_free.hpp\n\n
To divide implementation of non-intrusive serialization into separate\nsave and load functions.
\n\n
\nboost/serialization/split_member.hpp\n\n
To divide implementation of intrusive serialization into separate\nsave and load functions.
\n\n
\nboost/serialization/export.hpp\n\n
For serialization of pointers to derived classes via key export.
\n\n
\nboost/serialization/assume_abstract.hpp\n\n
This is just a thin wrapper which permits one to explicitly specify that a \nparticular type is an abstract base class. It is necessary to use this\nfor compilers which don't support the boost type traits implementation of\nis_abstact.\n
\n\n
\n\nThis group will be required less frequently. The are used to override aspects of\nthe default implementation of the serialization process for specified types.\n\n
\n\n
\nboost/serialization/version.hpp\n\n
To override the default version index (0) assigned to a class.
\n\n
\nboost/serialization/level.hpp\n\n
To override the default implementation level trait for a type.
\n\n
\nboost/serialization/tracking.hpp\n\n
To override the default tracking trait for a type.
\n\n
\nboost/serialization/type_info_implementation.hpp\n\n
By default, the library uses RTTI, to identify types at runtime. In some cases, E.G.\nsuch as a platform which doesn't implement RTTI, this header can be included to permit\nthe override of the default runtime type identification system.
\n\n
\n\n\n

Serialization Implementations

\nThis group of headers includes templates which implement serialization for Standard\nLibrary or Boost Library templates. Any program which uses these templates can\ninvoke serialization of objects of these types just by including the corresponding header.\n

\nBy convention these header files are named:\n\nboost/serialization/xxx.hpp\n\nwhere xxx is the name of the header file which contains the type to be serialized.\nFor example, the declaration\n

\n#include <boost/serialization/list.hpp>\n
\n\nincludes the code to implement serialization of the STL\nstd::list type. While\n\n
\n#include <boost/serialization/shared_ptr.hpp>\n
\n\nincludes code to implement serialization of the BOOST boost::shared_ptr type.\n\nNote that including the serialization header for a type automatically includes the \nappropriate header of the type to be serialized.\n\nAs of this writing, the library includes templates of all STL library templates as well\nas templates for boost::optional, \nboost::shared_ptr, and \nboost::scoped_ptr. \nPresumably, this list will expand with the passage of time.\n\n\n

Files Which Implement the Library

\n\n\n

Archive Development

\nThese header files contain declarations for basic types used to create\nconcrete archive types that are made available to users above. Users wishing\nto make their own type of archive may want to examine these headers to\nsee how the archives included with the libary have been constructed.\n\n
\n\n
\nboost/archive/basic_archive.hpp\n\n
\n
\nThis file includes declarations for certain types that have to be accounted\nfor in all archive implementations. The serialization system relies on \ncertain special types such as class_id_type and others to \nrecord information in archives that is required to reconstruct the original\ndata structure. These are handled exactly as any other serializable type.\nThat is, they can be handled as simple primitives such as they are in simple\ntext files, or with special code as they are in xml archives.\n
\n\n
\nboost/archive/basic_text_oprimitive.hpp\n\n
\nboost/archive/basic_text_iprimitive.hpp\n\n
\n
\nImplementation of serialization of primitive types in terms of character\nor wide character text streams. This is used in the implementation of text and\nxml archives. Presumably this would be useful for implementations of other variations\nof text archives such as user friendly text or windows ini files.\n
\n\n
\nboost/archive/basic_binary_oprimitive.hpp\n\n
\nboost/archive/basic_binary_iprimitive.hpp\n\n
\n
\nImplementation of serialization of primitive types in terms of character\nor wide character binary streams. \n
\n\n
\nboost/archive/basic_binary_oarchive.hpp\n\n
\nboost/archive/basic_binary_iarchive.hpp\n\n
\nImplementation of serialization of all types in terms of character\nor wide character binary streams. This is factored out separately from the\nimplementation of binary primitives above. This may facilitate the creation of\nother types of binary archives in the future. It also preserves analogy and symmetry with\nthe rest of the library which aids in understanding.\n
\n
\nboost/archive/basic_text_oarchive.hpp\n\n
\nboost/archive/basic_text_iarchive.hpp\n\n
\n
\nboost/archive/basic_xml_oarchive.hpp\n\n
\nboost/archive/basic_xml_iarchive.hpp\n\n
\n
\nImplementation of serialization of all types in terms of character\nor wide character text streams. These classes specify archive type specific\nbehavior on a type by type basis. For example, basic_xml_oarchive.hpp\nincludes code to guarantee that any object not attached to a name will \ntrap during compile time. On the other hand, basic_text_oarchive.hpp\ncontains code to strip out and ignore any names attached to objects.\n

\n

\nboost/archive/detail/common_iarchive.hpp\n\n
\nboost/archive/detail/common_oarchive.hpp\n\n
\nAll archive implementations are derived from these header files. They provide\nthe interface to the internal implementation details of the library.\n
\n\n
\n\n\n

Archive Internals

\n \nThe interface (see Archive Concepts) \nand implementation are factored out into separate classes to minimize code duplication.\n\nThese files are found in the directory\nboost/archive/detail. \nThese are included as necessary by the archive class implementations listed above.\nThis has the unfortunate side effect of making the implementation less transparent.\nUsers should never find it necessary to change these files.\n

\nThe following discussion is based on the\nclass diagram.\n

\n

\nboost/archive/detail/interface_iarchive.hpp\n
\nboost/archive/detail/interface_iarchive.hpp\n
\nHere are the declarations and definitions for the \narchive_concept. This class redirects calls to the \narchive interface to a function named save_override in the most derived\narchive class. \n
\nsave_override is declared and implemented in each class in\nthe archive hierarchy.\n\n
\ntemplate<class T>\nvoid save_override(T & t, BOOST_PFTO int){\n    // All for otherwise unhandled types are forwarded to the base class.\n    // This emulates behavior for function overloading.\n    this->base::save_override(t, 0);\n}\nvoid save_override(const some_type & t, int){\n    // any special handling for some type\n    // this will usually entail forwarding some other operation\n    // in the most derived class.\n    this->This()->...\n    // or in one of its parents basic_text_oprimitive\n    this->This()->save(static_cast<int>(t));\n}\n... // other special type handling\n
\n\nNote the usage of\nPartial Function Template Ordering\nto permit the correct save implementation to be selected. \n\n\n\n

Archive Library Code Modules

\nParts of the library are implemented as library code. All of this code is to be found in\nlibs/serialization/src. \nin the form of *.cpp. The directory\nboost/archive/impl\ncontains *.ipp files which implement templates. These templates are instantiated\nonly by archive implementation so are generally not included in user code modules.\n

\nThe trade offs related to library implementation via pre-compiled code and templated\nheaders are well known. This library uses both. It uses templated headers\nto generate code to serialize user and primitive types and it uses pre-compiled\nlibrary code for that part of the code which only depends upon the archive type.\nBuilding of the library generates and compiles code for all archives implemented.\n\n

    \n
  • Serialization of user and primitive types runs at top speed. This is a noticeable\n difference with a previous version of the library which did not use templates for archives.\n
  • Library implementation code that never changes need only be compiled once\n rather than each time a user's program is recompiled. This can save much\n development time.\n
  • Headers which solely related to implementation need only be included\n in the library code modules. This prevents a user program from accidentally \n depending on an implementation feature of the serialization library.\n
  • In building the library I came to the conclusions that there can arise\n situations regarding static code/data instantiation that could not be \n satisfactorily addressed without a code module. Unfortunately, I've forgotten\n the circumstances which led me to this conclusion.\n
\t\nAn example of this is the usage of the spirit library in the library.\nIt takes a long time to compile and includes lots of other files. Having this\nonly in the library is much more convenient that having to include it in every\nprogram which uses xml serialization.\n\n\n

Dataflow Iterators

\nIn the course of developing this library, it became convenient to make a set\nof composable iterator adaptors for handling archive text. Applications include\nescaping and unescaping xml text and implementing to/from base64 conversion among\nothers.\n

\nThis is a ripe topic in itself. It's touched upon by the \nboost iterator libraries, \nView Template Library, and others. \n

\nThe code for these iterators is really independent of this library. But since it\nhasn't been and probably won't be reviewed outside of this context. I've left it in a directory \nlocal to the serialization library:\nboost/archive/iterators.\nThese iterators are described in \nDataflow Iterators.\n

\n

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

\n\n\n" }, { "path": "doc/history.html", "content": "\n\n\n\n\n\n\nSerialization - History\n\n\n\n \n \n \n \n
\n

\"C++

\n 		\n

Serialization

\n

History

\n
\n
\n
    \n
  1. 26 Feb 2002 initial version uploaded to boost\n
  2. 27 Feb 2002\n
      \n
    • divide interface from implementation for class \n serialization to permit compilation on gcc\n
    • improved template instantantation for type templates\n
    \n
  3. 18 Mar 2002 - draft #2 uploaded to boost\n
      \n
    • elminated locale effects on archives\n
    • added signature and library version to archive header\n
    • improved detection of errors when objects are serialized \n as pointers and subsequently serialized as objects\n
    • permit non-portable binary archives\n
    • implement workaround for systems such as MSVC 6.0 that\n don't support partial ordering\n
    \n
  4. 16 May 2002 - draft #3 uploaded to boost\n
      \n
    • Ability to specify serialization of other templates in a\n non-intrusive way.\n
    • Included an example which uses boost::shared_ptr.\n
    • improved documentation\n
    • More test cases\n
    • More testing and documentation of obscure situtations\n
    • Better code organization for transparency\n
    • Wide character support implemented and tested with unicode.\n
    \n
  5. 28 Jun 2002 - #4 library submission\n
      \n
    • minor corrections\n
    • replaced erroneous shared_ptr example with std::auto_ptr example\n
    • prevention of memory leaks when exceptions are invoked\n
    \n
  6. 30 Aug 2002 - #5 library submission\n
      \n
    • minor corrections\n
    • Additions to documentation to explicitly address issues of\n exception safety.\n
    • More test cases/demos to illustrate handling of the above issues.\n
    • Additions to documentation to include rationale for not depending\n on type_id\n
    • Implementation of serialization of boost::shared_ptr.\n This is included as a demo as it depends upon a minor alteration\n of boost::shared_count.\n
    \n
  7. 08 Nov 2002 - #6 library submission\n
      \n
    • minor corrections\n
    • corrected error which manifested itself when serializing\n polymorphic pointers to obects derived from multiple\n base classes\n
    • minor adjustments to support plug-ins via virtual\n save/load/version functions\n
    • test cases to support the above\n
    \n
  8. 08 September 2003- version # 12 library submission\n
      \n
    • attempts to address all issues raised during the November 2002 review\n
    \n
  9. November 2003 - draft #13 uploaded\n
      \n
    • corrections, enhancements, change in api for pointer overload\n
    \n
  10. 28 December 2003\n
      \n
    • implementation of save/loadbinary\n
    • enhancements included archives to permit derivation\n
    \n
  11. 1 March 2004 - draft # 17 upload\n
      \n
    • portability to intel 8.0, and VC 6.0\n
    • Alter archive implementation to permit derivation. Make tests.\n
    • Implement serialize/save/load binary for text and XML archives\n using base64 character encoding.\n
    • Added documentation and test for serialization of large binary objects.\n
    • Added \"Derivation from an Existing Archive Class\" to documentation along\n with example program.\n
    • Added PIMPL example\n
    • certain special situations are now detected and addressed at\n compile time to generate all in-line code. For example, for types\n serialized without class information, and without memory tracking,\n the serialization process can be reduced to a minimal amount of inline\n code.\n
    • All tests have been run in release as well as debug mode\n
    • Many improvements in code and documentation to improve accuracy and completeness.\n
    \n
  12. 11 April 2004 - draft # 18 upload\n
      \n
    • Reorganization of header and template files.\n
    • Enhanced documentation to help explain implementation issues.\n
    • Adjustments to improve support for less conformant compilers.\n
    • A few bug fixes.\n
    \n
  13. 31 May 2004 - draft # 20 upload\n
      \n
    • Polymorphic archives.\n
    • A few bug fixes.\n
    \n
  14. 1 November 2004 - final changes for first boost official release 1.32 .\n
      \n
    • Adjustments to address package compatible with two-phase lookup.\n
    • Many small adjustments to accommodate quirks of various compilers.\n
    • A few bug fixes.\n
    \n
\n
\n

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

\n\n\n" }, { "path": "doc/implementation.html", "content": "\n\n\n\n\n\n\nSerialization - Implementation Notes\n\n\n\n \n \n \n \n
\n

\"C++

\n 		\n

Serialization

\n

Implementation Notes

\n
\n
\n
\n
Character Encoding\n
Specific Compiler/Library Issues\n
\n
44.X\n
Intel 8.0\n
Visual C++ 8.0\n
Visual C++ 7.1\n
Comeau 4.3.3\n
Code Warrior 9.x\n
Code Warrior 8.3\n
TRU64\n
Dinkumware Library\n
STLPort 4.5.3\n
\n
\n\n

Character Encoding

\nThe whole question of character encoding combined with wide characters\nis much more complicated than it would seem to be. The current library\ndefines in 3 formats (text, binary, and XML), wide and narrow characters, \nand attempts to be portable between compiler libraries. The results of \na rather long consideration of all these factors has been to set\ndefault encoding according to the following rules.\n
    \n
  • All text archives (i.e. text_?archive) will produce\n text output in the current stream locale. Generally this will\n produce no changes in string data.\n
  • To produce binary output with Microsoft compilers, the stream\n will have to be opened with mode ios::binary.\n Failure to do so will result in 0x0d characters (carriage-return)\n characters being removed from the input stream if they are followed\n by a 0x0a character (line-feed). This could corrupt the input\n and make the file unreadable. On UNIX systems the ios::binary\n is not required and is ignored if used.\n
  • character XML archives (i.e. xml_oarchive) will produce XML output\n with characters encoded according to the current stream locale.\n
  • wide character XML archives (i.e. xml_woarchive) will produce\n files encoded in UTF-8.\n
\nThis character encoding is implemented by changing the locale of the\ni/o stream used by an archive when the archive is constructed, the stream\nlocale is changed back to its original value. This action can be overridden \nby specifying boost::archive::no_codecvt\nwhen the archive is opened. In this case, the stream locale will\nnot be changed by the serialization library.\n

\nNote that the code conversion included for wide character text and XML\narchives could alter std::string data stored in archives.\nSuppose a normal (multi-byte) character string\nis written to a wide character stream. Our system uses the current locale\nto translate it to a wide character string before writing it out. \nUpon reading, it is translated back to a (multi-byte)string. \nIf the locale on the platform that reads the archive is different than \nthe locale on the platform that wrote the stream, the actual string data\nmay be altered by the serialization process. To avoid this, either\navoid usage of locale dependent multi-byte strings or be sure that\nthe locale is set correctly before reading the archive.\n

\nTo produce wide character text output (i.e. 16 bit characters on Win32 systems),\ndo the following.\n

    \n
  • Open a wide character stream.\n
  • Alter the stream locale to use \n boost::archive::codecvt_null<OStream::char_type>\n
  • Create the archive with the flag no_codecvt.\n
\nNaturally, the input process has to be symmetrical.\n

Specific Compiler/Library Issues

\n

GCC 4.X

\n
    \n
  • GCC versions for Cygwin and MinGW fail to support wide character I/O. \n So all tests using wide char I/O fail. Note that if wide character I/O support\n is added with STLPort, all tests complete successfully.\n
  • This compiler generates long warning messages related to the usage of\n non virtual destructors in polymorphic classes. These warnings have been\n carefully considered and the code that generates these warning has been \n unchanged. In this case the warning should should be ignored as in certain\n usages of the library, making the destructors virtual could lead to problems.\n As an alternative, base class destructors have been made \"protected\" to\n address the concerns that motivate these warning messages. When building\n the serialization library and tests with bjam, these warnings are suppressed. \n When building one's own applications, these warnings can be suppressed by\n adding the following to the compiler command line:\n 
    \n    -Wno-non-virtual-dtor\n    -Wno-ctor-dtor-privacy\n
    \n
\n

Intel C++ 8.0

\nNo known issues. All tests compile and run in debug and release modes.\n\n

Visual C++ 8.0

\nThis compiler emits warnings for calls to functions from the standard\nlibrary which are deemed security risks. The serialization depends upon\nmaking some of these calls so programs which use the serialization library\nwill get warning messages. These messages can be suppressed from the command \nline by including the following switch:\n 
\n    /wd4996\n
\n\n

Visual C++ 7.1

\nDerivation from an archive class defined in a DLL as described in ... will not work.\nThis is due to the way that VC++ handles templated code with __decl(dllexport) and\n__decl(dllimport) specifications. Basically, this compiler requires that all the\ninstantiations have the same specification - even though they have different\ntemplate arguments. The example \ndemo_portable_iarchive.cpp would have to be reformulated as a library or dll\nsimilar to the pre-defined archives in order to function.\n

\nThis compiler does not have RTTI or exception handling turned on by default. Although\nthey are not strictly necessary to use the serialization package, the example and test\nprograms presume that they are enabled. So be sure your command line or IDE settings \nenable these features if you want to build and run these programs.\n

\nThis compiler can treat wchar_t as either\na short integer or an intrinsic type.\nIf /Zc:wchar_t is specified on the\ncompile command line, wchar_t will be \nconsidered an intrinsic type - otherwise\nit will be treated as a synonym for a 16 bit integer. The library can be used\neither way - BUT - both the library AND the application \nmust be compiled with the same switch settings. Note that BJAM\nincludes this switch by default. So if want to use the libraries that\nBJAM builds, you should include this switch\nwhen you compile your own applications.\n

Using the Visual C++ IDE
\nThe library includes a VC++ 7.1 \"Solution\" - BoostSerializationLibrary\nalong with a set of project files - one for each demo and test. Consider the following if you\ndecide to use these configurations.\n
    \n
  • The projects assume that the tests have been built with bjam using the default\n locations. This will result in a bin subdirectory\n within one's main boost directory. Below this there is a whole structure which maintains \n object and library files according to the type of build. The easiest way to build this is to\n invoke the runtest script which uses bjam (see below). If the libraries are not in these locations,\n the projects will have to be modified accordingly.\n
  • There are project configurations for all the combinations of build variants that boost\n supports. That is for release, debug, static, static multi-threading, etc..\n
  • If you want to use/debug the DLL versions of libraries and corresponding tests, alter\n the project file to define BOOST_ALL_DYN_LINK=1.\n Note that for the executables to run, the PATH\n environmental variable will have to include the directories that contain the DLL versions of\n the boost libraries.\n
  • If you have difficulties building your own projects and linking with the boost libraries, \n compare the project settings of your own projects with the ones here. VC sometimes requires\n consistent settings between projects and the libraries they use in order to link properly.\n In particular, check support for exceptions, runtime typing(RTTI), and intrinsic support for\n wide characters. The standard version of this library presumes that these facilities are\n enabled. Projects generated by the IDE wizard do not have these features enabled by default.\n
  • Frequently when trying to build a project or view project properties, one is presented with\n a message box with the message \"unspecified error\". This seems to occur when one changes the\n build configuration selection. It turns out this can be \"fixed\" by going to the \"Build\" \n menu item, selecting \"Configuration Manager\" and selecting a build configuration for the project\n you're working with.\n
  • To test that boost libraries are built correctly, one can build and test them the way we do.\n This entails:\n
      \n
    1. downloading a copy of bjam.exe\n
    2. building process_jam_log\n
    3. building compiler_status\n\t
    4. invoking runtest.bat\n
    \n This will build the serialization library and run the tests on your system. If there are more than a\n a couple of test failures, you likely won't be able to get your own projects working. If most of the\n tests pass, you can be confident that your own projects will work once you get your project settings\n in sync with those included here.\n
\n\n

Comeau 4.3.3

\n
    \n
  • This compiler fails to make a DLL with export under windows.\n
  • The associated library - libcomo fails when using a codecvt facet.\n This generates a failure with all wide character archives.\n
  • the test_set fails by going into an infinite memory leak.\n
\n\n

Code Warrior 9.x

\n
    \n
  • Some tests and demos fail - still under investigation\n
\n\n

Code Warrior 8.3

\nall the above issues for Code Warrior 9.x plus:\n
    \n
  • This compiler only supports templated streams with the static library version.\n
  • The above inhibits the build of DLL versions of the library.\n
  • Some demos fail - still under investigation\n
\n\n

TRU64

\nAll tests and demos pass except for test_variant. Boost Variant doesn't function\nwih this compiler\n\n

Dinkumware Library

\nSeveral compilers, including Visual C++ 6.0, use an older dinkumware library. \nThese platforms have several issues: \n
    \n
  • The dinkumware library shipped with this compiler does not change the locale facet\n of an i/o stream unless the imbue function is called before the\n stream is opened. In order to use this library with this environment to generate UTF-8\n files, one cannot depend on the \"automatic\" setting of locale that archives implement. The\n stream locale must be set explicitly on the stream before an archive is opened on it. The\n archive should be opened with the no_codecvt flag. Note this problem will\n occur on all compilers shipped with this library.\n
  • Other issues have been worked around in the file.\n dinkumware.hpp\n
\n\n

STLPort 4.5.3

\n
    \n
  • when built to use the dynamic linking versions of the C++ runtime code (dynamic)\n all tests fail to link. This is due to a missing symbol in the stlport library related\n to custom codecvt facets.\n
  • the test_set fails to run correctly. It seems the hashed set iterator doesn't\n implement the ++ operator correctly. This causes the test to fail by consuming all available\n memory. Given this, this test is commented out.\n
\n\n
\n

Revised 1 November, 2004 \n

© Copyright Robert Ramey 2002-2015.\nDistributed under the Boost Software License, Version 1.0. (See\naccompanying file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)\n

\n\n\n" }, { "path": "doc/index.html", "content": "\n\n\n\n\nSerialization\n\n\n \n \n <a href=\"overview.html\"</a>\n\n\n" }, { "path": "doc/new_case_studies.html", "content": "\n\n\n\n\n\n\nSerialization - Proposed Case Studies\n\n\n\n \n \n \n \n
\n

\"C++

\n 		\n

Serialization

\n

Proposed Case Studies

\n
\n
\n
\n
Serializing a Function Object
\n
Archive Adaptors
\n
Archive Helpers
\n
\n\nThese are not part of the library itself, but rather\ntechniques on how to use the library to address specific situations.\n\n

Serializing a Function Object

\nAn example on how to serialize a function object. I believe this\ncould be done by serializing a pointer to the object in question. Since\nthe Serialization library resurrects a pointer of the correct type\nthis should be easily implementable.\n

\nIf a group of function objects were all derived from the\nsame polymorphic base class - perhaps via multiple inheritance,\nthen the function object effectively becomes a \"variable\" which\nencapsulates code.\n

\nThis case study would show how to do this.\n\n

Archive Adaptors

\n\nOften users want to add their own special functionality to an\nexisting archive. Examples of this are performance enhancements\nfor specific types, adjustment of output syntax for xml archives,\nand logging/debug output as archives are written and/or read.\nIf this functionality is implemented as an \"adaptor\" template\nwhich takes the base class as a template argument, such functionality could be\nappended to any archive for which that functionality makes sense.\nFor example, an adaptor for generating an xml schema could be\nappended to both wide and narrow character versions of xml archives.\n

\nThis case study would show how to make a useful archive adaptor.\n\n

Archive Helpers

\nSome types are not serializable as they stand. That is - they\ndo not fulfill the requirements of the \"Serializable Concept\".\nThe iconic example of this is boost::shared_ptr. Sometimes\nthese types could be made serializable by adding code inside\nthe library. Of course, doing that would create a lifetime\nof unpaid employment for the library author. Rather than\nadding a bunch of special code to the library itself, this\ncode can packaged as a \"helper\" or \"mix-in\" class. Then\na new archive is derived from both the \"base\" archive class\nAND the \"helper\" class. This is how boost::shared_ptr\nhas been implemented.\n

\nIt would also be possible to make a \"generic runtime helper\"\nwhich would effectively extend the API of the library. Previously\nthe library included such a helper class. It was removed\nin favor of the current implementation. But this functionality\nshould be added back in with another adaptor which would\nbecome part of the library.\n\n

\n

Revised 1 November, 2008 \n

© Copyright Robert Ramey 2002-2008. \nDistributed under the Boost Software License, Version 1.0. (See\naccompanying file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)\n

\n\n\n" }, { "path": "doc/overview.html", "content": "\n\n\n\n\n\n\nSerialization - Overview\n\n\n\n \n \n \n \n
\n

\"C++

\n 		\n

Serialization

\n

Overview

\n
\n
\n
\n
Requirements
\n
Other Implementations
\n
\n

Here, we use the term \"serialization\" to mean\nthe reversible deconstruction of an arbitrary set of C++ data structures\nto a sequence of bytes. Such a system can be used to reconstitute\nan equivalent structure in another program context. Depending on\nthe context, this might used implement object persistence, remote\nparameter passing or other facility. In this system we use the term\n\"archive\" to refer to a specific rendering of this\nstream of bytes. This could be a file of binary data, text data, \nXML, or some other created by the user of this library.\n

Our goals for such a system are:

\n
    \n
  1. Code portability - depend only on ANSI C++ facilities.\n\n
  2. Code economy - exploit features of C++ such as RTTI,\n templates, and multiple inheritance, etc. where appropriate to\n make code shorter and simpler to use.\n\n
  3. Independent versioning for each class definition. That\n is, when a class definition changed, older files can still be\n imported to the new version of the class.\n\n
  4. Deep pointer save and restore. That is, save and restore\n of pointers saves and restores the data pointed to.\n\n
  5. Proper restoration of pointers to shared data.\n\n
  6. Serialization of STL containers and other commonly used\n templates.\n\n
  7. Data Portability - Streams of bytes created on one platform\n should be readable on any other.\n\n
  8. Orthogonal specification of class serialization and archive format.\n That is, any file format should be able to store serialization\n of any arbitrary set of C++ data structures without having to\n alter the serialization of any class.\n\n
  9. Non-intrusive. Permit serialization to be applied to\n unaltered classes. That is, don't require that classes to be\n serialized be derived from a specific base class or implement\n specified member functions. This is necessary to easily\n permit serialization to be applied to classes from class\n libraries that we cannot or don't want to have to alter.\n\n
  10. The archive interface must be simple\n enough to easily permit creation of a new type of archive.\n\n
  11. The archive interface must be rich\n enough to permit the creation of an archive\n that presents serialized data as XML in a useful manner.\n
\n\n

Other implementations

\n Before getting started I searched around for current\n implementations. I found several. \n\n
    \n
  • MFC This is the one that I am very familiar with.\n I have used it for several years and have found it very useful.\n However it fails requirements 1, 2, 3, 6, 7, and 9. In spite\n of all the requirements not fulfilled, this is the most\n useful implementation I've found. It turns out that class\n versioning - partially implemented in MFC - really is\n indispensable for my applications. Inevitably, version 1.x of\n a shipping program needs to store more information in files\n than was originally provided for. MFC is the only one of these\n implementations that supports this - though only for the most\n derived class. Still it's better than nothing and does the\n job. MFC doesn't implement serialization of STL collections.\n Though it does so for MFC collections.\n\n
  • CommonC++ libraries [1]\n As far as I can tell, this\n closely follows the MFC implementation but does address a few\n of the issues. It is portable and creates portable archives but\n skips versioning. It does support proper and complete\n restoration of pointers and STL collections. It does address\n compression though not in the way that I would prefer. The\n package would also benefit from having better documentation.\n So it fails to address 2, 3, 7, 8, and 9.\n\n
  • Eternity [2] \n This is a bare bones package. It\n seems well coded but it really needs documentation and\n examples. It's not obvious how to use it without time\n consuming study of the source code. Recent versions do support\n files in XML format. This Fails 3, 6, 7?, 8, and 9. \n\n
  • Holub's implementation [3] This is the article that\n first got me thinking about my own requirements for\n a serialization implementation. Interesting and worth\n the read if you can overlook the arrogant tone of the prose.\n This implementation fails 2, 3, 4, 5, and 6.\n\n
  • s11n [13]\n This library has similar goals to this one. Some aspects of the\n implemenation are also similar. As of this writing, it would seem that:\n
      \n
    • Portability(1) is guaranteed only for recent versions of GCC.\n
    • Versioning(3) of class definitions is not explicitly supported by\n the library.\n
    • it doesn't seem to automatically account for shared pointers(5).\n I concluded this from the documentation as well as the statement that\n serialization of graph like structures is not supported.\n
    \n Its has lots of differences - and lots in common with this implementation. \n
\n
\n

Revised 1 November, 2004 \n

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

\n\n\n" }, { "path": "doc/performance_status.html", "content": "\n\nBoost Library Status Automatic Test\n\n\n\n\n\n\n
\n

Library Status: serialization

\nRun Date: 02:42:48 UTC, Tuesday 10 June 2008\n
\n
\n\n\n\n\n\n\n\n\n\n\n\n\n\n
Test Namegcc-3.4.4
profile
peformance_array_binary_archivePass Profile
peformance_array_text_archivePass Profile
peformance_array_text_warchiveMissing
peformance_array_xml_archivePass Profile
peformance_array_xml_warchiveMissing
performance_iteratorsPass Profile
performance_iterators_base64Pass Profile
\n\n\n" }, { "path": "doc/pimpl.html", "content": "\n\n\n\n\n\n\nSerialization - PIMPL\n\n\n\n \n \n \n \n
\n

\"C++

\n 		\n

Serialization

\n

PIMPL

\n
\n
\nPIMPL is a C++ programming idiom described by Herb Sutter [10]\nwhich stands for \"Private Implementation\". It is also referred to as\nthe \"Handle Body Idiom\". Included in this library is a program called \ndemo_pimpl.cpp \nwhich illustrates how this is used. The file \ndemo_pimpl_A.hpp\ncontains the declaration of the A class that hides its implementation\nby including a pointer to struct B that is only defined as a pointer.\n
\n// class whose declaration is hidden by a pointer\nstruct B;\n\nstruct A {\n    // class a contains a pointer to a \"hidden\" declaration\n    B *pimpl;\n    template<class Archive>\n    void serialize(Archive & ar, const unsigned int file_version);\n    A();\n};\n
\nSerialization of A requires access to the definition of B. But that doesn't mean\nthat it requires the this access from the header file. Since B is a pointer,\na declaration of class B is sufficient. The implemenation of the serialization\nof A includes the definition of class B defined in the separately compiled module:\n\ndemo_pimpl_A.cpp\nby:\n
\n#include \"demo_pimpl_A.hpp\"\n\n// \"hidden\" definition of class B\nstruct B {\n    int b;\n    template<class Archive>\n    void serialize(Archive & ar, const unsigned int file_version){\n        ar & b;\n    }\n};\n\nA::A() :\n    pimpl(new B)\n{}\n\nA::~A(){\n    delete pimpl;\n}\n\n// now we can define the serialization for class A\ntemplate<class Archive>\nvoid A::serialize(Archive & ar, const unsigned int file_version){\n    ar & pimpl;\n}\n
\nAs described in [10] this brings the\nfollowing advantages:\n
    \n
  • type \"B\" can be used without using its header.\n
  • implementation of B can be changed without generating a \n cascade of recompilations.\n
\nSo, we compile the modules and everything is fine. However when we\nlink, we get an error. Two symbols are undefined:\n
\nvoid A::serialize(boost::archive::text_oarchive & ar, const unsigned int file_version);\nvoid A::serialize(boost::archive::text_iarchive & ar, const unsigned int file_version);\n
\nThe problem is that when compiling the above code, \nthere is no instantiation of the serialize template.\nThere can't be as it's not \"known\" what types of archives\nthe serialization is going to be used with. So these functions are \"missing\"\nwhen an attempt to link is made. The solution is to explicitly instantiate\nserialization code for those archives which are going to be used. In this\nexample, including the the following code in any *.cpp file does just that:\n
\n#include <boost/archive/text_iarchive.hpp>\n#include <boost/archive/text_oarchive.hpp>\n\ntemplate void A::serialize<boost::archive::text_iarchive>(\n    boost::archive::text_iarchive & ar, \n    const unsigned int file_version\n);\ntemplate void A::serialize<boost::archive::text_oarchive>(\n    boost::archive::text_oarchive & ar, \n    const unsigned int file_version\n);\n
\nThe program should now link as well as compile.\n

\nThe downside of this is that one has to know which archives are going \nto be used with hidden serializations. This is an effect of using template\ndriven code. One can invoke explicitly instantiation for all known templates and\npresume that the linker will exclude unreferenced code. This should\nwork but is platform dependent.\n

\n

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

\n\n\n" }, { "path": "doc/private_base.html", "content": "\n\n\n\n\n\n\nSerialization - Private Base Classes\n\n\n\n \n \n \n \n
\n

\"C++

\n 		\n

Serialization

\n

Private Base Classes

\n
\n
\nIn many cases, serialization of private or protected base classes present no special problems.\nThis is true for both simple classes and types as well as pointers to those\nclasses and types. That is, the following program compiles and runs exactly as one would expect.\n
\n/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8\n// test_private_base.cpp\n\n// (C) Copyright 2009 Eric Moyer - http://www.rrsd.com . \n// Use, modification and distribution is subject to the Boost Software\n// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at\n// http://www.boost.org/LICENSE_1_0.txt)\n\n#include <fstream>\n#include <boost/config.hpp>\n#if defined(BOOST_NO_STDC_NAMESPACE)\nnamespace std{ \n    using ::remove;\n}\n#endif\n\n#include <boost/serialization/access.hpp>\n#include <boost/serialization/base_object.hpp>\n#include <boost/serialization/export.hpp>\n\nclass Base {\n    friend class boost::serialization::access;\n    int m_i;\n    template<class Archive>\n    void serialize(Archive & ar, const unsigned int version){\n        ar & BOOST_SERIALIZATION_NVP(m_i);\n    }\nprotected:\n    bool equals(const Base &rhs) const {\n        return m_i == rhs.m_i;\n    }\n    Base(int i = 0) :\n        m_i(i)\n    {}\n};\n\nclass Derived : private Base {\n    friend class boost::serialization::access;\nprivate:\n    Base & base_cast(){\n        return static_cast<Base &>(*this);\n    }\n    template<class Archive>\n    void serialize(Archive & ar, const unsigned int version){\n        ar & BOOST_SERIALIZATION_BASE_OBJECT_NVP(Base);\n    }\npublic:\n    bool operator==(const Derived &rhs) const {\n        return Base::equals(static_cast<const Base &>(rhs));\n    }\n    Derived(int i = 0) :\n        Base(i)\n    {}\n};\n\nint\nmain( int /* argc */, char* /* argv */[] )\n{\n    const char * testfile = boost::archive::tmpnam(NULL);\n\n    // serialize Derived and Base\n    Derived a(1), a1(2);\n    {   \n        test_ostream os(testfile);\n        test_oarchive oa(os);\n        oa << boost::serialization::make_nvp(\"a\", a);\n    }\n    {\n        test_istream is(testfile, TEST_STREAM_FLAGS);\n        test_iarchive ia(is, TEST_ARCHIVE_FLAGS);\n        ia >> boost::serialization::make_nvp(\"a\", a1);\n    }\n    std::remove(testfile);\n\n    if(a != a1)\n        return 1;\n\n    // serialize Derived and Base\n    Derived *ta = &a;\n    Derived *ta1 = NULL;\n    {   \n        test_ostream os(testfile);\n        test_oarchive oa(os);\n        oa << boost::serialization::make_nvp(\"ta\", ta);\n    }\n    {\n        test_istream is(testfile, TEST_STREAM_FLAGS);\n        test_iarchive ia(is, TEST_ARCHIVE_FLAGS);\n        ia >> boost::serialization::make_nvp(\"ta\", ta1);\n    }\n    std::remove(testfile);\n    if(*ta != *ta1)\n        return 1;\n\n    return 0;\n}\n
\nDifficulties start to occur when the base class is made polymorphic by the designation\nof one or more functions as \"virtual\". If a class is polymorphic, the library\npresumes that one will want the ability to serialize a derived class through\na pointer to the base class. Included in the macro\n\nBOOST_SERIALIZATION_BASE_OBJECT_NVP\n\nis code which links derived and base class definitions in tables used to serialize\nderived classes through pointers to a polymorphic base class. This code requires\nthe ability to invoke\n\nstatic_cast<Base &>(Derived &)\n\nwhich C++ will only permit from within the derived class if the base class is \nprivate or protected. The program will fail to compile with an error message \nindicating invalid cast.\n

\nIn order for this\ncode compiler the following alteration must be made:\n

\n    template<class Archive>\n    void serialize(Archive & ar, const unsigned int version){\n        //ar & BOOST_SERIALIZATION_BASE_OBJECT_NVP(Base);\n        ar & boost::serialization::make_nvp(\n            \"Base\",\n            static_cast<Base &>(*this)\n        );\n    }\n
\nWith this change the program will now compile.\n

\nIf we made one of the functions of Base virtual\nin order to use the \"export\" functionality of the serialization library and permit serialization through\na pointer the the base class, we'll be disappointed. Without the ability to\ncast to the base class, we can't use the functionality.\n

\n

© Copyright Robert Ramey 2015.\nDistributed under the Boost Software License, Version 1.0. (See\naccompanying file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)\n

\n\n\n" }, { "path": "doc/profile1.txt", "content": "Flat profile:\n\nEach sample counts as 0.01 seconds.\n no time accumulated\n\n % cumulative self self total \n time seconds seconds calls Ts/call Ts/call name \n 0.00 0.00 0.00 200 0.00 0.00 void accumulate(unsigned int&, unsigned long const&)\n 0.00 0.00 0.00 150 0.00 0.00 _pei386_runtime_relocator\n 0.00 0.00 0.00 1 0.00 0.00 std::ostream::operator<<(void const*)\n 0.00 0.00 0.00 1 0.00 0.00 __divdi3\n\n % the percentage of the total running time of the\ntime program used by this function.\n\ncumulative a running sum of the number of seconds accounted\n seconds for by this function and those listed above it.\n\n self the number of seconds accounted for by this\nseconds function alone. This is the major sort for this\n listing.\n\ncalls the number of times this function was invoked, if\n this function is profiled, else blank.\n \n self the average number of milliseconds spent in this\nms/call function per call, if this function is profiled,\n\t else blank.\n\n total the average number of milliseconds spent in this\nms/call function and its descendents per call, if this \n\t function is profiled, else blank.\n\nname the name of the function. This is the minor sort\n for this listing. The index shows the location of\n\t the function in the gprof listing. If the index is\n\t in parenthesis it shows where it would appear in\n\t the gprof listing if it were to be printed.\n\f\n\t\t Call graph (explanation follows)\n\n\ngranularity: each sample hit covers 4 byte(s) no time propagated\n\nindex % time self children called name\n 0.00 0.00 200/200 setvbuf [1286]\n[4] 0.0 0.00 0.00 200 void accumulate(unsigned int&, unsigned long const&) [4]\n-----------------------------------------------\n 0.00 0.00 150/150 _cygwin_crt0_common@8 [1230]\n[5] 0.0 0.00 0.00 150 _pei386_runtime_relocator [5]\n-----------------------------------------------\n 0.00 0.00 1/1 _lseek64 [1234]\n[6] 0.0 0.00 0.00 1 std::ostream::operator<<(void const*) [6]\n-----------------------------------------------\n 0.00 0.00 1/1 __tcf_1 [1221]\n[7] 0.0 0.00 0.00 1 __divdi3 [7]\n-----------------------------------------------\n 2 main [1263]\n[1263] 0.0 0.00 0.00 0+2 main [1263]\n 2 main [1263]\n-----------------------------------------------\n\n This table describes the call tree of the program, and was sorted by\n the total amount of time spent in each function and its children.\n\n Each entry in this table consists of several lines. The line with the\n index number at the left hand margin lists the current function.\n The lines above it list the functions that called this function,\n and the lines below it list the functions this one called.\n This line lists:\n index\tA unique number given to each element of the table.\n\t\tIndex numbers are sorted numerically.\n\t\tThe index number is printed next to every function name so\n\t\tit is easier to look up where the function in the table.\n\n % time\tThis is the percentage of the `total' time that was spent\n\t\tin this function and its children. Note that due to\n\t\tdifferent viewpoints, functions excluded by options, etc,\n\t\tthese numbers will NOT add up to 100%.\n\n self\tThis is the total amount of time spent in this function.\n\n children\tThis is the total amount of time propagated into this\n\t\tfunction by its children.\n\n called\tThis is the number of times the function was called.\n\t\tIf the function called itself recursively, the number\n\t\tonly includes non-recursive calls, and is followed by\n\t\ta `+' and the number of recursive calls.\n\n name\tThe name of the current function. The index number is\n\t\tprinted after it. If the function is a member of a\n\t\tcycle, the cycle number is printed between the\n\t\tfunction's name and the index number.\n\n\n For the function's parents, the fields have the following meanings:\n\n self\tThis is the amount of time that was propagated directly\n\t\tfrom the function into this parent.\n\n children\tThis is the amount of time that was propagated from\n\t\tthe function's children into this parent.\n\n called\tThis is the number of times this parent called the\n\t\tfunction `/' the total number of times the function\n\t\twas called. Recursive calls to the function are not\n\t\tincluded in the number after the `/'.\n\n name\tThis is the name of the parent. The parent's index\n\t\tnumber is printed after it. If the parent is a\n\t\tmember of a cycle, the cycle number is printed between\n\t\tthe name and the index number.\n\n If the parents of the function cannot be determined, the word\n `' is printed in the `name' field, and all the other\n fields are blank.\n\n For the function's children, the fields have the following meanings:\n\n self\tThis is the amount of time that was propagated directly\n\t\tfrom the child into the function.\n\n children\tThis is the amount of time that was propagated from the\n\t\tchild's children to the function.\n\n called\tThis is the number of times the function called\n\t\tthis child `/' the total number of times the child\n\t\twas called. Recursive calls by the child are not\n\t\tlisted in the number after the `/'.\n\n name\tThis is the name of the child. The child's index\n\t\tnumber is printed after it. If the child is a\n\t\tmember of a cycle, the cycle number is printed\n\t\tbetween the name and the index number.\n\n If there are any cycles (circles) in the call graph, there is an\n entry for the cycle-as-a-whole. This entry shows who called the\n cycle (as parents) and the members of the cycle (as children.)\n The `+' recursive calls entry shows the number of function calls that\n were internal to the cycle, and the calls entry for each member shows,\n for that member, how many times it was called from other members of\n the cycle.\n\n\f\nIndex by function name\n\n [4] void accumulate(unsigned int&, unsigned long const&) [7] __divdi3\n [6] std::ostream::operator<<(void const*) [5] _pei386_runtime_relocator\n" }, { "path": "doc/profile2.txt", "content": "Flat profile:\n\nEach sample counts as 0.01 seconds.\n % cumulative self self total \n time seconds seconds calls Ts/call Ts/call name \n100.00 0.01 0.01 __gnu_cxx::__atomic_add(int volatile*, int)\n 0.00 0.01 0.00 51 0.00 0.00 boost::archive::iterators::transform_width::fill()\n 0.00 0.01 0.00 36 0.00 0.00 boost::archive::iterators::transform_width<__gnu_cxx::__normal_iterator > >, 8, 6, char>::fill()\n 0.00 0.01 0.00 30 0.00 0.00 std::vector >::_M_insert_aux(__gnu_cxx::__normal_iterator > >, char const&)\n 0.00 0.01 0.00 11 0.00 0.00 boost::archive::iterators::xml_escape::fill(char const*&, char const*&)\n 0.00 0.01 0.00 9 0.00 0.00 void test_transform_width<6, 8>(unsigned int)\n 0.00 0.01 0.00 9 0.00 0.00 boost::archive::iterators::xml_unescape::drain()\n 0.00 0.01 0.00 5 0.00 0.00 boost::archive::iterators::xml_unescape::drain_residue(char const*)\n 0.00 0.01 0.00 2 0.00 0.00 __static_initialization_and_destruction_0(int, int)\n 0.00 0.01 0.00 1 0.00 0.00 void test_xml_escape(char const*, char const*, unsigned int)\n 0.00 0.01 0.00 1 0.00 0.00 void test_xml_unescape(char const*, char const*, unsigned int)\n 0.00 0.01 0.00 1 0.00 0.00 void test_stream_iterators(char const*, unsigned int)\n 0.00 0.01 0.00 1 0.00 0.00 test_main(int, char**)\n 0.00 0.01 0.00 1 0.00 0.00 char* std::string::_S_construct(char*, char*, std::allocator const&, std::forward_iterator_tag)\n 0.00 0.01 0.00 1 0.00 0.00 std::basic_string, std::allocator >::basic_string(char*, char*, std::allocator const&)\n\n % the percentage of the total running time of the\ntime program used by this function.\n\ncumulative a running sum of the number of seconds accounted\n seconds for by this function and those listed above it.\n\n self the number of seconds accounted for by this\nseconds function alone. This is the major sort for this\n listing.\n\ncalls the number of times this function was invoked, if\n this function is profiled, else blank.\n \n self the average number of milliseconds spent in this\nms/call function per call, if this function is profiled,\n\t else blank.\n\n total the average number of milliseconds spent in this\nms/call function and its descendents per call, if this \n\t function is profiled, else blank.\n\nname the name of the function. This is the minor sort\n for this listing. The index shows the location of\n\t the function in the gprof listing. If the index is\n\t in parenthesis it shows where it would appear in\n\t the gprof listing if it were to be printed.\n\f\n\t\t Call graph (explanation follows)\n\n\ngranularity: each sample hit covers 4 byte(s) for 100.00% of 0.01 seconds\n\nindex % time self children called name\n \n[1] 100.0 0.01 0.00 __gnu_cxx::__atomic_add(int volatile*, int) [1]\n-----------------------------------------------\n 0.00 0.00 51/51 void test_transform_width<6, 8>(unsigned int) [9]\n[5] 0.0 0.00 0.00 51 boost::archive::iterators::transform_width::fill() [5]\n-----------------------------------------------\n 0.00 0.00 36/36 void test_transform_width<6, 8>(unsigned int) [9]\n[6] 0.0 0.00 0.00 36 boost::archive::iterators::transform_width<__gnu_cxx::__normal_iterator > >, 8, 6, char>::fill() [6]\n-----------------------------------------------\n 0.00 0.00 30/30 void test_transform_width<6, 8>(unsigned int) [9]\n[7] 0.0 0.00 0.00 30 std::vector >::_M_insert_aux(__gnu_cxx::__normal_iterator > >, char const&) [7]\n-----------------------------------------------\n 0.00 0.00 11/11 void test_xml_escape(char const*, char const*, unsigned int) [13]\n[8] 0.0 0.00 0.00 11 boost::archive::iterators::xml_escape::fill(char const*&, char const*&) [8]\n-----------------------------------------------\n 0.00 0.00 9/9 test_main(int, char**) [16]\n[9] 0.0 0.00 0.00 9 void test_transform_width<6, 8>(unsigned int) [9]\n 0.00 0.00 51/51 boost::archive::iterators::transform_width::fill() [5]\n 0.00 0.00 36/36 boost::archive::iterators::transform_width<__gnu_cxx::__normal_iterator > >, 8, 6, char>::fill() [6]\n 0.00 0.00 30/30 std::vector >::_M_insert_aux(__gnu_cxx::__normal_iterator > >, char const&) [7]\n-----------------------------------------------\n 0.00 0.00 9/9 void test_xml_unescape(char const*, char const*, unsigned int) [14]\n[10] 0.0 0.00 0.00 9 boost::archive::iterators::xml_unescape::drain() [10]\n 0.00 0.00 5/5 boost::archive::iterators::xml_unescape::drain_residue(char const*) [11]\n-----------------------------------------------\n 0.00 0.00 5/5 boost::archive::iterators::xml_unescape::drain() [10]\n[11] 0.0 0.00 0.00 5 boost::archive::iterators::xml_unescape::drain_residue(char const*) [11]\n-----------------------------------------------\n 0.00 0.00 1/2 global constructors keyed to main [38]\n 0.00 0.00 1/2 global destructors keyed to main [35]\n[12] 0.0 0.00 0.00 2 __static_initialization_and_destruction_0(int, int) [12]\n-----------------------------------------------\n 0.00 0.00 1/1 test_main(int, char**) [16]\n[13] 0.0 0.00 0.00 1 void test_xml_escape(char const*, char const*, unsigned int) [13]\n 0.00 0.00 11/11 boost::archive::iterators::xml_escape::fill(char const*&, char const*&) [8]\n-----------------------------------------------\n 0.00 0.00 1/1 test_main(int, char**) [16]\n[14] 0.0 0.00 0.00 1 void test_xml_unescape(char const*, char const*, unsigned int) [14]\n 0.00 0.00 9/9 boost::archive::iterators::xml_unescape::drain() [10]\n-----------------------------------------------\n 0.00 0.00 1/1 test_main(int, char**) [16]\n[15] 0.0 0.00 0.00 1 void test_stream_iterators(char const*, unsigned int) [15]\n 0.00 0.00 1/1 std::basic_string, std::allocator >::basic_string(char*, char*, std::allocator const&) [18]\n-----------------------------------------------\n 0.00 0.00 1/1 main [1211]\n[16] 0.0 0.00 0.00 1 test_main(int, char**) [16]\n 0.00 0.00 9/9 void test_transform_width<6, 8>(unsigned int) [9]\n 0.00 0.00 1/1 void test_xml_escape(char const*, char const*, unsigned int) [13]\n 0.00 0.00 1/1 void test_xml_unescape(char const*, char const*, unsigned int) [14]\n 0.00 0.00 1/1 void test_stream_iterators(char const*, unsigned int) [15]\n-----------------------------------------------\n 0.00 0.00 1/1 std::basic_string, std::allocator >::basic_string(char*, char*, std::allocator const&) [18]\n[17] 0.0 0.00 0.00 1 char* std::string::_S_construct(char*, char*, std::allocator const&, std::forward_iterator_tag) [17]\n-----------------------------------------------\n 0.00 0.00 1/1 void test_stream_iterators(char const*, unsigned int) [15]\n[18] 0.0 0.00 0.00 1 std::basic_string, std::allocator >::basic_string(char*, char*, std::allocator const&) [18]\n 0.00 0.00 1/1 char* std::string::_S_construct(char*, char*, std::allocator const&, std::forward_iterator_tag) [17]\n-----------------------------------------------\n\n This table describes the call tree of the program, and was sorted by\n the total amount of time spent in each function and its children.\n\n Each entry in this table consists of several lines. The line with the\n index number at the left hand margin lists the current function.\n The lines above it list the functions that called this function,\n and the lines below it list the functions this one called.\n This line lists:\n index\tA unique number given to each element of the table.\n\t\tIndex numbers are sorted numerically.\n\t\tThe index number is printed next to every function name so\n\t\tit is easier to look up where the function in the table.\n\n % time\tThis is the percentage of the `total' time that was spent\n\t\tin this function and its children. Note that due to\n\t\tdifferent viewpoints, functions excluded by options, etc,\n\t\tthese numbers will NOT add up to 100%.\n\n self\tThis is the total amount of time spent in this function.\n\n children\tThis is the total amount of time propagated into this\n\t\tfunction by its children.\n\n called\tThis is the number of times the function was called.\n\t\tIf the function called itself recursively, the number\n\t\tonly includes non-recursive calls, and is followed by\n\t\ta `+' and the number of recursive calls.\n\n name\tThe name of the current function. The index number is\n\t\tprinted after it. If the function is a member of a\n\t\tcycle, the cycle number is printed between the\n\t\tfunction's name and the index number.\n\n\n For the function's parents, the fields have the following meanings:\n\n self\tThis is the amount of time that was propagated directly\n\t\tfrom the function into this parent.\n\n children\tThis is the amount of time that was propagated from\n\t\tthe function's children into this parent.\n\n called\tThis is the number of times this parent called the\n\t\tfunction `/' the total number of times the function\n\t\twas called. Recursive calls to the function are not\n\t\tincluded in the number after the `/'.\n\n name\tThis is the name of the parent. The parent's index\n\t\tnumber is printed after it. If the parent is a\n\t\tmember of a cycle, the cycle number is printed between\n\t\tthe name and the index number.\n\n If the parents of the function cannot be determined, the word\n `' is printed in the `name' field, and all the other\n fields are blank.\n\n For the function's children, the fields have the following meanings:\n\n self\tThis is the amount of time that was propagated directly\n\t\tfrom the child into the function.\n\n children\tThis is the amount of time that was propagated from the\n\t\tchild's children to the function.\n\n called\tThis is the number of times the function called\n\t\tthis child `/' the total number of times the child\n\t\twas called. Recursive calls by the child are not\n\t\tlisted in the number after the `/'.\n\n name\tThis is the name of the child. The child's index\n\t\tnumber is printed after it. If the child is a\n\t\tmember of a cycle, the cycle number is printed\n\t\tbetween the name and the index number.\n\n If there are any cycles (circles) in the call graph, there is an\n entry for the cycle-as-a-whole. This entry shows who called the\n cycle (as parents) and the members of the cycle (as children.)\n The `+' recursive calls entry shows the number of function calls that\n were internal to the cycle, and the calls entry for each member shows,\n for that member, how many times it was called from other members of\n the cycle.\n\n\f\nIndex by function name\n\n [13] void test_xml_escape(char const*, char const*, unsigned int) [16] test_main(int, char**) [5] boost::archive::iterators::transform_width::fill()\n [14] void test_xml_unescape(char const*, char const*, unsigned int) [8] boost::archive::iterators::xml_escape::fill(char const*&, char const*&) [1] __gnu_cxx::__atomic_add(int volatile*, int)\n [9] void test_transform_width<6, 8>(unsigned int) [11] boost::archive::iterators::xml_unescape::drain_residue(char const*) [17] char* std::string::_S_construct(char*, char*, std::allocator const&, std::forward_iterator_tag)\n [15] void test_stream_iterators(char const*, unsigned int) [10] boost::archive::iterators::xml_unescape::drain() [18] std::basic_string, std::allocator >::basic_string(char*, char*, std::allocator const&)\n [12] __static_initialization_and_destruction_0(int, int) (performance_iterators.cpp) [6] boost::archive::iterators::transform_width<__gnu_cxx::__normal_iterator > >, 8, 6, char>::fill() [7] std::vector >::_M_insert_aux(__gnu_cxx::__normal_iterator > >, char const&)\n" }, { "path": "doc/profile3.txt", "content": "Flat profile:\n\nEach sample counts as 0.01 seconds.\n no time accumulated\n\n % cumulative self self total \n time seconds seconds calls Ts/call Ts/call name \n 0.00 0.00 0.00 200 0.00 0.00 boost::archive::iterators::transform_width::fill()\n 0.00 0.00 0.00 150 0.00 0.00 boost::archive::iterators::transform_width >, char>, 8, 6, char>::fill()\n 0.00 0.00 0.00 2 0.00 0.00 __static_initialization_and_destruction_0(int, int)\n 0.00 0.00 0.00 1 0.00 0.00 void test_base64()\n 0.00 0.00 0.00 1 0.00 0.00 std::_List_base >::_M_clear()\n\n % the percentage of the total running time of the\ntime program used by this function.\n\ncumulative a running sum of the number of seconds accounted\n seconds for by this function and those listed above it.\n\n self the number of seconds accounted for by this\nseconds function alone. This is the major sort for this\n listing.\n\ncalls the number of times this function was invoked, if\n this function is profiled, else blank.\n \n self the average number of milliseconds spent in this\nms/call function per call, if this function is profiled,\n\t else blank.\n\n total the average number of milliseconds spent in this\nms/call function and its descendents per call, if this \n\t function is profiled, else blank.\n\nname the name of the function. This is the minor sort\n for this listing. The index shows the location of\n\t the function in the gprof listing. If the index is\n\t in parenthesis it shows where it would appear in\n\t the gprof listing if it were to be printed.\n\f\n\t\t Call graph (explanation follows)\n\n\ngranularity: each sample hit covers 4 byte(s) no time propagated\n\nindex % time self children called name\n 0.00 0.00 200/200 void test_base64() [7]\n[4] 0.0 0.00 0.00 200 boost::archive::iterators::transform_width::fill() [4]\n-----------------------------------------------\n 0.00 0.00 150/150 void test_base64() [7]\n[5] 0.0 0.00 0.00 150 boost::archive::iterators::transform_width >, char>, 8, 6, char>::fill() [5]\n-----------------------------------------------\n 0.00 0.00 1/2 global constructors keyed to main [27]\n 0.00 0.00 1/2 global destructors keyed to main [24]\n[6] 0.0 0.00 0.00 2 __static_initialization_and_destruction_0(int, int) [6]\n-----------------------------------------------\n 0.00 0.00 1/1 main [1156]\n[7] 0.0 0.00 0.00 1 void test_base64() [7]\n 0.00 0.00 200/200 boost::archive::iterators::transform_width::fill() [4]\n 0.00 0.00 150/150 boost::archive::iterators::transform_width >, char>, 8, 6, char>::fill() [5]\n 0.00 0.00 1/1 std::_List_base >::_M_clear() [8]\n-----------------------------------------------\n 0.00 0.00 1/1 void test_base64() [7]\n[8] 0.0 0.00 0.00 1 std::_List_base >::_M_clear() [8]\n-----------------------------------------------\n\n This table describes the call tree of the program, and was sorted by\n the total amount of time spent in each function and its children.\n\n Each entry in this table consists of several lines. The line with the\n index number at the left hand margin lists the current function.\n The lines above it list the functions that called this function,\n and the lines below it list the functions this one called.\n This line lists:\n index\tA unique number given to each element of the table.\n\t\tIndex numbers are sorted numerically.\n\t\tThe index number is printed next to every function name so\n\t\tit is easier to look up where the function in the table.\n\n % time\tThis is the percentage of the `total' time that was spent\n\t\tin this function and its children. Note that due to\n\t\tdifferent viewpoints, functions excluded by options, etc,\n\t\tthese numbers will NOT add up to 100%.\n\n self\tThis is the total amount of time spent in this function.\n\n children\tThis is the total amount of time propagated into this\n\t\tfunction by its children.\n\n called\tThis is the number of times the function was called.\n\t\tIf the function called itself recursively, the number\n\t\tonly includes non-recursive calls, and is followed by\n\t\ta `+' and the number of recursive calls.\n\n name\tThe name of the current function. The index number is\n\t\tprinted after it. If the function is a member of a\n\t\tcycle, the cycle number is printed between the\n\t\tfunction's name and the index number.\n\n\n For the function's parents, the fields have the following meanings:\n\n self\tThis is the amount of time that was propagated directly\n\t\tfrom the function into this parent.\n\n children\tThis is the amount of time that was propagated from\n\t\tthe function's children into this parent.\n\n called\tThis is the number of times this parent called the\n\t\tfunction `/' the total number of times the function\n\t\twas called. Recursive calls to the function are not\n\t\tincluded in the number after the `/'.\n\n name\tThis is the name of the parent. The parent's index\n\t\tnumber is printed after it. If the parent is a\n\t\tmember of a cycle, the cycle number is printed between\n\t\tthe name and the index number.\n\n If the parents of the function cannot be determined, the word\n `' is printed in the `name' field, and all the other\n fields are blank.\n\n For the function's children, the fields have the following meanings:\n\n self\tThis is the amount of time that was propagated directly\n\t\tfrom the child into the function.\n\n children\tThis is the amount of time that was propagated from the\n\t\tchild's children to the function.\n\n called\tThis is the number of times the function called\n\t\tthis child `/' the total number of times the child\n\t\twas called. Recursive calls by the child are not\n\t\tlisted in the number after the `/'.\n\n name\tThis is the name of the child. The child's index\n\t\tnumber is printed after it. If the child is a\n\t\tmember of a cycle, the cycle number is printed\n\t\tbetween the name and the index number.\n\n If there are any cycles (circles) in the call graph, there is an\n entry for the cycle-as-a-whole. This entry shows who called the\n cycle (as parents) and the members of the cycle (as children.)\n The `+' recursive calls entry shows the number of function calls that\n were internal to the cycle, and the calls entry for each member shows,\n for that member, how many times it was called from other members of\n the cycle.\n\n\f\nIndex by function name\n\n [7] void test_base64() [5] boost::archive::iterators::transform_width >, char>, 8, 6, char>::fill() [8] std::_List_base >::_M_clear()\n [6] __static_initialization_and_destruction_0(int, int) (performance_iterators_base64.cpp) [4] boost::archive::iterators::transform_width::fill()\n" }, { "path": "doc/rationale.html", "content": "\n\n\n\n\n\n\nSerialization - Rationale\n\n\n\n \n \n \n \n
\n

\"C++

\n 		\n

Serialization

\n

Rationale

\n
\n
\n
\n
The term \"serialization\" is preferred to \"persistence\"
\n
Archives are not streams
\n
Strings are treated specially in text archives
\n
typeid information is not included in archives
\n \n
\n

The term \"serialization\" is preferred to \"persistence\"

\n

\nI found that persistence is often used to refer\nto something quite different. Examples are storage of class\ninstances (objects) in database schema [4]\nThis library will be useful in other contexts besides implementing persistence. The\nmost obvious case is that of marshalling data for transmission to another system.\n

Archives are not streams

\n

\nArchive classes are NOT derived from\nstreams even though they have similar syntax rules.\n

    \n
  • Archive classes are not kinds of streams though they\n are implemented in terms of streams. This\n distinction is addressed in [5] item number 41.\n
  • We don't want users to insert/extract data\n directly into/from  the stream .  This could\n create a corrupted archive. Were archives\n derived from streams, it would possible to\n accidentally do this. So archive classes\n only define operations which are safe and necessary.\n
  • The usage of streams to implement the archive classes that\n are included in the library is merely convenient - not necessary.\n Library users may well want to define their own archive format\n which doesn't use streams at all.\n
\n

Archive Members are Templates \nRather than Virtual Functions

\nThe previous version of this library defined virtual functions for all\nprimitive types. These were overridden by each archive class. There were\ntwo issues related to this:\n\n
  • Some disliked virtual functions because of the added execution time\n overhead.\n
  • This caused implementation difficulties since the set of primitive\n data types varies between platforms. Attempting to define the correct\n set of virtual functions, (think long long, \n __int64, \n etc.) resulted in messy and fragile code. Replacing this with templates\n and letting the compiler generate the code for the primitive types actually\n used, resolved this problem. Of course, the ripple effects of this design\n change were significant, but in the end led to smaller, faster, more\n maintainable code.\n\n

    std::strings are treated specially in text files

    \n

    \nTreating strings as STL vectors would result in minimal code size. This was\nnot done because:\n

      \n
    • In text archives it is convenient to be able to view strings. Our text\n implementation stores single characters as integers. Storing strings\n as a vector of characters would waste space and render the archives\n inconvenient for debugging.\n
    • Stream implementations have special functions for std::string\n and std::wstring.\n Presumably they optimize appropriately.\n
    • Other specializations of std::basic_string are in fact handled\n as vectors of the element type.\n
    \n

    \n

    typeid information is not included in archives

    \n

    \nI originally thought that I had to save the name of the class specified by std::type_of::name()\nin the archive. This created difficulties as std::type_of::name() is not portable and\nnot guaranteed to return the class name. This makes it almost useless for implementing\narchive portability. This topic is explained in much more detail in\n[7] page 206. It turned out that it was not necessary.\nAs long as objects are loaded in the exact sequence as they were saved, the type\nis available when loading. The only exception to this is the case of polymorphic\npointers never before loaded/saved. This is addressed with the register_type()\nand/or export facilities described in the reference. \nIn effect, export generates a portable equivalent to\ntypeid information.\n\n\n

    \n

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

    \n\n\n" }, { "path": "doc/reference.html", "content": "\n\n\n\n\n\n\nSerialization - Serialization of Classes\n\n\n\n \n \n \n \n
    \n

    \"C++

    \n     		\n

    Serialization

    \n

    Serializable Concept

    \n
    \n
    \n
    \n
    Archive Concepts\n
    Serializable Concept\n
    Special Considerations\n
    Archive Class Reference\n
    Implementation Notes\n
    \n\n
    \n

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

    \n\n" }, { "path": "doc/release.html", "content": "\n\n\n\n\n\n \n Serialization - Release Notes\n\n\n\n \n \n \n \n
    \n

    \n \"C++

    \n     		\n

    \n Serialization

    \n

    \n Release Notes

    \n
    \n
    \n
    \n
    Differences from version 1.58
    \n
    Differences from version 1.48
    \n
    Differences from version 1.45
    \n
    Differences from version 1.43
    \n
    Differences from version 1.42
    \n
    Differences from version 1.41
    \n
    Differences from version 1.40
    \n
    Differences from version 1.39
    \n
    Differences from version 1.37
    \n
    Differences from version 1.35
    \n
    Differences from version 1.34
    \n
    Differences from version 1.33
    \n
    Differences from version 1.32
    \n
    Pending Issues
    \n
    \nAs of this writing, there are no known bugs. However, due to compiler/library \nquirks and or bugs, some tests fail with some combinations of compilers and \nlibraries.\n

    Differences from Boost 1.58

    \n
      \n
    • Eliminated support for Borland compilers and Microsoft compilers prior to version\n7.1.\n
    • Eliminated support for compilers which do not support Partial Function Template\nOrdering (pfto).\n
    • Added support for \"visibility hidden\" for GCC compilers. Shared libraries\nwill only expose symbols actually needed rather than all sympols in the library. This\nshould result in smaller shared libraries which are faster to load.\n
    \n

    Differences from Boost 1.48

    \n
      \n
    • Added support for C++11 types such as std::shared_ptr, std::array, and others.\n
    • Implemented the concept of a \"Helper\" which can be used to implement serialization of types which are otherwise not serializable.\"\n
    • Made library compatible with C++11, Compatibility with C++03 has been maintained.\n
    \n

    Differences from Boost 1.45

    \nSince the release of version 1.42, it has been discovered that binary\narchives created by versions 1.42-1.44 cannot always be read by the\nrecent binary archive code. Work has proceeded in detecting the source\nof these anomolies and those which have been reported with test cases\nhave been fixed. As of this writing, it is not known whether all\nbinary archives created with these versions can be loaded.\n

    Differences from Boost 1.43

    \n
      \n
    • fixed bug in the serialization of virtual base classes. Due\n to heroic efforts by Takatoshi Kondo.\n
    • Native binary archives created under versions 1.42 and 1.43\n suffer from a serious problem. It's likely they won't be readable\n by this latest version. This due to the fact that 1.42 made some\n changes in the binary format of some types. Normally this could\n be addressed by detecting the library version number written into\n the archive header. Unfortunately, this library version number\n was not incremented at 1.42 as it should have been. So now we have\n two different binary archive versions with the same library version\n number.\n

      \n This has been addressed by including a small utility in the example\n directory named fix_six.cpp. This should be run with the command line
      \n 

      \n    fix_six <file name>\n
      \n This will assign 7 to the library version number of the archive. This\n fix will need to ba applied to native binary archives created with\n boost versions 1.42 and 1.43.\n
    \n

    Differences from Boost 1.42

    \n
      \n
    • fixed failure of shared_ptr serialization when serializing pointers\ncreated from enable_shared_from_this.\n
    • added example for a simple archive which can be used as a debug log.\nThis example illustrates the implemenation of the archive concept to aid\nunderstanding required to create one's own archive classes. The resulting\narchive is useful for debugging in that it only 160 lines of code and is\nheader only - that is, it doesn't required linking to the serialization library.\n
    • replaced example used to show how to derive from an existing archive.\nThis example creates an XML archive class which doesn't include serialization\ntraits such as class_id, class_version, etc. It might be useful for exporting\none's class information to osme XML processor and/or debugging programs.\n
    • compile time warnings have been implemented to detect practices which\n though correct, will result in operation or side effects different than\n a user probably intends.\n
    • Some memory leaks associated with void_cast have been fixed.\n
    \n

    Differences from Boost 1.41

    \n
      \n
    • adjustments have been made to minimize compile time warnings.\n
    • compile time warnings have been implemented to detect practices which\n though correct, will result in operation or side effects different than\n a user probably intends.\n
    • Some memory leaks associated with void_cast have been fixed.\n
    \n

    Differences from Boost 1.40

    \nThis library has been tested against Boost version 1.39 and 1.40.\n

    \n Changes have been made to archive classes included with the library. Users who \n have used these a guide to making their own archive classes will find that \n these will likely no longer compile. This can be remedied by making the \n following changes in the code which instantiates these archive classes.\n

    \nOld Code:
    \n
    \n...\n#include <boost/archive/impl/archive_pointer_iserializer.ipp>\n...\ntemplate class detail::archive_pointer_iserializer<naked_text_iarchive> ;\n...\ntemplate class detail::archive_pointer_iserializer<text_iarchive> ;\n
    should be replaced with this new code: 
    \n#include <boost/archive/impl/archive_serializer_map.ipp>\n...\ntemplate class detail::archive_serializer_map<naked_text_iarchive> ;\n...\ntemplate class detail::archive_serializer_map<text_iarchive> ;\n
    \n\n

    Differences from Boost 1.39

    \n
      \n
    • \n It is now possible to serialize an object through a pointer to a class which \n implements its own new/delete\n operators. This functionaly is not available on some compilers.\n
    • \n serialization of polymorphic objects has been sped up considerably.\n
    \nAs of this writing, all bug reports filed as TRAK tickets have been addressed. \nThere are some TRAK tickets pending which would best be described as feature \nrequests. See Pending Issues.\n

    Differences from Boost 1.37

    \nThere are no new features in this version. As of this writing, all bug reports \nfiled as TRAK tickets have been addressed. There are some TRAK tickets pending \nwhich would best be described as feature requests. See Pending \n Issues.\n

    Differences from Boost 1.36

    \nThere are no new features in this version. As of this writing, all bug reports \nfiled as TRAK tickets have been addressed.\n

    Differences from Boost 1.35

    \n
      \n
    • \n The library is now thread safe. That is, multiple archives can be open in \n different threads. This has been implmented with a lock-free algorithm to avoid \n any performance bottlenecks.\n
    • \n Serialization of types defined in shared libraries is now supported. shared \n libraries (DLLS) can be loaded/unloaded dynamically at runtime. This includes \n the serialization of instances of abstract base classes so that a program can \n be written so as to be compatible with as yet undefined and un-implemented \n code.\n
    • \n The extended type info system has been enhanced to in order to implement the \n above. It is now a general purpose system for creating and casting of types \n about which is only known a string ID and an abstract base class.\n
    • \n All bug reports filed as TRAK tickets have been addressed.\n
    • \n As of this writing, the library will fail build on older compilers such as MSVC \n before version 7.1 and older versions of Borland compilers. This might or might \n not change in the future.\n
    \n

    Differences from Boost 1.34

    \n
      \n
    • \n Enhanced support for fast serialization for native binary archives. By Mattias \n Troyer.\n
    • \n Improved implementation of \"export\" functionality. Removes header ordering \n requirement and eliminates the maintenance of a pre-determined list of \"known \n archives\" By David Abrahams.\n
    • \n Improved support for STLPort.\n
    \n

    Differences from Boost 1.33

    \n
      \n
    • \n Native Binary archives use the std::streambuf\n interface. This should result in noticeably faster execution in many cases.\n
    \n

    Differences from Boost 1.32

    \n
      \n
    • \n Dynamic Linking Library (DLLs and shared libraries) for platforms which support \n them. See Automatic \n Linking on Windows.\n
    • \n Implementation of auto-link for compilers which can support this.\n
    • \n Better support for Argument Dependent Lookup\n and two-phase lookup. This results in simpler rules regarding the placing of \n serialization specializations namespaces.\n
    • \n Enhanced documentation to help explain usage of the above.\n
    • \n Adjustments to improve support for less conformant compilers.\n
    • \n Improved const correctness for save/load operators. Note that this \n may produce compile time errors in code which compiled without problem in \n earlier boost releases. In most cases the fix is trivial. In other cases, code \n should be scrutinized to be sure that it doesn't use the serialization system \n in a way which may introduce subtle bugs in to the program. A fuller \n explanation of this issue can be found \n here.\n
    • \n A new implementation of serialization for shared_ptr<T>. \n This is compatible with public interface of shared_ptr<T>\n so it should be more robust and not have to change in the future. The \n implementation optionally includes code to load shared_ptr<T>\n stored in archives created with boost 1.32. This code is stored in 'he header: \n boost/serialization/shared_ptr_132.hpp. If your application needs to \n load archives created with boost 1.32 libraries, include the above header \n before each inclusion of boost/serialization/shared_ptr.hpp.\n
    • \n More compilers tested and supported.\n
    • \n Miscellaneous bug fixes.\n
    \n

    Pending issues

    \n
      \n
    • \n Rvalues cannot be serialized. It would be possible to implement this for \n untracked types, but this has not been done.\n
    • \n Pointers to pointers cannot currently be serialized\n
    • \n It's possible that std::string and \n std::wstring\n contain characters such as '\\0' and -1 (EOF) which cannot be rendered in text \n and XML archives without an escape mechanism. Currently there is no such escape \n mechanism implemented.\n
    • \n A subtle error in the implementation of serializaton of \n std::map is fixed in this version. Unfortunately, the fix breaks \n serialization of std::map\n for those compilers which do not support partial template specialization. Also, \n types which contain pointers or tracked types might not work correctly.\n
    • \n Serialization of virtual base classes relies upon RTTI. It will fail when used on\n systems which don't have RTTI enabled.\n
    \n

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

    \n

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

    \n\n\n" }, { "path": "doc/serialization.html", "content": "\n\n\n\n\n\n\nSerialization - Serialization of Classes\n\n\n\n \n \n \n \n
    \n

    \"C++

    \n     		\n

    Serialization

    \n

    Serializable Concept

    \n
    \n
    \n
    \n
    Primitive Types\n
    Class Types\n
    \n
    Member Function\n
    Free Function\n
    \n
    Namespaces for Free Function Overrides\n
    \n
    Class Members\n
    \n
    Base Classes\n
    const Members\n
    Templates\n
    \n
    Versioning\n
    Splitting serialize into \n save/load\n
    \n
    Member Functions\n
    Free Functions\n
    \n
    \n
    Pointers\n
    \n
    Non-Default Constructors\n
    Pointers to Objects of Derived Classes\n
    \n
    Registration\n
    Export\n
    Instantiation\n
    Selective Tracking\n
    Runtime Casting\n
    \n
    \n
    References\n
    Arrays\n
    Class Serialization Traits\n
    Serialization Wrappers\n
    Models - Serialization Implementations Included in the Library\n
    \n\nA type T is Serializable \nif and only if one of the following is true:\n
      \n
    • it is a primitive type.
      \n By primitive type we mean a C++ built-in type and ONLY\n a C++ built-in type. Arithmetic (including characters), bool, enum are primitive types.\n Below in serialization traits,\n we define a \"primitive\" implementation level in a different way for a \n different purpose. This can be a source of confusion.\n
    • It is a class type and one of the following has been declared according\n to the prototypes detailed below:\n
        \n
      • a class member function serialize\n
      • a global function serialize\n
      \n
    • it is a pointer to a Serializable type.\n
    • it is a reference to a Serializable type.\n
    • it is a native C++ Array of Serializable type.\n
    \n\n

    Primitive Types

    \nThe template operators &, <<, and >> of the archive classes \ndescribed above will generate code to save/load all primitive types\nto/from an archive. This code will usually just add the\ndata to the archive according to the archive format.\nFor example, a four byte integer is appended to a binary archive\nas 4 binary bytes while a to a text archive it would be \nrendered as a space followed by a string representation.\n\n

    Class Types

    \nFor class/struct types, the template operators &, <<, and >>\nwill generate code that invokes the programmer's serialization code for the\nparticular data type. There is no default. An attempt to serialize a\nclass/struct for which no serialization has been explicitly specified\nwill result in a compile time error. The serialization of a class can\nbe specified via either a class member function or a free function which\ntakes a reference to an instance of the class as an argument.\n\n

    Member Function

    \nThe serialization library invokes the following code to save or load a class instance\nto/from and archive.\n
    \ntemplate<class Archive, class T>\ninline void serialize(\n    Archive & ar, \n    T & t, \n    const unsigned int file_version\n){\n    // invoke member function for class T\n    t.serialize(ar, file_version);\n}\n
    \nThat is, the default definition of template serialize \npresumes the existence of a class member function template of the following \nsignature:\n
    \ntemplate<class Archive>\nvoid serialize(Archive &ar, const unsigned int version){\n    ...\n}\n
    \nIf such a member function is not declared, a compile time error will occur. In order\nthat the member function generated by this template can be called to\nappend the data to an archive, it either must be public or the class must\nbe made accessible to the serialization library by including:\n
    \nfriend class boost::serialization::access;\n
    \nin the class definition. This latter method should be preferred over the option\nof making the member function public. This will prevent serialization functions from \nbeing called from outside the library. This is almost certainly an error. Unfortunately,\nit may appear to function but fail in a way that is very difficult to find.\n

    \nIt may not be immediately obvious how this one template serves for both\nsaving data to an archive as well as loading data from the archive.\nThe key is that the & operator is \ndefined as <<\nfor output archives and as >> input archives. The\n\"polymorphic\" behavior of the & permits the same template\nto be used for both save and load operations. This is very convenient in that it\nsaves a lot of typing and guarantees that the saving and loading of class\ndata members are always in sync. This is the key to the whole serialization\nsystem.\n\n

    Free Function

    \nOf course we're not restricted to using the default implementation described\nabove. We can override the default one with our own. Doing this will\npermit us to implement serialization of a class without altering\nthe class definition itself. We call this non-intrusive\nserialization. Suppose our class is named my_class, the\noverride would be specified as:\n
    \n// namespace selection\n\ntemplate<class Archive>\ninline void serialize(\n    Archive & ar, \n    my_class & t, \n    const unsigned int file_version\n){\n    ...\n}\n
    \n\nNote that we have called this override \"non-intrusive\". This is slightly\ninaccurate. It does not require that the class have special functions, that\nit be derived from some common base class or any other fundamental design changes.\nHowever, it will require access to the class members that are to\nbe saved and loaded. If these members are private, it won't be\npossible to serialize them. So in some instances, minor modifications to the\nclass to be serialized will be necessary even when using this \"non-intrusive\"\nmethod. In practice this may not be such a problem as many libraries \n(E.G. STL) expose enough information to permit implementation of non-intrusive\nserialization with absolutely no changes to the library.\n\n

    Namespaces for Free Function Overrides

    \nFor maximum portability, include any free functions templates and definitions in the \nnamespace boost::serialization. If portability is not a concern and the\ncompiler being used supports ADL (Argument Dependent Lookup) the free functions and\ntemplates can be in any of the following namespaces:\n
      \n
    • boost::serialization\n
    • namespace of the archive class\n
    • namespace of the type being serialized\n
    \n

    \nNote that, at first glance, this suggestion may seem to be wrong for compilers which implement\ntwo phase lookup. In fact, the serialization library used a perhaps overly clever \nmethod to support this rule even for such compilers. Those with an interest in studying\nthis further will find more information in \nserialization.hpp\n\n

    Serialization of Class Members

    \nRegardless of which of the above methods is used, the body of the serialize function must\nspecify the data to be saved/loaded by sequential application of the archive\noperator & to all the data members of the class.\n
    \n{\n    // save/load class member variables\n    ar & member1;\n    ar & member2;\n}\n
    \n\n

    Base Classes

    \nThe header file \n\nbase_object.hpp\n\nincludes the template:\n
    \ntemplate<class Base, class Derived>\nBase & base_object(Derived &d);\n
    \nwhich should be used to create a reference to an object of the base\nwhich can be used as an argument to the archive serialization operators.\nSo for a class of Serializable type\nT the base class state should be \nserialized like this:\n
    \n{\n    // invoke serialization of the base class \n    ar & boost::serialization::base_object<base_class_of_T>(*this);\n    // save/load class member variables\n    ar & member1;\n    ar & member2;\n}\n
    \nResist the temptation to just cast *this to the base class.\nThis might seem to work but may fail to invoke code necessary for\nproper serialization.\n

    \nNote that this is NOT the same as calling the serialize\nfunction of the base class. This might seem to work but will circumvent\ncertain code used for tracking of objects, and registering base-derived\nrelationships and other bookkeeping that is required for the serialization\nsystem to function as designed. For this reason, all serialize\nmember functions should be private.\n\n

    const Members

    \nSaving const members to an archive \nrequires no special considerations.\nLoading const members can be addressed by using a\nconst_cast:\n
    \n    ar & const_cast<T &>(t);\n
    \nNote that this violates the spirit and intention of the const\nkeyword. const members are initialized when a class instance\nis constructed and not changed thereafter. However, this may\nbe most appropriate in many cases. Ultimately, it comes down to \nthe question about what const means in the context\nof serialization. \n\n

    Templates

    \nImplementation of serialization for templates is exactly the same process \nas for normal classes and requires no additional considerations. Among\nother things, this implies that serialization of compositions of templates\nare automatically generated when required if serialization of the \ncomponent templates is defined. For example, this library includes\ndefinition of serialization for boost::shared_ptr<T> and for\nstd::list<T>. If I have defined serialization for my own\nclass my_t, then serialization for \nstd::list< boost::shared_ptr< my_t> > is already available\nfor use.\n

    \nFor an example that shows how this idea might be implemented for your own\nclass templates, see\n\ndemo_auto_ptr.cpp.\nThis shows how non-intrusive serialization\nfor the template auto_ptr from the standard library\ncan be implemented.\n

    \nA somewhat trickier addition of serialization to a standard template\ncan be found in the example \n\nshared_ptr.hpp\n\n\n

    \nIn the specification of serialization for templates, its common\nto split serialize \ninto a load/save pair. \nNote that the convenience macro described \nabove\nisn't helpful in these cases as the number and kind of\ntemplate class arguments won't match those used when splitting\nserialize for a simple class. Use the override\nsyntax instead.\n\n

    Versioning

    \nIt will eventually occur that class definitions change after archives have\nbeen created. When a class instance is saved, the current version\nin included in the class information stored in the archive. When the class instance\nis loaded from the archive, the original version number is passed as an\nargument to the loading function. This permits the load function to include\nlogic to accommodate older definitions for the class and reconcile them\nwith latest version. Save functions always save the current version. So this\nresults in automatically converting older format archives to the newest versions.\nVersion numbers are maintained independently for each class. This results in \na simple system for permitting access to older files and conversion of same.\nThe current version of the class is assigned as a\nClass Serialization Trait described later in this manual.\n
    \n{\n    // invoke serialization of the base class \n    ar & boost::serialization::base_object<base_class_of_T>(*this);\n    // save/load class member variables\n    ar & member1;\n    ar & member2;\n    // if its a recent version of the class\n    if(1 < file_version)\n        // save load recently added class members\n        ar & member3;\n}\n
    \n\n

    Splitting serialize into Save/Load

    \nThere are times when it is inconvenient to use the same\ntemplate for both save and load functions. For example, this might occur if versioning\ngets complex. \n\n

    Splitting Member Functions

    \nFor member functions this can be addressed by including\nthe header file \nboost/serialization/split_member.hpp including code like this in the class:\n
    \ntemplate<class Archive>\nvoid save(Archive & ar, const unsigned int version) const\n{\n    // invoke serialization of the base class \n    ar << boost::serialization::base_object<const base_class_of_T>(*this);\n    ar << member1;\n    ar << member2;\n    ar << member3;\n}\n\ntemplate<class Archive>\nvoid load(Archive & ar, const unsigned int version)\n{\n    // invoke serialization of the base class \n    ar >> boost::serialization::base_object<base_class_of_T>(*this);\n    ar >> member1;\n    ar >> member2;\n    if(version > 0)\n        ar >> member3;\n}\n\ntemplate<class Archive>\nvoid serialize(\n    Archive & ar,\n    const unsigned int file_version \n){\n    boost::serialization::split_member(ar, *this, file_version);\n}\n
    \nThis splits the serialization into two separate functions save\nand load. Since the new serialize template\nis always the same it can be generated by invoking the macro\nBOOST_SERIALIZATION_SPLIT_MEMBER() defined in the header file\n\nboost/serialization/split_member.hpp\n.\nSo the entire serialize function above can be replaced with:\n
    \nBOOST_SERIALIZATION_SPLIT_MEMBER()\n
    \n

    Splitting Free Functions

    \nThe situation is same for non-intrusive serialization with the free\nserialize function template.\n\n\nTo use save and \nload function templates rather than \nserialize:\n
    \nnamespace boost { namespace serialization {\ntemplate<class Archive>\nvoid save(Archive & ar, const my_class & t, unsigned int version)\n{\n    ...\n}\ntemplate<class Archive>\nvoid load(Archive & ar, my_class & t, unsigned int version)\n{\n    ...\n}\n}}\n
    \ninclude the header file \n    \nboost/serialization/split_free.hpp\n.\nand override the free serialize function template:\n
    \nnamespace boost { namespace serialization {\ntemplate<class Archive>\ninline void serialize(\n    Archive & ar,\n    my_class & t,\n    const unsigned int file_version\n){\n    split_free(ar, t, file_version); \n}\n}}\n
    \nTo shorten typing, the above template can be replaced with\nthe macro:\n
    \nBOOST_SERIALIZATION_SPLIT_FREE(my_class)\n
    \n\nNote that although the functionality to split the \nserialize function into save/load\nhas been provided, the usage of the serialize\nfunction with the corresponding & operator\nis preferred. The key to the serialization implementation is that objects are saved \nand loaded in exactly the same sequence. Using the & \noperator and serialize\nfunction guarantees that this is always the case and will minimize the\noccurrence of hard to find errors related to synchronization of \nsave and load \nfunctions.\n

    \nAlso note that BOOST_SERIALIZATION_SPLIT_FREE\nmust be used outside of any namespace.\n\n

    Pointers

    \nA pointer to any class instance can be serialized with any of the archive \nsave/load operators.\n

    \nTo properly save and restore an object through a pointer the\nfollowing situations must be addressed:\n

      \n
    1. If the same object is saved multiple times through different\n pointers, only one copy of the object need be saved.\n
    2. If an object is loaded multiple times through different pointers,\n only one new object should be created and all returned pointers\n should point to it.\n
    3. The system must detect the case where an object is first\n saved through a pointer then the object itself is saved.\n Without taking extra precautions, loading would result in the\n creation of multiple copies of the original object. This system detects\n this case when saving and throws an exception - see below.\n
    4. An object of a derived class may be stored through a\n pointer to the base class. The true type of the object must\n be determined and saved. Upon restoration the correct type\n must be created and its address correctly cast to the base\n class. That is, polymorphic pointers have to be considered.\n
    5. NULL pointers must be detected when saved and restored\n to NULL when deserialized.\n
    \n\nThis serialization library addresses all of the above\nconsiderations. The process of saving and loading an object\nthrough a pointer is non-trivial. It can be summarized as\nfollows:\n

    Saving a pointer:\n

      \n
    1. determine the true type of the object being pointed to.\n
    2. write a special tag to the archive\n
    3. if the object pointed to has not already been written\n to the archive, do so now\n
    \nLoading a pointer:\n
      \n
    1. read a tag from the archive.\n
    2. determine the type of object to be created\n
    3. if the object has already been loaded, return its address.\n
    4. otherwise, create a new instance of the object\n
    5. read the data back in using the operators described above\n
    6. return the address of the newly created object.\n
    \n\nGiven that class instances are saved/loaded to/from the archive\nonly once, regardless of how many times they are serialized with\nthe << \nand >> operators\n
      \n
    • Loading the same pointer object multiple times\n results in only one object being created, thereby replicating\n the original pointer configuration. \n
    • Structures, such as collections of polymorphic pointers,\n are handled with no special effort on the part of users of this library.\n
    \nSerialization of pointers of derived types through a pointer to the\nbase class may require a little extra \"help\". Also, the programmer\nmay desire to modify the process described above for his own reasons.\nFor example, it might be desired to suppress the tracking of objects\nas it is known a priori that the application in question can never\ncreate duplicate objects. Serialization of pointers can be \"fine tuned\"\nvia the specification of Class Serialization Traits\nas described in\n\nanother section of this manual\n\n\n

    Non-Default Constructors

    \nSerialization of pointers is implemented in the library with code\nsimilar to the following:\n
    \n// load data required for construction and invoke constructor in place\ntemplate<class Archive, class T>\ninline void load_construct_data(\n    Archive & ar, T * t, const unsigned int file_version\n){\n    // default just uses the default constructor to initialize\n    // previously allocated memory. \n    ::new(t)T();\n}\n
    \nThe default load_construct_data invokes the\ndefault constructor \"in-place\" to initialize the memory.\n

    \nIf there is no such default constructor, the function templates\nload_construct_data and \nperhaps save_construct_data\nwill have to be overridden. Here is a simple example:\n

    \nclass my_class {\nprivate:\n    friend class boost::serialization::access;\n    const int m_attribute;  // some immutable aspect of the instance\n    int m_state;            // mutable state of this instance\n    template<class Archive>\n    void serialize(Archive &ar, const unsigned int file_version){\n        ar & m_state;\n    }\npublic:\n    // no default construct guarantees that no invalid object\n    // ever exists\n    my_class(int attribute) :\n        m_attribute(attribute),\n        m_state(0)\n    {}\n};\n
    \nthe overrides would be:\n
    \nnamespace boost { namespace serialization {\ntemplate<class Archive>\ninline void save_construct_data(\n    Archive & ar, const my_class * t, const unsigned int file_version\n){\n    // save data required to construct instance\n    ar << t->m_attribute;\n}\n\ntemplate<class Archive>\ninline void load_construct_data(\n    Archive & ar, my_class * t, const unsigned int file_version\n){\n    // retrieve data from archive required to construct new instance\n    int attribute;\n    ar >> attribute;\n    // invoke inplace constructor to initialize instance of my_class\n    ::new(t)my_class(attribute);\n}\n}} // namespace ...\n
    \nIn addition to the deserialization of pointers, these overrides are used\nin the deserialization of STL containers whose element type has no default\nconstructor.\n\n

    Pointers to Objects of Derived Classes

    \n

    Registration

    \nConsider the following:\n
    \nclass base {\n    ...\n};\nclass derived_one : public base {\n    ...\n};\nclass derived_two : public base {\n    ...\n};\nint main(){\n    ...\n    base *b;\n    ...\n    ar & b; \n}\n
    \nWhen saving b what kind of object should be saved? \nWhen loading b what kind of object should be created? \nShould it be an object of class derived_one,\nderived_two, or maybe base?\n

    \nIt turns out that the kind of object serialized depends upon whether the base class\n(base in this case) is polymorphic or not.\nIf base is not polymorphic, that is if it has no\nvirtual functions, then an object of the type base\nwill be serialized. Information in any derived classes will be lost. If this is what is desired\n(it usually isn't) then no other effort is required.\n

    \n\nIf the base class is polymorphic, an object of the most derived type\n(derived_one\nor derived_two\nin this case) will be serialized. The question of which type of object is to be\nserialized is (almost) automatically handled by the library.\n

    \nThe system \"registers\" each class in an archive the first time an object of that\nclass it is serialized and assigns a sequential number to it. Next time an\nobject of that class is serialized in that same archive, this number is written\nin the archive. So every class is identified uniquely within the archive. \nWhen the archive is read back in, each new sequence number is re-associated with \nthe class being read. Note that this implies that \"registration\" has to occur\nduring both save and load so that the class-integer table built on load\nis identical to the class-integer table built on save. In fact, the key to\nwhole serialization system is that things are always saved and loaded in\nthe same sequence. This includes \"registration\".\n

    \nExpanding our previous example:\n

    \nint main(){\n    derived_one d1;\n    derived_two d2:\n    ...\n    ar & d1;\n    ar & d2;\n    // A side effect of serialization of objects d1 and d2 is that\n    // the classes derived_one and derived_two become known to the archive.\n    // So subsequent serialization of those classes by base pointer works\n    // without any special considerations.\n    base *b;\n    ...\n    ar & b; \n}\n
    \nWhen b is read it is\npreceded by a unique (to the archive) class identifier which\nhas previously been related to class derived_one or\nderived_two.\n

    \nIf a derived class has NOT been automatically \"registered\" as described\nabove, an \nunregistered_class exception \nwill be thrown when serialization is invoked.\n

    \nThis can be addressed by registering the derived class explicitly. All archives are\nderived from a base class which implements the following template:\n

    \ntemplate<class T>\nregister_type(T * = NULL);\n
    \nSo our problem could just as well be addressed by writing:\n
    \nint main(){\n    ...\n    ar.template register_type<derived_one>();\n    ar.template register_type<derived_two>();\n    base *b;\n    ...\n    ar & b; \n}\n
    \nNote that if the serialization function is split between save and load, both\nfunctions must include the registration. This is required to keep the save\nand corresponding load in synchronization.\n\n

    Export

    \nThe above will work but may be inconvenient. We don't always know which derived\nclasses we are going to serialize when we write the code to serialize through\na base class pointer. Every time a new derived class is written we have to\ngo back to all the places where the base class is serialized and update the\ncode.\n

    \nSo we have another method:\n

    \n#include <boost/serialization/export.hpp>\n...\nBOOST_CLASS_EXPORT_GUID(derived_one, \"derived_one\")\nBOOST_CLASS_EXPORT_GUID(derived_two, \"derived_two\")\n\nint main(){\n    ...\n    base *b;\n    ...\n    ar & b; \n}\n
    \nThe macro BOOST_CLASS_EXPORT_GUID associates a string literal\nwith a class. In the above example we've used a string rendering\nof the class name. If a object of such an \"exported\" class is serialized\nthrough a pointer and is otherwise unregistered, the \"export\" string is \nincluded in the archive. When the archive \nis later read, the string literal is used to find the class which \nshould be created by the serialization library.\nThis permits each class to be in a separate header file along with its \nstring identifier. There is no need to maintain a separate \"pre-registration\" \nof derived classes that might be serialized. This method of\nregistration is referred to as \"key export\". More information on this\ntopic is found in the section Class Traits - \nExport Key.\n

    \n

    Instantiation

    \nRegistration by means of any of the above methods fulfill another role \nwhose importance might not be obvious. This system relies on templated\nfunctions of the form template<class Archive, class T>.\nThis means that serialization code must be instantiated for each\ncombination of archive and data type that is serialized in the program.\n

    \nPolymorphic pointers of derived classes may never be referred to \nexplicitly by the program so normally code to serialize such classes\nwould never be instantiated. So in addition to including export key\nstrings in an archive, BOOST_CLASS_EXPORT_GUID explicitly\ninstantiates the class serialization code for all archive classes used \nby the program. \n\n

    Selective Tracking

    \nWhether or not an object is tracked is determined by its\nobject tracking trait.\nThe default setting for user defined types is track_selectively.\nThat is, track objects if and only if they are serialized through pointers anywhere\nin the program. Any objects that are \"registered\" by any of the above means are presumed\nto be serialized through pointers somewhere in the program and therefore\nwould be tracked. In certain situations this could lead to an inefficiency.\nSuppose we have a class module used by multiple programs. Because\nsome programs serializes polymorphic pointers to objects of this class, we \nexport a class\nidentifier by specifying BOOST_CLASS_EXPORT in the\nclass header. When this module is included by another program,\nobjects of this class will always be tracked even though it\nmay not be necessary. This situation could be addressed by using \ntrack_never \nin those programs.\n

    \nIt could also occur that even though a program serializes through \na pointer, we are more concerned with efficiency than avoiding the\nthe possibility of creating duplicate objects. It could be\nthat we happen to know that there will be no duplicates. It could\nalso be that the creation of a few duplicates is benign and not\nworth avoiding given the runtime cost of tracking duplicates.\nAgain, track_never \ncan be used.\n

    Runtime Casting

    \nIn order to properly translate between base and derived pointers\nat runtime, the system requires each base/derived pair be found\nin a table. A side effect of serializing a base object with\nboost::serialization::base_object<Base>(Derived &)\nis to ensure that the base/derived pair is added to the table\nbefore the main function is entered.\nThis is very convenient and results in a clean syntax. The only\nproblem is that it can occur where a derived class serialized\nthrough a pointer has no need to invoke the serialization of\nits base class. In such a case, there are two choices. The obvious\none is to invoke the base class serialization with base_object\nand specify an empty function for the base class serialization.\nThe alternative is to \"register\" the Base/Derived relationship\nexplicitly by invoking the template \nvoid_cast_register<Derived, Base>();.\nNote that this usage of the term \"register\" is not related\nto its usage in the previous section. Here is an example of how this is done:\n
    \n#include <sstream>\n#include <boost/serialization/serialization.hpp>\n#include <boost/archive/text_iarchive.hpp>\n#include <boost/serialization/export.hpp>\n\nclass base {\n    friend class boost::serialization::access;\n    //...\n    // only required when using method 1 below\n    // no real serialization required - specify a vestigial one\n    template<class Archive>\n    void serialize(Archive & ar, const unsigned int file_version){}\n};\n\nclass derived : public base {\n    friend class boost::serialization::access;\n    template<class Archive>\n    void serialize(Archive & ar, const unsigned int file_version){\n        // method 1 : invoke base class serialization\n        ar & boost::serialization::base_object<base>(*this);\n        // method 2 : explicitly register base/derived relationship\n        boost::serialization::void_cast_register<derived, base>(\n            static_cast<derived *>(NULL),\n            static_cast<base *>(NULL)\n        )\n    }\n};\n\nBOOST_CLASS_EXPORT_GUID(derived, \"derived\")\n\nint main(){\n    //...\n    std::stringstream ss;\n    boost::archive::text_iarchive ar(ss);\n    base *b;\n    ar >> b; \n}\n
    \n

    \n\nIn order for this template to be invoked in code compiled by non-conforming\ncompilers, the following syntax may be used:\n

    \nboost::serialization::void_cast_register(\n    static_cast<Derived *>(NULL),\n    static_cast<Base *>(NULL)\n);\n
    \nFor more information, see Template Invocation syntax\n\n

    References

    \nClasses that contain reference members will generally require\nnon-default constructors as references can only be set when\nan instance is constructed. The example of the previous section\nis slightly more complex if the class has reference members.\nThis raises the question of how and where the objects being\nreferred to are stored and how are they created. Also there is the question about\nreferences to polymorphic base classes. Basically, these\nare the same questions that arise regarding pointers. This is\nno surprise as references are really a special kind of pointer.\nWe address these questions by serializing references as though\nthey were pointers.\n
    \nclass object;\nclass my_class {\nprivate:\n    friend class boost::serialization::access;\n    int member1;\n    object & member2;\n    template<class Archive>\n    void serialize(Archive &ar, const unsigned int file_version);\npublic:\n    my_class(int m, object & o) :\n        member1(m), \n        member2(o)\n    {}\n};\n
    \nthe overrides would be:\n
    \nnamespace boost { namespace serialization {\ntemplate<class Archive>\ninline void save_construct_data(\n    Archive & ar, const my_class * t, const unsigned int file_version\n){\n    // save data required to construct instance\n    ar << t.member1;\n    // serialize reference to object as a pointer\n    ar << & t.member2;\n}\n\ntemplate<class Archive>\ninline void load_construct_data(\n    Archive & ar, my_class * t, const unsigned int file_version\n){\n    // retrieve data from archive required to construct new instance\n    int m;\n    ar >> m;\n    // create and load data through pointer to object\n    // tracking handles issues of duplicates.\n    object * optr;\n    ar >> optr;\n    // invoke inplace constructor to initialize instance of my_class\n    ::new(t)my_class(m, *optr);\n}\n}} // namespace ...\n
    \n\n

    Arrays

    \nIf T is a serializable type, \nthen any native C++ array of type T is a serializable type.\nThat is, if T\nis a serializable type, then the following\nis automatically available and will function as expected:\n
    \nT t[4];\nar << t;\n    ...\nar >> t;\n
    \n\n

    Class Serialization Traits

    \n\n

    Serialization Wrappers

    \n\n

    Models - Serialization Implementations Included in the Library

    \nThe facilities described above are sufficient to implement \nserialization for all STL containers. In fact, this has been done\nand has been included in the library. For example, in order to use\nthe included serialization code for std::list, use:\n
    \n#include <boost/serialization/list.hpp>\n
    \nrather than\n
    \n#include <list>\n
    \nSince the former includes the latter, this is all that is necessary.\nThe same holds true for all STL collections as well as templates\nrequired to support them (e.g. std::pair).\n

    \nAs of this writing, the library contains serialization of the following boost classes:\n

      \n
    • optional\n
    • variant\n
    • scoped_ptr\n
    • shared_ptr\n
    • auto_ptr (demo)\n
    \nC++17 std::variant is supported as well.\nOthers are being added to the list so check the boost files section and headers for\nnew implementations!\n
    \n

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

    \n\n\n" }, { "path": "doc/shared_ptr.html", "content": "\n\n\n\n\n\n\nTemplate serialization - shared_ptr\n\n\n\n \n \n \n \n
    \n

    \"C++

    \n     		\n

    Serialization

    \n

    Template serialization - shared_ptr<class T>

    \n
    \n
    \nAll the code snippets included below are defined within the\nboost::serialization namespace.\n

    \nshared_ptr<T> is defined in\nshared_ptr.hpp.\n

    \nThe general class outline for a shared_ptr<T> is:\n

    \n
    shared_ptr<T> contains:\n
    \n
    T *px;\n
    shared_count pn; which contains a pointer to:\n
    \n
    sp_counted_base_impl<T, ...> which is\nderived from the polymorphic abstract class\n
    \n
    sp_counted_base\n
    \n
    \n
    \n
    \nThe serialization process proceeds down the tree above.\n

    \nThe first cut at implementing serialization for shared_ptr\njust serializes the relevant members of shared_ptr.\nIt's almost trivial:\n

    \ntemplate<class Archive, class T>\ninline void serialize(\n    Archive & ar,\n    shared_ptr<T> & t,\n    const unsigned int file_version,\n    int\n){\n    ar & t.px; // save the raw pointer\n    ar & t.pn; // save the shared reference count\n}\n
    \nSo far so good. Now for the serialization of shared_count:\n
    \ntemplate<class Archive>\ninline void save(\n    Archive & ar,\n    const boost::detail::shared_count & t,\n    const unsigned int file_version\n){\n    ar << t.pi_;\n}\n\ntemplate<class Archive>\ninline void load(\n    Archive & ar,\n    boost::detail::shared_count & t,\n    const unsigned int file_version\n){\n    ar >> t.pi_;\n}\n
    \nA key feature of this library is the ability to specify serialization\nof a class or template without changing the class or template declaration\nor definition. This is referred to as non-intrusive serialization.\n

    \nThe pi_member of shared count is a pointer to an \ninstance of sp_counted_base_impl. Since this class\ndoesn't have a default constructor, serialization requires\nspecification of the following overload:\n

    \ntemplate<class Archive, class P, class D>\ninline void save_construct_data(\n    Archive & ar,\n    const boost::detail::sp_counted_base_impl<P, D> * t, \n    const unsigned int file_version\n){\n    // variables used for construction\n    ar << t->ptr;\n    ar << *t;\n}\n\ntemplate<class Archive, class P, class D>\ninline void load_construct_data(\n    Archive & ar,\n    boost::detail::sp_counted_base_impl<P, D> * t, \n    const unsigned int file_version\n){\n    P ptr_;\n    ar >> ptr_;\n    // placement new\n    ::new(t)boost::detail::sp_counted_base_impl<P, D>(ptr_,  D());\n    ar >> *t;\n}\n
    \nThe statement ar >> ptr_ is key. This deserializes\nthe same pointer deserialized above. Default object tracking will ensure\nthat no more than one instance of the object is created and that the\npointer returned by multiple deserializations are all the same. Hence,\nregardless of how many instances of shared_ptr/shared_count\ncorresponding to a particular object are created, they will all point\nto the same object.\n

    \nSince sp_counted_base_impl<P, D> is derived from \nsp_counted_base, the following is needed:\n\n

    \ntemplate<class Archive, class P, class D>\ninline void serialize(\n    Archive & ar,\n    boost::detail::sp_counted_base_impl<P, D> & t,\n    const unsigned int file_version,\n    int\n){\n    ar & boost::serialization::base_object<\n\tboost::detail::sp_counted_base\n    >(*this);\n}\n
    \nwhich will in turn require serialization of its base class:\n
    \ninline void serialize(\n    Archive & ar,\n    boost::detail::sp_counted & t,\n    const unsigned int file_version,\n    int\n){\n}\n
    \nIt would seem we're done, but running the test program,\n\ndemo_shared_ptr.cpp\n,\nwith this code produces the following output.\n
    \na = 0x003017A0 use count = 2\na1 = 0x003017A0 use count = 2\nunique element count = 1\na = 0x00000000 use count = 0\na1 = 0x00000000 use count = 0\nunique element count = 0\na = 0x00303060 use count = 1\na1 = 0x00303060 use count = 1\nunique element count = 1\n
    \nThis indicates that we're not quite done. Due to default object\ntracking, sp_counted_base_impl<P, D> is only\ncreated once regardless of how many shared pointers point to the\nsame object. Of course, it has to be this way. The reference\ncount starts at 1 and is never incremented. Code must be added\nto the serialization functions to maintain the proper reference\ncount.\n

    \nThe process of serialization of an empty base class - \nsp_counted_base - seems like additional overhead.\nExamination of code in \n\nbase_object.hpp\n\nreveals that base_object.hpp provides two functions:\n

      \n
    • invokes serialization of the base class data\n
    • as a side effect, \"registers\" the fact base/derived relationship\nso that conversions of pointers between base and derived classes can be\nmade at runtime.\n
    \nIn this case we need only the latter function so we can replace the\nbase object serialization with:\n
    \n// register the relationship between each derived class\n// and its polymorphic base\nvoid_cast_register<\n    boost::detail::sp_counted_base_impl<P, D>\n    boost::detail::sp_counted_base, \n>();\n
    \nand we don't have to include a trivial serializer for sp_counted_base.\n

    \nFinally we need to specify name-value pair wrappers if we want to be able\nto use this serialization with XML archives.\n

    \nActually, even this is really just a start. Among the issues not addressed in\nthis implementation are:\n

      \n
    • weak_ptr is not addressed. I haven't even looked into this.\n
    • Other smart pointers that might interact with shared_ptr\n haven't been addressed at all. To be confident that the implementation is\n complete and correct, all these should be addressed as well.\n
    • Exception handling hasn't been exhaustively considered.\n
    • Other issues yet to be discovered.\n
    \nOne thing that has been considered is export of shared_ptr. The header which\ndeclares shared pointer serialization includes some special macros for exporting\nshared pointers:\n
    \nBOOST_SHARED_POINTER_EXPORT(T)\nBOOST_SHARED_POINTER_EXPORT_GUID(T, K)\n
    \nThese are specialized versions of the macros used for exporting classes serialized through raw pointers.\n

    \nClear, complete, correct and exception safe serialization of smart pointers is going to\nbe a challenge. I hope that this implementation provides a useful\nstarting point for such an effort.\n

    \n

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

    \n\n\n" }, { "path": "doc/shared_ptr2.html", "content": "\n\n\n\n\n\n\nTemplate serialization - shared_ptr\n\n\n\n \n \n \n \n
    \n

    \"C++

    \n     		\n

    Serialization

    \n

    shared_ptr<class T> Revisited

    \n
    \n
    \nThe previously described serialization of shared_ptr\nillustrates the straightforward way of serializing a moderately complicated class structure.\nUnfortunately, this way of doing it suffered from some undesirable features\n
      \n
    • It was dependent on the Boost implementation of shared_ptr.\n The shared_ptr interface has been included\n in std::tr1 and may someday be included in the standard\n C++ library. An implementation which depends only on the public interface can be guaranteed to\n function with any other future implementation of shared_ptr.\n
    • It required extra macros for export.\n
    \n\n
    \ntemplate<class Archive, class T>\ninline void save(\n    Archive & ar,\n    const boost::shared_ptr<T> &t,\n    const unsigned int /* file_version */\n){\n    const T * t_ptr = t.get();\n    // just serialize the underlying raw pointer\n    ar << boost::serialization::make_nvp(\"px\", t_ptr);\n}\n\ntemplate<class Archive, class T>\ninline void load(\n    Archive & ar,\n    boost::shared_ptr<T> &t,\n    const unsigned int file_version\n){\n    T* r;\n    // recover the underlying raw pointer\n    ar >> boost::serialization::make_nvp(\"px\", r);\n\n    // To Do - match up with other shared pointers which \n    // use this same raw pointer.\n    ...\n}\n
    \n\nIn principle, this is very much simpler than the original implementation. Completion of\nthis code requires:\n\n
      \n
    1. Filling in the \"To Do\". This required making an extra map for\n shared_ptr instances.\n
    2. A method for identifying pointers to the same objects from pointers to their base classes.\n
    3. Backward compatibility with pointers serialized by the previous method. This exploits\n the serialization class versioning.\n
    4. Proper handling of weak_ptr.\n
    \n\nThe result of this effort can be found in \n\nboost::serialization::shared_ptr.hpp\n\n

    \nNote that if your code needs to read archives created under boost version 1.32, you will\nhave to include the following\n\n

    \n#include <boost/serialization/shared_ptr_132.hpp>\n#include <boost/serialization/shared_ptr.hpp>\n
    \nrather than just\n
    \n#include <boost/serialization/shared_ptr.hpp>\n
    \n\n
    \n

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

    \n\n\n" }, { "path": "doc/simple_log.html", "content": "\n\n\n\n\n\n\nSerialization - Derivation from an Existing Archive\n\n\n\n \n \n \n \n
    \n

    \"C++

    \n     		\n

    Serialization

    \n

    A Simple Logging Archive Class

    \n
    \n
    \nThe purpose of this example is to help clarify the usage of the\nArchive Concept \nso that one can implement his own archive classes. \n\nsimple_log_archive.hpp implements a simple but useful\narchive class. This class can be used to send any serializable types\non an output text stream in a readable format. Usage of this facility\nis trivially easy:\n\n
    \n#include \"simple_log_archive.hpp\"\n...\n// display the complete schedule\nsimple_log_archive log(std::cout);\nlog << schedule;\n
    \n\nand it produces the following output\n\n
    \nschedule \n count 6\n item \n  first \n   driver bob\n   hour 6\n   minute 24\n  second -> \n   stops \n    count 3\n    item -> \n     latitude \n      degrees 34\n      minutes 135\n      seconds 52.56\n     longitude \n      degrees 134\n      minutes 22\n      seconds 78.3\n...\n
    \n\nThe complete example is \ndemo_simple_log.cpp. Look at \nTrivial Archive to get a \nbetter understanding of how this works.\n\nAlso, note the following:\n
      \n
    • Only 160 lines of code.\n
    • Header only - linking with the serialization library not required.\n
    • Displays ALL Serializable types.\n
    • Lacks some features.\n
        \n
      • it will not display the data from the derived type given the pointer to a \n polymorphic base class. That is, only displays the information of the base class.\n To add that see the next example.\n
      • doesn't display information serialized as binary data\n
      \n
    \n\n
    \n

    © Copyright Robert Ramey 2002-2010. \nDistributed under the Boost Software License, Version 1.0. (See\naccompanying file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)\n

    \n\n\n" }, { "path": "doc/singleton.html", "content": "\n\n\n\n\n\n\nSerialization - singleton\n\n\n\n \n \n \n \n
    \n

    \"C++

    \n     		\n

    Serialization

    \n

    singleton

    \n
    \n
    \n
    \n
    Motivation\n
    Features\n
    Class Interface\n
    Requirements\n
    Examples\n
    Multi-Threading\n
    \n\n

    Motivation

    \nThe serialization library relies on the existence of a number\nof static variables and tables to store information related\nto runtime types. Examples are tables which relate exported\nnames to types and tables which relate base classes to derived\nclasses. Construction, destruction and usage of these variables\nrequires consideration of the following issues:\n
      \n
    • Some static data variable and constant entries refer to others. \n The sequence of initialization cannot be arbitrary but must be in proper\n sequence.
      • \n
    • A number of static variables aren't referred to explicitly and, without\n special precautions, will be stripped by most code optimizers
      • \n
    • Many of these variables are created by templates and special care must\n be taken to be sure that they are instantiated
      • \n
    • In a multi-threading system, its possible that these static variables\n will be accessed concurrently by separate threads. This would create a\n race condition with unpredictable behavior
      • \n
    \nThis singleton class addresses all of the above issues.\n\n

    Features

    \nThis singleton implementation has the following features:\n
      \n
    • \n Any instance will be constructed before any attempt is made to access it.
      • \n
    • \n Any instance created with a template is guaranteed to be instantiated.\n
    • \n Regardless of whether or not an instance has been explicitly\n referred to, it will not be stripped by the optimizer when the\n executable is built in release mode.\n
    • \n All instances are constructed before \n main is called\n regardless of where they might be referenced within the program.\n In a multi-tasking system, this guarantees that there will be no \n race conditions during the construction of any instance. No\n thread locking is required to guarantee this.\n
    • \n The above implies that any const\n instances are thread-safe during the whole program. Again, no\n thread locking is required.\n
    • \n If a mutable instance is created, and such an instance is modified\n after main is called in a multi-threading system, there exists\n the possibility that a race condition will occur. The serialization\n library takes care that in the few places where a mutable\n singleton is required, it is not altered after \n main is called.\n For a more general purpose usage, thread locking on this\n singleton could easily be implemented. But as the serialization\n library didn't require it, it wasn't implemented.\n
    \n\n

    Class Interface

    \n
    \nnamespace boost { \nnamespace serialization {\n\ntemplate <class T>\nclass singleton : public boost::noncopyable\n{\npublic:\n    static const T & get_const_instance();\n    static T & get_mutable_instance();\n    static bool is_destroyed();\n};\n\n} // namespace serialization \n} // namespace boost\n
    \n\n
    \n\n

    \nstatic const T & get_const_instance();\n

    \n
    \nRetrieve a constant reference to the singleton for this type.\n
    \n\n

    \nstatic T & get_mutable_instance();\n

    \n
    \nRetrieve a mutable reference to the singleton for this type.\n
    \n\n

    \nstatic bool is_destroyed();\n

    \n
    \nReturn true if the destructor on this singleton has been \ncalled. Otherwise, return false.\n
    \n\n
    \n\n

    Requirements

    \nIn order to be used as \n\n\nsingleton<T>\n\n, the type T must be default constructible. \nIt doesn't require static variables - though it may have them.\nSince the library guarantees that only one instance of \n\n\nsingleton<T>\n\n \nexists and all access is through the above static interface\nfunctions, common member functions of T become\nthe functional equivalent of \nstatic functions.\n\n

    Examples

    \nThere are at least two different ways to use this class template.\nBoth are used in the serialization library.\n

    \nThe first way is illustrated by an excerpt from the file\nextended_type_info.cpp.\nwhich contains the following code:\n\n

    \ntypedef std::set<const extended_type_info *, key_compare> ktmap;\n...\nvoid\nextended_type_info::key_register(const char *key) {\n    ...\n    result = singleton<ktmap>::get_mutable_instance().insert(this);\n    ...\n}\n
    \nJust by referring to the singleton instance anywhere in the program\nwill guarantee that one and only one instance for the specified\ntype (ktmap in this example) \nwill exist throughout the program. There is no need for any other\ndeclaration or definition.\n

    \nA second way is to use \n\n\nsingleton<T>\n \n\nas one of the base classes of the type. This is illustrated by a simplified\nexcerpt from\n\n\nextended_type_info_typeid.hpp\n \n\n\n

    \ntemplate<class T>\nclass extended_type_info_typeid : \n    public detail::extended_type_info_typeid_0,\n    public singleton<extended_type_info_typeid<const T> >\n{\n    friend class singleton<extended_type_info_typeid<const T> >;\nprivate:\n    // private constructor to inhibit any existence other than the \n    // static one.  Note: not all compilers support this !!!\n    extended_type_info_typeid() :\n        detail::extended_type_info_typeid_0()\n    {\n        type_register(typeid(T));\n    }\n    ~extended_type_info_typeid(){}\n    ...\n};\n
    \n\nThis usage will permit a more natural syntax to be used:\n
    \nextended_type_info_typeid<T>::get_const_instance()\n
    \n\nAgain, including one or more of the above statements anywhere\nin the program will guarantee that one and only one instance\nis created and referred to.\n\n

    Multi-Threading

    \nThis singleton CAN be safely used in multi-threading applications if one\nis careful follow a simple rule:\n

    \nDo not call get_mutable_instance when more than one thread is running!\nAll singletons used in the serialization library follow this rule. \nIn order to help detect accidental violations of this rule there\nexist singleton lock/unlock functions.\n

    \nvoid boost::serialization::singleton_module::lock();\nvoid boost::serialization::singleton_module::unlock();\nbool boost::serialization::singleton_module::is_locked();\n
    \nIn a program compiled for debug, any invocation of \nget_mutable_instance()\nwhile the library is in a \"locked\" state will trap in an assertion.\nThe singleton module lock state is initialized as \"unlocked\" to permit\nalteration of static variables before \nmain is called. \nThe lock() and\nunlock() are \"global\"\nin that they affect ALL the singletons defined by this template.\nAll serialization tests invoke lock()\nat the start of the program. For programs compiled in release\nmode these functions have no effect.\n\n
    \n

    © Copyright Robert Ramey 2007. \nDistributed under the Boost Software License, Version 1.0. (See\naccompanying file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)\n

    \n\n\n" }, { "path": "doc/smart_cast.html", "content": "\n\n\n\n\n\n\nSerialization - BOOST_STATIC_WARNING\n\n\n\n \n \n \n \n
    \n

    \"C++

    \n     		\n

    Serialization

    \n

    smart_cast

    \n
    \n
    \n

    Motivation

    \nTo cast from one type to another related type, C++ provides the following\noperators:\n\n
    \n
    static_cast<T *>(U *)
    static_cast<T &>(U &)
    \n
    \n
      \n
    • required if neither T nor U are polymorphic\n
    • permitted in other cases.\n
    • fails to detect erroneous casts of polymorphic pointers/references at runtime.\n
    • does not permit \"cross casting\"\n
    • inline function calls can be optimized away during compile time.\n
    \n
    \n

    \n

    dynamic_cast<T *>(U *)
    dynamic_cast<T &>(U &)
    \n
    \n
      \n
    • permitted if either T or U are polymorphic\n
    • prohibited in other cases.\n
    • throws exception on detecting erroneous casts of polymorphic pointers/references\n at runtime.\n
    • permits \"cross casting\"\n
    • cannot optimise inline virtual functions at compile time.\n
    \n
    \n
    \n\nThese rules can make it difficult to use casting with a function template argument.\nConsider the following example:\n\n
    \n#include <boost/serialization/smart_cast.hpp>\n\nstruct top {\n};\n\nstruct base1 : public top {\n    bool is_storable() const {\n        return true;\n    }\n    virtual ~base1();\n};\n\nstruct base2 {\n    virtual ~base2();\n};\n\nstruct derived1 :\n    public base1\n{\n    derived1();\n};\n\nstruct derived2 :\n    public base1, \n    public base2\n{\n    derived2();\n};\n\ntemplate<class T>\nbool is_storable(T &t){\n    // what type of cast to use here?\n\n    // this fails at compile time when T == base2\n    // return static_cast<base1 &>(t).is_storable();\n\n    // this fails at compile time when T == top\n    // otherwise it works but cannot optimize inline function call\n    // return dynamic_cast<base1 &>(t).is_storable();\n\n    // this always works - and is guaranteed to generate the fastest code !\n    return (boost::smart_cast_reference<base1 &>(t)).is_storable();\n}\n\nint main(){\n    derived1 d1;\n    top & t1 = d1;\n    derived2 d2;\n    base2 & b2 = d2;\n\n    bool result;\n    result = is_storable(d1);   \n    result = is_storable(d2);   \n    result = is_storable(b2);\n    result = is_storable(b2);\n    result = is_storable(t1);\n    return 0;\n}\n
    \nThe serialization library includes a mix of classes which use\nboth static polymorphism (CRTP) and dynamic\npolymorphism via virtual functions. smart_cast \nwas written to address the more problematic manifestations of the\nsituation exemplified above.\n\n

    Usage

    \nThe following syntax is supported:\n
    \nsmart_cast<Target *, Source *>(Source * s);\nsmart_cast<Target *>(Source * s);\nsmart_cast<Target &, Source &>(Source & s);\n
    \nNote that the above syntax doesn't include \n
    \nsmart_cast<Target & >(Source & s)\n
    \nbut the same functionality is supported with the following special syntax\n
    \nsmart_cast_reference<Target &>(Source & s)\n
    \n\n

    Requirements

    \nsmart_cast can be used only on compilers that support partial\ntemplate specialization or on types for which the\nmacro \nBOOST_BROKEN_COMPILER_TYPE_TRAITS_SPECIALIZATION(<type>)\nhas been applied.\n\n
    \n

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

    \n\n\n" }, { "path": "doc/special.html", "content": "\n\n\n\n\n\n\nSerialization - Special Considerations\n\n\n\n \n \n \n \n
    \n

    \"C++

    \n     		\n

    Serialization

    \n

    Special Considerations

    \n
    \n
    \n
    \n
    Object Tracking\n
    Class Information\n
    Helper Support\n
    Archive Portability\n
    \n
    Numerics\n
    Traits\n
    \n
    Binary Archives\n
    XML Archives\n
    Exporting Class Serialization\n
    Static Libraries and Serialization\n
    DLLS - Serialization and Runtime Linking\n
    Plugins\n
    Multi-Threading\n
    Optimizations\n
    Archive Exceptions\n
    Exception Safety\n
    \n\n

    Object Tracking

    \nDepending on how the class is used and other factors, serialized objects\nmay be tracked by memory address. This prevents the same object from being\nwritten to or read from an archive multiple times. These stored addresses\ncan also be used to delete objects created during a loading process\nthat has been interrupted by throwing of an exception. \n

    \nThis could cause problems in \nprograms where the copies of different objects are saved from the same address.\n

    \ntemplate<class Archive>\nvoid save(boost::basic_oarchive & ar, const unsigned int version) const\n{\n    for(int i = 0; i < 10; ++i){\n        A x = a[i];\n        ar << x;\n    }\n}\n
    \nIn this case, the data to be saved exists on the stack. Each iteration\nof the loop updates the value on the stack. So although the data changes\neach iteration, the address of the data doesn't. If a[i] is an array of\nobjects being tracked by memory address, the library will skip storing\nobjects after the first as it will be assumed that objects at the same address\nare really the same object.\n

    \nTo help detect such cases, output archive operators expect to be passed\nconst reference arguments.\n

    \nGiven this, the above code will invoke a compile time assertion.\nThe obvious fix in this example is to use\n

    \ntemplate<class Archive>\nvoid save(boost::basic_oarchive & ar, const unsigned int version) const\n{\n    for(int i = 0; i < 10; ++i){\n        ar << a[i];\n    }\n}\n
    \nwhich will compile and run without problem. \nThe usage of const by the output archive operators\nwill ensure that the process of serialization doesn't\nchange the state of the objects being serialized. An attempt to do this\nwould constitute augmentation of the concept of saving of state with\nsome sort of non-obvious side effect. This would almost surely be a mistake \nand a likely source of very subtle bugs.\n

    \nUnfortunately, implementation issues currently prevent the detection of this kind of\nerror when the data item is wrapped as a name-value pair.\n

    \nA similar problem can occur when different objects are loaded to an address\nwhich is different from the final location:\n

    \ntemplate<class Archive>\nvoid load(boost::basic_oarchive & ar, const unsigned int version) const\n{\n    for(int i = 0; i < 10; ++i){\n        A x;\n        ar >> x;\n        std::m_set.insert(x);\n    }\n}\n
    \nIn this case, the address of x is the one that is tracked rather than\nthe address of the new item added to the set. Left unaddressed\nthis will break the features that depend on tracking such as loading an object through a pointer.\nSubtle bugs will be introduced into the program. This can be\naddressed by altering the above code thusly:\n\n
    \ntemplate<class Archive>\nvoid load(boost::basic_iarchive & ar, const unsigned int version) const\n{\n    for(int i = 0; i < 10; ++i){\n        A x;\n        ar >> x;\n        std::pair<std::set::const_iterator, bool> result;\n        result = std::m_set.insert(x);\n        ar.reset_object_address(& (*result.first), &x);\n    }\n}\n
    \nThis will adjust the tracking information to reflect the final resting place of \nthe moved variable and thereby rectify the above problem.\n

    \nIf it is known a priori that no pointer\nvalues are duplicated, overhead associated with object tracking can\nbe eliminated by setting the object tracking class serialization trait\nappropriately.\n

    \nBy default, data types designated primitive by the\nImplementation Level\nclass serialization trait are never tracked. If it is desired to\ntrack a shared primitive object through a pointer (e.g. a\nlong used as a reference count), It should be wrapped\nin a class/struct so that it is an identifiable type.\nThe alternative of changing the implementation level of a long\nwould affect all longs serialized in the whole\nprogram - probably not what one would intend.\n

    \nIt is possible that we may want to track addresses even though\nthe object is never serialized through a pointer. For example,\na virtual base class need be saved/loaded only once. By setting\nthis serialization trait to track_always, we can suppress \nredundant save/load operations.\n

    \nBOOST_CLASS_TRACKING(my_virtual_base_class, boost::serialization::track_always)\n
    \n\n

    Helper Support

    \nSome types, specially those with complicated lifetime behavior or limited\naccess to their internal state, might need or benefit from elaborate serialization\nalgorithms. The principle motivating case is that of shared_ptr. As instances\nare loaded, they have to be \"matched up\" with any other instances which have\nalready been loaded. Thus, a table of previously loaded instances has to be\nmaintained while the archive containing the shared_ptr instances is being loaded.\nWithout maintaining such a table, the shared_ptr would be a serializable type.\n

    \nTo implement this facility, one declares a helper object\nassociated to the current archive that can be used to store contextual\ninformation relevant to the particular type serialization algorithm.\n\n

    \ntemplate<class T>\nclass shared_ptr\n{\n   ...\n};\n\nBOOST_SERIALIZATION_SPLIT_FREE(shared_ptr)\n\nclass shared_ptr_serialization_helper\n{\n  // table of previously loaded shared_ptr\n  // lookup a shared_ptr from the object address\n  shared_ptr<T> lookup(const T *);\n  // insert a new shared_ptr\n  void insert<shared_ptr<T> >(const shared_ptr<T> *);\n};\n\nnamespace boost {\nnamespace serialization {\n\ntemplate<class Archive>\nvoid save(Archive & ar, const shared_ptr & x, const unsigned int /* version */)\n{\n    // save shared ptr\n    ...\n}\n\ntemplate<class Archive>\nvoid load(Archive & ar, shared_ptr & x, const unsigned int /* version */)\n{\n    // get a unique identifier.  Using a constant means that all shared pointers\n    // are held in the same set.  Thus we detect handle multiple pointers to the\n    // same value instances in the archive.\n    const void * shared_ptr_helper_id = 0;\n\n    shared_ptr_serialization_helper & hlp =\n        ar.template get_helper<shared_ptr_serialization_helper>(helper_instance_id);\n\n    // load shared pointer object\n    ...\n\n    shared_ptr_serialization_helper & hlp =\n        ar.template get_helper<shared_ptr_serialization_helper>(shared_ptr_helper_id);\n\n    // look up object in helper object\n    T * shared_object hlp.lookup(...);\n\n    // if found, return the one from the table\n\n    // load the shared_ptr data\n    shared_ptr<T> sp = ...\n\n    // and add it to the table\n    hlp.insert(sp);\n    // implement shared_ptr_serialization_helper load algorithm with the aid of hlp\n}\n\n} // namespace serialization\n} // namespace boost\n
    \nget_helper<shared_ptr_serialization_helper>();\ncreates a helper object associated to the archive the first time it is invoked;\nsubsequent invocations return a reference to the object created in the first\nplace, so that hlp can effectively be\nused to store contextual information persisting through the serialization\nof different complex_type objects on\nthe same archive.\n\n

    \nHelpers may be created for saving and loading archives.\nThe same program might have several different helpers or the same helper instantiated\nseparately from different parts of the program. This is what makes the helper_instance_id\nnecessary. In principle it could be any unique integer. In practice it seems\neasiest to use the address of the serialization function which contains it. The\nabove example uses this technique.\n\n

    Class Information

    \nBy default, for each class serialized, class information is written to the archive.\nThis information includes version number, implementation level and tracking\nbehavior. This is necessary so that the archive can be correctly\ndeserialized even if a subsequent version of the program changes\nsome of the current trait values for a class. The space overhead for\nthis data is minimal. There is a little bit of runtime overhead\nsince each class has to be checked to see if it has already had its\nclass information included in the archive. In some cases, even this\nmight be considered too much. This extra overhead can be eliminated\nby setting the \nimplementation level\nclass trait to: boost::serialization::object_serializable. \n

    \nTurning off tracking and class information serialization will result\nin pure template inline code that in principle could be optimised down\nto a simple stream write/read. Elimination of all serialization overhead\nin this manner comes at a cost. Once archives are released to users, the\nclass serialization traits cannot be changed without invalidating the old\narchives. Including the class information in the archive assures us\nthat they will be readable in the future even if the class definition\nis revised. A light weight structure such as a display pixel might be\ndeclared in a header like this:\n\n

    \n#include <boost/serialization/serialization.hpp>\n#include <boost/serialization/level.hpp>\n#include <boost/serialization/tracking.hpp>\n\n// a pixel is a light weight struct which is used in great numbers.\nstruct pixel\n{\n    unsigned char red, green, blue;\n    template<class Archive>\n    void serialize(Archive & ar, const unsigned int /* version */){\n        ar << red << green << blue;\n    }\n};\n\n// elminate serialization overhead at the cost of\n// never being able to increase the version.\nBOOST_CLASS_IMPLEMENTATION(pixel, boost::serialization::object_serializable);\n\n// eliminate object tracking (even if serialized through a pointer)\n// at the risk of a programming error creating duplicate objects.\nBOOST_CLASS_TRACKING(pixel, boost::serialization::track_never)\n
    \n\n

    Archive Portability

    \nSeveral archive classes create their data in the form of text or a portable binary format. \nIt should be possible to save such a class on one platform and load it on another. \nThis is subject to a couple of conditions.\n

    Numerics

    \nThe architecture of the machine reading the archive must be able hold the data\nsaved. For example, the gcc compiler reserves 4 bytes to store a variable of type\nwchar_t while other compilers reserve only 2 bytes. \nSo it's possible that a value could be written that couldn't be represented by the loading program. This is a\nfairly obvious situation and easily handled by using the numeric types in\n<boost/cstdint.hpp>\n

    \nA special integral type is std::size_t which is a typedef\nof an integral types guaranteed to be large enough\nto hold the size of any collection, but its actual size can differ depending\non the platform. The \ncollection_size_type\nwrapper exists to enable a portable serialization of collection sizes by an archive.\nRecommended choices for a portable serialization of collection sizes are to \nuse either 64-bit or variable length integer representation.\n\n\n

    Traits

    \nAnother potential problem is illustrated by the following example:\n
    \ntemplate<class T>\nstruct my_wrapper {\n    template<class Archive>\n    Archive & serialize ...\n};\n\n...\n\nclass my_class {\n    wchar_t a;\n    short unsigned b;\n    template<class Archive>\n    Archive & serialize(Archive & ar, unsigned int version){\n        ar & my_wrapper(a);\n        ar & my_wrapper(b);\n    }\n};\n
    \nIf my_wrapper uses default serialization\ntraits there could be a problem. With the default traits, each time a new type is\nadded to the archive, bookkeeping information is added. So in this example, the\narchive would include such bookkeeping information for \nmy_wrapper<wchar_t> and for\nmy_wrapper<short_unsigned>.\nOr would it? What about compilers that treat \nwchar_t as a\nsynonym for unsigned short?\nIn this case there is only one distinct type - not two. If archives are passed between\nprograms with compilers that differ in their treatment \nof wchar_t the load operation will fail\nin a catastrophic way.\n

    \nOne remedy for this is to assign serialization traits to the template\nmy_template such that class\ninformation for instantiations of this template is never serialized. This \nprocess is described above and\nhas been used for Name-Value Pairs.\nWrappers would typically be assigned such traits.\n

    \nAnother way to avoid this problem is to assign serialization traits\nto all specializations of the template my_wrapper\nfor all primitive types so that class information is never saved. This is what has\nbeen done for our implementation of serializations for STL collections.\n\n

    Binary Archives

    \nStandard stream i/o on some systems will expand linefeed characters to carriage-return/linefeed \non output. This creates a problem for binary archives. The easiest way to handle this is to \nopen streams for binary archives in \"binary mode\" by using the flag \nios::binary. If this is not done, the archive generated\nwill be unreadable.\n

    \nUnfortunately, no way has been found to detect this error before loading the archive. Debug builds\nwill assert when this is detected so that may be helpful in catching this error.\n\n

    XML Archives

    \nXML archives present a somewhat special case. \nXML format has a nested structure that maps well to the \"recursive class member visitor\" pattern \nused by the serialization system. However, XML differs from other formats in that it \nrequires a name for each data member. Our goal is to add this information to the \nclass serialization specification while still permiting the the serialization code to be \nused with any archive. This is archived by requiring that all data serialized to an XML archive\nbe serialized as a name-value pair.\nThe first member is the name to be used as the XML tag for the\ndata item while the second is a reference to the data item itself. Any attempt to serialize data\nnot wrapped in a in a name-value pair will\nbe trapped at compile time. The system is implemented in such a way that for other archive classes,\njust the value portion of the data is serialized. The name portion is discarded during compilation.\nSo by always using name-value pairs, it will\nbe guaranteed that all data can be serialized to all archive classes with maximum efficiency.\n\n

    Exporting Class Serialization

    \nElsewhere in this manual, we have described \nBOOST_CLASS_EXPORT. \nExport implies two things:\n
      \n
    • Instantiates code which is not otherwise referred to.\n
    • Associates an external identifier with the class to be serialized.\nThe fact that the class isn't explicitly referred to implies this\nrequirement.\n
    \nIn C++, usage of code not explicitly referred to is implemented via\nvirtual functions. Hence, the need for export is implied by the \nusage of a derived class that is manipulated via a pointer or\nreference to its base class.\n\n

    \nBOOST_CLASS_EXPORT in the same\nsource module that includes any of the archive class headers will\ninstantiate code required to serialize polymorphic pointers of\nthe indicated type to the all those archive classes. If no\narchive class headers are included, then no code will be instantiated.\n\n

    \nNote that the implemenation of this functionality requires\nthat the BOOST_CLASS_EXPORT\nmacro appear after the inclusion of any archive\nclass headers for which code is to be instantiated.\nSo, code that uses BOOST_CLASS_EXPORT\nwill look like the following:\n

    \n#include <boost/archive/text_oarchive.hpp>\n#include <boost/archive/text_oarchive.hpp>\n... // other archives\n\n#include \"a.hpp\" // header declaration for class a\nBOOST_CLASS_EXPORT(a)\n... // other class headers and exports\n
    \nThis will be true regardless of whether the code is part\nof a stand alone executable, a static library or\na dynamic or shared library. \n

    \nIncluding\nBOOST_CLASS_EXPORT\nin the \"a.hpp\" header itself as one would do with\nother serialization traits will make it difficult\nor impossible to follow the rule above regarding\ninclusion of archive headers before\nBOOST_CLASS_EXPORT\nis invoked. This can best be addressed by using\nBOOST_CLASS_EXPORT_KEY\nin the header declarations and\nBOOST_CLASS_EXPORT_IMPLEMENT\nin the class definition file.\n\n

    \nThis system has certain implications for placing code in static or shared\nlibraries. Placing BOOST_CLASS_EXPORT\nin library code will have no effect unless archive class headers are\nalso included. So when building a library, one should include all headers\nfor all the archive classes which he anticipates using. Alternatively,\none can include headers for just the\nPolymorphic Archives.\n\n

    \nStrictly speaking, export should not be necessary if all pointer serialization\noccurs through the most derived class. However, in order to detect\nwhat would be a catastrophic error, the library traps ALL serializations through\na pointer to a polymorphic class which are not exported or otherwise registered.\nSo, in practice, be prepared to register or export all classes with one\nor more virtual functions which are serialized through a pointer. \n\n

    \nNote that the implementation of this functionality depends upon vendor\nspecific extensions to the C++ language. So, there is no guaranteed portability\nof programs which use this facility. However, all C++ compilers which\nare tested with boost provide the required extensions. The library\nincludes the extra declarations required by each of these compilers.\nIt's reasonable to expect that future C++ compilers will support\nthese extensions or something equivalent.\n\n

    Static Libraries and Serialization

    \nCode for serialization of data types can be saved in libraries\njust as it can for the rest of the type implementation.\nThis works well, and can save a huge amount of compilation time.\n
      \n
    • Only compile serialization definitions in the library.\n
    • Explicitly instantiate serialization code for ALL\narchive classes you intend to use in the library.\n
    • For exported types, only use BOOST_CLASS_EXPORT_KEY\nin headers.\n
    • For exported types, only use BOOST_CLASS_EXPORT_IMPLEMENT\nin definitions compiled in the library. For any particular type,\nthere should be only one file which contains\nBOOST_CLASS_EXPORT_IMPLEMENT\nfor that type. This ensures that only one copy\nof serialization code will exist within the program. It avoids\nwasted space and the possibility of having different\nversions of the serialization code in the same program.\nIncluding\nBOOST_CLASS_EXPORT_IMPLEMENT\nin multiple files could result in a failure\nto link due to duplicated symbols or the throwing\nof a runtime exception.\n
    • Code for serialization should be only in the library,\n
    • Familiarize yourself with the PIMPL idiom.\n
    \nThis is illustrated by\n\ndemo_pimpl.cpp\n,\n\ndemo_pimpl_A.cpp\n\nand\n\ndemo_pimpl_A.hpp\n\nwhere implementation of serialization is in a static library \ncompletely separate from the main program.\n\n

    DLLS - Serialization and Runtime Linking

    \nSerialization code can be placed in libraries to be linked at runtime. That is,\ncode can be placed in DLLS(Windows) Shared Libraries(*nix), or static libraries\nas well as the main executable. The best technique is the\nsame as that described above for libraries. The serialization\nlibrary test suite includes the following programs\nto illustrate how this works:\n

    \n\n\ntest_dll_simple\n,\nand\n\ndll_a.cpp\n\nwhere implementation of serialization is also completely separate\nfrom the main program but the code is loaded at runtime. In this\nexample, this code is loaded automatically when the program which\nuses it starts up, but it could just as well be loaded and unloaded \nwith an OS dependent API call.\n

    \nAlso included are\n\ntest_dll_exported.cpp\n,\nand\n\npolymorphic_derived2.cpp\n\nwhich are similar to the above but include tests of the export\nand no_rtti facilities in the context of DLLS.\n

    \nFor best results, write your code to conform to the following\nguidelines:\n

      \n
    • Don't include inline code in classes used in DLLS.\nThis will generate duplicate code in the DLLS and mainline. This\nneedlessly duplicates code. Worse, it makes is possible for \ndifferent versions of the same code to exist simultaneously. This\ntype of error turns out to be excruciatingly difficult to debug.\nFinally, it opens the possibility that a module being referred to\nmight be explicitly unloaded which would (hopefully) result in\na runtime error. This is another bug that is not always \nreproducible or easy to find. For class member templates use something like\n\n
      \ntemplate<class Archive>\nvoid serialize(Archive & ar, const unsigned int version);\n
      \nin the header, and\n\n
      \ntemplate<class Archive>\nvoid myclass::serialize(Archive & ar, const unsigned int version){\n\t...\n}\n\nBOOST_CLASS_EXPORT_IMPLEMENT(my_class)\n\n#include <boost/archive/text_oarchive>\n#include <boost/archive/text_iarchive>\ntemplate myclass::serialize(boost::archive::text_oarchive & ar, const unsigned int version);\ntemplate myclass::serialize(boost::archive::text_iarchive & ar, const unsigned int version);\n... // repeat for each archive class to be used.\n
      \nin the implementation file. This will result in generation of all code\nrequired in only one place. The library does not detect this type of error for you.\n
    • If DLLS are to be loaded and unloaded explicitly (e.g. using dlopen in *nix or \nLoadLibrary in Windows). Try to arrange that they are unloaded in the reverse\nsequence. This should guarantee that problems are avoided even if the\nabove guideline hasn't been followed.\n\n
    \n\n

    Plugins

    \nIn order to implement the library, various facilities for runtime\nmanipulation of types at runtime were required. These\nare extended_type_info\nfor associating classes with external identifying strings (GUID)\nand void_cast\nfor casting between pointers of related types.\n\nTo complete the functionality of \nextended_type_info\nthe ability to construct and destroy corresponding types has been\nadded. In order to use this functionality, one must specify\nhow each type is created. This should be done at the time\na class is exported. So, a more complete example of the code above would be:\n\n
    \n#include <boost/archive/text_oarchive.hpp>\n#include <boost/archive/text_oarchive.hpp>\n... // other archives\n\n#include \"a.hpp\" // header declaration for class a\n\n// this class has a default constructor\nBOOST_SERIALIZATION_FACTORY_0(a)\n// as well as one that takes one integer argument\nBOOST_SERIALIZATION_FACTORY_1(a, int)\n\n// specify the GUID for this class\nBOOST_CLASS_EXPORT(a)\n... // other class headers and exports\n
    \n\nWith this in place, one can construct, serialize and destroy a class\nabout which is known only the GUID and a base class.\n\n\n

    Multi-Threading

    \nThe fundamental purpose of serialization would conflict with multiple \nthreads concurrently writing/reading from/to a single open archive instance.\nThe library implementation presumes that the application avoids such a situation.\n

    \nHowever, Writing/Reading different archives simultaneously\nin different tasks is permitted as each archive instance is (almost) \ncompletely independent from any other archive instance. The only shared \ninformation is some type tables which have been implemented using a \nlock-free thread-safe \n\nsingleton\n\ndescribed elsewhere in this documentation.\n

    \nThis singleton implementation guarantees that all of this shared\ninformation is initialized when the code module which contains\nit is loaded. The serialization library takes care to\nensure that these data structures are not subsequently\nmodified. The only time there could be a problem would\nbe if code is loaded/unloaded while another task is\nserializing data. This could only occur for types whose \nserialization is implemented in a dynamically loaded/unloaded DLL\nor shared library. So if the following is avoided:\n

      \n
    • Accessing the same archive instance from different tasks.\n
    • Loading/Unloading DLLS or shared libraries while any archive\n instances are open.\n
    \nThe library should be thread safe.\n\n

    Optimizations

    \nIn performance critical applications that serialize large sets of contiguous data of homogeneous\ntypes one wants to avoid the overhead of serializing each element individually, which is\nthe motivation for the array\nwrapper.\n\nSerialization functions for data types containing contiguous arrays of homogeneous\ntypes, such as for std::vector, std::valarray or \nboost::multiarray should serialize them using an\narray wrapper to make use of \nthese optimizations.\n\nArchive types that can provide optimized serialization for contiguous arrays of \nhomogeneous types should implement these by overloading the serialization of\nthe array wrapper, as is done\nfor the binary archives.\n\n\n

    Archive Exceptions

    \n

    Exception Safety

    \n\n
    \n

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

    \n\n\n" }, { "path": "doc/state_saver.html", "content": "\n\n\n\n\n\n\nSerialization - <code style=\"white-space: normal\">state_saver</code>\n\n\n\n \n \n \n \n
    \n

    \"C++

    \n     		\n

    Serialization

    \n

    state_saver\n

    \n
    \n

    \nSometimes a certain value has to change only for a limited scope. \nThis class wrapper saves a copy of the current state of some object, \nand resets the object's state at destruction time, undoing any change the object \nmay have gone through. Here is the interface:\n\n

    \ntemplate<class T>\n// T requirements:\n//  - POD or object semantic (cannot be reference, function, ...)\n//  - copy constructor\n//  - operator = (no-throw one preferred)\nclass state_saver : private boost::noncopyable\n{\nprivate:\n    ... // implementation\n\npublic:\n    state_saver(T & object);\n    ~state_saver();\n};\n
    \n\nThe complete implementation can be found\nhere\n\nThe following illustrates how this is expected to be used.\n\n
    \n#include <boost/state_saver.hpp>\n\nvoid func(A & a)\n    boost::state_saver<A> s(a);\n    ... // alter state of a by calling non-const functions\n    ... // call other functions\n    // original state of a automatically restored on exit\n}\n
    \n\n

    History

    \nThis is a generalization of Daryle Walker's \nio_state_saver library.\n

    \nRobert Ramey made an initial version for the serialization library.\n

    \nPavel Vozenilek made several non-obvious refinements to make it more\nsecure and boost friendly\n\n

    \n

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

    \n\n\n" }, { "path": "doc/static_warning.html", "content": "\n\n\n\n\n\n\nSerialization - BOOST_STATIC_WARNING\n\n\n\n \n \n \n \n
    \n

    \"C++

    \n     		\n

    Serialization

    \n

    BOOST_STATIC_WARNING

    \n
    \n
    \n\nThe header <boost/serialization/static_warning.hpp> supplies a single macro \nBOOST_STATIC_WARNING(x), which generates a compile time warning message if \nthe integral-constant-expression x is not true. \n

    \nNote that if the condition is true, then the macro will generate neither \ncode nor data - and the macro can also be used at either namespace, \nclass or function scope. When used in a template, the expression x \nwill be evaluated at the time the template is instantiated; this is \nparticularly useful for validating template parameters. \n

    \nIt is intended that the functioning of BOOST_STATIC_WARNING(x)\nbe identical to that of BOOST_STATIC_ASSERT(x)\nexcept that rather than resulting in a compilation error, it will result in\na compiler warning. In all other respects it should be the same. So\nfor more information on using BOOST_STATIC_WARNING(x)\nconsult the documentation for BOOST_STATIC_ASSERT(x)\nhere.\n\n

    \n

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

    \n\n\n" }, { "path": "doc/strong_typedef.html", "content": "\n\n\n\n\n\n\nSerialization - BOOST_STATIC_WARNING\n\n\n\n \n \n \n \n
    \n

    \"C++

    \n     		\n

    Serialization

    \n

    BOOST_STRONG_TYPEDEF

    \n
    \n
    \n

    Motivation

    \ntypedef creates an alias for an existing type. It does not create\na new type that can be used for matching either function or template parameters.\nThis can be shown by trying to compile the following example.\n
    \ntypedef int a;\nvoid f(int x);  // (1) function to handle simple integers\nvoid f(a x);    // (2) special function to handle integers of type a \nint main(){\n    int x = 1;\n    a y;\n    y = x;      // other operations permitted as a is converted as necessary\n    f(x);       // chooses (1)\n    f(y);       // chooses (2)\n}\n
    \nSince typedef doesn't create a new type, this program can't compile to code\nthat implements its obvious intention. \n

    \nUsage of BOOST_STRONG_TYPEDEF\naddresses this.\n

    \n\n#include <boost/serialization/strong_typedef.hpp>\n\n\nBOOST_STRONG_TYPEDEF(int, a)\nvoid f(int x);  // (1) function to handle simple integers\nvoid f(a x);    // (2) special function to handle integers of type a \nint main(){\n    int x = 1;\n    a y;\n    y = x;      // other operations permitted as a is converted as necessary\n    f(x);       // chooses (1)\n    f(y);       // chooses (2)\n}\n
    \nThe program will now compile and run as expected.\n\n

    Usage

    \nSyntax of BOOST_STRONG_TYPEDEF\nhas been designed to be similar to the standard\ntypedef. So\n\n
    \nBOOST_STRONG_TYPEDEF(primitive type, name)\n
    \n\nwill create a new type \"name\" which will be substitutable for the original\ntype but still of distinct type.\n\n

    Implemenation

    \nBOOST_STRONG_TYPEDEF is a macro\nwhich generates a class named \"name\" which wraps an instance of its\nprimitive type and provides appropriate conversion operators in order\nto make the new type substitutable for the one that it wraps.\n\n
    \n

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

    \n\n\n" }, { "path": "doc/style.css", "content": "pre{\n BORDER-RIGHT: gray 1pt solid;\n BORDER-TOP: gray 1pt solid;\n BORDER-LEFT: gray 1pt solid;\n BORDER-BOTTOM: gray 1pt solid;\n MARGIN-LEFT: 0pt;\n background-color: #EEEEEE;\n}\n\n/*\n(C) Copyright 2008 Robert Ramey - http://www.rrsd.com . \nUse, modification and distribution is subject to the Boost Software\nLicense, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at\nhttp://www.boost.org/LICENSE_1_0.txt)\n*/" }, { "path": "doc/todo.html", "content": "\n\n\n\n\n\n\nSerialization - To Do\n\n\n\n \n \n \n \n
    \n

    \"C++

    \n     		\n

    Serialization

    \n

    To Do

    \n
    \n
    \n
    \n
    Portable Binary Archives
    \n
    Performance Testing and Profiling
    \n
    Back Versioning
    \n
    Testing for Environments with No RTTI
    \n
    Additional Case Studies
    \n
    \n\nThese are enhancements that the serialization library needs but have not been done.\nSome of these projects, though tricky, are not huge and would be suitable\nfor someone who has a limited time to spend on them. In particular, they\nmight be of interest as student projects such as the Google Summer of Code.\n\n

    Portable Binary Archives

    \nCurrently there is a portable binary archive in the examples directory.\nIt is not regularly submitted to the exhaustive boost testing regimen\nbut it is tested occasionally and has been used in production code.\n

    \nIt's missing the following:\n

      \n
    • Addition of portable floating point types. This is not trivial. In addition to\n handling floating point types of varying sizes, It requires\n handling invalid floating point numbers (NaNs) in a portable manner.\n
    • Integration into the Boost testing regimen similar to the other archive classes.\n
    \n\n

    Performance Testing and Profiling

    \n\nI've managed to setup performance profiling using the following:\n
      \n
    • current (as I write this) Boost.Build tools.\n
    • the gcc compiler.\n
    • and a shell script - profile.sh\n
    • library_status program from the tools/regression/src directory\n
    \nInvoking profile script produces a \ntable\nwhich shows the results of each test and links to the actual\nprofile.\n

    \nThe first thing I did was include some of the serialization library tests.\nIt became immediately apparent that these tests were totally unsuitable\nfor performance testing and that new tests needed to be written for this \npurpose. These tests would highlight the location of any performance\nbottlenecks in the serialization library. Whenever I've subjected my\ncode in the past to this type of analysis, I've always been surprised\nto find bottlenecks in totally unanticipated places and fixing those\nhas always led to large improvements in performance. I expect that\nthis project would have a huge impact on the utility of the serialization\nlibrary.\n\n

    Back Versioning

    \n\nIt has been suggested that a useful feature of the library would be\nthe ability to create \"older versions\" of archives. Currently,\nthe library permits one to make programs that are guaranteed\nthe ability to load archives with classes of a previous version. \nBut there is no way to save classes in accordance with a\nprevious version. At first I dismissed this as a huge project\nwith small demand. A cursory examination of the code revealed\nthat this would not be very difficult. It would require some\nsmall changes in code and some additional tests. Also it\nwould require special treatment in the documentation - perhaps\na case study.\n\n\n

    Environments without RTTI

    \n\nI note that some have commented that this library requires RTTI.\nThis is not strictly true. The examples and almost all the\ntests presume the existence of RTTI. But it should be possible\nto use the library without it. The example used for testing is an \nextended_typeinfo \nimplemenation which presumes that all classes names have been exported. \nSo, to make this library compatible for platforms without RTTI, \na set of tests, examples and new manual section would have to be created.\n\n
    \n

    Revised 1 November, 2008 \n

    © Copyright Robert Ramey 2002-2008. \nDistributed under the Boost Software License, Version 1.0. (See\naccompanying file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)\n

    \n\n\n" }, { "path": "doc/traits.html", "content": "\n\n\n\n\n\n\nSerialization - Class Serialization Traits\n\n\n\n \n \n \n \n
    \n

    \"C++

    \n     		\n

    Serialization

    \n

    Class Serialization Traits

    \n
    \n
    \n
    \n
    Version\n
    Implementation Level\n
    Object Tracking\n
    Export Key\n
    Abstract\n
    Type Information Implementation\n
    Wrappers\n
    Bitwise Serialization\n
    Template Serialization Traits\n
    Compile Time Warnings and Errors\n
    \nSerialization of data depends on the type of the data. For example, for\nprimitive types such as int, it wouldn't make sense to save\na version number in the archive. Likewise, for a data type that is never\nserialized through a pointer, it would (almost) never make sense to track\nthe address of objects saved to/loaded from the archive as it will never\nbe saved/loaded more than once in any case. Details of\nserialization for a particular data type will vary depending on the\ntype, the way it is used and specifications of the programmer. \n

    \nOne can alter the manner in which a particular data type is serialized\nby specifying one or more class serialization traits.\nIt is not generally necessary for the programmer to explicitly assign\ntraits to his classes as there are default values for all traits.\nIf the default values are not appropriate they can be assigned by the programmer.\nA template is used to associate a typename with a constant. For example\nsee \nversion.hpp. \n

    Version

    \nThis header file includes the following code:\n\n
    \nnamespace boost { \nnamespace serialization {\ntemplate<class T>\nstruct version\n{\n    BOOST_STATIC_CONSTANT(unsigned int, value = 0);\n};\n} // namespace serialization\n} // namespace boost\n
    \n\nFor any class T, The default definition \nof boost::serialization::version<T>::value is 0. \nIf we want to assign a value of 2 as the version for class my_class\nwe specialize the version template:\n
    \nnamespace boost { \nnamespace serialization {\nstruct version<my_class>\n{\n    BOOST_STATIC_CONSTANT(unsigned int, value = 2);\n};\n} // namespace serialization\n} // namespace boost\n
    \nNow whenever the version number for class my_class is required,\nthe value 2 will be returned rather than the default value of 0.\n

    \nTo diminish typing and enhance readability, a macro is defined\nso that instead of the above, we could write:\n

    \nBOOST_CLASS_VERSION(my_class, 2)\n
    \nwhich expands to the code above.\n\n

    Implementation Level

    \nIn the same manner as the above, the \"level\" of implementation of serialization is\nspecified. The header file level.hpp defines the following.\n
    \n// names for each level\nenum level_type\n{\n    // Don't serialize this type. An attempt to do so should\n    // invoke a compile time assertion.\n    not_serializable = 0,\n    // write/read this type directly to the archive. In this case\n    // serialization code won't be called.  This is the default\n    // case for fundamental types.  It presumes a member function or\n    // template in the archive class that can handle this type.\n    // there is no runtime overhead associated reading/writing\n    // instances of this level\n    primitive_type = 1,\n    // Serialize the objects of this type using the objects \"serialize\"\n    // function or template. This permits values to be written/read\n    // to/from archives but includes no class or version information. \n    object_serializable = 2,\n    ///////////////////////////////////////////////////////////////////\n    // once an object is serialized at one of the above levels, the\n    // corresponding archives cannot be read if the implementation level\n    // for the archive object is changed.  \n    ///////////////////////////////////////////////////////////////////\n    // Add class information to the archive.  Class information includes\n    // implementation level, class version and class name if available.\n    object_class_info = 3,\n};\n
    \nUsing a macro defined in level.hpp we can specify\nthat my_class should be serialized along with its version number:\n
    \nBOOST_CLASS_IMPLEMENTATION(my_class, boost::serialization::object_class_info)\n
    \nIf implementation level is not explicitly assigned, the system uses\na default according to the following rules.\n
      \n
    • if the data type is volatile \nassign not_serializable\n
    • else if it's an enum or fundamental type assign primitive_type\n
    • else assign object_class_info\n
    \nThat is, for most user defined types, objects will be serialized along with\nclass version information. This will permit one to maintain backward\ncompatibility with archives which contain previous versions. However, with this \nability comes a small runtime cost. For types whose definition will \"never\" \nchange, efficiency can be gained by specifying object_serializable \nto override the default setting of object_class_info. \nFor example, \nthis has been done for the \n\nbinary_object wrapper\n\n

    Object Tracking

    \nDepending on the way a type is used, it may be necessary or convenient to\ntrack the address of objects saved and loaded. For example, this is generally\nnecessary while serializing objects through a pointer in order to be sure\nthat multiple identical objects are not created when an archive is loaded.\nThis \"tracking behavior\" is controlled by the type trait defined in the header\nfile tracking.hpp\nwhich defines the following:\n
    \n// names for each tracking level\nenum tracking_type\n{\n    // never track this type\n    track_never = 0,\n    // track objects of this type if the object is serialized through a \n    // pointer.\n    track_selectively = 1,\n    // always track this type\n    track_always = 2\n};\n
    \nA corresponding macro is defined so that we can use:\n
    \nBOOST_CLASS_TRACKING(my_class, boost::serialization::track_never)\n
    \nDefault tracking traits are:\n
      \n
    • For primitive, track_never.\n
    • For pointers, track_never.\n That is, addresses of addresses are not tracked by default.\n
    • All current serialization wrappers such as boost::serialization::nvp,\n track_never.\n
    • For all other types, track_selectively.\n That is addresses of serialized objects are tracked if and only if\n one or more of the following is true:\n
        \n
      • an object of this type is anywhere in the program serialized\n through a pointer.\n
      • the class is explicitly \"exported\" - see below.\n
      • the class is explicitly \"registered\" in the archive\n
      \n
    \n\n

    \nThe default behavior is almost always the most convenient one. However,\nthere a few cases where it would be desirable to override the\ndefault. One case is that of a virtual base class. In a diamond\ninheritance structure with a virtual base class, object tracking\nwill prevent redundant save/load invocations. So here is one\ncase where it might be convenient to override the default tracking\ntrait. (Note: in a future version the default will be reimplemented\nto automatically track classes used as virtual bases). This \nsituation is demonstrated by \ntest_diamond.cpp\nincluded with the library.\n\n

    Export Key

    \n\nWhen serializing a derived class through a virtual base class pointer,\ntwo issues may arise.\n
      \n
    • The code in the derived class might never be explicitly\nreferred to. Such code will never be instantiated.\n

      \nThis is addressed by invoking \nBOOST_CLASS_EXPORT_IMPLEMENT(T)\nin the file which defines (implements) the class T.\nThis ensures that code for the derived class T will\nbe explicitly instantiated.\n

    • There needs to be some sort of identifier which can\nbe used to select the code to be invoked when the object\nis loaded.\nStandard C++ does implement typeid() which can be\nused to return a unique string for the class. This is not entirely\nsatisfactory for our purposes for the following reasons:\n
        \n
      • There is no guarantee that the string is the same across platforms.\n This would then fail to support portable archives.\n
      • In using code modules from various sources, classes may have\n to be wrapped in different namespaces in different programs.\n
      • There might be classes locally defined in different code modules\n that have the same name. \n
      • There might be classes with different names that we want to\n consider equivalent for purposes of serialization.\n
      \n

      \nSo in the serialization library, this is addressed by invoking\nBOOST_CLASS_EXPORT_KEY2(my_class, \"my_class_external_identifier\")\nin the header file which declares the class.\nIn a large majority of applications, the class name works just fine\nfor the external identifier string so the following short cut is\ndefined -\nBOOST_CLASS_EXPORT_KEY(my_class).\n

    \nFor programs which consist of only one module - that is \nprograms which do not use DLLS, one can specify\nBOOST_CLASS_EXPORT(my_class)\nor\nBOOST_CLASS_EXPORT_GUID(my_class, \"my_class_external_identifier\")\nin either the declaration header or definition. These macros\nexpand to invocation of both of the macros described above.\n(GUID stands for Globally Unique IDentifier.)\n

    \n(Elsewhere\nin this manual, the serialization of derived classes is addressed in detail.)\n

    \nThe header file\nexport.hpp\ncontains all macro definitions described here.\nThe library will throw a runtime exception if\n

      \n
    • A type not explicitly referred to is not exported.\n
    • Serialization code for the same type is instantiated\nin more than one module (or DLL).\n
    \n\n

    Abstract

    \nWhen serializing an object through a pointer to its base class,\nthe library needs to determine whether or not the base is abstract\n(i.e. has at least one virtual function). The library uses the\ntype trait macro BOOST_IS_ABSTRACT(T)\nto do this. Not all compilers support this type trait and corresponding\nmacro. To address this, the macro \nBOOST_SERIALIZATION_ASSUME_ABSTRACT(T) has been\nimplemented to permit one to explicitly indicate that a specified\ntype is in fact abstract. This will guarentee that\nBOOST_IS_ABSTRACT\nwill return the correct value for all compilers.\n\n

    Type Information Implementation

    \nThis last trait is also related to the serialization of objects\nthrough a base class pointer. The implementation of this facility\nrequires the ability to determine at run time the true type of the\nobject that a base class pointer points to. Different serialization\nsystems do this in different ways. In our system, the default method\nis to use the function typeid(...) which is available \nin systems which support RTTI (Run Time \nType Information).\nThis will be satisfactory in almost all cases and most users of this \nlibrary will lose nothing in skipping this section of the manual.\n

    \nHowever, there are some cases where the default type determination\nsystem is not convenient. Some platforms might not support\nRTTI or it may have been disabled in order to speed execution\nor for some other reason. Some applications, E.G. runtime linking\nof plug-in modules, can't depend on C++ RTTI to determine the\ntrue derived class. RTTI only returns the correct type for polymorphic\nclasses - classes with at least one virtual function. If any of these\nsituations applies, one may substitute his own implementation of\nextended_type_info\n

    \nThe interface to facilities required to implement serialization is defined in\nextended_type_info.hpp.\n\nDefault implementation of these facilities based on typeid(...)\nis defined in\n\nextended_type_info_typeid.hpp.\n\nAn alternative implementation based on exported class identifiers\nis defined in\nextended_type_info_no_rtti.hpp.\n

    \nBy invoking the macro:\n

    \nBOOST_CLASS_TYPE_INFO(\n    my_class, \n    extended_type_info_no_rtti<my_class>\n)\n
    \nwe can assign the type information implementation to each class on a case by\ncase basis. There is no requirement that all classes in a program use the same \nimplementation of extended_type_info. This supports the concept\nthat serialization of each class is specified \"once and for all\" in a header\nfile that can be included in any project without change.\n

    \nThis is illustrated by the test program\ntest_no_rtti.cpp.\nOther implementations are possible and might be necessary for\ncertain special cases.\n\n

    Wrappers

    \nArchives need to treat wrappers differently from other types since, for example,\nthey usually are non-const objects while output archives require that any\nserialized object (with the exception of a wrapper) be const. \n\nThis header file wrapper.hpp\nincludes the following code:\n\n
    \nnamespace boost { \nnamespace serialization {\ntemplate<class T>\nstruct is_wrapper\n : public mpl::false_\n{};\n} // namespace serialization\n} // namespace boost\n
    \n\nFor any class T, The default definition \nof boost::serialization::is_wrapper<T>::value is thus false.\n \nIf we want to declare that a class my_class\nis a wrapper we specialize the version template:\n
    \nnamespace boost { \nnamespace serialization {\nstruct is_wrapper<my_class>\n : mpl::true_\n{};\n} // namespace serialization\n} // namespace boost\n
    \n

    \nTo diminish typing and enhance readability, a macro is defined\nso that instead of the above, we could write:\n

    \nBOOST_CLASS_IS_WRAPPER(my_class)\n
    \nwhich expands to the code above.\n\n

    Bitwise Serialization

    \nSome simple classes could be serialized just by directly copying all bits\nof the class. This is, in particular, the case for POD data types containing\nno pointer members, and which are neither versioned nor tracked. Some archives, \nsuch as non-portable binary archives can make us of this information to \nsubstantially speed up serialization.\n\nTo indicate the possibility of bitwise serialization the type trait defined \nin the header\nfile is_bitwise_serializable.hpp\nis used:\n
    \nnamespace boost { namespace serialization {\n    template<class T>\n    struct is_bitwise_serializable\n     : public is_arithmetic<T>\n    {};\n} }\n
    \nis used, and can be specialized for other classes. The specialization\nis made easy by the corresponding macro:\n
    \nBOOST_IS_BITWISE_SERIALIZABLE(my_class)\n
    \n\n

    Template Serialization Traits

    \nIn some instances it might be convenient to assign serialization traits\nto a whole group of classes at once. Consider, the name-value pair\nwrapper \n
    \ntemplate<class T>\nstruct nvp : public std::pair<const char *, T *>\n{\n    ...\n};\n
    \nused by XML archives to associate a name with a data variable of type T.\nThese data types are never tracked and never versioned. So one might\nwant to specify:\n
    \nBOOST_CLASS_IMPLEMENTATION(nvp<T>, boost::serialization::level_type::object_serializable)\nBOOST_CLASS_TRACKING(nvp<T>, boost::serialization::track_never)\n
    \nExamination of the definition of these macros reveals that they won't expand\nto sensible code when used with a template argument. So rather than using the\nconvenience macros, use the original definitions\n
    \ntemplate<class T>\nstruct implementation_level<nvp<T> >\n{\n    typedef mpl::integral_c_tag tag;\n    typedef mpl::int_<object_serializable> type;\n    BOOST_STATIC_CONSTANT(\n        int,\n        value = implementation_level::type::value\n    );\n};\n\n// nvp objects are generally created on the stack and are never tracked\ntemplate<class T>\nstruct tracking_level<nvp<T> >\n{\n    typedef mpl::integral_c_tag tag;\n    typedef mpl::int_<track_never> type;\n    BOOST_STATIC_CONSTANT(\n        int, \n        value = tracking_level::type::value\n    );\n};\n
    \nto assign serialization traits to all classes generated by the template\nnvp<T>\n

    \n\nNote that it is only possible to use the above method to assign traits to \ntemplates when using compilers which correctly support Partial Template Specialization.\n\nOne's first impulse might be to do something like:\n\n

    \n#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION\ntemplate<class T>\nstruct implementation_level<nvp<T> >\n{\n   ... // see above\n};\n\n// nvp objects are generally created on the stack and are never tracked\ntemplate<class T>\nstruct tracking_level<nvp<T> >\n{\n   ... // see above\n};\n#endif\n
    \nThis can be problematic when one wants to make his code and archives\nportable to other platforms. It means the objects will be serialized differently\ndepending on the platform used. This implies that objects saved from one platform\nwon't be loaded properly on another. In other words, archives won't be portable.\n

    \nThis problem is addressed by creating another method of assigning serialization traits\nto user classes. This is illustrated by the serialization for a \nname-value pair.\n

    \nSpecifically, this entails deriving the template from a special class\n\nboost::serialization::traits which is specialized for a specific\ncombination of serialization traits. \nWhen looking up the serialization traits, the library first checks to see if this class has been\nused as a base class. If so, the corresponding traits are used. Otherwise, the standard defaults\nare used. By deriving from a serialization traits class rather than relying upon Partial Template\nSpecializaton, one can a apply serialization traits to a template and those traits will be\nthe same across all known platforms.\n

    \nThe signature for the traits template is:\n

    \ntemplate<\n    class T,       \n    int Level, \n    int Tracking,\n    unsigned int Version = 0,\n    class ETII = BOOST_SERIALIZATION_DEFAULT_TYPE_INFO(T),\n    class IsWrapper = mpl::false_\n>\nstruct traits\n
    \nand template parameters should be assigned according to the following table:\n

    \n\n\n \n \n\n\n\n\n
    parameterdescriptionpermitted valuesdefault value
    Ttarget classclass namenone
    Levelimplementation levelnot_serializable
    primitive_type
    object_serializable
    object_class_info    		none
    Trackingtracking leveltrack_never
    track_selectivly
    track_always    		none
    Versionclass versionunsigned integer0
    ETTItype_info implementationextended_type_info_typeid
    extended_type_info_no_rtti    		default type_info implementation
    IsWrapperis the type a wrapper?mpl::false_
    mpl::true_    		mpl::false_
    \n\n

    Compile Time Warnings and Errors

    \nSome serialization traits can conflict with other ones. Sometimes these conflicts\nwill result in erroneous behavior (E.G. creating of archives which could not be read)\nand other times they represent a probable misconception on the part of the\nlibrary user which could result in surprising behavior. To the extent possible,\nthese conflicts are detected at compile time and errors (BOOST_STATIC_ASSERT) \nor warnings (BOOST_STATIC_WARNING) are generated. They are generated in a\ncompiler dependent manner which should show a chain of instantiation\nto the point where the error/warning is detected. Without this capability,\nit would be very hard to track down errors or unexpected behavior in library\nusage. Here is a list of the conflicts trapped:\n\n
    \n

    object_level - error

    \n
    \nThis error traps attempts to serialize types whose\nimplementation level is set to non_serializable.\n
    \n

    object_versioning - error

    \n
    \nIt's possible that for efficiency reasons, a type can be\nassigned a serialization level which doesn't include type information \nin the archive. This would preclude the assignment\nof a new version number to the type. This error\ntraps attempts to assign a version number in this case.\nThis has to be a user error.\n
    \n\n

    object_tracking - warning

    \n
    \nThe following code will display a message when compiled:\n\n
    \nT t;\nar << t;\n
    \n\nunless the tracking_level serialization trait is set to \"track_never\". The following\nwill compile without problem:\n\n
    \nconst T t\nar << t;\n
    \n\nLikewise, the following code will trap at compile time:\n\n
    \nT * t;\nar >> t;\n
    \n\nif the tracking_level serialization trait is set to \"track_never\".\n

    \n\nThe following case illustrates the function of this message.\nIt was originally used as an example in the\nmailing list by Peter Dimov.\n\n

    \nclass construct_from \n{ \n    ... \n}; \n\nvoid main(){ \n    ... \n    Y y; \n    construct_from x(y); \n    ar << x; \n} \n
    \n\nSuppose that the above message is not displayed and the code is used as is.\n
      \n
    1. this example compiles and executes fine. No tracking is done because \n construct_from has never been serialized through a pointer. Now some time \n later, the next programmer(2) comes along and makes an enhancement. He \n wants the archive to be sort of a log. \n\n
      \nvoid main(){ \n    ... \n    Y y; \n    construct_from x(y); \n    ar << x; \n    ... \n    x.f(); // change x in some way \n   ... \n    ar << x \n} \n
      \n

      \n Again no problem. He gets two different of copies in the archive, each one is different. \n That is he gets exactly what he expects and is naturally delighted. \n

      \n

    2. Now sometime later, a third programmer(3) sees construct_from and says - \n oh cool, just what I need. He writes a function in a totally disjoint \n module. (The project is so big, he doesn't even realize the existence of \n the original usage) and writes something like: \n\n
      \nclass K { \n    shared_ptr <construct_from> z; \n    template <class Archive> \n    void serialize(Archive & ar, const unsigned version){ \n        ar << z; \n    } \n}; \n
      \n\n

      \n He builds and runs the program and tests his new functionality. It works \n great and he's delighted. \n

      \n

    3. Things continue smoothly as before. A month goes by and it's \n discovered that when loading the archives made in the last month (reading the \n log). Things don't work. The second log entry is always the same as the \n first. After a series of very long and increasingly acrimonious email exchanges, \nit's discovered \n that programmer(3) accidentally broke programmer(2)'s code .This is because by \n serializing via a pointer, the \"log\" object is now being tracked. This is because\n the default tracking behavior is \"track_selectively\". This means that class\n instances are tracked only if they are serialized through pointers anywhere in\n the program. Now multiple saves from the same address result in only the first one \n being written to the archive. Subsequent saves only add the address - even though the \n data might have been changed. When it comes time to load the data, all instances of the log record show the same data.\n In this way, the behavior of a functioning piece of code is changed due the side\n effect of a change in an otherwise disjoint module.\n Worse yet, the data has been lost and cannot be recovered from the archives.\n People are really upset and disappointed with boost (at least the serialization system).\n

      \n

    4. \n After a lot of investigation, it's discovered what the source of the problem is\n and class construct_from is marked \"track_never\" by including:\n
      \nBOOST_CLASS_TRACKING(construct_from, track_never) \n
      \n
    5. Now everything works again. Or - so it seems.\n

      \n

    6. shared_ptr<construct_from>\nis not going to have a single raw pointer shared amongst the instances. Each loaded \nshared_ptr<construct_from> is going to \nhave its own distinct raw pointer. This will break \nshared_ptr and cause a memory leak. Again,\nThe cause of this problem is very far removed from the point of discovery. It could \nwell be that the problem is not even discovered until after the archives are loaded.\nNow we not only have a difficult to find and fix program bug, but we have a bunch of\ninvalid archives and lost data.\n
    \n\n

    Now consider what happens when the message is displayed:\n\n

      \n

      \n

    1. Right away, the program traps at \n
      \nar << x; \n
      \n

      \n

    2. The programmer curses (another %^&*&* hoop to jump through). He's in a \n hurry (and who isn't) and would prefer not to const_cast\n - because it looks bad. So he'll just make the following change an move on. \n
      \nY y; \nconst construct_from x(y); \nar << x; \n
      \n

      \n Things work fine and he moves on. \n

      \n

    3. Now programmer (2) wants to make his change - and again another \n annoying const issue; \n
      \nY y; \nconst construct_from x(y); \n... \nx.f(); // change x in some way ; compile error f() is not const \n... \nar << x \n
      \n

      \n He's mildly annoyed now he tries the following: \n

        \n
      • He considers making f() a const - but presumably that shifts the const \n error to somewhere else. And he doesn't want to fiddle with \"his\" code to \n work around a quirk in the serializaition system \n

        \n

      • He removes the const\n from const construct_from above - damn now he \n gets the trap. If he looks at the comment code where the \n BOOST_STATIC_ASSERT\n occurs, he'll do one of two things \n
          \n

          \n

        1. This is just crazy. Its making my life needlessly difficult and flagging \n code that is just fine. So I'll fix this with a const_cast\n and fire off a complaint to the list and maybe they will fix it. \n In this case, the story branches off to the previous scenario.\n

          \n

        2. Oh, this trap is suggesting that the default serialization isn't really \n what I want. Of course in this particular program it doesn't matter. But \n then the code in the trap can't really evaluate code in other modules (which \n might not even be written yet). OK, I'll add the following to my \n construct_from.hpp to solve the problem. \n
          \nBOOST_CLASS_TRACKING(construct_from, track_never) \n
          \n
        \n
      \n

      \n

    4. Now programmer (3) comes along and make his change. The behavior of the \n original (and distant module) remains unchanged because the \n construct_from trait has been set to \n \"track_never\" so he should always get copies and the log should be what we expect.\n

      \n

    5. But now he gets another trap - trying to save an object of a \n class marked \"track_never\" through a pointer. So he goes back to \n construct_from.hpp and comments out the \n BOOST_CLASS_TRACKING that \n was inserted. Now the second trap is avoided, But damn - the first trap is \n popping up again. Eventually, after some code restructuring, the differing\n requirements of serializating construct_from\n are reconciled.\n
    \nNote that in this second scenario\n
      \n
    • all errors are trapped at compile time.\n
    • no invalid archives are created.\n
    • no data is lost.\n
    • no runtime errors occur.\n
    \n\nIt's true that these messages may sometimes flag code that is currently correct and\nthat this may be annoying to some programmers. However, this example illustrates\nmy view that these messages are useful and that any such annoyance is a small price to\npay to avoid particularly vexing programming errors.\n\n
    \n\n

    pointer_level - warning

    \n
    \nThis trap addresses the following situation when serializing \na pointer:\n
      \n
    • A type doesn't save class information in the\narchive. That is, the serialization trait implementation\nlevel <= object_serializable.\n
    • Tracking for this type is set to \"track selectively\"\nin this case, indication that an object is tracked is\nnot stored in the archive itself - see level == object_serializable.\nSince class information is not saved in the archive, the existence\nor absence of the operation ar << T * anywhere else in the \nprogram is used to infer that an object of this type should be tracked.\n

      \nA problem arises when a program which reads an archive\nincludes the operation ar >> T * so that tracking information\nwill be included in the archive. When a program which\ncreates the archive doesn't include ar << T it is presumed\nthat the archive doesn't include tracking information and\nthe archive will fail to load. Also the reverse situation could \ntrigger a similar problem.\n

      \nThough this situation is unlikely for several reasons, \nit is possible - hence this warning. \n

    \nSo if your program traps here, consider changing the \ntracking or implementation level traits - or not\nserializing via a pointer.\n
    \n\n

    pointer_tracking - warning

    \n
    \nSerializing an object of a type marked \"track_never\" through a pointer\ncould result in creating more objects than were saved! There are cases\nin which a user might really want to do this so we leave it as a warning.\n
    \n\n

    const_loading - error

    \n
    \nOne cannot load data into a \"const\" object unless it's a\nwrapper around some other non-const object.\n
    \n
    \n\n
    \n

    © Copyright Robert Ramey 2002-2004 and Matthias Troyer 2006. \nDistributed under the Boost Software License, Version 1.0. (See\naccompanying file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)\n

    \n\n\n" }, { "path": "doc/tutorial.html", "content": "\n\n\n\n\n\n\nSerialization - Tutorial\n\n\n\n \n \n \n \n
    \n

    \"C++

    \n     		\n

    Serialization

    \n

    Tutorial

    \n
    \n
    \n
    \n
    A Very Simple Case\n
    Non Intrusive Version\n
    Serializable Members\n
    Derived Classes\n
    Pointers\n
    Arrays\n
    STL Collections\n
    Class Versioning\n
    Splitting serialize into save/load\n
    Archives\n
    List of examples\n
    \nAn output archive is similar to an output data stream. Data can be saved to the archive\nwith either the << or the & operator:\n
    \nar << data;\nar & data;\n
    \nAn input archive is similar to an input datastream. Data can be loaded from the archive\nwith either the >> or the & operator.\n
    \nar >> data;\nar & data;\n
    \n

    \nWhen these operators are invoked for primitive data types, the data is simply saved/loaded\nto/from the archive. When invoked for class data types, the class\nserialize function is invoked. Each\nserialize function is uses the above operators\nto save/load its data members. This process will continue in a recursive manner until\nall the data contained in the class is saved/loaded.\n\n

    A Very Simple Case

    \nThese operators are used inside the serialize\nfunction to save and load class data members.\n

    \nIncluded in this library is a program called\ndemo.cpp which illustrates how\nto use this system. Below we excerpt code from this program to\nillustrate with the simplest possible case how this library is\nintended to be used.\n

    \n\n#include <fstream>\n\n// include headers that implement a archive in simple text format\n#include <boost/archive/text_oarchive.hpp>\n#include <boost/archive/text_iarchive.hpp>\n\n/////////////////////////////////////////////////////////////\n// gps coordinate\n//\n// illustrates serialization for a simple type\n//\nclass gps_position\n{\nprivate:\n    friend class boost::serialization::access;\n    // When the class Archive corresponds to an output archive, the\n    // & operator is defined similar to <<.  Likewise, when the class Archive\n    // is a type of input archive the & operator is defined similar to >>.\n    template<class Archive>\n    void serialize(Archive & ar, const unsigned int version)\n    {\n        ar & degrees;\n        ar & minutes;\n        ar & seconds;\n    }\n    int degrees;\n    int minutes;\n    float seconds;\npublic:\n    gps_position(){};\n    gps_position(int d, int m, float s) :\n        degrees(d), minutes(m), seconds(s)\n    {}\n};\n\nint main() {\n    // create and open a character archive for output\n    std::ofstream ofs(\"filename\");\n\n    // create class instance\n    const gps_position g(35, 59, 24.567f);\n\n    // save data to archive\n    {\n        boost::archive::text_oarchive oa(ofs);\n        // write class instance to archive\n        oa << g;\n    \t// archive and stream closed when destructors are called\n    }\n\n    // ... some time later restore the class instance to its orginal state\n    gps_position newg;\n    {\n        // create and open an archive for input\n        std::ifstream ifs(\"filename\");\n        boost::archive::text_iarchive ia(ifs);\n        // read class state from archive\n        ia >> newg;\n        // archive and stream closed when destructors are called\n    }\n    return 0;\n}\n\n
    \n

    For each class to be saved via serialization, there must exist a function to\nsave all the class members which define the state of the class.\nFor each class to be loaded via serialization, there must exist a function to\nload these class members in the same sequence as they were saved.\nIn the above example, these functions are generated by the\ntemplate member function serialize.\n\n

    Non Intrusive Version

    \n

    The above formulation is intrusive. That is, it requires\nthat classes whose instances are to be serialized be\naltered. This can be inconvenient in some cases.\nAn equivalent alternative formulation permitted by the\nsystem would be:\n

    \n#include <boost/archive/text_oarchive.hpp>\n#include <boost/archive/text_iarchive.hpp>\n\nclass gps_position\n{\npublic:\n    int degrees;\n    int minutes;\n    float seconds;\n    gps_position(){};\n    gps_position(int d, int m, float s) :\n        degrees(d), minutes(m), seconds(s)\n    {}\n};\n\nnamespace boost {\nnamespace serialization {\n\ntemplate<class Archive>\nvoid serialize(Archive & ar, gps_position & g, const unsigned int version)\n{\n    ar & g.degrees;\n    ar & g.minutes;\n    ar & g.seconds;\n}\n\n} // namespace serialization\n} // namespace boost\n
    \n

    \nIn this case the generated serialize functions are not members of the\ngps_position class. The two formulations function\nin exactly the same way.\n

    \nThe main application of non-intrusive serialization is to permit serialization\nto be implemented for classes without changing the class definition.\nIn order for this to be possible, the class must expose enough information\nto reconstruct the class state. In this example, we presumed that the\nclass had public members - not a common occurrence. Only\nclasses which expose enough information to save and restore the class\nstate will be serializable without changing the class definition.\n

    Serializable Members

    \n

    \nA serializable class with serializable members would look like this:\n

    \nclass bus_stop\n{\n    friend class boost::serialization::access;\n    template<class Archive>\n    void serialize(Archive & ar, const unsigned int version)\n    {\n        ar & latitude;\n        ar & longitude;\n    }\n    gps_position latitude;\n    gps_position longitude;\nprotected:\n    bus_stop(const gps_position & lat_, const gps_position & long_) :\n    latitude(lat_), longitude(long_)\n    {}\npublic:\n    bus_stop(){}\n    // See item # 14 in Effective C++ by Scott Meyers.\n    // re non-virtual destructors in base classes.\n    virtual ~bus_stop(){}\n};\n
    \n

    That is, members of class type are serialized just as\nmembers of primitive types are.\n

    \nNote that saving an instance of the class bus_stop\nwith one of the archive operators will invoke the\nserialize function which saves\nlatitude and\nlongitude. Each of these in turn will be saved by invoking\nserialize in the definition of\ngps_position. In this manner the whole\ndata structure is saved by the application of an archive operator to\njust its root item.\n\n\n

    Derived Classes

    \n

    Derived classes should include serializations of their base classes.\n

    \n#include <boost/serialization/base_object.hpp>\n\nclass bus_stop_corner : public bus_stop\n{\n    friend class boost::serialization::access;\n    template<class Archive>\n    void serialize(Archive & ar, const unsigned int version)\n    {\n        // serialize base class information\n        ar & boost::serialization::base_object<bus_stop>(*this);\n        ar & street1;\n        ar & street2;\n    }\n    std::string street1;\n    std::string street2;\n    virtual std::string description() const\n    {\n        return street1 + \" and \" + street2;\n    }\npublic:\n    bus_stop_corner(){}\n    bus_stop_corner(const gps_position & lat_, const gps_position & long_,\n        const std::string & s1_, const std::string & s2_\n    ) :\n        bus_stop(lat_, long_), street1(s1_), street2(s2_)\n    {}\n};\n\n
    \n

    \nNote the serialization of the base classes from the derived\nclass. Do NOT directly call the base class serialize\nfunctions. Doing so might seem to work but will bypass the code\nthat tracks instances written to storage to eliminate redundancies.\nIt will also bypass the writing of class version information into\nthe archive. For this reason, it is advisable to always make member\nserialize functions private. The declaration\nfriend boost::serialization::access will grant to the\nserialization library access to private member variables and functions.\n

    \n

    Pointers

    \nSuppose we define a bus route as an array of bus stops. Given that\n
      \n
    1. we might have several types of bus stops (remember bus_stop is\na base class)\n
    2. a given bus_stop might appear in more than one route.\n
    \nit's convenient to represent a bus route with an array of pointers\nto bus_stop.\n
    \n\nclass bus_route\n{\n    friend class boost::serialization::access;\n    bus_stop * stops[10];\n    template<class Archive>\n    void serialize(Archive & ar, const unsigned int version)\n    {\n        int i;\n        for(i = 0; i < 10; ++i)\n            ar & stops[i];\n    }\npublic:\n    bus_route(){}\n};\n\n
    \nEach member of the array stops will be serialized.\nBut remember each member is a pointer - so what can this really\nmean? The whole object of this serialization is to permit\nreconstruction of the original data structures at another place\nand time. In order to accomplish this with a pointer, it is\nnot sufficient to save the value of the pointer, rather the\nobject it points to must be saved. When the member is later\nloaded, a new object has to be created and a new pointer has\nto be loaded into the class member.\n

    \nIf the same pointer is serialized more than once, only one instance\nis be added to the archive. When read back, no data is read back in.\nThe only operation that occurs is for the second pointer is set equal to the first\n

    \nNote that, in this example, the array consists of polymorphic pointers.\nThat is, each array element point to one of several possible \nkinds of bus stops. So when the pointer is saved, some sort of class\nidentifier must be saved. When the pointer is loaded, the class\nidentifier must be read and and instance of the corresponding class\nmust be constructed. Finally the data can be loaded to newly created\ninstance of the correct type.\n\nAs can be seen in \ndemo.cpp,\nserialization of pointers to derived classes through a base\nclas pointer may require explicit enumeration of the derived\nclasses to be serialized. This is referred to as \"registration\" or \"export\"\nof derived classes. This requirement and the methods of\nsatisfying it are explained in detail\nhere.\n

    \nAll this is accomplished automatically by the serialization\nlibrary. The above code is all that is necessary to accomplish\nthe saving and loading of objects accessed through pointers.\n

    \n

    Arrays

    \nThe above formulation is in fact more complex than necessary.\nThe serialization library detects when the object being\nserialized is an array and emits code equivalent to the above.\nSo the above can be shortened to:\n
    \n\nclass bus_route\n{\n    friend class boost::serialization::access;\n    bus_stop * stops[10];\n    template<class Archive>\n    void serialize(Archive & ar, const unsigned int version)\n    {\n        ar & stops;\n    }\npublic:\n    bus_route(){}\n};\n\n
    \n

    STL Collections

    \nThe above example uses an array of members. More likely such\nan application would use an STL collection for such a purpose.\nThe serialization library contains code for serialization\nof all STL classes. Hence, the reformulation below will\nalso work as one would expect.\n
    \n\n#include <boost/serialization/list.hpp>\n\nclass bus_route\n{\n    friend class boost::serialization::access;\n    std::list<bus_stop *> stops;\n    template<class Archive>\n    void serialize(Archive & ar, const unsigned int version)\n    {\n        ar & stops;\n    }\npublic:\n    bus_route(){}\n};\n\n
    \n

    Class Versioning

    \n

    \nSuppose we're satisfied with our bus_route class, build a program\nthat uses it and ship the product. Some time later, it's decided\nthat the program needs enhancement and the bus_route class is\naltered to include the name of the driver of the route. So the\nnew version looks like:\n

    \n\n#include <boost/serialization/list.hpp>\n#include <boost/serialization/string.hpp>\n\nclass bus_route\n{\n    friend class boost::serialization::access;\n    std::list<bus_stop *> stops;\n    std::string driver_name;\n    template<class Archive>\n    void serialize(Archive & ar, const unsigned int version)\n    {\n        ar & driver_name;\n        ar & stops;\n    }\npublic:\n    bus_route(){}\n};\n\n
    \nGreat, we're all done. Except... what about people using our application\nwho now have a bunch of files created under the previous program.\nHow can these be used with our new program version?\n

    \nIn general, the serialization library stores a version number in the\narchive for each class serialized. By default this version number is 0.\nWhen the archive is loaded, the version number under which it was saved\nis read. The above code can be altered to exploit this\n

    \n\n#include <boost/serialization/list.hpp>\n#include <boost/serialization/string.hpp>\n#include <boost/serialization/version.hpp>\n\nclass bus_route\n{\n    friend class boost::serialization::access;\n    std::list<bus_stop *> stops;\n    std::string driver_name;\n    template<class Archive>\n    void serialize(Archive & ar, const unsigned int version)\n    {\n        // only save/load driver_name for newer archives\n        if(version > 0)\n            ar & driver_name;\n        ar & stops;\n    }\npublic:\n    bus_route(){}\n};\n\nBOOST_CLASS_VERSION(bus_route, 1)\n\n
    \nBy application of versioning to each class, there is no need to\ntry to maintain a versioning of files. That is, a file version\nis the combination of the versions of all its constituent classes.\n\nThis system permits programs to be always compatible with archives\ncreated by all previous versions of a program with no more\neffort than required by this example.\n\n

    Splitting serialize\ninto save/load

    \nThe serialize function is simple, concise, and guarantees\nthat class members are saved and loaded in the same sequence\n- the key to the serialization system. However, there are cases\nwhere the load and save operations are not as similar as the examples\nused here. For example, this could occur with a class that has evolved through\nmultiple versions. The above class can be reformulated as:\n
    \n\n#include <boost/serialization/list.hpp>\n#include <boost/serialization/string.hpp>\n#include <boost/serialization/version.hpp>\n#include <boost/serialization/split_member.hpp>\n\nclass bus_route\n{\n    friend class boost::serialization::access;\n    std::list<bus_stop *> stops;\n    std::string driver_name;\n    template<class Archive>\n    void save(Archive & ar, const unsigned int version) const\n    {\n        // note, version is always the latest when saving\n        ar  & driver_name;\n        ar  & stops;\n    }\n    template<class Archive>\n    void load(Archive & ar, const unsigned int version)\n    {\n        if(version > 0)\n            ar & driver_name;\n        ar  & stops;\n    }\n    BOOST_SERIALIZATION_SPLIT_MEMBER()\npublic:\n    bus_route(){}\n};\n\nBOOST_CLASS_VERSION(bus_route, 1)\n\n
    \nThe macro BOOST_SERIALIZATION_SPLIT_MEMBER() generates\ncode which invokes the save\nor load\ndepending on whether the archive is used for saving or loading.\n

    Archives

    \nOur discussion here has focused on adding serialization\ncapability to classes. The actual rendering of the data to be serialized\nis implemented in the archive class. Thus the stream of serialized\ndata is a product of the serialization of the class and the\narchive selected. It is a key design decision that these two\ncomponents be independent. This permits any serialization specification\nto be usable with any archive.\n

    \nIn this tutorial, we have used a particular\narchive class - text_oarchive for saving and\ntext_iarchive for loading.\ntext archives render data as text and are portable across platforms. In addition\nto text archives, the library includes archive class for native binary data\nand xml formatted data. Interfaces to all archive classes are all identical.\nOnce serialization has been defined for a class, that class can be serialized to \nany type of archive.\n

    \nIf the current set of archive classes doesn't provide the\nattributes, format, or behavior needed for a particular application,\none can either make a new archive class or derive from an existing one.\nThis is described later in the manual.\n\n

    List of Examples

    \n
    \n
    demo.cpp\n
    This is the completed example used in this tutorial.\n It does the following:\n
      \n
    1. Creates a structure of differing kinds of stops, routes and schedules\n
    2. Displays it\n
    3. Serializes it to a file named \"testfile.txt\" with one\n statement\n
    4. Restores to another structure\n
    5. Displays the restored structure\n
    \n Output of\n this program is sufficient to verify that all the\n originally stated requirements for a serialization system\n are met with this system. The contents of the archive file can\n also be displayed as serialization files are ASCII text.\n\n
    demo_xml.cpp\n
    This is a variation the original demo which supports xml archives in addition\n to the others. The extra wrapping macro, BOOST_SERIALIZATION_NVP(name), is \n needed to associate a data item name with the corresponding xml \n tag. It is important that 'name' be a valid xml tag, else it \n will be impossible to restore the archive. \n For more information see\n Name-Value Pairs.\n Here\n is what an xml archive looks like.\n\n
    demo_xml_save.cpp\n and demo_xml_load.cpp\n
    Note also that though our examples save and load the program data\n to an archive within the same program, this merely a convenience\n for purposes of illustration. In general, the archive may or may\n not be loaded by the same program that created it.\n
    \n

    \nThe astute reader might notice that these examples contain a subtle but important flaw.\nThey leak memory. The bus stops are created in the \nmain function. The bus schedules may refer to these bus stops\nany number of times. At the end of the main function after the bus schedules are destroyed,\nthe bus stops are destroyed. This seems fine. But what about the structure\nnew_schedule data item created by the\nprocess of loading from an archive? This contains its own separate set of bus stops\nthat are not referenced outside of the bus schedule. These won't be destroyed\nanywhere in the program - a memory leak.\n

    \nThere are couple of ways of fixing this. One way is to explicitly manage the bus stops.\nHowever, a more robust and transparent is to use \nshared_ptr rather than raw pointers. Along\nwith serialization implementations for the Standard Library, the serialization library\nincludes implementation of serialization for \nboost::shared ptr. Given this, it should be\neasy to alter any of these examples to eliminate the memory leak. This is left \nas an exercise for the reader.\n\n

    \n

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

    \n\n\n" }, { "path": "doc/void_cast.html", "content": "\n\n\n\n\n\n\nSerialization - BOOST_STATIC_WARNING\n\n\n\n \n \n \n \n
    \n

    \"C++

    \n     		\n

    Serialization

    \n

    void_cast

    \n
    \n
    \n

    Motivation

    \nC++ includes the operator dynamic_cast<T>(U * u)\nfor casting a pointer at runtime between two related types. However, this can only be \nused for polymorphic classes. That is, it can only be used with related classes which have at least one virtual function.\nLimiting the serialization of pointers to only such classes would diminish the applicability\nof the library.\n\n

    Usage

    \n\nThe following functions are defined in the header\nvoid_cast.hpp.\nThey are declared in the namespace\nboost::serialization.\n\n
    \n

    \ntemplate<class Derived, class Base>\nconst void_cast_detail::void_caster &\nvoid_cast_register(\n    Derived const * derived = NULL, \n    Base * const base = NULL\n);\n

    \n
    \nThis function \"registers\" a pair of related types. It stores the fact that\nDerived is immediately derived from \nBase in a global table. \n
      \n
    • This \"registration\" can be invoked anywhere in the program. The table is built at\n pre-runtime and is available anywhere else in the program.\n
    • only adjacent base/derived pairs need be registered. That is,\n 
      \n  void_cast_register<A, B>();\n  void_cast_register<B, C>();\n
      \n automatically derives the fact that A can be upcast to C and vice-versa.\n
    \n
    \n\n

    \nvoid *\nvoid_upcast(\n    extended_type_info const & derived_type,\n    extended_type_info const & base_type,\n    void * const t \n);\n

    \n\n

    \nvoid *\nvoid_downcast(\n    extended_type_info const & derived_type,\n    extended_type_info const & base_type,\n    void * const t \n);\n

    \n
    \nThese functions cast a void pointer from one type to another. The source and\ndefinition types are specified by passing references to the corresponding\n\nextended_type_info\nrecords. An attempt to cast between types not \"registered\" with\nvoid_cast_register \nwill throw a\nboost::archive::archive_exception\nwith value equal to\nunregistered_cast\n
    \n
    \n\n
    \n

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

    \n\n\n" }, { "path": "doc/wrappers.html", "content": "\n\n\n\n\n\n\nSerialization - Serialization Wrappers\n\n\n\n \n \n \n \n
    \n

    \"C++

    \n     		\n

    Serialization

    \n

    Serialization Wrappers

    \n
    \n
    \n
    \n
    Binary Objects\n
    Arrays\n
    BOOST_STRONG_TYPEDEF\n
    Collection Sizes\n
    Name-Value Pairs\n
    Composition\n
    \nSometimes it convenient to create a temporary object just to support serialization\nof some underlying data. This permits an archive class to define special\nhandling of this type. The library includes several such types for varying \npurposes.\n

    \nWrappers need to be treated in a special way by some archives, and hence\nthe is_wrapper trait for \nthese wrapper classes is set to true.\n\n

    Binary Objects

    \nA binary object is just a sequence of bytes stored as raw\nbinary data. This would most likely be used for a large amount\nof \"light weight\" data such as a pixel map or embedded binary file.\nThe header file \n\nbinary_object.hpp\n\nincludes the constructors:\n
    \nboost::serialization::binary_object(void * t, size_t size);\nboost::serialization::make_binary_object(void * t, size_t size);\n
    \nwhich will construct a temporary binary object that can be serialized just like any other object.\nIts default serialization is to use archive class primitives \nsave_binary and load_binary. \nNote that it doesn't allocated any storage or create any objects.\nIts sole purpose is to pass the data size and address as a pair to the archive class. \n\n\n

    Arrays

    \nAn array is a contiguous sequence of homogeneous data types, such as a builtin\nC-array, a boost::array<T> or a std::vector<T>. \nThe purpose of this wrapper is to support archive types (such as binary\narchives) that provide optimized serialization for contiguous sequences of \nobjects of the same type. \n\nThe header file \n\narray.hpp\n\nincludes the function\n
    \ntemplate <T>\nboost::serialization::make_array(T* t, std::size_t size);\n
    \nwhich will construct a temporary array object\n
    \ntemplate<class T>\nclass array\n{\npublic:    \n    typedef T value_type;\n    array(value_type* t, std::size_t s);\n    value_type* address() const;\n    std::size_t count() const;\n};\n
    \nthat can be serialized just like any other object.\nIts default serialization is to serialize each array element. \nNote that it doesn't allocated any storage or create any objects.\nIts sole purpose is to pass the data type, size and address to the archive class.\n\nArchive types that can provide optimized implementations for contiguous\narrays of homogeneous data types should overload the serialization of\narray.\n\n \n

    BOOST_STRONG_TYPEDEF

    \nAnother example of a serialization wrapper is the \nBOOST_STRONG_TYPEDEF template.\nThe serialization libraries uses these to pass particular kinds of integers such\nas object_id, version, etc. to an archive class. Given that these integers\nare now distinguishable according to their type, XML archives can apply\nspecial handling to these types. For example, a version number is rendered\nas an XML attribute in the form \"version=12\". In the absence of any specific override,\nthese types are automatically converted to the underlying integer type so the\nspecial overrides used for XML archives aren't needed for other archives.\n\n\n\n

    Collection Sizes

    \nAn example of a strong typedef is the collection_size_type in the\nheader file\n\ncollection_size_type.hpp\n. This type should be used for serializing the size of a C++ collection, so\nthat the archive can pick the best integral representation for the serialization\nof collection sizes. This is necessary since, although std::size_t\nis guaranteed to be an integral type large enough to represent the size of\na collection on a specific platform, the archive might want to serialize\nthe size differently than this type. For example, the collection_size_type\nmight be serialized as a variable length integer in a portable binary archive.\n\n\n\n\n\n\n

    Name-Value Pairs

    \nXML archives present a somewhat special case. XML format has a nested\nstructure that maps well to the \"recursive class member visitor\" pattern used\nby the serialization system. However, XML differs from other formats\nin that it requires a name for each class data member. Our goal is to\nadd this information to the class serialization specification while\nstill permiting the the serialization code to be used with any archive.\n

    \nOur solution is to wrap class members to be serialized in a\nname-value-pair. This structure is defined in\nnvp.hpp.\nIt is just a reference to the data member coupled with a pointer to\nto a const char * which \ncorresponds to the XML name. It implements the default\nserialization functions for a name-value pair. This default\naction is to just ignore the item name and serialize the\ndata value in the normal manner. For archive classes that\ndon't make any special provision for name-value pairs, this\nis the action which will be invoked when the name-value pair\nis serialized. Hence, wrapping a data value into a name-value\npair will have no effect when used with archives which\nmake no special provision for this wrapper.\n

    \nThe xml archive classes contain code similar to:\n

    \n// special treatment for name-value pairs.\ntemplate<class T>\nxml_oarchive & operator&(const boost::serialization::nvp<T> & t)\n{\n    // write an xml start tag\n    start_tag(t.name());\n\n    // serialize the data as usual\n    *this & t.value();\n\n    // write an xml end tag\n    end_tag(t.name());\n}\n
    \nThe most obvious and convenient name to assign to as the XML data item name\nis - surprise! - the name of the C++ class data member. So our serialization\ncode will look like:\n
    \nar & make_nvp(\"my_variable\", my_variable);\n
    \nTo simplify typing and enhance readability a macro is defined so we can write:\n
    \nar & BOOST_SERIALIZATION_NVP(my_variable);\n
    \nSimilarly there exists a macro definition that permits us to write:\n
    \nBOOST_SERIALIZATION_BASE_OBJECT_NVP(my_base_class)\n
    \n\nNote that these macros must be used in the namespace of the class, \nand without qualifying the namespace in the argument. \n\n

    \ndemo_gps.hpp\nincludes NVP wrappers or all data members.\ndemo_xml.cpp\nsaves and loads data to an XML archive.\nHere\nis example of the XML Archive corresponding to our tutorial example.\n\n

    Composition

    \nWrappers should be designed so that they can be composed as necessary.\nFor example, to pass binary data as a name value pair use:\n
    \nar & make_nvp(\"named_binary_object\", make_binary_object(address, size));\n
    \n\n
    \n

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

    \n\n\n\n" }, { "path": "example/Jamfile.v2", "content": "# Boost serialization Library Build Jamfile\n# (C) Copyright Robert Ramey 2002-2004.\n# Use, modification, and distribution are subject to the\n# Boost Software License, Version 1.0. (See accompanying file\n# LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)\n#\n# See http://www.boost.org/libs/serialization for the library home page.\n\nproject libs/serialization/example\n : id serialization_example\n : requirements ../build//boost_serialization\n ;\n\nimport ../util/test :\n run-template\n run-invoke\n run-winvoke\n test-bsl-run-no-lib\n test-bsl-run\n test-bsl-run_archive\n test-bsl-run_files\n;\n\ntest-suite \"demo-suite\" :\n # demos\n [ test-bsl-run demo ]\n [ test-bsl-run demo_auto_ptr ]\n [ test-bsl-run demo_exception ]\n [ test-bsl-run demo_fast_archive ]\n [ test-bsl-run demo_log : log_archive ]\n [ test-bsl-run demo_pimpl : demo_pimpl_A ]\n [ test-bsl-run demo_polymorphic : demo_polymorphic_A ]\n [ test-bsl-run demo_portable_archive : portable_binary_iarchive portable_binary_oarchive ]\n [ test-bsl-run demo_shared_ptr ]\n [ test-bsl-run demo_simple_log ]\n [ test-bsl-run demo_trivial_archive ]\n [ test-bsl-run demo_xml ]\n [ test-bsl-run demo_xml_save ]\n [ test-bsl-run demo_xml_load : : : demo_xml_save ]\n;\n\n" }, { "path": "example/demo.cpp", "content": "/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8\n// demo.cpp\n//\n// (C) Copyright 2002-4 Robert Ramey - http://www.rrsd.com .\n// Use, modification and distribution is subject to the Boost Software\n// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at\n// http://www.boost.org/LICENSE_1_0.txt)\n\n\n#include // NULL\n#include \n#include \n#include \n#include \n\n#include \n\n#include \n#include \n\n#include \n#include \n#include \n#include \n\n/////////////////////////////////////////////////////////////\n// The intent of this program is to serve as a tutorial for\n// users of the serialization package. An attempt has been made\n// to illustrate most of the facilities of the package.\n//\n// The intent is to create an example sufficiently complete to\n// illustrate the usage and utility of the package while\n// including a minimum of other code.\n//\n// This illustration models the bus system of a small city.\n// This includes, multiple bus stops, bus routes and schedules.\n// There are different kinds of stops. Bus stops in general\n// will appear on multiple routes. A schedule will include\n// multiple trips on the same route.\n\n/////////////////////////////////////////////////////////////\n// gps coordinate\n//\n// illustrates serialization for a simple type\n//\nclass gps_position\n{\n friend std::ostream & operator<<(std::ostream &os, const gps_position &gp);\n friend class boost::serialization::access;\n int degrees;\n int minutes;\n float seconds;\n template\n void serialize(Archive & ar, const unsigned int /* file_version */){\n ar & degrees & minutes & seconds;\n }\npublic:\n // every serializable class needs a constructor\n gps_position(){};\n gps_position(int _d, int _m, float _s) :\n degrees(_d), minutes(_m), seconds(_s)\n {}\n};\nstd::ostream & operator<<(std::ostream &os, const gps_position &gp)\n{\n return os << ' ' << gp.degrees << (unsigned char)186 << gp.minutes << '\\'' << gp.seconds << '\"';\n}\n\n/////////////////////////////////////////////////////////////\n// One bus stop\n//\n// illustrates serialization of serializable members\n//\n\nclass bus_stop\n{\n friend class boost::serialization::access;\n friend std::ostream & operator<<(std::ostream &os, const bus_stop &gp);\n virtual std::string description() const = 0;\n gps_position latitude;\n gps_position longitude;\n template\n void serialize(Archive &ar, const unsigned int version)\n {\n ar & latitude;\n ar & longitude;\n }\nprotected:\n bus_stop(const gps_position & _lat, const gps_position & _long) :\n latitude(_lat), longitude(_long)\n {}\npublic:\n bus_stop(){}\n virtual ~bus_stop(){}\n};\n\nBOOST_SERIALIZATION_ASSUME_ABSTRACT(bus_stop)\n\nstd::ostream & operator<<(std::ostream &os, const bus_stop &bs)\n{\n return os << bs.latitude << bs.longitude << ' ' << bs.description();\n}\n\n/////////////////////////////////////////////////////////////\n// Several kinds of bus stops\n//\n// illustrates serialization of derived types\n//\nclass bus_stop_corner : public bus_stop\n{\n friend class boost::serialization::access;\n std::string street1;\n std::string street2;\n virtual std::string description() const\n {\n return street1 + \" and \" + street2;\n }\n template\n void serialize(Archive &ar, const unsigned int version)\n {\n // save/load base class information\n ar & boost::serialization::base_object(*this);\n ar & street1 & street2;\n }\n\npublic:\n bus_stop_corner(){}\n bus_stop_corner(const gps_position & _lat, const gps_position & _long,\n const std::string & _s1, const std::string & _s2\n ) :\n bus_stop(_lat, _long), street1(_s1), street2(_s2)\n {\n }\n};\n\nclass bus_stop_destination : public bus_stop\n{\n friend class boost::serialization::access;\n std::string name;\n virtual std::string description() const\n {\n return name;\n }\n template\n void serialize(Archive &ar, const unsigned int version)\n {\n ar & boost::serialization::base_object(*this) & name;\n }\npublic:\n\n bus_stop_destination(){}\n bus_stop_destination(\n const gps_position & _lat, const gps_position & _long, const std::string & _name\n ) :\n bus_stop(_lat, _long), name(_name)\n {\n }\n};\n\n/////////////////////////////////////////////////////////////\n// a bus route is a collection of bus stops\n//\n// illustrates serialization of STL collection templates.\n//\n// illustrates serialization of polymorphic pointer (bus stop *);\n//\n// illustrates storage and recovery of shared pointers is correct\n// and efficient. That is objects pointed to by more than one\n// pointer are stored only once. In such cases only one such\n// object is restored and pointers are restored to point to it\n//\nclass bus_route\n{\n friend class boost::serialization::access;\n friend std::ostream & operator<<(std::ostream &os, const bus_route &br);\n typedef bus_stop * bus_stop_pointer;\n std::list stops;\n template\n void serialize(Archive &ar, const unsigned int version)\n {\n // in this program, these classes are never serialized directly but rather\n // through a pointer to the base class bus_stop. So we need a way to be\n // sure that the archive contains information about these derived classes.\n //ar.template register_type();\n ar.register_type(static_cast(NULL));\n //ar.template register_type();\n ar.register_type(static_cast(NULL));\n // serialization of stl collections is already defined\n // in the header\n ar & stops;\n }\npublic:\n bus_route(){}\n void append(bus_stop *_bs)\n {\n stops.insert(stops.end(), _bs);\n }\n};\nstd::ostream & operator<<(std::ostream &os, const bus_route &br)\n{\n std::list::const_iterator it;\n // note: we're displaying the pointer to permit verification\n // that duplicated pointers are properly restored.\n for(it = br.stops.begin(); it != br.stops.end(); it++){\n os << '\\n' << std::hex << \"0x\" << *it << std::dec << ' ' << **it;\n }\n return os;\n}\n\n/////////////////////////////////////////////////////////////\n// a bus schedule is a collection of routes each with a starting time\n//\n// Illustrates serialization of STL objects(pair) in a non-intrusive way.\n// See definition of operator<< >(ar, pair) and others in\n// serialization.hpp\n//\n// illustrates nesting of serializable classes\n//\n// illustrates use of version number to automatically grandfather older\n// versions of the same class.\n\nclass bus_schedule\n{\npublic:\n // note: this structure was made public. because the friend declarations\n // didn't seem to work as expected.\n struct trip_info\n {\n template\n void serialize(Archive &ar, const unsigned int file_version)\n {\n // in versions 2 or later\n if(file_version >= 2)\n // read the drivers name\n ar & driver;\n // all versions have the following info\n ar & hour & minute;\n }\n\n // starting time\n int hour;\n int minute;\n // only after system shipped was the driver's name added to the class\n std::string driver;\n\n trip_info(){}\n trip_info(int _h, int _m, const std::string &_d) :\n hour(_h), minute(_m), driver(_d)\n {}\n };\nprivate:\n friend class boost::serialization::access;\n friend std::ostream & operator<<(std::ostream &os, const bus_schedule &bs);\n friend std::ostream & operator<<(std::ostream &os, const bus_schedule::trip_info &ti);\n std::list > schedule;\n template\n void serialize(Archive &ar, const unsigned int version)\n {\n ar & schedule;\n }\npublic:\n void append(const std::string &_d, int _h, int _m, bus_route *_br)\n {\n schedule.insert(schedule.end(), std::make_pair(trip_info(_h, _m, _d), _br));\n }\n bus_schedule(){}\n};\nBOOST_CLASS_VERSION(bus_schedule::trip_info, 2)\n\nstd::ostream & operator<<(std::ostream &os, const bus_schedule::trip_info &ti)\n{\n return os << '\\n' << ti.hour << ':' << ti.minute << ' ' << ti.driver << ' ';\n}\nstd::ostream & operator<<(std::ostream &os, const bus_schedule &bs)\n{\n std::list >::const_iterator it;\n for(it = bs.schedule.begin(); it != bs.schedule.end(); it++){\n os << it->first << *(it->second);\n }\n return os;\n}\n\nvoid save_schedule(const bus_schedule &s, const char * filename){\n // make an archive\n std::ofstream ofs(filename);\n boost::archive::text_oarchive oa(ofs);\n oa << s;\n}\n\nvoid\nrestore_schedule(bus_schedule &s, const char * filename)\n{\n // open the archive\n std::ifstream ifs(filename);\n boost::archive::text_iarchive ia(ifs);\n\n // restore the schedule from the archive\n ia >> s;\n}\n\nint main(int argc, char *argv[])\n{\n // make the schedule\n bus_schedule original_schedule;\n\n // fill in the data\n // make a few stops\n bus_stop *bs0 = new bus_stop_corner(\n gps_position(34, 135, 52.560f),\n gps_position(134, 22, 78.30f),\n \"24th Street\", \"10th Avenue\"\n );\n bus_stop *bs1 = new bus_stop_corner(\n gps_position(35, 137, 23.456f),\n gps_position(133, 35, 54.12f),\n \"State street\", \"Cathedral Vista Lane\"\n );\n bus_stop *bs2 = new bus_stop_destination(\n gps_position(35, 136, 15.456f),\n gps_position(133, 32, 15.300f),\n \"White House\"\n );\n bus_stop *bs3 = new bus_stop_destination(\n gps_position(35, 134, 48.789f),\n gps_position(133, 32, 16.230f),\n \"Lincoln Memorial\"\n );\n\n // make a route\n bus_route route0;\n route0.append(bs0);\n route0.append(bs1);\n route0.append(bs2);\n\n // add trips to schedule\n original_schedule.append(\"bob\", 6, 24, &route0);\n original_schedule.append(\"bob\", 9, 57, &route0);\n original_schedule.append(\"alice\", 11, 02, &route0);\n\n // make another route\n bus_route route1;\n route1.append(bs3);\n route1.append(bs2);\n route1.append(bs1);\n\n // add trips to schedule\n original_schedule.append(\"ted\", 7, 17, &route1);\n original_schedule.append(\"ted\", 9, 38, &route1);\n original_schedule.append(\"alice\", 11, 47, &route1);\n\n // display the complete schedule\n std::cout << \"original schedule\";\n std::cout << original_schedule;\n\n std::string filename(boost::archive::tmpdir());\n filename += \"/demofile.txt\";\n\n // save the schedule\n save_schedule(original_schedule, filename.c_str());\n\n // ... some time later\n // make a new schedule\n bus_schedule new_schedule;\n\n restore_schedule(new_schedule, filename.c_str());\n\n // and display\n std::cout << \"\\nrestored schedule\";\n std::cout << new_schedule;\n // should be the same as the old one. (except for the pointer values)\n\n delete bs0;\n delete bs1;\n delete bs2;\n delete bs3;\n return 0;\n}\n" }, { "path": "example/demo_auto_ptr.cpp", "content": "/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8\n// demo_auto_ptr.cpp\n\n// (C) Copyright 2002-4 Robert Ramey - http://www.rrsd.com .\n// Use, modification and distribution is subject to the Boost Software\n// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at\n// http://www.boost.org/LICENSE_1_0.txt)\n\n#include \n#include \n#include \n#include \n\n#include // remove, std::autoptr inteface wrong in dinkumware\n#include \n#if defined(BOOST_NO_STDC_NAMESPACE)\nnamespace std{\n using ::remove;\n}\n#endif\n\n#include \n#include \n#include \n\n#include \n\nnamespace boost {\nnamespace serialization {\n\n/////////////////////////////////////////////////////////////\n// implement serialization for auto_ptr< T >\n// note: this must be added to the boost namespace in order to\n// be called by the library\ntemplate\ninline void save(\n Archive & ar,\n const std::auto_ptr< T > &t,\n const unsigned int file_version\n){\n // only the raw pointer has to be saved\n // the ref count is rebuilt automatically on load\n const T * const tx = t.get();\n ar << tx;\n}\n\ntemplate\ninline void load(\n Archive & ar,\n std::auto_ptr< T > &t,\n const unsigned int file_version\n){\n T *pTarget;\n ar >> pTarget;\n // note that the reset automagically maintains the reference count\n #if BOOST_WORKAROUND(BOOST_DINKUMWARE_STDLIB, == 1)\n t.release();\n t = std::auto_ptr< T >(pTarget);\n #else\n t.reset(pTarget);\n #endif\n}\n\n// split non-intrusive serialization function member into separate\n// non intrusive save/load member functions\ntemplate\ninline void serialize(\n Archive & ar,\n std::auto_ptr< T > &t,\n const unsigned int file_version\n){\n boost::serialization::split_free(ar, t, file_version);\n}\n\n} // namespace serialization\n} // namespace boost\n\n/////////////////////////////////////////////////////////////\n// test auto_ptr serialization\nclass A\n{\nprivate:\n friend class boost::serialization::access;\n int x;\n template\n void serialize(Archive &ar, const unsigned int /* file_version */){\n ar & x;\n }\npublic:\n A(){} // default constructor\n ~A(){} // default destructor\n};\n\nvoid save(const std::auto_ptr & spa, const char *filename)\n{\n std::ofstream ofs(filename);\n boost::archive::text_oarchive oa(ofs);\n oa << spa;\n}\n\nvoid load(std::auto_ptr & spa, const char *filename)\n{\n // open the archive\n std::ifstream ifs(filename);\n boost::archive::text_iarchive ia(ifs);\n\n // restore the schedule from the archive\n ia >> spa;\n}\n\nint main(int argc, char *argv[])\n{\n std::string filename = boost::archive::tmpdir();\n filename += \"/testfile\";\n\n // create a new auto pointer to ta new object of type A\n std::auto_ptr spa(new A);\n // serialize it\n save(spa, filename.c_str());\n // reset the auto pointer to NULL\n // thereby destroying the object of type A\n // note that the reset automagically maintains the reference count\n #if BOOST_WORKAROUND(BOOST_DINKUMWARE_STDLIB, == 1)\n spa.release();\n #else\n spa.reset();\n #endif\n // restore state to one equivalent to the original\n // creating a new type A object\n load(spa, filename.c_str());\n // obj of type A gets destroyed\n // as auto_ptr goes out of scope\n std::remove(filename.c_str());\n return 0;\n}\n" }, { "path": "example/demo_dll_a.hpp", "content": "#ifndef BOOST_SERIALIZATION_TEST_A_HPP\n#define BOOST_SERIALIZATION_TEST_A_HPP\n\n// MS compatible compilers support #pragma once\n#if defined(_MSC_VER)\n# pragma once\n#endif\n\n/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8\n// A.hpp simple class test\n\n// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .\n// Use, modification and distribution is subject to the Boost Software\n// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at\n// http://www.boost.org/LICENSE_1_0.txt)\n\n// See http://www.boost.org for updates, documentation, and revision history.\n\n#include \n#include // for rand()\n#include // for fabs()\n#include // size_t\n#include \n\n#include \n#if defined(BOOST_NO_STDC_NAMESPACE)\nnamespace std{\n using ::rand;\n using ::fabs;\n using ::size_t;\n}\n#endif\n\n//#include \n#include \n#include \n\n#include \n#if BOOST_WORKAROUND(BOOST_DINKUMWARE_STDLIB, == 1)\n#include \n#endif\n\n#include \n#include \n#include \n\nclass A\n{\nprivate:\n friend class boost::serialization::access;\n // note: from an aesthetic perspective, I would much prefer to have this\n // defined out of line. Unfortunately, this trips a bug in the VC 6.0\n // compiler. So hold our nose and put it her to permit running of tests.\n template\n void serialize(\n Archive &ar,\n const unsigned int /* file_version */\n ){\n ar & BOOST_SERIALIZATION_NVP(b);\n #ifndef BOOST_NO_INT64_T\n ar & BOOST_SERIALIZATION_NVP(f);\n ar & BOOST_SERIALIZATION_NVP(g);\n #endif\n #if BOOST_WORKAROUND(BOOST_BORLANDC, <= 0x551 )\n int i;\n if(BOOST_DEDUCED_TYPENAME Archive::is_saving::value){\n i = l;\n ar & BOOST_SERIALIZATION_NVP(i);\n }\n else{\n ar & BOOST_SERIALIZATION_NVP(i);\n l = i;\n }\n #else\n ar & BOOST_SERIALIZATION_NVP(l);\n #endif\n ar & BOOST_SERIALIZATION_NVP(m);\n ar & BOOST_SERIALIZATION_NVP(n);\n ar & BOOST_SERIALIZATION_NVP(o);\n ar & BOOST_SERIALIZATION_NVP(p);\n ar & BOOST_SERIALIZATION_NVP(q);\n #ifndef BOOST_NO_CWCHAR\n ar & BOOST_SERIALIZATION_NVP(r);\n #endif\n ar & BOOST_SERIALIZATION_NVP(c);\n ar & BOOST_SERIALIZATION_NVP(s);\n ar & BOOST_SERIALIZATION_NVP(t);\n ar & BOOST_SERIALIZATION_NVP(u);\n ar & BOOST_SERIALIZATION_NVP(v);\n ar & BOOST_SERIALIZATION_NVP(w);\n ar & BOOST_SERIALIZATION_NVP(x);\n ar & BOOST_SERIALIZATION_NVP(y);\n #ifndef BOOST_NO_STD_WSTRING\n ar & BOOST_SERIALIZATION_NVP(z);\n #endif\n }\n bool b;\n #ifndef BOOST_NO_INT64_T\n boost::int64_t f;\n boost::uint64_t g;\n #endif\n enum h {\n i = 0,\n j,\n k\n } l;\n std::size_t m;\n signed long n;\n unsigned long o;\n signed short p;\n unsigned short q;\n #ifndef BOOST_NO_CWCHAR\n wchar_t r;\n #endif\n char c;\n signed char s;\n unsigned char t;\n signed int u;\n unsigned int v;\n float w;\n double x;\n std::string y;\n #ifndef BOOST_NO_STD_WSTRING\n std::wstring z;\n #endif\npublic:\n A();\n bool operator==(const A &rhs) const;\n bool operator!=(const A &rhs) const;\n bool operator<(const A &rhs) const; // used by less\n // hash function for class A\n operator std::size_t () const;\n friend std::ostream & operator<<(std::ostream & os, A const & a);\n friend std::istream & operator>>(std::istream & is, A & a);\n};\n\n//BOOST_TEST_DONT_PRINT_LOG_VALUE(A);\n\ntemplate\nvoid randomize(S &x)\n{\n assert(0 == x.size());\n for(;;){\n unsigned int i = std::rand() % 27;\n if(0 == i)\n break;\n x += static_cast('a' - 1 + i);\n }\n}\n\ntemplate\nvoid accumulate(std::size_t & s, const T & t){\n const char * tptr = (const char *)(& t);\n unsigned int count = sizeof(t);\n while(count-- > 0){\n s += *tptr++;\n }\n}\n\nA::operator std::size_t () const {\n std::size_t retval = 0;\n accumulate(retval, b);\n #ifndef BOOST_NO_INT64_T\n accumulate(retval, f);\n accumulate(retval, g);\n #endif\n accumulate(retval, l);\n accumulate(retval, m);\n accumulate(retval, n);\n accumulate(retval, o);\n accumulate(retval, p);\n accumulate(retval, q);\n #ifndef BOOST_NO_CWCHAR\n accumulate(retval, r);\n #endif\n accumulate(retval, c);\n accumulate(retval, s);\n accumulate(retval, t);\n accumulate(retval, u);\n accumulate(retval, v);\n return retval;\n}\n\ninline A::A() :\n b(true),\n #ifndef BOOST_NO_INT64_T\n f(std::rand() * std::rand()),\n g(std::rand() * std::rand()),\n #endif\n l(static_cast(std::rand() % 3)),\n m(std::rand()),\n n(std::rand()),\n o(std::rand()),\n p(std::rand()),\n q(std::rand()),\n #ifndef BOOST_NO_CWCHAR\n r(std::rand()),\n #endif\n c(std::rand()),\n s(std::rand()),\n t(std::rand()),\n u(std::rand()),\n v(std::rand()),\n w((float)std::rand()),\n x((double)std::rand())\n{\n randomize(y);\n #ifndef BOOST_NO_STD_WSTRING\n randomize(z);\n #endif\n}\n\ninline bool A::operator==(const A &rhs) const\n{\n if(b != rhs.b)\n return false;\n if(l != rhs.l)\n return false;\n #ifndef BOOST_NO_INT64_T\n if(f != rhs.f)\n return false;\n if(g != rhs.g)\n return false;\n #endif\n if(m != rhs.m)\n return false;\n if(n != rhs.n)\n return false;\n if(o != rhs.o)\n return false;\n if(p != rhs.p)\n return false;\n if(q != rhs.q)\n return false;\n #ifndef BOOST_NO_CWCHAR\n if(r != rhs.r)\n return false;\n #endif\n if(c != rhs.c)\n return false;\n if(s != rhs.s)\n return false;\n if(t != rhs.t)\n return false;\n if(u != rhs.u)\n return false;\n if(v != rhs.v)\n return false;\n if(std::abs( boost::math::float_distance(w, rhs.w)) > 1)\n return false;\n if(std::abs( boost::math::float_distance(x, rhs.x)) > 1)\n return false;\n if(0 != y.compare(rhs.y))\n return false;\n #ifndef BOOST_NO_STD_WSTRING\n if(0 != z.compare(rhs.z))\n return false;\n #endif\n return true;\n}\n\ninline bool A::operator!=(const A &rhs) const\n{\n return ! (*this == rhs);\n}\n\ninline bool A::operator<(const A &rhs) const\n{\n if(b != rhs.b)\n return b < rhs.b;\n #ifndef BOOST_NO_INT64_T\n if(f != rhs.f)\n return f < rhs.f;\n if(g != rhs.g)\n return g < rhs.g;\n #endif\n if(l != rhs.l )\n return l < rhs.l;\n if(m != rhs.m )\n return m < rhs.m;\n if(n != rhs.n )\n return n < rhs.n;\n if(o != rhs.o )\n return o < rhs.o;\n if(p != rhs.p )\n return p < rhs.p;\n if(q != rhs.q )\n return q < rhs.q;\n #ifndef BOOST_NO_CWCHAR\n if(r != rhs.r )\n return r < rhs.r;\n #endif\n if(c != rhs.c )\n return c < rhs.c;\n if(s != rhs.s )\n return s < rhs.s;\n if(t != rhs.t )\n return t < rhs.t;\n if(u != rhs.u )\n return u < rhs.u;\n if(v != rhs.v )\n return v < rhs.v;\n if(w != rhs.w )\n return w < rhs.w;\n if(x != rhs.x )\n return x < rhs.x;\n int i = y.compare(rhs.y);\n if(i != 0 )\n return i < 0;\n #ifndef BOOST_NO_STD_WSTRING\n int j = z.compare(rhs.z);\n if(j != 0 )\n return j < 0;\n #endif\n return false;\n}\n\n#endif // BOOST_SERIALIZATION_TEST_A_HPP\n" }, { "path": "example/demo_dll_a.ipp", "content": "#ifndef BOOST_SERIALIZATION_TEST_A_HPP\n#define BOOST_SERIALIZATION_TEST_A_HPP\n\n// MS compatible compilers support #pragma once\n#if defined(_MSC_VER)\n# pragma once\n#endif\n\n/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8\n// A.hpp simple class test\n\n// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . \n// Use, modification and distribution is subject to the Boost Software\n// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at\n// http://www.boost.org/LICENSE_1_0.txt)\n\n// See http://www.boost.org for updates, documentation, and revision history.\n\n#include \n#include // for rand()\n#include // for fabs()\n#include // size_t\n\n#include \n#if defined(BOOST_NO_STDC_NAMESPACE)\nnamespace std{\n using ::rand; \n using ::fabs;\n using ::size_t;\n}\n#endif\n\n//#include \n#include \n#include \n\n#include \n#if BOOST_WORKAROUND(BOOST_DINKUMWARE_STDLIB, == 1)\n#include \n#endif\n\n#include \n#include \n#include \n\nclass A\n{\nprivate:\n friend class boost::serialization::access;\n // note: from an aesthetic perspective, I would much prefer to have this\n // defined out of line. Unfortunately, this trips a bug in the VC 6.0\n // compiler. So hold our nose and put it her to permit running of tests.\n template\n void serialize(\n Archive &ar,\n const unsigned int /* file_version */\n ){\n ar & BOOST_SERIALIZATION_NVP(b);\n #ifndef BOOST_NO_INT64_T\n ar & BOOST_SERIALIZATION_NVP(f);\n ar & BOOST_SERIALIZATION_NVP(g);\n #endif\n #if BOOST_WORKAROUND(BOOST_BORLANDC, <= 0x551 )\n int i;\n if(BOOST_DEDUCED_TYPENAME Archive::is_saving::value){\n i = l;\n ar & BOOST_SERIALIZATION_NVP(i);\n }\n else{\n ar & BOOST_SERIALIZATION_NVP(i);\n l = i;\n }\n #else\n ar & BOOST_SERIALIZATION_NVP(l);\n #endif\n ar & BOOST_SERIALIZATION_NVP(m);\n ar & BOOST_SERIALIZATION_NVP(n);\n ar & BOOST_SERIALIZATION_NVP(o);\n ar & BOOST_SERIALIZATION_NVP(p);\n ar & BOOST_SERIALIZATION_NVP(q);\n #ifndef BOOST_NO_CWCHAR\n ar & BOOST_SERIALIZATION_NVP(r);\n #endif\n ar & BOOST_SERIALIZATION_NVP(c);\n ar & BOOST_SERIALIZATION_NVP(s);\n ar & BOOST_SERIALIZATION_NVP(t);\n ar & BOOST_SERIALIZATION_NVP(u);\n ar & BOOST_SERIALIZATION_NVP(v);\n ar & BOOST_SERIALIZATION_NVP(w);\n ar & BOOST_SERIALIZATION_NVP(x);\n ar & BOOST_SERIALIZATION_NVP(y);\n #ifndef BOOST_NO_STD_WSTRING\n ar & BOOST_SERIALIZATION_NVP(z);\n #endif\n }\n bool b;\n #ifndef BOOST_NO_INT64_T\n boost::int64_t f;\n boost::uint64_t g;\n #endif\n enum h {\n i = 0,\n j,\n k\n } l;\n std::size_t m;\n signed long n;\n unsigned long o;\n signed short p;\n unsigned short q;\n #ifndef BOOST_NO_CWCHAR\n wchar_t r;\n #endif\n char c;\n signed char s;\n unsigned char t;\n signed int u;\n unsigned int v;\n float w;\n double x;\n std::string y;\n #ifndef BOOST_NO_STD_WSTRING\n std::wstring z;\n #endif\npublic:\n A();\n bool operator==(const A &rhs) const;\n bool operator!=(const A &rhs) const;\n bool operator<(const A &rhs) const; // used by less\n // hash function for class A\n operator std::size_t () const;\n friend std::ostream & operator<<(std::ostream & os, A const & a);\n friend std::istream & operator>>(std::istream & is, A & a);\n};\n\n//BOOST_TEST_DONT_PRINT_LOG_VALUE(A);\n\ntemplate\nvoid randomize(S &x)\n{\n assert(0 == x.size());\n for(;;){\n unsigned int i = std::rand() % 27;\n if(0 == i)\n break;\n x += static_cast('a' - 1 + i);\n }\n}\n\ntemplate\nvoid accumulate(std::size_t & s, const T & t){\n const char * tptr = (const char *)(& t);\n unsigned int count = sizeof(t);\n while(count-- > 0){\n s += *tptr++;\n }\n}\n\nA::operator std::size_t () const {\n std::size_t retval = 0;\n accumulate(retval, b);\n #ifndef BOOST_NO_INT64_T\n accumulate(retval, f);\n accumulate(retval, g);\n #endif\n accumulate(retval, l);\n accumulate(retval, m);\n accumulate(retval, n);\n accumulate(retval, o);\n accumulate(retval, p);\n accumulate(retval, q);\n #ifndef BOOST_NO_CWCHAR\n accumulate(retval, r);\n #endif\n accumulate(retval, c);\n accumulate(retval, s);\n accumulate(retval, t);\n accumulate(retval, u);\n accumulate(retval, v);\n return retval;\n}\n\ninline A::A() :\n b(true),\n #ifndef BOOST_NO_INT64_T\n f(std::rand() * std::rand()),\n g(std::rand() * std::rand()),\n #endif\n l(static_cast(std::rand() % 3)),\n m(std::rand()),\n n(std::rand()),\n o(std::rand()),\n p(std::rand()),\n q(std::rand()),\n #ifndef BOOST_NO_CWCHAR\n r(std::rand()),\n #endif\n c(std::rand()),\n s(std::rand()),\n t(std::rand()),\n u(std::rand()),\n v(std::rand()),\n w((float)std::rand()),\n x((double)std::rand())\n{\n randomize(y);\n #ifndef BOOST_NO_STD_WSTRING\n randomize(z);\n #endif\n}\n\ninline bool A::operator==(const A &rhs) const\n{\n if(b != rhs.b)\n return false;\n if(l != rhs.l)\n return false;\n #ifndef BOOST_NO_INT64_T\n if(f != rhs.f)\n return false;\n if(g != rhs.g)\n return false;\n #endif\n if(m != rhs.m)\n return false;\n if(n != rhs.n)\n return false;\n if(o != rhs.o)\n return false;\n if(p != rhs.p)\n return false; \n if(q != rhs.q)\n return false;\n #ifndef BOOST_NO_CWCHAR\n if(r != rhs.r)\n return false; \n #endif\n if(c != rhs.c)\n return false;\n if(s != rhs.s)\n return false;\n if(t != rhs.t)\n return false;\n if(u != rhs.u)\n return false; \n if(v != rhs.v)\n return false;\n if(std::abs( boost::math::float_distance(w, rhs.w)) > 1)\n return false;\n if(std::abs( boost::math::float_distance(x, rhs.x)) > 1)\n return false;\n if(0 != y.compare(rhs.y))\n return false;\n #ifndef BOOST_NO_STD_WSTRING\n if(0 != z.compare(rhs.z))\n return false;\n #endif \n return true;\n}\n\ninline bool A::operator!=(const A &rhs) const\n{\n return ! (*this == rhs);\n}\n\ninline bool A::operator<(const A &rhs) const\n{\n if(b != rhs.b)\n return b < rhs.b;\n #ifndef BOOST_NO_INT64_T\n if(f != rhs.f)\n return f < rhs.f;\n if(g != rhs.g)\n return g < rhs.g;\n #endif\n if(l != rhs.l )\n return l < rhs.l;\n if(m != rhs.m )\n return m < rhs.m;\n if(n != rhs.n )\n return n < rhs.n;\n if(o != rhs.o )\n return o < rhs.o;\n if(p != rhs.p )\n return p < rhs.p;\n if(q != rhs.q )\n return q < rhs.q;\n #ifndef BOOST_NO_CWCHAR\n if(r != rhs.r )\n return r < rhs.r;\n #endif\n if(c != rhs.c )\n return c < rhs.c;\n if(s != rhs.s )\n return s < rhs.s;\n if(t != rhs.t )\n return t < rhs.t;\n if(u != rhs.u )\n return u < rhs.u; \n if(v != rhs.v )\n return v < rhs.v;\n if(w != rhs.w )\n return w < rhs.w; \n if(x != rhs.x )\n return x < rhs.x;\n int i = y.compare(rhs.y);\n if(i != 0 )\n return i < 0;\n #ifndef BOOST_NO_STD_WSTRING\n int j = z.compare(rhs.z);\n if(j != 0 )\n return j < 0;\n #endif\n return false;\n}\n\n#endif // BOOST_SERIALIZATION_TEST_A_HPP\n" }, { "path": "example/demo_dll_b.hpp", "content": "#ifndef BOOST_SERIALIZATION_TEST_B_HPP\n#define BOOST_SERIALIZATION_TEST_B_HPP\n\n// MS compatible compilers support #pragma once\n#if defined(_MSC_VER)\n# pragma once\n#endif\n\n/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8\n// B.hpp\n\n// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .\n// Use, modification and distribution is subject to the Boost Software\n// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at\n// http://www.boost.org/LICENSE_1_0.txt)\n\n// See http://www.boost.org for updates, documentation, and revision history.\n\n#include // for rand()\n#include \n\n#include \n#if defined(BOOST_NO_STDC_NAMESPACE)\nnamespace std{\n using ::rand;\n}\n#endif\n\n#include \n#include \n#include \n\n#include \"A.hpp\"\n\n///////////////////////////////////////////////////////\n// Derived class test\nclass B : public A\n{\nprivate:\n friend class boost::serialization::access;\n template\n void save(Archive &ar, const unsigned int /* file_version */) const\n {\n // write any base class info to the archive\n ar << BOOST_SERIALIZATION_BASE_OBJECT_NVP(A);\n\n // write out members\n ar << BOOST_SERIALIZATION_NVP(s);\n ar << BOOST_SERIALIZATION_NVP(t);\n ar << BOOST_SERIALIZATION_NVP(u);\n ar << BOOST_SERIALIZATION_NVP(v);\n ar << BOOST_SERIALIZATION_NVP(w);\n ar << BOOST_SERIALIZATION_NVP(x);\n }\n\n template\n void load(Archive & ar, const unsigned int file_version)\n {\n // read any base class info to the archive\n ar >> BOOST_SERIALIZATION_BASE_OBJECT_NVP(A);\n switch(file_version){\n case 1:\n case 2:\n ar >> BOOST_SERIALIZATION_NVP(s);\n ar >> BOOST_SERIALIZATION_NVP(t);\n ar >> BOOST_SERIALIZATION_NVP(u);\n ar >> BOOST_SERIALIZATION_NVP(v);\n ar >> BOOST_SERIALIZATION_NVP(w);\n ar >> BOOST_SERIALIZATION_NVP(x);\n default:\n break;\n }\n }\n\n BOOST_SERIALIZATION_SPLIT_MEMBER()\n signed char s;\n unsigned char t;\n signed int u;\n unsigned int v;\n float w;\n double x;\npublic:\n B();\n virtual ~B(){};\n bool operator==(const B &rhs) const;\n};\n\nB::B() :\n s(std::rand()),\n t(std::rand()),\n u(std::rand()),\n v(std::rand()),\n w((float)std::rand() / std::rand()),\n x((double)std::rand() / std::rand())\n{\n}\n\nBOOST_CLASS_VERSION(B, 2)\n\ninline bool B::operator==(const B &rhs) const\n{\n return\n A::operator==(rhs)\n && s == rhs.s\n && t == rhs.t\n && u == rhs.u\n && v == rhs.v\n && std::abs( boost::math::float_distance(w, rhs.w)) < 2\n && std::abs( boost::math::float_distance(x, rhs.x)) < 2\n ;\n}\n\n#endif // BOOST_SERIALIZATION_TEST_B_HPP\n" }, { "path": "example/demo_dll_b.ipp", "content": "#ifndef BOOST_SERIALIZATION_TEST_B_HPP\n#define BOOST_SERIALIZATION_TEST_B_HPP\n\n// MS compatible compilers support #pragma once\n#if defined(_MSC_VER)\n# pragma once\n#endif\n\n/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8\n// B.hpp\n\n// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . \n// Use, modification and distribution is subject to the Boost Software\n// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at\n// http://www.boost.org/LICENSE_1_0.txt)\n\n// See http://www.boost.org for updates, documentation, and revision history.\n\n#include // for rand()\n\n#include \n#if defined(BOOST_NO_STDC_NAMESPACE)\nnamespace std{\n using ::rand; \n}\n#endif\n\n#include \n#include \n#include \n\n#include \"A.hpp\"\n\n///////////////////////////////////////////////////////\n// Derived class test\nclass B : public A\n{\nprivate:\n friend class boost::serialization::access;\n template\n void save(Archive &ar, const unsigned int /* file_version */) const\n {\n // write any base class info to the archive\n ar << BOOST_SERIALIZATION_BASE_OBJECT_NVP(A);\n\n // write out members\n ar << BOOST_SERIALIZATION_NVP(s);\n ar << BOOST_SERIALIZATION_NVP(t);\n ar << BOOST_SERIALIZATION_NVP(u);\n ar << BOOST_SERIALIZATION_NVP(v);\n ar << BOOST_SERIALIZATION_NVP(w);\n ar << BOOST_SERIALIZATION_NVP(x);\n }\n\n template\n void load(Archive & ar, const unsigned int file_version)\n {\n // read any base class info to the archive\n ar >> BOOST_SERIALIZATION_BASE_OBJECT_NVP(A);\n switch(file_version){\n case 1:\n case 2:\n ar >> BOOST_SERIALIZATION_NVP(s);\n ar >> BOOST_SERIALIZATION_NVP(t);\n ar >> BOOST_SERIALIZATION_NVP(u);\n ar >> BOOST_SERIALIZATION_NVP(v);\n ar >> BOOST_SERIALIZATION_NVP(w);\n ar >> BOOST_SERIALIZATION_NVP(x);\n default:\n break;\n }\n }\n\n BOOST_SERIALIZATION_SPLIT_MEMBER()\n signed char s;\n unsigned char t;\n signed int u;\n unsigned int v;\n float w;\n double x;\npublic:\n B();\n virtual ~B(){};\n bool operator==(const B &rhs) const;\n};\n\nB::B() :\n s(std::rand()),\n t(std::rand()),\n u(std::rand()),\n v(std::rand()),\n w((float)std::rand() / std::rand()),\n x((double)std::rand() / std::rand())\n{\n}\n\nBOOST_CLASS_VERSION(B, 2)\n\ninline bool B::operator==(const B &rhs) const\n{\n return\n A::operator==(rhs)\n && s == rhs.s \n && t == rhs.t \n && u == rhs.u \n && v == rhs.v \n && std::abs( boost::math::float_distance(w, rhs.w)) < 2\n && std::abs( boost::math::float_distance(x, rhs.x)) < 2\n ;\n}\n\n#endif // BOOST_SERIALIZATION_TEST_B_HPP\n" }, { "path": "example/demo_exception.cpp", "content": "/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8\n// demo_exception.cpp\n\n// (C) Copyright 2002-4 Robert Ramey - http://www.rrsd.com .\n// Use, modification and distribution is subject to the Boost Software\n// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at\n// http://www.boost.org/LICENSE_1_0.txt)\n\n// Example of safe exception handling for pointer de-serialization\n//\n// This example was prepared by Robert Ramey to demonstrate and test\n// safe exception handling during the de-serialization of pointers in\n// a non-trivial example.\n//\n// Hopefully, this addresses exception issues raised by\n// Vahan Margaryan who spent considerable time and effort\n// in the analysis and testing of issues of exception safety\n// of the serialization library.\n\n#include \n#include \n#include // NULL\n#include \n#include \n\n#include // remove\n#include \n#if defined(BOOST_NO_STDC_NAMESPACE)\nnamespace std{\n using ::remove;\n}\n#endif\n\n#include \n\n#ifndef BOOST_NO_EXCEPTIONS\n#include \n#endif\n\n#include \n#include \n\n#include \n#include \n\ntemplate\nstruct deleter\n{\n void operator()(TPTR t){\n delete t;\n }\n};\n\nclass Course;\nclass Student;\n\nclass Student\n{\npublic:\n static int count;\n Student(){\n count++;\n }\n ~Student(){\n some_courses.clear();\n count--;\n }\n std::list some_courses;\nprivate:\n friend class boost::serialization::access;\n template\n void serialize(Archive & ar, const unsigned int /* file_version */){\n ar & some_courses;\n }\n};\n\nint Student::count = 0;\n\nclass Course\n{\npublic:\n static int count;\n Course(){\n count++;\n }\n ~Course(){\n // doesnt delete pointers in list\n // since it doesn't \"own\" them\n some_students.clear();\n count--;\n }\n std::list some_students;\nprivate:\n friend class boost::serialization::access;\n template\n void serialize(Archive & ar, const unsigned int /* file_version */){\n ar & some_students;\n }\n};\n\nint Course::count = 0;\n\nclass School\n{\npublic:\n ~School(){\n // must delete all the students because\n // it \"owns\" them\n std::for_each(all_students.begin(), all_students.end(), deleter());\n all_students.clear();\n // as well as courses\n std::for_each(all_courses.begin(), all_courses.end(), deleter());\n all_courses.clear();\n }\n std::list all_students;\n std::list all_courses;\nprivate:\n friend class boost::serialization::access;\n BOOST_SERIALIZATION_SPLIT_MEMBER()\n template\n void save(Archive & ar, const unsigned int file_version) const;\n template\n void load(Archive & ar, const unsigned int file_version);\n};\n\n#if 0\n// case 1:\ntemplate\nvoid School::serialize(Archive & ar, const unsigned int /* file_version */){\n // if an exception occurs while loading courses\n // the structure courses may have some courses each\n // with students\n ar & all_courses;\n // while all_students will have no members.\n ar & all_students; // create students that have no courses\n // so ~School() will delete all members of courses\n // but this will NOT delete any students - see above\n // a memory leak will be the result.\n}\n\n// switching the order of serialization doesn't help in this case\n// case 2:\ntemplate\nvoid School::serialize(Archive & ar, const unsigned int /* file_version */){\n ar & all_students;\n ar >> all_courses; // create any courses that have no students\n}\n#endif\n\ntemplate\nvoid School::save(Archive & ar, const unsigned int /* file_version */) const {\n ar << all_students;\n ar << all_courses;\n}\n\ntemplate\nvoid School::load(Archive & ar, const unsigned int /* file_version */){\n // if an exception occurs while loading courses\n // the structure courses may have some courses each\n // with students\n try{\n // deserialization of a Course * will in general provoke the\n // deserialization of Student * which are added to the list of\n // students for a class. That is, this process will result\n // in the copying of a pointer.\n ar >> all_courses;\n ar >> all_students; // create students that have no courses\n }\n catch(std::exception){\n // eliminate any dangling references\n all_courses.clear();\n all_students.clear();\n throw;\n }\n}\n\nvoid init(School *school){\n Student *bob = new Student();\n Student *ted = new Student();\n Student *carol = new Student();\n Student *alice = new Student();\n\n school->all_students.push_back(bob);\n school->all_students.push_back(ted);\n school->all_students.push_back(carol);\n school->all_students.push_back(alice);\n\n Course *math = new Course();\n Course *history = new Course();\n Course *literature = new Course();\n Course *gym = new Course();\n\n school->all_courses.push_back(math);\n school->all_courses.push_back(history);\n school->all_courses.push_back(literature);\n school->all_courses.push_back(gym);\n\n bob->some_courses.push_back(math);\n math->some_students.push_back(bob);\n bob->some_courses.push_back(literature);\n literature->some_students.push_back(bob);\n\n ted->some_courses.push_back(math);\n math->some_students.push_back(ted);\n ted->some_courses.push_back(history);\n history->some_students.push_back(ted);\n\n alice->some_courses.push_back(literature);\n literature->some_students.push_back(alice);\n alice->some_courses.push_back(history);\n history->some_students.push_back(alice);\n\n // no students signed up for gym\n // carol has no courses\n}\n\nvoid save(const School * const school, const char *filename){\n std::ofstream ofile(filename);\n boost::archive::text_oarchive ar(ofile);\n ar << school;\n}\n\nvoid load(School * & school, const char *filename){\n std::ifstream ifile(filename);\n boost::archive::text_iarchive ar(ifile);\n try{\n ar >> school;\n }\n catch(std::exception){\n // eliminate dangling reference\n school = NULL;\n }\n}\n\nint main(int argc, char *argv[]){\n std::string filename(boost::archive::tmpdir());\n filename += \"/demofile.txt\";\n\n School *school = new School();\n std::cout << \"1. student count = \" << Student::count << std::endl;\n std::cout << \"2. class count = \" << Course::count << std::endl;\n init(school);\n std::cout << \"3. student count = \" << Student::count << std::endl;\n std::cout << \"4. class count = \" << Course::count << std::endl;\n save(school, filename.c_str());\n delete school;\n school = NULL;\n std::cout << \"5. student count = \" << Student::count << std::endl;\n std::cout << \"6. class count = \" << Course::count << std::endl;\n load(school, filename.c_str());\n std::cout << \"7. student count = \" << Student::count << std::endl;\n std::cout << \"8. class count = \" << Course::count << std::endl;\n delete school;\n std::cout << \"9. student count = \" << Student::count << std::endl;\n std::cout << \"10. class count = \" << Course::count << std::endl;\n std::remove(filename.c_str());\n return Student::count + Course::count;\n}\n" }, { "path": "example/demo_fast_archive.cpp", "content": "/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8\n// demo_fast_binary_archive.cpp\n\n// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .\n// Use, modification and distribution is subject to the Boost Software\n// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at\n// http://www.boost.org/LICENSE_1_0.txt)\n\n// should pass compilation and execution\n#include \n\n#include \n#include \n\n#define BOOST_ARCHIVE_SOURCE\n#include \n#include \n#include \n\n// include template definitions for base classes used. Otherwise\n// you'll get link failure with undefined symbols\n#include \n#include \n#include \n#include \n\nusing namespace boost::archive;\n\n/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8\n// \"Fast\" output binary archive. This is a variation of the native binary\nclass fast_binary_oarchive :\n // don't derive from binary_oarchive !!!\n public binary_oarchive_impl<\n fast_binary_oarchive,\n std::ostream::char_type,\n std::ostream::traits_type\n >\n{\n typedef fast_binary_oarchive derived_t;\n typedef binary_oarchive_impl<\n fast_binary_oarchive,\n std::ostream::char_type,\n std::ostream::traits_type\n > base_t;\n#ifndef BOOST_NO_MEMBER_TEMPLATE_FRIENDS\npublic:\n#else\n friend class boost::archive::detail::interface_oarchive;\n friend class basic_binary_oarchive;\n friend class basic_binary_oprimitive<\n derived_t,\n std::ostream::char_type,\n std::ostream::traits_type\n >;\n friend class boost::archive::save_access;\n#endif\n // add base class to the places considered when matching\n // save function to a specific set of arguments. Note, this didn't\n // work on my MSVC 7.0 system using\n // binary_oarchive_impl::load_override;\n // so we use the sure-fire method below. This failed to work as well\n template\n void save_override(T & t){\n base_t::save_override(t);\n // verify that this program is in fact working by making sure\n // that arrays are getting passed here\n BOOST_STATIC_ASSERT(! (boost::is_array::value) );\n }\n template\n void save_override(const int (& t)[N]){\n save_binary(t, sizeof(t));\n }\n template\n void save_override(const unsigned int (& t)[N]){\n save_binary(t, sizeof(t));\n }\n template\n void save_override(const long (& t)[N]){\n save_binary(t, sizeof(t));\n }\n template\n void save_override(const unsigned long (& t)[N]){\n save_binary(t, sizeof(t));\n }\npublic:\n fast_binary_oarchive(std::ostream & os, unsigned flags = 0) :\n base_t(os, flags)\n {}\n fast_binary_oarchive(std::streambuf & bsb, unsigned int flags = 0) :\n base_t(bsb, flags)\n {}\n};\n\n// required by export\nBOOST_SERIALIZATION_REGISTER_ARCHIVE(fast_binary_oarchive)\n\n/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8\n// \"Fast\" input binary archive. This is a variation of the native binary\nclass fast_binary_iarchive :\n // don't derive from binary_oarchive !!!\n public binary_iarchive_impl<\n fast_binary_iarchive,\n std::istream::char_type,\n std::istream::traits_type\n >\n{\n typedef fast_binary_iarchive derived_t;\n typedef binary_iarchive_impl<\n fast_binary_iarchive,\n std::istream::char_type,\n std::istream::traits_type\n > base_t;\n#ifndef BOOST_NO_MEMBER_TEMPLATE_FRIENDS\npublic:\n#else\n friend class boost::archive::detail::interface_iarchive;\n friend class basic_binary_iarchive;\n friend class basic_binary_iprimitive<\n derived_t,\n std::ostream::char_type,\n std::ostream::traits_type\n >;\n friend class boost::archive::load_access;\n#endif\n // add base class to the places considered when matching\n // save function to a specific set of arguments. Note, this didn't\n // work on my MSVC 7.0 system using\n // binary_oarchive_impl::load_override;\n // so we use the sure-fire method below. This failed to work as well\n template\n void load_override(T & t){\n base_t::load_override(t);\n BOOST_STATIC_ASSERT(! (boost::is_array::value) );\n }\n template\n void load_override(int (& t)[N]){\n load_binary(t, sizeof(t));\n }\n template\n void load_override(unsigned int (& t)[N]){\n load_binary(t, sizeof(t));\n }\n template\n void load_override(long (& t)[N]){\n load_binary(t, sizeof(t));\n }\n template\n void load_override(unsigned long (& t)[N]){\n load_binary(t, sizeof(t));\n }\npublic:\n fast_binary_iarchive(std::istream & is, unsigned int flags = 0) :\n base_t(is, flags)\n {}\n fast_binary_iarchive(std::streambuf & bsb, unsigned int flags = 0) :\n base_t(bsb, flags)\n {}\n};\n\n// required by export\nBOOST_SERIALIZATION_REGISTER_ARCHIVE(fast_binary_iarchive)\n\nint main( int argc, char* argv[] )\n{\n const int a[3] = {1, 2, 3};\n int a1[3] = {4, 5, 6};\n\n std::stringstream ss;\n {\n fast_binary_oarchive pboa(ss);\n pboa << a;\n }\n {\n fast_binary_iarchive pbia(ss);\n pbia >> a1;\n }\n return (a[0] != a1[0]) || (a[1] != a1[1]) || (a[2] != a1[2]);\n}\n\n\n" }, { "path": "example/demo_gps.hpp", "content": "#ifndef BOOST_SERIALIZATION_EXAMPLE_DEMO_GPS_HPP\n#define BOOST_SERIALIZATION_EXAMPLE_DEMO_GPS_HPP\n\n/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8\n//\n// demo_gps.hpp\n//\n// (C) Copyright 2002-4 Robert Ramey - http://www.rrsd.com .\n// Use, modification and distribution is subject to the Boost Software\n// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at\n// http://www.boost.org/LICENSE_1_0.txt)\n\n#include \n#include \n#include \n\n#include \n#include \n#include \n#include \n#include \n#include \n\n// This illustration models the bus system of a small city.\n// This includes, multiple bus stops, bus routes and schedules.\n// There are different kinds of stops. Bus stops in general\n// will appear on multiple routes. A schedule will include\n// multiple trips on the same route.\n\n/////////////////////////////////////////////////////////////\n// gps coordinate\n//\n// illustrates serialization for a simple type\n//\nclass gps_position\n{\n friend class boost::serialization::access;\n friend std::ostream & operator<<(std::ostream &os, const gps_position &gp);\n\n int degrees;\n int minutes;\n float seconds;\n\n template\n void serialize(Archive & ar, const unsigned int /* file_version */){\n ar & BOOST_SERIALIZATION_NVP(degrees)\n & BOOST_SERIALIZATION_NVP(minutes)\n & BOOST_SERIALIZATION_NVP(seconds);\n }\n\npublic:\n // every serializable class needs a constructor\n gps_position(){};\n gps_position(int _d, int _m, float _s) :\n degrees(_d), minutes(_m), seconds(_s)\n {}\n};\n\nstd::ostream & operator<<(std::ostream &os, const gps_position &gp)\n{\n return os << ' ' << gp.degrees << (unsigned char)186 << gp.minutes << '\\'' << gp.seconds << '\"';\n}\n\n/////////////////////////////////////////////////////////////\n// One bus stop\n//\n// illustrates serialization of serializable members\n//\n\nclass bus_stop\n{\n friend class boost::serialization::access;\n virtual std::string description() const = 0;\n gps_position latitude;\n gps_position longitude;\n\n template\n void serialize(Archive &ar, const unsigned int version)\n {\n ar & BOOST_SERIALIZATION_NVP(latitude);\n ar & BOOST_SERIALIZATION_NVP(longitude);\n }\n\nprotected:\n bus_stop(const gps_position & _lat, const gps_position & _long) :\n latitude(_lat), longitude(_long)\n {}\npublic:\n bus_stop(){}\n friend std::ostream & operator<<(std::ostream &os, const bus_stop &gp);\n virtual ~bus_stop(){}\n};\n\nBOOST_SERIALIZATION_ASSUME_ABSTRACT(bus_stop)\n\nstd::ostream & operator<<(std::ostream &os, const bus_stop &bs)\n{\n return os << bs.latitude << bs.longitude << ' ' << bs.description();\n}\n\n/////////////////////////////////////////////////////////////\n// Several kinds of bus stops\n//\n// illustrates serialization of derived types\n//\nclass bus_stop_corner : public bus_stop\n{\n friend class boost::serialization::access;\n std::string street1;\n std::string street2;\n virtual std::string description() const\n {\n return street1 + \" and \" + street2;\n }\n template\n void serialize(Archive &ar, const unsigned int version)\n {\n // save/load base class information\n ar & BOOST_SERIALIZATION_BASE_OBJECT_NVP(bus_stop);\n ar & BOOST_SERIALIZATION_NVP(street1);\n ar & BOOST_SERIALIZATION_NVP(street2);\n }\npublic:\n bus_stop_corner(){}\n bus_stop_corner(const gps_position & _lat, const gps_position & _long,\n const std::string & _s1, const std::string & _s2\n ) :\n bus_stop(_lat, _long), street1(_s1), street2(_s2)\n {\n }\n};\n\nclass bus_stop_destination : public bus_stop\n{\n friend class boost::serialization::access;\n std::string name;\n virtual std::string description() const\n {\n return name;\n }\n template\n void serialize(Archive &ar, const unsigned int version)\n {\n ar & BOOST_SERIALIZATION_BASE_OBJECT_NVP(bus_stop)\n & BOOST_SERIALIZATION_NVP(name);\n }\npublic:\n bus_stop_destination(){}\n bus_stop_destination(\n const gps_position & _lat, const gps_position & _long, const std::string & _name\n ) :\n bus_stop(_lat, _long), name(_name)\n {\n }\n};\n\n/////////////////////////////////////////////////////////////\n// a bus route is a collection of bus stops\n//\n// illustrates serialization of STL collection templates.\n//\n// illustrates serialization of polymorphic pointer (bus stop *);\n//\n// illustrates storage and recovery of shared pointers is correct\n// and efficient. That is objects pointed to by more than one\n// pointer are stored only once. In such cases only one such\n// object is restored and pointers are restored to point to it\n//\nclass bus_route\n{\n friend class boost::serialization::access;\n friend std::ostream & operator<<(std::ostream &os, const bus_route &br);\n typedef bus_stop * bus_stop_pointer;\n std::list stops;\n template\n void serialize(Archive &ar, const unsigned int version)\n {\n // in this program, these classes are never serialized directly but rather\n // through a pointer to the base class bus_stop. So we need a way to be\n // sure that the archive contains information about these derived classes.\n //ar.template register_type();\n ar.register_type(static_cast(NULL));\n //ar.template register_type();\n ar.register_type(static_cast(NULL));\n // serialization of stl collections is already defined\n // in the header\n ar & BOOST_SERIALIZATION_NVP(stops);\n }\npublic:\n bus_route(){}\n void append(bus_stop *_bs)\n {\n stops.insert(stops.end(), _bs);\n }\n};\nstd::ostream & operator<<(std::ostream &os, const bus_route &br)\n{\n std::list::const_iterator it;\n // note: we're displaying the pointer to permit verification\n // that duplicated pointers are properly restored.\n for(it = br.stops.begin(); it != br.stops.end(); it++){\n os << '\\n' << std::hex << \"0x\" << *it << std::dec << ' ' << **it;\n }\n return os;\n}\n\n/////////////////////////////////////////////////////////////\n// a bus schedule is a collection of routes each with a starting time\n//\n// Illustrates serialization of STL objects(pair) in a non-intrusive way.\n// See definition of operator<< >(ar, pair)\n//\n// illustrates nesting of serializable classes\n//\n// illustrates use of version number to automatically grandfather older\n// versions of the same class.\n\nclass bus_schedule\n{\n friend class boost::serialization::access;\n friend std::ostream & operator<<(std::ostream &os, const bus_schedule &bs);\n template\n void serialize(Archive &ar, const unsigned int version)\n {\n ar & BOOST_SERIALIZATION_NVP(schedule);\n }\n // note: this structure was made public. because the friend declarations\n // didn't seem to work as expected.\npublic:\n struct trip_info\n {\n template\n void serialize(Archive &ar, const unsigned int file_version)\n {\n // in versions 2 or later\n if(file_version >= 2)\n // read the drivers name\n ar & BOOST_SERIALIZATION_NVP(driver);\n // all versions have the following info\n ar & BOOST_SERIALIZATION_NVP(hour)\n & BOOST_SERIALIZATION_NVP(minute);\n }\n\n // starting time\n int hour;\n int minute;\n // only after system shipped was the driver's name added to the class\n std::string driver;\n\n trip_info(){}\n trip_info(int _h, int _m, const std::string &_d) :\n hour(_h), minute(_m), driver(_d)\n {}\n ~trip_info(){\n }\n };\n// friend std::ostream & operator<<(std::ostream &os, const trip_info &ti);\nprivate:\n std::list > schedule;\npublic:\n void append(const std::string &_d, int _h, int _m, bus_route *_br)\n {\n schedule.insert(schedule.end(), std::make_pair(trip_info(_h, _m, _d), _br));\n }\n bus_schedule(){}\n};\n\nBOOST_CLASS_VERSION(bus_schedule::trip_info, 3)\nBOOST_CLASS_VERSION(bus_schedule, 2)\n\nstd::ostream & operator<<(std::ostream &os, const bus_schedule::trip_info &ti)\n{\n return os << '\\n' << ti.hour << ':' << ti.minute << ' ' << ti.driver << ' ';\n}\nstd::ostream & operator<<(std::ostream &os, const bus_schedule &bs)\n{\n std::list >::const_iterator it;\n for(it = bs.schedule.begin(); it != bs.schedule.end(); it++){\n os << it->first << *(it->second);\n }\n return os;\n}\n\n#endif // BOOST_SERIALIZATION_EXAMPLE_DEMO_GPS_HPP\n" }, { "path": "example/demo_log.cpp", "content": "/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8\n//\n// demo_log.cpp\n//\n// (C) Copyright 2009 Robert Ramey - http://www.rrsd.com .\n// Use, modification and distribution is subject to the Boost Software\n// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at\n// http://www.boost.org/LICENSE_1_0.txt)\n\n#include \n#include \n\n#include \"demo_gps.hpp\"\n#include \"log_archive.hpp\"\n\nint main(int argc, char *argv[]){\n // make the schedule\n bus_schedule schedule;\n\n // fill in the data\n // make a few stops\n bus_stop *bs0 = new bus_stop_corner(\n gps_position(34, 135, 52.560f),\n gps_position(134, 22, 78.30f),\n \"24th Street\", \"10th Avenue\"\n );\n bus_stop *bs1 = new bus_stop_corner(\n gps_position(35, 137, 23.456f),\n gps_position(133, 35, 54.12f),\n \"State street\", \"Cathedral Vista Lane\"\n );\n bus_stop *bs2 = new bus_stop_destination(\n gps_position(35, 136, 15.456f),\n gps_position(133, 32, 15.300f),\n \"White House\"\n );\n bus_stop *bs3 = new bus_stop_destination(\n gps_position(35, 134, 48.789f),\n gps_position(133, 32, 16.230f),\n \"Lincoln Memorial\"\n );\n\n // make a route\n bus_route route0;\n route0.append(bs0);\n route0.append(bs1);\n route0.append(bs2);\n\n // add trips to schedule\n schedule.append(\"bob\", 6, 24, &route0);\n schedule.append(\"bob\", 9, 57, &route0);\n schedule.append(\"alice\", 11, 02, &route0);\n\n // make another route\n bus_route route1;\n route1.append(bs3);\n route1.append(bs2);\n route1.append(bs1);\n\n // add trips to schedule\n schedule.append(\"ted\", 7, 17, &route1);\n schedule.append(\"ted\", 9, 38, &route1);\n schedule.append(\"alice\", 11, 47, &route1);\n\n // display the complete schedule\n log_archive oa(std::cout);\n oa << BOOST_SERIALIZATION_NVP(schedule);\n oa << schedule;\n\n delete bs0;\n delete bs1;\n delete bs2;\n delete bs3;\n return 0;\n}\n\n" }, { "path": "example/demo_output.txt", "content": "original schedule\n6:24 bob \n0x003265C8 34135'52.56\" 13422'78.3\" 24th Street and 10th Avenue\n0x00326648 35137'23.456\" 13335'54.12\" State street and Cathedral Vista Lane\n0x00326768 35136'15.456\" 13332'15.3\" White House\n9:57 bob \n0x003265C8 34135'52.56\" 13422'78.3\" 24th Street and 10th Avenue\n0x00326648 35137'23.456\" 13335'54.12\" State street and Cathedral Vista Lane\n0x00326768 35136'15.456\" 13332'15.3\" White House\n11:2 alice \n0x003265C8 34135'52.56\" 13422'78.3\" 24th Street and 10th Avenue\n0x00326648 35137'23.456\" 13335'54.12\" State street and Cathedral Vista Lane\n0x00326768 35136'15.456\" 13332'15.3\" White House\n7:17 ted \n0x003267D0 35134'48.789\" 13332'16.23\" Lincoln Memorial\n0x00326768 35136'15.456\" 13332'15.3\" White House\n0x00326648 35137'23.456\" 13335'54.12\" State street and Cathedral Vista Lane\n9:38 ted \n0x003267D0 35134'48.789\" 13332'16.23\" Lincoln Memorial\n0x00326768 35136'15.456\" 13332'15.3\" White House\n0x00326648 35137'23.456\" 13335'54.12\" State street and Cathedral Vista Lane\n11:47 alice \n0x003267D0 35134'48.789\" 13332'16.23\" Lincoln Memorial\n0x00326768 35136'15.456\" 13332'15.3\" White House\n0x00326648 35137'23.456\" 13335'54.12\" State street and Cathedral Vista Lane\nrestored schedule\n6:24 \n0x0032A2F8 34135'52.56\" 13422'78.3\" 24th Street and 10th Avenue\n0x0032A508 35137'23.456\" 13335'54.12\" State street and Cathedral Vista Lane\n0x0032A628 35136'15.456\" 13332'15.3\" White House\n9:57 \n0x0032A2F8 34135'52.56\" 13422'78.3\" 24th Street and 10th Avenue\n0x0032A508 35137'23.456\" 13335'54.12\" State street and Cathedral Vista Lane\n0x0032A628 35136'15.456\" 13332'15.3\" White House\n11:2 \n0x0032A2F8 34135'52.56\" 13422'78.3\" 24th Street and 10th Avenue\n0x0032A508 35137'23.456\" 13335'54.12\" State street and Cathedral Vista Lane\n0x0032A628 35136'15.456\" 13332'15.3\" White House\n7:17 \n0x0032A8C0 35134'48.789\" 13332'16.23\" Lincoln Memorial\n0x0032A628 35136'15.456\" 13332'15.3\" White House\n0x0032A508 35137'23.456\" 13335'54.12\" State street and Cathedral Vista Lane\n9:38 \n0x0032A8C0 35134'48.789\" 13332'16.23\" Lincoln Memorial\n0x0032A628 35136'15.456\" 13332'15.3\" White House\n0x0032A508 35137'23.456\" 13335'54.12\" State street and Cathedral Vista Lane\n11:47 \n0x0032A8C0 35134'48.789\" 13332'16.23\" Lincoln Memorial\n0x0032A628 35136'15.456\" 13332'15.3\" White House\n0x0032A508 35137'23.456\" 13335'54.12\" State street and Cathedral Vista Lane\n*** No errors detected\n" }, { "path": "example/demo_pimpl.cpp", "content": "/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8\n// demo_pimpl.cpp\n\n// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .\n// Use, modification and distribution is subject to the Boost Software\n// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at\n// http://www.boost.org/LICENSE_1_0.txt)\n\n// should pass compilation and execution\n\n#include \n\n#include \n#include \n\n#include \"demo_pimpl_A.hpp\"\n\nint main(int argc, char* argv[])\n{\n std::stringstream ss;\n\n const A a;\n {\n boost::archive::text_oarchive oa(ss);\n oa << a;\n }\n A a1;\n {\n boost::archive::text_iarchive ia(ss);\n ia >> a1;\n }\n return 0;\n}\n\n" }, { "path": "example/demo_pimpl_A.cpp", "content": "/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8\n// demo_pimpl_A.cpp\n\n// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .\n// Use, modification and distribution is subject to the Boost Software\n// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at\n// http://www.boost.org/LICENSE_1_0.txt)\n\n#include \n#include \n\n#include \"demo_pimpl_A.hpp\"\n\n// \"hidden\" definition of class B\nstruct B {\n int b;\n template\n void serialize(Archive & ar, const unsigned int /* file_version */){\n ar & b;\n }\n};\n\nA::A() :\n pimpl(new B)\n{}\nA::~A(){\n delete pimpl;\n}\n// now we can define the serialization for class A\ntemplate\nvoid A::serialize(Archive & ar, const unsigned int /* file_version */){\n ar & pimpl;\n}\n\n// without the explicit instantiation below, the program will\n// fail to link for lack of instantiation of the above function\n// note: the following failed to fix link errors for vc 7.0 !\ntemplate void A::serialize(\n boost::archive::text_iarchive & ar,\n const unsigned int file_version\n);\ntemplate void A::serialize(\n boost::archive::text_oarchive & ar,\n const unsigned int file_version\n);\n" }, { "path": "example/demo_pimpl_A.hpp", "content": "#ifndef BOOST_SERIALIZATION_EXAMPLE_DEMO_PIMPL_A_HPP\n#define BOOST_SERIALIZATION_EXAMPLE_DEMO_PIMPL_A_HPP\n\n/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8\n// demo_pimpl_A.hpp\n\n// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .\n// Use, modification and distribution is subject to the Boost Software\n// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at\n// http://www.boost.org/LICENSE_1_0.txt)\n\n// class whose declaration is hidden by a pointer\nstruct B;\n\nstruct A {\n // class a contains a pointer to a \"hidden\" declaration\n B *pimpl;\n template\n void serialize(Archive & ar, const unsigned int file_version);\n A();\n ~A();\n};\n\n#endif // BOOST_SERIALIZATION_EXAMPLE_DEMO_PIMPL_A_HPP\n" }, { "path": "example/demo_polymorphic.cpp", "content": "/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8\n// demo_polymorphic.cpp\n\n// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .\n// Use, modification and distribution is subject to the Boost Software\n// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at\n// http://www.boost.org/LICENSE_1_0.txt)\n\n// should pass compilation and execution\n\n#include \n\n#include \n#include \n\n#include \n#include \n\n#include \"demo_polymorphic_A.hpp\"\n\nint main(int argc, char* argv[])\n{\n const A a;\n A a1;\n {\n // test with a text archive\n std::stringstream ss;\n {\n // instantiate archive which inherits polymorphic interface\n // and the normal text archive implementation\n boost::archive::polymorphic_text_oarchive oa(ss);\n boost::archive::polymorphic_oarchive & oa_interface = oa;\n // we can just just the interface for saving\n oa_interface << a;\n }\n {\n // or we can use the implementation directly\n boost::archive::polymorphic_text_iarchive ia(ss);\n ia >> a1;\n }\n }\n if(! (a == a1))\n return 1;\n {\n //test with a binary archive\n std::stringstream ss;\n {\n // instantiate archive which inherits polymorphic interface\n // and the normal binary archive implementation\n boost::archive::polymorphic_binary_oarchive oa(ss);\n oa << a;\n }\n {\n // see above\n boost::archive::polymorphic_binary_iarchive ia(ss);\n boost::archive::polymorphic_iarchive & ia_interface = ia;\n // use just the polymorphic interface for loading.\n ia_interface >> a1;\n }\n }\n if(! (a == a1))\n return 1;\n return 0;\n}\n\n" }, { "path": "example/demo_polymorphic_A.cpp", "content": "/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8\n// demo_polymorphic_A.cpp\n\n// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .\n// Use, modification and distribution is subject to the Boost Software\n// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at\n// http://www.boost.org/LICENSE_1_0.txt)\n\n\n#include \n#include \n\n#include \"demo_polymorphic_A.hpp\"\n\n// explicitly instantiate templates for polymorphic archives\n// used by this demo.\ntemplate\nvoid A::serialize(\n boost::archive::polymorphic_iarchive &,\n const unsigned int\n);\ntemplate\nvoid A::serialize(\n boost::archive::polymorphic_oarchive &,\n const unsigned int\n);\n" }, { "path": "example/demo_polymorphic_A.hpp", "content": "#ifndef BOOST_SERIALIZATION_EXAMPLE_DEMO_POLYMORPHIC_A_HPP\n#define BOOST_SERIALIZATION_EXAMPLE_DEMO_POLYMORPHIC_A_HPP\n\n/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8\n// demo_polymorphic_A.hpp\n\n// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .\n// Use, modification and distribution is subject to the Boost Software\n// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at\n// http://www.boost.org/LICENSE_1_0.txt)\n\nnamespace boost {\nnamespace archive {\n\nclass polymorphic_iarchive;\nclass polymorphic_oarchive;\n\n} // namespace archive\n} // namespace boost\n\nstruct A {\n // class a contains a pointer to a \"hidden\" declaration\n template\n void serialize(\n Archive & ar,\n const unsigned int file_version\n ){\n ar & data;\n }\n int data;\n bool operator==(const A & rhs) const {\n return data == rhs.data;\n }\n A() :\n data(0)\n {}\n};\n\n#endif // BOOST_SERIALIZATION_EXAMPLE_DEMO_POLYMORPHIC_A_HPP\n" }, { "path": "example/demo_portable_archive.cpp", "content": "/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8\n//\n// demo_portable_archive.cpp\n//\n// (C) Copyright 2002-4 Robert Ramey - http://www.rrsd.com .\n// Use, modification and distribution is subject to the Boost Software\n// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at\n// http://www.boost.org/LICENSE_1_0.txt)\n\n// should pass compilation and execution\n\n// note:: this example can only be built with the static library\n// (at least with MSVC - due to conflicts related to import of library\n// code and instantiation of templates.\n#include \n\n#include \"portable_binary_oarchive.hpp\"\n#include \"portable_binary_iarchive.hpp\"\n\n#include \n#include \n#if defined(BOOST_NO_STDC_NAMESPACE)\nnamespace std{ using ::rand; }\n#endif\n\nclass A\n{\n friend class boost::serialization::access;\n char c;\n A *pa;\n int i;\n int i2; // special tricky case to check sign extension\n unsigned int ui;\n long l;\n unsigned long ul;\n template\n void serialize(Archive & ar, const unsigned int /* version */){\n ar & c & i & i2 & ui & l & ul ;\n }\npublic:\n bool operator==(const A & rhs) const {\n return\n c == rhs.c\n && i == rhs.i\n && i2 == rhs.i2\n && ui == rhs.ui\n && l == rhs.l\n && ul == rhs.ul\n ;\n }\n A() :\n c(0xFF & std::rand()),\n pa(0),\n i(std::rand()),\n i2(0x80),\n ui(std::rand()),\n l(std::rand() * std::rand()),\n ul(std::rand())\n {}\n};\n\nint main( int /* argc */, char* /* argv */[] )\n{\n const A a;\n A a1;\n\n std::stringstream ss;\n {\n portable_binary_oarchive pboa(ss);\n pboa << a;\n }\n {\n portable_binary_iarchive pbia(ss);\n pbia >> a1;\n }\n if(! (a == a1))\n return 1;\n\n ss.clear();\n {\n portable_binary_oarchive pboa(ss, endian_big);\n pboa << a;\n }\n {\n portable_binary_iarchive pbia(ss, endian_big);\n pbia >> a1;\n }\n if(! (a == a1))\n return 1;\n\n ss.clear();\n {\n portable_binary_oarchive pboa(ss, endian_big);\n pboa << a;\n }\n {\n portable_binary_iarchive pbia(ss, endian_big);\n pbia >> a1;\n }\n\n return !(a == a1);\n}\n\n\n" }, { "path": "example/demo_save.xml", "content": "\n\n\n\n\t\n\t\t6\n\t\t\n\t\t\t\n\t\t\t\tbob\n\t\t\t\t6\n\t\t\t\t24\n\t\t\t\n\t\t\t\n\t\t\t\t\n\t\t\t\t\t3\n\t\t\t\t\t\n\t\t\t\t\t\t\n\t\t\t\t\t\t\t\n\t\t\t\t\t\t\t\t34\n\t\t\t\t\t\t\t\t135\n\t\t\t\t\t\t\t\t52.560001\n\t\t\t\t\t\t\t\n\t\t\t\t\t\t\t\n\t\t\t\t\t\t\t\t134\n\t\t\t\t\t\t\t\t22\n\t\t\t\t\t\t\t\t78.300003\n\t\t\t\t\t\t\t\n\t\t\t\t\t\t\n\t\t\t\t\t\t24th Street\n\t\t\t\t\t\t10th Avenue\n\t\t\t\t\t\n\t\t\t\t\t\n\t\t\t\t\t\t\n\t\t\t\t\t\t\t\n\t\t\t\t\t\t\t\t35\n\t\t\t\t\t\t\t\t137\n\t\t\t\t\t\t\t\t23.455999\n\t\t\t\t\t\t\t\n\t\t\t\t\t\t\t\n\t\t\t\t\t\t\t\t133\n\t\t\t\t\t\t\t\t35\n\t\t\t\t\t\t\t\t54.119999\n\t\t\t\t\t\t\t\n\t\t\t\t\t\t\n\t\t\t\t\t\tState street\n\t\t\t\t\t\tCathedral Vista Lane\n\t\t\t\t\t\n\t\t\t\t\t\n\t\t\t\t\t\t\n\t\t\t\t\t\t\t\n\t\t\t\t\t\t\t\t35\n\t\t\t\t\t\t\t\t136\n\t\t\t\t\t\t\t\t15.456\n\t\t\t\t\t\t\t\n\t\t\t\t\t\t\t\n\t\t\t\t\t\t\t\t133\n\t\t\t\t\t\t\t\t32\n\t\t\t\t\t\t\t\t15.3\n\t\t\t\t\t\t\t\n\t\t\t\t\t\t\n\t\t\t\t\t\tWhite House\n\t\t\t\t\t\n\t\t\t\t\n\t\t\t\n\t\t\n\t\t\n\t\t\t\n\t\t\t\tbob\n\t\t\t\t9\n\t\t\t\t57\n\t\t\t\n\t\t\t\n\t\t\n\t\t\n\t\t\t\n\t\t\t\talice\n\t\t\t\t11\n\t\t\t\t2\n\t\t\t\n\t\t\t\n\t\t\n\t\t\n\t\t\t\n\t\t\t\tted\n\t\t\t\t7\n\t\t\t\t17\n\t\t\t\n\t\t\t\n\t\t\t\t\n\t\t\t\t\t3\n\t\t\t\t\t\n\t\t\t\t\t\t\n\t\t\t\t\t\t\t\n\t\t\t\t\t\t\t\t35\n\t\t\t\t\t\t\t\t134\n\t\t\t\t\t\t\t\t48.789001\n\t\t\t\t\t\t\t\n\t\t\t\t\t\t\t\n\t\t\t\t\t\t\t\t133\n\t\t\t\t\t\t\t\t32\n\t\t\t\t\t\t\t\t16.23\n\t\t\t\t\t\t\t\n\t\t\t\t\t\t\n\t\t\t\t\t\tLincoln Memorial\n\t\t\t\t\t\n\t\t\t\t\t\n\t\t\t\t\t\n\t\t\t\t\n\t\t\t\n\t\t\n\t\t\n\t\t\t\n\t\t\t\tted\n\t\t\t\t9\n\t\t\t\t38\n\t\t\t\n\t\t\t\n\t\t\n\t\t\n\t\t\t\n\t\t\t\talice\n\t\t\t\t11\n\t\t\t\t47\n\t\t\t\n\t\t\t\n\t\t\n\t\n\n\n" }, { "path": "example/demo_shared_ptr.cpp", "content": "// demo_shared_ptr.cpp : demonstrates adding serialization to a template\n\n// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . Polymorphic\n// derived pointer example by David Tonge.\n\n// Use, modification and distribution is subject to the Boost Software\n// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at\n// http://www.boost.org/LICENSE_1_0.txt)\n//\n// See http://www.boost.org for updates, documentation, and revision history.\n\n#include \n#include \n#include // NULL\n#include \n#include \n\n#include // remove\n#include \n#if defined(BOOST_NO_STDC_NAMESPACE)\nnamespace std{\n using ::remove;\n}\n#endif\n\n#include \n#include \n#include \n\n#include \n\n///////////////////////////\n// test shared_ptr serialization\nclass A\n{\nprivate:\n friend class boost::serialization::access;\n int x;\n template\n void serialize(Archive & ar, const unsigned int /* file_version */){\n ar & x;\n }\npublic:\n static int count;\n A(){++count;} // default constructor\n virtual ~A(){--count;} // default destructor\n};\n\nBOOST_SERIALIZATION_SHARED_PTR(A)\n\n/////////////////\n// ADDITION BY DT\nclass B : public A\n{\nprivate:\n friend class boost::serialization::access;\n int x;\n template\n void serialize(Archive & ar, const unsigned int /* file_version */){\n ar & boost::serialization::base_object(*this);\n }\npublic:\n static int count;\n B() : A() {};\n virtual ~B() {};\n};\n\nBOOST_SERIALIZATION_SHARED_PTR(B)\n\n/////////////////\n\nint A::count = 0;\n\nvoid display(boost::shared_ptr &spa, boost::shared_ptr &spa1)\n{\n std::cout << \"a = 0x\" << std::hex << spa.get() << \" \";\n if (spa.get()) std::cout << \"is a \" << typeid(*(spa.get())).name() << \"* \";\n std::cout << \"use count = \" << std::dec << spa.use_count() << std::endl;\n std::cout << \"a1 = 0x\" << std::hex << spa1.get() << \" \";\n if (spa1.get()) std::cout << \"is a \" << typeid(*(spa1.get())).name() << \"* \";\n std::cout << \"use count = \" << std::dec << spa1.use_count() << std::endl;\n std::cout << \"unique element count = \" << A::count << std::endl;\n}\n\nint main(int /* argc */, char * /*argv*/[])\n{\n std::string filename(boost::archive::tmpdir());\n filename += \"/testfile\";\n\n // create a new shared pointer to ta new object of type A\n boost::shared_ptr spa(new A);\n boost::shared_ptr spa1;\n spa1 = spa;\n display(spa, spa1);\n // serialize it\n {\n std::ofstream ofs(filename.c_str());\n boost::archive::text_oarchive oa(ofs);\n oa << spa;\n oa << spa1;\n }\n // reset the shared pointer to NULL\n // thereby destroying the object of type A\n spa.reset();\n spa1.reset();\n display(spa, spa1);\n // restore state to one equivalent to the original\n // creating a new type A object\n {\n // open the archive\n std::ifstream ifs(filename.c_str());\n boost::archive::text_iarchive ia(ifs);\n\n // restore the schedule from the archive\n ia >> spa;\n ia >> spa1;\n }\n display(spa, spa1);\n spa.reset();\n spa1.reset();\n\n std::cout << std::endl;\n std::cout << std::endl;\n std::cout << \"New tests\" << std::endl;\n\n /////////////////\n // ADDITION BY DT\n // create a new shared pointer to ta new object of type A\n spa = boost::shared_ptr(new B);\n spa1 = spa;\n display(spa, spa1);\n // serialize it\n {\n std::ofstream ofs(filename.c_str());\n boost::archive::text_oarchive oa(ofs);\n oa.register_type(static_cast(NULL));\n oa << spa;\n oa << spa1;\n }\n // reset the shared pointer to NULL\n // thereby destroying the object of type B\n spa.reset();\n spa1.reset();\n display(spa, spa1);\n // restore state to one equivalent to the original\n // creating a new type B object\n {\n // open the archive\n std::ifstream ifs(filename.c_str());\n boost::archive::text_iarchive ia(ifs);\n\n // restore the schedule from the archive\n ia.register_type(static_cast(NULL));\n ia >> spa;\n ia >> spa1;\n }\n display(spa, spa1);\n ///////////////\n std::remove(filename.c_str());\n\n // obj of type A gets destroyed\n // as smart_ptr goes out of scope\n return 0;\n}\n" }, { "path": "example/demo_simple_log.cpp", "content": "/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8\n//\n// demo_log.cpp\n//\n// (C) Copyright 2009 Robert Ramey - http://www.rrsd.com .\n// Use, modification and distribution is subject to the Boost Software\n// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at\n// http://www.boost.org/LICENSE_1_0.txt)\n\n#include \n#include \n\n#include \"demo_gps.hpp\"\n#include \"simple_log_archive.hpp\"\n\nint main(int argc, char *argv[])\n{\n // make the schedule\n bus_schedule schedule;\n\n // fill in the data\n // make a few stops\n bus_stop *bs0 = new bus_stop_corner(\n gps_position(34, 135, 52.560f),\n gps_position(134, 22, 78.30f),\n \"24th Street\", \"10th Avenue\"\n );\n bus_stop *bs1 = new bus_stop_corner(\n gps_position(35, 137, 23.456f),\n gps_position(133, 35, 54.12f),\n \"State street\", \"Cathedral Vista Lane\"\n );\n bus_stop *bs2 = new bus_stop_destination(\n gps_position(35, 136, 15.456f),\n gps_position(133, 32, 15.300f),\n \"White House\"\n );\n bus_stop *bs3 = new bus_stop_destination(\n gps_position(35, 134, 48.789f),\n gps_position(133, 32, 16.230f),\n \"Lincoln Memorial\"\n );\n\n // make a route\n bus_route route0;\n route0.append(bs0);\n route0.append(bs1);\n route0.append(bs2);\n\n // add trips to schedule\n schedule.append(\"bob\", 6, 24, &route0);\n schedule.append(\"bob\", 9, 57, &route0);\n schedule.append(\"alice\", 11, 02, &route0);\n\n // make another route\n bus_route route1;\n route1.append(bs3);\n route1.append(bs2);\n route1.append(bs1);\n\n // add trips to schedule\n schedule.append(\"ted\", 7, 17, &route1);\n schedule.append(\"ted\", 9, 38, &route1);\n schedule.append(\"alice\", 11, 47, &route1);\n\n // display the complete schedule\n simple_log_archive log(std::cout);\n log << schedule;\n\n delete bs0;\n delete bs1;\n delete bs2;\n delete bs3;\n return 0;\n}\n" }, { "path": "example/demo_trivial_archive.cpp", "content": "/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8\n//\n// demo_trivial_archive.cpp\n//\n// (C) Copyright 2009 Robert Ramey - http://www.rrsd.com .\n// Use, modification and distribution is subject to the Boost Software\n// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at\n// http://www.boost.org/LICENSE_1_0.txt)\n\n#include // std::size_t\n#include \n\n/////////////////////////////////////////////////////////////////////////\n// class trivial_oarchive\nclass trivial_oarchive {\n\npublic:\n //////////////////////////////////////////////////////////\n // public interface used by programs that use the\n // serialization library\n typedef boost::mpl::bool_ is_saving;\n typedef boost::mpl::bool_ is_loading;\n template void register_type(){}\n template trivial_oarchive & operator<<(const T & t){\n return *this;\n }\n template trivial_oarchive & operator&(const T & t){\n return *this << t;\n }\n void save_binary(void *address, std::size_t count){};\n};\n\n#include \"demo_gps.hpp\"\n\nint main(int argc, char *argv[])\n{\n // make the schedule\n bus_schedule schedule;\n\n // fill in the data\n // make a few stops\n bus_stop *bs0 = new bus_stop_corner(\n gps_position(34, 135, 52.560f),\n gps_position(134, 22, 78.30f),\n \"24th Street\", \"10th Avenue\"\n );\n bus_stop *bs1 = new bus_stop_corner(\n gps_position(35, 137, 23.456f),\n gps_position(133, 35, 54.12f),\n \"State street\", \"Cathedral Vista Lane\"\n );\n bus_stop *bs2 = new bus_stop_destination(\n gps_position(35, 136, 15.456f),\n gps_position(133, 32, 15.300f),\n \"White House\"\n );\n bus_stop *bs3 = new bus_stop_destination(\n gps_position(35, 134, 48.789f),\n gps_position(133, 32, 16.230f),\n \"Lincoln Memorial\"\n );\n\n // make a route\n bus_route route0;\n route0.append(bs0);\n route0.append(bs1);\n route0.append(bs2);\n\n // add trips to schedule\n schedule.append(\"bob\", 6, 24, &route0);\n schedule.append(\"bob\", 9, 57, &route0);\n schedule.append(\"alice\", 11, 02, &route0);\n\n // make another route\n bus_route route1;\n route1.append(bs3);\n route1.append(bs2);\n route1.append(bs1);\n\n // add trips to schedule\n schedule.append(\"ted\", 7, 17, &route1);\n schedule.append(\"ted\", 9, 38, &route1);\n schedule.append(\"alice\", 11, 47, &route1);\n\n // display the complete schedule\n trivial_oarchive ta;\n ta << schedule;\n\n delete bs0;\n delete bs1;\n delete bs2;\n delete bs3;\n return 0;\n}\n" }, { "path": "example/demo_xml.cpp", "content": "/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8\n//\n// demo_xml.cpp\n//\n// (C) Copyright 2002-4 Robert Ramey - http://www.rrsd.com .\n// Use, modification and distribution is subject to the Boost Software\n// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at\n// http://www.boost.org/LICENSE_1_0.txt)\n\n#include \n#include \n#include \n#include \n\n#include // remove\n#include \n#if defined(BOOST_NO_STDC_NAMESPACE)\nnamespace std{\n using ::remove;\n}\n#endif\n\n#include \n#include \n#include \n\n#include \"demo_gps.hpp\"\n\nvoid save_schedule(const bus_schedule &s, const char * filename){\n // make an archive\n std::ofstream ofs(filename);\n assert(ofs.good());\n boost::archive::xml_oarchive oa(ofs);\n oa << BOOST_SERIALIZATION_NVP(s);\n}\n\nvoid\nrestore_schedule(bus_schedule &s, const char * filename)\n{\n // open the archive\n std::ifstream ifs(filename);\n assert(ifs.good());\n boost::archive::xml_iarchive ia(ifs);\n\n // restore the schedule from the archive\n ia >> BOOST_SERIALIZATION_NVP(s);\n}\n\nint main(int argc, char *argv[])\n{\n // make the schedule\n bus_schedule original_schedule;\n\n // fill in the data\n // make a few stops\n bus_stop *bs0 = new bus_stop_corner(\n gps_position(34, 135, 52.560f),\n gps_position(134, 22, 78.30f),\n \"24th Street\", \"10th Avenue\"\n );\n bus_stop *bs1 = new bus_stop_corner(\n gps_position(35, 137, 23.456f),\n gps_position(133, 35, 54.12f),\n \"State street\", \"Cathedral Vista Lane\"\n );\n bus_stop *bs2 = new bus_stop_destination(\n gps_position(35, 136, 15.456f),\n gps_position(133, 32, 15.300f),\n \"White House\"\n );\n bus_stop *bs3 = new bus_stop_destination(\n gps_position(35, 134, 48.789f),\n gps_position(133, 32, 16.230f),\n \"Lincoln Memorial\"\n );\n\n // make a route\n bus_route route0;\n route0.append(bs0);\n route0.append(bs1);\n route0.append(bs2);\n\n // add trips to schedule\n original_schedule.append(\"bob\", 6, 24, &route0);\n original_schedule.append(\"bob\", 9, 57, &route0);\n original_schedule.append(\"alice\", 11, 02, &route0);\n\n // make another route\n bus_route route1;\n route1.append(bs3);\n route1.append(bs2);\n route1.append(bs1);\n\n // add trips to schedule\n original_schedule.append(\"ted\", 7, 17, &route1);\n original_schedule.append(\"ted\", 9, 38, &route1);\n original_schedule.append(\"alice\", 11, 47, &route1);\n\n // display the complete schedule\n std::cout << \"original schedule\";\n std::cout << original_schedule;\n\n std::string filename(boost::archive::tmpdir());\n filename += \"/demo.xml\";\n\n // save the schedule\n save_schedule(original_schedule, filename.c_str());\n\n // ... some time later\n // make a new schedule\n bus_schedule new_schedule;\n\n restore_schedule(new_schedule, filename.c_str());\n\n // and display\n std::cout << \"\\nrestored schedule\";\n std::cout << new_schedule;\n // should be the same as the old one. (except for the pointer values)\n\n std::remove(filename.c_str());\n\n delete bs0;\n delete bs1;\n delete bs2;\n delete bs3;\n return 0;\n}\n" }, { "path": "example/demo_xml.hpp", "content": "#ifndef BOOST_SERIALIZATION_EXAMPLE_DEMO_XML_HPP\n#define BOOST_SERIALIZATION_EXAMPLE_DEMO_XML_HPP\n\n/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8\n//\n// demo_xml.hpp\n//\n// (C) Copyright 2002-4 Robert Ramey - http://www.rrsd.com .\n// Use, modification and distribution is subject to the Boost Software\n// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at\n// http://www.boost.org/LICENSE_1_0.txt)\n\n\n#include \n#include \n#include \n#include \n\n#include \n#include \n#include \n#include \n\n// This illustration models the bus system of a small city.\n// This includes, multiple bus stops, bus routes and schedules.\n// There are different kinds of stops. Bus stops in general\n// will appear on multiple routes. A schedule will include\n// multiple trips on the same route.\n\n/////////////////////////////////////////////////////////////\n// gps coordinate\n//\n// illustrates serialization for a simple type\n//\nclass gps_position\n{\n friend class boost::serialization::access;\n friend std::ostream & operator<<(std::ostream &os, const gps_position &gp);\n\n int degrees;\n int minutes;\n float seconds;\n\n template\n void serialize(Archive & ar, const unsigned int /* file_version */){\n ar & BOOST_SERIALIZATION_NVP(degrees)\n & BOOST_SERIALIZATION_NVP(minutes)\n & BOOST_SERIALIZATION_NVP(seconds);\n }\n\npublic:\n // every serializable class needs a constructor\n gps_position(){};\n gps_position(int _d, int _m, float _s) :\n degrees(_d), minutes(_m), seconds(_s)\n {}\n};\n\nstd::ostream & operator<<(std::ostream &os, const gps_position &gp)\n{\n return os << ' ' << gp.degrees << (unsigned char)186 << gp.minutes << '\\'' << gp.seconds << '\"';\n}\n\n/////////////////////////////////////////////////////////////\n// One bus stop\n//\n// illustrates serialization of serializable members\n//\n\nclass bus_stop\n{\n friend class boost::serialization::access;\n virtual std::string description() const = 0;\n gps_position latitude;\n gps_position longitude;\n\n template\n void serialize(Archive &ar, const unsigned int version)\n {\n ar & BOOST_SERIALIZATION_NVP(latitude);\n ar & BOOST_SERIALIZATION_NVP(longitude);\n }\n\nprotected:\n bus_stop(const gps_position & _lat, const gps_position & _long) :\n latitude(_lat), longitude(_long)\n {}\npublic:\n bus_stop(){}\n friend std::ostream & operator<<(std::ostream &os, const bus_stop &gp);\n virtual ~bus_stop(){}\n};\n\nBOOST_IS_ABSTRACT(bus_stop)\n\nstd::ostream & operator<<(std::ostream &os, const bus_stop &bs)\n{\n return os << bs.latitude << bs.longitude << ' ' << bs.description();\n}\n\n/////////////////////////////////////////////////////////////\n// Several kinds of bus stops\n//\n// illustrates serialization of derived types\n//\nclass bus_stop_corner : public bus_stop\n{\n friend class boost::serialization::access;\n std::string street1;\n std::string street2;\n virtual std::string description() const\n {\n return street1 + \" and \" + street2;\n }\n template\n void serialize(Archive &ar, const unsigned int version)\n {\n // save/load base class information\n ar & BOOST_SERIALIZATION_BASE_OBJECT_NVP(bus_stop);\n ar & BOOST_SERIALIZATION_NVP(street1);\n ar & BOOST_SERIALIZATION_NVP(street2);\n }\npublic:\n bus_stop_corner(){}\n bus_stop_corner(const gps_position & _lat, const gps_position & _long,\n const std::string & _s1, const std::string & _s2\n ) :\n bus_stop(_lat, _long), street1(_s1), street2(_s2)\n {\n }\n};\n\nclass bus_stop_destination : public bus_stop\n{\n friend class boost::serialization::access;\n std::string name;\n virtual std::string description() const\n {\n return name;\n }\n template\n void serialize(Archive &ar, const unsigned int version)\n {\n ar & BOOST_SERIALIZATION_BASE_OBJECT_NVP(bus_stop)\n & BOOST_SERIALIZATION_NVP(name);\n }\npublic:\n bus_stop_destination(){}\n bus_stop_destination(\n const gps_position & _lat, const gps_position & _long, const std::string & _name\n ) :\n bus_stop(_lat, _long), name(_name)\n {\n }\n};\n\n/////////////////////////////////////////////////////////////\n// a bus route is a collection of bus stops\n//\n// illustrates serialization of STL collection templates.\n//\n// illustrates serialization of polymorphic pointer (bus stop *);\n//\n// illustrates storage and recovery of shared pointers is correct\n// and efficient. That is objects pointed to by more than one\n// pointer are stored only once. In such cases only one such\n// object is restored and pointers are restored to point to it\n//\nclass bus_route\n{\n friend class boost::serialization::access;\n friend std::ostream & operator<<(std::ostream &os, const bus_route &br);\n typedef bus_stop * bus_stop_pointer;\n std::list stops;\n template\n void serialize(Archive &ar, const unsigned int version)\n {\n // in this program, these classes are never serialized directly but rather\n // through a pointer to the base class bus_stop. So we need a way to be\n // sure that the archive contains information about these derived classes.\n //ar.template register_type();\n ar.register_type(static_cast(NULL));\n //ar.template register_type();\n ar.register_type(static_cast(NULL));\n // serialization of stl collections is already defined\n // in the header\n ar & BOOST_SERIALIZATION_NVP(stops);\n }\npublic:\n bus_route(){}\n void append(bus_stop *_bs)\n {\n stops.insert(stops.end(), _bs);\n }\n};\nstd::ostream & operator<<(std::ostream &os, const bus_route &br)\n{\n std::list::const_iterator it;\n // note: we're displaying the pointer to permit verification\n // that duplicated pointers are properly restored.\n for(it = br.stops.begin(); it != br.stops.end(); it++){\n os << '\\n' << std::hex << \"0x\" << *it << std::dec << ' ' << **it;\n }\n return os;\n}\n\n/////////////////////////////////////////////////////////////\n// a bus schedule is a collection of routes each with a starting time\n//\n// Illustrates serialization of STL objects(pair) in a non-intrusive way.\n// See definition of operator<< >(ar, pair)\n//\n// illustrates nesting of serializable classes\n//\n// illustrates use of version number to automatically grandfather older\n// versions of the same class.\n\nclass bus_schedule\n{\n friend class boost::serialization::access;\n friend std::ostream & operator<<(std::ostream &os, const bus_schedule &bs);\n template\n void serialize(Archive &ar, const unsigned int version)\n {\n ar & BOOST_SERIALIZATION_NVP(schedule);\n }\n // note: this structure was made public. because the friend declarations\n // didn't seem to work as expected.\npublic:\n struct trip_info\n {\n template\n void serialize(Archive &ar, const unsigned int file_version)\n {\n // in versions 2 or later\n if(file_version >= 2)\n // read the drivers name\n ar & BOOST_SERIALIZATION_NVP(driver);\n // all versions have the following info\n ar & BOOST_SERIALIZATION_NVP(hour)\n & BOOST_SERIALIZATION_NVP(minute);\n }\n\n // starting time\n int hour;\n int minute;\n // only after system shipped was the driver's name added to the class\n std::string driver;\n\n trip_info(){}\n trip_info(int _h, int _m, const std::string &_d) :\n hour(_h), minute(_m), driver(_d)\n {}\n ~trip_info(){\n }\n };\n// friend std::ostream & operator<<(std::ostream &os, const trip_info &ti);\nprivate:\n std::list > schedule;\npublic:\n void append(const std::string &_d, int _h, int _m, bus_route *_br)\n {\n schedule.insert(schedule.end(), std::make_pair(trip_info(_h, _m, _d), _br));\n }\n bus_schedule(){}\n};\n\nBOOST_CLASS_VERSION(bus_schedule::trip_info, 3)\nBOOST_CLASS_VERSION(bus_schedule, 2)\n\nstd::ostream & operator<<(std::ostream &os, const bus_schedule::trip_info &ti)\n{\n return os << '\\n' << ti.hour << ':' << ti.minute << ' ' << ti.driver << ' ';\n}\nstd::ostream & operator<<(std::ostream &os, const bus_schedule &bs)\n{\n std::list >::const_iterator it;\n for(it = bs.schedule.begin(); it != bs.schedule.end(); it++){\n os << it->first << *(it->second);\n }\n return os;\n}\n\n#endif // BOOST_SERIALIZATION_EXAMPLE_DEMO_XML_HPP\n" }, { "path": "example/demo_xml_load.cpp", "content": "/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8\n//\n// demo_xml_load.cpp\n//\n// (C) Copyright 2002-4 Robert Ramey - http://www.rrsd.com .\n// Use, modification and distribution is subject to the Boost Software\n// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at\n// http://www.boost.org/LICENSE_1_0.txt)\n\n#include \n#include \n#include \n\n#include \n\n#include \"demo_gps.hpp\"\n\nvoid\nrestore_schedule(bus_schedule &s, const char * filename)\n{\n // open the archive\n std::ifstream ifs(filename);\n assert(ifs.good());\n boost::archive::xml_iarchive ia(ifs);\n\n // restore the schedule from the archive\n ia >> BOOST_SERIALIZATION_NVP(s);\n}\n\nint main(int argc, char *argv[])\n{\n // make a new schedule\n bus_schedule new_schedule;\n\n std::string filename(boost::archive::tmpdir());\n filename += \"/demo_save.xml\";\n\n restore_schedule(new_schedule, filename.c_str());\n\n // and display\n std::cout << \"\\nrestored schedule\";\n std::cout << new_schedule;\n\n return 0;\n}\n" }, { "path": "example/demo_xml_save.cpp", "content": "/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8\n//\n// demo_xml_save.cpp\n//\n// (C) Copyright 2002-4 Robert Ramey - http://www.rrsd.com .\n// Use, modification and distribution is subject to the Boost Software\n// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at\n// http://www.boost.org/LICENSE_1_0.txt)\n\n#include \n#include \n#include \n\n#include \n\n#include \"demo_gps.hpp\"\n\nvoid save_schedule(const bus_schedule &s, const char * filename){\n // make an archive\n std::ofstream ofs(filename);\n assert(ofs.good());\n boost::archive::xml_oarchive oa(ofs);\n oa << BOOST_SERIALIZATION_NVP(s);\n}\n\nint main(int argc, char *argv[])\n{\n // make the schedule\n bus_schedule original_schedule;\n\n // fill in the data\n // make a few stops\n bus_stop *bs0 = new bus_stop_corner(\n gps_position(34, 135, 52.560f),\n gps_position(134, 22, 78.30f),\n \"24th Street\", \"10th Avenue\"\n );\n bus_stop *bs1 = new bus_stop_corner(\n gps_position(35, 137, 23.456f),\n gps_position(133, 35, 54.12f),\n \"State street\", \"Cathedral Vista Lane\"\n );\n bus_stop *bs2 = new bus_stop_destination(\n gps_position(35, 136, 15.456f),\n gps_position(133, 32, 15.300f),\n \"White House\"\n );\n bus_stop *bs3 = new bus_stop_destination(\n gps_position(35, 134, 48.789f),\n gps_position(133, 32, 16.230f),\n \"Lincoln Memorial\"\n );\n\n // make a route\n bus_route route0;\n route0.append(bs0);\n route0.append(bs1);\n route0.append(bs2);\n\n // add trips to schedule\n original_schedule.append(\"bob\", 6, 24, &route0);\n original_schedule.append(\"bob\", 9, 57, &route0);\n original_schedule.append(\"alice\", 11, 02, &route0);\n\n // make an other route\n bus_route route1;\n route1.append(bs3);\n route1.append(bs2);\n route1.append(bs1);\n\n // add trips to schedule\n original_schedule.append(\"ted\", 7, 17, &route1);\n original_schedule.append(\"ted\", 9, 38, &route1);\n original_schedule.append(\"alice\", 11, 47, &route1);\n\n // display the complete schedule\n std::cout << \"original schedule\";\n std::cout << original_schedule;\n\n std::string filename(boost::archive::tmpdir());\n filename += \"/demo_save.xml\";\n\n // save the schedule\n save_schedule(original_schedule, filename.c_str());\n\n delete bs0;\n delete bs1;\n delete bs2;\n delete bs3;\n return 0;\n}\n" }, { "path": "example/demofile.txt", "content": "22 serialization::archive 3 0 2 0 0 6 0 0 0 0 6 24 4 1 0\n0 0 0 3 5 1 0\n1 0 0 0 0 34 135 52.560001 134 22 78.300003 11 24th Street 11 10th Avenue 5\n2 35 137 23.455999 133 35 54.119999 12 State street 20 Cathedral Vista Lane 6 1 0\n3 35 136 15.456 133 32 15.3 11 White House 9 57 4\n0 11 2 4\n0 7 17 4\n4 3 6\n5 35 134 48.789001 133 32 16.23 16 Lincoln Memorial 6\n3 5\n2 9 38 4\n4 11 47 4\n4" }, { "path": "example/fix_six.cpp", "content": "#include \n#include \n#include \n#include \n#include \n\nvoid usage(const char * program_name){\n std::cout << \"usage:\";\n std::cout << program_name << \" filename\" << std::endl;\n}\n\nint main(int argc, char *argv[]){\n if(argc != 2){\n std::cout << \"invalid number of arguments\" << std::endl;\n usage(argv[0]);\n return 1;\n }\n std::filebuf fb;\n fb.open(\n argv[1],\n std::ios_base::binary | std::ios_base::in | std::ios_base::out\n );\n if(!fb.is_open()){\n std::cout << argv[1] << \" failed to open\" << std::endl;\n return 1;\n }\n boost::archive::binary_iarchive ia(fb);\n boost::archive::library_version_type lvt = ia.get_library_version();\n if(boost::archive::library_version_type(6) != lvt){\n std::cout << \"library version not equal to six\" << std::endl;\n return 1;\n }\n lvt = boost::archive::library_version_type(7);\n fb.pubseekpos(26, std::ios_base::out);\n fb.sputn(reinterpret_cast(& lvt), sizeof(lvt));\n fb.close();\n}\n" }, { "path": "example/log_archive.cpp", "content": "/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8\n// log_archive.cpp:\n\n// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .\n// Use, modification and distribution is subject to the Boost Software\n// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at\n// http://www.boost.org/LICENSE_1_0.txt)\n\n// See http://www.boost.org for updates, documentation, and revision history.\n\n#if (defined _MSC_VER) && (_MSC_VER == 1200)\n# pragma warning (disable : 4786) // too long name, harmless warning\n#endif\n\n//#define BOOST_ARCHIVE_SOURCE\n#include \"log_archive.hpp\"\n#include \n\n// explicitly instantiate for this type of xml stream\n#include \n#include \n#include \n\nnamespace boost {\nnamespace archive {\n\ntemplate class detail::archive_serializer_map;\ntemplate class basic_xml_oarchive ;\ntemplate class xml_oarchive_impl ;\n\n} // namespace archive\n} // namespace boost\n" }, { "path": "example/log_archive.hpp", "content": "#ifndef LOG_ARCHIVE_HPP\n#define LOG_ARCHIVE_HPP\n\n// MS compatible compilers support #pragma once\n#if defined(_MSC_VER)\n# pragma once\n#endif\n\n/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8\n// log_archive.hpp\n\n// (C) Copyright 2010 Robert Ramey - http://www.rrsd.com .\n// Use, modification and distribution is subject to the Boost Software\n// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at\n// http://www.boost.org/LICENSE_1_0.txt)\n\n// See http://www.boost.org for updates, documentation, and revision history.\n\n#include \n\nnamespace boost {\n namespace archive {\n namespace detail {\n template class interface_oarchive;\n } // namespace detail\n } // namespace archive\n} // boost\n\n/////////////////////////////////////////////////////////////////////////\n// log data to an output stream. This illustrates a simpler implementation\n// of text output which is useful for getting a formatted display of\n// any serializable class. Intended to be useful as a debugging aid.\nclass log_archive :\n /* protected ? */\n public boost::archive::xml_oarchive_impl\n{\n typedef boost::archive::xml_oarchive_impl base;\n // give serialization implementation access to this class\n friend class boost::archive::detail::interface_oarchive;\n friend class boost::archive::basic_xml_oarchive;\n friend class boost::archive::save_access;\n\n /////////////////////////////////////////////////////////////////////\n // Override functions defined in basic_xml_oarchive\n\n // Anything not an attribute and not a name-value pair is an\n // error and should be trapped here.\n template\n void save_override(T & t){\n // make it a name-value pair and pass it on.\n // this permits this to be used even with data types which\n // are not wrapped with the name\n base::save_override(boost::serialization::make_nvp(NULL, t));\n }\n template\n void save_override(const boost::serialization::nvp< T > & t){\n // this is here to remove the \"const\" requirement. Since\n // this class is to be used only for output, it's not required.\n base::save_override(t);\n }\n // specific overrides for attributes - not name value pairs so we\n // want to trap them before the above \"fall through\"\n // since we don't want to see these in the output - make them no-ops.\n void save_override(const boost::archive::object_id_type & t){}\n void save_override(const boost::archive::object_reference_type & t){}\n void save_override(const boost::archive::version_type & t){}\n void save_override(const boost::archive::class_id_type & t){}\n void save_override(const boost::archive::class_id_optional_type & t){}\n void save_override(const boost::archive::class_id_reference_type & t){}\n void save_override(const boost::archive::class_name_type & t){}\n void save_override(const boost::archive::tracking_type & t){}\npublic:\n log_archive(std::ostream & os, unsigned int flags = 0) :\n boost::archive::xml_oarchive_impl(\n os,\n flags | boost::archive::no_header\n )\n {}\n};\n\n#endif // LOG_ARCHIVE_HPP\n" }, { "path": "example/polymorphic_portable_binary_iarchive.cpp", "content": "/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8\n// polymorphic_portable_binary_iarchive.cpp\n\n// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .\n// Use, modification and distribution is subject to the Boost Software\n// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at\n// http://www.boost.org/LICENSE_1_0.txt)\n\n// See http://www.boost.org for updates, documentation, and revision history.\n\n#include \n\n#define BOOST_ARCHIVE_SOURCE\n#include \"polymorphic_portable_binary_iarchive.hpp\"\n\n// explicitly instantiate for this type of text stream\n#include \n#include \n#include \n\nnamespace boost {\nnamespace archive {\n\ntemplate class binary_iarchive_impl<\n polymorphic_portable_binary_iarchive,\n std::istream::char_type,\n std::istream::traits_type\n>;\ntemplate class detail::archive_pointer_iserializer<\n polymorphic_portable_binary_iarchive\n> ;\n\n} // namespace archive\n} // namespace boost\n" }, { "path": "example/polymorphic_portable_binary_iarchive.hpp", "content": "#ifndef BOOST_ARCHIVE_POLYMORPHIC_PORTABLE_BINARY_IARCHIVE_HPP\n#define BOOST_ARCHIVE_POLYMORPHIC_PORTABLE_BINARY_IARCHIVE_HPP\n\n// MS compatible compilers support #pragma once\n#if defined(_MSC_VER)\n# pragma once\n#endif\n\n/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8\n// polymorphic_portable_binary_iarchive.hpp\n\n// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .\n// Use, modification and distribution is subject to the Boost Software\n// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at\n// http://www.boost.org/LICENSE_1_0.txt)\n\n// See http://www.boost.org for updates, documentation, and revision history.\n\n#include \n#include \"portable_binary_iarchive.hpp\"\n\ntypedef boost::archive::detail::polymorphic_iarchive_dispatch<\n portable_binary_iarchive\n> polymorphic_portable_binary_iarchive;\n\n#include \n#if BOOST_VERSION > 103401\n // required by export\n BOOST_SERIALIZATION_REGISTER_ARCHIVE(\n polymorphic_portable_binary_iarchive\n )\n#endif\n\n#endif // BOOST_ARCHIVE_POLYMORPHIC_PORTABLE_BINARY_OARCHIVE_HPP\n\n" }, { "path": "example/polymorphic_portable_binary_oarchive.cpp", "content": "/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8\n// polymorphic_portable_binary_oarchive.cpp\n\n// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .\n// Use, modification and distribution is subject to the Boost Software\n// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at\n// http://www.boost.org/LICENSE_1_0.txt)\n\n// See http://www.boost.org for updates, documentation, and revision history.\n\n#include \n\n#define BOOST_ARCHIVE_SOURCE\n#include \"polymorphic_portable_binary_oarchive.hpp\"\n\n// explicitly instantiate for this type of text stream\n#include \n#include \n#include \n\nnamespace boost {\nnamespace archive {\n\n// explicitly instantiate for this type of binary stream\ntemplate class binary_oarchive_impl<\n polymorphic_portable_binary_oarchive,\n std::ostream::char_type,\n std::ostream::traits_type\n>;\ntemplate class detail::archive_pointer_oserializer<\n polymorphic_portable_binary_oarchive\n> ;\n\n} // namespace archive\n} // namespace boost\n" }, { "path": "example/polymorphic_portable_binary_oarchive.hpp", "content": "#ifndef BOOST_ARCHIVE_POLYMORPHIC_PORTABLE_BINARY_OARCHIVE_HPP\n#define BOOST_ARCHIVE_POLYMORPHIC_PORTABLE_BINARY_OARCHIVE_HPP\n\n// MS compatible compilers support #pragma once\n#if defined(_MSC_VER)\n# pragma once\n#endif\n\n/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8\n// polymorphic_portable_binary_oarchive.hpp\n\n// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .\n// Use, modification and distribution is subject to the Boost Software\n// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at\n// http://www.boost.org/LICENSE_1_0.txt)\n\n// See http://www.boost.org for updates, documentation, and revision history.\n\n#include \n#include \"portable_binary_oarchive.hpp\"\n\ntypedef boost::archive::detail::polymorphic_oarchive_dispatch<\n portable_binary_oarchive\n > polymorphic_portable_binary_oarchive;\n\n#include \n#if BOOST_VERSION > 103401\n // required by export\n BOOST_SERIALIZATION_REGISTER_ARCHIVE(\n polymorphic_portable_binary_oarchive\n )\n#endif\n\n#endif // BOOST_ARCHIVE_POLYMORPHIC_PORTABLE_BINARY_OARCHIVE_HPP\n" }, { "path": "example/portable_binary_archive.hpp", "content": "#ifndef PORTABLE_BINARY_ARCHIVE_HPP\n#define PORTABLE_BINARY_ARCHIVE_HPP\n\n// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .\n// Use, modification and distribution is subject to the Boost Software\n// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at\n// http://www.boost.org/LICENSE_1_0.txt)\n\n// MS compatible compilers support #pragma once\n#if defined(_MSC_VER)\n# pragma once\n#endif\n\n#include \n#include \n#include \n\n#include \n#if CHAR_BIT != 8\n#error This code assumes an eight-bit byte.\n#endif\n\n#include \n#include \n\nenum portable_binary_archive_flags {\n endian_big = 0x4000,\n endian_little = 0x8000\n};\n\n//#if ( endian_big <= boost::archive::flags_last )\n//#error archive flags conflict\n//#endif\n\ninline void\nreverse_bytes(char size, char *address){\n char * first = address;\n char * last = first + size - 1;\n for(;first < last;++first, --last){\n char x = *last;\n *last = *first;\n *first = x;\n }\n}\n\n#endif // PORTABLE_BINARY_ARCHIVE_HPP\n" }, { "path": "example/portable_binary_iarchive.cpp", "content": "/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8\n// portable_binary_iarchive.cpp\n\n// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .\n// Use, modification and distribution is subject to the Boost Software\n// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at\n// http://www.boost.org/LICENSE_1_0.txt)\n\n// See http://www.boost.org for updates, documentation, and revision history.\n\n#include \n#include \n\n#include \n#include \n#include \n\n#include \"portable_binary_iarchive.hpp\"\n\nvoid\nportable_binary_iarchive::load_impl(boost::intmax_t & l, char maxsize){\n char size;\n l = 0;\n this->primitive_base_t::load(size);\n\n if(0 == size){\n return;\n }\n\n bool negative = (size < 0);\n if(negative)\n size = -size;\n\n if(size > maxsize)\n boost::serialization::throw_exception(\n portable_binary_iarchive_exception()\n );\n\n char * cptr = reinterpret_cast(& l);\n #if BOOST_ENDIAN_BIG_BYTE\n cptr += (sizeof(boost::intmax_t) - size);\n #endif\n this->primitive_base_t::load_binary(cptr, size);\n\n #if BOOST_ENDIAN_BIG_BYTE\n if(m_flags & endian_little)\n #else\n if(m_flags & endian_big)\n #endif\n reverse_bytes(size, cptr);\n\n if(negative)\n l = -l;\n}\n\nvoid\nportable_binary_iarchive::load_override(\n boost::archive::class_name_type & t\n){\n std::string cn;\n cn.reserve(BOOST_SERIALIZATION_MAX_KEY_SIZE);\n load_override(cn);\n if(cn.size() > (BOOST_SERIALIZATION_MAX_KEY_SIZE - 1))\n boost::serialization::throw_exception(\n boost::archive::archive_exception(\n boost::archive::archive_exception::invalid_class_name)\n );\n std::memcpy(t, cn.data(), cn.size());\n // borland tweak\n t.t[cn.size()] = '\\0';\n}\n\nvoid\nportable_binary_iarchive::init(unsigned int flags){\n if(0 == (flags & boost::archive::no_header)){\n // read signature in an archive version independent manner\n std::string file_signature;\n * this >> file_signature;\n if(file_signature != boost::archive::BOOST_ARCHIVE_SIGNATURE())\n boost::serialization::throw_exception(\n boost::archive::archive_exception(\n boost::archive::archive_exception::invalid_signature\n )\n );\n // make sure the version of the reading archive library can\n // support the format of the archive being read\n boost::archive::library_version_type input_library_version;\n * this >> input_library_version;\n\n // extra little .t is to get around borland quirk\n if(boost::archive::BOOST_ARCHIVE_VERSION() < input_library_version)\n boost::serialization::throw_exception(\n boost::archive::archive_exception(\n boost::archive::archive_exception::unsupported_version\n )\n );\n\n #if BOOST_WORKAROUND(__MWERKS__, BOOST_TESTED_AT(0x3205))\n this->set_library_version(input_library_version);\n //#else\n //#if ! BOOST_WORKAROUND(BOOST_MSVC, <= 1200)\n //detail::\n //#endif\n boost::archive::detail::basic_iarchive::set_library_version(\n input_library_version\n );\n #endif\n }\n unsigned char x;\n load(x);\n m_flags = x << CHAR_BIT;\n}\n\n#include \n#include \n\nnamespace boost {\nnamespace archive {\n\nnamespace detail {\n template class archive_serializer_map;\n}\n\ntemplate class basic_binary_iprimitive<\n portable_binary_iarchive,\n std::istream::char_type,\n std::istream::traits_type\n> ;\n\n} // namespace archive\n} // namespace boost\n" }, { "path": "example/portable_binary_iarchive.hpp", "content": "#ifndef PORTABLE_BINARY_IARCHIVE_HPP\n#define PORTABLE_BINARY_IARCHIVE_HPP\n\n// MS compatible compilers support #pragma once\n#if defined(_MSC_VER)\n# pragma once\n#endif\n\n#if defined(_MSC_VER)\n#pragma warning( push )\n#pragma warning( disable : 4244 )\n#endif\n\n/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8\n// portable_binary_iarchive.hpp\n\n// (C) Copyright 2002-7 Robert Ramey - http://www.rrsd.com .\n// Use, modification and distribution is subject to the Boost Software\n// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at\n// http://www.boost.org/LICENSE_1_0.txt)\n\n// See http://www.boost.org for updates, documentation, and revision history.\n\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\n#include \"portable_binary_archive.hpp\"\n\n/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8\n// exception to be thrown if integer read from archive doesn't fit\n// variable being loaded\nclass portable_binary_iarchive_exception :\n public boost::archive::archive_exception\n{\npublic:\n enum exception_code {\n incompatible_integer_size\n } m_exception_code ;\n portable_binary_iarchive_exception(exception_code c = incompatible_integer_size ) :\n boost::archive::archive_exception(boost::archive::archive_exception::other_exception),\n m_exception_code(c)\n {}\n virtual const char *what( ) const throw( )\n {\n const char *msg = \"programmer error\";\n switch(m_exception_code){\n case incompatible_integer_size:\n msg = \"integer cannot be represented\";\n break;\n default:\n msg = boost::archive::archive_exception::what();\n assert(false);\n break;\n }\n return msg;\n }\n};\n\n/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8\n// \"Portable\" input binary archive. It addresses integer size and endianness so\n// that binary archives can be passed across systems. Note:floating point types\n// not addressed here\nclass portable_binary_iarchive :\n public boost::archive::basic_binary_iprimitive<\n portable_binary_iarchive,\n std::istream::char_type,\n std::istream::traits_type\n >,\n public boost::archive::detail::common_iarchive<\n portable_binary_iarchive\n >\n {\n typedef boost::archive::basic_binary_iprimitive<\n portable_binary_iarchive,\n std::istream::char_type,\n std::istream::traits_type\n > primitive_base_t;\n typedef boost::archive::detail::common_iarchive<\n portable_binary_iarchive\n > archive_base_t;\n#ifndef BOOST_NO_MEMBER_TEMPLATE_FRIENDS\npublic:\n#else\n friend archive_base_t;\n friend primitive_base_t; // since with override load below\n friend class boost::archive::detail::interface_iarchive<\n portable_binary_iarchive\n >;\n friend class boost::archive::load_access;\nprotected:\n#endif\n unsigned int m_flags;\n void load_impl(boost::intmax_t & l, char maxsize);\n\n // default fall through for any types not specified here\n template\n void load(T & t){\n boost::intmax_t l;\n load_impl(l, sizeof(T));\n // use cast to avoid compile time warning\n //t = static_cast< T >(l);\n t = T(l);\n }\n void load(boost::serialization::item_version_type & t){\n boost::intmax_t l;\n load_impl(l, sizeof(boost::serialization::item_version_type));\n // use cast to avoid compile time warning\n t = boost::serialization::item_version_type(l);\n }\n void load(boost::archive::version_type & t){\n boost::intmax_t l;\n load_impl(l, sizeof(boost::archive::version_type));\n // use cast to avoid compile time warning\n t = boost::archive::version_type(l);\n }\n void load(boost::archive::class_id_type & t){\n boost::intmax_t l;\n load_impl(l, sizeof(boost::archive::class_id_type));\n // use cast to avoid compile time warning\n t = boost::archive::class_id_type(static_cast(l));\n }\n void load(std::string & t){\n this->primitive_base_t::load(t);\n }\n #ifndef BOOST_NO_STD_WSTRING\n void load(std::wstring & t){\n this->primitive_base_t::load(t);\n }\n #endif\n void load(float & t){\n this->primitive_base_t::load(t);\n // floats not supported\n //BOOST_STATIC_ASSERT(false);\n }\n void load(double & t){\n this->primitive_base_t::load(t);\n // doubles not supported\n //BOOST_STATIC_ASSERT(false);\n }\n void load(char & t){\n this->primitive_base_t::load(t);\n }\n void load(unsigned char & t){\n this->primitive_base_t::load(t);\n }\n typedef boost::archive::detail::common_iarchive\n detail_common_iarchive;\n template\n void load_override(T & t){\n this->detail_common_iarchive::load_override(t);\n }\n void load_override(boost::archive::class_name_type & t);\n // binary files don't include the optional information\n void load_override(boost::archive::class_id_optional_type &){}\n\n void init(unsigned int flags);\npublic:\n portable_binary_iarchive(std::istream & is, unsigned flags = 0) :\n primitive_base_t(\n * is.rdbuf(),\n 0 != (flags & boost::archive::no_codecvt)\n ),\n archive_base_t(flags),\n m_flags(0)\n {\n init(flags);\n }\n\n portable_binary_iarchive(\n std::basic_streambuf<\n std::istream::char_type,\n std::istream::traits_type\n > & bsb,\n unsigned int flags\n ) :\n primitive_base_t(\n bsb,\n 0 != (flags & boost::archive::no_codecvt)\n ),\n archive_base_t(flags),\n m_flags(0)\n {\n init(flags);\n }\n};\n\n// required by export in boost version > 1.34\n#ifdef BOOST_SERIALIZATION_REGISTER_ARCHIVE\n BOOST_SERIALIZATION_REGISTER_ARCHIVE(portable_binary_iarchive)\n#endif\n\n// required by export in boost <= 1.34\n#define BOOST_ARCHIVE_CUSTOM_IARCHIVE_TYPES portable_binary_iarchive\n\n#if defined(_MSC_VER)\n#pragma warning( pop )\n#endif\n\n#endif // PORTABLE_BINARY_IARCHIVE_HPP\n" }, { "path": "example/portable_binary_oarchive.cpp", "content": "/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8\n// portable_binary_oarchive.cpp\n\n// (C) Copyright 2002-7 Robert Ramey - http://www.rrsd.com .\n// Use, modification and distribution is subject to the Boost Software\n// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at\n// http://www.boost.org/LICENSE_1_0.txt)\n\n// See http://www.boost.org for updates, documentation, and revision history.\n\n#include \n#include \n#include \"portable_binary_oarchive.hpp\"\n\nvoid\nportable_binary_oarchive::save_impl(\n const boost::intmax_t l,\n const char maxsize\n){\n char size = 0;\n\n if(l == 0){\n this->primitive_base_t::save(size);\n return;\n }\n\n boost::intmax_t ll;\n bool negative = (l < 0);\n if(negative)\n ll = -l;\n else\n ll = l;\n\n do{\n ll >>= CHAR_BIT;\n ++size;\n }while(ll != 0);\n\n this->primitive_base_t::save(\n static_cast(negative ? -size : size)\n );\n\n if(negative)\n ll = -l;\n else\n ll = l;\n char * cptr = reinterpret_cast(& ll);\n #if BOOST_ENDIAN_BIG_BYTE\n cptr += (sizeof(boost::intmax_t) - size);\n if(m_flags & endian_little)\n reverse_bytes(size, cptr);\n #else\n if(m_flags & endian_big)\n reverse_bytes(size, cptr);\n #endif\n this->primitive_base_t::save_binary(cptr, size);\n}\n\nvoid\nportable_binary_oarchive::init(unsigned int flags) {\n if(m_flags == (endian_big | endian_little)){\n boost::serialization::throw_exception(\n portable_binary_oarchive_exception()\n );\n }\n if(0 == (flags & boost::archive::no_header)){\n // write signature in an archive version independent manner\n const std::string file_signature(\n boost::archive::BOOST_ARCHIVE_SIGNATURE()\n );\n * this << file_signature;\n // write library version\n const boost::archive::library_version_type v(\n boost::archive::BOOST_ARCHIVE_VERSION()\n );\n * this << v;\n }\n save(static_cast(m_flags >> CHAR_BIT));\n}\n\n#include \n#include \n\nnamespace boost {\nnamespace archive {\n\nnamespace detail {\n template class archive_serializer_map;\n}\n\ntemplate class basic_binary_oprimitive<\n portable_binary_oarchive,\n std::ostream::char_type,\n std::ostream::traits_type\n> ;\n\n} // namespace archive\n} // namespace boost\n" }, { "path": "example/portable_binary_oarchive.hpp", "content": "#ifndef PORTABLE_BINARY_OARCHIVE_HPP\n#define PORTABLE_BINARY_OARCHIVE_HPP\n\n// MS compatible compilers support #pragma once\n#if defined(_MSC_VER)\n# pragma once\n#endif\n\n#if defined(_MSC_VER)\n#pragma warning( push )\n#pragma warning( disable : 4244 )\n#endif\n\n/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8\n// portable_binary_oarchive.hpp\n\n// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .\n// Use, modification and distribution is subject to the Boost Software\n// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at\n// http://www.boost.org/LICENSE_1_0.txt)\n\n// See http://www.boost.org for updates, documentation, and revision history.\n\n#include \n#include \n#include \n#include \n#include \n#include \n\n#include \"portable_binary_archive.hpp\"\n\n/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8\n// exception to be thrown if integer read from archive doesn't fit\n// variable being loaded\nclass portable_binary_oarchive_exception :\n public boost::archive::archive_exception\n{\npublic:\n typedef enum {\n invalid_flags\n } exception_code;\n portable_binary_oarchive_exception(exception_code c = invalid_flags )\n {}\n virtual const char *what( ) const throw( )\n {\n const char *msg = \"programmer error\";\n switch(code){\n case invalid_flags:\n msg = \"cannot be both big and little endian\";\n default:\n boost::archive::archive_exception::what();\n }\n return msg;\n }\n};\n\n/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8\n// \"Portable\" output binary archive. This is a variation of the native binary\n// archive. it addresses integer size and endianness so that binary archives can\n// be passed across systems. Note:floating point types not addressed here\n\nclass portable_binary_oarchive :\n public boost::archive::basic_binary_oprimitive<\n portable_binary_oarchive,\n std::ostream::char_type,\n std::ostream::traits_type\n >,\n public boost::archive::detail::common_oarchive<\n portable_binary_oarchive\n >\n{\n typedef boost::archive::basic_binary_oprimitive<\n portable_binary_oarchive,\n std::ostream::char_type,\n std::ostream::traits_type\n > primitive_base_t;\n typedef boost::archive::detail::common_oarchive<\n portable_binary_oarchive\n > archive_base_t;\n#ifndef BOOST_NO_MEMBER_TEMPLATE_FRIENDS\npublic:\n#else\n friend archive_base_t;\n friend primitive_base_t; // since with override save below\n friend class boost::archive::detail::interface_oarchive<\n portable_binary_oarchive\n >;\n friend class boost::archive::save_access;\nprotected:\n#endif\n unsigned int m_flags;\n void save_impl(const boost::intmax_t l, const char maxsize);\n // add base class to the places considered when matching\n // save function to a specific set of arguments. Note, this didn't\n // work on my MSVC 7.0 system so we use the sure-fire method below\n // using archive_base_t::save;\n\n // default fall through for any types not specified here\n template\n void save(const T & t){\n save_impl(t, sizeof(T));\n }\n void save(const std::string & t){\n this->primitive_base_t::save(t);\n }\n #ifndef BOOST_NO_STD_WSTRING\n void save(const std::wstring & t){\n this->primitive_base_t::save(t);\n }\n #endif\n void save(const float & t){\n this->primitive_base_t::save(t);\n // floats not supported\n //BOOST_STATIC_ASSERT(false);\n }\n void save(const double & t){\n this->primitive_base_t::save(t);\n // doubles not supported\n //BOOST_STATIC_ASSERT(false);\n }\n void save(const char & t){\n this->primitive_base_t::save(t);\n }\n void save(const unsigned char & t){\n this->primitive_base_t::save(t);\n }\n\n // default processing - kick back to base class. Note the\n // extra stuff to get it passed borland compilers\n typedef boost::archive::detail::common_oarchive\n detail_common_oarchive;\n template\n void save_override(T & t){\n this->detail_common_oarchive::save_override(t);\n }\n // explicitly convert to char * to avoid compile ambiguities\n void save_override(const boost::archive::class_name_type & t){\n const std::string s(t);\n * this << s;\n }\n // binary files don't include the optional information\n void save_override(\n const boost::archive::class_id_optional_type & /* t */\n ){}\n\n void init(unsigned int flags);\npublic:\n portable_binary_oarchive(std::ostream & os, unsigned flags = 0) :\n primitive_base_t(\n * os.rdbuf(),\n 0 != (flags & boost::archive::no_codecvt)\n ),\n archive_base_t(flags),\n m_flags(flags & (endian_big | endian_little))\n {\n init(flags);\n }\n\n portable_binary_oarchive(\n std::basic_streambuf<\n std::ostream::char_type,\n std::ostream::traits_type\n > & bsb,\n unsigned int flags\n ) :\n primitive_base_t(\n bsb,\n 0 != (flags & boost::archive::no_codecvt)\n ),\n archive_base_t(flags),\n m_flags(0)\n {\n init(flags);\n }\n};\n\n\n// required by export in boost version > 1.34\n#ifdef BOOST_SERIALIZATION_REGISTER_ARCHIVE\n BOOST_SERIALIZATION_REGISTER_ARCHIVE(portable_binary_oarchive)\n#endif\n\n// required by export in boost <= 1.34\n#define BOOST_ARCHIVE_CUSTOM_OARCHIVE_TYPES portable_binary_oarchive\n\n#if defined(_MSC_VER)\n#pragma warning( pop )\n#endif\n\n#endif // PORTABLE_BINARY_OARCHIVE_HPP\n" }, { "path": "example/simple_log_archive.hpp", "content": "#ifndef BOOST_SIMPLE_LOG_ARCHIVE_HPP\n#define BOOST_SIMPLE_LOG_ARCHIVE_HPP\n\n// MS compatible compilers support #pragma once\n#if defined(_MSC_VER)\n# pragma once\n#endif\n\n/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8\n// simple_log_archive.hpp\n\n// (C) Copyright 2010 Robert Ramey - http://www.rrsd.com .\n// Use, modification and distribution is subject to the Boost Software\n// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at\n// http://www.boost.org/LICENSE_1_0.txt)\n\n// See http://www.boost.org for updates, documentation, and revision history.\n\n#include \n#include // std::size_t\n\n#include \n#if defined(BOOST_NO_STDC_NAMESPACE)\nnamespace std{\n using ::size_t;\n} // namespace std\n#endif\n\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\n/////////////////////////////////////////////////////////////////////////\n// log data to an output stream. This illustrates a simpler implementation\n// of text output which is useful for getting a formatted display of\n// any serializable class. Intended to be useful as a debugging aid.\nclass simple_log_archive {\n std::ostream & m_os;\n unsigned int m_depth;\n\n template\n struct save_enum_type {\n template\n static void invoke(Archive &ar, const T &t){\n ar.m_os << static_cast(t);\n }\n };\n template\n struct save_primitive {\n template\n static void invoke(Archive & ar, const T & t){\n ar.m_os << t;\n }\n };\n template\n struct save_only {\n template\n static void invoke(Archive & ar, const T & t){\n // make sure call is routed through the highest interface that might\n // be specialized by the user.\n boost::serialization::serialize_adl(\n ar,\n const_cast(t),\n ::boost::serialization::version< T >::value\n );\n }\n };\n template\n void save(const T &t){\n typedef\n BOOST_DEDUCED_TYPENAME boost::mpl::eval_if,\n boost::mpl::identity >,\n //else\n BOOST_DEDUCED_TYPENAME boost::mpl::eval_if<\n // if its primitive\n boost::mpl::equal_to<\n boost::serialization::implementation_level< T >,\n boost::mpl::int_\n >,\n boost::mpl::identity >,\n // else\n boost::mpl::identity >\n > >::type typex;\n typex::invoke(*this, t);\n }\n #ifndef BOOST_NO_STD_WSTRING\n void save(const std::wstring &ws){\n m_os << \"wide string types not supported in log archive\";\n }\n #endif\n\npublic:\n ///////////////////////////////////////////////////\n // Implement requirements for archive concept\n\n typedef boost::mpl::bool_ is_loading;\n typedef boost::mpl::bool_ is_saving;\n\n // this can be a no-op since we ignore pointer polymorphism\n template\n void register_type(const T * = NULL){}\n\n unsigned int get_library_version(){\n return 0;\n }\n\n void\n save_binary(const void *address, std::size_t count){\n m_os << \"save_binary not implemented\";\n }\n\n // the << operators\n template\n simple_log_archive & operator<<(T const & t){\n m_os << ' ';\n save(t);\n return * this;\n }\n template\n simple_log_archive & operator<<(T * const t){\n m_os << \" ->\";\n if(NULL == t)\n m_os << \" null\";\n else\n *this << * t;\n return * this;\n }\n template\n simple_log_archive & operator<<(const T (&t)[N]){\n return *this << boost::serialization::make_array(\n static_cast(&t[0]),\n N\n );\n }\n template\n simple_log_archive & operator<<(const boost::serialization::nvp< T > & t){\n m_os << '\\n'; // start line with each named object\n // indent according to object depth\n for(unsigned int i = 0; i < m_depth; ++i)\n m_os << ' ';\n ++m_depth;\n m_os << t.name(); // output the name of the object\n * this << t.const_value();\n --m_depth;\n return * this;\n }\n\n // the & operator\n template\n simple_log_archive & operator&(const T & t){\n return * this << t;\n }\n ///////////////////////////////////////////////\n\n simple_log_archive(std::ostream & os) :\n m_os(os),\n m_depth(0)\n {}\n};\n\n#endif // BOOST_SIMPLE_LOG_ARCHIVE_HPP\n" }, { "path": "include/boost/archive/archive_exception.hpp", "content": "#ifndef BOOST_ARCHIVE_ARCHIVE_EXCEPTION_HPP\n#define BOOST_ARCHIVE_ARCHIVE_EXCEPTION_HPP\n\n// MS compatible compilers support #pragma once\n#if defined(_MSC_VER)\n# pragma once\n#endif\n\n/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8\n// archive/archive_exception.hpp:\n\n// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .\n// Use, modification and distribution is subject to the Boost Software\n// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at\n// http://www.boost.org/LICENSE_1_0.txt)\n\n// See http://www.boost.org for updates, documentation, and revision history.\n\n#include \n#include \n#include \n\n#include \n#include \n\n// note: the only reason this is in here is that windows header\n// includes #define exception_code _exception_code (arrrgghhhh!).\n// the most expedient way to address this is be sure that this\n// header is always included whenever this header file is included.\n#if defined(BOOST_WINDOWS)\n#include \n#endif\n\n#include // must be the last header\n\nnamespace boost {\nnamespace archive {\n\n//////////////////////////////////////////////////////////////////////\n// exceptions thrown by archives\n//\nclass BOOST_SYMBOL_VISIBLE archive_exception :\n public virtual std::exception\n{\nprivate:\n char m_buffer[128];\nprotected:\n BOOST_ARCHIVE_DECL unsigned int\n append(unsigned int l, const char * a);\n BOOST_ARCHIVE_DECL\n archive_exception() BOOST_NOEXCEPT;\npublic:\n typedef enum {\n no_exception, // initialized without code\n other_exception, // any exception not listed below\n unregistered_class, // attempt to serialize a pointer of\n // an unregistered class\n invalid_signature, // first line of archive does not contain\n // expected string\n unsupported_version,// archive created with library version\n // subsequent to this one\n pointer_conflict, // an attempt has been made to directly\n // serialize an object which has\n // already been serialized through a pointer.\n // Were this permitted, the archive load would result\n // in the creation of an extra copy of the object.\n incompatible_native_format, // attempt to read native binary format\n // on incompatible platform\n array_size_too_short,// array being loaded doesn't fit in array allocated\n input_stream_error, // error on input stream\n invalid_class_name, // class name greater than the maximum permitted.\n // most likely a corrupted archive or an attempt\n // to insert virus via buffer overrun method.\n unregistered_cast, // base - derived relationship not registered with\n // void_cast_register\n unsupported_class_version, // type saved with a version # greater than the\n // one used by the program. This indicates that the program\n // needs to be rebuilt.\n multiple_code_instantiation, // code for implementing serialization for some\n // type has been instantiated in more than one module.\n output_stream_error // error on input stream\n } exception_code;\n exception_code code;\n\n BOOST_ARCHIVE_DECL archive_exception(\n exception_code c,\n const char * e1 = NULL,\n const char * e2 = NULL\n ) BOOST_NOEXCEPT;\n BOOST_ARCHIVE_DECL archive_exception(archive_exception const &) BOOST_NOEXCEPT;\n BOOST_ARCHIVE_DECL ~archive_exception() BOOST_NOEXCEPT_OR_NOTHROW BOOST_OVERRIDE;\n BOOST_ARCHIVE_DECL const char * what() const BOOST_NOEXCEPT_OR_NOTHROW BOOST_OVERRIDE;\n};\n\n}// namespace archive\n}// namespace boost\n\n#include // pops abi_suffix.hpp pragmas\n\n#endif //BOOST_ARCHIVE_ARCHIVE_EXCEPTION_HPP\n" }, { "path": "include/boost/archive/basic_archive.hpp", "content": "#ifndef BOOST_ARCHIVE_BASIC_ARCHIVE_HPP\n#define BOOST_ARCHIVE_BASIC_ARCHIVE_HPP\n\n// MS compatible compilers support #pragma once\n#if defined(_MSC_VER)\n# pragma once\n#endif\n\n/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8\n// basic_archive.hpp:\n\n// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .\n// Use, modification and distribution is subject to the Boost Software\n// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at\n// http://www.boost.org/LICENSE_1_0.txt)\n\n// See http://www.boost.org for updates, documentation, and revision history.\n#include // count\n#include \n#include \n#include \n#include \n#include \n\n#include \n#include // must be the last header\n\nnamespace boost {\nnamespace archive {\n\n#if defined(_MSC_VER)\n#pragma warning( push )\n#pragma warning( disable : 4244 4267 )\n#endif\n\nBOOST_ARCHIVE_DECL boost::serialization::library_version_type\nBOOST_ARCHIVE_VERSION();\n\n// create alias in boost::archive for older user code.\ntypedef boost::serialization::library_version_type library_version_type;\n\nclass version_type {\nprivate:\n typedef uint_least32_t base_type;\n base_type t;\npublic:\n // should be private - but MPI fails if it's not!!!\n version_type(): t(0) {}\n explicit version_type(const unsigned int & t_) : t(t_){\n BOOST_ASSERT(t_ <= boost::integer_traits::const_max);\n }\n version_type(const version_type & t_) :\n t(t_.t)\n {}\n version_type & operator=(const version_type & rhs){\n t = rhs.t;\n return *this;\n }\n // used for text output\n operator base_type () const {\n return t;\n }\n // used for text input\n operator base_type & (){\n return t;\n }\n bool operator==(const version_type & rhs) const {\n return t == rhs.t;\n }\n bool operator<(const version_type & rhs) const {\n return t < rhs.t;\n }\n};\n\nclass class_id_type {\nprivate:\n typedef int_least16_t base_type;\n base_type t;\npublic:\n // should be private - but then can't use BOOST_STRONG_TYPE below\n class_id_type() : t(0) {}\n explicit class_id_type(const int t_) : t(t_){\n BOOST_ASSERT(t_ <= boost::integer_traits::const_max);\n }\n explicit class_id_type(const std::size_t t_) : t(t_){\n // BOOST_ASSERT(t_ <= boost::integer_traits::const_max);\n }\n class_id_type(const class_id_type & t_) :\n t(t_.t)\n {}\n class_id_type & operator=(const class_id_type & rhs){\n t = rhs.t;\n return *this;\n }\n\n // used for text output\n operator base_type () const {\n return t;\n }\n // used for text input\n operator base_type &() {\n return t;\n }\n bool operator==(const class_id_type & rhs) const {\n return t == rhs.t;\n }\n bool operator<(const class_id_type & rhs) const {\n return t < rhs.t;\n }\n};\n\n#define BOOST_SERIALIZATION_NULL_POINTER_TAG boost::archive::class_id_type(-1)\n\nclass object_id_type {\nprivate:\n typedef uint_least32_t base_type;\n base_type t;\npublic:\n object_id_type(): t(0) {}\n // note: presumes that size_t >= unsigned int.\n // use explicit cast to silence useless warning\n explicit object_id_type(const std::size_t & t_) : t(static_cast(t_)){\n // make quadruple sure that we haven't lost any real integer\n // precision\n BOOST_ASSERT(t_ <= boost::integer_traits::const_max);\n }\n object_id_type(const object_id_type & t_) :\n t(t_.t)\n {}\n object_id_type & operator=(const object_id_type & rhs){\n t = rhs.t;\n return *this;\n }\n // used for text output\n operator base_type () const {\n return t;\n }\n // used for text input\n operator base_type & () {\n return t;\n }\n bool operator==(const object_id_type & rhs) const {\n return t == rhs.t;\n }\n bool operator<(const object_id_type & rhs) const {\n return t < rhs.t;\n }\n};\n\n#if defined(_MSC_VER)\n#pragma warning( pop )\n#endif\n\nstruct tracking_type {\n bool t;\n explicit tracking_type(const bool t_ = false)\n : t(t_)\n {}\n tracking_type(const tracking_type & t_)\n : t(t_.t)\n {}\n operator bool () const {\n return t;\n }\n operator bool & () {\n return t;\n }\n tracking_type & operator=(const bool t_){\n t = t_;\n return *this;\n }\n bool operator==(const tracking_type & rhs) const {\n return t == rhs.t;\n }\n bool operator==(const bool & rhs) const {\n return t == rhs;\n }\n tracking_type & operator=(const tracking_type & rhs){\n t = rhs.t;\n return *this;\n }\n};\n\nstruct class_name_type :\n private boost::noncopyable\n{\n char *t;\n operator const char * & () const {\n return const_cast(t);\n }\n operator char * () {\n return t;\n }\n std::size_t size() const {\n return std::strlen(t);\n }\n explicit class_name_type(const char *key_)\n : t(const_cast(key_)){}\n explicit class_name_type(char *key_)\n : t(key_){}\n class_name_type & operator=(const class_name_type & rhs){\n t = rhs.t;\n return *this;\n }\n};\n\nenum archive_flags {\n no_header = 1, // suppress archive header info\n no_codecvt = 2, // suppress alteration of codecvt facet\n no_xml_tag_checking = 4, // suppress checking of xml tags\n no_tracking = 8, // suppress ALL tracking\n flags_last = 8\n};\n\nBOOST_ARCHIVE_DECL const char *\nBOOST_ARCHIVE_SIGNATURE();\n\n/* NOTE : Warning : Warning : Warning : Warning : Warning\n * If any of these are changed to different sized types,\n * binary_iarchive won't be able to read older archives\n * unless you rev the library version and include conditional\n * code based on the library version. There is nothing\n * inherently wrong in doing this - but you have to be super\n * careful because it's easy to get wrong and start breaking\n * old archives !!!\n */\n\n#define BOOST_ARCHIVE_STRONG_TYPEDEF(T, D) \\\n class D : public T { \\\n public: \\\n explicit D(const T tt) : T(tt){} \\\n }; \\\n/**/\n\nBOOST_ARCHIVE_STRONG_TYPEDEF(class_id_type, class_id_reference_type)\nBOOST_ARCHIVE_STRONG_TYPEDEF(class_id_type, class_id_optional_type)\nBOOST_ARCHIVE_STRONG_TYPEDEF(object_id_type, object_reference_type)\n\n}// namespace archive\n}// namespace boost\n\n#include // pops abi_suffix.hpp pragmas\n\n#include \n\n// set implementation level to primitive for all types\n// used internally by the serialization library\n\nBOOST_CLASS_IMPLEMENTATION(boost::serialization::library_version_type, primitive_type)\nBOOST_CLASS_IMPLEMENTATION(boost::archive::version_type, primitive_type)\nBOOST_CLASS_IMPLEMENTATION(boost::archive::class_id_type, primitive_type)\nBOOST_CLASS_IMPLEMENTATION(boost::archive::class_id_reference_type, primitive_type)\nBOOST_CLASS_IMPLEMENTATION(boost::archive::class_id_optional_type, primitive_type)\nBOOST_CLASS_IMPLEMENTATION(boost::archive::class_name_type, primitive_type)\nBOOST_CLASS_IMPLEMENTATION(boost::archive::object_id_type, primitive_type)\nBOOST_CLASS_IMPLEMENTATION(boost::archive::object_reference_type, primitive_type)\nBOOST_CLASS_IMPLEMENTATION(boost::archive::tracking_type, primitive_type)\n\n#include \n\n// set types used internally by the serialization library\n// to be bitwise serializable\n\nBOOST_IS_BITWISE_SERIALIZABLE(boost::serialization::library_version_type)\nBOOST_IS_BITWISE_SERIALIZABLE(boost::archive::version_type)\nBOOST_IS_BITWISE_SERIALIZABLE(boost::archive::class_id_type)\nBOOST_IS_BITWISE_SERIALIZABLE(boost::archive::class_id_reference_type)\nBOOST_IS_BITWISE_SERIALIZABLE(boost::archive::class_id_optional_type)\nBOOST_IS_BITWISE_SERIALIZABLE(boost::archive::class_name_type)\nBOOST_IS_BITWISE_SERIALIZABLE(boost::archive::object_id_type)\nBOOST_IS_BITWISE_SERIALIZABLE(boost::archive::object_reference_type)\nBOOST_IS_BITWISE_SERIALIZABLE(boost::archive::tracking_type)\n\n#endif //BOOST_ARCHIVE_BASIC_ARCHIVE_HPP\n" }, { "path": "include/boost/archive/basic_binary_iarchive.hpp", "content": "#ifndef BOOST_ARCHIVE_BASIC_BINARY_IARCHIVE_HPP\n#define BOOST_ARCHIVE_BASIC_BINARY_IARCHIVE_HPP\n\n// MS compatible compilers support #pragma once\n#if defined(_MSC_VER)\n# pragma once\n#endif\n\n/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8\n// basic_binary_iarchive.hpp\n//\n// archives stored as native binary - this should be the fastest way\n// to archive the state of a group of objects. It makes no attempt to\n// convert to any canonical form.\n\n// IN GENERAL, ARCHIVES CREATED WITH THIS CLASS WILL NOT BE READABLE\n// ON PLATFORM APART FROM THE ONE THEY ARE CREATED ON\n\n// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .\n// Use, modification and distribution is subject to the Boost Software\n// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at\n// http://www.boost.org/LICENSE_1_0.txt)\n\n// See http://www.boost.org for updates, documentation, and revision history.\n\n#include \n#include \n\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\n#ifdef BOOST_MSVC\n# pragma warning(push)\n# pragma warning(disable : 4511 4512)\n#endif\n\n#include // must be the last header\n\nnamespace boost {\nnamespace archive {\n\nnamespace detail {\n template class interface_iarchive;\n} // namespace detail\n\n/////////////////////////////////////////////////////////////////////////\n// class basic_binary_iarchive - read serialized objects from a input binary stream\ntemplate\nclass BOOST_SYMBOL_VISIBLE basic_binary_iarchive :\n public detail::common_iarchive\n{\n#ifdef BOOST_NO_MEMBER_TEMPLATE_FRIENDS\npublic:\n#else\nprotected:\n #if BOOST_WORKAROUND(BOOST_MSVC, < 1500)\n // for some inexplicable reason insertion of \"class\" generates compile erro\n // on msvc 7.1\n friend detail::interface_iarchive;\n #else\n friend class detail::interface_iarchive;\n #endif\n#endif\n // intermediate level to support override of operators\n // fot templates in the absence of partial function\n // template ordering. If we get here pass to base class\n // note extra nonsense to sneak it pass the borland compilers\n typedef detail::common_iarchive detail_common_iarchive;\n template\n void load_override(T & t){\n this->detail_common_iarchive::load_override(t);\n }\n\n // include these to trap a change in binary format which\n // isn't specifically handled\n // upto 32K classes\n BOOST_STATIC_ASSERT(sizeof(class_id_type) == sizeof(int_least16_t));\n BOOST_STATIC_ASSERT(sizeof(class_id_reference_type) == sizeof(int_least16_t));\n // upto 2G objects\n BOOST_STATIC_ASSERT(sizeof(object_id_type) == sizeof(uint_least32_t));\n BOOST_STATIC_ASSERT(sizeof(object_reference_type) == sizeof(uint_least32_t));\n\n // binary files don't include the optional information\n void load_override(class_id_optional_type & /* t */){}\n\n void load_override(tracking_type & t, int /*version*/){\n boost::serialization::library_version_type lv = this->get_library_version();\n if(boost::serialization::library_version_type(6) < lv){\n int_least8_t x=0;\n * this->This() >> x;\n t = boost::archive::tracking_type(x);\n }\n else{\n bool x=0;\n * this->This() >> x;\n t = boost::archive::tracking_type(x);\n }\n }\n void load_override(class_id_type & t){\n boost::serialization::library_version_type lv = this->get_library_version();\n /*\n * library versions:\n * boost 1.39 -> 5\n * boost 1.43 -> 7\n * boost 1.47 -> 9\n *\n *\n * 1) in boost 1.43 and inferior, class_id_type is always a 16bit value, with no check on the library version\n * --> this means all archives with version v <= 7 are written with a 16bit class_id_type\n * 2) in boost 1.44 this load_override has disappeared (and thus boost 1.44 is not backward compatible at all !!)\n * 3) recent boosts reintroduced load_override with a test on the version :\n * - v > 7 : this->detail_common_iarchive::load_override(t, version)\n * - v > 6 : 16bit\n * - other : 32bit\n * --> which is obviously incorrect, see point 1\n *\n * the fix here decodes class_id_type on 16bit for all v <= 7, which seems to be the correct behaviour ...\n */\n if(boost::serialization::library_version_type (7) < lv){\n this->detail_common_iarchive::load_override(t);\n }\n else{\n int_least16_t x=0;\n * this->This() >> x;\n t = boost::archive::class_id_type(x);\n }\n }\n void load_override(class_id_reference_type & t){\n load_override(static_cast(t));\n }\n\n void load_override(version_type & t){\n boost::serialization::library_version_type lv = this->get_library_version();\n if(boost::serialization::library_version_type(7) < lv){\n this->detail_common_iarchive::load_override(t);\n }\n else\n if(boost::serialization::library_version_type(6) < lv){\n uint_least8_t x=0;\n * this->This() >> x;\n t = boost::archive::version_type(x);\n }\n else\n if(boost::serialization::library_version_type(5) < lv){\n uint_least16_t x=0;\n * this->This() >> x;\n t = boost::archive::version_type(x);\n }\n else\n if(boost::serialization::library_version_type(2) < lv){\n // upto 255 versions\n unsigned char x=0;\n * this->This() >> x;\n t = version_type(x);\n }\n else{\n unsigned int x=0;\n * this->This() >> x;\n t = boost::archive::version_type(x);\n }\n }\n\n void load_override(boost::serialization::item_version_type & t){\n boost::serialization::library_version_type lv = this->get_library_version();\n// if(boost::serialization::library_version_type(7) < lvt){\n if(boost::serialization::library_version_type(6) < lv){\n this->detail_common_iarchive::load_override(t);\n }\n else\n if(boost::serialization::library_version_type(6) < lv){\n uint_least16_t x=0;\n * this->This() >> x;\n t = boost::serialization::item_version_type(x);\n }\n else{\n unsigned int x=0;\n * this->This() >> x;\n t = boost::serialization::item_version_type(x);\n }\n }\n\n void load_override(serialization::collection_size_type & t){\n if(boost::serialization::library_version_type(5) < this->get_library_version()){\n this->detail_common_iarchive::load_override(t);\n }\n else{\n unsigned int x=0;\n * this->This() >> x;\n t = serialization::collection_size_type(x);\n }\n }\n\n BOOST_ARCHIVE_OR_WARCHIVE_DECL void\n load_override(class_name_type & t);\n BOOST_ARCHIVE_OR_WARCHIVE_DECL void\n init();\n\n basic_binary_iarchive(unsigned int flags) :\n detail::common_iarchive(flags)\n {}\n};\n\n} // namespace archive\n} // namespace boost\n\n#ifdef BOOST_MSVC\n#pragma warning(pop)\n#endif\n\n#include // pops abi_suffix.hpp pragmas\n\n#endif // BOOST_ARCHIVE_BASIC_BINARY_IARCHIVE_HPP\n" }, { "path": "include/boost/archive/basic_binary_iprimitive.hpp", "content": "#ifndef BOOST_ARCHIVE_BINARY_IPRIMITIVE_HPP\n#define BOOST_ARCHIVE_BINARY_IPRIMITIVE_HPP\n\n// MS compatible compilers support #pragma once\n#if defined(_MSC_VER)\n# pragma once\n#endif\n\n#if defined(_MSC_VER)\n#pragma warning( disable : 4800 )\n#endif\n\n/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8\n// basic_binary_iprimitive.hpp\n//\n// archives stored as native binary - this should be the fastest way\n// to archive the state of a group of objects. It makes no attempt to\n// convert to any canonical form.\n\n// IN GENERAL, ARCHIVES CREATED WITH THIS CLASS WILL NOT BE READABLE\n// ON PLATFORM APART FROM THE ONE THEY ARE CREATED ON\n\n// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .\n// Use, modification and distribution is subject to the Boost Software\n// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at\n// http://www.boost.org/LICENSE_1_0.txt)\n\n// See http://www.boost.org for updates, documentation, and revision history.\n\n#include \n#include \n#include \n#include // std::memcpy\n#include // std::size_t\n#include // basic_streambuf\n#include \n\n#include \n#if defined(BOOST_NO_STDC_NAMESPACE)\nnamespace std{\n using ::memcpy;\n using ::size_t;\n} // namespace std\n#endif\n\n#include \n#include \n#include \n#include \n\n#include \n#include \n\n#include \n#include \n#include \n#include \n#include // must be the last header\n\nnamespace boost {\nnamespace archive {\n\n/////////////////////////////////////////////////////////////////////////////\n// class binary_iarchive - read serialized objects from a input binary stream\ntemplate\nclass BOOST_SYMBOL_VISIBLE basic_binary_iprimitive {\n#ifndef BOOST_NO_MEMBER_TEMPLATE_FRIENDS\n friend class load_access;\nprotected:\n#else\npublic:\n#endif\n std::basic_streambuf & m_sb;\n // return a pointer to the most derived class\n Archive * This(){\n return static_cast(this);\n }\n\n #ifndef BOOST_NO_STD_LOCALE\n // note order! - if you change this, libstd++ will fail!\n // a) create new locale with new codecvt facet\n // b) save current locale\n // c) change locale to new one\n // d) use stream buffer\n // e) change locale back to original\n // f) destroy new codecvt facet\n boost::archive::codecvt_null codecvt_null_facet;\n basic_streambuf_locale_saver locale_saver;\n std::locale archive_locale;\n #endif\n\n // main template for serialization of primitive types\n template\n void load(T & t){\n load_binary(& t, sizeof(T));\n }\n\n /////////////////////////////////////////////////////////\n // fundamental types that need special treatment\n\n // trap usage of invalid uninitialized boolean\n void load(bool & t){\n load_binary(& t, sizeof(t));\n int i = t;\n BOOST_ASSERT(0 == i || 1 == i);\n (void)i; // warning suppression for release builds.\n }\n BOOST_ARCHIVE_OR_WARCHIVE_DECL void\n load(std::string &s);\n #ifndef BOOST_NO_STD_WSTRING\n BOOST_ARCHIVE_OR_WARCHIVE_DECL void\n load(std::wstring &ws);\n #endif\n BOOST_ARCHIVE_OR_WARCHIVE_DECL void\n load(char * t);\n BOOST_ARCHIVE_OR_WARCHIVE_DECL void\n load(wchar_t * t);\n\n BOOST_ARCHIVE_OR_WARCHIVE_DECL void\n init();\n BOOST_ARCHIVE_OR_WARCHIVE_DECL\n basic_binary_iprimitive(\n std::basic_streambuf & sb,\n bool no_codecvt\n );\n BOOST_ARCHIVE_OR_WARCHIVE_DECL\n ~basic_binary_iprimitive();\npublic:\n // we provide an optimized load for all fundamental types\n // typedef serialization::is_bitwise_serializable\n // use_array_optimization;\n struct use_array_optimization {\n template \n #if defined(BOOST_NO_DEPENDENT_NESTED_DERIVATIONS)\n struct apply {\n typedef typename boost::serialization::is_bitwise_serializable< T >::type type;\n };\n #else\n struct apply : public boost::serialization::is_bitwise_serializable< T > {};\n #endif\n };\n\n // the optimized load_array dispatches to load_binary\n template \n void load_array(serialization::array_wrapper& a, unsigned int)\n {\n load_binary(a.address(),a.count()*sizeof(ValueType));\n }\n\n void\n load_binary(void *address, std::size_t count);\n};\n\ntemplate\ninline void\nbasic_binary_iprimitive::load_binary(\n void *address,\n std::size_t count\n){\n // note: an optimizer should eliminate the following for char files\n BOOST_ASSERT(\n static_cast(count / sizeof(Elem))\n <= boost::integer_traits::const_max\n );\n std::streamsize s = static_cast(count / sizeof(Elem));\n std::streamsize scount = m_sb.sgetn(\n static_cast(address),\n s\n );\n if(scount != s)\n boost::serialization::throw_exception(\n archive_exception(archive_exception::input_stream_error)\n );\n // note: an optimizer should eliminate the following for char files\n BOOST_ASSERT(count % sizeof(Elem) <= boost::integer_traits::const_max);\n s = static_cast(count % sizeof(Elem));\n if(0 < s){\n// if(is.fail())\n// boost::serialization::throw_exception(\n// archive_exception(archive_exception::stream_error)\n// );\n Elem t;\n scount = m_sb.sgetn(& t, 1);\n if(scount != 1)\n boost::serialization::throw_exception(\n archive_exception(archive_exception::input_stream_error)\n );\n std::memcpy(static_cast(address) + (count - s), &t, static_cast(s));\n }\n}\n\n} // namespace archive\n} // namespace boost\n\n#include // pop pragmas\n\n#endif // BOOST_ARCHIVE_BINARY_IPRIMITIVE_HPP\n" }, { "path": "include/boost/archive/basic_binary_oarchive.hpp", "content": "#ifndef BOOST_ARCHIVE_BASIC_BINARY_OARCHIVE_HPP\n#define BOOST_ARCHIVE_BASIC_BINARY_OARCHIVE_HPP\n\n// MS compatible compilers support #pragma once\n#if defined(_MSC_VER)\n# pragma once\n#endif\n\n/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8\n// basic_binary_oarchive.hpp\n\n// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .\n// Use, modification and distribution is subject to the Boost Software\n// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at\n// http://www.boost.org/LICENSE_1_0.txt)\n\n// See http://www.boost.org for updates, documentation, and revision history.\n\n// archives stored as native binary - this should be the fastest way\n// to archive the state of a group of objects. It makes no attempt to\n// convert to any canonical form.\n\n// IN GENERAL, ARCHIVES CREATED WITH THIS CLASS WILL NOT BE READABLE\n// ON PLATFORM APART FROM THE ONE THEY ARE CREATE ON\n\n#include \n#include \n#include \n\n#include \n#include \n\n#include \n#include \n#include \n#include \n\n#include // must be the last header\n\n#ifdef BOOST_MSVC\n# pragma warning(push)\n# pragma warning(disable : 4511 4512)\n#endif\n\nnamespace boost {\nnamespace archive {\n\nnamespace detail {\n template class interface_oarchive;\n} // namespace detail\n\n//////////////////////////////////////////////////////////////////////\n// class basic_binary_oarchive - write serialized objects to a binary output stream\n// note: this archive has no pretensions to portability. Archive format\n// may vary across machine architectures and compilers. About the only\n// guarantee is that an archive created with this code will be readable\n// by a program built with the same tools for the same machine. This class\n// does have the virtue of building the smallest archive in the minimum amount\n// of time. So under some circumstances it may be he right choice.\ntemplate\nclass BOOST_SYMBOL_VISIBLE basic_binary_oarchive :\n public detail::common_oarchive\n{\n#ifdef BOOST_NO_MEMBER_TEMPLATE_FRIENDS\npublic:\n#else\nprotected:\n #if BOOST_WORKAROUND(BOOST_MSVC, < 1500)\n // for some inexplicable reason insertion of \"class\" generates compile erro\n // on msvc 7.1\n friend detail::interface_oarchive;\n #else\n friend class detail::interface_oarchive;\n #endif\n#endif\n // any datatype not specified below will be handled by base class\n typedef detail::common_oarchive detail_common_oarchive;\n template\n void save_override(const T & t){\n this->detail_common_oarchive::save_override(t);\n }\n\n // include these to trap a change in binary format which\n // isn't specifically handled\n BOOST_STATIC_ASSERT(sizeof(tracking_type) == sizeof(bool));\n // upto 32K classes\n BOOST_STATIC_ASSERT(sizeof(class_id_type) == sizeof(int_least16_t));\n BOOST_STATIC_ASSERT(sizeof(class_id_reference_type) == sizeof(int_least16_t));\n // upto 2G objects\n BOOST_STATIC_ASSERT(sizeof(object_id_type) == sizeof(uint_least32_t));\n BOOST_STATIC_ASSERT(sizeof(object_reference_type) == sizeof(uint_least32_t));\n\n // binary files don't include the optional information\n void save_override(const class_id_optional_type & /* t */){}\n\n // enable this if we decide to support generation of previous versions\n #if 0\n void save_override(const boost::archive::version_type & t){\n library_version_type lvt = this->get_library_version();\n if(boost::serialization::library_version_type(7) < lvt){\n this->detail_common_oarchive::save_override(t);\n }\n else\n if(boost::serialization::library_version_type(6) < lvt){\n const boost::uint_least16_t x = t;\n * this->This() << x;\n }\n else{\n const unsigned int x = t;\n * this->This() << x;\n }\n }\n void save_override(const boost::serialization::item_version_type & t){\n library_version_type lvt = this->get_library_version();\n if(boost::serialization::library_version_type(7) < lvt){\n this->detail_common_oarchive::save_override(t);\n }\n else\n if(boost::serialization::library_version_type(6) < lvt){\n const boost::uint_least16_t x = t;\n * this->This() << x;\n }\n else{\n const unsigned int x = t;\n * this->This() << x;\n }\n }\n\n void save_override(class_id_type & t){\n library_version_type lvt = this->get_library_version();\n if(boost::serialization::library_version_type(7) < lvt){\n this->detail_common_oarchive::save_override(t);\n }\n else\n if(boost::serialization::library_version_type(6) < lvt){\n const boost::int_least16_t x = t;\n * this->This() << x;\n }\n else{\n const int x = t;\n * this->This() << x;\n }\n }\n void save_override(class_id_reference_type & t){\n save_override(static_cast(t));\n }\n\n #endif\n\n // explicitly convert to char * to avoid compile ambiguities\n void save_override(const class_name_type & t){\n const std::string s(t);\n * this->This() << s;\n }\n\n #if 0\n void save_override(const serialization::collection_size_type & t){\n if (get_library_version() < boost::serialization::library_version_type(6)){\n unsigned int x=0;\n * this->This() >> x;\n t = serialization::collection_size_type(x);\n }\n else{\n * this->This() >> t;\n }\n }\n #endif\n BOOST_ARCHIVE_OR_WARCHIVE_DECL void\n init();\n\n basic_binary_oarchive(unsigned int flags) :\n detail::common_oarchive(flags)\n {}\n};\n\n} // namespace archive\n} // namespace boost\n\n#ifdef BOOST_MSVC\n#pragma warning(pop)\n#endif\n\n#include // pops abi_suffix.hpp pragmas\n\n#endif // BOOST_ARCHIVE_BASIC_BINARY_OARCHIVE_HPP\n" }, { "path": "include/boost/archive/basic_binary_oprimitive.hpp", "content": "#ifndef BOOST_ARCHIVE_BASIC_BINARY_OPRIMITIVE_HPP\n#define BOOST_ARCHIVE_BASIC_BINARY_OPRIMITIVE_HPP\n\n// MS compatible compilers support #pragma once\n#if defined(_MSC_VER)\n# pragma once\n#endif\n\n/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8\n// basic_binary_oprimitive.hpp\n\n// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .\n// Use, modification and distribution is subject to the Boost Software\n// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at\n// http://www.boost.org/LICENSE_1_0.txt)\n\n// See http://www.boost.org for updates, documentation, and revision history.\n\n// archives stored as native binary - this should be the fastest way\n// to archive the state of a group of objects. It makes no attempt to\n// convert to any canonical form.\n\n// IN GENERAL, ARCHIVES CREATED WITH THIS CLASS WILL NOT BE READABLE\n// ON PLATFORM APART FROM THE ONE THEY ARE CREATE ON\n\n#include \n#include \n#include \n#include // basic_streambuf\n#include \n#include // size_t\n\n#include \n#if defined(BOOST_NO_STDC_NAMESPACE)\nnamespace std{\n using ::size_t;\n} // namespace std\n#endif\n\n#include \n#include \n#include \n#include \n#include \n\n#include \n#include \n\n#include \n#include \n#include \n#include \n#include // must be the last header\n\nnamespace boost {\nnamespace archive {\n\n/////////////////////////////////////////////////////////////////////////\n// class basic_binary_oprimitive - binary output of primitives\n\ntemplate\nclass BOOST_SYMBOL_VISIBLE basic_binary_oprimitive {\n#ifndef BOOST_NO_MEMBER_TEMPLATE_FRIENDS\n friend class save_access;\nprotected:\n#else\npublic:\n#endif\n std::basic_streambuf & m_sb;\n // return a pointer to the most derived class\n Archive * This(){\n return static_cast(this);\n }\n #ifndef BOOST_NO_STD_LOCALE\n // note order! - if you change this, libstd++ will fail!\n // a) create new locale with new codecvt facet\n // b) save current locale\n // c) change locale to new one\n // d) use stream buffer\n // e) change locale back to original\n // f) destroy new codecvt facet\n boost::archive::codecvt_null codecvt_null_facet;\n basic_streambuf_locale_saver locale_saver;\n std::locale archive_locale;\n #endif\n // default saving of primitives.\n template\n void save(const T & t)\n {\n save_binary(& t, sizeof(T));\n }\n\n /////////////////////////////////////////////////////////\n // fundamental types that need special treatment\n\n // trap usage of invalid uninitialized boolean which would\n // otherwise crash on load.\n void save(const bool t){\n BOOST_ASSERT(0 == static_cast(t) || 1 == static_cast(t));\n save_binary(& t, sizeof(t));\n }\n BOOST_ARCHIVE_OR_WARCHIVE_DECL void\n save(const std::string &s);\n #ifndef BOOST_NO_STD_WSTRING\n BOOST_ARCHIVE_OR_WARCHIVE_DECL void\n save(const std::wstring &ws);\n #endif\n BOOST_ARCHIVE_OR_WARCHIVE_DECL void\n save(const char * t);\n BOOST_ARCHIVE_OR_WARCHIVE_DECL void\n save(const wchar_t * t);\n\n BOOST_ARCHIVE_OR_WARCHIVE_DECL void\n init();\n\n BOOST_ARCHIVE_OR_WARCHIVE_DECL\n basic_binary_oprimitive(\n std::basic_streambuf & sb,\n bool no_codecvt\n );\n BOOST_ARCHIVE_OR_WARCHIVE_DECL\n ~basic_binary_oprimitive();\npublic:\n\n // we provide an optimized save for all fundamental types\n // typedef serialization::is_bitwise_serializable\n // use_array_optimization;\n // workaround without using mpl lambdas\n struct use_array_optimization {\n template \n #if defined(BOOST_NO_DEPENDENT_NESTED_DERIVATIONS)\n struct apply {\n typedef typename boost::serialization::is_bitwise_serializable< T >::type type;\n };\n #else\n struct apply : public boost::serialization::is_bitwise_serializable< T > {};\n #endif\n };\n\n // the optimized save_array dispatches to save_binary\n template \n void save_array(boost::serialization::array_wrapper const& a, unsigned int)\n {\n save_binary(a.address(),a.count()*sizeof(ValueType));\n }\n\n void save_binary(const void *address, std::size_t count);\n};\n\ntemplate\ninline void\nbasic_binary_oprimitive::save_binary(\n const void *address,\n std::size_t count\n){\n // BOOST_ASSERT(count <= std::size_t(boost::integer_traits::const_max));\n // note: if the following assertions fail\n // a likely cause is that the output stream is set to \"text\"\n // mode where by cr characters receive special treatment.\n // be sure that the output stream is opened with ios::binary\n //if(os.fail())\n // boost::serialization::throw_exception(\n // archive_exception(archive_exception::output_stream_error)\n // );\n // figure number of elements to output - round up\n count = ( count + sizeof(Elem) - 1) / sizeof(Elem);\n std::streamsize scount = m_sb.sputn(\n static_cast(address),\n static_cast(count)\n );\n if(count != static_cast(scount))\n boost::serialization::throw_exception(\n archive_exception(archive_exception::output_stream_error)\n );\n //os.write(\n // static_cast(address),\n // count\n //);\n //BOOST_ASSERT(os.good());\n}\n\n} //namespace boost\n} //namespace archive\n\n#include // pop pragmas\n\n#endif // BOOST_ARCHIVE_BASIC_BINARY_OPRIMITIVE_HPP\n" }, { "path": "include/boost/archive/basic_streambuf_locale_saver.hpp", "content": "#ifndef BOOST_ARCHIVE_BASIC_STREAMBUF_LOCALE_SAVER_HPP\n#define BOOST_ARCHIVE_BASIC_STREAMBUF_LOCALE_SAVER_HPP\n\n// MS compatible compilers support #pragma once\n#if defined(_MSC_VER)\n# pragma once\n#endif\n\n/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8\n// basic_streambuf_locale_saver.hpp\n\n// (C) Copyright 2005 Robert Ramey - http://www.rrsd.com\n\n// Use, modification and distribution is subject to the Boost Software\n// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at\n// http://www.boost.org/LICENSE_1_0.txt)\n\n// See http://www.boost.org for updates, documentation, and revision history.\n\n// note derived from boost/io/ios_state.hpp\n// Copyright 2002, 2005 Daryle Walker. Use, modification, and distribution\n// are subject to the Boost Software License, Version 1.0. (See accompanying\n// file LICENSE_1_0.txt or a copy at .)\n\n// See for the library's home page.\n\n#ifndef BOOST_NO_STD_LOCALE\n\n#include // for std::locale\n#include \n#include // for std::basic_streambuf\n\n#include \n#include \n\n#ifdef BOOST_MSVC\n# pragma warning(push)\n# pragma warning(disable : 4511 4512)\n#endif\n\nnamespace boost{\nnamespace archive{\n\ntemplate < typename Ch, class Tr >\nclass basic_streambuf_locale_saver :\n private boost::noncopyable\n{\npublic:\n explicit basic_streambuf_locale_saver(std::basic_streambuf &s) :\n m_streambuf(s),\n m_locale(s.getloc())\n {}\n ~basic_streambuf_locale_saver(){\n m_streambuf.pubsync();\n m_streambuf.pubimbue(m_locale);\n }\nprivate:\n std::basic_streambuf & m_streambuf;\n std::locale const m_locale;\n};\n\ntemplate < typename Ch, class Tr >\nclass basic_istream_locale_saver :\n private boost::noncopyable\n{\npublic:\n explicit basic_istream_locale_saver(std::basic_istream &s) :\n m_istream(s),\n m_locale(s.getloc())\n {}\n ~basic_istream_locale_saver(){\n // libstdc++ crashes without this\n m_istream.sync();\n m_istream.imbue(m_locale);\n }\nprivate:\n std::basic_istream & m_istream;\n std::locale const m_locale;\n};\n\ntemplate < typename Ch, class Tr >\nclass basic_ostream_locale_saver :\n private boost::noncopyable\n{\npublic:\n explicit basic_ostream_locale_saver(std::basic_ostream &s) :\n m_ostream(s),\n m_locale(s.getloc())\n {}\n ~basic_ostream_locale_saver(){\n m_ostream.flush();\n m_ostream.imbue(m_locale);\n }\nprivate:\n std::basic_ostream & m_ostream;\n std::locale const m_locale;\n};\n\n\n} // archive\n} // boost\n\n#ifdef BOOST_MSVC\n#pragma warning(pop)\n#endif\n\n#endif // BOOST_NO_STD_LOCALE\n#endif // BOOST_ARCHIVE_BASIC_STREAMBUF_LOCALE_SAVER_HPP\n" }, { "path": "include/boost/archive/basic_text_iarchive.hpp", "content": "#ifndef BOOST_ARCHIVE_BASIC_TEXT_IARCHIVE_HPP\n#define BOOST_ARCHIVE_BASIC_TEXT_IARCHIVE_HPP\n\n// MS compatible compilers support #pragma once\n#if defined(_MSC_VER)\n# pragma once\n#endif\n\n/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8\n// basic_text_iarchive.hpp\n\n// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .\n// Use, modification and distribution is subject to the Boost Software\n// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at\n// http://www.boost.org/LICENSE_1_0.txt)\n\n// See http://www.boost.org for updates, documentation, and revision history.\n\n// archives stored as text - note these ar templated on the basic\n// stream templates to accommodate wide (and other?) kind of characters\n//\n// note the fact that on libraries without wide characters, ostream is\n// is not a specialization of basic_ostream which in fact is not defined\n// in such cases. So we can't use basic_istream but rather\n// use two template parameters\n\n#include \n#include \n\n#include \n\n#include // must be the last header\n\n#ifdef BOOST_MSVC\n# pragma warning(push)\n# pragma warning(disable : 4511 4512)\n#endif\n\nnamespace boost {\nnamespace archive {\n\nnamespace detail {\n template class interface_iarchive;\n} // namespace detail\n\n/////////////////////////////////////////////////////////////////////////\n// class basic_text_iarchive - read serialized objects from a input text stream\ntemplate\nclass BOOST_SYMBOL_VISIBLE basic_text_iarchive :\n public detail::common_iarchive\n{\n#ifdef BOOST_NO_MEMBER_TEMPLATE_FRIENDS\npublic:\n#else\nprotected:\n #if BOOST_WORKAROUND(BOOST_MSVC, < 1500)\n // for some inexplicable reason insertion of \"class\" generates compile error\n // on msvc 7.1\n friend detail::interface_iarchive;\n #else\n friend class detail::interface_iarchive;\n #endif\n#endif\n // intermediate level to support override of operators\n // fot templates in the absence of partial function\n // template ordering\n typedef detail::common_iarchive detail_common_iarchive;\n template\n void load_override(T & t){\n this->detail_common_iarchive::load_override(t);\n }\n // text file don't include the optional information\n void load_override(class_id_optional_type & /*t*/){}\n\n BOOST_ARCHIVE_OR_WARCHIVE_DECL void\n load_override(class_name_type & t);\n\n BOOST_ARCHIVE_OR_WARCHIVE_DECL void\n init();\n\n basic_text_iarchive(unsigned int flags) :\n detail::common_iarchive(flags)\n {}\n ~basic_text_iarchive() BOOST_OVERRIDE {}\n};\n\n} // namespace archive\n} // namespace boost\n\n#ifdef BOOST_MSVC\n#pragma warning(pop)\n#endif\n\n#include // pops abi_suffix.hpp pragmas\n\n#endif // BOOST_ARCHIVE_BASIC_TEXT_IARCHIVE_HPP\n" }, { "path": "include/boost/archive/basic_text_iprimitive.hpp", "content": "#ifndef BOOST_ARCHIVE_BASIC_TEXT_IPRIMITIVE_HPP\n#define BOOST_ARCHIVE_BASIC_TEXT_IPRIMITIVE_HPP\n\n// MS compatible compilers support #pragma once\n#if defined(_MSC_VER)\n# pragma once\n#endif\n\n/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8\n// basic_text_iprimitive.hpp\n\n// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .\n// Use, modification and distribution is subject to the Boost Software\n// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at\n// http://www.boost.org/LICENSE_1_0.txt)\n\n// See http://www.boost.org for updates, documentation, and revision history.\n\n// archives stored as text - note these are templated on the basic\n// stream templates to accommodate wide (and other?) kind of characters\n//\n// Note the fact that on libraries without wide characters, ostream is\n// not a specialization of basic_ostream which in fact is not defined\n// in such cases. So we can't use basic_ostream but rather\n// use two template parameters\n\n#include \n#include // size_t\n\n#include \n#if defined(BOOST_NO_STDC_NAMESPACE)\nnamespace std{\n using ::size_t;\n #if ! defined(BOOST_DINKUMWARE_STDLIB) && ! defined(__SGI_STL_PORT)\n using ::locale;\n #endif\n} // namespace std\n#endif\n\n#include \n#include \n\n#include \n#if BOOST_WORKAROUND(BOOST_DINKUMWARE_STDLIB, == 1)\n#include \n#endif\n#include \n#include \n#include \n#include \n#include // must be the last header\n\nnamespace boost {\nnamespace archive {\n\n/////////////////////////////////////////////////////////////////////////\n// class basic_text_iarchive - load serialized objects from a input text stream\n#if defined(_MSC_VER)\n#pragma warning( push )\n#pragma warning( disable : 4244 4267 )\n#endif\n\ntemplate\nclass BOOST_SYMBOL_VISIBLE basic_text_iprimitive {\nprotected:\n IStream &is;\n io::ios_flags_saver flags_saver;\n io::ios_precision_saver precision_saver;\n\n #ifndef BOOST_NO_STD_LOCALE\n // note order! - if you change this, libstd++ will fail!\n // a) create new locale with new codecvt facet\n // b) save current locale\n // c) change locale to new one\n // d) use stream buffer\n // e) change locale back to original\n // f) destroy new codecvt facet\n boost::archive::codecvt_null codecvt_null_facet;\n std::locale archive_locale;\n basic_istream_locale_saver<\n typename IStream::char_type,\n typename IStream::traits_type\n > locale_saver;\n #endif\n\n template\n void load(T & t)\n {\n if(is >> t)\n return;\n boost::serialization::throw_exception(\n archive_exception(archive_exception::input_stream_error)\n );\n }\n\n void load(char & t)\n {\n short int i;\n load(i);\n t = i;\n }\n void load(signed char & t)\n {\n short int i;\n load(i);\n t = i;\n }\n void load(unsigned char & t)\n {\n unsigned short int i;\n load(i);\n t = i;\n }\n\n #ifndef BOOST_NO_INTRINSIC_WCHAR_T\n void load(wchar_t & t)\n {\n BOOST_STATIC_ASSERT(sizeof(wchar_t) <= sizeof(int));\n int i;\n load(i);\n t = i;\n }\n #endif\n BOOST_ARCHIVE_OR_WARCHIVE_DECL\n basic_text_iprimitive(IStream &is, bool no_codecvt);\n BOOST_ARCHIVE_OR_WARCHIVE_DECL\n ~basic_text_iprimitive();\npublic:\n BOOST_ARCHIVE_OR_WARCHIVE_DECL void\n load_binary(void *address, std::size_t count);\n};\n\n#if defined(_MSC_VER)\n#pragma warning( pop )\n#endif\n\n} // namespace archive\n} // namespace boost\n\n#include // pop pragmas\n\n#endif // BOOST_ARCHIVE_BASIC_TEXT_IPRIMITIVE_HPP\n" }, { "path": "include/boost/archive/basic_text_oarchive.hpp", "content": "#ifndef BOOST_ARCHIVE_BASIC_TEXT_OARCHIVE_HPP\n#define BOOST_ARCHIVE_BASIC_TEXT_OARCHIVE_HPP\n\n// MS compatible compilers support #pragma once\n#if defined(_MSC_VER)\n# pragma once\n#endif\n\n/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8\n// basic_text_oarchive.hpp\n\n// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .\n// Use, modification and distribution is subject to the Boost Software\n// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at\n// http://www.boost.org/LICENSE_1_0.txt)\n\n// See http://www.boost.org for updates, documentation, and revision history.\n\n// archives stored as text - note these ar templated on the basic\n// stream templates to accommodate wide (and other?) kind of characters\n//\n// note the fact that on libraries without wide characters, ostream is\n// is not a specialization of basic_ostream which in fact is not defined\n// in such cases. So we can't use basic_ostream but rather\n// use two template parameters\n\n#include \n#include \n#include \n#include \n\n#include // must be the last header\n\n#ifdef BOOST_MSVC\n# pragma warning(push)\n# pragma warning(disable : 4511 4512)\n#endif\n\nnamespace boost {\nnamespace archive {\n\nnamespace detail {\n template class interface_oarchive;\n} // namespace detail\n\n/////////////////////////////////////////////////////////////////////////\n// class basic_text_oarchive\ntemplate\nclass BOOST_SYMBOL_VISIBLE basic_text_oarchive :\n public detail::common_oarchive\n{\n#ifdef BOOST_NO_MEMBER_TEMPLATE_FRIENDS\npublic:\n#else\nprotected:\n #if BOOST_WORKAROUND(BOOST_MSVC, < 1500)\n // for some inexplicable reason insertion of \"class\" generates compile erro\n // on msvc 7.1\n friend detail::interface_oarchive;\n #else\n friend class detail::interface_oarchive;\n #endif\n#endif\n\n enum {\n none,\n eol,\n space\n } delimiter;\n\n BOOST_ARCHIVE_OR_WARCHIVE_DECL void\n newtoken();\n\n void newline(){\n delimiter = eol;\n }\n\n // default processing - kick back to base class. Note the\n // extra stuff to get it passed borland compilers\n typedef detail::common_oarchive detail_common_oarchive;\n template\n void save_override(T & t){\n this->detail_common_oarchive::save_override(t);\n }\n\n // start new objects on a new line\n void save_override(const object_id_type & t){\n this->This()->newline();\n this->detail_common_oarchive::save_override(t);\n }\n\n // text file don't include the optional information\n void save_override(const class_id_optional_type & /* t */){}\n\n void save_override(const class_name_type & t){\n const std::string s(t);\n * this->This() << s;\n }\n\n BOOST_ARCHIVE_OR_WARCHIVE_DECL void\n init();\n\n basic_text_oarchive(unsigned int flags) :\n detail::common_oarchive(flags),\n delimiter(none)\n {}\n ~basic_text_oarchive() BOOST_OVERRIDE {}\n};\n\n} // namespace archive\n} // namespace boost\n\n#ifdef BOOST_MSVC\n#pragma warning(pop)\n#endif\n\n#include // pops abi_suffix.hpp pragmas\n\n#endif // BOOST_ARCHIVE_BASIC_TEXT_OARCHIVE_HPP\n" }, { "path": "include/boost/archive/basic_text_oprimitive.hpp", "content": "#ifndef BOOST_ARCHIVE_BASIC_TEXT_OPRIMITIVE_HPP\n#define BOOST_ARCHIVE_BASIC_TEXT_OPRIMITIVE_HPP\n\n// MS compatible compilers support #pragma once\n#if defined(_MSC_VER)\n# pragma once\n#endif\n\n/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8\n// basic_text_oprimitive.hpp\n\n// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .\n// Use, modification and distribution is subject to the Boost Software\n// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at\n// http://www.boost.org/LICENSE_1_0.txt)\n\n// See http://www.boost.org for updates, documentation, and revision history.\n\n// archives stored as text - note these ar templated on the basic\n// stream templates to accommodate wide (and other?) kind of characters\n//\n// note the fact that on libraries without wide characters, ostream is\n// is not a specialization of basic_ostream which in fact is not defined\n// in such cases. So we can't use basic_ostream but rather\n// use two template parameters\n\n#include \n#include \n#include // size_t\n\n#include \n#include \n#include \n\n#include \n#if BOOST_WORKAROUND(BOOST_DINKUMWARE_STDLIB, == 1)\n#include \n#endif\n\n#if defined(BOOST_NO_STDC_NAMESPACE)\nnamespace std{\n using ::size_t;\n #if ! defined(BOOST_DINKUMWARE_STDLIB) && ! defined(__SGI_STL_PORT)\n using ::locale;\n #endif\n} // namespace std\n#endif\n\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include // must be the last header\n\nnamespace boost {\nnamespace archive {\n\n/////////////////////////////////////////////////////////////////////////\n// class basic_text_oprimitive - output of primitives to stream\ntemplate\nclass BOOST_SYMBOL_VISIBLE basic_text_oprimitive\n{\nprotected:\n OStream &os;\n io::ios_flags_saver flags_saver;\n io::ios_precision_saver precision_saver;\n\n #ifndef BOOST_NO_STD_LOCALE\n // note order! - if you change this, libstd++ will fail!\n // a) create new locale with new codecvt facet\n // b) save current locale\n // c) change locale to new one\n // d) use stream buffer\n // e) change locale back to original\n // f) destroy new codecvt facet\n boost::archive::codecvt_null codecvt_null_facet;\n std::locale archive_locale;\n basic_ostream_locale_saver<\n typename OStream::char_type,\n typename OStream::traits_type\n > locale_saver;\n #endif\n\n /////////////////////////////////////////////////////////\n // fundamental types that need special treatment\n void save(const bool t){\n // trap usage of invalid uninitialized boolean which would\n // otherwise crash on load.\n BOOST_ASSERT(0 == static_cast(t) || 1 == static_cast(t));\n if(os.fail())\n boost::serialization::throw_exception(\n archive_exception(archive_exception::output_stream_error)\n );\n os << t;\n }\n void save(const signed char t)\n {\n save(static_cast(t));\n }\n void save(const unsigned char t)\n {\n save(static_cast(t));\n }\n void save(const char t)\n {\n save(static_cast(t));\n }\n #ifndef BOOST_NO_INTRINSIC_WCHAR_T\n void save(const wchar_t t)\n {\n BOOST_STATIC_ASSERT(sizeof(wchar_t) <= sizeof(int));\n save(static_cast(t));\n }\n #endif\n\n /////////////////////////////////////////////////////////\n // saving of any types not listed above\n\n template\n void save_impl(const T &t, boost::mpl::bool_ &){\n if(os.fail())\n boost::serialization::throw_exception(\n archive_exception(archive_exception::output_stream_error)\n );\n os << t;\n }\n\n /////////////////////////////////////////////////////////\n // floating point types need even more special treatment\n // the following determines whether the type T is some sort\n // of floating point type. Note that we then assume that\n // the stream << operator is defined on that type - if not\n // we'll get a compile time error. This is meant to automatically\n // support synthesized types which support floating point\n // operations. Also it should handle compiler dependent types\n // such long double. Due to John Maddock.\n\n template\n struct is_float {\n typedef typename mpl::bool_<\n boost::is_floating_point::value\n || (std::numeric_limits::is_specialized\n && !std::numeric_limits::is_integer\n && !std::numeric_limits::is_exact\n && std::numeric_limits::max_exponent)\n >::type type;\n };\n\n template\n void save_impl(const T &t, boost::mpl::bool_ &){\n // must be a user mistake - can't serialize un-initialized data\n if(os.fail()){\n boost::serialization::throw_exception(\n archive_exception(archive_exception::output_stream_error)\n );\n }\n // The formulae for the number of decimal digits required is given in\n // http://www2.open-std.org/JTC1/SC22/WG21/docs/papers/2005/n1822.pdf\n // which is derived from Kahan's paper:\n // www.eecs.berkeley.edu/~wkahan/ieee754status/ieee754.ps\n // const unsigned int digits = (std::numeric_limits::digits * 3010) / 10000;\n // note: I've commented out the above because I didn't get good results. e.g.\n // in one case I got a difference of 19 units.\n const unsigned int digits =\n #ifndef BOOST_NO_CXX11_NUMERIC_LIMITS\n std::numeric_limits::max_digits10;\n #else\n std::numeric_limits::digits10 + 2;\n #endif\n os << std::setprecision(digits) << std::scientific << t;\n }\n\n template\n void save(const T & t){\n typename is_float::type tf;\n save_impl(t, tf);\n }\n\n BOOST_ARCHIVE_OR_WARCHIVE_DECL\n basic_text_oprimitive(OStream & os, bool no_codecvt);\n BOOST_ARCHIVE_OR_WARCHIVE_DECL\n ~basic_text_oprimitive();\npublic:\n // unformatted append of one character\n void put(typename OStream::char_type c){\n if(os.fail())\n boost::serialization::throw_exception(\n archive_exception(archive_exception::output_stream_error)\n );\n os.put(c);\n }\n // unformatted append of null terminated string\n void put(const char * s){\n while('\\0' != *s)\n os.put(*s++);\n }\n BOOST_ARCHIVE_OR_WARCHIVE_DECL void\n save_binary(const void *address, std::size_t count);\n};\n\n} //namespace boost\n} //namespace archive\n\n#include // pops abi_suffix.hpp pragmas\n\n#endif // BOOST_ARCHIVE_BASIC_TEXT_OPRIMITIVE_HPP\n" }, { "path": "include/boost/archive/basic_xml_archive.hpp", "content": "#ifndef BOOST_ARCHIVE_BASIC_XML_TEXT_ARCHIVE_HPP\n#define BOOST_ARCHIVE_BASIC_XML_TEXT_ARCHIVE_HPP\n\n// MS compatible compilers support #pragma once\n#if defined(_MSC_VER)\n# pragma once\n#endif\n\n/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8\n// basic_xml_archive.hpp:\n\n// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .\n// Use, modification and distribution is subject to the Boost Software\n// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at\n// http://www.boost.org/LICENSE_1_0.txt)\n\n// See http://www.boost.org for updates, documentation, and revision history.\n\n#include \n\n#include \n#include // must be the last header\n\nnamespace boost {\nnamespace archive {\n\n// constant strings used in xml i/o\n\nextern\nBOOST_ARCHIVE_DECL const char *\nBOOST_ARCHIVE_XML_OBJECT_ID();\n\nextern\nBOOST_ARCHIVE_DECL const char *\nBOOST_ARCHIVE_XML_OBJECT_REFERENCE();\n\nextern\nBOOST_ARCHIVE_DECL const char *\nBOOST_ARCHIVE_XML_CLASS_ID();\n\nextern\nBOOST_ARCHIVE_DECL const char *\nBOOST_ARCHIVE_XML_CLASS_ID_REFERENCE();\n\nextern\nBOOST_ARCHIVE_DECL const char *\nBOOST_ARCHIVE_XML_CLASS_NAME();\n\nextern\nBOOST_ARCHIVE_DECL const char *\nBOOST_ARCHIVE_XML_TRACKING();\n\nextern\nBOOST_ARCHIVE_DECL const char *\nBOOST_ARCHIVE_XML_VERSION();\n\nextern\nBOOST_ARCHIVE_DECL const char *\nBOOST_ARCHIVE_XML_SIGNATURE();\n\n}// namespace archive\n}// namespace boost\n\n#include // pops abi_suffix.hpp pragmas\n\n#endif // BOOST_ARCHIVE_BASIC_XML_TEXT_ARCHIVE_HPP\n\n" }, { "path": "include/boost/archive/basic_xml_iarchive.hpp", "content": "#ifndef BOOST_ARCHIVE_BASIC_XML_IARCHIVE_HPP\n#define BOOST_ARCHIVE_BASIC_XML_IARCHIVE_HPP\n\n// MS compatible compilers support #pragma once\n#if defined(_MSC_VER)\n# pragma once\n#endif\n\n/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8\n// basic_xml_iarchive.hpp\n\n// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .\n// Use, modification and distribution is subject to the Boost Software\n// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at\n// http://www.boost.org/LICENSE_1_0.txt)\n\n// See http://www.boost.org for updates, documentation, and revision history.\n\n#include \n#include \n\n#include \n#include \n#include \n\n#include // must be the last header\n\n#ifdef BOOST_MSVC\n# pragma warning(push)\n# pragma warning(disable : 4511 4512)\n#endif\n\nnamespace boost {\nnamespace archive {\n\nnamespace detail {\n template class interface_iarchive;\n} // namespace detail\n\n/////////////////////////////////////////////////////////////////////////\n// class basic_xml_iarchive - read serialized objects from a input text stream\ntemplate\nclass BOOST_SYMBOL_VISIBLE basic_xml_iarchive :\n public detail::common_iarchive\n{\n unsigned int depth;\n#ifdef BOOST_NO_MEMBER_TEMPLATE_FRIENDS\npublic:\n#else\nprotected:\n friend class detail::interface_iarchive;\n#endif\n BOOST_ARCHIVE_OR_WARCHIVE_DECL void\n load_start(const char *name);\n BOOST_ARCHIVE_OR_WARCHIVE_DECL void\n load_end(const char *name);\n\n // Anything not an attribute and not a name-value pair is an\n // should be trapped here.\n template\n void load_override(T & t)\n {\n // If your program fails to compile here, its most likely due to\n // not specifying an nvp wrapper around the variable to\n // be serialized.\n BOOST_MPL_ASSERT((serialization::is_wrapper< T >));\n this->detail_common_iarchive::load_override(t);\n }\n\n // Anything not an attribute - see below - should be a name value\n // pair and be processed here\n typedef detail::common_iarchive detail_common_iarchive;\n template\n void load_override(\n const boost::serialization::nvp< T > & t\n ){\n this->This()->load_start(t.name());\n this->detail_common_iarchive::load_override(t.value());\n this->This()->load_end(t.name());\n }\n\n // specific overrides for attributes - handle as\n // primitives. These are not name-value pairs\n // so they have to be intercepted here and passed on to load.\n // although the class_id is included in the xml text file in order\n // to make the file self describing, it isn't used when loading\n // an xml archive. So we can skip it here. Note: we MUST override\n // it otherwise it will be loaded as a normal primitive w/o tag and\n // leaving the archive in an undetermined state\n BOOST_ARCHIVE_OR_WARCHIVE_DECL void\n load_override(class_id_type & t);\n void load_override(class_id_optional_type & /* t */){}\n BOOST_ARCHIVE_OR_WARCHIVE_DECL void\n load_override(object_id_type & t);\n BOOST_ARCHIVE_OR_WARCHIVE_DECL void\n load_override(version_type & t);\n BOOST_ARCHIVE_OR_WARCHIVE_DECL void\n load_override(tracking_type & t);\n // class_name_type can't be handled here as it depends upon the\n // char type used by the stream. So require the derived implementation\n // handle this.\n // void load_override(class_name_type & t);\n\n BOOST_ARCHIVE_OR_WARCHIVE_DECL\n basic_xml_iarchive(unsigned int flags);\n BOOST_ARCHIVE_OR_WARCHIVE_DECL\n ~basic_xml_iarchive() BOOST_OVERRIDE;\n};\n\n} // namespace archive\n} // namespace boost\n\n#ifdef BOOST_MSVC\n#pragma warning(pop)\n#endif\n\n#include // pops abi_suffix.hpp pragmas\n\n#endif // BOOST_ARCHIVE_BASIC_XML_IARCHIVE_HPP\n" }, { "path": "include/boost/archive/basic_xml_oarchive.hpp", "content": "#ifndef BOOST_ARCHIVE_BASIC_XML_OARCHIVE_HPP\n#define BOOST_ARCHIVE_BASIC_XML_OARCHIVE_HPP\n\n// MS compatible compilers support #pragma once\n#if defined(_MSC_VER)\n# pragma once\n#endif\n\n/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8\n// basic_xml_oarchive.hpp\n\n// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .\n// Use, modification and distribution is subject to the Boost Software\n// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at\n// http://www.boost.org/LICENSE_1_0.txt)\n\n// See http://www.boost.org for updates, documentation, and revision history.\n\n#include \n#include \n\n#include \n#include \n#include \n\n#include // must be the last header\n\n#ifdef BOOST_MSVC\n# pragma warning(push)\n# pragma warning(disable : 4511 4512)\n#endif\n\nnamespace boost {\nnamespace archive {\n\nnamespace detail {\n template class interface_oarchive;\n} // namespace detail\n\n//////////////////////////////////////////////////////////////////////\n// class basic_xml_oarchive - write serialized objects to a xml output stream\ntemplate\nclass BOOST_SYMBOL_VISIBLE basic_xml_oarchive :\n public detail::common_oarchive\n{\n // special stuff for xml output\n unsigned int depth;\n bool pending_preamble;\n#ifdef BOOST_NO_MEMBER_TEMPLATE_FRIENDS\npublic:\n#else\nprotected:\n friend class detail::interface_oarchive;\n#endif\n bool indent_next;\n BOOST_ARCHIVE_OR_WARCHIVE_DECL void\n indent();\n BOOST_ARCHIVE_OR_WARCHIVE_DECL void\n init();\n BOOST_ARCHIVE_OR_WARCHIVE_DECL void\n windup();\n BOOST_ARCHIVE_OR_WARCHIVE_DECL void\n write_attribute(\n const char *attribute_name,\n int t,\n const char *conjunction = \"=\\\"\"\n );\n BOOST_ARCHIVE_OR_WARCHIVE_DECL void\n write_attribute(\n const char *attribute_name,\n const char *key\n );\n // helpers used below\n BOOST_ARCHIVE_OR_WARCHIVE_DECL void\n save_start(const char *name);\n BOOST_ARCHIVE_OR_WARCHIVE_DECL void\n save_end(const char *name);\n BOOST_ARCHIVE_OR_WARCHIVE_DECL void\n end_preamble();\n\n // Anything not an attribute and not a name-value pair is an\n // error and should be trapped here.\n template\n void save_override(T & t)\n {\n // If your program fails to compile here, its most likely due to\n // not specifying an nvp wrapper around the variable to\n // be serialized.\n BOOST_MPL_ASSERT((serialization::is_wrapper< T >));\n this->detail_common_oarchive::save_override(t);\n }\n\n // special treatment for name-value pairs.\n typedef detail::common_oarchive detail_common_oarchive;\n template\n void save_override(\n const ::boost::serialization::nvp< T > & t\n ){\n this->This()->save_start(t.name());\n this->detail_common_oarchive::save_override(t.const_value());\n this->This()->save_end(t.name());\n }\n\n // specific overrides for attributes - not name value pairs so we\n // want to trap them before the above \"fall through\"\n BOOST_ARCHIVE_OR_WARCHIVE_DECL void\n save_override(const class_id_type & t);\n BOOST_ARCHIVE_OR_WARCHIVE_DECL void\n save_override(const class_id_optional_type & t);\n BOOST_ARCHIVE_OR_WARCHIVE_DECL void\n save_override(const class_id_reference_type & t);\n BOOST_ARCHIVE_OR_WARCHIVE_DECL void\n save_override(const object_id_type & t);\n BOOST_ARCHIVE_OR_WARCHIVE_DECL void\n save_override(const object_reference_type & t);\n BOOST_ARCHIVE_OR_WARCHIVE_DECL void\n save_override(const version_type & t);\n BOOST_ARCHIVE_OR_WARCHIVE_DECL void\n save_override(const class_name_type & t);\n BOOST_ARCHIVE_OR_WARCHIVE_DECL void\n save_override(const tracking_type & t);\n\n BOOST_ARCHIVE_OR_WARCHIVE_DECL\n basic_xml_oarchive(unsigned int flags);\n BOOST_ARCHIVE_OR_WARCHIVE_DECL\n ~basic_xml_oarchive() BOOST_OVERRIDE;\n};\n\n} // namespace archive\n} // namespace boost\n\n#ifdef BOOST_MSVC\n#pragma warning(pop)\n#endif\n\n#include // pops abi_suffix.hpp pragmas\n\n#endif // BOOST_ARCHIVE_BASIC_XML_OARCHIVE_HPP\n" }, { "path": "include/boost/archive/binary_iarchive.hpp", "content": "#ifndef BOOST_ARCHIVE_BINARY_IARCHIVE_HPP\n#define BOOST_ARCHIVE_BINARY_IARCHIVE_HPP\n\n// MS compatible compilers support #pragma once\n#if defined(_MSC_VER)\n# pragma once\n#endif\n\n/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8\n// binary_iarchive.hpp\n\n// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .\n// Use, modification and distribution is subject to the Boost Software\n// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at\n// http://www.boost.org/LICENSE_1_0.txt)\n\n// See http://www.boost.org for updates, documentation, and revision history.\n\n#include \n#include \n#include \n\n#ifdef BOOST_MSVC\n# pragma warning(push)\n# pragma warning(disable : 4511 4512)\n#endif\n\nnamespace boost {\nnamespace archive {\n\n// do not derive from this class. If you want to extend this functionality\n// via inheritance, derived from binary_iarchive_impl instead. This will\n// preserve correct static polymorphism.\nclass BOOST_SYMBOL_VISIBLE binary_iarchive :\n public binary_iarchive_impl<\n boost::archive::binary_iarchive,\n std::istream::char_type,\n std::istream::traits_type\n >{\npublic:\n binary_iarchive(std::istream & is, unsigned int flags = 0) :\n binary_iarchive_impl<\n binary_iarchive, std::istream::char_type, std::istream::traits_type\n >(is, flags)\n {\n init(flags);\n }\n binary_iarchive(std::streambuf & bsb, unsigned int flags = 0) :\n binary_iarchive_impl<\n binary_iarchive, std::istream::char_type, std::istream::traits_type\n >(bsb, flags)\n {\n init(flags);\n }\n};\n\n} // namespace archive\n} // namespace boost\n\n// required by export\nBOOST_SERIALIZATION_REGISTER_ARCHIVE(boost::archive::binary_iarchive)\nBOOST_SERIALIZATION_USE_ARRAY_OPTIMIZATION(boost::archive::binary_iarchive)\n\n#ifdef BOOST_MSVC\n#pragma warning(pop)\n#endif\n\n#endif // BOOST_ARCHIVE_BINARY_IARCHIVE_HPP\n" }, { "path": "include/boost/archive/binary_iarchive_impl.hpp", "content": "#ifndef BOOST_ARCHIVE_BINARY_IARCHIVE_IMPL_HPP\n#define BOOST_ARCHIVE_BINARY_IARCHIVE_IMPL_HPP\n\n// MS compatible compilers support #pragma once\n#if defined(_MSC_VER)\n# pragma once\n#endif\n\n/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8\n// binary_iarchive_impl.hpp\n\n// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .\n// Use, modification and distribution is subject to the Boost Software\n// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at\n// http://www.boost.org/LICENSE_1_0.txt)\n\n// See http://www.boost.org for updates, documentation, and revision history.\n\n#include \n#include \n#include \n\n#ifdef BOOST_MSVC\n# pragma warning(push)\n# pragma warning(disable : 4511 4512)\n#endif\n\nnamespace boost {\nnamespace archive {\n\nnamespace detail {\n template class interface_iarchive;\n} // namespace detail\n\ntemplate\nclass BOOST_SYMBOL_VISIBLE binary_iarchive_impl :\n public basic_binary_iprimitive,\n public basic_binary_iarchive\n{\n#ifdef BOOST_NO_MEMBER_TEMPLATE_FRIENDS\npublic:\n#else\nprotected:\n #if BOOST_WORKAROUND(BOOST_MSVC, < 1500)\n // for some inexplicable reason insertion of \"class\" generates compile erro\n // on msvc 7.1\n friend detail::interface_iarchive;\n friend basic_binary_iarchive;\n friend load_access;\n #else\n friend class detail::interface_iarchive;\n friend class basic_binary_iarchive;\n friend class load_access;\n #endif\n#endif\n template\n void load_override(T & t){\n this->basic_binary_iarchive::load_override(t);\n }\n void init(unsigned int flags){\n if(0 != (flags & no_header)){\n return;\n }\n #if ! defined(__MWERKS__)\n this->basic_binary_iarchive::init();\n this->basic_binary_iprimitive::init();\n #else\n basic_binary_iarchive::init();\n basic_binary_iprimitive::init();\n #endif\n }\n binary_iarchive_impl(\n std::basic_streambuf & bsb,\n unsigned int flags\n ) :\n basic_binary_iprimitive(\n bsb,\n 0 != (flags & no_codecvt)\n ),\n basic_binary_iarchive(flags)\n {}\n binary_iarchive_impl(\n std::basic_istream & is,\n unsigned int flags\n ) :\n basic_binary_iprimitive(\n * is.rdbuf(),\n 0 != (flags & no_codecvt)\n ),\n basic_binary_iarchive(flags)\n {}\n};\n\n} // namespace archive\n} // namespace boost\n\n#ifdef BOOST_MSVC\n#pragma warning(pop)\n#endif\n\n#endif // BOOST_ARCHIVE_BINARY_IARCHIVE_IMPL_HPP\n" }, { "path": "include/boost/archive/binary_oarchive.hpp", "content": "#ifndef BOOST_ARCHIVE_BINARY_OARCHIVE_HPP\n#define BOOST_ARCHIVE_BINARY_OARCHIVE_HPP\n\n// MS compatible compilers support #pragma once\n#if defined(_MSC_VER)\n# pragma once\n#endif\n\n/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8\n// binary_oarchive.hpp\n\n// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .\n// Use, modification and distribution is subject to the Boost Software\n// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at\n// http://www.boost.org/LICENSE_1_0.txt)\n\n// See http://www.boost.org for updates, documentation, and revision history.\n\n#include \n#include \n#include \n#include \n\n#ifdef BOOST_MSVC\n# pragma warning(push)\n# pragma warning(disable : 4511 4512)\n#endif\n\nnamespace boost {\nnamespace archive {\n\n// do not derive from this class. If you want to extend this functionality\n// via inheritance, derived from binary_oarchive_impl instead. This will\n// preserve correct static polymorphism.\nclass BOOST_SYMBOL_VISIBLE binary_oarchive :\n public binary_oarchive_impl<\n binary_oarchive, std::ostream::char_type, std::ostream::traits_type\n >\n{\npublic:\n binary_oarchive(std::ostream & os, unsigned int flags = 0) :\n binary_oarchive_impl<\n binary_oarchive, std::ostream::char_type, std::ostream::traits_type\n >(os, flags)\n {\n init(flags);\n }\n binary_oarchive(std::streambuf & bsb, unsigned int flags = 0) :\n binary_oarchive_impl<\n binary_oarchive, std::ostream::char_type, std::ostream::traits_type\n >(bsb, flags)\n {\n init(flags);\n }\n};\n\n} // namespace archive\n} // namespace boost\n\n// required by export\nBOOST_SERIALIZATION_REGISTER_ARCHIVE(boost::archive::binary_oarchive)\nBOOST_SERIALIZATION_USE_ARRAY_OPTIMIZATION(boost::archive::binary_oarchive)\n\n#ifdef BOOST_MSVC\n#pragma warning(pop)\n#endif\n\n#endif // BOOST_ARCHIVE_BINARY_OARCHIVE_HPP\n" }, { "path": "include/boost/archive/binary_oarchive_impl.hpp", "content": "#ifndef BOOST_ARCHIVE_BINARY_OARCHIVE_IMPL_HPP\n#define BOOST_ARCHIVE_BINARY_OARCHIVE_IMPL_HPP\n\n// MS compatible compilers support #pragma once\n#if defined(_MSC_VER)\n# pragma once\n#endif\n\n/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8\n// binary_oarchive_impl.hpp\n\n// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .\n// Use, modification and distribution is subject to the Boost Software\n// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at\n// http://www.boost.org/LICENSE_1_0.txt)\n\n// See http://www.boost.org for updates, documentation, and revision history.\n\n#include \n#include \n#include \n#include \n\n#ifdef BOOST_MSVC\n# pragma warning(push)\n# pragma warning(disable : 4511 4512)\n#endif\n\nnamespace boost {\nnamespace archive {\n\nnamespace detail {\n template class interface_oarchive;\n} // namespace detail\n\ntemplate\nclass BOOST_SYMBOL_VISIBLE binary_oarchive_impl :\n public basic_binary_oprimitive,\n public basic_binary_oarchive\n{\n#ifdef BOOST_NO_MEMBER_TEMPLATE_FRIENDS\npublic:\n#else\nprotected:\n #if BOOST_WORKAROUND(BOOST_MSVC, < 1500)\n // for some inexplicable reason insertion of \"class\" generates compile erro\n // on msvc 7.1\n friend detail::interface_oarchive;\n friend basic_binary_oarchive;\n friend save_access;\n #else\n friend class detail::interface_oarchive;\n friend class basic_binary_oarchive;\n friend class save_access;\n #endif\n#endif\n template\n void save_override(T & t){\n this->basic_binary_oarchive::save_override(t);\n }\n void init(unsigned int flags) {\n if(0 != (flags & no_header)){\n return;\n }\n #if ! defined(__MWERKS__)\n this->basic_binary_oarchive::init();\n this->basic_binary_oprimitive::init();\n #else\n basic_binary_oarchive::init();\n basic_binary_oprimitive::init();\n #endif\n }\n binary_oarchive_impl(\n std::basic_streambuf & bsb,\n unsigned int flags\n ) :\n basic_binary_oprimitive(\n bsb,\n 0 != (flags & no_codecvt)\n ),\n basic_binary_oarchive(flags)\n {}\n binary_oarchive_impl(\n std::basic_ostream & os,\n unsigned int flags\n ) :\n basic_binary_oprimitive(\n * os.rdbuf(),\n 0 != (flags & no_codecvt)\n ),\n basic_binary_oarchive(flags)\n {}\n};\n\n} // namespace archive\n} // namespace boost\n\n#ifdef BOOST_MSVC\n#pragma warning(pop)\n#endif\n\n#endif // BOOST_ARCHIVE_BINARY_OARCHIVE_IMPL_HPP\n" }, { "path": "include/boost/archive/binary_wiarchive.hpp", "content": "#ifndef BOOST_ARCHIVE_BINARY_WIARCHIVE_HPP\n#define BOOST_ARCHIVE_BINARY_WIARCHIVE_HPP\n\n// MS compatible compilers support #pragma once\n#if defined(_MSC_VER)\n# pragma once\n#endif\n\n/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8\n// binary_wiarchive.hpp\n\n// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .\n// Use, modification and distribution is subject to the Boost Software\n// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at\n// http://www.boost.org/LICENSE_1_0.txt)\n\n// See http://www.boost.org for updates, documentation, and revision history.\n\n#include \n#ifdef BOOST_NO_STD_WSTREAMBUF\n#error \"wide char i/o not supported on this platform\"\n#else\n\n#include // wistream\n#include \n#include \n\nnamespace boost {\nnamespace archive {\n\nclass binary_wiarchive :\n public binary_iarchive_impl<\n binary_wiarchive, std::wistream::char_type, std::wistream::traits_type\n >\n{\npublic:\n binary_wiarchive(std::wistream & is, unsigned int flags = 0) :\n binary_iarchive_impl<\n binary_wiarchive, std::wistream::char_type, std::wistream::traits_type\n >(is, flags)\n {}\n binary_wiarchive(std::wstreambuf & bsb, unsigned int flags = 0) :\n binary_iarchive_impl<\n binary_wiarchive, std::wistream::char_type, std::wistream::traits_type\n >(bsb, flags)\n {}\n};\n\n} // namespace archive\n} // namespace boost\n\n// required by export\nBOOST_SERIALIZATION_REGISTER_ARCHIVE(boost::archive::binary_wiarchive)\n\n#endif // BOOST_NO_STD_WSTREAMBUF\n#endif // BOOST_ARCHIVE_BINARY_WIARCHIVE_HPP\n" }, { "path": "include/boost/archive/binary_woarchive.hpp", "content": "#ifndef BOOST_ARCHIVE_BINARY_WOARCHIVE_HPP\n#define BOOST_ARCHIVE_BINARY_WOARCHIVE_HPP\n\n// MS compatible compilers support #pragma once\n#if defined(_MSC_VER)\n# pragma once\n#endif\n\n/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8\n// binary_woarchive.hpp\n\n// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .\n// Use, modification and distribution is subject to the Boost Software\n// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at\n// http://www.boost.org/LICENSE_1_0.txt)\n\n// See http://www.boost.org for updates, documentation, and revision history.\n\n#include \n#ifdef BOOST_NO_STD_WSTREAMBUF\n#error \"wide char i/o not supported on this platform\"\n#else\n\n#include \n#include \n#include \n\nnamespace boost {\nnamespace archive {\n\n// do not derive from this class. If you want to extend this functionality\n// via inheritance, derived from binary_oarchive_impl instead. This will\n// preserve correct static polymorphism.\nclass binary_woarchive :\n public binary_oarchive_impl<\n binary_woarchive, std::wostream::char_type, std::wostream::traits_type\n >\n{\npublic:\n binary_woarchive(std::wostream & os, unsigned int flags = 0) :\n binary_oarchive_impl<\n binary_woarchive, std::wostream::char_type, std::wostream::traits_type\n >(os, flags)\n {}\n binary_woarchive(std::wstreambuf & bsb, unsigned int flags = 0) :\n binary_oarchive_impl<\n binary_woarchive, std::wostream::char_type, std::wostream::traits_type\n >(bsb, flags)\n {}\n};\n\n} // namespace archive\n} // namespace boost\n\n// required by export\nBOOST_SERIALIZATION_REGISTER_ARCHIVE(boost::archive::binary_woarchive)\n\n#endif // BOOST_NO_STD_WSTREAMBUF\n#endif // BOOST_ARCHIVE_BINARY_WOARCHIVE_HPP\n" }, { "path": "include/boost/archive/codecvt_null.hpp", "content": "#ifndef BOOST_ARCHIVE_CODECVT_NULL_HPP\n#define BOOST_ARCHIVE_CODECVT_NULL_HPP\n\n// MS compatible compilers support #pragma once\n#if defined(_MSC_VER)\n# pragma once\n#endif\n\n/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8\n// codecvt_null.hpp:\n\n// (C) Copyright 2004 Robert Ramey - http://www.rrsd.com .\n// Use, modification and distribution is subject to the Boost Software\n// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at\n// http://www.boost.org/LICENSE_1_0.txt)\n\n// See http://www.boost.org for updates, documentation, and revision history.\n\n#include \n#include // NULL, size_t\n#ifndef BOOST_NO_CWCHAR\n#include // for mbstate_t\n#endif\n#include \n#include \n#include \n//#include // must be the last header\n\n#if defined(BOOST_NO_STDC_NAMESPACE)\nnamespace std {\n// For STLport on WinCE, BOOST_NO_STDC_NAMESPACE can get defined if STLport is putting symbols in its own namespace.\n// In the case of codecvt, however, this does not mean that codecvt is in the global namespace (it will be in STLport's namespace)\n# if !defined(__SGI_STL_PORT) && !defined(_STLPORT_VERSION)\n using ::codecvt;\n# endif\n using ::mbstate_t;\n using ::size_t;\n} // namespace\n#endif\n\n#ifdef BOOST_MSVC\n# pragma warning(push)\n# pragma warning(disable : 4511 4512)\n#endif\n\nnamespace boost {\nnamespace archive {\n\ntemplate\nclass codecvt_null;\n\ntemplate<>\nclass codecvt_null : public std::codecvt\n{\n bool do_always_noconv() const BOOST_NOEXCEPT_OR_NOTHROW BOOST_OVERRIDE {\n return true;\n }\npublic:\n explicit codecvt_null(std::size_t no_locale_manage = 0) :\n std::codecvt(no_locale_manage)\n {}\n ~codecvt_null() BOOST_OVERRIDE {}\n};\n\ntemplate<>\nclass BOOST_SYMBOL_VISIBLE codecvt_null :\n public std::codecvt\n{\n BOOST_SYMBOL_EXPORT std::codecvt_base::result\n do_out(\n std::mbstate_t & state,\n const wchar_t * first1,\n const wchar_t * last1,\n const wchar_t * & next1,\n char * first2,\n char * last2,\n char * & next2\n ) const BOOST_OVERRIDE;\n\n BOOST_SYMBOL_EXPORT std::codecvt_base::result\n do_in(\n std::mbstate_t & state,\n const char * first1,\n const char * last1,\n const char * & next1,\n wchar_t * first2,\n wchar_t * last2,\n wchar_t * & next2\n ) const BOOST_OVERRIDE;\n\n BOOST_SYMBOL_EXPORT int do_encoding( ) const BOOST_NOEXCEPT_OR_NOTHROW BOOST_OVERRIDE {\n return sizeof(wchar_t) / sizeof(char);\n }\n\n BOOST_SYMBOL_EXPORT bool do_always_noconv() const BOOST_NOEXCEPT_OR_NOTHROW BOOST_OVERRIDE {\n return false;\n }\n\n BOOST_SYMBOL_EXPORT int do_max_length( ) const BOOST_NOEXCEPT_OR_NOTHROW BOOST_OVERRIDE {\n return do_encoding();\n }\npublic:\n BOOST_SYMBOL_EXPORT explicit codecvt_null(std::size_t no_locale_manage = 0);\n\n BOOST_SYMBOL_EXPORT ~codecvt_null() BOOST_OVERRIDE ;\n};\n\n} // namespace archive\n} // namespace boost\n\n#ifdef BOOST_MSVC\n# pragma warning(pop)\n#endif\n//#include // pop pragmas\n\n#endif //BOOST_ARCHIVE_CODECVT_NULL_HPP\n" }, { "path": "include/boost/archive/detail/abi_prefix.hpp", "content": "/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8\n// abi_prefix.hpp\n\n// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .\n// Use, modification and distribution is subject to the Boost Software\n// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at\n// http://www.boost.org/LICENSE_1_0.txt)\n\n// See http://www.boost.org for updates, documentation, and revision history.\n\n#include // must be the last header\n#ifdef BOOST_MSVC\n# pragma warning(push)\n# pragma warning(disable : 4251 4231 4660 4275)\n#endif\n\n" }, { "path": "include/boost/archive/detail/abi_suffix.hpp", "content": "/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8\n// abi_suffix.hpp\n\n// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .\n// Use, modification and distribution is subject to the Boost Software\n// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at\n// http://www.boost.org/LICENSE_1_0.txt)\n\n// See http://www.boost.org for updates, documentation, and revision history.\n\n#ifdef BOOST_MSVC\n#pragma warning(pop)\n#endif\n#include // pops abi_suffix.hpp pragmas\n\n" }, { "path": "include/boost/archive/detail/archive_serializer_map.hpp", "content": "#ifndef BOOST_ARCHIVE_SERIALIZER_MAP_HPP\n#define BOOST_ARCHIVE_SERIALIZER_MAP_HPP\n\n// MS compatible compilers support #pragma once\n#if defined(_MSC_VER)\n# pragma once\n#endif\n\n/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8\n// archive_serializer_map.hpp: extension of type_info required for\n// serialization.\n\n// (C) Copyright 2009 Robert Ramey - http://www.rrsd.com .\n// Use, modification and distribution is subject to the Boost Software\n// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at\n// http://www.boost.org/LICENSE_1_0.txt)\n\n// See http://www.boost.org for updates, documentation, and revision history.\n\n// note: this is nothing more than the thinnest of wrappers around\n// basic_serializer_map so we can have a one map / archive type.\n\n#include \n#include \n#include // must be the last header\n\nnamespace boost {\n\nnamespace serialization {\n class extended_type_info;\n} // namespace serialization\n\nnamespace archive {\nnamespace detail {\n\nclass basic_serializer;\n\ntemplate\nclass BOOST_SYMBOL_VISIBLE archive_serializer_map {\npublic:\n static BOOST_ARCHIVE_OR_WARCHIVE_DECL bool insert(const basic_serializer * bs);\n static BOOST_ARCHIVE_OR_WARCHIVE_DECL void erase(const basic_serializer * bs);\n static BOOST_ARCHIVE_OR_WARCHIVE_DECL const basic_serializer * find(\n const boost::serialization::extended_type_info & type_\n );\n};\n\n} // namespace detail\n} // namespace archive\n} // namespace boost\n\n#include // must be the last header\n\n#endif //BOOST_ARCHIVE_SERIALIZER_MAP_HPP\n" }, { "path": "include/boost/archive/detail/auto_link_archive.hpp", "content": "#ifndef BOOST_ARCHIVE_DETAIL_AUTO_LINK_ARCHIVE_HPP\n#define BOOST_ARCHIVE_DETAIL_AUTO_LINK_ARCHIVE_HPP\n\n// MS compatible compilers support #pragma once\n#if defined(_MSC_VER)\n# pragma once\n#endif\n\n/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8\n// auto_link_archive.hpp\n//\n// (c) Copyright Robert Ramey 2004\n// Use, modification, and distribution is subject to the Boost Software\n// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at\n// http://www.boost.org/LICENSE_1_0.txt)\n\n// See library home page at http://www.boost.org/libs/serialization\n\n//----------------------------------------------------------------------------//\n\n// This header implements separate compilation features as described in\n// http://www.boost.org/more/separate_compilation.html\n\n// enable automatic library variant selection ------------------------------//\n\n#include \n\n#if !defined(BOOST_ALL_NO_LIB) && !defined(BOOST_SERIALIZATION_NO_LIB) \\\n&& !defined(BOOST_ARCHIVE_SOURCE) && !defined(BOOST_WARCHIVE_SOURCE) \\\n&& !defined(BOOST_SERIALIZATION_SOURCE)\n\n // Set the name of our library, this will get undef'ed by auto_link.hpp\n // once it's done with it:\n //\n #define BOOST_LIB_NAME boost_serialization\n //\n // If we're importing code from a dll, then tell auto_link.hpp about it:\n //\n #if defined(BOOST_ALL_DYN_LINK) || defined(BOOST_SERIALIZATION_DYN_LINK)\n # define BOOST_DYN_LINK\n #endif\n //\n // And include the header that does the work:\n //\n #include \n#endif // auto-linking disabled\n\n#endif // BOOST_ARCHIVE_DETAIL_AUTO_LINK_ARCHIVE_HPP\n" }, { "path": "include/boost/archive/detail/auto_link_warchive.hpp", "content": "#ifndef BOOST_ARCHIVE_DETAIL_AUTO_LINK_WARCHIVE_HPP\n#define BOOST_ARCHIVE_DETAIL_AUTO_LINK_WARCHIVE_HPP\n\n// MS compatible compilers support #pragma once\n#if defined(_MSC_VER)\n# pragma once\n#endif\n\n/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8\n// auto_link_warchive.hpp\n//\n// (c) Copyright Robert Ramey 2004\n// Use, modification, and distribution is subject to the Boost Software\n// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at\n// http://www.boost.org/LICENSE_1_0.txt)\n\n// See library home page at http://www.boost.org/libs/serialization\n\n//----------------------------------------------------------------------------//\n\n// This header implements separate compilation features as described in\n// http://www.boost.org/more/separate_compilation.html\n\n// enable automatic library variant selection ------------------------------//\n\n#include \n\n#if !defined(BOOST_WARCHIVE_SOURCE) \\\n&& !defined(BOOST_ALL_NO_LIB) && !defined(BOOST_SERIALIZATION_NO_LIB)\n\n// Set the name of our library, this will get undef'ed by auto_link.hpp\n// once it's done with it:\n//\n#define BOOST_LIB_NAME boost_wserialization\n//\n// If we're importing code from a dll, then tell auto_link.hpp about it:\n//\n#if defined(BOOST_ALL_DYN_LINK) || defined(BOOST_SERIALIZATION_DYN_LINK)\n# define BOOST_DYN_LINK\n#endif\n//\n// And include the header that does the work:\n//\n#include \n#endif // auto-linking disabled\n\n#endif // ARCHIVE_DETAIL_AUTO_LINK_ARCHIVE_HPP\n" }, { "path": "include/boost/archive/detail/basic_iarchive.hpp", "content": "#ifndef BOOST_ARCHIVE_DETAIL_BASIC_IARCHIVE_HPP\n#define BOOST_ARCHIVE_DETAIL_BASIC_IARCHIVE_HPP\n\n// MS compatible compilers support #pragma once\n#if defined(_MSC_VER)\n# pragma once\n#endif\n\n/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8\n// basic_iarchive.hpp:\n\n// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .\n// Use, modification and distribution is subject to the Boost Software\n// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at\n// http://www.boost.org/LICENSE_1_0.txt)\n\n// See http://www.boost.org for updates, documentation, and revision history.\n\n// can't use this - much as I'd like to as borland doesn't support it\n\n#include \n#include \n#include \n\n#include \n#include \n#include \n#include \n#include // must be the last header\n\nnamespace boost {\nnamespace serialization {\n class extended_type_info;\n} // namespace serialization\n\nnamespace archive {\nnamespace detail {\n\nclass basic_iarchive_impl;\nclass basic_iserializer;\nclass basic_pointer_iserializer;\n\n//////////////////////////////////////////////////////////////////////\n// class basic_iarchive - read serialized objects from a input stream\nclass BOOST_SYMBOL_VISIBLE basic_iarchive :\n private boost::noncopyable,\n public boost::archive::detail::helper_collection\n{\n friend class basic_iarchive_impl;\n // hide implementation of this class to minimize header conclusion\n boost::scoped_ptr pimpl;\n\n virtual void vload(version_type &t) = 0;\n virtual void vload(object_id_type &t) = 0;\n virtual void vload(class_id_type &t) = 0;\n virtual void vload(class_id_optional_type &t) = 0;\n virtual void vload(class_name_type &t) = 0;\n virtual void vload(tracking_type &t) = 0;\nprotected:\n BOOST_ARCHIVE_DECL basic_iarchive(unsigned int flags);\n boost::archive::detail::helper_collection &\n get_helper_collection(){\n return *this;\n }\npublic:\n // some msvc versions require that the following function be public\n // otherwise it should really protected.\n virtual BOOST_ARCHIVE_DECL ~basic_iarchive();\n // note: NOT part of the public API.\n BOOST_ARCHIVE_DECL void next_object_pointer(void *t);\n BOOST_ARCHIVE_DECL void register_basic_serializer(\n const basic_iserializer & bis\n );\n BOOST_ARCHIVE_DECL void load_object(\n void *t,\n const basic_iserializer & bis\n );\n BOOST_ARCHIVE_DECL const basic_pointer_iserializer *\n load_pointer(\n void * & t,\n const basic_pointer_iserializer * bpis_ptr,\n const basic_pointer_iserializer * (*finder)(\n const boost::serialization::extended_type_info & eti\n )\n );\n // real public API starts here\n BOOST_ARCHIVE_DECL void\n set_library_version(boost::serialization::library_version_type archive_library_version);\n BOOST_ARCHIVE_DECL boost::serialization::library_version_type\n get_library_version() const;\n BOOST_ARCHIVE_DECL unsigned int\n get_flags() const;\n BOOST_ARCHIVE_DECL void\n reset_object_address(const void * new_address, const void * old_address);\n BOOST_ARCHIVE_DECL void\n delete_created_pointers();\n};\n\n} // namespace detail\n} // namespace archive\n} // namespace boost\n\n#include // pops abi_suffix.hpp pragmas\n\n#endif //BOOST_ARCHIVE_DETAIL_BASIC_IARCHIVE_HPP\n" }, { "path": "include/boost/archive/detail/basic_iserializer.hpp", "content": "#ifndef BOOST_ARCHIVE_DETAIL_BASIC_ISERIALIZER_HPP\n#define BOOST_ARCHIVE_DETAIL_BASIC_ISERIALIZER_HPP\n\n// MS compatible compilers support #pragma once\n#if defined(_MSC_VER)\n# pragma once\n#endif\n\n/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8\n// basic_iserializer.hpp: extension of type_info required for serialization.\n\n// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .\n// Use, modification and distribution is subject to the Boost Software\n// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at\n// http://www.boost.org/LICENSE_1_0.txt)\n\n// See http://www.boost.org for updates, documentation, and revision history.\n\n#include // NULL\n#include \n\n#include \n#include \n#include \n#include \n#include // must be the last header\n\n#ifdef BOOST_MSVC\n# pragma warning(push)\n# pragma warning(disable : 4511 4512)\n#endif\n\nnamespace boost {\nnamespace serialization {\n class extended_type_info;\n} // namespace serialization\n\n// forward declarations\nnamespace archive {\nnamespace detail {\n\nclass basic_iarchive;\nclass basic_pointer_iserializer;\n\nclass BOOST_SYMBOL_VISIBLE basic_iserializer :\n public basic_serializer\n{\nprivate:\n basic_pointer_iserializer *m_bpis;\nprotected:\n explicit BOOST_ARCHIVE_DECL basic_iserializer(\n const boost::serialization::extended_type_info & type\n );\n virtual BOOST_ARCHIVE_DECL ~basic_iserializer();\npublic:\n bool serialized_as_pointer() const {\n return m_bpis != NULL;\n }\n void set_bpis(basic_pointer_iserializer *bpis){\n m_bpis = bpis;\n }\n const basic_pointer_iserializer * get_bpis_ptr() const {\n return m_bpis;\n }\n virtual void load_object_data(\n basic_iarchive & ar,\n void *x,\n const unsigned int file_version\n ) const = 0;\n // returns true if class_info should be saved\n virtual bool class_info() const = 0 ;\n // returns true if objects should be tracked\n virtual bool tracking(const unsigned int) const = 0 ;\n // returns class version\n virtual version_type version() const = 0 ;\n // returns true if this class is polymorphic\n virtual bool is_polymorphic() const = 0;\n virtual void destroy(/*const*/ void *address) const = 0 ;\n};\n\n} // namespace detail\n} // namespace archive\n} // namespace boost\n\n#ifdef BOOST_MSVC\n#pragma warning(pop)\n#endif\n\n#include // pops abi_suffix.hpp pragmas\n\n#endif // BOOST_ARCHIVE_DETAIL_BASIC_ISERIALIZER_HPP\n" }, { "path": "include/boost/archive/detail/basic_oarchive.hpp", "content": "#ifndef BOOST_ARCHIVE_BASIC_OARCHIVE_HPP\n#define BOOST_ARCHIVE_BASIC_OARCHIVE_HPP\n\n// MS compatible compilers support #pragma once\n#if defined(_MSC_VER)\n# pragma once\n#endif\n\n/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8\n// basic_oarchive.hpp:\n\n// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .\n// Use, modification and distribution is subject to the Boost Software\n// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at\n// http://www.boost.org/LICENSE_1_0.txt)\n\n// See http://www.boost.org for updates, documentation, and revision history.\n\n#include // NULL\n#include \n#include \n#include \n\n#include \n#include \n#include \n#include // must be the last header\n\nnamespace boost {\nnamespace serialization {\n class extended_type_info;\n} // namespace serialization\n\nnamespace archive {\nnamespace detail {\n\nclass basic_oarchive_impl;\nclass basic_oserializer;\nclass basic_pointer_oserializer;\n\n//////////////////////////////////////////////////////////////////////\n// class basic_oarchive - write serialized objects to an output stream\nclass BOOST_SYMBOL_VISIBLE basic_oarchive :\n private boost::noncopyable,\n public boost::archive::detail::helper_collection\n{\n friend class basic_oarchive_impl;\n // hide implementation of this class to minimize header conclusion\n boost::scoped_ptr pimpl;\n\n // overload these to bracket object attributes. Used to implement\n // xml archives\n virtual void vsave(const version_type t) = 0;\n virtual void vsave(const object_id_type t) = 0;\n virtual void vsave(const object_reference_type t) = 0;\n virtual void vsave(const class_id_type t) = 0;\n virtual void vsave(const class_id_optional_type t) = 0;\n virtual void vsave(const class_id_reference_type t) = 0;\n virtual void vsave(const class_name_type & t) = 0;\n virtual void vsave(const tracking_type t) = 0;\nprotected:\n BOOST_ARCHIVE_DECL basic_oarchive(unsigned int flags = 0);\n BOOST_ARCHIVE_DECL boost::archive::detail::helper_collection &\n get_helper_collection();\n virtual BOOST_ARCHIVE_DECL ~basic_oarchive();\npublic:\n // note: NOT part of the public interface\n BOOST_ARCHIVE_DECL void register_basic_serializer(\n const basic_oserializer & bos\n );\n BOOST_ARCHIVE_DECL void save_object(\n const void *x,\n const basic_oserializer & bos\n );\n BOOST_ARCHIVE_DECL void save_pointer(\n const void * t,\n const basic_pointer_oserializer * bpos_ptr\n );\n void save_null_pointer(){\n vsave(BOOST_SERIALIZATION_NULL_POINTER_TAG);\n }\n // real public interface starts here\n BOOST_ARCHIVE_DECL void end_preamble(); // default implementation does nothing\n BOOST_ARCHIVE_DECL boost::serialization::library_version_type get_library_version() const;\n BOOST_ARCHIVE_DECL unsigned int get_flags() const;\n};\n\n} // namespace detail\n} // namespace archive\n} // namespace boost\n\n#include // pops abi_suffix.hpp pragmas\n\n#endif //BOOST_ARCHIVE_BASIC_OARCHIVE_HPP\n" }, { "path": "include/boost/archive/detail/basic_oserializer.hpp", "content": "#ifndef BOOST_SERIALIZATION_BASIC_OSERIALIZER_HPP\n#define BOOST_SERIALIZATION_BASIC_OSERIALIZER_HPP\n\n// MS compatible compilers support #pragma once\n#if defined(_MSC_VER)\n# pragma once\n#endif\n\n/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8\n// basic_oserializer.hpp: extension of type_info required for serialization.\n\n// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .\n// Use, modification and distribution is subject to the Boost Software\n// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at\n// http://www.boost.org/LICENSE_1_0.txt)\n\n// See http://www.boost.org for updates, documentation, and revision history.\n\n#include // NULL\n#include \n#include \n\n#include \n#include \n#include \n\n#include // must be the last header\n\n#ifdef BOOST_MSVC\n# pragma warning(push)\n# pragma warning(disable : 4511 4512)\n#endif\n\nnamespace boost {\nnamespace serialization {\n class extended_type_info;\n} // namespace serialization\n\n// forward declarations\nnamespace archive {\nnamespace detail {\n\nclass basic_oarchive;\nclass basic_pointer_oserializer;\n\nclass BOOST_SYMBOL_VISIBLE basic_oserializer :\n public basic_serializer\n{\nprivate:\n basic_pointer_oserializer *m_bpos;\nprotected:\n explicit BOOST_ARCHIVE_DECL basic_oserializer(\n const boost::serialization::extended_type_info & type_\n );\n virtual BOOST_ARCHIVE_DECL ~basic_oserializer();\npublic:\n bool serialized_as_pointer() const {\n return m_bpos != NULL;\n }\n void set_bpos(basic_pointer_oserializer *bpos){\n m_bpos = bpos;\n }\n const basic_pointer_oserializer * get_bpos() const {\n return m_bpos;\n }\n virtual void save_object_data(\n basic_oarchive & ar, const void * x\n ) const = 0;\n // returns true if class_info should be saved\n virtual bool class_info() const = 0;\n // returns true if objects should be tracked\n virtual bool tracking(const unsigned int flags) const = 0;\n // returns class version\n virtual version_type version() const = 0;\n // returns true if this class is polymorphic\n virtual bool is_polymorphic() const = 0;\n};\n\n} // namespace detail\n} // namespace serialization\n} // namespace boost\n\n#ifdef BOOST_MSVC\n#pragma warning(pop)\n#endif\n\n#include // pops abi_suffix.hpp pragmas\n\n#endif // BOOST_SERIALIZATION_BASIC_OSERIALIZER_HPP\n" }, { "path": "include/boost/archive/detail/basic_pointer_iserializer.hpp", "content": "#ifndef BOOST_ARCHIVE_BASIC_POINTER_ISERIALIZER_HPP\n#define BOOST_ARCHIVE_BASIC_POINTER_ISERIALIZER_HPP\n\n// MS compatible compilers support #pragma once\n#if defined(_MSC_VER)\n# pragma once\n#endif\n\n/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8\n// basic_pointer_oserializer.hpp: extension of type_info required for\n// serialization.\n\n// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .\n// Use, modification and distribution is subject to the Boost Software\n// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at\n// http://www.boost.org/LICENSE_1_0.txt)\n\n// See http://www.boost.org for updates, documentation, and revision history.\n#include \n#include \n#include \n#include \n\n#include // must be the last header\n\n#ifdef BOOST_MSVC\n# pragma warning(push)\n# pragma warning(disable : 4511 4512)\n#endif\n\nnamespace boost {\nnamespace serialization {\n class extended_type_info;\n} // namespace serialization\n\n// forward declarations\nnamespace archive {\nnamespace detail {\n\nclass basic_iarchive;\nclass basic_iserializer;\n\nclass BOOST_SYMBOL_VISIBLE basic_pointer_iserializer\n : public basic_serializer {\nprotected:\n explicit BOOST_ARCHIVE_DECL basic_pointer_iserializer(\n const boost::serialization::extended_type_info & type_\n );\n virtual BOOST_ARCHIVE_DECL ~basic_pointer_iserializer();\npublic:\n virtual void * heap_allocation() const = 0;\n virtual const basic_iserializer & get_basic_serializer() const = 0;\n virtual void load_object_ptr(\n basic_iarchive & ar,\n void * x,\n const unsigned int file_version\n ) const = 0;\n};\n\n} // namespace detail\n} // namespace archive\n} // namespace boost\n\n#ifdef BOOST_MSVC\n#pragma warning(pop)\n#endif\n\n#include // pops abi_suffix.hpp pragmas\n\n#endif // BOOST_ARCHIVE_BASIC_POINTER_ISERIALIZER_HPP\n" }, { "path": "include/boost/archive/detail/basic_pointer_oserializer.hpp", "content": "#ifndef BOOST_ARCHIVE_BASIC_POINTER_OSERIALIZER_HPP\n#define BOOST_ARCHIVE_BASIC_POINTER_OSERIALIZER_HPP\n\n// MS compatible compilers support #pragma once\n#if defined(_MSC_VER)\n# pragma once\n#endif\n\n/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8\n// basic_pointer_oserializer.hpp: extension of type_info required for\n// serialization.\n\n// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .\n// Use, modification and distribution is subject to the Boost Software\n// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at\n// http://www.boost.org/LICENSE_1_0.txt)\n\n// See http://www.boost.org for updates, documentation, and revision history.\n#include \n#include \n#include \n#include \n\n#include // must be the last header\n\n#ifdef BOOST_MSVC\n# pragma warning(push)\n# pragma warning(disable : 4511 4512)\n#endif\n\nnamespace boost {\nnamespace serialization {\n class extended_type_info;\n} // namespace serialization\n\nnamespace archive {\nnamespace detail {\n\nclass basic_oarchive;\nclass basic_oserializer;\n\nclass BOOST_SYMBOL_VISIBLE basic_pointer_oserializer :\n public basic_serializer\n{\nprotected:\n explicit BOOST_ARCHIVE_DECL basic_pointer_oserializer(\n const boost::serialization::extended_type_info & type_\n );\npublic:\n virtual BOOST_ARCHIVE_DECL ~basic_pointer_oserializer();\n virtual const basic_oserializer & get_basic_serializer() const = 0;\n virtual void save_object_ptr(\n basic_oarchive & ar,\n const void * x\n ) const = 0;\n};\n\n} // namespace detail\n} // namespace archive\n} // namespace boost\n\n#ifdef BOOST_MSVC\n#pragma warning(pop)\n#endif\n\n#include // pops abi_suffix.hpp pragmas\n\n#endif // BOOST_ARCHIVE_BASIC_POINTER_OSERIALIZER_HPP\n" }, { "path": "include/boost/archive/detail/basic_serializer.hpp", "content": "#ifndef BOOST_ARCHIVE_BASIC_SERIALIZER_HPP\n#define BOOST_ARCHIVE_BASIC_SERIALIZER_HPP\n\n// MS compatible compilers support #pragma once\n#if defined(_MSC_VER)\n# pragma once\n#endif\n\n/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8\n// basic_serializer.hpp: extension of type_info required for serialization.\n\n// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .\n// Use, modification and distribution is subject to the Boost Software\n// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at\n// http://www.boost.org/LICENSE_1_0.txt)\n\n// See http://www.boost.org for updates, documentation, and revision history.\n\n#include \n#include // NULL\n\n#include \n#include \n#include \n\n#ifdef BOOST_MSVC\n# pragma warning(push)\n# pragma warning(disable : 4511 4512)\n#endif\n\nnamespace boost {\nnamespace archive {\nnamespace detail {\n\nclass basic_serializer :\n private boost::noncopyable\n{\n const boost::serialization::extended_type_info * m_eti;\nprotected:\n explicit basic_serializer(\n const boost::serialization::extended_type_info & eti\n ) :\n m_eti(& eti)\n {}\npublic:\n inline bool\n operator<(const basic_serializer & rhs) const {\n // can't compare address since there can be multiple eti records\n // for the same type in different execution modules (that is, DLLS)\n // leave this here as a reminder not to do this!\n // return & lhs.get_eti() < & rhs.get_eti();\n return get_eti() < rhs.get_eti();\n }\n const char * get_debug_info() const {\n return m_eti->get_debug_info();\n }\n const boost::serialization::extended_type_info & get_eti() const {\n return * m_eti;\n }\n};\n\nclass basic_serializer_arg : public basic_serializer {\npublic:\n basic_serializer_arg(const serialization::extended_type_info & eti) :\n basic_serializer(eti)\n {}\n};\n\n} // namespace detail\n} // namespace archive\n} // namespace boost\n\n#ifdef BOOST_MSVC\n#pragma warning(pop)\n#endif\n\n#endif // BOOST_ARCHIVE_BASIC_SERIALIZER_HPP\n" }, { "path": "include/boost/archive/detail/basic_serializer_map.hpp", "content": "#ifndef BOOST_SERIALIZER_MAP_HPP\n#define BOOST_SERIALIZER_MAP_HPP\n\n// MS compatible compilers support #pragma once\n#if defined(_MSC_VER)\n# pragma once\n#endif\n\n/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8\n// basic_serializer_map.hpp: extension of type_info required for serialization.\n\n// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .\n// Use, modification and distribution is subject to the Boost Software\n// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at\n// http://www.boost.org/LICENSE_1_0.txt)\n\n// See http://www.boost.org for updates, documentation, and revision history.\n\n#include \n\n#include \n#include \n#include \n\n#include // must be the last header\n\nnamespace boost {\nnamespace serialization {\n class extended_type_info;\n}\n\nnamespace archive {\nnamespace detail {\n\nclass basic_serializer;\n\nclass BOOST_SYMBOL_VISIBLE\nbasic_serializer_map : public\n boost::noncopyable\n{\n struct type_info_pointer_compare\n {\n bool operator()(\n const basic_serializer * lhs, const basic_serializer * rhs\n ) const ;\n };\n typedef std::set<\n const basic_serializer *,\n type_info_pointer_compare\n > map_type;\n map_type m_map;\npublic:\n BOOST_ARCHIVE_DECL bool insert(const basic_serializer * bs);\n BOOST_ARCHIVE_DECL void erase(const basic_serializer * bs);\n BOOST_ARCHIVE_DECL const basic_serializer * find(\n const boost::serialization::extended_type_info & type_\n ) const;\nprivate:\n // cw 8.3 requires this\n basic_serializer_map& operator=(basic_serializer_map const&);\n};\n\n} // namespace detail\n} // namespace archive\n} // namespace boost\n\n#include // must be the last header\n\n#endif // BOOST_SERIALIZER_MAP_HPP\n" }, { "path": "include/boost/archive/detail/check.hpp", "content": "#ifndef BOOST_ARCHIVE_DETAIL_CHECK_HPP\n#define BOOST_ARCHIVE_DETAIL_CHECK_HPP\n\n// MS compatible compilers support #pragma once\n#if defined(_MSC_VER)\n# pragma once\n#if !defined(__clang__)\n#pragma inline_depth(255)\n#pragma inline_recursion(on)\n#endif\n#endif\n\n#if defined(__MWERKS__)\n#pragma inline_depth(255)\n#endif\n\n/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8\n// check.hpp: interface for serialization system.\n\n// (C) Copyright 2009 Robert Ramey - http://www.rrsd.com .\n// Use, modification and distribution is subject to the Boost Software\n// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at\n// http://www.boost.org/LICENSE_1_0.txt)\n\n// See http://www.boost.org for updates, documentation, and revision history.\n\n#include \n\n#include \n#include \n\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\n#include \n#include \n#include \n#include \n#include \n\nnamespace boost {\nnamespace archive {\nnamespace detail {\n\n// checks for objects\n\ntemplate\ninline void check_object_level(){\n typedef\n typename mpl::greater_equal<\n serialization::implementation_level< T >,\n mpl::int_\n >::type typex;\n\n // trap attempts to serialize objects marked\n // not_serializable\n BOOST_STATIC_ASSERT(typex::value);\n}\n\ntemplate\ninline void check_object_versioning(){\n typedef\n typename mpl::or_<\n typename mpl::greater<\n serialization::implementation_level< T >,\n mpl::int_\n >,\n typename mpl::equal_to<\n serialization::version< T >,\n mpl::int_<0>\n >\n > typex;\n // trap attempts to serialize with objects that don't\n // save class information in the archive with versioning.\n BOOST_STATIC_ASSERT(typex::value);\n}\n\ntemplate\ninline void check_object_tracking(){\n // presume it has already been determined that\n // T is not a const\n BOOST_STATIC_ASSERT(! boost::is_const< T >::value);\n typedef typename mpl::equal_to<\n serialization::tracking_level< T >,\n mpl::int_\n >::type typex;\n // saving an non-const object of a type not marked \"track_never)\n\n // may be an indicator of an error usage of the\n // serialization library and should be double checked.\n // See documentation on object tracking. Also, see the\n // \"rationale\" section of the documentation\n // for motivation for this checking.\n\n BOOST_STATIC_WARNING(typex::value);\n}\n\n// checks for pointers\n\ntemplate\ninline void check_pointer_level(){\n // we should only invoke this once we KNOW that T\n // has been used as a pointer!!\n typedef\n typename mpl::or_<\n typename mpl::greater<\n serialization::implementation_level< T >,\n mpl::int_\n >,\n typename mpl::not_<\n typename mpl::equal_to<\n serialization::tracking_level< T >,\n mpl::int_\n >\n >\n > typex;\n // Address the following when serializing to a pointer:\n\n // a) This type doesn't save class information in the\n // archive. That is, the serialization trait implementation\n // level <= object_serializable.\n // b) Tracking for this type is set to \"track selectively\"\n\n // in this case, indication that an object is tracked is\n // not stored in the archive itself - see level == object_serializable\n // but rather the existence of the operation ar >> T * is used to\n // infer that an object of this type should be tracked. So, if\n // you save via a pointer but don't load via a pointer the operation\n // will fail on load without given any valid reason for the failure.\n\n // So if your program traps here, consider changing the\n // tracking or implementation level traits - or not\n // serializing via a pointer.\n BOOST_STATIC_WARNING(typex::value);\n}\n\ntemplate\nvoid inline check_pointer_tracking(){\n typedef typename mpl::greater<\n serialization::tracking_level< T >,\n mpl::int_\n >::type typex;\n // serializing an object of a type marked \"track_never\" through a pointer\n // could result in creating more objects than were saved!\n BOOST_STATIC_WARNING(typex::value);\n}\n\ntemplate\ninline void check_const_loading(){\n typedef\n typename mpl::or_<\n typename boost::serialization::is_wrapper< T >,\n typename mpl::not_<\n typename boost::is_const< T >\n >\n >::type typex;\n // cannot load data into a \"const\" object unless it's a\n // wrapper around some other non-const object.\n BOOST_STATIC_ASSERT(typex::value);\n}\n\n} // detail\n} // archive\n} // boost\n\n#endif // BOOST_ARCHIVE_DETAIL_CHECK_HPP\n" }, { "path": "include/boost/archive/detail/common_iarchive.hpp", "content": "#ifndef BOOST_ARCHIVE_DETAIL_COMMON_IARCHIVE_HPP\n#define BOOST_ARCHIVE_DETAIL_COMMON_IARCHIVE_HPP\n\n// MS compatible compilers support #pragma once\n#if defined(_MSC_VER)\n# pragma once\n#endif\n\n/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8\n// common_iarchive.hpp\n\n// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .\n// Use, modification and distribution is subject to the Boost Software\n// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at\n// http://www.boost.org/LICENSE_1_0.txt)\n\n// See http://www.boost.org for updates, documentation, and revision history.\n\n#include \n\n#include \n#include \n#include \n\n#ifdef BOOST_MSVC\n# pragma warning(push)\n# pragma warning(disable : 4511 4512)\n#endif\n\nnamespace boost {\nnamespace archive {\nnamespace detail {\n\nclass extended_type_info;\n\n// note: referred to as Curiously Recurring Template Patter (CRTP)\ntemplate\nclass BOOST_SYMBOL_VISIBLE common_iarchive :\n public basic_iarchive,\n public interface_iarchive\n{\n friend class interface_iarchive;\n friend class basic_iarchive;\nprivate:\n void vload(version_type & t) BOOST_OVERRIDE {\n * this->This() >> t;\n }\n void vload(object_id_type & t) BOOST_OVERRIDE {\n * this->This() >> t;\n }\n void vload(class_id_type & t) BOOST_OVERRIDE {\n * this->This() >> t;\n }\n void vload(class_id_optional_type & t) BOOST_OVERRIDE {\n * this->This() >> t;\n }\n void vload(tracking_type & t) BOOST_OVERRIDE {\n * this->This() >> t;\n }\n void vload(class_name_type &s) BOOST_OVERRIDE {\n * this->This() >> s;\n }\nprotected:\n // default processing - invoke serialization library\n template\n void load_override(T & t){\n archive::load(* this->This(), t);\n }\n // default implementations of functions which emit start/end tags for\n // archive types that require them.\n void load_start(const char * /*name*/){}\n void load_end(const char * /*name*/){}\n // default archive initialization\n common_iarchive(unsigned int flags = 0) :\n basic_iarchive(flags),\n interface_iarchive()\n {}\n};\n\n} // namespace detail\n} // namespace archive\n} // namespace boost\n\n#ifdef BOOST_MSVC\n#pragma warning(pop)\n#endif\n\n#endif // BOOST_ARCHIVE_DETAIL_COMMON_IARCHIVE_HPP\n" }, { "path": "include/boost/archive/detail/common_oarchive.hpp", "content": "#ifndef BOOST_ARCHIVE_DETAIL_COMMON_OARCHIVE_HPP\n#define BOOST_ARCHIVE_DETAIL_COMMON_OARCHIVE_HPP\n\n// MS compatible compilers support #pragma once\n#if defined(_MSC_VER)\n# pragma once\n#endif\n\n/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8\n// common_oarchive.hpp\n\n// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .\n// Use, modification and distribution is subject to the Boost Software\n// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at\n// http://www.boost.org/LICENSE_1_0.txt)\n\n// See http://www.boost.org for updates, documentation, and revision history.\n\n#include \n\n#include \n#include \n\n#ifdef BOOST_MSVC\n# pragma warning(push)\n# pragma warning(disable : 4511 4512)\n#endif\n\nnamespace boost {\nnamespace archive {\nnamespace detail {\n\n// note: referred to as Curiously Recurring Template Patter (CRTP)\ntemplate\n\nclass BOOST_SYMBOL_VISIBLE common_oarchive :\n public basic_oarchive,\n public interface_oarchive\n{\n friend class interface_oarchive;\n friend class basic_oarchive;\nprivate:\n void vsave(const version_type t) BOOST_OVERRIDE {\n * this->This() << t;\n }\n void vsave(const object_id_type t) BOOST_OVERRIDE {\n * this->This() << t;\n }\n void vsave(const object_reference_type t) BOOST_OVERRIDE {\n * this->This() << t;\n }\n void vsave(const class_id_type t) BOOST_OVERRIDE {\n * this->This() << t;\n }\n void vsave(const class_id_reference_type t) BOOST_OVERRIDE {\n * this->This() << t;\n }\n void vsave(const class_id_optional_type t) BOOST_OVERRIDE {\n * this->This() << t;\n }\n void vsave(const class_name_type & t) BOOST_OVERRIDE {\n * this->This() << t;\n }\n void vsave(const tracking_type t) BOOST_OVERRIDE {\n * this->This() << t;\n }\nprotected:\n // default processing - invoke serialization library\n template\n void save_override(T & t){\n archive::save(* this->This(), t);\n }\n void save_start(const char * /*name*/){}\n void save_end(const char * /*name*/){}\n common_oarchive(unsigned int flags = 0) :\n basic_oarchive(flags),\n interface_oarchive()\n {}\n};\n\n} // namespace detail\n} // namespace archive\n} // namespace boost\n\n#ifdef BOOST_MSVC\n#pragma warning(pop)\n#endif\n\n#endif // BOOST_ARCHIVE_DETAIL_COMMON_OARCHIVE_HPP\n" }, { "path": "include/boost/archive/detail/decl.hpp", "content": "#ifndef BOOST_ARCHIVE_DETAIL_DECL_HPP\n#define BOOST_ARCHIVE_DETAIL_DECL_HPP\n\n// MS compatible compilers support #pragma once\n#if defined(_MSC_VER)\n# pragma once\n#endif\n\n/////////1/////////2///////// 3/////////4/////////5/////////6/////////7/////////8\n// decl.hpp\n//\n// (c) Copyright Robert Ramey 2004\n// Use, modification, and distribution is subject to the Boost Software\n// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at\n// http://www.boost.org/LICENSE_1_0.txt)\n\n// See library home page at http://www.boost.org/libs/serialization\n\n//----------------------------------------------------------------------------//\n\n// This header implements separate compilation features as described in\n// http://www.boost.org/more/separate_compilation.html\n\n#include \n\n#if (defined(BOOST_ALL_DYN_LINK) || defined(BOOST_SERIALIZATION_DYN_LINK))\n #if defined(BOOST_ARCHIVE_SOURCE)\n #define BOOST_ARCHIVE_DECL BOOST_SYMBOL_EXPORT\n #else\n #define BOOST_ARCHIVE_DECL BOOST_SYMBOL_IMPORT\n #endif\n\n #if defined(BOOST_WARCHIVE_SOURCE)\n #define BOOST_WARCHIVE_DECL BOOST_SYMBOL_EXPORT\n #else\n #define BOOST_WARCHIVE_DECL BOOST_SYMBOL_IMPORT\n #endif\n\n #if defined(BOOST_WARCHIVE_SOURCE) || defined(BOOST_ARCHIVE_SOURCE)\n #define BOOST_ARCHIVE_OR_WARCHIVE_DECL BOOST_SYMBOL_EXPORT\n #else\n #define BOOST_ARCHIVE_OR_WARCHIVE_DECL BOOST_SYMBOL_IMPORT\n #endif\n\n#endif\n\n#if ! defined(BOOST_ARCHIVE_DECL)\n #define BOOST_ARCHIVE_DECL\n#endif\n#if ! defined(BOOST_WARCHIVE_DECL)\n #define BOOST_WARCHIVE_DECL\n#endif\n#if ! defined(BOOST_ARCHIVE_OR_WARCHIVE_DECL)\n #define BOOST_ARCHIVE_OR_WARCHIVE_DECL\n#endif\n\n#endif // BOOST_ARCHIVE_DETAIL_DECL_HPP\n" }, { "path": "include/boost/archive/detail/helper_collection.hpp", "content": "#ifndef BOOST_ARCHIVE_DETAIL_HELPER_COLLECTION_HPP\n#define BOOST_ARCHIVE_DETAIL_HELPER_COLLECTION_HPP\n\n// MS compatible compilers support #pragma once\n#if defined(_MSC_VER) && (_MSC_VER >= 1020)\n# pragma once\n#endif\n\n/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8\n// helper_collection.hpp: archive support for run-time helpers\n\n// (C) Copyright 2002-2008 Robert Ramey and Joaquin M Lopez Munoz\n// Use, modification and distribution is subject to the Boost Software\n// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at\n// http://www.boost.org/LICENSE_1_0.txt)\n\n// See http://www.boost.org for updates, documentation, and revision history.\n\n#include // NULL\n#include \n#include \n#include \n#include \n\n#include \n\n#include \n#include \n\nnamespace boost {\n\nnamespace archive {\nnamespace detail {\n\nclass helper_collection\n{\n helper_collection(const helper_collection&); // non-copyable\n helper_collection& operator = (const helper_collection&); // non-copyable\n\n // note: we dont' actually \"share\" the function object pointer\n // we only use shared_ptr to make sure that it get's deleted\n\n typedef std::pair<\n const void *,\n boost::shared_ptr\n > helper_value_type;\n template\n boost::shared_ptr make_helper_ptr(){\n // use boost::shared_ptr rather than std::shared_ptr to maintain\n // c++03 compatibility\n return boost::make_shared();\n }\n\n typedef std::vector collection;\n collection m_collection;\n\n struct predicate {\n BOOST_DEFAULTED_FUNCTION(predicate(const predicate& rhs), : m_ti(rhs.m_ti) {})\n BOOST_DELETED_FUNCTION(predicate & operator=(const predicate & rhs))\n public:\n const void * const m_ti;\n bool operator()(helper_value_type const &rhs){\n return m_ti == rhs.first;\n }\n predicate(const void * ti) :\n m_ti(ti)\n {}\n };\nprotected:\n helper_collection(){}\n ~helper_collection(){}\npublic:\n template\n Helper& find_helper(void * const id = 0) {\n collection::const_iterator it =\n std::find_if(\n m_collection.begin(),\n m_collection.end(),\n predicate(id)\n );\n\n void * rval = 0;\n if(it == m_collection.end()){\n m_collection.push_back(\n std::make_pair(id, make_helper_ptr())\n );\n rval = m_collection.back().second.get();\n }\n else{\n rval = it->second.get();\n }\n return *static_cast(rval);\n }\n};\n\n} // namespace detail\n} // namespace serialization\n} // namespace boost\n\n#endif // BOOST_ARCHIVE_DETAIL_HELPER_COLLECTION_HPP\n" }, { "path": "include/boost/archive/detail/interface_iarchive.hpp", "content": "#ifndef BOOST_ARCHIVE_DETAIL_INTERFACE_IARCHIVE_HPP\n#define BOOST_ARCHIVE_DETAIL_INTERFACE_IARCHIVE_HPP\n\n// MS compatible compilers support #pragma once\n#if defined(_MSC_VER)\n# pragma once\n#endif\n\n/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8\n// interface_iarchive.hpp\n\n// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .\n// Use, modification and distribution is subject to the Boost Software\n// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at\n// http://www.boost.org/LICENSE_1_0.txt)\n\n// See http://www.boost.org for updates, documentation, and revision history.\n#include // NULL\n#include \n#include \n#include \n#include \n#include \n#include \n#include // must be the last header\n\nnamespace boost {\nnamespace archive {\nnamespace detail {\n\nclass basic_pointer_iserializer;\n\ntemplate\nclass interface_iarchive\n{\nprotected:\n interface_iarchive() {}\npublic:\n /////////////////////////////////////////////////////////\n // archive public interface\n typedef mpl::bool_ is_loading;\n typedef mpl::bool_ is_saving;\n\n // return a pointer to the most derived class\n Archive * This(){\n return static_cast(this);\n }\n\n template\n const basic_pointer_iserializer *\n register_type(T * = NULL){\n const basic_pointer_iserializer & bpis =\n boost::serialization::singleton<\n pointer_iserializer\n >::get_const_instance();\n this->This()->register_basic_serializer(bpis.get_basic_serializer());\n return & bpis;\n }\n template\n Helper &\n get_helper(void * const id = 0){\n helper_collection & hc = this->This()->get_helper_collection();\n return hc.template find_helper(id);\n }\n\n template\n Archive & operator>>(T & t){\n this->This()->load_override(t);\n return * this->This();\n }\n\n // the & operator\n template\n Archive & operator&(T & t){\n return *(this->This()) >> t;\n }\n};\n\n} // namespace detail\n} // namespace archive\n} // namespace boost\n\n#include // pops abi_suffix.hpp pragmas\n\n#endif // BOOST_ARCHIVE_DETAIL_INTERFACE_IARCHIVE_HPP\n" }, { "path": "include/boost/archive/detail/interface_oarchive.hpp", "content": "#ifndef BOOST_ARCHIVE_DETAIL_INTERFACE_OARCHIVE_HPP\n#define BOOST_ARCHIVE_DETAIL_INTERFACE_OARCHIVE_HPP\n\n// MS compatible compilers support #pragma once\n#if defined(_MSC_VER)\n# pragma once\n#endif\n\n/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8\n// interface_oarchive.hpp\n\n// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .\n// Use, modification and distribution is subject to the Boost Software\n// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at\n// http://www.boost.org/LICENSE_1_0.txt)\n\n// See http://www.boost.org for updates, documentation, and revision history.\n#include // NULL\n#include \n#include \n#include \n\n#include \n#include \n#include // must be the last header\n\n#include \n\nnamespace boost {\nnamespace archive {\nnamespace detail {\n\nclass basic_pointer_oserializer;\n\ntemplate\nclass interface_oarchive\n{\nprotected:\n interface_oarchive() {}\npublic:\n /////////////////////////////////////////////////////////\n // archive public interface\n typedef mpl::bool_ is_loading;\n typedef mpl::bool_ is_saving;\n\n // return a pointer to the most derived class\n Archive * This(){\n return static_cast(this);\n }\n\n template\n const basic_pointer_oserializer *\n register_type(const T * = NULL){\n const basic_pointer_oserializer & bpos =\n boost::serialization::singleton<\n pointer_oserializer\n >::get_const_instance();\n this->This()->register_basic_serializer(bpos.get_basic_serializer());\n return & bpos;\n }\n\n template\n Helper &\n get_helper(void * const id = 0){\n helper_collection & hc = this->This()->get_helper_collection();\n return hc.template find_helper(id);\n }\n\n template\n Archive & operator<<(const T & t){\n this->This()->save_override(t);\n return * this->This();\n }\n\n // the & operator\n template\n Archive & operator&(const T & t){\n return * this ->This() << t;\n }\n};\n\n} // namespace detail\n} // namespace archive\n} // namespace boost\n\n#include // pops abi_suffix.hpp pragmas\n\n#endif // BOOST_ARCHIVE_DETAIL_INTERFACE_IARCHIVE_HPP\n" }, { "path": "include/boost/archive/detail/iserializer.hpp", "content": "#ifndef BOOST_ARCHIVE_DETAIL_ISERIALIZER_HPP\n#define BOOST_ARCHIVE_DETAIL_ISERIALIZER_HPP\n\n// MS compatible compilers support #pragma once\n#if defined(BOOST_MSVC)\n# pragma once\n#if !defined(__clang__)\n#pragma inline_depth(255)\n#pragma inline_recursion(on)\n#endif\n#endif\n\n#if defined(__MWERKS__)\n#pragma inline_depth(255)\n#endif\n\n/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8\n// iserializer.hpp: interface for serialization system.\n\n// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .\n// Use, modification and distribution is subject to the Boost Software\n// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at\n// http://www.boost.org/LICENSE_1_0.txt)\n\n// See http://www.boost.org for updates, documentation, and revision history.\n\n#include // for placement new\n#include // size_t, NULL\n\n#include \n#include \n#if defined(BOOST_NO_STDC_NAMESPACE)\nnamespace std{\n using ::size_t;\n} // namespace std\n#endif\n\n#include \n\n#include \n#include \n#include \n#include \n#include \n\n#ifndef BOOST_SERIALIZATION_DEFAULT_TYPE_INFO\n #include \n#endif\n#include \n#include \n#include \n\n#include \n#include \n#include \n#include \n#include \n#include \n\n#include \n\n#if !defined(BOOST_MSVC) && \\\n (BOOST_WORKAROUND(__IBMCPP__, < 1210) || \\\n defined(__SUNPRO_CC) && (__SUNPRO_CC < 0x590))\n #define BOOST_SERIALIZATION_DONT_USE_HAS_NEW_OPERATOR 1\n#else\n #define BOOST_SERIALIZATION_DONT_USE_HAS_NEW_OPERATOR 0\n#endif\n\n#if ! BOOST_SERIALIZATION_DONT_USE_HAS_NEW_OPERATOR\n#include \n#endif\n\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\n// the following is need only for dynamic cast of polymorphic pointers\n#include \n#include \n#include \n#include \n#include \n#include \n\n#include \n\nnamespace boost {\n\nnamespace serialization {\n class extended_type_info;\n} // namespace serialization\n\nnamespace archive {\n\n// an accessor to permit friend access to archives. Needed because\n// some compilers don't handle friend templates completely\nclass load_access {\npublic:\n template\n static void load_primitive(Archive &ar, T &t){\n ar.load(t);\n }\n};\n\nnamespace detail {\n\n#ifdef BOOST_MSVC\n# pragma warning(push)\n# pragma warning(disable : 4511 4512)\n#endif\n\ntemplate\nclass iserializer : public basic_iserializer\n{\nprivate:\n void destroy(/*const*/ void *address) const BOOST_OVERRIDE {\n boost::serialization::access::destroy(static_cast(address));\n }\npublic:\n explicit iserializer() :\n basic_iserializer(\n boost::serialization::singleton<\n typename\n boost::serialization::type_info_implementation< T >::type\n >::get_const_instance()\n )\n {}\n BOOST_DLLEXPORT void load_object_data(\n basic_iarchive & ar,\n void *x,\n const unsigned int file_version\n ) const BOOST_OVERRIDE BOOST_USED;\n bool class_info() const BOOST_OVERRIDE {\n return boost::serialization::implementation_level< T >::value\n >= boost::serialization::object_class_info;\n }\n bool tracking(const unsigned int /* flags */) const BOOST_OVERRIDE {\n return boost::serialization::tracking_level< T >::value\n == boost::serialization::track_always\n || ( boost::serialization::tracking_level< T >::value\n == boost::serialization::track_selectively\n && serialized_as_pointer());\n }\n version_type version() const BOOST_OVERRIDE {\n return version_type(::boost::serialization::version< T >::value);\n }\n bool is_polymorphic() const BOOST_OVERRIDE {\n return boost::is_polymorphic< T >::value;\n }\n ~iserializer() BOOST_OVERRIDE {}\n};\n\n#ifdef BOOST_MSVC\n# pragma warning(pop)\n#endif\n\ntemplate\nBOOST_DLLEXPORT void iserializer::load_object_data(\n basic_iarchive & ar,\n void *x,\n const unsigned int file_version\n) const {\n // note: we now comment this out. Before we permitted archive\n // version # to be very large. Now we don't. To permit\n // readers of these old archives, we have to suppress this\n // code. Perhaps in the future we might re-enable it but\n // permit its suppression with a runtime switch.\n #if 1\n // trap case where the program cannot handle the current version\n if(file_version > static_cast(version()))\n boost::serialization::throw_exception(\n archive::archive_exception(\n boost::archive::archive_exception::unsupported_class_version,\n get_debug_info()\n )\n );\n #endif\n // make sure call is routed through the highest interface that might\n // be specialized by the user.\n boost::serialization::serialize_adl(\n boost::serialization::smart_cast_reference(ar),\n * static_cast(x),\n file_version\n );\n}\n\n#ifdef BOOST_MSVC\n# pragma warning(push)\n# pragma warning(disable : 4511 4512)\n#endif\n\n// the purpose of this code is to allocate memory for an object\n// without requiring the constructor to be called. Presumably\n// the allocated object will be subsequently initialized with\n// \"placement new\".\n// note: we have the boost type trait has_new_operator but we\n// have no corresponding has_delete_operator. So we presume\n// that the former being true would imply that the a delete\n// operator is also defined for the class T.\n\ntemplate\nstruct heap_allocation {\n // boost::has_new_operator< T > doesn't work on these compilers\n #if BOOST_SERIALIZATION_DONT_USE_HAS_NEW_OPERATOR\n // This doesn't handle operator new overload for class T\n static T * invoke_new(){\n return static_cast(operator new(sizeof(T)));\n }\n static void invoke_delete(T *t){\n (operator delete(t));\n }\n #else\n // note: we presume that a true value for has_new_operator\n // implies the existence of a class specific delete operator as well\n // as a class specific new operator.\n struct has_new_operator {\n static T * invoke_new() {\n return static_cast((T::operator new)(sizeof(T)));\n }\n static void invoke_delete(T * t) {\n // if compilation fails here, the likely cause that the class\n // T has a class specific new operator but no class specific\n // delete operator which matches the following signature.\n // note that this solution addresses the issue that two\n // possible signatures. But it doesn't address the possibility\n // that the class might have class specific new with NO\n // class specific delete at all. Patches (compatible with\n // C++03) welcome!\n (operator delete)(t);\n }\n };\n struct doesnt_have_new_operator {\n static T* invoke_new() {\n return static_cast(operator new(sizeof(T)));\n }\n static void invoke_delete(T * t) {\n // Note: I'm reliance upon automatic conversion from T * to void * here\n (operator delete)(t);\n }\n };\n static T * invoke_new() {\n typedef typename\n mpl::eval_if<\n boost::has_new_operator< T >,\n mpl::identity,\n mpl::identity\n >::type typex;\n return typex::invoke_new();\n }\n static void invoke_delete(T *t) {\n typedef typename\n mpl::eval_if<\n boost::has_new_operator< T >,\n mpl::identity,\n mpl::identity\n >::type typex;\n typex::invoke_delete(t);\n }\n #endif\n explicit heap_allocation(){\n m_p = invoke_new();\n }\n ~heap_allocation(){\n if (0 != m_p)\n invoke_delete(m_p);\n }\n T* get() const {\n return m_p;\n }\n\n T* release() {\n T* p = m_p;\n m_p = 0;\n return p;\n }\nprivate:\n T* m_p;\n};\n\ntemplate\nclass pointer_iserializer :\n public basic_pointer_iserializer\n{\nprivate:\n void * heap_allocation() const BOOST_OVERRIDE {\n detail::heap_allocation h;\n T * t = h.get();\n h.release();\n return t;\n }\n const basic_iserializer & get_basic_serializer() const BOOST_OVERRIDE {\n return boost::serialization::singleton<\n iserializer\n >::get_const_instance();\n }\n BOOST_DLLEXPORT void load_object_ptr(\n basic_iarchive & ar,\n void * x,\n const unsigned int file_version\n ) const BOOST_OVERRIDE BOOST_USED;\npublic:\n // this should always be a singleton so make the constructor protected\n pointer_iserializer();\n ~pointer_iserializer() BOOST_OVERRIDE;\n};\n\n#ifdef BOOST_MSVC\n# pragma warning(pop)\n#endif\n\n// note: BOOST_DLLEXPORT is so that code for polymorphic class\n// serialized only through base class won't get optimized out\ntemplate\nBOOST_DLLEXPORT void pointer_iserializer::load_object_ptr(\n basic_iarchive & ar,\n void * t,\n const unsigned int file_version\n) const\n{\n Archive & ar_impl =\n boost::serialization::smart_cast_reference(ar);\n\n // note that the above will throw std::bad_alloc if the allocation\n // fails so we don't have to address this contingency here.\n\n // catch exception during load_construct_data so that we don't\n // automatically delete the t which is most likely not fully\n // constructed\n BOOST_TRY {\n // this addresses an obscure situation that occurs when\n // load_constructor de-serializes something through a pointer.\n ar.next_object_pointer(t);\n boost::serialization::load_construct_data_adl(\n ar_impl,\n static_cast(t),\n file_version\n );\n }\n BOOST_CATCH(...){\n // if we get here the load_construct failed. The heap_allocation\n // will be automatically deleted so we don't have to do anything\n // special here.\n BOOST_RETHROW;\n }\n BOOST_CATCH_END\n\n ar_impl >> boost::serialization::make_nvp(NULL, * static_cast(t));\n}\n\ntemplate\npointer_iserializer::pointer_iserializer() :\n basic_pointer_iserializer(\n boost::serialization::singleton<\n typename\n boost::serialization::type_info_implementation< T >::type\n >::get_const_instance()\n )\n{\n boost::serialization::singleton<\n iserializer\n >::get_mutable_instance().set_bpis(this);\n archive_serializer_map::insert(this);\n}\n\ntemplate\npointer_iserializer::~pointer_iserializer(){\n archive_serializer_map::erase(this);\n}\n\ntemplate\nstruct load_non_pointer_type {\n // note this bounces the call right back to the archive\n // with no runtime overhead\n struct load_primitive {\n template\n static void invoke(Archive & ar, T & t){\n load_access::load_primitive(ar, t);\n }\n };\n // note this bounces the call right back to the archive\n // with no runtime overhead\n struct load_only {\n template\n static void invoke(Archive & ar, const T & t){\n // short cut to user's serializer\n // make sure call is routed through the highest interface that might\n // be specialized by the user.\n boost::serialization::serialize_adl(\n ar,\n const_cast(t),\n boost::serialization::version< T >::value\n );\n }\n };\n\n // note this save class information including version\n // and serialization level to the archive\n struct load_standard {\n template\n static void invoke(Archive &ar, const T & t){\n void * x = boost::addressof(const_cast(t));\n ar.load_object(\n x,\n boost::serialization::singleton<\n iserializer\n >::get_const_instance()\n );\n }\n };\n\n struct load_conditional {\n template\n static void invoke(Archive &ar, T &t){\n //if(0 == (ar.get_flags() & no_tracking))\n load_standard::invoke(ar, t);\n //else\n // load_only::invoke(ar, t);\n }\n };\n\n template\n static void invoke(Archive & ar, T &t){\n typedef typename mpl::eval_if<\n // if its primitive\n mpl::equal_to<\n boost::serialization::implementation_level< T >,\n mpl::int_\n >,\n mpl::identity,\n // else\n typename mpl::eval_if<\n // class info / version\n mpl::greater_equal<\n boost::serialization::implementation_level< T >,\n mpl::int_\n >,\n // do standard load\n mpl::identity,\n // else\n typename mpl::eval_if<\n // no tracking\n mpl::equal_to<\n boost::serialization::tracking_level< T >,\n mpl::int_\n >,\n // do a fast load\n mpl::identity,\n // else\n // do a fast load only tracking is turned off\n mpl::identity\n > > >::type typex;\n check_object_versioning< T >();\n check_object_level< T >();\n typex::invoke(ar, t);\n }\n};\n\ntemplate\nstruct load_pointer_type {\n struct abstract\n {\n template\n static const basic_pointer_iserializer * register_type(Archive & /* ar */){\n // it has? to be polymorphic\n BOOST_STATIC_ASSERT(boost::is_polymorphic< T >::value);\n return static_cast(NULL);\n }\n };\n\n struct non_abstract\n {\n template\n static const basic_pointer_iserializer * register_type(Archive & ar){\n return ar.register_type(static_cast(NULL));\n }\n };\n\n template\n static const basic_pointer_iserializer * register_type(Archive &ar, const T* const /*t*/){\n // there should never be any need to load an abstract polymorphic\n // class pointer. Inhibiting code generation for this\n // permits abstract base classes to be used - note: exception\n // virtual serialize functions used for plug-ins\n typedef typename\n mpl::eval_if<\n boost::serialization::is_abstract,\n boost::mpl::identity,\n boost::mpl::identity\n >::type typex;\n return typex::template register_type< T >(ar);\n }\n\n template\n static T * pointer_tweak(\n const boost::serialization::extended_type_info & eti,\n void const * const t,\n const T &\n ) {\n // tweak the pointer back to the base class\n void * upcast = const_cast(\n boost::serialization::void_upcast(\n eti,\n boost::serialization::singleton<\n typename\n boost::serialization::type_info_implementation< T >::type\n >::get_const_instance(),\n t\n )\n );\n if(NULL == upcast)\n boost::serialization::throw_exception(\n archive_exception(archive_exception::unregistered_class)\n );\n return static_cast(upcast);\n }\n\n template\n static void check_load(T * const /* t */){\n check_pointer_level< T >();\n check_pointer_tracking< T >();\n }\n\n static const basic_pointer_iserializer *\n find(const boost::serialization::extended_type_info & type){\n return static_cast(\n archive_serializer_map::find(type)\n );\n }\n\n template\n static void invoke(Archive & ar, Tptr & t){\n check_load(t);\n const basic_pointer_iserializer * bpis_ptr = register_type(ar, t);\n const basic_pointer_iserializer * newbpis_ptr = ar.load_pointer(\n // note major hack here !!!\n // I tried every way to convert Tptr &t (where Tptr might\n // include const) to void * &. This is the only way\n // I could make it work. RR\n (void * & )t,\n bpis_ptr,\n find\n );\n // if the pointer isn't that of the base class\n if(newbpis_ptr != bpis_ptr){\n t = pointer_tweak(newbpis_ptr->get_eti(), t, *t);\n }\n }\n};\n\ntemplate\nstruct load_enum_type {\n template\n static void invoke(Archive &ar, T &t){\n // convert integers to correct enum to load\n int i;\n ar >> boost::serialization::make_nvp(NULL, i);\n t = static_cast< T >(i);\n }\n};\n\ntemplate\nstruct load_array_type {\n template\n static void invoke(Archive &ar, T &t){\n typedef typename remove_extent< T >::type value_type;\n\n // convert integers to correct enum to load\n // determine number of elements in the array. Consider the\n // fact that some machines will align elements on boundaries\n // other than characters.\n std::size_t current_count = sizeof(t) / (\n static_cast(static_cast(&t[1]))\n - static_cast(static_cast(&t[0]))\n );\n boost::serialization::collection_size_type count;\n ar >> BOOST_SERIALIZATION_NVP(count);\n if(static_cast(count) > current_count)\n boost::serialization::throw_exception(\n archive::archive_exception(\n boost::archive::archive_exception::array_size_too_short\n )\n );\n // explicit template arguments to pass intel C++ compiler\n ar >> serialization::make_array<\n value_type,\n boost::serialization::collection_size_type\n >(\n static_cast(&t[0]),\n count\n );\n }\n};\n\n} // detail\n\ntemplate\ninline void load(Archive & ar, T &t){\n // if this assertion trips. It means we're trying to load a\n // const object with a compiler that doesn't have correct\n // function template ordering. On other compilers, this is\n // handled below.\n detail::check_const_loading< T >();\n typedef\n typename mpl::eval_if,\n mpl::identity >\n ,//else\n typename mpl::eval_if,\n mpl::identity >\n ,//else\n typename mpl::eval_if,\n mpl::identity >\n ,//else\n mpl::identity >\n >\n >\n >::type typex;\n typex::invoke(ar, t);\n}\n\n} // namespace archive\n} // namespace boost\n\n#endif // BOOST_ARCHIVE_DETAIL_ISERIALIZER_HPP\n" }, { "path": "include/boost/archive/detail/oserializer.hpp", "content": "#ifndef BOOST_ARCHIVE_OSERIALIZER_HPP\n#define BOOST_ARCHIVE_OSERIALIZER_HPP\n\n// MS compatible compilers support #pragma once\n#if defined(_MSC_VER)\n# pragma once\n#if !defined(__clang__)\n#pragma inline_depth(255)\n#pragma inline_recursion(on)\n#endif\n#endif\n\n#if defined(__MWERKS__)\n#pragma inline_depth(255)\n#endif\n\n/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8\n// oserializer.hpp: interface for serialization system.\n\n// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .\n// Use, modification and distribution is subject to the Boost Software\n// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at\n// http://www.boost.org/LICENSE_1_0.txt)\n\n// See http://www.boost.org for updates, documentation, and revision history.\n\n#include \n#include // NULL\n\n#include \n\n#include \n#include \n\n#include \n#include \n#include \n#include \n#include \n\n#ifndef BOOST_SERIALIZATION_DEFAULT_TYPE_INFO\n #include \n#endif\n#include \n#include \n#include \n#include \n\n#include \n#include \n#include \n#include \n#include \n\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\n#include \n\n#include \n#include \n#include \n#include \n#include \n#include \n\n#include \n\nnamespace boost {\n\nnamespace serialization {\n class extended_type_info;\n} // namespace serialization\n\nnamespace archive {\n\n// an accessor to permit friend access to archives. Needed because\n// some compilers don't handle friend templates completely\nclass save_access {\npublic:\n template\n static void end_preamble(Archive & ar){\n ar.end_preamble();\n }\n template\n static void save_primitive(Archive & ar, const T & t){\n ar.end_preamble();\n ar.save(t);\n }\n};\n\nnamespace detail {\n\n#ifdef BOOST_MSVC\n# pragma warning(push)\n# pragma warning(disable : 4511 4512)\n#endif\n\ntemplate\nclass oserializer : public basic_oserializer\n{\nprivate:\n // private constructor to inhibit any existence other than the\n // static one\npublic:\n explicit BOOST_DLLEXPORT oserializer() :\n basic_oserializer(\n boost::serialization::singleton<\n typename\n boost::serialization::type_info_implementation< T >::type\n >::get_const_instance()\n )\n {}\n BOOST_DLLEXPORT void save_object_data(\n basic_oarchive & ar,\n const void *x\n ) const BOOST_OVERRIDE BOOST_USED;\n bool class_info() const BOOST_OVERRIDE {\n return boost::serialization::implementation_level< T >::value\n >= boost::serialization::object_class_info;\n }\n bool tracking(const unsigned int /* flags */) const BOOST_OVERRIDE {\n return boost::serialization::tracking_level< T >::value == boost::serialization::track_always\n || (boost::serialization::tracking_level< T >::value == boost::serialization::track_selectively\n && serialized_as_pointer());\n }\n version_type version() const BOOST_OVERRIDE {\n return version_type(::boost::serialization::version< T >::value);\n }\n bool is_polymorphic() const BOOST_OVERRIDE {\n return boost::is_polymorphic< T >::value;\n }\n ~oserializer() BOOST_OVERRIDE {}\n};\n\n#ifdef BOOST_MSVC\n# pragma warning(pop)\n#endif\n\ntemplate\nBOOST_DLLEXPORT void oserializer::save_object_data(\n basic_oarchive & ar,\n const void *x\n) const {\n // make sure call is routed through the highest interface that might\n // be specialized by the user.\n BOOST_STATIC_ASSERT(boost::is_const< T >::value == false);\n boost::serialization::serialize_adl(\n boost::serialization::smart_cast_reference(ar),\n * static_cast(const_cast(x)),\n version()\n );\n}\n\n#ifdef BOOST_MSVC\n# pragma warning(push)\n# pragma warning(disable : 4511 4512)\n#endif\n\ntemplate\nclass pointer_oserializer :\n public basic_pointer_oserializer\n{\nprivate:\n const basic_oserializer &\n get_basic_serializer() const BOOST_OVERRIDE {\n return boost::serialization::singleton<\n oserializer\n >::get_const_instance();\n }\n BOOST_DLLEXPORT void save_object_ptr(\n basic_oarchive & ar,\n const void * x\n ) const BOOST_OVERRIDE BOOST_USED;\npublic:\n pointer_oserializer();\n ~pointer_oserializer() BOOST_OVERRIDE;\n};\n\n#ifdef BOOST_MSVC\n# pragma warning(pop)\n#endif\n\ntemplate\nBOOST_DLLEXPORT void pointer_oserializer::save_object_ptr(\n basic_oarchive & ar,\n const void * x\n) const {\n BOOST_ASSERT(NULL != x);\n // make sure call is routed through the highest interface that might\n // be specialized by the user.\n T * t = static_cast(const_cast(x));\n const unsigned int file_version = boost::serialization::version< T >::value;\n Archive & ar_impl\n = boost::serialization::smart_cast_reference(ar);\n boost::serialization::save_construct_data_adl(\n ar_impl,\n t,\n file_version\n );\n ar_impl << boost::serialization::make_nvp(NULL, * t);\n}\n\ntemplate\npointer_oserializer::pointer_oserializer() :\n basic_pointer_oserializer(\n boost::serialization::singleton<\n typename\n boost::serialization::type_info_implementation< T >::type\n >::get_const_instance()\n )\n{\n // make sure appropriate member function is instantiated\n boost::serialization::singleton<\n oserializer\n >::get_mutable_instance().set_bpos(this);\n archive_serializer_map::insert(this);\n}\n\ntemplate\npointer_oserializer::~pointer_oserializer(){\n archive_serializer_map::erase(this);\n}\n\ntemplate\nstruct save_non_pointer_type {\n // note this bounces the call right back to the archive\n // with no runtime overhead\n struct save_primitive {\n template\n static void invoke(Archive & ar, const T & t){\n save_access::save_primitive(ar, t);\n }\n };\n // same as above but passes through serialization\n struct save_only {\n template\n static void invoke(Archive & ar, const T & t){\n // make sure call is routed through the highest interface that might\n // be specialized by the user.\n boost::serialization::serialize_adl(\n ar,\n const_cast(t),\n ::boost::serialization::version< T >::value\n );\n }\n };\n // adds class information to the archive. This includes\n // serialization level and class version\n struct save_standard {\n template\n static void invoke(Archive &ar, const T & t){\n ar.save_object(\n boost::addressof(t),\n boost::serialization::singleton<\n oserializer\n >::get_const_instance()\n );\n }\n };\n\n\n\n // adds class information to the archive. This includes\n // serialization level and class version\n struct save_conditional {\n template\n static void invoke(Archive &ar, const T &t){\n //if(0 == (ar.get_flags() & no_tracking))\n save_standard::invoke(ar, t);\n //else\n // save_only::invoke(ar, t);\n }\n };\n\n\n template\n static void invoke(Archive & ar, const T & t){\n typedef\n typename mpl::eval_if<\n // if its primitive\n mpl::equal_to<\n boost::serialization::implementation_level< T >,\n mpl::int_\n >,\n mpl::identity,\n // else\n typename mpl::eval_if<\n // class info / version\n mpl::greater_equal<\n boost::serialization::implementation_level< T >,\n mpl::int_\n >,\n // do standard save\n mpl::identity,\n // else\n typename mpl::eval_if<\n // no tracking\n mpl::equal_to<\n boost::serialization::tracking_level< T >,\n mpl::int_\n >,\n // do a fast save\n mpl::identity,\n // else\n // do a fast save only tracking is turned off\n mpl::identity\n > > >::type typex;\n check_object_versioning< T >();\n typex::invoke(ar, t);\n }\n template\n static void invoke(Archive & ar, T & t){\n check_object_level< T >();\n check_object_tracking< T >();\n invoke(ar, const_cast(t));\n }\n};\n\ntemplate\nstruct save_pointer_type {\n struct abstract\n {\n template\n static const basic_pointer_oserializer * register_type(Archive & /* ar */){\n // it has? to be polymorphic\n BOOST_STATIC_ASSERT(boost::is_polymorphic< T >::value);\n return NULL;\n }\n };\n\n struct non_abstract\n {\n template\n static const basic_pointer_oserializer * register_type(Archive & ar){\n return ar.register_type(static_cast(NULL));\n }\n };\n\n template\n static const basic_pointer_oserializer * register_type(Archive &ar, T* const /*t*/){\n // there should never be any need to save an abstract polymorphic\n // class pointer. Inhibiting code generation for this\n // permits abstract base classes to be used - note: exception\n // virtual serialize functions used for plug-ins\n typedef\n typename mpl::eval_if<\n boost::serialization::is_abstract< T >,\n mpl::identity,\n mpl::identity\n >::type typex;\n return typex::template register_type< T >(ar);\n }\n\n struct non_polymorphic\n {\n template\n static void save(\n Archive &ar,\n T & t\n ){\n const basic_pointer_oserializer & bpos =\n boost::serialization::singleton<\n pointer_oserializer\n >::get_const_instance();\n // save the requested pointer type\n ar.save_pointer(& t, & bpos);\n }\n };\n\n struct polymorphic\n {\n template\n static void save(\n Archive &ar,\n T & t\n ){\n typename\n boost::serialization::type_info_implementation< T >::type const\n & i = boost::serialization::singleton<\n typename\n boost::serialization::type_info_implementation< T >::type\n >::get_const_instance();\n\n boost::serialization::extended_type_info const * const this_type = & i;\n\n // retrieve the true type of the object pointed to\n // if this assertion fails its an error in this library\n BOOST_ASSERT(NULL != this_type);\n\n const boost::serialization::extended_type_info * true_type =\n i.get_derived_extended_type_info(t);\n\n // note:if this exception is thrown, be sure that derived pointer\n // is either registered or exported.\n if(NULL == true_type){\n boost::serialization::throw_exception(\n archive_exception(\n archive_exception::unregistered_class,\n \"derived class not registered or exported\"\n )\n );\n }\n\n // if its not a pointer to a more derived type\n const void *vp = static_cast(&t);\n if(*this_type == *true_type){\n const basic_pointer_oserializer * bpos = register_type(ar, &t);\n ar.save_pointer(vp, bpos);\n return;\n }\n // convert pointer to more derived type. if this is thrown\n // it means that the base/derived relationship hasn't be registered\n vp = serialization::void_downcast(\n *true_type,\n *this_type,\n static_cast(&t)\n );\n if(NULL == vp){\n boost::serialization::throw_exception(\n archive_exception(\n archive_exception::unregistered_cast,\n true_type->get_debug_info(),\n this_type->get_debug_info()\n )\n );\n }\n\n // since true_type is valid, and this only gets made if the\n // pointer oserializer object has been created, this should never\n // fail\n const basic_pointer_oserializer * bpos\n = static_cast(\n boost::serialization::singleton<\n archive_serializer_map\n >::get_const_instance().find(*true_type)\n );\n BOOST_ASSERT(NULL != bpos);\n if(NULL == bpos)\n boost::serialization::throw_exception(\n archive_exception(\n archive_exception::unregistered_class,\n \"derived class not registered or exported\"\n )\n );\n ar.save_pointer(vp, bpos);\n }\n };\n\n template\n static void save(\n Archive & ar,\n const T & t\n ){\n check_pointer_level< T >();\n check_pointer_tracking< T >();\n typedef typename mpl::eval_if<\n is_polymorphic< T >,\n mpl::identity,\n mpl::identity\n >::type type;\n type::save(ar, const_cast(t));\n }\n\n template\n static void invoke(Archive &ar, const TPtr t){\n register_type(ar, t);\n if(NULL == t){\n basic_oarchive & boa\n = boost::serialization::smart_cast_reference(ar);\n boa.save_null_pointer();\n save_access::end_preamble(ar);\n return;\n }\n save(ar, * t);\n }\n};\n\ntemplate\nstruct save_enum_type\n{\n template\n static void invoke(Archive &ar, const T &t){\n // convert enum to integers on save\n const int i = static_cast(t);\n ar << boost::serialization::make_nvp(NULL, i);\n }\n};\n\ntemplate\nstruct save_array_type\n{\n template\n static void invoke(Archive &ar, const T &t){\n typedef typename boost::remove_extent< T >::type value_type;\n\n save_access::end_preamble(ar);\n // consider alignment\n std::size_t c = sizeof(t) / (\n static_cast(static_cast(&t[1]))\n - static_cast(static_cast(&t[0]))\n );\n boost::serialization::collection_size_type count(c);\n ar << BOOST_SERIALIZATION_NVP(count);\n // explicit template arguments to pass intel C++ compiler\n ar << serialization::make_array<\n const value_type,\n boost::serialization::collection_size_type\n >(\n static_cast(&t[0]),\n count\n );\n }\n};\n\n} // detail\n\ntemplate\ninline void save(Archive & ar, /*const*/ T &t){\n typedef\n typename mpl::eval_if,\n mpl::identity >,\n //else\n typename mpl::eval_if,\n mpl::identity >,\n //else\n typename mpl::eval_if,\n mpl::identity >,\n //else\n mpl::identity >\n >\n >\n >::type typex;\n typex::invoke(ar, t);\n}\n\n} // namespace archive\n} // namespace boost\n\n#endif // BOOST_ARCHIVE_OSERIALIZER_HPP\n" }, { "path": "include/boost/archive/detail/polymorphic_iarchive_route.hpp", "content": "#ifndef BOOST_ARCHIVE_DETAIL_POLYMORPHIC_IARCHIVE_ROUTE_HPP\n#define BOOST_ARCHIVE_DETAIL_POLYMORPHIC_IARCHIVE_ROUTE_HPP\n\n// MS compatible compilers support #pragma once\n#if defined(_MSC_VER)\n# pragma once\n#endif\n\n/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8\n// polymorphic_iarchive_route.hpp\n\n// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .\n// Use, modification and distribution is subject to the Boost Software\n// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at\n// http://www.boost.org/LICENSE_1_0.txt)\n\n// See http://www.boost.org for updates, documentation, and revision history.\n\n#include \n#include \n#include \n\n#include \n#if defined(BOOST_NO_STDC_NAMESPACE)\nnamespace std{\n using ::size_t;\n} // namespace std\n#endif\n\n#include \n#include \n#include \n#include // must be the last header\n\nnamespace boost {\nnamespace serialization {\n class extended_type_info;\n} // namespace serialization\nnamespace archive {\nnamespace detail{\n\nclass basic_iserializer;\nclass basic_pointer_iserializer;\n\n#ifdef BOOST_MSVC\n# pragma warning(push)\n# pragma warning(disable : 4511 4512)\n#endif\n\ntemplate\nclass polymorphic_iarchive_route :\n public polymorphic_iarchive,\n // note: gcc dynamic cross cast fails if the the derivation below is\n // not public. I think this is a mistake.\n public /*protected*/ ArchiveImplementation\n{\nprivate:\n // these are used by the serialization library.\n void load_object(\n void *t,\n const basic_iserializer & bis\n ) BOOST_OVERRIDE {\n ArchiveImplementation::load_object(t, bis);\n }\n const basic_pointer_iserializer * load_pointer(\n void * & t,\n const basic_pointer_iserializer * bpis_ptr,\n const basic_pointer_iserializer * (*finder)(\n const boost::serialization::extended_type_info & type\n )\n ) BOOST_OVERRIDE {\n return ArchiveImplementation::load_pointer(t, bpis_ptr, finder);\n }\n void set_library_version(boost::serialization::library_version_type archive_library_version) BOOST_OVERRIDE {\n ArchiveImplementation::set_library_version(archive_library_version);\n }\n boost::serialization::library_version_type get_library_version() const BOOST_OVERRIDE {\n return ArchiveImplementation::get_library_version();\n }\n unsigned int get_flags() const BOOST_OVERRIDE {\n return ArchiveImplementation::get_flags();\n }\n void delete_created_pointers() BOOST_OVERRIDE {\n ArchiveImplementation::delete_created_pointers();\n }\n void reset_object_address(\n const void * new_address,\n const void * old_address\n ) BOOST_OVERRIDE {\n ArchiveImplementation::reset_object_address(new_address, old_address);\n }\n void load_binary(void * t, std::size_t size) BOOST_OVERRIDE {\n ArchiveImplementation::load_binary(t, size);\n }\n // primitive types the only ones permitted by polymorphic archives\n void load(bool & t) BOOST_OVERRIDE {\n ArchiveImplementation::load(t);\n }\n void load(char & t) BOOST_OVERRIDE {\n ArchiveImplementation::load(t);\n }\n void load(signed char & t) BOOST_OVERRIDE {\n ArchiveImplementation::load(t);\n }\n void load(unsigned char & t) BOOST_OVERRIDE {\n ArchiveImplementation::load(t);\n }\n #ifndef BOOST_NO_CWCHAR\n #ifndef BOOST_NO_INTRINSIC_WCHAR_T\n void load(wchar_t & t) BOOST_OVERRIDE {\n ArchiveImplementation::load(t);\n }\n #endif\n #endif\n void load(short & t) BOOST_OVERRIDE {\n ArchiveImplementation::load(t);\n }\n void load(unsigned short & t) BOOST_OVERRIDE {\n ArchiveImplementation::load(t);\n }\n void load(int & t) BOOST_OVERRIDE {\n ArchiveImplementation::load(t);\n }\n void load(unsigned int & t) BOOST_OVERRIDE {\n ArchiveImplementation::load(t);\n }\n void load(long & t) BOOST_OVERRIDE {\n ArchiveImplementation::load(t);\n }\n void load(unsigned long & t) BOOST_OVERRIDE {\n ArchiveImplementation::load(t);\n }\n #if defined(BOOST_HAS_LONG_LONG)\n void load(boost::long_long_type & t) BOOST_OVERRIDE {\n ArchiveImplementation::load(t);\n }\n void load(boost::ulong_long_type & t) BOOST_OVERRIDE {\n ArchiveImplementation::load(t);\n }\n #elif defined(BOOST_HAS_MS_INT64)\n void load(__int64 & t) BOOST_OVERRIDE {\n ArchiveImplementation::load(t);\n }\n void load(unsigned __int64 & t) BOOST_OVERRIDE {\n ArchiveImplementation::load(t);\n }\n #endif\n void load(float & t) BOOST_OVERRIDE {\n ArchiveImplementation::load(t);\n }\n void load(double & t) BOOST_OVERRIDE {\n ArchiveImplementation::load(t);\n }\n void load(std::string & t) BOOST_OVERRIDE {\n ArchiveImplementation::load(t);\n }\n #ifndef BOOST_NO_STD_WSTRING\n void load(std::wstring & t) BOOST_OVERRIDE {\n ArchiveImplementation::load(t);\n }\n #endif\n // used for xml and other tagged formats default does nothing\n void load_start(const char * name) BOOST_OVERRIDE {\n ArchiveImplementation::load_start(name);\n }\n void load_end(const char * name) BOOST_OVERRIDE {\n ArchiveImplementation::load_end(name);\n }\n void register_basic_serializer(const basic_iserializer & bis) BOOST_OVERRIDE {\n ArchiveImplementation::register_basic_serializer(bis);\n }\n helper_collection &\n get_helper_collection() BOOST_OVERRIDE {\n return ArchiveImplementation::get_helper_collection();\n }\npublic:\n // this can't be inherited because they appear in multiple\n // parents\n typedef mpl::bool_ is_loading;\n typedef mpl::bool_ is_saving;\n // the >> operator\n template\n polymorphic_iarchive & operator>>(T & t){\n return polymorphic_iarchive::operator>>(t);\n }\n // the & operator\n template\n polymorphic_iarchive & operator&(T & t){\n return polymorphic_iarchive::operator&(t);\n }\n // register type function\n template\n const basic_pointer_iserializer *\n register_type(T * t = NULL){\n return ArchiveImplementation::register_type(t);\n }\n // all current archives take a stream as constructor argument\n template \n polymorphic_iarchive_route(\n std::basic_istream<_Elem, _Tr> & is,\n unsigned int flags = 0\n ) :\n ArchiveImplementation(is, flags)\n {}\n ~polymorphic_iarchive_route() BOOST_OVERRIDE {}\n};\n\n} // namespace detail\n} // namespace archive\n} // namespace boost\n\n#ifdef BOOST_MSVC\n#pragma warning(pop)\n#endif\n\n#include // pops abi_suffix.hpp pragmas\n\n#endif // BOOST_ARCHIVE_DETAIL_POLYMORPHIC_IARCHIVE_DISPATCH_HPP\n" }, { "path": "include/boost/archive/detail/polymorphic_oarchive_route.hpp", "content": "#ifndef BOOST_ARCHIVE_DETAIL_POLYMORPHIC_OARCHIVE_ROUTE_HPP\n#define BOOST_ARCHIVE_DETAIL_POLYMORPHIC_OARCHIVE_ROUTE_HPP\n\n// MS compatible compilers support #pragma once\n#if defined(_MSC_VER)\n# pragma once\n#endif\n\n/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8\n// polymorphic_oarchive_route.hpp\n\n// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .\n// Use, modification and distribution is subject to the Boost Software\n// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at\n// http://www.boost.org/LICENSE_1_0.txt)\n\n// See http://www.boost.org for updates, documentation, and revision history.\n\n#include \n#include \n#include // size_t\n\n#include \n#if defined(BOOST_NO_STDC_NAMESPACE)\nnamespace std{\n using ::size_t;\n} // namespace std\n#endif\n\n#include \n#include \n#include \n#include // must be the last header\n\nnamespace boost {\nnamespace serialization {\n class extended_type_info;\n} // namespace serialization\nnamespace archive {\nnamespace detail{\n\nclass basic_oserializer;\nclass basic_pointer_oserializer;\n\n#ifdef BOOST_MSVC\n# pragma warning(push)\n# pragma warning(disable : 4511 4512)\n#endif\n\ntemplate\nclass polymorphic_oarchive_route :\n public polymorphic_oarchive,\n // note: gcc dynamic cross cast fails if the the derivation below is\n // not public. I think this is a mistake.\n public /*protected*/ ArchiveImplementation\n{\nprivate:\n // these are used by the serialization library.\n void save_object(\n const void *x,\n const detail::basic_oserializer & bos\n ) BOOST_OVERRIDE {\n ArchiveImplementation::save_object(x, bos);\n }\n void save_pointer(\n const void * t,\n const detail::basic_pointer_oserializer * bpos_ptr\n ) BOOST_OVERRIDE {\n ArchiveImplementation::save_pointer(t, bpos_ptr);\n }\n void save_null_pointer() BOOST_OVERRIDE {\n ArchiveImplementation::save_null_pointer();\n }\n // primitive types the only ones permitted by polymorphic archives\n void save(const bool t) BOOST_OVERRIDE {\n ArchiveImplementation::save(t);\n }\n void save(const char t) BOOST_OVERRIDE {\n ArchiveImplementation::save(t);\n }\n void save(const signed char t) BOOST_OVERRIDE {\n ArchiveImplementation::save(t);\n }\n void save(const unsigned char t) BOOST_OVERRIDE {\n ArchiveImplementation::save(t);\n }\n #ifndef BOOST_NO_CWCHAR\n #ifndef BOOST_NO_INTRINSIC_WCHAR_T\n void save(const wchar_t t) BOOST_OVERRIDE {\n ArchiveImplementation::save(t);\n }\n #endif\n #endif\n void save(const short t) BOOST_OVERRIDE {\n ArchiveImplementation::save(t);\n }\n void save(const unsigned short t) BOOST_OVERRIDE {\n ArchiveImplementation::save(t);\n }\n void save(const int t) BOOST_OVERRIDE {\n ArchiveImplementation::save(t);\n }\n void save(const unsigned int t) BOOST_OVERRIDE {\n ArchiveImplementation::save(t);\n }\n void save(const long t) BOOST_OVERRIDE {\n ArchiveImplementation::save(t);\n }\n void save(const unsigned long t) BOOST_OVERRIDE {\n ArchiveImplementation::save(t);\n }\n #if defined(BOOST_HAS_LONG_LONG)\n void save(const boost::long_long_type t) BOOST_OVERRIDE {\n ArchiveImplementation::save(t);\n }\n void save(const boost::ulong_long_type t) BOOST_OVERRIDE {\n ArchiveImplementation::save(t);\n }\n #elif defined(BOOST_HAS_MS_INT64)\n void save(const boost::int64_t t) BOOST_OVERRIDE {\n ArchiveImplementation::save(t);\n }\n void save(const boost::uint64_t t) BOOST_OVERRIDE {\n ArchiveImplementation::save(t);\n }\n #endif\n void save(const float t) BOOST_OVERRIDE {\n ArchiveImplementation::save(t);\n }\n void save(const double t) BOOST_OVERRIDE {\n ArchiveImplementation::save(t);\n }\n void save(const std::string & t) BOOST_OVERRIDE {\n ArchiveImplementation::save(t);\n }\n #ifndef BOOST_NO_STD_WSTRING\n void save(const std::wstring & t) BOOST_OVERRIDE {\n ArchiveImplementation::save(t);\n }\n #endif\n boost::serialization::library_version_type get_library_version() const BOOST_OVERRIDE {\n return ArchiveImplementation::get_library_version();\n }\n unsigned int get_flags() const BOOST_OVERRIDE {\n return ArchiveImplementation::get_flags();\n }\n void save_binary(const void * t, std::size_t size) BOOST_OVERRIDE {\n ArchiveImplementation::save_binary(t, size);\n }\n // used for xml and other tagged formats default does nothing\n void save_start(const char * name) BOOST_OVERRIDE {\n ArchiveImplementation::save_start(name);\n }\n void save_end(const char * name) BOOST_OVERRIDE {\n ArchiveImplementation::save_end(name);\n }\n void end_preamble() BOOST_OVERRIDE {\n ArchiveImplementation::end_preamble();\n }\n void register_basic_serializer(const detail::basic_oserializer & bos) BOOST_OVERRIDE {\n ArchiveImplementation::register_basic_serializer(bos);\n }\n helper_collection &\n get_helper_collection() BOOST_OVERRIDE {\n return ArchiveImplementation::get_helper_collection();\n }\npublic:\n // this can't be inherited because they appear in multiple\n // parents\n typedef mpl::bool_ is_loading;\n typedef mpl::bool_ is_saving;\n // the << operator\n template\n polymorphic_oarchive & operator<<(T & t){\n return polymorphic_oarchive::operator<<(t);\n }\n // the & operator\n template\n polymorphic_oarchive & operator&(T & t){\n return polymorphic_oarchive::operator&(t);\n }\n // register type function\n template\n const basic_pointer_oserializer *\n register_type(T * t = NULL){\n return ArchiveImplementation::register_type(t);\n }\n // all current archives take a stream as constructor argument\n template \n polymorphic_oarchive_route(\n std::basic_ostream<_Elem, _Tr> & os,\n unsigned int flags = 0\n ) :\n ArchiveImplementation(os, flags)\n {}\n ~polymorphic_oarchive_route() BOOST_OVERRIDE {}\n};\n\n} // namespace detail\n} // namespace archive\n} // namespace boost\n\n#ifdef BOOST_MSVC\n#pragma warning(pop)\n#endif\n\n#include // pops abi_suffix.hpp pragmas\n\n#endif // BOOST_ARCHIVE_DETAIL_POLYMORPHIC_OARCHIVE_DISPATCH_HPP\n" }, { "path": "include/boost/archive/detail/register_archive.hpp", "content": "// Copyright David Abrahams 2006. Distributed under the Boost\n// Software License, Version 1.0. (See accompanying\n// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)\n#ifndef BOOST_ARCHIVE_DETAIL_REGISTER_ARCHIVE_DWA2006521_HPP\n# define BOOST_ARCHIVE_DETAIL_REGISTER_ARCHIVE_DWA2006521_HPP\n\nnamespace boost { namespace archive { namespace detail {\n\n// No instantiate_ptr_serialization overloads generated by\n// BOOST_SERIALIZATION_REGISTER_ARCHIVE that lexically follow the call\n// will be seen *unless* they are in an associated namespace of one of\n// the arguments, so we pass one of these along to make sure this\n// namespace is considered. See temp.dep.candidate (14.6.4.2) in the\n// standard.\nstruct adl_tag {};\n\ntemplate \nstruct ptr_serialization_support;\n\n// We could've just used ptr_serialization_support, above, but using\n// it with only a forward declaration causes vc6/7 to complain about a\n// missing instantiate member, even if it has one. This is just a\n// friendly layer of indirection.\ntemplate \nstruct _ptr_serialization_support\n : ptr_serialization_support\n{\n typedef int type;\n};\n\n#if defined(__SUNPRO_CC) && (__SUNPRO_CC < 0x5130)\n\ntemplate\nstruct counter : counter {};\ntemplate<>\nstruct counter<0> {};\n\ntemplate\nvoid instantiate_ptr_serialization(Serializable* s, int, adl_tag) {\n instantiate_ptr_serialization(s, counter<20>());\n}\n\ntemplate\nstruct get_counter {\n static const int value = sizeof(adjust_counter(counter<20>()));\n typedef counter type;\n typedef counter prior;\n typedef char (&next)[value+1];\n};\n\nchar adjust_counter(counter<0>);\ntemplate\nvoid instantiate_ptr_serialization(Serializable*, counter<0>) {}\n\n#define BOOST_SERIALIZATION_REGISTER_ARCHIVE(Archive) \\\nnamespace boost { namespace archive { namespace detail { \\\n get_counter::next adjust_counter(get_counter::type);\\\n template \\\n void instantiate_ptr_serialization(Serializable* s, \\\n get_counter::type) { \\\n ptr_serialization_support x; \\\n instantiate_ptr_serialization(s, get_counter::prior()); \\\n }\\\n}}}\n\n\n#else\n\n// This function gets called, but its only purpose is to participate\n// in overload resolution with the functions declared by\n// BOOST_SERIALIZATION_REGISTER_ARCHIVE, below.\ntemplate \nvoid instantiate_ptr_serialization(Serializable*, int, adl_tag ) {}\n\n// The function declaration generated by this macro never actually\n// gets called, but its return type gets instantiated, and that's\n// enough to cause registration of serialization functions between\n// Archive and any exported Serializable type. See also:\n// boost/serialization/export.hpp\n# define BOOST_SERIALIZATION_REGISTER_ARCHIVE(Archive) \\\nnamespace boost { namespace archive { namespace detail { \\\n \\\ntemplate \\\ntypename _ptr_serialization_support::type \\\ninstantiate_ptr_serialization( Serializable*, Archive*, adl_tag ); \\\n \\\n}}}\n#endif\n}}} // namespace boost::archive::detail\n\n#endif // BOOST_ARCHIVE_DETAIL_INSTANTIATE_SERIALIZE_DWA2006521_HPP\n" }, { "path": "include/boost/archive/detail/utf8_codecvt_facet.hpp", "content": "// Copyright (c) 2001 Ronald Garcia, Indiana University (garcia@osl.iu.edu)\n// Andrew Lumsdaine, Indiana University (lums@osl.iu.edu).\n// Distributed under the Boost Software License, Version 1.0. (See\n// accompanying file LICENSE_1_0.txt or copy at\n// http://www.boost.org/LICENSE_1_0.txt)\n\n#ifndef BOOST_ARCHIVE_DETAIL_UTF8_CODECVT_FACET_HPP\n#define BOOST_ARCHIVE_DETAIL_UTF8_CODECVT_FACET_HPP\n\n#include \n\n#ifdef BOOST_NO_STD_WSTREAMBUF\n#error \"wide char i/o not supported on this platform\"\n#endif\n\n// use boost's utf8 codecvt facet\n#include \n#define BOOST_UTF8_BEGIN_NAMESPACE \\\n namespace boost { namespace archive { namespace detail {\n#define BOOST_UTF8_END_NAMESPACE }}}\n\n#include \n\n#undef BOOST_UTF8_END_NAMESPACE\n#undef BOOST_UTF8_DECL\n#undef BOOST_UTF8_BEGIN_NAMESPACE\n\n#endif // BOOST_ARCHIVE_DETAIL_UTF8_CODECVT_FACET_HPP\n" }, { "path": "include/boost/archive/dinkumware.hpp", "content": "#ifndef BOOST_ARCHIVE_DINKUMWARE_HPP\n#define BOOST_ARCHIVE_DINKUMWARE_HPP\n\n// MS compatible compilers support #pragma once\n#if defined(_MSC_VER)\n# pragma once\n#endif\n\n/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8\n// dinkumware.hpp:\n\n// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .\n// Use, modification and distribution is subject to the Boost Software\n// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at\n// http://www.boost.org/LICENSE_1_0.txt)\n\n// See http://www.boost.org for updates, documentation, and revision history.\n\n// this file adds a couple of things that are missing from the dinkumware\n// implementation of the standard library.\n\n#include \n#include \n\n#include \n#include \n\nnamespace std {\n\n// define i/o operators for 64 bit integers\ntemplate\nbasic_ostream &\noperator<<(basic_ostream & os, boost::uint64_t t){\n // octal rendering of 64 bit number would be 22 octets + eos\n CharType d[23];\n unsigned int radix;\n\n if(os.flags() & (int)std::ios_base::hex)\n radix = 16;\n else\n if(os.flags() & (int)std::ios_base::oct)\n radix = 8;\n else\n //if(s.flags() & (int)std::ios_base::dec)\n radix = 10;\n unsigned int i = 0;\n do{\n unsigned int j = t % radix;\n d[i++] = j + ((j < 10) ? '0' : ('a' - 10));\n t /= radix;\n }\n while(t > 0);\n d[i--] = '\\0';\n\n // reverse digits\n unsigned int j = 0;\n while(j < i){\n CharType k = d[i];\n d[i] = d[j];\n d[j] = k;\n --i;++j;\n }\n os << d;\n return os;\n\n}\n\ntemplate\nbasic_ostream &\noperator<<(basic_ostream &os, boost::int64_t t){\n if(0 <= t){\n os << static_cast(t);\n }\n else{\n os.put('-');\n os << -t;\n }\n return os;\n}\n\ntemplate\nbasic_istream &\noperator>>(basic_istream &is, boost::int64_t & t){\n CharType d;\n do{\n d = is.get();\n }\n while(::isspace(d));\n bool negative = (d == '-');\n if(negative)\n d = is.get();\n unsigned int radix;\n if(is.flags() & (int)std::ios_base::hex)\n radix = 16;\n else\n if(is.flags() & (int)std::ios_base::oct)\n radix = 8;\n else\n //if(s.flags() & (int)std::ios_base::dec)\n radix = 10;\n t = 0;\n do{\n if('0' <= d && d <= '9')\n t = t * radix + (d - '0');\n else\n if('a' <= d && d <= 'f')\n t = t * radix + (d - 'a' + 10);\n else\n break;\n d = is.get();\n }\n while(!is.fail());\n // restore the delimiter\n is.putback(d);\n is.clear();\n if(negative)\n t = -t;\n return is;\n}\n\ntemplate\nbasic_istream &\noperator>>(basic_istream &is, boost::uint64_t & t){\n boost::int64_t it;\n is >> it;\n t = it;\n return is;\n}\n\ntemplate<>\nclass back_insert_iterator > : public\n iterator\n{\npublic:\n typedef basic_string container_type;\n typedef container_type::reference reference;\n\n explicit back_insert_iterator(container_type & s)\n : container(& s)\n {} // construct with container\n\n back_insert_iterator & operator=(\n container_type::const_reference Val_\n ){ // push value into container\n //container->push_back(Val_);\n *container += Val_;\n return (*this);\n }\n\n back_insert_iterator & operator*(){\n return (*this);\n }\n\n back_insert_iterator & operator++(){\n // pretend to preincrement\n return (*this);\n }\n\n back_insert_iterator operator++(int){\n // pretend to postincrement\n return (*this);\n }\n\nprotected:\n container_type *container; // pointer to container\n};\n\ntemplate\ninline back_insert_iterator > back_inserter(\n basic_string & s\n){\n return (std::back_insert_iterator >(s));\n}\n\ntemplate<>\nclass back_insert_iterator > : public\n iterator\n{\npublic:\n typedef basic_string container_type;\n typedef container_type::reference reference;\n\n explicit back_insert_iterator(container_type & s)\n : container(& s)\n {} // construct with container\n\n back_insert_iterator & operator=(\n container_type::const_reference Val_\n ){ // push value into container\n //container->push_back(Val_);\n *container += Val_;\n return (*this);\n }\n\n back_insert_iterator & operator*(){\n return (*this);\n }\n\n back_insert_iterator & operator++(){\n // pretend to preincrement\n return (*this);\n }\n\n back_insert_iterator operator++(int){\n // pretend to postincrement\n return (*this);\n }\n\nprotected:\n container_type *container; // pointer to container\n};\n\ntemplate\ninline back_insert_iterator > back_inserter(\n basic_string & s\n){\n return (std::back_insert_iterator >(s));\n}\n\n} // namespace std\n\n#endif //BOOST_ARCHIVE_DINKUMWARE_HPP\n" }, { "path": "include/boost/archive/impl/archive_serializer_map.ipp", "content": "/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8\n// archive_serializer_map.ipp:\n\n// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .\n// Distributed under the Boost Software License, Version 1.0. (See\n// accompanying file LICENSE_1_0.txt or copy at\n// http://www.boost.org/LICENSE_1_0.txt)\n\n// See http://www.boost.org for updates, documentation, and revision history.\n\n//////////////////////////////////////////////////////////////////////\n// implementation of basic_text_iprimitive overrides for the combination\n// of template parameters used to implement a text_iprimitive\n\n#include \n#include \n#include \n#include \n\nnamespace boost {\nnamespace archive {\nnamespace detail {\n\n#ifdef BOOST_MSVC\n# pragma warning(push)\n# pragma warning(disable : 4511 4512)\n#endif\n\nnamespace extra_detail { // anon\n template\n class map : public basic_serializer_map \n {};\n}\n\n#ifdef BOOST_MSVC\n# pragma warning(pop)\n#endif\n\ntemplate\nBOOST_ARCHIVE_OR_WARCHIVE_DECL bool\narchive_serializer_map::insert(const basic_serializer * bs){\n return boost::serialization::singleton<\n extra_detail::map\n >::get_mutable_instance().insert(bs);\n}\n\ntemplate\nBOOST_ARCHIVE_OR_WARCHIVE_DECL void\narchive_serializer_map::erase(const basic_serializer * bs){\n // note: previously this conditional was a runtime assertion with\n // BOOST_ASSERT. We've changed it because we've discovered that at\n // least one platform is not guaranteed to destroy singletons in\n // reverse order of distruction.\n if(boost::serialization::singleton<\n extra_detail::map\n >::is_destroyed())\n return;\n boost::serialization::singleton<\n extra_detail::map\n >::get_mutable_instance().erase(bs);\n}\n\ntemplate\nBOOST_ARCHIVE_OR_WARCHIVE_DECL const basic_serializer *\narchive_serializer_map::find(\n const boost::serialization::extended_type_info & eti\n) {\n return boost::serialization::singleton<\n extra_detail::map\n >::get_const_instance().find(eti);\n}\n\n} // namespace detail\n} // namespace archive\n} // namespace boost\n" }, { "path": "include/boost/archive/impl/basic_binary_iarchive.ipp", "content": "/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8\n// basic_binary_iarchive.ipp:\n\n// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . \n// Use, modification and distribution is subject to the Boost Software\n// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at\n// http://www.boost.org/LICENSE_1_0.txt)\n\n// See http://www.boost.org for updates, documentation, and revision history.\n#include \n#include \n#include \n#include \n\n#include \n#if defined(BOOST_NO_STDC_NAMESPACE)\nnamespace std{ \n using ::memcpy; \n using ::strlen;\n using ::size_t;\n}\n#endif\n\n#include \n#include \n\n#include \n\nnamespace boost {\nnamespace archive {\n\n/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8\n// implementation of binary_binary_archive\ntemplate\nBOOST_ARCHIVE_OR_WARCHIVE_DECL void\nbasic_binary_iarchive::load_override(class_name_type & t){\n std::string cn;\n cn.reserve(BOOST_SERIALIZATION_MAX_KEY_SIZE);\n load_override(cn);\n if(cn.size() > (BOOST_SERIALIZATION_MAX_KEY_SIZE - 1))\n boost::serialization::throw_exception(\n archive_exception(archive_exception::invalid_class_name)\n );\n std::memcpy(t, cn.data(), cn.size());\n // borland tweak\n t.t[cn.size()] = '\\0';\n}\n\ntemplate\nBOOST_ARCHIVE_OR_WARCHIVE_DECL void\nbasic_binary_iarchive::init() {\n // read signature in an archive version independent manner\n std::string file_signature;\n \n #if 0 // commented out since it interfers with derivation\n BOOST_TRY {\n std::size_t l;\n this->This()->load(l);\n if(l == std::strlen(BOOST_ARCHIVE_SIGNATURE())) {\n // borland de-allocator fixup\n #if BOOST_WORKAROUND(_RWSTD_VER, BOOST_TESTED_AT(20101))\n if(NULL != file_signature.data())\n #endif\n file_signature.resize(l);\n // note breaking a rule here - could be a problem on some platform\n if(0 < l)\n this->This()->load_binary(&(*file_signature.begin()), l);\n }\n }\n BOOST_CATCH(archive_exception const &) { // catch stream_error archive exceptions\n // will cause invalid_signature archive exception to be thrown below\n file_signature = \"\"; \n }\n BOOST_CATCH_END\n #else\n // https://svn.boost.org/trac/boost/ticket/7301\n * this->This() >> file_signature;\n #endif\n\n if(file_signature != BOOST_ARCHIVE_SIGNATURE())\n boost::serialization::throw_exception(\n archive_exception(archive_exception::invalid_signature)\n );\n\n // make sure the version of the reading archive library can\n // support the format of the archive being read\n boost::serialization::library_version_type input_library_version;\n //* this->This() >> input_library_version;\n {\n int v = 0;\n v = this->This()->m_sb.sbumpc();\n #if BOOST_ENDIAN_LITTLE_BYTE\n if(v < 6){\n ;\n }\n else\n if(v < 7){\n // version 6 - next byte should be zero\n this->This()->m_sb.sbumpc();\n }\n else\n if(v < 8){\n int x1;\n // version 7 = might be followed by zero or some other byte\n x1 = this->This()->m_sb.sgetc();\n // it's =a zero, push it back\n if(0 == x1)\n this->This()->m_sb.sbumpc();\n }\n else{\n // version 8+ followed by a zero\n this->This()->m_sb.sbumpc();\n }\n #elif BOOST_ENDIAN_BIG_BYTE\n if(v == 0)\n v = this->This()->m_sb.sbumpc();\n #endif\n input_library_version = static_cast(v);\n }\n \n #if BOOST_WORKAROUND(__MWERKS__, BOOST_TESTED_AT(0x3205))\n this->set_library_version(input_library_version);\n #else\n detail::basic_iarchive::set_library_version(input_library_version);\n #endif\n \n if(BOOST_ARCHIVE_VERSION() < input_library_version)\n boost::serialization::throw_exception(\n archive_exception(archive_exception::unsupported_version)\n );\n}\n\n} // namespace archive\n} // namespace boost\n" }, { "path": "include/boost/archive/impl/basic_binary_iprimitive.ipp", "content": "/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8\n// basic_binary_iprimitive.ipp:\n\n// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . \n// Use, modification and distribution is subject to the Boost Software\n// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at\n// http://www.boost.org/LICENSE_1_0.txt)\n\n// See http://www.boost.org for updates, documentation, and revision history.\n\n#include \n#include // size_t, NULL\n#include // memcpy\n\n#include \n#if defined(BOOST_NO_STDC_NAMESPACE)\nnamespace std{ \n using ::size_t;\n using ::memcpy;\n} // namespace std\n#endif\n\n#include \n#include \n#include \n#include \n\nnamespace boost {\nnamespace archive {\n\n//////////////////////////////////////////////////////////////////////\n// implementation of basic_binary_iprimitive\n\ntemplate\nBOOST_ARCHIVE_OR_WARCHIVE_DECL void\nbasic_binary_iprimitive::init()\n{\n // Detect attempts to pass native binary archives across\n // incompatible platforms. This is not fool proof but its\n // better than nothing.\n unsigned char size;\n this->This()->load(size);\n if(sizeof(int) != size)\n boost::serialization::throw_exception(\n archive_exception(\n archive_exception::incompatible_native_format,\n \"size of int\"\n )\n );\n this->This()->load(size);\n if(sizeof(long) != size)\n boost::serialization::throw_exception(\n archive_exception(\n archive_exception::incompatible_native_format,\n \"size of long\"\n )\n );\n this->This()->load(size);\n if(sizeof(float) != size)\n boost::serialization::throw_exception(\n archive_exception(\n archive_exception::incompatible_native_format,\n \"size of float\"\n )\n );\n this->This()->load(size);\n if(sizeof(double) != size)\n boost::serialization::throw_exception(\n archive_exception(\n archive_exception::incompatible_native_format,\n \"size of double\"\n )\n );\n\n // for checking endian\n int i;\n this->This()->load(i);\n if(1 != i)\n boost::serialization::throw_exception(\n archive_exception(\n archive_exception::incompatible_native_format,\n \"endian setting\"\n )\n );\n}\n\n#ifndef BOOST_NO_CWCHAR\n#ifndef BOOST_NO_INTRINSIC_WCHAR_T\ntemplate\nBOOST_ARCHIVE_OR_WARCHIVE_DECL void\nbasic_binary_iprimitive::load(wchar_t * ws)\n{\n std::size_t l; // number of wchar_t !!!\n this->This()->load(l);\n load_binary(ws, l * sizeof(wchar_t) / sizeof(char));\n ws[l] = L'\\0';\n}\n#endif\n#endif\n\ntemplate\nBOOST_ARCHIVE_OR_WARCHIVE_DECL void\nbasic_binary_iprimitive::load(std::string & s)\n{\n std::size_t l;\n this->This()->load(l);\n // borland de-allocator fixup\n #if BOOST_WORKAROUND(_RWSTD_VER, BOOST_TESTED_AT(20101))\n if(NULL != s.data())\n #endif\n s.resize(l);\n // note breaking a rule here - could be a problem on some platform\n if(0 < l)\n load_binary(&(*s.begin()), l);\n}\n\ntemplate\nBOOST_ARCHIVE_OR_WARCHIVE_DECL void\nbasic_binary_iprimitive::load(char * s)\n{\n std::size_t l;\n this->This()->load(l);\n load_binary(s, l);\n s[l] = '\\0';\n}\n\n#ifndef BOOST_NO_STD_WSTRING\ntemplate\nBOOST_ARCHIVE_OR_WARCHIVE_DECL void\nbasic_binary_iprimitive::load(std::wstring & ws)\n{\n std::size_t l;\n this->This()->load(l);\n // borland de-allocator fixup\n #if BOOST_WORKAROUND(_RWSTD_VER, BOOST_TESTED_AT(20101))\n if(NULL != ws.data())\n #endif\n ws.resize(l);\n // note breaking a rule here - is could be a problem on some platform\n load_binary(const_cast(ws.data()), l * sizeof(wchar_t) / sizeof(char));\n}\n#endif\n\ntemplate\nBOOST_ARCHIVE_OR_WARCHIVE_DECL\nbasic_binary_iprimitive::basic_binary_iprimitive(\n std::basic_streambuf & sb, \n bool no_codecvt\n) :\n#ifndef BOOST_NO_STD_LOCALE\n m_sb(sb),\n codecvt_null_facet(1),\n locale_saver(m_sb),\n archive_locale(sb.getloc(), & codecvt_null_facet)\n{\n if(! no_codecvt){\n m_sb.pubsync();\n m_sb.pubimbue(archive_locale);\n }\n}\n#else\n m_sb(sb)\n{}\n#endif\n\n// scoped_ptr requires that g be a complete type at time of\n// destruction so define destructor here rather than in the header\ntemplate\nBOOST_ARCHIVE_OR_WARCHIVE_DECL\nbasic_binary_iprimitive::~basic_binary_iprimitive(){}\n\n} // namespace archive\n} // namespace boost\n" }, { "path": "include/boost/archive/impl/basic_binary_oarchive.ipp", "content": "/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8\n// basic_binary_oarchive.ipp:\n\n// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . \n// Use, modification and distribution is subject to the Boost Software\n// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at\n// http://www.boost.org/LICENSE_1_0.txt)\n\n// See http://www.boost.org for updates, documentation, and revision history.\n#include \n#include \n#include \n#include \n\n#include \n#if defined(BOOST_NO_STDC_NAMESPACE)\nnamespace std{ \n using ::memcpy; \n}\n#endif\n\n#include \n\nnamespace boost {\nnamespace archive {\n\n/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8\n// implementation of binary_binary_oarchive\n\ntemplate\nBOOST_ARCHIVE_OR_WARCHIVE_DECL void\nbasic_binary_oarchive::init(){\n // write signature in an archive version independent manner\n const std::string file_signature(BOOST_ARCHIVE_SIGNATURE());\n * this->This() << file_signature;\n // write library version\n const boost::serialization::library_version_type v(BOOST_ARCHIVE_VERSION());\n * this->This() << v;\n}\n\n} // namespace archive\n} // namespace boost\n" }, { "path": "include/boost/archive/impl/basic_binary_oprimitive.ipp", "content": "/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8\n// basic_binary_oprimitive.ipp:\n\n// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . \n// Use, modification and distribution is subject to the Boost Software\n// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at\n// http://www.boost.org/LICENSE_1_0.txt)\n\n// See http://www.boost.org for updates, documentation, and revision history.\n\n#include \n#include // NULL\n#include \n\n#include \n\n#if defined(BOOST_NO_STDC_NAMESPACE) && ! defined(__LIBCOMO__)\nnamespace std{ \n using ::strlen; \n} // namespace std\n#endif\n\n#ifndef BOOST_NO_CWCHAR\n#include \n#ifdef BOOST_NO_STDC_NAMESPACE\nnamespace std{ using ::wcslen; }\n#endif\n#endif\n\n#include \n#include \n\nnamespace boost {\nnamespace archive {\n\n//////////////////////////////////////////////////////////////////////\n// implementation of basic_binary_oprimitive\n\ntemplate\nBOOST_ARCHIVE_OR_WARCHIVE_DECL void\nbasic_binary_oprimitive::init()\n{\n // record native sizes of fundamental types\n // this is to permit detection of attempts to pass\n // native binary archives accross incompatible machines.\n // This is not foolproof but its better than nothing.\n this->This()->save(static_cast(sizeof(int)));\n this->This()->save(static_cast(sizeof(long)));\n this->This()->save(static_cast(sizeof(float)));\n this->This()->save(static_cast(sizeof(double)));\n // for checking endianness\n this->This()->save(int(1));\n}\n\ntemplate\nBOOST_ARCHIVE_OR_WARCHIVE_DECL void\nbasic_binary_oprimitive::save(const char * s)\n{\n std::size_t l = std::strlen(s);\n this->This()->save(l);\n save_binary(s, l);\n}\n\ntemplate\nBOOST_ARCHIVE_OR_WARCHIVE_DECL void\nbasic_binary_oprimitive::save(const std::string &s)\n{\n std::size_t l = static_cast(s.size());\n this->This()->save(l);\n save_binary(s.data(), l);\n}\n\n#ifndef BOOST_NO_CWCHAR\n#ifndef BOOST_NO_INTRINSIC_WCHAR_T\ntemplate\nBOOST_ARCHIVE_OR_WARCHIVE_DECL void\nbasic_binary_oprimitive::save(const wchar_t * ws)\n{\n std::size_t l = std::wcslen(ws);\n this->This()->save(l);\n save_binary(ws, l * sizeof(wchar_t) / sizeof(char));\n}\n#endif\n\n#ifndef BOOST_NO_STD_WSTRING\ntemplate\nBOOST_ARCHIVE_OR_WARCHIVE_DECL void\nbasic_binary_oprimitive::save(const std::wstring &ws)\n{\n std::size_t l = ws.size();\n this->This()->save(l);\n save_binary(ws.data(), l * sizeof(wchar_t) / sizeof(char));\n}\n#endif\n#endif // BOOST_NO_CWCHAR\n\ntemplate\nBOOST_ARCHIVE_OR_WARCHIVE_DECL\nbasic_binary_oprimitive::basic_binary_oprimitive(\n std::basic_streambuf & sb, \n bool no_codecvt\n) : \n#ifndef BOOST_NO_STD_LOCALE\n m_sb(sb),\n codecvt_null_facet(1),\n locale_saver(m_sb),\n archive_locale(sb.getloc(), & codecvt_null_facet)\n{\n if(! no_codecvt){\n m_sb.pubsync();\n m_sb.pubimbue(archive_locale);\n }\n}\n#else\n m_sb(sb)\n{}\n#endif\n\n// scoped_ptr requires that g be a complete type at time of\n// destruction so define destructor here rather than in the header\ntemplate\nBOOST_ARCHIVE_OR_WARCHIVE_DECL\nbasic_binary_oprimitive::~basic_binary_oprimitive(){}\n\n} // namespace archive\n} // namespace boost\n" }, { "path": "include/boost/archive/impl/basic_text_iarchive.ipp", "content": "/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8\n// basic_text_iarchive.ipp:\n\n// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . \n// Use, modification and distribution is subject to the Boost Software\n// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at\n// http://www.boost.org/LICENSE_1_0.txt)\n\n// See http://www.boost.org for updates, documentation, and revision history.\n#include \n#include \n#include \n\n#include \n#if defined(BOOST_NO_STDC_NAMESPACE)\nnamespace std{ \n using ::memcpy; \n}\n#endif\n\n#include \n#include \n#include \n\nnamespace boost {\nnamespace archive {\n\n/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8\n// implementation of text_text_archive\n\ntemplate\nBOOST_ARCHIVE_OR_WARCHIVE_DECL void\nbasic_text_iarchive::load_override(class_name_type & t){\n std::string cn;\n cn.reserve(BOOST_SERIALIZATION_MAX_KEY_SIZE);\n load_override(cn);\n if(cn.size() > (BOOST_SERIALIZATION_MAX_KEY_SIZE - 1))\n boost::serialization::throw_exception(\n archive_exception(archive_exception::invalid_class_name)\n );\n std::memcpy(t, cn.data(), cn.size());\n // borland tweak\n t.t[cn.size()] = '\\0';\n}\n\ntemplate\nBOOST_ARCHIVE_OR_WARCHIVE_DECL void\nbasic_text_iarchive::init() {\n // read signature in an archive version independent manner\n std::string file_signature;\n * this->This() >> file_signature;\n if(file_signature != BOOST_ARCHIVE_SIGNATURE())\n boost::serialization::throw_exception(\n archive_exception(archive_exception::invalid_signature)\n );\n\n // make sure the version of the reading archive library can\n // support the format of the archive being read\n boost::serialization::library_version_type input_library_version;\n * this->This() >> input_library_version;\n\n #if BOOST_WORKAROUND(__MWERKS__, BOOST_TESTED_AT(0x3205))\n this->set_library_version(input_library_version);\n #else\n detail::basic_iarchive::set_library_version(input_library_version);\n #endif\n\n // extra little .t is to get around borland quirk\n if(BOOST_ARCHIVE_VERSION() < input_library_version)\n boost::serialization::throw_exception(\n archive_exception(archive_exception::unsupported_version)\n );\n}\n\n} // namespace archive\n} // namespace boost\n" }, { "path": "include/boost/archive/impl/basic_text_iprimitive.ipp", "content": "/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8\n// basic_text_iprimitive.ipp:\n\n// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .\n// Distributed under the Boost Software License, Version 1.0. (See\n// accompanying file LICENSE_1_0.txt or copy at\n// http://www.boost.org/LICENSE_1_0.txt)\n\n// See http://www.boost.org for updates, documentation, and revision history.\n\n#include // size_t, NULL\n#include // NULL\n\n#include \n#if defined(BOOST_NO_STDC_NAMESPACE)\nnamespace std{ \n using ::size_t; \n} // namespace std\n#endif\n\n#include \n\n#include \n\n#include \n#include \n#include \n#include \n\nnamespace boost {\nnamespace archive {\n\nnamespace detail {\n template\n static inline bool is_whitespace(CharType c);\n\n template<>\n inline bool is_whitespace(char t){\n return 0 != std::isspace(t);\n }\n\n #ifndef BOOST_NO_CWCHAR\n template<>\n inline bool is_whitespace(wchar_t t){\n return 0 != std::iswspace(t);\n }\n #endif\n} // detail\n\n// translate base64 text into binary and copy into buffer\n// until buffer is full.\ntemplate\nBOOST_ARCHIVE_OR_WARCHIVE_DECL void\nbasic_text_iprimitive::load_binary(\n void *address, \n std::size_t count\n){\n typedef typename IStream::char_type CharType;\n \n if(0 == count)\n return;\n \n BOOST_ASSERT(\n static_cast((std::numeric_limits::max)())\n > (count + sizeof(CharType) - 1)/sizeof(CharType)\n );\n \n if(is.fail())\n boost::serialization::throw_exception(\n archive_exception(archive_exception::input_stream_error)\n );\n // convert from base64 to binary\n typedef typename\n iterators::transform_width<\n iterators::binary_from_base64<\n iterators::remove_whitespace<\n iterators::istream_iterator\n >\n ,typename IStream::int_type\n >\n ,8\n ,6\n ,CharType\n > \n binary;\n \n binary i = binary(iterators::istream_iterator(is));\n\n char * caddr = static_cast(address);\n \n // take care that we don't increment anymore than necessary\n while(count-- > 0){\n *caddr++ = static_cast(*i++);\n }\n\n // skip over any excess input\n for(;;){\n typename IStream::int_type r;\n r = is.get();\n if(is.eof())\n break;\n if(detail::is_whitespace(static_cast(r)))\n break;\n }\n}\n \ntemplate\nBOOST_ARCHIVE_OR_WARCHIVE_DECL\nbasic_text_iprimitive::basic_text_iprimitive(\n IStream &is_,\n bool no_codecvt\n) :\n is(is_),\n flags_saver(is_),\n#ifndef BOOST_NO_STD_LOCALE\n precision_saver(is_),\n codecvt_null_facet(1),\n archive_locale(is.getloc(), & codecvt_null_facet),\n locale_saver(is)\n{\n if(! no_codecvt){\n is_.sync();\n is_.imbue(archive_locale);\n }\n is_ >> std::noboolalpha;\n}\n#else\n precision_saver(is_)\n{}\n#endif\n\ntemplate\nBOOST_ARCHIVE_OR_WARCHIVE_DECL\nbasic_text_iprimitive::~basic_text_iprimitive(){\n}\n\n} // namespace archive\n} // namespace boost\n" }, { "path": "include/boost/archive/impl/basic_text_oarchive.ipp", "content": "/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8\n// basic_text_oarchive.ipp:\n\n// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . \n// Use, modification and distribution is subject to the Boost Software\n// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at\n// http://www.boost.org/LICENSE_1_0.txt)\n\n// See http://www.boost.org for updates, documentation, and revision history.\n#include \n#include \n#include \n\n#include \n#if defined(BOOST_NO_STDC_NAMESPACE)\nnamespace std{ \n using ::memcpy; \n}\n#endif\n\n#include \n\nnamespace boost {\nnamespace archive {\n\n/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8\n// implementation of basic_text_oarchive\n\ntemplate\nBOOST_ARCHIVE_OR_WARCHIVE_DECL void\nbasic_text_oarchive::newtoken()\n{\n switch(delimiter){\n default:\n BOOST_ASSERT(false);\n break;\n case eol:\n this->This()->put('\\n');\n delimiter = space;\n break;\n case space:\n this->This()->put(' ');\n break;\n case none:\n delimiter = space;\n break;\n }\n}\n\ntemplate\nBOOST_ARCHIVE_OR_WARCHIVE_DECL void\nbasic_text_oarchive::init(){\n // write signature in an archive version independent manner\n const std::string file_signature(BOOST_ARCHIVE_SIGNATURE());\n * this->This() << file_signature;\n // write library version\n const boost::serialization::library_version_type v(BOOST_ARCHIVE_VERSION());\n * this->This() << v;\n}\n\n} // namespace archive\n} // namespace boost\n" }, { "path": "include/boost/archive/impl/basic_text_oprimitive.ipp", "content": "/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8\n// basic_text_oprimitive.ipp:\n\n// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . \n// Use, modification and distribution is subject to the Boost Software\n// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at\n// http://www.boost.org/LICENSE_1_0.txt)\n\n// See http://www.boost.org for updates, documentation, and revision history.\n\n#include // NULL\n#include // std::copy\n#include \n#if defined(BOOST_NO_STDC_NAMESPACE)\nnamespace std{ \n using ::size_t; \n} // namespace std\n#endif\n\n#include \n\n#include \n\n#include \n#include \n#include \n#include \n\nnamespace boost {\nnamespace archive {\n\n// translate to base64 and copy in to buffer.\ntemplate\nBOOST_ARCHIVE_OR_WARCHIVE_DECL void\nbasic_text_oprimitive::save_binary(\n const void *address, \n std::size_t count\n){\n typedef typename OStream::char_type CharType;\n \n if(0 == count)\n return;\n \n if(os.fail())\n boost::serialization::throw_exception(\n archive_exception(archive_exception::output_stream_error)\n );\n \n os.put('\\n');\n \n typedef \n boost::archive::iterators::insert_linebreaks<\n boost::archive::iterators::base64_from_binary<\n boost::archive::iterators::transform_width<\n const char *,\n 6,\n 8\n >\n > \n ,76\n ,const char // cwpro8 needs this\n > \n base64_text;\n\n boost::archive::iterators::ostream_iterator oi(os);\n std::copy(\n base64_text(static_cast(address)),\n base64_text(\n static_cast(address) + count\n ),\n oi\n );\n \n std::size_t tail = count % 3;\n if(tail > 0){\n *oi++ = '=';\n if(tail < 2)\n *oi = '=';\n }\n}\n\ntemplate\nBOOST_ARCHIVE_OR_WARCHIVE_DECL\nbasic_text_oprimitive::basic_text_oprimitive(\n OStream & os_,\n bool no_codecvt\n) : \n os(os_),\n flags_saver(os_),\n#ifndef BOOST_NO_STD_LOCALE\n precision_saver(os_),\n codecvt_null_facet(1),\n archive_locale(os.getloc(), & codecvt_null_facet),\n locale_saver(os)\n{\n if(! no_codecvt){\n os_.flush();\n os_.imbue(archive_locale);\n }\n os_ << std::noboolalpha;\n}\n#else\n precision_saver(os_)\n{}\n#endif\n\n\ntemplate\nBOOST_ARCHIVE_OR_WARCHIVE_DECL\nbasic_text_oprimitive::~basic_text_oprimitive(){\n if(boost::core::uncaught_exceptions() > 0)\n return;\n os << std::endl;\n}\n\n} //namespace boost \n} //namespace archive \n" }, { "path": "include/boost/archive/impl/basic_xml_grammar.hpp", "content": "#ifndef BOOST_ARCHIVE_BASIC_XML_GRAMMAR_HPP\n#define BOOST_ARCHIVE_BASIC_XML_GRAMMAR_HPP\n\n// MS compatible compilers support #pragma once\n#if defined(_MSC_VER)\n# pragma once\n#endif\n\n/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8\n// basic_xml_grammar.hpp\n\n// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .\n// Use, modification and distribution is subject to the Boost Software\n// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at\n// http://www.boost.org/LICENSE_1_0.txt)\n\n// See http://www.boost.org for updates, documentation, and revision history.\n\n// this module is derived from simplexml.cpp - an example shipped as part of\n// the spirit parser. This example contains the following notice:\n/*=============================================================================\n simplexml.cpp\n\n Spirit V1.3\n URL: http://spirit.sourceforge.net/\n\n Copyright (c) 2001, Daniel C. Nuffer\n\n This software is provided 'as-is', without any express or implied\n warranty. In no event will the copyright holder be held liable for\n any damages arising from the use of this software.\n\n Permission is granted to anyone to use this software for any purpose,\n including commercial applications, and to alter it and redistribute\n it freely, subject to the following restrictions:\n\n 1. The origin of this software must not be misrepresented; you must\n not claim that you wrote the original software. If you use this\n software in a product, an acknowledgment in the product documentation\n would be appreciated but is not required.\n\n 2. Altered source versions must be plainly marked as such, and must\n not be misrepresented as being the original software.\n\n 3. This notice may not be removed or altered from any source\n distribution.\n=============================================================================*/\n#include \n\n#include \n#include \n\n#include \n#include \n\n#include \n#include \n#include \n\nnamespace boost {\nnamespace archive {\n\n/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8\n// XML grammar parsing\n\ntemplate\nclass BOOST_SYMBOL_VISIBLE basic_xml_grammar {\npublic:\n // The following is not necessary according to DR45, but at least\n // one compiler (Compaq C++ 6.5 in strict_ansi mode) chokes otherwise.\n struct return_values;\n friend struct return_values;\n\nprivate:\n typedef typename std::basic_istream IStream;\n typedef typename std::basic_string StringType;\n typedef typename boost::spirit::classic::chset chset_t;\n typedef typename boost::spirit::classic::chlit chlit_t;\n typedef typename boost::spirit::classic::scanner<\n typename std::basic_string::iterator\n > scanner_t;\n typedef typename boost::spirit::classic::rule rule_t;\n // Start grammar definition\n rule_t\n Reference,\n Eq,\n STag,\n ETag,\n LetterOrUnderscoreOrColon,\n AttValue,\n CharRef1,\n CharRef2,\n CharRef,\n AmpRef,\n LTRef,\n GTRef,\n AposRef,\n QuoteRef,\n CharData,\n CharDataChars,\n content,\n AmpName,\n LTName,\n GTName,\n ClassNameChar,\n ClassName,\n Name,\n XMLDecl,\n XMLDeclChars,\n DocTypeDecl,\n DocTypeDeclChars,\n ClassIDAttribute,\n ObjectIDAttribute,\n ClassNameAttribute,\n TrackingAttribute,\n VersionAttribute,\n UnusedAttribute,\n Attribute,\n SignatureAttribute,\n SerializationWrapper,\n NameHead,\n NameTail,\n AttributeList,\n S;\n\n // XML Character classes\n chset_t\n BaseChar,\n Ideographic,\n Char,\n Letter,\n Digit,\n CombiningChar,\n Extender,\n Sch,\n NameChar;\n\n void init_chset();\n\n bool my_parse(\n IStream & is,\n const rule_t &rule_,\n const CharType delimiter = L'>'\n ) const ;\npublic:\n struct return_values {\n StringType object_name;\n StringType contents;\n //class_id_type class_id;\n int_least16_t class_id;\n //object_id_type object_id;\n uint_least32_t object_id;\n //version_type version;\n unsigned int version;\n tracking_type tracking_level;\n StringType class_name;\n return_values() :\n version(0),\n tracking_level(false)\n {}\n } rv;\n bool parse_start_tag(IStream & is) /*const*/;\n bool parse_end_tag(IStream & is) const;\n bool parse_string(IStream & is, StringType & s) /*const*/;\n void init(IStream & is);\n bool windup(IStream & is);\n basic_xml_grammar();\n};\n\n} // namespace archive\n} // namespace boost\n\n#endif // BOOST_ARCHIVE_BASIC_XML_GRAMMAR_HPP\n" }, { "path": "include/boost/archive/impl/basic_xml_iarchive.ipp", "content": "/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8\n// basic_xml_iarchive.ipp:\n\n// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . \n// Use, modification and distribution is subject to the Boost Software\n// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at\n// http://www.boost.org/LICENSE_1_0.txt)\n\n// See http://www.boost.org for updates, documentation, and revision history.\n\n#include \n#include // NULL\n#include // strlen\n#include \n\n#include \n#include \n#include \n#include \n\nnamespace boost {\nnamespace archive {\n\n/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8\n// implementation of xml_text_archive\n\ntemplate\nBOOST_ARCHIVE_OR_WARCHIVE_DECL void\nbasic_xml_iarchive::load_start(const char *name){\n // if there's no name\n if(NULL == name)\n return;\n bool result = this->This()->gimpl->parse_start_tag(this->This()->get_is());\n if(true != result){\n boost::serialization::throw_exception(\n archive_exception(archive_exception::input_stream_error)\n );\n }\n // don't check start tag at highest level\n ++depth;\n}\n\ntemplate\nBOOST_ARCHIVE_OR_WARCHIVE_DECL void\nbasic_xml_iarchive::load_end(const char *name){\n // if there's no name\n if(NULL == name)\n return;\n bool result = this->This()->gimpl->parse_end_tag(this->This()->get_is());\n if(true != result){\n boost::serialization::throw_exception(\n archive_exception(archive_exception::input_stream_error)\n );\n }\n \n // don't check start tag at highest level\n if(0 == --depth)\n return;\n \n if(0 == (this->get_flags() & no_xml_tag_checking)){\n // double check that the tag matches what is expected - useful for debug\n std::size_t parameter_name_length = std::strlen(name);\n std::size_t object_name_length = this->This()->gimpl->rv.object_name.size();\n\n if(parameter_name_length != object_name_length\n || ! std::equal(\n this->This()->gimpl->rv.object_name.begin(),\n this->This()->gimpl->rv.object_name.end(),\n name\n )\n ){\n boost::serialization::throw_exception(\n xml_archive_exception(\n xml_archive_exception::xml_archive_tag_mismatch,\n name\n )\n );\n }\n }\n}\n\ntemplate\nBOOST_ARCHIVE_OR_WARCHIVE_DECL void\nbasic_xml_iarchive::load_override(object_id_type & t){\n t = object_id_type(this->This()->gimpl->rv.object_id);\n}\n\ntemplate\nBOOST_ARCHIVE_OR_WARCHIVE_DECL void\nbasic_xml_iarchive::load_override(version_type & t){\n t = version_type(this->This()->gimpl->rv.version);\n}\n\ntemplate\nBOOST_ARCHIVE_OR_WARCHIVE_DECL void\nbasic_xml_iarchive::load_override(class_id_type & t){\n t = class_id_type(this->This()->gimpl->rv.class_id);\n}\n\ntemplate\nBOOST_ARCHIVE_OR_WARCHIVE_DECL void\nbasic_xml_iarchive::load_override(tracking_type & t){\n t = this->This()->gimpl->rv.tracking_level;\n}\n\ntemplate\nBOOST_ARCHIVE_OR_WARCHIVE_DECL\nbasic_xml_iarchive::basic_xml_iarchive(unsigned int flags) :\n detail::common_iarchive(flags),\n depth(0)\n{}\ntemplate\nBOOST_ARCHIVE_OR_WARCHIVE_DECL\nbasic_xml_iarchive::~basic_xml_iarchive(){\n}\n\n} // namespace archive\n} // namespace boost\n" }, { "path": "include/boost/archive/impl/basic_xml_oarchive.ipp", "content": "/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8\n// basic_xml_oarchive.ipp:\n\n// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .\n// Distributed under the Boost Software License, Version 1.0. (See\n// accompanying file LICENSE_1_0.txt or copy at\n// http://www.boost.org/LICENSE_1_0.txt)\n\n// See http://www.boost.org for updates, documentation, and revision history.\n\n#include \n#include // NULL\n#include \n#if defined(BOOST_NO_STDC_NAMESPACE) && ! defined(__LIBCOMO__)\nnamespace std{\n using ::strlen;\n} // namespace std\n#endif\n\n#include \n#include \n#include \n#include \n\nnamespace boost {\nnamespace archive {\n\nnamespace detail {\ntemplate\nstruct XML_name {\n void operator()(CharType t) const{\n const unsigned char lookup_table[] = {\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,0, // -.\n 1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0, // 0-9\n 0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, // A-\n 1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,1, // -Z _\n 0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, // a-\n 1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0, // -z\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0\n };\n if((unsigned)t > 127)\n return;\n if(0 == lookup_table[(unsigned)t])\n boost::serialization::throw_exception(\n xml_archive_exception(\n xml_archive_exception::xml_archive_tag_name_error\n )\n );\n }\n};\n\n} // namespace detail\n\n/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8\n// implemenations of functions common to both types of xml output\n\ntemplate\nBOOST_ARCHIVE_OR_WARCHIVE_DECL void\nbasic_xml_oarchive::write_attribute(\n const char *attribute_name,\n int t,\n const char *conjunction\n){\n this->This()->put(' ');\n this->This()->put(attribute_name);\n this->This()->put(conjunction);\n this->This()->save(t);\n this->This()->put('\"');\n}\n\ntemplate\nBOOST_ARCHIVE_OR_WARCHIVE_DECL void\nbasic_xml_oarchive::write_attribute(\n const char *attribute_name,\n const char *key\n){\n this->This()->put(' ');\n this->This()->put(attribute_name);\n this->This()->put(\"=\\\"\");\n this->This()->save(key);\n this->This()->put('\"');\n}\n\ntemplate\nBOOST_ARCHIVE_OR_WARCHIVE_DECL void\nbasic_xml_oarchive::indent(){\n int i;\n for(i = depth; i-- > 0;)\n this->This()->put('\\t');\n}\n\ntemplate\nBOOST_ARCHIVE_OR_WARCHIVE_DECL void\nbasic_xml_oarchive::save_start(const char *name)\n{\n if(NULL == name)\n return;\n\n // be sure name has no invalid characters\n std::for_each(name, name + std::strlen(name), detail::XML_name());\n\n end_preamble();\n if(depth > 0){\n this->This()->put('\\n');\n indent();\n }\n ++depth;\n this->This()->put('<');\n this->This()->save(name);\n pending_preamble = true;\n indent_next = false;\n}\n\ntemplate\nBOOST_ARCHIVE_OR_WARCHIVE_DECL void\nbasic_xml_oarchive::save_end(const char *name)\n{\n if(NULL == name)\n return;\n\n // be sure name has no invalid characters\n std::for_each(name, name + std::strlen(name), detail::XML_name());\n\n end_preamble();\n --depth;\n if(indent_next){\n this->This()->put('\\n');\n indent();\n }\n indent_next = true;\n this->This()->put(\"This()->save(name);\n this->This()->put('>');\n if(0 == depth)\n this->This()->put('\\n');\n}\n\ntemplate\nBOOST_ARCHIVE_OR_WARCHIVE_DECL void\nbasic_xml_oarchive::end_preamble(){\n if(pending_preamble){\n this->This()->put('>');\n pending_preamble = false;\n }\n}\n#if 0\ntemplate\nBOOST_ARCHIVE_OR_WARCHIVE_DECL void\nbasic_xml_oarchive::save_override(const object_id_type & t)\n{\n int i = t.t; // extra .t is for borland\n write_attribute(BOOST_ARCHIVE_XML_OBJECT_ID(), i, \"=\\\"_\");\n}\ntemplate\nBOOST_ARCHIVE_OR_WARCHIVE_DECL void\nbasic_xml_oarchive::save_override(\n const object_reference_type & t,\n int\n){\n int i = t.t; // extra .t is for borland\n write_attribute(BOOST_ARCHIVE_XML_OBJECT_REFERENCE(), i, \"=\\\"_\");\n}\ntemplate\nBOOST_ARCHIVE_OR_WARCHIVE_DECL void\nbasic_xml_oarchive::save_override(const version_type & t)\n{\n int i = t.t; // extra .t is for borland\n write_attribute(BOOST_ARCHIVE_XML_VERSION(), i);\n}\n#endif\n\ntemplate\nBOOST_ARCHIVE_OR_WARCHIVE_DECL void\nbasic_xml_oarchive::save_override(const object_id_type & t)\n{\n // borland doesn't do conversion of STRONG_TYPEDEFs very well\n const unsigned int i = t;\n write_attribute(BOOST_ARCHIVE_XML_OBJECT_ID(), i, \"=\\\"_\");\n}\ntemplate\nBOOST_ARCHIVE_OR_WARCHIVE_DECL void\nbasic_xml_oarchive::save_override(\n const object_reference_type & t\n){\n const unsigned int i = t;\n write_attribute(BOOST_ARCHIVE_XML_OBJECT_REFERENCE(), i, \"=\\\"_\");\n}\ntemplate\nBOOST_ARCHIVE_OR_WARCHIVE_DECL void\nbasic_xml_oarchive::save_override(const version_type & t)\n{\n const unsigned int i = t;\n write_attribute(BOOST_ARCHIVE_XML_VERSION(), i);\n}\n\ntemplate\nBOOST_ARCHIVE_OR_WARCHIVE_DECL void\nbasic_xml_oarchive::save_override(const class_id_type & t)\n{\n write_attribute(BOOST_ARCHIVE_XML_CLASS_ID(), t);\n}\ntemplate\nBOOST_ARCHIVE_OR_WARCHIVE_DECL void\nbasic_xml_oarchive::save_override(\n const class_id_reference_type & t\n){\n write_attribute(BOOST_ARCHIVE_XML_CLASS_ID_REFERENCE(), t);\n}\ntemplate\nBOOST_ARCHIVE_OR_WARCHIVE_DECL void\nbasic_xml_oarchive::save_override(\n const class_id_optional_type & t\n){\n write_attribute(BOOST_ARCHIVE_XML_CLASS_ID(), t);\n}\ntemplate\nBOOST_ARCHIVE_OR_WARCHIVE_DECL void\nbasic_xml_oarchive::save_override(const class_name_type & t)\n{\n const char * key = t;\n if(NULL == key)\n return;\n write_attribute(BOOST_ARCHIVE_XML_CLASS_NAME(), key);\n}\n\ntemplate\nBOOST_ARCHIVE_OR_WARCHIVE_DECL void\nbasic_xml_oarchive::save_override(const tracking_type & t)\n{\n write_attribute(BOOST_ARCHIVE_XML_TRACKING(), t.t);\n}\n\ntemplate\nBOOST_ARCHIVE_OR_WARCHIVE_DECL void\nbasic_xml_oarchive::init(){\n // xml header\n this->This()->put(\"\\n\");\n this->This()->put(\"\\n\");\n // xml document wrapper - outer root\n this->This()->put(\"This()->put(\">\\n\");\n}\n\ntemplate\nBOOST_ARCHIVE_OR_WARCHIVE_DECL void\nbasic_xml_oarchive::windup(){\n // xml_trailer\n this->This()->put(\"\\n\");\n}\n\ntemplate\nBOOST_ARCHIVE_OR_WARCHIVE_DECL\nbasic_xml_oarchive::basic_xml_oarchive(unsigned int flags) :\n detail::common_oarchive(flags),\n depth(0),\n pending_preamble(false),\n indent_next(false)\n{\n}\n\ntemplate\nBOOST_ARCHIVE_OR_WARCHIVE_DECL\nbasic_xml_oarchive::~basic_xml_oarchive(){\n}\n\n} // namespace archive\n} // namespace boost\n" }, { "path": "include/boost/archive/impl/text_iarchive_impl.ipp", "content": "/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8\n// text_iarchive_impl.ipp:\n\n// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .\n// Distributed under the Boost Software License, Version 1.0. (See\n// accompanying file LICENSE_1_0.txt or copy at\n// http://www.boost.org/LICENSE_1_0.txt)\n\n// See http://www.boost.org for updates, documentation, and revision history.\n\n//////////////////////////////////////////////////////////////////////\n// implementation of basic_text_iprimitive overrides for the combination\n// of template parameters used to implement a text_iprimitive\n\n#include // size_t, NULL\n#include \n#if defined(BOOST_NO_STDC_NAMESPACE)\nnamespace std{ \n using ::size_t; \n} // namespace std\n#endif\n\n#include // RogueWave\n\n#include \n\nnamespace boost {\nnamespace archive {\n\ntemplate\nBOOST_ARCHIVE_DECL void\ntext_iarchive_impl::load(char *s)\n{\n std::size_t size;\n * this->This() >> size;\n // skip separating space\n is.get();\n // Works on all tested platforms\n is.read(s, size);\n s[size] = '\\0';\n}\n\ntemplate\nBOOST_ARCHIVE_DECL void\ntext_iarchive_impl::load(std::string &s)\n{\n std::size_t size;\n * this->This() >> size;\n // skip separating space\n is.get();\n // borland de-allocator fixup\n #if BOOST_WORKAROUND(_RWSTD_VER, BOOST_TESTED_AT(20101))\n if(NULL != s.data())\n #endif\n s.resize(size);\n if(0 < size)\n is.read(&(*s.begin()), size);\n}\n\n#ifndef BOOST_NO_CWCHAR\n#ifndef BOOST_NO_INTRINSIC_WCHAR_T\ntemplate\nBOOST_ARCHIVE_DECL void\ntext_iarchive_impl::load(wchar_t *ws)\n{\n std::size_t size;\n * this->This() >> size;\n // skip separating space\n is.get();\n is.read((char *)ws, size * sizeof(wchar_t)/sizeof(char));\n ws[size] = L'\\0';\n}\n#endif // BOOST_NO_INTRINSIC_WCHAR_T\n\n#ifndef BOOST_NO_STD_WSTRING\ntemplate\nBOOST_ARCHIVE_DECL void\ntext_iarchive_impl::load(std::wstring &ws)\n{\n std::size_t size;\n * this->This() >> size;\n // borland de-allocator fixup\n #if BOOST_WORKAROUND(_RWSTD_VER, BOOST_TESTED_AT(20101))\n if(NULL != ws.data())\n #endif\n ws.resize(size);\n // skip separating space\n is.get();\n is.read((char *)ws.data(), size * sizeof(wchar_t)/sizeof(char));\n}\n\n#endif // BOOST_NO_STD_WSTRING\n#endif // BOOST_NO_CWCHAR\n\ntemplate\nBOOST_ARCHIVE_DECL void\ntext_iarchive_impl::load_override(class_name_type & t){\n basic_text_iarchive::load_override(t);\n}\n\ntemplate\nBOOST_ARCHIVE_DECL void\ntext_iarchive_impl::init(){\n basic_text_iarchive::init();\n}\n\ntemplate\nBOOST_ARCHIVE_DECL \ntext_iarchive_impl::text_iarchive_impl(\n std::istream & is, \n unsigned int flags\n) :\n basic_text_iprimitive(\n is, \n 0 != (flags & no_codecvt)\n ),\n basic_text_iarchive(flags)\n{}\n\n} // namespace archive\n} // namespace boost\n" }, { "path": "include/boost/archive/impl/text_oarchive_impl.ipp", "content": "/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8\n// text_oarchive_impl.ipp:\n\n// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .\n// Distributed under the Boost Software License, Version 1.0. (See\n// accompanying file LICENSE_1_0.txt or copy at\n// http://www.boost.org/LICENSE_1_0.txt)\n\n// See http://www.boost.org for updates, documentation, and revision history.\n\n#include \n#include \n#include // size_t\n\n#include \n#if defined(BOOST_NO_STDC_NAMESPACE)\nnamespace std{ \n using ::size_t; \n} // namespace std\n#endif\n\n#ifndef BOOST_NO_CWCHAR\n#include \n#ifdef BOOST_NO_STDC_NAMESPACE\nnamespace std{ using ::wcslen; }\n#endif\n#endif\n\n#include \n\nnamespace boost { \nnamespace archive {\n\n//////////////////////////////////////////////////////////////////////\n// implementation of basic_text_oprimitive overrides for the combination\n// of template parameters used to create a text_oprimitive\n\ntemplate\nBOOST_ARCHIVE_DECL void\ntext_oarchive_impl::save(const char * s)\n{\n const std::size_t len = std::ostream::traits_type::length(s);\n *this->This() << len;\n this->This()->newtoken();\n os << s;\n}\n\ntemplate\nBOOST_ARCHIVE_DECL void\ntext_oarchive_impl::save(const std::string &s)\n{\n const std::size_t size = s.size();\n *this->This() << size;\n this->This()->newtoken();\n os << s;\n}\n\n#ifndef BOOST_NO_CWCHAR\n#ifndef BOOST_NO_INTRINSIC_WCHAR_T\ntemplate\nBOOST_ARCHIVE_DECL void\ntext_oarchive_impl::save(const wchar_t * ws)\n{\n const std::size_t l = std::wcslen(ws);\n * this->This() << l;\n this->This()->newtoken();\n os.write((const char *)ws, l * sizeof(wchar_t)/sizeof(char));\n}\n#endif\n\n#ifndef BOOST_NO_STD_WSTRING\ntemplate\nBOOST_ARCHIVE_DECL void\ntext_oarchive_impl::save(const std::wstring &ws)\n{\n const std::size_t l = ws.size();\n * this->This() << l;\n this->This()->newtoken();\n os.write((const char *)(ws.data()), l * sizeof(wchar_t)/sizeof(char));\n}\n#endif\n#endif // BOOST_NO_CWCHAR\n\ntemplate\nBOOST_ARCHIVE_DECL \ntext_oarchive_impl::text_oarchive_impl(\n std::ostream & os, \n unsigned int flags\n) :\n basic_text_oprimitive(\n os, \n 0 != (flags & no_codecvt)\n ),\n basic_text_oarchive(flags)\n{\n}\n\ntemplate\nBOOST_ARCHIVE_DECL void\ntext_oarchive_impl::save_binary(const void *address, std::size_t count){\n put('\\n');\n this->end_preamble();\n #if ! defined(__MWERKS__)\n this->basic_text_oprimitive::save_binary(\n #else\n this->basic_text_oprimitive::save_binary(\n #endif\n address, \n count\n );\n this->delimiter = this->eol;\n}\n\n} // namespace archive\n} // namespace boost\n\n" }, { "path": "include/boost/archive/impl/text_wiarchive_impl.ipp", "content": "/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8\n// text_text_wiarchive_impl.ipp:\n\n// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .\n// Distributed under the Boost Software License, Version 1.0. (See\n// accompanying file LICENSE_1_0.txt or copy at\n// http://www.boost.org/LICENSE_1_0.txt)\n\n// See http://www.boost.org for updates, documentation, and revision history.\n\n#include // size_t, NULL\n\n#include \n#if defined(BOOST_NO_STDC_NAMESPACE)\nnamespace std{ \n using ::size_t; \n} // namespace std\n#endif\n\n#include // fixup for RogueWave\n\n#ifndef BOOST_NO_STD_WSTREAMBUF\n#include \n\nnamespace boost { \nnamespace archive {\n\n//////////////////////////////////////////////////////////////////////\n// implementation of wiprimtives functions\n//\ntemplate\nBOOST_WARCHIVE_DECL void\ntext_wiarchive_impl::load(char *s)\n{\n std::size_t size;\n * this->This() >> size;\n // skip separating space\n is.get();\n while(size-- > 0){\n *s++ = is.narrow(is.get(), '\\0');\n }\n *s = '\\0';\n}\n\ntemplate\nBOOST_WARCHIVE_DECL void\ntext_wiarchive_impl::load(std::string &s)\n{\n std::size_t size;\n * this->This() >> size;\n // skip separating space\n is.get();\n #if BOOST_WORKAROUND(_RWSTD_VER, BOOST_TESTED_AT(20101))\n if(NULL != s.data())\n #endif\n s.resize(0);\n s.reserve(size);\n while(size-- > 0){\n char x = is.narrow(is.get(), '\\0');\n s += x;\n }\n}\n\n#ifndef BOOST_NO_INTRINSIC_WCHAR_T\ntemplate\nBOOST_WARCHIVE_DECL void\ntext_wiarchive_impl::load(wchar_t *s)\n{\n std::size_t size;\n * this->This() >> size;\n // skip separating space\n is.get();\n // Works on all tested platforms\n is.read(s, size);\n s[size] = L'\\0';\n}\n#endif\n\n#ifndef BOOST_NO_STD_WSTRING\ntemplate\nBOOST_WARCHIVE_DECL void\ntext_wiarchive_impl::load(std::wstring &ws)\n{\n std::size_t size;\n * this->This() >> size;\n // skip separating space\n is.get();\n // borland complains about resize\n // borland de-allocator fixup\n #if BOOST_WORKAROUND(_RWSTD_VER, BOOST_TESTED_AT(20101))\n if(NULL != ws.data())\n #endif\n ws.resize(size);\n // note breaking a rule here - is this a problem on some platform\n is.read(const_cast(ws.data()), size);\n}\n#endif\n\ntemplate\nBOOST_WARCHIVE_DECL \ntext_wiarchive_impl::text_wiarchive_impl(\n std::wistream & is, \n unsigned int flags\n) :\n basic_text_iprimitive(\n is, \n 0 != (flags & no_codecvt)\n ),\n basic_text_iarchive(flags)\n{\n}\n\n} // archive\n} // boost\n\n#endif // BOOST_NO_STD_WSTREAMBUF\n" }, { "path": "include/boost/archive/impl/text_woarchive_impl.ipp", "content": "/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8\n// text_woarchive_impl.ipp:\n\n// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .\n// Distributed under the Boost Software License, Version 1.0. (See\n// accompanying file LICENSE_1_0.txt or copy at\n// http://www.boost.org/LICENSE_1_0.txt)\n\n// See http://www.boost.org for updates, documentation, and revision history.\n\n#include \n#ifndef BOOST_NO_STD_WSTREAMBUF\n\n#include \n#include // size_t\n#if defined(BOOST_NO_STDC_NAMESPACE) && ! defined(__LIBCOMO__)\nnamespace std{ \n using ::strlen;\n using ::size_t; \n} // namespace std\n#endif\n\n#include \n\n#include \n\nnamespace boost {\nnamespace archive {\n\n//////////////////////////////////////////////////////////////////////\n// implementation of woarchive functions\n//\ntemplate\nBOOST_WARCHIVE_DECL void\ntext_woarchive_impl::save(const char *s)\n{\n // note: superfluous local variable fixes borland warning\n const std::size_t size = std::strlen(s);\n * this->This() << size;\n this->This()->newtoken();\n while(*s != '\\0')\n os.put(os.widen(*s++));\n}\n\ntemplate\nBOOST_WARCHIVE_DECL void\ntext_woarchive_impl::save(const std::string &s)\n{\n const std::size_t size = s.size();\n * this->This() << size;\n this->This()->newtoken();\n const char * cptr = s.data();\n for(std::size_t i = size; i-- > 0;)\n os.put(os.widen(*cptr++));\n}\n\n#ifndef BOOST_NO_INTRINSIC_WCHAR_T\ntemplate\nBOOST_WARCHIVE_DECL void\ntext_woarchive_impl::save(const wchar_t *ws)\n{\n const std::size_t size = std::wostream::traits_type::length(ws);\n * this->This() << size;\n this->This()->newtoken();\n os.write(ws, size);\n}\n#endif\n\n#ifndef BOOST_NO_STD_WSTRING\ntemplate\nBOOST_WARCHIVE_DECL void\ntext_woarchive_impl::save(const std::wstring &ws)\n{\n const std::size_t size = ws.length();\n * this->This() << size;\n this->This()->newtoken();\n os.write(ws.data(), size);\n}\n#endif\n\n} // namespace archive\n} // namespace boost\n\n#endif\n\n" }, { "path": "include/boost/archive/impl/xml_iarchive_impl.ipp", "content": "/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8\n// xml_iarchive_impl.cpp:\n\n// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .\n// Distributed under the Boost Software License, Version 1.0. (See\n// accompanying file LICENSE_1_0.txt or copy at\n// http://www.boost.org/LICENSE_1_0.txt)\n\n// See http://www.boost.org for updates, documentation, and revision history.\n\n#include \n#include // memcpy\n#include // NULL\n\n#if defined(BOOST_NO_STDC_NAMESPACE)\nnamespace std{ \n using ::memcpy;\n} // namespace std\n#endif\n\n#ifndef BOOST_NO_CWCHAR\n#include // mbstate_t and mbrtowc\n#if defined(BOOST_NO_STDC_NAMESPACE)\nnamespace std{ \n using ::mbstate_t;\n using ::mbrtowc;\n } // namespace std\n#endif\n#endif // BOOST_NO_CWCHAR\n\n#include // RogueWave and Dinkumware\n#if BOOST_WORKAROUND(BOOST_DINKUMWARE_STDLIB, == 1)\n#include \n#endif\n\n#include \n#include \n\n#include \n#include \n#include \n#include \n\n#include \"basic_xml_grammar.hpp\"\n\nnamespace boost {\nnamespace archive {\n\n/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8\n// implemenations of functions specific to char archives\n\n// wide char stuff used by char archives\n\n#ifndef BOOST_NO_CWCHAR\n#ifndef BOOST_NO_STD_WSTRING\ntemplate\nBOOST_ARCHIVE_DECL void\nxml_iarchive_impl::load(std::wstring &ws){\n std::string s;\n bool result = gimpl->parse_string(is, s);\n if(! result)\n boost::serialization::throw_exception(\n xml_archive_exception(xml_archive_exception::xml_archive_parsing_error)\n );\n \n #if BOOST_WORKAROUND(_RWSTD_VER, BOOST_TESTED_AT(20101))\n if(NULL != ws.data())\n #endif\n ws.resize(0);\n std::mbstate_t mbs = std::mbstate_t();\n const char * start = s.data();\n const char * end = start + s.size();\n while(start < end){\n wchar_t wc;\n std::size_t count = std::mbrtowc(&wc, start, end - start, &mbs);\n if(count == static_cast(-1))\n boost::serialization::throw_exception(\n iterators::dataflow_exception(\n iterators::dataflow_exception::invalid_conversion\n )\n );\n if(count == static_cast(-2))\n continue;\n start += count;\n ws += wc;\n }\n}\n#endif // BOOST_NO_STD_WSTRING\n\n#ifndef BOOST_NO_INTRINSIC_WCHAR_T\ntemplate\nBOOST_ARCHIVE_DECL void\nxml_iarchive_impl::load(wchar_t * ws){\n std::string s;\n bool result = gimpl->parse_string(is, s);\n if(! result)\n boost::serialization::throw_exception(\n xml_archive_exception(\n xml_archive_exception::xml_archive_parsing_error\n )\n );\n \n std::mbstate_t mbs = std::mbstate_t();\n const char * start = s.data();\n const char * end = start + s.size();\n while(start < end){\n wchar_t wc;\n std::size_t length = std::mbrtowc(&wc, start, end - start, &mbs);\n if(static_cast(-1) == length)\n boost::serialization::throw_exception(\n iterators::dataflow_exception(\n iterators::dataflow_exception::invalid_conversion\n )\n );\n if(static_cast(-2) == length)\n continue;\n\n start += length;\n *ws++ = wc;\n }\n *ws = L'\\0';\n}\n#endif // BOOST_NO_INTRINSIC_WCHAR_T\n\n#endif // BOOST_NO_CWCHAR\n\ntemplate\nBOOST_ARCHIVE_DECL void\nxml_iarchive_impl::load(std::string &s){\n bool result = gimpl->parse_string(is, s);\n if(! result)\n boost::serialization::throw_exception(\n xml_archive_exception(xml_archive_exception::xml_archive_parsing_error)\n );\n}\n\ntemplate\nBOOST_ARCHIVE_DECL void\nxml_iarchive_impl::load(char * s){\n std::string tstring;\n bool result = gimpl->parse_string(is, tstring);\n if(! result)\n boost::serialization::throw_exception(\n xml_archive_exception(xml_archive_exception::xml_archive_parsing_error)\n );\n std::memcpy(s, tstring.data(), tstring.size());\n s[tstring.size()] = 0;\n}\n\ntemplate\nBOOST_ARCHIVE_DECL void\nxml_iarchive_impl::load_override(class_name_type & t){\n const std::string & s = gimpl->rv.class_name;\n if(s.size() > BOOST_SERIALIZATION_MAX_KEY_SIZE - 1)\n boost::serialization::throw_exception(\n archive_exception(archive_exception::invalid_class_name)\n );\n char * tptr = t;\n std::memcpy(tptr, s.data(), s.size());\n tptr[s.size()] = '\\0';\n}\n\ntemplate\nBOOST_ARCHIVE_DECL void\nxml_iarchive_impl::init(){\n gimpl->init(is);\n this->set_library_version(\n boost::serialization::library_version_type(gimpl->rv.version)\n );\n}\n\ntemplate\nBOOST_ARCHIVE_DECL\nxml_iarchive_impl::xml_iarchive_impl(\n std::istream &is_,\n unsigned int flags\n) :\n basic_text_iprimitive(\n is_, \n 0 != (flags & no_codecvt)\n ),\n basic_xml_iarchive(flags),\n gimpl(new xml_grammar())\n{}\n\ntemplate\nBOOST_ARCHIVE_DECL\nxml_iarchive_impl::~xml_iarchive_impl(){\n if(boost::core::uncaught_exceptions() > 0)\n return;\n if(0 == (this->get_flags() & no_header)){\n gimpl->windup(is);\n }\n}\n} // namespace archive\n} // namespace boost\n" }, { "path": "include/boost/archive/impl/xml_oarchive_impl.ipp", "content": "/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8\n// xml_oarchive_impl.ipp:\n\n// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .\n// Distributed under the Boost Software License, Version 1.0. (See\n// accompanying file LICENSE_1_0.txt or copy at\n// http://www.boost.org/LICENSE_1_0.txt)\n\n#include \n#include \n#include // std::copy\n#include \n\n#include // strlen\n#include // msvc 6.0 needs this to suppress warnings\n#if defined(BOOST_NO_STDC_NAMESPACE)\nnamespace std{ \n using ::strlen; \n} // namespace std\n#endif\n\n#include \n#include \n#include \n\n#ifndef BOOST_NO_CWCHAR\n#include \n#include \n#endif\n\nnamespace boost {\nnamespace archive {\n\n/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8\n// implemenations of functions specific to char archives\n\n// wide char stuff used by char archives\n#ifndef BOOST_NO_CWCHAR\n// copy chars to output escaping to xml and translating wide chars to mb chars\ntemplate\nvoid save_iterator(std::ostream &os, InputIterator begin, InputIterator end){\n typedef boost::archive::iterators::mb_from_wchar<\n boost::archive::iterators::xml_escape\n > translator;\n std::copy(\n translator(begin),\n translator(end),\n boost::archive::iterators::ostream_iterator(os)\n );\n}\n\n#ifndef BOOST_NO_STD_WSTRING\ntemplate\nBOOST_ARCHIVE_DECL void\nxml_oarchive_impl::save(const std::wstring & ws){\n// at least one library doesn't typedef value_type for strings\n// so rather than using string directly make a pointer iterator out of it\n// save_iterator(os, ws.data(), ws.data() + std::wcslen(ws.data()));\n save_iterator(os, ws.data(), ws.data() + ws.size());\n}\n#endif\n\n#ifndef BOOST_NO_INTRINSIC_WCHAR_T\ntemplate\nBOOST_ARCHIVE_DECL void\nxml_oarchive_impl::save(const wchar_t * ws){\n save_iterator(os, ws, ws + std::wcslen(ws));\n}\n#endif\n\n#endif // BOOST_NO_CWCHAR\n\ntemplate\nBOOST_ARCHIVE_DECL void\nxml_oarchive_impl::save(const std::string & s){\n// at least one library doesn't typedef value_type for strings\n// so rather than using string directly make a pointer iterator out of it\n typedef boost::archive::iterators::xml_escape<\n const char * \n > xml_escape_translator;\n std::copy(\n xml_escape_translator(s.data()),\n xml_escape_translator(s.data()+ s.size()),\n boost::archive::iterators::ostream_iterator(os)\n );\n}\n\ntemplate\nBOOST_ARCHIVE_DECL void\nxml_oarchive_impl::save(const char * s){\n typedef boost::archive::iterators::xml_escape<\n const char * \n > xml_escape_translator;\n std::copy(\n xml_escape_translator(s),\n xml_escape_translator(s + std::strlen(s)),\n boost::archive::iterators::ostream_iterator(os)\n );\n}\n\ntemplate\nBOOST_ARCHIVE_DECL\nxml_oarchive_impl::xml_oarchive_impl(\n std::ostream & os_, \n unsigned int flags\n) : \n basic_text_oprimitive(\n os_,\n 0 != (flags & no_codecvt)\n ),\n basic_xml_oarchive(flags)\n{}\n\ntemplate\nBOOST_ARCHIVE_DECL void\nxml_oarchive_impl::save_binary(const void *address, std::size_t count){\n this->end_preamble();\n #if ! defined(__MWERKS__)\n this->basic_text_oprimitive::save_binary(\n #else\n this->basic_text_oprimitive::save_binary(\n #endif\n address, \n count\n );\n this->indent_next = true;\n}\n\ntemplate\nBOOST_ARCHIVE_DECL\nxml_oarchive_impl::~xml_oarchive_impl(){\n if(boost::core::uncaught_exceptions() > 0)\n return;\n if(0 == (this->get_flags() & no_header)){\n this->put(\"\\n\");\n }\n}\n\n} // namespace archive\n} // namespace boost\n" }, { "path": "include/boost/archive/impl/xml_wiarchive_impl.ipp", "content": "/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8\n// xml_wiarchive_impl.ipp:\n\n// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .\n// Distributed under the Boost Software License, Version 1.0. (See\n// accompanying file LICENSE_1_0.txt or copy at\n// http://www.boost.org/LICENSE_1_0.txt)\n\n// See http://www.boost.org for updates, documentation, and revision history.\n\n#include \n#if defined(BOOST_NO_STDC_NAMESPACE)\nnamespace std{ \n using ::memcpy; \n} //std\n#endif\n\n#include // msvc 6.0 needs this to suppress warnings\n#ifndef BOOST_NO_STD_WSTREAMBUF\n\n#include \n#include // std::copy\n#include // Dinkumware and RogueWave\n#if BOOST_WORKAROUND(BOOST_DINKUMWARE_STDLIB, == 1)\n#include \n#endif\n\n#include \n#include \n#include \n#include \n\n#include \n#include \n\n#include \n#include \n\n#include \n\n#include \"basic_xml_grammar.hpp\"\n\nnamespace boost {\nnamespace archive {\n\n/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8\n// implemenations of functions specific to wide char archives\n\nnamespace { // anonymous\n\nvoid copy_to_ptr(char * s, const std::wstring & ws){\n std::copy(\n iterators::mb_from_wchar(\n ws.begin()\n ), \n iterators::mb_from_wchar(\n ws.end()\n ), \n s\n );\n s[ws.size()] = 0;\n}\n\n} // anonymous\n\ntemplate\nBOOST_WARCHIVE_DECL void\nxml_wiarchive_impl::load(std::string & s){\n std::wstring ws;\n bool result = gimpl->parse_string(is, ws);\n if(! result)\n boost::serialization::throw_exception(\n xml_archive_exception(xml_archive_exception::xml_archive_parsing_error)\n );\n #if BOOST_WORKAROUND(_RWSTD_VER, BOOST_TESTED_AT(20101))\n if(NULL != s.data())\n #endif\n s.resize(0);\n s.reserve(ws.size());\n std::copy(\n iterators::mb_from_wchar(\n ws.begin()\n ), \n iterators::mb_from_wchar(\n ws.end()\n ), \n std::back_inserter(s)\n );\n}\n\n#ifndef BOOST_NO_STD_WSTRING\ntemplate\nBOOST_WARCHIVE_DECL void\nxml_wiarchive_impl::load(std::wstring & ws){\n bool result = gimpl->parse_string(is, ws);\n if(! result)\n boost::serialization::throw_exception(\n xml_archive_exception(xml_archive_exception::xml_archive_parsing_error)\n );\n}\n#endif\n\ntemplate\nBOOST_WARCHIVE_DECL void\nxml_wiarchive_impl::load(char * s){\n std::wstring ws;\n bool result = gimpl->parse_string(is, ws);\n if(! result)\n boost::serialization::throw_exception(\n xml_archive_exception(xml_archive_exception::xml_archive_parsing_error)\n );\n copy_to_ptr(s, ws);\n}\n\n#ifndef BOOST_NO_INTRINSIC_WCHAR_T\ntemplate\nBOOST_WARCHIVE_DECL void\nxml_wiarchive_impl::load(wchar_t * ws){\n std::wstring twstring;\n bool result = gimpl->parse_string(is, twstring);\n if(! result)\n boost::serialization::throw_exception(\n xml_archive_exception(xml_archive_exception::xml_archive_parsing_error)\n );\n std::memcpy(ws, twstring.c_str(), twstring.size());\n ws[twstring.size()] = L'\\0';\n}\n#endif\n\ntemplate\nBOOST_WARCHIVE_DECL void\nxml_wiarchive_impl::load_override(class_name_type & t){\n const std::wstring & ws = gimpl->rv.class_name;\n if(ws.size() > BOOST_SERIALIZATION_MAX_KEY_SIZE - 1)\n boost::serialization::throw_exception(\n archive_exception(archive_exception::invalid_class_name)\n );\n copy_to_ptr(t, ws);\n}\n\ntemplate\nBOOST_WARCHIVE_DECL void\nxml_wiarchive_impl::init(){\n gimpl->init(is);\n this->set_library_version(\n boost::serialization::library_version_type(gimpl->rv.version)\n );\n}\n\ntemplate\nBOOST_WARCHIVE_DECL\nxml_wiarchive_impl::xml_wiarchive_impl(\n std::wistream &is_,\n unsigned int flags\n) :\n basic_text_iprimitive(\n is_, \n true // don't change the codecvt - use the one below\n ),\n basic_xml_iarchive(flags),\n gimpl(new xml_wgrammar())\n{\n if(0 == (flags & no_codecvt)){\n archive_locale = std::locale(\n is_.getloc(),\n new boost::archive::detail::utf8_codecvt_facet\n );\n // libstdc++ crashes without this\n is_.sync();\n is_.imbue(archive_locale);\n }\n}\n\ntemplate\nBOOST_WARCHIVE_DECL\nxml_wiarchive_impl::~xml_wiarchive_impl(){\n if(boost::core::uncaught_exceptions() > 0)\n return;\n if(0 == (this->get_flags() & no_header)){\n gimpl->windup(is);\n }\n}\n\n} // namespace archive\n} // namespace boost\n\n#endif // BOOST_NO_STD_WSTREAMBUF\n" }, { "path": "include/boost/archive/impl/xml_woarchive_impl.ipp", "content": "/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8\n// xml_woarchive_impl.ipp:\n\n// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .\n// Distributed under the Boost Software License, Version 1.0. (See\n// accompanying file LICENSE_1_0.txt or copy at\n// http://www.boost.org/LICENSE_1_0.txt)\n\n#include \n#ifndef BOOST_NO_STD_WSTREAMBUF\n\n#include \n#include \n#include // std::copy\n#include \n\n#include // strlen\n#include // mbtowc\n#ifndef BOOST_NO_CWCHAR\n#include // wcslen\n#endif\n\n#include \n#if defined(BOOST_NO_STDC_NAMESPACE)\nnamespace std{ \n using ::strlen; \n #if ! defined(BOOST_NO_INTRINSIC_WCHAR_T)\n using ::mbtowc; \n using ::wcslen;\n #endif\n} // namespace std\n#endif\n\n#include \n\n#include \n#include \n\n#include \n\n#include \n#include \n#include \n#include \n\nnamespace boost {\nnamespace archive {\n\n/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8\n// implemenations of functions specific to wide char archives\n\n// copy chars to output escaping to xml and widening characters as we go\ntemplate\nvoid save_iterator(std::wostream &os, InputIterator begin, InputIterator end){\n typedef iterators::wchar_from_mb<\n iterators::xml_escape\n > xmbtows;\n std::copy(\n xmbtows(begin),\n xmbtows(end),\n boost::archive::iterators::ostream_iterator(os)\n );\n}\n\ntemplate\nBOOST_WARCHIVE_DECL void\nxml_woarchive_impl::save(const std::string & s){\n // note: we don't use s.begin() and s.end() because dinkumware\n // doesn't have string::value_type defined. So use a wrapper\n // around these values to implement the definitions.\n const char * begin = s.data();\n const char * end = begin + s.size();\n save_iterator(os, begin, end);\n}\n\n#ifndef BOOST_NO_STD_WSTRING\ntemplate\nBOOST_WARCHIVE_DECL void\nxml_woarchive_impl::save(const std::wstring & ws){\n#if 0\n typedef iterators::xml_escape xmbtows;\n std::copy(\n xmbtows(ws.begin()),\n xmbtows(ws.end()),\n boost::archive::iterators::ostream_iterator(os)\n );\n#endif\n typedef iterators::xml_escape xmbtows;\n std::copy(\n xmbtows(ws.data()),\n xmbtows(ws.data() + ws.size()),\n boost::archive::iterators::ostream_iterator(os)\n );\n}\n#endif //BOOST_NO_STD_WSTRING\n\ntemplate\nBOOST_WARCHIVE_DECL void\nxml_woarchive_impl::save(const char * s){\n save_iterator(os, s, s + std::strlen(s));\n}\n\n#ifndef BOOST_NO_INTRINSIC_WCHAR_T\ntemplate\nBOOST_WARCHIVE_DECL void\nxml_woarchive_impl::save(const wchar_t * ws){\n typedef iterators::xml_escape xmbtows;\n std::copy(\n xmbtows(ws),\n xmbtows(ws + std::wcslen(ws)),\n boost::archive::iterators::ostream_iterator(os)\n );\n}\n#endif\n\ntemplate\nBOOST_WARCHIVE_DECL\nxml_woarchive_impl::xml_woarchive_impl(\n std::wostream & os_,\n unsigned int flags\n) :\n basic_text_oprimitive(\n os_,\n true // don't change the codecvt - use the one below\n ),\n basic_xml_oarchive(flags)\n{\n if(0 == (flags & no_codecvt)){\n archive_locale = std::locale(\n os_.getloc(),\n new boost::archive::detail::utf8_codecvt_facet\n );\n os_.flush();\n os_.imbue(archive_locale);\n }\n}\n\ntemplate\nBOOST_WARCHIVE_DECL\nxml_woarchive_impl::~xml_woarchive_impl(){\n if(boost::core::uncaught_exceptions() > 0)\n return;\n if(0 == (this->get_flags() & no_header)){\n os << L\"\";\n }\n}\n\ntemplate\nBOOST_WARCHIVE_DECL void\nxml_woarchive_impl::save_binary(\n const void *address,\n std::size_t count\n){\n this->end_preamble();\n #if ! defined(__MWERKS__)\n this->basic_text_oprimitive::save_binary(\n #else\n this->basic_text_oprimitive::save_binary(\n #endif\n address, \n count\n );\n this->indent_next = true;\n}\n\n} // namespace archive\n} // namespace boost\n\n#endif //BOOST_NO_STD_WSTREAMBUF\n" }, { "path": "include/boost/archive/iterators/base64_exception.hpp", "content": "#ifndef BOOST_ARCHIVE_ITERATORS_BASE64_EXCEPTION_HPP\n#define BOOST_ARCHIVE_ITERATORS_BASE64_EXCEPTION_HPP\n\n// MS compatible compilers support #pragma once\n#if defined(_MSC_VER)\n# pragma once\n#endif\n\n/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8\n// base64_exception.hpp:\n\n// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .\n// Use, modification and distribution is subject to the Boost Software\n// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at\n// http://www.boost.org/LICENSE_1_0.txt)\n\n// See http://www.boost.org for updates, documentation, and revision history.\n\n#include \n#ifndef BOOST_NO_EXCEPTIONS\n#include \n\n#include \n\nnamespace boost {\nnamespace archive {\nnamespace iterators {\n\n//////////////////////////////////////////////////////////////////////\n// exceptions thrown by base64s\n//\nclass base64_exception : public std::exception\n{\npublic:\n typedef enum {\n invalid_code, // attempt to encode a value > 6 bits\n invalid_character, // decode a value not in base64 char set\n other_exception\n } exception_code;\n exception_code code;\n\n base64_exception(exception_code c = other_exception) : code(c)\n {}\n\n virtual const char *what( ) const BOOST_NOEXCEPT_OR_NOTHROW\n {\n const char *msg = \"unknown exception code\";\n switch(code){\n case invalid_code:\n msg = \"attempt to encode a value > 6 bits\";\n break;\n case invalid_character:\n msg = \"attempt to decode a value not in base64 char set\";\n break;\n default:\n BOOST_ASSERT(false);\n break;\n }\n return msg;\n }\n};\n\n} // namespace iterators\n} // namespace archive\n} // namespace boost\n\n#endif //BOOST_NO_EXCEPTIONS\n#endif //BOOST_ARCHIVE_ITERATORS_ARCHIVE_EXCEPTION_HPP\n" }, { "path": "include/boost/archive/iterators/base64_from_binary.hpp", "content": "#ifndef BOOST_ARCHIVE_ITERATORS_BASE64_FROM_BINARY_HPP\n#define BOOST_ARCHIVE_ITERATORS_BASE64_FROM_BINARY_HPP\n\n// MS compatible compilers support #pragma once\n#if defined(_MSC_VER)\n# pragma once\n#endif\n\n/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8\n// base64_from_binary.hpp\n\n// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .\n// Use, modification and distribution is subject to the Boost Software\n// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at\n// http://www.boost.org/LICENSE_1_0.txt)\n\n// See http://www.boost.org for updates, documentation, and revision history.\n\n#include \n\n#include // size_t\n#if defined(BOOST_NO_STDC_NAMESPACE)\nnamespace std{\n using ::size_t;\n} // namespace std\n#endif\n\n#include \n#include \n\nnamespace boost {\nnamespace archive {\nnamespace iterators {\n\n/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8\n// convert binary integers to base64 characters\n\nnamespace detail {\n\ntemplate\nstruct from_6_bit {\n typedef CharType result_type;\n CharType operator()(CharType t) const{\n static const char * lookup_table =\n \"ABCDEFGHIJKLMNOPQRSTUVWXYZ\"\n \"abcdefghijklmnopqrstuvwxyz\"\n \"0123456789\"\n \"+/\";\n BOOST_ASSERT(t < 64);\n return lookup_table[static_cast(t)];\n }\n};\n\n} // namespace detail\n\n// note: what we would like to do is\n// template\n// typedef transform_iterator<\n// from_6_bit,\n// transform_width\n// > base64_from_binary;\n// but C++ won't accept this. Rather than using a \"type generator\" and\n// using a different syntax, make a derivation which should be equivalent.\n//\n// Another issue addressed here is that the transform_iterator doesn't have\n// a templated constructor. This makes it incompatible with the dataflow\n// ideal. This is also addressed here.\n\n//template\ntemplate<\n class Base,\n class CharType = typename boost::iterator_value::type\n>\nclass base64_from_binary :\n public transform_iterator<\n detail::from_6_bit,\n Base\n >\n{\n friend class boost::iterator_core_access;\n typedef transform_iterator<\n typename detail::from_6_bit,\n Base\n > super_t;\n\npublic:\n // make composable by using templated constructor\n template\n base64_from_binary(T start) :\n super_t(\n Base(static_cast< T >(start)),\n detail::from_6_bit()\n )\n {}\n // intel 7.1 doesn't like default copy constructor\n base64_from_binary(const base64_from_binary & rhs) :\n super_t(\n Base(rhs.base_reference()),\n detail::from_6_bit()\n )\n {}\n// base64_from_binary(){};\n};\n\n} // namespace iterators\n} // namespace archive\n} // namespace boost\n\n#endif // BOOST_ARCHIVE_ITERATORS_BASE64_FROM_BINARY_HPP\n" }, { "path": "include/boost/archive/iterators/binary_from_base64.hpp", "content": "#ifndef BOOST_ARCHIVE_ITERATORS_BINARY_FROM_BASE64_HPP\n#define BOOST_ARCHIVE_ITERATORS_BINARY_FROM_BASE64_HPP\n\n// MS compatible compilers support #pragma once\n#if defined(_MSC_VER)\n# pragma once\n#endif\n\n/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8\n// binary_from_base64.hpp\n\n// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .\n// Use, modification and distribution is subject to the Boost Software\n// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at\n// http://www.boost.org/LICENSE_1_0.txt)\n\n// See http://www.boost.org for updates, documentation, and revision history.\n\n#include \n\n#include \n#include \n\n#include \n#include \n\nnamespace boost {\nnamespace archive {\nnamespace iterators {\n\n/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8\n// convert base64 characters to binary data\n\nnamespace detail {\n\ntemplate\nstruct to_6_bit {\n typedef CharType result_type;\n CharType operator()(CharType t) const{\n static const signed char lookup_table[] = {\n -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,\n -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,\n -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,62,-1,-1,-1,63,\n 52,53,54,55,56,57,58,59,60,61,-1,-1,-1, 0,-1,-1, // render '=' as 0\n -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9,10,11,12,13,14,\n 15,16,17,18,19,20,21,22,23,24,25,-1,-1,-1,-1,-1,\n -1,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,\n 41,42,43,44,45,46,47,48,49,50,51,-1,-1,-1,-1,-1\n };\n // metrowerks trips this assertion - how come?\n #if ! defined(__MWERKS__)\n BOOST_STATIC_ASSERT(128 == sizeof(lookup_table));\n #endif\n signed char value = -1;\n if((unsigned)t <= 127)\n value = lookup_table[(unsigned)t];\n if(-1 == value)\n boost::serialization::throw_exception(\n dataflow_exception(dataflow_exception::invalid_base64_character)\n );\n return value;\n }\n};\n\n} // namespace detail\n\n// note: what we would like to do is\n// template\n// typedef transform_iterator<\n// from_6_bit,\n// transform_width\n// > base64_from_binary;\n// but C++ won't accept this. Rather than using a \"type generator\" and\n// using a different syntax, make a derivation which should be equivalent.\n//\n// Another issue addressed here is that the transform_iterator doesn't have\n// a templated constructor. This makes it incompatible with the dataflow\n// ideal. This is also addressed here.\n\ntemplate<\n class Base,\n class CharType = typename boost::iterator_value::type\n>\nclass binary_from_base64 : public\n transform_iterator<\n detail::to_6_bit,\n Base\n >\n{\n friend class boost::iterator_core_access;\n typedef transform_iterator<\n detail::to_6_bit,\n Base\n > super_t;\npublic:\n // make composable by using templated constructor\n template\n binary_from_base64(T start) :\n super_t(\n Base(static_cast< T >(start)),\n detail::to_6_bit()\n )\n {}\n // intel 7.1 doesn't like default copy constructor\n binary_from_base64(const binary_from_base64 & rhs) :\n super_t(\n Base(rhs.base_reference()),\n detail::to_6_bit()\n )\n {}\n// binary_from_base64(){};\n};\n\n} // namespace iterators\n} // namespace archive\n} // namespace boost\n\n#endif // BOOST_ARCHIVE_ITERATORS_BINARY_FROM_BASE64_HPP\n" }, { "path": "include/boost/archive/iterators/dataflow.hpp", "content": "#ifndef BOOST_ARCHIVE_ITERATORS_DATAFLOW_HPP\n#define BOOST_ARCHIVE_ITERATORS_DATAFLOW_HPP\n\n// MS compatible compilers support #pragma once\n#if defined(_MSC_VER)\n# pragma once\n#endif\n\n/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8\n// dataflow.hpp\n\n// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .\n// Use, modification and distribution is subject to the Boost Software\n// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at\n// http://www.boost.org/LICENSE_1_0.txt)\n\n// See http://www.boost.org for updates, documentation, and revision history.\n\n#include \n\n#include \n#include \n#include \n#include \n#include \n\n#include \n#include \n#include \n#include \n#include \n#include \n\nnamespace boost {\nnamespace archive {\nnamespace iterators {\n\n// poor man's tri-state\nstruct tri_state {\n enum state_enum {\n is_false = false,\n is_true = true,\n is_indeterminant\n } m_state;\n // convert to bool\n operator bool (){\n BOOST_ASSERT(is_indeterminant != m_state);\n return is_true == m_state ? true : false;\n }\n // assign from bool\n tri_state & operator=(bool rhs) {\n m_state = rhs ? is_true : is_false;\n return *this;\n }\n tri_state(bool rhs) :\n m_state(rhs ? is_true : is_false)\n {}\n tri_state(state_enum state) :\n m_state(state)\n {}\n bool operator==(const tri_state & rhs) const {\n return m_state == rhs.m_state;\n }\n bool operator!=(const tri_state & rhs) const {\n return m_state != rhs.m_state;\n }\n};\n\n/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8\n// implement functions common to dataflow iterators\ntemplate\nclass dataflow {\n bool m_eoi;\nprotected:\n // test for iterator equality\n tri_state equal(const Derived & rhs) const {\n if(m_eoi && rhs.m_eoi)\n return true;\n if(m_eoi || rhs.m_eoi)\n return false;\n return tri_state(tri_state::is_indeterminant);\n }\n void eoi(bool tf){\n m_eoi = tf;\n }\n bool eoi() const {\n return m_eoi;\n }\npublic:\n dataflow(bool tf) :\n m_eoi(tf)\n {}\n dataflow() : // used for iterator end\n m_eoi(true)\n {}\n};\n\n} // namespace iterators\n} // namespace archive\n} // namespace boost\n\n#endif // BOOST_ARCHIVE_ITERATORS_DATAFLOW_HPP\n" }, { "path": "include/boost/archive/iterators/dataflow_exception.hpp", "content": "#ifndef BOOST_ARCHIVE_ITERATORS_DATAFLOW_EXCEPTION_HPP\n#define BOOST_ARCHIVE_ITERATORS_DATAFLOW_EXCEPTION_HPP\n\n// MS compatible compilers support #pragma once\n#if defined(_MSC_VER)\n# pragma once\n#endif\n\n/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8\n// dataflow_exception.hpp:\n\n// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .\n// Use, modification and distribution is subject to the Boost Software\n// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at\n// http://www.boost.org/LICENSE_1_0.txt)\n\n// See http://www.boost.org for updates, documentation, and revision history.\n\n#include \n#ifndef BOOST_NO_EXCEPTIONS\n#include \n#endif //BOOST_NO_EXCEPTIONS\n\n#include \n\nnamespace boost {\nnamespace archive {\nnamespace iterators {\n\n//////////////////////////////////////////////////////////////////////\n// exceptions thrown by dataflows\n//\nclass dataflow_exception : public std::exception\n{\npublic:\n typedef enum {\n invalid_6_bitcode,\n invalid_base64_character,\n invalid_xml_escape_sequence,\n comparison_not_permitted,\n invalid_conversion,\n other_exception\n } exception_code;\n exception_code code;\n\n dataflow_exception(exception_code c = other_exception) : code(c)\n {}\n\n const char *what( ) const BOOST_NOEXCEPT_OR_NOTHROW BOOST_OVERRIDE\n {\n const char *msg = \"unknown exception code\";\n switch(code){\n case invalid_6_bitcode:\n msg = \"attempt to encode a value > 6 bits\";\n break;\n case invalid_base64_character:\n msg = \"attempt to decode a value not in base64 char set\";\n break;\n case invalid_xml_escape_sequence:\n msg = \"invalid xml escape_sequence\";\n break;\n case comparison_not_permitted:\n msg = \"cannot invoke iterator comparison now\";\n break;\n case invalid_conversion:\n msg = \"invalid multbyte/wide char conversion\";\n break;\n default:\n BOOST_ASSERT(false);\n break;\n }\n return msg;\n }\n};\n\n} // namespace iterators\n} // namespace archive\n} // namespace boost\n\n#endif //BOOST_ARCHIVE_ITERATORS_DATAFLOW_EXCEPTION_HPP\n" }, { "path": "include/boost/archive/iterators/escape.hpp", "content": "#ifndef BOOST_ARCHIVE_ITERATORS_ESCAPE_HPP\n#define BOOST_ARCHIVE_ITERATORS_ESCAPE_HPP\n\n// MS compatible compilers support #pragma once\n#if defined(_MSC_VER)\n# pragma once\n#endif\n\n/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8\n// escape.hpp\n\n// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .\n// Use, modification and distribution is subject to the Boost Software\n// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at\n// http://www.boost.org/LICENSE_1_0.txt)\n\n// See http://www.boost.org for updates, documentation, and revision history.\n\n#include \n#include // NULL\n\n#include \n#include \n\nnamespace boost {\nnamespace archive {\nnamespace iterators {\n\n/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8\n// insert escapes into text\n\ntemplate\nclass escape :\n public boost::iterator_adaptor<\n Derived,\n Base,\n typename boost::iterator_value::type,\n single_pass_traversal_tag,\n typename boost::iterator_value::type\n >\n{\n typedef typename boost::iterator_value::type base_value_type;\n typedef typename boost::iterator_reference::type reference_type;\n friend class boost::iterator_core_access;\n\n typedef typename boost::iterator_adaptor<\n Derived,\n Base,\n base_value_type,\n single_pass_traversal_tag,\n base_value_type\n > super_t;\n\n typedef escape this_t;\n\n void dereference_impl() {\n m_current_value = static_cast(this)->fill(m_bnext, m_bend);\n m_full = true;\n }\n\n //Access the value referred to\n reference_type dereference() const {\n if(!m_full)\n const_cast(this)->dereference_impl();\n return m_current_value;\n }\n\n bool equal(const this_t & rhs) const {\n if(m_full){\n if(! rhs.m_full)\n const_cast(& rhs)->dereference_impl();\n }\n else{\n if(rhs.m_full)\n const_cast(this)->dereference_impl();\n }\n if(m_bnext != rhs.m_bnext)\n return false;\n if(this->base_reference() != rhs.base_reference())\n return false;\n return true;\n }\n\n void increment(){\n if(m_bnext != m_bend && ++m_bnext < m_bend){\n m_current_value = *m_bnext;\n return;\n }\n ++(this->base_reference());\n m_bnext = NULL;\n m_bend = NULL;\n m_full = false;\n }\n\n // buffer to handle pending characters\n const base_value_type *m_bnext;\n const base_value_type *m_bend;\n bool m_full;\n base_value_type m_current_value;\npublic:\n escape(Base base) :\n super_t(base),\n m_bnext(NULL),\n m_bend(NULL),\n m_full(false),\n m_current_value(0)\n {\n }\n};\n\n} // namespace iterators\n} // namespace archive\n} // namespace boost\n\n#endif // BOOST_ARCHIVE_ITERATORS_ESCAPE_HPP\n" }, { "path": "include/boost/archive/iterators/insert_linebreaks.hpp", "content": "#ifndef BOOST_ARCHIVE_ITERATORS_INSERT_LINEBREAKS_HPP\n#define BOOST_ARCHIVE_ITERATORS_INSERT_LINEBREAKS_HPP\n\n// MS compatible compilers support #pragma once\n#if defined(_MSC_VER)\n# pragma once\n#endif\n\n/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8\n// insert_linebreaks.hpp\n\n// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .\n// Use, modification and distribution is subject to the Boost Software\n// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at\n// http://www.boost.org/LICENSE_1_0.txt)\n\n// See http://www.boost.org for updates, documentation, and revision history.\n\n#include \n\n#include \n#if defined(BOOST_NO_STDC_NAMESPACE)\nnamespace std{ using ::memcpy; }\n#endif\n\n#include \n#include \n\nnamespace boost {\nnamespace archive {\nnamespace iterators {\n\n/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8\n// insert line break every N characters\ntemplate<\n class Base,\n int N,\n class CharType = typename boost::iterator_value::type\n>\nclass insert_linebreaks :\n public iterator_adaptor<\n insert_linebreaks,\n Base,\n CharType,\n single_pass_traversal_tag,\n CharType\n >\n{\nprivate:\n friend class boost::iterator_core_access;\n typedef iterator_adaptor<\n insert_linebreaks,\n Base,\n CharType,\n single_pass_traversal_tag,\n CharType\n > super_t;\n\n bool equal(const insert_linebreaks & rhs) const {\n return\n// m_count == rhs.m_count\n// && base_reference() == rhs.base_reference()\n this->base_reference() == rhs.base_reference()\n ;\n }\n\n void increment() {\n if(m_count == N){\n m_count = 0;\n return;\n }\n ++m_count;\n ++(this->base_reference());\n }\n CharType dereference() const {\n if(m_count == N)\n return '\\n';\n return * (this->base_reference());\n }\n unsigned int m_count;\npublic:\n // make composable by using templated constructor\n template\n insert_linebreaks(T start) :\n super_t(Base(static_cast< T >(start))),\n m_count(0)\n {}\n // intel 7.1 doesn't like default copy constructor\n insert_linebreaks(const insert_linebreaks & rhs) :\n super_t(rhs.base_reference()),\n m_count(rhs.m_count)\n {}\n};\n\n} // namespace iterators\n} // namespace archive\n} // namespace boost\n\n#endif // BOOST_ARCHIVE_ITERATORS_INSERT_LINEBREAKS_HPP\n" }, { "path": "include/boost/archive/iterators/istream_iterator.hpp", "content": "#ifndef BOOST_ARCHIVE_ITERATORS_ISTREAM_ITERATOR_HPP\n#define BOOST_ARCHIVE_ITERATORS_ISTREAM_ITERATOR_HPP\n\n// MS compatible compilers support #pragma once\n#if defined(_MSC_VER)\n# pragma once\n#endif\n\n/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8\n// istream_iterator.hpp\n\n// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .\n// Use, modification and distribution is subject to the Boost Software\n// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at\n// http://www.boost.org/LICENSE_1_0.txt)\n\n// See http://www.boost.org for updates, documentation, and revision history.\n\n// note: this is a custom version of the standard istream_iterator.\n// This is necessary as the standard version doesn't work as expected\n// for wchar_t based streams on systems for which wchar_t not a true\n// type but rather a synonym for some integer type.\n\n#include // NULL\n#include \n#include \n\nnamespace boost {\nnamespace archive {\nnamespace iterators {\n\n// given a type, make an input iterator based on a pointer to that type\ntemplate\nclass istream_iterator :\n public boost::iterator_facade<\n istream_iterator,\n Elem,\n std::input_iterator_tag,\n Elem\n >\n{\n friend class boost::iterator_core_access;\n typedef istream_iterator this_t ;\n typedef typename boost::iterator_facade<\n istream_iterator,\n Elem,\n std::input_iterator_tag,\n Elem\n > super_t;\n typedef typename std::basic_istream istream_type;\n\n bool equal(const this_t & rhs) const {\n // note: only works for comparison against end of stream\n return m_istream == rhs.m_istream;\n }\n\n //Access the value referred to\n Elem dereference() const {\n return static_cast(m_istream->peek());\n }\n\n void increment(){\n if(NULL != m_istream){\n m_istream->ignore(1);\n }\n }\n\n istream_type *m_istream;\n Elem m_current_value;\npublic:\n istream_iterator(istream_type & is) :\n m_istream(& is)\n {\n //increment();\n }\n\n istream_iterator() :\n m_istream(NULL),\n m_current_value(NULL)\n {}\n\n istream_iterator(const istream_iterator & rhs) :\n m_istream(rhs.m_istream),\n m_current_value(rhs.m_current_value)\n {}\n};\n\n} // namespace iterators\n} // namespace archive\n} // namespace boost\n\n#endif // BOOST_ARCHIVE_ITERATORS_ISTREAM_ITERATOR_HPP\n" }, { "path": "include/boost/archive/iterators/mb_from_wchar.hpp", "content": "#ifndef BOOST_ARCHIVE_ITERATORS_MB_FROM_WCHAR_HPP\n#define BOOST_ARCHIVE_ITERATORS_MB_FROM_WCHAR_HPP\n\n// MS compatible compilers support #pragma once\n#if defined(_MSC_VER)\n# pragma once\n#endif\n\n/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8\n// mb_from_wchar.hpp\n\n// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .\n// Use, modification and distribution is subject to the Boost Software\n// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at\n// http://www.boost.org/LICENSE_1_0.txt)\n\n// See http://www.boost.org for updates, documentation, and revision history.\n\n#include \n#include // size_t\n#include // memcpy\n#ifndef BOOST_NO_CWCHAR\n#include // mbstate_t\n#endif\n#include \n#if defined(BOOST_NO_STDC_NAMESPACE)\nnamespace std{\n using ::mbstate_t;\n using ::memcpy;\n} // namespace std\n#endif\n\n#include \n#include \n\nnamespace boost {\nnamespace archive {\nnamespace iterators {\n\n/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8\n// class used by text archives to translate wide strings and to char\n// strings of the currently selected locale\ntemplate // the input iterator\nclass mb_from_wchar\n : public boost::iterator_adaptor<\n mb_from_wchar,\n Base,\n wchar_t,\n single_pass_traversal_tag,\n char\n >\n{\n friend class boost::iterator_core_access;\n\n typedef typename boost::iterator_adaptor<\n mb_from_wchar,\n Base,\n wchar_t,\n single_pass_traversal_tag,\n char\n > super_t;\n\n typedef mb_from_wchar this_t;\n\n char dereference_impl() {\n if(! m_full){\n fill();\n m_full = true;\n }\n return m_buffer[m_bnext];\n }\n\n char dereference() const {\n return (const_cast(this))->dereference_impl();\n }\n // test for iterator equality\n bool equal(const mb_from_wchar & rhs) const {\n // once the value is filled, the base_reference has been incremented\n // so don't permit comparison anymore.\n return\n 0 == m_bend\n && 0 == m_bnext\n && this->base_reference() == rhs.base_reference()\n ;\n }\n\n void fill(){\n wchar_t value = * this->base_reference();\n const wchar_t *wend;\n char *bend;\n BOOST_VERIFY(\n m_codecvt_facet.out(\n m_mbs,\n & value, & value + 1, wend,\n m_buffer, m_buffer + sizeof(m_buffer), bend\n )\n ==\n std::codecvt_base::ok\n );\n m_bnext = 0;\n m_bend = bend - m_buffer;\n }\n\n void increment(){\n if(++m_bnext < m_bend)\n return;\n m_bend =\n m_bnext = 0;\n ++(this->base_reference());\n m_full = false;\n }\n\n boost::archive::detail::utf8_codecvt_facet m_codecvt_facet;\n std::mbstate_t m_mbs;\n // buffer to handle pending characters\n char m_buffer[9 /* MB_CUR_MAX */];\n std::size_t m_bend;\n std::size_t m_bnext;\n bool m_full;\n\npublic:\n // make composable by using templated constructor\n template\n mb_from_wchar(T start) :\n super_t(Base(static_cast< T >(start))),\n m_mbs(std::mbstate_t()),\n m_bend(0),\n m_bnext(0),\n m_full(false)\n {}\n // intel 7.1 doesn't like default copy constructor\n mb_from_wchar(const mb_from_wchar & rhs) :\n super_t(rhs.base_reference()),\n m_mbs(rhs.m_mbs),\n m_bend(rhs.m_bend),\n m_bnext(rhs.m_bnext),\n m_full(rhs.m_full)\n {\n std::memcpy(m_buffer, rhs.m_buffer, sizeof(m_buffer));\n }\n};\n\n} // namespace iterators\n} // namespace archive\n} // namespace boost\n\n#endif // BOOST_ARCHIVE_ITERATORS_MB_FROM_WCHAR_HPP\n" }, { "path": "include/boost/archive/iterators/ostream_iterator.hpp", "content": "#ifndef BOOST_ARCHIVE_ITERATORS_OSTREAM_ITERATOR_HPP\n#define BOOST_ARCHIVE_ITERATORS_OSTREAM_ITERATOR_HPP\n\n// MS compatible compilers support #pragma once\n#if defined(_MSC_VER)\n# pragma once\n#endif\n\n/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8\n// ostream_iterator.hpp\n\n// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .\n// Use, modification and distribution is subject to the Boost Software\n// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at\n// http://www.boost.org/LICENSE_1_0.txt)\n\n// See http://www.boost.org for updates, documentation, and revision history.\n\n// note: this is a custom version of the standard ostream_iterator.\n// This is necessary as the standard version doesn't work as expected\n// for wchar_t based streams on systems for which wchar_t not a true\n// type but rather a synonym for some integer type.\n\n#include \n#include \n\nnamespace boost {\nnamespace archive {\nnamespace iterators {\n\n// given a type, make an input iterator based on a pointer to that type\ntemplate\nclass ostream_iterator :\n public boost::iterator_facade<\n ostream_iterator,\n Elem,\n std::output_iterator_tag,\n ostream_iterator &\n >\n{\n friend class boost::iterator_core_access;\n typedef ostream_iterator this_t ;\n typedef Elem char_type;\n typedef std::basic_ostream ostream_type;\n\n //emulate the behavior of std::ostream\n ostream_iterator & dereference() const {\n return const_cast(*this);\n }\n bool equal(const this_t & rhs) const {\n return m_ostream == rhs.m_ostream;\n }\n void increment(){}\nprotected:\n ostream_type *m_ostream;\n void put_val(char_type e){\n if(NULL != m_ostream){\n m_ostream->put(e);\n if(! m_ostream->good())\n m_ostream = NULL;\n }\n }\npublic:\n this_t & operator=(char_type c){\n put_val(c);\n return *this;\n }\n ostream_iterator(ostream_type & os) :\n m_ostream (& os)\n {}\n ostream_iterator() :\n m_ostream (NULL)\n {}\n ostream_iterator(const ostream_iterator & rhs) :\n m_ostream (rhs.m_ostream)\n {}\n};\n\n} // namespace iterators\n} // namespace archive\n} // namespace boost\n\n#endif // BOOST_ARCHIVE_ITERATORS_OSTREAM_ITERATOR_HPP\n" }, { "path": "include/boost/archive/iterators/remove_whitespace.hpp", "content": "#ifndef BOOST_ARCHIVE_ITERATORS_REMOVE_WHITESPACE_HPP\n#define BOOST_ARCHIVE_ITERATORS_REMOVE_WHITESPACE_HPP\n\n// MS compatible compilers support #pragma once\n#if defined(_MSC_VER)\n# pragma once\n#endif\n\n/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8\n// remove_whitespace.hpp\n\n// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .\n// Use, modification and distribution is subject to the Boost Software\n// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at\n// http://www.boost.org/LICENSE_1_0.txt)\n\n// See http://www.boost.org for updates, documentation, and revision history.\n\n#include \n\n#include \n#include \n#include \n\n// here is the default standard implementation of the functor used\n// by the filter iterator to remove spaces. Unfortunately usage\n// of this implementation in combination with spirit trips a bug\n// VC 6.5. The only way I can find to work around it is to\n// implement a special non-standard version for this platform\n\n#ifndef BOOST_NO_CWCTYPE\n#include // iswspace\n#if defined(BOOST_NO_STDC_NAMESPACE)\nnamespace std{ using ::iswspace; }\n#endif\n#endif\n\n#include // isspace\n#if defined(BOOST_NO_STDC_NAMESPACE)\nnamespace std{ using ::isspace; }\n#endif\n\n#if defined(__STD_RWCOMPILER_H__) || defined(_RWSTD_VER)\n// this is required for the RW STL on Linux and Tru64.\n#undef isspace\n#undef iswspace\n#endif\n\nnamespace { // anonymous\n\ntemplate\nstruct remove_whitespace_predicate;\n\ntemplate<>\nstruct remove_whitespace_predicate\n{\n bool operator()(unsigned char t){\n return ! std::isspace(t);\n }\n};\n\n#ifndef BOOST_NO_CWCHAR\ntemplate<>\nstruct remove_whitespace_predicate\n{\n bool operator()(wchar_t t){\n return ! std::iswspace(t);\n }\n};\n#endif\n\n} // namespace anonymous\n\n/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8\n// convert base64 file data (including whitespace and padding) to binary\n\nnamespace boost {\nnamespace archive {\nnamespace iterators {\n\n// custom version of filter iterator which doesn't look ahead further than\n// necessary\n\ntemplate\nclass filter_iterator\n : public boost::iterator_adaptor<\n filter_iterator,\n Base,\n use_default,\n single_pass_traversal_tag\n >\n{\n friend class boost::iterator_core_access;\n typedef typename boost::iterator_adaptor<\n filter_iterator,\n Base,\n use_default,\n single_pass_traversal_tag\n > super_t;\n typedef filter_iterator this_t;\n typedef typename super_t::reference reference_type;\n\n reference_type dereference_impl(){\n if(! m_full){\n while(! m_predicate(* this->base_reference()))\n ++(this->base_reference());\n m_full = true;\n }\n return * this->base_reference();\n }\n\n reference_type dereference() const {\n return const_cast(this)->dereference_impl();\n }\n\n Predicate m_predicate;\n bool m_full;\npublic:\n // note: this function is public only because comeau compiler complained\n // I don't know if this is because the compiler is wrong or what\n void increment(){\n m_full = false;\n ++(this->base_reference());\n }\n filter_iterator(Base start) :\n super_t(start),\n m_full(false)\n {}\n filter_iterator(){}\n};\n\ntemplate\nclass remove_whitespace :\n public filter_iterator<\n remove_whitespace_predicate<\n typename boost::iterator_value::type\n //typename Base::value_type\n >,\n Base\n >\n{\n friend class boost::iterator_core_access;\n typedef filter_iterator<\n remove_whitespace_predicate<\n typename boost::iterator_value::type\n //typename Base::value_type\n >,\n Base\n > super_t;\npublic:\n// remove_whitespace(){} // why is this needed?\n // make composable by using templated constructor\n template\n remove_whitespace(T start) :\n super_t(Base(static_cast< T >(start)))\n {}\n // intel 7.1 doesn't like default copy constructor\n remove_whitespace(const remove_whitespace & rhs) :\n super_t(rhs.base_reference())\n {}\n};\n\n} // namespace iterators\n} // namespace archive\n} // namespace boost\n\n#endif // BOOST_ARCHIVE_ITERATORS_REMOVE_WHITESPACE_HPP\n" }, { "path": "include/boost/archive/iterators/transform_width.hpp", "content": "#ifndef BOOST_ARCHIVE_ITERATORS_TRANSFORM_WIDTH_HPP\n#define BOOST_ARCHIVE_ITERATORS_TRANSFORM_WIDTH_HPP\n\n// MS compatible compilers support #pragma once\n#if defined(_MSC_VER)\n# pragma once\n#endif\n\n/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8\n// transform_width.hpp\n\n// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .\n// Use, modification and distribution is subject to the Boost Software\n// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at\n// http://www.boost.org/LICENSE_1_0.txt)\n\n// See http://www.boost.org for updates, documentation, and revision history.\n\n// iterator which takes elements of x bits and returns elements of y bits.\n// used to change streams of 8 bit characters into streams of 6 bit characters.\n// and vice-versa for implementing base64 encodeing/decoding. Be very careful\n// when using and end iterator. end is only reliable detected when the input\n// stream length is some common multiple of x and y. E.G. Base64 6 bit\n// character and 8 bit bytes. Lowest common multiple is 24 => 4 6 bit characters\n// or 3 8 bit characters\n\n#include \n#include \n\n#include // std::min\n\nnamespace boost {\nnamespace archive {\nnamespace iterators {\n\n/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8\n// class used by text archives to translate char strings to wchar_t\n// strings of the currently selected locale\ntemplate<\n class Base,\n int BitsOut,\n int BitsIn,\n class CharType = typename boost::iterator_value::type // output character\n>\nclass transform_width :\n public boost::iterator_adaptor<\n transform_width,\n Base,\n CharType,\n single_pass_traversal_tag,\n CharType\n >\n{\n friend class boost::iterator_core_access;\n typedef typename boost::iterator_adaptor<\n transform_width,\n Base,\n CharType,\n single_pass_traversal_tag,\n CharType\n > super_t;\n\n typedef transform_width this_t;\n typedef typename iterator_value::type base_value_type;\n\n void fill();\n\n CharType dereference() const {\n if(!m_buffer_out_full)\n const_cast(this)->fill();\n return m_buffer_out;\n }\n\n bool equal_impl(const this_t & rhs){\n if(BitsIn < BitsOut) // discard any left over bits\n return this->base_reference() == rhs.base_reference();\n else{\n // BitsIn > BitsOut // zero fill\n if(this->base_reference() == rhs.base_reference()){\n m_end_of_sequence = true;\n return 0 == m_remaining_bits;\n }\n return false;\n }\n }\n\n // standard iterator interface\n bool equal(const this_t & rhs) const {\n return const_cast(this)->equal_impl(rhs);\n }\n\n void increment(){\n m_buffer_out_full = false;\n }\n\n bool m_buffer_out_full;\n CharType m_buffer_out;\n\n // last read element from input\n base_value_type m_buffer_in;\n\n // number of bits to left in the input buffer.\n unsigned int m_remaining_bits;\n\n // flag to indicate we've reached end of data.\n bool m_end_of_sequence;\n\npublic:\n // make composable by using templated constructor\n template\n transform_width(T start) :\n super_t(Base(static_cast< T >(start))),\n m_buffer_out_full(false),\n m_buffer_out(0),\n // To disable GCC warning, but not truly necessary\n\t //(m_buffer_in will be initialized later before being\n\t //used because m_remaining_bits == 0)\n m_buffer_in(0),\n m_remaining_bits(0),\n m_end_of_sequence(false)\n {}\n // intel 7.1 doesn't like default copy constructor\n transform_width(const transform_width & rhs) :\n super_t(rhs.base_reference()),\n m_buffer_out_full(rhs.m_buffer_out_full),\n m_buffer_out(rhs.m_buffer_out),\n m_buffer_in(rhs.m_buffer_in),\n m_remaining_bits(rhs.m_remaining_bits),\n m_end_of_sequence(false)\n {}\n};\n\ntemplate<\n class Base,\n int BitsOut,\n int BitsIn,\n class CharType\n>\nvoid transform_width::fill() {\n unsigned int missing_bits = BitsOut;\n m_buffer_out = 0;\n do{\n if(0 == m_remaining_bits){\n if(m_end_of_sequence){\n m_buffer_in = 0;\n m_remaining_bits = missing_bits;\n }\n else{\n m_buffer_in = * this->base_reference()++;\n m_remaining_bits = BitsIn;\n }\n }\n\n // append these bits to the next output\n // up to the size of the output\n unsigned int i = (std::min)(missing_bits, m_remaining_bits);\n // shift interesting bits to least significant position\n base_value_type j = m_buffer_in >> (m_remaining_bits - i);\n // and mask off the un interesting higher bits\n // note presumption of twos complement notation\n j &= (1 << i) - 1;\n // append then interesting bits to the output value\n m_buffer_out <<= i;\n m_buffer_out |= j;\n\n // and update counters\n missing_bits -= i;\n m_remaining_bits -= i;\n }while(0 < missing_bits);\n m_buffer_out_full = true;\n}\n\n} // namespace iterators\n} // namespace archive\n} // namespace boost\n\n#endif // BOOST_ARCHIVE_ITERATORS_TRANSFORM_WIDTH_HPP\n" }, { "path": "include/boost/archive/iterators/unescape.hpp", "content": "#ifndef BOOST_ARCHIVE_ITERATORS_UNESCAPE_HPP\n#define BOOST_ARCHIVE_ITERATORS_UNESCAPE_HPP\n\n// MS compatible compilers support #pragma once\n#if defined(_MSC_VER)\n# pragma once\n#endif\n\n/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8\n// unescape.hpp\n\n// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .\n// Use, modification and distribution is subject to the Boost Software\n// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at\n// http://www.boost.org/LICENSE_1_0.txt)\n\n// See http://www.boost.org for updates, documentation, and revision history.\n\n#include \n\n#include \n#include \n\nnamespace boost {\nnamespace archive {\nnamespace iterators {\n\n/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8\n// class used by text archives to translate char strings to wchar_t\n// strings of the currently selected locale\ntemplate\nclass unescape\n : public boost::iterator_adaptor<\n unescape,\n Base,\n typename pointee::type,\n single_pass_traversal_tag,\n typename pointee::type\n >\n{\n friend class boost::iterator_core_access;\n typedef typename boost::iterator_adaptor<\n unescape,\n Base,\n typename pointee::type,\n single_pass_traversal_tag,\n typename pointee::type\n > super_t;\n\n typedef unescape this_t;\npublic:\n typedef typename this_t::value_type value_type;\n typedef typename this_t::reference reference;\nprivate:\n value_type dereference_impl() {\n if(! m_full){\n m_current_value = static_cast(this)->drain();\n m_full = true;\n }\n return m_current_value;\n }\n\n reference dereference() const {\n return const_cast(this)->dereference_impl();\n }\n\n value_type m_current_value;\n bool m_full;\n\n void increment(){\n ++(this->base_reference());\n dereference_impl();\n m_full = false;\n }\n\npublic:\n\n unescape(Base base) :\n super_t(base),\n m_full(false)\n {}\n\n};\n\n} // namespace iterators\n} // namespace archive\n} // namespace boost\n\n#endif // BOOST_ARCHIVE_ITERATORS_UNESCAPE_HPP\n" }, { "path": "include/boost/archive/iterators/wchar_from_mb.hpp", "content": "#ifndef BOOST_ARCHIVE_ITERATORS_WCHAR_FROM_MB_HPP\n#define BOOST_ARCHIVE_ITERATORS_WCHAR_FROM_MB_HPP\n\n// MS compatible compilers support #pragma once\n#if defined(_MSC_VER)\n# pragma once\n#endif\n\n/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8\n// wchar_from_mb.hpp\n\n// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .\n// Use, modification and distribution is subject to the Boost Software\n// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at\n// http://www.boost.org/LICENSE_1_0.txt)\n\n// See http://www.boost.org for updates, documentation, and revision history.\n\n#include \n#include // size_t\n#ifndef BOOST_NO_CWCHAR\n#include // mbstate_t\n#endif\n#include // copy\n\n#include \n#if defined(BOOST_NO_STDC_NAMESPACE)\nnamespace std{\n using ::mbstate_t;\n} // namespace std\n#endif\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\n#include \n\nnamespace boost {\nnamespace archive {\nnamespace iterators {\n\n/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8\n// class used by text archives to translate char strings to wchar_t\n// strings of the currently selected locale\ntemplate\nclass wchar_from_mb\n : public boost::iterator_adaptor<\n wchar_from_mb,\n Base,\n wchar_t,\n single_pass_traversal_tag,\n wchar_t\n >\n{\n friend class boost::iterator_core_access;\n typedef typename boost::iterator_adaptor<\n wchar_from_mb,\n Base,\n wchar_t,\n single_pass_traversal_tag,\n wchar_t\n > super_t;\n\n typedef wchar_from_mb this_t;\n\n void drain();\n\n wchar_t dereference() const {\n if(m_output.m_next == m_output.m_next_available)\n return static_cast(0);\n return * m_output.m_next;\n }\n\n void increment(){\n if(m_output.m_next == m_output.m_next_available)\n return;\n if(++m_output.m_next == m_output.m_next_available){\n if(m_input.m_done)\n return;\n drain();\n }\n }\n\n bool equal(this_t const & rhs) const {\n return dereference() == rhs.dereference();\n }\n\n boost::archive::detail::utf8_codecvt_facet m_codecvt_facet;\n std::mbstate_t m_mbs;\n\n template\n struct sliding_buffer {\n boost::array m_buffer;\n typename boost::array::const_iterator m_next_available;\n typename boost::array::iterator m_next;\n bool m_done;\n // default ctor\n sliding_buffer() :\n m_next_available(m_buffer.begin()),\n m_next(m_buffer.begin()),\n m_done(false)\n {}\n // copy ctor\n sliding_buffer(const sliding_buffer & rhs) :\n m_next_available(\n std::copy(\n rhs.m_buffer.begin(),\n rhs.m_next_available,\n m_buffer.begin()\n )\n ),\n m_next(\n m_buffer.begin() + (rhs.m_next - rhs.m_buffer.begin())\n ),\n m_done(rhs.m_done)\n {}\n };\n\n sliding_buffer::type> m_input;\n sliding_buffer::type> m_output;\n\npublic:\n // make composable by using templated constructor\n template\n wchar_from_mb(T start) :\n super_t(Base(static_cast< T >(start))),\n m_mbs(std::mbstate_t())\n {\n BOOST_ASSERT(std::mbsinit(&m_mbs));\n drain();\n }\n // default constructor used as an end iterator\n wchar_from_mb(){}\n\n // copy ctor\n wchar_from_mb(const wchar_from_mb & rhs) :\n super_t(rhs.base_reference()),\n m_mbs(rhs.m_mbs),\n m_input(rhs.m_input),\n m_output(rhs.m_output)\n {}\n};\n\ntemplate\nvoid wchar_from_mb::drain(){\n BOOST_ASSERT(! m_input.m_done);\n for(;;){\n typename boost::iterators::iterator_reference::type c = *(this->base_reference());\n // a null character in a multibyte stream is takes as end of string\n if(0 == c){\n m_input.m_done = true;\n break;\n }\n ++(this->base_reference());\n * const_cast::type *>(\n (m_input.m_next_available++)\n ) = c;\n // if input buffer is full - we're done for now\n if(m_input.m_buffer.end() == m_input.m_next_available)\n break;\n }\n const typename boost::iterators::iterator_value::type * input_new_start;\n typename iterator_value::type * next_available;\n\n BOOST_ATTRIBUTE_UNUSED // redundant with ignore_unused below but clarifies intention\n std::codecvt_base::result r = m_codecvt_facet.in(\n m_mbs,\n m_input.m_buffer.begin(),\n m_input.m_next_available,\n input_new_start,\n m_output.m_buffer.begin(),\n m_output.m_buffer.end(),\n next_available\n );\n BOOST_ASSERT(std::codecvt_base::ok == r);\n m_output.m_next_available = next_available;\n m_output.m_next = m_output.m_buffer.begin();\n\n // we're done with some of the input so shift left.\n m_input.m_next_available = std::copy(\n input_new_start,\n m_input.m_next_available,\n m_input.m_buffer.begin()\n );\n m_input.m_next = m_input.m_buffer.begin();\n}\n\n} // namespace iterators\n} // namespace archive\n} // namespace boost\n\n#endif // BOOST_ARCHIVE_ITERATORS_WCHAR_FROM_MB_HPP\n" }, { "path": "include/boost/archive/iterators/xml_escape.hpp", "content": "#ifndef BOOST_ARCHIVE_ITERATORS_XML_ESCAPE_HPP\n#define BOOST_ARCHIVE_ITERATORS_XML_ESCAPE_HPP\n\n// MS compatible compilers support #pragma once\n#if defined(_MSC_VER)\n# pragma once\n#endif\n\n/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8\n// xml_escape.hpp\n\n// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .\n// Use, modification and distribution is subject to the Boost Software\n// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at\n// http://www.boost.org/LICENSE_1_0.txt)\n\n// See http://www.boost.org for updates, documentation, and revision history.\n\n#include \n#include \n\nnamespace boost {\nnamespace archive {\nnamespace iterators {\n\n/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8\n// insert escapes into xml text\n\ntemplate\nclass xml_escape\n : public escape, Base>\n{\n friend class boost::iterator_core_access;\n\n typedef escape, Base> super_t;\n\npublic:\n char fill(const char * & bstart, const char * & bend);\n wchar_t fill(const wchar_t * & bstart, const wchar_t * & bend);\n\n template\n xml_escape(T start) :\n super_t(Base(static_cast< T >(start)))\n {}\n // intel 7.1 doesn't like default copy constructor\n xml_escape(const xml_escape & rhs) :\n super_t(rhs.base_reference())\n {}\n};\n\ntemplate\nchar xml_escape::fill(\n const char * & bstart,\n const char * & bend\n){\n char current_value = * this->base_reference();\n switch(current_value){\n case '<':\n bstart = \"<\";\n bend = bstart + 4;\n break;\n case '>':\n bstart = \">\";\n bend = bstart + 4;\n break;\n case '&':\n bstart = \"&\";\n bend = bstart + 5;\n break;\n case '\"':\n bstart = \""\";\n bend = bstart + 6;\n break;\n case '\\'':\n bstart = \"'\";\n bend = bstart + 6;\n break;\n default:\n bstart=\"\";\n bend=bstart;\n return current_value;\n }\n return *bstart;\n}\n\ntemplate\nwchar_t xml_escape::fill(\n const wchar_t * & bstart,\n const wchar_t * & bend\n){\n wchar_t current_value = * this->base_reference();\n switch(current_value){\n case '<':\n bstart = L\"<\";\n bend = bstart + 4;\n break;\n case '>':\n bstart = L\">\";\n bend = bstart + 4;\n break;\n case '&':\n bstart = L\"&\";\n bend = bstart + 5;\n break;\n case '\"':\n bstart = L\""\";\n bend = bstart + 6;\n break;\n case '\\'':\n bstart = L\"'\";\n bend = bstart + 6;\n break;\n default:\n return current_value;\n }\n return *bstart;\n}\n\n} // namespace iterators\n} // namespace archive\n} // namespace boost\n\n#endif // BOOST_ARCHIVE_ITERATORS_XML_ESCAPE_HPP\n" }, { "path": "include/boost/archive/iterators/xml_unescape.hpp", "content": "#ifndef BOOST_ARCHIVE_ITERATORS_XML_UNESCAPE_HPP\n#define BOOST_ARCHIVE_ITERATORS_XML_UNESCAPE_HPP\n\n// MS compatible compilers support #pragma once\n#if defined(_MSC_VER)\n# pragma once\n#endif\n\n/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8\n// xml_unescape.hpp\n\n// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .\n// Use, modification and distribution is subject to the Boost Software\n// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at\n// http://www.boost.org/LICENSE_1_0.txt)\n\n// See http://www.boost.org for updates, documentation, and revision history.\n\n#include \n#include \n#include \n\n#include \n\n#include \n#include \n\nnamespace boost {\nnamespace archive {\nnamespace iterators {\n\n/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8\n// replace &??? xml escape sequences with the corresponding characters\ntemplate\nclass xml_unescape\n : public unescape, Base>\n{\n friend class boost::iterator_core_access;\n typedef xml_unescape this_t;\n typedef unescape super_t;\n typedef typename boost::iterator_reference reference_type;\n\n reference_type dereference() const {\n return unescape, Base>::dereference();\n }\npublic:\n // msvc versions prior to 14.0 crash with and ICE\n #if BOOST_WORKAROUND(BOOST_MSVC, < 1900)\n typedef int value_type;\n #else\n typedef typename super_t::value_type value_type;\n #endif\n\n void drain_residue(const char *literal);\n value_type drain();\n\n template\n xml_unescape(T start) :\n super_t(Base(static_cast< T >(start)))\n {}\n // intel 7.1 doesn't like default copy constructor\n xml_unescape(const xml_unescape & rhs) :\n super_t(rhs.base_reference())\n {}\n};\n\ntemplate\nvoid xml_unescape::drain_residue(const char * literal){\n do{\n if(* literal != * ++(this->base_reference()))\n boost::serialization::throw_exception(\n dataflow_exception(\n dataflow_exception::invalid_xml_escape_sequence\n )\n );\n }\n while('\\0' != * ++literal);\n}\n\n// note key constraint on this function is that can't \"look ahead\" any\n// more than necessary into base iterator. Doing so would alter the base\n// iterator reference which would make subsequent iterator comparisons\n// incorrect and thereby break the composiblity of iterators.\ntemplate\ntypename xml_unescape::value_type\n//int\nxml_unescape::drain(){\n value_type retval = * this->base_reference();\n if('&' != retval){\n return retval;\n }\n retval = * ++(this->base_reference());\n switch(retval){\n case 'l': // <\n drain_residue(\"t;\");\n retval = '<';\n break;\n case 'g': // >\n drain_residue(\"t;\");\n retval = '>';\n break;\n case 'a':\n retval = * ++(this->base_reference());\n switch(retval){\n case 'p': // '\n drain_residue(\"os;\");\n retval = '\\'';\n break;\n case 'm': // &\n drain_residue(\"p;\");\n retval = '&';\n break;\n }\n break;\n case 'q':\n drain_residue(\"uot;\");\n retval = '\"';\n break;\n }\n return retval;\n}\n\n} // namespace iterators\n} // namespace archive\n} // namespace boost\n\n#endif // BOOST_ARCHIVE_ITERATORS_XML_UNESCAPE_HPP\n" }, { "path": "include/boost/archive/iterators/xml_unescape_exception.hpp", "content": "#ifndef BOOST_ARCHIVE_ITERATORS_XML_UNESCAPE_EXCEPTION_HPP\n#define BOOST_ARCHIVE_ITERATORS_XML_UNESCAPE_EXCEPTION_HPP\n\n// MS compatible compilers support #pragma once\n#if defined(_MSC_VER)\n# pragma once\n#endif\n\n/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8\n// xml_unescape_exception.hpp:\n\n// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .\n// Use, modification and distribution is subject to the Boost Software\n// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at\n// http://www.boost.org/LICENSE_1_0.txt)\n\n// See http://www.boost.org for updates, documentation, and revision history.\n\n#include \n#ifndef BOOST_NO_EXCEPTIONS\n#include \n\n#include \n\nnamespace boost {\nnamespace archive {\nnamespace iterators {\n\n//////////////////////////////////////////////////////////////////////\n// exceptions thrown by xml_unescapes\n//\nclass xml_unescape_exception : public std::exception\n{\npublic:\n xml_unescape_exception()\n {}\n\n virtual const char *what( ) const BOOST_NOEXCEPT_OR_NOTHROW\n {\n return \"xml contained un-recognized escape code\";\n }\n};\n\n} // namespace iterators\n} // namespace archive\n} // namespace boost\n\n#endif //BOOST_NO_EXCEPTIONS\n#endif //BOOST_ARCHIVE_ITERATORS_XML_UNESCAPE_EXCEPTION_HPP\n" }, { "path": "include/boost/archive/polymorphic_binary_iarchive.hpp", "content": "#ifndef BOOST_ARCHIVE_POLYMORPHIC_BINARY_IARCHIVE_HPP\n#define BOOST_ARCHIVE_POLYMORPHIC_BINARY_IARCHIVE_HPP\n\n// MS compatible compilers support #pragma once\n#if defined(_MSC_VER)\n# pragma once\n#endif\n\n/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8\n// polymorphic_binary_iarchive.hpp\n\n// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .\n// Use, modification and distribution is subject to the Boost Software\n// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at\n// http://www.boost.org/LICENSE_1_0.txt)\n\n// See http://www.boost.org for updates, documentation, and revision history.\n\n#include \n#include \n#include \n\n#ifdef BOOST_MSVC\n# pragma warning(push)\n# pragma warning(disable : 4511 4512)\n#endif\n\nnamespace boost {\nnamespace archive {\n\nclass BOOST_SYMBOL_VISIBLE polymorphic_binary_iarchive :\n public detail::polymorphic_iarchive_route\n{\npublic:\n polymorphic_binary_iarchive(std::istream & is, unsigned int flags = 0) :\n detail::polymorphic_iarchive_route(is, flags)\n {}\n ~polymorphic_binary_iarchive() BOOST_OVERRIDE {}\n};\n\n} // namespace archive\n} // namespace boost\n\n#ifdef BOOST_MSVC\n#pragma warning(pop)\n#endif\n\n// required by export\nBOOST_SERIALIZATION_REGISTER_ARCHIVE(\n boost::archive::polymorphic_binary_iarchive\n)\n\n#endif // BOOST_ARCHIVE_POLYMORPHIC_BINARY_IARCHIVE_HPP\n" }, { "path": "include/boost/archive/polymorphic_binary_oarchive.hpp", "content": "#ifndef BOOST_ARCHIVE_POLYMORPHIC_BINARY_OARCHIVE_HPP\n#define BOOST_ARCHIVE_POLYMORPHIC_BINARY_OARCHIVE_HPP\n\n// MS compatible compilers support #pragma once\n#if defined(_MSC_VER)\n# pragma once\n#endif\n\n/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8\n// polymorphic_binary_oarchive.hpp\n\n// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .\n// Use, modification and distribution is subject to the Boost Software\n// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at\n// http://www.boost.org/LICENSE_1_0.txt)\n\n// See http://www.boost.org for updates, documentation, and revision history.\n\n#include \n#include \n#include \n\nnamespace boost {\nnamespace archive {\n\nclass BOOST_SYMBOL_VISIBLE polymorphic_binary_oarchive :\n public detail::polymorphic_oarchive_route\n{\npublic:\n polymorphic_binary_oarchive(std::ostream & os, unsigned int flags = 0) :\n detail::polymorphic_oarchive_route(os, flags)\n {}\n ~polymorphic_binary_oarchive() BOOST_OVERRIDE {}\n};\n\n} // namespace archive\n} // namespace boost\n\n// required by export\nBOOST_SERIALIZATION_REGISTER_ARCHIVE(\n boost::archive::polymorphic_binary_oarchive\n)\n\n#endif // BOOST_ARCHIVE_POLYMORPHIC_BINARY_OARCHIVE_HPP\n" }, { "path": "include/boost/archive/polymorphic_iarchive.hpp", "content": "#ifndef BOOST_ARCHIVE_POLYMORPHIC_IARCHIVE_HPP\n#define BOOST_ARCHIVE_POLYMORPHIC_IARCHIVE_HPP\n\n// MS compatible compilers support #pragma once\n#if defined(_MSC_VER)\n# pragma once\n#endif\n\n/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8\n// polymorphic_iarchive.hpp\n\n// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .\n// Use, modification and distribution is subject to the Boost Software\n// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at\n// http://www.boost.org/LICENSE_1_0.txt)\n\n// See http://www.boost.org for updates, documentation, and revision history.\n\n#include // std::size_t\n#include // ULONG_MAX\n#include \n\n#include \n#if defined(BOOST_NO_STDC_NAMESPACE)\nnamespace std{\n using ::size_t;\n} // namespace std\n#endif\n\n#include \n\n#include \n#include \n#include \n#include \n#include \n\n#include \n#include // must be the last header\n\nnamespace boost {\nnamespace serialization {\n class extended_type_info;\n} // namespace serialization\nnamespace archive {\nnamespace detail {\n class basic_iarchive;\n class basic_iserializer;\n}\n\nclass polymorphic_iarchive;\n\nclass BOOST_SYMBOL_VISIBLE polymorphic_iarchive_impl :\n public detail::interface_iarchive\n{\n#ifdef BOOST_NO_MEMBER_TEMPLATE_FRIENDS\npublic:\n#else\n friend class detail::interface_iarchive;\n friend class load_access;\n#endif\n // primitive types the only ones permitted by polymorphic archives\n virtual void load(bool & t) = 0;\n\n virtual void load(char & t) = 0;\n virtual void load(signed char & t) = 0;\n virtual void load(unsigned char & t) = 0;\n #ifndef BOOST_NO_CWCHAR\n #ifndef BOOST_NO_INTRINSIC_WCHAR_T\n virtual void load(wchar_t & t) = 0;\n #endif\n #endif\n virtual void load(short & t) = 0;\n virtual void load(unsigned short & t) = 0;\n virtual void load(int & t) = 0;\n virtual void load(unsigned int & t) = 0;\n virtual void load(long & t) = 0;\n virtual void load(unsigned long & t) = 0;\n\n #if defined(BOOST_HAS_LONG_LONG)\n virtual void load(boost::long_long_type & t) = 0;\n virtual void load(boost::ulong_long_type & t) = 0;\n #elif defined(BOOST_HAS_MS_INT64)\n virtual void load(__int64 & t) = 0;\n virtual void load(unsigned __int64 & t) = 0;\n #endif\n\n virtual void load(float & t) = 0;\n virtual void load(double & t) = 0;\n\n // string types are treated as primitives\n virtual void load(std::string & t) = 0;\n #ifndef BOOST_NO_STD_WSTRING\n virtual void load(std::wstring & t) = 0;\n #endif\n\n // used for xml and other tagged formats\n virtual void load_start(const char * name) = 0;\n virtual void load_end(const char * name) = 0;\n virtual void register_basic_serializer(const detail::basic_iserializer & bis) = 0;\n virtual detail::helper_collection & get_helper_collection() = 0;\n\n // msvc and borland won't automatically pass these to the base class so\n // make it explicit here\n template\n void load_override(T & t)\n {\n archive::load(* this->This(), t);\n }\n // special treatment for name-value pairs.\n template\n void load_override(\n const boost::serialization::nvp< T > & t\n ){\n load_start(t.name());\n archive::load(* this->This(), t.value());\n load_end(t.name());\n }\nprotected:\n virtual ~polymorphic_iarchive_impl() {}\npublic:\n // utility function implemented by all legal archives\n virtual void set_library_version(\n boost::serialization::library_version_type archive_library_version\n ) = 0;\n virtual boost::serialization::library_version_type get_library_version() const = 0;\n virtual unsigned int get_flags() const = 0;\n virtual void delete_created_pointers() = 0;\n virtual void reset_object_address(\n const void * new_address,\n const void * old_address\n ) = 0;\n\n virtual void load_binary(void * t, std::size_t size) = 0;\n\n // these are used by the serialization library implementation.\n virtual void load_object(\n void *t,\n const detail::basic_iserializer & bis\n ) = 0;\n virtual const detail::basic_pointer_iserializer * load_pointer(\n void * & t,\n const detail::basic_pointer_iserializer * bpis_ptr,\n const detail::basic_pointer_iserializer * (*finder)(\n const boost::serialization::extended_type_info & type\n )\n ) = 0;\n};\n\n} // namespace archive\n} // namespace boost\n\n#include // pops abi_suffix.hpp pragmas\n\nnamespace boost {\nnamespace archive {\n\nclass BOOST_SYMBOL_VISIBLE polymorphic_iarchive :\n public polymorphic_iarchive_impl\n{\npublic:\n ~polymorphic_iarchive() BOOST_OVERRIDE {}\n};\n\n} // namespace archive\n} // namespace boost\n\n// required by export\nBOOST_SERIALIZATION_REGISTER_ARCHIVE(boost::archive::polymorphic_iarchive)\n\n#endif // BOOST_ARCHIVE_POLYMORPHIC_IARCHIVE_HPP\n" }, { "path": "include/boost/archive/polymorphic_oarchive.hpp", "content": "#ifndef BOOST_ARCHIVE_POLYMORPHIC_OARCHIVE_HPP\n#define BOOST_ARCHIVE_POLYMORPHIC_OARCHIVE_HPP\n\n// MS compatible compilers support #pragma once\n#if defined(_MSC_VER)\n# pragma once\n#endif\n\n/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8\n// polymorphic_oarchive.hpp\n\n// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .\n// Use, modification and distribution is subject to the Boost Software\n// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at\n// http://www.boost.org/LICENSE_1_0.txt)\n\n// See http://www.boost.org for updates, documentation, and revision history.\n\n#include // size_t\n#include // ULONG_MAX\n#include \n\n#include \n#if defined(BOOST_NO_STDC_NAMESPACE)\nnamespace std{\n using ::size_t;\n} // namespace std\n#endif\n\n#include \n#include \n#include \n#include \n#include \n\n#include \n#include // must be the last header\n\nnamespace boost {\nnamespace serialization {\n class extended_type_info;\n} // namespace serialization\nnamespace archive {\nnamespace detail {\n class basic_oarchive;\n class basic_oserializer;\n}\n\nclass polymorphic_oarchive;\n\nclass BOOST_SYMBOL_VISIBLE polymorphic_oarchive_impl :\n public detail::interface_oarchive\n{\n#ifdef BOOST_NO_MEMBER_TEMPLATE_FRIENDS\npublic:\n#else\n friend class detail::interface_oarchive;\n friend class save_access;\n#endif\n // primitive types the only ones permitted by polymorphic archives\n virtual void save(const bool t) = 0;\n\n virtual void save(const char t) = 0;\n virtual void save(const signed char t) = 0;\n virtual void save(const unsigned char t) = 0;\n #ifndef BOOST_NO_CWCHAR\n #ifndef BOOST_NO_INTRINSIC_WCHAR_T\n virtual void save(const wchar_t t) = 0;\n #endif\n #endif\n virtual void save(const short t) = 0;\n virtual void save(const unsigned short t) = 0;\n virtual void save(const int t) = 0;\n virtual void save(const unsigned int t) = 0;\n virtual void save(const long t) = 0;\n virtual void save(const unsigned long t) = 0;\n\n #if defined(BOOST_HAS_LONG_LONG)\n virtual void save(const boost::long_long_type t) = 0;\n virtual void save(const boost::ulong_long_type t) = 0;\n #elif defined(BOOST_HAS_MS_INT64)\n virtual void save(const __int64 t) = 0;\n virtual void save(const unsigned __int64 t) = 0;\n #endif\n\n virtual void save(const float t) = 0;\n virtual void save(const double t) = 0;\n\n // string types are treated as primitives\n virtual void save(const std::string & t) = 0;\n #ifndef BOOST_NO_STD_WSTRING\n virtual void save(const std::wstring & t) = 0;\n #endif\n\n virtual void save_null_pointer() = 0;\n // used for xml and other tagged formats\n virtual void save_start(const char * name) = 0;\n virtual void save_end(const char * name) = 0;\n virtual void register_basic_serializer(const detail::basic_oserializer & bos) = 0;\n virtual detail::helper_collection & get_helper_collection() = 0;\n\n virtual void end_preamble() = 0;\n\n // msvc and borland won't automatically pass these to the base class so\n // make it explicit here\n template\n void save_override(T & t)\n {\n archive::save(* this->This(), t);\n }\n // special treatment for name-value pairs.\n template\n void save_override(\n const ::boost::serialization::nvp< T > & t\n ){\n save_start(t.name());\n archive::save(* this->This(), t.const_value());\n save_end(t.name());\n }\nprotected:\n virtual ~polymorphic_oarchive_impl() {}\npublic:\n // utility functions implemented by all legal archives\n virtual unsigned int get_flags() const = 0;\n virtual boost::serialization::library_version_type get_library_version() const = 0;\n virtual void save_binary(const void * t, std::size_t size) = 0;\n\n virtual void save_object(\n const void *x,\n const detail::basic_oserializer & bos\n ) = 0;\n virtual void save_pointer(\n const void * t,\n const detail::basic_pointer_oserializer * bpos_ptr\n ) = 0;\n};\n\n// note: preserve naming symmetry\nclass BOOST_SYMBOL_VISIBLE polymorphic_oarchive :\n public polymorphic_oarchive_impl\n{\npublic:\n ~polymorphic_oarchive() BOOST_OVERRIDE {}\n};\n\n} // namespace archive\n} // namespace boost\n\n// required by export\nBOOST_SERIALIZATION_REGISTER_ARCHIVE(boost::archive::polymorphic_oarchive)\n\n#include // pops abi_suffix.hpp pragmas\n\n#endif // BOOST_ARCHIVE_POLYMORPHIC_OARCHIVE_HPP\n" }, { "path": "include/boost/archive/polymorphic_text_iarchive.hpp", "content": "#ifndef BOOST_ARCHIVE_POLYMORPHIC_TEXT_IARCHIVE_HPP\n#define BOOST_ARCHIVE_POLYMORPHIC_TEXT_IARCHIVE_HPP\n\n// MS compatible compilers support #pragma once\n#if defined(_MSC_VER)\n# pragma once\n#endif\n\n/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8\n// polymorphic_text_iarchive.hpp\n\n// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .\n// Use, modification and distribution is subject to the Boost Software\n// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at\n// http://www.boost.org/LICENSE_1_0.txt)\n\n// See http://www.boost.org for updates, documentation, and revision history.\n\n#include \n#include \n#include \n\n#ifdef BOOST_MSVC\n# pragma warning(push)\n# pragma warning(disable : 4511 4512)\n#endif\n\nnamespace boost {\nnamespace archive {\n\nclass BOOST_SYMBOL_VISIBLE polymorphic_text_iarchive :\n public detail::polymorphic_iarchive_route\n{\npublic:\n polymorphic_text_iarchive(std::istream & is, unsigned int flags = 0) :\n detail::polymorphic_iarchive_route(is, flags)\n {}\n ~polymorphic_text_iarchive() BOOST_OVERRIDE {}\n};\n\n} // namespace archive\n} // namespace boost\n\n#ifdef BOOST_MSVC\n#pragma warning(pop)\n#endif\n\n// required by export\nBOOST_SERIALIZATION_REGISTER_ARCHIVE(\n boost::archive::polymorphic_text_iarchive\n)\n\n#endif // BOOST_ARCHIVE_POLYMORPHIC_TEXT_IARCHIVE_HPP\n" }, { "path": "include/boost/archive/polymorphic_text_oarchive.hpp", "content": "#ifndef BOOST_ARCHIVE_POLYMORPHIC_TEXT_OARCHIVE_HPP\n#define BOOST_ARCHIVE_POLYMORPHIC_TEXT_OARCHIVE_HPP\n\n// MS compatible compilers support #pragma once\n#if defined(_MSC_VER)\n# pragma once\n#endif\n\n/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8\n// polymorphic_text_oarchive.hpp\n\n// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .\n// Use, modification and distribution is subject to the Boost Software\n// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at\n// http://www.boost.org/LICENSE_1_0.txt)\n\n// See http://www.boost.org for updates, documentation, and revision history.\n\n#include \n#include \n#include \n\nnamespace boost {\nnamespace archive {\n\nclass BOOST_SYMBOL_VISIBLE polymorphic_text_oarchive :\n public detail::polymorphic_oarchive_route\n{\npublic:\n polymorphic_text_oarchive(std::ostream & os, unsigned int flags = 0) :\n detail::polymorphic_oarchive_route(os, flags)\n {}\n ~polymorphic_text_oarchive() BOOST_OVERRIDE {}\n};\n\n} // namespace archive\n} // namespace boost\n\n// required by export\nBOOST_SERIALIZATION_REGISTER_ARCHIVE(\n boost::archive::polymorphic_text_oarchive\n)\n\n#endif // BOOST_ARCHIVE_POLYMORPHIC_TEXT_OARCHIVE_HPP\n" }, { "path": "include/boost/archive/polymorphic_text_wiarchive.hpp", "content": "#ifndef BOOST_ARCHIVE_POLYMORPHIC_TEXT_WIARCHIVE_HPP\n#define BOOST_ARCHIVE_POLYMORPHIC_TEXT_WIARCHIVE_HPP\n\n// MS compatible compilers support #pragma once\n#if defined(_MSC_VER)\n# pragma once\n#endif\n\n/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8\n// polymorphic_text_wiarchive.hpp\n\n// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .\n// Use, modification and distribution is subject to the Boost Software\n// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at\n// http://www.boost.org/LICENSE_1_0.txt)\n\n// See http://www.boost.org for updates, documentation, and revision history.\n\n#include \n#ifdef BOOST_NO_STD_WSTREAMBUF\n#error \"wide char i/o not supported on this platform\"\n#else\n\n#include \n#include \n\n#ifdef BOOST_MSVC\n# pragma warning(push)\n# pragma warning(disable : 4511 4512)\n#endif\n\nnamespace boost {\nnamespace archive {\n\nclass BOOST_SYMBOL_VISIBLE polymorphic_text_wiarchive :\n public detail::polymorphic_iarchive_route\n{\npublic:\n polymorphic_text_wiarchive(std::wistream & is, unsigned int flags = 0) :\n detail::polymorphic_iarchive_route(is, flags)\n {}\n ~polymorphic_text_wiarchive() BOOST_OVERRIDE {}\n};\n\n} // namespace archive\n} // namespace boost\n\n#ifdef BOOST_MSVC\n#pragma warning(pop)\n#endif\n\n// required by export\nBOOST_SERIALIZATION_REGISTER_ARCHIVE(\n boost::archive::polymorphic_text_wiarchive\n)\n\n#endif // BOOST_NO_STD_WSTREAMBUF\n#endif // BOOST_ARCHIVE_POLYMORPHIC_TEXT_WIARCHIVE_HPP\n" }, { "path": "include/boost/archive/polymorphic_text_woarchive.hpp", "content": "#ifndef BOOST_ARCHIVE_POLYMORPHIC_TEXT_WOARCHIVE_HPP\n#define BOOST_ARCHIVE_POLYMORPHIC_TEXT_WOARCHIVE_HPP\n\n// MS compatible compilers support #pragma once\n#if defined(_MSC_VER)\n# pragma once\n#endif\n\n/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8\n// polymorphic_text_oarchive.hpp\n\n// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .\n// Use, modification and distribution is subject to the Boost Software\n// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at\n// http://www.boost.org/LICENSE_1_0.txt)\n\n// See http://www.boost.org for updates, documentation, and revision history.\n\n#include \n#ifdef BOOST_NO_STD_WSTREAMBUF\n#error \"wide char i/o not supported on this platform\"\n#else\n\n#include \n#include \n\nnamespace boost {\nnamespace archive {\n\nclass BOOST_SYMBOL_VISIBLE polymorphic_text_woarchive :\n public detail::polymorphic_oarchive_route\n{\npublic:\n polymorphic_text_woarchive(std::wostream & os, unsigned int flags = 0) :\n detail::polymorphic_oarchive_route(os, flags)\n {}\n ~polymorphic_text_woarchive() BOOST_OVERRIDE {}\n};\n\n} // namespace archive\n} // namespace boost\n\n// required by export\nBOOST_SERIALIZATION_REGISTER_ARCHIVE(\n boost::archive::polymorphic_text_woarchive\n)\n\n#endif // BOOST_NO_STD_WSTREAMBUF\n#endif // BOOST_ARCHIVE_POLYMORPHIC_TEXT_WOARCHIVE_HPP\n" }, { "path": "include/boost/archive/polymorphic_xml_iarchive.hpp", "content": "#ifndef BOOST_ARCHIVE_POLYMORPHIC_XML_IARCHIVE_HPP\n#define BOOST_ARCHIVE_POLYMORPHIC_XML_IARCHIVE_HPP\n\n// MS compatible compilers support #pragma once\n#if defined(_MSC_VER)\n# pragma once\n#endif\n\n/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8\n// polymorphic_xml_iarchive.hpp\n\n// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .\n// Use, modification and distribution is subject to the Boost Software\n// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at\n// http://www.boost.org/LICENSE_1_0.txt)\n\n// See http://www.boost.org for updates, documentation, and revision history.\n\n#include \n#include \n#include \n\n#ifdef BOOST_MSVC\n# pragma warning(push)\n# pragma warning(disable : 4511 4512)\n#endif\n\nnamespace boost {\nnamespace archive {\n\nclass BOOST_SYMBOL_VISIBLE polymorphic_xml_iarchive :\n public detail::polymorphic_iarchive_route\n{\npublic:\n polymorphic_xml_iarchive(std::istream & is, unsigned int flags = 0) :\n detail::polymorphic_iarchive_route(is, flags)\n {}\n ~polymorphic_xml_iarchive() BOOST_OVERRIDE {}\n};\n\n} // namespace archive\n} // namespace boost\n\n#ifdef BOOST_MSVC\n#pragma warning(pop)\n#endif\n\n// required by export\nBOOST_SERIALIZATION_REGISTER_ARCHIVE(\n boost::archive::polymorphic_xml_iarchive\n)\n\n#endif // BOOST_ARCHIVE_POLYMORPHIC_XML_IARCHIVE_HPP\n" }, { "path": "include/boost/archive/polymorphic_xml_oarchive.hpp", "content": "#ifndef BOOST_ARCHIVE_POLYMORPHIC_XML_OARCHIVE_HPP\n#define BOOST_ARCHIVE_POLYMORPHIC_XML_OARCHIVE_HPP\n\n// MS compatible compilers support #pragma once\n#if defined(_MSC_VER)\n# pragma once\n#endif\n\n/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8\n// polymorphic_xml_oarchive.hpp\n\n// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .\n// Use, modification and distribution is subject to the Boost Software\n// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at\n// http://www.boost.org/LICENSE_1_0.txt)\n\n// See http://www.boost.org for updates, documentation, and revision history.\n\n#include \n#include \n#include \n\nnamespace boost {\nnamespace archive {\n\nclass BOOST_SYMBOL_VISIBLE polymorphic_xml_oarchive :\n public detail::polymorphic_oarchive_route\n{\npublic:\n polymorphic_xml_oarchive(std::ostream & os, unsigned int flags = 0) :\n detail::polymorphic_oarchive_route(os, flags)\n {}\n ~polymorphic_xml_oarchive() BOOST_OVERRIDE {}\n};\n} // namespace archive\n} // namespace boost\n\n// required by export\nBOOST_SERIALIZATION_REGISTER_ARCHIVE(\n boost::archive::polymorphic_xml_oarchive\n)\n\n#endif // BOOST_ARCHIVE_POLYMORPHIC_XML_OARCHIVE_HPP\n" }, { "path": "include/boost/archive/polymorphic_xml_wiarchive.hpp", "content": "#ifndef BOOST_ARCHIVE_POLYMORPHIC_XML_WIARCHIVE_HPP\n#define BOOST_ARCHIVE_POLYMORPHIC_XML_WIARCHIVE_HPP\n\n// MS compatible compilers support #pragma once\n#if defined(_MSC_VER)\n# pragma once\n#endif\n\n/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8\n// polymorphic_xml_wiarchive.hpp\n\n// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .\n// Use, modification and distribution is subject to the Boost Software\n// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at\n// http://www.boost.org/LICENSE_1_0.txt)\n\n// See http://www.boost.org for updates, documentation, and revision history.\n\n#include \n#ifdef BOOST_NO_STD_WSTREAMBUF\n#error \"wide char i/o not supported on this platform\"\n#else\n\n#include \n#include \n\nnamespace boost {\nnamespace archive {\n\nclass BOOST_SYMBOL_VISIBLE polymorphic_xml_wiarchive :\n public detail::polymorphic_iarchive_route\n{\npublic:\n polymorphic_xml_wiarchive(std::wistream & is, unsigned int flags = 0) :\n detail::polymorphic_iarchive_route(is, flags)\n {}\n ~polymorphic_xml_wiarchive() BOOST_OVERRIDE {}\n};\n\n} // namespace archive\n} // namespace boost\n\n// required by export\nBOOST_SERIALIZATION_REGISTER_ARCHIVE(\n boost::archive::polymorphic_xml_wiarchive\n)\n\n#endif // BOOST_NO_STD_WSTREAMBUF\n#endif // BOOST_ARCHIVE_POLYMORPHIC_XML_WIARCHIVE_HPP\n" }, { "path": "include/boost/archive/polymorphic_xml_woarchive.hpp", "content": "#ifndef BOOST_ARCHIVE_POLYMORPHIC_XML_WOARCHIVE_HPP\n#define BOOST_ARCHIVE_POLYMORPHIC_XML_WOARCHIVE_HPP\n\n// MS compatible compilers support #pragma once\n#if defined(_MSC_VER)\n# pragma once\n#endif\n\n/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8\n// polymorphic_xml_woarchive.hpp\n\n// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .\n// Use, modification and distribution is subject to the Boost Software\n// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at\n// http://www.boost.org/LICENSE_1_0.txt)\n\n// See http://www.boost.org for updates, documentation, and revision history.\n\n#include \n#ifdef BOOST_NO_STD_WSTREAMBUF\n#error \"wide char i/o not supported on this platform\"\n#else\n\n#include \n#include \n\nnamespace boost {\nnamespace archive {\n\nclass BOOST_SYMBOL_VISIBLE polymorphic_xml_woarchive :\n public detail::polymorphic_oarchive_route\n{\npublic:\n polymorphic_xml_woarchive(std::wostream & os, unsigned int flags = 0) :\n detail::polymorphic_oarchive_route(os, flags)\n {}\n ~polymorphic_xml_woarchive() BOOST_OVERRIDE {}\n};\n\n} // namespace archive\n} // namespace boost\n\n// required by export\nBOOST_SERIALIZATION_REGISTER_ARCHIVE(\n boost::archive::polymorphic_xml_woarchive\n)\n\n#endif // BOOST_NO_STD_WSTREAMBUF\n#endif // BOOST_ARCHIVE_POLYMORPHIC_XML_WOARCHIVE_HPP\n" }, { "path": "include/boost/archive/text_iarchive.hpp", "content": "#ifndef BOOST_ARCHIVE_TEXT_IARCHIVE_HPP\n#define BOOST_ARCHIVE_TEXT_IARCHIVE_HPP\n\n// MS compatible compilers support #pragma once\n#if defined(_MSC_VER)\n# pragma once\n#endif\n\n/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8\n// text_iarchive.hpp\n\n// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .\n// Use, modification and distribution is subject to the Boost Software\n// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at\n// http://www.boost.org/LICENSE_1_0.txt)\n\n// See http://www.boost.org for updates, documentation, and revision history.\n\n#include \n\n#include \n#include \n#include \n#include \n#include \n#include \n\n#include // must be the last header\n\n#ifdef BOOST_MSVC\n# pragma warning(push)\n# pragma warning(disable : 4511 4512)\n#endif\n\nnamespace boost {\nnamespace archive {\n\nnamespace detail {\n template class interface_iarchive;\n} // namespace detail\n\ntemplate\nclass BOOST_SYMBOL_VISIBLE text_iarchive_impl :\n public basic_text_iprimitive,\n public basic_text_iarchive\n{\n#ifdef BOOST_NO_MEMBER_TEMPLATE_FRIENDS\npublic:\n#else\nprotected:\n friend class detail::interface_iarchive;\n friend class load_access;\n#endif\n template\n void load(T & t){\n basic_text_iprimitive::load(t);\n }\n void load(version_type & t){\n unsigned int v;\n load(v);\n t = version_type(v);\n }\n void load(boost::serialization::item_version_type & t){\n unsigned int v;\n load(v);\n t = boost::serialization::item_version_type(v);\n }\n BOOST_ARCHIVE_DECL void\n load(char * t);\n #ifndef BOOST_NO_INTRINSIC_WCHAR_T\n BOOST_ARCHIVE_DECL void\n load(wchar_t * t);\n #endif\n BOOST_ARCHIVE_DECL void\n load(std::string &s);\n #ifndef BOOST_NO_STD_WSTRING\n BOOST_ARCHIVE_DECL void\n load(std::wstring &ws);\n #endif\n template\n void load_override(T & t){\n basic_text_iarchive::load_override(t);\n }\n BOOST_ARCHIVE_DECL void\n load_override(class_name_type & t);\n BOOST_ARCHIVE_DECL void\n init();\n BOOST_ARCHIVE_DECL\n text_iarchive_impl(std::istream & is, unsigned int flags);\n // don't import inline definitions! leave this as a reminder.\n //BOOST_ARCHIVE_DECL\n ~text_iarchive_impl() BOOST_OVERRIDE {}\n};\n\n} // namespace archive\n} // namespace boost\n\n#ifdef BOOST_MSVC\n#pragma warning(pop)\n#endif\n\n#include // pops abi_suffix.hpp pragmas\n\n#ifdef BOOST_MSVC\n# pragma warning(push)\n# pragma warning(disable : 4511 4512)\n#endif\n\nnamespace boost {\nnamespace archive {\n\nclass BOOST_SYMBOL_VISIBLE text_iarchive :\n public text_iarchive_impl{\npublic:\n text_iarchive(std::istream & is_, unsigned int flags = 0) :\n // note: added _ to suppress useless gcc warning\n text_iarchive_impl(is_, flags)\n {\n if(0 == (flags & no_header))\n init();\n }\n ~text_iarchive() BOOST_OVERRIDE {}\n};\n\n} // namespace archive\n} // namespace boost\n\n// required by export\nBOOST_SERIALIZATION_REGISTER_ARCHIVE(boost::archive::text_iarchive)\n\n#ifdef BOOST_MSVC\n#pragma warning(pop)\n#endif\n\n#endif // BOOST_ARCHIVE_TEXT_IARCHIVE_HPP\n" }, { "path": "include/boost/archive/text_oarchive.hpp", "content": "#ifndef BOOST_ARCHIVE_TEXT_OARCHIVE_HPP\n#define BOOST_ARCHIVE_TEXT_OARCHIVE_HPP\n\n// MS compatible compilers support #pragma once\n#if defined(_MSC_VER)\n# pragma once\n#endif\n\n/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8\n// text_oarchive.hpp\n\n// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .\n// Use, modification and distribution is subject to the Boost Software\n// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at\n// http://www.boost.org/LICENSE_1_0.txt)\n\n// See http://www.boost.org for updates, documentation, and revision history.\n\n#include \n#include // std::size_t\n\n#include \n#if defined(BOOST_NO_STDC_NAMESPACE)\nnamespace std{\n using ::size_t;\n} // namespace std\n#endif\n\n#include \n#include \n#include \n#include \n#include \n\n#include // must be the last header\n\n#ifdef BOOST_MSVC\n# pragma warning(push)\n# pragma warning(disable : 4511 4512)\n#endif\n\nnamespace boost {\nnamespace archive {\n\nnamespace detail {\n template class interface_oarchive;\n} // namespace detail\n\ntemplate\nclass BOOST_SYMBOL_VISIBLE text_oarchive_impl :\n /* protected ? */ public basic_text_oprimitive,\n public basic_text_oarchive\n{\n#ifdef BOOST_NO_MEMBER_TEMPLATE_FRIENDS\npublic:\n#else\nprotected:\n friend class detail::interface_oarchive;\n friend class basic_text_oarchive;\n friend class save_access;\n#endif\n template\n void save(const T & t){\n this->newtoken();\n basic_text_oprimitive::save(t);\n }\n void save(const version_type & t){\n save(static_cast(t));\n }\n void save(const boost::serialization::item_version_type & t){\n save(static_cast(t));\n }\n BOOST_ARCHIVE_DECL void\n save(const char * t);\n #ifndef BOOST_NO_INTRINSIC_WCHAR_T\n BOOST_ARCHIVE_DECL void\n save(const wchar_t * t);\n #endif\n BOOST_ARCHIVE_DECL void\n save(const std::string &s);\n #ifndef BOOST_NO_STD_WSTRING\n BOOST_ARCHIVE_DECL void\n save(const std::wstring &ws);\n #endif\n BOOST_ARCHIVE_DECL\n text_oarchive_impl(std::ostream & os, unsigned int flags);\n // don't import inline definitions! leave this as a reminder.\n //BOOST_ARCHIVE_DECL\n ~text_oarchive_impl() BOOST_OVERRIDE {}\npublic:\n BOOST_ARCHIVE_DECL void\n save_binary(const void *address, std::size_t count);\n};\n\n// do not derive from this class. If you want to extend this functionality\n// via inheritance, derived from text_oarchive_impl instead. This will\n// preserve correct static polymorphism.\nclass BOOST_SYMBOL_VISIBLE text_oarchive :\n public text_oarchive_impl\n{\npublic:\n text_oarchive(std::ostream & os_, unsigned int flags = 0) :\n // note: added _ to suppress useless gcc warning\n text_oarchive_impl(os_, flags)\n {\n if(0 == (flags & no_header))\n init();\n }\n ~text_oarchive() BOOST_OVERRIDE {}\n};\n\n} // namespace archive\n} // namespace boost\n\n// required by export\nBOOST_SERIALIZATION_REGISTER_ARCHIVE(boost::archive::text_oarchive)\n\n#ifdef BOOST_MSVC\n#pragma warning(pop)\n#endif\n\n#include // pops abi_suffix.hpp pragmas\n\n#endif // BOOST_ARCHIVE_TEXT_OARCHIVE_HPP\n" }, { "path": "include/boost/archive/text_wiarchive.hpp", "content": "#ifndef BOOST_ARCHIVE_TEXT_WIARCHIVE_HPP\n#define BOOST_ARCHIVE_TEXT_WIARCHIVE_HPP\n\n// MS compatible compilers support #pragma once\n#if defined(_MSC_VER)\n# pragma once\n#endif\n\n/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8\n// text_wiarchive.hpp\n\n// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .\n// Use, modification and distribution is subject to the Boost Software\n// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at\n// http://www.boost.org/LICENSE_1_0.txt)\n\n// See http://www.boost.org for updates, documentation, and revision history.\n\n#include \n#ifdef BOOST_NO_STD_WSTREAMBUF\n#error \"wide char i/o not supported on this platform\"\n#else\n\n#include \n\n#include \n#include \n#include \n#include \n#include \n\n#include // must be the last header\n\n#ifdef BOOST_MSVC\n# pragma warning(push)\n# pragma warning(disable : 4511 4512)\n#endif\n\nnamespace boost {\nnamespace archive {\n\nnamespace detail {\n template class interface_iarchive;\n} // namespace detail\n\ntemplate\nclass BOOST_SYMBOL_VISIBLE text_wiarchive_impl :\n public basic_text_iprimitive,\n public basic_text_iarchive\n{\n#ifdef BOOST_NO_MEMBER_TEMPLATE_FRIENDS\npublic:\n#else\nprotected:\n #if BOOST_WORKAROUND(BOOST_MSVC, < 1500)\n // for some inexplicable reason insertion of \"class\" generates compile erro\n // on msvc 7.1\n friend detail::interface_iarchive;\n friend load_access;\n #else\n friend class detail::interface_iarchive;\n friend class load_access;\n #endif\n#endif\n template\n void load(T & t){\n basic_text_iprimitive::load(t);\n }\n void load(version_type & t){\n unsigned int v;\n load(v);\n t = version_type(v);\n }\n void load(boost::serialization::item_version_type & t){\n unsigned int v;\n load(v);\n t = boost::serialization::item_version_type(v);\n }\n BOOST_WARCHIVE_DECL void\n load(char * t);\n #ifndef BOOST_NO_INTRINSIC_WCHAR_T\n BOOST_WARCHIVE_DECL void\n load(wchar_t * t);\n #endif\n BOOST_WARCHIVE_DECL void\n load(std::string &s);\n #ifndef BOOST_NO_STD_WSTRING\n BOOST_WARCHIVE_DECL void\n load(std::wstring &ws);\n #endif\n template\n void load_override(T & t){\n basic_text_iarchive::load_override(t);\n }\n BOOST_WARCHIVE_DECL\n text_wiarchive_impl(std::wistream & is, unsigned int flags);\n ~text_wiarchive_impl() BOOST_OVERRIDE {}\n};\n\n} // namespace archive\n} // namespace boost\n\n#ifdef BOOST_MSVC\n#pragma warning(pop)\n#endif\n\n#include // pops abi_suffix.hpp pragmas\n\n#ifdef BOOST_MSVC\n# pragma warning(push)\n# pragma warning(disable : 4511 4512)\n#endif\n\nnamespace boost {\nnamespace archive {\n\nclass BOOST_SYMBOL_VISIBLE text_wiarchive :\n public text_wiarchive_impl{\npublic:\n text_wiarchive(std::wistream & is, unsigned int flags = 0) :\n text_wiarchive_impl(is, flags)\n {\n if(0 == (flags & no_header))\n init();\n }\n ~text_wiarchive() BOOST_OVERRIDE {}\n};\n\n} // namespace archive\n} // namespace boost\n\n// required by export\nBOOST_SERIALIZATION_REGISTER_ARCHIVE(boost::archive::text_wiarchive)\n\n#ifdef BOOST_MSVC\n#pragma warning(pop)\n#endif\n\n#endif // BOOST_NO_STD_WSTREAMBUF\n#endif // BOOST_ARCHIVE_TEXT_WIARCHIVE_HPP\n" }, { "path": "include/boost/archive/text_woarchive.hpp", "content": "#ifndef BOOST_ARCHIVE_TEXT_WOARCHIVE_HPP\n#define BOOST_ARCHIVE_TEXT_WOARCHIVE_HPP\n\n// MS compatible compilers support #pragma once\n#if defined(_MSC_VER)\n# pragma once\n#endif\n\n/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8\n// text_woarchive.hpp\n\n// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .\n// Use, modification and distribution is subject to the Boost Software\n// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at\n// http://www.boost.org/LICENSE_1_0.txt)\n\n// See http://www.boost.org for updates, documentation, and revision history.\n\n#include \n\n#ifdef BOOST_NO_STD_WSTREAMBUF\n#error \"wide char i/o not supported on this platform\"\n#else\n\n#include \n#include // size_t\n\n#if defined(BOOST_NO_STDC_NAMESPACE)\nnamespace std{\n using ::size_t;\n} // namespace std\n#endif\n\n#include \n#include \n#include \n#include \n#include \n\n#include // must be the last header\n\n#ifdef BOOST_MSVC\n# pragma warning(push)\n# pragma warning(disable : 4511 4512)\n#endif\n\nnamespace boost {\nnamespace archive {\n\nnamespace detail {\n template class interface_oarchive;\n} // namespace detail\n\ntemplate\nclass BOOST_SYMBOL_VISIBLE text_woarchive_impl :\n public basic_text_oprimitive,\n public basic_text_oarchive\n{\n#ifdef BOOST_NO_MEMBER_TEMPLATE_FRIENDS\npublic:\n#else\nprotected:\n #if BOOST_WORKAROUND(BOOST_MSVC, < 1500)\n // for some inexplicable reason insertion of \"class\" generates compile erro\n // on msvc 7.1\n friend detail::interface_oarchive;\n friend basic_text_oarchive;\n friend save_access;\n #else\n friend class detail::interface_oarchive;\n friend class basic_text_oarchive;\n friend class save_access;\n #endif\n#endif\n template\n void save(const T & t){\n this->newtoken();\n basic_text_oprimitive::save(t);\n }\n void save(const version_type & t){\n save(static_cast(t));\n }\n void save(const boost::serialization::item_version_type & t){\n save(static_cast(t));\n }\n BOOST_WARCHIVE_DECL void\n save(const char * t);\n #ifndef BOOST_NO_INTRINSIC_WCHAR_T\n BOOST_WARCHIVE_DECL void\n save(const wchar_t * t);\n #endif\n BOOST_WARCHIVE_DECL void\n save(const std::string &s);\n #ifndef BOOST_NO_STD_WSTRING\n BOOST_WARCHIVE_DECL void\n save(const std::wstring &ws);\n #endif\n text_woarchive_impl(std::wostream & os, unsigned int flags) :\n basic_text_oprimitive(\n os,\n 0 != (flags & no_codecvt)\n ),\n basic_text_oarchive(flags)\n {}\npublic:\n void save_binary(const void *address, std::size_t count){\n put(static_cast('\\n'));\n this->end_preamble();\n #if ! defined(__MWERKS__)\n this->basic_text_oprimitive::save_binary(\n #else\n this->basic_text_oprimitive::save_binary(\n #endif\n address,\n count\n );\n put(static_cast('\\n'));\n this->delimiter = this->none;\n }\n\n};\n\n// we use the following because we can't use\n// typedef text_oarchive_impl > text_oarchive;\n\n// do not derive from this class. If you want to extend this functionality\n// via inheritance, derived from text_oarchive_impl instead. This will\n// preserve correct static polymorphism.\nclass BOOST_SYMBOL_VISIBLE text_woarchive :\n public text_woarchive_impl\n{\npublic:\n text_woarchive(std::wostream & os, unsigned int flags = 0) :\n text_woarchive_impl(os, flags)\n {\n if(0 == (flags & no_header))\n init();\n }\n ~text_woarchive() BOOST_OVERRIDE {}\n};\n\n} // namespace archive\n} // namespace boost\n\n// required by export\nBOOST_SERIALIZATION_REGISTER_ARCHIVE(boost::archive::text_woarchive)\n\n#ifdef BOOST_MSVC\n#pragma warning(pop)\n#endif\n\n#include // pops abi_suffix.hpp pragmas\n\n#endif // BOOST_NO_STD_WSTREAMBUF\n#endif // BOOST_ARCHIVE_TEXT_WOARCHIVE_HPP\n" }, { "path": "include/boost/archive/tmpdir.hpp", "content": "#ifndef BOOST_ARCHIVE_TMPDIR_HPP\n#define BOOST_ARCHIVE_TMPDIR_HPP\n\n// MS compatible compilers support #pragma once\n#if defined(_MSC_VER)\n# pragma once\n#endif\n\n/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8\n// tmpdir.hpp:\n\n// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .\n// Use, modification and distribution is subject to the Boost Software\n// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at\n// http://www.boost.org/LICENSE_1_0.txt)\n\n// See http://www.boost.org for updates, documentation, and revision history.\n\n#include // getenv\n#include // NULL\n\n#include \n#ifdef BOOST_NO_STDC_NAMESPACE\nnamespace std {\n using ::getenv;\n}\n#endif\n\nnamespace boost {\nnamespace archive {\n\ninline const char * tmpdir(){\n const char *dirname;\n dirname = std::getenv(\"TMP\");\n if(NULL == dirname)\n dirname = std::getenv(\"TMPDIR\");\n if(NULL == dirname)\n dirname = std::getenv(\"TEMP\");\n if(NULL == dirname){\n //BOOST_ASSERT(false); // no temp directory found\n dirname = \".\";\n }\n return dirname;\n}\n\n} // archive\n} // boost\n\n#endif // BOOST_ARCHIVE_TMPDIR_HPP\n" }, { "path": "include/boost/archive/wcslen.hpp", "content": "#ifndef BOOST_ARCHIVE_WCSLEN_HPP\n#define BOOST_ARCHIVE_WCSLEN_HPP\n\n// MS compatible compilers support #pragma once\n#if defined(_MSC_VER)\n# pragma once\n#endif\n\n/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8\n// wcslen.hpp:\n\n// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .\n// Use, modification and distribution is subject to the Boost Software\n// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at\n// http://www.boost.org/LICENSE_1_0.txt)\n\n// See http://www.boost.org for updates, documentation, and revision history.\n\n#include // size_t\n#include \n#if defined(BOOST_NO_STDC_NAMESPACE)\nnamespace std{\n using ::size_t;\n} // namespace std\n#endif\n\n#ifndef BOOST_NO_CWCHAR\n\n// a couple of libraries which include wchar_t don't include\n// wcslen\n\n#if defined(BOOST_DINKUMWARE_STDLIB) && BOOST_DINKUMWARE_STDLIB < 306 \\\n|| defined(__LIBCOMO__)\n\nnamespace std {\ninline std::size_t wcslen(const wchar_t * ws)\n{\n const wchar_t * eows = ws;\n while(* eows != 0)\n ++eows;\n return eows - ws;\n}\n} // namespace std\n\n#else\n\n#ifndef BOOST_NO_CWCHAR\n#include \n#endif\n#ifdef BOOST_NO_STDC_NAMESPACE\nnamespace std{ using ::wcslen; }\n#endif\n\n#endif // wcslen\n\n#endif //BOOST_NO_CWCHAR\n\n#endif //BOOST_ARCHIVE_WCSLEN_HPP\n" }, { "path": "include/boost/archive/xml_archive_exception.hpp", "content": "#ifndef BOOST_ARCHIVE_XML_ARCHIVE_EXCEPTION_HPP\n#define BOOST_ARCHIVE_XML_ARCHIVE_EXCEPTION_HPP\n\n// MS compatible compilers support #pragma once\n#if defined(_MSC_VER)\n# pragma once\n#endif\n\n/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8\n// xml_archive_exception.hpp:\n\n// (C) Copyright 2007 Robert Ramey - http://www.rrsd.com .\n// Use, modification and distribution is subject to the Boost Software\n// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at\n// http://www.boost.org/LICENSE_1_0.txt)\n\n// See http://www.boost.org for updates, documentation, and revision history.\n\n#include \n#include \n\n#include \n#include \n#include \n\n#include // must be the last header\n\nnamespace boost {\nnamespace archive {\n\n//////////////////////////////////////////////////////////////////////\n// exceptions thrown by xml archives\n//\nclass BOOST_SYMBOL_VISIBLE xml_archive_exception :\n public virtual boost::archive::archive_exception\n{\npublic:\n typedef enum {\n xml_archive_parsing_error, // see save_register\n xml_archive_tag_mismatch,\n xml_archive_tag_name_error\n } exception_code;\n BOOST_ARCHIVE_DECL xml_archive_exception(\n exception_code c,\n const char * e1 = NULL,\n const char * e2 = NULL\n );\n BOOST_ARCHIVE_DECL xml_archive_exception(xml_archive_exception const &);\n BOOST_ARCHIVE_DECL ~xml_archive_exception() BOOST_NOEXCEPT_OR_NOTHROW BOOST_OVERRIDE;\n};\n\n}// namespace archive\n}// namespace boost\n\n#include // pops abi_suffix.hpp pragmas\n\n#endif //BOOST_XML_ARCHIVE_ARCHIVE_EXCEPTION_HPP\n" }, { "path": "include/boost/archive/xml_iarchive.hpp", "content": "#ifndef BOOST_ARCHIVE_XML_IARCHIVE_HPP\n#define BOOST_ARCHIVE_XML_IARCHIVE_HPP\n\n// MS compatible compilers support #pragma once\n#if defined(_MSC_VER)\n# pragma once\n#endif\n\n/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8\n// xml_iarchive.hpp\n\n// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .\n// Use, modification and distribution is subject to the Boost Software\n// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at\n// http://www.boost.org/LICENSE_1_0.txt)\n\n// See http://www.boost.org for updates, documentation, and revision history.\n\n#include \n\n#include \n#include \n#include \n#include \n#include \n#include \n\n#include // must be the last header\n\n#ifdef BOOST_MSVC\n# pragma warning(push)\n# pragma warning(disable : 4511 4512)\n#endif\n\nnamespace boost {\nnamespace archive {\n\nnamespace detail {\n template class interface_iarchive;\n} // namespace detail\n\ntemplate\nclass basic_xml_grammar;\ntypedef basic_xml_grammar xml_grammar;\n\ntemplate\nclass BOOST_SYMBOL_VISIBLE xml_iarchive_impl :\n public basic_text_iprimitive,\n public basic_xml_iarchive\n{\n#ifdef BOOST_NO_MEMBER_TEMPLATE_FRIENDS\npublic:\n#else\nprotected:\n friend class detail::interface_iarchive;\n friend class basic_xml_iarchive;\n friend class load_access;\n#endif\n // use boost:scoped_ptr to implement automatic deletion;\n boost::scoped_ptr gimpl;\n\n std::istream & get_is(){\n return is;\n }\n template\n void load(T & t){\n basic_text_iprimitive::load(t);\n }\n void\n load(version_type & t){\n unsigned int v;\n load(v);\n t = version_type(v);\n }\n void\n load(boost::serialization::item_version_type & t){\n unsigned int v;\n load(v);\n t = boost::serialization::item_version_type(v);\n }\n BOOST_ARCHIVE_DECL void\n load(char * t);\n #ifndef BOOST_NO_INTRINSIC_WCHAR_T\n BOOST_ARCHIVE_DECL void\n load(wchar_t * t);\n #endif\n BOOST_ARCHIVE_DECL void\n load(std::string &s);\n #ifndef BOOST_NO_STD_WSTRING\n BOOST_ARCHIVE_DECL void\n load(std::wstring &ws);\n #endif\n template\n void load_override(T & t){\n basic_xml_iarchive::load_override(t);\n }\n BOOST_ARCHIVE_DECL void\n load_override(class_name_type & t);\n BOOST_ARCHIVE_DECL void\n init();\n BOOST_ARCHIVE_DECL\n xml_iarchive_impl(std::istream & is, unsigned int flags);\n BOOST_ARCHIVE_DECL\n ~xml_iarchive_impl() BOOST_OVERRIDE;\n};\n\n} // namespace archive\n} // namespace boost\n\n#ifdef BOOST_MSVC\n#pragma warning(pop)\n#endif\n\n#include // pops abi_suffix.hpp pragmas\n#ifdef BOOST_MSVC\n# pragma warning(push)\n# pragma warning(disable : 4511 4512)\n#endif\n\nnamespace boost {\nnamespace archive {\n\nclass BOOST_SYMBOL_VISIBLE xml_iarchive :\n public xml_iarchive_impl{\npublic:\n xml_iarchive(std::istream & is, unsigned int flags = 0) :\n xml_iarchive_impl(is, flags)\n {\n if(0 == (flags & no_header))\n init();\n }\n ~xml_iarchive() BOOST_OVERRIDE {}\n};\n\n} // namespace archive\n} // namespace boost\n\n// required by export\nBOOST_SERIALIZATION_REGISTER_ARCHIVE(boost::archive::xml_iarchive)\n\n#ifdef BOOST_MSVC\n#pragma warning(pop)\n#endif\n\n#endif // BOOST_ARCHIVE_XML_IARCHIVE_HPP\n" }, { "path": "include/boost/archive/xml_oarchive.hpp", "content": "#ifndef BOOST_ARCHIVE_XML_OARCHIVE_HPP\n#define BOOST_ARCHIVE_XML_OARCHIVE_HPP\n\n// MS compatible compilers support #pragma once\n#if defined(_MSC_VER)\n# pragma once\n#endif\n\n/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8\n// xml_oarchive.hpp\n\n// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .\n// Use, modification and distribution is subject to the Boost Software\n// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at\n// http://www.boost.org/LICENSE_1_0.txt)\n\n// See http://www.boost.org for updates, documentation, and revision history.\n\n#include \n\n#include // size_t\n#include \n#if defined(BOOST_NO_STDC_NAMESPACE)\nnamespace std{\n using ::size_t;\n} // namespace std\n#endif\n\n#include \n#include \n#include \n#include \n#include \n\n#include // must be the last header\n\n#ifdef BOOST_MSVC\n# pragma warning(push)\n# pragma warning(disable : 4511 4512)\n#endif\n\nnamespace boost {\nnamespace archive {\n\nnamespace detail {\n template class interface_oarchive;\n} // namespace detail\n\ntemplate\nclass BOOST_SYMBOL_VISIBLE xml_oarchive_impl :\n public basic_text_oprimitive,\n public basic_xml_oarchive\n{\n#ifdef BOOST_NO_MEMBER_TEMPLATE_FRIENDS\npublic:\n#else\nprotected:\n friend class detail::interface_oarchive;\n friend class basic_xml_oarchive;\n friend class save_access;\n#endif\n template\n void save(const T & t){\n basic_text_oprimitive::save(t);\n }\n void\n save(const version_type & t){\n save(static_cast(t));\n }\n void\n save(const boost::serialization::item_version_type & t){\n save(static_cast(t));\n }\n BOOST_ARCHIVE_DECL void\n save(const char * t);\n #ifndef BOOST_NO_INTRINSIC_WCHAR_T\n BOOST_ARCHIVE_DECL void\n save(const wchar_t * t);\n #endif\n BOOST_ARCHIVE_DECL void\n save(const std::string &s);\n #ifndef BOOST_NO_STD_WSTRING\n BOOST_ARCHIVE_DECL void\n save(const std::wstring &ws);\n #endif\n BOOST_ARCHIVE_DECL\n xml_oarchive_impl(std::ostream & os, unsigned int flags);\n BOOST_ARCHIVE_DECL\n ~xml_oarchive_impl() BOOST_OVERRIDE;\npublic:\n BOOST_ARCHIVE_DECL\n void save_binary(const void *address, std::size_t count);\n};\n\n} // namespace archive\n} // namespace boost\n\n#ifdef BOOST_MSVC\n#pragma warning(pop)\n#endif\n\n#include // pops abi_suffix.hpp pragmas\n#ifdef BOOST_MSVC\n# pragma warning(push)\n# pragma warning(disable : 4511 4512)\n#endif\n\nnamespace boost {\nnamespace archive {\n\n// we use the following because we can't use\n// typedef xml_oarchive_impl > xml_oarchive;\n\n// do not derive from this class. If you want to extend this functionality\n// via inheritance, derived from xml_oarchive_impl instead. This will\n// preserve correct static polymorphism.\nclass BOOST_SYMBOL_VISIBLE xml_oarchive :\n public xml_oarchive_impl\n{\npublic:\n xml_oarchive(std::ostream & os, unsigned int flags = 0) :\n xml_oarchive_impl(os, flags)\n {\n if(0 == (flags & no_header))\n init();\n }\n ~xml_oarchive() BOOST_OVERRIDE {}\n};\n\n} // namespace archive\n} // namespace boost\n\n// required by export\nBOOST_SERIALIZATION_REGISTER_ARCHIVE(boost::archive::xml_oarchive)\n\n#ifdef BOOST_MSVC\n#pragma warning(pop)\n#endif\n\n#endif // BOOST_ARCHIVE_XML_OARCHIVE_HPP\n" }, { "path": "include/boost/archive/xml_wiarchive.hpp", "content": "#ifndef BOOST_ARCHIVE_XML_WIARCHIVE_HPP\n#define BOOST_ARCHIVE_XML_WIARCHIVE_HPP\n\n// MS compatible compilers support #pragma once\n#if defined(_MSC_VER)\n# pragma once\n#endif\n\n/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8\n// xml_wiarchive.hpp\n\n// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .\n// Use, modification and distribution is subject to the Boost Software\n// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at\n// http://www.boost.org/LICENSE_1_0.txt)\n\n// See http://www.boost.org for updates, documentation, and revision history.\n\n#include \n#ifdef BOOST_NO_STD_WSTREAMBUF\n#error \"wide char i/o not supported on this platform\"\n#else\n\n#include \n\n#include \n#include \n#include \n#include \n#include \n#include \n\n#include // must be the last header\n\n#ifdef BOOST_MSVC\n# pragma warning(push)\n# pragma warning(disable : 4511 4512)\n#endif\n\nnamespace boost {\nnamespace archive {\n\nnamespace detail {\n template class interface_iarchive;\n} // namespace detail\n\ntemplate\nclass basic_xml_grammar;\ntypedef basic_xml_grammar xml_wgrammar;\n\ntemplate\nclass BOOST_SYMBOL_VISIBLE xml_wiarchive_impl :\n public basic_text_iprimitive,\n public basic_xml_iarchive\n{\n#ifdef BOOST_NO_MEMBER_TEMPLATE_FRIENDS\npublic:\n#else\nprotected:\n friend class detail::interface_iarchive;\n friend class basic_xml_iarchive;\n friend class load_access;\n#endif\n std::locale archive_locale;\n boost::scoped_ptr gimpl;\n std::wistream & get_is(){\n return is;\n }\n template\n void\n load(T & t){\n basic_text_iprimitive::load(t);\n }\n void\n load(version_type & t){\n unsigned int v;\n load(v);\n t = version_type(v);\n }\n void\n load(boost::serialization::item_version_type & t){\n unsigned int v;\n load(v);\n t = boost::serialization::item_version_type(v);\n }\n BOOST_WARCHIVE_DECL void\n load(char * t);\n #ifndef BOOST_NO_INTRINSIC_WCHAR_T\n BOOST_WARCHIVE_DECL void\n load(wchar_t * t);\n #endif\n BOOST_WARCHIVE_DECL void\n load(std::string &s);\n #ifndef BOOST_NO_STD_WSTRING\n BOOST_WARCHIVE_DECL void\n load(std::wstring &ws);\n #endif\n template\n void load_override(T & t){\n basic_xml_iarchive::load_override(t);\n }\n BOOST_WARCHIVE_DECL void\n load_override(class_name_type & t);\n BOOST_WARCHIVE_DECL void\n init();\n BOOST_WARCHIVE_DECL\n xml_wiarchive_impl(std::wistream & is, unsigned int flags);\n BOOST_WARCHIVE_DECL\n ~xml_wiarchive_impl() BOOST_OVERRIDE;\n};\n\n} // namespace archive\n} // namespace boost\n\n#ifdef BOOST_MSVC\n# pragma warning(pop)\n#endif\n\n#include // pops abi_suffix.hpp pragmas\n\n#ifdef BOOST_MSVC\n# pragma warning(push)\n# pragma warning(disable : 4511 4512)\n#endif\n\nnamespace boost {\nnamespace archive {\n\nclass BOOST_SYMBOL_VISIBLE xml_wiarchive :\n public xml_wiarchive_impl{\npublic:\n xml_wiarchive(std::wistream & is, unsigned int flags = 0) :\n xml_wiarchive_impl(is, flags)\n {\n if(0 == (flags & no_header))\n init();\n }\n ~xml_wiarchive() BOOST_OVERRIDE {}\n};\n\n} // namespace archive\n} // namespace boost\n\n// required by export\nBOOST_SERIALIZATION_REGISTER_ARCHIVE(boost::archive::xml_wiarchive)\n\n#ifdef BOOST_MSVC\n#pragma warning(pop)\n#endif\n\n#endif // BOOST_NO_STD_WSTREAMBUF\n#endif // BOOST_ARCHIVE_XML_WIARCHIVE_HPP\n" }, { "path": "include/boost/archive/xml_woarchive.hpp", "content": "#ifndef BOOST_ARCHIVE_XML_WOARCHIVE_HPP\n#define BOOST_ARCHIVE_XML_WOARCHIVE_HPP\n\n// MS compatible compilers support #pragma once\n#if defined(_MSC_VER)\n# pragma once\n#endif\n\n/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8\n// xml_woarchive.hpp\n\n// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .\n// Use, modification and distribution is subject to the Boost Software\n// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at\n// http://www.boost.org/LICENSE_1_0.txt)\n\n// See http://www.boost.org for updates, documentation, and revision history.\n\n#include \n#ifdef BOOST_NO_STD_WSTREAMBUF\n#error \"wide char i/o not supported on this platform\"\n#else\n#include // size_t\n#if defined(BOOST_NO_STDC_NAMESPACE)\nnamespace std{\n using ::size_t;\n} // namespace std\n#endif\n\n#include \n\n#include \n#include \n#include \n#include \n#include \n\n#include // must be the last header\n\n#ifdef BOOST_MSVC\n# pragma warning(push)\n# pragma warning(disable : 4511 4512)\n#endif\n\nnamespace boost {\nnamespace archive {\n\nnamespace detail {\n template class interface_oarchive;\n} // namespace detail\n\ntemplate\nclass BOOST_SYMBOL_VISIBLE xml_woarchive_impl :\n public basic_text_oprimitive,\n public basic_xml_oarchive\n{\n#ifdef BOOST_NO_MEMBER_TEMPLATE_FRIENDS\npublic:\n#else\nprotected:\n friend class detail::interface_oarchive;\n friend class basic_xml_oarchive;\n friend class save_access;\n#endif\n //void end_preamble(){\n // basic_xml_oarchive::end_preamble();\n //}\n template\n void\n save(const T & t){\n basic_text_oprimitive::save(t);\n }\n void\n save(const version_type & t){\n save(static_cast(t));\n }\n void\n save(const boost::serialization::item_version_type & t){\n save(static_cast(t));\n }\n BOOST_WARCHIVE_DECL void\n save(const char * t);\n #ifndef BOOST_NO_INTRINSIC_WCHAR_T\n BOOST_WARCHIVE_DECL void\n save(const wchar_t * t);\n #endif\n BOOST_WARCHIVE_DECL void\n save(const std::string &s);\n #ifndef BOOST_NO_STD_WSTRING\n BOOST_WARCHIVE_DECL void\n save(const std::wstring &ws);\n #endif\n BOOST_WARCHIVE_DECL\n xml_woarchive_impl(std::wostream & os, unsigned int flags);\n BOOST_WARCHIVE_DECL\n ~xml_woarchive_impl() BOOST_OVERRIDE;\npublic:\n BOOST_WARCHIVE_DECL void\n save_binary(const void *address, std::size_t count);\n\n};\n\n// we use the following because we can't use\n// typedef xml_woarchive_impl > xml_woarchive;\n\n// do not derive from this class. If you want to extend this functionality\n// via inheritance, derived from xml_woarchive_impl instead. This will\n// preserve correct static polymorphism.\nclass BOOST_SYMBOL_VISIBLE xml_woarchive :\n public xml_woarchive_impl\n{\npublic:\n xml_woarchive(std::wostream & os, unsigned int flags = 0) :\n xml_woarchive_impl(os, flags)\n {\n if(0 == (flags & no_header))\n init();\n }\n ~xml_woarchive() BOOST_OVERRIDE {}\n};\n\n} // namespace archive\n} // namespace boost\n\n// required by export\nBOOST_SERIALIZATION_REGISTER_ARCHIVE(boost::archive::xml_woarchive)\n\n#ifdef BOOST_MSVC\n#pragma warning(pop)\n#endif\n\n#include // pops abi_suffix.hpp pragmas\n\n#endif // BOOST_NO_STD_WSTREAMBUF\n#endif // BOOST_ARCHIVE_XML_OARCHIVE_HPP\n" }, { "path": "include/boost/serialization/access.hpp", "content": "#ifndef BOOST_SERIALIZATION_ACCESS_HPP\n#define BOOST_SERIALIZATION_ACCESS_HPP\n\n// MS compatible compilers support #pragma once\n#if defined(_MSC_VER)\n# pragma once\n#endif\n\n/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8\n// access.hpp: interface for serialization system.\n\n// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .\n// Use, modification and distribution is subject to the Boost Software\n// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at\n// http://www.boost.org/LICENSE_1_0.txt)\n\n// See http://www.boost.org for updates, documentation, and revision history.\n\n#include \n\nnamespace boost {\n\nnamespace archive {\nnamespace detail {\n template\n class iserializer;\n template\n class oserializer;\n} // namespace detail\n} // namespace archive\n\nnamespace serialization {\n\n// forward declarations\ntemplate\ninline void serialize_adl(Archive &, T &, const unsigned int);\nnamespace detail {\n template\n struct member_saver;\n template\n struct member_loader;\n} // namespace detail\n\n// use an \"accessor class so that we can use:\n// \"friend class boost::serialization::access;\"\n// in any serialized class to permit clean, safe access to private class members\n// by the serialization system\n\nclass access {\npublic:\n // grant access to \"real\" serialization defaults\n#ifdef BOOST_NO_MEMBER_TEMPLATE_FRIENDS\npublic:\n#else\n template\n friend struct detail::member_saver;\n template\n friend struct detail::member_loader;\n template\n friend class archive::detail::iserializer;\n template\n friend class archive::detail::oserializer;\n template\n friend inline void serialize(\n Archive & ar,\n T & t,\n const unsigned int file_version\n );\n template\n friend inline void save_construct_data(\n Archive & ar,\n const T * t,\n const unsigned int file_version\n );\n template\n friend inline void load_construct_data(\n Archive & ar,\n T * t,\n const unsigned int file_version\n );\n#endif\n\n // pass calls to users's class implementation\n template\n static void member_save(\n Archive & ar,\n //const T & t,\n T & t,\n const unsigned int file_version\n ){\n t.save(ar, file_version);\n }\n template\n static void member_load(\n Archive & ar,\n T & t,\n const unsigned int file_version\n ){\n t.load(ar, file_version);\n }\n template\n static void serialize(\n Archive & ar,\n T & t,\n const unsigned int file_version\n ){\n // note: if you get a compile time error here with a\n // message something like:\n // cannot convert parameter 1 from to \n // a likely possible cause is that the class T contains a\n // serialize function - but that serialize function isn't\n // a template and corresponds to a file type different than\n // the class Archive. To resolve this, don't include an\n // archive type other than that for which the serialization\n // function is defined!!!\n t.serialize(ar, file_version);\n }\n template\n static void destroy( const T * t) // const appropriate here?\n {\n // the const business is an MSVC 6.0 hack that should be\n // benign on everything else\n delete const_cast(t);\n }\n template\n static void construct(T * t){\n // default is inplace invocation of default constructor\n // Note the :: before the placement new. Required if the\n // class doesn't have a class-specific placement new defined.\n ::new(t)T;\n }\n template\n static T & cast_reference(U & u){\n return static_cast(u);\n }\n template\n static T * cast_pointer(U * u){\n return static_cast(u);\n }\n};\n\n} // namespace serialization\n} // namespace boost\n\n#endif // BOOST_SERIALIZATION_ACCESS_HPP\n" }, { "path": "include/boost/serialization/archive_input_unordered_map.hpp", "content": "#ifndef BOOST_SERIALIZATION_ARCHIVE_INPUT_UNORDERED_MAP_HPP\n#define BOOST_SERIALIZATION_ARCHIVE_INPUT_UNORDERED_MAP_HPP\n\n// MS compatible compilers support #pragma once\n#if defined(_MSC_VER) && (_MSC_VER >= 1020)\n# pragma once\n#endif\n\n/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8\n// serialization/unordered_map.hpp:\n// serialization for stl unordered_map templates\n\n// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .\n// (C) Copyright 2014 Jim Bell\n// Use, modification and distribution is subject to the Boost Software\n// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at\n// http://www.boost.org/LICENSE_1_0.txt)\n\n// See http://www.boost.org for updates, documentation, and revision history.\n\n#include \n#include \n#include \n#include \n#include \n\nnamespace boost {\nnamespace serialization {\nnamespace stl {\n\n// map input\ntemplate\nstruct archive_input_unordered_map\n{\n inline void operator()(\n Archive &ar,\n Container &s,\n const unsigned int v\n ){\n typedef typename Container::value_type type;\n detail::stack_construct t(ar, v);\n ar >> boost::serialization::make_nvp(\"item\", t.reference());\n std::pair result =\n s.insert(boost::move(t.reference()));\n // note: the following presumes that the map::value_type was NOT tracked\n // in the archive. This is the usual case, but here there is no way\n // to determine that.\n if(result.second){\n ar.reset_object_address(\n & (result.first->second),\n & t.reference().second\n );\n }\n }\n};\n\n// multimap input\ntemplate\nstruct archive_input_unordered_multimap\n{\n inline void operator()(\n Archive &ar,\n Container &s,\n const unsigned int v\n ){\n typedef typename Container::value_type type;\n detail::stack_construct t(ar, v);\n ar >> boost::serialization::make_nvp(\"item\", t.reference());\n typename Container::const_iterator result =\n s.insert(t.reference());\n // note: the following presumes that the map::value_type was NOT tracked\n // in the archive. This is the usual case, but here there is no way\n // to determine that.\n ar.reset_object_address(\n & result->second,\n & t.reference()\n );\n }\n};\n\n} // stl\n} // namespace serialization\n} // namespace boost\n\n#endif // BOOST_SERIALIZATION_ARCHIVE_INPUT_UNORDERED_MAP_HPP\n" }, { "path": "include/boost/serialization/archive_input_unordered_set.hpp", "content": "#ifndef BOOST_SERIALIZATION_ARCHIVE_INPUT_UNORDERED_SET_HPP\n#define BOOST_SERIALIZATION_ARCHIVE_INPUT_UNORDERED_SET_HPP\n\n// MS compatible compilers support #pragma once\n#if defined(_MSC_VER) && (_MSC_VER >= 1020)\n# pragma once\n#endif\n\n/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8\n// archive_input_unordered_set.hpp\n\n// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .\n// (C) Copyright 2014 Jim Bell\n// Use, modification and distribution is subject to the Boost Software\n// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at\n// http://www.boost.org/LICENSE_1_0.txt)\n\n// See http://www.boost.org for updates, documentation, and revision history.\n\n#include \n#include \n#include \n#include \n\nnamespace boost {\nnamespace serialization {\n\nnamespace stl {\n\n// unordered_set input\ntemplate\nstruct archive_input_unordered_set\n{\n inline void operator()(\n Archive &ar,\n Container &s,\n const unsigned int v\n ){\n typedef typename Container::value_type type;\n detail::stack_construct t(ar, v);\n // borland fails silently w/o full namespace\n ar >> boost::serialization::make_nvp(\"item\", t.reference());\n std::pair result =\n s.insert(boost::move(t.reference()));\n if(result.second)\n ar.reset_object_address(& (* result.first), & t.reference());\n }\n};\n\n// unordered_multiset input\ntemplate\nstruct archive_input_unordered_multiset\n{\n inline void operator()(\n Archive &ar,\n Container &s,\n const unsigned int v\n ){\n typedef typename Container::value_type type;\n detail::stack_construct t(ar, v);\n ar >> boost::serialization::make_nvp(\"item\", t.reference());\n typename Container::const_iterator result =\n s.insert(boost::move(t.reference()));\n ar.reset_object_address(& (* result), & t.reference());\n }\n};\n\n} // stl\n} // serialization\n} // boost\n\n#endif // BOOST_SERIALIZATION_ARCHIVE_INPUT_UNORDERED_SET_HPP\n" }, { "path": "include/boost/serialization/array.hpp", "content": "#ifndef BOOST_SERIALIZATION_ARRAY_HPP\n#define BOOST_SERIALIZATION_ARRAY_HPP\n\n// (C) Copyright 2005 Matthias Troyer and Dave Abrahams\n// Use, modification and distribution is subject to the Boost Software\n// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at\n// http://www.boost.org/LICENSE_1_0.txt)\n\n// for serialization of . If not supported by the standard\n// library - this file becomes empty. This is to avoid breaking backward\n// compatibility for applications which used this header to support\n// serialization of native arrays. Code to serialize native arrays is\n// now always include by default. RR\n\n#include // msvc 6.0 needs this for warning suppression\n\n#if defined(BOOST_NO_STDC_NAMESPACE)\n\n#include \n#include // std::size_t\nnamespace std{\n using ::size_t;\n} // namespace std\n#endif\n\n#include \n\n#ifndef BOOST_NO_CXX11_HDR_ARRAY\n\n#include \n#include \n\nnamespace boost { namespace serialization {\n\ntemplate \nvoid serialize(Archive& ar, std::array& a, const unsigned int /* version */)\n{\n ar & boost::serialization::make_nvp(\n \"elems\",\n *static_cast(static_cast(a.data()))\n );\n\n}\n} } // end namespace boost::serialization\n\n#endif // BOOST_NO_CXX11_HDR_ARRAY\n\n#endif //BOOST_SERIALIZATION_ARRAY_HPP\n" }, { "path": "include/boost/serialization/array_optimization.hpp", "content": "#ifndef BOOST_SERIALIZATION_ARRAY_OPTIMIZATION_HPP\n#define BOOST_SERIALIZATION_ARRAY_OPTIMIZATION_HPP\n\n// (C) Copyright 2005 Matthias Troyer and Dave Abrahams\n// Use, modification and distribution is subject to the Boost Software\n// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at\n// http://www.boost.org/LICENSE_1_0.txt)\n\n#include // msvc 6.0 needs this for warning suppression\n\n#if defined(BOOST_NO_STDC_NAMESPACE)\nnamespace std{\n using ::size_t;\n} // namespace std\n#endif\n\n#include \n#include \n#include \n\nnamespace boost { namespace serialization {\n\ntemplate \nstruct use_array_optimization : boost::mpl::always {};\n\n} } // end namespace boost::serialization\n\n#define BOOST_SERIALIZATION_USE_ARRAY_OPTIMIZATION(Archive) \\\nnamespace boost { namespace serialization { \\\ntemplate <> struct use_array_optimization { \\\n template \\\n struct apply : boost::mpl::apply1::type \\\n >::type {}; \\\n}; }}\n\n#endif //BOOST_SERIALIZATION_ARRAY_OPTIMIZATION_HPP\n" }, { "path": "include/boost/serialization/array_wrapper.hpp", "content": "#ifndef BOOST_SERIALIZATION_ARRAY_WRAPPER_HPP\n#define BOOST_SERIALIZATION_ARRAY_WRAPPER_HPP\n\n// (C) Copyright 2005 Matthias Troyer and Dave Abrahams\n// Use, modification and distribution is subject to the Boost Software\n// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at\n// http://www.boost.org/LICENSE_1_0.txt)\n\n#include // msvc 6.0 needs this for warning suppression\n\n#if defined(BOOST_NO_STDC_NAMESPACE)\nnamespace std{\n using ::size_t;\n} // namespace std\n#endif\n\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nnamespace boost { namespace serialization {\n\ntemplate\nclass array_wrapper :\n public wrapper_traits >\n{\nprivate:\n array_wrapper & operator=(const array_wrapper & rhs);\n // note: I would like to make the copy constructor private but this breaks\n // make_array. So I make make_array a friend\n template\n friend const boost::serialization::array_wrapper make_array(Tx * t, S s);\npublic:\n\n array_wrapper(const array_wrapper & rhs) :\n m_t(rhs.m_t),\n m_element_count(rhs.m_element_count)\n {}\npublic:\n array_wrapper(T * t, std::size_t s) :\n m_t(t),\n m_element_count(s)\n {}\n\n // default implementation\n template\n void serialize_optimized(Archive &ar, const unsigned int, mpl::false_ ) const\n {\n // default implementation does the loop\n std::size_t c = count();\n T * t = address();\n while(0 < c--)\n ar & boost::serialization::make_nvp(\"item\", *t++);\n }\n\n // optimized implementation\n template\n void serialize_optimized(Archive &ar, const unsigned int version, mpl::true_ )\n {\n boost::serialization::split_member(ar, *this, version);\n }\n\n // default implementation\n template\n void save(Archive &ar, const unsigned int version) const\n {\n ar.save_array(*this,version);\n }\n\n // default implementation\n template\n void load(Archive &ar, const unsigned int version)\n {\n ar.load_array(*this,version);\n }\n\n // default implementation\n template\n void serialize(Archive &ar, const unsigned int version)\n {\n typedef typename\n boost::serialization::use_array_optimization::template apply<\n typename remove_const< T >::type\n >::type use_optimized;\n serialize_optimized(ar,version,use_optimized());\n }\n\n T * address() const\n {\n return m_t;\n }\n\n std::size_t count() const\n {\n return m_element_count;\n }\n\nprivate:\n T * const m_t;\n const std::size_t m_element_count;\n};\n\ntemplate\ninline\nconst array_wrapper< T > make_array(T* t, S s){\n const array_wrapper< T > a(t, s);\n return a;\n}\n\n} } // end namespace boost::serialization\n\n\n#endif //BOOST_SERIALIZATION_ARRAY_WRAPPER_HPP\n" }, { "path": "include/boost/serialization/assume_abstract.hpp", "content": "#ifndef BOOST_SERIALIZATION_ASSUME_ABSTRACT_HPP\n#define BOOST_SERIALIZATION_ASSUME_ABSTRACT_HPP\n\n// MS compatible compilers support #pragma once\n#if defined(_MSC_VER)\n# pragma once\n#endif\n\n/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8\n// assume_abstract_class.hpp:\n\n// (C) Copyright 2008 Robert Ramey\n// Use, modification and distribution is subject to the Boost Software\n// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at\n// http://www.boost.org/LICENSE_1_0.txt)\n\n// See http://www.boost.org for updates, documentation, and revision history.\n\n// this is useful for compilers which don't support the boost::is_abstract\n\n#include \n#include \n\n#ifndef BOOST_NO_IS_ABSTRACT\n\n// if there is an intrinsic is_abstract defined, we don't have to do anything\n#define BOOST_SERIALIZATION_ASSUME_ABSTRACT(T)\n\n// but forward to the \"official\" is_abstract\nnamespace boost {\nnamespace serialization {\n template\n struct is_abstract : boost::is_abstract< T > {} ;\n} // namespace serialization\n} // namespace boost\n\n#else\n// we have to \"make\" one\n\nnamespace boost {\nnamespace serialization {\n template\n struct is_abstract : boost::false_type {};\n} // namespace serialization\n} // namespace boost\n\n// define a macro to make explicit designation of this more transparent\n#define BOOST_SERIALIZATION_ASSUME_ABSTRACT(T) \\\nnamespace boost { \\\nnamespace serialization { \\\ntemplate<> \\\nstruct is_abstract< T > : boost::true_type {}; \\\ntemplate<> \\\nstruct is_abstract< const T > : boost::true_type {}; \\\n}} \\\n/**/\n\n#endif // BOOST_NO_IS_ABSTRACT\n\n#endif //BOOST_SERIALIZATION_ASSUME_ABSTRACT_HPP\n" }, { "path": "include/boost/serialization/base_object.hpp", "content": "#ifndef BOOST_SERIALIZATION_BASE_OBJECT_HPP\n#define BOOST_SERIALIZATION_BASE_OBJECT_HPP\n\n// MS compatible compilers support #pragma once\n#if defined(_MSC_VER)\n# pragma once\n#endif\n\n/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8\n// base_object.hpp:\n\n// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .\n// Use, modification and distribution is subject to the Boost Software\n// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at\n// http://www.boost.org/LICENSE_1_0.txt)\n\n// See http://www.boost.org for updates, documentation, and revision history.\n\n// if no archive headers have been included this is a no op\n// this is to permit BOOST_EXPORT etc to be included in a\n// file declaration header\n\n#include \n#include \n\n#include \n#include \n#include \n\n#include \n#include \n#include \n#include \n\n#include \n#include \n#include \n#include \n\nnamespace boost {\nnamespace serialization {\n\nnamespace detail\n{\n // get the base type for a given derived type\n // preserving the const-ness\n template\n struct base_cast\n {\n typedef typename\n mpl::if_<\n is_const,\n const B,\n B\n >::type type;\n BOOST_STATIC_ASSERT(is_const::value == is_const::value);\n };\n\n // only register void casts if the types are polymorphic\n template\n struct base_register\n {\n struct polymorphic {\n static void const * invoke(){\n Base const * const b = 0;\n Derived const * const d = 0;\n return & void_cast_register(d, b);\n }\n };\n struct non_polymorphic {\n static void const * invoke(){\n return 0;\n }\n };\n static void const * invoke(){\n typedef typename mpl::eval_if<\n is_polymorphic,\n mpl::identity,\n mpl::identity\n >::type type;\n return type::invoke();\n }\n };\n\n} // namespace detail\ntemplate\ntypename detail::base_cast::type &\nbase_object(Derived &d)\n{\n BOOST_STATIC_ASSERT(( is_base_and_derived::value));\n BOOST_STATIC_ASSERT(! is_pointer::value);\n typedef typename detail::base_cast::type type;\n detail::base_register::invoke();\n return access::cast_reference(d);\n}\n\n} // namespace serialization\n} // namespace boost\n\n#endif // BOOST_SERIALIZATION_BASE_OBJECT_HPP\n" }, { "path": "include/boost/serialization/binary_object.hpp", "content": "#ifndef BOOST_SERIALIZATION_BINARY_OBJECT_HPP\n#define BOOST_SERIALIZATION_BINARY_OBJECT_HPP\n\n// MS compatible compilers support #pragma once\n#if defined(_MSC_VER)\n# pragma once\n#endif\n\n/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8\n// nvp.hpp: interface for serialization system.\n\n// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .\n// Use, modification and distribution is subject to the Boost Software\n// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at\n// http://www.boost.org/LICENSE_1_0.txt)\n\n// See http://www.boost.org for updates, documentation, and revision history.\n\n#include \n\n#include // std::size_t\n#include \n#if defined(BOOST_NO_STDC_NAMESPACE)\nnamespace std{\n using ::size_t;\n} // namespace std\n#endif\n\n#include \n#include \n#include \n#include \n#include \n#include \n\nnamespace boost {\nnamespace serialization {\n\nstruct binary_object :\n public wrapper_traits >\n{\n void const * m_t;\n std::size_t m_size;\n template\n void save(Archive & ar, const unsigned int /* file_version */) const {\n ar.save_binary(m_t, m_size);\n }\n template\n void load(Archive & ar, const unsigned int /* file_version */) const {\n ar.load_binary(const_cast(m_t), m_size);\n }\n BOOST_SERIALIZATION_SPLIT_MEMBER()\n binary_object & operator=(const binary_object & rhs) {\n m_t = rhs.m_t;\n m_size = rhs.m_size;\n return *this;\n }\n binary_object(const void * const t, std::size_t size) :\n m_t(t),\n m_size(size)\n {}\n binary_object(const binary_object & rhs) :\n m_t(rhs.m_t),\n m_size(rhs.m_size)\n {}\n};\n\n// just a little helper to support the convention that all serialization\n// wrappers follow the naming convention make_xxxxx\ninline\nconst binary_object\nmake_binary_object(const void * t, std::size_t size){\n return binary_object(t, size);\n}\n\n} // namespace serialization\n} // boost\n\n#endif // BOOST_SERIALIZATION_BINARY_OBJECT_HPP\n" }, { "path": "include/boost/serialization/bitset.hpp", "content": "/*!\n * \\file bitset.hpp\n * \\brief Provides Boost.Serialization support for std::bitset\n * \\author Brian Ravnsgaard Riis\n * \\author Kenneth Riddile\n * \\date 16.09.2004, updated 04.03.2009\n * \\copyright 2004 Brian Ravnsgaard Riis\n * \\license Boost Software License 1.0\n */\n#ifndef BOOST_SERIALIZATION_BITSET_HPP\n#define BOOST_SERIALIZATION_BITSET_HPP\n\n// MS compatible compilers support #pragma once\n#if defined(_MSC_VER)\n# pragma once\n#endif\n\n#include \n#include // size_t\n\n#include \n#include \n#include \n#include \n\nnamespace boost{\nnamespace serialization{\n\ntemplate \ninline void save(\n Archive & ar,\n std::bitset const & t,\n const unsigned int /* version */\n){\n const std::string bits = t.template to_string<\n std::string::value_type,\n std::string::traits_type,\n std::string::allocator_type\n >();\n ar << BOOST_SERIALIZATION_NVP( bits );\n}\n\ntemplate \ninline void load(\n Archive & ar,\n std::bitset & t,\n const unsigned int /* version */\n){\n std::string bits;\n ar >> BOOST_SERIALIZATION_NVP( bits );\n t = std::bitset(bits);\n}\n\ntemplate \ninline void serialize(\n Archive & ar,\n std::bitset & t,\n const unsigned int version\n){\n boost::serialization::split_free( ar, t, version );\n}\n\n// don't track bitsets since that would trigger tracking\n// all over the program - which probably would be a surprise.\n// also, tracking would be hard to implement since, we're\n// serialization a representation of the data rather than\n// the data itself.\ntemplate \nstruct tracking_level >\n : mpl::int_ {} ;\n\n} //serialization\n} //boost\n\n#endif // BOOST_SERIALIZATION_BITSET_HPP\n" }, { "path": "include/boost/serialization/boost_array.hpp", "content": "#ifndef BOOST_SERIALIZATION_BOOST_ARRAY_HPP\n#define BOOST_SERIALIZATION_BOOST_ARRAY_HPP\n\n// (C) Copyright 2005 Matthias Troyer and Dave Abrahams\n// Use, modification and distribution is subject to the Boost Software\n// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at\n// http://www.boost.org/LICENSE_1_0.txt)\n\n#include // msvc 6.0 needs this for warning suppression\n\n#if defined(BOOST_NO_STDC_NAMESPACE)\nnamespace std{\n using ::size_t;\n} // namespace std\n#endif\n\n#include \n#include \n\nnamespace boost { namespace serialization {\n// implement serialization for boost::array\ntemplate \nvoid serialize(Archive& ar, boost::array& a, const unsigned int /* version */)\n{\n ar & boost::serialization::make_nvp(\"elems\", a.elems);\n}\n\n} } // end namespace boost::serialization\n\n\n#endif //BOOST_SERIALIZATION_BOOST_ARRAY_HPP\n" }, { "path": "include/boost/serialization/boost_unordered_map.hpp", "content": "#ifndef BOOST_SERIALIZATION_BOOST_SERIALIZATION_UNORDERED_MAP_HPP\n#define BOOST_SERIALIZATION_BOOST_SERIALIZATION_UNORDERED_MAP_HPP\n\n// MS compatible compilers support #pragma once\n#if defined(_MSC_VER) && (_MSC_VER >= 1020)\n# pragma once\n#endif\n\n/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8\n// serialization/unordered_map.hpp:\n// serialization for stl unordered_map templates\n\n// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .\n// (C) Copyright 2014 Jim Bell\n// Use, modification and distribution is subject to the Boost Software\n// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at\n// http://www.boost.org/LICENSE_1_0.txt)\n\n// See http://www.boost.org for updates, documentation, and revision history.\n\n#include \nBOOST_STATIC_ASSERT_MSG(\n false,\n \"Boost.Unordered now provides its own Serialization support. \"\n \"This header is no longer necessary and is now deprecated.\"\n)\n\n#endif // BOOST_SERIALIZATION_BOOST_SERIALIZATION_UNORDERED_MAP_HPP\n" }, { "path": "include/boost/serialization/boost_unordered_set.hpp", "content": "#ifndef BOOST_SERIALIZATION_BOOST_UNORDERED_SET_HPP\n#define BOOST_SERIALIZATION_BOOST_UNORDERED_SET_HPP\n\n// MS compatible compilers support #pragma once\n#if defined(_MSC_VER) && (_MSC_VER >= 1020)\n# pragma once\n#endif\n\n/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8\n// unordered_set.hpp: serialization for boost unordered_set templates\n\n// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .\n// (C) Copyright 2014 Jim Bell\n// Use, modification and distribution is subject to the Boost Software\n// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at\n// http://www.boost.org/LICENSE_1_0.txt)\n\n// See http://www.boost.org for updates, documentation, and revision history.\n\n#include \nBOOST_STATIC_ASSERT_MSG(\n false,\n \"Boost.Unordered now provides its own Serialization support. \"\n \"This header is no longer necessary and is now deprecated.\"\n)\n\n#endif // BOOST_SERIALIZATION_BOOST_UNORDERED_SET_HPP\n" }, { "path": "include/boost/serialization/collection_size_type.hpp", "content": "#ifndef BOOST_SERIALIZATION_COLLECTION_SIZE_TYPE_HPP\n#define BOOST_SERIALIZATION_COLLECTION_SIZE_TYPE_HPP\n\n// (C) Copyright 2005 Matthias Troyer\n// Use, modification and distribution is subject to the Boost Software\n// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at\n// http://www.boost.org/LICENSE_1_0.txt)\n\n#include // size_t\n#include \n#include \n#include \n#include \n\nnamespace boost {\nnamespace serialization {\n\n//BOOST_STRONG_TYPEDEF(std::size_t, collection_size_type)\n\nclass collection_size_type {\nprivate:\n typedef std::size_t base_type;\n base_type t;\npublic:\n collection_size_type(): t(0) {}\n explicit collection_size_type(const std::size_t & t_) :\n t(t_)\n {}\n collection_size_type(const collection_size_type & t_) :\n t(t_.t)\n {}\n collection_size_type & operator=(const collection_size_type & rhs){\n t = rhs.t;\n return *this;\n }\n collection_size_type & operator=(const unsigned int & rhs){\n t = rhs;\n return *this;\n }\n // used for text output\n operator base_type () const {\n return t;\n }\n // used for text input\n operator base_type & () {\n return t;\n }\n bool operator==(const collection_size_type & rhs) const {\n return t == rhs.t;\n }\n bool operator<(const collection_size_type & rhs) const {\n return t < rhs.t;\n }\n};\n\n\n} } // end namespace boost::serialization\n\nBOOST_CLASS_IMPLEMENTATION(collection_size_type, primitive_type)\nBOOST_IS_BITWISE_SERIALIZABLE(collection_size_type)\n\n#endif //BOOST_SERIALIZATION_COLLECTION_SIZE_TYPE_HPP\n" }, { "path": "include/boost/serialization/collection_traits.hpp", "content": "#ifndef BOOST_SERIALIZATION_COLLECTION_TRAITS_HPP\n#define BOOST_SERIALIZATION_COLLECTION_TRAITS_HPP\n\n// MS compatible compilers support #pragma once\n#if defined(_MSC_VER)\n# pragma once\n#endif\n\n/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8\n// collection_traits.hpp:\n\n// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .\n// Use, modification and distribution is subject to the Boost Software\n// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at\n// http://www.boost.org/LICENSE_1_0.txt)\n\n// See http://www.boost.org for updates, documentation, and revision history.\n\n// This header assigns a level implementation trait to a collection type\n// for all primitives. It is needed so that archives which are meant to be\n// portable don't write class information in the archive. Since, not all\n// compiles recognize the same set of primitive types, the possibility\n// exists for archives to be non-portable if class information for primitive\n// types is included. This is addressed by the following macros.\n#include \n#include \n\n#include \n#include \n#include // ULONG_MAX\n#include \n\n#define BOOST_SERIALIZATION_COLLECTION_TRAITS_HELPER(T, C) \\\ntemplate<> \\\nstruct implementation_level< C < T > > { \\\n typedef mpl::integral_c_tag tag; \\\n typedef mpl::int_ type; \\\n BOOST_STATIC_CONSTANT(int, value = object_serializable); \\\n}; \\\n/**/\n\n#if defined(BOOST_NO_CWCHAR) || defined(BOOST_NO_INTRINSIC_WCHAR_T)\n #define BOOST_SERIALIZATION_COLLECTION_TRAITS_HELPER_WCHAR(C)\n#else\n #define BOOST_SERIALIZATION_COLLECTION_TRAITS_HELPER_WCHAR(C) \\\n BOOST_SERIALIZATION_COLLECTION_TRAITS_HELPER(wchar_t, C) \\\n /**/\n#endif\n\n#if defined(BOOST_HAS_LONG_LONG)\n #define BOOST_SERIALIZATION_COLLECTION_TRAITS_HELPER_INT64(C) \\\n BOOST_SERIALIZATION_COLLECTION_TRAITS_HELPER(boost::long_long_type, C) \\\n BOOST_SERIALIZATION_COLLECTION_TRAITS_HELPER(boost::ulong_long_type, C) \\\n /**/\n#else\n #define BOOST_SERIALIZATION_COLLECTION_TRAITS_HELPER_INT64(C)\n#endif\n\n#define BOOST_SERIALIZATION_COLLECTION_TRAITS(C) \\\n namespace boost { namespace serialization { \\\n BOOST_SERIALIZATION_COLLECTION_TRAITS_HELPER(bool, C) \\\n BOOST_SERIALIZATION_COLLECTION_TRAITS_HELPER(char, C) \\\n BOOST_SERIALIZATION_COLLECTION_TRAITS_HELPER(signed char, C) \\\n BOOST_SERIALIZATION_COLLECTION_TRAITS_HELPER(unsigned char, C) \\\n BOOST_SERIALIZATION_COLLECTION_TRAITS_HELPER(signed int, C) \\\n BOOST_SERIALIZATION_COLLECTION_TRAITS_HELPER(unsigned int, C) \\\n BOOST_SERIALIZATION_COLLECTION_TRAITS_HELPER(signed long, C) \\\n BOOST_SERIALIZATION_COLLECTION_TRAITS_HELPER(unsigned long, C) \\\n BOOST_SERIALIZATION_COLLECTION_TRAITS_HELPER(float, C) \\\n BOOST_SERIALIZATION_COLLECTION_TRAITS_HELPER(double, C) \\\n BOOST_SERIALIZATION_COLLECTION_TRAITS_HELPER(unsigned short, C) \\\n BOOST_SERIALIZATION_COLLECTION_TRAITS_HELPER(signed short, C) \\\n BOOST_SERIALIZATION_COLLECTION_TRAITS_HELPER_INT64(C) \\\n BOOST_SERIALIZATION_COLLECTION_TRAITS_HELPER_WCHAR(C) \\\n } } \\\n /**/\n\n#endif // BOOST_SERIALIZATION_COLLECTION_TRAITS\n" }, { "path": "include/boost/serialization/collections_load_imp.hpp", "content": "#ifndef BOOST_SERIALIZATION_COLLECTIONS_LOAD_IMP_HPP\n#define BOOST_SERIALIZATION_COLLECTIONS_LOAD_IMP_HPP\n\n// MS compatible compilers support #pragma once\n#if defined(_MSC_VER)\n# pragma once\n#endif\n\n#if defined(_MSC_VER) && (_MSC_VER <= 1020)\n# pragma warning (disable : 4786) // too long name, harmless warning\n#endif\n\n/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8\n// collections_load_imp.hpp: serialization for loading stl collections\n\n// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .\n// Use, modification and distribution is subject to the Boost Software\n// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at\n// http://www.boost.org/LICENSE_1_0.txt)\n\n// See http://www.boost.org for updates, documentation, and revision history.\n\n// helper function templates for serialization of collections\n\n#include \n#include // size_t\n#include // msvc 6.0 needs this for warning suppression\n#if defined(BOOST_NO_STDC_NAMESPACE)\nnamespace std{\n using ::size_t;\n} // namespace std\n#endif\n#include \n\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nnamespace boost{\nnamespace serialization {\nnamespace stl {\n\n//////////////////////////////////////////////////////////////////////\n// implementation of serialization for STL containers\n//\n\ntemplate<\n class Archive,\n class T\n>\ntypename boost::enable_if<\n typename detail::is_default_constructible<\n typename T::value_type\n >,\n void\n>::type\ncollection_load_impl(\n Archive & ar,\n T & t,\n collection_size_type count,\n item_version_type /*item_version*/\n){\n t.resize(count);\n typename T::iterator hint;\n hint = t.begin();\n while(count-- > 0){\n ar >> boost::serialization::make_nvp(\"item\", *hint++);\n }\n}\n\ntemplate<\n class Archive,\n class T\n>\ntypename boost::disable_if<\n typename detail::is_default_constructible<\n typename T::value_type\n >,\n void\n>::type\ncollection_load_impl(\n Archive & ar,\n T & t,\n collection_size_type count,\n item_version_type item_version\n){\n t.clear();\n while(count-- > 0){\n detail::stack_construct u(ar, item_version);\n ar >> boost::serialization::make_nvp(\"item\", u.reference());\n t.push_back(boost::move(u.reference()));\n ar.reset_object_address(& t.back() , u.address());\n }\n}\n\n} // namespace stl\n} // namespace serialization\n} // namespace boost\n\n#endif //BOOST_SERIALIZATION_COLLECTIONS_LOAD_IMP_HPP\n" }, { "path": "include/boost/serialization/collections_save_imp.hpp", "content": "#ifndef BOOST_SERIALIZATION_COLLECTIONS_SAVE_IMP_HPP\n#define BOOST_SERIALIZATION_COLLECTIONS_SAVE_IMP_HPP\n\n// MS compatible compilers support #pragma once\n#if defined(_MSC_VER)\n# pragma once\n#endif\n\n/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8\n// collections_save_imp.hpp: serialization for stl collections\n\n// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .\n// Use, modification and distribution is subject to the Boost Software\n// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at\n// http://www.boost.org/LICENSE_1_0.txt)\n\n// See http://www.boost.org for updates, documentation, and revision history.\n\n// helper function templates for serialization of collections\n\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nnamespace boost{\nnamespace serialization {\nnamespace stl {\n\n//////////////////////////////////////////////////////////////////////\n// implementation of serialization for STL containers\n//\n\ntemplate\ninline void save_collection(\n Archive & ar,\n const Container &s,\n collection_size_type count)\n{\n ar << BOOST_SERIALIZATION_NVP(count);\n // record number of elements\n const item_version_type item_version(\n version::value\n );\n\n ar << BOOST_SERIALIZATION_NVP(item_version);\n\n typename Container::const_iterator it = s.begin();\n while(count-- > 0){\n // note borland emits a no-op without the explicit namespace\n boost::serialization::save_construct_data_adl(\n ar,\n boost::addressof(*it),\n item_version\n );\n ar << boost::serialization::make_nvp(\"item\", *it++);\n }\n}\n\ntemplate\ninline void save_collection(Archive & ar, const Container &s)\n{\n // record number of elements\n collection_size_type count(s.size());\n save_collection(ar, s, count);\n}\n\n} // namespace stl\n} // namespace serialization\n} // namespace boost\n\n#endif //BOOST_SERIALIZATION_COLLECTIONS_SAVE_IMP_HPP\n" }, { "path": "include/boost/serialization/complex.hpp", "content": "#ifndef BOOST_SERIALIZATION_COMPLEX_HPP\n#define BOOST_SERIALIZATION_COMPLEX_HPP\n\n// MS compatible compilers support #pragma once\n#if defined(_MSC_VER)\n# pragma once\n#endif\n\n/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8\n// serialization/utility.hpp:\n// serialization for stl utility templates\n\n// (C) Copyright 2007 Matthias Troyer .\n// Use, modification and distribution is subject to the Boost Software\n// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at\n// http://www.boost.org/LICENSE_1_0.txt)\n\n// See http://www.boost.org for updates, documentation, and revision history.\n\n#include \n#include \n\n#include \n#include \n#include \n\nnamespace boost {\nnamespace serialization {\n\ntemplate\ninline void serialize(\n Archive & ar,\n std::complex< T > & t,\n const unsigned int file_version\n){\n boost::serialization::split_free(ar, t, file_version);\n}\n\ntemplate\ninline void save(\n Archive & ar,\n std::complex< T > const & t,\n const unsigned int /* file_version */\n){\n const T re = t.real();\n const T im = t.imag();\n ar << boost::serialization::make_nvp(\"real\", re);\n ar << boost::serialization::make_nvp(\"imag\", im);\n}\n\ntemplate\ninline void load(\n Archive & ar,\n std::complex< T >& t,\n const unsigned int /* file_version */\n){\n T re;\n T im;\n ar >> boost::serialization::make_nvp(\"real\", re);\n ar >> boost::serialization::make_nvp(\"imag\", im);\n t = std::complex< T >(re,im);\n}\n\n// specialization of serialization traits for complex\ntemplate \nstruct is_bitwise_serializable >\n : public is_bitwise_serializable< T > {};\n\ntemplate \nstruct implementation_level >\n : mpl::int_ {} ;\n\n// treat complex just like builtin arithmetic types for tracking\ntemplate \nstruct tracking_level >\n : mpl::int_ {} ;\n\n} // serialization\n} // namespace boost\n\n#endif // BOOST_SERIALIZATION_COMPLEX_HPP\n" }, { "path": "include/boost/serialization/config.hpp", "content": "#ifndef BOOST_SERIALIZATION_CONFIG_HPP\n#define BOOST_SERIALIZATION_CONFIG_HPP\n\n// config.hpp ---------------------------------------------//\n\n// (c) Copyright Robert Ramey 2004\n// Use, modification, and distribution is subject to the Boost Software\n// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at\n// http://www.boost.org/LICENSE_1_0.txt)\n\n// See library home page at http://www.boost.org/libs/serialization\n\n//----------------------------------------------------------------------------//\n\n// This header implements separate compilation features as described in\n// http://www.boost.org/more/separate_compilation.html\n\n#include \n#include \n\n// note: this version incorporates the related code into the the\n// the same library as BOOST_ARCHIVE. This could change some day in the\n// future\n\n// if BOOST_SERIALIZATION_DECL is defined undefine it now:\n#ifdef BOOST_SERIALIZATION_DECL\n #undef BOOST_SERIALIZATION_DECL\n#endif\n\n// we need to import/export our code only if the user has specifically\n// asked for it by defining either BOOST_ALL_DYN_LINK if they want all boost\n// libraries to be dynamically linked, or BOOST_SERIALIZATION_DYN_LINK\n// if they want just this one to be dynamically liked:\n#if defined(BOOST_ALL_DYN_LINK) || defined(BOOST_SERIALIZATION_DYN_LINK)\n #if !defined(BOOST_DYN_LINK)\n #define BOOST_DYN_LINK\n #endif\n // export if this is our own source, otherwise import:\n #if defined(BOOST_SERIALIZATION_SOURCE)\n #define BOOST_SERIALIZATION_DECL BOOST_SYMBOL_EXPORT\n #else\n #define BOOST_SERIALIZATION_DECL BOOST_SYMBOL_IMPORT\n #endif // defined(BOOST_SERIALIZATION_SOURCE)\n#endif // defined(BOOST_ALL_DYN_LINK) || defined(BOOST_SERIALIZATION_DYN_LINK)\n\n// if BOOST_SERIALIZATION_DECL isn't defined yet define it now:\n#ifndef BOOST_SERIALIZATION_DECL\n #define BOOST_SERIALIZATION_DECL\n#endif\n\n// enable automatic library variant selection ------------------------------//\n\n#if !defined(BOOST_ALL_NO_LIB) && !defined(BOOST_SERIALIZATION_NO_LIB) \\\n&& !defined(BOOST_ARCHIVE_SOURCE) && !defined(BOOST_WARCHIVE_SOURCE) \\\n&& !defined(BOOST_SERIALIZATION_SOURCE)\n //\n // Set the name of our library, this will get undef'ed by auto_link.hpp\n // once it's done with it:\n //\n #define BOOST_LIB_NAME boost_serialization\n //\n // If we're importing code from a dll, then tell auto_link.hpp about it:\n //\n #if defined(BOOST_ALL_DYN_LINK) || defined(BOOST_SERIALIZATION_DYN_LINK)\n # define BOOST_DYN_LINK\n #endif\n //\n // And include the header that does the work:\n //\n #include \n\n#endif\n\n#endif // BOOST_SERIALIZATION_CONFIG_HPP\n" }, { "path": "include/boost/serialization/deque.hpp", "content": "#ifndef BOOST_SERIALIZATION_DEQUE_HPP\n#define BOOST_SERIALIZATION_DEQUE_HPP\n\n// MS compatible compilers support #pragma once\n#if defined(_MSC_VER)\n# pragma once\n#endif\n\n/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8\n// deque.hpp\n\n// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .\n// Use, modification and distribution is subject to the Boost Software\n// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at\n// http://www.boost.org/LICENSE_1_0.txt)\n\n// See http://www.boost.org for updates, documentation, and revision history.\n\n#include \n\n#include \n\n#include \n#include \n#include \n#include \n\nnamespace boost {\nnamespace serialization {\n\ntemplate\ninline void save(\n Archive & ar,\n const std::deque &t,\n const unsigned int /* file_version */\n){\n boost::serialization::stl::save_collection<\n Archive, std::deque\n >(ar, t);\n}\n\ntemplate\ninline void load(\n Archive & ar,\n std::deque &t,\n const unsigned int /* file_version */\n){\n const boost::serialization::library_version_type library_version(\n ar.get_library_version()\n );\n // retrieve number of elements\n item_version_type item_version(0);\n collection_size_type count;\n ar >> BOOST_SERIALIZATION_NVP(count);\n if(boost::serialization::library_version_type(3) < library_version){\n ar >> BOOST_SERIALIZATION_NVP(item_version);\n }\n stl::collection_load_impl(ar, t, count, item_version);\n}\n\n// split non-intrusive serialization function member into separate\n// non intrusive save/load member functions\ntemplate\ninline void serialize(\n Archive & ar,\n std::deque &t,\n const unsigned int file_version\n){\n boost::serialization::split_free(ar, t, file_version);\n}\n\n} // namespace serialization\n} // namespace boost\n\n#include \n\nBOOST_SERIALIZATION_COLLECTION_TRAITS(std::deque)\n\n#endif // BOOST_SERIALIZATION_DEQUE_HPP\n" }, { "path": "include/boost/serialization/detail/is_default_constructible.hpp", "content": "#ifndef BOOST_SERIALIZATION_DETAIL_IS_DEFAULT_CONSTRUCTIBLE_HPP\n#define BOOST_SERIALIZATION_DETAIL_IS_DEFAULT_CONSTRUCTIBLE_HPP\n\n// MS compatible compilers support #pragma once\n#if defined(_MSC_VER)\n# pragma once\n#endif\n\n/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8\n// is_default_constructible.hpp: serialization for loading stl collections\n//\n// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .\n// Use, modification and distribution is subject to the Boost Software\n// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at\n// http://www.boost.org/LICENSE_1_0.txt)\n\n// See http://www.boost.org for updates, documentation, and revision history.\n\n#include \n\n#if ! defined(BOOST_NO_CXX11_HDR_TYPE_TRAITS)\n #include \n namespace boost{\n namespace serialization {\n namespace detail {\n\n template\n struct is_default_constructible : public std::is_default_constructible {};\n\n } // detail\n } // serialization\n } // boost\n#else\n // we don't have standard library support for is_default_constructible\n // so we fake it by using boost::has_trivial_construtor. But this is not\n // actually correct because it's possible that a default constructor\n // to be non trivial. So when using this, make sure you're not using your\n // own definition of of T() but are using the actual default one!\n #include \n namespace boost{\n namespace serialization {\n namespace detail {\n\n template\n struct is_default_constructible : public boost::has_trivial_constructor {};\n\n } // detail\n } // serialization\n } // boost\n\n#endif\n\n\n#endif // BOOST_SERIALIZATION_DETAIL_IS_DEFAULT_CONSTRUCTIBLE_HPP\n" }, { "path": "include/boost/serialization/detail/shared_count_132.hpp", "content": "#ifndef BOOST_DETAIL_SHARED_COUNT_132_HPP_INCLUDED\n#define BOOST_DETAIL_SHARED_COUNT_132_HPP_INCLUDED\n\n// MS compatible compilers support #pragma once\n\n#if defined(_MSC_VER)\n# pragma once\n#endif\n\n//\n// detail/shared_count.hpp\n//\n// Copyright (c) 2001, 2002, 2003 Peter Dimov and Multi Media Ltd.\n//\n// Distributed under the Boost Software License, Version 1.0. (See\n// accompanying file LICENSE_1_0.txt or copy at\n// http://www.boost.org/LICENSE_1_0.txt)\n//\n\n#include \n\n#if defined(BOOST_SP_USE_STD_ALLOCATOR) && defined(BOOST_SP_USE_QUICK_ALLOCATOR)\n# error BOOST_SP_USE_STD_ALLOCATOR and BOOST_SP_USE_QUICK_ALLOCATOR are incompatible.\n#endif\n\n#include \n#include \n#include \n\n#if defined(BOOST_SP_USE_QUICK_ALLOCATOR)\n#include \n#endif\n\n#include // std::auto_ptr, std::allocator\n#include // std::less\n#include // std::exception\n#include // std::bad_alloc\n#include // std::type_info in get_deleter\n#include // std::size_t\n\n#include // msvc 6.0 needs this for warning suppression\n#if defined(BOOST_NO_STDC_NAMESPACE)\nnamespace std{\n using ::size_t;\n} // namespace std\n#endif\n\nnamespace boost_132 {\n\n// Debug hooks\n\n#if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)\n\nvoid sp_scalar_constructor_hook(void * px, std::size_t size, void * pn);\nvoid sp_array_constructor_hook(void * px);\nvoid sp_scalar_destructor_hook(void * px, std::size_t size, void * pn);\nvoid sp_array_destructor_hook(void * px);\n\n#endif\n\n\n// The standard library that comes with Borland C++ 5.5.1\n// defines std::exception and its members as having C calling\n// convention (-pc). When the definition of bad_weak_ptr\n// is compiled with -ps, the compiler issues an error.\n// Hence, the temporary #pragma option -pc below. The version\n// check is deliberately conservative.\n\nclass bad_weak_ptr: public std::exception\n{\npublic:\n\n virtual char const * what() const BOOST_NOEXCEPT_OR_NOTHROW\n {\n return \"boost::bad_weak_ptr\";\n }\n};\n\nnamespace detail{\n\nclass sp_counted_base\n{\n//private:\n\n typedef boost::detail::lightweight_mutex mutex_type;\n\npublic:\n\n sp_counted_base(): use_count_(1), weak_count_(1)\n {\n }\n\n virtual ~sp_counted_base() // nothrow\n {\n }\n\n // dispose() is called when use_count_ drops to zero, to release\n // the resources managed by *this.\n\n virtual void dispose() = 0; // nothrow\n\n // destruct() is called when weak_count_ drops to zero.\n\n virtual void destruct() // nothrow\n {\n delete this;\n }\n\n virtual void * get_deleter(std::type_info const & ti) = 0;\n\n void add_ref_copy()\n {\n#if defined(BOOST_HAS_THREADS)\n mutex_type::scoped_lock lock(mtx_);\n#endif\n ++use_count_;\n }\n\n void add_ref_lock()\n {\n#if defined(BOOST_HAS_THREADS)\n mutex_type::scoped_lock lock(mtx_);\n#endif\n if(use_count_ == 0) boost::serialization::throw_exception(bad_weak_ptr());\n ++use_count_;\n }\n\n void release() // nothrow\n {\n {\n#if defined(BOOST_HAS_THREADS)\n mutex_type::scoped_lock lock(mtx_);\n#endif\n long new_use_count = --use_count_;\n\n if(new_use_count != 0) return;\n }\n\n dispose();\n weak_release();\n }\n\n void weak_add_ref() // nothrow\n {\n#if defined(BOOST_HAS_THREADS)\n mutex_type::scoped_lock lock(mtx_);\n#endif\n ++weak_count_;\n }\n\n void weak_release() // nothrow\n {\n long new_weak_count;\n\n {\n#if defined(BOOST_HAS_THREADS)\n mutex_type::scoped_lock lock(mtx_);\n#endif\n new_weak_count = --weak_count_;\n }\n\n if(new_weak_count == 0)\n {\n destruct();\n }\n }\n\n long use_count() const // nothrow\n {\n#if defined(BOOST_HAS_THREADS)\n mutex_type::scoped_lock lock(mtx_);\n#endif\n return use_count_;\n }\n\n//private:\npublic:\n sp_counted_base(sp_counted_base const &);\n sp_counted_base & operator= (sp_counted_base const &);\n\n long use_count_; // #shared\n long weak_count_; // #weak + (#shared != 0)\n\n#if defined(BOOST_HAS_THREADS) || defined(BOOST_LWM_WIN32)\n mutable mutex_type mtx_;\n#endif\n};\n\n#if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)\n\ntemplate void cbi_call_constructor_hook(sp_counted_base * pn, T * px, boost::checked_deleter< T > const &)\n{\n boost::sp_scalar_constructor_hook(px, sizeof(T), pn);\n}\n\ntemplate void cbi_call_constructor_hook(sp_counted_base *, T * px, boost::checked_array_deleter< T > const &)\n{\n boost::sp_array_constructor_hook(px);\n}\n\ntemplate void cbi_call_constructor_hook(sp_counted_base *, P const &, D const &, long)\n{\n}\n\ntemplate void cbi_call_destructor_hook(sp_counted_base * pn, T * px, boost::checked_deleter< T > const &)\n{\n boost::sp_scalar_destructor_hook(px, sizeof(T), pn);\n}\n\ntemplate void cbi_call_destructor_hook(sp_counted_base *, T * px, boost::checked_array_deleter< T > const &)\n{\n boost::sp_array_destructor_hook(px);\n}\n\ntemplate void cbi_call_destructor_hook(sp_counted_base *, P const &, D const &, long)\n{\n}\n\n#endif\n\n//\n// Borland's Codeguard trips up over the -Vx- option here:\n//\n#ifdef __CODEGUARD__\n# pragma option push -Vx-\n#endif\n\ntemplate class sp_counted_base_impl: public sp_counted_base\n{\n//private:\npublic:\n P ptr; // copy constructor must not throw\n D del; // copy constructor must not throw\n\n sp_counted_base_impl(sp_counted_base_impl const &);\n sp_counted_base_impl & operator= (sp_counted_base_impl const &);\n\n typedef sp_counted_base_impl this_type;\n\npublic:\n\n // pre: initial_use_count <= initial_weak_count, d(p) must not throw\n\n sp_counted_base_impl(P p, D d): ptr(p), del(d)\n {\n#if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)\n detail::cbi_call_constructor_hook(this, p, d, 0);\n#endif\n }\n\n virtual void dispose() // nothrow\n {\n#if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)\n detail::cbi_call_destructor_hook(this, ptr, del, 0);\n#endif\n del(ptr);\n }\n\n virtual void * get_deleter(std::type_info const & ti)\n {\n return ti == typeid(D)? &del: 0;\n }\n\n#if defined(BOOST_SP_USE_STD_ALLOCATOR)\n\n void * operator new(std::size_t)\n {\n return std::allocator().allocate(1, static_cast(0));\n }\n\n void operator delete(void * p)\n {\n std::allocator().deallocate(static_cast(p), 1);\n }\n\n#endif\n\n#if defined(BOOST_SP_USE_QUICK_ALLOCATOR)\n\n void * operator new(std::size_t)\n {\n return boost::detail::quick_allocator::alloc();\n }\n\n void operator delete(void * p)\n {\n boost::detail::quick_allocator::dealloc(p);\n }\n\n#endif\n};\n\n#if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)\n\nint const shared_count_id = 0x2C35F101;\nint const weak_count_id = 0x298C38A4;\n\n#endif\n\nclass weak_count;\n\nclass shared_count\n{\n//private:\npublic:\n sp_counted_base * pi_;\n\n#if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)\n int id_;\n#endif\n\n friend class weak_count;\n\npublic:\n\n shared_count(): pi_(0) // nothrow\n#if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)\n , id_(shared_count_id)\n#endif\n {\n }\n\n template shared_count(P p, D d): pi_(0)\n#if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)\n , id_(shared_count_id)\n#endif\n {\n#ifndef BOOST_NO_EXCEPTIONS\n\n try\n {\n pi_ = new sp_counted_base_impl(p, d);\n }\n catch(...)\n {\n d(p); // delete p\n throw;\n }\n\n#else\n\n pi_ = new sp_counted_base_impl(p, d);\n\n if(pi_ == 0)\n {\n d(p); // delete p\n boost::serialization::throw_exception(std::bad_alloc());\n }\n\n#endif\n }\n\n#ifndef BOOST_NO_AUTO_PTR\n\n // auto_ptr is special cased to provide the strong guarantee\n\n template\n explicit shared_count(std::auto_ptr & r): pi_(\n new sp_counted_base_impl<\n Y *,\n boost::checked_deleter\n >(r.get(), boost::checked_deleter()))\n#if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)\n , id_(shared_count_id)\n#endif\n {\n r.release();\n }\n\n#endif\n\n ~shared_count() // nothrow\n {\n if(pi_ != 0) pi_->release();\n#if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)\n id_ = 0;\n#endif\n }\n\n shared_count(shared_count const & r): pi_(r.pi_) // nothrow\n#if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)\n , id_(shared_count_id)\n#endif\n {\n if(pi_ != 0) pi_->add_ref_copy();\n }\n\n explicit shared_count(weak_count const & r); // throws bad_weak_ptr when r.use_count() == 0\n\n shared_count & operator= (shared_count const & r) // nothrow\n {\n sp_counted_base * tmp = r.pi_;\n\n if(tmp != pi_)\n {\n if(tmp != 0) tmp->add_ref_copy();\n if(pi_ != 0) pi_->release();\n pi_ = tmp;\n }\n\n return *this;\n }\n\n void swap(shared_count & r) // nothrow\n {\n sp_counted_base * tmp = r.pi_;\n r.pi_ = pi_;\n pi_ = tmp;\n }\n\n long use_count() const // nothrow\n {\n return pi_ != 0? pi_->use_count(): 0;\n }\n\n bool unique() const // nothrow\n {\n return use_count() == 1;\n }\n\n friend inline bool operator==(shared_count const & a, shared_count const & b)\n {\n return a.pi_ == b.pi_;\n }\n\n friend inline bool operator<(shared_count const & a, shared_count const & b)\n {\n return std::less()(a.pi_, b.pi_);\n }\n\n void * get_deleter(std::type_info const & ti) const\n {\n return pi_? pi_->get_deleter(ti): 0;\n }\n};\n\n#ifdef __CODEGUARD__\n# pragma option pop\n#endif\n\n\nclass weak_count\n{\nprivate:\n\n sp_counted_base * pi_;\n\n#if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)\n int id_;\n#endif\n\n friend class shared_count;\n\npublic:\n\n weak_count(): pi_(0) // nothrow\n#if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)\n , id_(weak_count_id)\n#endif\n {\n }\n\n weak_count(shared_count const & r): pi_(r.pi_) // nothrow\n#if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)\n , id_(shared_count_id)\n#endif\n {\n if(pi_ != 0) pi_->weak_add_ref();\n }\n\n weak_count(weak_count const & r): pi_(r.pi_) // nothrow\n#if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)\n , id_(shared_count_id)\n#endif\n {\n if(pi_ != 0) pi_->weak_add_ref();\n }\n\n ~weak_count() // nothrow\n {\n if(pi_ != 0) pi_->weak_release();\n#if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)\n id_ = 0;\n#endif\n }\n\n weak_count & operator= (shared_count const & r) // nothrow\n {\n sp_counted_base * tmp = r.pi_;\n if(tmp != 0) tmp->weak_add_ref();\n if(pi_ != 0) pi_->weak_release();\n pi_ = tmp;\n\n return *this;\n }\n\n weak_count & operator= (weak_count const & r) // nothrow\n {\n sp_counted_base * tmp = r.pi_;\n if(tmp != 0) tmp->weak_add_ref();\n if(pi_ != 0) pi_->weak_release();\n pi_ = tmp;\n\n return *this;\n }\n\n void swap(weak_count & r) // nothrow\n {\n sp_counted_base * tmp = r.pi_;\n r.pi_ = pi_;\n pi_ = tmp;\n }\n\n long use_count() const // nothrow\n {\n return pi_ != 0? pi_->use_count(): 0;\n }\n\n friend inline bool operator==(weak_count const & a, weak_count const & b)\n {\n return a.pi_ == b.pi_;\n }\n\n friend inline bool operator<(weak_count const & a, weak_count const & b)\n {\n return std::less()(a.pi_, b.pi_);\n }\n};\n\ninline shared_count::shared_count(weak_count const & r): pi_(r.pi_)\n#if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)\n , id_(shared_count_id)\n#endif\n{\n if(pi_ != 0)\n {\n pi_->add_ref_lock();\n }\n else\n {\n boost::serialization::throw_exception(bad_weak_ptr());\n }\n}\n\n} // namespace detail\n\n} // namespace boost\n\nBOOST_SERIALIZATION_ASSUME_ABSTRACT(boost_132::detail::sp_counted_base)\n\n#endif // #ifndef BOOST_DETAIL_SHARED_COUNT_HPP_INCLUDED\n" }, { "path": "include/boost/serialization/detail/shared_ptr_132.hpp", "content": "#ifndef BOOST_SHARED_PTR_132_HPP_INCLUDED\n#define BOOST_SHARED_PTR_132_HPP_INCLUDED\n\n//\n// shared_ptr.hpp\n//\n// (C) Copyright Greg Colvin and Beman Dawes 1998, 1999.\n// Copyright (c) 2001, 2002, 2003 Peter Dimov\n//\n// Distributed under the Boost Software License, Version 1.0. (See\n// accompanying file LICENSE_1_0.txt or copy at\n// http://www.boost.org/LICENSE_1_0.txt)\n//\n// See http://www.boost.org/libs/smart_ptr/shared_ptr.htm for documentation.\n//\n\n#include // for broken compiler workarounds\n\n#if defined(BOOST_NO_MEMBER_TEMPLATES) && !defined(BOOST_MSVC6_MEMBER_TEMPLATES)\n#include \n#else\n\n#include \n#include \n#include \n#include \n\n#include \n#include \n\n#include // for std::auto_ptr\n#include // for std::swap\n#include // for std::less\n#include // for std::bad_cast\n#include // for std::basic_ostream\n\n#ifdef BOOST_MSVC // moved here to work around VC++ compiler crash\n# pragma warning(push)\n# pragma warning(disable:4284) // odd return type for operator->\n#endif\n\nnamespace boost_132 {\n\ntemplate class weak_ptr;\ntemplate class enable_shared_from_this;\n\nnamespace detail\n{\n\nstruct static_cast_tag {};\nstruct const_cast_tag {};\nstruct dynamic_cast_tag {};\nstruct polymorphic_cast_tag {};\n\ntemplate struct shared_ptr_traits\n{\n typedef T & reference;\n};\n\ntemplate<> struct shared_ptr_traits\n{\n typedef void reference;\n};\n\n#if !defined(BOOST_NO_CV_VOID_SPECIALIZATIONS)\n\ntemplate<> struct shared_ptr_traits\n{\n typedef void reference;\n};\n\ntemplate<> struct shared_ptr_traits\n{\n typedef void reference;\n};\n\ntemplate<> struct shared_ptr_traits\n{\n typedef void reference;\n};\n\n#endif\n\n// enable_shared_from_this support\n\ntemplate void sp_enable_shared_from_this( shared_count const & pn, enable_shared_from_this< T > const * pe, Y const * px )\n{\n if(pe != 0) pe->_internal_weak_this._internal_assign(const_cast(px), pn);\n}\n\ninline void sp_enable_shared_from_this( shared_count const & /*pn*/, ... )\n{\n}\n\n} // namespace detail\n\n\n//\n// shared_ptr\n//\n// An enhanced relative of scoped_ptr with reference counted copy semantics.\n// The object pointed to is deleted when the last shared_ptr pointing to it\n// is destroyed or reset.\n//\n\ntemplate class shared_ptr\n{\nprivate:\n // Borland 5.5.1 specific workaround\n typedef shared_ptr< T > this_type;\n\npublic:\n\n typedef T element_type;\n typedef T value_type;\n typedef T * pointer;\n typedef typename detail::shared_ptr_traits< T >::reference reference;\n\n shared_ptr(): px(0), pn() // never throws in 1.30+\n {\n }\n\n template\n explicit shared_ptr(Y * p): px(p), pn(p, boost::checked_deleter()) // Y must be complete\n {\n detail::sp_enable_shared_from_this( pn, p, p );\n }\n\n //\n // Requirements: D's copy constructor must not throw\n //\n // shared_ptr will release p by calling d(p)\n //\n\n template shared_ptr(Y * p, D d): px(p), pn(p, d)\n {\n detail::sp_enable_shared_from_this( pn, p, p );\n }\n\n// generated copy constructor, assignment, destructor are fine...\n\n// except that Borland C++ has a bug, and g++ with -Wsynth warns\n#if defined(__GNUC__)\n shared_ptr & operator=(shared_ptr const & r) // never throws\n {\n px = r.px;\n pn = r.pn; // shared_count::op= doesn't throw\n return *this;\n }\n#endif\n\n template\n explicit shared_ptr(weak_ptr const & r): pn(r.pn) // may throw\n {\n // it is now safe to copy r.px, as pn(r.pn) did not throw\n px = r.px;\n }\n\n template\n shared_ptr(shared_ptr const & r): px(r.px), pn(r.pn) // never throws\n {\n }\n\n template\n shared_ptr(shared_ptr const & r, detail::static_cast_tag): px(static_cast(r.px)), pn(r.pn)\n {\n }\n\n template\n shared_ptr(shared_ptr const & r, detail::const_cast_tag): px(const_cast(r.px)), pn(r.pn)\n {\n }\n\n template\n shared_ptr(shared_ptr const & r, detail::dynamic_cast_tag): px(dynamic_cast(r.px)), pn(r.pn)\n {\n if(px == 0) // need to allocate new counter -- the cast failed\n {\n pn = detail::shared_count();\n }\n }\n\n template\n shared_ptr(shared_ptr const & r, detail::polymorphic_cast_tag): px(dynamic_cast(r.px)), pn(r.pn)\n {\n if(px == 0)\n {\n boost::serialization::throw_exception(std::bad_cast());\n }\n }\n\n#ifndef BOOST_NO_AUTO_PTR\n\n template\n explicit shared_ptr(std::auto_ptr & r): px(r.get()), pn()\n {\n Y * tmp = r.get();\n pn = detail::shared_count(r);\n detail::sp_enable_shared_from_this( pn, tmp, tmp );\n }\n\n#endif\n\n#if !defined(BOOST_MSVC) || (BOOST_MSVC > 1200)\n\n template\n shared_ptr & operator=(shared_ptr const & r) // never throws\n {\n px = r.px;\n pn = r.pn; // shared_count::op= doesn't throw\n return *this;\n }\n\n#endif\n\n#ifndef BOOST_NO_AUTO_PTR\n\n template\n shared_ptr & operator=(std::auto_ptr & r)\n {\n this_type(r).swap(*this);\n return *this;\n }\n\n#endif\n\n void reset() // never throws in 1.30+\n {\n this_type().swap(*this);\n }\n\n template void reset(Y * p) // Y must be complete\n {\n BOOST_ASSERT(p == 0 || p != px); // catch self-reset errors\n this_type(p).swap(*this);\n }\n\n template void reset(Y * p, D d)\n {\n this_type(p, d).swap(*this);\n }\n\n reference operator* () const // never throws\n {\n BOOST_ASSERT(px != 0);\n return *px;\n }\n\n T * operator-> () const // never throws\n {\n BOOST_ASSERT(px != 0);\n return px;\n }\n\n T * get() const // never throws\n {\n return px;\n }\n\n // implicit conversion to \"bool\"\n\n#if defined(__SUNPRO_CC) && BOOST_WORKAROUND(__SUNPRO_CC, <= 0x530)\n\n operator bool () const\n {\n return px != 0;\n }\n\n#elif defined(__MWERKS__) && BOOST_WORKAROUND(__MWERKS__, BOOST_TESTED_AT(0x3003))\n typedef T * (this_type::*unspecified_bool_type)() const;\n\n operator unspecified_bool_type() const // never throws\n {\n return px == 0? 0: &this_type::get;\n }\n\n#else\n\n typedef T * this_type::*unspecified_bool_type;\n\n operator unspecified_bool_type() const // never throws\n {\n return px == 0? 0: &this_type::px;\n }\n\n#endif\n\n // operator! is redundant, but some compilers need it\n\n bool operator! () const // never throws\n {\n return px == 0;\n }\n\n bool unique() const // never throws\n {\n return pn.unique();\n }\n\n long use_count() const // never throws\n {\n return pn.use_count();\n }\n\n void swap(shared_ptr< T > & other) // never throws\n {\n std::swap(px, other.px);\n pn.swap(other.pn);\n }\n\n template bool _internal_less(shared_ptr const & rhs) const\n {\n return pn < rhs.pn;\n }\n\n void * _internal_get_deleter(std::type_info const & ti) const\n {\n return pn.get_deleter(ti);\n }\n\n// Tasteless as this may seem, making all members public allows member templates\n// to work in the absence of member template friends. (Matthew Langston)\n\n#ifndef BOOST_NO_MEMBER_TEMPLATE_FRIENDS\n\nprivate:\n\n template friend class shared_ptr;\n template friend class weak_ptr;\n\n\n#endif\npublic: // for serialization\n T * px; // contained pointer\n detail::shared_count pn; // reference counter\n\n}; // shared_ptr\n\ntemplate inline bool operator==(shared_ptr< T > const & a, shared_ptr const & b)\n{\n return a.get() == b.get();\n}\n\ntemplate inline bool operator!=(shared_ptr< T > const & a, shared_ptr const & b)\n{\n return a.get() != b.get();\n}\n\ntemplate inline bool operator<(shared_ptr< T > const & a, shared_ptr const & b)\n{\n return a._internal_less(b);\n}\n\ntemplate inline void swap(shared_ptr< T > & a, shared_ptr< T > & b)\n{\n a.swap(b);\n}\n\ntemplate shared_ptr< T > static_pointer_cast(shared_ptr const & r)\n{\n return shared_ptr< T >(r, detail::static_cast_tag());\n}\n\ntemplate shared_ptr< T > const_pointer_cast(shared_ptr const & r)\n{\n return shared_ptr< T >(r, detail::const_cast_tag());\n}\n\ntemplate shared_ptr< T > dynamic_pointer_cast(shared_ptr const & r)\n{\n return shared_ptr< T >(r, detail::dynamic_cast_tag());\n}\n\n// shared_*_cast names are deprecated. Use *_pointer_cast instead.\n\ntemplate shared_ptr< T > shared_static_cast(shared_ptr const & r)\n{\n return shared_ptr< T >(r, detail::static_cast_tag());\n}\n\ntemplate shared_ptr< T > shared_dynamic_cast(shared_ptr const & r)\n{\n return shared_ptr< T >(r, detail::dynamic_cast_tag());\n}\n\ntemplate shared_ptr< T > shared_polymorphic_cast(shared_ptr const & r)\n{\n return shared_ptr< T >(r, detail::polymorphic_cast_tag());\n}\n\ntemplate shared_ptr< T > shared_polymorphic_downcast(shared_ptr const & r)\n{\n BOOST_ASSERT(dynamic_cast(r.get()) == r.get());\n return shared_static_cast< T >(r);\n}\n\n// get_pointer() enables boost::mem_fn to recognize shared_ptr\n\ntemplate inline T * get_pointer(shared_ptr< T > const & p)\n{\n return p.get();\n}\n\n// operator<<\n\n\ntemplate std::basic_ostream & operator<< (std::basic_ostream & os, shared_ptr const & p)\n{\n os << p.get();\n return os;\n}\n\n// get_deleter (experimental)\n\n#if defined(__EDG_VERSION__) && (__EDG_VERSION__ <= 238)\n\n// g++ 2.9x doesn't allow static_cast(void *)\n// apparently EDG 2.38 also doesn't accept it\n\ntemplate D * get_deleter(shared_ptr< T > const & p)\n{\n void const * q = p._internal_get_deleter(typeid(D));\n return const_cast(static_cast(q));\n}\n\n#else\n\ntemplate D * get_deleter(shared_ptr< T > const & p)\n{\n return static_cast(p._internal_get_deleter(typeid(D)));\n}\n\n#endif\n\n} // namespace boost\n\n#ifdef BOOST_MSVC\n# pragma warning(pop)\n#endif\n\n#endif // #if defined(BOOST_NO_MEMBER_TEMPLATES) && !defined(BOOST_MSVC6_MEMBER_TEMPLATES)\n\n#endif // #ifndef BOOST_SHARED_PTR_132_HPP_INCLUDED\n" }, { "path": "include/boost/serialization/detail/shared_ptr_nmt_132.hpp", "content": "#ifndef BOOST_DETAIL_SHARED_PTR_NMT_132_HPP_INCLUDED\n#define BOOST_DETAIL_SHARED_PTR_NMT_132_HPP_INCLUDED\n\n//\n// detail/shared_ptr_nmt.hpp - shared_ptr.hpp without member templates\n//\n// (C) Copyright Greg Colvin and Beman Dawes 1998, 1999.\n// Copyright (c) 2001, 2002 Peter Dimov\n//\n// Distributed under the Boost Software License, Version 1.0. (See\n// accompanying file LICENSE_1_0.txt or copy at\n// http://www.boost.org/LICENSE_1_0.txt)\n//\n// See http://www.boost.org/libs/smart_ptr/shared_ptr.htm for documentation.\n//\n\n#include \n#include \n#include \n#include \n\n#ifndef BOOST_NO_AUTO_PTR\n# include // for std::auto_ptr\n#endif\n\n#include // for std::swap\n#include // for std::less\n#include // for std::bad_alloc\n\nnamespace boost\n{\n\ntemplate class shared_ptr\n{\nprivate:\n\n typedef detail::atomic_count count_type;\n\npublic:\n\n typedef T element_type;\n typedef T value_type;\n\n explicit shared_ptr(T * p = 0): px(p)\n {\n#ifndef BOOST_NO_EXCEPTIONS\n\n try // prevent leak if new throws\n {\n pn = new count_type(1);\n }\n catch(...)\n {\n boost::checked_delete(p);\n throw;\n }\n\n#else\n\n pn = new count_type(1);\n\n if(pn == 0)\n {\n boost::checked_delete(p);\n boost::serialization::throw_exception(std::bad_alloc());\n }\n\n#endif\n }\n\n ~shared_ptr()\n {\n if(--*pn == 0)\n {\n boost::checked_delete(px);\n delete pn;\n }\n }\n\n shared_ptr(shared_ptr const & r): px(r.px) // never throws\n {\n pn = r.pn;\n ++*pn;\n }\n\n shared_ptr & operator=(shared_ptr const & r)\n {\n shared_ptr(r).swap(*this);\n return *this;\n }\n\n#ifndef BOOST_NO_AUTO_PTR\n\n explicit shared_ptr(std::auto_ptr< T > & r)\n {\n pn = new count_type(1); // may throw\n px = r.release(); // fix: moved here to stop leak if new throws\n }\n\n shared_ptr & operator=(std::auto_ptr< T > & r)\n {\n shared_ptr(r).swap(*this);\n return *this;\n }\n\n#endif\n\n void reset(T * p = 0)\n {\n BOOST_ASSERT(p == 0 || p != px);\n shared_ptr(p).swap(*this);\n }\n\n T & operator*() const // never throws\n {\n BOOST_ASSERT(px != 0);\n return *px;\n }\n\n T * operator->() const // never throws\n {\n BOOST_ASSERT(px != 0);\n return px;\n }\n\n T * get() const // never throws\n {\n return px;\n }\n\n long use_count() const // never throws\n {\n return *pn;\n }\n\n bool unique() const // never throws\n {\n return *pn == 1;\n }\n\n void swap(shared_ptr< T > & other) // never throws\n {\n std::swap(px, other.px);\n std::swap(pn, other.pn);\n }\n\nprivate:\n\n T * px; // contained pointer\n count_type * pn; // ptr to reference counter\n};\n\ntemplate inline bool operator==(shared_ptr< T > const & a, shared_ptr const & b)\n{\n return a.get() == b.get();\n}\n\ntemplate inline bool operator!=(shared_ptr< T > const & a, shared_ptr const & b)\n{\n return a.get() != b.get();\n}\n\ntemplate inline bool operator<(shared_ptr< T > const & a, shared_ptr< T > const & b)\n{\n return std::less()(a.get(), b.get());\n}\n\ntemplate void swap(shared_ptr< T > & a, shared_ptr< T > & b)\n{\n a.swap(b);\n}\n\n// get_pointer() enables boost::mem_fn to recognize shared_ptr\n\ntemplate inline T * get_pointer(shared_ptr< T > const & p)\n{\n return p.get();\n}\n\n} // namespace boost\n\n#endif // #ifndef BOOST_DETAIL_SHARED_PTR_NMT_132_HPP_INCLUDED\n" }, { "path": "include/boost/serialization/detail/stack_constructor.hpp", "content": "#ifndef BOOST_SERIALIZATION_DETAIL_STACK_CONSTRUCTOR_HPP\n#define BOOST_SERIALIZATION_DETAIL_STACK_CONSTRUCTOR_HPP\n\n// MS compatible compilers support #pragma once\n#if defined(_MSC_VER)\n# pragma once\n#endif\n\n/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8\n// stack_constructor.hpp: serialization for loading stl collections\n\n// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .\n// Use, modification and distribution is subject to the Boost Software\n// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at\n// http://www.boost.org/LICENSE_1_0.txt)\n\n// See http://www.boost.org for updates, documentation, and revision history.\n\n#include \n#include \n\nnamespace boost{\nnamespace serialization {\nnamespace detail {\n\n// reserve space on stack for an object of type T without actually\n// construction such an object\ntemplate\nstruct stack_allocate\n{\n T * address() {\n return static_cast(storage_.address());\n }\n T & reference() {\n return * address();\n }\nprivate:\n typedef typename boost::aligned_storage<\n sizeof(T),\n boost::alignment_of::value\n > type;\n type storage_;\n};\n\n// construct element on the stack\ntemplate\nstruct stack_construct : public stack_allocate\n{\n stack_construct(Archive & ar, const unsigned int version){\n // note borland emits a no-op without the explicit namespace\n boost::serialization::load_construct_data_adl(\n ar,\n this->address(),\n version\n );\n }\n ~stack_construct(){\n this->address()->~T(); // undo load_construct_data above\n }\n};\n\n} // detail\n} // serialization\n} // boost\n\n#endif // BOOST_SERIALIZATION_DETAIL_STACH_CONSTRUCTOR_HPP\n" }, { "path": "include/boost/serialization/export.hpp", "content": "#ifndef BOOST_SERIALIZATION_EXPORT_HPP\n#define BOOST_SERIALIZATION_EXPORT_HPP\n\n// MS compatible compilers support #pragma once\n#if defined(_MSC_VER)\n# pragma once\n#endif\n\n/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8\n// export.hpp: set traits of classes to be serialized\n\n// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .\n// Use, modification and distribution is subject to the Boost Software\n// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at\n// http://www.boost.org/LICENSE_1_0.txt)\n\n// See http://www.boost.org for updates, documentation, and revision history.\n\n// (C) Copyright 2006 David Abrahams - http://www.boost.org.\n// implementation of class export functionality. This is an alternative to\n// \"forward declaration\" method to provoke instantiation of derived classes\n// that are to be serialized through pointers.\n\n#include \n#include // NULL\n\n#include \n#include \n#include \n#include \n\n#include \n#include \n#include \n#include \n\n#include // for guid_defined only\n#include \n#include \n#include \n#include \n\n#include \n\nnamespace boost {\nnamespace archive {\nnamespace detail {\n\nclass basic_pointer_iserializer;\nclass basic_pointer_oserializer;\n\ntemplate\nclass pointer_iserializer;\ntemplate\nclass pointer_oserializer;\n\ntemplate \nstruct export_impl\n{\n static const basic_pointer_iserializer &\n enable_load(mpl::true_){\n return boost::serialization::singleton<\n pointer_iserializer\n >::get_const_instance();\n }\n\n static const basic_pointer_oserializer &\n enable_save(mpl::true_){\n return boost::serialization::singleton<\n pointer_oserializer\n >::get_const_instance();\n }\n inline static void enable_load(mpl::false_) {}\n inline static void enable_save(mpl::false_) {}\n};\n\n// On many platforms, naming a specialization of this template is\n// enough to cause its argument to be instantiated.\ntemplate \nstruct instantiate_function {};\n\ntemplate \nstruct ptr_serialization_support\n{\n# if defined(BOOST_MSVC) || defined(__SUNPRO_CC)\n virtual BOOST_DLLEXPORT void instantiate() BOOST_USED;\n# else\n static BOOST_DLLEXPORT void instantiate() BOOST_USED;\n typedef instantiate_function<\n &ptr_serialization_support::instantiate\n > x;\n# endif\n};\n\ntemplate \nBOOST_DLLEXPORT void\nptr_serialization_support::instantiate()\n{\n export_impl::enable_save(\n typename Archive::is_saving()\n );\n\n export_impl::enable_load(\n typename Archive::is_loading()\n );\n}\n\n// Note INTENTIONAL usage of anonymous namespace in header.\n// This was made this way so that export.hpp could be included\n// in other headers. This is still under study.\n\nnamespace extra_detail {\n\ntemplate\nstruct guid_initializer\n{\n void export_guid(mpl::false_) const {\n // generates the statically-initialized objects whose constructors\n // register the information allowing serialization of T objects\n // through pointers to their base classes.\n instantiate_ptr_serialization((T*)0, 0, adl_tag());\n }\n void export_guid(mpl::true_) const {\n }\n guid_initializer const & export_guid() const {\n BOOST_STATIC_WARNING(boost::is_polymorphic< T >::value);\n // note: exporting an abstract base class will have no effect\n // and cannot be used to instantiate serialization code\n // (one might be using this in a DLL to instantiate code)\n //BOOST_STATIC_WARNING(! boost::serialization::is_abstract< T >::value);\n export_guid(boost::serialization::is_abstract< T >());\n return *this;\n }\n};\n\ntemplate\nstruct init_guid;\n\n} // anonymous\n} // namespace detail\n} // namespace archive\n} // namespace boost\n\n#define BOOST_CLASS_EXPORT_IMPLEMENT(T) \\\n namespace boost { \\\n namespace archive { \\\n namespace detail { \\\n namespace extra_detail { \\\n template<> \\\n struct init_guid< T > { \\\n static guid_initializer< T > const & g; \\\n }; \\\n guid_initializer< T > const & init_guid< T >::g = \\\n ::boost::serialization::singleton< \\\n guid_initializer< T > \\\n >::get_mutable_instance().export_guid(); \\\n }}}} \\\n/**/\n\n#define BOOST_CLASS_EXPORT_KEY2(T, K) \\\nnamespace boost { \\\nnamespace serialization { \\\ntemplate<> \\\nstruct guid_defined< T > : boost::mpl::true_ {}; \\\ntemplate<> \\\ninline const char * guid< T >(){ \\\n return K; \\\n} \\\n} /* serialization */ \\\n} /* boost */ \\\n/**/\n\n#define BOOST_CLASS_EXPORT_KEY(T) \\\n BOOST_CLASS_EXPORT_KEY2(T, BOOST_PP_STRINGIZE(T)) \\\n/**/\n\n#define BOOST_CLASS_EXPORT_GUID(T, K) \\\nBOOST_CLASS_EXPORT_KEY2(T, K) \\\nBOOST_CLASS_EXPORT_IMPLEMENT(T) \\\n/**/\n\n#if BOOST_WORKAROUND(__MWERKS__, BOOST_TESTED_AT(0x3205))\n\n// CodeWarrior fails to construct static members of class templates\n// when they are instantiated from within templates, so on that\n// compiler we ask users to specifically register base/derived class\n// relationships for exported classes. On all other compilers, use of\n// this macro is entirely optional.\n# define BOOST_SERIALIZATION_MWERKS_BASE_AND_DERIVED(Base,Derived) \\\nnamespace { \\\n static int BOOST_PP_CAT(boost_serialization_mwerks_init_, __LINE__) = \\\n (::boost::archive::detail::instantiate_ptr_serialization((Derived*)0,0), 3); \\\n static int BOOST_PP_CAT(boost_serialization_mwerks_init2_, __LINE__) = ( \\\n ::boost::serialization::void_cast_register((Derived*)0,(Base*)0) \\\n , 3); \\\n}\n\n#else\n\n# define BOOST_SERIALIZATION_MWERKS_BASE_AND_DERIVED(Base,Derived)\n\n#endif\n\n// check for unnecessary export. T isn't polymorphic so there is no\n// need to export it.\n#define BOOST_CLASS_EXPORT_CHECK(T) \\\n BOOST_STATIC_WARNING( \\\n boost::is_polymorphic::value \\\n ); \\\n /**/\n\n// the default exportable class identifier is the class name\n// the default list of archives types for which code id generated\n// are the originally included with this serialization system\n#define BOOST_CLASS_EXPORT(T) \\\n BOOST_CLASS_EXPORT_GUID( \\\n T, \\\n BOOST_PP_STRINGIZE(T) \\\n ) \\\n /**/\n\n#endif // BOOST_SERIALIZATION_EXPORT_HPP\n\n" }, { "path": "include/boost/serialization/extended_type_info.hpp", "content": "#ifndef BOOST_SERIALIZATION_EXTENDED_TYPE_INFO_HPP\n#define BOOST_SERIALIZATION_EXTENDED_TYPE_INFO_HPP\n\n// MS compatible compilers support #pragma once\n#if defined(_MSC_VER)\n# pragma once\n#endif\n\n/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8\n// extended_type_info.hpp: interface for portable version of type_info\n\n// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .\n// Use, modification and distribution is subject to the Boost Software\n// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at\n// http://www.boost.org/LICENSE_1_0.txt)\n\n// See http://www.boost.org for updates, documentation, and revision history.\n\n// for now, extended type info is part of the serialization libraries\n// this could change in the future.\n#include \n#include \n#include // NULL\n#include \n#include \n#include \n\n#include \n#include // must be the last header\n#ifdef BOOST_MSVC\n# pragma warning(push)\n# pragma warning(disable : 4251 4231 4660 4275)\n#endif\n\n#define BOOST_SERIALIZATION_MAX_KEY_SIZE 128\n\nnamespace boost {\nnamespace serialization {\n\nnamespace void_cast_detail{\n class void_caster;\n}\n\nclass BOOST_SYMBOL_VISIBLE extended_type_info :\n private boost::noncopyable\n{\nprivate:\n friend class boost::serialization::void_cast_detail::void_caster;\n\n // used to uniquely identify the type of class derived from this one\n // so that different derivations of this class can be simultaneously\n // included in implementation of sets and maps.\n const unsigned int m_type_info_key;\n virtual bool is_less_than(const extended_type_info & /*rhs*/) const = 0;\n virtual bool is_equal(const extended_type_info & /*rhs*/) const = 0;\n const char * m_key;\n\nprotected:\n BOOST_SERIALIZATION_DECL void key_unregister() const;\n BOOST_SERIALIZATION_DECL void key_register() const;\n // this class can't be used as is. It's just the\n // common functionality for all type_info replacement\n // systems. Hence, make these protected\n BOOST_SERIALIZATION_DECL extended_type_info(\n const unsigned int type_info_key,\n const char * key\n );\n virtual BOOST_SERIALIZATION_DECL ~extended_type_info();\npublic:\n const char * get_key() const {\n return m_key;\n }\n virtual const char * get_debug_info() const = 0;\n BOOST_SERIALIZATION_DECL bool operator<(const extended_type_info &rhs) const;\n BOOST_SERIALIZATION_DECL bool operator==(const extended_type_info &rhs) const;\n bool operator!=(const extended_type_info &rhs) const {\n return !(operator==(rhs));\n }\n // note explicit \"export\" of static function to work around\n // gcc 4.5 mingw error\n static BOOST_SERIALIZATION_DECL const extended_type_info *\n find(const char *key);\n // for plugins\n virtual void * construct(unsigned int /*count*/ = 0, ...) const = 0;\n virtual void destroy(void const * const /*p*/) const = 0;\n};\n\ntemplate\nstruct guid_defined : boost::mpl::false_ {};\n\nnamespace ext {\n template \n struct guid_impl\n {\n static inline const char * call()\n {\n return NULL;\n }\n };\n}\n\ntemplate\ninline const char * guid(){\n return ext::guid_impl::call();\n}\n\n} // namespace serialization\n} // namespace boost\n\n#ifdef BOOST_MSVC\n#pragma warning(pop)\n#endif\n\n#include // pops abi_suffix.hpp pragmas\n\n#endif // BOOST_SERIALIZATION_EXTENDED_TYPE_INFO_HPP\n" }, { "path": "include/boost/serialization/extended_type_info_no_rtti.hpp", "content": "#ifndef BOOST_EXTENDED_TYPE_INFO_NO_RTTI_HPP\n#define BOOST_EXTENDED_TYPE_INFO_NO_RTTI_HPP\n\n/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8\n// MS compatible compilers support #pragma once\n#if defined(_MSC_VER)\n# pragma once\n#endif\n\n// extended_type_info_no_rtti.hpp: implementation for version that depends\n// on runtime typing (rtti - typeid) but uses a user specified string\n// as the portable class identifier.\n\n// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .\n// Use, modification and distribution is subject to the Boost Software\n// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at\n// http://www.boost.org/LICENSE_1_0.txt)\n\n// See http://www.boost.org for updates, documentation, and revision history.\n#include \n\n#include \n#include \n\n#include \n#include \n#include \n\n#include \n\n#include \n#include \n#include \n#include \n#include \n\n#include \n// hijack serialization access\n#include \n\n#include // must be the last header\n#ifdef BOOST_MSVC\n# pragma warning(push)\n# pragma warning(disable : 4251 4231 4660 4275 4511 4512)\n#endif\n\nnamespace boost {\nnamespace serialization {\n///////////////////////////////////////////////////////////////////////\n// define a special type_info that doesn't depend on rtti which is not\n// available in all situations.\n\nnamespace no_rtti_system {\n\n// common base class to share type_info_key. This is used to\n// identify the method used to keep track of the extended type\nclass BOOST_SYMBOL_VISIBLE extended_type_info_no_rtti_0 :\n public extended_type_info\n{\nprotected:\n BOOST_SERIALIZATION_DECL extended_type_info_no_rtti_0(const char * key);\n BOOST_SERIALIZATION_DECL ~extended_type_info_no_rtti_0() BOOST_OVERRIDE;\npublic:\n BOOST_SERIALIZATION_DECL bool\n is_less_than(const boost::serialization::extended_type_info &rhs) const BOOST_OVERRIDE;\n BOOST_SERIALIZATION_DECL bool\n is_equal(const boost::serialization::extended_type_info &rhs) const BOOST_OVERRIDE;\n};\n\n} // no_rtti_system\n\ntemplate\nclass extended_type_info_no_rtti :\n public no_rtti_system::extended_type_info_no_rtti_0,\n public singleton >\n{\n template\n struct action {\n struct defined {\n static const char * invoke(){\n return guid< T >();\n }\n };\n struct undefined {\n // if your program traps here - you failed to\n // export a guid for this type. the no_rtti\n // system requires export for types serialized\n // as pointers.\n BOOST_STATIC_ASSERT(0 == sizeof(T));\n static const char * invoke();\n };\n static const char * invoke(){\n typedef\n typename boost::mpl::if_c<\n tf,\n defined,\n undefined\n >::type type;\n return type::invoke();\n }\n };\npublic:\n extended_type_info_no_rtti() :\n no_rtti_system::extended_type_info_no_rtti_0(\n action::value >::invoke())\n {\n key_register();\n }\n ~extended_type_info_no_rtti() BOOST_OVERRIDE {\n key_unregister();\n }\n const extended_type_info *\n get_derived_extended_type_info(const T & t) const {\n // find the type that corresponds to the most derived type.\n // this implementation doesn't depend on typeid() but assumes\n // that the specified type has a function of the following signature.\n // A common implementation of such a function is to define as a virtual\n // function. So if the type is not a polymorphic type it's likely an error\n BOOST_STATIC_WARNING(boost::is_polymorphic< T >::value);\n const char * derived_key = t.get_key();\n BOOST_ASSERT(NULL != derived_key);\n return boost::serialization::extended_type_info::find(derived_key);\n }\n const char * get_key() const{\n return action::value >::invoke();\n }\n const char * get_debug_info() const BOOST_OVERRIDE {\n return action::value >::invoke();\n }\n void * construct(unsigned int count, ...) const BOOST_OVERRIDE {\n // count up the arguments\n void * r = NULL;\n std::va_list ap;\n va_start(ap, count);\n switch(count){\n case 0:\n r = factory::type, 0>(ap); break;\n case 1:\n r = factory::type, 1>(ap); break;\n case 2:\n r = factory::type, 2>(ap); break;\n case 3:\n r = factory::type, 3>(ap); break;\n case 4:\n r = factory::type, 4>(ap); break;\n default:\n BOOST_ASSERT(false); // too many arguments\n // throw exception here?\n }\n va_end(ap);\n return r;\n }\n void destroy(void const * const p) const BOOST_OVERRIDE {\n boost::serialization::access::destroy(\n static_cast(p)\n );\n //delete static_cast(p) ;\n }\n};\n\n} // namespace serialization\n} // namespace boost\n\n///////////////////////////////////////////////////////////////////////////////\n// If no other implementation has been designated as default,\n// use this one. To use this implementation as the default, specify it\n// before any of the other headers.\n\n#ifndef BOOST_SERIALIZATION_DEFAULT_TYPE_INFO\n #define BOOST_SERIALIZATION_DEFAULT_TYPE_INFO\n namespace boost {\n namespace serialization {\n template\n struct extended_type_info_impl {\n typedef typename\n boost::serialization::extended_type_info_no_rtti< T > type;\n };\n } // namespace serialization\n } // namespace boost\n#endif\n\n#ifdef BOOST_MSVC\n# pragma warning(pop)\n#endif\n#include // pops abi_suffix.hpp pragmas\n\n#endif // BOOST_EXTENDED_TYPE_INFO_NO_RTTI_HPP\n" }, { "path": "include/boost/serialization/extended_type_info_typeid.hpp", "content": "#ifndef BOOST_SERIALIZATION_EXTENDED_TYPE_INFO_TYPEID_HPP\n#define BOOST_SERIALIZATION_EXTENDED_TYPE_INFO_TYPEID_HPP\n\n/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8\n// MS compatible compilers support #pragma once\n#if defined(_MSC_VER)\n# pragma once\n#endif\n\n// extended_type_info_typeid.hpp: implementation for version that depends\n// on runtime typing (rtti - typeid) but uses a user specified string\n// as the portable class identifier.\n\n// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .\n// Use, modification and distribution is subject to the Boost Software\n// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at\n// http://www.boost.org/LICENSE_1_0.txt)\n\n// See http://www.boost.org for updates, documentation, and revision history.\n\n#include \n#include \n#include \n#include \n\n#include \n#include \n#include \n#include \n\n#include \n#include \n#include \n#include \n\n// hijack serialization access\n#include \n\n#include \n\n#include // must be the last header\n\n#ifdef BOOST_MSVC\n# pragma warning(push)\n# pragma warning(disable : 4251 4231 4660 4275 4511 4512)\n#endif\n\nnamespace boost {\nnamespace serialization {\nnamespace typeid_system {\n\nclass BOOST_SYMBOL_VISIBLE extended_type_info_typeid_0 :\n public extended_type_info\n{\n const char * get_debug_info() const BOOST_OVERRIDE {\n if(static_cast(0) == m_ti)\n return static_cast(0);\n return m_ti->name();\n }\nprotected:\n const std::type_info * m_ti;\n BOOST_SERIALIZATION_DECL extended_type_info_typeid_0(const char * key);\n BOOST_SERIALIZATION_DECL ~extended_type_info_typeid_0() BOOST_OVERRIDE;\n BOOST_SERIALIZATION_DECL void type_register(const std::type_info & ti);\n BOOST_SERIALIZATION_DECL void type_unregister();\n BOOST_SERIALIZATION_DECL const extended_type_info *\n get_extended_type_info(const std::type_info & ti) const;\npublic:\n BOOST_SERIALIZATION_DECL bool\n is_less_than(const extended_type_info &rhs) const BOOST_OVERRIDE;\n BOOST_SERIALIZATION_DECL bool\n is_equal(const extended_type_info &rhs) const BOOST_OVERRIDE;\n const std::type_info & get_typeid() const {\n return *m_ti;\n }\n};\n\n} // typeid_system\n\ntemplate\nclass extended_type_info_typeid :\n public typeid_system::extended_type_info_typeid_0,\n public singleton >\n{\npublic:\n extended_type_info_typeid() :\n typeid_system::extended_type_info_typeid_0(\n boost::serialization::guid< T >()\n )\n {\n type_register(typeid(T));\n key_register();\n }\n ~extended_type_info_typeid() BOOST_OVERRIDE {\n key_unregister();\n type_unregister();\n }\n // get the eti record for the true type of this record\n // relying upon standard type info implementation (rtti)\n const extended_type_info *\n get_derived_extended_type_info(const T & t) const {\n // note: this implementation - based on usage of typeid (rtti)\n // only does something if the class has at least one virtual function.\n BOOST_STATIC_WARNING(boost::is_polymorphic< T >::value);\n return\n typeid_system::extended_type_info_typeid_0::get_extended_type_info(\n typeid(t)\n );\n }\n const char * get_key() const {\n return boost::serialization::guid< T >();\n }\n void * construct(unsigned int count, ...) const BOOST_OVERRIDE {\n // count up the arguments\n void * r = NULL;\n std::va_list ap;\n va_start(ap, count);\n switch(count){\n case 0:\n r = factory::type, 0>(ap); break;\n case 1:\n r = factory::type, 1>(ap); break;\n case 2:\n r = factory::type, 2>(ap); break;\n case 3:\n r = factory::type, 3>(ap); break;\n case 4:\n r = factory::type, 4>(ap); break;\n default:\n BOOST_ASSERT(false); // too many arguments\n // throw exception here?\n }\n va_end(ap);\n return r;\n }\n void destroy(void const * const p) const BOOST_OVERRIDE {\n boost::serialization::access::destroy(\n static_cast(p)\n );\n //delete static_cast(p);\n }\n};\n\n} // namespace serialization\n} // namespace boost\n\n///////////////////////////////////////////////////////////////////////////////\n// If no other implementation has been designated as default,\n// use this one. To use this implementation as the default, specify it\n// before any of the other headers.\n#ifndef BOOST_SERIALIZATION_DEFAULT_TYPE_INFO\n #define BOOST_SERIALIZATION_DEFAULT_TYPE_INFO\n namespace boost {\n namespace serialization {\n template\n struct extended_type_info_impl {\n typedef typename\n boost::serialization::extended_type_info_typeid< T > type;\n };\n } // namespace serialization\n } // namespace boost\n#endif\n\n#ifdef BOOST_MSVC\n#pragma warning(pop)\n#endif\n#include // pops abi_suffix.hpp pragmas\n\n#endif // BOOST_SERIALIZATION_EXTENDED_TYPE_INFO_TYPEID_HPP\n" }, { "path": "include/boost/serialization/factory.hpp", "content": "#ifndef BOOST_SERIALIZATION_FACTORY_HPP\n#define BOOST_SERIALIZATION_FACTORY_HPP\n\n/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8\n// MS compatible compilers support #pragma once\n#if defined(_MSC_VER)\n# pragma once\n#endif\n\n// factory.hpp: create an instance from an extended_type_info instance.\n\n// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .\n// Use, modification and distribution is subject to the Boost Software\n// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at\n// http://www.boost.org/LICENSE_1_0.txt)\n\n// See http://www.boost.org for updates, documentation, and revision history.\n\n#include // valist\n#include // NULL\n\n#include \n#include \n#include \n\nnamespace std{\n #if defined(__LIBCOMO__)\n using ::va_list;\n #endif\n} // namespace std\n\nnamespace boost {\nnamespace serialization {\n\n// default implementation does nothing.\ntemplate\nT * factory(std::va_list){\n BOOST_ASSERT(false);\n // throw exception here?\n return NULL;\n}\n\n} // namespace serialization\n} // namespace boost\n\n#define BOOST_SERIALIZATION_FACTORY(N, T, A0, A1, A2, A3) \\\nnamespace boost { \\\nnamespace serialization { \\\n template<> \\\n T * factory(std::va_list ap){ \\\n BOOST_PP_IF(BOOST_PP_GREATER(N, 0) \\\n , A0 a0 = va_arg(ap, A0);, BOOST_PP_EMPTY()) \\\n BOOST_PP_IF(BOOST_PP_GREATER(N, 1) \\\n , A1 a1 = va_arg(ap, A1);, BOOST_PP_EMPTY()) \\\n BOOST_PP_IF(BOOST_PP_GREATER(N, 2) \\\n , A2 a2 = va_arg(ap, A2);, BOOST_PP_EMPTY()) \\\n BOOST_PP_IF(BOOST_PP_GREATER(N, 3) \\\n , A3 a3 = va_arg(ap, A3);, BOOST_PP_EMPTY()) \\\n return new T( \\\n BOOST_PP_IF(BOOST_PP_GREATER(N, 0) \\\n , a0, BOOST_PP_EMPTY()) \\\n BOOST_PP_IF(BOOST_PP_GREATER(N, 1)) \\\n , BOOST_PP_COMMA, BOOST_PP_EMPTY)() \\\n BOOST_PP_IF(BOOST_PP_GREATER(N, 1) \\\n , a1, BOOST_PP_EMPTY()) \\\n BOOST_PP_IF(BOOST_PP_GREATER(N, 2)) \\\n , BOOST_PP_COMMA, BOOST_PP_EMPTY)() \\\n BOOST_PP_IF(BOOST_PP_GREATER(N, 2) \\\n , a2, BOOST_PP_EMPTY()) \\\n BOOST_PP_IF(BOOST_PP_GREATER(N, 3)) \\\n , BOOST_PP_COMMA, BOOST_PP_EMPTY)() \\\n BOOST_PP_IF(BOOST_PP_GREATER(N, 3) \\\n , a3, BOOST_PP_EMPTY()) \\\n ); \\\n } \\\n} \\\n} /**/\n\n#define BOOST_SERIALIZATION_FACTORY_4(T, A0, A1, A2, A3) \\\n BOOST_SERIALIZATION_FACTORY(4, T, A0, A1, A2, A3)\n\n#define BOOST_SERIALIZATION_FACTORY_3(T, A0, A1, A2) \\\n BOOST_SERIALIZATION_FACTORY(3, T, A0, A1, A2, 0)\n\n#define BOOST_SERIALIZATION_FACTORY_2(T, A0, A1) \\\n BOOST_SERIALIZATION_FACTORY(2, T, A0, A1, 0, 0)\n\n#define BOOST_SERIALIZATION_FACTORY_1(T, A0) \\\n BOOST_SERIALIZATION_FACTORY(1, T, A0, 0, 0, 0)\n\n#define BOOST_SERIALIZATION_FACTORY_0(T) \\\nnamespace boost { \\\nnamespace serialization { \\\n template<> \\\n T * factory(std::va_list){ \\\n return new T(); \\\n } \\\n} \\\n} \\\n/**/\n\n#endif // BOOST_SERIALIZATION_FACTORY_HPP\n" }, { "path": "include/boost/serialization/force_include.hpp", "content": "#ifndef BOOST_SERIALIZATION_FORCE_INCLUDE_HPP\n#define BOOST_SERIALIZATION_FORCE_INCLUDE_HPP\n\n// MS compatible compilers support #pragma once\n#if defined(_MSC_VER)\n# pragma once\n#endif\n\n/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8\n// force_include.hpp:\n\n// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .\n// Use, modification and distribution is subject to the Boost Software\n// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at\n// http://www.boost.org/LICENSE_1_0.txt)\n\n// See http://www.boost.org for updates, documentation, and revision history.\n\n#include \n\n// the following help macro is to guarantee that certain coded\n// is not removed by over-eager linker optimiser. In certain cases\n// we create static objects must be created but are actually never\n// referenced - creation has a side-effect such as global registration\n// which is important to us. We make an effort to refer these objects\n// so that a smart linker won't remove them as being unreferenced.\n// In microsoft compilers, inlining the code that does the referring\n// means the code gets lost and the static object is not included\n// in the library and hence never registered. This manifests itself\n// in an ungraceful crash at runtime when (and only when) built in\n// release mode.\n\n#if defined(BOOST_HAS_DECLSPEC) && !defined(__COMO__)\n# define BOOST_DLLEXPORT __declspec(dllexport)\n#elif ! defined(_WIN32) && ! defined(_WIN64)\n# if defined(__MWERKS__)\n# define BOOST_DLLEXPORT __declspec(dllexport)\n# elif defined(__GNUC__) && (__GNUC__ >= 3)\n# define BOOST_USED __attribute__ ((__used__))\n# elif defined(__IBMCPP__) && (__IBMCPP__ >= 1110)\n# define BOOST_USED __attribute__ ((__used__))\n# elif defined(__INTEL_COMPILER) && (BOOST_INTEL_CXX_VERSION >= 800)\n# define BOOST_USED __attribute__ ((__used__))\n# endif\n#endif\n\n#ifndef BOOST_USED\n# define BOOST_USED\n#endif\n\n#ifndef BOOST_DLLEXPORT\n# define BOOST_DLLEXPORT\n#endif\n\n#endif // BOOST_SERIALIZATION_FORCE_INCLUDE_HPP\n" }, { "path": "include/boost/serialization/forward_list.hpp", "content": "#ifndef BOOST_SERIALIZATION_FORWARD_LIST_HPP\n#define BOOST_SERIALIZATION_FORWARD_LIST_HPP\n\n// MS compatible compilers support #pragma once\n#if defined(_MSC_VER)\n# pragma once\n#endif\n\n/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8\n// forward_list.hpp\n\n// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .\n// Use, modification and distribution is subject to the Boost Software\n// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at\n// http://www.boost.org/LICENSE_1_0.txt)\n\n// See http://www.boost.org for updates, documentation, and revision history.\n\n#include \n\n#include \n#include // distance\n\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nnamespace boost {\nnamespace serialization {\n\ntemplate\ninline void save(\n Archive & ar,\n const std::forward_list &t,\n const unsigned int /*file_version*/\n){\n const collection_size_type count(std::distance(t.cbegin(), t.cend()));\n boost::serialization::stl::save_collection<\n Archive,\n std::forward_list\n >(ar, t, count);\n}\n\nnamespace stl {\n\ntemplate<\n class Archive,\n class T,\n class Allocator\n>\ntypename boost::disable_if<\n typename detail::is_default_constructible<\n typename std::forward_list::value_type\n >,\n void\n>::type\ncollection_load_impl(\n Archive & ar,\n std::forward_list &t,\n collection_size_type count,\n item_version_type item_version\n){\n t.clear();\n boost::serialization::detail::stack_construct u(ar, item_version);\n ar >> boost::serialization::make_nvp(\"item\", u.reference());\n t.push_front(boost::move(u.reference()));\n typename std::forward_list::iterator last;\n last = t.begin();\n ar.reset_object_address(&(*t.begin()) , & u.reference());\n while(--count > 0){\n detail::stack_construct u(ar, item_version);\n ar >> boost::serialization::make_nvp(\"item\", u.reference());\n last = t.insert_after(last, boost::move(u.reference()));\n ar.reset_object_address(&(*last) , & u.reference());\n }\n}\n\n} // stl\n\ntemplate\ninline void load(\n Archive & ar,\n std::forward_list &t,\n const unsigned int /*file_version*/\n){\n const boost::serialization::library_version_type library_version(\n ar.get_library_version()\n );\n // retrieve number of elements\n item_version_type item_version(0);\n collection_size_type count;\n ar >> BOOST_SERIALIZATION_NVP(count);\n if(boost::serialization::library_version_type(3) < library_version){\n ar >> BOOST_SERIALIZATION_NVP(item_version);\n }\n stl::collection_load_impl(ar, t, count, item_version);\n}\n\n// split non-intrusive serialization function member into separate\n// non intrusive save/load member functions\ntemplate\ninline void serialize(\n Archive & ar,\n std::forward_list &t,\n const unsigned int file_version\n){\n boost::serialization::split_free(ar, t, file_version);\n}\n\n} // serialization\n} // namespace boost\n\n#include \n\nBOOST_SERIALIZATION_COLLECTION_TRAITS(std::forward_list)\n\n#endif // BOOST_SERIALIZATION_FORWARD_LIST_HPP\n" }, { "path": "include/boost/serialization/hash_collections_load_imp.hpp", "content": "#ifndef BOOST_SERIALIZATION_HASH_COLLECTIONS_LOAD_IMP_HPP\n#define BOOST_SERIALIZATION_HASH_COLLECTIONS_LOAD_IMP_HPP\n\n// MS compatible compilers support #pragma once\n#if defined(_MSC_VER)\n# pragma once\n# pragma warning (disable : 4786) // too long name, harmless warning\n#endif\n\n/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8\n// hash_collections_load_imp.hpp: serialization for loading stl collections\n\n// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .\n// Use, modification and distribution is subject to the Boost Software\n// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at\n// http://www.boost.org/LICENSE_1_0.txt)\n\n// See http://www.boost.org for updates, documentation, and revision history.\n\n// helper function templates for serialization of hashed collections\n#include \n#include \n#include \n\nnamespace boost{\nnamespace serialization {\nnamespace stl {\n\n//////////////////////////////////////////////////////////////////////\n// implementation of serialization for STL containers\n//\ntemplate\ninline void load_hash_collection(Archive & ar, Container &s)\n{\n collection_size_type count;\n collection_size_type bucket_count;\n boost::serialization::item_version_type item_version(0);\n boost::serialization::library_version_type library_version(\n ar.get_library_version()\n );\n // retrieve number of elements\n if(boost::serialization::library_version_type(6) != library_version){\n ar >> BOOST_SERIALIZATION_NVP(count);\n ar >> BOOST_SERIALIZATION_NVP(bucket_count);\n }\n else{\n // note: fixup for error in version 6. collection size was\n // changed to size_t BUT for hashed collections it was implemented\n // as an unsigned int. This should be a problem only on win64 machines\n // but I'll leave it for everyone just in case.\n unsigned int c;\n unsigned int bc;\n ar >> BOOST_SERIALIZATION_NVP(c);\n count = c;\n ar >> BOOST_SERIALIZATION_NVP(bc);\n bucket_count = bc;\n }\n if(boost::serialization::library_version_type(3) < library_version){\n ar >> BOOST_SERIALIZATION_NVP(item_version);\n }\n s.clear();\n #if ! defined(__MWERKS__)\n s.resize(bucket_count);\n #endif\n InputFunction ifunc;\n while(count-- > 0){\n ifunc(ar, s, item_version);\n }\n}\n\n} // namespace stl\n} // namespace serialization\n} // namespace boost\n\n#endif //BOOST_SERIALIZATION_HASH_COLLECTIONS_LOAD_IMP_HPP\n" }, { "path": "include/boost/serialization/hash_collections_save_imp.hpp", "content": "#ifndef BOOST_SERIALIZATION_HASH_COLLECTIONS_SAVE_IMP_HPP\n#define BOOST_SERIALIZATION_HASH_COLLECTIONS_SAVE_IMP_HPP\n\n// MS compatible compilers support #pragma once\n#if defined(_MSC_VER)\n# pragma once\n#endif\n\n/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8\n// hash_collections_save_imp.hpp: serialization for stl collections\n\n// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .\n// Use, modification and distribution is subject to the Boost Software\n// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at\n// http://www.boost.org/LICENSE_1_0.txt)\n\n// See http://www.boost.org for updates, documentation, and revision history.\n\n// helper function templates for serialization of collections\n\n#include \n#include \n#include \n#include \n#include \n#include \n\nnamespace boost{\nnamespace serialization {\nnamespace stl {\n\n//////////////////////////////////////////////////////////////////////\n// implementation of serialization for STL containers\n//\n\ntemplate\ninline void save_hash_collection(Archive & ar, const Container &s)\n{\n collection_size_type count(s.size());\n const collection_size_type bucket_count(s.bucket_count());\n const item_version_type item_version(\n version::value\n );\n\n #if 0\n /* should only be necessary to create archives of previous versions\n * which is not currently supported. So for now comment this out\n */\n boost::serialization::library_version_type library_version(\n ar.get_library_version()\n );\n // retrieve number of elements\n if(boost::serialization::library_version_type(6) != library_version){\n ar << BOOST_SERIALIZATION_NVP(count);\n ar << BOOST_SERIALIZATION_NVP(bucket_count);\n }\n else{\n // note: fixup for error in version 6. collection size was\n // changed to size_t BUT for hashed collections it was implemented\n // as an unsigned int. This should be a problem only on win64 machines\n // but I'll leave it for everyone just in case.\n const unsigned int c = count;\n const unsigned int bc = bucket_count;\n ar << BOOST_SERIALIZATION_NVP(c);\n ar << BOOST_SERIALIZATION_NVP(bc);\n }\n if(boost::serialization::library_version_type(3) < library_version){\n // record number of elements\n // make sure the target type is registered so we can retrieve\n // the version when we load\n ar << BOOST_SERIALIZATION_NVP(item_version);\n }\n #else\n ar << BOOST_SERIALIZATION_NVP(count);\n ar << BOOST_SERIALIZATION_NVP(bucket_count);\n ar << BOOST_SERIALIZATION_NVP(item_version);\n #endif\n\n typename Container::const_iterator it = s.begin();\n while(count-- > 0){\n // note borland emits a no-op without the explicit namespace\n boost::serialization::save_construct_data_adl(\n ar,\n &(*it),\n boost::serialization::version<\n typename Container::value_type\n >::value\n );\n ar << boost::serialization::make_nvp(\"item\", *it++);\n }\n}\n\n} // namespace stl\n} // namespace serialization\n} // namespace boost\n\n#endif //BOOST_SERIALIZATION_HASH_COLLECTIONS_SAVE_IMP_HPP\n" }, { "path": "include/boost/serialization/hash_map.hpp", "content": "#ifndef BOOST_SERIALIZATION_HASH_MAP_HPP\n#define BOOST_SERIALIZATION_HASH_MAP_HPP\n\n// MS compatible compilers support #pragma once\n#if defined(_MSC_VER)\n# pragma once\n#endif\n\n/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8\n// hash_map.hpp: serialization for stl hash_map templates\n\n// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .\n// Use, modification and distribution is subject to the Boost Software\n// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at\n// http://www.boost.org/LICENSE_1_0.txt)\n\n// See http://www.boost.org for updates, documentation, and revision history.\n\n#include \n#ifdef BOOST_HAS_HASH\n#include BOOST_HASH_MAP_HEADER\n\n#include // pair\n#include \n#include \n#include \n#include \n#include \n\nnamespace boost {\nnamespace serialization {\n\nnamespace stl {\n\n// hash_map input\ntemplate\nstruct archive_input_hash_map\n{\n inline void operator()(\n Archive &ar,\n Container &s,\n const unsigned int v\n ){\n typedef typename Container::value_type type;\n detail::stack_construct t(ar, v);\n // borland fails silently w/o full namespace\n ar >> boost::serialization::make_nvp(\"item\", t.reference());\n std::pair result =\n s.insert(boost::move(t.reference()));\n // note: the following presumes that the map::value_type was NOT tracked\n // in the archive. This is the usual case, but here there is no way\n // to determine that.\n if(result.second){\n ar.reset_object_address(\n & (result.first->second),\n & t.reference().second\n );\n }\n }\n};\n\n// hash_multimap input\ntemplate\nstruct archive_input_hash_multimap\n{\n inline void operator()(\n Archive &ar,\n Container &s,\n const unsigned int v\n ){\n typedef typename Container::value_type type;\n detail::stack_construct t(ar, v);\n // borland fails silently w/o full namespace\n ar >> boost::serialization::make_nvp(\"item\", t.reference());\n typename Container::const_iterator result\n = s.insert(boost::move(t.reference()));\n // note: the following presumes that the map::value_type was NOT tracked\n // in the archive. This is the usual case, but here there is no way\n // to determine that.\n ar.reset_object_address(\n & result->second,\n & t.reference()\n );\n }\n};\n\n} // stl\n\ntemplate<\n class Archive,\n class Key,\n class T,\n class HashFcn,\n class EqualKey,\n class Allocator\n>\ninline void save(\n Archive & ar,\n const BOOST_STD_EXTENSION_NAMESPACE::hash_map<\n Key, T, HashFcn, EqualKey, Allocator\n > &t,\n const unsigned int file_version\n){\n boost::serialization::stl::save_hash_collection<\n Archive,\n BOOST_STD_EXTENSION_NAMESPACE::hash_map<\n Key, T, HashFcn, EqualKey, Allocator\n >\n >(ar, t);\n}\n\ntemplate<\n class Archive,\n class Key,\n class T,\n class HashFcn,\n class EqualKey,\n class Allocator\n>\ninline void load(\n Archive & ar,\n BOOST_STD_EXTENSION_NAMESPACE::hash_map<\n Key, T, HashFcn, EqualKey, Allocator\n > &t,\n const unsigned int file_version\n){\n boost::serialization::stl::load_hash_collection<\n Archive,\n BOOST_STD_EXTENSION_NAMESPACE::hash_map<\n Key, T, HashFcn, EqualKey, Allocator\n >,\n boost::serialization::stl::archive_input_hash_map<\n Archive,\n BOOST_STD_EXTENSION_NAMESPACE::hash_map<\n Key, T, HashFcn, EqualKey, Allocator\n >\n >\n >(ar, t);\n}\n\n// split non-intrusive serialization function member into separate\n// non intrusive save/load member functions\ntemplate<\n class Archive,\n class Key,\n class T,\n class HashFcn,\n class EqualKey,\n class Allocator\n>\ninline void serialize(\n Archive & ar,\n BOOST_STD_EXTENSION_NAMESPACE::hash_map<\n Key, T, HashFcn, EqualKey, Allocator\n > &t,\n const unsigned int file_version\n){\n boost::serialization::split_free(ar, t, file_version);\n}\n\n// hash_multimap\ntemplate<\n class Archive,\n class Key,\n class T,\n class HashFcn,\n class EqualKey,\n class Allocator\n>\ninline void save(\n Archive & ar,\n const BOOST_STD_EXTENSION_NAMESPACE::hash_multimap<\n Key, T, HashFcn, EqualKey, Allocator\n > &t,\n const unsigned int file_version\n){\n boost::serialization::stl::save_hash_collection<\n Archive,\n BOOST_STD_EXTENSION_NAMESPACE::hash_multimap<\n Key, T, HashFcn, EqualKey, Allocator\n >\n >(ar, t);\n}\n\ntemplate<\n class Archive,\n class Key,\n class T,\n class HashFcn,\n class EqualKey,\n class Allocator\n>\ninline void load(\n Archive & ar,\n BOOST_STD_EXTENSION_NAMESPACE::hash_multimap<\n Key, T, HashFcn, EqualKey, Allocator\n > &t,\n const unsigned int file_version\n){\n boost::serialization::stl::load_hash_collection<\n Archive,\n BOOST_STD_EXTENSION_NAMESPACE::hash_multimap<\n Key, T, HashFcn, EqualKey, Allocator\n >,\n boost::serialization::stl::archive_input_hash_multimap<\n Archive,\n BOOST_STD_EXTENSION_NAMESPACE::hash_multimap<\n Key, T, HashFcn, EqualKey, Allocator\n >\n >\n >(ar, t);\n}\n\n// split non-intrusive serialization function member into separate\n// non intrusive save/load member functions\ntemplate<\n class Archive,\n class Key,\n class T,\n class HashFcn,\n class EqualKey,\n class Allocator\n>\ninline void serialize(\n Archive & ar,\n BOOST_STD_EXTENSION_NAMESPACE::hash_multimap<\n Key, T, HashFcn, EqualKey, Allocator\n > &t,\n const unsigned int file_version\n){\n boost::serialization::split_free(ar, t, file_version);\n}\n\n} // namespace serialization\n} // namespace boost\n\n#endif // BOOST_HAS_HASH\n#endif // BOOST_SERIALIZATION_HASH_MAP_HPP\n" }, { "path": "include/boost/serialization/hash_set.hpp", "content": "#ifndef BOOST_SERIALIZATION_HASH_SET_HPP\n#define BOOST_SERIALIZATION_HASH_SET_HPP\n\n// MS compatible compilers support #pragma once\n#if defined(_MSC_VER)\n# pragma once\n#endif\n\n/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8\n// hash_set.hpp: serialization for stl hash_set templates\n\n// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .\n// Use, modification and distribution is subject to the Boost Software\n// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at\n// http://www.boost.org/LICENSE_1_0.txt)\n\n// See http://www.boost.org for updates, documentation, and revision history.\n\n#include \n#ifdef BOOST_HAS_HASH\n#include BOOST_HASH_SET_HEADER\n\n#include \n#include \n#include \n#include \n#include \n\nnamespace boost {\nnamespace serialization {\n\nnamespace stl {\n\n// hash_set input\ntemplate\nstruct archive_input_hash_set\n{\n inline void operator()(\n Archive &ar,\n Container &s,\n const unsigned int v\n ){\n typedef typename Container::value_type type;\n detail::stack_construct t(ar, v);\n // borland fails silently w/o full namespace\n ar >> boost::serialization::make_nvp(\"item\", t.reference());\n std::pair result =\n s.insert(boost::move(t.reference()));\n if(result.second)\n ar.reset_object_address(& (* result.first), & t.reference());\n }\n};\n\n// hash_multiset input\ntemplate\nstruct archive_input_hash_multiset\n{\n inline void operator()(\n Archive &ar,\n Container &s,\n const unsigned int v\n ){\n typedef typename Container::value_type type;\n detail::stack_construct t(ar, v);\n // borland fails silently w/o full namespace\n ar >> boost::serialization::make_nvp(\"item\", t.reference());\n typename Container::const_iterator result\n = s.insert(boost::move(t.reference()));\n ar.reset_object_address(& (* result), & t.reference());\n }\n};\n\n} // stl\n\ntemplate<\n class Archive,\n class Key,\n class HashFcn,\n class EqualKey,\n class Allocator\n>\ninline void save(\n Archive & ar,\n const BOOST_STD_EXTENSION_NAMESPACE::hash_set<\n Key, HashFcn, EqualKey, Allocator\n > &t,\n const unsigned int file_version\n){\n boost::serialization::stl::save_hash_collection<\n Archive,\n BOOST_STD_EXTENSION_NAMESPACE::hash_set<\n Key, HashFcn, EqualKey, Allocator\n >\n >(ar, t);\n}\n\ntemplate<\n class Archive,\n class Key,\n class HashFcn,\n class EqualKey,\n class Allocator\n>\ninline void load(\n Archive & ar,\n BOOST_STD_EXTENSION_NAMESPACE::hash_set<\n Key, HashFcn, EqualKey, Allocator\n > &t,\n const unsigned int file_version\n){\n boost::serialization::stl::load_hash_collection<\n Archive,\n BOOST_STD_EXTENSION_NAMESPACE::hash_set<\n Key, HashFcn, EqualKey, Allocator\n >,\n boost::serialization::stl::archive_input_hash_set<\n Archive,\n BOOST_STD_EXTENSION_NAMESPACE::hash_set<\n Key, HashFcn, EqualKey, Allocator\n >\n >\n >(ar, t);\n}\n\n// split non-intrusive serialization function member into separate\n// non intrusive save/load member functions\ntemplate<\n class Archive,\n class Key,\n class HashFcn,\n class EqualKey,\n class Allocator\n>\ninline void serialize(\n Archive & ar,\n BOOST_STD_EXTENSION_NAMESPACE::hash_set<\n Key, HashFcn, EqualKey, Allocator\n > &t,\n const unsigned int file_version\n){\n boost::serialization::split_free(ar, t, file_version);\n}\n\n// hash_multiset\ntemplate<\n class Archive,\n class Key,\n class HashFcn,\n class EqualKey,\n class Allocator\n>\ninline void save(\n Archive & ar,\n const BOOST_STD_EXTENSION_NAMESPACE::hash_multiset<\n Key, HashFcn, EqualKey, Allocator\n > &t,\n const unsigned int file_version\n){\n boost::serialization::stl::save_hash_collection<\n Archive,\n BOOST_STD_EXTENSION_NAMESPACE::hash_multiset<\n Key, HashFcn, EqualKey, Allocator\n >\n >(ar, t);\n}\n\ntemplate<\n class Archive,\n class Key,\n class HashFcn,\n class EqualKey,\n class Allocator\n>\ninline void load(\n Archive & ar,\n BOOST_STD_EXTENSION_NAMESPACE::hash_multiset<\n Key, HashFcn, EqualKey, Allocator\n > &t,\n const unsigned int file_version\n){\n boost::serialization::stl::load_hash_collection<\n Archive,\n BOOST_STD_EXTENSION_NAMESPACE::hash_multiset<\n Key, HashFcn, EqualKey, Allocator\n >,\n boost::serialization::stl::archive_input_hash_multiset<\n Archive,\n BOOST_STD_EXTENSION_NAMESPACE::hash_multiset<\n Key, HashFcn, EqualKey, Allocator\n >\n >\n >(ar, t);\n}\n\n// split non-intrusive serialization function member into separate\n// non intrusive save/load member functions\ntemplate<\n class Archive,\n class Key,\n class HashFcn,\n class EqualKey,\n class Allocator\n>\ninline void serialize(\n Archive & ar,\n BOOST_STD_EXTENSION_NAMESPACE::hash_multiset<\n Key, HashFcn, EqualKey, Allocator\n > & t,\n const unsigned int file_version\n){\n boost::serialization::split_free(ar, t, file_version);\n}\n\n} // namespace serialization\n} // namespace boost\n\n#include \n\nBOOST_SERIALIZATION_COLLECTION_TRAITS(BOOST_STD_EXTENSION_NAMESPACE::hash_set)\nBOOST_SERIALIZATION_COLLECTION_TRAITS(BOOST_STD_EXTENSION_NAMESPACE::hash_multiset)\n\n#endif // BOOST_HAS_HASH\n#endif // BOOST_SERIALIZATION_HASH_SET_HPP\n" }, { "path": "include/boost/serialization/is_bitwise_serializable.hpp", "content": "// (C) Copyright 2007 Matthias Troyer\n\n// Use, modification and distribution is subject to the Boost Software\n// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at\n// http://www.boost.org/LICENSE_1_0.txt)\n\n// Authors: Matthias Troyer\n\n/** @file is_bitwise_serializable.hpp\n *\n * This header provides a traits class for determining whether a class\n * can be serialized (in a non-portable way) just by copying the bits.\n */\n\n\n#ifndef BOOST_SERIALIZATION_IS_BITWISE_SERIALIZABLE_HPP\n#define BOOST_SERIALIZATION_IS_BITWISE_SERIALIZABLE_HPP\n\n// MS compatible compilers support #pragma once\n#if defined(_MSC_VER)\n# pragma once\n#endif\n\n#include \n#include \n\nnamespace boost {\nnamespace serialization {\n template\n struct is_bitwise_serializable\n : public is_arithmetic< T >\n {};\n} // namespace serialization\n} // namespace boost\n\n\n// define a macro to make explicit designation of this more transparent\n#define BOOST_IS_BITWISE_SERIALIZABLE(T) \\\nnamespace boost { \\\nnamespace serialization { \\\ntemplate<> \\\nstruct is_bitwise_serializable< T > : mpl::true_ {}; \\\n}} \\\n/**/\n\n#endif //BOOST_SERIALIZATION_IS_BITWISE_SERIALIZABLE_HPP\n" }, { "path": "include/boost/serialization/item_version_type.hpp", "content": "#ifndef BOOST_SERIALIZATION_ITEM_VERSION_TYPE_HPP\n#define BOOST_SERIALIZATION_ITEM_VERSION_TYPE_HPP\n\n// (C) Copyright 2010 Robert Ramey\n// Use, modification and distribution is subject to the Boost Software\n// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at\n// http://www.boost.org/LICENSE_1_0.txt)\n\n#include // uint_least8_t\n#include \n#include \n#include \n\n// fixes broken example build on x86_64-linux-gnu-gcc-4.6.0\n#include \n\nnamespace boost {\nnamespace serialization {\n\n#if defined(_MSC_VER)\n#pragma warning( push )\n#pragma warning( disable : 4244 4267 )\n#endif\n\nclass item_version_type {\nprivate:\n typedef unsigned int base_type;\n base_type t;\npublic:\n // should be private - but MPI fails if it's not!!!\n item_version_type(): t(0) {}\n explicit item_version_type(const unsigned int t_) : t(t_){\n BOOST_ASSERT(t_ <= boost::integer_traits::const_max);\n }\n item_version_type(const item_version_type & t_) :\n t(t_.t)\n {}\n item_version_type & operator=(item_version_type rhs){\n t = rhs.t;\n return *this;\n }\n // used for text output\n operator base_type () const {\n return t;\n }\n // used for text input\n operator base_type & () {\n return t;\n }\n bool operator==(const item_version_type & rhs) const {\n return t == rhs.t;\n }\n bool operator<(const item_version_type & rhs) const {\n return t < rhs.t;\n }\n};\n\n#if defined(_MSC_VER)\n#pragma warning( pop )\n#endif\n\n} } // end namespace boost::serialization\n\nBOOST_IS_BITWISE_SERIALIZABLE(item_version_type)\n\nBOOST_CLASS_IMPLEMENTATION(item_version_type, primitive_type)\n\n#endif //BOOST_SERIALIZATION_ITEM_VERSION_TYPE_HPP\n" }, { "path": "include/boost/serialization/level.hpp", "content": "#ifndef BOOST_SERIALIZATION_LEVEL_HPP\n#define BOOST_SERIALIZATION_LEVEL_HPP\n\n// MS compatible compilers support #pragma once\n#if defined(_MSC_VER)\n# pragma once\n#endif\n\n/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8\n// level.hpp:\n\n// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .\n// Use, modification and distribution is subject to the Boost Software\n// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at\n// http://www.boost.org/LICENSE_1_0.txt)\n\n// See http://www.boost.org for updates, documentation, and revision history.\n\n#include \n#include \n\n#include \n#include \n#include \n#include \n#include \n\n#include \n#include \n#include \n#include \n\n#include \n\nnamespace boost {\nnamespace serialization {\n\nstruct basic_traits;\n\n// default serialization implementation level\ntemplate\nstruct implementation_level_impl {\n template\n struct traits_class_level {\n typedef typename U::level type;\n };\n\n typedef mpl::integral_c_tag tag;\n // note: at least one compiler complained w/o the full qualification\n // on basic traits below\n typedef\n typename mpl::eval_if<\n is_base_and_derived,\n traits_class_level< T >,\n //else\n typename mpl::eval_if<\n is_fundamental< T >,\n mpl::int_,\n //else\n typename mpl::eval_if<\n is_class< T >,\n mpl::int_,\n //else\n typename mpl::eval_if<\n is_array< T >,\n mpl::int_,\n //else\n typename mpl::eval_if<\n is_enum< T >,\n mpl::int_,\n //else\n mpl::int_\n >\n >\n >\n >\n >::type type;\n // vc 7.1 doesn't like enums here\n BOOST_STATIC_CONSTANT(int, value = type::value);\n};\n\ntemplate\nstruct implementation_level :\n public implementation_level_impl\n{\n};\n\ntemplate\ninline bool operator>=(implementation_level< T > t, enum level_type l)\n{\n return t.value >= (int)l;\n}\n\n} // namespace serialization\n} // namespace boost\n\n// specify the level of serialization implementation for the class\n// require that class info saved when versioning is used\n#define BOOST_CLASS_IMPLEMENTATION(T, E) \\\n namespace boost { \\\n namespace serialization { \\\n template <> \\\n struct implementation_level_impl< const T > \\\n { \\\n typedef mpl::integral_c_tag tag; \\\n typedef mpl::int_< E > type; \\\n BOOST_STATIC_CONSTANT( \\\n int, \\\n value = implementation_level_impl::type::value \\\n ); \\\n }; \\\n } \\\n }\n /**/\n\n#endif // BOOST_SERIALIZATION_LEVEL_HPP\n" }, { "path": "include/boost/serialization/level_enum.hpp", "content": "#ifndef BOOST_SERIALIZATION_LEVEL_ENUM_HPP\n#define BOOST_SERIALIZATION_LEVEL_ENUM_HPP\n\n// MS compatible compilers support #pragma once\n#if defined(_MSC_VER)\n# pragma once\n#endif\n\n/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8\n// level_enum.hpp:\n\n// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .\n// Use, modification and distribution is subject to the Boost Software\n// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at\n// http://www.boost.org/LICENSE_1_0.txt)\n\n// See http://www.boost.org for updates, documentation, and revision history.\n\nnamespace boost {\nnamespace serialization {\n\n// for each class used in the program, specify which level\n// of serialization should be implemented\n\n// names for each level\nenum level_type\n{\n // Don't serialize this type. An attempt to do so should\n // invoke a compile time assertion.\n not_serializable = 0,\n // write/read this type directly to the archive. In this case\n // serialization code won't be called. This is the default\n // case for fundamental types. It presumes a member function or\n // template in the archive class that can handle this type.\n // there is no runtime overhead associated reading/writing\n // instances of this level\n primitive_type = 1,\n // Serialize the objects of this type using the objects \"serialize\"\n // function or template. This permits values to be written/read\n // to/from archives but includes no class or version information.\n object_serializable = 2,\n ///////////////////////////////////////////////////////////////////\n // once an object is serialized at one of the above levels, the\n // corresponding archives cannot be read if the implementation level\n // for the archive object is changed.\n ///////////////////////////////////////////////////////////////////\n // Add class information to the archive. Class information includes\n // implementation level, class version and class name if available\n object_class_info = 3\n};\n\n} // namespace serialization\n} // namespace boost\n\n#endif // BOOST_SERIALIZATION_LEVEL_ENUM_HPP\n" }, { "path": "include/boost/serialization/library_version_type.hpp", "content": "#ifndef BOOST_SERIALIZATION_LIBRARY_VERSION_TYPE_HPP\n#define BOOST_SERIALIZATION_LIBRARY_VERSION_TYPE_HPP\n\n// MS compatible compilers support #pragma once\n#if defined(_MSC_VER)\n# pragma once\n#endif\n\n/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8\n// library_version_type.hpp:\n\n// (C) Copyright 2002-2020 Robert Ramey - http://www.rrsd.com .\n// Use, modification and distribution is subject to the Boost Software\n// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at\n// http://www.boost.org/LICENSE_1_0.txt)\n\n// See http://www.boost.org for updates, documentation, and revision history.\n#include // count\n#include // uint_least16_t\n#include \n#include \n#include \n\nnamespace boost {\nnamespace serialization {\n\n#if defined(_MSC_VER)\n#pragma warning( push )\n#pragma warning( disable : 4244 4267 )\n#endif\n\n/* NOTE : Warning : Warning : Warning : Warning : Warning\n * Don't ever changes this. If you do, they previously created\n * binary archives won't be readable !!!\n */\nclass library_version_type {\nprivate:\n typedef uint_least16_t base_type;\n base_type t;\npublic:\n library_version_type(): t(0) {}\n explicit library_version_type(const unsigned int & t_) : t(t_){\n BOOST_ASSERT(t_ <= boost::integer_traits::const_max);\n }\n library_version_type(const library_version_type & t_) :\n t(t_.t)\n {}\n library_version_type & operator=(const library_version_type & rhs){\n t = rhs.t;\n return *this;\n }\n // used for text output\n operator base_type () const {\n return t;\n }\n // used for text input\n operator base_type & (){\n return t;\n }\n bool operator==(const library_version_type & rhs) const {\n return t == rhs.t;\n }\n bool operator<(const library_version_type & rhs) const {\n return t < rhs.t;\n }\n};\n\n#if defined(_MSC_VER)\n#pragma warning( pop )\n#endif\n\n} // serialization\n} // boost\n\n#endif // BOOST_SERIALIZATION_LIBRARY_VERSION_TYPE_HPP\n" }, { "path": "include/boost/serialization/list.hpp", "content": "#ifndef BOOST_SERIALIZATION_LIST_HPP\n#define BOOST_SERIALIZATION_LIST_HPP\n\n// MS compatible compilers support #pragma once\n#if defined(_MSC_VER)\n# pragma once\n#endif\n\n/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8\n// list.hpp: serialization for stl list templates\n\n// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .\n// Use, modification and distribution is subject to the Boost Software\n// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at\n// http://www.boost.org/LICENSE_1_0.txt)\n\n// See http://www.boost.org for updates, documentation, and revision history.\n\n#include \n\n#include \n\n#include \n#include \n\n#include \n#include \n#include \n#include \n#include \n#include \n\nnamespace boost {\nnamespace serialization {\n\ntemplate\ninline void save(\n Archive & ar,\n const std::list &t,\n const unsigned int /* file_version */\n){\n boost::serialization::stl::save_collection<\n Archive,\n std::list\n >(ar, t);\n}\n\ntemplate\ninline void load(\n Archive & ar,\n std::list &t,\n const unsigned int /* file_version */\n){\n const boost::serialization::library_version_type library_version(\n ar.get_library_version()\n );\n // retrieve number of elements\n item_version_type item_version(0);\n collection_size_type count;\n ar >> BOOST_SERIALIZATION_NVP(count);\n if(boost::serialization::library_version_type(3) < library_version){\n ar >> BOOST_SERIALIZATION_NVP(item_version);\n }\n stl::collection_load_impl(ar, t, count, item_version);\n}\n\n// split non-intrusive serialization function member into separate\n// non intrusive save/load member functions\ntemplate\ninline void serialize(\n Archive & ar,\n std::list & t,\n const unsigned int file_version\n){\n boost::serialization::split_free(ar, t, file_version);\n}\n\n} // serialization\n} // namespace boost\n\n#include \n\nBOOST_SERIALIZATION_COLLECTION_TRAITS(std::list)\n\n#endif // BOOST_SERIALIZATION_LIST_HPP\n" }, { "path": "include/boost/serialization/map.hpp", "content": "#ifndef BOOST_SERIALIZATION_MAP_HPP\n#define BOOST_SERIALIZATION_MAP_HPP\n\n// MS compatible compilers support #pragma once\n#if defined(_MSC_VER)\n# pragma once\n#endif\n\n/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8\n// serialization/map.hpp:\n// serialization for stl map templates\n\n// (C) Copyright 2002-2014 Robert Ramey - http://www.rrsd.com .\n// Use, modification and distribution is subject to the Boost Software\n// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at\n// http://www.boost.org/LICENSE_1_0.txt)\n\n// See http://www.boost.org for updates, documentation, and revision history.\n\n#include \n\n#include \n\n#include \n#include \n#include \n#include \n#include \n#include \n\n#include \n#include \n#include \n#include \n\nnamespace boost {\nnamespace serialization {\n\n////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8\n// implementation of serialization for map and mult-map STL containers\n\ntemplate\ninline void load_map_collection(Archive & ar, Container &s)\n{\n s.clear();\n const boost::serialization::library_version_type library_version(\n ar.get_library_version()\n );\n // retrieve number of elements\n item_version_type item_version(0);\n collection_size_type count;\n ar >> BOOST_SERIALIZATION_NVP(count);\n if(boost::serialization::library_version_type(3) < library_version){\n ar >> BOOST_SERIALIZATION_NVP(item_version);\n }\n typename Container::iterator hint;\n hint = s.begin();\n while(count-- > 0){\n typedef typename Container::value_type type;\n detail::stack_construct t(ar, item_version);\n ar >> boost::serialization::make_nvp(\"item\", t.reference());\n typename Container::iterator result =\n s.insert(hint, boost::move(t.reference()));\n ar.reset_object_address(& (result->second), & t.reference().second);\n hint = result;\n ++hint;\n }\n}\n\n// map\ntemplate\ninline void save(\n Archive & ar,\n const std::map &t,\n const unsigned int /* file_version */\n){\n boost::serialization::stl::save_collection<\n Archive,\n std::map\n >(ar, t);\n}\n\ntemplate\ninline void load(\n Archive & ar,\n std::map &t,\n const unsigned int /* file_version */\n){\n load_map_collection(ar, t);\n}\n\n// split non-intrusive serialization function member into separate\n// non intrusive save/load member functions\ntemplate\ninline void serialize(\n Archive & ar,\n std::map &t,\n const unsigned int file_version\n){\n boost::serialization::split_free(ar, t, file_version);\n}\n\n// multimap\ntemplate\ninline void save(\n Archive & ar,\n const std::multimap &t,\n const unsigned int /* file_version */\n){\n boost::serialization::stl::save_collection<\n Archive,\n std::multimap\n >(ar, t);\n}\n\ntemplate\ninline void load(\n Archive & ar,\n std::multimap &t,\n const unsigned int /* file_version */\n){\n load_map_collection(ar, t);\n}\n\n// split non-intrusive serialization function member into separate\n// non intrusive save/load member functions\ntemplate\ninline void serialize(\n Archive & ar,\n std::multimap &t,\n const unsigned int file_version\n){\n boost::serialization::split_free(ar, t, file_version);\n}\n\n} // serialization\n} // namespace boost\n\n#endif // BOOST_SERIALIZATION_MAP_HPP\n" }, { "path": "include/boost/serialization/nvp.hpp", "content": "#ifndef BOOST_SERIALIZATION_NVP_HPP\n#define BOOST_SERIALIZATION_NVP_HPP\n\n// MS compatible compilers support #pragma once\n#if defined(_MSC_VER)\n# pragma once\n#endif\n\n/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8\n// nvp.hpp: interface for serialization system.\n\n// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .\n// Use, modification and distribution is subject to the Boost Software\n// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at\n// http://www.boost.org/LICENSE_1_0.txt)\n\n// See http://www.boost.org for updates, documentation, and revision history.\n\n#include \n#include \n\n#define BOOST_SERIALIZATION_NVP(name) \\\n boost::serialization::make_nvp(BOOST_PP_STRINGIZE(name), name)\n/**/\n\n#define BOOST_SERIALIZATION_BASE_OBJECT_NVP(name) \\\n boost::serialization::make_nvp( \\\n BOOST_PP_STRINGIZE(name), \\\n boost::serialization::base_object(*this) \\\n )\n/**/\n\n#include \n#include \n#include \n#include \n#include \n\nnamespace boost {\nnamespace serialization {\n\ntemplate\nvoid save(\n Archive & ar,\n const nvp & t,\n const unsigned int /* file_version */\n){\n ar << t.const_value();\n}\ntemplate\nvoid load(\n Archive & ar,\n nvp & t ,\n const unsigned int /* file_version */\n){\n ar >> t.value();\n}\n\ntemplate\ninline void serialize(\n Archive & ar,\n nvp & t,\n const unsigned int file_version\n){\n split_free(ar, t, file_version);\n}\n\ntemplate \nstruct implementation_level >\n{\n typedef mpl::integral_c_tag tag;\n typedef mpl::int_ type;\n BOOST_STATIC_CONSTANT(int, value = implementation_level::type::value);\n};\ntemplate \nstruct implementation_level >\n{\n typedef mpl::integral_c_tag tag;\n typedef mpl::int_ type;\n BOOST_STATIC_CONSTANT(int, value = implementation_level::type::value);\n};\n\n// nvp objects are generally created on the stack and are never tracked\ntemplate\nstruct tracking_level >\n{\n typedef mpl::integral_c_tag tag;\n typedef mpl::int_ type;\n BOOST_STATIC_CONSTANT(int, value = tracking_level::type::value);\n};\ntemplate\nstruct tracking_level >\n{\n typedef mpl::integral_c_tag tag;\n typedef mpl::int_ type;\n BOOST_STATIC_CONSTANT(int, value = tracking_level::type::value);\n};\n\n// these traits aren't used by nvp so they don't need to be defined\n#if 0\ntemplate\nstruct version > {\n typedef mpl::integral_c_tag tag;\n typedef mpl::int_<0> type;\n BOOST_STATIC_CONSTANT(int, value = 0);\n};\nstruct version > {\n typedef mpl::integral_c_tag tag;\n typedef mpl::int_<0> type;\n BOOST_STATIC_CONSTANT(int, value = 0);\n};\n\ntemplate\nstruct extended_type_info_impl > {\n typedef extended_type_info_impl< T > type;\n};\n#endif\n\ntemplate\nstruct is_wrapper > {\n typedef boost::mpl::true_ type;\n};\ntemplate\nstruct is_wrapper > {\n typedef boost::mpl::true_ type;\n};\n\n\n} // serialization\n} // boost\n\n\n#endif // BOOST_SERIALIZATION_NVP_HPP\n" }, { "path": "include/boost/serialization/optional.hpp", "content": "/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8\n\n// (C) Copyright 2002-4 Pavel Vozenilek .\n// Use, modification and distribution is subject to the Boost Software\n// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at\n// http://www.boost.org/LICENSE_1_0.txt)\n\n// Provides non-intrusive serialization for boost::optional.\n\n#ifndef BOOST_SERIALIZATION_OPTIONAL_HPP\n#define BOOST_SERIALIZATION_OPTIONAL_HPP\n\n#if defined(_MSC_VER)\n# pragma once\n#endif\n\n#include \n#include \n#ifndef BOOST_NO_CXX17_HDR_OPTIONAL\n#include \n#endif\n\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\n// function specializations must be defined in the appropriate\n// namespace - boost::serialization\nnamespace boost {\nnamespace serialization {\nnamespace detail {\n\n// OT is of the form optional\ntemplate\nvoid save_impl(\n Archive & ar,\n const OT & ot\n){\n // It is an inherent limitation to the serialization of optional.hpp\n // that the underlying type must be either a pointer or must have a\n // default constructor. It's possible that this could change sometime\n // in the future, but for now, one will have to work around it. This can\n // be done by serialization the optional as optional\n #ifndef BOOST_NO_CXX11_HDR_TYPE_TRAITS\n BOOST_STATIC_ASSERT(\n boost::serialization::detail::is_default_constructible::value\n || boost::is_pointer::value\n );\n #endif\n const bool tflag(ot);\n ar << boost::serialization::make_nvp(\"initialized\", tflag);\n if (tflag){\n ar << boost::serialization::make_nvp(\"value\", *ot);\n }\n}\n\n// OT is of the form optional\ntemplate\nvoid load_impl(\n Archive & ar,\n OT & ot,\n const unsigned int version\n){\n bool tflag;\n ar >> boost::serialization::make_nvp(\"initialized\", tflag);\n if(! tflag){\n ot.reset();\n return;\n }\n\n if(0 == version){\n boost::serialization::item_version_type item_version(0);\n boost::serialization::library_version_type library_version(\n ar.get_library_version()\n );\n if(boost::serialization::library_version_type(3) < library_version){\n ar >> BOOST_SERIALIZATION_NVP(item_version);\n }\n }\n typename OT::value_type t;\n ar >> boost::serialization::make_nvp(\"value\",t);\n ot = t;\n}\n\n} // detail\n\ntemplate\nvoid save(\n Archive & ar,\n const boost::optional< T > & ot,\n const unsigned int /*version*/\n){\n detail::save_impl(ar, ot);\n}\n\n#ifndef BOOST_NO_CXX17_HDR_OPTIONAL\ntemplate\nvoid save(\n Archive & ar,\n const std::optional< T > & ot,\n const unsigned int /*version*/\n){\n detail::save_impl(ar, ot);\n}\n#endif\n\ntemplate\nvoid load(\n Archive & ar,\n boost::optional< T > & ot,\n const unsigned int version\n){\n detail::load_impl(ar, ot, version);\n}\n\n#ifndef BOOST_NO_CXX17_HDR_OPTIONAL\ntemplate\nvoid load(\n Archive & ar,\n std::optional< T > & ot,\n const unsigned int version\n){\n detail::load_impl(ar, ot, version);\n}\n#endif\n\ntemplate\nvoid serialize(\n Archive & ar,\n boost::optional< T > & ot,\n const unsigned int version\n){\n boost::serialization::split_free(ar, ot, version);\n}\n\n#ifndef BOOST_NO_CXX17_HDR_OPTIONAL\ntemplate\nvoid serialize(\n Archive & ar,\n std::optional< T > & ot,\n const unsigned int version\n){\n boost::serialization::split_free(ar, ot, version);\n}\n#endif\n\ntemplate\nstruct version >{\n BOOST_STATIC_CONSTANT(int, value = 1);\n};\n\n#ifndef BOOST_NO_CXX17_HDR_OPTIONAL\ntemplate\nstruct version >{\n BOOST_STATIC_CONSTANT(int, value = 1);\n};\n#endif\n\n} // serialization\n} // boost\n\n#endif // BOOST_SERIALIZATION_OPTIONAL_HPP\n" }, { "path": "include/boost/serialization/priority_queue.hpp", "content": "#ifndef BOOST_SERIALIZATION_PRIORITY_QUEUE_HPP\n#define BOOST_SERIALIZATION_PRIORITY_QUEUE_HPP\n\n// MS compatible compilers support #pragma once\n#if defined(_MSC_VER) && (_MSC_VER >= 1020)\n# pragma once\n#endif\n\n/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8\n// priority_queue.hpp\n\n// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .\n// Use, modification and distribution is subject to the Boost Software\n// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at\n// http://www.boost.org/LICENSE_1_0.txt)\n\n// See http://www.boost.org for updates, documentation, and revision history.\n\n#include \n#include \n#include \n#include \n\n// function specializations must be defined in the appropriate\n// namespace - boost::serialization\n#if defined(__SGI_STL_PORT) || defined(_STLPORT_VERSION)\n#define STD _STLP_STD\n#else\n#define STD std\n#endif\n\nnamespace boost {\nnamespace serialization {\nnamespace detail{\n\ntemplate \nstruct priority_queue_save : public STD::priority_queue {\n template\n void operator()(Archive & ar, const unsigned int file_version) const {\n save(ar, STD::priority_queue::c, file_version);\n }\n};\ntemplate \nstruct priority_queue_load : public STD::priority_queue {\n template\n void operator()(Archive & ar, const unsigned int file_version) {\n load(ar, STD::priority_queue::c, file_version);\n }\n};\n\n} // detail\n\ntemplate\ninline void serialize(\n Archive & ar,\n std::priority_queue< T, Container, Compare> & t,\n const unsigned int file_version\n){\n typedef typename mpl::eval_if<\n typename Archive::is_saving,\n mpl::identity >,\n mpl::identity >\n >::type typex;\n static_cast(t)(ar, file_version);\n}\n\n} // namespace serialization\n} // namespace boost\n\n#include \n\nBOOST_SERIALIZATION_COLLECTION_TRAITS(STD::priority_queue)\n\n#undef STD\n\n#endif // BOOST_SERIALIZATION_PRIORITY_QUEUE_HPP\n" }, { "path": "include/boost/serialization/queue.hpp", "content": "#ifndef BOOST_SERIALIZATION_QUEUE_HPP\n#define BOOST_SERIALIZATION_QUEUE_HPP\n\n// MS compatible compilers support #pragma once\n#if defined(_MSC_VER) && (_MSC_VER >= 1020)\n# pragma once\n#endif\n\n/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8\n// queue.hpp\n\n// (C) Copyright 2014 Robert Ramey - http://www.rrsd.com .\n// Use, modification and distribution is subject to the Boost Software\n// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at\n// http://www.boost.org/LICENSE_1_0.txt)\n\n// See http://www.boost.org for updates, documentation, and revision history.\n\n#include \n#include \n#include \n#include \n\n// function specializations must be defined in the appropriate\n// namespace - boost::serialization\n#if defined(__SGI_STL_PORT) || defined(_STLPORT_VERSION)\n#define STD _STLP_STD\n#else\n#define STD std\n#endif\n\nnamespace boost {\nnamespace serialization {\nnamespace detail {\n\ntemplate \nstruct queue_save : public STD::queue {\n template\n void operator()(Archive & ar, const unsigned int file_version) const {\n save(ar, STD::queue::c, file_version);\n }\n};\ntemplate \nstruct queue_load : public STD::queue {\n template\n void operator()(Archive & ar, const unsigned int file_version) {\n load(ar, STD::queue::c, file_version);\n }\n};\n\n} // detail\n\ntemplate\ninline void serialize(\n Archive & ar,\n std::queue< T, C> & t,\n const unsigned int file_version\n){\n typedef typename mpl::eval_if<\n typename Archive::is_saving,\n mpl::identity >,\n mpl::identity >\n >::type typex;\n static_cast(t)(ar, file_version);\n}\n\n} // namespace serialization\n} // namespace boost\n\n#include \n\nBOOST_SERIALIZATION_COLLECTION_TRAITS(STD::queue)\n\n#undef STD\n\n#endif // BOOST_SERIALIZATION_QUEUE_HPP\n" }, { "path": "include/boost/serialization/scoped_ptr.hpp", "content": "#ifndef BOOST_SERIALIZATION_SCOPED_PTR_HPP_VP_2003_10_30\n#define BOOST_SERIALIZATION_SCOPED_PTR_HPP_VP_2003_10_30\n\n#if defined(_MSC_VER)\n# pragma once\n#endif\n\n// Copyright (c) 2003 Vladimir Prus.\n// Use, modification and distribution is subject to the Boost Software\n// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at\n// http://www.boost.org/LICENSE_1_0.txt)\n\n// Provides non-intrusive serialization for boost::scoped_ptr\n// Does not allow to serialize scoped_ptr's to builtin types.\n\n#include \n\n#include \n#include \n#include \n\nnamespace boost {\nnamespace serialization {\n\n template\n void save(\n Archive & ar,\n const boost::scoped_ptr< T > & t,\n const unsigned int /* version */\n ){\n T* r = t.get();\n ar << boost::serialization::make_nvp(\"scoped_ptr\", r);\n }\n\n template\n void load(\n Archive & ar,\n boost::scoped_ptr< T > & t,\n const unsigned int /* version */\n ){\n T* r;\n ar >> boost::serialization::make_nvp(\"scoped_ptr\", r);\n t.reset(r);\n }\n\n template\n void serialize(\n Archive& ar,\n boost::scoped_ptr< T >& t,\n const unsigned int version\n ){\n boost::serialization::split_free(ar, t, version);\n }\n\n} // namespace serialization\n} // namespace boost\n\n#endif // BOOST_SERIALIZATION_SCOPED_PTR_HPP_VP_2003_10_30\n" }, { "path": "include/boost/serialization/serialization.hpp", "content": "#ifndef BOOST_SERIALIZATION_SERIALIZATION_HPP\n#define BOOST_SERIALIZATION_SERIALIZATION_HPP\n\n// MS compatible compilers support #pragma once\n#if defined(_MSC_VER)\n# pragma once\n#endif\n\n#if defined(_MSC_VER)\n# pragma warning (disable : 4675) // suppress ADL warning\n#endif\n\n#include \n#include \n\n/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8\n// serialization.hpp: interface for serialization system.\n\n// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .\n// Use, modification and distribution is subject to the Boost Software\n// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at\n// http://www.boost.org/LICENSE_1_0.txt)\n\n// See http://www.boost.org for updates, documentation, and revision history.\n\n//////////////////////////////////////////////////////////////////////\n// public interface to serialization.\n\n/////////////////////////////////////////////////////////////////////////////\n// layer 0 - intrusive version\n// declared and implemented for each user defined class to be serialized\n//\n// template\n// serialize(Archive &ar, const unsigned int file_version){\n// ar & base_object(*this) & member1 & member2 ... ;\n// }\n\n/////////////////////////////////////////////////////////////////////////////\n// layer 1 - layer that routes member access through the access class.\n// this is what permits us to grant access to private class member functions\n// by specifying friend class boost::serialization::access\n\n#include \n\n/////////////////////////////////////////////////////////////////////////////\n// layer 2 - default implementation of non-intrusive serialization.\n//\n\nnamespace boost {\nnamespace serialization {\n\nBOOST_STRONG_TYPEDEF(unsigned int, version_type)\n\n// default implementation - call the member function \"serialize\"\ntemplate\ninline void serialize(\n Archive & ar, T & t, const unsigned int file_version\n){\n access::serialize(ar, t, static_cast(file_version));\n}\n\n// save data required for construction\ntemplate\ninline void save_construct_data(\n Archive & /*ar*/,\n const T * /*t*/,\n const unsigned int /*file_version */\n){\n // default is to save no data because default constructor\n // requires no arguments.\n}\n\n// load data required for construction and invoke constructor in place\ntemplate\ninline void load_construct_data(\n Archive & /*ar*/,\n T * t,\n const unsigned int /*file_version*/\n){\n // default just uses the default constructor. going\n // through access permits usage of otherwise private default\n // constructor\n access::construct(t);\n}\n\n/////////////////////////////////////////////////////////////////////////////\n// layer 3 - move call into serialization namespace so that ADL will function\n// in the manner we desire.\n//\n// on compilers which don't implement ADL. only the current namespace\n// i.e. boost::serialization will be searched.\n//\n// on compilers which DO implement ADL\n// serialize overrides can be in any of the following\n//\n// 1) same namepace as Archive\n// 2) same namespace as T\n// 3) boost::serialization\n//\n// Due to Martin Ecker\n\ntemplate\ninline void serialize_adl(\n Archive & ar,\n T & t,\n const unsigned int file_version\n){\n const version_type v(file_version);\n serialize(ar, t, v);\n}\n\ntemplate\ninline void save_construct_data_adl(\n Archive & ar,\n const T * t,\n const unsigned int file_version\n){\n\n const version_type v(file_version);\n save_construct_data(ar, t, v);\n}\n\ntemplate\ninline void load_construct_data_adl(\n Archive & ar,\n T * t,\n const unsigned int file_version\n){\n // see above comment\n const version_type v(file_version);\n load_construct_data(ar, t, v);\n}\n\n} // namespace serialization\n} // namespace boost\n\n#endif //BOOST_SERIALIZATION_SERIALIZATION_HPP\n" }, { "path": "include/boost/serialization/set.hpp", "content": "#ifndef BOOST_SERIALIZATION_SET_HPP\n#define BOOST_SERIALIZATION_SET_HPP\n\n// MS compatible compilers support #pragma once\n#if defined(_MSC_VER)\n# pragma once\n#endif\n\n/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8\n// set.hpp: serialization for stl set templates\n\n// (C) Copyright 2002-2014 Robert Ramey - http://www.rrsd.com .\n// Use, modification and distribution is subject to the Boost Software\n// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at\n// http://www.boost.org/LICENSE_1_0.txt)\n\n// See http://www.boost.org for updates, documentation, and revision history.\n\n#include \n\n#include \n\n#include \n#include \n#include \n#include \n#include \n#include \n\n#include \n#include \n#include \n\nnamespace boost {\nnamespace serialization {\n\ntemplate\ninline void load_set_collection(Archive & ar, Container &s)\n{\n s.clear();\n const boost::serialization::library_version_type library_version(\n ar.get_library_version()\n );\n // retrieve number of elements\n item_version_type item_version(0);\n collection_size_type count;\n ar >> BOOST_SERIALIZATION_NVP(count);\n if(boost::serialization::library_version_type(3) < library_version){\n ar >> BOOST_SERIALIZATION_NVP(item_version);\n }\n typename Container::iterator hint;\n hint = s.begin();\n while(count-- > 0){\n typedef typename Container::value_type type;\n detail::stack_construct t(ar, item_version);\n // borland fails silently w/o full namespace\n ar >> boost::serialization::make_nvp(\"item\", t.reference());\n typename Container::iterator result =\n s.insert(hint, boost::move(t.reference()));\n const type * new_address = & (* result);\n ar.reset_object_address(new_address, & t.reference());\n hint = result;\n }\n}\n\ntemplate\ninline void save(\n Archive & ar,\n const std::set &t,\n const unsigned int /* file_version */\n){\n boost::serialization::stl::save_collection<\n Archive, std::set\n >(ar, t);\n}\n\ntemplate\ninline void load(\n Archive & ar,\n std::set &t,\n const unsigned int /* file_version */\n){\n load_set_collection(ar, t);\n}\n\n// split non-intrusive serialization function member into separate\n// non intrusive save/load member functions\ntemplate\ninline void serialize(\n Archive & ar,\n std::set & t,\n const unsigned int file_version\n){\n boost::serialization::split_free(ar, t, file_version);\n}\n\n// multiset\ntemplate\ninline void save(\n Archive & ar,\n const std::multiset &t,\n const unsigned int /* file_version */\n){\n boost::serialization::stl::save_collection<\n Archive,\n std::multiset\n >(ar, t);\n}\n\ntemplate\ninline void load(\n Archive & ar,\n std::multiset &t,\n const unsigned int /* file_version */\n){\n load_set_collection(ar, t);\n}\n\n// split non-intrusive serialization function member into separate\n// non intrusive save/load member functions\ntemplate\ninline void serialize(\n Archive & ar,\n std::multiset & t,\n const unsigned int file_version\n){\n boost::serialization::split_free(ar, t, file_version);\n}\n\n} // namespace serialization\n} // namespace boost\n\n#include \n\nBOOST_SERIALIZATION_COLLECTION_TRAITS(std::set)\nBOOST_SERIALIZATION_COLLECTION_TRAITS(std::multiset)\n\n#endif // BOOST_SERIALIZATION_SET_HPP\n" }, { "path": "include/boost/serialization/shared_ptr.hpp", "content": "#ifndef BOOST_SERIALIZATION_SHARED_PTR_HPP\n#define BOOST_SERIALIZATION_SHARED_PTR_HPP\n\n// MS compatible compilers support #pragma once\n#if defined(_MSC_VER)\n# pragma once\n#endif\n\n/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8\n// shared_ptr.hpp: serialization for boost shared pointer\n\n// (C) Copyright 2004 Robert Ramey and Martin Ecker\n// Use, modification and distribution is subject to the Boost Software\n// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at\n// http://www.boost.org/LICENSE_1_0.txt)\n\n// See http://www.boost.org for updates, documentation, and revision history.\n\n#include // NULL\n#include \n\n#include \n#include \n#include \n\n#include \n#include \n\n#include \n#include \n#include \n#include \n#include \n\n/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8\n// boost:: shared_ptr serialization traits\n// version 1 to distinguish from boost 1.32 version. Note: we can only do this\n// for a template when the compiler supports partial template specialization\n\n#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION\n namespace boost {\n namespace serialization{\n template\n struct version< ::boost::shared_ptr< T > > {\n typedef mpl::integral_c_tag tag;\n #if BOOST_WORKAROUND(__MWERKS__, BOOST_TESTED_AT(0x3206))\n typedef typename mpl::int_<1> type;\n #else\n typedef mpl::int_<1> type;\n #endif\n BOOST_STATIC_CONSTANT(int, value = type::value);\n };\n // don't track shared pointers\n template\n struct tracking_level< ::boost::shared_ptr< T > > {\n typedef mpl::integral_c_tag tag;\n #if BOOST_WORKAROUND(__MWERKS__, BOOST_TESTED_AT(0x3206))\n typedef typename mpl::int_< ::boost::serialization::track_never> type;\n #else\n typedef mpl::int_< ::boost::serialization::track_never> type;\n #endif\n BOOST_STATIC_CONSTANT(int, value = type::value);\n };\n }}\n #define BOOST_SERIALIZATION_SHARED_PTR(T)\n#else\n // define macro to let users of these compilers do this\n #define BOOST_SERIALIZATION_SHARED_PTR(T) \\\n BOOST_CLASS_VERSION( \\\n ::boost::shared_ptr< T >, \\\n 1 \\\n ) \\\n BOOST_CLASS_TRACKING( \\\n ::boost::shared_ptr< T >, \\\n ::boost::serialization::track_never \\\n ) \\\n /**/\n#endif\n\nnamespace boost {\nnamespace serialization{\n\nstruct null_deleter {\n void operator()(void const *) const {}\n};\n\n/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8\n// serialization for boost::shared_ptr\n\n// Using a constant means that all shared pointers are held in the same set.\n// Thus we detect handle multiple pointers to the same value instances\n// in the archive.\nvoid * const shared_ptr_helper_id = 0;\n\ntemplate\ninline void save(\n Archive & ar,\n const boost::shared_ptr< T > &t,\n const unsigned int /* file_version */\n){\n // The most common cause of trapping here would be serializing\n // something like shared_ptr. This occurs because int\n // is never tracked by default. Wrap int in a trackable type\n BOOST_STATIC_ASSERT((tracking_level< T >::value != track_never));\n const T * t_ptr = t.get();\n ar << boost::serialization::make_nvp(\"px\", t_ptr);\n}\n\n#ifdef BOOST_SERIALIZATION_SHARED_PTR_132_HPP\ntemplate\ninline void load(\n Archive & ar,\n boost::shared_ptr< T > &t,\n const unsigned int file_version\n){\n // something like shared_ptr. This occurs because int\n // is never tracked by default. Wrap int in a trackable type\n BOOST_STATIC_ASSERT((tracking_level< T >::value != track_never));\n T* r;\n if(file_version < 1){\n ar.register_type(static_cast<\n boost_132::detail::sp_counted_base_impl *\n >(NULL));\n boost_132::shared_ptr< T > sp;\n ar >> boost::serialization::make_nvp(\"px\", sp.px);\n ar >> boost::serialization::make_nvp(\"pn\", sp.pn);\n // got to keep the sps around so the sp.pns don't disappear\n boost::serialization::shared_ptr_helper & h =\n ar.template get_helper< shared_ptr_helper >(\n shared_ptr_helper_id\n );\n h.append(sp);\n r = sp.get();\n }\n else{\n ar >> boost::serialization::make_nvp(\"px\", r);\n }\n shared_ptr_helper & h =\n ar.template get_helper >(\n shared_ptr_helper_id\n );\n h.reset(t,r);\n}\n#else\n\ntemplate\ninline void load(\n Archive & ar,\n boost::shared_ptr< T > &t,\n const unsigned int /*file_version*/\n){\n // The most common cause of trapping here would be serializing\n // something like shared_ptr. This occurs because int\n // is never tracked by default. Wrap int in a trackable type\n BOOST_STATIC_ASSERT((tracking_level< T >::value != track_never));\n T* r;\n ar >> boost::serialization::make_nvp(\"px\", r);\n\n boost::serialization::shared_ptr_helper & h =\n ar.template get_helper >(\n shared_ptr_helper_id\n );\n h.reset(t,r);\n}\n#endif\n\ntemplate\ninline void serialize(\n Archive & ar,\n boost::shared_ptr< T > &t,\n const unsigned int file_version\n){\n // correct shared_ptr serialization depends upon object tracking\n // being used.\n BOOST_STATIC_ASSERT(\n boost::serialization::tracking_level< T >::value\n != boost::serialization::track_never\n );\n boost::serialization::split_free(ar, t, file_version);\n}\n\n} // namespace serialization\n} // namespace boost\n\n/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8\n// std::shared_ptr serialization traits\n// version 1 to distinguish from boost 1.32 version. Note: we can only do this\n// for a template when the compiler supports partial template specialization\n\n#ifndef BOOST_NO_CXX11_SMART_PTR\n#include \n\n// note: we presume that any compiler/library which supports C++11\n// std::pointers also supports template partial specialization\n// trap here if such presumption were to turn out to wrong!!!\n#ifdef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION\n BOOST_STATIC_ASSERT(false);\n#endif\n\nnamespace boost {\nnamespace serialization{\n template\n struct version< ::std::shared_ptr< T > > {\n typedef mpl::integral_c_tag tag;\n typedef mpl::int_<1> type;\n BOOST_STATIC_CONSTANT(int, value = type::value);\n };\n // don't track shared pointers\n template\n struct tracking_level< ::std::shared_ptr< T > > {\n typedef mpl::integral_c_tag tag;\n typedef mpl::int_< ::boost::serialization::track_never> type;\n BOOST_STATIC_CONSTANT(int, value = type::value);\n };\n}}\n// the following just keeps older programs from breaking\n#define BOOST_SERIALIZATION_SHARED_PTR(T)\n\nnamespace boost {\nnamespace serialization{\n\n/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8\n// serialization for std::shared_ptr\n\ntemplate\ninline void save(\n Archive & ar,\n const std::shared_ptr< T > &t,\n const unsigned int /* file_version */\n){\n // The most common cause of trapping here would be serializing\n // something like shared_ptr. This occurs because int\n // is never tracked by default. Wrap int in a trackable type\n BOOST_STATIC_ASSERT((tracking_level< T >::value != track_never));\n const T * t_ptr = t.get();\n ar << boost::serialization::make_nvp(\"px\", t_ptr);\n}\n\ntemplate\ninline void load(\n Archive & ar,\n std::shared_ptr< T > &t,\n const unsigned int /*file_version*/\n){\n // The most common cause of trapping here would be serializing\n // something like shared_ptr. This occurs because int\n // is never tracked by default. Wrap int in a trackable type\n BOOST_STATIC_ASSERT((tracking_level< T >::value != track_never));\n T* r;\n ar >> boost::serialization::make_nvp(\"px\", r);\n //void (* const id)(Archive &, std::shared_ptr< T > &, const unsigned int) = & load;\n boost::serialization::shared_ptr_helper & h =\n ar.template get_helper<\n shared_ptr_helper\n >(\n shared_ptr_helper_id\n );\n h.reset(t,r);\n}\n\ntemplate\ninline void serialize(\n Archive & ar,\n std::shared_ptr< T > &t,\n const unsigned int file_version\n){\n // correct shared_ptr serialization depends upon object tracking\n // being used.\n BOOST_STATIC_ASSERT(\n boost::serialization::tracking_level< T >::value\n != boost::serialization::track_never\n );\n boost::serialization::split_free(ar, t, file_version);\n}\n\n} // namespace serialization\n} // namespace boost\n\n#endif // BOOST_NO_CXX11_SMART_PTR\n\n#endif // BOOST_SERIALIZATION_SHARED_PTR_HPP\n" }, { "path": "include/boost/serialization/shared_ptr_132.hpp", "content": "#ifndef BOOST_SERIALIZATION_SHARED_PTR_132_HPP\n#define BOOST_SERIALIZATION_SHARED_PTR_132_HPP\n\n// MS compatible compilers support #pragma once\n#if defined(_MSC_VER)\n# pragma once\n#endif\n\n/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8\n// shared_ptr.hpp: serialization for boost shared pointer\n\n// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .\n// Use, modification and distribution is subject to the Boost Software\n// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at\n// http://www.boost.org/LICENSE_1_0.txt)\n\n// See http://www.boost.org for updates, documentation, and revision history.\n\n// note: totally unadvised hack to gain access to private variables\n// in shared_ptr and shared_count. Unfortunately its the only way to\n// do this without changing shared_ptr and shared_count\n// the best we can do is to detect a conflict here\n#include \n\n#include \n#include // NULL\n\n#include \n#include \n#include \n#include \n#include \n\n// mark base class as an (uncreatable) base class\n#include \n\n/////////////////////////////////////////////////////////////\n// Maintain a couple of lists of loaded shared pointers of the old previous\n// version (1.32)\n\nnamespace boost_132 {\nnamespace serialization {\nnamespace detail {\n\nstruct null_deleter {\n void operator()(void const *) const {}\n};\n\n} // namespace detail\n} // namespace serialization\n} // namespace boost_132\n\n/////////////////////////////////////////////////////////////\n// sp_counted_base_impl serialization\n\nnamespace boost {\nnamespace serialization {\n\ntemplate\ninline void serialize(\n Archive & /* ar */,\n boost_132::detail::sp_counted_base_impl & /* t */,\n const unsigned int /*file_version*/\n){\n // register the relationship between each derived class\n // its polymorphic base\n boost::serialization::void_cast_register<\n boost_132::detail::sp_counted_base_impl,\n boost_132::detail::sp_counted_base\n >(\n static_cast *>(NULL),\n static_cast(NULL)\n );\n}\n\ntemplate\ninline void save_construct_data(\n Archive & ar,\n const\n boost_132::detail::sp_counted_base_impl *t,\n const unsigned int /* file_version */\n){\n // variables used for construction\n ar << boost::serialization::make_nvp(\"ptr\", t->ptr);\n}\n\ntemplate\ninline void load_construct_data(\n Archive & ar,\n boost_132::detail::sp_counted_base_impl * t,\n const unsigned int /* file_version */\n){\n P ptr_;\n ar >> boost::serialization::make_nvp(\"ptr\", ptr_);\n // ::new(t)boost_132::detail::sp_counted_base_impl(ptr_, D());\n // placement\n // note: the original ::new... above is replaced by the one here. This one\n // creates all new objects with a null_deleter so that after the archive\n // is finished loading and the shared_ptrs are destroyed - the underlying\n // raw pointers are NOT deleted. This is necessary as they are used by the\n // new system as well.\n ::new(t)boost_132::detail::sp_counted_base_impl<\n P,\n boost_132::serialization::detail::null_deleter\n >(\n ptr_, boost_132::serialization::detail::null_deleter()\n ); // placement new\n // compensate for that fact that a new shared count always is\n // initialized with one. the add_ref_copy below will increment it\n // every time its serialized so without this adjustment\n // the use and weak counts will be off by one.\n t->use_count_ = 0;\n}\n\n} // serialization\n} // namespace boost\n\n/////////////////////////////////////////////////////////////\n// shared_count serialization\n\nnamespace boost {\nnamespace serialization {\n\ntemplate\ninline void save(\n Archive & ar,\n const boost_132::detail::shared_count &t,\n const unsigned int /* file_version */\n){\n ar << boost::serialization::make_nvp(\"pi\", t.pi_);\n}\n\ntemplate\ninline void load(\n Archive & ar,\n boost_132::detail::shared_count &t,\n const unsigned int /* file_version */\n){\n ar >> boost::serialization::make_nvp(\"pi\", t.pi_);\n if(NULL != t.pi_)\n t.pi_->add_ref_copy();\n}\n\n} // serialization\n} // namespace boost\n\nBOOST_SERIALIZATION_SPLIT_FREE(boost_132::detail::shared_count)\n\n/////////////////////////////////////////////////////////////\n// implement serialization for shared_ptr< T >\n\nnamespace boost {\nnamespace serialization {\n\ntemplate\ninline void save(\n Archive & ar,\n const boost_132::shared_ptr< T > &t,\n const unsigned int /* file_version */\n){\n // only the raw pointer has to be saved\n // the ref count is maintained automatically as shared pointers are loaded\n ar.register_type(static_cast<\n boost_132::detail::sp_counted_base_impl > *\n >(NULL));\n ar << boost::serialization::make_nvp(\"px\", t.px);\n ar << boost::serialization::make_nvp(\"pn\", t.pn);\n}\n\ntemplate\ninline void load(\n Archive & ar,\n boost_132::shared_ptr< T > &t,\n const unsigned int /* file_version */\n){\n // only the raw pointer has to be saved\n // the ref count is maintained automatically as shared pointers are loaded\n ar.register_type(static_cast<\n boost_132::detail::sp_counted_base_impl > *\n >(NULL));\n ar >> boost::serialization::make_nvp(\"px\", t.px);\n ar >> boost::serialization::make_nvp(\"pn\", t.pn);\n}\n\ntemplate\ninline void serialize(\n Archive & ar,\n boost_132::shared_ptr< T > &t,\n const unsigned int file_version\n){\n // correct shared_ptr serialization depends upon object tracking\n // being used.\n BOOST_STATIC_ASSERT(\n boost::serialization::tracking_level< T >::value\n != boost::serialization::track_never\n );\n boost::serialization::split_free(ar, t, file_version);\n}\n\n} // serialization\n} // namespace boost\n\n// note: change below uses null_deleter\n// This macro is used to export GUIDS for shared pointers to allow\n// the serialization system to export them properly. David Tonge\n#define BOOST_SHARED_POINTER_EXPORT_GUID(T, K) \\\n typedef boost_132::detail::sp_counted_base_impl< \\\n T *, \\\n boost::checked_deleter< T > \\\n > __shared_ptr_ ## T; \\\n BOOST_CLASS_EXPORT_GUID(__shared_ptr_ ## T, \"__shared_ptr_\" K) \\\n BOOST_CLASS_EXPORT_GUID(T, K) \\\n /**/\n\n#define BOOST_SHARED_POINTER_EXPORT(T) \\\n BOOST_SHARED_POINTER_EXPORT_GUID( \\\n T, \\\n BOOST_PP_STRINGIZE(T) \\\n ) \\\n /**/\n\n#endif // BOOST_SERIALIZATION_SHARED_PTR_132_HPP\n" }, { "path": "include/boost/serialization/shared_ptr_helper.hpp", "content": "#ifndef BOOST_SERIALIZATION_SHARED_PTR_HELPER_HPP\n#define BOOST_SERIALIZATION_SHARED_PTR_HELPER_HPP\n\n// MS compatible compilers support #pragma once\n#if defined(_MSC_VER)\n# pragma once\n#endif\n\n/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8\n// shared_ptr_helper.hpp: serialization for boost shared pointer\n\n// (C) Copyright 2004-2009 Robert Ramey, Martin Ecker and Takatoshi Kondo\n// Use, modification and distribution is subject to the Boost Software\n// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at\n// http://www.boost.org/LICENSE_1_0.txt)\n\n// See http://www.boost.org for updates, documentation, and revision history.\n\n#include \n#include \n#include \n#include // NULL\n\n#include \n#include \n#include \n#include \n\n#include \n#include \n#include \n#include \n#include \n\nnamespace boost_132 {\n template class shared_ptr;\n}\nnamespace boost {\nnamespace serialization {\n\n#ifndef BOOST_NO_MEMBER_TEMPLATE_FRIENDS\ntemplate class SPT >\nvoid load(\n Archive & ar,\n SPT< class U > &t,\n const unsigned int file_version\n);\n#endif\n\n/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8\n// a common class for holding various types of shared pointers\n\ntemplate class SPT>\nclass shared_ptr_helper {\n typedef std::map<\n const void *, // address of object\n SPT // address shared ptr to single instance\n > object_shared_pointer_map;\n\n // list of shared_pointers create accessible by raw pointer. This\n // is used to \"match up\" shared pointers loaded at different\n // points in the archive. Note, we delay construction until\n // it is actually used since this is by default included as\n // a \"mix-in\" even if shared_ptr isn't used.\n object_shared_pointer_map * m_o_sp;\n\n struct null_deleter {\n void operator()(void const *) const {}\n };\n\n#if defined(BOOST_NO_MEMBER_TEMPLATE_FRIENDS) \\\n|| defined(BOOST_MSVC) \\\n|| defined(__SUNPRO_CC)\npublic:\n#else\n template\n friend void boost::serialization::load(\n Archive & ar,\n SPT< U > &t,\n const unsigned int file_version\n );\n#endif\n\n #ifdef BOOST_SERIALIZATION_SHARED_PTR_132_HPP\n // list of loaded pointers. This is used to be sure that the pointers\n // stay around long enough to be \"matched\" with other pointers loaded\n // by the same archive. These are created with a \"null_deleter\" so that\n // when this list is destroyed - the underlying raw pointers are not\n // destroyed. This has to be done because the pointers are also held by\n // new system which is disjoint from this set. This is implemented\n // by a change in load_construct_data below. It makes this file suitable\n // only for loading pointers into a 1.33 or later boost system.\n std::list > * m_pointers_132;\n void\n append(const boost_132::shared_ptr & t){\n if(NULL == m_pointers_132)\n m_pointers_132 = new std::list >;\n m_pointers_132->push_back(t);\n }\n #endif\n\n struct non_polymorphic {\n template\n static const boost::serialization::extended_type_info *\n get_object_type(U & ){\n return & boost::serialization::singleton<\n typename\n boost::serialization::type_info_implementation< U >::type\n >::get_const_instance();\n }\n };\n struct polymorphic {\n template\n static const boost::serialization::extended_type_info *\n get_object_type(U & u){\n return boost::serialization::singleton<\n typename\n boost::serialization::type_info_implementation< U >::type\n >::get_const_instance().get_derived_extended_type_info(u);\n }\n };\n\npublic:\n template\n void reset(SPT< T > & s, T * t){\n if(NULL == t){\n s.reset();\n return;\n }\n const boost::serialization::extended_type_info * this_type\n = & boost::serialization::type_info_implementation< T >::type\n ::get_const_instance();\n\n // get pointer to the most derived object's eti. This is effectively\n // the object type identifier\n typedef typename mpl::if_<\n is_polymorphic< T >,\n polymorphic,\n non_polymorphic\n >::type type;\n\n const boost::serialization::extended_type_info * true_type\n = type::get_object_type(*t);\n\n // note:if this exception is thrown, be sure that derived pointer\n // is either registered or exported.\n if(NULL == true_type)\n boost::serialization::throw_exception(\n boost::archive::archive_exception(\n boost::archive::archive_exception::unregistered_class,\n this_type->get_debug_info()\n )\n );\n // get void pointer to the most derived type\n // this uniquely identifies the object referred to\n // oid = \"object identifier\"\n const void * oid = void_downcast(\n *true_type,\n *this_type,\n t\n );\n if(NULL == oid)\n boost::serialization::throw_exception(\n boost::archive::archive_exception(\n boost::archive::archive_exception::unregistered_cast,\n true_type->get_debug_info(),\n this_type->get_debug_info()\n )\n );\n\n // make tracking array if necessary\n if(NULL == m_o_sp)\n m_o_sp = new object_shared_pointer_map;\n\n typename object_shared_pointer_map::iterator i = m_o_sp->find(oid);\n\n // if it's a new object\n if(i == m_o_sp->end()){\n s.reset(t);\n std::pair result;\n result = m_o_sp->insert(std::make_pair(oid, s));\n BOOST_ASSERT(result.second);\n }\n // if the object has already been seen\n else{\n s = SPT(i->second, t);\n }\n }\n\n shared_ptr_helper() :\n m_o_sp(NULL)\n #ifdef BOOST_SERIALIZATION_SHARED_PTR_132_HPP\n , m_pointers_132(NULL)\n #endif\n {}\n virtual ~shared_ptr_helper(){\n if(NULL != m_o_sp)\n delete m_o_sp;\n #ifdef BOOST_SERIALIZATION_SHARED_PTR_132_HPP\n if(NULL != m_pointers_132)\n delete m_pointers_132;\n #endif\n }\n};\n\n} // namespace serialization\n} // namespace boost\n\n#endif // BOOST_SERIALIZATION_SHARED_PTR_HELPER_HPP\n" }, { "path": "include/boost/serialization/singleton.hpp", "content": "#ifndef BOOST_SERIALIZATION_SINGLETON_HPP\n#define BOOST_SERIALIZATION_SINGLETON_HPP\n\n/////////1/////////2///////// 3/////////4/////////5/////////6/////////7/////////8\n// singleton.hpp\n//\n// Copyright David Abrahams 2006. Original version\n//\n// Copyright Robert Ramey 2007. Changes made to permit\n// application throughout the serialization library.\n//\n// Copyright Alexander Grund 2018. Corrections to singleton lifetime\n//\n// Distributed under the Boost\n// Software License, Version 1.0. (See accompanying\n// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)\n//\n// The intention here is to define a template which will convert\n// any class into a singleton with the following features:\n//\n// a) initialized before first use.\n// b) thread-safe for const access to the class\n// c) non-locking\n//\n// In order to do this,\n// a) Initialize dynamically when used.\n// b) Require that all singletons be initialized before main\n// is called or any entry point into the shared library is invoked.\n// This guarantees no race condition for initialization.\n// In debug mode, we assert that no non-const functions are called\n// after main is invoked.\n//\n\n// MS compatible compilers support #pragma once\n#if defined(_MSC_VER)\n# pragma once\n#endif\n\n#include \n#include \n#include \n#include \n#include \n\n#include \n#include // must be the last header\n\n#ifdef BOOST_MSVC\n# pragma warning(push)\n# pragma warning(disable : 4511 4512)\n#endif\n\nnamespace boost {\nnamespace serialization {\n\n//////////////////////////////////////////////////////////////////////\n// Provides a dynamically-initialized (singleton) instance of T in a\n// way that avoids LNK1179 on vc6. See http://tinyurl.com/ljdp8 or\n// http://lists.boost.org/Archives/boost/2006/05/105286.php for\n// details.\n//\n\n// Singletons created by this code are guaranteed to be unique\n// within the executable or shared library which creates them.\n// This is sufficient and in fact ideal for the serialization library.\n// The singleton is created when the module is loaded and destroyed\n// when the module is unloaded.\n\n// This base class has two functions.\n\n// First it provides a module handle for each singleton indicating\n// the executable or shared library in which it was created. This\n// turns out to be necessary and sufficient to implement the tables\n// used by serialization library.\n\n// Second, it provides a mechanism to detect when a non-const function\n// is called after initialization.\n\n// Make a singleton to lock/unlock all singletons for alteration.\n// The intent is that all singletons created/used by this code\n// are to be initialized before main is called. A test program\n// can lock all the singletons when main is entered. Thus any\n// attempt to retrieve a mutable instance while locked will\n// generate an assertion if compiled for debug.\n\n// The singleton template can be used in 2 ways:\n// 1 (Recommended): Publicly inherit your type T from singleton,\n// make its ctor protected and access it via T::get_const_instance()\n// 2: Simply access singleton without changing T. Note that this only\n// provides a global instance accessible by singleton::get_const_instance()\n// or singleton::get_mutable_instance() to prevent using multiple instances\n// of T make its ctor protected\n\n// Note on usage of BOOST_DLLEXPORT: These functions are in danger of\n// being eliminated by the optimizer when building an application in\n// release mode. Usage of the macro is meant to signal the compiler/linker\n// to avoid dropping these functions which seem to be unreferenced.\n// This usage is not related to autolinking.\n\nclass BOOST_SYMBOL_VISIBLE singleton_module :\n public boost::noncopyable\n{\nprivate:\n BOOST_DLLEXPORT bool & get_lock() BOOST_USED {\n static bool lock = false;\n return lock;\n }\n\npublic:\n BOOST_DLLEXPORT void lock(){\n get_lock() = true;\n }\n BOOST_DLLEXPORT void unlock(){\n get_lock() = false;\n }\n BOOST_DLLEXPORT bool is_locked(){\n return get_lock();\n }\n};\n\nstatic inline singleton_module & get_singleton_module(){\n static singleton_module m;\n return m;\n}\n\nnamespace detail {\n\n// This is the class actually instantiated and hence the real singleton.\n// So there will only be one instance of this class. This does not hold\n// for singleton as a class derived from singleton could be\n// instantiated multiple times.\n// It also provides a flag `is_destroyed` which returns true, when the\n// class was destructed. It is static and hence accessible even after\n// destruction. This can be used to check, if the singleton is still\n// accessible e.g. in destructors of other singletons.\ntemplate\nclass singleton_wrapper : public T\n{\n static bool & get_is_destroyed(){\n // Prefer a static function member to avoid LNK1179.\n // Note: As this is for a singleton (1 instance only) it must be set\n // never be reset (to false)!\n static bool is_destroyed_flag = false;\n return is_destroyed_flag;\n }\npublic:\n singleton_wrapper(){\n BOOST_ASSERT(! is_destroyed());\n }\n ~singleton_wrapper(){\n get_is_destroyed() = true;\n }\n static bool is_destroyed(){\n return get_is_destroyed();\n }\n};\n\n} // detail\n\ntemplate \nclass singleton {\nprivate:\n static T * m_instance;\n // include this to provoke instantiation at pre-execution time\n static void use(T const &) {}\n static T & get_instance() {\n BOOST_ASSERT(! is_destroyed());\n\n // use a wrapper so that types T with protected constructors can be used\n // Using a static function member avoids LNK1179\n static detail::singleton_wrapper< T > t;\n\n // note that the following is absolutely essential.\n // commenting out this statement will cause compilers to fail to\n // construct the instance at pre-execution time. This would prevent\n // our usage/implementation of \"locking\" and introduce uncertainty into\n // the sequence of object initialization.\n // Unfortunately, this triggers detectors of undefined behavior\n // and reports an error. But I've been unable to find a different way\n // of guaranteeing that the the singleton is created at pre-main time.\n if (m_instance) use(* m_instance);\n\n return static_cast(t);\n }\nprotected:\n // Do not allow instantiation of a singleton. But we want to allow\n // `class T: public singleton` so we can't delete this ctor\n BOOST_DLLEXPORT singleton(){}\n\npublic:\n BOOST_DLLEXPORT static T & get_mutable_instance(){\n BOOST_ASSERT(! get_singleton_module().is_locked());\n return get_instance();\n }\n BOOST_DLLEXPORT static const T & get_const_instance(){\n return get_instance();\n }\n BOOST_DLLEXPORT static bool is_destroyed(){\n return detail::singleton_wrapper< T >::is_destroyed();\n }\n};\n\n// Assigning the instance reference to a static member forces initialization\n// at startup time as described in\n// https://groups.google.com/forum/#!topic/microsoft.public.vc.language/kDVNLnIsfZk\ntemplate\nT * singleton< T >::m_instance = & singleton< T >::get_instance();\n\n} // namespace serialization\n} // namespace boost\n\n#include // pops abi_suffix.hpp pragmas\n\n#ifdef BOOST_MSVC\n#pragma warning(pop)\n#endif\n\n#endif // BOOST_SERIALIZATION_SINGLETON_HPP\n" }, { "path": "include/boost/serialization/slist.hpp", "content": "#ifndef BOOST_SERIALIZATION_SLIST_HPP\n#define BOOST_SERIALIZATION_SLIST_HPP\n\n// MS compatible compilers support #pragma once\n#if defined(_MSC_VER)\n# pragma once\n#endif\n\n/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8\n// slist.hpp\n\n// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .\n// Use, modification and distribution is subject to the Boost Software\n// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at\n// http://www.boost.org/LICENSE_1_0.txt)\n\n// See http://www.boost.org for updates, documentation, and revision history.\n\n#include \n#ifdef BOOST_HAS_SLIST\n#include BOOST_SLIST_HEADER\n\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nnamespace boost {\nnamespace serialization {\n\ntemplate\ninline void save(\n Archive & ar,\n const BOOST_STD_EXTENSION_NAMESPACE::slist &t,\n const unsigned int file_version\n){\n boost::serialization::stl::save_collection<\n Archive,\n BOOST_STD_EXTENSION_NAMESPACE::slist\n >(ar, t);\n}\n\nnamespace stl {\n\ntemplate<\n class Archive,\n class T,\n class Allocator\n>\ntypename boost::disable_if<\n typename detail::is_default_constructible<\n typename BOOST_STD_EXTENSION_NAMESPACE::slist::value_type\n >,\n void\n>::type\ncollection_load_impl(\n Archive & ar,\n BOOST_STD_EXTENSION_NAMESPACE::slist &t,\n collection_size_type count,\n item_version_type item_version\n){\n t.clear();\n boost::serialization::detail::stack_construct u(ar, item_version);\n ar >> boost::serialization::make_nvp(\"item\", u.reference());\n t.push_front(boost::move(u.reference()));\n typename BOOST_STD_EXTENSION_NAMESPACE::slist::iterator last;\n last = t.begin();\n ar.reset_object_address(&(*t.begin()) , & u.reference());\n while(--count > 0){\n detail::stack_construct u(ar, item_version);\n ar >> boost::serialization::make_nvp(\"item\", u.reference());\n last = t.insert_after(last, boost::move(u.reference()));\n ar.reset_object_address(&(*last) , & u.reference());\n }\n}\n\n} // stl\n\ntemplate\ninline void load(\n Archive & ar,\n BOOST_STD_EXTENSION_NAMESPACE::slist &t,\n const unsigned int file_version\n){\n const boost::serialization::library_version_type library_version(\n ar.get_library_version()\n );\n // retrieve number of elements\n item_version_type item_version(0);\n collection_size_type count;\n ar >> BOOST_SERIALIZATION_NVP(count);\n if(boost::serialization::library_version_type(3) < library_version){\n ar >> BOOST_SERIALIZATION_NVP(item_version);\n }\n if(detail::is_default_constructible()){\n t.resize(count);\n typename BOOST_STD_EXTENSION_NAMESPACE::slist::iterator hint;\n hint = t.begin();\n while(count-- > 0){\n ar >> boost::serialization::make_nvp(\"item\", *hint++);\n }\n }\n else{\n t.clear();\n boost::serialization::detail::stack_construct u(ar, item_version);\n ar >> boost::serialization::make_nvp(\"item\", u.reference());\n t.push_front(boost::move(u.reference()));\n typename BOOST_STD_EXTENSION_NAMESPACE::slist::iterator last;\n last = t.begin();\n ar.reset_object_address(&(*t.begin()) , & u.reference());\n while(--count > 0){\n detail::stack_construct u(ar, item_version);\n ar >> boost::serialization::make_nvp(\"item\", u.reference());\n last = t.insert_after(last, boost::move(u.reference()));\n ar.reset_object_address(&(*last) , & u.reference());\n }\n }\n}\n\n// split non-intrusive serialization function member into separate\n// non intrusive save/load member functions\ntemplate\ninline void serialize(\n Archive & ar,\n BOOST_STD_EXTENSION_NAMESPACE::slist &t,\n const unsigned int file_version\n){\n boost::serialization::split_free(ar, t, file_version);\n}\n\n} // serialization\n} // namespace boost\n\n#include \n\nBOOST_SERIALIZATION_COLLECTION_TRAITS(BOOST_STD_EXTENSION_NAMESPACE::slist)\n\n#endif // BOOST_HAS_SLIST\n#endif // BOOST_SERIALIZATION_SLIST_HPP\n" }, { "path": "include/boost/serialization/smart_cast.hpp", "content": "#ifndef BOOST_SERIALIZATION_SMART_CAST_HPP\n#define BOOST_SERIALIZATION_SMART_CAST_HPP\n\n// MS compatible compilers support #pragma once\n#if defined(_MSC_VER)\n# pragma once\n#endif\n\n/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8\n// smart_cast.hpp:\n\n// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .\n// Use, modification and distribution is subject to the Boost Software\n// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at\n// http://www.boost.org/LICENSE_1_0.txt)\n\n// See http://www.boost.org/libs/serialization for updates, documentation, and revision history.\n\n// casting of pointers and references.\n\n// In casting between different C++ classes, there are a number of\n// rules that have to be kept in mind in deciding whether to use\n// static_cast or dynamic_cast.\n\n// a) dynamic casting can only be applied when one of the types is polymorphic\n// Otherwise static_cast must be used.\n// b) only dynamic casting can do runtime error checking\n// use of static_cast is generally un checked even when compiled for debug\n// c) static_cast would be considered faster than dynamic_cast.\n\n// If casting is applied to a template parameter, there is no apriori way\n// to know which of the two casting methods will be permitted or convenient.\n\n// smart_cast uses C++ type_traits, and program debug mode to select the\n// most convenient cast to use.\n\n#include \n#include \n#include // NULL\n\n#include \n#include \n\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\n#include \n#include \n#include \n#include \n#include \n#include \n\n#include \n\nnamespace boost {\nnamespace serialization {\nnamespace smart_cast_impl {\n\n template\n struct reference {\n\n struct polymorphic {\n\n struct linear {\n template\n static T cast(U & u){\n return static_cast< T >(u);\n }\n };\n\n struct cross {\n template\n static T cast(U & u){\n return dynamic_cast< T >(u);\n }\n };\n\n template\n static T cast(U & u){\n // if we're in debug mode\n #if ! defined(NDEBUG) \\\n || defined(__MWERKS__)\n // do a checked dynamic cast\n return cross::cast(u);\n #else\n // borland 5.51 chokes here so we can't use it\n // note: if remove_reference isn't function for these types\n // cross casting will be selected this will work but will\n // not be the most efficient method. This will conflict with\n // the original smart_cast motivation.\n typedef typename mpl::eval_if<\n typename mpl::and_<\n mpl::not_::type,\n U\n > >,\n mpl::not_::type\n > >\n >,\n // borland chokes w/o full qualification here\n mpl::identity,\n mpl::identity\n >::type typex;\n // typex works around gcc 2.95 issue\n return typex::cast(u);\n #endif\n }\n };\n\n struct non_polymorphic {\n template\n static T cast(U & u){\n return static_cast< T >(u);\n }\n };\n template\n static T cast(U & u){\n typedef typename mpl::eval_if<\n boost::is_polymorphic,\n mpl::identity,\n mpl::identity\n >::type typex;\n return typex::cast(u);\n }\n };\n\n template\n struct pointer {\n\n struct polymorphic {\n // unfortunately, this below fails to work for virtual base\n // classes. need has_virtual_base to do this.\n // Subject for further study\n #if 0\n struct linear {\n template\n static T cast(U * u){\n return static_cast< T >(u);\n }\n };\n\n struct cross {\n template\n static T cast(U * u){\n T tmp = dynamic_cast< T >(u);\n #ifndef NDEBUG\n if ( tmp == 0 ) throw_exception(std::bad_cast());\n #endif\n return tmp;\n }\n };\n\n template\n static T cast(U * u){\n typedef\n typename mpl::eval_if<\n typename mpl::and_<\n mpl::not_::type,\n U\n > >,\n mpl::not_::type\n > >\n >,\n // borland chokes w/o full qualification here\n mpl::identity,\n mpl::identity\n >::type typex;\n return typex::cast(u);\n }\n #else\n template\n static T cast(U * u){\n T tmp = dynamic_cast< T >(u);\n #ifndef NDEBUG\n if ( tmp == 0 ) throw_exception(std::bad_cast());\n #endif\n return tmp;\n }\n #endif\n };\n\n struct non_polymorphic {\n template\n static T cast(U * u){\n return static_cast< T >(u);\n }\n };\n\n template\n static T cast(U * u){\n typedef typename mpl::eval_if<\n boost::is_polymorphic,\n mpl::identity,\n mpl::identity\n >::type typex;\n return typex::cast(u);\n }\n\n };\n\n template\n struct void_pointer {\n template\n static TPtr cast(UPtr uptr){\n return static_cast(uptr);\n }\n };\n\n template\n struct error {\n // if we get here, its because we are using one argument in the\n // cast on a system which doesn't support partial template\n // specialization\n template\n static T cast(U){\n BOOST_STATIC_ASSERT(sizeof(T)==0);\n return * static_cast(NULL);\n }\n };\n\n} // smart_cast_impl\n\n// this implements:\n// smart_cast(Source * s)\n// smart_cast(s)\n// note that it will fail with\n// smart_cast(s)\ntemplate\nT smart_cast(U u) {\n typedef\n typename mpl::eval_if<\n typename mpl::or_<\n boost::is_same,\n boost::is_same,\n boost::is_same,\n boost::is_same\n >,\n mpl::identity >,\n // else\n typename mpl::eval_if,\n mpl::identity >,\n // else\n typename mpl::eval_if,\n mpl::identity >,\n // else\n mpl::identity\n >\n >\n >\n >::type typex;\n return typex::cast(u);\n}\n\n// this implements:\n// smart_cast_reference(Source & s)\ntemplate\nT smart_cast_reference(U & u) {\n return smart_cast_impl::reference< T >::cast(u);\n}\n\n} // namespace serialization\n} // namespace boost\n\n#endif // BOOST_SERIALIZATION_SMART_CAST_HPP\n" }, { "path": "include/boost/serialization/split_free.hpp", "content": "#ifndef BOOST_SERIALIZATION_SPLIT_FREE_HPP\n#define BOOST_SERIALIZATION_SPLIT_FREE_HPP\n\n// MS compatible compilers support #pragma once\n#if defined(_MSC_VER)\n# pragma once\n#endif\n\n/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8\n// split_free.hpp:\n\n// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .\n// Use, modification and distribution is subject to the Boost Software\n// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at\n// http://www.boost.org/LICENSE_1_0.txt)\n\n// See http://www.boost.org for updates, documentation, and revision history.\n\n#include \n#include \n#include \n#include \n\nnamespace boost {\nnamespace archive {\n namespace detail {\n template class interface_oarchive;\n template class interface_iarchive;\n } // namespace detail\n} // namespace archive\n\nnamespace serialization {\n\ntemplate\nstruct free_saver {\n static void invoke(\n Archive & ar,\n const T & t,\n const unsigned int file_version\n ){\n // use function overload (version_type) to workaround\n // two-phase lookup issue\n const version_type v(file_version);\n save(ar, t, v);\n }\n};\ntemplate\nstruct free_loader {\n static void invoke(\n Archive & ar,\n T & t,\n const unsigned int file_version\n ){\n // use function overload (version_type) to workaround\n // two-phase lookup issue\n const version_type v(file_version);\n load(ar, t, v);\n }\n};\n\ntemplate\ninline void split_free(\n Archive & ar,\n T & t,\n const unsigned int file_version\n){\n typedef typename mpl::eval_if<\n typename Archive::is_saving,\n mpl::identity >,\n mpl::identity >\n >::type typex;\n typex::invoke(ar, t, file_version);\n}\n\n} // namespace serialization\n} // namespace boost\n\n#define BOOST_SERIALIZATION_SPLIT_FREE(T) \\\nnamespace boost { namespace serialization { \\\ntemplate \\\ninline void serialize( \\\n Archive & ar, \\\n T & t, \\\n const unsigned int file_version \\\n){ \\\n split_free(ar, t, file_version); \\\n} \\\n}}\n/**/\n\n#endif // BOOST_SERIALIZATION_SPLIT_FREE_HPP\n" }, { "path": "include/boost/serialization/split_member.hpp", "content": "#ifndef BOOST_SERIALIZATION_SPLIT_MEMBER_HPP\n#define BOOST_SERIALIZATION_SPLIT_MEMBER_HPP\n\n// MS compatible compilers support #pragma once\n#if defined(_MSC_VER)\n# pragma once\n#endif\n\n/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8\n// split_member.hpp:\n\n// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .\n// Use, modification and distribution is subject to the Boost Software\n// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at\n// http://www.boost.org/LICENSE_1_0.txt)\n\n// See http://www.boost.org for updates, documentation, and revision history.\n\n#include \n#include \n#include \n\n#include \n\nnamespace boost {\nnamespace archive {\n namespace detail {\n template class interface_oarchive;\n template class interface_iarchive;\n } // namespace detail\n} // namespace archive\n\nnamespace serialization {\nnamespace detail {\n\n template\n struct member_saver {\n static void invoke(\n Archive & ar,\n const T & t,\n const unsigned int file_version\n ){\n access::member_save(ar, t, file_version);\n }\n };\n\n template\n struct member_loader {\n static void invoke(\n Archive & ar,\n T & t,\n const unsigned int file_version\n ){\n access::member_load(ar, t, file_version);\n }\n };\n\n} // detail\n\ntemplate\ninline void split_member(\n Archive & ar, T & t, const unsigned int file_version\n){\n typedef typename mpl::eval_if<\n typename Archive::is_saving,\n mpl::identity >,\n mpl::identity >\n >::type typex;\n typex::invoke(ar, t, file_version);\n}\n\n} // namespace serialization\n} // namespace boost\n\n// split member function serialize function into save/load\n#define BOOST_SERIALIZATION_SPLIT_MEMBER() \\\ntemplate \\\nvoid serialize( \\\n Archive &ar, \\\n const unsigned int file_version \\\n){ \\\n boost::serialization::split_member(ar, *this, file_version); \\\n} \\\n/**/\n\n#endif // BOOST_SERIALIZATION_SPLIT_MEMBER_HPP\n" }, { "path": "include/boost/serialization/stack.hpp", "content": "#ifndef BOOST_SERIALIZATION_STACK_HPP\n#define BOOST_SERIALIZATION_STACK_HPP\n\n// MS compatible compilers support #pragma once\n#if defined(_MSC_VER) && (_MSC_VER >= 1020)\n# pragma once\n#endif\n\n/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8\n// stack.hpp\n\n// (C) Copyright 2014 Robert Ramey - http://www.rrsd.com .\n// Use, modification and distribution is subject to the Boost Software\n// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at\n// http://www.boost.org/LICENSE_1_0.txt)\n\n// See http://www.boost.org for updates, documentation, and revision history.\n\n#include \n#include \n#include \n#include \n\n// function specializations must be defined in the appropriate\n// namespace - boost::serialization\n#if defined(__SGI_STL_PORT) || defined(_STLPORT_VERSION)\n#define STD _STLP_STD\n#else\n#define STD std\n#endif\n\nnamespace boost {\nnamespace serialization {\nnamespace detail{\n\ntemplate \nstruct stack_save : public STD::stack {\n template\n void operator()(Archive & ar, const unsigned int file_version) const {\n save(ar, STD::stack::c, file_version);\n }\n};\ntemplate \nstruct stack_load : public STD::stack {\n template\n void operator()(Archive & ar, const unsigned int file_version) {\n load(ar, STD::stack::c, file_version);\n }\n};\n\n} // detail\n\ntemplate\ninline void serialize(\n Archive & ar,\n std::stack< T, C> & t,\n const unsigned int file_version\n){\n typedef typename mpl::eval_if<\n typename Archive::is_saving,\n mpl::identity >,\n mpl::identity >\n >::type typex;\n static_cast(t)(ar, file_version);\n}\n\n} // namespace serialization\n} // namespace boost\n\n#include \n\nBOOST_SERIALIZATION_COLLECTION_TRAITS(STD::stack)\n\n#undef STD\n\n#endif // BOOST_SERIALIZATION_DEQUE_HPP\n" }, { "path": "include/boost/serialization/state_saver.hpp", "content": "#ifndef BOOST_SERIALIZATION_STATE_SAVER_HPP\n#define BOOST_SERIALIZATION_STATE_SAVER_HPP\n\n// MS compatible compilers support #pragma once\n#if defined(_MSC_VER)\n# pragma once\n#endif\n\n/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8\n// state_saver.hpp:\n\n// (C) Copyright 2003-4 Pavel Vozenilek and Robert Ramey - http://www.rrsd.com.\n// Use, modification and distribution is subject to the Boost Software\n// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at\n// http://www.boost.org/LICENSE_1_0.txt)\n\n// See http://www.boost.org/libs/serialization for updates, documentation, and revision history.\n\n// Inspired by Daryle Walker's iostate_saver concept. This saves the original\n// value of a variable when a state_saver is constructed and restores\n// upon destruction. Useful for being sure that state is restored to\n// variables upon exit from scope.\n\n\n#include \n#ifndef BOOST_NO_EXCEPTIONS\n #include \n#endif\n\n#include \n#include \n#include \n#include \n\n#include \n#include \n\nnamespace boost {\nnamespace serialization {\n\ntemplate\n// T requirements:\n// - POD or object semantic (cannot be reference, function, ...)\n// - copy constructor\n// - operator = (no-throw one preferred)\nclass state_saver : private boost::noncopyable\n{\nprivate:\n const T previous_value;\n T & previous_ref;\n\n struct restore {\n static void invoke(T & previous_ref, const T & previous_value){\n previous_ref = previous_value; // won't throw\n }\n };\n\n struct restore_with_exception {\n static void invoke(T & previous_ref, const T & previous_value){\n BOOST_TRY{\n previous_ref = previous_value;\n }\n BOOST_CATCH(::std::exception &) {\n // we must ignore it - we are in destructor\n }\n BOOST_CATCH_END\n }\n };\n\npublic:\n state_saver(\n T & object\n ) :\n previous_value(object),\n previous_ref(object)\n {}\n\n ~state_saver() {\n #ifndef BOOST_NO_EXCEPTIONS\n typedef typename mpl::eval_if<\n has_nothrow_copy< T >,\n mpl::identity,\n mpl::identity\n >::type typex;\n typex::invoke(previous_ref, previous_value);\n #else\n previous_ref = previous_value;\n #endif\n }\n\n}; // state_saver<>\n\n} // serialization\n} // boost\n\n#endif //BOOST_SERIALIZATION_STATE_SAVER_HPP\n" }, { "path": "include/boost/serialization/static_warning.hpp", "content": "#ifndef BOOST_SERIALIZATION_STATIC_WARNING_HPP\n#define BOOST_SERIALIZATION_STATIC_WARNING_HPP\n\n// (C) Copyright Robert Ramey 2003. Jonathan Turkanis 2004.\n// Use, modification and distribution is subject to the Boost Software\n// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at\n// MS compatible compilers support #pragma once\n#if defined(_MSC_VER)\n# pragma once\n#endif\n\n// http://www.boost.org/LICENSE_1_0.txt)\n\n// See http://www.boost.org/libs/static_assert for documentation.\n\n/*\n Revision history:\n 15 June 2003 - Initial version.\n 31 March 2004 - improved diagnostic messages and portability\n (Jonathan Turkanis)\n 03 April 2004 - works on VC6 at class and namespace scope\n - ported to DigitalMars\n - static warnings disabled by default; when enabled,\n uses pragmas to enable required compiler warnings\n on MSVC, Intel, Metrowerks and Borland 5.x.\n (Jonathan Turkanis)\n 30 May 2004 - tweaked for msvc 7.1 and gcc 3.3\n - static warnings ENabled by default; when enabled,\n (Robert Ramey)\n*/\n\n#include \n\n//\n// Implementation\n// Makes use of the following warnings:\n// 1. GCC prior to 3.3: division by zero.\n// 2. BCC 6.0 preview: unreferenced local variable.\n// 3. DigitalMars: returning address of local automatic variable.\n// 4. VC6: class previously seen as struct (as in 'boost/mpl/print.hpp')\n// 5. All others: deletion of pointer to incomplete type.\n//\n// The trick is to find code which produces warnings containing the name of\n// a structure or variable. Details, with same numbering as above:\n// 1. static_warning_impl::value is zero iff B is false, so diving an int\n// by this value generates a warning iff B is false.\n// 2. static_warning_impl::type has a constructor iff B is true, so an\n// unreferenced variable of this type generates a warning iff B is false.\n// 3. static_warning_impl::type overloads operator& to return a dynamically\n// allocated int pointer only is B is true, so returning the address of an\n// automatic variable of this type generates a warning iff B is false.\n// 4. static_warning_impl::STATIC_WARNING is declared as a struct iff B is\n// false.\n// 5. static_warning_impl::type is incomplete iff B is false, so deleting a\n// pointer to this type generates a warning iff B is false.\n//\n\n//------------------Enable selected warnings----------------------------------//\n\n// Enable the warnings relied on by BOOST_STATIC_WARNING, where possible.\n\n// 6. replaced implementation with one which depends solely on\n// mpl::print<>. The previous one was found to fail for functions\n// under recent versions of gcc and intel compilers - Robert Ramey\n\n#include \n#include \n#include \n#include \n#include \n\nnamespace boost {\nnamespace serialization {\n\ntemplate\nstruct BOOST_SERIALIZATION_STATIC_WARNING_LINE{};\n\ntemplate\nstruct static_warning_test{\n typename boost::mpl::eval_if_c<\n B,\n boost::mpl::true_,\n typename boost::mpl::identity<\n boost::mpl::print<\n BOOST_SERIALIZATION_STATIC_WARNING_LINE\n >\n >\n >::type type;\n};\n\ntemplate\nstruct BOOST_SERIALIZATION_SS {};\n\n} // serialization\n} // boost\n\n#define BOOST_SERIALIZATION_BSW(B, L) \\\n typedef boost::serialization::BOOST_SERIALIZATION_SS< \\\n sizeof( boost::serialization::static_warning_test< B, L > ) \\\n > BOOST_JOIN(STATIC_WARNING_LINE, L) BOOST_ATTRIBUTE_UNUSED;\n#define BOOST_STATIC_WARNING(B) BOOST_SERIALIZATION_BSW(B, __LINE__)\n\n#endif // BOOST_SERIALIZATION_STATIC_WARNING_HPP\n" }, { "path": "include/boost/serialization/std_variant.hpp", "content": "#ifndef BOOST_SERIALIZATION_STD_VARIANT_HPP\n#define BOOST_SERIALIZATION_STD_VARIANT_HPP\n\n// MS compatible compilers support #pragma once\n#if defined(_MSC_VER)\n# pragma once\n#endif\n\n/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8\n// variant.hpp - non-intrusive serialization of variant types\n//\n// copyright (c) 2019 Samuel Debionne, ESRF\n//\n// Use, modification and distribution is subject to the Boost Software\n// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at\n// http://www.boost.org/LICENSE_1_0.txt)\n//\n// See http://www.boost.org for updates, documentation, and revision history.\n//\n// Widely inspired form boost::variant serialization\n//\n\n#include \n\n#include \n\n#include \n\n#include \n#include \n#include \n\nnamespace boost {\nnamespace serialization {\n\ntemplate\nstruct std_variant_save_visitor\n{\n std_variant_save_visitor(Archive& ar) :\n m_ar(ar)\n {}\n template\n void operator()(T const & value) const\n {\n m_ar << BOOST_SERIALIZATION_NVP(value);\n }\nprivate:\n Archive & m_ar;\n};\n\n\ntemplate\nstruct std_variant_load_visitor\n{\n std_variant_load_visitor(Archive& ar) :\n m_ar(ar)\n {}\n template\n void operator()(T & value) const\n {\n m_ar >> BOOST_SERIALIZATION_NVP(value);\n }\nprivate:\n Archive & m_ar;\n};\n\ntemplate\nvoid save(\n Archive & ar,\n std::variant const & v,\n unsigned int /*version*/\n){\n const std::size_t which = v.index();\n ar << BOOST_SERIALIZATION_NVP(which);\n std_variant_save_visitor visitor(ar);\n std::visit(visitor, v);\n}\n\n// Minimalist metaprogramming for handling parameter pack\nnamespace mp {\n namespace detail {\n template \n struct front_impl;\n\n template