Squashed 'third_party/boostorg/serialization/' content from commit 738695b
Change-Id: I48528198ad1f62b90288d249eb2243d4db02fd5d
git-subtree-dir: third_party/boostorg/serialization
git-subtree-split: 738695b70733f9d592a570fb17a505d6a029b48a
diff --git a/.gitattributes b/.gitattributes
new file mode 100644
index 0000000..3e84d7c
--- /dev/null
+++ b/.gitattributes
@@ -0,0 +1,96 @@
+* text=auto !eol svneol=native#text/plain
+*.gitattributes text svneol=native#text/plain
+
+# Scriptish formats
+*.bat text svneol=native#text/plain
+*.bsh text svneol=native#text/x-beanshell
+*.cgi text svneol=native#text/plain
+*.cmd text svneol=native#text/plain
+*.js text svneol=native#text/javascript
+*.php text svneol=native#text/x-php
+*.pl text svneol=native#text/x-perl
+*.pm text svneol=native#text/x-perl
+*.py text svneol=native#text/x-python
+*.sh eol=lf svneol=LF#text/x-sh
+configure eol=lf svneol=LF#text/x-sh
+
+# Image formats
+*.bmp binary svneol=unset#image/bmp
+*.gif binary svneol=unset#image/gif
+*.ico binary svneol=unset#image/ico
+*.jpeg binary svneol=unset#image/jpeg
+*.jpg binary svneol=unset#image/jpeg
+*.png binary svneol=unset#image/png
+*.tif binary svneol=unset#image/tiff
+*.tiff binary svneol=unset#image/tiff
+*.svg text svneol=native#image/svg%2Bxml
+
+# Data formats
+*.pdf binary svneol=unset#application/pdf
+*.avi binary svneol=unset#video/avi
+*.doc binary svneol=unset#application/msword
+*.dsp text svneol=crlf#text/plain
+*.dsw text svneol=crlf#text/plain
+*.eps binary svneol=unset#application/postscript
+*.gz binary svneol=unset#application/gzip
+*.mov binary svneol=unset#video/quicktime
+*.mp3 binary svneol=unset#audio/mpeg
+*.ppt binary svneol=unset#application/vnd.ms-powerpoint
+*.ps binary svneol=unset#application/postscript
+*.psd binary svneol=unset#application/photoshop
+*.rdf binary svneol=unset#text/rdf
+*.rss text svneol=unset#text/xml
+*.rtf binary svneol=unset#text/rtf
+*.sln text svneol=native#text/plain
+*.swf binary svneol=unset#application/x-shockwave-flash
+*.tgz binary svneol=unset#application/gzip
+*.vcproj text svneol=native#text/xml
+*.vcxproj text svneol=native#text/xml
+*.vsprops text svneol=native#text/xml
+*.wav binary svneol=unset#audio/wav
+*.xls binary svneol=unset#application/vnd.ms-excel
+*.zip binary svneol=unset#application/zip
+
+# Text formats
+.htaccess text svneol=native#text/plain
+*.bbk text svneol=native#text/xml
+*.cmake text svneol=native#text/plain
+*.css text svneol=native#text/css
+*.dtd text svneol=native#text/xml
+*.htm text svneol=native#text/html
+*.html text svneol=native#text/html
+*.ini text svneol=native#text/plain
+*.log text svneol=native#text/plain
+*.mak text svneol=native#text/plain
+*.qbk text svneol=native#text/plain
+*.rst text svneol=native#text/plain
+*.sql text svneol=native#text/x-sql
+*.txt text svneol=native#text/plain
+*.xhtml text svneol=native#text/xhtml%2Bxml
+*.xml text svneol=native#text/xml
+*.xsd text svneol=native#text/xml
+*.xsl text svneol=native#text/xml
+*.xslt text svneol=native#text/xml
+*.xul text svneol=native#text/xul
+*.yml text svneol=native#text/plain
+boost-no-inspect text svneol=native#text/plain
+CHANGES text svneol=native#text/plain
+COPYING text svneol=native#text/plain
+INSTALL text svneol=native#text/plain
+Jamfile text svneol=native#text/plain
+Jamroot text svneol=native#text/plain
+Jamfile.v2 text svneol=native#text/plain
+Jamrules text svneol=native#text/plain
+Makefile* text svneol=native#text/plain
+README text svneol=native#text/plain
+TODO text svneol=native#text/plain
+
+# Code formats
+*.c text svneol=native#text/plain
+*.cpp text svneol=native#text/plain
+*.h text svneol=native#text/plain
+*.hpp text svneol=native#text/plain
+*.ipp text svneol=native#text/plain
+*.tpp text svneol=native#text/plain
+*.jam text svneol=native#text/plain
+*.java text svneol=native#text/plain
diff --git a/.travis.yml b/.travis.yml
new file mode 100644
index 0000000..d2fbcb7
--- /dev/null
+++ b/.travis.yml
@@ -0,0 +1,106 @@
+# Copyright 2016, 2017 Peter Dimov
+# Distributed under the Boost Software License, Version 1.0.
+# (See accompanying file LICENSE_1_0.txt or copy at http://boost.org/LICENSE_1_0.txt)
+
+language: cpp
+
+sudo: false
+
+cache:
+ ccache: true
+
+branches:
+ only:
+ - master
+ - develop
+ - /feature\/.*/
+
+env:
+ matrix:
+ - BOGUS_JOB=true
+
+matrix:
+
+ exclude:
+ - env: BOGUS_JOB=true
+
+ include:
+ - os: linux
+ compiler: g++
+ env: TOOLSET=gcc
+
+ - os: linux
+ compiler: g++-5
+ env: TOOLSET=gcc-5
+ addons:
+ apt:
+ packages:
+ - g++-5
+ sources:
+ - ubuntu-toolchain-r-test
+
+ - os: linux
+ compiler: g++-6
+ env: TOOLSET=gcc-6
+ addons:
+ apt:
+ packages:
+ - g++-6
+ sources:
+ - ubuntu-toolchain-r-test
+
+ - os: linux
+ compiler: g++-7
+ env: TOOLSET=gcc-7
+ addons:
+ apt:
+ packages:
+ - g++-7
+ sources:
+ - ubuntu-toolchain-r-test
+
+ - os: linux
+ compiler: g++-7
+ env: TOOLSET=gcc-7 LINK=static
+ addons:
+ apt:
+ packages:
+ - g++-7
+ sources:
+ - ubuntu-toolchain-r-test
+
+ - os: linux
+ compiler: clang++
+ env: TOOLSET=clang
+
+ - os: linux
+ compiler: clang++
+ env: TOOLSET=clang LINK=static
+
+ - os: osx
+ compiler: clang++
+ env: TOOLSET=clang
+
+ - os: osx
+ compiler: clang++
+ env: TOOLSET=clang LINK=static
+
+install:
+ - BOOST_BRANCH=develop && [ "$TRAVIS_BRANCH" == "master" ] && BOOST_BRANCH=master || true
+ - cd ..
+ - git clone -b $BOOST_BRANCH https://github.com/boostorg/boost.git boost-root
+ - cd boost-root
+ - git submodule update --init tools/build
+ - git submodule update --init libs/config
+ - git submodule update --init tools/boostdep
+ - cp -r $TRAVIS_BUILD_DIR/* libs/serialization
+ - python tools/boostdep/depinst/depinst.py serialization
+ - ./bootstrap.sh
+ - ./b2 headers
+
+script:
+ - ./b2 -j 3 libs/serialization/test toolset=$TOOLSET link=${LINK:-shared}
+
+notifications:
+ email:
+ on_success: always
diff --git a/CMake/CMakeLists.txt b/CMake/CMakeLists.txt
new file mode 100644
index 0000000..a6b1478
--- /dev/null
+++ b/CMake/CMakeLists.txt
@@ -0,0 +1,433 @@
+# CMake build control file for Serialization Library tests
+
+cmake_minimum_required(VERSION 3.0)
+
+if (POLICY CMP0054)
+ cmake_policy (SET CMP0054 NEW)
+endif (POLICY CMP0054)
+
+if (POLICY CMP0063)
+ cmake_policy (SET CMP0063 NEW)
+endif (POLICY CMP0063)
+
+if(Boost_USE_STATIC_LIBS)
+ project("Serialization-Static")
+else()
+ project("Serialization-Shared")
+endif()
+
+#
+# Compiler settings
+#
+
+message(STATUS "compiler is ${CMAKE_CXX_COMPILER_ID}" )
+add_definitions(${Boost_LIB_DIAGNOSTIC_DEFINITIONS})
+
+if( CMAKE_CXX_COMPILER_ID STREQUAL "GNU" )
+ add_definitions( -ftemplate-depth=300 )
+ # we use gcc to test for C++03 compatibility
+ add_definitions( -std=c++03 )
+ message(STATUS "compiler is g++ c++03")
+ set(COMPILER_SUPPORTS_CXX11 FALSE)
+elseif( CMAKE_CXX_COMPILER_ID STREQUAL "MSVC" )
+ add_definitions( /wd4996 )
+ message(STATUS "compiler is MSVC")
+ set(COMPILER_SUPPORTS_CXX11 TRUE)
+elseif( CMAKE_CXX_COMPILER_ID STREQUAL "AppleClang" )
+ set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -ftemplate-depth=300")
+ #set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++98")
+ set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++11")
+ set(CMAKE_CXX_FLAGS_DEBUG "-g -O0" )
+ set(CMAKE_CXX_FLAGS_RELWITHDEBINFO "-g -O3" )
+ set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -stdlib=libc++ -dead_strip")
+ set(COMPILER_SUPPORTS_CXX11 TRUE)
+endif()
+
+#
+# IDE settings
+#
+
+if( CMAKE_HOST_APPLE )
+ # note: it seems that bjam builds both address models in any case
+ # so we can defer this decision to the IDE just as we do for debug/release
+ # so we'll not use this now
+ # set(Boost_ADDRESS_MODEL 64 CACHE INTEGER "32/64 bits")
+ set(Boost_USE_STATIC_LIBS ON CACHE BOOL "Link to Boost static libraries")
+ set(Boost_USE_MULTITHREADED ON)
+else()
+ set(Boost_ADDRESS_MODEL 64 CACHE INTEGER "32/64 bits")
+ set(Boost_USE_STATIC_LIBS ON CACHE BOOL "Link to Boost static libraries")
+ set(Boost_USE_MULTITHREADED ON)
+endif()
+
+#
+# Locate Project Prerequisites
+#
+
+# Boost
+
+# note: we're assuming that boost has been built with:
+# ./b2 —-layout=versioned toolset=clang-darwin link=static,shared variant=debug,release stage
+
+###########################
+# special notes for Xcode.
+
+# these three should result in CMake setting the variables
+# Boost_SERIALIZATION_LIBRARY_DEBUG … to the correct values.
+
+# But my current version of CMake doesn't automatically set the library names
+# to point to the the libraries to be used. The variables are created
+# but they are not initialized. So be prepared to set these variables by hand.
+# If you want to use the static libraries - point to the boost libraries ending
+# in ".a". If you want to use the shared boost libraries - point to the libraries
+# ending in ".dylib".
+
+# But wait - there's more.
+# if both lib.a and lib.dylib both exist in the library directory, Xcode will
+# automatically chose the *.dylib one - and there's nothing you can do to fix this.
+# So my recommendation is
+# a) to place the compiled libraries in two different directories
+# - e.g. stage/lib-static/*.a and stage/lib-shared/*.dylib
+# and set the CMake variable Boost_LIBRARY_DIR to point to one or the other
+# b) create two different CMake build directories - build-static and build-shared
+# and switch between projects as desired. I like to test both since
+# there are things like dead code elimination and visibility which vary
+# between the two environments.
+#
+# caveat - as I write this, I've been unable to get the tests on the shared
+# library to function. Problem is that one needs to either put the shared
+# libraries in a special known place or set an environmental
+# variable which points to the shared library directory. I prefer the latter
+# but I've been unable to figure out how to get Xcode to do on a global basis
+# and it's not practical to do this for 247 test targets one at a time.
+
+# c) The targets in the project will by default be built as universal 32/64 binaries
+# I have yet to experiment with these yet so I just set the target to 64 bit.
+
+# end special note for Xcode
+############################
+
+set(Boost_DEBUG true)
+set(Boost_DETAILED_FAILURE_MSG true)
+set(Boost_FOUND true)
+
+find_package(Boost REQUIRED COMPONENTS system filesystem)
+include(CheckIncludeFileCXX)
+
+message(STATUS "Boost_FOUND is ${Boost_FOUND}")
+
+if(Boost_FOUND)
+ message(STATUS "Boost Found!")
+ message(STATUS "Boost is ${BOOST_ROOT}")
+ message(STATUS "Boost directories found at ${Boost_INCLUDE_DIRS}")
+ message(STATUS "Boost libraries found at ${Boost_LIBRARY_DIRS}")
+ message(STATUS "Boost libraries prefix is ${Boost_LIB_PREFIX}")
+ message(STATUS "Boost component libraries to be linked are ${Boost_LIBRARIES}")
+ message(STATUS "Boost version found is ${Boost_VERSION}")
+ #include_directories("../include" "${Boost_INCLUDE_DIRS}")
+ #link_directories("${Boost_LIBRARY_DIRS}")
+else()
+ message(STATUS "Boost NOT Found!")
+endif()
+
+if(Boost_USE_STATIC_LIBS)
+ message(STATUS "Use static libraries")
+ set(LINK_TYPE "STATIC")
+else()
+ message(STATUS "Building shared libraries")
+ set(LINK_TYPE "SHARED")
+ add_definitions( "-DBOOST_ALL_DYN_LINK=1")
+ add_definitions( "-DBOOST_ALL_NO_LIB=1")
+ add_definitions( "-DBOOST_LIB_DIAGNOSTICS=1")
+ set(CMAKE_CXX_VISIBILITY_PRESET hidden)
+ set(VISIBILITY_INLINES_HIDDEN)
+endif()
+
+###########################
+# library builds
+
+add_library(serialization ${LINK_TYPE}
+ ../src/archive_exception.cpp
+ ../src/basic_archive.cpp
+ ../src/basic_iarchive.cpp
+ ../src/basic_iserializer.cpp
+ ../src/basic_oarchive.cpp
+ ../src/basic_oserializer.cpp
+ ../src/basic_pointer_iserializer.cpp
+ ../src/basic_pointer_oserializer.cpp
+ ../src/basic_serializer_map.cpp
+ ../src/basic_text_iprimitive.cpp
+ ../src/basic_text_oprimitive.cpp
+ ../src/basic_xml_archive.cpp
+ ../src/binary_iarchive.cpp
+ ../src/binary_oarchive.cpp
+ ../src/extended_type_info_no_rtti.cpp
+ ../src/extended_type_info_typeid.cpp
+ ../src/extended_type_info.cpp
+ ../src/polymorphic_iarchive.cpp
+ ../src/polymorphic_oarchive.cpp
+ ../src/stl_port.cpp
+ ../src/text_iarchive.cpp
+ ../src/text_oarchive.cpp
+ ../src/void_cast.cpp
+ ../src/xml_archive_exception.cpp
+ ../src/xml_iarchive.cpp
+ ../src/xml_oarchive.cpp
+ ../src/xml_grammar.cpp
+ ../src/utf8_codecvt_facet.cpp
+ ../src/basic_xml_grammar.ipp # doesn't show up in "Source Files" in Xcode"'
+)
+
+add_library(wserialization ${LINK_TYPE}
+ ../src/codecvt_null.cpp
+ ../src/basic_text_wiprimitive.cpp
+ ../src/basic_text_woprimitive.cpp
+ ../src/text_wiarchive.cpp
+ ../src/text_woarchive.cpp
+ ../src/xml_wiarchive.cpp
+ ../src/xml_woarchive.cpp
+ ../src/xml_wgrammar.cpp
+ ../src/basic_xml_grammar.ipp # doesn't show up in "Source Files" in Xcode"'
+)
+
+# end library build
+###########################
+
+###########################
+# test targets
+
+function( serialization_test test_name)
+ set(arglist)
+ foreach(a IN ITEMS ${ARGN} )
+ set(arglist ${arglist} ../test/${a}.cpp)
+ endforeach()
+ message(STATUS ${test_name})
+ add_executable( ${test_name} ../test/${test_name}.cpp ${arglist} )
+ target_link_libraries(${test_name} serialization wserialization ${Boost_LIBRARIES})
+ add_test( ${test_name} ${test_name} )
+endfunction(serialization_test)
+
+function(archive_test test_name)
+ set(arglist)
+ foreach(a IN ITEMS ${ARGN} )
+ set(arglist ${arglist} ../test/${a}.cpp)
+ endforeach()
+ foreach(
+ archive-name
+ IN ITEMS text_archive text_warchive binary_archive xml_archive xml_warchive
+ )
+ set(amended_test_name ${test_name}_${archive-name})
+ message(STATUS ${amended_test_name})
+ add_executable(${amended_test_name} ../test/${test_name}.cpp ${arglist})
+ set_property(
+ TARGET ${amended_test_name}
+ PROPERTY COMPILE_DEFINITIONS BOOST_ARCHIVE_TEST=${archive-name}.hpp
+ )
+ target_link_libraries(${amended_test_name} serialization wserialization ${Boost_LIBRARIES})
+ add_test(${amended_test_name} ${amended_test_name})
+ endforeach()
+endfunction(archive_test)
+
+function(polymorphic_archive_test test_name)
+ set(arglist)
+ foreach(a IN ITEMS ${ARGN} )
+ set(arglist ${arglist} ../test/${a}.cpp)
+ endforeach()
+ foreach(
+ archive-name
+ IN ITEMS text_archive text_warchive binary_archive xml_archive xml_warchive
+ )
+ set(amended_test_name ${test_name}_polymorphic_${archive-name})
+ message(STATUS ${amended_test_name})
+ add_executable(${amended_test_name} ../test/${test_name}.cpp ${arglist})
+ set_property(
+ TARGET ${amended_test_name}
+ PROPERTY COMPILE_DEFINITIONS BOOST_ARCHIVE_TEST=polymorphic_${archive-name}.hpp
+ )
+ target_link_libraries(${amended_test_name} serialization wserialization ${Boost_LIBRARIES})
+ add_test(${amended_test_name} ${amended_test_name})
+ endforeach()
+endfunction(polymorphic_archive_test)
+
+enable_testing()
+
+serialization_test(test_dll_exported polymorphic_derived2 polymorphic_base)
+
+# serialization(test_dll_simple dll_a_lib)
+# compile test_dll_plugin.cpp
+# Running the following test requires that the test know the directory
+# in which the dll is stored. I don't know how to extract this from bjam
+# serialization(test_dll_plugin : : dll_polymorphic_derived2_lib)
+
+serialization_test(test_private_ctor)
+serialization_test(test_reset_object_address A)
+serialization_test(test_void_cast)
+serialization_test(test_mult_archive_types)
+serialization_test(test_iterators)
+serialization_test(test_iterators_base64)
+serialization_test(test_inclusion)
+serialization_test(test_inclusion2)
+serialization_test(test_smart_cast)
+serialization_test(test_codecvt_null ../src/codecvt_null)
+serialization_test(test_strong_typedef)
+
+archive_test(test_native_array A)
+archive_test(test_boost_array A)
+if(COMPILER_SUPPORTS_CXX11)
+ archive_test(test_array A)
+endif()
+archive_test(test_binary)
+archive_test(test_bitset)
+archive_test(test_class_info_save)
+archive_test(test_class_info_load)
+archive_test(test_complex)
+archive_test(test_contained_class A)
+archive_test(test_cyclic_ptrs A)
+archive_test(test_delete_pointer)
+archive_test(test_deque A)
+archive_test(test_derived)
+archive_test(test_derived_class A)
+archive_test(test_diamond)
+archive_test(test_diamond_complex)
+archive_test(test_exported polymorphic_base)
+archive_test(test_forward_list A)
+archive_test(test_forward_list_ptrs A)
+archive_test(test_helper_support)
+archive_test(test_interrupts)
+archive_test(test_list A)
+archive_test(test_list_ptrs A)
+archive_test(test_map A)
+archive_test(test_map_boost_unordered A)
+archive_test(test_mi)
+archive_test(test_multiple_ptrs A)
+archive_test(test_multiple_inheritance)
+archive_test(test_no_rtti polymorphic_base polymorphic_derived1)
+archive_test(test_new_operator A)
+archive_test(test_non_intrusive)
+archive_test(test_non_default_ctor)
+archive_test(test_non_default_ctor2)
+archive_test(test_null_ptr)
+archive_test(test_nvp A)
+archive_test(test_object)
+archive_test(test_optional)
+archive_test(test_primitive)
+archive_test(test_priority_queue A)
+archive_test(test_private_base)
+archive_test(test_private_base2)
+archive_test(test_queue A)
+archive_test(test_recursion A)
+archive_test(test_registered)
+archive_test(test_shared_ptr)
+archive_test(test_shared_ptr_multi_base)
+archive_test(test_shared_ptr_132)
+archive_test(test_simple_class A)
+archive_test(test_simple_class_ptr A)
+CHECK_INCLUDE_FILE_CXX(slist SLIST_FOUND)
+if(SLIST_FOUND)
+ message(STATUS "slist header found")
+ archive_test(test_slist A)
+ archive_test(test_slist_ptr A)
+else()
+ message(STATUS "slist header NOT found")
+endif()
+archive_test(test_stack A)
+archive_test(test_split)
+archive_test(test_tracking)
+archive_test(test_unregistered)
+archive_test(test_unique_ptr)
+archive_test(test_valarray)
+archive_test(test_variant A)
+archive_test(test_vector A)
+archive_test(test_set A)
+archive_test(test_set_boost_unordered A)
+if(COMPILER_SUPPORTS_CXX11)
+ archive_test(test_set_unordered A)
+else()
+ CHECK_INCLUDE_FILE_CXX(hash_set HASH_SET_FOUND)
+ if(HASH_SET_FOUND)
+ archive_test(test_set_hashed A)
+ endif()
+endif()
+if(COMPILER_SUPPORTS_CXX11)
+ archive_test(test_map_unordered A)
+else()
+ CHECK_INCLUDE_FILE_CXX(hash_map HASH_MAP_FOUND)
+ if(HASH_MAP_FOUND)
+ archive_test(test_map_hashed A)
+ endif()
+endif()
+
+polymorphic_archive_test(test_polymorphic test_polymorphic_A A)
+polymorphic_archive_test(test_polymorphic2 test_polymorphic2imp)
+polymorphic_archive_test(test_polymorphic_helper)
+
+# end test targets
+####################
+
+####################
+# add headers in IDE
+
+# for serialisation
+
+file(GLOB x
+ RELATIVE "${CMAKE_CURRENT_SOURCE_DIR}"
+ "${CMAKE_CURRENT_SOURCE_DIR}/../include/boost/archive/*.hpp"
+)
+add_custom_target(archive SOURCES ${x})
+set_property(TARGET archive PROPERTY FOLDER "serialization")
+
+file(GLOB x
+ RELATIVE "${CMAKE_CURRENT_SOURCE_DIR}"
+ "${CMAKE_CURRENT_SOURCE_DIR}/../include/boost/archive/detail/*.hpp"
+)
+add_custom_target(archive-detail SOURCES ${x})
+set_property(TARGET archive-detail PROPERTY FOLDER "serialization")
+
+file(GLOB x
+ RELATIVE "${CMAKE_CURRENT_SOURCE_DIR}"
+ "${CMAKE_CURRENT_SOURCE_DIR}/../include/boost/archive/impl/*.ipp"
+)
+add_custom_target(archive-impl SOURCES ${x})
+set_property(TARGET archive-impl PROPERTY FOLDER "serialization")
+
+file(GLOB x
+ RELATIVE "${CMAKE_CURRENT_SOURCE_DIR}"
+ "${CMAKE_CURRENT_SOURCE_DIR}/../include/boost/archive/iterators/*.hpp"
+)
+add_custom_target(archive-iterators SOURCES ${x})
+set_property(TARGET archive-iterators PROPERTY FOLDER "serialization")
+
+file(GLOB x
+ RELATIVE "${CMAKE_CURRENT_SOURCE_DIR}"
+ "${CMAKE_CURRENT_SOURCE_DIR}/../include/boost/serialization/*.hpp"
+)
+add_custom_target(serialization-headers SOURCES ${x})
+set_property(TARGET serialization-headers PROPERTY FOLDER "serialization")
+
+file(GLOB x
+ RELATIVE "${CMAKE_CURRENT_SOURCE_DIR}"
+ "${CMAKE_CURRENT_SOURCE_DIR}/../include/boost/serialization/detail/*.hpp"
+)
+add_custom_target(serialization-detail SOURCES ${x})
+set_property(TARGET serialization-detail PROPERTY FOLDER "serialization")
+
+# for wserialization
+
+file(GLOB x
+ RELATIVE "${CMAKE_CURRENT_SOURCE_DIR}"
+ "${CMAKE_CURRENT_SOURCE_DIR}/../include/boost/archive/*_w*.hpp"
+)
+add_custom_target(wserialization_headers SOURCES ${x})
+set_property(TARGET wserialization_headers PROPERTY FOLDER "wserialization")
+
+# end headers in IDE
+####################
+
+#####################
+# add test project to run misc tests
+
+add_executable( test_z ../test/test_z.cpp)
+target_link_libraries(test_z serialization wserialization ${Boost_LIBRARIES})
+
+# end test project
+#####################
diff --git a/appveyor.yml b/appveyor.yml
new file mode 100644
index 0000000..b98be23
--- /dev/null
+++ b/appveyor.yml
@@ -0,0 +1,80 @@
+# Copyright 2016 Peter Dimov
+# Copyright 2016 Robert Ramey
+# Distributed under the Boost Software License, Version 1.0.
+# (See accompanying file LICENSE_1_0.txt or copy at http://boost.org/LICENSE_1_0.txt)
+
+version: 1.0.{build}-{branch}
+
+shallow_clone: true
+
+branches:
+ only:
+ - develop
+# - master
+
+environment:
+ matrix:
+ - BUILD_TOOLSET: gcc
+ BUILD_LINK: static
+ - BUILD_TOOLSET: gcc
+ BUILD_LINK: shared
+ - BUILD_TOOLSET: msvc-14.0
+ BUILD_LINK: static
+ - BUILD_TOOLSET: msvc-14.0
+ BUILD_LINK: shared
+
+install:
+ - cd ..
+ - git clone -b %APPVEYOR_REPO_BRANCH% https://github.com/boostorg/boost.git boost-root
+ - cd boost-root
+ - git submodule init libs/align
+ - git submodule init libs/array
+ - git submodule init libs/assert
+ - git submodule init libs/bind
+ - git submodule init libs/compatibility
+ - git submodule init libs/concept_check
+ - git submodule init libs/config
+ - git submodule init libs/container
+ - git submodule init libs/container_hash
+ - git submodule init libs/core
+ - git submodule init libs/detail
+ - git submodule init libs/filesystem
+ - git submodule init libs/function
+ - git submodule init libs/functional
+ - git submodule init libs/integer
+ - git submodule init libs/intrusive
+ - git submodule init libs/io
+ - git submodule init libs/iterator
+ - git submodule init libs/lexical_cast
+ - git submodule init libs/math
+ - git submodule init libs/move
+ - git submodule init libs/mpl
+ - git submodule init libs/numeric/conversion
+ - git submodule init libs/optional
+ - git submodule init libs/predef
+ - git submodule init libs/preprocessor
+ - git submodule init libs/range
+ - git submodule init libs/smart_ptr
+ - git submodule init libs/spirit
+ - git submodule init libs/static_assert
+ - git submodule init libs/system
+ - git submodule init libs/throw_exception
+ - git submodule init libs/tuple
+ - git submodule init libs/type_index
+ - git submodule init libs/type_traits
+ - git submodule init libs/unordered
+ - git submodule init libs/utility
+ - git submodule init libs/variant
+ - git submodule init libs/winapi
+ - git submodule init tools/build
+ - git submodule update
+ - xcopy /s /e /q %APPVEYOR_BUILD_FOLDER% libs\serialization
+ - set PATH=C:\mingw-w64\i686-6.3.0-posix-dwarf-rt_v5-rev1\mingw32\bin;%CD%;%PATH%
+ - bootstrap gcc
+ - b2 headers
+
+build: off
+
+test_script:
+ - cd libs/serialization/test
+ - b2 -j2 toolset=%BUILD_TOOLSET% link=%BUILD_LINK%
diff --git a/build/Jamfile.v2 b/build/Jamfile.v2
new file mode 100644
index 0000000..d7823a5
--- /dev/null
+++ b/build/Jamfile.v2
@@ -0,0 +1,127 @@
+# Boost serialization Library Build Jamfile
+# (C) Copyright Robert Ramey 2002-2004.
+# Use, modification, and distribution are subject to the
+# Boost Software License, Version 1.0. (See accompanying file
+# LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+#
+# See http://www.boost.org/libs/serialization for the library home page.
+
+project boost/serialization
+ : source-location ../src
+ : requirements
+ <conditional>@include-spirit
+;
+
+SPIRIT_ROOT = [ modules.peek : SPIRIT_ROOT ] ;
+rule include-spirit ( properties * )
+{
+ local old-compiler ;
+ if <toolset>borland in $(properties)
+ {
+ if ! <toolset-borland:version>6.1.0 in $(properties)
+ {
+ old-compiler = true ;
+ }
+
+ }
+ else if <toolset>msvc in $(properties)
+ {
+ if <toolset-msvc:version>6.5 in $(properties)
+ || <toolset-msvc:version>7.0 in $(properties)
+ {
+ old-compiler = true ;
+ }
+ }
+
+ local result ;
+ if $(old-compiler)
+ {
+ if $(SPIRIT_ROOT)
+ {
+ # note - we can't use <include>$(SPIRIT_ROOT) because
+ # it puts -I$(SPIRIT_ROOT) AFTER the "../../.." in the command line.
+ # so use these instead
+ result = <cxxflags>-I$(SPIRIT_ROOT) ;
+ }
+ else
+ {
+ echo **** spirit 1.6x required to build library with this compiler **** ;
+ result = <build>no ;
+ }
+ }
+ return $(result) ;
+}
+
+SOURCES =
+ basic_archive
+ basic_iarchive
+ basic_iserializer
+ basic_oarchive
+ basic_oserializer
+ basic_pointer_iserializer
+ basic_pointer_oserializer
+ basic_serializer_map
+ basic_text_iprimitive
+ basic_text_oprimitive
+ basic_xml_archive
+ binary_iarchive
+ binary_oarchive
+ extended_type_info
+ extended_type_info_typeid
+ extended_type_info_no_rtti
+ polymorphic_iarchive
+ polymorphic_oarchive
+ stl_port
+ text_iarchive
+ text_oarchive
+ void_cast
+ archive_exception
+ xml_grammar
+ xml_iarchive
+ xml_oarchive
+ xml_archive_exception
+ codecvt_null
+ utf8_codecvt_facet
+ ;
+
+WSOURCES =
+ basic_text_wiprimitive
+ basic_text_woprimitive
+ text_wiarchive
+ text_woarchive
+ xml_wgrammar
+ xml_wiarchive
+ xml_woarchive
+;
+
+lib boost_serialization
+ : $(SOURCES).cpp
+ :
+ <toolset>msvc:<cxxflags>/Gy
+ <toolset>msvc:<define>_SCL_SECURE_NO_WARNINGS
+ <toolset>clang:<cxxflags>"-fvisibility=hidden -fvisibility-inlines-hidden"
+ <toolset>gcc:<cxxflags>"-fvisibility=hidden -fvisibility-inlines-hidden"
+ <toolset>darwin:<cxxflags>"-fvisibility=hidden -fvisibility-inlines-hidden"
+ <toolset>gcc:<cxxflags>"-ftemplate-depth-255"
+ <toolset>clang:<cxxflags>"-ftemplate-depth-255"
+ <toolset>darwin:<cxxflags>"-ftemplate-depth-255"
+ <link>shared:<define>BOOST_SERIALIZATION_DYN_LINK=1
+ ;
+
+lib boost_wserialization
+ : $(WSOURCES).cpp boost_serialization
+ :
+ <toolset>msvc:<cxxflags>/Gy
+ <toolset>msvc:<define>_SCL_SECURE_NO_WARNINGS
+ <toolset>clang:<cxxflags>"-fvisibility=hidden -fvisibility-inlines-hidden"
+ <toolset>gcc:<cxxflags>"-fvisibility=hidden -fvisibility-inlines-hidden"
+ <toolset>darwin:<cxxflags>"-fvisibility=hidden -fvisibility-inlines-hidden"
+ <toolset>gcc:<cxxflags>"-ftemplate-depth-255"
+ <toolset>clang:<cxxflags>"-ftemplate-depth-255"
+ <toolset>darwin:<cxxflags>"-ftemplate-depth-255"
+ # note: both serialization and wserialization are conditioned on the this
+ # switch - don't change it to BOOST_WSERIALIZATION_DYN_LINK
+ <link>shared:<define>BOOST_SERIALIZATION_DYN_LINK=1
+ ;
+
+boost-install boost_serialization boost_wserialization ;
diff --git a/doc/acknowledgments.html b/doc/acknowledgments.html
new file mode 100644
index 0000000..e482928
--- /dev/null
+++ b/doc/acknowledgments.html
@@ -0,0 +1,92 @@
+<!doctype HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
+<html>
+<!--
+(C) Copyright 2002-4 Robert Ramey - http://www.rrsd.com .
+Use, modification and distribution is subject to the Boost Software
+License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+http://www.boost.org/LICENSE_1_0.txt)
+-->
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
+<link rel="stylesheet" type="text/css" href="../../../boost.css">
+<link rel="stylesheet" type="text/css" href="style.css">
+<title>Serialization - Acknowledgments</title>
+</head>
+<body link="#0000ff" vlink="#800080">
+<table border="0" cellpadding="7" cellspacing="0" width="100%" summary=
+ "header">
+ <tr>
+ <td valign="top" width="300">
+ <h3><a href="http://www.boost.org"><img height="86" width="277" alt="C++ Boost" src="../../../boost.png" border="0"></a></h3>
+ </td>
+ <td valign="top">
+ <h1 align="center">Serialization</h1>
+ <h2 align="center">Acknowledgments</h2>
+ </td>
+ </tr>
+</table>
+<hr>
+<ul>
+ <li>Takatoshi Kondo found and corrected a very obscure and difficult bug in the
+ serialization of virtual base classes.
+ <li><a href="http://www.autoform.com">AutoForm Engineering GmbH</a> supported
+ development efforts to extend correct serialization to objects stored in DLLS.
+ <li><a href"http://www.cadence.com/il">Cadence Israel</a> supported enhancement
+ and testing of the portable binary archive.
+ <li>David Abrahams improved implementation of "export" functionality. This not
+ only eliminated an annoying header sequencing requirement, but also the need to maintain
+ a list of "known archives".
+ <li>Mattias Troyer enhanced the implementation of native binary archives. This includes
+ enhancement and generalization of the library itself including generalization of
+ the wrapper concept.
+ <li>Markus Schöpflin tracked down issues with TRU64 compiler resulting in 100% passing.
+ <li><a href="mailto::troy@resophonic.com"> Troy D. Straszheim</a> made the initial version of variant serialization.
+ <li>Tonko Juricic helped refine and complete project files for VC 7.1 ide
+ <li><a href="http://www.boost.org/people/rene_rivera.htm">Rene Rivera</a> tracked down several issues related to
+ Code Warrior, toolset configuration and bjam and much else.
+ <li>Martin Ecker detected (and fixed!) a number of subtle errors regarding cyclic
+ pointers, shared pointers. He also built the library as a DLL and raised some issues
+ <li>Pavel Vozenilek invested much effort in review of code and documentation
+ resulting in many improvements. In addition he helped a lot with porting to other
+ platforms including VC 6.0, Intel, and especially Borland.
+ <li><a href="http://www.boost.org/people/jens_maurer.htm">Jens Maurer</a> and
+ <a href="http://www.boost.org/people/beman_dawes.html">Beman Dawes</a> who got the boost
+ serialization ball rolling. It was one or both of these two that invented
+ the much beloved <code>&</code> syntax used to implement both save and
+ load in one fuction specification.
+ <li><a href="http://www.boost.org/people/vladimir_prus.htm">Vladimir Prus</a> for evaluating an
+ early draft and contributing the diamond inheritance example.
+ <li><a href="http://www.boost.org/people/william_kempf.htm">William E. Kempf</a>
+ who made the templates for this and other boost manuals. This relieved
+ me of much aggravation.
+ <li><a href="mailto:vahan@unicad.am">Vahan Margaryan</a> and
+ <a href="mailto:fredrik_blomqvist-at-home.se">Fredrik Blomqvist</a> for their contributions
+ to my understanding of the subtle issues of exception safety in this context.
+ <li>all other boost members who responded with feedback during the
+ development of this library. Almost all comments resulted in
+ tangible changes in the library which made it much better.
+ <li>boosters who helped out in porting to other platforms:, Fernando Cacciola (Borland),
+ Jeff Flinn (VC 7.1), Vladimir Prus (gcc 3.3), Christoph Ludwig(gcc 3.4),
+ Rob Lievaart(mingw), Marshal Clow(gcc-darwin) among others.
+ <li>all boost members who participated in the first formal review
+ in November 2002. Many of these members invested quite an effort
+ to evaluate the library and suggest changes. They are
+ Matthias Troyer, Pavel Vozenilek, Vladimir Prus, Fredrik Blomqvist,
+ Jeff Garland, Gennadiy Rozental, Alberto Barbati, Dave Harris.
+ Mr. Rozenthal in particular wrote an incredibly insightful analysis
+ that has driven all subsequent development that has resulted in the
+ current package.
+ <li>Dave Harris proposal and spirited defense of it led to a re-thinking
+ of the overrides for serialization of pointers. This resulted in a simpler
+ and more effective method of accounting for non-default constructors
+ required by serialization of pointers and STL collections.
+ <li><a href="mailto:admin@thefireflyproject.us">Bryce Lelbach</a> rewrote the XML Serialization grammar using Boost.Spirit 2.x.
+</ul>
+<hr>
+<p><i>© Copyright <a href="http://www.rrsd.com">Robert Ramey</a> 2002-2004.
+Distributed under the Boost Software License, Version 1.0. (See
+accompanying file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+</i></p>
+</body>
+</html>
+
diff --git a/doc/archive_reference.html b/doc/archive_reference.html
new file mode 100644
index 0000000..c4551fa
--- /dev/null
+++ b/doc/archive_reference.html
@@ -0,0 +1,433 @@
+<!doctype HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
+<html>
+<!--
+(C) Copyright 2002-10 Robert Ramey - http://www.rrsd.com .
+Use, modification and distribution is subject to the Boost Software
+License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+http://www.boost.org/LICENSE_1_0.txt)
+-->
+<head>
+<meta http-equiv="Content-Type" content="text/html; UTF-8">
+<link rel="stylesheet" type="text/css" href="../../../boost.css">
+<link rel="stylesheet" type="text/css" href="style.css">
+<title>Serialization - More on Archives</title>
+</head>
+<body link="#0000ff" vlink="#800080">
+<table border="0" cellpadding="7" cellspacing="0" width="100%" summary="header">
+ <tr>
+ <td valign="top" width="300">
+ <h3><a href="../../../index.htm"><img height="86" width="277" alt="C++ Boost" src="../../../boost.png" border="0"></a></h3>
+ </td>
+ <td valign="top">
+ <h1 align="center">Serialization</h1>
+ <h2 align="center">Archive Class Reference</h2>
+ </td>
+ </tr>
+</table>
+<hr>
+<dl class="page-index">
+ <dt><a href="#trivial">Trivial Archive</a>
+ <dt><a href="#implementation">More Useful Archive Classes</a>
+ <dt><a href="#usage">Usage</a>
+ <dt><a href="#testing">Testing</a>
+ <dt><a href="#polymorphic">Polymorphic Archives</a>
+</dl>
+
+<h3><a name="trivial">Trivial Archive</a></h3>
+The <a href="archives.html"><strong>Archive</strong></a> concept specifies the functions that a
+class must implement in order to be used to serialize
+<a href="serialization.html"><strong>Serializable</strong></a> types.
+
+Our discussion will focus on archives used for saving as the hierarchy is exactly analogous
+for archives used for loading data.
+
+<h4>Minimum Requirments</h4>
+
+The simplest class which will model the <a href="archives.html"><strong>Archive</strong></a> concept specifies the functions that a
+class will look like:
+
+<pre><code>
+#include <cstddef> // std::size_t
+//////////////////////////////////////////////////////////////
+// class trivial_oarchive
+class trivial_oarchive {
+public:
+ //////////////////////////////////////////////////////////
+ // public interface used by programs that use the
+ // serialization library
+ typedef boost::mpl::bool_<true> is_saving;
+ typedef boost::mpl::bool_<false> is_loading;
+ template<class T> void register_type(){}
+ template<class T> trivial_oarchive & operator<<(const T & t){
+ return *this;
+ }
+ template<class T> trivial_oarchive & operator&(const T & t){
+ return *this << t;
+ }
+ void save_binary(void *address, std::size_t count){};
+};
+</code></pre>
+The simplest possible input archive class is analogous to the above.
+In the following discussion, only output archives will be addressed.
+Input archives are exactly symmetrical to output archives.
+<p>
+This archive will compile and execute with any types which implement the
+<a href="serialization.html"><strong>Serializable</strong></a> concept.
+For an example see
+<a href="../example/demo_trivial_archive.cpp" target="demo_trivial_archive">
+<code style="white-space: normal">demo_trivial_archive.cpp</code></a>.
+Of course this program won't produce any output as it is. But it provides
+the starting point for a simple class which can be used to log formatted
+output. See the implementation of a <a href="simple_log.html">simple
+log archive</a> to how this has been done.
+
+<h3><a name="implementation">More Useful Archive Classes</a></h3>
+The above example is fine as far as it goes. But it doesn't implement
+useful features such as serialization of pointers, class versioning
+and others. This library implements a family of full featured archive
+classes appropriate for a variety of purposes.
+
+<p>
+Our archives have been factored into a tree of classes in order to minimize
+repetition of code. This is shown in the accompanying
+<a target="class_diagram" href="class_diagram.html">class diagram</a>.
+
+Any class which fulfills the following requirements will fit into
+this hierarchy and implement all the features we require. Deriving from
+the base class <a href="../../../boost/archive/detail/common_oarchive.hpp" target="common_oarchive_hpp">
+common_oarchive.hpp</a> provides all features we desire which
+are missing from trivial_oarchive above.
+
+<pre><code>
+<a href="../../../boost/archive/detail/common_oarchive.hpp" target="common_oarchive_hpp">
+#include <cstddef> // std::size_t
+#include <boost/archive/detail/common_oarchive.hpp>
+</a>
+/////////////////////////////////////////////////////////////////////////
+// class complete_oarchive
+class complete_oarchive :
+ public boost::archive::detail::common_oarchive<complete_oarchive>
+{
+ // permit serialization system privileged access to permit
+ // implementation of inline templates for maximum speed.
+ friend class boost::archive::save_access;
+
+ // member template for saving primitive types.
+ // Specialize for any types/templates that require special treatment
+ template<class T>
+ void save(T & t);
+
+public:
+ //////////////////////////////////////////////////////////
+ // public interface used by programs that use the
+ // serialization library
+
+ // archives are expected to support this function
+ void save_binary(void *address, std::size_t count);
+};
+</code></pre>
+
+Given a suitable definitions of <code style="white-space: normal">save</code>
+and <code style="white-space: normal">save_binary</code>,
+any program using serialization with a conforming C++ compiler should compile
+and run with this archive class.
+
+<h4>Optional Overrides</h4>
+
+The <code style="white-space: normal">detail::common_oarchive</code> class contains
+a number of functions that are used by various parts of the serialization library
+to help render the archive in a particular form.
+
+<dl>
+
+<dt><h4><code>void save_start(char const *)</code></h4></dt>
+<dd>
+<strong>Default</strong>:Does nothing.<br>
+<strong>Purpose</strong>:To inject/retrieve an object name into the archive. Used
+by XML archive to inject "<name>" before data.
+</dd>
+<p>
+
+<dt><h4><code>void save_end(char const *)</code></h4></dt>
+<dd>
+<strong>Default</strong>:Does nothing.<br>
+<strong>Purpose</strong>:To inject/retrieve an object name into the archive. Used
+by XML archive to inject "</name>" after data.
+<dd>
+</dd>
+<p>
+<dt><h4><code>void end_preamble()</code></h4></dt>
+<dd>
+<strong>Default</strong>:Does nothing.<br>
+<strong>Purpose</strong>:Called <strong>each time</strong> user data is saved.
+It's not called when archive bookkeeping data is saved. This is used by XML archives
+to determine when to inject a ">" character at the end of an XML header. XML output archives
+keep their own internal flag indicating that data being written is header data. This
+internal flag is reset when an object start tag is written. When
+<code style="white-space: normal">void end_preamble()</code> is invoked and this internal flag is set
+a ">" character is appended to the output and the internal flag is reset. The default
+implementation for <code style="white-space: normal">void end_preamble()</code> is a no-op thereby permitting it
+to be optimised away for archive classes that don't use it.
+</dd>
+<p>
+<dt><h4><code>
+template<class T>
+void save_override(T & t, int);
+</code></h4></dt>
+<dd>
+<strong>Default</strong>:Invokes <code style="white-space: normal">archive::save(Archive & ar, t)</code><br>
+This is the main entry into the serialization library.<br>
+<strong>Purpose</strong>:This can be specialized in cases where the data is to be written
+to the archive in some special way. For example, XML archives implement special handling for
+name-value pairs by overriding this function template for name-value pairs.
+This replaces the default name-value pair handling, which is just to throw away the name,
+with one appropriate for XML which writes out the start of an XML tag with the correct object name.
+<p>
+The second argument must be part of the function signature even though it is not used.
+Its purpose is to be sure that code is portable to compilers which fail to correctly
+implement partial function template ordering. For more information see
+<a href="implementation.html#functiontemplateordering">this</a>.
+</dd>
+
+</dl>
+
+<h4>Types used by the serialization library</h4>
+The serialization library injects bookkeeping data into the serialization archive.
+This data includes things like object ids, version numbers, class names etc. Each
+of these objects is included in a wrapper so that the archive class can override the
+implementation of <code style="white-space: normal">void save_override(T & t, int);</code>.
+For example, in the XML archive, the override for this type renders an object_id equal to 23 as
+"object_id=_23". The following table lists the types defined in the
+<code style="white-space: normal">boost::archive namespace</code>
+used internally by the serialization library:
+<p>
+<table border>
+<tr><th align=left>type</th><th align=left><code style="white-space: normal">default<br>serialized as</code></th>
+<tr><td><code style="white-space: normal">version_type</code></td><td><code style="white-space: normal">unsigned int</code></td>
+<tr><td><code style="white-space: normal">object_id_type</code></td><td><code style="white-space: normal">unsigned int</code></td>
+<tr><td><code style="white-space: normal">object_id_reference_type</code></td><td><code style="white-space: normal">unsigned int</code></td>
+<tr><td><code style="white-space: normal">class_id_type</code></td><td><code style="white-space: normal">int</code></td>
+<tr><td><code style="white-space: normal">class_id_optional_type</code></td><td><code style="white-space: normal">nothing</code></td>
+<tr><td><code style="white-space: normal">class_id_reference_type</code></td><td><code style="white-space: normal">int</code></td>
+<tr><td><code style="white-space: normal">tracking_type</code></td><td><code style="white-space: normal">bool</code></td>
+<tr><td><code style="white-space: normal">classname_type</code></td><td><code style="white-space: normal">string</code></td>
+</table>
+<p>
+All of these are associated with a default serialization defined in terms of primitive types
+so it isn't a requirement to define <code style="white-space: normal">save_override</code>
+for these types.
+<p>
+These are defined in
+<a href="../../../boost/archive/basic_archive.hpp" target="basic_archive_hpp"><code style="white-space: normal">basic_archive.hpp</code></a>.
+All of these types have been assigned an
+<a target="detail" href="traits.html#level">implementation level</a> of
+<code style="white-space: normal">primitive</code> and are convertible to types such as int, unsigned int, etc.
+so that they have default implementations. This is illustrated by
+<a href="../../../boost/archive/basic_text_iarchive.hpp" target="basic_text_iarchive_hpp"><code style="white-space: normal">basic_text_iarchive.hpp</code></a>.
+which relies upon the default. However, in some cases, overrides will have to be
+explicitly provided for these types. For an example see
+<a href="../../../boost/archive/basic_xml_iarchive.hpp" target="basic_xml_iarchive_hpp"><code style="white-space: normal">basic_xml_iarchive.hpp</code></a>.
+<p>
+In real practice, we probably won't be quite done.
+One or more of the following issues may need to be addressed:
+<ul>
+ <li>Many compilers fail to implement correct partial ordering of
+ function templates. The archives included with this library work around
+ this using argument overloading. This technique is described in
+ <a target="detail" href="implementation.html#functiontemplateordering">
+ another section of this manual</a>
+ <li>Even if we are using a conforming compiler, we might want our new archive class
+ to be portable to non-conforming compilers.
+ <li>Our archive format might require extra information inserted into it. For
+ example, XML archives need <name ... >...</name> surrounding
+ all data objects.
+ <li>Addressing any of the above may generate more issues to be addressed.
+ <li>The archives included with the library are all templates which use a
+ <code style="white-space: normal">stream</code> or
+ <code style="white-space: normal">streambuf</code>
+ as a template parameter rather than simple classes.
+ Combined with the above, even more issues arise with non-conforming compilers.
+</ul>
+The attached <a target="class_diagram" href="class_diagram.html">class diagram</a>
+shows the relationships between classes used to implement the serialization library.
+<p>
+A close examination of the archives included with the library illustrate
+what it takes to make a portable archive that covers all data types.
+<h3><a name="usage">Usage</a></h3>
+The newly created archive will usually be stored in its own header module. All
+that is necessary is to include the header and construct an instance of the new archive.
+EXCEPT for one special case.
+<ul>
+ <li>Instances of a derived class are serialized through a base class pointer.
+ <li>Such instances are not "registered" neither implicitly nor explicitly. That
+ is, the macro <code style="white-space: normal">BOOT_CLASS_EXPORT</code> is used
+ to instantiate the serialization code for the included archives.
+</ul>
+
+To make this work, the following should be included after the archive
+class definition.
+<pre><code>
+#define BOOST_SERIALIZATION_REGISTER_ARCHIVE(Archive)
+</code></pre>
+Failure to do this will not inhibit the program from compiling, linking
+and executing properly - except in one case. If an instance of a derived
+class is serialized through a pointer to its base class, the program
+will throw an
+<a href="exceptions.html#unregistered_class"><code style="white-space: normal">unregistered_class</code></a>
+exception.
+<p>
+
+<h4><a name="testing">Testing</h4>
+Exhaustive testing of the library requires testing the different aspects of object
+serialization with each archive. There are 46 different tests that can run with any archive.
+There are 5 "standard archives" included with the system.
+(3 in systems that don't support wide charactor i/o).
+<p>
+In addition, there are 28 other tests which aren't related to any particular archive class.
+<p>
+The default <code style="white-space: normal">bjam</code> testing setup will run all
+the above described tests. This will result in as many as 46 archive tests * 5
+standard archives + 28 general tests = 258 tests. Note that a complete test of the
+library would include DLL vs static library, release vs debug so the actual total
+would be closer to 1032 tests.
+<p>
+For each archive there is a header file in the test directory similar to the one below.
+The name of this archive is passed to the test program by setting the
+environmental variable <code style="white-space: normal">BOOST_ARCHIVE_TEST</code>
+to the name of the header. Here is the header file
+<code style="white-space: normal">test_archive.hpp</code> . Test header files for
+other archives are similar.
+<pre><code>
+// text_archive test header
+// include output archive header
+#include <boost/archive/text_oarchive.hpp>
+// set name of test output archive
+typedef boost::archive::text_oarchive test_oarchive;
+// set name of test output stream
+typedef std::ofstream test_ostream;
+
+// repeat the above for input archive
+#include <boost/archive/text_iarchive.hpp>
+typedef boost::archive::text_iarchive test_iarchive;
+typedef std::ifstream test_istream;
+
+// define open mode for streams
+// binary archives should use std::ios_base::binary
+#define TEST_STREAM_FLAGS (std::ios_base::openmode)0
+</code></pre>
+
+To test a new archive, for example, portable binary archives, with the gcc compiler,
+make a header file <code style="white-space: normal">portable_binary_archive.hpp</code>
+and invoke <code style="white-space: normal">bjam</code> with
+<pre><code>
+-sBOOST_ARCHIVE_LIST=portable_binary_archive.hpp
+</code></pre>
+This process in encapsulated in the shell or cmd script
+<code style="white-space: normal">library_test</code> whose command line is
+<pre><code>
+library_test --toolset=gcc -sBOOST_ARCHIVE_LIST=portable_binary_archive.hpp
+</code></pre>
+<h3><a name="polymorphic">Polymorphic Archives</a></h3>
+
+<h4>Motivation</h4>
+
+All archives described so far are implemented as templates. Code to save and load
+data to archives is regenerated for each combination of archive class and data type.
+Under these cirumstances, a good optimizing compiler that can expand
+<code>inline</code> functions to enough depth will generate fast code.
+However:
+<ul>
+<li>Much inline code may be replicated.
+<li>If there are several archive classes, code will be regenerated for each archive class.
+<li>If serialization code is placed in a library, that library must be rebuilt
+each time a new archive class is created.
+<li>If serialization code is placed in a DLL,
+ <ul>
+ <li>The DLL will contain versions of code for each known archive type.
+ This would result in loading of DLLs which contain
+ much code that is not used - basically defeating one of the main motivations
+ for choosing to use a DLL in the first place.
+ <li>If a new archive is created and an application shipped, all DLLs have to be
+ rebuilt, and reshipped along with the application which uses the new archive. Thus
+ the other main motivation for using a DLL is defeated.
+ </ul>
+</ul>
+
+<h4>Implementation</h4>
+The solution is the pair <code>polymorphic_oarchive</code>
+and <code>polymorphic_iarchive</code>. They present a common interface of virtual
+functions - no templates - that is equivalent to the standard templated one.
+
+This is shown in the accompanying
+<a target="class_diagram" href="class_diagram.html">class diagram</a>
+<p>
+The accompanying demo program in files
+
+<a target=demo_polymorphic_cp href="../example/demo_polymorphic.cpp"><code style="white-space: normal">demo_polymorphic.cpp</code></a>,
+<a target=demo_polymorphic_A_hpp href="../example/demo_polymorphic_A.hpp"><code style="white-space: normal">demo_polymorphic_A.hpp</code></a>, and
+<a target=demo_polymorphic_A_cpp href="../example/demo_polymorphic_A.cpp"><code style="white-space: normal">demo_polymorphic_A</code></a>
+show how polymorphic archives are to be used. Note the following:
+<ul>
+ <li><a target=demo_polymorphic_A_hpp href="../example/demo_polymorphic_A.hpp"><code style="white-space: normal">demo_polymorphic_A.hpp</code></a> and
+<a target=demo_polymorphic_A_cpp href="../example/demo_polymorphic_A.cpp"><code style="white-space: normal">demo_polymorphic_A.cpp</code></a>
+contain no templates and no reference to any specific archive implementation. That is, they will
+only have to be compiled once for all archive implementations. This even applies to archives classes
+created in the future.
+ <li>The main program <a target=demo_polymorphic_cp href="../example/demo_polymorphic.cpp"><code style="white-space: normal">demo_polymorphic.cpp</code></a>
+specifies a specific archive implementation.
+</ul>
+As can be seen in the
+<a target="class_diagram" href="class_diagram.html">class diagram</a>
+and the header files, this implementation is just a composition of the polymorphic
+interface and the standard template driven implementation. This composition is
+accomplished by the templates
+<a target=polymorphic_iarchive_route_hpp href="../../../boost/archive/detail/polymorphic_iarchive_route.hpp"><code style="white-space: normal">polymorphic_iarchive_route.hpp</code></a>
+and
+<a target=polymorphic_oarchive_route_hpp href="../../../boost/archive/detail/polymorphic_oarchive_route.hpp"><code style="white-space: normal">polymorphic_oarchive_route.hpp</code></a>
+which redirect calls to the polymorphic archives to the specific archive.
+As these contain no code specific to the particular implementation archive, they can be used to create
+a polymorphic archive implementation from any functioning templated archive implementation.
+<p>
+As a convenience, small header files have been included which contain
+a <code style="white-space: normal">typedef</code> for a polymorphic implementation for each corresponding
+templated one. For example, the headers
+<a target=polymorphic_text_iarchive_hpp href="../../../boost/archive/polymorphic_text_iarchive.hpp"><code style="white-space: normal">polymorphic_text_iarchive.hpp</code></a>
+and
+<a target=polymorphic_text_oarchive_hpp href="../../../boost/archive/polymorphic_text_oarchive.hpp"><code style="white-space: normal">polymorphic_text_oarchive.hpp</code></a>.
+contain the <code style="white-space: normal">typedef</code> for the polymorphic implementation
+of the standard text archive classes
+<a target=text_iarchive_hpp href="../../../boost/archive/text_iarchive.hpp"><code style="white-space: normal">text_iarchive.hpp</code></a>
+and
+<a target=text_oarchive_hpp href="../../../boost/archive/text_oarchive.hpp"><code style="white-space: normal">text_oarchive.hpp</code></a>
+respectively. All included polymorphic archives use the same naming scheme.
+
+<h4>Usage</h4>
+Polymorphic archives address the issues raised above regarding templated implementation.
+That is, there is no replicated code, and no recompilation for new archives. This will
+result in smaller executables for program which use more than one type of archive, and
+smaller DLLS. There is a penalty for calling archive functions through a virtual function
+dispatch table and there is no possibility for a compiler to <code style="white-space: normal">inline</code>
+archive functions. This will result in a detectable degradation in performance for
+saving and loading archives.
+<p>
+Note that the concept of polymophic archives is fundamentally incompatible with the
+serialization of new types that are marked "primitive" by the user with:
+<pre><code>
+BOOST_CLASS_IMPLEMENTATION(my_primitive_type, boost::serialization::primitive_type)
+</code></pre>
+
+Code to implement serialization for these types is instantiated "on the fly" in the user's program.
+But this conflicts with the whole purpose of the polymorphic archive. An attempt to
+serialize such a primitive type will result in a compilation error since the common polymorhic
+interface is static and cannot instantiate code for a new type.
+
+<p>
+The main utility of polymorphic archives will be to permit the building of class DLLs that will
+include serialization code for all present and future archives with no redundant code.
+<hr>
+<p><i>© Copyright <a href="http://www.rrsd.com">Robert Ramey</a> 2002-2004.
+Distributed under the Boost Software License, Version 1.0. (See
+accompanying file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+</i></p>
+</body>
+</html>
diff --git a/doc/archives.html b/doc/archives.html
new file mode 100644
index 0000000..0f16227
--- /dev/null
+++ b/doc/archives.html
@@ -0,0 +1,458 @@
+<!doctype HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
+<link rel="stylesheet" type="text/css" href="../../../boost.css">
+<link rel="stylesheet" type="text/css" href="style.css">
+<title>Serialization - Archives</title>
+</head>
+<body link="#0000ff" vlink="#800080">
+<table border="0" cellpadding="7" cellspacing="0" width="100%" summary="header">
+ <tr>
+ <td valign="top" width="300">
+ <h3><a href="../../../index.htm"><img height="86" width="277" alt="C++ Boost" src="../../../boost.png" border="0"></a></h3>
+ </td>
+ <td valign="top">
+ <h1 align="center">Serialization</h1>
+ <h2 align="center">Archive Concepts</h2>
+ </td>
+ </tr>
+</table>
+<hr>
+<dl class="page-index">
+ <dt><a href="#saving_interface">Saving Archive Concept</a>
+ <dt><a href="#loading_interface">Loading Archive Concept</a>
+ <dt><a href="#archive_models">Models</a>
+ <dt><a href="#exceptions">Exceptions</a>
+ <dt><a href="#charactersets">Character Sets</a>
+</dl>
+<h4>Notation</h4>
+In the following descriptions
+<ul>
+ <li><code>SA</code> is an type modeling the <a href="#saving_interface">Saving Archive Concept</a>.
+ <li><code>sa</code> is an instance of type SA.
+ <li><code>LA</code> is an type modeling the <a href="#loading_interface">Loading Archive Concept</a>.
+ <li><code>la</code> is an instance of type LA.
+ <li><code>T</code> is an <a href="serialization.html"><strong>Serializable</strong></a> Type.
+ <li><code>x</code> is an instance of type T Type.
+ <li><code>u,v</code> is a pointer to a an instance of type T.
+ <li><code>count</code> is an instance of a type that can be converted to <code>std::size_t</code>.
+</ul>
+<h4><a name="saving_interface">Saving Archive Concept</a></h4>
+<h4>Associated Types</h4>
+Intuitively, a type modeling this concept will generate a sequence of bytes
+corresponding to an arbitrary set of C++ data structures. Each type modeling the
+Saving Archive concept (SA) may be associated with another type modeling the
+<a href="#loading_interface">Loading Archive Concept</a>(LA).
+This associated type will perform the inverse operation.
+That is, given a sequence of bytes generated by SA, it will generate a set of
+C++ data structures that is equivalent to the original.
+The notion of equivalence is defined by the implementations of the pair of archives and the
+way the data are rendered <a href="serialization.html">serializable</a>.
+<p>
+<h4>Valid Expressions</h4>
+<dl>
+ <dt><h4><code>
+ SA::is_saving
+ </code></h4></dt>
+ <dd>
+ Returns the Boost MPL Integral Constant type boost::mpl::bool_<true>
+ </dd>
+ <dt><h4><code>
+ SA::is_loading
+ </code></h4></dt>
+ <dd>
+ Returns the Boost MPL Integral Constant type boost::mpl::bool_<false>
+ </dd>
+ <dt><h4><code>
+ sa << x
+ <br>
+ sa & x
+ </code></h4></dt>
+ <dd>
+ These expressions must perform exactly the same function. They append the
+ value of <code style="white-space: normal">x</code> along with other information to <code>sa</code>.
+ This other information is defined by the implementation of the archive.
+ Typically this information is that which is required by a corresponding
+ Loading Archive type to properly restore the value of <code>x</code>.
+ <p>
+ Returns a reference to <code>sa</code>.
+ </dd>
+ <dt><h4><code>
+ sa.save_binary(u, count)
+ </code></h4></dt>
+ <dd>
+ Appends to the archive <code style="white-space: normal">size_t(count)</code> bytes found at
+ <code style="white-space: normal">u</code>.
+ </dd>
+ <dt><h4><code>
+ sa.register_type<T>()
+ <br>
+ sa.register_type(u)
+ </code></h4></dt>
+ <dd>
+ Appends information about class T to the archive. This information is used to
+ construct the correct class when a derived pointer is loaded by a corresponding
+ Loading Archive type.
+ Invocation of this member function is referred to as "class registration".
+ This is explained in detail in
+ <a href="special.html#derivedpointers">Special Considerations - Derived Pointers</a>.
+ The second syntax is included to permit this function to be called on non-conforming
+ compilers when <code style="white-space: normal">sa</code> is a template argument.
+ For more information, see <a target="detail" href="implementation.html#tempatesyntax">Template Invocation syntax</a>
+ </dd>
+ <dt><h4><code>
+ sa.get_library_version()
+ </code></h4></dt>
+ <dd>
+ Returns an unsigned integer containing the current version number of the serialization
+ library. This number will be incremented each time the library is altered in such a
+ way that serialization could be altered for some type. For example, suppose the type
+ used for a count of collection members is changed. The code that loads collections
+ might be conditioned on the library version to make sure that libraries created by
+ previous versions of the library can still be read.
+ </dd>
+ <dt><h4><code>
+ sa.get_helper<Helper>(void * const helper_instance_id = 0)
+ </code></h4></dt>
+ <dd>
+ See <code>la.get_helper<Helper>(void * const helper_instance_id = 0)</code>
+ below.
+ </dd>
+
+</dl>
+
+<h4><a name="loading_interface">Loading Archive Concept</a></h4>
+<h4>Associated Types</h4>
+Each model of this concept presumes the
+existence of a corresponding type modeling the
+<a href="#saving_interface">Saving Archive Concept</a>.
+The purpose of an instance of this concept is to convert a sequence of bytes
+generated by this corresponding type to a set of C++ data structures
+equivalent to the original.
+<h4>Valid Expressions</h4>
+<dl>
+ <dt><h4><code>
+ LA::is_saving
+ </code></h4></dt>
+ <dd>
+ Returns the Boost MPL Integral Constant type boost::mpl::bool_<false>
+ </dd>
+ <dt><h4><code>
+ LA::is_loading
+ </code></h4></dt>
+ <dd>
+ Returns the Boost MPL Integral Constant type boost::mpl::bool_<true>
+ </dd>
+ <dt><h4><code>
+ la >> x
+ <br>
+ la & x
+ </code></h4></dt>
+ <dd>
+ These expressions must perform exactly the same function.
+ Sets <code>x</code> to a value retrieved from <code>la</code>.
+ <p>
+ Returns a reference to <code>la</code>.
+ </dd>
+ <dt><h4><code>
+ la.load_binary(u, count)
+ </code></h4></dt>
+ <dd>
+ Retrieves from <code style="white-space: normal">la</code> <code style="white-space: normal">size_t(count)</code> bytes and stores
+ them in memory starting at <code style="white-space: normal">u</code>.
+ </dd>
+ <dt>
+ <dt><h4><code>
+ la.register_type<T>()
+ <br>
+ la.register_type(u)
+ </code></h4></dt>
+ <dd>
+ Retrieves information about class T from the archive. This information is used to
+ construct the correct class when loading a pointer to a derived class not
+ otherwise referred to in the program by name.
+ Invocation of this member function is referred to as "class registration".
+ This is explained in detail in
+ <a href="special.html#derivedpointers">Special Considerations - Derived Pointers</a>.
+ The second syntax is included to permit this function to be called on non-conforming
+ compilers when <code style="white-space: normal">la</code> is a template argument.
+ For more information, see <a target="detail" href="implementation.html#tempatesyntax">Template Invocation syntax</a>
+ </dd>
+ <dt><h4><code>
+ la.get_library_version()
+ </code></h4></dt>
+ <dd>
+ Returns an unsigned integer containing the version number of the serialization
+ library that created the archive. This number will be incremented each time the
+ library is altered in such a way that serialization could be altered for some type.
+ For example, suppose the type used for a count of collection members is changed.
+ The code that loads collections might be conditioned on the library version to make
+ sure that libraries created by previous versions of the library can still be read.
+ </dd>
+ <dt><h4><code>
+ la.get_helper<Helper>(void * const helper_instance_id)
+ </code></h4></dt>
+ <dd>
+ Some otherwise unserializable types can be made serializable by inclusion of
+ a helper object. The iconic example of this is shared_ptr which needs this
+ helper object to keep track of previously loaded shared_ptr instances so they
+ can be "matched up" with subsequently loaded ones.
+ The first time <code style="white-space: normal">la.get_helper<Helper>(void * const helper_instance_id)</code>
+ is invoked for a given helper_instance_id, <code style="white-space: normal">Helper</code>, a default-constructed
+ <code style="white-space: normal">Helper</code> object is created, attached to
+ <code style="white-space: normal">la</code> and a reference to it is returned. Subsequent
+ invocations of <code style="white-space: normal">la.get_helper<Helper>(void * const helper_instance_id)</code> with the same id value return
+ a reference to the formerly constructed object. All objects created in this manner are
+ destroyed upon <code style="white-space: normal">la</code> destruction time. The purpose
+ of helper objects is discussed in
+ <a href="special.html#helpersupport">Special Considerations - Helper Support</a>.
+ </dd>
+ <dt><h4><code>
+ la.reset_object_address(v, u)
+ </code></h4></dt>
+ <dd>
+ Communicates to the archive that the object originally at address u has been
+ moved to address v.
+ <p>
+ When an object is loaded to a temporary variable and later moved to another location,
+ this function must be called in order communicate this fact. This permits the
+ archive to properly implement object tracking. Object tracking is required in order
+ to correctly implement serialization of pointers to instances of derived classes.
+ </dd>
+ <dt><h4><code>
+ la.delete_created_pointers()
+ </code></h4></dt>
+ <dd>
+ Deletes all objects created by the loading of pointers. This can be used to
+ avoid memory leaks that might otherwise occur if pointers are being loaded
+ and the archive load encounters an exception.
+ </dd>
+</dl>
+
+There are archives based on text, binary and XML file
+formats but all have the above interface. Given that all archives present
+the same public interface, specifcation of serialization is exactly the same
+for all archives. Archive classes have other members not mentioned here.
+However they are related to the internal functioning of the library and
+are not meant to be called by users of an archive. Implementation of new
+archives is discussed in
+<a href="archive_reference.html#implementation">New Archives - Implementation</a>.
+
+<p>
+The existence of the <code style="white-space: normal"><<</code>
+and <code style="white-space: normal">>></code> suggests
+a relationship between archives and C++ i/o streams. <strong>Archives are not
+C++ i/o streams</strong>. All the archives included with this system take a stream
+as an argument in the constructor and that stream is used for output or input.
+However, this is not a requirement of the serialization functions or the
+archive interface. It just turns out that the archives written so far have
+found it useful to base their implementation on streams.
+
+<h3><a name="archive_models">Archive Models</a></h3>
+This library includes various implementations of the Archive concept.
+
+An archive is defined by two complementary classes. One is for saving data while
+the other is for loading it.
+
+This library includes a number of archive implementations that are "ready to go" for the
+most common requirements. These classes implement the archive concept for differing data formats.
+They can be used "as is" or as a basis for developing one's own particular type of archive.
+An archive is defined by two complementary classes. One is for saving data while the other is for loading it.
+
+To invoke serialization using one of
+these archives, one or more of the following header files must be
+included in the code module containing the serialization code.
+<pre><code>
+// a portable text archive</a>
+<a href="../../../boost/archive/text_oarchive.hpp" target="text_oarchive_cpp">boost::archive::text_oarchive</a> // saving
+<a href="../../../boost/archive/text_iarchive.hpp" target="text_iarchive_cpp">boost::archive::text_iarchive</a> // loading
+
+// a portable text archive using a wide character stream</a>
+<a href="../../../boost/archive/text_woarchive.hpp">boost::archive::text_woarchive</a> // saving
+<a href="../../../boost/archive/text_wiarchive.hpp">boost::archive::text_wiarchive</a> // loading
+
+// a portable XML archive</a>
+<a href="../../../boost/archive/xml_oarchive.hpp" target="xml_oarchive_cpp">boost::archive::xml_oarchive</a> // saving
+<a href="../../../boost/archive/xml_iarchive.hpp" target="xml_iarchive_cpp">boost::archive::xml_iarchive</a> // loading
+
+// a portable XML archive which uses wide characters - use for utf-8 output</a>
+<a href="../../../boost/archive/xml_woarchive.hpp" target="xml_woarchive_cpp">boost::archive::xml_woarchive</a> // saving
+<a href="../../../boost/archive/xml_wiarchive.hpp" target="xml_wiarchive_cpp">boost::archive::xml_wiarchive</a> // loading
+
+// a non-portable native binary archive</a>
+<a href="../../../boost/archive/binary_oarchive.hpp" target="binary_oarchive_cpp">boost::archive::binary_oarchive</a> // saving
+<a href="../../../boost/archive/binary_iarchive.hpp" target="binary_iarchive_cpp">boost::archive::binary_iarchive</a> // loading
+
+<!--
+// a non-portable native binary archive which use wide character streams
+<a href="../../../boost/archive/binary_woarchive.hpp">boost::archive::binary_woarchive</a> // saving
+<a href="../../../boost/archive/binary_wiarchive.hpp">boost::archive::binary_wiarchive</a> // loading
+-->
+
+</code></pre>
+
+All of these archives implement the same interface. Hence, it should suffice to describe only one
+of them in detail. For this purpose we will use the text archive.
+
+
+<pre><code>
+namespace boost {
+namespace archive {
+
+enum archive_flags {
+ no_header = 1, // suppress archive header info
+ no_codecvt = 2, // suppress alteration of codecvt facet
+ no_xml_tag_checking = 4 // suppress checking of xml tags - igored on saving
+};
+
+} // archive
+} // boost
+</code></pre>
+
+<pre><code>
+namespace boost {
+namespace archive {
+
+class text_oarchive : ...
+{
+ ...
+public:
+ ... // implementation of the <strong>Saving Archive</strong> concept
+ text_oarchive(std::ostream & os, unsigned int flags = 0);
+ ~text_oarchive();
+};
+
+} // archive
+} // boost
+</code></pre>
+
+<dl>
+
+<dt><h4><code>
+text_oarchive(std::ostream & os, unsigned int flags = 0);
+</code></h4></dt>
+<dd>
+Constructs an archive given an open <code style="white-space: normal">stream</code> as
+an argument and optional flags. For most applications there will be no need to use flags.
+Flags are defined by <code style="white-space: normal">enum archive_flags</code> enumerator.
+Multiple flags can be combined with the <code style="white-space: normal">|</code> operator.
+
+By default, archives prepend
+output with initial data which helps identify them as archives produced by this system.
+This permits a more graceful handling of the case where an attempt is made to load an archive
+from an invalid file format. In addition to this, each type of archive might have
+its own information. For example, native binary archives include information about
+sizes of native types and endianess to gracefully handle the case where it has been
+erroneously assumed that such an archive is portable across platforms. In some cases,
+where this extra overhead might be considered objectionable, it can be suppressed with the
+<code style="white-space: normal">no_header</code> flag.
+<p>
+In some cases, an archive may alter (and later restore)
+the codecvt facet of the stream locale. To suppress this action,
+include the <code style="white-space: normal">no_codecvt</code> flag.
+<p>
+XML archives contain nested tags signifying the start and end of data fields.
+These tags are normally checked for agreement with the object name when
+data is loaded. If a mismatch occurs an exception is thrown. It's possible
+that this may not be desired behavior. To suppress this checking of XML
+tags, use <code style="white-space: normal">no_xml_tag_checking</code> flag.
+</dd>
+
+<dt><h4><code>
+~text_oarchive();
+</code></h4></dt>
+<dd>
+Destructor for an archive. This should be called before the stream is
+closed. It restores any altered stream facets to their state before the
+archive was opened.
+</dd>
+
+</dl>
+
+<pre><code>
+namespace boost {
+namespace archive {
+
+class text_iarchive : ...
+{
+ ...
+public:
+ ... // implementation of the <strong>Loading Archive</strong> concept
+ text_iarchive(std::istream & is, unsigned int flags = 0);
+ ~text_iarchive();
+};
+
+} //namespace archive
+) //namespace boost
+
+</code></pre>
+
+<dl>
+
+<dt><h4><code>
+text_iarchive(std::istream & is, unsigned int flags = 0);
+</code></h4></dt>
+<dd>
+Contructs an archive given an open <code style="white-space: normal">stream</code> as
+an argument and optional flags. If flags are used, they should be the same
+as those used when the archive was created. Function and usage of flags is described
+above.
+</dd>
+
+<dt><h4><code>
+~text_iarchive();
+</code></h4></dt>
+<dd>
+Destructor for an archive. This should be called before the stream is
+closed. It restores any altered stream facets to their state before the
+the archive was opened.
+</dd>
+</dl>
+<p>
+The <code style="white-space: normal">binary_oarchive</code> and
+<code style="white-space: normal">binary_iarchive</code> classes are
+implemented in terms of the more basic
+<code style="white-space: normal">std::streambuf</code>. So, in addition
+to the common class interface described above, they include the following
+constructors:
+<dl>
+<dt><h4><code>
+binary_oarchive(std::streambuf & bsb, unsigned int flags = 0);
+</code></h4></dt>
+and
+<dt><h4><code>
+binary_iarchive(std::streambuf & bsb, unsigned int flags = 0);
+</code></h4></dt>
+</dl>
+
+<h3><a name="exceptions">Exceptions</h3>
+All of the archive classes included may throw exceptions. The list of exceptions that might
+be thrown can be found in section <a target="detail" href="exceptions.html">Archive Exceptions</a>
+of this documentation.
+
+<h3><a name="charactersets">Character Sets</h3>
+This library includes two archive classes for XML. The wide character
+version (<code style="white-space: normal">xml_w?archive</code>) renders its output as UTF-8 which can
+handle any wide character without loss of information.
+<code style="white-space: normal">std::string</code> data is converted from multi-byte format to wide
+character format using the current <code style="white-space: normal">
+locale</code>. Hence this version should give a fair rendering of all
+C++ data for all cases. This could result in some unexpected behavior.
+Suppose an <code style="white-space: normal">std::string</code>
+is created with the <code style="white-space: normal">locale</code> character
+set to hebrew characters. On output this is converted to wide characters.
+On input however, there could be a problem if the <code style="white-space: normal">locale</code> is
+not set the same as when the archive is created.
+<p>
+The normal character version (<code style="white-space: normal">xml_?archive</code>) renders
+<code style="white-space: normal">std::string</code> output without any conversion. Though this may work
+fine for serialization, it may create difficulties if the XML archive is used
+for some other purpose.
+<hr>
+<p><i>© Copyright <a href="http://www.rrsd.com">Robert Ramey</a> 2002-2004.
+Distributed under the Boost Software License, Version 1.0. (See
+accompanying file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+</i></p>
+</body>
+</html>
diff --git a/doc/bibliography.html b/doc/bibliography.html
new file mode 100644
index 0000000..59da5bb
--- /dev/null
+++ b/doc/bibliography.html
@@ -0,0 +1,75 @@
+<!doctype HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
+<html>
+<!--
+(C) Copyright 2002-4 Robert Ramey - http://www.rrsd.com .
+Use, modification and distribution is subject to the Boost Software
+License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+http://www.boost.org/LICENSE_1_0.txt)
+-->
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
+<link rel="stylesheet" type="text/css" href="../../../boost.css">
+<link rel="stylesheet" type="text/css" href="style.css">
+<title>Serialization - Bibliography</title>
+</head>
+<body link="#0000ff" vlink="#800080">
+<table border="0" cellpadding="7" cellspacing="0" width="100%" summary=
+ "header">
+ <tr>
+ <td valign="top" width="300">
+ <h3><a href="../../../index.htm"><img height="86" width="277" alt="C++ Boost" src="../../../boost.png" border="0"></a></h3>
+ </td>
+ <td valign="top">
+ <h1 align="center">Serialization</h1>
+ <h2 align="center">Bibliography</h2>
+ </td>
+ </tr>
+</table>
+<hr>
+<ol><a name="1"></a>
+ <li>David Sugar and Daniel Silverstone, "CommonC++ Libraries", <a href=
+ "http://www.gnu.org/software/commoncpp/">http://www.gnu.org/software/commoncpp/</a>
+ <a name="2"></a>
+ <li>Nicola Santi, "Eternity", <a href=
+ "http://www.sourceforge.net/projects/eternity-it/">www.sourceforge.net/projects/eternity-it/</a>
+ <a name="3"></a>
+ <li>Allen Holub, "Roll Your Own Persistence", <u>Microsoft
+ Systems Journal</u> vol 11, no 6 Jun 1996
+ <a name="4"></a>
+ <li><a href="www.codefarms.com">Code Farms, Inc.</a>
+ <li>Tasos Kontogiorgos & Michael Kim, "A C++
+ Template-Based Application Architecture", <u>C++ Report</u>
+ <a name="5"></a>
+ <li>Scott Meyers, <u>Effective C++</u>, Addison-Wesley, 1992
+ <a name="6"></a>
+ <li>Bjarne Stroustrup, <u>The C++ Programming Langage</u>, Addison-Wesley, 1997
+ <a name="7"></a>
+ <li>Alexandrescu, Andrei, <u>Modern C++ Design</u>, Addison-Wesley, 2001
+ <a name="8"></a>
+ <li>Jim Hyslop, and Herb Sutter, "Factory Redux, Part2",
+ <u>C/C++ User's Journal</u>, vol 21, No. 8, August 2003
+ <a name="9"></a>
+ <li>David Vandevoorde and Nicolai M. Josuttis,
+ <u>C++ Templates - The Complete Guide</u>, Addison-Wesley, 2003
+ <a name="10"></a>
+ <li>Herb Sutter, "Pimpls--Beauty Marks You Can Depend On",
+ <u>C++ Report</u>, from <u>More C++ Gems</u>, Cambridge University Press, 2000
+ <a name="11"></a>
+ <li>James Coplien, "Curiously Recurring Template Patterns",
+ <u>C++ Report</u>, from <u>C++ Gems</u>, Cambridge University Press, 1998
+ <a name="12"></a>
+ <li>Erich Gamma, Richard Helm, Ralph Johnson, and John Vlissides,
+ <u>Design Patterns</u>, Addison-Wesley Publishing Company, 1995
+ <a name="13"></a>
+ <li>Stephan Beal, "s11n serialization library", <a href="http://www.s11n.net">www.s11n.net</a>
+ <a name="14"></a>
+ <li>Vandevoorde and Josuttis, <b>C++ Templates - A Complete Guide</b>, Addison-Wesley, 2003</a>
+</ol>
+<hr>
+<p><i>© Copyright <a href="http://www.rrsd.com">Robert Ramey</a> 2002-2004.
+Distributed under the Boost Software License, Version 1.0. (See
+accompanying file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+</i></p>
+</body>
+</html>
+
diff --git a/doc/class_diagram.html b/doc/class_diagram.html
new file mode 100644
index 0000000..9cdc9d6
--- /dev/null
+++ b/doc/class_diagram.html
@@ -0,0 +1,170 @@
+<!doctype HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
+<!--
+(C) Copyright 2002-4 Robert Ramey - http://www.rrsd.com .
+Use, modification and distribution is subject to the Boost Software
+License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+http://www.boost.org/LICENSE_1_0.txt)
+-->
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
+<link rel="stylesheet" type="text/css" href="../../../boost.css">
+<link rel="stylesheet" type="text/css" href="style.css">
+<title>Serialization - Archive Class Diagram</title>
+</head>
+<body link="#0000ff" vlink="#800080">
+<table border="0" cellpadding="7" cellspacing="0" width="100%" summary="header">
+ <tr>
+ <td valign="top" width="300">
+ <h3><a href="../../../index.htm"><img height="86" width="277" alt="C++ Boost" src="../../../boost.png" border="0"></a></h3>
+ </td>
+ <td valign="top">
+ <h1 align="center">Serialization</h1>
+ <h2 align="center">Text Archive Class Diagram</h2>
+ </td>
+ </tr>
+</table>
+<hr>
+
+<pre><code>
+
+
+basic_oarchive <a href="../../../boost/archive/detail/basic_oarchive.hpp">-></a>
+ |
+ |
+ | interface_oarchive<text_oarchive> <a href="../../../boost/archive/detail/interface_oarchive.hpp">-></a>
+ | /
+ | /
+ | _________/
+ | /
+ | /
+ | /
+common_oarchive<text_oarchive> <a href="../../../boost/archive/detail/common_oarchive.hpp">-></a>
+ |
+ |
+<font color="blue">basic_text_oarchive<text_oarchive></font> <a href="../../../boost/archive/basic_text_oarchive.hpp">-></a>
+ |
+ |
+ | <font color="blue">basic_text_oprimitive<basic_ostream></font> <a href="../../../boost/archive/basic_text_oprimitive.hpp">-></a>
+ | /
+ | /
+ | _________/ interface_oarchive<polymorphic_oarchive> <a href="../../../boost/archive/detail/interface_oarchive.hpp">-></a>
+ | / |
+ | / |
+ | / |
+<font color="blue">text_oarchive_impl<text_oarchive></font> <a href="../../../boost/archive/text_oarchive.hpp">-></a> polymorphic_oarchive_impl <a href="../../../boost/archive/polymorphic_oarchive.hpp">-></a>
+ | \ |
+ | \ |
+ | \_____________________________________ <font color="red">polymorphic_oarchive</font> <a href="../../../boost/archive/polymorphic_oarchive.hpp">-></a>
+ | \ /
+ | \ /
+ | \ /
+<font color="red">text_oarchive</font> <a href="../../../boost/archive/text_oarchive.hpp">-></a> polymorphic_oarchive_route<text_oarchive_impl<text_oarchive> > <a href="../../../boost/archive/detail/polymorphic_oarchive_route.hpp">-></a>
+ |
+ |
+ |
+ <font color="red">polymorphic_text_oarchive</font> <a href="../../../boost/archive/polymorphic_text_oarchive.hpp">-></a>
+
+
+</code></pre>
+This diagram shows the relationship between the various classes that implement saving (output
+serialization) for text archives. The hierachy and organization is similar for loading and for
+other types of archives as well. In the diagram, classes written in <font color="blue">blue</font>
+implement saving for a given archive type. (in this case its text archives).
+Users include classes in <font color="red">red</font> to save their data from a partcular
+type of archive. Other classes whose names are in black implement the library and should
+never change. They are in <code>namespace boost::archive::detail</code>
+<dl>
+ <dt><code>
+ <a href="../../../boost/archive/detail/basic_oarchive.hpp">basic_oarchive</a>
+ </code></dt>
+ <dd>
+ Implements the core library functions for class export, versioning, and object tracking. It is compiled
+ into the library as it has no template parameters.
+ </dd>
+ <p><dt><code>
+ <a href="../../../boost/archive/detail/interface_oarchive.hpp">interface_oarchive<text_oarchive></a>
+ </code></dt>
+ <dd>
+ A class that declares the standard archive interface. This has been factored out so that it
+ can be used as a base class for <code style="white-space: normal">polymorphic_oarchive</code>
+ as well as for archive implementations.
+
+ <p><dt><code>
+ <a href="../../../boost/archive/detail/common_oarchive.hpp">common_oarchive<text_oarchive></a>
+ </code></dt>
+ <dd>
+ The function of this class is to make the connection between the virtual function
+ interface used by <code>basic_oarchive</code> and the template interface used by archive
+ class implementations.
+
+ <p><dt><code>
+ <a href="../../../boost/archive/basic_text_oarchive.hpp">basic_text_oarchive<text_oarchive></a>
+ </code></dt>
+ <dd>
+ Implements the basic functionality for simple text archives. The primitive save functions have been
+ factored out so it can be used in other text based archives like XML archives.
+
+ <p><dt><code>
+ <a href="../../../boost/archive/basic_text_oprimitive.hpp">basic_text_oprimitive<basic_ostream></a>
+ </code></dt>
+ <dd>
+ Implements the save oversaves for all primitive types. This is a template with a parameter
+ which describes the stream.
+
+ <p><dt><code>
+ <a href="../../../boost/archive/text_oarchive.hpp">text_oarchive_impl<text_oarchive></a>
+ </code></dt>
+ <dd>
+ Inherits from the above two classes to implement text archives.
+ </dd>
+
+ <p><dt><code>
+ <a href="../../../boost/archive/text_oarchive.hpp">text_oarchive</a>
+ </code></dt>
+ <dd>
+ This is just a short hand for <code style="white-space: normal">text_oarchive_impl<text_oarchive></code> .
+ We can't use <code style="white-space: normal">typedef</code> because a
+ <code style="white-space: normal">typedef</code> can't refer to it self in its definition.
+ This is the class name that is used to serialize to a text archive.
+ </dd>
+
+ <p><dt><code>
+ <a href="../../../boost/archive/detail/interface_oarchive.hpp">interface_oarchive<polymorphic_oarchive></a>
+ </code></dt>
+ <dd>
+ Same template as above. However, this time the Archive parameter refers to the polymorphic archive
+ with a virtual function interface rather than that the template interface that
+ <code style="white-space: normal">common_oarchive</code> uses.
+
+ <p><dt><code>
+ <a href="../../../boost/archive/polymorphic_oarchive.hpp">polymorphic_oarchive</a>
+ </code></dt>
+ <dd>
+ A class with a list of virtual <code style="white-space: normal">save(T &t)</code>
+ for all primitive types T. This is the class that is used to do pre-compile serialization of classes
+ for all archives present and future.
+
+ <p><dt><code>
+ <a href="../../../boost/archive/detail/polymorphic_oarchive_route.hpp">polymorphic_oarchive_route<text_oarchive_impl<text_oarchive> ></a>
+ </code></dt>
+ <dd><p>
+ This class implements the <code style="white-space: normal">polymorphic_oarchive</code> in terms of a specific
+ concrete class. Virtual function calls are routed to the implementing class. In this example,
+ that implementing class would be text_oarchive_impl.
+
+ <p><dt><code>
+ <a href="../../../boost/archive/polymorphic_text_oarchive.hpp">polymorphic_text_oarchive</a>
+ </code></dt>
+ <dd>
+ this is just a typedef so we can write polymorphic_text_archive rather than
+ <code style="white-space: normal">polymorphic_oarchive_route<text_oarchive_impl&'t;text_oarchive> ></code>
+
+</dl>
+<hr>
+<p><i>© Copyright <a href="http://www.rrsd.com">Robert Ramey</a> 2002-2004.
+Distributed under the Boost Software License, Version 1.0. (See
+accompanying file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+</i></p>
+</body>
+</html>
\ No newline at end of file
diff --git a/doc/codecvt.html b/doc/codecvt.html
new file mode 100644
index 0000000..41f11c9
--- /dev/null
+++ b/doc/codecvt.html
@@ -0,0 +1,171 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
+<html>
+<!--
+ == Copyright (c) 2001 Ronald Garcia
+ ==
+ == Permission to use, copy, modify, distribute and sell this software
+ == and its documentation for any purpose is hereby granted without fee,
+ == provided that the above copyright notice appears in all copies and
+ == that both that copyright notice and this permission notice appear
+ == in supporting documentation. Ronald Garcia makes no
+ == representations about the suitability of this software for any
+ == purpose. It is provided "as is" without express or implied warranty.
+ -->
+<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
+<link rel="stylesheet" type="text/css" href="../../../boost.css">
+<link rel="stylesheet" type="text/css" href="style.css">
+<head>
+<title>UTF-8 Codecvt Facet</title>
+
+</head>
+
+<body bgcolor="#ffffff" link="#0000ee" text="#000000"
+ vlink="#551a8b" alink="#ff0000">
+<img src="../../../boost.png" alt="C++ Boost"
+width="277" height="86"> <br clear="all">
+
+
+<a name="sec:utf8-codecvt-facet-class"></a>
+
+
+<h1><code>utf8_codecvt_facet</code></h1>
+
+
+<pre>
+template<
+ typename InternType = wchar_t,
+ typename ExternType = char
+> utf8_codecvt_facet
+</pre>
+
+
+<h2>Rationale</h2>
+
+
+ UTF-8 is a method of encoding Unicode text in environments
+ where data is stored as 8-bit characters and some ascii characters
+ are considered special (i.e. Unix filesystem filenames) and tend
+ to appear more commonly than other characters. While
+ UTF-8 is convenient and efficient for storing data on filesystems,
+ it was not meant to be manipulated in memory by
+ applications. While some applications (such as Unix's 'cat') can
+ simply ignore the encoding of data, others should convert
+ from UTF-8 to UCS-4 (the more canonical representation of Unicode)
+ on reading from file, and reversing the process on writing out to
+ file.
+
+ <p>The C++ Standard IOStreams provides the <tt>std::codecvt</tt>
+ facet to handle specifically these cases. On reading from or
+ writing to a file, the <tt>std::basic_filebuf</tt> can call out to
+ the codecvt facet to convert data representations from external
+ format (ie. UTF-8) to internal format (ie. UCS-4) and
+ vice-versa. <tt>utf8_codecvt_facet</tt> is a specialization of
+ <tt>std::codecvt</tt> specifically designed to handle the case
+ of translating between UTF-8 and UCS-4.
+
+
+<h2>Template Parameters</h2>
+
+<table border summary="template parameters">
+<tr>
+<th>Parameter</th><th>Description</th><th>Default</th>
+</tr>
+
+<tr>
+<td><tt>InternType</tt></td>
+<td>The internal type used to represent UCS-4 characters.</td>
+<td><tt>wchar_t</tt></td>
+</tr>
+
+<tr>
+<td><tt>ExternType</tt></td>
+<td>The external type used to represent UTF-8 octets.</td>
+<td><tt>char_t</tt></td>
+</tr>
+</table>
+
+
+<h2>Requirements</h2>
+
+ <tt>utf8_codecvt_facet</tt> defaults to using <tt>char</tt> as
+ its external data type and <tt>wchar_t</tt> as its internal
+ datatype, but on some architectures <tt>wchar_t</tt> is
+ not large enough to hold UCS-4 characters. In order to use
+ another internal type.You must also specialize <tt>std::codecvt</tt>
+ to handle your internal and external types.
+ (<tt>std::codecvt<char,wchar_t,std::mbstate_t></tt> is required to be
+ supplied by any standard-conforming compiler).
+
+
+<h2>Example Use</h2>
+ The following is a simple example of using this facet:
+
+<pre>
+ //...
+ // My encoding type
+ typedef wchar_t ucs4_t;
+
+ std::locale old_locale;
+ std::locale utf8_locale(old_locale,new utf8_codecvt_facet<ucs4_t>);
+
+ // Set a New global locale
+ std::locale::global(utf8_locale);
+
+ // Send the UCS-4 data out, converting to UTF-8
+ {
+ std::wofstream ofs("data.ucd");
+ ofs.imbue(utf8_locale);
+ std::copy(ucs4_data.begin(),ucs4_data.end(),
+ std::ostream_iterator<ucs4_t,ucs4_t>(ofs));
+ }
+
+ // Read the UTF-8 data back in, converting to UCS-4 on the way in
+ std::vector<ucs4_t> from_file;
+ {
+ std::wifstream ifs("data.ucd");
+ ifs.imbue(utf8_locale);
+ ucs4_t item = 0;
+ while (ifs >> item) from_file.push_back(item);
+ }
+ //...
+</pre>
+
+
+<h2>History</h2>
+
+ This code was originally written as an iterator adaptor over
+ containers for use with UTF-8 encoded strings in memory.
+ Dietmar Kuehl suggested that it would be better provided as a
+ codecvt facet.
+
+<h2>Resources</h2>
+
+<ul>
+<li> <a href="http://www.unicode.org">Unicode Homepage</a>
+<li> <a href="http://home.CameloT.de/langer/iostreams.htm">Standard
+ C++ IOStreams and Locales</a>
+<li> <a href="http://www.research.att.com/~bs/3rd.html">The C++
+ Programming Language Special Edition, Appendix D.</a>
+</ul>
+
+<br>
+<hr>
+<table summary="Copyright information">
+<tr valign="top">
+<td nowrap>Copyright © 2001</td>
+<td><a href="http://www.osl.iu.edu/~garcia">Ronald Garcia</a>,
+Indiana University
+(<a href="mailto:garcia@cs.indiana.edu">garcia@osl.iu.edu</a>)<br>
+<a href="http://www.osl.iu.edu/~lums">Andrew Lumsdaine</a>,
+Indiana University
+(<a href="mailto:lums@osl.iu.edu">lums@osl.iu.edu</a>)</td>
+</tr>
+</table>
+<p><i>© Copyright <a href="http://www.rrsd.com">Robert Ramey</a> 2002-2004.
+Distributed under the Boost Software License, Version 1.0. (See
+accompanying file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+</i></p>
+</body>
+</html>
+
+
diff --git a/doc/configuration.html b/doc/configuration.html
new file mode 100644
index 0000000..0997298
--- /dev/null
+++ b/doc/configuration.html
@@ -0,0 +1,17 @@
+<!doctype HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
+<html>
+<!--
+(C) Copyright 2002-4 Robert Ramey - http://www.rrsd.com .
+Use, modification and distribution is subject to the Boost Software
+License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+http://www.boost.org/LICENSE_1_0.txt)
+-->
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
+<link rel="stylesheet" type="text/css" href="../../../boost.css">
+<link rel="stylesheet" type="text/css" href="style.css">
+<title>Serialization - Configuration</title>
+</head>
+<body link="#0000ff" vlink="#800080">
+</body>
+</html>
diff --git a/doc/contents.html b/doc/contents.html
new file mode 100644
index 0000000..8639502
--- /dev/null
+++ b/doc/contents.html
@@ -0,0 +1,339 @@
+<!doctype HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
+<html>
+<!--
+(C) Copyright 2002-4 Robert Ramey - http://www.rrsd.com .
+Use, modification and distribution is subject to the Boost Software
+License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+http://www.boost.org/LICENSE_1_0.txt)
+-->
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
+<link rel="stylesheet" type="text/css" href="../../../boost.css">
+<title>Serialization</title>
+
+<!-- Expanding Menu Script Starts Here -->
+<script language="JavaScript">
+//<--!
+// netscape version
+
+function toggle(element) {
+ if (null == element){
+ return;
+ }
+ var targetId = element.id + "_detail";
+ targetElement = document.getElementById(targetId);
+ if (null != targetElement){
+ if (targetElement.style.display == "none") {
+ targetElement.style.display = "";
+ element.src="minus.gif";
+ }
+ else{
+ targetElement.style.display = "none";
+ element.src="plus.gif";
+ }
+ }
+}
+
+function clickHandlerNS(e) {
+ toggle(e.target);
+}
+
+// explorer version
+function clickHandlerIE() {
+ toggle(window.event.srcElement);
+}
+
+function collapse_all() {
+ var l = document.images;
+ var i = l.length;
+ while(i > 0){
+ i = i - 1;
+ var image = l[i];
+ image.style.display = "";
+ toggle(image);
+ }
+}
+
+
+function initialize() {
+ if(navigator.appName.indexOf("Netscape") != -1){
+ document.onclick = clickHandlerNS;
+ collapse_all();
+ }
+ else
+ if(navigator.appName.indexOf("Microsoft") != -1){
+ document.onclick = clickHandlerIE;
+ collapse_all();
+ }
+ else
+ if (navigator.appnName.indexOf("Konqueror") >= 0){
+ document.onclick = clickHandlerIE;
+ collapse_all();
+ }
+}
+
+//-->
+</script>
+
+</head>
+<body onload="initialize()">
+<h2>Contents</h2>
+<small>
+<!--
+<img src="dot.gif" onclick="collapse_all()">Collapse All
+-->
+<p>
+<dl class="page-index">
+ <dt><img style="display:none" src="dot.gif" id="release_notes"><a target="detail" href="release.html">Release Notes</a></dt>
+ <dt><img style="display:none" src="plus.gif" id="overview"><a target="detail" href="overview.html">Overview</a></dt>
+ <dd><div id="overview_detail"><dl class="page-index">
+ <dt><img style="display:none" src="dot.gif"><a target="detail" href="overview.html#Requirements">Requirements</a></dt>
+ <dt><img style="display:none" src="dot.gif"><a target="detail" href="overview.html#Otherimplementations">Other Implementations</a></dt>
+ </dl></div></dd>
+ <dt><img style="display:none" src="plus.gif" id="tutorial"><a target="detail" href="tutorial.html">Tutorial</a></dt>
+ <dd><div id="tutorial_detail"><dl class="page-index">
+ <dt><img style="display:none" src="dot.gif"><a target="detail" href="tutorial.html#simplecase">A Very Simple Case</a>
+ <dt><img style="display:none" src="dot.gif"><a target="detail" href="tutorial.html#nonintrusiveversion">Non Intrusive Version</a>
+ <dt><img style="display:none" src="dot.gif"><a target="detail" href="tutorial.html#serializablemembers">Serializable Members</a>
+ <dt><img style="display:none" src="dot.gif"><a target="detail" href="tutorial.html#derivedclasses">Derived Classes</a>
+ <dt><img style="display:none" src="dot.gif"><a target="detail" href="tutorial.html#pointers">Pointers</a>
+ <dt><img style="display:none" src="dot.gif"><a target="detail" href="tutorial.html#arrays">Arrays</a>
+
+ <dt><img style="display:none" src="dot.gif"><a target="detail" href="tutorial.html#stl">STL Collections</a>
+ <dt><img style="display:none" src="dot.gif"><a target="detail" href="tutorial.html#versioning">Class Versioning</a>
+ <dt><img style="display:none" src="dot.gif"><a target="detail" href="tutorial.html#splitting">Splitting <code>serialize</code> into <code>save/load</code></a>
+ <dt><img style="display:none" src="dot.gif"><a target="detail" href="tutorial.html#archives">Archives</a>
+ <dt><img style="display:none" src="dot.gif"><a target="detail" href="tutorial.html#examples">List of Examples</a>
+ </dl></div></dd>
+
+ <dt><img style="display:none" src="plus.gif" id="reference"><a target="detail" href="reference.html">Reference</a></dt>
+ <dd><div id="reference_detail"><dl class="page-index">
+ <dt><img style="display:none" src="plus.gif" id="archive_concept"><a target="detail" href="archives.html">Archive Concepts</a>
+ <dd><div id="archive_concept_detail"><dl class="page-index">
+ <dt><img style="display:none" src="dot.gif"><a target="detail" href="archives.html#saving_interface">Saving Archive Concept</a>
+ <dt><img style="display:none" src="dot.gif"><a target="detail" href="archives.html#loading_interface">Loading Archive Concept</a>
+ <dt><img style="display:none" src="dot.gif"><a target="detail" href="archives.html#archive_models">Archive Models</a>
+ <dt><img style="display:none" src="dot.gif"><a target="detail" href="archives.html#exceptions">Exceptions</a>
+ <dt><img style="display:none" src="dot.gif"><a target="detail" href="archives.html#charactersets">Character Sets</a>
+ </dl></div></dd>
+ <dt><img style="display:none" src="plus.gif" id="serialization"><a target="detail" href="serialization.html">Serializable Concept</a>
+ <dd><div id="serialization_detail"><dl class="page-index">
+ <dt><img style="display:none" src="dot.gif"><a target="detail" href="serialization.html#primitiveoperators">Primitive Types</a>
+ <dt><img style="display:none" src="dot.gif" id="class"><a target="detail" href="serialization.html#classoperators">Class Types</a>
+ <dd><div id="class_detail"><dl class="page-index">
+ <dt><img style="display:none" src="dot.gif"><a target="detail" href="serialization.html#member">Member Function</a>
+ <dt><img style="display:none" src="plus.gif" id="splitfree"><a target="detail" href="serialization.html#free">Free Function</a>
+ <dd><div id="splitfree_detail"><dl class="page-index">
+ <dt><img style="display:none" src="dot.gif"><a target="detail" href="serialization.html#namespaces">Namespaces for Free Function Overrides</a>
+ </dl></div></dd>
+ <dt><img style="display:none" src="plus.gif" id="members"><a target="detail" href="serialization.html#classmembers">Class Members</a>
+ <dd><div id="members_detail"><dl class="page-index">
+ <dt><img style="display:none" src="dot.gif"><a target="detail" href="serialization.html#base">Base Classes</a>
+ <dt><img style="display:none" src="dot.gif"><a target="detail" href="serialization.html#const"><code>const</code> Members</a>
+ <dt><img style="display:none" src="dot.gif"><a target="detail" href="serialization.html#templates">Templates</a>
+ </dl></div></dd>
+ <dt><img style="display:none" src="dot.gif"><a target="detail" href="serialization.html#versioning">Versioning</a>
+ <dt><img style="display:none" s'c="dot.gif"><a target="detail" href="serialization.html#splitting">Splitting <code>serialize</code> into <code>save/load</code></a>
+ </dl></div></dd>
+ <dt><img style="display:none" src="plus.gif" id="pointers"><a target="detail" href="serialization.html#pointeroperators">Pointers</a>
+ <dd><div id="pointers_detail"><dl class="page-index">
+ <dt><img style="display:none" src="dot.gif"><a target="detail" href="serialization.html#constructors">Non-Default Constructors</a>
+ <dt><img style="display:none" src="plus.gif" id="derivedpointers"><a target="detail" href="serialization.html#derivedpointers">Pointers to Objects of Derived Classes</a>
+ <dd><div id="derivedpointers_detail"><dl class="page-index">
+ <dt><img style="display:none" src="dot.gif"><a target="detail" href="serialization.html#registration">Registration</a>
+ <dt><img style="display:none" src="dot.gif"><a target="detail" href="serialization.html#export">Export</a>
+ <dt><img style="display:none" src="dot.gif"><a target="detail" href="serialization.html#instantiation">Instantiation</a>
+ <dt><img style="display:none" src="dot.gif"><a target="detail" href="serialization.html#selectivetracking">Selective Tracking</a>
+ <dt><img style="display:none" src="dot.gif"><a target="detail" href="serialization.html#runtimecasting">Runtime Casting</a>
+ </dl></div></dd>
+ </dl></div></dd>
+ <dt><img style="display:none" src="dot.gif"><a target="detail" href="serialization.html#references">References</a>
+ <dt><img style="display:none" src="plus.gif" id="traits"><a target="detail" href="traits.html">Class Serialization Traits</a>
+ <dd><div id="traits_detail"><dl class="page-index">
+ <dt><img style="display:none" src="dot.gif"><a target="detail" href="traits.html#version">Version</a>
+ <dt><img style="display:none" src="dot.gif"><a target="detail" href="traits.html#level">Implementation Level</a>
+ <dt><img style="display:none" src="dot.gif"><a target="detail" href="traits.html#tracking">Object Tracking</a>
+ <dt><img style="display:none" src="dot.gif"><a target="detail" href="traits.html#export">Export Key</a>
+ <dt><img style="display:none" src="dot.gif"><a target="detail" href="traits.html#Abstract">Abstract</a>
+ <dt><img style="display:none" src="dot.gif"><a target="detail" href="traits.html#typeinfo">Type Information Implementation</a>
+ <dt><img style="display:none" src="dot.gif"><a target="detail" href="traits.html#wrappers">Wrappers</a>
+ <dt><img style="display:none" src="dot.gif"><a target="detail" href="traits.html#bitwise">Bitwise Serialization</a>
+ <dt><img style="display:none" src="dot.gif"><a target="detail" href="traits.html#templates">Template Serialization Traits</a>
+
+ <dt><img style="display:none" src="plus.gif" id="compiletimemessages"><a target="detail" href="traits.html#compiletime_messages">Compile Time Warnings and Errors</a>
+ <dd><div id="compiletimemessages_detail"><dl class="page-index">
+ <dt><img style="display:none" src="dot.gif"><a target="detail" href="traits.html#object_level">object_level</a>
+ <dt><img style="display:none" src="dot.gif"><a target="detail" href="traits.html#object_versioning">object_versioning</a>
+ <dt><img style="display:none" src="dot.gif"><a target="detail" href="traits.html#object_tracking">object_tracking</a>
+ <dt><img style="display:none" src="dot.gif"><a target="detail" href="traits.html#pointer_level">pointer_level</a>
+ <dt><img style="display:none" src="dot.gif"><a target="detail" href="traits.html#pointer_tracking">pointer_tracking</a>
+ <dt><img style="display:none" src="dot.gif"><a target="detail" href="traits.html#const_loading">const_loading</a>
+ </dl></div></dd>
+ </dl></div></dd>
+ <dt><img style="display:none" src="plus.gif" id="wrappers"><a target="detail" href="wrappers.html">Serialization Wrappers</a>
+ <dd><div id="wrappers_detail"><dl class="page-index">
+ <dt><img style="display:none" src="dot.gif"><a target="detail" href="wrappers.html#binaryobjects">Binary Objects</a>
+ <dt><img style="display:none" src="dot.gif"><a target="detail" href="wrappers.html#arrays">Arrays</a>
+ <dt><img style="display:none" src="dot.gif"><a target="detail" href="wrappers.html#strong_type"><code style="white-space: normal">strong_type</code></a>
+ <dt><img style="display:none" src="dot.gif"><a target="detail" href="wrappers.html#collection_size_type">Collection Sizes</a>
+ <dt><img style="display:none" src="dot.gif"><a target="detail" href="wrappers.html#nvp">Name-Value Pairs</a>
+ <dt><img style="display:none" src="dot.gif"><a target="detail" href="wrappers.html#composition">Composition</a>
+ </dl></div></dd>
+ <dt><img style="display:none" src="dot.gif"><a target="detail" href="serialization.html#models">Models - Serialization Implementations Included in the Library</a>
+ </dl></div></dd>
+ <dt><img style="display:none" src="plus.gif" id="special"><a target="detail" 'ref="special.html">Special Considerations</a>
+ <dd><div id="special_detail"><dl class="page-index">
+ <dt><img style="display:none" src="dot.gif"><a target="detail" href="special.html#objecttracking">Object Tracking</a>
+ <dt><img style="display:none" src="dot.gif"><a target="detail" href="special.html#classinfo">Class Information</a>
+ <dt><img style="display:none" src="dot.gif"><a target="detail" href="special.html#helpersupport">Helper Support</a>
+ <dt><img style="display:none" src="plus.gif" id="portability"><a target="detail" href="special.html#portability">Archive Portability</a>
+ <dd><div id="portability_detail"><dl class="page-index">
+ <dt><img style="display:none" src="dot.gif"><a target="detail" href="special.html#numerics">Numerics</a>
+ <dt><img style="display:none" src="dot.gif"><a target="detail" href="special.html#traits">Traits</a>
+ </dl></div></dd>
+ <dt><img style="display:none" src="dot.gif"><a target="detail" href="special.html#binary_archives">Binary Archives</a>
+ <dt><img style="display:none" src="dot.gif"><a target="detail" href="special.html#xml_archives">XML Archives</a>
+ <dt><img style="display:none" src="dot.gif"><a target="detail" href="special.html#export">Exporting Class Serialization</a>
+ <dt><img style="display:none" src="dot.gif"><a target="detail" href="special.html#static_libraries">Static Libraries and Serialization</a>
+ <dt><img style="display:none" src="dot.gif"><a target="detail" href="special.html#dlls">DLLS - Serialization and Runtime Linking</a>
+ <dt><img style="display:none" src="dot.gif"><a target="detail" href="special.html#plugins">Plugins</a>
+ <dt><img style="display:none" src="dot.gif"><a target="detail" href="special.html#multi_threading">Multi-Threading</a>
+ <dt><img style="display:none" src="dot.gif"><a target="detail" href="special.html#optimizations">Optimzations</a>
+ <dt><img style="display:none" src="plus.gif" id="exceptions"><a target="detail" href="exceptions.html">Archive Exceptions</a>
+ <dd><div id="exceptions_detail"><dl class="page-index">
+ <dt><img style="display:none" src="dot.gif"><a target="detail" href="exceptions.html#unregistered_class"><code>unregistered_class</code></a>
+ <dt><img style="display:none" src="dot.gif"><a target="detail" href="exceptions.html#invalid_signature"><code>invalid_signature</code></a>
+ <dt><img style="display:none" src="dot.gif"><a target="detail" href="exceptions.html#unsupported_version"><code>unsupported_version</code></a>
+ <dt><img style="display:none" src="dot.gif"><a target="detail" href="exceptions.html#pointer_conflict"><code>pointer_conflict</code></a>
+ <dt><img style="display:none" src="dot.gif"><a target="detail" href="exceptions.html#incompatible_native_format"><code>incompatible_format</code></a>
+ <dt><img style="display:none" src="dot.gif"><a target="detail" href="exceptions.html#array_size_too_short"><code>array_size_too_short</code></a>
+ <dt><img style="display:none" src="dot.gif"><a target="detail" href="exceptions.html#stream_error"><code>stream_error</code></a>
+ <dt><img style="display:none" src="dot.gif"><a target="detail" href="exceptions.html#invalid_class_name"><code>invalid_class_name</code></a>
+ <dt><img style="display:none" src="dot.gif"><a target="detail" href="exceptions.html#unregistered_cast"><code>unregistered_cast</code></a>
+ <dt><img style="display:none" src="dot.gif"><a target="detail" href="exceptions.html#xml_archive_parsing_error"><code>xml_archive_parsing_error</code></a>
+ <dt><img style="display:none" src="dot.gif"><a target="detail" href="exceptions.html#xml_archive_tag_mismatch"><code>xml_archive_tag_mismatch</code></a>
+ <dt><img style="display:none" src="dot.gif"><a target="detail" href="exceptions.html#xml_archive_tag_name_error"><code>xml_archive_tag_name_error</code></a>
+ </dl></div></dd>
+ <dt><img style="display:none" src="dot.gif"><a target="detail" href="exception_safety.html">Exception Safety</a>
+ </dl></div></dd>
+ <dt><img style="display:none" src="plus.gif" id="archive_reference"><a target="detail" href="archive_reference.html">Archive Class Reference</a>
+ <dd><div id="archive_reference_detail"><dl class="page-index">
+ <dt><img style="display:none" src="dot.gif"><a target="detail" href="archive_reference.html#trivial">Trivial Archive</a>
+ <dt><img style="display:none" src="dot.gif"><a target="detail" href="archive_reference.html#implementation">More Useful Archive Classes</a>
+ <dt><img style="display:none" src="dot.gif"><a target="detail" href="archive_reference.html#usage">Usage</a>
+ <dt><img style="display:none" src="dot.gif"><a target="detail" href="archive_reference.html#testing">Testing</a>
+ <dt><img style="display:none" src="dot.gif"><a target="detail" href="archive_reference.html#polymorphic">Polymorphic Archives</a>
+ </dl></div></dd>
+ </dl></div></dd>
+ <dt><img style="display:none" src="plus.gif" id="implementation"><a target="detail" href="implementation.html">Implementation Notes</a>
+ <dd><div id="implementation_detail"><dl class="page-index">
+ <dt><img style="display:none" src="dot.gif"><a target="detail" href="implementation.html#functiontemplateordering">Partial Function Template Ordering</a>
+ <dt><img style="display:none" src="dot.gif"><a target="detail" href="implementation.html#charencoding">Character Encoding</a>
+ <dt><img style="display:none" src="dot.gif"><a target="detail" href="implementation.html#tempatesyntax">Template Invocation syntax</a>
+ <dt><img style="display:none" src="dot.gif"><a target="detail" href="implementation.html#partialtemplatespecialization">Partial Template Specialization</a>
+ <dt><img style="display:none" src="plus.gif" id="othercompilerissues"><a target="detail" href="implementation.html#othercompilerissues">Specific Compiler/Library Issues</a>
+ <dd><div id="othercompilerissues_detail"><dl class="page-index">
+ <dt><img style="display:none" src="dot.gif"><a target="detail" href="implementation.html#gcc3x">GCC 3.X,4.X</a>
+ <dt><img style="display:none" src="dot.gif"><a target="detail" href="implementation.html#gcc295">GCC 2.95</a>
+ <dt><img style="display:none" src="dot.gif"><a target="detail" href="implementation.html#intel80">Intel 8.0</a>
+ <dt><img style="display:none" src="dot.gif"><a target="detail" href="implementation.html#vc80">Visual C++ 8.0</a>
+ <dt><img style="display:none" src="dot.gif"><a target="detail" href="implementation.html#vc71">Visual C++ 7.1</a>
+ <dt><img style="display:none" src="dot.gif"><a target="detail" href="implementation.html#vc70">Visual C++ 7.0</a>
+ <dt><img style="display:none" src="dot.gif"><a target="detail" href="implementation.html#vc6">Visual C++ 6.0</a>
+ <dt><img style="display:none" src="dot.gif"><a target="detail" href="implementation.html#borland">Borland 5.64 and 5.51</a>
+ <dt><img style="display:none" src="dot.gif"><a target="detail" href="implementation.html#comeau">Comeau 4.3.3</a>
+ <dt><img style="display:none" src="dot.gif"><a target="detail" href="implementation.html#codewarrior">Code Warrior 8.3</a>
+ <dt><img style="display:none" src="dot.gif"><a target="detail" href="implementation.html#tru64">TRU64</a>
+ <dt><img style="display:none" src="dot.gif"><a target="detail" href="implementation.html#dinkumware">Dinkumware Library</a>
+ <dt><img style="display:none" src="dot.gif"><a target="detail" href="implementation.html#stlport">STLPort 4.5.3</a>
+ </dl></div></dd>
+ <dt><img style="display:none" src="plus.gif" id="headers"><a target="detail" href="headers.html">Code Structure</a>
+ <dd><div id="headers_detail"><dl class="page-index">
+ <dt><img style="display:none" src="plus.gif" id="userincludes"><a target="detail" href="headers.html#userincludes">Files Included by User Programs</a>
+ <dd><div id="userincludes_detail"><dl class="page-index">
+ <dt><img style="display:none" src="dot.gif"><a target="detail" href="headers.html#archiveimplementations">Archive Implementations</a>
+ <dt><img style="display:none" src="dot.gif"><a target="detail" href="headers.html#serializationdeclarations">Serialization Declarations</a>
+ <dt><img style="display:none" src="dot.gif"><a target="detail" href="headers.html#serializationimplementations">Serialization Implementations</a>
+ </dl></div>
+ <dt><img style="display:none" src="plus.gif" id="libraryimplementation"><a target="detail" href="headers.html#libraryimplementation">Files Which Implement the Library</a>
+ <dd><div id="libraryimplementation_detail"><dl class="page-index">
+ <dt><img style="display:none" src="dot.gif"><a target="detail" href="headers.html#archivedevelopment">Archive Development</a>
+ <dt><img style="display:none" src="dot.gif"><a target="detail" href="headers.html#archiveinternals">Archive Internals</a>
+ <dt><img style="display:none" src="dot.gif"><a target="detail" href="headers.html#codemodules">Archive Library Code Modules</a>
+ <dt><img style="display:none" src="dot.gif"><a target="detail" href="headers.html#dataflowiterators">Dataflow Iterators</a>
+ </dl></div></dd>
+ </dl></div></dd>
+ </dl></div></dd>
+ <dt><img style="display:none" src="plus.gif" id="case_studies">Case Studies
+ <dd><div id="case_studies_detail"><dl class="page-index">
+ <dt><img style="display:none" src="dot.gif"><a target="detail" href="shared_ptr.html">Template serialization - <code>shared_ptr<class T></code></a>
+ <dt><img style="display:none" src="dot.gif"><a target="detail" href="shared_ptr2.html"><code>shared_ptr<class T></code>Revisited</a>
+ <dt><img style="display:none" src="dot.gif"><a target="detail" href="pimpl.html">PIMPL</a>
+ <dt><img style="display:none" src="dot.gif"><a target="detail" href="private_base.html">Private Base Classes</a>
+ <dt><img style="display:none" src="dot.gif"><a target="detail" href="simple_log.html">A Simple Logging Archive Class</a>
+ <dt><img style="display:none" src="dot.gif"><a target="detail" href="derivation.html">Derivation from an Existing Archive Class</a>
+ </dl></div></dd>
+ <dt><img style="display:none" src="plus.gif" id="otherclasses">Other Classes
+ <dd><div id="otherclasses_detail"><dl class="page-index">
+ <dt><img style="display:none" src="plus.gif" id="extended_type_info"><a target="detail" href="extended_type_info.html"><code>extended_type_info</code></a>
+ <dd><div id="extended_type_info_detail"><dl class="page-index">
+ <dt><img style="display:none" src="dot.gif"><a target="detail" href="extended_type_info.html#motivation">Motivation</a>
+ <dt><img style="display:none" src="dot.gif"><a target="detail" href="extended_type_info.html#runtime">Runtime Interface</a>
+ <dt><img style="display:none" src="dot.gif"><a target="detail" href="extended_type_info.html#requirements">Requirements</a>
+ <dt><img style="display:none" src="dot.gif"><a target="detail" href="extended_type_info.html#models">Models</a>
+ </dl></div></dd>
+ <dt><img style="display:none" src="dot.gif"><a target="detail" href="void_cast.html"><code>void_cast</code></a>
+ <dt><img style="display:none" src="dot.gif"><a target="detail" href="codecvt.html"><code>utf8_codecvt_facet</code></a>
+ <dt><img style="display:none" src="dot.gif"><a target="detail" href="strong_typedef.html"><code>BOOST_STRONG_TYPEDEF</code></a>
+ <dt><img style="display:none" src="dot.gif"><a target="detail" href="state_saver.html"><code>state_saver</code></a>
+ <dt><img style="display:none" src="dot.gif"><a target="detail" href="dataflow.html">Dataflow Iterators</a>
+ <dt><img style="display:none" src="dot.gif"><a target="detail" href="smart_cast.html"><code>smart_cast</code></a>
+ <dt><img style="display:none" src="dot.gif"><a target="detail" href="static_warning.html"><code>BOOST_STATIC_WARNING</code></a>
+ <dt><img style="display:none" src="plus.gif" id="singleton"><a target="detail" href="singleton.html"><code>singleton</code></a>
+ <dd><div id="singleton_detail"><dl class="page-index">
+ <dt><img style="display:none" src="dot.gif"><a target="detail" href="singleton.html#motivation">Motivation</a>
+ <dt><img style="display:none" src="dot.gif"><a target="detail" href="singleton.html#features">Features</a>
+ <dt><img style="display:none" src="dot.gif"><a target="detail" href="singleton.html#classinterface">Class Interface</a>
+ <dt><img style="display:none" src="dot.gif"><a target="detail" href="singleton.html#requirements">Requirements</a>
+ <dt><img style="display:none" src="dot.gif"><a target="detail" href="singleton.html#examples">Examples</a>
+ <dt><img style="display:none" src="dot.gif"><a target="detail" href="singleton.html#multithreading">Multi-Threading</a>
+ </dl></div></dd>
+ </dl></div></dd>
+ <!--
+ <dt><img style="display:none" src="dot.gif"><a target="detail" href="configuration.html">Configuration Information</a></dt>
+ -->
+ <dt><img style="display:none" src="dot.gif"><a target="detail" href="faq.html">Tips and Tricks</a>
+ <dt><img style="display:none" src="plus.gif" id="rationale"><a target="detail" href="rationale.html">Rationale</a></dt>
+ <dd><div id="rationale_detail"><dl class="page-index">
+ <dt><img style="display:none" src="dot.gif"><a target="detail" href="rationale.html#serialization">The term "serialization" is preferred to "persistence"</a></dt>
+ <dt><img style="display:none" src="dot.gif"><a target="detail" href="rationale.html#archives">Archives are not streams</a></dt>
+ <dt><img style="display:none" src="dot.gif"><a target="detail" href="rationale.html#typeid"><code style="white-space: normal">typeid</code> information is not included in archives</a></dt>
+ </dl></div></dd>
+
+ <dt><img style="display:none" src="plus.gif" id="todo"><a target="detail" href="todo.html">To Do</a></dt>
+ <dd><div id="todo_detail"><dl class="page-index">
+ <dt><img style="display:none" src="dot.gif"><a target="detail" href="todo.html#portablebinaryarchive">Portable Binary Archive</a></dt>
+ <dt><img style="display:none" src="dot.gif"><a target="detail" href="todo.html#performancetesting">Performance Testing and Profiling</a></dt>
+ <dt><img style="display:none" src="dot.gif"><a target="detail" href="todo.html#backversioning">Back Versioning</a></dt>
+ <dt><img style="display:none" src="dot.gif"><a target="detail" href="todo.html#nortti">Environments without RTTI</a></dt>
+
+ <dt><img style="display:none" src="plus.gif" id="newcasestudies"><a target="detail" href="new_case_studies.html">Proposed Case Studies</a></dt>
+ <dd><div id="newcasestudies_detail"><dl class="page-index">
+ <dt><img style="display:none" src="dot.gif"><a target="detail" href="new_case_studies.html#functionobject">Serializing a Function Object</a></dt>
+ <dt><img style="display:none" src="dot.gif"><a target="detail" href="new_case_studies.html#archiveadaptor">Archive Adaptors</a></dt>
+ <dt><img style="display:none" src="dot.gif"><a target="detail" href="new_case_studies.html#archivehelper">Archive Helpers</a></dt>
+ </dl></div></dd>
+
+ </dl></div></dd>
+
+ <dt><img style="display:none" src="dot.gif"><a target="detail" href="history.html">History</a>
+ <!--
+ <dt><img style="display:none" src="dot.gif"><a target="detail" href="definitions.html">Definitions</a></dt>
+ <dt><img style="display:none" src="dot.gif"><a target="detail" href="faq.html">Frequently Asked Questions (FAQs)</a></dt>
+ -->
+ <dt><img style="display:none" src="dot.gif"><a target="detail" href="bibliography.html">Bibliography</a></dt>
+ <dt><img style="display:none" src="dot.gif"><a target="detail" href="acknowledgments.html">Acknowledgments</a></dt>
+</dl></div>
+</small>
+</body>
+</html>
diff --git a/doc/dataflow.html b/doc/dataflow.html
new file mode 100644
index 0000000..553cc38
--- /dev/null
+++ b/doc/dataflow.html
@@ -0,0 +1,212 @@
+<!doctype HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
+<html>
+<!--
+(C) Copyright 2002-4 Robert Ramey - http://www.rrsd.com .
+Use, modification and distribution is subject to the Boost Software
+License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+http://www.boost.org/LICENSE_1_0.txt)
+-->
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
+<link rel="stylesheet" type="text/css" href="../../../boost.css">
+<link rel="stylesheet" type="text/css" href="style.css">
+<title>Serialization - Dataflow Iterators</title>
+</head>
+<body link="#0000ff" vlink="#800080">
+<table border="0" cellpadding="7" cellspacing="0" width="100%" summary="header">
+ <tr>
+ <td valign="top" width="300">
+ <h3><a href="../../../index.htm"><img height="86" width="277" alt="C++ Boost" src="../../../boost.png" border="0"></a></h3>
+ </td>
+ <td valign="top">
+ <h1 align="center">Serialization</h1>
+ <h2 align="center">Dataflow Iterators</h2>
+ </td>
+ </tr>
+</table>
+<hr>
+<h3>Motivation</h3>
+Consider the problem of translating an arbitrary length sequence of 8 bit bytes
+to base64 text. Such a process can be summarized as:
+<p>
+source => 8 bit bytes => 6 bit integers => encode to base64 characters => insert line breaks => destination
+<p>
+We would prefer the solution that is:
+<ul>
+ <li>Decomposable. so we can code, test, verify and use each (simple) stage of the conversion
+ independently.
+ <li>Composable. so we can use this composite as a new component somewhere else.
+ <li>Efficient, so we're not required to re-implement it again.
+ <li>Scalable, so that it works well for short and arbitrarily long sequences.
+</ul>
+The approach that comes closest to meeting these requirements is that described
+and implemented with <a href="../../iterator/doc/index.html">Iterator Adaptors</a>.
+The fundamental feature of an Iterator Adaptor template that makes it interesting to
+us is that it takes as a parameter a base iterator from which it derives its
+input. This suggests that something like the following might be possible.
+<pre><code>
+typedef
+ insert_linebreaks< // insert line breaks every 76 characters
+ base64_from_binary< // convert binary values to base64 characters
+ transform_width< // retrieve 6 bit integers from a sequence of 8 bit bytes
+ const char *,
+ 6,
+ 8
+ >
+ >
+ ,76
+ >
+ base64_text; // compose all the above operations in to a new iterator
+
+std::copy(
+ base64_text(address),
+ base64_text(address + count),
+ ostream_iterator<CharType>(os)
+);
+</code></pre>
+Indeed, this seems to be exactly the kind of problem that iterator adaptors are
+intended to address. The Iterator Adaptor library already includes
+modules which can be configured to implement some of the operations above. For example,
+included is <a target="transform_iterator" href="../../iterator/doc/transform_iterator.html">
+transform_iterator</a>, which can be used to implement 6 bit integer => base64 code.
+
+<h3>Dataflow Iterators</h3>
+Unfortunately, not all iterators which inherit from Iterator Adaptors are guaranteed
+to meet the composability goals stated above. To accomplish this purpose, they have
+to be written with some additional considerations in mind.
+
+We define a Dataflow Iterator as an class inherited from <code style="white-space: normal">iterator_adaptor</code> which
+fulfills a small set of additional requirements.
+
+<h4>Templated Constructors</h4>
+<p>
+Templated constructor have the form:
+<pre><code>
+template<class T>
+dataflow_iterator(T start) :
+ iterator_adaptor(Base(start))
+{}
+</code></pre>
+When these constructors are applied to our example of above, the following code is generated:
+<pre><code>
+std::copy(
+ insert_linebreaks(
+ base64_from_binary(
+ transform_width(
+ address
+ ),
+ )
+ ),
+ insert_linebreaks(
+ base64_from_binary(
+ transform_width(
+ address + count
+ )
+ )
+ )
+ ostream_iterator<char>(os)
+);
+</code></pre>
+The recursive application of this template is what automatically generates the
+constructor <code style="white-space: normal">base64_text(const char *)</code> in our example above. The original
+Iterator Adaptors include a <code style="white-space: normal">make_xxx_iterator</code> to fulfill this function.
+However, I believe these are unwieldy to use compared to the above solution using
+Templated constructors.
+<p>
+Unfortunately, some systems which fail to properly support partial function template
+ordering cannot support the concept of a templated constructor as implemented above.
+A special "wrapper" macro has been created to work around this problem. With this "wrapper"
+the above example is modified to:
+<pre><code>
+std::copy(
+ base64_text(BOOST_MAKE_PFTO_WRAPPER(address)),
+ base64_text(BOOST_MAKE_PFTO_WRAPPER(address + count)),
+ ostream_iterator<char>(os)
+);
+</code></pre>
+This macro is defined in <a target="pfto" href="../../../boost/serialization/pfto.hpp"><boost/serialization/pfto.hpp></a>.
+For more information about this topic, check the source.
+
+<h4>Dereferencing</h4>
+Dereferencing some iterators can cause problems. For example, a natural
+way to write a <code style="white-space: normal">remove_whitespace</code> iterator is to increment past the initial
+whitespaces when the iterator is constructed. This will fail if the iterator passed to the
+constructor "points" to the end of a string. The
+<a target="filter_iterator" href="../../iterator/doc/filter_iterator.html">
+<code style="white-space: normal">filter_iterator</code></a> is implemented
+in this way so it can't be used in our context. So, for implementation of this iterator,
+space removal is deferred until the iterator actually is dereferenced.
+
+<h4>Comparison</h4>
+The default implementation of iterator equality of <code style="white-space: normal">iterator_adaptor</code> just
+invokes the equality operator on the base iterators. Generally this is satisfactory.
+However, this implies that other operations (E. G. dereference) do not prematurely
+increment the base iterator. Avoiding this can be surprisingly tricky in some cases.
+(E.G. transform_width)
+
+<p>
+Iterators which fulfill the above requirements should be composable and the above sample
+code should implement our binary to base64 conversion.
+
+<h3>Iterators Included in the Library</h3>
+Dataflow iterators for the serialization library are all defined in the hamespace
+<code style="white-space: normal">boost::archive::iterators</code> included here are:
+<dl class="index">
+ <dt><a target="base64_from_binary" href="../../../boost/archive/iterators/base64_from_binary.hpp">
+ base64_from_binary</a></dt>
+ <dd>transforms a sequence of integers to base64 text</dd>
+
+ <dt><a target="base64_from_binary" href="../../../boost/archive/iterators/binary_from_base64.hpp">
+ binary_from_base64</a></dt>
+ <dd>transforms a sequence of base64 characters to a sequence of integers</dd>
+
+ <dt><a target="insert_linebreaks" href="../../../boost/archive/iterators/insert_linebreaks.hpp">
+ insert_linebreaks</a></dt>
+ <dd>given a sequence, creates a sequence with newline characters inserted</dd>
+
+ <dt><a target="mb_from_wchar" href="../../../boost/archive/iterators/mb_from_wchar.hpp">
+ mb_from_wchar</a></dt>
+ <dd>transforms a sequence of wide characters to a sequence of multi-byte characters</dd>
+
+ <dt><a target="remove_whitespace" href="../../../boost/archive/iterators/remove_whitespace.hpp">
+ remove_whitespace</a></dt>
+ <dd>given a sequence of characters, returns a sequence with the white characters
+ removed. This is a derivation from the <code style="white-space: normal">boost::filter_iterator</code></dd>
+
+ <dt><a target="transform_width" href="../../../boost/archive/iterators/transform_width.hpp">
+ transform_width</a></dt>
+ <dd>transforms a sequence of x bit elements into a sequence of y bit elements. This
+ is a key component in iterators which translate to and from base64 text.</dd>
+
+ <dt><a target="wchar_from_mb" href="../../../boost/archive/iterators/wchar_from_mb.hpp">
+ wchar_from_mb</a></dt>
+ <dd>transform a sequence of multi-byte characters in the current locale to wide characters.</dd>
+
+ <dt><a target="xml_escape" href="../../../boost/archive/iterators/xml_escape.hpp">
+ xml_escape</a></dt>
+ <dd>escapes xml meta-characters from xml text</dd>
+
+ <dt><a target="xml_unescape" href="../../../boost/archive/iterators/xml_unescape.hpp">
+ xml_unescape</a></dt>
+ <dd>unescapes xml escape sequences to create a sequence of normal text<dd>
+</dl>
+<p>
+The standard stream iterators don't quite work for us. On systems which implement <code style="white-space: normal">wchar_t</code>
+as unsigned short integers (E.G. VC 6) they didn't function as I expected. I also made some
+adjustments to be consistent with our concept of Dataflow Iterators. Like the rest of our
+iterators, they are found in the namespace <code style="white-space: normal">boost::archive::interators</code> to avoid
+conflicts with the standard library versions.
+<dl class = "index">
+ <dt><a target="istream_iterator" href="../../../boost/archive/iterators/istream_iterator.hpp">
+ istream_iterator</a></dt>
+ <dt><a target="ostream_iterator" href="../../../boost/archive/iterators/ostream_iterator.hpp">
+ ostream_iterator</a></dt>
+</dl>
+
+<hr>
+<p><i>© Copyright <a href="http://www.rrsd.com">Robert Ramey</a> 2002-2004.
+Distributed under the Boost Software License, Version 1.0. (See
+accompanying file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+</i></p>
+</body>
+</html>
diff --git a/doc/definitions.html b/doc/definitions.html
new file mode 100644
index 0000000..ecfb61d
--- /dev/null
+++ b/doc/definitions.html
@@ -0,0 +1,17 @@
+<!doctype HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
+<html>
+<!--
+(C) Copyright 2002-4 Robert Ramey - http://www.rrsd.com .
+Use, modification and distribution is subject to the Boost Software
+License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+http://www.boost.org/LICENSE_1_0.txt)
+-->
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
+<link rel="stylesheet" type="text/css" href="../../../boost.css">
+<link rel="stylesheet" type="text/css" href="style.css">
+<title>Serialization - Definitions</title>
+</head>
+<body link="#0000ff" vlink="#800080">
+</body>
+</html>
diff --git a/doc/derivation.html b/doc/derivation.html
new file mode 100644
index 0000000..31a8819
--- /dev/null
+++ b/doc/derivation.html
@@ -0,0 +1,157 @@
+<!doctype HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
+<html>
+<!--
+(C) Copyright 2002-4 Robert Ramey - http://www.rrsd.com .
+Use, modification and distribution is subject to the Boost Software
+License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+http://www.boost.org/LICENSE_1_0.txt)
+-->
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
+<link rel="stylesheet" type="text/css" href="../../../boost.css">
+<link rel="stylesheet" type="text/css" href="style.css">
+<title>Serialization - Derivation from an Existing Archive</title>
+</head>
+<body link="#0000ff" vlink="#800080">
+<table border="0" cellpadding="7" cellspacing="0" width="100%" summary="header">
+ <tr>
+ <td valign="top" width="300">
+ <h3><a href="../../../index.htm"><img height="86" width="277" alt="C++ Boost" src="../../../boost.png" border="0"></a></h3>
+ </td>
+ <td valign="top">
+ <h1 align="center">Serialization</h1>
+ <h2 align="center">Derivation from an Existing Archive</h2>
+ </td>
+ </tr>
+</table>
+<hr>
+<dl class="page-index">
+</dl>
+
+<h3>Log Archive</h3>
+It may happen that one wants to create a new archive class by derivation from one
+of the included ones. Included is a sample program that shows how to derive a
+new archive from one of the ones included with the library. The first example is
+<a href="../example/demo_log.cpp" target="demo_log_cpp">
+demo_log.cpp</a>.
+<p>
+This derivation from the xml archive writes output in xml without the extra
+information required to read the data back into the application. It might be
+used to export one's data as simple xml for other applications or for logging
+data while debugging.
+<p>
+To this end it is derived from the included xml archive and the save functions for
+some types are specialized for this application.
+<p>
+The serialization library is
+implemented using the <b>C</b>uriously <b>R</b>ecurring <b>T</b>emplate
+<b>P</b>attern (<b>CRTP</b>). Also, all common code is factored out into
+separate modules to minimize code repetition. This makes derivation from
+an existing archive less straightforward than it would otherwise be.
+<p>
+This example illustrates several issues that have to be addressed when doing
+something like this
+<ol>
+ <li><i>It is derived from</i> <code style="white-space: normal">xml_oarchive_impl<log_archive></code>
+ <b>NOT</b> <code style="white-space: normal">xml_oarchive</code> <br>
+As described in the comments in
+<a href="../../../boost/archive/xml_oarchive.hpp" target="xml_oarchive_hpp">xml_oarchive.hpp</a>.
+<code style="white-space: normal">xml_oarchive</code> really a shorthand name for
+<code style="white-space: normal">xml_oarchive_impl<xml_oarchive></code>. So we should derive
+from <code style="white-space: normal">xml_oarchive_impl<log_archive></code> rather
+than <code style="white-space: normal">xml_oarchive</code>.
+<pre><code>
+class log_archive :
+ // don't derive from xml_oarchive !!!
+ public xml_oarchive_impl<log_archive>
+{
+...
+</code></pre>
+ <li><i>Note the</i> <code style="white-space: normal">log_archive</code> <i>between the</i> <>
+This is required so that base classes can downcast their <code style="white-space: normal">this</code> pointer
+to the most derived class. This is referred to as <b>C</b>uriously <b>R</b>ecurring
+<b>T</b>emplate <b>P</b>attern (<b>CRTP</b>) <a href="bibliography.html#11">[11]</a>.
+It is used to implement static polymorphism.
+ <li><i>Base classes need to be explicitly given access to the derived class.</i>
+This can be done by making members public or by including friend declarations for
+the base classes.
+<pre><code>
+ friend class detail::common_oarchive<log_archive>;
+ friend class basic_xml_oarchive<log_archive>;
+ friend class boost::serialization::save_access;
+</code></pre>
+
+ <li><i></i>Reread <a target="detail" href="headers.html#archiveinternals">Archive Internals</a>.
+This describes the class hierarchy so that you know what to override.
+ <li><i>Note the usage of PFTO.</i> Some compilers fail to provide support for
+partial function template ordering. The serialization library works around this by
+using <a target="detail" href="implementation.html#functiontemplateordering">
+<b>P</b>artial <b>F</b>unction <b>T</b>emplate <b>O</b>rdering</a> in several places.
+This is done
+in several places, including the archive classes themselves.
+ <li><i>Base class functions will usually need to be explicitly invoked.</i>
+We commonly specialize the function name <code style="white-space: normal">save_override</code>
+for saving primitives. Usage of a function name in a derived class
+"hides" similarly named functions of the base class. That is,
+function name overloading doesn't automatically
+include base classes. To address this, we can use:
+<pre><code>
+ using xml_oarchive_impl<derived_t>::save;
+ void save(const unsigned int t);
+ ...
+</code></pre>
+which should work on conforming compilers. However, I have found
+that the following equivalent works on more compilers.
+<pre><code>
+ // default fall through for any types not specified here
+ template<class T>
+ void save(const T & t){
+ xml_oarchive_impl<derived_t>::save(t);
+ }
+ void save(const unsigned int t);
+ ...
+</code></pre>
+so it's what I use.
+ <li><i>Template definitions of base classes may have to be explicitly instantiated.</i>
+ The demo includes
+<pre><code>
+// explicitly instantiate for this type of binary stream
+#include <boost/archive/basic_binary_oprimitive.ipp>
+</code></pre>
+for just this purpose. Failure to include required template definitions
+will result in undefined symbol errors when the program is linked.
+ <li><i>Without alteration, this class cannot be further derived from.</i><br>
+Base classes using <b>CRTP</b> must be templates with a parameter corresponding to
+the most derived class. As presented here, this class doesn't qualify, so
+it cannot be used as a base class. In order to derive further from this class,
+it would have to be reorganized along the lines of the original <code style="white-space: normal">xml_oarchive</code>.
+Specifically, it would look something like:
+<pre><code>
+template<class Archive>
+class log_archive_impl :
+ // don't derive from xml_oarchive !!!
+ public xml_oarchive_impl<Archive>
+{
+ ...
+);
+
+// do not derive from this class !!!
+class log_archive :
+ public log_archive_impl<log_archive>
+{
+public:
+ log_archive(std::ostream & os, unsigned int flags = 0) :
+ log_archive_impl<xml_oarchive>(os, flags)
+ {}
+};
+</code></pre>
+
+</ol>
+
+<hr>
+<p><i>© Copyright <a href="http://www.rrsd.com">Robert Ramey</a> 2002-2004.
+Distributed under the Boost Software License, Version 1.0. (See
+accompanying file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+</i></p>
+</body>
+</html>