Showing preview only (2,304K chars total). Download the full file or copy to clipboard to get everything.
Repository: boostorg/serialization
Branch: develop
Commit: 097a6c63a137
Files: 540
Total size: 2.1 MB
Directory structure:
gitextract_ba__d2tt/
├── .drone/
│ └── drone.sh
├── .drone.star
├── .gitattributes
├── .github/
│ └── workflows/
│ ├── posix.yml
│ └── windows.yml
├── .gitignore
├── .travis.yml
├── CMake/
│ └── CMakeLists.txt
├── CMakeLists.txt
├── appveyor.yml
├── build/
│ └── Jamfile.v2
├── build.jam
├── doc/
│ ├── acknowledgments.html
│ ├── archive_reference.html
│ ├── archives.html
│ ├── bibliography.html
│ ├── class_diagram.html
│ ├── codecvt.html
│ ├── configuration.html
│ ├── contents.html
│ ├── dataflow.html
│ ├── definitions.html
│ ├── derivation.html
│ ├── exception_safety.html
│ ├── exceptions.html
│ ├── extended_type_info.html
│ ├── faq.html
│ ├── headers.html
│ ├── history.html
│ ├── implementation.html
│ ├── index.html
│ ├── new_case_studies.html
│ ├── overview.html
│ ├── performance_status.html
│ ├── pimpl.html
│ ├── private_base.html
│ ├── profile1.txt
│ ├── profile2.txt
│ ├── profile3.txt
│ ├── rationale.html
│ ├── reference.html
│ ├── release.html
│ ├── serialization.html
│ ├── shared_ptr.html
│ ├── shared_ptr2.html
│ ├── simple_log.html
│ ├── singleton.html
│ ├── smart_cast.html
│ ├── special.html
│ ├── state_saver.html
│ ├── static_warning.html
│ ├── strong_typedef.html
│ ├── style.css
│ ├── todo.html
│ ├── traits.html
│ ├── tutorial.html
│ ├── void_cast.html
│ └── wrappers.html
├── example/
│ ├── Jamfile.v2
│ ├── demo.cpp
│ ├── demo_auto_ptr.cpp
│ ├── demo_dll_a.hpp
│ ├── demo_dll_a.ipp
│ ├── demo_dll_b.hpp
│ ├── demo_dll_b.ipp
│ ├── demo_exception.cpp
│ ├── demo_fast_archive.cpp
│ ├── demo_gps.hpp
│ ├── demo_log.cpp
│ ├── demo_output.txt
│ ├── demo_pimpl.cpp
│ ├── demo_pimpl_A.cpp
│ ├── demo_pimpl_A.hpp
│ ├── demo_polymorphic.cpp
│ ├── demo_polymorphic_A.cpp
│ ├── demo_polymorphic_A.hpp
│ ├── demo_portable_archive.cpp
│ ├── demo_save.xml
│ ├── demo_shared_ptr.cpp
│ ├── demo_simple_log.cpp
│ ├── demo_trivial_archive.cpp
│ ├── demo_xml.cpp
│ ├── demo_xml.hpp
│ ├── demo_xml_load.cpp
│ ├── demo_xml_save.cpp
│ ├── demofile.txt
│ ├── fix_six.cpp
│ ├── log_archive.cpp
│ ├── log_archive.hpp
│ ├── polymorphic_portable_binary_iarchive.cpp
│ ├── polymorphic_portable_binary_iarchive.hpp
│ ├── polymorphic_portable_binary_oarchive.cpp
│ ├── polymorphic_portable_binary_oarchive.hpp
│ ├── portable_binary_archive.hpp
│ ├── portable_binary_iarchive.cpp
│ ├── portable_binary_iarchive.hpp
│ ├── portable_binary_oarchive.cpp
│ ├── portable_binary_oarchive.hpp
│ └── simple_log_archive.hpp
├── include/
│ └── boost/
│ ├── archive/
│ │ ├── archive_exception.hpp
│ │ ├── basic_archive.hpp
│ │ ├── basic_binary_iarchive.hpp
│ │ ├── basic_binary_iprimitive.hpp
│ │ ├── basic_binary_oarchive.hpp
│ │ ├── basic_binary_oprimitive.hpp
│ │ ├── basic_streambuf_locale_saver.hpp
│ │ ├── basic_text_iarchive.hpp
│ │ ├── basic_text_iprimitive.hpp
│ │ ├── basic_text_oarchive.hpp
│ │ ├── basic_text_oprimitive.hpp
│ │ ├── basic_xml_archive.hpp
│ │ ├── basic_xml_iarchive.hpp
│ │ ├── basic_xml_oarchive.hpp
│ │ ├── binary_iarchive.hpp
│ │ ├── binary_iarchive_impl.hpp
│ │ ├── binary_oarchive.hpp
│ │ ├── binary_oarchive_impl.hpp
│ │ ├── binary_wiarchive.hpp
│ │ ├── binary_woarchive.hpp
│ │ ├── codecvt_null.hpp
│ │ ├── detail/
│ │ │ ├── abi_prefix.hpp
│ │ │ ├── abi_suffix.hpp
│ │ │ ├── archive_serializer_map.hpp
│ │ │ ├── auto_link_archive.hpp
│ │ │ ├── auto_link_warchive.hpp
│ │ │ ├── basic_iarchive.hpp
│ │ │ ├── basic_iserializer.hpp
│ │ │ ├── basic_oarchive.hpp
│ │ │ ├── basic_oserializer.hpp
│ │ │ ├── basic_pointer_iserializer.hpp
│ │ │ ├── basic_pointer_oserializer.hpp
│ │ │ ├── basic_serializer.hpp
│ │ │ ├── basic_serializer_map.hpp
│ │ │ ├── check.hpp
│ │ │ ├── common_iarchive.hpp
│ │ │ ├── common_oarchive.hpp
│ │ │ ├── decl.hpp
│ │ │ ├── helper_collection.hpp
│ │ │ ├── interface_iarchive.hpp
│ │ │ ├── interface_oarchive.hpp
│ │ │ ├── iserializer.hpp
│ │ │ ├── oserializer.hpp
│ │ │ ├── polymorphic_iarchive_route.hpp
│ │ │ ├── polymorphic_oarchive_route.hpp
│ │ │ ├── register_archive.hpp
│ │ │ └── utf8_codecvt_facet.hpp
│ │ ├── dinkumware.hpp
│ │ ├── impl/
│ │ │ ├── archive_serializer_map.ipp
│ │ │ ├── basic_binary_iarchive.ipp
│ │ │ ├── basic_binary_iprimitive.ipp
│ │ │ ├── basic_binary_oarchive.ipp
│ │ │ ├── basic_binary_oprimitive.ipp
│ │ │ ├── basic_text_iarchive.ipp
│ │ │ ├── basic_text_iprimitive.ipp
│ │ │ ├── basic_text_oarchive.ipp
│ │ │ ├── basic_text_oprimitive.ipp
│ │ │ ├── basic_xml_grammar.hpp
│ │ │ ├── basic_xml_iarchive.ipp
│ │ │ ├── basic_xml_oarchive.ipp
│ │ │ ├── text_iarchive_impl.ipp
│ │ │ ├── text_oarchive_impl.ipp
│ │ │ ├── text_wiarchive_impl.ipp
│ │ │ ├── text_woarchive_impl.ipp
│ │ │ ├── xml_iarchive_impl.ipp
│ │ │ ├── xml_oarchive_impl.ipp
│ │ │ ├── xml_wiarchive_impl.ipp
│ │ │ └── xml_woarchive_impl.ipp
│ │ ├── iterators/
│ │ │ ├── base64_exception.hpp
│ │ │ ├── base64_from_binary.hpp
│ │ │ ├── binary_from_base64.hpp
│ │ │ ├── dataflow.hpp
│ │ │ ├── dataflow_exception.hpp
│ │ │ ├── escape.hpp
│ │ │ ├── insert_linebreaks.hpp
│ │ │ ├── istream_iterator.hpp
│ │ │ ├── mb_from_wchar.hpp
│ │ │ ├── ostream_iterator.hpp
│ │ │ ├── remove_whitespace.hpp
│ │ │ ├── transform_width.hpp
│ │ │ ├── unescape.hpp
│ │ │ ├── wchar_from_mb.hpp
│ │ │ ├── xml_escape.hpp
│ │ │ ├── xml_unescape.hpp
│ │ │ └── xml_unescape_exception.hpp
│ │ ├── polymorphic_binary_iarchive.hpp
│ │ ├── polymorphic_binary_oarchive.hpp
│ │ ├── polymorphic_iarchive.hpp
│ │ ├── polymorphic_oarchive.hpp
│ │ ├── polymorphic_text_iarchive.hpp
│ │ ├── polymorphic_text_oarchive.hpp
│ │ ├── polymorphic_text_wiarchive.hpp
│ │ ├── polymorphic_text_woarchive.hpp
│ │ ├── polymorphic_xml_iarchive.hpp
│ │ ├── polymorphic_xml_oarchive.hpp
│ │ ├── polymorphic_xml_wiarchive.hpp
│ │ ├── polymorphic_xml_woarchive.hpp
│ │ ├── text_iarchive.hpp
│ │ ├── text_oarchive.hpp
│ │ ├── text_wiarchive.hpp
│ │ ├── text_woarchive.hpp
│ │ ├── tmpdir.hpp
│ │ ├── wcslen.hpp
│ │ ├── xml_archive_exception.hpp
│ │ ├── xml_iarchive.hpp
│ │ ├── xml_oarchive.hpp
│ │ ├── xml_wiarchive.hpp
│ │ └── xml_woarchive.hpp
│ └── serialization/
│ ├── access.hpp
│ ├── archive_input_unordered_map.hpp
│ ├── archive_input_unordered_set.hpp
│ ├── array.hpp
│ ├── array_optimization.hpp
│ ├── array_wrapper.hpp
│ ├── assume_abstract.hpp
│ ├── base_object.hpp
│ ├── binary_object.hpp
│ ├── bitset.hpp
│ ├── boost_array.hpp
│ ├── boost_unordered_map.hpp
│ ├── boost_unordered_set.hpp
│ ├── collection_size_type.hpp
│ ├── collection_traits.hpp
│ ├── collections_load_imp.hpp
│ ├── collections_save_imp.hpp
│ ├── complex.hpp
│ ├── config.hpp
│ ├── deque.hpp
│ ├── detail/
│ │ ├── is_default_constructible.hpp
│ │ ├── shared_count_132.hpp
│ │ ├── shared_ptr_132.hpp
│ │ ├── shared_ptr_nmt_132.hpp
│ │ └── stack_constructor.hpp
│ ├── export.hpp
│ ├── extended_type_info.hpp
│ ├── extended_type_info_no_rtti.hpp
│ ├── extended_type_info_typeid.hpp
│ ├── factory.hpp
│ ├── force_include.hpp
│ ├── forward_list.hpp
│ ├── hash_collections_load_imp.hpp
│ ├── hash_collections_save_imp.hpp
│ ├── hash_map.hpp
│ ├── hash_set.hpp
│ ├── is_bitwise_serializable.hpp
│ ├── item_version_type.hpp
│ ├── level.hpp
│ ├── level_enum.hpp
│ ├── library_version_type.hpp
│ ├── list.hpp
│ ├── map.hpp
│ ├── nvp.hpp
│ ├── optional.hpp
│ ├── priority_queue.hpp
│ ├── queue.hpp
│ ├── scoped_ptr.hpp
│ ├── serialization.hpp
│ ├── set.hpp
│ ├── shared_ptr.hpp
│ ├── shared_ptr_132.hpp
│ ├── shared_ptr_helper.hpp
│ ├── singleton.hpp
│ ├── slist.hpp
│ ├── smart_cast.hpp
│ ├── split_free.hpp
│ ├── split_member.hpp
│ ├── stack.hpp
│ ├── state_saver.hpp
│ ├── static_warning.hpp
│ ├── std_variant.hpp
│ ├── string.hpp
│ ├── strong_typedef.hpp
│ ├── throw_exception.hpp
│ ├── tracking.hpp
│ ├── tracking_enum.hpp
│ ├── traits.hpp
│ ├── type_info_implementation.hpp
│ ├── unique_ptr.hpp
│ ├── unordered_collections_load_imp.hpp
│ ├── unordered_collections_save_imp.hpp
│ ├── unordered_map.hpp
│ ├── unordered_set.hpp
│ ├── utility.hpp
│ ├── valarray.hpp
│ ├── variant.hpp
│ ├── variant2.hpp
│ ├── vector.hpp
│ ├── vector_135.hpp
│ ├── version.hpp
│ ├── void_cast.hpp
│ ├── void_cast_fwd.hpp
│ ├── weak_ptr.hpp
│ └── wrapper.hpp
├── index.html
├── meta/
│ └── libraries.json
├── performance/
│ ├── Jamfile.v2
│ ├── binary_archive.hpp
│ ├── binary_warchive.hpp
│ ├── peformance_array.cpp
│ ├── performance_binary.cpp
│ ├── performance_codecvt_null.cpp
│ ├── performance_iterators.cpp
│ ├── performance_iterators_base64.cpp
│ ├── performance_no_rtti.cpp
│ ├── performance_polymorphic.cpp
│ ├── performance_simple_class.cpp
│ ├── performance_utf8_codecvt.cpp
│ ├── performance_vector.cpp
│ ├── polymorphic_array_binary_archive.hpp
│ ├── polymorphic_binary_archive.hpp
│ ├── polymorphic_text_archive.hpp
│ ├── polymorphic_text_warchive.hpp
│ ├── polymorphic_xml_archive.hpp
│ ├── polymorphic_xml_warchive.hpp
│ ├── portable_binary_archive.hpp
│ ├── profile.sh
│ ├── text_archive.hpp
│ ├── text_warchive.hpp
│ ├── xml/
│ │ ├── Jamfile.v2
│ │ ├── harness.hpp
│ │ ├── high_resolution_timer.hpp
│ │ ├── int16_results.xml
│ │ ├── int16_test.cpp
│ │ ├── int256_results.xml
│ │ ├── int256_test.cpp
│ │ ├── int4_results.xml
│ │ ├── int4_test.cpp
│ │ ├── int64_results.xml
│ │ ├── int64_test.cpp
│ │ ├── macro.hpp
│ │ ├── node.hpp
│ │ ├── string16_results.xml
│ │ ├── string16_test.cpp
│ │ ├── string256_results.xml
│ │ ├── string256_test.cpp
│ │ ├── string4_results.xml
│ │ ├── string4_test.cpp
│ │ ├── string64_results.xml
│ │ └── string64_test.cpp
│ ├── xml_archive.hpp
│ └── xml_warchive.hpp
├── src/
│ ├── archive_exception.cpp
│ ├── basic_archive.cpp
│ ├── basic_iarchive.cpp
│ ├── basic_iserializer.cpp
│ ├── basic_oarchive.cpp
│ ├── basic_oserializer.cpp
│ ├── basic_pointer_iserializer.cpp
│ ├── basic_pointer_oserializer.cpp
│ ├── basic_serializer_map.cpp
│ ├── basic_text_iprimitive.cpp
│ ├── basic_text_oprimitive.cpp
│ ├── basic_text_wiprimitive.cpp
│ ├── basic_text_woprimitive.cpp
│ ├── basic_xml_archive.cpp
│ ├── basic_xml_grammar.ipp
│ ├── binary_iarchive.cpp
│ ├── binary_oarchive.cpp
│ ├── binary_wiarchive.cpp
│ ├── binary_woarchive.cpp
│ ├── codecvt_null.cpp
│ ├── extended_type_info.cpp
│ ├── extended_type_info_no_rtti.cpp
│ ├── extended_type_info_typeid.cpp
│ ├── polymorphic_binary_iarchive.cpp
│ ├── polymorphic_binary_oarchive.cpp
│ ├── polymorphic_iarchive.cpp
│ ├── polymorphic_oarchive.cpp
│ ├── polymorphic_text_iarchive.cpp
│ ├── polymorphic_text_oarchive.cpp
│ ├── polymorphic_text_wiarchive.cpp
│ ├── polymorphic_text_woarchive.cpp
│ ├── polymorphic_xml_iarchive.cpp
│ ├── polymorphic_xml_oarchive.cpp
│ ├── polymorphic_xml_wiarchive.cpp
│ ├── polymorphic_xml_woarchive.cpp
│ ├── stl_port.cpp
│ ├── text_iarchive.cpp
│ ├── text_oarchive.cpp
│ ├── text_wiarchive.cpp
│ ├── text_woarchive.cpp
│ ├── utf8_codecvt_facet.cpp
│ ├── void_cast.cpp
│ ├── xml_archive_exception.cpp
│ ├── xml_grammar.cpp
│ ├── xml_iarchive.cpp
│ ├── xml_oarchive.cpp
│ ├── xml_wgrammar.cpp
│ ├── xml_wiarchive.cpp
│ └── xml_woarchive.cpp
├── test/
│ ├── A.cpp
│ ├── A.hpp
│ ├── A.ipp
│ ├── B.hpp
│ ├── C.hpp
│ ├── D.hpp
│ ├── J.hpp
│ ├── Jamfile.v2
│ ├── base.hpp
│ ├── binary_archive.hpp
│ ├── binary_warchive.hpp
│ ├── config_test.cpp
│ ├── derived2.hpp
│ ├── dll_a.cpp
│ ├── dll_base.cpp
│ ├── dll_derived2.cpp
│ ├── dll_polymorphic_base.cpp
│ ├── dll_polymorphic_derived2.cpp
│ ├── multi_shared1.cpp
│ ├── multi_shared2.cpp
│ ├── polymorphic_array_binary_archive.hpp
│ ├── polymorphic_base.cpp
│ ├── polymorphic_base.hpp
│ ├── polymorphic_binary_archive.hpp
│ ├── polymorphic_derived1.cpp
│ ├── polymorphic_derived1.hpp
│ ├── polymorphic_derived2.cpp
│ ├── polymorphic_derived2.hpp
│ ├── polymorphic_text_archive.hpp
│ ├── polymorphic_text_warchive.hpp
│ ├── polymorphic_xml_archive.hpp
│ ├── polymorphic_xml_warchive.hpp
│ ├── portable_binary_archive.hpp
│ ├── test__helper.cpp
│ ├── test_array.cpp
│ ├── test_binary.cpp
│ ├── test_bitset.cpp
│ ├── test_boost_array.cpp
│ ├── test_check.cpp
│ ├── test_class_info_load.cpp
│ ├── test_class_info_save.cpp
│ ├── test_codecvt_null.cpp
│ ├── test_complex.cpp
│ ├── test_const_load_fail1.cpp
│ ├── test_const_load_fail1_nvp.cpp
│ ├── test_const_load_fail2.cpp
│ ├── test_const_load_fail2_nvp.cpp
│ ├── test_const_load_fail3.cpp
│ ├── test_const_load_fail3_nvp.cpp
│ ├── test_const_pass.cpp
│ ├── test_const_save_warn1.cpp
│ ├── test_const_save_warn1_nvp.cpp
│ ├── test_const_save_warn2.cpp
│ ├── test_const_save_warn2_nvp.cpp
│ ├── test_const_save_warn3.cpp
│ ├── test_const_save_warn3_nvp.cpp
│ ├── test_const_save_warn4.cpp
│ ├── test_const_save_warn4_nvp.cpp
│ ├── test_contained_class.cpp
│ ├── test_cyclic_ptrs.cpp
│ ├── test_delete_pointer.cpp
│ ├── test_deque.cpp
│ ├── test_derived.cpp
│ ├── test_derived_class.cpp
│ ├── test_derived_class_ptr.cpp
│ ├── test_diamond.cpp
│ ├── test_diamond_complex.cpp
│ ├── test_dll_exported.cpp
│ ├── test_dll_plugin.cpp
│ ├── test_dll_simple.cpp
│ ├── test_enable_shared_from_this.cpp
│ ├── test_exported.cpp
│ ├── test_forward_list.cpp
│ ├── test_forward_list_ptrs.cpp
│ ├── test_helper_support.cpp
│ ├── test_inclusion.cpp
│ ├── test_inclusion2.cpp
│ ├── test_interators.cpp
│ ├── test_interrupts.cpp
│ ├── test_iterators.cpp
│ ├── test_iterators_base64.cpp
│ ├── test_list.cpp
│ ├── test_list_ptrs.cpp
│ ├── test_map.cpp
│ ├── test_map_hashed.cpp
│ ├── test_mi.cpp
│ ├── test_mult_archive_types.cpp
│ ├── test_multi_shared_lib.cpp
│ ├── test_multiple_inheritance.cpp
│ ├── test_multiple_ptrs.cpp
│ ├── test_native_array.cpp
│ ├── test_new_operator.cpp
│ ├── test_no_rtti.cpp
│ ├── test_non_default_ctor.cpp
│ ├── test_non_default_ctor2.cpp
│ ├── test_non_intrusive.cpp
│ ├── test_not_serializable.cpp
│ ├── test_null_ptr.cpp
│ ├── test_nvp.cpp
│ ├── test_object.cpp
│ ├── test_optional.cpp
│ ├── test_p_helper.cpp
│ ├── test_pimpl.cpp
│ ├── test_polymorphic.cpp
│ ├── test_polymorphic2.cpp
│ ├── test_polymorphic2.hpp
│ ├── test_polymorphic2imp.cpp
│ ├── test_polymorphic_A.cpp
│ ├── test_polymorphic_A.hpp
│ ├── test_primitive.cpp
│ ├── test_priority_queue.cpp
│ ├── test_private_base.cpp
│ ├── test_private_base2.cpp
│ ├── test_private_ctor.cpp
│ ├── test_queue.cpp
│ ├── test_recursion.cpp
│ ├── test_registered.cpp
│ ├── test_reset_object_address.cpp
│ ├── test_set.cpp
│ ├── test_set_hashed.cpp
│ ├── test_shared_ptr.cpp
│ ├── test_shared_ptr_132.cpp
│ ├── test_shared_ptr_multi_base.cpp
│ ├── test_simple_class.cpp
│ ├── test_simple_class_ptr.cpp
│ ├── test_singleton.cpp
│ ├── test_singleton_inherited.cpp
│ ├── test_singleton_plain.cpp
│ ├── test_slist.cpp
│ ├── test_slist_ptrs.cpp
│ ├── test_smart_cast.cpp
│ ├── test_split.cpp
│ ├── test_stack.cpp
│ ├── test_static_warning.cpp
│ ├── test_strong_typedef.cpp
│ ├── test_tools.hpp
│ ├── test_tracking.cpp
│ ├── test_traits_fail.cpp
│ ├── test_traits_pass.cpp
│ ├── test_unique_ptr.cpp
│ ├── test_unregistered.cpp
│ ├── test_valarray.cpp
│ ├── test_variant.cpp
│ ├── test_vector.cpp
│ ├── test_void_cast.cpp
│ ├── test_z.cpp
│ ├── text_archive.hpp
│ ├── text_warchive.hpp
│ ├── xml_archive.hpp
│ └── xml_warchive.hpp
└── util/
└── test.jam
================================================
FILE CONTENTS
================================================
================================================
FILE: .drone/drone.sh
================================================
#!/bin/bash
# Copyright 2020 Rene Rivera, Sam Darwin
# Distributed under the Boost Software License, Version 1.0.
# (See accompanying file LICENSE.txt or copy at http://boost.org/LICENSE_1_0.txt)
set -e
export TRAVIS_BUILD_DIR=$(pwd)
export DRONE_BUILD_DIR=$(pwd)
export TRAVIS_BRANCH=$DRONE_BRANCH
export VCS_COMMIT_ID=$DRONE_COMMIT
export GIT_COMMIT=$DRONE_COMMIT
export REPO_NAME=$DRONE_REPO
export PATH=~/.local/bin:/usr/local/bin:$PATH
if [ "$DRONE_JOB_BUILDTYPE" == "boost" ]; then
echo '==================================> INSTALL'
BOOST_BRANCH=develop && [ "$TRAVIS_BRANCH" == "master" ] && BOOST_BRANCH=master || true
cd ..
git clone -b $BOOST_BRANCH https://github.com/boostorg/boost.git boost-root
cd boost-root
git submodule update --init tools/build
git submodule update --init libs/config
git submodule update --init tools/boostdep
cp -r $TRAVIS_BUILD_DIR/* libs/serialization
python tools/boostdep/depinst/depinst.py serialization
./bootstrap.sh
./b2 headers
echo '==================================> SCRIPT'
echo "using $TOOLSET : : $TRAVIS_COMPILER ;" > ~/user-config.jam
./b2 -j 3 libs/serialization/test toolset=$TOOLSET link=${LINK:-shared}
fi
================================================
FILE: .drone.star
================================================
# Use, modification, and distribution are
# subject to the Boost Software License, Version 1.0. (See accompanying
# file LICENSE.txt)
#
# Copyright Rene Rivera 2020.
# For Drone CI we use the Starlark scripting language to reduce duplication.
# As the yaml syntax for Drone CI is rather limited.
#
#
globalenv={}
linuxglobalimage="cppalliance/droneubuntu1604:1"
windowsglobalimage="cppalliance/dronevs2019"
def main(ctx):
return [
linux_cxx("TOOLSET=gcc LINK=static,shared Job 0", "g++", packages="", buildtype="boost", buildscript="drone", image=linuxglobalimage, environment={'TOOLSET': 'gcc', 'LINK': 'static,shared', 'TRAVIS_COMPILER': 'g++', 'DRONE_JOB_UUID': 'b6589fc6ab'}, globalenv=globalenv),
linux_cxx("TOOLSET=gcc LINK=static,shared Job 1", "g++", packages="g++-5", buildtype="boost", buildscript="drone", image=linuxglobalimage, environment={'TOOLSET': 'gcc', 'LINK': 'static,shared', 'TRAVIS_COMPILER': 'g++-5', 'DRONE_JOB_UUID': '356a192b79'}, globalenv=globalenv),
linux_cxx("TOOLSET=gcc LINK=static,shared Job 2", "g++", packages="g++-6", buildtype="boost", buildscript="drone", image=linuxglobalimage, environment={'TOOLSET': 'gcc', 'LINK': 'static,shared', 'TRAVIS_COMPILER': 'g++-6', 'DRONE_JOB_UUID': 'da4b9237ba'}, globalenv=globalenv),
linux_cxx("TOOLSET=gcc LINK=static,shared Job 3", "g++", packages="g++-7", buildtype="boost", buildscript="drone", image=linuxglobalimage, environment={'TOOLSET': 'gcc', 'LINK': 'static,shared', 'TRAVIS_COMPILER': 'g++-7', 'DRONE_JOB_UUID': '77de68daec'}, globalenv=globalenv),
linux_cxx("TOOLSET=clang LINK=static,shared Job 4", "clang++", packages="", buildtype="boost", buildscript="drone", image=linuxglobalimage, environment={'TOOLSET': 'clang', 'LINK': 'static,shared', 'TRAVIS_COMPILER': 'clang++', 'DRONE_JOB_UUID': '1b64538924'}, globalenv=globalenv),
linux_cxx("TOOLSET=clang LINK=static,shared Job 5", "clang++", packages="libc++-dev", buildtype="boost", buildscript="drone", image=linuxglobalimage, environment={'TOOLSET': 'clang', 'LINK': 'static,shared', 'TRAVIS_COMPILER': 'clang++-libc++', 'DRONE_JOB_UUID': 'ac3478d69a'}, globalenv=globalenv),
osx_cxx("TOOLSET=clang LINK=static,shared Job 6", "clang++", packages="", buildtype="boost", buildscript="drone", environment={'TOOLSET': 'clang', 'LINK': 'static,shared', 'TRAVIS_COMPILER': 'clang++', 'DRONE_JOB_UUID': 'c1dfd96eea'}, globalenv=globalenv),
osx_cxx("TOOLSET=clang LINK=static,shared Job 7", "clang++", packages="", buildtype="boost", buildscript="drone", xcode_version="10", environment={'TOOLSET': 'clang', 'LINK': 'static,shared', 'TRAVIS_COMPILER': 'clang++', 'DRONE_JOB_UUID': '902ba3cda1'}, globalenv=globalenv),
]
# from https://github.com/boostorg/boost-ci
load("@boost_ci//ci/drone/:functions.star", "linux_cxx","windows_cxx","osx_cxx","freebsd_cxx")
================================================
FILE: .gitattributes
================================================
* 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
================================================
FILE: .github/workflows/posix.yml
================================================
# Copyright 2020-2021 Peter Dimov
# Copyright 2021 Andrey Semashev
# Copyright 2021 Alexander Grund
# Copyright 2022 James E. King III
# Copyright 2023 Matt Borland
#
# 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)
name: POSIX
on:
pull_request:
push:
branches:
- master
- develop
- feature/**
concurrency:
group: ${{ github.workflow }}-${{ github.ref }}
cancel-in-progress: true
env:
LIBRARY: serialization
UBSAN_OPTIONS: print_stacktrace=1
GIT_FETCH_JOBS: 8
NET_RETRY_COUNT: 5
DEFAULT_BUILD_VARIANT: release
jobs:
CI:
defaults:
run:
shell: bash
strategy:
fail-fast: false
matrix:
include:
- toolset: gcc-4.8
cxxstd: "11"
address_model: 64
os: ubuntu-latest
container: ubuntu:16.04
install:
- g++-4.8
sources:
- "ppa:ubuntu-toolchain-r/test"
- toolset: gcc-4.9
cxxstd: "11"
address_model: 64
os: ubuntu-latest
container: ubuntu:16.04
install:
- g++-4.9
sources:
- "ppa:ubuntu-toolchain-r/test"
- toolset: gcc-5
cxxstd: "11,14,1z"
address_model: 64
os: ubuntu-latest
container: ubuntu:16.04
install:
- g++-5-multilib
- toolset: gcc-5
cxxstd: "11-gnu,14-gnu,1z-gnu"
address_model: 64
os: ubuntu-latest
container: ubuntu:16.04
install:
- g++-5-multilib
- toolset: gcc-6
cxxstd: "11,14,1z"
address_model: 64
os: ubuntu-latest
container: ubuntu:18.04
install:
- g++-6-multilib
- toolset: gcc-7
cxxstd: "11,14,17"
address_model: 64
os: ubuntu-latest
container: ubuntu:18.04
install:
- g++-7-multilib
- toolset: gcc-8
cxxstd: "11,14,17,2a"
address_model: 64
os: ubuntu-latest
container: ubuntu:18.04
install:
- g++-8-multilib
- toolset: gcc-9
cxxstd: "11,14,17,2a"
address_model: 64
os: ubuntu-20.04
install:
- g++-9-multilib
- toolset: gcc-9
cxxstd: "11-gnu,14-gnu,17-gnu,2a-gnu"
address_model: 64
os: ubuntu-20.04
install:
- g++-9-multilib
- toolset: gcc-10
cxxstd: "11,14,17,20"
address_model: 64
os: ubuntu-20.04
install:
- g++-10-multilib
- toolset: gcc-11
cxxstd: "11,14,17,20,23"
address_model: 64
os: ubuntu-22.04
install:
- g++-11-multilib
- toolset: gcc-12
cxxstd: "11,14,17,20,23"
address_model: 64
os: ubuntu-22.04
install:
- g++-12-multilib
- toolset: gcc-12
cxxstd: "11-gnu,14-gnu,17-gnu,20-gnu,23-gnu"
address_model: 64
os: ubuntu-22.04
install:
- g++-12-multilib
- name: UBSAN
toolset: gcc-12
cxxstd: "11,20"
address_model: 64
ubsan: 1
os: ubuntu-22.04
install:
- g++-12-multilib
# Linux, clang
- toolset: clang
compiler: clang++-3.7
cxxstd: "11,14"
os: ubuntu-latest
container: ubuntu:16.04
install:
- clang-3.7
- toolset: clang
compiler: clang++-3.8
cxxstd: "11,14"
os: ubuntu-latest
container: ubuntu:16.04
install:
- clang-3.8
- toolset: clang
compiler: clang++-3.9
cxxstd: "11,14"
os: ubuntu-latest
container: ubuntu:18.04
install:
- clang-3.9
- toolset: clang
compiler: clang++-4.0
cxxstd: "11,14"
os: ubuntu-latest
container: ubuntu:18.04
install:
- clang-4.0
- toolset: clang
compiler: clang++-5.0
cxxstd: "11,14,1z"
os: ubuntu-latest
container: ubuntu:18.04
install:
- clang-5.0
- toolset: clang
compiler: clang++-6.0
cxxstd: "11,14,17"
os: ubuntu-latest
container: ubuntu:18.04
install:
- clang-6.0
- toolset: clang
compiler: clang++-7
cxxstd: "11,14,17"
os: ubuntu-latest
container: ubuntu:18.04
install:
- clang-7
# Note: clang-8 does not fully support C++20, so it is not compatible with libstdc++-8 in this mode
- toolset: clang
compiler: clang++-8
cxxstd: "11,14,17,2a"
os: ubuntu-latest
container: ubuntu:18.04
install:
- clang-8
- g++-7
gcc_toolchain: 7
- toolset: clang
compiler: clang++-9
cxxstd: "11,14,17,2a"
os: ubuntu-20.04
install:
- clang-9
- toolset: clang
compiler: clang++-10
cxxstd: "11,14,17,20"
os: ubuntu-20.04
install:
- clang-10
- toolset: clang
compiler: clang++-11
cxxstd: "11,14,17,20"
os: ubuntu-22.04
install:
- clang-11
- toolset: clang
compiler: clang++-12
cxxstd: "11,14,17,20,2b"
os: ubuntu-22.04
install:
- clang-12
- toolset: clang
compiler: clang++-13
cxxstd: "11,14,17,20,2b"
os: ubuntu-22.04
install:
- clang-13
- toolset: clang
compiler: clang++-14
cxxstd: "11,14,17,20,2b"
os: ubuntu-22.04
install:
- clang-14
- toolset: clang
compiler: clang++-14
cxxstd: "11-gnu,14-gnu,17-gnu,20-gnu,2b-gnu"
os: ubuntu-22.04
install:
- clang-14
- toolset: clang
compiler: clang++-15
cxxstd: "11,14,17,20,2b"
os: ubuntu-22.04
install:
- clang-15
sources:
- "deb http://apt.llvm.org/jammy/ llvm-toolchain-jammy-15 main"
source_keys:
- "https://apt.llvm.org/llvm-snapshot.gpg.key"
- toolset: clang
compiler: clang++-15
cxxstd: "11,14,17,20,2b"
os: ubuntu-22.04
install:
- clang-15
- libc++-15-dev
- libc++abi-15-dev
sources:
- "deb http://apt.llvm.org/jammy/ llvm-toolchain-jammy-15 main"
source_keys:
- "https://apt.llvm.org/llvm-snapshot.gpg.key"
cxxflags: -stdlib=libc++
linkflags: -stdlib=libc++
- toolset: clang
cxxstd: "11,14,17,2a"
os: macos-11
- toolset: clang
cxxstd: "11,14,17,20,2b"
os: macos-12
timeout-minutes: 360
runs-on: ${{matrix.os}}
container: ${{matrix.container}}
steps:
- name: Setup environment
run: |
if [ -f "/etc/debian_version" ]
then
echo "DEBIAN_FRONTEND=noninteractive" >> $GITHUB_ENV
export DEBIAN_FRONTEND=noninteractive
fi
if [ -n "${{matrix.container}}" ]
then
echo "GHA_CONTAINER=${{matrix.container}}" >> $GITHUB_ENV
if [ -f "/etc/debian_version" ]
then
apt-get -o Acquire::Retries=$NET_RETRY_COUNT update
if [ "$(apt-cache search "^python-is-python3$" | wc -l)" -ne 0 ]
then
PYTHON_PACKAGE="python-is-python3"
else
PYTHON_PACKAGE="python"
fi
apt-get -o Acquire::Retries=$NET_RETRY_COUNT install -y sudo software-properties-common tzdata wget curl apt-transport-https ca-certificates make build-essential g++ $PYTHON_PACKAGE python3 perl git cmake
fi
fi
git config --global pack.threads 0
- uses: actions/checkout@v3
- name: Install packages
if: matrix.install
run: |
declare -a SOURCE_KEYS SOURCES
if [ -n "${{join(matrix.source_keys, ' ')}}" ]
then
SOURCE_KEYS=("${{join(matrix.source_keys, '" "')}}")
fi
if [ -n "${{join(matrix.sources, ' ')}}" ]
then
SOURCES=("${{join(matrix.sources, '" "')}}")
fi
for key in "${SOURCE_KEYS[@]}"
do
for i in {1..$NET_RETRY_COUNT}
do
echo "Adding key: $key"
wget -O - "$key" | sudo apt-key add - && break || sleep 2
done
done
if [ ${#SOURCES[@]} -gt 0 ]
then
APT_ADD_REPO_COMMON_ARGS=("-y")
APT_ADD_REPO_SUPPORTED_ARGS="$(apt-add-repository --help | perl -ne 'if (/^\s*-n/) { print "n"; } elsif (/^\s*-P/) { print "P"; } elsif (/^\s*-S/) { print "S"; } elsif (/^\s*-U/) { print "U"; }')"
if [ -n "$APT_ADD_REPO_SUPPORTED_ARGS" -a -z "${APT_ADD_REPO_SUPPORTED_ARGS##*n*}" ]
then
APT_ADD_REPO_COMMON_ARGS+=("-n")
fi
APT_ADD_REPO_HAS_SOURCE_ARGS="$([ -n "$APT_ADD_REPO_SUPPORTED_ARGS" -a -z "${APT_ADD_REPO_SUPPORTED_ARGS##*P*}" -a -z "${APT_ADD_REPO_SUPPORTED_ARGS##*S*}" -a -z "${APT_ADD_REPO_SUPPORTED_ARGS##*U*}" ] && echo 1 || echo 0)"
for source in "${SOURCES[@]}"
do
for i in {1..$NET_RETRY_COUNT}
do
APT_ADD_REPO_ARGS=("${APT_ADD_REPO_COMMON_ARGS[@]}")
if [ $APT_ADD_REPO_HAS_SOURCE_ARGS -ne 0 ]
then
case "$source" in
"ppa:"*)
APT_ADD_REPO_ARGS+=("-P")
;;
"deb "*)
APT_ADD_REPO_ARGS+=("-S")
;;
*)
APT_ADD_REPO_ARGS+=("-U")
;;
esac
fi
APT_ADD_REPO_ARGS+=("$source")
echo "apt-add-repository ${APT_ADD_REPO_ARGS[@]}"
sudo -E apt-add-repository "${APT_ADD_REPO_ARGS[@]}" && break || sleep 2
done
done
fi
sudo apt-get -o Acquire::Retries=$NET_RETRY_COUNT update
sudo apt-get -o Acquire::Retries=$NET_RETRY_COUNT install -y ${{join(matrix.install, ' ')}}
- name: Setup GCC Toolchain
if: matrix.gcc_toolchain
run: |
GCC_TOOLCHAIN_ROOT="$HOME/gcc-toolchain"
echo "GCC_TOOLCHAIN_ROOT=\"$GCC_TOOLCHAIN_ROOT\"" >> $GITHUB_ENV
MULTIARCH_TRIPLET="$(dpkg-architecture -qDEB_HOST_MULTIARCH)"
mkdir -p "$GCC_TOOLCHAIN_ROOT"
ln -s /usr/include "$GCC_TOOLCHAIN_ROOT/include"
ln -s /usr/bin "$GCC_TOOLCHAIN_ROOT/bin"
mkdir -p "$GCC_TOOLCHAIN_ROOT/lib/gcc/$MULTIARCH_TRIPLET"
ln -s "/usr/lib/gcc/$MULTIARCH_TRIPLET/${{matrix.gcc_toolchain}}" "$GCC_TOOLCHAIN_ROOT/lib/gcc/$MULTIARCH_TRIPLET/${{matrix.gcc_toolchain}}"
- name: Setup Boost
run: |
echo GITHUB_REPOSITORY: $GITHUB_REPOSITORY
LIBRARY=${GITHUB_REPOSITORY#*/}
echo LIBRARY: $LIBRARY
echo "LIBRARY=$LIBRARY" >> $GITHUB_ENV
echo GITHUB_BASE_REF: $GITHUB_BASE_REF
echo GITHUB_REF: $GITHUB_REF
REF=${GITHUB_BASE_REF:-$GITHUB_REF}
REF=${REF#refs/heads/}
echo REF: $REF
BOOST_BRANCH=develop && [ "$REF" = "master" ] && BOOST_BRANCH=master || true
echo BOOST_BRANCH: $BOOST_BRANCH
BUILD_JOBS=$((nproc || sysctl -n hw.ncpu) 2> /dev/null)
echo "BUILD_JOBS=$BUILD_JOBS" >> $GITHUB_ENV
echo "CMAKE_BUILD_PARALLEL_LEVEL=$BUILD_JOBS" >> $GITHUB_ENV
DEPINST_ARGS=()
GIT_VERSION="$(git --version | sed -e 's/git version //')"
GIT_HAS_JOBS=1
if [ -f "/etc/debian_version" ]
then
if $(dpkg --compare-versions "$GIT_VERSION" lt 2.8.0)
then
GIT_HAS_JOBS=0
fi
else
declare -a GIT_VER=(${GIT_VERSION//./ })
declare -a GIT_MIN_VER=(2 8 0)
for ((i=0; i<${#GIT_VER[@]}; i++))
do
if [ -z "${GIT_MIN_VER[i]}" ]
then
GIT_MIN_VER[i]=0
fi
if [ "${GIT_VER[i]}" -lt "${GIT_MIN_VER[i]}" ]
then
GIT_HAS_JOBS=0
break
fi
done
fi
if [ "$GIT_HAS_JOBS" -ne 0 ]
then
DEPINST_ARGS+=("--git_args" "--jobs $GIT_FETCH_JOBS")
fi
cd ..
git clone -b "$BOOST_BRANCH" --depth 1 "https://github.com/boostorg/boost.git" "boost-root"
cd boost-root
mkdir -p libs/$LIBRARY
cp -r $GITHUB_WORKSPACE/* libs/$LIBRARY
git submodule update --init tools/boostdep
DEPINST_ARGS+=("$LIBRARY")
python tools/boostdep/depinst/depinst.py "${DEPINST_ARGS[@]}"
if [ -z "${{matrix.cmake_tests}}" ]
then
./bootstrap.sh
./b2 headers
if [ -n "${{matrix.compiler}}" -o -n "$GCC_TOOLCHAIN_ROOT" ]
then
echo -n "using ${{matrix.toolset}} : : ${{matrix.compiler}}" > ~/user-config.jam
if [ -n "$GCC_TOOLCHAIN_ROOT" ]
then
echo -n " : <compileflags>\"--gcc-toolchain=$GCC_TOOLCHAIN_ROOT\" <linkflags>\"--gcc-toolchain=$GCC_TOOLCHAIN_ROOT\"" >> ~/user-config.jam
fi
echo " ;" >> ~/user-config.jam
fi
fi
- name: Run tests
if: matrix.cmake_tests == ''
run: |
cd ../boost-root
B2_ARGS=("-j" "$BUILD_JOBS" "toolset=${{matrix.toolset}}" "cxxstd=${{matrix.cxxstd}}" "link=static,shared")
if [ -n "${{matrix.build_variant}}" ]
then
B2_ARGS+=("variant=${{matrix.build_variant}}")
else
B2_ARGS+=("variant=$DEFAULT_BUILD_VARIANT")
fi
if [ -n "${{matrix.threading}}" ]
then
B2_ARGS+=("threading=${{matrix.threading}}")
fi
if [ -n "${{matrix.ubsan}}" ]
then
export UBSAN_OPTIONS="print_stacktrace=1"
B2_ARGS+=("cxxflags=-fsanitize=undefined -fno-sanitize-recover=undefined" "linkflags=-fsanitize=undefined -fuse-ld=gold" "define=UBSAN=1" "debug-symbols=on" "visibility=global")
fi
if [ -n "${{matrix.cxxflags}}" ]
then
B2_ARGS+=("cxxflags=${{matrix.cxxflags}}")
fi
if [ -n "${{matrix.linkflags}}" ]
then
B2_ARGS+=("linkflags=${{matrix.linkflags}}")
fi
if [ -n "${{matrix.address_model}}" ]
then
B2_ARGS+=("address-model=${{matrix.address_model}}")
fi
B2_ARGS+=("libs/$LIBRARY/test")
./b2 "${B2_ARGS[@]}"
================================================
FILE: .github/workflows/windows.yml
================================================
name: Windows
on:
pull_request:
push:
branches:
- master
- develop
- feature/**
concurrency:
group: ${{ github.workflow }}-${{ github.ref }}
cancel-in-progress: true
env:
LIBRARY: serialization
jobs:
CI:
strategy:
fail-fast: false
matrix:
include:
- toolset: msvc-14.0
cxxstd: "11,14"
addrmd: 32,64
os: windows-2019
- toolset: msvc-14.2
cxxstd: "14,17,latest"
addrmd: 32,64
os: windows-2019
- toolset: msvc-14.3
cxxstd: "17,20,latest"
addrmd: 32,64
os: windows-2022
- toolset: clang-win
cxxstd: "14,17,latest"
addrmd: 32,64
os: windows-2022
- toolset: gcc
cxxstd: "11,14,17,2a"
addrmd: 64
os: windows-2019
runs-on: ${{matrix.os}}
steps:
- uses: actions/checkout@v3
- name: Setup Boost
shell: cmd
run: |
echo GITHUB_REPOSITORY: %GITHUB_REPOSITORY%
for /f %%i in ("%GITHUB_REPOSITORY%") do set LIBRARY=%%~nxi
echo LIBRARY: %LIBRARY%
echo LIBRARY=%LIBRARY%>>%GITHUB_ENV%
echo GITHUB_BASE_REF: %GITHUB_BASE_REF%
echo GITHUB_REF: %GITHUB_REF%
if "%GITHUB_BASE_REF%" == "" set GITHUB_BASE_REF=%GITHUB_REF%
set BOOST_BRANCH=develop
for /f %%i in ("%GITHUB_BASE_REF%") do if "%%~nxi" == "master" set BOOST_BRANCH=master
echo BOOST_BRANCH: %BOOST_BRANCH%
cd ..
git clone -b %BOOST_BRANCH% --depth 1 https://github.com/boostorg/boost.git boost-root
cd boost-root
xcopy /s /e /q %GITHUB_WORKSPACE% libs\%LIBRARY%\
git submodule update --init tools/boostdep
python tools/boostdep/depinst/depinst.py --git_args "--jobs 3" %LIBRARY%
cmd /c bootstrap
b2 -d0 headers
- name: Run tests
shell: cmd
run: |
cd ../boost-root
b2 -j3 libs/%LIBRARY%/test toolset=${{matrix.toolset}} cxxstd=${{matrix.cxxstd}} address-model=${{matrix.addrmd}} variant=release
================================================
FILE: .gitignore
================================================
================================================
FILE: .travis.yml
================================================
# Copyright 2016, 2017 Peter Dimov
# Distributed under the Boost Software License, Version 1.0.
# (See accompanying file LICENSE_1_0.txt or copy at http://boost.org/LICENSE_1_0.txt)
language: cpp
sudo: false
cache:
ccache: true
branches:
only:
- master
- develop
- /feature\/.*/
env:
matrix:
- BOGUS_JOB=true
matrix:
exclude:
- env: BOGUS_JOB=true
include:
- os: linux
compiler: g++
env: TOOLSET=gcc LINK=static,shared
- os: linux
compiler: g++-5
env: TOOLSET=gcc LINK=static,shared
addons:
apt:
packages:
- g++-5
sources:
- ubuntu-toolchain-r-test
- os: linux
compiler: g++-6
env: TOOLSET=gcc LINK=static,shared
addons:
apt:
packages:
- g++-6
sources:
- ubuntu-toolchain-r-test
- os: linux
compiler: g++-7
env: TOOLSET=gcc LINK=static,shared
addons:
apt:
packages:
- g++-7
sources:
- ubuntu-toolchain-r-test
- os: linux
compiler: clang++
env: TOOLSET=clang LINK=static,shared
- os: linux
compiler: clang++-libc++
env: TOOLSET=clang LINK=static,shared
addons:
apt:
packages:
- libc++-dev
- os: osx
compiler: clang++
env: TOOLSET=clang LINK=static,shared
- os: osx
osx_image: xcode10
compiler: clang++
env: TOOLSET=clang LINK=static,shared
install:
- BOOST_BRANCH=develop && [ "$TRAVIS_BRANCH" == "master" ] && BOOST_BRANCH=master || true
- cd ..
- git clone -b $BOOST_BRANCH https://github.com/boostorg/boost.git boost-root
- cd boost-root
- git submodule update --init tools/build
- git submodule update --init libs/config
- git submodule update --init tools/boostdep
- cp -r $TRAVIS_BUILD_DIR/* libs/serialization
- python tools/boostdep/depinst/depinst.py serialization
- ./bootstrap.sh
- ./b2 headers
script:
- |-
echo "using $TOOLSET : : $TRAVIS_COMPILER ;" > ~/user-config.jam
- ./b2 -j 3 libs/serialization/test toolset=$TOOLSET link=${LINK:-shared}
notifications:
email:
on_success: always
================================================
FILE: CMake/CMakeLists.txt
================================================
# CMake build control file for Serialization Library tests
cmake_minimum_required(VERSION 3.5)
if (POLICY CMP0054)
cmake_policy (SET CMP0054 NEW)
endif (POLICY CMP0054)
if (POLICY CMP0063)
cmake_policy (SET CMP0063 NEW)
endif (POLICY CMP0063)
project("serialization")
#
# Compiler settings
#
message(STATUS "C++ compiler is ${CMAKE_CXX_COMPILER_ID}" )
add_definitions(${Boost_LIB_DIAGNOSTIC_DEFINITIONS})
message(STATUS "C compiler is ${CMAKE_C_COMPILER_ID}" )
if( CMAKE_CXX_COMPILER_ID STREQUAL "GNU" )
add_definitions( -ftemplate-depth=255 )
# we use gcc to test for C++03 compatibility
set(COMPILER_SUPPORTS_CXX11 FALSE)
elseif( CMAKE_CXX_COMPILER_ID STREQUAL "MSVC" )
add_definitions( /wd4996 )
set(COMPILER_SUPPORTS_CXX11 TRUE)
elseif( CMAKE_CXX_COMPILER_ID STREQUAL "AppleClang" )
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -ftemplate-depth=300")
set(CMAKE_CXX_FLAGS_DEBUG "-g -O0" )
set(CMAKE_CXX_FLAGS_RELWITHDEBINFO "-g -O3" )
set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -stdlib=libc++ -dead_strip")
set(COMPILER_SUPPORTS_CXX11 TRUE)
endif()
add_definitions( -std=c++11 )
#set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++03")
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++11")
#set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++17")
#set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++11")
#
# Locate Project Prerequisites
#
# Boost
#
# Project settings
#
option(BUILD_SHARED_LIBS "Build Shared Libraries" true)
find_package(Boost 1.82 REQUIRED COMPONENTS system filesystem)
if(NOT Boost_FOUND)
message("Boost NOT Found!")
else()
message(STATUS "Boost Found!")
endif()
set(CMAKE_CXX_VISIBILITY_PRESET hidden)
set(VISIBILITY_INLINES_HIDDEN YES)
# enable usage of CHECK_INCLUDE_FILE_CXX
include(CheckIncludeFileCXX)
# list of archive names for which tests should be generated
set(archive_list text_archive text_warchive binary_archive xml_archive xml_warchive)
# set(archive_list xml_warchive)
# list of tests generated by each function call
set(test_list)
###########################
# library builds
add_library(serialization
../src/archive_exception.cpp
../src/basic_archive.cpp
../src/basic_iarchive.cpp
../src/basic_iserializer.cpp
../src/basic_oarchive.cpp
../src/basic_oserializer.cpp
../src/basic_pointer_iserializer.cpp
../src/basic_pointer_oserializer.cpp
../src/basic_serializer_map.cpp
../src/basic_text_iprimitive.cpp
../src/basic_text_oprimitive.cpp
../src/basic_xml_archive.cpp
../src/binary_iarchive.cpp
../src/binary_oarchive.cpp
../src/extended_type_info.cpp
../src/extended_type_info_typeid.cpp
../src/extended_type_info_no_rtti.cpp
../src/stl_port.cpp
../src/text_iarchive.cpp
../src/text_oarchive.cpp
../src/polymorphic_iarchive.cpp
../src/polymorphic_oarchive.cpp
../src/polymorphic_text_iarchive.cpp
../src/polymorphic_text_oarchive.cpp
../src/polymorphic_binary_iarchive.cpp
../src/polymorphic_binary_oarchive.cpp
../src/polymorphic_xml_iarchive.cpp
../src/polymorphic_xml_oarchive.cpp
../src/void_cast.cpp
../src/xml_grammar.cpp
../src/xml_iarchive.cpp
../src/xml_oarchive.cpp
../src/xml_archive_exception.cpp
../src/codecvt_null.cpp
../src/utf8_codecvt_facet.cpp
../src/basic_xml_grammar.ipp # doesn't show up in "Source Files" in Xcode"'
)
target_include_directories(serialization PUBLIC ${Boost_INCLUDE_DIR})
add_library(wserialization
../src/basic_text_wiprimitive.cpp
../src/basic_text_woprimitive.cpp
../src/text_wiarchive.cpp
../src/text_woarchive.cpp
../src/polymorphic_text_wiarchive.cpp
../src/polymorphic_text_woarchive.cpp
../src/xml_wiarchive.cpp
../src/xml_woarchive.cpp
../src/polymorphic_xml_wiarchive.cpp
../src/polymorphic_xml_woarchive.cpp
../src/xml_wgrammar.cpp
../src/basic_xml_grammar.ipp # doesn't show up in "Source Files" in Xcode"'
)
target_include_directories(wserialization PUBLIC ${Boost_INCLUDE_DIR})
target_link_libraries(wserialization PUBLIC serialization)
# end library build
###########################
###########################
# test targets
function( serialization_test test_name)
set(arglist)
foreach(a IN ITEMS ${ARGN} )
set(arglist ${arglist} ../test/${a}.cpp)
endforeach()
message(STATUS ${test_name})
add_executable( ${test_name} ../test/${test_name}.cpp ${arglist} )
target_include_directories(${test_name} PUBLIC ${Boost_INCLUDE_DIR})
target_link_libraries(${test_name} serialization wserialization Boost::filesystem)
add_test( ${test_name} ${test_name} )
endfunction(serialization_test)
function(archive_test test_name)
set(test_listx)
set(arglist)
foreach(a IN ITEMS ${ARGN} )
set(arglist ${arglist} ../test/${a}.cpp)
endforeach()
foreach(
archive-name
IN ITEMS ${archive_list}
)
set(amended_test_name ${test_name}_${archive-name})
add_executable(${amended_test_name} ../test/${test_name}.cpp ${arglist})
set_property(
TARGET ${amended_test_name}
PROPERTY COMPILE_DEFINITIONS BOOST_ARCHIVE_TEST=${archive-name}.hpp
)
target_include_directories(${amended_test_name} PUBLIC ${Boost_INCLUDE_DIR})
target_link_libraries(${amended_test_name} serialization wserialization Boost::filesystem)
add_test(${amended_test_name} ${amended_test_name})
set(test_listx ${test_listx} ${amended_test_name})
endforeach()
set(test_list ${test_listx} PARENT_SCOPE)
endfunction(archive_test)
function(polymorphic_archive_test test_name)
set(test_listx)
set(arglist)
foreach(a IN ITEMS ${ARGN} )
set(arglist ${arglist} ../test/${a}.cpp)
endforeach()
foreach(
archive-name
IN ITEMS ${archive_list}
)
set(amended_archive_name polymorphic_${archive-name})
set(amended_test_name ${test_name}_${amended_archive_name})
add_executable(${amended_test_name} ../test/${test_name}.cpp ${arglist})
set_property(
TARGET ${amended_test_name}
PROPERTY COMPILE_DEFINITIONS BOOST_ARCHIVE_TEST=${amended_archive_name}.hpp
)
message(STATUS ${amended_test_name} " " ${arglist} " " ${amended_archive_name})
target_include_directories(${amended_test_name} PUBLIC ${Boost_INCLUDE_DIR})
target_link_libraries(${amended_test_name} serialization wserialization Boost::filesystem)
add_test(${amended_test_name} ${amended_test_name})
set(test_listx ${test_listx} ${amended_test_name})
endforeach()
set(test_list ${test_listx} PARENT_SCOPE)
endfunction(polymorphic_archive_test)
enable_testing()
message(STATUS dll_a)
add_library(dll_a SHARED ../test/dll_a.cpp)
target_link_libraries(dll_a serialization)
message(STATUS dll_polymorphic_base)
add_library(dll_polymorphic_base SHARED ../test/dll_polymorphic_base.cpp)
target_link_libraries(dll_polymorphic_base serialization)
message(STATUS dll_polymorphic_derived2)
add_library(dll_polymorphic_derived2 SHARED ../test/dll_polymorphic_derived2.cpp)
target_link_libraries(dll_polymorphic_derived2 dll_polymorphic_base serialization)
# compile test_dll_plugin.cpp
# Running the following test requires that the test know the directory
# in which the dll is stored. I don't know how to extract this from bjam
# serialization(test_dll_plugin : : dll_polymorphic_derived2_lib)
if(BUILD_SHARED_LIBS)
# this test can only be made to work if we're linking with shared
# libraries. Basically the build systems like to have all shared
# or all static so if we're building with static C++ libraries
# then linking with a shared one - we need multiple C++ libraries
# and things get complex. So just run this test when we're
# building with shared libraries (dll in windows speak)
serialization_test(test_dll_simple)
target_link_libraries(test_dll_simple dll_a serialization)
endif()
serialization_test(test_private_ctor)
serialization_test(test_reset_object_address A)
serialization_test(test_void_cast)
serialization_test(test_mult_archive_types)
serialization_test(test_iterators)
serialization_test(test_iterators_base64)
serialization_test(test_inclusion)
serialization_test(test_inclusion2)
serialization_test(test_smart_cast)
serialization_test(test_codecvt_null)
serialization_test(test_strong_typedef)
serialization_test(test_singleton)
serialization_test(test_singleton_inherited)
serialization_test(test_singleton_plain)
archive_test(test_native_array A)
archive_test(test_boost_array A)
if(COMPILER_SUPPORTS_CXX11)
archive_test(test_array A)
endif()
archive_test(test_binary)
archive_test(test_bitset)
archive_test(test_class_info_save)
archive_test(test_class_info_load)
archive_test(test_complex)
archive_test(test_contained_class A)
archive_test(test_cyclic_ptrs A)
archive_test(test_delete_pointer)
archive_test(test_deque A)
archive_test(test_derived)
archive_test(test_derived_class A)
archive_test(test_diamond)
archive_test(test_diamond_complex)
CHECK_INCLUDE_FILE_CXX(forward_list FORWARD_LIST_FOUND)
if(FORWARD_LIST_FOUND)
message(STATUS "forward_list header found")
archive_test(test_forward_list A)
archive_test(test_forward_list_ptrs A)
else()
message(STATUS "forward_list header NOT found")
endif()
archive_test(test_helper_support)
archive_test(test_interrupts)
archive_test(test_list A)
archive_test(test_list_ptrs A)
archive_test(test_map A)
CHECK_INCLUDE_FILE_CXX(hash_map HASH_MAP_FOUND)
if(HASH_MAP_FOUND)
archive_test(test_map_hashed A)
endif()
archive_test(test_mi)
archive_test(test_multiple_ptrs A)
archive_test(test_multiple_inheritance)
archive_test(test_new_operator A)
archive_test(test_non_intrusive)
archive_test(test_non_default_ctor)
archive_test(test_non_default_ctor2)
archive_test(test_null_ptr)
archive_test(test_nvp A)
archive_test(test_object)
archive_test(test_optional)
archive_test(test_primitive)
archive_test(test_priority_queue A)
archive_test(test_private_base)
archive_test(test_private_base2)
archive_test(test_queue A)
archive_test(test_recursion A)
archive_test(test_registered)
archive_test(test_set A)
CHECK_INCLUDE_FILE_CXX(hash_set HASH_SET_FOUND)
if(HASH_SET_FOUND)
archive_test(test_set_hashed A)
endif()
archive_test(test_shared_ptr)
archive_test(test_shared_ptr_multi_base)
archive_test(test_shared_ptr_132)
archive_test(test_simple_class A)
archive_test(test_simple_class_ptr A)
CHECK_INCLUDE_FILE_CXX(slist SLIST_FOUND)
if(SLIST_FOUND)
message(STATUS "slist header found")
archive_test(test_slist A)
archive_test(test_slist_ptr A)
endif()
archive_test(test_stack A)
archive_test(test_split)
archive_test(test_tracking)
archive_test(test_unregistered)
archive_test(test_unique_ptr)
archive_test(test_valarray)
archive_test(test_variant A)
archive_test(test_vector A)
if(BUILD_SHARED_LIBS)
polymorphic_archive_test(test_dll_exported polymorphic_derived1)
foreach(test_name IN ITEMS ${test_list} )
target_link_libraries(${test_name} dll_polymorphic_derived2 dll_polymorphic_base serialization wserialization)
endforeach()
endif()
polymorphic_archive_test(test_no_rtti polymorphic_base polymorphic_derived1 polymorphic_derived2)
polymorphic_archive_test(test_exported polymorphic_base polymorphic_derived1 polymorphic_derived2)
polymorphic_archive_test(test_polymorphic test_polymorphic_A A)
polymorphic_archive_test(test_polymorphic2 test_polymorphic2imp)
polymorphic_archive_test(test_p_helper)
# end test targets
####################
####################
# add headers in IDE
# for serialization
file(GLOB x
RELATIVE "${CMAKE_CURRENT_SOURCE_DIR}"
"${CMAKE_CURRENT_SOURCE_DIR}/../include/boost/archive/*.hpp"
)
add_custom_target(archive SOURCES ${x})
set_property(TARGET archive PROPERTY FOLDER "serialization")
file(GLOB x
RELATIVE "${CMAKE_CURRENT_SOURCE_DIR}"
"${CMAKE_CURRENT_SOURCE_DIR}/../include/boost/archive/detail/*.hpp"
)
add_custom_target(archive-detail SOURCES ${x})
set_property(TARGET archive-detail PROPERTY FOLDER "serialization")
file(GLOB x
RELATIVE "${CMAKE_CURRENT_SOURCE_DIR}"
"${CMAKE_CURRENT_SOURCE_DIR}/../include/boost/archive/impl/*.ipp"
)
add_custom_target(archive-impl SOURCES ${x})
set_property(TARGET archive-impl PROPERTY FOLDER "serialization")
file(GLOB x
RELATIVE "${CMAKE_CURRENT_SOURCE_DIR}"
"${CMAKE_CURRENT_SOURCE_DIR}/../include/boost/archive/iterators/*.hpp"
)
add_custom_target(archive-iterators SOURCES ${x})
set_property(TARGET archive-iterators PROPERTY FOLDER "serialization")
file(GLOB x
RELATIVE "${CMAKE_CURRENT_SOURCE_DIR}"
"${CMAKE_CURRENT_SOURCE_DIR}/../include/boost/serialization/*.hpp"
)
add_custom_target(serialization-headers SOURCES ${x})
set_property(TARGET serialization-headers PROPERTY FOLDER "serialization")
file(GLOB x
RELATIVE "${CMAKE_CURRENT_SOURCE_DIR}"
"${CMAKE_CURRENT_SOURCE_DIR}/../include/boost/serialization/detail/*.hpp"
)
add_custom_target(serialization-detail SOURCES ${x})
set_property(TARGET serialization-detail PROPERTY FOLDER "serialization")
# for wserialization
file(GLOB x
RELATIVE "${CMAKE_CURRENT_SOURCE_DIR}"
"${CMAKE_CURRENT_SOURCE_DIR}/../include/boost/archive/*_w*.hpp"
)
add_custom_target(wserialization_headers SOURCES ${x})
set_property(TARGET wserialization_headers PROPERTY FOLDER "wserialization")
# end headers in IDE
####################
#####################
# add test project to run misc tests
add_executable( test_z ../test/test_z.cpp)
target_link_libraries(test_z serialization wserialization ${Boost_LIBRARIES})
# end test project
#####################
================================================
FILE: CMakeLists.txt
================================================
# Copyright 2020, 2021 Peter Dimov
# Distributed under the Boost Software License, Version 1.0.
# https://www.boost.org/LICENSE_1_0.txt
cmake_minimum_required(VERSION 3.5...3.16)
project(boost_serialization VERSION "${BOOST_SUPERPROJECT_VERSION}" LANGUAGES CXX)
add_library(boost_serialization
src/archive_exception.cpp
src/basic_archive.cpp
src/basic_iarchive.cpp
src/basic_iserializer.cpp
src/basic_oarchive.cpp
src/basic_oserializer.cpp
src/basic_pointer_iserializer.cpp
src/basic_pointer_oserializer.cpp
src/basic_serializer_map.cpp
src/basic_text_iprimitive.cpp
src/basic_text_oprimitive.cpp
src/basic_xml_archive.cpp
src/binary_iarchive.cpp
src/binary_oarchive.cpp
src/codecvt_null.cpp
src/extended_type_info.cpp
src/extended_type_info_no_rtti.cpp
src/extended_type_info_typeid.cpp
src/polymorphic_binary_iarchive.cpp
src/polymorphic_binary_oarchive.cpp
src/polymorphic_iarchive.cpp
src/polymorphic_oarchive.cpp
src/polymorphic_text_iarchive.cpp
src/polymorphic_text_oarchive.cpp
src/polymorphic_xml_iarchive.cpp
src/polymorphic_xml_oarchive.cpp
src/stl_port.cpp
src/text_iarchive.cpp
src/text_oarchive.cpp
src/utf8_codecvt_facet.cpp
src/void_cast.cpp
src/xml_archive_exception.cpp
src/xml_grammar.cpp
src/xml_iarchive.cpp
src/xml_oarchive.cpp
)
add_library(boost_wserialization
src/basic_text_wiprimitive.cpp
src/basic_text_woprimitive.cpp
src/binary_wiarchive.cpp
src/binary_woarchive.cpp
src/polymorphic_text_wiarchive.cpp
src/polymorphic_text_woarchive.cpp
src/polymorphic_xml_wiarchive.cpp
src/polymorphic_xml_woarchive.cpp
src/text_wiarchive.cpp
src/text_woarchive.cpp
src/xml_wgrammar.cpp
src/xml_wiarchive.cpp
src/xml_woarchive.cpp
)
add_library(Boost::serialization ALIAS boost_serialization)
add_library(Boost::wserialization ALIAS boost_wserialization)
target_include_directories(boost_serialization PUBLIC include)
target_include_directories(boost_wserialization PUBLIC include)
target_link_libraries(boost_serialization
PUBLIC
Boost::array
Boost::assert
Boost::config
Boost::core
Boost::detail
Boost::integer
Boost::io
Boost::iterator
Boost::move
Boost::mpl
Boost::optional
Boost::predef
Boost::preprocessor
Boost::smart_ptr
Boost::spirit
Boost::type_traits
Boost::unordered
Boost::utility
Boost::variant
PRIVATE
Boost::function
)
target_link_libraries(boost_wserialization PUBLIC boost_serialization)
target_compile_definitions(boost_serialization
PUBLIC BOOST_SERIALIZATION_NO_LIB
# Source files already define BOOST_SERIALIZATION_SOURCE
# PRIVATE BOOST_SERIALIZATION_SOURCE
)
target_compile_definitions(boost_wserialization
PUBLIC BOOST_SERIALIZATION_NO_LIB
# Source files already define BOOST_SERIALIZATION_SOURCE
# PRIVATE BOOST_SERIALIZATION_SOURCE
)
if(BUILD_SHARED_LIBS)
target_compile_definitions(boost_serialization PUBLIC BOOST_SERIALIZATION_DYN_LINK)
target_compile_definitions(boost_wserialization PUBLIC BOOST_SERIALIZATION_DYN_LINK)
else()
target_compile_definitions(boost_serialization PUBLIC BOOST_SERIALIZATION_STATIC_LINK)
target_compile_definitions(boost_wserialization PUBLIC BOOST_SERIALIZATION_STATIC_LINK)
endif()
if(BOOST_SUPERPROJECT_VERSION AND NOT CMAKE_VERSION VERSION_LESS 3.13)
boost_install(TARGETS boost_serialization boost_wserialization VERSION ${BOOST_SUPERPROJECT_VERSION} HEADER_DIRECTORY include)
endif()
if(BUILD_TESTING AND EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/test/CMakeLists.txt")
add_subdirectory(test)
endif()
================================================
FILE: appveyor.yml
================================================
# Copyright 2016 Peter Dimov
# Copyright 2016 Robert Ramey
# Distributed under the Boost Software License, Version 1.0.
# (See accompanying file LICENSE_1_0.txt or copy at http://boost.org/LICENSE_1_0.txt)
version: 1.0.{build}-{branch}
shallow_clone: true
branches:
only:
- develop
# - master
environment:
matrix:
- BUILD_TOOLSET: gcc
BUILD_LINK: static
- BUILD_TOOLSET: gcc
BUILD_LINK: shared
- BUILD_TOOLSET: msvc-14.0
BUILD_LINK: static
- BUILD_TOOLSET: msvc-14.0
BUILD_LINK: shared
install:
- cd ..
- git clone -b %APPVEYOR_REPO_BRANCH% https://github.com/boostorg/boost.git boost-root
- cd boost-root
- git submodule init libs/align
- git submodule init libs/array
- git submodule init libs/assert
- git submodule init libs/bind
- git submodule init libs/compatibility
- git submodule init libs/concept_check
- git submodule init libs/config
- git submodule init libs/container
- git submodule init libs/container_hash
- git submodule init libs/core
- git submodule init libs/detail
- git submodule init libs/filesystem
- git submodule init libs/function
- git submodule init libs/functional
- git submodule init libs/integer
- git submodule init libs/intrusive
- git submodule init libs/io
- git submodule init libs/iterator
- git submodule init libs/lexical_cast
- git submodule init libs/math
- git submodule init libs/move
- git submodule init libs/mpl
- git submodule init libs/numeric/conversion
- git submodule init libs/optional
- git submodule init libs/predef
- git submodule init libs/preprocessor
- git submodule init libs/range
- git submodule init libs/smart_ptr
- git submodule init libs/spirit
- git submodule init libs/system
- git submodule init libs/throw_exception
- git submodule init libs/tuple
- git submodule init libs/type_index
- git submodule init libs/type_traits
- git submodule init libs/unordered
- git submodule init libs/utility
- git submodule init libs/variant
- git submodule init libs/winapi
- git submodule init tools/boost_install
- git submodule init libs/headers
- git submodule init tools/build
- git submodule update
- xcopy /s /e /q %APPVEYOR_BUILD_FOLDER% libs\serialization
- set PATH=C:\mingw-w64\i686-6.3.0-posix-dwarf-rt_v5-rev1\mingw32\bin;%CD%;%PATH%
- bootstrap gcc
- b2 headers
build: off
test_script:
- cd libs/serialization/test
- b2 -j2 toolset=%BUILD_TOOLSET% link=%BUILD_LINK%
================================================
FILE: build/Jamfile.v2
================================================
# 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.
require-b2 5.0.1 ;
import-search /boost/config/checks ;
import config : requires ;
constant boost_dependencies_private :
/boost/function//boost_function
;
project
: source-location ../src
: common-requirements <library>$(boost_dependencies)
: requirements
<conditional>@include-spirit
<library>$(boost_dependencies_private)
: usage-requirements
<define>BOOST_SERIALIZATION_NO_LIB=1
;
SPIRIT_ROOT = [ modules.peek : SPIRIT_ROOT ] ;
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 =
archive_exception
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
polymorphic_text_iarchive
polymorphic_text_oarchive
polymorphic_binary_iarchive
polymorphic_binary_oarchive
polymorphic_xml_iarchive
polymorphic_xml_oarchive
void_cast
xml_grammar
xml_iarchive
xml_archive_exception
codecvt_null
;
SOURCES_HAS_STD_WSTREAMBUF =
xml_oarchive
utf8_codecvt_facet
;
WSOURCES =
basic_text_wiprimitive
basic_text_woprimitive
text_wiarchive
text_woarchive
polymorphic_text_wiarchive
polymorphic_text_woarchive
xml_wgrammar
xml_wiarchive
xml_woarchive
polymorphic_xml_wiarchive
polymorphic_xml_woarchive
codecvt_null
;
lib boost_serialization
: ## sources ##
$(SOURCES).cpp
: ## requirements ##
[ check-target-builds /boost/config/checks//std_wstreambuf : <source>../src/$(SOURCES_HAS_STD_WSTREAMBUF).cpp ]
<toolset>msvc:<cxxflags>/Gy
<toolset>msvc:<define>_SCL_SECURE_NO_WARNINGS
<toolset>msvc:<define>_CRT_SECURE_NO_WARNINGS
<link>shared:<define>BOOST_SERIALIZATION_DYN_LINK=1
;
lib boost_wserialization
: $(WSOURCES).cpp boost_serialization
:
[ requires std_wstreambuf ]
<toolset>msvc:<cxxflags>/Gy
<toolset>msvc:<define>_SCL_SECURE_NO_WARNINGS
<toolset>msvc:<define>_CRT_SECURE_NO_WARNINGS
# note: both serialization and wserialization are conditioned on the this
# switch - don't change it to BOOST_WSERIALIZATION_DYN_LINK
<link>shared:<define>BOOST_SERIALIZATION_DYN_LINK=1
;
================================================
FILE: build.jam
================================================
# Copyright René Ferdinand Rivera Morell 2023-2024
# Distributed under the Boost Software License, Version 1.0.
# (See accompanying file LICENSE_1_0.txt or copy at
# http://www.boost.org/LICENSE_1_0.txt)
require-b2 5.2 ;
constant boost_dependencies :
/boost/array//boost_array
/boost/assert//boost_assert
/boost/config//boost_config
/boost/core//boost_core
/boost/detail//boost_detail
/boost/integer//boost_integer
/boost/io//boost_io
/boost/iterator//boost_iterator
/boost/move//boost_move
/boost/mp11//boost_mp11
/boost/mpl//boost_mpl
/boost/optional//boost_optional
/boost/predef//boost_predef
/boost/preprocessor//boost_preprocessor
/boost/smart_ptr//boost_smart_ptr
/boost/spirit//boost_spirit
/boost/throw_exception//boost_throw_exception
/boost/type_traits//boost_type_traits
/boost/utility//boost_utility
/boost/variant//boost_variant
/boost/variant2//boost_variant2 ;
project /boost/serialization
: common-requirements
<include>include
;
explicit
[ alias boost_serialization : build//boost_serialization ]
[ alias boost_wserialization : build//boost_wserialization ]
[ alias all : boost_serialization boost_wserialization example test ]
;
call-if : boost-library serialization
: install boost_serialization boost_wserialization
;
================================================
FILE: doc/acknowledgments.html
================================================
<!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 function specification.
<li><a href="http://www.boost.org/people/vladimir_prus.htm">Vladimir Prus</a> for evaluating an
early draft and contributing the diamond inheritance example.
<li><a href="http://www.boost.org/people/william_kempf.htm">William E. Kempf</a>
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>
================================================
FILE: doc/archive_reference.html
================================================
<!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 Requirements</h4>
The simplest class which will model the <a href="archives.html"><strong>Archive</strong></a> concept specifies the functions that a
class will look like:
<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.
</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>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">BOOST_CLASS_EXPORT</code> is used
to instantiate the serialization code for the included archives.
</ul>
To make this work, the following should be included after the archive
class definition.
<pre><code>
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 character 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 circumstances, 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 polymorphic archives is fundamentally incompatible with the
serialization of new types that are marked "primitive" by the user with:
<pre><code>
BOOST_CLASS_IMPLEMENTATION(my_primitive_type, boost::serialization::primitive_type)
</code></pre>
Code to implement serialization for these types is instantiated "on the fly" in the user's program.
But this conflicts with the whole purpose of the polymorphic archive. An attempt to
serialize such a primitive type will result in a compilation error since the common polymorphic
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>
================================================
FILE: doc/archives.html
================================================
<!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, specification of serialization is exactly the same
for all archives. Archive classes have other members not mentioned here.
However they are related to the internal functioning of the library and
are not meant to be called by users of an archive. Implementation of new
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 - ignored 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 endianness to gracefully handle the case where it has been
erroneously assumed that such an archive is portable across platforms. In some cases,
where this extra overhead might be considered objectionable, it can be suppressed with the
<code style="white-space: normal">no_header</code> flag.
<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>
Constructs an archive given an open <code style="white-space: normal">stream</code> as
an argument and optional flags. If flags are used, they should be the same
as those used when the archive was created. Function and usage of flags is described
above.
</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>
================================================
FILE: doc/bibliography.html
================================================
<!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 Language</u>, Addison-Wesley, 1997
<a name="7"></a>
<li>Alexandrescu, Andrei, <u>Modern C++ Design</u>, Addison-Wesley, 2001
<a name="8"></a>
<li>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>
================================================
FILE: doc/class_diagram.html
================================================
<!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 hierarchy and organization is similar for loading and for
other types of archives as well. In the diagram, classes written in <font color="blue">blue</font>
implement saving for a given archive type. (in this case it's text archives).
Users include classes in <font color="red">red</font> to save their data from a particular
type of archive. Other classes whose names are in black implement the library and should
never change. They are in <code>namespace boost::archive::detail</code>
<dl>
<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 <code style="white-space: normal">polymorphic_text_archive</code> rather than
<code style="white-space: normal">polymorphic_oarchive_route<text_oarchive_impl<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>
================================================
FILE: doc/codecvt.html
================================================
<!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>
================================================
FILE: doc/configuration.html
================================================
<!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>
================================================
FILE: doc/contents.html
================================================
<!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" src="dot.gif"><a target="detail" href="tutorial.html#splitting">
Splitting <code>serialize</code> into <code>save/load</code>
</a>
</dl></div></dd>
<dt><img style="display:none" src="plus.gif" id="pointers"><a target="detail" href="serialization.html#pointeroperators">Pointers</a>
<dd><div id="pointers_detail"><dl class="page-index">
<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" href="special.html">Special Considerations</a>
<dd><div id="special_detail"><dl class="page-index">
<dt><img style="display:none" src="dot.gif"><a target="detail" href="special.html#objecttracking">Object Tracking</a>
<dt><img style="display:none" src="dot.gif"><a target="detail" href="special.html#classinfo">Class Information</a>
<dt><img style="display:none" src="dot.gif"><a target="detail" href="special.html#helpersupport">Helper Support</a>
<dt><img style="display:none" src="plus.gif" id="portability"><a target="detail" href="special.html#portability">Archive Portability</a>
<dd><div id="portability_detail"><dl class="page-index">
<dt><img style="display:none" src="dot.gif"><a target="detail" href="special.html#numerics">Numerics</a>
<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">Optimizations</a>
<dt><img style="display:none" src="plus.gif" id="exceptions"><a target="detail" href="exceptions.html">Archive Exceptions</a>
<dd><div id="exceptions_detail"><dl class="page-index">
<dt><img style="display:none" src="dot.gif"><a target="detail" href="exceptions.html#unregistered_class"><code>unregistered_class</code></a>
<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#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>
================================================
FILE: doc/dataflow.html
================================================
<!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.
<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 namespace
<code style="white-space: normal">boost::archive::iterators</code> included here are:
<dl class="index">
<dt><a target="base64_from_binary" href="../../../boost/archive/iterators/base64_from_binary.hpp">
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>
================================================
FILE: doc/definitions.html
================================================
<!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>
================================================
FILE: doc/derivation.html
================================================
<!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>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>
================================================
FILE: doc/exception_safety.html
================================================
<!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 - Reference</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">Exception Safety</h2>
</td>
</tr>
</table>
<hr>
The process of loading an archive may result in the creation of new objects. That
same process may throw an exception at some point. In order to prevent memory leaks
and invalid pointers, these situations must be considered. Unfortunately, there is
no simple universal solution to this problem. The manner of addressing this must
depend on the design of the data structures to be serialized. Below, we discuss
varying scenarios in increasing order of difficulty. This discussion presumes that
the class member functions are exception safe before considering serialization.
That is, the destructor could be called at anytime without referencing
an invalid pointer, or creating a memory leak.
<ol>
<li><h4>class contains no pointers</h4>
No problem here.
<p>
<li><h4>class contains only <i>owned</i> pointers</h4>
From here on, we have to make a distinction between pointers used
to manage heap storage (<i>owned</i> pointers) and pointers used to refer
to related objects (<i>referenced</i> pointers). Programs containing <i>owned</i>
pointers must contain code for deleting these objects and returning the
deallocated storage to the heap. Programs containing <i>referenced</i> pointers
must be designed to ensure that no such <i>referenced</i> pointers are de-referenced
after the object pointed to has been destroyed and its storage returned
to the heap. If a pointer is stored in only one place, it must be an <i>owned</i>
pointer.
<p>
The load function traps any exceptions that occur between the time an object
is created and its pointer is stored. Should an exception occur while
reading an archive, the created object is deleted and the de-serialized
pointer is set to NULL. This ensures that there are no memory leaks.
The fact that there are no other copies of this pointer ensures that
no pointers are left invalid. The object's destructor should
be able to delete any other existing objects in the normal manner
without problem.
<a href="../test/test_delete_pointer.cpp" target="test_delete_pointer.cpp">test_delete_pointer.cpp</a>
illustrates this case.
<p>
<li><h4>class contains one or more <i>referenced</i> pointers</h4>
This situation can be further subdivided into two cases
<p>
<ol>
<li><h4><i>owned</i> pointers are always serialized before <i>referenced</i> pointers</h4>
Object tracking will ensure that no new objects will be created
by the loading of a <i>referenced</i> pointer.
If an exception occurs, <i>referenced</i> pointers will not need to be deleted
so there will be no memory leaks. The destructor of this class won't attempt to
delete these pointers so there will be no problem with dangling references.
<i>Owned</i> pointers are handled exactly as described above.
<p>
<li><h4>class contains <i>referenced</i> pointers which might be created by load</h4>
If a <i>referenced</i> pointer is loaded before its corresponding <i>owned</i>
pointer, the object will be allocated on the heap. In certain cases
it cannot be known which pointers were created by their owners and which
were created by the load function. To address this:
<ul>
<li>Trap exceptions with a <code style="white-space: normal">try/catch</code> block.
<li>Within the catch part, invoke the archive function
<code style="white-space: normal">delete_created_pointers()</code> to delete any pointers
created by the class load. Without other action, objects created in
this way would end up as memory leaks as they are not considered <i>owned</i>
pointers and hence aren't destroyed.
<li>The object's destructor won't try
to delete <i>referenced</i> pointers so any dangling references will
cause no harm.
</ul>
<a href="../example/demo_exception.cpp" target="demo_exception.cpp">demo_exception.cpp</a>
is a program that illustrates this case.
<p>
</ol>
<p>
<li><h4>Other cases</h4>
Situations not covered above are pointers for which the classifications of
<i>referenced</i> and <i>owned</i> are not applicable. This might occur where
pointers are created by one class but consumed and deleted by another. These
may be addressed with an ad hoc analysis similar to the above. As the
situation becomes more complex this becomes more difficult and error prone.
Eventually, it will be have to addressed by building heap management into the
pointer itself - that is into <code style="white-space: normal">boost::shared_ptr</code>.
The library includes serialization of <code style="white-space: normal">boost::shared_ptr</code>. As
previously mentioned, this required a tiny alteration in one of the
<code style="white-space: normal">boost::shared_ptr</code> implementation files in order to permit
access by the serialization system.
</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>
================================================
FILE: doc/exceptions.html
================================================
<!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 - Archive Exceptions</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 Exceptions</h2>
</td>
</tr>
</table>
<hr>
<dl class="page-index">
<dt><a href="#unregistered_class"><code style="white-space: normal">unregistered_class</code></a>
<dt><a href="#invalid_signature"><code style="white-space: normal">invalid_signature</code></a>
<dt><a href="#unsupported_version"><code style="white-space: normal">unsupported_version</code></a>
<dt><a href="#unsupported_class_version"><code style="white-space: normal">unsupported_class_version</code></a>
<dt><a href="#pointer_conflict"><code style="white-space: normal">pointer_conflict</code></a>
<dt><a href="#incompatible_native_format"><code style="white-space: normal">incompatible_native_format</code></a>
<dt><a href="#array_size_too_short"><code style="white-space: normal">array_size_too_short</code></a>
<dt><a href="#input_stream_error"><code style="white-space: normal">input_stream_error</code></a>
<dt><a href="#output_stream_error"><code style="white-space: normal">output_stream_error</code></a>
<dt><a href="#invalid_class_name"><code style="white-space: normal">invalid_class_name</code></a>
<dt><a href="#unregistered_class"><code style="white-space: normal">unregistered_class</code></a>
<dt><a href="#multiple_code_instantiation"><code style="white-space: normal">multiple_code_instantiation</code></a>
<dt><a href="#xml_archive_parsing_error"><code style="white-space: normal">xml_archive_parsing_error</code></a>
<dt><a href="#xml_archive_tag_mismatch"><code style="white-space: normal">xml_archive_tag_mismatch</code></a>
<dt><a href="#xml_archive_tag_name_error"><code style="white-space: normal">xml_archive_tag_name_error</code></a>
</dl>
Archive operators can throw a <code style="white-space: normal">boost::archive_exception</code>
object which can be caught by an application program. These exceptions are defined
in the files <a target="archive_exception_hpp" href="../../../boost/archive/archive_exception.hpp">
archive_exception.hpp</a>
and <a target="basic_xml_archive_hpp" href="../../../boost/archive/basic_xml_archive.hpp">
basic_xml_archive.hpp</a>.
<pre><code>
namespace boost {
namespace archive {
class archive_exception : public std::exception
{
public:
typedef enum {
unregistered_class, // attempt to serialize a pointer of
// an unregistered class
invalid_signature, // first line of archive does not contain
// expected string
unsupported_version, // archive created with library version subsequent
// to this one
pointer_conflict // an attempt has been made to directly serialize
// an object after having already serialized the same
// object through a pointer. Were this permitted,
// the archive load would result in the creation
// of an extraneous object.
incompatible_native_format, // attempt to read native binary format
// on incompatible platform
array_size_too_short, // array being loaded doesn't fit in array allocated
input_stream_error // error on stream input
invalid_class_name, // class name greater than the maximum permitted.
// most likely a corrupted archive or an attempt
// to insert virus via buffer overrun method.
unregistered_cast, // base - derived relationship not registered with
// void_cast_register
unsupported_class_version, // type saved with a version # greater than the
// one used by the program. This indicates that the program
// needs to be rebuilt.
multiple_code_instantiation, // code for implementing serialization for some
// type has been instantiated in more than one module.
output_stream_error // error on stream output
} exception_code;
exception_code code;
archive_exception(exception_code c) : code(c) {}
virtual const char *what( ) const throw();
};
class xml_archive_exception : public virtual archive_exception
{
public:
typedef enum {
xml_archive_parsing_error, // archive doesn't contain expected data
xml_archive_tag_mismatch, // start/end tag in archive doesn't match program
xml_archive_tag_name_error // tag name contains invalid characters
} exception_code;
xml_archive_exception(exception_code c){}
virtual const char *what( ) const throw();
};
} // archive
} // boost
</code></pre>
<p>
<h3><a name="unregistered_class"><code style="white-space: normal">unregistered_class</code></a></h3>
An attempt has been made to serialize a polymorphic class through a pointer
without either registering it or associating it with an export key. This can also occur
when using a new archive whose class name has not been added to the system with the
<code style="white-space: normal">BOOST_ARCHIVE_CUSTOM_ARCHIVE_TYPES</code> macro.
<h3><a name="invalid_signature"><code style="white-space: normal">invalid_signature</code></a></h3>
Archives are initiated with a known string. If this string is not found when
the archive is opened, It is presumed that this file is not a valid archive and this
exception is thrown.
<h3><a name="unsupported_version"><code style="white-space: normal">unsupported_version</code></a></h3>
This system records the current library version number to all archives created. Note that this is in
no way related to version number of classes used by application programs. This refers
to the version of the serialization system used to create the archive. Future versions
of this serialization system will be able to identify archives created under a previous
(i.e. this) system and alter the loading procedure accordingly. Hence, future enhancements
to this serialization system should not obsolete any existing archive files. It is only
necessary to increment this version number when the newer system creates archives
incompatible in format with the current one.
<p>Should it ever occur that an older program attempts to read newer archives whose
format has changed, this exception is thrown.
<h3><a name="unsupported_class_version"><code style="white-space: normal">unsupported_class_version</code></a></h3>
An attempt has been made to load a class whose version has been incremented since the
program was written. Suppose that a class has been assigned version number 3 and the program
has been built and sent to third parties. Now suppose that the definition of that class
has been altered, the version number has been incremented to 4 and new archives have been
built. If one attempts to load these new archives with the original program, this
exception will be thrown.
<h3><a name="pointer_conflict"><code style="white-space: normal">pointer_conflict</code></a></h3>
To understand what this exception means consider the following scenario
<pre><code>
template<class Archive>
void T::save(Archive &ar) const
{
const A * aptr = &a;
ar << aptr; // save an instance of object of class A through a pointer
...
ar << a; // save an instance of an object of class A
assert(aptr == &a); // this must be true
}
template<class Archive>
void T::load(Archive &ar)
{
A * aptr;
ar >> aptr; // create and initialize a new instance of class A
...
ar >> a; // restore state of on object of class A
assert(aptr == &a); // this won't be true
}
</pre></code>
An object is saved first through a pointer then directly. Upon loading back
in the same sequence, we first create an new object and load in its data. Then
we load the data into another existing object. Where we started with one
object during save, we have two objects after restore. In a more realistic
situation, it could be very difficult to find this error. Fortunately,
these situations can be detected when the archive is created. When
this occurs, this exception is thrown.
<h3><a name = "incompatible_native_format"><code style="white-space: normal">incompatible_native_format</code></a></h3>
The library currently supports char text, wide char text and native binary
archive files. At the beginning of every archive, a signature is written indicating
the type of archive. This exception is thrown when an attempt is made to read
an archive written in a different format.
<h3><a name="array_size_too_short"><code style="white-space: normal">array_size_too_short</code></a></h3>
An attempt has been made to read an array that is larger than the array size.
This should only occur when the size of an array in code is reduced after an
archive has already been created.
<h3>
<a name="input_stream_error"><code style="white-space: normal">input_stream_error</code></a>
<br>
<a name="output_stream_error"><code style="white-space: normal">output_stream_error</code></a>
</h3>
An error has occurred during stream input or ouput. Aside from the common
situations such as a corrupted or truncated input file, there are
several less obvious ones that sometimes occur.
<p>
This includes
an attempt to read past the end of the file. Text files need a terminating
new line character at the end of the file which is appended when the
archive destructor is invoked. Be sure that an output archive on a stream
is destroyed before opening an input archive on that same stream. That is,
rather than using something like:
<pre><code>
std::stringstream ss;
std::vector<V> v;
boost::archive::text_oarchive oa(ss);
oa << v;
boost::archive::text_iarchive ia(ss);
ia >> v;
</code></pre>
use
<pre><code>
std::stringstream ss;
std::vector<V> v;
{
boost::archive::text_oarchive oa(ss);
oa << v;
}
{
boost::archive::text_iarchive ia(ss);
ia >> v;
}
</code></pre>
<p>
Another one is the passing of uninitialized data. In general, the behavior
of the serialization library when passed uninitialized data is undefined.
If it can be detected, it will invoke an assertion in debug builds.
Otherwise, depending on the type of archive, it may pass through without
incident or it may result in an archive with unexpected data in it.
This, in turn, can result in the throwing of this exception.
<h3><a name="invalid_class_name"><code style="white-space: normal">invalid_class_name</code></a></h3>
Class name length greater than the maximum permitted. Most likely cause is a corrupted
archive or an attempt to insert a virus via the buffer overrun method.
<h3><a name="unregistered_cast"><code style="white-space: normal">unregistered_cast</code></a></h3>
In order to support casting between pointers of base and derived classes
at runtime, a collection of legitimate conversions is maintained by the system.
Normally this collection is maintained without any explicit action
on the part of the user of the library. However, there are special cases
where this might have to be done explicitly and could be overlooked. This
is described in <a href="serialization.html#runtimecasting">Runtime Casting</a>.
This exception is thrown if an attempt is made to convert between two pointers
whose relationship has not been registered,
<h3><a name="multiple_code_instantiation"><code style="white-space: normal">multiple_code_instantiation</code></a></h3>
This exception is thrown when it is detected that the serialization of the same type
has been instantiated more than once. This might occur when
serialization code is instantiated in both the mainline and one or more DLLS.
<h3><a name="xml_archive_parsing_error"><code style="white-space: normal">xml_archive_parsing_error</code></a></h3>
The XML generated by the serialization process is intimately coupled to the
C++ class structure, relationships between objects and the serialization
specifications. If these become out of sync in any way, the XML may not map
to the loading serialization and this exception might be thrown. This might
occur for one of the following reasons:
<ul>
<li>The archive has been edited outside the serialization system. This might
be possible if only the data is changed and the XML attributes and nesting
structure are left unaltered. But any other editing is likely to render the
archive unreadable by the serialization library.
<li>The serialization has been altered and an archive generated by the old
code is being read. That is, versioning has not been properly employed to
properly deserialize previously created archives.
</ul>
<h3><a name="xml_archive_tag_mismatch"><code style="white-space: normal">xml_archive_tag_mismatch</code></a></h3>
This exception will be thrown if the start or end tag of an XML element doesn't match
the name specified for the object in the program.
<h3><a name="xml_archive_tag_name_error"><code style="white-space: normal">xml_archive_tag_name_error</code></a></h3>
This exception will be thrown if the tag name contains invalid characters. Valid characters
for an XML tag are: upper and lower case letters, digits, and the following punctuation: .(period),
_(underscore), :(colon), and -(hyphen).
<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>
================================================
FILE: doc/extended_type_info.html
================================================
<!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 - extended_type_info</title>
</head>
<body link="#0000ff" vlink="#800080">
<table border="0" cellpadding="7" cellspacing="0" width="100%" summary="header">
<tr>
<td valign="top" width="300">
<h3><a href="../../../index.htm"><img height="86" width="277" alt="C++ Boost" src="../../../boost.png" border="0"></a></h3>
</td>
<td valign="top">
<h1 align="center">Serialization</h1>
<h2 align="center"><code style="white-space: normal">extended_type_info</code></h2>
</td>
</tr>
</table>
<hr>
<dl class="page-index">
<dt><a href="#motivation">Motivation</a>
<dt><a href="#runtime">Runtime Interface</a>
<dt><a href="#requirements">Requirements</a>
<dt><a href="#models">Models</a>
<dt><a href="#example">Example</a>
</dl>
<h3><a name="motivation">Motivation</a></h3>
The serialization library needs a system like
<code style="white-space: normal">type_info/typeid()</code> to perform
the following functions
<ol>
<li>
given a pointer to a type T discover the true type pointed to.
<li>
given an "external" key - determine what type of object to create.
</ol>
<h3>The problem with <code style="white-space: normal">std::type_info</code></h3>
<ul>
<li>
The main function we require - <code style="white-space: normal">std::typeid()</code>
is not available in all environments. Support for this function depends upon
runtime typing(RTTI) support from the compiler. This may be non-existent
or not enabled for reasons such as a perceived inefficiency.
<li>
<code style="white-space: normal">std::type_info</code> includes a string
containing type name. This would seem to satisfy 2) above.
But the format of this string is not consistent accross compilers, libraries,
and operating systems. This makes it unusable for support of portable archives.
<li>
Even if the type name string could somehow be made portable, there is no
guarantee that class headers would be included in the same namespace accross
different applications. In fact, including different headers in different
namespaces is an accepted method used to avoid namespace conflicts.
Thus the namespace::class_name can't be used as a key.
<li>
There exists the possibility that different classes use different type id
mechanisms. The class header might include this information. If we want to
import class headers accross applications, it's convenient that the type id
mechanism support inter-operability accross different type id systems.
</ul>
<h3>Features</h3>
<code style="white-space: normal"><a target="extended_type_info.hpp" href = "../../../boost/serialization/extended_type_info.hpp">
extended_type_info</a></code> is an implementation
of <code style="white-space: normal">std::type_info</code> functionality with the
following features:
<ul>
<li>
Builds a set of <a target="extended_type_info.hpp" href = "../../../boost/serialization/extended_type_info.hpp">
<code style="white-space: normal">extended_type_info</a></code> records - one for each type
serialized.
<li>
permits association of an arbitrary string key with a type. Often this key would
be the class name - but it doesn't have to be. This key is referred to as
a GUID - Globally Unique IDentifier. Presumably it should be unique in the universe.
Typically this GUID would be in header files and be used to match type accross
applications. The macro BOOST_CLASS_EXPORT can be invoked to associate a string
key with any known type. We'll refer to these types as "exported types"
<li>
permits the "mixing" of type info systems. For example, one class might use
<code style="white-space: normal">typeid()</code> to find the external identifier
of a class while another might not.
</ul>
Exported types are maintained in a global table so that given a string key, the
corresponding type can be found. This facility is used by the serialization library
in order to construct types serialized through a base class pointer.
<h3><a name="runtime">Runtime Interface</a></h3>
<pre><code>
namespace boost {
namespace serialization {
class extended_type_info
{
protected:
// this class can't be used as is. It's just the
// common functionality for all type_info replacement
// systems. Hence, make these protected
extended_type_info(
const unsigned int type_info_key,
const char * key
);
~extended_type_info();
void key_register();
void key_unregister();
public:
const char * get_key() const;
bool operator<(const extended_type_info &rhs) const;
bool operator==(const extended_type_info &rhs) const;
bool operator!=(const extended_type_info &rhs) const {
return !(operator==(rhs));
}
// for plugins
virtual void * construct(unsigned int count = 0, ...) const;
virtual void destroy(void const * const p) const;
static const extended_type_info * find(const char *key);
};
} // namespace serialization
} // namespace boost
</code></pre>
<p>
Generally, there will be one and only one
<code style="white-space: normal"><a target="extended_type_info.hpp" href = "../../../boost/serialization/extended_type_info.hpp">extended_type_info</a></code>
instance created for each type. However, this is enforced only at the executable
module level. That is, if a program includes some shared libraries or DLLS,
there may be more than one instance of this class corresponding to a particular type.
For this reason the comparison functions below can't just compare the addresses of
this instance but rather must be programmed to compare the actual information
the instances contain.
<dl>
<dt><h4><pre><code>
extended_type_info(unsigned int type_info_key, const char *key);
</code></pre></h4></dt>
<dd>
This constructor should be called by all derived classes.
The first argument should be the particular implementation.
For this default implementation base on typeid(), this is the
value 1. Each system must have its own integer. This value
is used to permit the inter-operability of different typeinfo
systems.
<p>
The second argument is a const string which is the external
name of the type to which this record corresponds.
It may sometimes be referred to as a GUID - a <b>G</b>lobal <b>U</b>nique <b>ID</b>entifier.
It is passed through archives from one program invocation to
another to uniquely identify the types that the archive contains.
If the "export" facility is not going to be used,
this value may be NULL.
</dd>
<dt><h4><pre><code>
void key_register();
void key_unregister();
</code></pre></h4></dt>
<dd>
This system maintains a global table which relates
external strings to
<code style="white-space: normal">extended_type_info</code> records.
This table is used when loading pointers to objects serialized
through a base class pointer. In this case, the archive
contains a string which is looked up in this table to
determine which <code style="white-space: normal">extended_type_info</code>
to use for creating a new object.
<p>
These functions are called by constructors and
destructors of classes which implement
<code style="white-space: normal">extended_type_info</code>
to add and remove entries from this table.
</dd>
<dt><h4><pre><code>
const char *get_key() const;
</code></pre></h4></dt>
<dd>
Retrieves the key for <code style="white-space: normal"><a target="extended_type_info.hpp" href = "../../../boost/serialization/extended_type_info.hpp">extended_type_info</a></code>
instance. If no key has been associated with the instance, then a NULL is returned.
</dd>
<dt><h4><pre><code>
bool operator<(const extended_type_info & rhs) const;
bool operator==(const extended_type_info & rhs) const;
bool operator!=(const extended_type_info & rhs) const;
</code></pre></h4></dt>
<dd>
These functions are used to compare
<a target="extended_type_info.hpp" href = "../../../boost/serialization/extended_type_info.hpp">
<code style="white-space: normal">
extended_type_info
</code>
</a>
objects. They impose a strict total ordering on all
<code style="white-space: normal">extended_type_info</code> records.
</dd>
<dt><h4><pre><code>
virtual void * construct(unsigned int count = 0, ...) const;
</code></pre></h4></dt>
<dd>
Construct a new instance of the type to which this
<a target="extended_type_info.hpp" href = "../../../boost/serialization/extended_type_info.hpp">
<code style="white-space: normal">
extended_type_info
</code>
</a>
record corresponds. This function takes a variable list of up to 4 arguments
of any type. These arguments are passed to the type's constructor
at runtime. In order to use the facility,
one must declare a type sequence for the constructor arguments.
Arguments for this function must match in number and type
with those specified when the type was exported.
This function permits one to create instances of
any exported type given only the exported <strong>GUID</strong> assigned
with BOOST_CLASS_EXPORT.
If these types are defined in DLLS or shared libraries loaded at runtime,
these constructors can be called until the module is unloaded.
Such modules are referred to as <b>plugins</b>.
</code>
</dd>
<dt><h4><pre><code>
virtual void destroy(void const * const p) const;
</code></pre></h4></dt>
<dd>
Destroy an instance created by the above constructor.
</dd>
<dt><h4><pre><code>
static const extended_type_info * find(const char *key);
</code></pre></h4></dt>
<dd>
Given a character string key or <strong>GUID</strong>, return the address of a
corresponding <code style="white-space: normal"><a target="extended_type_info.hpp" href = "../../../boost/serialization/extended_type_info.hpp">extended_type_info</a></code>
object.
</dl>
<h3><a name="requirements">Requirements for an Implementation</a></h3>
In order to be used by the serialization library, an implementation of
<code style="white-space: normal">extended_type_info</code>,
(referred to as ETI here), must be derived from
<a target="extended_type_info.hpp" href = "../../../boost/serialization/extended_type_info.hpp">
<code style="white-space: normal">
extended_type_info
</code>
</a>
and also implement the following:
<dl>
<dt><h4><code style="white-space: normal"><pre>
template<class ETI>
const extended_type_info *
ETI::get_derived_extended_type_info(const T & t) const;
</pre></code></h4></dt>
<dd>
Return a pointer to the
<code style="white-space: normal">extended_type_info</code>
instance that corresponds to
the "true type" of the type T. The "true type" is the lowest type in the
hierarchy of classes. The type T can always be cast to the "true type" with
a static cast. Implementation of this function will vary among type id systems
and sometimes will make presumptions about the type T than can be identified
with a particular <code style="white-space: normal">extended_type_info</code> implementation.
</dd>
<dt><h4><code style="white-space: normal"><pre>
virtual bool ETI::is_less_than(const extended_type_info &rhs) const;
</pre></code></h4></dt>
<dd>
Compare this instance to another one using the same
<code style="white-space: normal">extended_type_info</code> implementation.
</dd>
<dt><h4><code style="white-space: normal"><pre>
virtual bool ETI::is_equal(const extended_type_info &rhs) const;
</pre></code></h4></dt>
<dd>
Compare this instance to another one using the same
<code style="white-space: normal">extended_type_info</code> implementation.
Return <code style="white-space: normal">true</code> if the types referred
to are the same. Otherwise return
<code style="white-space: normal">false</code>
</dd>
<dt><h4><code style="white-space: normal"><pre>
const char ETI::get_key() const;
</pre></code></h4></dt>
<dd>
Retrieve the external key (aka GUID) for this class.
</dd>
<dt><h4><code style="white-space: normal"><pre>
virtual void * construct(unsigned int count, ...) const;
</pre></code></h4></dt>
<dd>
Construct an instance of the corresponding type
with the include argument list.
</dd>
<dt><h4><code style="white-space: normal"><pre>
virtual void * destroy(void const * const ptr ) const;
</pre></code></h4></dt>
<dd>
Destroy an instance of this type. This calls the
proper destructor and recovers allocated memory.
</dd>
</dl>
<h3><a name="models">Models</a></h3>
The serialization library includes
gitextract_ba__d2tt/
├── .drone/
│ └── drone.sh
├── .drone.star
├── .gitattributes
├── .github/
│ └── workflows/
│ ├── posix.yml
│ └── windows.yml
├── .gitignore
├── .travis.yml
├── CMake/
│ └── CMakeLists.txt
├── CMakeLists.txt
├── appveyor.yml
├── build/
│ └── Jamfile.v2
├── build.jam
├── doc/
│ ├── acknowledgments.html
│ ├── archive_reference.html
│ ├── archives.html
│ ├── bibliography.html
│ ├── class_diagram.html
│ ├── codecvt.html
│ ├── configuration.html
│ ├── contents.html
│ ├── dataflow.html
│ ├── definitions.html
│ ├── derivation.html
│ ├── exception_safety.html
│ ├── exceptions.html
│ ├── extended_type_info.html
│ ├── faq.html
│ ├── headers.html
│ ├── history.html
│ ├── implementation.html
│ ├── index.html
│ ├── new_case_studies.html
│ ├── overview.html
│ ├── performance_status.html
│ ├── pimpl.html
│ ├── private_base.html
│ ├── profile1.txt
│ ├── profile2.txt
│ ├── profile3.txt
│ ├── rationale.html
│ ├── reference.html
│ ├── release.html
│ ├── serialization.html
│ ├── shared_ptr.html
│ ├── shared_ptr2.html
│ ├── simple_log.html
│ ├── singleton.html
│ ├── smart_cast.html
│ ├── special.html
│ ├── state_saver.html
│ ├── static_warning.html
│ ├── strong_typedef.html
│ ├── style.css
│ ├── todo.html
│ ├── traits.html
│ ├── tutorial.html
│ ├── void_cast.html
│ └── wrappers.html
├── example/
│ ├── Jamfile.v2
│ ├── demo.cpp
│ ├── demo_auto_ptr.cpp
│ ├── demo_dll_a.hpp
│ ├── demo_dll_a.ipp
│ ├── demo_dll_b.hpp
│ ├── demo_dll_b.ipp
│ ├── demo_exception.cpp
│ ├── demo_fast_archive.cpp
│ ├── demo_gps.hpp
│ ├── demo_log.cpp
│ ├── demo_output.txt
│ ├── demo_pimpl.cpp
│ ├── demo_pimpl_A.cpp
│ ├── demo_pimpl_A.hpp
│ ├── demo_polymorphic.cpp
│ ├── demo_polymorphic_A.cpp
│ ├── demo_polymorphic_A.hpp
│ ├── demo_portable_archive.cpp
│ ├── demo_save.xml
│ ├── demo_shared_ptr.cpp
│ ├── demo_simple_log.cpp
│ ├── demo_trivial_archive.cpp
│ ├── demo_xml.cpp
│ ├── demo_xml.hpp
│ ├── demo_xml_load.cpp
│ ├── demo_xml_save.cpp
│ ├── demofile.txt
│ ├── fix_six.cpp
│ ├── log_archive.cpp
│ ├── log_archive.hpp
│ ├── polymorphic_portable_binary_iarchive.cpp
│ ├── polymorphic_portable_binary_iarchive.hpp
│ ├── polymorphic_portable_binary_oarchive.cpp
│ ├── polymorphic_portable_binary_oarchive.hpp
│ ├── portable_binary_archive.hpp
│ ├── portable_binary_iarchive.cpp
│ ├── portable_binary_iarchive.hpp
│ ├── portable_binary_oarchive.cpp
│ ├── portable_binary_oarchive.hpp
│ └── simple_log_archive.hpp
├── include/
│ └── boost/
│ ├── archive/
│ │ ├── archive_exception.hpp
│ │ ├── basic_archive.hpp
│ │ ├── basic_binary_iarchive.hpp
│ │ ├── basic_binary_iprimitive.hpp
│ │ ├── basic_binary_oarchive.hpp
│ │ ├── basic_binary_oprimitive.hpp
│ │ ├── basic_streambuf_locale_saver.hpp
│ │ ├── basic_text_iarchive.hpp
│ │ ├── basic_text_iprimitive.hpp
│ │ ├── basic_text_oarchive.hpp
│ │ ├── basic_text_oprimitive.hpp
│ │ ├── basic_xml_archive.hpp
│ │ ├── basic_xml_iarchive.hpp
│ │ ├── basic_xml_oarchive.hpp
│ │ ├── binary_iarchive.hpp
│ │ ├── binary_iarchive_impl.hpp
│ │ ├── binary_oarchive.hpp
│ │ ├── binary_oarchive_impl.hpp
│ │ ├── binary_wiarchive.hpp
│ │ ├── binary_woarchive.hpp
│ │ ├── codecvt_null.hpp
│ │ ├── detail/
│ │ │ ├── abi_prefix.hpp
│ │ │ ├── abi_suffix.hpp
│ │ │ ├── archive_serializer_map.hpp
│ │ │ ├── auto_link_archive.hpp
│ │ │ ├── auto_link_warchive.hpp
│ │ │ ├── basic_iarchive.hpp
│ │ │ ├── basic_iserializer.hpp
│ │ │ ├── basic_oarchive.hpp
│ │ │ ├── basic_oserializer.hpp
│ │ │ ├── basic_pointer_iserializer.hpp
│ │ │ ├── basic_pointer_oserializer.hpp
│ │ │ ├── basic_serializer.hpp
│ │ │ ├── basic_serializer_map.hpp
│ │ │ ├── check.hpp
│ │ │ ├── common_iarchive.hpp
│ │ │ ├── common_oarchive.hpp
│ │ │ ├── decl.hpp
│ │ │ ├── helper_collection.hpp
│ │ │ ├── interface_iarchive.hpp
│ │ │ ├── interface_oarchive.hpp
│ │ │ ├── iserializer.hpp
│ │ │ ├── oserializer.hpp
│ │ │ ├── polymorphic_iarchive_route.hpp
│ │ │ ├── polymorphic_oarchive_route.hpp
│ │ │ ├── register_archive.hpp
│ │ │ └── utf8_codecvt_facet.hpp
│ │ ├── dinkumware.hpp
│ │ ├── impl/
│ │ │ ├── archive_serializer_map.ipp
│ │ │ ├── basic_binary_iarchive.ipp
│ │ │ ├── basic_binary_iprimitive.ipp
│ │ │ ├── basic_binary_oarchive.ipp
│ │ │ ├── basic_binary_oprimitive.ipp
│ │ │ ├── basic_text_iarchive.ipp
│ │ │ ├── basic_text_iprimitive.ipp
│ │ │ ├── basic_text_oarchive.ipp
│ │ │ ├── basic_text_oprimitive.ipp
│ │ │ ├── basic_xml_grammar.hpp
│ │ │ ├── basic_xml_iarchive.ipp
│ │ │ ├── basic_xml_oarchive.ipp
│ │ │ ├── text_iarchive_impl.ipp
│ │ │ ├── text_oarchive_impl.ipp
│ │ │ ├── text_wiarchive_impl.ipp
│ │ │ ├── text_woarchive_impl.ipp
│ │ │ ├── xml_iarchive_impl.ipp
│ │ │ ├── xml_oarchive_impl.ipp
│ │ │ ├── xml_wiarchive_impl.ipp
│ │ │ └── xml_woarchive_impl.ipp
│ │ ├── iterators/
│ │ │ ├── base64_exception.hpp
│ │ │ ├── base64_from_binary.hpp
│ │ │ ├── binary_from_base64.hpp
│ │ │ ├── dataflow.hpp
│ │ │ ├── dataflow_exception.hpp
│ │ │ ├── escape.hpp
│ │ │ ├── insert_linebreaks.hpp
│ │ │ ├── istream_iterator.hpp
│ │ │ ├── mb_from_wchar.hpp
│ │ │ ├── ostream_iterator.hpp
│ │ │ ├── remove_whitespace.hpp
│ │ │ ├── transform_width.hpp
│ │ │ ├── unescape.hpp
│ │ │ ├── wchar_from_mb.hpp
│ │ │ ├── xml_escape.hpp
│ │ │ ├── xml_unescape.hpp
│ │ │ └── xml_unescape_exception.hpp
│ │ ├── polymorphic_binary_iarchive.hpp
│ │ ├── polymorphic_binary_oarchive.hpp
│ │ ├── polymorphic_iarchive.hpp
│ │ ├── polymorphic_oarchive.hpp
│ │ ├── polymorphic_text_iarchive.hpp
│ │ ├── polymorphic_text_oarchive.hpp
│ │ ├── polymorphic_text_wiarchive.hpp
│ │ ├── polymorphic_text_woarchive.hpp
│ │ ├── polymorphic_xml_iarchive.hpp
│ │ ├── polymorphic_xml_oarchive.hpp
│ │ ├── polymorphic_xml_wiarchive.hpp
│ │ ├── polymorphic_xml_woarchive.hpp
│ │ ├── text_iarchive.hpp
│ │ ├── text_oarchive.hpp
│ │ ├── text_wiarchive.hpp
│ │ ├── text_woarchive.hpp
│ │ ├── tmpdir.hpp
│ │ ├── wcslen.hpp
│ │ ├── xml_archive_exception.hpp
│ │ ├── xml_iarchive.hpp
│ │ ├── xml_oarchive.hpp
│ │ ├── xml_wiarchive.hpp
│ │ └── xml_woarchive.hpp
│ └── serialization/
│ ├── access.hpp
│ ├── archive_input_unordered_map.hpp
│ ├── archive_input_unordered_set.hpp
│ ├── array.hpp
│ ├── array_optimization.hpp
│ ├── array_wrapper.hpp
│ ├── assume_abstract.hpp
│ ├── base_object.hpp
│ ├── binary_object.hpp
│ ├── bitset.hpp
│ ├── boost_array.hpp
│ ├── boost_unordered_map.hpp
│ ├── boost_unordered_set.hpp
│ ├── collection_size_type.hpp
│ ├── collection_traits.hpp
│ ├── collections_load_imp.hpp
│ ├── collections_save_imp.hpp
│ ├── complex.hpp
│ ├── config.hpp
│ ├── deque.hpp
│ ├── detail/
│ │ ├── is_default_constructible.hpp
│ │ ├── shared_count_132.hpp
│ │ ├── shared_ptr_132.hpp
│ │ ├── shared_ptr_nmt_132.hpp
│ │ └── stack_constructor.hpp
│ ├── export.hpp
│ ├── extended_type_info.hpp
│ ├── extended_type_info_no_rtti.hpp
│ ├── extended_type_info_typeid.hpp
│ ├── factory.hpp
│ ├── force_include.hpp
│ ├── forward_list.hpp
│ ├── hash_collections_load_imp.hpp
│ ├── hash_collections_save_imp.hpp
│ ├── hash_map.hpp
│ ├── hash_set.hpp
│ ├── is_bitwise_serializable.hpp
│ ├── item_version_type.hpp
│ ├── level.hpp
│ ├── level_enum.hpp
│ ├── library_version_type.hpp
│ ├── list.hpp
│ ├── map.hpp
│ ├── nvp.hpp
│ ├── optional.hpp
│ ├── priority_queue.hpp
│ ├── queue.hpp
│ ├── scoped_ptr.hpp
│ ├── serialization.hpp
│ ├── set.hpp
│ ├── shared_ptr.hpp
│ ├── shared_ptr_132.hpp
│ ├── shared_ptr_helper.hpp
│ ├── singleton.hpp
│ ├── slist.hpp
│ ├── smart_cast.hpp
│ ├── split_free.hpp
│ ├── split_member.hpp
│ ├── stack.hpp
│ ├── state_saver.hpp
│ ├── static_warning.hpp
│ ├── std_variant.hpp
│ ├── string.hpp
│ ├── strong_typedef.hpp
│ ├── throw_exception.hpp
│ ├── tracking.hpp
│ ├── tracking_enum.hpp
│ ├── traits.hpp
│ ├── type_info_implementation.hpp
│ ├── unique_ptr.hpp
│ ├── unordered_collections_load_imp.hpp
│ ├── unordered_collections_save_imp.hpp
│ ├── unordered_map.hpp
│ ├── unordered_set.hpp
│ ├── utility.hpp
│ ├── valarray.hpp
│ ├── variant.hpp
│ ├── variant2.hpp
│ ├── vector.hpp
│ ├── vector_135.hpp
│ ├── version.hpp
│ ├── void_cast.hpp
│ ├── void_cast_fwd.hpp
│ ├── weak_ptr.hpp
│ └── wrapper.hpp
├── index.html
├── meta/
│ └── libraries.json
├── performance/
│ ├── Jamfile.v2
│ ├── binary_archive.hpp
│ ├── binary_warchive.hpp
│ ├── peformance_array.cpp
│ ├── performance_binary.cpp
│ ├── performance_codecvt_null.cpp
│ ├── performance_iterators.cpp
│ ├── performance_iterators_base64.cpp
│ ├── performance_no_rtti.cpp
│ ├── performance_polymorphic.cpp
│ ├── performance_simple_class.cpp
│ ├── performance_utf8_codecvt.cpp
│ ├── performance_vector.cpp
│ ├── polymorphic_array_binary_archive.hpp
│ ├── polymorphic_binary_archive.hpp
│ ├── polymorphic_text_archive.hpp
│ ├── polymorphic_text_warchive.hpp
│ ├── polymorphic_xml_archive.hpp
│ ├── polymorphic_xml_warchive.hpp
│ ├── portable_binary_archive.hpp
│ ├── profile.sh
│ ├── text_archive.hpp
│ ├── text_warchive.hpp
│ ├── xml/
│ │ ├── Jamfile.v2
│ │ ├── harness.hpp
│ │ ├── high_resolution_timer.hpp
│ │ ├── int16_results.xml
│ │ ├── int16_test.cpp
│ │ ├── int256_results.xml
│ │ ├── int256_test.cpp
│ │ ├── int4_results.xml
│ │ ├── int4_test.cpp
│ │ ├── int64_results.xml
│ │ ├── int64_test.cpp
│ │ ├── macro.hpp
│ │ ├── node.hpp
│ │ ├── string16_results.xml
│ │ ├── string16_test.cpp
│ │ ├── string256_results.xml
│ │ ├── string256_test.cpp
│ │ ├── string4_results.xml
│ │ ├── string4_test.cpp
│ │ ├── string64_results.xml
│ │ └── string64_test.cpp
│ ├── xml_archive.hpp
│ └── xml_warchive.hpp
├── src/
│ ├── archive_exception.cpp
│ ├── basic_archive.cpp
│ ├── basic_iarchive.cpp
│ ├── basic_iserializer.cpp
│ ├── basic_oarchive.cpp
│ ├── basic_oserializer.cpp
│ ├── basic_pointer_iserializer.cpp
│ ├── basic_pointer_oserializer.cpp
│ ├── basic_serializer_map.cpp
│ ├── basic_text_iprimitive.cpp
│ ├── basic_text_oprimitive.cpp
│ ├── basic_text_wiprimitive.cpp
│ ├── basic_text_woprimitive.cpp
│ ├── basic_xml_archive.cpp
│ ├── basic_xml_grammar.ipp
│ ├── binary_iarchive.cpp
│ ├── binary_oarchive.cpp
│ ├── binary_wiarchive.cpp
│ ├── binary_woarchive.cpp
│ ├── codecvt_null.cpp
│ ├── extended_type_info.cpp
│ ├── extended_type_info_no_rtti.cpp
│ ├── extended_type_info_typeid.cpp
│ ├── polymorphic_binary_iarchive.cpp
│ ├── polymorphic_binary_oarchive.cpp
│ ├── polymorphic_iarchive.cpp
│ ├── polymorphic_oarchive.cpp
│ ├── polymorphic_text_iarchive.cpp
│ ├── polymorphic_text_oarchive.cpp
│ ├── polymorphic_text_wiarchive.cpp
│ ├── polymorphic_text_woarchive.cpp
│ ├── polymorphic_xml_iarchive.cpp
│ ├── polymorphic_xml_oarchive.cpp
│ ├── polymorphic_xml_wiarchive.cpp
│ ├── polymorphic_xml_woarchive.cpp
│ ├── stl_port.cpp
│ ├── text_iarchive.cpp
│ ├── text_oarchive.cpp
│ ├── text_wiarchive.cpp
│ ├── text_woarchive.cpp
│ ├── utf8_codecvt_facet.cpp
│ ├── void_cast.cpp
│ ├── xml_archive_exception.cpp
│ ├── xml_grammar.cpp
│ ├── xml_iarchive.cpp
│ ├── xml_oarchive.cpp
│ ├── xml_wgrammar.cpp
│ ├── xml_wiarchive.cpp
│ └── xml_woarchive.cpp
├── test/
│ ├── A.cpp
│ ├── A.hpp
│ ├── A.ipp
│ ├── B.hpp
│ ├── C.hpp
│ ├── D.hpp
│ ├── J.hpp
│ ├── Jamfile.v2
│ ├── base.hpp
│ ├── binary_archive.hpp
│ ├── binary_warchive.hpp
│ ├── config_test.cpp
│ ├── derived2.hpp
│ ├── dll_a.cpp
│ ├── dll_base.cpp
│ ├── dll_derived2.cpp
│ ├── dll_polymorphic_base.cpp
│ ├── dll_polymorphic_derived2.cpp
│ ├── multi_shared1.cpp
│ ├── multi_shared2.cpp
│ ├── polymorphic_array_binary_archive.hpp
│ ├── polymorphic_base.cpp
│ ├── polymorphic_base.hpp
│ ├── polymorphic_binary_archive.hpp
│ ├── polymorphic_derived1.cpp
│ ├── polymorphic_derived1.hpp
│ ├── polymorphic_derived2.cpp
│ ├── polymorphic_derived2.hpp
│ ├── polymorphic_text_archive.hpp
│ ├── polymorphic_text_warchive.hpp
│ ├── polymorphic_xml_archive.hpp
│ ├── polymorphic_xml_warchive.hpp
│ ├── portable_binary_archive.hpp
│ ├── test__helper.cpp
│ ├── test_array.cpp
│ ├── test_binary.cpp
│ ├── test_bitset.cpp
│ ├── test_boost_array.cpp
│ ├── test_check.cpp
│ ├── test_class_info_load.cpp
│ ├── test_class_info_save.cpp
│ ├── test_codecvt_null.cpp
│ ├── test_complex.cpp
│ ├── test_const_load_fail1.cpp
│ ├── test_const_load_fail1_nvp.cpp
│ ├── test_const_load_fail2.cpp
│ ├── test_const_load_fail2_nvp.cpp
│ ├── test_const_load_fail3.cpp
│ ├── test_const_load_fail3_nvp.cpp
│ ├── test_const_pass.cpp
│ ├── test_const_save_warn1.cpp
│ ├── test_const_save_warn1_nvp.cpp
│ ├── test_const_save_warn2.cpp
│ ├── test_const_save_warn2_nvp.cpp
│ ├── test_const_save_warn3.cpp
│ ├── test_const_save_warn3_nvp.cpp
│ ├── test_const_save_warn4.cpp
│ ├── test_const_save_warn4_nvp.cpp
│ ├── test_contained_class.cpp
│ ├── test_cyclic_ptrs.cpp
│ ├── test_delete_pointer.cpp
│ ├── test_deque.cpp
│ ├── test_derived.cpp
│ ├── test_derived_class.cpp
│ ├── test_derived_class_ptr.cpp
│ ├── test_diamond.cpp
│ ├── test_diamond_complex.cpp
│ ├── test_dll_exported.cpp
│ ├── test_dll_plugin.cpp
│ ├── test_dll_simple.cpp
│ ├── test_enable_shared_from_this.cpp
│ ├── test_exported.cpp
│ ├── test_forward_list.cpp
│ ├── test_forward_list_ptrs.cpp
│ ├── test_helper_support.cpp
│ ├── test_inclusion.cpp
│ ├── test_inclusion2.cpp
│ ├── test_interators.cpp
│ ├── test_interrupts.cpp
│ ├── test_iterators.cpp
│ ├── test_iterators_base64.cpp
│ ├── test_list.cpp
│ ├── test_list_ptrs.cpp
│ ├── test_map.cpp
│ ├── test_map_hashed.cpp
│ ├── test_mi.cpp
│ ├── test_mult_archive_types.cpp
│ ├── test_multi_shared_lib.cpp
│ ├── test_multiple_inheritance.cpp
│ ├── test_multiple_ptrs.cpp
│ ├── test_native_array.cpp
│ ├── test_new_operator.cpp
│ ├── test_no_rtti.cpp
│ ├── test_non_default_ctor.cpp
│ ├── test_non_default_ctor2.cpp
│ ├── test_non_intrusive.cpp
│ ├── test_not_serializable.cpp
│ ├── test_null_ptr.cpp
│ ├── test_nvp.cpp
│ ├── test_object.cpp
│ ├── test_optional.cpp
│ ├── test_p_helper.cpp
│ ├── test_pimpl.cpp
│ ├── test_polymorphic.cpp
│ ├── test_polymorphic2.cpp
│ ├── test_polymorphic2.hpp
│ ├── test_polymorphic2imp.cpp
│ ├── test_polymorphic_A.cpp
│ ├── test_polymorphic_A.hpp
│ ├── test_primitive.cpp
│ ├── test_priority_queue.cpp
│ ├── test_private_base.cpp
│ ├── test_private_base2.cpp
│ ├── test_private_ctor.cpp
│ ├── test_queue.cpp
│ ├── test_recursion.cpp
│ ├── test_registered.cpp
│ ├── test_reset_object_address.cpp
│ ├── test_set.cpp
│ ├── test_set_hashed.cpp
│ ├── test_shared_ptr.cpp
│ ├── test_shared_ptr_132.cpp
│ ├── test_shared_ptr_multi_base.cpp
│ ├── test_simple_class.cpp
│ ├── test_simple_class_ptr.cpp
│ ├── test_singleton.cpp
│ ├── test_singleton_inherited.cpp
│ ├── test_singleton_plain.cpp
│ ├── test_slist.cpp
│ ├── test_slist_ptrs.cpp
│ ├── test_smart_cast.cpp
│ ├── test_split.cpp
│ ├── test_stack.cpp
│ ├── test_static_warning.cpp
│ ├── test_strong_typedef.cpp
│ ├── test_tools.hpp
│ ├── test_tracking.cpp
│ ├── test_traits_fail.cpp
│ ├── test_traits_pass.cpp
│ ├── test_unique_ptr.cpp
│ ├── test_unregistered.cpp
│ ├── test_valarray.cpp
│ ├── test_variant.cpp
│ ├── test_vector.cpp
│ ├── test_void_cast.cpp
│ ├── test_z.cpp
│ ├── text_archive.hpp
│ ├── text_warchive.hpp
│ ├── xml_archive.hpp
│ └── xml_warchive.hpp
└── util/
└── test.jam
Showing preview only (2,262K chars total). Download the full file or copy to clipboard to get everything.
SYMBOL INDEX (3195 symbols across 377 files)
FILE: example/demo.cpp
class gps_position (line 46) | class gps_position
method serialize (line 54) | void serialize(Archive & ar, const unsigned int /* file_version */){
method gps_position (line 59) | gps_position(){}
method gps_position (line 60) | gps_position(int _d, int _m, float _s) :
class bus_stop (line 75) | class bus_stop
method serialize (line 83) | void serialize(Archive &ar, const unsigned int version)
method bus_stop (line 89) | bus_stop(const gps_position & _lat, const gps_position & _long) :
method bus_stop (line 93) | bus_stop(){}
class bus_stop_corner (line 109) | class bus_stop_corner : public bus_stop
method description (line 114) | virtual std::string description() const
method serialize (line 119) | void serialize(Archive &ar, const unsigned int version)
method bus_stop_corner (line 127) | bus_stop_corner(){}
method bus_stop_corner (line 128) | bus_stop_corner(const gps_position & _lat, const gps_position & _long,
class bus_stop_destination (line 136) | class bus_stop_destination : public bus_stop
method description (line 140) | virtual std::string description() const
method serialize (line 145) | void serialize(Archive &ar, const unsigned int version)
method bus_stop_destination (line 151) | bus_stop_destination(){}
method bus_stop_destination (line 152) | bus_stop_destination(
class bus_route (line 172) | class bus_route
method serialize (line 179) | void serialize(Archive &ar, const unsigned int version)
method bus_route (line 193) | bus_route(){}
method append (line 194) | void append(bus_stop *_bs)
class bus_schedule (line 222) | class bus_schedule
type trip_info (line 227) | struct trip_info
method serialize (line 230) | void serialize(Archive &ar, const unsigned int file_version)
method trip_info (line 246) | trip_info(){}
method trip_info (line 247) | trip_info(int _h, int _m, const std::string &_d) :
method serialize (line 257) | void serialize(Archive &ar, const unsigned int version)
method append (line 262) | void append(const std::string &_d, int _h, int _m, bus_route *_br)
method bus_schedule (line 266) | bus_schedule(){}
function save_schedule (line 283) | void save_schedule(const bus_schedule &s, const char * filename){
function restore_schedule (line 290) | void
function main (line 301) | int main(int argc, char *argv[])
FILE: example/demo_auto_ptr.cpp
type std (line 17) | namespace std{
type boost (line 28) | namespace boost {
type serialization (line 29) | namespace serialization {
function save (line 36) | inline void save(
function load (line 48) | inline void load(
function serialize (line 67) | inline void serialize(
class A (line 80) | class A
method serialize (line 86) | void serialize(Archive &ar, const unsigned int /* file_version */){
method A (line 90) | A(){}
function save (line 94) | void save(const std::auto_ptr<A> & spa, const char *filename)
function load (line 101) | void load(std::auto_ptr<A> & spa, const char *filename)
function main (line 111) | int main(int argc, char *argv[])
FILE: example/demo_dll_a.hpp
type std (line 27) | namespace std{
function randomize (line 140) | void randomize(S &x)
function accumulate (line 152) | void accumulate(std::size_t & s, const T & t){
type h (line 190) | enum h
FILE: example/demo_dll_b.hpp
type std (line 24) | namespace std{
class B (line 37) | class B : public A
method save (line 42) | void save(Archive &ar, const unsigned int /* file_version */) const
method load (line 57) | void load(Archive & ar, const unsigned int file_version)
FILE: example/demo_exception.cpp
type std (line 29) | namespace std{
type deleter (line 47) | struct deleter
class Course (line 54) | class Course
method Course (line 83) | Course(){
method serialize (line 96) | void serialize(Archive & ar, const unsigned int /* file_version */){
class Student (line 55) | class Student
method Student (line 61) | Student(){
method serialize (line 72) | void serialize(Archive & ar, const unsigned int /* file_version */){
class Student (line 57) | class Student
method Student (line 61) | Student(){
method serialize (line 72) | void serialize(Archive & ar, const unsigned int /* file_version */){
class Course (line 79) | class Course
method Course (line 83) | Course(){
method serialize (line 96) | void serialize(Archive & ar, const unsigned int /* file_version */){
class School (line 103) | class School
function init (line 177) | void init(School *school){
function save (line 217) | void save(const School * const school, const char *filename){
function load (line 223) | void load(School * & school, const char *filename){
function main (line 235) | int main(int argc, char *argv[]){
FILE: example/demo_fast_archive.cpp
class fast_binary_oarchive (line 31) | class fast_binary_oarchive :
method save_override (line 63) | void save_override(T & t){
method save_override (line 70) | void save_override(const int (& t)[N]){
method save_override (line 74) | void save_override(const unsigned int (& t)[N]){
method save_override (line 78) | void save_override(const long (& t)[N]){
method save_override (line 82) | void save_override(const unsigned long (& t)[N]){
method fast_binary_oarchive (line 86) | fast_binary_oarchive(std::ostream & os, unsigned flags = 0) :
method fast_binary_oarchive (line 89) | fast_binary_oarchive(std::streambuf & bsb, unsigned int flags = 0) :
class fast_binary_iarchive (line 99) | class fast_binary_iarchive :
method load_override (line 131) | void load_override(T & t){
method load_override (line 136) | void load_override(int (& t)[N]){
method load_override (line 140) | void load_override(unsigned int (& t)[N]){
method load_override (line 144) | void load_override(long (& t)[N]){
method load_override (line 148) | void load_override(unsigned long (& t)[N]){
method fast_binary_iarchive (line 152) | fast_binary_iarchive(std::istream & is, unsigned int flags = 0) :
method fast_binary_iarchive (line 155) | fast_binary_iarchive(std::streambuf & bsb, unsigned int flags = 0) :
function main (line 163) | int main( int argc, char* argv[] )
FILE: example/demo_gps.hpp
class gps_position (line 35) | class gps_position
method serialize (line 45) | void serialize(Archive & ar, const unsigned int /* file_version */){
method gps_position (line 53) | gps_position(){}
method gps_position (line 54) | gps_position(int _d, int _m, float _s) :
class bus_stop (line 70) | class bus_stop
method serialize (line 78) | void serialize(Archive &ar, const unsigned int version)
method bus_stop (line 85) | bus_stop(const gps_position & _lat, const gps_position & _long) :
method bus_stop (line 89) | bus_stop(){}
class bus_stop_corner (line 106) | class bus_stop_corner : public bus_stop
method description (line 111) | virtual std::string description() const
method serialize (line 116) | void serialize(Archive &ar, const unsigned int version)
method bus_stop_corner (line 124) | bus_stop_corner(){}
method bus_stop_corner (line 125) | bus_stop_corner(const gps_position & _lat, const gps_position & _long,
class bus_stop_destination (line 133) | class bus_stop_destination : public bus_stop
method description (line 137) | virtual std::string description() const
method serialize (line 142) | void serialize(Archive &ar, const unsigned int version)
method bus_stop_destination (line 148) | bus_stop_destination(){}
method bus_stop_destination (line 149) | bus_stop_destination(
class bus_route (line 169) | class bus_route
method serialize (line 176) | void serialize(Archive &ar, const unsigned int version)
method bus_route (line 190) | bus_route(){}
method append (line 191) | void append(bus_stop *_bs)
class bus_schedule (line 218) | class bus_schedule
method serialize (line 223) | void serialize(Archive &ar, const unsigned int version)
type trip_info (line 230) | struct trip_info
method serialize (line 233) | void serialize(Archive &ar, const unsigned int file_version)
method trip_info (line 250) | trip_info(){}
method trip_info (line 251) | trip_info(int _h, int _m, const std::string &_d) :
method append (line 261) | void append(const std::string &_d, int _h, int _m, bus_route *_br)
method bus_schedule (line 265) | bus_schedule(){}
FILE: example/demo_log.cpp
function main (line 16) | int main(int argc, char *argv[]){
FILE: example/demo_pimpl.cpp
function main (line 18) | int main(int argc, char* argv[])
FILE: example/demo_pimpl_A.cpp
type B (line 15) | struct B {
method serialize (line 18) | void serialize(Archive & ar, const unsigned int /* file_version */){
FILE: example/demo_pimpl_A.hpp
type B (line 13) | struct B
type A (line 15) | struct A {
FILE: example/demo_polymorphic.cpp
function main (line 21) | int main(int argc, char* argv[])
FILE: example/demo_polymorphic_A.hpp
type boost (line 12) | namespace boost {
type archive (line 13) | namespace archive {
class polymorphic_iarchive (line 15) | class polymorphic_iarchive
class polymorphic_oarchive (line 16) | class polymorphic_oarchive
type A (line 21) | struct A {
method serialize (line 24) | void serialize(
method A (line 34) | A() :
FILE: example/demo_portable_archive.cpp
type std (line 23) | namespace std{ using ::rand; }
class A (line 26) | class A
method serialize (line 37) | void serialize(Archive & ar, const unsigned int /* version */){
method A (line 51) | A() :
function main (line 62) | int main( int /* argc */, char* /* argv */[] )
FILE: example/demo_shared_ptr.cpp
type std (line 21) | namespace std{
class A (line 34) | class A
method serialize (line 40) | void serialize(Archive & ar, const unsigned int /* file_version */){
method A (line 45) | A(){++count;}
class B (line 53) | class B : public A
method serialize (line 59) | void serialize(Archive & ar, const unsigned int /* file_version */){
method B (line 64) | B() : A() {}
function display (line 74) | void display(boost::shared_ptr<A> &spa, boost::shared_ptr<A> &spa1)
function main (line 85) | int main(int /* argc */, char * /*argv*/[])
FILE: example/demo_simple_log.cpp
function main (line 16) | int main(int argc, char *argv[])
FILE: example/demo_trivial_archive.cpp
class trivial_oarchive (line 15) | class trivial_oarchive {
method register_type (line 23) | void register_type(){}
method trivial_oarchive (line 24) | trivial_oarchive & operator<<(const T & t){
method trivial_oarchive (line 27) | trivial_oarchive & operator&(const T & t){
function main (line 35) | int main(int argc, char *argv[])
FILE: example/demo_xml.cpp
type std (line 18) | namespace std{
function save_schedule (line 29) | void save_schedule(const bus_schedule &s, const char * filename){
function restore_schedule (line 37) | void
function main (line 49) | int main(int argc, char *argv[])
FILE: example/demo_xml.hpp
class gps_position (line 35) | class gps_position
method serialize (line 45) | void serialize(Archive & ar, const unsigned int /* file_version */){
method gps_position (line 53) | gps_position(){}
method gps_position (line 54) | gps_position(int _d, int _m, float _s) :
class bus_stop (line 70) | class bus_stop
method serialize (line 78) | void serialize(Archive &ar, const unsigned int version)
method bus_stop (line 85) | bus_stop(const gps_position & _lat, const gps_position & _long) :
method bus_stop (line 89) | bus_stop(){}
class bus_stop_corner (line 106) | class bus_stop_corner : public bus_stop
method description (line 111) | virtual std::string description() const
method serialize (line 116) | void serialize(Archive &ar, const unsigned int version)
method bus_stop_corner (line 124) | bus_stop_corner(){}
method bus_stop_corner (line 125) | bus_stop_corner(const gps_position & _lat, const gps_position & _long,
class bus_stop_destination (line 133) | class bus_stop_destination : public bus_stop
method description (line 137) | virtual std::string description() const
method serialize (line 142) | void serialize(Archive &ar, const unsigned int version)
method bus_stop_destination (line 148) | bus_stop_destination(){}
method bus_stop_destination (line 149) | bus_stop_destination(
class bus_route (line 169) | class bus_route
method serialize (line 176) | void serialize(Archive &ar, const unsigned int version)
method bus_route (line 190) | bus_route(){}
method append (line 191) | void append(bus_stop *_bs)
class bus_schedule (line 218) | class bus_schedule
method serialize (line 223) | void serialize(Archive &ar, const unsigned int version)
type trip_info (line 230) | struct trip_info
method serialize (line 233) | void serialize(Archive &ar, const unsigned int file_version)
method trip_info (line 250) | trip_info(){}
method trip_info (line 251) | trip_info(int _h, int _m, const std::string &_d) :
method append (line 261) | void append(const std::string &_d, int _h, int _m, bus_route *_br)
method bus_schedule (line 265) | bus_schedule(){}
FILE: example/demo_xml_load.cpp
function restore_schedule (line 18) | void
function main (line 30) | int main(int argc, char *argv[])
FILE: example/demo_xml_save.cpp
function save_schedule (line 18) | void save_schedule(const bus_schedule &s, const char * filename){
function main (line 26) | int main(int argc, char *argv[])
FILE: example/fix_six.cpp
function usage (line 7) | void usage(const char * program_name){
function main (line 12) | int main(int argc, char *argv[]){
FILE: example/log_archive.cpp
type boost (line 24) | namespace boost {
type archive (line 25) | namespace archive {
class detail::archive_serializer_map<log_archive> (line 27) | class detail::archive_serializer_map<log_archive>
class basic_xml_oarchive<log_archive> (line 28) | class basic_xml_oarchive<log_archive>
class xml_oarchive_impl<log_archive> (line 29) | class xml_oarchive_impl<log_archive>
FILE: example/log_archive.hpp
type boost (line 21) | namespace boost {
type archive (line 22) | namespace archive {
type detail (line 23) | namespace detail {
class interface_oarchive (line 24) | class interface_oarchive
class log_archive (line 33) | class log_archive :
method save_override (line 49) | void save_override(T & t){
method save_override (line 56) | void save_override(const boost::serialization::nvp< T > & t){
method save_override (line 64) | void save_override(const boost::archive::object_id_type & t){}
method save_override (line 65) | void save_override(const boost::archive::object_reference_type & t){}
method save_override (line 66) | void save_override(const boost::archive::version_type & t){}
method save_override (line 67) | void save_override(const boost::archive::class_id_type & t){}
method save_override (line 68) | void save_override(const boost::archive::class_id_optional_type & t){}
method save_override (line 69) | void save_override(const boost::archive::class_id_reference_type & t){}
method save_override (line 70) | void save_override(const boost::archive::class_name_type & t){}
method save_override (line 71) | void save_override(const boost::archive::tracking_type & t){}
method log_archive (line 73) | log_archive(std::ostream & os, unsigned int flags = 0) :
FILE: example/polymorphic_portable_binary_iarchive.cpp
type boost (line 21) | namespace boost {
type archive (line 22) | namespace archive {
class binary_iarchive_impl<
polymorphic_portable_binary_iarchive,
std::istream::char_type,
std::istream::traits_type
> (line 24) | class binary_iarchive_impl<
class detail::archive_pointer_iserializer<
polymorphic_portable_binary_iarchive
> (line 29) | class detail::archive_pointer_iserializer<
FILE: example/polymorphic_portable_binary_oarchive.cpp
type boost (line 21) | namespace boost {
type archive (line 22) | namespace archive {
class binary_oarchive_impl<
polymorphic_portable_binary_oarchive,
std::ostream::char_type,
std::ostream::traits_type
> (line 25) | class binary_oarchive_impl<
class detail::archive_pointer_oserializer<
polymorphic_portable_binary_oarchive
> (line 30) | class detail::archive_pointer_oserializer<
FILE: example/portable_binary_archive.hpp
type portable_binary_archive_flags (line 26) | enum portable_binary_archive_flags {
function reverse_bytes (line 35) | inline void
FILE: example/portable_binary_iarchive.cpp
type boost (line 117) | namespace boost {
type archive (line 118) | namespace archive {
type detail (line 120) | namespace detail {
class archive_serializer_map<portable_binary_iarchive> (line 121) | class archive_serializer_map<portable_binary_iarchive>
class basic_binary_iprimitive<
portable_binary_iarchive,
std::istream::char_type,
std::istream::traits_type
> (line 124) | class basic_binary_iprimitive<
FILE: example/portable_binary_iarchive.hpp
class portable_binary_iarchive_exception (line 37) | class portable_binary_iarchive_exception :
type exception_code (line 41) | enum exception_code {
method portable_binary_iarchive_exception (line 44) | portable_binary_iarchive_exception(exception_code c = incompatible_int...
class portable_binary_iarchive (line 68) | class portable_binary_iarchive :
method load (line 102) | void load(T & t){
method load (line 109) | void load(boost::serialization::item_version_type & t){
method load (line 115) | void load(boost::archive::version_type & t){
method load (line 121) | void load(boost::archive::class_id_type & t){
method load (line 127) | void load(std::string & t){
method load (line 131) | void load(std::wstring & t){
method load (line 135) | void load(float & t){
method load (line 140) | void load(double & t){
method load (line 145) | void load(char & t){
method load (line 148) | void load(unsigned char & t){
method load_override (line 154) | void load_override(T & t){
method load_override (line 159) | void load_override(boost::archive::class_id_optional_type &){}
method portable_binary_iarchive (line 163) | portable_binary_iarchive(std::istream & is, unsigned flags = 0) :
method portable_binary_iarchive (line 174) | portable_binary_iarchive(
FILE: example/portable_binary_oarchive.cpp
type boost (line 84) | namespace boost {
type archive (line 85) | namespace archive {
type detail (line 87) | namespace detail {
class archive_serializer_map<portable_binary_oarchive> (line 88) | class archive_serializer_map<portable_binary_oarchive>
class basic_binary_oprimitive<
portable_binary_oarchive,
std::ostream::char_type,
std::ostream::traits_type
> (line 91) | class basic_binary_oprimitive<
FILE: example/portable_binary_oarchive.hpp
class portable_binary_oarchive_exception (line 36) | class portable_binary_oarchive_exception :
method portable_binary_oarchive_exception (line 43) | portable_binary_oarchive_exception(exception_code c = invalid_flags )
class portable_binary_oarchive (line 63) | class portable_binary_oarchive :
method save (line 101) | void save(const T & t){
method save (line 104) | void save(const std::string & t){
method save (line 108) | void save(const std::wstring & t){
method save (line 112) | void save(const float & t){
method save (line 117) | void save(const double & t){
method save (line 122) | void save(const char & t){
method save (line 125) | void save(const unsigned char & t){
method save_override (line 134) | void save_override(T & t){
method save_override (line 138) | void save_override(const boost::archive::class_name_type & t){
method save_override (line 143) | void save_override(
method portable_binary_oarchive (line 149) | portable_binary_oarchive(std::ostream & os, unsigned flags = 0) :
method portable_binary_oarchive (line 160) | portable_binary_oarchive(
FILE: example/simple_log_archive.hpp
type std (line 24) | namespace std{
class simple_log_archive (line 43) | class simple_log_archive {
type save_enum_type (line 48) | struct save_enum_type {
method invoke (line 50) | static void invoke(Archive &ar, const T &t){
type save_primitive (line 55) | struct save_primitive {
method invoke (line 57) | static void invoke(Archive & ar, const T & t){
type save_only (line 62) | struct save_only {
method invoke (line 64) | static void invoke(Archive & ar, const T & t){
method save (line 75) | void save(const T &t){
method save (line 93) | void save(const std::wstring &ws){
method register_type (line 107) | void register_type(const T * = NULL){}
method get_library_version (line 109) | unsigned int get_library_version(){
method save_binary (line 113) | void
method simple_log_archive (line 120) | simple_log_archive & operator<<(T const & t){
method simple_log_archive (line 126) | simple_log_archive & operator<<(T * const t){
method simple_log_archive (line 135) | simple_log_archive & operator<<(const T (&t)[N]){
method simple_log_archive (line 142) | simple_log_archive & operator<<(const boost::serialization::nvp< T > &...
method simple_log_archive (line 156) | simple_log_archive & operator&(const T & t){
method simple_log_archive (line 161) | simple_log_archive(std::ostream & os) :
FILE: include/boost/archive/archive_exception.hpp
type boost (line 36) | namespace boost {
type archive (line 37) | namespace archive {
class BOOST_SYMBOL_VISIBLE (line 42) | class BOOST_SYMBOL_VISIBLE
FILE: include/boost/archive/basic_archive.hpp
type boost (line 28) | namespace boost {
type archive (line 29) | namespace archive {
class version_type (line 42) | class version_type {
method version_type (line 48) | version_type(): t(0) {}
method version_type (line 49) | explicit version_type(const unsigned int & t_) : t(t_){
method version_type (line 52) | version_type(const version_type & t_) :
method version_type (line 55) | version_type & operator=(const version_type & rhs){
class class_id_type (line 75) | class class_id_type {
method class_id_type (line 81) | class_id_type() : t(0) {}
method class_id_type (line 82) | explicit class_id_type(const int t_) : t(t_){
method class_id_type (line 85) | explicit class_id_type(const std::size_t t_) : t(t_){
method class_id_type (line 88) | class_id_type(const class_id_type & t_) :
method class_id_type (line 91) | class_id_type & operator=(const class_id_type & rhs){
class object_id_type (line 114) | class object_id_type {
method object_id_type (line 119) | object_id_type(): t(0) {}
method object_id_type (line 122) | explicit object_id_type(const std::size_t & t_) : t(static_cast<ba...
method object_id_type (line 127) | object_id_type(const object_id_type & t_) :
method object_id_type (line 130) | object_id_type & operator=(const object_id_type & rhs){
type tracking_type (line 154) | struct tracking_type {
method tracking_type (line 156) | explicit tracking_type(const bool t_ = false)
method tracking_type (line 159) | tracking_type(const tracking_type & t_)
method tracking_type (line 168) | tracking_type & operator=(const bool t_){
method tracking_type (line 178) | tracking_type & operator=(const tracking_type & rhs){
type class_name_type (line 184) | struct class_name_type :
method size (line 194) | std::size_t size() const {
method class_name_type (line 197) | explicit class_name_type(const char *key_)
method class_name_type (line 199) | explicit class_name_type(char *key_)
method class_name_type (line 201) | class_name_type & operator=(const class_name_type & rhs){
type archive_flags (line 207) | enum archive_flags {
FILE: include/boost/archive/basic_binary_iarchive.hpp
type boost (line 44) | namespace boost {
type archive (line 45) | namespace archive {
type detail (line 47) | namespace detail {
class interface_iarchive (line 48) | class interface_iarchive
class BOOST_SYMBOL_VISIBLE (line 54) | class BOOST_SYMBOL_VISIBLE
function load_override (line 75) | void load_override(T & t){
function load_override (line 89) | void load_override(class_id_optional_type & /* t */){}
function load_override (line 91) | void load_override(tracking_type & t, int /*version*/){
function load_override (line 104) | void load_override(class_id_type & t){
function load_override (line 133) | void load_override(class_id_reference_type & t){
function load_override (line 137) | void load_override(version_type & t){
function load_override (line 168) | void load_override(boost::serialization::item_version_type & t){
function load_override (line 187) | void load_override(serialization::collection_size_type & t){
function basic_binary_iarchive (line 203) | basic_binary_iarchive(unsigned int flags) :
FILE: include/boost/archive/basic_binary_iprimitive.hpp
type std (line 40) | namespace std{
type archive (line 61) | namespace archive {
function basic_binary_iprimitive (line 66) | class BOOST_SYMBOL_VISIBLE basic_binary_iprimitive {
FILE: include/boost/archive/basic_binary_oarchive.hpp
type boost (line 45) | namespace boost {
type archive (line 46) | namespace archive {
type detail (line 48) | namespace detail {
class interface_oarchive (line 49) | class interface_oarchive
class BOOST_SYMBOL_VISIBLE (line 61) | class BOOST_SYMBOL_VISIBLE
function save_override (line 79) | void save_override(const T & t){
function save_override (line 94) | void save_override(const class_id_optional_type & /* t */){}
function save_override (line 98) | void save_override(const boost::archive::version_type & t){
function save_override (line 113) | void save_override(const boost::serialization::item_version_type & t){
function save_override (line 129) | void save_override(class_id_type & t){
function save_override (line 144) | void save_override(class_id_reference_type & t){
function save_override (line 151) | void save_override(const class_name_type & t){
function save_override (line 157) | void save_override(const serialization::collection_size_type & t){
function basic_binary_oarchive (line 171) | basic_binary_oarchive(unsigned int flags) :
FILE: include/boost/archive/basic_binary_oprimitive.hpp
type std (line 35) | namespace std{
type boost (line 55) | namespace boost {
type archive (line 56) | namespace archive {
function basic_binary_oprimitive (line 62) | class BOOST_SYMBOL_VISIBLE basic_binary_oprimitive {
FILE: include/boost/archive/basic_streambuf_locale_saver.hpp
type boost (line 41) | namespace boost{
type archive (line 42) | namespace archive{
class basic_streambuf_locale_saver (line 45) | class basic_streambuf_locale_saver :
method basic_streambuf_locale_saver (line 49) | explicit basic_streambuf_locale_saver(std::basic_streambuf<Ch, Tr>...
class basic_istream_locale_saver (line 63) | class basic_istream_locale_saver :
method basic_istream_locale_saver (line 67) | explicit basic_istream_locale_saver(std::basic_istream<Ch, Tr> &s) :
class basic_ostream_locale_saver (line 82) | class basic_ostream_locale_saver :
method basic_ostream_locale_saver (line 86) | explicit basic_ostream_locale_saver(std::basic_ostream<Ch, Tr> &s) :
FILE: include/boost/archive/basic_text_iarchive.hpp
type boost (line 39) | namespace boost {
type archive (line 40) | namespace archive {
type detail (line 42) | namespace detail {
class interface_iarchive (line 43) | class interface_iarchive
class BOOST_SYMBOL_VISIBLE (line 49) | class BOOST_SYMBOL_VISIBLE
function load_override (line 69) | void load_override(T & t){
function load_override (line 73) | void load_override(class_id_optional_type & /*t*/){}
function basic_text_iarchive (line 81) | basic_text_iarchive(unsigned int flags) :
FILE: include/boost/archive/basic_text_iprimitive.hpp
type std (line 32) | namespace std{
type boost (line 53) | namespace boost {
type archive (line 54) | namespace archive {
function basic_text_iprimitive (line 64) | class BOOST_SYMBOL_VISIBLE basic_text_iprimitive {
FILE: include/boost/archive/basic_text_oarchive.hpp
type boost (line 39) | namespace boost {
type archive (line 40) | namespace archive {
type detail (line 42) | namespace detail {
class interface_oarchive (line 43) | class interface_oarchive
class BOOST_SYMBOL_VISIBLE (line 49) | class BOOST_SYMBOL_VISIBLE
function newline (line 74) | void newline(){
function save_override (line 82) | void save_override(T & t){
function save_override (line 87) | void save_override(const object_id_type & t){
function save_override (line 93) | void save_override(const class_id_optional_type & /* t */){}
function save_override (line 95) | void save_override(const class_name_type & t){
function basic_text_oarchive (line 103) | basic_text_oarchive(unsigned int flags) :
FILE: include/boost/archive/basic_text_oprimitive.hpp
type std (line 41) | namespace std{
type boost (line 60) | namespace boost {
type archive (line 61) | namespace archive {
function basic_text_oprimitive (line 66) | class BOOST_SYMBOL_VISIBLE basic_text_oprimitive
function put (line 198) | void put(const char * s){
FILE: include/boost/archive/basic_xml_archive.hpp
type boost (line 24) | namespace boost {
type archive (line 25) | namespace archive {
FILE: include/boost/archive/basic_xml_iarchive.hpp
type boost (line 33) | namespace boost {
type archive (line 34) | namespace archive {
type detail (line 36) | namespace detail {
class interface_iarchive (line 37) | class interface_iarchive
class BOOST_SYMBOL_VISIBLE (line 43) | class BOOST_SYMBOL_VISIBLE
function load_override (line 61) | void load_override(T & t)
function load_override (line 74) | void load_override(
function load_override (line 92) | void load_override(class_id_optional_type & /* t */){}
FILE: include/boost/archive/basic_xml_oarchive.hpp
type boost (line 33) | namespace boost {
type archive (line 34) | namespace archive {
type detail (line 36) | namespace detail {
class interface_oarchive (line 37) | class interface_oarchive
class BOOST_SYMBOL_VISIBLE (line 43) | class BOOST_SYMBOL_VISIBLE
function save_override (line 84) | void save_override(T & t)
function save_override (line 96) | void save_override(
FILE: include/boost/archive/binary_iarchive.hpp
type boost (line 28) | namespace boost {
type archive (line 29) | namespace archive {
class BOOST_SYMBOL_VISIBLE (line 34) | class BOOST_SYMBOL_VISIBLE
function binary_iarchive (line 48) | binary_iarchive(std::streambuf & bsb, unsigned int flags = 0) :
FILE: include/boost/archive/binary_iarchive_impl.hpp
type boost (line 28) | namespace boost {
type archive (line 29) | namespace archive {
type detail (line 31) | namespace detail {
class interface_iarchive (line 32) | class interface_iarchive
class BOOST_SYMBOL_VISIBLE (line 36) | class BOOST_SYMBOL_VISIBLE
function load_override (line 57) | void load_override(T & t){
function init (line 60) | void init(unsigned int flags){
function binary_iarchive_impl (line 72) | binary_iarchive_impl(
function binary_iarchive_impl (line 82) | binary_iarchive_impl(
FILE: include/boost/archive/binary_oarchive.hpp
type boost (line 29) | namespace boost {
type archive (line 30) | namespace archive {
class BOOST_SYMBOL_VISIBLE (line 35) | class BOOST_SYMBOL_VISIBLE
function binary_oarchive (line 48) | binary_oarchive(std::streambuf & bsb, unsigned int flags = 0) :
FILE: include/boost/archive/binary_oarchive_impl.hpp
type boost (line 29) | namespace boost {
type archive (line 30) | namespace archive {
type detail (line 32) | namespace detail {
class interface_oarchive (line 33) | class interface_oarchive
class BOOST_SYMBOL_VISIBLE (line 37) | class BOOST_SYMBOL_VISIBLE
function save_override (line 58) | void save_override(T & t){
function init (line 61) | void init(unsigned int flags) {
function binary_oarchive_impl (line 73) | binary_oarchive_impl(
function binary_oarchive_impl (line 83) | binary_oarchive_impl(
FILE: include/boost/archive/binary_wiarchive.hpp
type boost (line 28) | namespace boost {
type archive (line 29) | namespace archive {
class binary_wiarchive (line 31) | class binary_wiarchive :
method binary_wiarchive (line 37) | binary_wiarchive(std::wistream & is, unsigned int flags = 0) :
method binary_wiarchive (line 42) | binary_wiarchive(std::wstreambuf & bsb, unsigned int flags = 0) :
FILE: include/boost/archive/binary_woarchive.hpp
type boost (line 28) | namespace boost {
type archive (line 29) | namespace archive {
class binary_woarchive (line 34) | class binary_woarchive :
method binary_woarchive (line 40) | binary_woarchive(std::wostream & os, unsigned int flags = 0) :
method binary_woarchive (line 45) | binary_woarchive(std::wstreambuf & bsb, unsigned int flags = 0) :
FILE: include/boost/archive/codecvt_null.hpp
type std (line 30) | namespace std {
type boost (line 46) | namespace boost {
type archive (line 47) | namespace archive {
class codecvt_null (line 50) | class codecvt_null
class codecvt_null<char> (line 53) | class codecvt_null<char> : public std::codecvt<char, char, std::mbst...
method BOOST_NOEXCEPT_OR_NOTHROW (line 55) | BOOST_NOEXCEPT_OR_NOTHROW BOOST_OVERRIDE {
method codecvt_null (line 59) | explicit codecvt_null(std::size_t no_locale_manage = 0) :
class BOOST_SYMBOL_VISIBLE (line 66) | class BOOST_SYMBOL_VISIBLE
function BOOST_SYMBOL_EXPORT (line 91) | BOOST_SYMBOL_EXPORT int do_encoding( ) const BOOST_NOEXCEPT_OR_NOTHR...
function BOOST_SYMBOL_EXPORT (line 95) | BOOST_SYMBOL_EXPORT bool do_always_noconv() const BOOST_NOEXCEPT_OR_...
function BOOST_SYMBOL_EXPORT (line 99) | BOOST_SYMBOL_EXPORT int do_max_length( ) const BOOST_NOEXCEPT_OR_NOT...
FILE: include/boost/archive/detail/archive_serializer_map.hpp
type boost (line 27) | namespace boost {
type serialization (line 29) | namespace serialization {
class extended_type_info (line 30) | class extended_type_info
type archive (line 33) | namespace archive {
type detail (line 34) | namespace detail {
class basic_serializer (line 36) | class basic_serializer
function archive_serializer_map (line 39) | class BOOST_SYMBOL_VISIBLE archive_serializer_map {
FILE: include/boost/archive/detail/basic_iarchive.hpp
type boost (line 31) | namespace boost {
type serialization (line 32) | namespace serialization {
class extended_type_info (line 33) | class extended_type_info
type archive (line 36) | namespace archive {
type detail (line 37) | namespace detail {
class basic_iarchive_impl (line 39) | class basic_iarchive_impl
class basic_iserializer (line 40) | class basic_iserializer
class basic_pointer_iserializer (line 41) | class basic_pointer_iserializer
class BOOST_SYMBOL_VISIBLE (line 45) | class BOOST_SYMBOL_VISIBLE
FILE: include/boost/archive/detail/basic_iserializer.hpp
type boost (line 33) | namespace boost {
type serialization (line 34) | namespace serialization {
class extended_type_info (line 35) | class extended_type_info
type archive (line 39) | namespace archive {
type detail (line 40) | namespace detail {
class basic_iarchive (line 42) | class basic_iarchive
class basic_pointer_iserializer (line 43) | class basic_pointer_iserializer
function basic_iserializer (line 45) | class BOOST_SYMBOL_VISIBLE basic_iserializer :
function set_bpis (line 59) | void set_bpis(basic_pointer_iserializer *bpis){
function basic_pointer_iserializer (line 62) | const basic_pointer_iserializer * get_bpis_ptr() const {
FILE: include/boost/archive/detail/basic_oarchive.hpp
type boost (line 29) | namespace boost {
type serialization (line 30) | namespace serialization {
class extended_type_info (line 31) | class extended_type_info
type archive (line 34) | namespace archive {
type detail (line 35) | namespace detail {
class basic_oarchive_impl (line 37) | class basic_oarchive_impl
class basic_oserializer (line 38) | class basic_oserializer
class basic_pointer_oserializer (line 39) | class basic_pointer_oserializer
class BOOST_SYMBOL_VISIBLE (line 43) | class BOOST_SYMBOL_VISIBLE
function save_null_pointer (line 79) | void save_null_pointer(){
FILE: include/boost/archive/detail/basic_oserializer.hpp
type boost (line 34) | namespace boost {
type serialization (line 35) | namespace serialization {
class extended_type_info (line 36) | class extended_type_info
type archive (line 40) | namespace archive {
type detail (line 41) | namespace detail {
class basic_oarchive (line 43) | class basic_oarchive
class basic_pointer_oserializer (line 44) | class basic_pointer_oserializer
function basic_oserializer (line 46) | class BOOST_SYMBOL_VISIBLE basic_oserializer :
function set_bpos (line 60) | void set_bpos(basic_pointer_oserializer *bpos){
function basic_pointer_oserializer (line 63) | const basic_pointer_oserializer * get_bpos() const {
FILE: include/boost/archive/detail/basic_pointer_iserializer.hpp
type boost (line 31) | namespace boost {
type serialization (line 32) | namespace serialization {
class extended_type_info (line 33) | class extended_type_info
type archive (line 37) | namespace archive {
type detail (line 38) | namespace detail {
class basic_iarchive (line 40) | class basic_iarchive
class basic_iserializer (line 41) | class basic_iserializer
function basic_pointer_iserializer (line 43) | class BOOST_SYMBOL_VISIBLE basic_pointer_iserializer
FILE: include/boost/archive/detail/basic_pointer_oserializer.hpp
type boost (line 31) | namespace boost {
type serialization (line 32) | namespace serialization {
class extended_type_info (line 33) | class extended_type_info
type archive (line 36) | namespace archive {
type detail (line 37) | namespace detail {
class basic_oarchive (line 39) | class basic_oarchive
class basic_oserializer (line 40) | class basic_oserializer
function basic_pointer_oserializer (line 42) | class BOOST_SYMBOL_VISIBLE basic_pointer_oserializer :
FILE: include/boost/archive/detail/basic_serializer.hpp
type boost (line 31) | namespace boost {
type archive (line 32) | namespace archive {
type detail (line 33) | namespace detail {
class basic_serializer (line 35) | class basic_serializer :
method basic_serializer (line 40) | explicit basic_serializer(
class basic_serializer_arg (line 62) | class basic_serializer_arg : public basic_serializer {
method basic_serializer_arg (line 64) | basic_serializer_arg(const serialization::extended_type_info & e...
FILE: include/boost/archive/detail/basic_serializer_map.hpp
type boost (line 27) | namespace boost {
type serialization (line 28) | namespace serialization {
class extended_type_info (line 29) | class extended_type_info
type archive (line 32) | namespace archive {
type detail (line 33) | namespace detail {
class basic_serializer (line 35) | class basic_serializer
class BOOST_SYMBOL_VISIBLE (line 37) | class BOOST_SYMBOL_VISIBLE
type type_info_pointer_compare (line 41) | struct type_info_pointer_compare
FILE: include/boost/archive/detail/check.hpp
type boost (line 46) | namespace boost {
type archive (line 47) | namespace archive {
type detail (line 48) | namespace detail {
function check_object_level (line 53) | inline void check_object_level(){
function check_object_versioning (line 66) | inline void check_object_versioning(){
function check_object_tracking (line 84) | inline void check_object_tracking(){
function check_pointer_level (line 106) | inline void check_pointer_level(){
function check_pointer_tracking (line 143) | void inline check_pointer_tracking(){
function check_const_loading (line 154) | inline void check_const_loading(){
FILE: include/boost/archive/detail/common_iarchive.hpp
type boost (line 30) | namespace boost {
type archive (line 31) | namespace archive {
type detail (line 32) | namespace detail {
class extended_type_info (line 34) | class extended_type_info
class BOOST_SYMBOL_VISIBLE (line 38) | class BOOST_SYMBOL_VISIBLE
function vload (line 48) | void vload(object_id_type & t) BOOST_OVERRIDE {
function vload (line 51) | void vload(class_id_type & t) BOOST_OVERRIDE {
function vload (line 54) | void vload(class_id_optional_type & t) BOOST_OVERRIDE {
function vload (line 57) | void vload(tracking_type & t) BOOST_OVERRIDE {
function vload (line 60) | void vload(class_name_type &s) BOOST_OVERRIDE {
function load_override (line 63) | protected:
function load_start (line 71) | void load_start(const char * /*name*/){}
function load_end (line 72) | void load_end(const char * /*name*/){}
function common_iarchive (line 74) | common_iarchive(unsigned int flags = 0) :
FILE: include/boost/archive/detail/common_oarchive.hpp
type boost (line 29) | namespace boost {
type archive (line 30) | namespace archive {
type detail (line 31) | namespace detail {
class BOOST_SYMBOL_VISIBLE (line 36) | class BOOST_SYMBOL_VISIBLE
function vsave (line 46) | void vsave(const object_id_type t) BOOST_OVERRIDE {
function vsave (line 49) | void vsave(const object_reference_type t) BOOST_OVERRIDE {
function vsave (line 52) | void vsave(const class_id_type t) BOOST_OVERRIDE {
function vsave (line 55) | void vsave(const class_id_reference_type t) BOOST_OVERRIDE {
function vsave (line 58) | void vsave(const class_id_optional_type t) BOOST_OVERRIDE {
function vsave (line 61) | void vsave(const class_name_type & t) BOOST_OVERRIDE {
function vsave (line 64) | void vsave(const tracking_type t) BOOST_OVERRIDE {
function save_override (line 67) | protected:
function save_start (line 73) | void save_start(const char * /*name*/){}
function save_end (line 74) | void save_end(const char * /*name*/){}
function common_oarchive (line 75) | common_oarchive(unsigned int flags = 0) :
FILE: include/boost/archive/detail/helper_collection.hpp
type boost (line 30) | namespace boost {
type archive (line 32) | namespace archive {
type detail (line 33) | namespace detail {
class helper_collection (line 35) | class helper_collection
method make_helper_ptr (line 48) | boost::shared_ptr<void> make_helper_ptr(){
type predicate (line 57) | struct predicate {
method BOOST_DEFAULTED_FUNCTION (line 58) | BOOST_DEFAULTED_FUNCTION(predicate(const predicate& rhs), : m_...
method predicate (line 65) | predicate(const void * ti) :
method helper_collection (line 70) | helper_collection(){}
method Helper (line 74) | Helper& find_helper(void * const id = 0) {
FILE: include/boost/archive/detail/interface_iarchive.hpp
type boost (line 27) | namespace boost {
type archive (line 28) | namespace archive {
type detail (line 29) | namespace detail {
class basic_pointer_iserializer (line 31) | class basic_pointer_iserializer
class interface_iarchive (line 34) | class interface_iarchive
method interface_iarchive (line 37) | interface_iarchive() {}
method Archive (line 45) | Archive * This(){
method basic_pointer_iserializer (line 50) | const basic_pointer_iserializer *
method Helper (line 60) | Helper &
method Archive (line 67) | Archive & operator>>(T & t){
method Archive (line 74) | Archive & operator&(T & t){
FILE: include/boost/archive/detail/interface_oarchive.hpp
type boost (line 29) | namespace boost {
type archive (line 30) | namespace archive {
type detail (line 31) | namespace detail {
class basic_pointer_oserializer (line 33) | class basic_pointer_oserializer
class interface_oarchive (line 36) | class interface_oarchive
method interface_oarchive (line 39) | interface_oarchive() {}
method Archive (line 47) | Archive * This(){
method basic_pointer_oserializer (line 52) | const basic_pointer_oserializer *
method Helper (line 63) | Helper &
method Archive (line 70) | Archive & operator<<(const T & t){
method Archive (line 77) | Archive & operator&(const T & t){
FILE: include/boost/archive/detail/iserializer.hpp
type std (line 33) | namespace std{
type boost (line 96) | namespace boost {
type serialization (line 98) | namespace serialization {
class extended_type_info (line 99) | class extended_type_info
type archive (line 102) | namespace archive {
class load_access (line 106) | class load_access {
method load_primitive (line 109) | static void load_primitive(Archive &ar, T &t){
type detail (line 114) | namespace detail {
class iserializer (line 122) | class iserializer : public basic_iserializer
method destroy (line 125) | void destroy(/*const*/ void *address) const BOOST_OVERRIDE {
method iserializer (line 129) | explicit iserializer() :
method class_info (line 142) | bool class_info() const BOOST_OVERRIDE {
method tracking (line 146) | bool tracking(const unsigned int /* flags */) const BOOST_OVERRI...
method version_type (line 153) | version_type version() const BOOST_OVERRIDE {
method is_polymorphic (line 156) | bool is_polymorphic() const BOOST_OVERRIDE {
function BOOST_DLLEXPORT (line 167) | BOOST_DLLEXPORT void iserializer<Archive, T>::load_object_data(
type heap_allocation (line 211) | struct heap_allocation {
method T (line 215) | static T * invoke_new(){
method invoke_delete (line 218) | static void invoke_delete(T *t){
type has_new_operator (line 225) | struct has_new_operator {
method T (line 226) | static T * invoke_new() {
method invoke_delete (line 229) | static void invoke_delete(T * t) {
type doesnt_have_new_operator (line 241) | struct doesnt_have_new_operator {
method T (line 242) | static T* invoke_new() {
method invoke_delete (line 245) | static void invoke_delete(T * t) {
method T (line 250) | static T * invoke_new() {
method invoke_delete (line 259) | static void invoke_delete(T *t) {
method heap_allocation (line 269) | explicit heap_allocation(){
method T (line 276) | T* get() const {
method T (line 280) | T* release() {
class pointer_iserializer (line 290) | class pointer_iserializer :
method basic_iserializer (line 300) | const basic_iserializer & get_basic_serializer() const BOOST_OVE...
function BOOST_DLLEXPORT (line 323) | BOOST_DLLEXPORT void pointer_iserializer<Archive, T>::load_object_...
function BOOST_CATCH (line 348) | BOOST_CATCH(...){
type load_non_pointer_type (line 380) | struct load_non_pointer_type {
type load_primitive (line 383) | struct load_primitive {
method invoke (line 385) | static void invoke(Archive & ar, T & t){
type load_only (line 391) | struct load_only {
method invoke (line 393) | static void invoke(Archive & ar, const T & t){
type load_standard (line 407) | struct load_standard {
method invoke (line 409) | static void invoke(Archive &ar, const T & t){
type load_conditional (line 420) | struct load_conditional {
method invoke (line 422) | static void invoke(Archive &ar, T &t){
method invoke (line 431) | static void invoke(Archive & ar, T &t){
type load_pointer_type (line 468) | struct load_pointer_type {
type abstract (line 469) | struct abstract
method basic_pointer_iserializer (line 472) | static const basic_pointer_iserializer * register_type(Archive &...
type non_abstract (line 479) | struct non_abstract
method basic_pointer_iserializer (line 482) | static const basic_pointer_iserializer * register_type(Archive &...
method basic_pointer_iserializer (line 488) | static const basic_pointer_iserializer * register_type(Archive &ar...
method T (line 503) | static T * pointer_tweak(
method check_load (line 527) | static void check_load(T * const /* t */){
method basic_pointer_iserializer (line 532) | static const basic_pointer_iserializer *
method invoke (line 540) | static void invoke(Archive & ar, Tptr & t){
type load_enum_type (line 560) | struct load_enum_type {
method invoke (line 562) | static void invoke(Archive &ar, T &t){
type load_array_type (line 571) | struct load_array_type {
method invoke (line 573) | static void invoke(Archive &ar, T &t){
function load (line 606) | inline void load(Archive & ar, T &t){
FILE: include/boost/archive/detail/oserializer.hpp
type boost (line 76) | namespace boost {
type serialization (line 78) | namespace serialization {
class extended_type_info (line 79) | class extended_type_info
type archive (line 82) | namespace archive {
class save_access (line 86) | class save_access {
method end_preamble (line 89) | static void end_preamble(Archive & ar){
method save_primitive (line 93) | static void save_primitive(Archive & ar, const T & t){
type detail (line 99) | namespace detail {
class oserializer (line 107) | class oserializer : public basic_oserializer
method class_info (line 125) | bool class_info() const BOOST_OVERRIDE {
method tracking (line 129) | bool tracking(const unsigned int /* flags */) const BOOST_OVERRI...
method version_type (line 134) | version_type version() const BOOST_OVERRIDE {
method is_polymorphic (line 137) | bool is_polymorphic() const BOOST_OVERRIDE {
function BOOST_DLLEXPORT (line 148) | BOOST_DLLEXPORT void oserializer<Archive, T>::save_object_data(
class pointer_oserializer (line 168) | class pointer_oserializer :
method basic_oserializer (line 172) | const basic_oserializer &
function BOOST_DLLEXPORT (line 192) | BOOST_DLLEXPORT void pointer_oserializer<Archive, T>::save_object_...
type save_non_pointer_type (line 233) | struct save_non_pointer_type {
type save_primitive (line 236) | struct save_primitive {
method invoke (line 238) | static void invoke(Archive & ar, const T & t){
type save_only (line 243) | struct save_only {
method invoke (line 245) | static void invoke(Archive & ar, const T & t){
type save_standard (line 257) | struct save_standard {
method invoke (line 259) | static void invoke(Archive &ar, const T & t){
type save_conditional (line 273) | struct save_conditional {
method invoke (line 275) | static void invoke(Archive &ar, const T &t){
method invoke (line 285) | static void invoke(Archive & ar, const T & t){
method invoke (line 320) | static void invoke(Archive & ar, T & t){
type save_pointer_type (line 328) | struct save_pointer_type {
type abstract (line 329) | struct abstract
method basic_pointer_oserializer (line 332) | static const basic_pointer_oserializer * register_type(Archive...
type non_abstract (line 339) | struct non_abstract
method basic_pointer_oserializer (line 342) | static const basic_pointer_oserializer * register_type(Archive...
method basic_pointer_oserializer (line 348) | static const basic_pointer_oserializer * register_type(Archive &...
type non_polymorphic (line 362) | struct non_polymorphic
method save (line 365) | static void save(
type polymorphic (line 378) | struct polymorphic
method save (line 381) | static void save(
method save (line 458) | static void save(
method invoke (line 473) | static void invoke(Archive &ar, const TPtr t){
type save_enum_type (line 487) | struct save_enum_type
method invoke (line 490) | static void invoke(Archive &ar, const T &t){
type save_array_type (line 498) | struct save_array_type
method invoke (line 501) | static void invoke(Archive &ar, const T &t){
function save (line 526) | inline void save(Archive & ar, /*const*/ T &t){
FILE: include/boost/archive/detail/polymorphic_iarchive_route.hpp
type std (line 25) | namespace std{
type boost (line 35) | namespace boost {
type serialization (line 36) | namespace serialization {
class extended_type_info (line 37) | class extended_type_info
type archive (line 39) | namespace archive {
type detail (line 40) | namespace detail{
class basic_iserializer (line 42) | class basic_iserializer
class basic_pointer_iserializer (line 43) | class basic_pointer_iserializer
class polymorphic_iarchive_route (line 51) | class polymorphic_iarchive_route :
method load_object (line 59) | void load_object(
method basic_pointer_iserializer (line 65) | const basic_pointer_iserializer * load_pointer(
method set_library_version (line 74) | void set_library_version(boost::serialization::library_version_t...
method get_library_version (line 77) | boost::serialization::library_version_type get_library_version()...
method get_flags (line 80) | unsigned int get_flags() const BOOST_OVERRIDE {
method delete_created_pointers (line 83) | void delete_created_pointers() BOOST_OVERRIDE {
method reset_object_address (line 86) | void reset_object_address(
method load_binary (line 92) | void load_binary(void * t, std::size_t size) BOOST_OVERRIDE {
method load (line 96) | void load(bool & t) BOOST_OVERRIDE {
method load (line 99) | void load(char & t) BOOST_OVERRIDE {
method load (line 102) | void load(signed char & t) BOOST_OVERRIDE {
method load (line 105) | void load(unsigned char & t) BOOST_OVERRIDE {
method load (line 110) | void load(wchar_t & t) BOOST_OVERRIDE {
method load (line 115) | void load(short & t) BOOST_OVERRIDE {
method load (line 118) | void load(unsigned short & t) BOOST_OVERRIDE {
method load (line 124) | void load(unsigned int & t) BOOST_OVERRIDE {
method load (line 127) | void load(long & t) BOOST_OVERRIDE {
method load (line 130) | void load(unsigned long & t) BOOST_OVERRIDE {
method load (line 134) | void load(boost::long_long_type & t) BOOST_OVERRIDE {
method load (line 137) | void load(boost::ulong_long_type & t) BOOST_OVERRIDE {
method load (line 141) | void load(__int64 & t) BOOST_OVERRIDE {
method load (line 144) | void load(unsigned __int64 & t) BOOST_OVERRIDE {
method load (line 148) | void load(float & t) BOOST_OVERRIDE {
method load (line 151) | void load(double & t) BOOST_OVERRIDE {
method load (line 154) | void load(std::string & t) BOOST_OVERRIDE {
method load (line 158) | void load(std::wstring & t) BOOST_OVERRIDE {
method load_start (line 163) | void load_start(const char * name) BOOST_OVERRIDE {
method load_end (line 166) | void load_end(const char * name) BOOST_OVERRIDE {
method register_basic_serializer (line 169) | void register_basic_serializer(const basic_iserializer & bis) BO...
method helper_collection (line 172) | helper_collection &
method polymorphic_iarchive (line 183) | polymorphic_iarchive & operator>>(T & t){
method polymorphic_iarchive (line 188) | polymorphic_iarchive & operator&(T & t){
method basic_pointer_iserializer (line 193) | const basic_pointer_iserializer *
method polymorphic_iarchive_route (line 199) | polymorphic_iarchive_route(
FILE: include/boost/archive/detail/polymorphic_oarchive_route.hpp
type std (line 25) | namespace std{
type boost (line 35) | namespace boost {
type serialization (line 36) | namespace serialization {
class extended_type_info (line 37) | class extended_type_info
type archive (line 39) | namespace archive {
type detail (line 40) | namespace detail{
class basic_oserializer (line 42) | class basic_oserializer
class basic_pointer_oserializer (line 43) | class basic_pointer_oserializer
class polymorphic_oarchive_route (line 51) | class polymorphic_oarchive_route :
method save_object (line 59) | void save_object(
method save_pointer (line 65) | void save_pointer(
method save_null_pointer (line 71) | void save_null_pointer() BOOST_OVERRIDE {
method save (line 75) | void save(const bool t) BOOST_OVERRIDE {
method save (line 78) | void save(const char t) BOOST_OVERRIDE {
method save (line 81) | void save(const signed char t) BOOST_OVERRIDE {
method save (line 84) | void save(const unsigned char t) BOOST_OVERRIDE {
method save (line 89) | void save(const wchar_t t) BOOST_OVERRIDE {
method save (line 94) | void save(const short t) BOOST_OVERRIDE {
method save (line 97) | void save(const unsigned short t) BOOST_OVERRIDE {
method save (line 100) | void save(const int t) BOOST_OVERRIDE {
method save (line 103) | void save(const unsigned int t) BOOST_OVERRIDE {
method save (line 106) | void save(const long t) BOOST_OVERRIDE {
method save (line 109) | void save(const unsigned long t) BOOST_OVERRIDE {
method save (line 113) | void save(const boost::long_long_type t) BOOST_OVERRIDE {
method save (line 116) | void save(const boost::ulong_long_type t) BOOST_OVERRIDE {
method save (line 120) | void save(const boost::int64_t t) BOOST_OVERRIDE {
method save (line 123) | void save(const boost::uint64_t t) BOOST_OVERRIDE {
method save (line 127) | void save(const float t) BOOST_OVERRIDE {
method save (line 130) | void save(const double t) BOOST_OVERRIDE {
method save (line 133) | void save(const std::string & t) BOOST_OVERRIDE {
method save (line 137) | void save(const std::wstring & t) BOOST_OVERRIDE {
method get_library_version (line 141) | boost::serialization::library_version_type get_library_version()...
method get_flags (line 144) | unsigned int get_flags() const BOOST_OVERRIDE {
method save_binary (line 147) | void save_binary(const void * t, std::size_t size) BOOST_OVERRIDE {
method save_start (line 151) | void save_start(const char * name) BOOST_OVERRIDE {
method save_end (line 154) | void save_end(const char * name) BOOST_OVERRIDE {
method end_preamble (line 157) | void end_preamble() BOOST_OVERRIDE {
method register_basic_serializer (line 160) | void register_basic_serializer(const detail::basic_oserializer &...
method helper_collection (line 163) | helper_collection &
method polymorphic_oarchive (line 174) | polymorphic_oarchive & operator<<(T & t){
method polymorphic_oarchive (line 179) | polymorphic_oarchive & operator&(T & t){
method basic_pointer_oserializer (line 184) | const basic_pointer_oserializer *
method polymorphic_oarchive_route (line 190) | polymorphic_oarchive_route(
FILE: include/boost/archive/detail/register_archive.hpp
type boost (line 7) | namespace boost { namespace archive { namespace detail {
type archive (line 7) | namespace archive { namespace detail {
type detail (line 7) | namespace detail {
type adl_tag (line 15) | struct adl_tag {}
type ptr_serialization_support (line 18) | struct ptr_serialization_support
type _ptr_serialization_support (line 25) | struct _ptr_serialization_support
type counter (line 34) | struct counter : counter<N-1> {}
type counter<0> (line 36) | struct counter<0> {}
function instantiate_ptr_serialization (line 39) | void instantiate_ptr_serialization(Serializable* s, int, adl_tag) {
type get_counter (line 44) | struct get_counter {
function instantiate_ptr_serialization (line 53) | void instantiate_ptr_serialization(Serializable*, counter<0>) {}
function instantiate_ptr_serialization (line 73) | void instantiate_ptr_serialization(Serializable*, int, adl_tag ) {}
FILE: include/boost/archive/dinkumware.hpp
type std (line 28) | namespace std {
class back_insert_iterator<basic_string<char> > (line 131) | class back_insert_iterator<basic_string<char> > : public
method back_insert_iterator (line 138) | explicit back_insert_iterator(container_type & s)
function back_inserter (line 169) | inline back_insert_iterator<basic_string<char> > back_inserter(
class back_insert_iterator<basic_string<wchar_t> > (line 176) | class back_insert_iterator<basic_string<wchar_t> > : public
method back_insert_iterator (line 183) | explicit back_insert_iterator(container_type & s)
function back_inserter (line 214) | inline back_insert_iterator<basic_string<wchar_t> > back_inserter(
FILE: include/boost/archive/impl/basic_xml_grammar.hpp
type boost (line 60) | namespace boost {
type archive (line 61) | namespace archive {
function basic_xml_grammar (line 67) | class BOOST_SYMBOL_VISIBLE basic_xml_grammar {
FILE: include/boost/archive/iterators/base64_exception.hpp
type boost (line 25) | namespace boost {
type archive (line 26) | namespace archive {
type iterators (line 27) | namespace iterators {
class base64_exception (line 32) | class base64_exception : public std::exception
method base64_exception (line 42) | base64_exception(exception_code c = other_exception) : code(c)
FILE: include/boost/archive/iterators/base64_from_binary.hpp
type std (line 23) | namespace std{
type boost (line 31) | namespace boost {
type archive (line 32) | namespace archive {
type iterators (line 33) | namespace iterators {
type detail (line 38) | namespace detail {
type from_6_bit (line 41) | struct from_6_bit {
method CharType (line 43) | CharType operator()(CharType t) const{
class base64_from_binary (line 74) | class base64_from_binary :
method base64_from_binary (line 89) | base64_from_binary(T start) :
method base64_from_binary (line 96) | base64_from_binary(const base64_from_binary & rhs) :
FILE: include/boost/archive/iterators/binary_from_base64.hpp
type boost (line 27) | namespace boost {
type archive (line 28) | namespace archive {
type iterators (line 29) | namespace iterators {
type detail (line 34) | namespace detail {
type to_6_bit (line 37) | struct to_6_bit {
method CharType (line 39) | CharType operator()(CharType t) const{
class binary_from_base64 (line 84) | class binary_from_base64 : public
method binary_from_base64 (line 98) | binary_from_base64(T start) :
method binary_from_base64 (line 105) | binary_from_base64(const binary_from_base64 & rhs) :
FILE: include/boost/archive/iterators/dataflow.hpp
type boost (line 34) | namespace boost {
type archive (line 35) | namespace archive {
type iterators (line 36) | namespace iterators {
type tri_state (line 39) | struct tri_state {
type state_enum (line 40) | enum state_enum {
method tri_state (line 51) | tri_state & operator=(bool rhs) {
method tri_state (line 55) | tri_state(bool rhs) :
method tri_state (line 58) | tri_state(state_enum state) :
class dataflow (line 72) | class dataflow {
method tri_state (line 76) | tri_state equal(const Derived & rhs) const {
method eoi (line 83) | void eoi(bool tf){
method eoi (line 86) | bool eoi() const {
method dataflow (line 90) | dataflow(bool tf) :
method dataflow (line 93) | dataflow() : // used for iterator end
FILE: include/boost/archive/iterators/dataflow_exception.hpp
type boost (line 26) | namespace boost {
type archive (line 27) | namespace archive {
type iterators (line 28) | namespace iterators {
class dataflow_exception (line 33) | class dataflow_exception : public std::exception
method dataflow_exception (line 46) | dataflow_exception(exception_code c = other_exception) : code(c)
method BOOST_NOEXCEPT_OR_NOTHROW (line 49) | BOOST_NOEXCEPT_OR_NOTHROW BOOST_OVERRIDE
FILE: include/boost/archive/iterators/escape.hpp
type boost (line 25) | namespace boost {
type archive (line 26) | namespace archive {
type iterators (line 27) | namespace iterators {
class escape (line 33) | class escape :
method dereference_impl (line 56) | void dereference_impl() {
method reference_type (line 62) | reference_type dereference() const {
method equal (line 68) | bool equal(const this_t & rhs) const {
method increment (line 84) | void increment(){
method escape (line 101) | escape(Base base) :
FILE: include/boost/archive/iterators/insert_linebreaks.hpp
type std (line 23) | namespace std{ using ::memcpy; }
type boost (line 29) | namespace boost {
type archive (line 30) | namespace archive {
type iterators (line 31) | namespace iterators {
class insert_linebreaks (line 40) | class insert_linebreaks :
method equal (line 59) | bool equal(const insert_linebreaks<Base, N, CharType> & rhs) con...
method increment (line 67) | void increment() {
method CharType (line 75) | CharType dereference() const {
method insert_linebreaks (line 84) | insert_linebreaks(T start) :
method insert_linebreaks (line 89) | insert_linebreaks(const insert_linebreaks & rhs) :
FILE: include/boost/archive/iterators/istream_iterator.hpp
type boost (line 28) | namespace boost {
type archive (line 29) | namespace archive {
type iterators (line 30) | namespace iterators {
class istream_iterator (line 34) | class istream_iterator :
method equal (line 52) | bool equal(const this_t & rhs) const {
method Elem (line 58) | Elem dereference() const {
method increment (line 62) | void increment(){
method istream_iterator (line 71) | istream_iterator(istream_type & is) :
method istream_iterator (line 77) | istream_iterator() :
method istream_iterator (line 82) | istream_iterator(const istream_iterator<Elem> & rhs) :
FILE: include/boost/archive/iterators/mb_from_wchar.hpp
type std (line 27) | namespace std{
type boost (line 36) | namespace boost {
type archive (line 37) | namespace archive {
type iterators (line 38) | namespace iterators {
class mb_from_wchar (line 44) | class mb_from_wchar
method dereference_impl (line 65) | char dereference_impl() {
method dereference (line 73) | char dereference() const {
method equal (line 77) | bool equal(const mb_from_wchar<Base> & rhs) const {
method fill (line 87) | void fill(){
method increment (line 104) | void increment(){
method mb_from_wchar (line 124) | mb_from_wchar(T start) :
method mb_from_wchar (line 132) | mb_from_wchar(const mb_from_wchar & rhs) :
FILE: include/boost/archive/iterators/ostream_iterator.hpp
type boost (line 27) | namespace boost {
type archive (line 28) | namespace archive {
type iterators (line 29) | namespace iterators {
class ostream_iterator (line 33) | class ostream_iterator :
method ostream_iterator (line 47) | ostream_iterator & dereference() const {
method equal (line 50) | bool equal(const this_t & rhs) const {
method increment (line 53) | void increment(){}
method put_val (line 56) | void put_val(char_type e){
method this_t (line 64) | this_t & operator=(char_type c){
method ostream_iterator (line 68) | ostream_iterator(ostream_type & os) :
method ostream_iterator (line 71) | ostream_iterator() :
method ostream_iterator (line 74) | ostream_iterator(const ostream_iterator & rhs) :
FILE: include/boost/archive/iterators/remove_whitespace.hpp
type std (line 34) | namespace std{ using ::iswspace; }
type std (line 40) | namespace std{ using ::isspace; }
type remove_whitespace_predicate (line 52) | struct remove_whitespace_predicate
type remove_whitespace_predicate<char> (line 55) | struct remove_whitespace_predicate<char>
type remove_whitespace_predicate<wchar_t> (line 64) | struct remove_whitespace_predicate<wchar_t>
type boost (line 77) | namespace boost {
type archive (line 78) | namespace archive {
type iterators (line 79) | namespace iterators {
class filter_iterator (line 85) | class filter_iterator
method reference_type (line 103) | reference_type dereference_impl(){
method reference_type (line 112) | reference_type dereference() const {
method increment (line 121) | void increment(){
method filter_iterator (line 125) | filter_iterator(Base start) :
method filter_iterator (line 129) | filter_iterator(){}
class remove_whitespace (line 133) | class remove_whitespace :
method remove_whitespace (line 154) | remove_whitespace(T start) :
method remove_whitespace (line 158) | remove_whitespace(const remove_whitespace & rhs) :
FILE: include/boost/archive/iterators/transform_width.hpp
type boost (line 32) | namespace boost {
type archive (line 33) | namespace archive {
type iterators (line 34) | namespace iterators {
class transform_width (line 45) | class transform_width :
method CharType (line 68) | CharType dereference() const {
method equal_impl (line 74) | bool equal_impl(const this_t & rhs){
method equal (line 88) | bool equal(const this_t & rhs) const {
method increment (line 92) | void increment(){
method transform_width (line 111) | transform_width(T start) :
method transform_width (line 123) | transform_width(const transform_width & rhs) :
FILE: include/boost/archive/iterators/unescape.hpp
type boost (line 24) | namespace boost {
type archive (line 25) | namespace archive {
type iterators (line 26) | namespace iterators {
class unescape (line 32) | class unescape
method value_type (line 55) | value_type dereference_impl() {
method reference (line 63) | reference dereference() const {
method increment (line 70) | void increment(){
method unescape (line 78) | unescape(Base base) :
FILE: include/boost/archive/iterators/wchar_from_mb.hpp
type std (line 28) | namespace std{
type boost (line 42) | namespace boost {
type archive (line 43) | namespace archive {
type iterators (line 44) | namespace iterators {
class wchar_from_mb (line 50) | class wchar_from_mb
method wchar_t (line 72) | wchar_t dereference() const {
method increment (line 78) | void increment(){
method equal (line 88) | bool equal(this_t const & rhs) const {
type sliding_buffer (line 96) | struct sliding_buffer {
method sliding_buffer (line 102) | sliding_buffer() :
method sliding_buffer (line 108) | sliding_buffer(const sliding_buffer & rhs) :
method wchar_from_mb (line 129) | wchar_from_mb(T start) :
method wchar_from_mb (line 137) | wchar_from_mb(){}
method wchar_from_mb (line 140) | wchar_from_mb(const wchar_from_mb & rhs) :
FILE: include/boost/archive/iterators/xml_escape.hpp
type boost (line 22) | namespace boost {
type archive (line 23) | namespace archive {
type iterators (line 24) | namespace iterators {
class xml_escape (line 30) | class xml_escape
method xml_escape (line 42) | xml_escape(T start) :
method xml_escape (line 46) | xml_escape(const xml_escape & rhs) :
function wchar_t (line 87) | wchar_t xml_escape<Base>::fill(
FILE: include/boost/archive/iterators/xml_unescape.hpp
type boost (line 28) | namespace boost {
type archive (line 29) | namespace archive {
type iterators (line 30) | namespace iterators {
class xml_unescape (line 35) | class xml_unescape
method reference_type (line 43) | reference_type dereference() const {
method xml_unescape (line 58) | xml_unescape(T start) :
method xml_unescape (line 62) | xml_unescape(const xml_unescape & rhs) :
FILE: include/boost/archive/iterators/xml_unescape_exception.hpp
type boost (line 25) | namespace boost {
type archive (line 26) | namespace archive {
type iterators (line 27) | namespace iterators {
class xml_unescape_exception (line 32) | class xml_unescape_exception : public std::exception
method xml_unescape_exception (line 35) | xml_unescape_exception()
FILE: include/boost/archive/polymorphic_binary_iarchive.hpp
type boost (line 28) | namespace boost {
type archive (line 29) | namespace archive {
class BOOST_SYMBOL_VISIBLE (line 31) | class BOOST_SYMBOL_VISIBLE
FILE: include/boost/archive/polymorphic_binary_oarchive.hpp
type boost (line 23) | namespace boost {
type archive (line 24) | namespace archive {
class BOOST_SYMBOL_VISIBLE (line 26) | class BOOST_SYMBOL_VISIBLE
FILE: include/boost/archive/polymorphic_iarchive.hpp
type std (line 25) | namespace std{
type boost (line 41) | namespace boost {
type serialization (line 42) | namespace serialization {
class extended_type_info (line 43) | class extended_type_info
type archive (line 45) | namespace archive {
type detail (line 46) | namespace detail {
class basic_iarchive (line 47) | class basic_iarchive
class basic_iserializer (line 48) | class basic_iserializer
class polymorphic_iarchive (line 51) | class polymorphic_iarchive
class BOOST_SYMBOL_VISIBLE (line 53) | class BOOST_SYMBOL_VISIBLE
function load_override (line 106) | void load_override(T & t)
function load_override (line 112) | void load_override(
class BOOST_SYMBOL_VISIBLE (line 158) | class BOOST_SYMBOL_VISIBLE
type archive (line 156) | namespace archive {
type detail (line 46) | namespace detail {
class basic_iarchive (line 47) | class basic_iarchive
class basic_iserializer (line 48) | class basic_iserializer
class polymorphic_iarchive (line 51) | class polymorphic_iarchive
class BOOST_SYMBOL_VISIBLE (line 53) | class BOOST_SYMBOL_VISIBLE
function load_override (line 106) | void load_override(T & t)
function load_override (line 112) | void load_override(
class BOOST_SYMBOL_VISIBLE (line 158) | class BOOST_SYMBOL_VISIBLE
type boost (line 155) | namespace boost {
type serialization (line 42) | namespace serialization {
class extended_type_info (line 43) | class extended_type_info
type archive (line 45) | namespace archive {
type detail (line 46) | namespace detail {
class basic_iarchive (line 47) | class basic_iarchive
class basic_iserializer (line 48) | class basic_iserializer
class polymorphic_iarchive (line 51) | class polymorphic_iarchive
class BOOST_SYMBOL_VISIBLE (line 53) | class BOOST_SYMBOL_VISIBLE
function load_override (line 106) | void load_override(T & t)
function load_override (line 112) | void load_override(
class BOOST_SYMBOL_VISIBLE (line 158) | class BOOST_SYMBOL_VISIBLE
type archive (line 156) | namespace archive {
type detail (line 46) | namespace detail {
class basic_iarchive (line 47) | class basic_iarchive
class basic_iserializer (line 48) | class basic_iserializer
class polymorphic_iarchive (line 51) | class polymorphic_iarchive
class BOOST_SYMBOL_VISIBLE (line 53) | class BOOST_SYMBOL_VISIBLE
function load_override (line 106) | void load_override(T & t)
function load_override (line 112) | void load_override(
class BOOST_SYMBOL_VISIBLE (line 158) | class BOOST_SYMBOL_VISIBLE
FILE: include/boost/archive/polymorphic_oarchive.hpp
type std (line 25) | namespace std{
type boost (line 39) | namespace boost {
type serialization (line 40) | namespace serialization {
class extended_type_info (line 41) | class extended_type_info
type archive (line 43) | namespace archive {
type detail (line 44) | namespace detail {
class basic_oarchive (line 45) | class basic_oarchive
class basic_oserializer (line 46) | class basic_oserializer
class polymorphic_oarchive (line 49) | class polymorphic_oarchive
class BOOST_SYMBOL_VISIBLE (line 51) | class BOOST_SYMBOL_VISIBLE
function save_override (line 107) | void save_override(T & t)
function save_override (line 113) | void save_override(
class BOOST_SYMBOL_VISIBLE (line 139) | class BOOST_SYMBOL_VISIBLE
FILE: include/boost/archive/polymorphic_text_iarchive.hpp
type boost (line 28) | namespace boost {
type archive (line 29) | namespace archive {
class BOOST_SYMBOL_VISIBLE (line 31) | class BOOST_SYMBOL_VISIBLE
FILE: include/boost/archive/polymorphic_text_oarchive.hpp
type boost (line 23) | namespace boost {
type archive (line 24) | namespace archive {
class BOOST_SYMBOL_VISIBLE (line 26) | class BOOST_SYMBOL_VISIBLE
FILE: include/boost/archive/polymorphic_text_wiarchive.hpp
type boost (line 32) | namespace boost {
type archive (line 33) | namespace archive {
class BOOST_SYMBOL_VISIBLE (line 35) | class BOOST_SYMBOL_VISIBLE
FILE: include/boost/archive/polymorphic_text_woarchive.hpp
type boost (line 27) | namespace boost {
type archive (line 28) | namespace archive {
class BOOST_SYMBOL_VISIBLE (line 30) | class BOOST_SYMBOL_VISIBLE
FILE: include/boost/archive/polymorphic_xml_iarchive.hpp
type boost (line 28) | namespace boost {
type archive (line 29) | namespace archive {
class BOOST_SYMBOL_VISIBLE (line 31) | class BOOST_SYMBOL_VISIBLE
FILE: include/boost/archive/polymorphic_xml_oarchive.hpp
type boost (line 23) | namespace boost {
type archive (line 24) | namespace archive {
class BOOST_SYMBOL_VISIBLE (line 26) | class BOOST_SYMBOL_VISIBLE
FILE: include/boost/archive/polymorphic_xml_wiarchive.hpp
type boost (line 27) | namespace boost {
type archive (line 28) | namespace archive {
class BOOST_SYMBOL_VISIBLE (line 30) | class BOOST_SYMBOL_VISIBLE
FILE: include/boost/archive/polymorphic_xml_woarchive.hpp
type boost (line 27) | namespace boost {
type archive (line 28) | namespace archive {
class BOOST_SYMBOL_VISIBLE (line 30) | class BOOST_SYMBOL_VISIBLE
FILE: include/boost/archive/text_iarchive.hpp
type boost (line 35) | namespace boost {
type archive (line 36) | namespace archive {
type detail (line 38) | namespace detail {
class interface_iarchive (line 39) | class interface_iarchive
class BOOST_SYMBOL_VISIBLE (line 43) | class BOOST_SYMBOL_VISIBLE
function load (line 55) | void load(T & t){
function load (line 58) | void load(version_type & t){
function load (line 63) | void load(boost::serialization::item_version_type & t){
function load_override (line 81) | void load_override(T & t){
class BOOST_SYMBOL_VISIBLE (line 112) | class BOOST_SYMBOL_VISIBLE
type archive (line 110) | namespace archive {
type detail (line 38) | namespace detail {
class interface_iarchive (line 39) | class interface_iarchive
class BOOST_SYMBOL_VISIBLE (line 43) | class BOOST_SYMBOL_VISIBLE
function load (line 55) | void load(T & t){
function load (line 58) | void load(version_type & t){
function load (line 63) | void load(boost::serialization::item_version_type & t){
function load_override (line 81) | void load_override(T & t){
class BOOST_SYMBOL_VISIBLE (line 112) | class BOOST_SYMBOL_VISIBLE
type boost (line 109) | namespace boost {
type archive (line 36) | namespace archive {
type detail (line 38) | namespace detail {
class interface_iarchive (line 39) | class interface_iarchive
class BOOST_SYMBOL_VISIBLE (line 43) | class BOOST_SYMBOL_VISIBLE
function load (line 55) | void load(T & t){
function load (line 58) | void load(version_type & t){
function load (line 63) | void load(boost::serialization::item_version_type & t){
function load_override (line 81) | void load_override(T & t){
class BOOST_SYMBOL_VISIBLE (line 112) | class BOOST_SYMBOL_VISIBLE
type archive (line 110) | namespace archive {
type detail (line 38) | namespace detail {
class interface_iarchive (line 39) | class interface_iarchive
class BOOST_SYMBOL_VISIBLE (line 43) | class BOOST_SYMBOL_VISIBLE
function load (line 55) | void load(T & t){
function load (line 58) | void load(version_type & t){
function load (line 63) | void load(boost::serialization::item_version_type & t){
function load_override (line 81) | void load_override(T & t){
class BOOST_SYMBOL_VISIBLE (line 112) | class BOOST_SYMBOL_VISIBLE
FILE: include/boost/archive/text_oarchive.hpp
type std (line 24) | namespace std{
type boost (line 42) | namespace boost {
type archive (line 43) | namespace archive {
type detail (line 45) | namespace detail {
class interface_oarchive (line 46) | class interface_oarchive
class BOOST_SYMBOL_VISIBLE (line 50) | class BOOST_SYMBOL_VISIBLE
function save (line 63) | void save(const T & t){
function save (line 67) | void save(const version_type & t){
function save (line 70) | void save(const boost::serialization::item_version_type & t){
class BOOST_SYMBOL_VISIBLE (line 98) | class BOOST_SYMBOL_VISIBLE
FILE: include/boost/archive/text_wiarchive.hpp
type boost (line 39) | namespace boost {
type archive (line 40) | namespace archive {
type detail (line 42) | namespace detail {
class interface_iarchive (line 43) | class interface_iarchive
class BOOST_SYMBOL_VISIBLE (line 47) | class BOOST_SYMBOL_VISIBLE
function load (line 66) | void load(T & t){
function load (line 69) | void load(version_type & t){
function load (line 74) | void load(boost::serialization::item_version_type & t){
function load_override (line 92) | void load_override(T & t){
class BOOST_SYMBOL_VISIBLE (line 117) | class BOOST_SYMBOL_VISIBLE
type archive (line 115) | namespace archive {
type detail (line 42) | namespace detail {
class interface_iarchive (line 43) | class interface_iarchive
class BOOST_SYMBOL_VISIBLE (line 47) | class BOOST_SYMBOL_VISIBLE
function load (line 66) | void load(T & t){
function load (line 69) | void load(version_type & t){
function load (line 74) | void load(boost::serialization::item_version_type & t){
function load_override (line 92) | void load_override(T & t){
class BOOST_SYMBOL_VISIBLE (line 117) | class BOOST_SYMBOL_VISIBLE
type boost (line 114) | namespace boost {
type archive (line 40) | namespace archive {
type detail (line 42) | namespace detail {
class interface_iarchive (line 43) | class interface_iarchive
class BOOST_SYMBOL_VISIBLE (line 47) | class BOOST_SYMBOL_VISIBLE
function load (line 66) | void load(T & t){
function load (line 69) | void load(version_type & t){
function load (line 74) | void load(boost::serialization::item_version_type & t){
function load_override (line 92) | void load_override(T & t){
class BOOST_SYMBOL_VISIBLE (line 117) | class BOOST_SYMBOL_VISIBLE
type archive (line 115) | namespace archive {
type detail (line 42) | namespace detail {
class interface_iarchive (line 43) | class interface_iarchive
class BOOST_SYMBOL_VISIBLE (line 47) | class BOOST_SYMBOL_VISIBLE
function load (line 66) | void load(T & t){
function load (line 69) | void load(version_type & t){
function load (line 74) | void load(boost::serialization::item_version_type & t){
function load_override (line 92) | void load_override(T & t){
class BOOST_SYMBOL_VISIBLE (line 117) | class BOOST_SYMBOL_VISIBLE
FILE: include/boost/archive/text_woarchive.hpp
type std (line 29) | namespace std{
type boost (line 47) | namespace boost {
type archive (line 48) | namespace archive {
type detail (line 50) | namespace detail {
class interface_oarchive (line 51) | class interface_oarchive
class BOOST_SYMBOL_VISIBLE (line 55) | class BOOST_SYMBOL_VISIBLE
function save (line 76) | void save(const T & t){
function save (line 80) | void save(const version_type & t){
function save (line 83) | void save(const boost::serialization::item_version_type & t){
function text_woarchive_impl (line 98) | text_woarchive_impl(std::wostream & os, unsigned int flags) :
class BOOST_SYMBOL_VISIBLE (line 129) | class BOOST_SYMBOL_VISIBLE
FILE: include/boost/archive/tmpdir.hpp
type std (line 24) | namespace std {
type boost (line 29) | namespace boost {
type archive (line 30) | namespace archive {
FILE: include/boost/archive/wcslen.hpp
type std (line 22) | namespace std{
function wcslen (line 36) | inline std::size_t wcslen(const wchar_t * ws)
type std (line 35) | namespace std {
function wcslen (line 36) | inline std::size_t wcslen(const wchar_t * ws)
type std (line 51) | namespace std{ using ::wcslen; }
function wcslen (line 36) | inline std::size_t wcslen(const wchar_t * ws)
FILE: include/boost/archive/xml_archive_exception.hpp
type boost (line 28) | namespace boost {
type archive (line 29) | namespace archive {
class BOOST_SYMBOL_VISIBLE (line 34) | class BOOST_SYMBOL_VISIBLE
FILE: include/boost/archive/xml_iarchive.hpp
type boost (line 35) | namespace boost {
type archive (line 36) | namespace archive {
type detail (line 38) | namespace detail {
class interface_iarchive (line 39) | class interface_iarchive
class basic_xml_grammar (line 43) | class basic_xml_grammar
class BOOST_SYMBOL_VISIBLE (line 47) | class BOOST_SYMBOL_VISIBLE
function load (line 66) | void load(T & t){
function load (line 69) | void
function load (line 75) | void
function load_override (line 94) | void load_override(T & t){
class BOOST_SYMBOL_VISIBLE (line 123) | class BOOST_SYMBOL_VISIBLE
type archive (line 121) | namespace archive {
type detail (line 38) | namespace detail {
class interface_iarchive (line 39) | class interface_iarchive
class basic_xml_grammar (line 43) | class basic_xml_grammar
class BOOST_SYMBOL_VISIBLE (line 47) | class BOOST_SYMBOL_VISIBLE
function load (line 66) | void load(T & t){
function load (line 69) | void
function load (line 75) | void
function load_override (line 94) | void load_override(T & t){
class BOOST_SYMBOL_VISIBLE (line 123) | class BOOST_SYMBOL_VISIBLE
type boost (line 120) | namespace boost {
type archive (line 36) | namespace archive {
type detail (line 38) | namespace detail {
class interface_iarchive (line 39) | class interface_iarchive
class basic_xml_grammar (line 43) | class basic_xml_grammar
class BOOST_SYMBOL_VISIBLE (line 47) | class BOOST_SYMBOL_VISIBLE
function load (line 66) | void load(T & t){
function load (line 69) | void
function load (line 75) | void
function load_override (line 94) | void load_override(T & t){
class BOOST_SYMBOL_VISIBLE (line 123) | class BOOST_SYMBOL_VISIBLE
type archive (line 121) | namespace archive {
type detail (line 38) | namespace detail {
class interface_iarchive (line 39) | class interface_iarchive
class basic_xml_grammar (line 43) | class basic_xml_grammar
class BOOST_SYMBOL_VISIBLE (line 47) | class BOOST_SYMBOL_VISIBLE
function load (line 66) | void load(T & t){
function load (line 69) | void
function load (line 75) | void
function load_override (line 94) | void load_override(T & t){
class BOOST_SYMBOL_VISIBLE (line 123) | class BOOST_SYMBOL_VISIBLE
FILE: include/boost/archive/xml_oarchive.hpp
type std (line 24) | namespace std{
type boost (line 42) | namespace boost {
type archive (line 43) | namespace archive {
type detail (line 45) | namespace detail {
class interface_oarchive (line 46) | class interface_oarchive
class BOOST_SYMBOL_VISIBLE (line 50) | class BOOST_SYMBOL_VISIBLE
function save (line 63) | void save(const T & t){
function save (line 66) | void
function save (line 70) | void
class BOOST_SYMBOL_VISIBLE (line 117) | class BOOST_SYMBOL_VISIBLE
type archive (line 109) | namespace archive {
type detail (line 45) | namespace detail {
class interface_oarchive (line 46) | class interface_oarchive
class BOOST_SYMBOL_VISIBLE (line 50) | class BOOST_SYMBOL_VISIBLE
function save (line 63) | void save(const T & t){
function save (line 66) | void
function save (line 70) | void
class BOOST_SYMBOL_VISIBLE (line 117) | class BOOST_SYMBOL_VISIBLE
type boost (line 108) | namespace boost {
type archive (line 43) | namespace archive {
type detail (line 45) | namespace detail {
class interface_oarchive (line 46) | class interface_oarchive
class BOOST_SYMBOL_VISIBLE (line 50) | class BOOST_SYMBOL_VISIBLE
function save (line 63) | void save(const T & t){
function save (line 66) | void
function save (line 70) | void
class BOOST_SYMBOL_VISIBLE (line 117) | class BOOST_SYMBOL_VISIBLE
type archive (line 109) | namespace archive {
type detail (line 45) | namespace detail {
class interface_oarchive (line 46) | class interface_oarchive
class BOOST_SYMBOL_VISIBLE (line 50) | class BOOST_SYMBOL_VISIBLE
function save (line 63) | void save(const T & t){
function save (line 66) | void
function save (line 70) | void
class BOOST_SYMBOL_VISIBLE (line 117) | class BOOST_SYMBOL_VISIBLE
FILE: include/boost/archive/xml_wiarchive.hpp
type boost (line 40) | namespace boost {
type archive (line 41) | namespace archive {
type detail (line 43) | namespace detail {
class interface_iarchive (line 44) | class interface_iarchive
class basic_xml_grammar (line 48) | class basic_xml_grammar
class BOOST_SYMBOL_VISIBLE (line 52) | class BOOST_SYMBOL_VISIBLE
function load (line 70) | void
function load (line 74) | void
function load (line 80) | void
function load_override (line 99) | void load_override(T & t){
class BOOST_SYMBOL_VISIBLE (line 129) | class BOOST_SYMBOL_VISIBLE
type archive (line 127) | namespace archive {
type detail (line 43) | namespace detail {
class interface_iarchive (line 44) | class interface_iarchive
class basic_xml_grammar (line 48) | class basic_xml_grammar
class BOOST_SYMBOL_VISIBLE (line 52) | class BOOST_SYMBOL_VISIBLE
function load (line 70) | void
function load (line 74) | void
function load (line 80) | void
function load_override (line 99) | void load_override(T & t){
class BOOST_SYMBOL_VISIBLE (line 129) | class BOOST_SYMBOL_VISIBLE
type boost (line 126) | namespace boost {
type archive (line 41) | namespace archive {
type detail (line 43) | namespace detail {
class interface_iarchive (line 44) | class interface_iarchive
class basic_xml_grammar (line 48) | class basic_xml_grammar
class BOOST_SYMBOL_VISIBLE (line 52) | class BOOST_SYMBOL_VISIBLE
function load (line 70) | void
function load (line 74) | void
function load (line 80) | void
function load_override (line 99) | void load_override(T & t){
class BOOST_SYMBOL_VISIBLE (line 129) | class BOOST_SYMBOL_VISIBLE
type archive (line 127) | namespace archive {
type detail (line 43) | namespace detail {
class interface_iarchive (line 44) | class interface_iarchive
class basic_xml_grammar (line 48) | class basic_xml_grammar
class BOOST_SYMBOL_VISIBLE (line 52) | class BOOST_SYMBOL_VISIBLE
function load (line 70) | void
function load (line 74) | void
function load (line 80) | void
function load_override (line 99) | void load_override(T & t){
class BOOST_SYMBOL_VISIBLE (line 129) | class BOOST_SYMBOL_VISIBLE
FILE: include/boost/archive/xml_woarchive.hpp
type std (line 25) | namespace std{
type boost (line 45) | namespace boost {
type archive (line 46) | namespace archive {
type detail (line 48) | namespace detail {
class interface_oarchive (line 49) | class interface_oarchive
class BOOST_SYMBOL_VISIBLE (line 53) | class BOOST_SYMBOL_VISIBLE
function save (line 69) | void
function save (line 73) | void
function save (line 77) | void
class BOOST_SYMBOL_VISIBLE (line 109) | class BOOST_SYMBOL_VISIBLE
FILE: include/boost/serialization/access.hpp
type boost (line 21) | namespace boost {
type archive (line 23) | namespace archive {
type detail (line 24) | namespace detail {
class iserializer (line 26) | class iserializer
class oserializer (line 28) | class oserializer
type serialization (line 32) | namespace serialization {
type detail (line 37) | namespace detail {
type member_saver (line 39) | struct member_saver
type member_loader (line 41) | struct member_loader
class access (line 49) | class access {
method member_save (line 85) | static void member_save(
method member_load (line 94) | static void member_load(
method serialize (line 102) | static void serialize(
method destroy (line 119) | static void destroy( const T * t) // const appropriate here?
method construct (line 126) | static void construct(T * t){
method T (line 133) | static T & cast_reference(U & u){
method T (line 137) | static T * cast_pointer(U * u){
FILE: include/boost/serialization/archive_input_unordered_map.hpp
type boost (line 27) | namespace boost {
type serialization (line 28) | namespace serialization {
type stl (line 29) | namespace stl {
type archive_input_unordered_map (line 33) | struct archive_input_unordered_map
type archive_input_unordered_multimap (line 59) | struct archive_input_unordered_multimap
FILE: include/boost/serialization/archive_input_unordered_set.hpp
type boost (line 25) | namespace boost {
type serialization (line 26) | namespace serialization {
type stl (line 28) | namespace stl {
type archive_input_unordered_set (line 32) | struct archive_input_unordered_set
type archive_input_unordered_multiset (line 52) | struct archive_input_unordered_multiset
FILE: include/boost/serialization/array.hpp
type std (line 21) | namespace std{
type boost (line 33) | namespace boost { namespace serialization {
type serialization (line 33) | namespace serialization {
function serialize (line 36) | void serialize(Archive& ar, std::array<T,N>& a, const unsigned int /...
FILE: include/boost/serialization/array_optimization.hpp
type std (line 12) | namespace std{
type boost (line 21) | namespace boost { namespace serialization {
type serialization (line 21) | namespace serialization {
type use_array_optimization (line 24) | struct use_array_optimization : boost::mpl::always<boost::mpl::false...
FILE: include/boost/serialization/array_wrapper.hpp
type std (line 12) | namespace std{
type boost (line 27) | namespace boost { namespace serialization {
type serialization (line 27) | namespace serialization {
class array_wrapper (line 30) | class array_wrapper :
method array_wrapper (line 41) | array_wrapper(const array_wrapper & rhs) :
method array_wrapper (line 46) | array_wrapper(T * t, std::size_t s) :
method serialize_optimized (line 53) | void serialize_optimized(Archive &ar, const unsigned int, mpl::fal...
method serialize_optimized (line 64) | void serialize_optimized(Archive &ar, const unsigned int version, ...
method save (line 71) | void save(Archive &ar, const unsigned int version) const
method load (line 78) | void load(Archive &ar, const unsigned int version)
method serialize (line 85) | void serialize(Archive &ar, const unsigned int version)
method T (line 94) | T * address() const
method count (line 99) | std::size_t count() const
function make_array (line 110) | inline
FILE: include/boost/serialization/assume_abstract.hpp
type boost (line 30) | namespace boost {
type serialization (line 31) | namespace serialization {
type is_abstract (line 33) | struct is_abstract : boost::is_abstract< T > {}
type is_abstract (line 43) | struct is_abstract : boost::false_type {}
type serialization (line 41) | namespace serialization {
type is_abstract (line 33) | struct is_abstract : boost::is_abstract< T > {}
type is_abstract (line 43) | struct is_abstract : boost::false_type {}
type boost (line 40) | namespace boost {
type serialization (line 31) | namespace serialization {
type is_abstract (line 33) | struct is_abstract : boost::is_abstract< T > {}
type is_abstract (line 43) | struct is_abstract : boost::false_type {}
type serialization (line 41) | namespace serialization {
type is_abstract (line 33) | struct is_abstract : boost::is_abstract< T > {}
type is_abstract (line 43) | struct is_abstract : boost::false_type {}
FILE: include/boost/serialization/base_object.hpp
type boost (line 40) | namespace boost {
type serialization (line 41) | namespace serialization {
type detail (line 43) | namespace detail
type base_cast (line 48) | struct base_cast
type base_register (line 61) | struct base_register
type polymorphic (line 63) | struct polymorphic {
type non_polymorphic (line 70) | struct non_polymorphic {
FILE: include/boost/serialization/binary_object.hpp
type std (line 24) | namespace std{
type boost (line 36) | namespace boost {
type serialization (line 37) | namespace serialization {
type binary_object (line 39) | struct binary_object :
method save (line 45) | void save(Archive & ar, const unsigned int /* file_version */) con...
method load (line 49) | void load(Archive & ar, const unsigned int /* file_version */) con...
method binary_object (line 53) | binary_object & operator=(const binary_object & rhs) {
method binary_object (line 58) | binary_object(const void * const t, std::size_t size) :
method binary_object (line 62) | binary_object(const binary_object & rhs) :
function binary_object (line 70) | inline
method save (line 45) | void save(Archive & ar, const unsigned int /* file_version */) con...
method load (line 49) | void load(Archive & ar, const unsigned int /* file_version */) con...
method binary_object (line 53) | binary_object & operator=(const binary_object & rhs) {
method binary_object (line 58) | binary_object(const void * const t, std::size_t size) :
method binary_object (line 62) | binary_object(const binary_object & rhs) :
FILE: include/boost/serialization/bitset.hpp
type boost (line 26) | namespace boost{
type serialization (line 27) | namespace serialization{
function save (line 30) | inline void save(
function load (line 44) | inline void load(
function serialize (line 55) | inline void serialize(
type tracking_level<std::bitset<size> > (line 69) | struct tracking_level<std::bitset<size> >
FILE: include/boost/serialization/boost_array.hpp
type std (line 12) | namespace std{
type boost (line 20) | namespace boost { namespace serialization {
type serialization (line 20) | namespace serialization {
function serialize (line 23) | void serialize(Archive& ar, boost::array<T,N>& a, const unsigned int...
FILE: include/boost/serialization/collection_size_type.hpp
type boost (line 15) | namespace boost {
type serialization (line 16) | namespace serialization {
class collection_size_type (line 20) | class collection_size_type {
method collection_size_type (line 25) | collection_size_type(): t(0) {}
method collection_size_type (line 26) | explicit collection_size_type(const std::size_t & t_) :
method collection_size_type (line 29) | collection_size_type(const collection_size_type & t_) :
method collection_size_type (line 32) | collection_size_type & operator=(const collection_size_type & rhs){
method collection_size_type (line 36) | collection_size_type & operator=(const unsigned int & rhs){
FILE: include/boost/serialization/collections_load_imp.hpp
type std (line 29) | namespace std{
type boost (line 44) | namespace boost{
type serialization (line 45) | namespace serialization {
type stl (line 46) | namespace stl {
function collection_load_impl (line 56) | typename boost::enable_if<
function collection_load_impl (line 80) | typename boost::disable_if<
FILE: include/boost/serialization/collections_save_imp.hpp
type boost (line 29) | namespace boost{
type serialization (line 30) | namespace serialization {
type stl (line 31) | namespace stl {
function save_collection (line 38) | inline void save_collection(
function save_collection (line 64) | inline void save_collection(Archive & ar, const Container &s)
FILE: include/boost/serialization/complex.hpp
type boost (line 27) | namespace boost {
type serialization (line 28) | namespace serialization {
function serialize (line 31) | inline void serialize(
function save (line 40) | inline void save(
function load (line 52) | inline void load(
type is_bitwise_serializable<std::complex< T > > (line 66) | struct is_bitwise_serializable<std::complex< T > >
type implementation_level<std::complex< T > > (line 70) | struct implementation_level<std::complex< T > >
type tracking_level<std::complex< T > > (line 75) | struct tracking_level<std::complex< T > >
FILE: include/boost/serialization/deque.hpp
type boost (line 28) | namespace boost {
type serialization (line 29) | namespace serialization {
function save (line 32) | inline void save(
function load (line 43) | inline void load(
function serialize (line 64) | inline void serialize(
FILE: include/boost/serialization/detail/is_default_constructible.hpp
type boost (line 23) | namespace boost{
type serialization (line 24) | namespace serialization {
type detail (line 25) | namespace detail {
type is_default_constructible (line 28) | struct is_default_constructible : public std::is_default_construct...
type is_default_constructible (line 45) | struct is_default_constructible : public boost::has_trivial_constr...
type detail (line 42) | namespace detail {
type is_default_constructible (line 28) | struct is_default_constructible : public std::is_default_construct...
type is_default_constructible (line 45) | struct is_default_constructible : public boost::has_trivial_constr...
type serialization (line 41) | namespace serialization {
type detail (line 25) | namespace detail {
type is_default_constructible (line 28) | struct is_default_constructible : public std::is_default_construct...
type is_default_constructible (line 45) | struct is_default_constructible : public boost::has_trivial_constr...
type detail (line 42) | namespace detail {
type is_default_constructible (line 28) | struct is_default_constructible : public std::is_default_construct...
type is_default_constructible (line 45) | struct is_default_constructible : public boost::has_trivial_constr...
type boost (line 40) | namespace boost{
type serialization (line 24) | namespace serialization {
type detail (line 25) | namespace detail {
type is_default_constructible (line 28) | struct is_default_constructible : public std::is_default_construct...
type is_default_constructible (line 45) | struct is_default_constructible : public boost::has_trivial_constr...
type detail (line 42) | namespace detail {
type is_default_constructible (line 28) | struct is_default_constructible : public std::is_default_construct...
type is_default_constructible (line 45) | struct is_default_constructible : public boost::has_trivial_constr...
type serialization (line 41) | namespace serialization {
type detail (line 25) | namespace detail {
type is_default_constructible (line 28) | struct is_default_constructible : public std::is_default_construct...
type is_default_constructible (line 45) | struct is_default_constructible : public boost::has_trivial_constr...
type detail (line 42) | namespace detail {
type is_default_constructible (line 28) | struct is_default_constructible : public std::is_default_construct...
type is_default_constructible (line 45) | struct is_default_constructible : public boost::has_trivial_constr...
FILE: include/boost/serialization/detail/shared_count_132.hpp
type std (line 43) | namespace std{
class bad_weak_ptr (line 69) | class bad_weak_ptr: public std::exception
class sp_counted_base (line 81) | class sp_counted_base
method sp_counted_base (line 89) | sp_counted_base(): use_count_(1), weak_count_(1)
method destruct (line 104) | virtual void destruct() // nothrow
method add_ref_copy (line 111) | void add_ref_copy()
method add_ref_lock (line 119) | void add_ref_lock()
method release (line 128) | void release() // nothrow
method weak_add_ref (line 143) | void weak_add_ref() // nothrow
method weak_release (line 151) | void weak_release() // nothrow
method use_count (line 168) | long use_count() const // nothrow
function cbi_call_constructor_hook (line 191) | void cbi_call_constructor_hook(sp_counted_base * pn, T * px, boost::chec...
function cbi_call_constructor_hook (line 196) | void cbi_call_constructor_hook(sp_counted_base *, T * px, boost::checked...
function cbi_call_constructor_hook (line 201) | void cbi_call_constructor_hook(sp_counted_base *, P const &, D const &, ...
function cbi_call_destructor_hook (line 205) | void cbi_call_destructor_hook(sp_counted_base * pn, T * px, boost::check...
function cbi_call_destructor_hook (line 210) | void cbi_call_destructor_hook(sp_counted_base *, T * px, boost::checked_...
function cbi_call_destructor_hook (line 215) | void cbi_call_destructor_hook(sp_counted_base *, P const &, D const &, l...
class sp_counted_base_impl (line 228) | class sp_counted_base_impl: public sp_counted_base
method sp_counted_base_impl (line 244) | sp_counted_base_impl(P p, D d): ptr(p), del(d)
method dispose (line 251) | virtual void dispose() // nothrow
class weak_count (line 300) | class weak_count
function id_ (line 318) | id_(shared_count_id)
function id_ (line 325) | id_(shared_count_id)
function shared_count (line 358) | explicit shared_count(std::auto_ptr<Y> & r): pi_(
function id_ (line 382) | id_(shared_count_id)
function shared_count (line 390) | shared_count & operator= (shared_count const & r) // nothrow
function swap (line 404) | void swap(shared_count & r) // nothrow
function use_count (line 411) | long use_count() const // nothrow
function unique (line 416) | bool unique() const // nothrow
function id_ (line 458) | id_(weak_count_id)
function id_ (line 465) | id_(shared_count_id)
function id_ (line 473) | id_(shared_count_id)
function weak_count (line 487) | weak_count & operator= (shared_count const & r) // nothrow
function weak_count (line 497) | weak_count & operator= (weak_count const & r) // nothrow
function swap (line 507) | void swap(weak_count & r) // nothrow
function use_count (line 514) | long use_count() const // nothrow
function id_ (line 532) | id_(shared_count_id)
FILE: include/boost/serialization/detail/shared_ptr_132.hpp
type boost_132 (line 42) | namespace boost_132 {
class weak_ptr (line 44) | class weak_ptr
class enable_shared_from_this (line 45) | class enable_shared_from_this
type detail (line 47) | namespace detail
type static_cast_tag (line 50) | struct static_cast_tag {}
type const_cast_tag (line 51) | struct const_cast_tag {}
type dynamic_cast_tag (line 52) | struct dynamic_cast_tag {}
type polymorphic_cast_tag (line 53) | struct polymorphic_cast_tag {}
type shared_ptr_traits (line 55) | struct shared_ptr_traits
type shared_ptr_traits<void> (line 60) | struct shared_ptr_traits<void>
type shared_ptr_traits<void const> (line 67) | struct shared_ptr_traits<void const>
type shared_ptr_traits<void volatile> (line 72) | struct shared_ptr_traits<void volatile>
type shared_ptr_traits<void const volatile> (line 77) | struct shared_ptr_traits<void const volatile>
function sp_enable_shared_from_this (line 86) | void sp_enable_shared_from_this( shared_count const & pn, enable_sha...
function sp_enable_shared_from_this (line 91) | inline void sp_enable_shared_from_this( shared_count const & /*pn*/,...
class shared_ptr (line 106) | class shared_ptr
method shared_ptr (line 119) | shared_ptr(): px(0), pn() // never throws in 1.30+
method shared_ptr (line 124) | explicit shared_ptr(Y * p): px(p), pn(p, boost::checked_deleter<Y>()...
method shared_ptr (line 135) | shared_ptr(Y * p, D d): px(p), pn(p, d)
method shared_ptr (line 144) | shared_ptr & operator=(shared_ptr const & r) // never throws
method shared_ptr (line 153) | explicit shared_ptr(weak_ptr<Y> const & r): pn(r.pn) // may throw
method shared_ptr (line 160) | shared_ptr(shared_ptr<Y> const & r): px(r.px), pn(r.pn) // never throws
method shared_ptr (line 165) | shared_ptr(shared_ptr<Y> const & r, detail::static_cast_tag): px(sta...
method shared_ptr (line 170) | shared_ptr(shared_ptr<Y> const & r, detail::const_cast_tag): px(cons...
method shared_ptr (line 175) | shared_ptr(shared_ptr<Y> const & r, detail::dynamic_cast_tag): px(dy...
method shared_ptr (line 184) | shared_ptr(shared_ptr<Y> const & r, detail::polymorphic_cast_tag): p...
method shared_ptr (line 195) | explicit shared_ptr(std::auto_ptr<Y> & r): px(r.get()), pn()
method shared_ptr (line 207) | shared_ptr & operator=(shared_ptr<Y> const & r) // never throws
method shared_ptr (line 219) | shared_ptr & operator=(std::auto_ptr<Y> & r)
method reset (line 227) | void reset() // never throws in 1.30+
method reset (line 232) | void reset(Y * p) // Y must be complete
method reset (line 238) | void reset(Y * p, D d)
method reference (line 243) | reference operator* () const // never throws
method T (line 249) | T * operator-> () const // never throws
method T (line 255) | T * get() const // never throws
method unique (line 295) | bool unique() const // never throws
method use_count (line 300) | long use_count() const // never throws
method swap (line 305) | void swap(shared_ptr< T > & other) // never throws
method _internal_less (line 311) | bool _internal_less(shared_ptr<Y> const & rhs) const
function swap (line 354) | inline void swap(shared_ptr< T > & a, shared_ptr< T > & b)
function static_pointer_cast (line 359) | shared_ptr< T > static_pointer_cast(shared_ptr<U> const & r)
function const_pointer_cast (line 364) | shared_ptr< T > const_pointer_cast(shared_ptr<U> const & r)
function dynamic_pointer_cast (line 369) | shared_ptr< T > dynamic_pointer_cast(shared_ptr<U> const & r)
function shared_static_cast (line 376) | shared_ptr< T > shared_static_cast(shared_ptr<U> const & r)
function shared_dynamic_cast (line 381) | shared_ptr< T > shared_dynamic_cast(shared_ptr<U> const & r)
function shared_polymorphic_cast (line 386) | shared_ptr< T > shared_polymorphic_cast(shared_ptr<U> const & r)
function shared_polymorphic_downcast (line 391) | shared_ptr< T > shared_polymorphic_downcast(shared_ptr<U> const & r)
function T (line 399) | inline T * get_pointer(shared_ptr< T > const & p)
function D (line 420) | D * get_deleter(shared_ptr< T > const & p)
function D (line 428) | D * get_deleter(shared_ptr< T > const & p)
FILE: include/boost/serialization/detail/shared_ptr_nmt_132.hpp
type boost (line 30) | namespace boost
class shared_ptr (line 33) | class shared_ptr
method shared_ptr (line 44) | explicit shared_ptr(T * p = 0): px(p)
method shared_ptr (line 80) | shared_ptr(shared_ptr const & r): px(r.px) // never throws
method shared_ptr (line 86) | shared_ptr & operator=(shared_ptr const & r)
method shared_ptr (line 94) | explicit shared_ptr(std::auto_ptr< T > & r)
method shared_ptr (line 100) | shared_ptr & operator=(std::auto_ptr< T > & r)
method reset (line 108) | void reset(T * p = 0)
method T (line 114) | T & operator*() const // never throws
method T (line 120) | T * operator->() const // never throws
method T (line 126) | T * get() const // never throws
method use_count (line 131) | long use_count() const // never throws
method unique (line 136) | bool unique() const // never throws
method swap (line 141) | void swap(shared_ptr< T > & other) // never throws
function swap (line 168) | void swap(shared_ptr< T > & a, shared_ptr< T > & b)
function T (line 175) | inline T * get_pointer(shared_ptr< T > const & p)
FILE: include/boost/serialization/detail/stack_constructor.hpp
type boost (line 22) | namespace boost{
type serialization (line 23) | namespace serialization {
type detail (line 24) | namespace detail {
type stack_allocate (line 29) | struct stack_allocate
method T (line 31) | T * address() {
method T (line 34) | T & reference() {
type stack_construct (line 47) | struct stack_construct : public stack_allocate<T>
method stack_construct (line 49) | stack_construct(Archive & ar, const unsigned int version){
FILE: include/boost/serialization/export.hpp
type boost (line 45) | namespace boost {
type archive (line 46) | namespace archive {
type detail (line 47) | namespace detail {
class basic_pointer_iserializer (line 49) | class basic_pointer_iserializer
class basic_pointer_oserializer (line 50) | class basic_pointer_oserializer
class pointer_iserializer (line 53) | class pointer_iserializer
class pointer_oserializer (line 55) | class pointer_oserializer
type export_impl (line 58) | struct export_impl
method basic_pointer_iserializer (line 60) | static const basic_pointer_iserializer &
method basic_pointer_oserializer (line 67) | static const basic_pointer_oserializer &
method enable_load (line 73) | inline static void enable_load(mpl::false_) {}
method enable_save (line 74) | inline static void enable_save(mpl::false_) {}
type instantiate_function (line 80) | struct instantiate_function {}
type ptr_serialization_support (line 83) | struct ptr_serialization_support
function BOOST_DLLEXPORT (line 96) | BOOST_DLLEXPORT void
type extra_detail (line 112) | namespace extra_detail {
type guid_initializer (line 115) | struct guid_initializer
method export_guid (line 117) | void export_guid(mpl::false_) const {
method export_guid (line 123) | void export_guid(mpl::true_) const {
method guid_initializer (line 125) | guid_initializer const & export_guid() const {
type init_guid (line 137) | struct init_guid
FILE: include/boost/serialization/extended_type_info.hpp
type boost (line 37) | namespace boost {
type serialization (line 38) | namespace serialization {
type void_cast_detail (line 40) | namespace void_cast_detail{
class void_caster (line 41) | class void_caster
class BOOST_SYMBOL_VISIBLE (line 44) | class BOOST_SYMBOL_VISIBLE
type guid_defined (line 89) | struct guid_defined : boost::mpl::false_ {}
type ext (line 91) | namespace ext {
type guid_impl (line 93) | struct guid_impl
FILE: include/boost/serialization/extended_type_info_no_rtti.hpp
type boost (line 47) | namespace boost {
type serialization (line 48) | namespace serialization {
type no_rtti_system (line 53) | namespace no_rtti_system {
function extended_type_info_no_rtti_0 (line 57) | class BOOST_SYMBOL_VISIBLE extended_type_info_no_rtti_0 :
class extended_type_info_no_rtti (line 73) | class extended_type_info_no_rtti :
type action (line 78) | struct action {
type defined (line 79) | struct defined {
type undefined (line 84) | struct undefined {
method extended_type_info_no_rtti (line 103) | extended_type_info_no_rtti() :
method extended_type_info (line 112) | const extended_type_info *
method destroy (line 153) | void destroy(void const * const p) const BOOST_OVERRIDE {
type extended_type_info_impl (line 174) | struct extended_type_info_impl {
type serialization (line 172) | namespace serialization {
type no_rtti_system (line 53) | namespace no_rtti_system {
function extended_type_info_no_rtti_0 (line 57) | class BOOST_SYMBOL_VISIBLE extended_type_info_no_rtti_0 :
class extended_type_info_no_rtti (line 73) | class extended_type_info_no_rtti :
type action (line 78) | struct action {
type defined (line 79) | struct defined {
type undefined (line 84) | struct undefined {
method extended_type_info_no_rtti (line 103) | extended_type_info_no_rtti() :
method extended_type_info (line 112) | const extended_type_info *
method destroy (line 153) | void destroy(void const * const p) const BOOST_OVERRIDE {
type extended_type_info_impl (line 174) | struct extended_type_info_impl {
type boost (line 171) | namespace boost {
type serialization (line 48) | namespace serialization {
type no_rtti_system (line 53) | namespace no_rtti_system {
function extended_type_info_no_rtti_0 (line 57) | class BOOST_SYMBOL_VISIBLE extended_type_info_no_rtti_0 :
class extended_type_info_no_rtti (line 73) | class extended_type_info_no_rtti :
type action (line 78) | struct action {
type defined (line 79) | struct defined {
type undefined (line 84) | struct undefined {
method extended_type_info_no_rtti (line 103) | extended_type_info_no_rtti() :
method extended_type_info (line 112) | const extended_type_info *
method destroy (line 153) | void destroy(void const * const p) const BOOST_OVERRIDE {
type extended_type_info_impl (line 174) | struct extended_type_info_impl {
type serialization (line 172) | namespace serialization {
type no_rtti_system (line 53) | namespace no_rtti_system {
function extended_type_info_no_rtti_0 (line 57) | class BOOST_SYMBOL_VISIBLE extended_type_info_no_rtti_0 :
class extended_type_info_no_rtti (line 73) | class extended_type_info_no_rtti :
type action (line 78) | struct action {
type defined (line 79) | struct defined {
type undefined (line 84) | struct undefined {
method extended_type_info_no_rtti (line 103) | extended_type_info_no_rtti() :
method extended_type_info (line 112) | const extended_type_info *
method destroy (line 153) | void destroy(void const * const p) const BOOST_OVERRIDE {
type extended_type_info_impl (line 174) | struct extended_type_info_impl {
FILE: include/boost/serialization/extended_type_info_typeid.hpp
type boost (line 48) | namespace boost {
type serialization (line 49) | namespace serialization {
type typeid_system (line 50) | namespace typeid_system {
function extended_type_info_typeid_0 (line 52) | class BOOST_SYMBOL_VISIBLE extended_type_info_typeid_0 :
class extended_type_info_typeid (line 81) | class extended_type_info_typeid :
method extended_type_info_typeid (line 86) | extended_type_info_typeid() :
method extended_type_info (line 100) | const extended_type_info *
method destroy (line 136) | void destroy(void const * const p) const BOOST_OVERRIDE {
type extended_type_info_impl (line 156) | struct extended_type_info_impl {
type serialization (line 154) | namespace serialization {
type typeid_system (line 50) | namespace typeid_system {
function extended_type_info_typeid_0 (line 52) | class BOOST_SYMBOL_VISIBLE extended_type_info_typeid_0 :
class extended_type_info_typeid (line 81) | class extended_type_info_typeid :
method extended_type_info_typeid (line 86) | extended_type_info_typeid() :
method extended_type_info (line 100) | const extended_type_info *
method destroy (line 136) | void destroy(void const * const p) const BOOST_OVERRIDE {
type extended_type_info_impl (line 156) | struct extended_type_info_impl {
type boost (line 153) | namespace boost {
type serialization (line 49) | namespace serialization {
type typeid_system (line 50) | namespace typeid_system {
function extended_type_info_typeid_0 (line 52) | class BOOST_SYMBOL_VISIBLE extended_type_info_typeid_0 :
class extended_type_info_typeid (line 81) | class extended_type_info_typeid :
method extended_type_info_typeid (line 86) | extended_type_info_typeid() :
method extended_type_info (line 100) | const extended_type_info *
method destroy (line 136) | void destroy(void const * const p) const BOOST_OVERRIDE {
type extended_type_info_impl (line 156) | struct extended_type_info_impl {
type serialization (line 154) | namespace serialization {
type typeid_system (line 50) | namespace typeid_system {
function extended_type_info_typeid_0 (line 52) | class BOOST_SYMBOL_VISIBLE extended_type_info_typeid_0 :
class extended_type_info_typeid (line 81) | class extended_type_info_typeid :
method extended_type_info_typeid (line 86) | extended_type_info_typeid() :
method extended_type_info (line 100) | const extended_type_info *
method destroy (line 136) | void destroy(void const * const p) const BOOST_OVERRIDE {
type extended_type_info_impl (line 156) | struct extended_type_info_impl {
FILE: include/boost/serialization/factory.hpp
type std (line 26) | namespace std{
type boost (line 32) | namespace boost {
type serialization (line 33) | namespace serialization {
function T (line 37) | T * factory(std::va_list){
FILE: include/boost/serialization/forward_list.hpp
type boost (line 35) | namespace boost {
type serialization (line 36) | namespace serialization {
function save (line 39) | inline void save(
type stl (line 51) | namespace stl {
function collection_load_impl (line 58) | typename boost::disable_if<
function load (line 88) | inline void load(
function serialize (line 109) | inline void serialize(
FILE: include/boost/serialization/hash_collections_load_imp.hpp
type boost (line 25) | namespace boost{
type serialization (line 26) | namespace serialization {
type stl (line 27) | namespace stl {
function load_hash_collection (line 33) | inline void load_hash_collection(Archive & ar, Container &s)
FILE: include/boost/serialization/hash_collections_save_imp.hpp
type boost (line 28) | namespace boost{
type serialization (line 29) | namespace serialization {
type stl (line 30) | namespace stl {
function save_hash_collection (line 37) | inline void save_hash_collection(Archive & ar, const Container &s)
FILE: include/boost/serialization/hash_map.hpp
type boost (line 30) | namespace boost {
type serialization (line 31) | namespace serialization {
type stl (line 33) | namespace stl {
type archive_input_hash_map (line 37) | struct archive_input_hash_map
type archive_input_hash_multimap (line 64) | struct archive_input_hash_multimap
function save (line 97) | inline void save(
function load (line 120) | inline void load(
function serialize (line 151) | inline void serialize(
function save (line 170) | inline void save(
function load (line 193) | inline void load(
function serialize (line 224) | inline void serialize(
FILE: include/boost/serialization/hash_set.hpp
type boost (line 29) | namespace boost {
type serialization (line 30) | namespace serialization {
type stl (line 32) | namespace stl {
type archive_input_hash_set (line 36) | struct archive_input_hash_set
type archive_input_hash_multiset (line 56) | struct archive_input_hash_multiset
function save (line 82) | inline void save(
function load (line 104) | inline void load(
function serialize (line 134) | inline void serialize(
function save (line 152) | inline void save(
function load (line 174) | inline void load(
function serialize (line 204) | inline void serialize(
FILE: include/boost/serialization/is_bitwise_serializable.hpp
type boost (line 27) | namespace boost {
type serialization (line 28) | namespace serialization {
type is_bitwise_serializable (line 30) | struct is_bitwise_serializable
FILE: include/boost/serialization/item_version_type.hpp
type boost (line 17) | namespace boost {
type serialization (line 18) | namespace serialization {
class item_version_type (line 25) | class item_version_type {
method item_version_type (line 31) | item_version_type(): t(0) {}
method item_version_type (line 32) | explicit item_version_type(const unsigned int t_) : t(t_){
method item_version_type (line 35) | item_version_type(const item_version_type & t_) :
method item_version_type (line 38) | item_version_type & operator=(item_version_type rhs){
FILE: include/boost/serialization/level.hpp
type boost (line 35) | namespace boost {
type serialization (line 36) | namespace serialization {
type basic_traits (line 38) | struct basic_traits
type implementation_level_impl (line 42) | struct implementation_level_impl {
type traits_class_level (line 44) | struct traits_class_level {
type implementation_level (line 83) | struct implementation_level :
type level_type (line 89) | enum level_type
FILE: include/boost/serialization/level_enum.hpp
type boost (line 19) | namespace boost {
type serialization (line 20) | namespace serialization {
type level_type (line 26) | enum level_type
FILE: include/boost/serialization/library_version_type.hpp
type boost (line 24) | namespace boost {
type serialization (line 25) | namespace serialization {
class library_version_type (line 36) | class library_version_type {
method library_version_type (line 41) | library_version_type(): t(0) {}
method library_version_type (line 42) | explicit library_version_type(const unsigned int & t_) : t(t_){
method library_version_type (line 45) | library_version_type(const library_version_type & t_) :
method library_version_type (line 48) | library_version_type & operator=(const library_version_type & rhs){
FILE: include/boost/serialization/list.hpp
type boost (line 33) | namespace boost {
type serialization (line 34) | namespace serialization {
function save (line 37) | inline void save(
function load (line 49) | inline void load(
function serialize (line 70) | inline void serialize(
FILE: include/boost/serialization/map.hpp
type boost (line 36) | namespace boost {
type serialization (line 37) | namespace serialization {
function load_map_collection (line 43) | inline void load_map_collection(Archive & ar, Container &s)
function save (line 72) | inline void save(
function load (line 84) | inline void load(
function serialize (line 95) | inline void serialize(
function save (line 105) | inline void save(
function load (line 117) | inline void load(
function serialize (line 128) | inline void serialize(
FILE: include/boost/serialization/nvp.hpp
type boost (line 39) | namespace boost {
type serialization (line 40) | namespace serialization {
function save (line 43) | void save(
function load (line 51) | void load(
function serialize (line 60) | inline void serialize(
type implementation_level<nvp< T > > (line 69) | struct implementation_level<nvp< T > >
type implementation_level<const nvp< T > > (line 76) | struct implementation_level<const nvp< T > >
type tracking_level<nvp< T > > (line 85) | struct tracking_level<nvp< T > >
type tracking_level<const nvp< T > > (line 92) | struct tracking_level<const nvp< T > >
type version<const nvp< T > > (line 102) | struct version<const nvp< T > > {
type version<const nvp< T > > (line 107) | struct version<const nvp< T > > {
type extended_type_info_impl<const nvp< T > > (line 114) | struct extended_type_info_impl<const nvp< T > > {
type is_wrapper<const nvp<T> > (line 120) | struct is_wrapper<const nvp<T> > {
type is_wrapper<nvp<T> > (line 124) | struct is_wrapper<nvp<T> > {
FILE: include/boost/serialization/optional.hpp
type boost (line 33) | namespace boost {
type serialization (line 34) | namespace serialization {
type detail (line 35) | namespace detail {
function save_impl (line 39) | void save_impl(
function load_impl (line 63) | void load_impl(
function save (line 92) | void save(
function save (line 102) | void save(
function load (line 112) | void load(
function load (line 122) | void load(
function serialize (line 132) | void serialize(
function serialize (line 142) | void serialize(
type version<boost::optional<T> > (line 152) | struct version<boost::optional<T> >{
type version<std::optional<T> > (line 158) | struct version<std::optional<T> >{
FILE: include/boost/serialization/priority_queue.hpp
type boost (line 32) | namespace boost {
type serialization (line 33) | namespace serialization {
type detail (line 34) | namespace detail{
type priority_queue_save (line 37) | struct priority_queue_save : public STD::priority_queue<U, Contain...
type priority_queue_load (line 44) | struct priority_queue_load : public STD::priority_queue<U, Contain...
function serialize (line 54) | inline void serialize(
FILE: include/boost/serialization/queue.hpp
type boost (line 32) | namespace boost {
type serialization (line 33) | namespace serialization {
type detail (line 34) | namespace detail {
type queue_save (line 37) | struct queue_save : public STD::queue<U, C> {
type queue_load (line 44) | struct queue_load : public STD::queue<U, C> {
function serialize (line 54) | inline void serialize(
FILE: include/boost/serialization/scoped_ptr.hpp
type boost (line 22) | namespace boost {
type serialization (line 23) | namespace serialization {
function save (line 26) | void save(
function load (line 36) | void load(
function serialize (line 47) | void serialize(
FILE: include/boost/serialization/serialization.hpp
type boost (line 49) | namespace boost {
type serialization (line 50) | namespace serialization {
function serialize (line 56) | inline void serialize(
function save_construct_data (line 64) | inline void save_construct_data(
function load_construct_data (line 75) | inline void load_construct_data(
function serialize_adl (line 103) | inline void serialize_adl(
function save_construct_data_adl (line 113) | inline void save_construct_data_adl(
function load_construct_data_adl (line 124) | inline void load_construct_data_adl(
FILE: include/boost/serialization/set.hpp
type boost (line 34) | namespace boost {
type serialization (line 35) | namespace serialization {
function load_set_collection (line 38) | inline void load_set_collection(Archive & ar, Container &s)
function save (line 67) | inline void save(
function load (line 78) | inline void load(
function serialize (line 89) | inline void serialize(
function save (line 99) | inline void save(
function load (line 111) | inline void load(
function serialize (line 122) | inline void serialize(
FILE: include/boost/serialization/shared_ptr.hpp
type boost (line 41) | namespace boost {
type serialization (line 42) | namespace serialization{
type version< ::boost::shared_ptr< T > > (line 44) | struct version< ::boost::shared_ptr< T > > {
type tracking_level< ::boost::shared_ptr< T > > (line 55) | struct tracking_level< ::boost::shared_ptr< T > > {
type null_deleter (line 83) | struct null_deleter {
function save (line 96) | inline void save(
function load (line 111) | inline void load(
function load (line 147) | inline void load(
function serialize (line 168) | inline void serialize(
type version< ::std::shared_ptr< T > > (line 203) | struct version< ::std::shared_ptr< T > > {
type tracking_level< ::std::shared_ptr< T > > (line 210) | struct tracking_level< ::std::shared_ptr< T > > {
function save (line 226) | inline void save(
function load (line 240) | inline void load(
function serialize (line 262) | inline void serialize(
type serialization (line 81) | namespace serialization{
type version< ::boost::shared_ptr< T > > (line 44) | struct version< ::boost::shared_ptr< T > > {
type tracking_level< ::boost::shared_ptr< T > > (line 55) | struct tracking_level< ::boost::shared_ptr< T > > {
type null_deleter (line 83) | struct null_deleter {
function save (line 96) | inline void save(
function load (line 111) | inline void load(
function load (line 147) | inline void load(
function serialize (line 168) | inline void serialize(
type version< ::std::shared_ptr< T > > (line 203) | struct version< ::std::shared_ptr< T > > {
type tracking_level< ::std::shared_ptr< T > > (line 210) | struct tracking_level< ::std::shared_ptr< T > > {
function save (line 226) | inline void save(
function load (line 240) | inline void load(
function serialize (line 262) | inline void serialize(
type serialization (line 201) | namespace serialization{
type version< ::boost::shared_ptr< T > > (line 44) | struct version< ::boost::shared_ptr< T > > {
type tracking_level< ::boost::shared_ptr< T > > (line 55) | struct tracking_level< ::boost::shared_ptr< T > > {
type null_deleter (line 83) | struct null_deleter {
function save (line 96) | inline void save(
function load (line 111) | inline void load(
function load (line 147) | inline void load(
function serialize (line 168) | inline void serialize(
type version< ::std::shared_ptr< T > > (line 203) | struct version< ::std::shared_ptr< T > > {
type tracking_level< ::std::shared_ptr< T > > (line 210) | struct tracking_level< ::std::shared_ptr< T > > {
function save (line 226) | inline void save(
function load (line 240) | inline void load(
function serialize (line 262) | inline void serialize(
type serialization (line 220) | namespace serialization{
type version< ::boost::shared_ptr< T > > (line 44) | struct version< ::boost::shared_ptr< T > > {
type tracking_level< ::boost::shared_ptr< T > > (line 55) | struct tracking_level< ::boost::shared_ptr< T > > {
type null_deleter (line 83) | struct null_deleter {
function save (line 96) | inline void save(
function load (line 111) | inline void load(
function load (line 147) | inline void load(
function serialize (line 168) | inline void serialize(
type version< ::std::shared_ptr< T > > (line 203) | struct version< ::std::shared_ptr< T > > {
type tracking_level< ::std::shared_ptr< T > > (line 210) | struct tracking_level< ::std::shared_ptr< T > > {
function save (line 226) | inline void save(
function load (line 240) | inline void load(
function serialize (line 262) | inline void serialize(
type boost (line 80) | namespace boost {
type serialization (line 42) | namespace serialization{
type version< ::boost::shared_ptr< T > > (line 44) | struct version< ::boost::shared_ptr< T > > {
type tracking_level< ::boost::shared_ptr< T > > (line 55) | struct tracking_level< ::boost::shared_ptr< T > > {
type null_deleter (line 83) | struct null_deleter {
function save (line 96) | inline void save(
function load (line 111) | inline void load(
function load (line 147) | inline void load(
function serialize (line 168) | inline void serialize(
type version< ::std::shared_ptr< T > > (line 203) | struct version< ::std::shared_ptr< T > > {
type tracking_level< ::std::shared_ptr< T > > (line 210) | struct tracking_level< ::std::shared_ptr< T > > {
function save (line 226) | inline void save(
function load (line 240) | inline void load(
function serialize (line 262) | inline void serialize(
type serialization (line 81) | namespace serialization{
type version< ::boost::shared_ptr< T > > (line 44) | struct version< ::boost::shared_ptr< T > > {
type tracking_level< ::boost::shared_ptr< T > > (line 55) | struct tracking_level< ::boost::shared_ptr< T > > {
type null_deleter (line 83) | struct null_deleter {
function save (line 96) | inline void save(
function load (line 111) | inline void load(
function load (line 147) | inline void load(
function serialize (line 168) | inline void serialize(
type version< ::std::shared_ptr< T > > (line 203) | struct version< ::std::shared_ptr< T > > {
type tracking_level< ::std::shared_ptr< T > > (line 210) | struct tracking_level< ::std::shared_ptr< T > > {
function save (line 226) | inline void save(
function load (line 240) | inline void load(
function serialize (line 262) | inline void serialize(
type serialization (line 201) | namespace serialization{
type version< ::boost::shared_ptr< T > > (line 44) | struct version< ::boost::shared_ptr< T > > {
type tracking_level< ::boost::shared_ptr< T > > (line 55) | struct tracking_level< ::boost::shared_ptr< T > > {
type null_deleter (line 83) | struct null_deleter {
function save (line 96) | inline void save(
function load (line 111) | inline void load(
function load (line 147) | inline void load(
function serialize (line 168) | inline void serialize(
type version< ::std::shared_ptr< T > > (line 203) | struct version< ::std::shared_ptr< T > > {
type tracking_level< ::std::shared_ptr< T > > (line 210) | struct tracking_level< ::std::shared_ptr< T > > {
function save (line 226) | inline void save(
function load (line 240) | inline void load(
function serialize (line 262) | inline void serialize(
type serialization (line 220) | namespace serialization{
type version< ::boost::shared_ptr< T > > (line 44) | struct version< ::boost::shared_ptr< T > > {
type tracking_level< ::boost::shared_ptr< T > > (line 55) | struct tracking_level< ::boost::shared_ptr< T > > {
type null_deleter (line 83) | struct null_deleter {
function save (line 96) | inline void save(
function load (line 111) | inline void load(
function load (line 147) | inline void load(
function serialize (line 168) | inline void serialize(
type version< ::std::shared_ptr< T > > (line 203) | struct version< ::std::shared_ptr< T > > {
type tracking_level< ::std::shared_ptr< T > > (line 210) | struct tracking_level< ::std::shared_ptr< T > > {
function save (line 226) | inline void save(
function load (line 240) | inline void load(
function serialize (line 262) | inline void serialize(
type boost (line 200) | namespace boost {
type serialization (line 42) | namespace serialization{
type version< ::boost::shared_ptr< T > > (line 44) | struct version< ::boost::shared_ptr< T > > {
type tracking_level< ::boost::shared_ptr< T > > (line 55) | struct tracking_level< ::boost::shared_ptr< T > > {
type null_deleter (line 83) | struct null_deleter {
function save (line 96) | inline void save(
function load (line 111) | inline void load(
function load (line 147) | inline void load(
function serialize (line 168) | inline void serialize(
type version< ::std::shared_ptr< T > > (line 203) | struct version< ::std::shared_ptr< T > > {
type tracking_level< ::std::shared_ptr< T > > (line 210) | struct tracking_level< ::std::shared_ptr< T > > {
function save (line 226) | inline void save(
function load (line 240) | inline void load(
function serialize (line 262) | inline void serialize(
type serialization (line 81) | namespace serialization{
type version< ::boost::shared_ptr< T > > (line 44) | struct version< ::boost::shared_ptr< T > > {
type tracking_level< ::boost::shared_ptr< T > > (line 55) | struct tracking_level< ::boost::shared_ptr< T > > {
type null_deleter (line 83) | struct null_deleter {
function save (line 96) | inline void save(
function load (line 111) | inline void load(
function load (line 147) | inline void load(
function serialize (line 168) | inline void serialize(
type version< ::std::shared_ptr< T > > (line 203) | struct version< ::std::shared_ptr< T > > {
type tracking_level< ::std::shared_ptr< T > > (line 210) | struct tracking_level< ::std::shared_ptr< T > > {
function save (line 226) | inline void save(
function load (line 240) | inline void load(
function serialize (line 262) | inline void serialize(
type serialization (line 201) | namespace serialization{
type version< ::boost::shared_ptr< T > > (line 44) | struct version< ::boost::shared_ptr< T > > {
type tracking_level< ::boost::shared_ptr< T > > (line 55) | struct tracking_level< ::boost::shared_ptr< T > > {
type null_deleter (line 83) | struct null_deleter {
function save (line 96) | inline void save(
function load (line 111) | inline void load(
function load (line 147) | inline void load(
function serialize (line 168) | inline void serialize(
type version< ::std::shared_ptr< T > > (line 203) | struct version< ::std::shared_ptr< T > > {
type tracking_level< ::std::shared_ptr< T > > (line 210) | struct tracking_level< ::std::shared_ptr< T > > {
function save (line 226) | inline void save(
function load (line 240) | inline void load(
function serialize (line 262) | inline void serialize(
type serialization (line 220) | namespace serialization{
type version< ::boost::shared_ptr< T > > (line 44) | struct version< ::boost::shared_ptr< T > > {
type tracking_level< ::boost::shared_ptr< T > > (line 55) | struct tracking_level< ::boost::shared_ptr< T > > {
type null_deleter (line 83) | struct null_deleter {
function save (line 96) | inline void save(
function load (line 111) | inline void load(
function load (line 147) | inline void load(
function serialize (line 168) | inline void serialize(
type version< ::std::shared_ptr< T > > (line 203) | struct version< ::std::shared_ptr< T > > {
type tracking_level< ::std::shared_ptr< T > > (line 210) | struct tracking_level< ::std::shared_ptr< T > > {
function save (line 226) | inline void save(
function load (line 240) | inline void load(
function serialize (line 262) | inline void serialize(
type boost (line 219) | namespace boost {
type serialization (line 42) | namespace serialization{
type version< ::boost::shared_ptr< T > > (line 44) | struct version< ::boost::shared_ptr< T > > {
type tracking_level< ::boost::shared_ptr< T > > (line 55) | struct tracking_level< ::boost::shared_ptr< T > > {
type null_deleter (line 83) | struct null_deleter {
function save (line 96) | inline void save(
function load (line 111) | inline void load(
function load (line 147) | inline void load(
function serialize (line 168) | inline void serialize(
type version< ::std::shared_ptr< T > > (line 203) | struct version< ::std::shared_ptr< T > > {
type tracking_level< ::std::shared_ptr< T > > (line 210) | struct tracking_level< ::std::shared_ptr< T > > {
function save (line 226) | inline void save(
function load (line 240) | inline void load(
function serialize (line 262) | inline void serialize(
type serialization (line 81) | namespace serialization{
type version< ::boost::shared_ptr< T > > (line 44) | struct version< ::boost::shared_ptr< T > > {
type tracking_level< ::boost::shared_ptr< T > > (line 55) | struct tracking_level< ::boost::shared_ptr< T > > {
type null_deleter (line 83) | struct null_deleter {
function save (line 96) | inline void save(
function load (line 111) | inline void load(
function load (line 147) | inline void load(
function serialize (line 168) | inline void serialize(
type version< ::std::shared_ptr< T > > (line 203) | struct version< ::std::shared_ptr< T > > {
type tracking_level< ::std::shared_ptr< T > > (line 210) | struct tracking_level< ::std::shared_ptr< T > > {
function save (line 226) | inline void save(
function load (line 240) | inline void load(
function serialize (line 262) | inline void serialize(
type serialization (line 201) | namespace serialization{
type version< ::boost::shared_ptr< T > > (line 44) | struct version< ::boost::shared_ptr< T > > {
type tracking_level< ::boost::shared_ptr< T > > (line 55) | struct tracking_level< ::boost::shared_ptr< T > > {
type null_deleter (line 83) | struct null_deleter {
function save (line 96) | inline void save(
function load (line 111) | inline void load(
function load (line 147) | inline void load(
function serialize (line 168) | inline void serialize(
type version< ::std::shared_ptr< T > > (line 203) | struct version< ::std::shared_ptr< T > > {
type tracking_level< ::std::shared_ptr< T > > (line 210) | struct tracking_level< ::std::shared_ptr< T > > {
function save (line 226) | inline void save(
function load (line 240) | inline void load(
function serialize (line 262) | inline void serialize(
type serialization (line 220) | namespace serialization{
type version< ::boost::shared_ptr< T > > (line 44) | struct version< ::boost::shared_ptr< T > > {
type tracking_level< ::boost::shared_ptr< T > > (line 55) | struct tracking_level< ::boost::shared_ptr< T > > {
type null_deleter (line 83) | struct null_deleter {
function save (line 96) | inline void save(
function load (line 111) | inline void load(
function load (line 147) | inline void load(
function serialize (line 168) | inline void serialize(
type version< ::std::shared_ptr< T > > (line 203) | struct version< ::std::shared_ptr< T > > {
type tracking_level< ::std::shared_ptr< T > > (line 210) | struct tracking_level< ::std::shared_ptr< T > > {
function save (line 226) | inline void save(
function load (line 240) | inline void load(
function serialize (line 262) | inline void serialize(
FILE: include/boost/serialization/shared_ptr_132.hpp
type boost_132 (line 41) | namespace boost_132 {
type serialization (line 42) | namespace serialization {
type detail (line 43) | namespace detail {
type null_deleter (line 45) | struct null_deleter {
type boost (line 56) | namespace boost {
type serialization (line 57) | namespace serialization {
function serialize (line 60) | inline void serialize(
function save_construct_data (line 77) | inline void save_construct_data(
function load_construct_data (line 88) | inline void load_construct_data(
function save (line 125) | inline void save(
function load (line 134) | inline void load(
function save (line 156) | inline void save(
function load (line 171) | inline void load(
function serialize (line 186) | inline void serialize(
type serialization (line 122) | namespace serialization {
function serialize (line 60) | inline void serialize(
function save_construct_data (line 77) | inline void save_construct_data(
function load_construct_data (line 88) | inline void load_construct_data(
function save (line 125) | inline void save(
function load (line 134) | inline void load(
function save (line 156) | inline void save(
function load (line 171) | inline void load(
function serialize (line 186) | inline void serialize(
type serialization (line 153) | namespace serialization {
function serialize (line 60) | inline void serialize(
function save_construct_data (line 77) | inline void save_construct_data(
function load_construct_data (line 88) | inline void load_construct_data(
function save (line 125) | inline void save(
function load (line 134) | inline void load(
function save (line 156) | inline void save(
function load (line 171) | inline void load(
function serialize (line 186) | inline void serialize(
type boost (line 121) | namespace boost {
type serialization (line 57) | namespace serialization {
function serialize (line 60) | inline void serialize(
function save_construct_data (line 77) | inline void save_construct_data(
function load_construct_data (line 88) | inline void load_construct_data(
function save (line 125) | inline void save(
function load (line 134) | inline void load(
function save (line 156) | inline void save(
function load (line 171) | inline void load(
function serialize (line 186) | inline void serialize(
type serialization (line 122) | namespace serialization {
function serialize (line 60) | inline void serialize(
function save_construct_data (line 77) | inline void save_construct_data(
function load_construct_data (line 88) | inline void load_construct_data(
function save (line 125) | inline void save(
function load (line 134) | inline void load(
function save (line 156) | inline void save(
function load (line 171) | inline void load(
function serialize (line 186) | inline void serialize(
type serialization (line 153) | namespace serialization {
function serialize (line 60) | inline void serialize(
function save_construct_data (line 77) | inline void save_construct_data(
function load_construct_data (line 88) | inline void load_construct_data(
function save (line 125) | inline void save(
function load (line 134) | inline void load(
function save (line 156) | inline void save(
function load (line 171) | inline void load(
function serialize (line 186) | inline void serialize(
type boost (line 152) | namespace boost {
type serialization (line 57) | namespace serialization {
function serialize (line 60) | inline void serialize(
function save_construct_data (line 77) | inline void save_construct_data(
function load_construct_data (line 88) | inline void load_construct_data(
function save (line 125) | inline void save(
function load (line 134) | inline void load(
function save (line 156) | inline void save(
function load (line 171) | inline void load(
function serialize (line 186) | inline void serialize(
type serialization (line 122) | namespace serialization {
function serialize (line 60) | inline void serialize(
function save_construct_data (line 77) | inline void save_construct_data(
function load_construct_data (line 88) | inline void load_construct_data(
function save (line 125) | inline void save(
function load (line 134) | inline void load(
function save (line 156) | inline void save(
function load (line 171) | inline void load(
function serialize (line 186) | inline void serialize(
type serialization (line 153) | namespace serialization {
function serialize (line 60) | inline void serialize(
function save_construct_data (line 77) | inline void save_construct_data(
function load_construct_data (line 88) | inline void load_construct_data(
function save (line 125) | inline void save(
function load (line 134) | inline void load(
function save (line 156) | inline void save(
function load (line 171) | inline void load(
function serialize (line 186) | inline void serialize(
FILE: include/boost/serialization/shared_ptr_helper.hpp
type boost_132 (line 35) | namespace boost_132 {
class shared_ptr (line 36) | class shared_ptr
type boost (line 38) | namespace boost {
type serialization (line 39) | namespace serialization {
class U (line 45) | class U
class shared_ptr_helper (line 54) | class shared_ptr_helper {
type null_deleter (line 67) | struct null_deleter {
method append (line 94) | void
type non_polymorphic (line 102) | struct non_polymorphic {
type polymorphic (line 112) | struct polymorphic {
method reset (line 125) | void reset(SPT< T > & s, T * t){
method shared_ptr_helper (line 190) | shared_ptr_helper() :
FILE: include/boost/serialization/singleton.hpp
type boost (line 53) | namespace boost {
type serialization (line 54) | namespace serialization {
class BOOST_SYMBOL_VISIBLE (line 100) | class BOOST_SYMBOL_VISIBLE
function BOOST_DLLEXPORT (line 113) | BOOST_DLLEXPORT void unlock(){
function BOOST_DLLEXPORT (line 116) | BOOST_DLLEXPORT bool is_locked(){
function singleton_module (line 121) | static inline singleton_module & get_singleton_module(){
type detail (line 126) | namespace detail {
class singleton_wrapper (line 137) | class singleton_wrapper : public T
method singleton_wrapper (line 147) | singleton_wrapper(){
method is_destroyed (line 153) | static bool is_destroyed(){
class singleton (line 161) | class singleton {
method use (line 165) | static void use(T const &) {}
method T (line 166) | static T & get_instance() {
method BOOST_DLLEXPORT (line 188) | BOOST_DLLEXPORT singleton(){}
method BOOST_DLLEXPORT (line 191) | BOOST_DLLEXPORT static T & get_mutable_instance(){
method BOOST_DLLEXPORT (line 195) | BOOST_DLLEXPORT static const T & get_const_instance(){
method BOOST_DLLEXPORT (line 198) | BOOST_DLLEXPORT static bool is_destroyed(){
FILE: include/boost/serialization/slist.hpp
type boost (line 34) | namespace boost {
type serialization (line 35) | namespace serialization {
function save (line 38) | inline void save(
type stl (line 49) | namespace stl {
function collection_load_impl (line 56) | typename boost::disable_if<
function load (line 86) | inline void load(
function serialize (line 129) | inline void serialize(
FILE: include/boost/serialization/smart_cast.hpp
type boost (line 61) | namespace boost {
type serialization (line 62) | namespace serialization {
type smart_cast_impl (line 63) | namespace smart_cast_impl {
type reference (line 66) | struct reference {
type polymorphic (line 68) | struct polymorphic {
type linear (line 70) | struct linear {
method T (line 72) | static T cast(U & u){
type cross (line 77) | struct cross {
method T (line 79) | static T cast(U & u){
method T (line 85) | static T cast(U & u){
type non_polymorphic (line 118) | struct non_polymorphic {
method T (line 120) | static T cast(U & u){
method T (line 125) | static T cast(U & u){
type pointer (line 136) | struct pointer {
type polymorphic (line 138) | struct polymorphic {
type linear (line 143) | struct linear {
method T (line 145) | static T cast(U * u){
type cross (line 150) | struct cross {
method T (line 152) | static T cast(U * u){
method T (line 162) | static T cast(U * u){
method T (line 183) | static T cast(U * u){
type non_polymorphic (line 193) | struct non_polymorphic {
method T (line 195) | static T cast(U * u){
method T (line 201) | static T cast(U * u){
type void_pointer (line 213) | struct void_pointer {
method TPtr (line 215) | static TPtr cast(UPtr uptr){
type error (line 221) | struct error {
method T (line 226) | static T cast(U){
function T (line 240) | T smart_cast(U u) {
function T (line 268) | T smart_cast_reference(U & u) {
FILE: include/boost/serialization/split_free.hpp
type boost (line 24) | namespace boost {
type archive (line 25) | namespace archive {
type detail (line 26) | namespace detail {
class interface_oarchive (line 27) | class interface_oarchive
class interface_iarchive (line 28) | class interface_iarchive
type serialization (line 32) | namespace serialization {
type free_saver (line 35) | struct free_saver {
method invoke (line 36) | static void invoke(
type free_loader (line 48) | struct free_loader {
method invoke (line 49) | static void invoke(
function split_free (line 62) | inline void split_free(
FILE: include/boost/serialization/split_member.hpp
type boost (line 25) | namespace boost {
type archive (line 26) | namespace archive {
type detail (line 27) | namespace detail {
class interface_oarchive (line 28) | class interface_oarchive
class interface_iarchive (line 29) | class interface_iarchive
type serialization (line 33) | namespace serialization {
type detail (line 34) | namespace detail {
type member_saver (line 37) | struct member_saver {
method invoke (line 38) | static void invoke(
type member_loader (line 48) | struct member_loader {
method invoke (line 49) | static void invoke(
function split_member (line 61) | inline void split_member(
FILE: include/boost/serialization/stack.hpp
type boost (line 32) | namespace boost {
type serialization (line 33) | namespace serialization {
type detail (line 34) | namespace detail{
type stack_save (line 37) | struct stack_save : public STD::stack<U, C> {
type stack_load (line 44) | struct stack_load : public STD::stack<U, C> {
function serialize (line 54) | inline void serialize(
FILE: include/boost/serialization/state_saver.hpp
type serialization (line 39) | namespace serialization {
class state_saver (line 46) | class state_saver : private boost::noncopyable
type restore (line 52) | struct restore {
method invoke (line 53) | static void invoke(T & previous_ref, const T & previous_value){
type restore_with_exception (line 58) | struct restore_with_exception {
method invoke (line 59) | static void invoke(T & previous_ref, const T & previous_value){
method BOOST_CATCH (line 63) | BOOST_CATCH(::std::exception &) {
method state_saver (line 71) | state_saver(
FILE: include/boost/serialization/static_warning.hpp
type boost (line 72) | namespace boost {
type serialization (line 73) | namespace serialization {
type BOOST_SERIALIZATION_STATIC_WARNING_LINE (line 76) | struct BOOST_SERIALIZATION_STATIC_WARNING_LINE{}
type static_warning_test (line 79) | struct static_warning_test{
type BOOST_SERIALIZATION_SS (line 92) | struct BOOST_SERIALIZATION_SS {}
FILE: include/boost/serialization/std_variant.hpp
type boost (line 33) | namespace boost {
type serialization (line 34) | namespace serialization {
type std_variant_save_visitor (line 37) | struct std_variant_save_visitor
method std_variant_save_visitor (line 39) | std_variant_save_visitor(Archive& ar) :
type std_variant_load_visitor (line 53) | struct std_variant_load_visitor
method std_variant_load_visitor (line 55) | std_variant_load_visitor(Archive& ar) :
function save (line 68) | void save(
type mp (line 80) | namespace mp {
type detail (line 81) | namespace detail {
type front_impl (line 83) | struct front_impl
type pop_front_impl (line 91) | struct pop_front_impl
type typelist (line 100) | struct typelist {}
type variant_impl (line 110) | struct variant_impl
method load (line 113) | static void load (
type variant_impl<0, Seq> (line 139) | struct variant_impl<0, Seq>
method load (line 142) | static void load (
function load (line 151) | void load(
function serialize (line 169) | inline void serialize(
function serialize (line 179) | void serialize(Archive &, std::monostate &, const unsigned int /*ver...
type serialization (line 190) | namespace serialization {
type std_variant_save_visitor (line 37) | struct std_variant_save_visitor
method std_variant_save_visitor (line 39) | std_variant_save_visitor(Archive& ar) :
type std_variant_load_visitor (line 53) | struct std_variant_load_visitor
method std_variant_load_visitor (line 55) | std_variant_load_visitor(Archive& ar) :
function save (line 68) | void save(
type mp (line 80) | namespace mp {
type detail (line 81) | namespace detail {
type front_impl (line 83) | struct front_impl
type pop_front_impl (line 91) | struct pop_front_impl
type typelist (line 100) | struct typelist {}
type variant_impl (line 110) | struct variant_impl
method load (line 113) | static void load (
type variant_impl<0, Seq> (line 139) | struct variant_impl<0, Seq>
method load (line 142) | static void load (
function load (line 151) | void load(
function serialize (line 169) | inline void serialize(
function serialize (line 179) | void serialize(Archive &, std::monostate &, const unsigned int /*ver...
type front_impl<Seq<T, Ts...>> (line 86) | struct front_impl<Seq<T, Ts...>> {
type pop_front_impl<Seq<T, Ts...>> (line 94) | struct pop_front_impl<Seq<T, Ts...>> {
type boost (line 189) | namespace boost {
type serialization (line 34) | namespace serialization {
type std_variant_save_visitor (line 37) | struct std_variant_save_visitor
method std_variant_save_visitor (line 39) | std_variant_save_visitor(Archive& ar) :
type std_variant_load_visitor (line 53) | struct std_variant_load_visitor
method std_variant_load_visitor (line 55) | std_variant_load_visitor(Archive& ar) :
function save (line 68) | void save(
type mp (line 80) | namespace mp {
type detail (line 81) | namespace detail {
type front_impl (line 83) | struct front_impl
type pop_front_impl (line 91) | struct pop_front_impl
type typelist (line 100) | struct typelist {}
type variant_impl (line 110) | struct variant_impl
method load (line 113) | static void load (
type variant_impl<0, Seq> (line 139) | struct variant_impl<0, Seq>
method load (line 142) | static void load (
function load (line 151) | void load(
function serialize (line 169) | inline void serialize(
function serialize (line 179) | void serialize(Archive &, std::monostate &, const unsigned int /*ver...
type serialization (line 190) | namespace serialization {
type std_variant_save_visitor (line 37) | struct std_variant_save_visitor
method std_variant_save_visitor (line 39) | std_variant_save_visitor(Archive& ar) :
type std_variant_load_visitor (line 53) | struct std_variant_load_visitor
method std_variant_load_visitor (line 55) | std_variant_load_visitor(Archive& ar) :
function save (line 68) | void save(
type mp (line 80) | namespace mp {
type detail (line 81) | namespace detail {
type front_impl (line 83) | struct front_impl
type pop_front_impl (line 91) | struct pop_front_impl
type typelist (line 100) | struct typelist {}
type variant_impl (line 110) | struct variant_impl
method load (line 113) | static void load (
type variant_impl<0, Seq> (line 139) | struct variant_impl<0, Seq>
method load (line 142) | static void load (
function load (line 151) | void load(
function serialize (line 169) | inline void serialize(
function serialize (line 179) | void serialize(Archive &, std::monostate &, const unsigned int /*ver...
type tracking_level<
std::variant<Types...>
> (line 193) | struct tracking_level<
FILE: include/boost/serialization/throw_exception.hpp
type boost (line 24) | namespace boost {
type serialization (line 25) | namespace serialization {
function BOOST_NORETURN (line 29) | BOOST_NORETURN inline void throw_exception(std::exception const & e) {
function BOOST_NORETURN (line 36) | BOOST_NORETURN inline void throw_exception(E const & e){
FILE: include/boost/serialization/tracking.hpp
type boost (line 34) | namespace boost {
type serialization (line 35) | namespace serialization {
type basic_traits (line 37) | struct basic_traits
type tracking_level_impl (line 41) | struct tracking_level_impl {
type traits_class_tracking (line 43) | struct traits_class_tracking {
type tracking_level (line 74) | struct tracking_level :
type tracking_type (line 79) | enum tracking_type
type tracking_type (line 80) | enum tracking_type
FILE: include/boost/serialization/tracking_enum.hpp
type boost (line 19) | namespace boost {
type serialization (line 20) | namespace serialization {
type tracking_type (line 27) | enum tracking_type
FILE: include/boost/serialization/traits.hpp
type boost (line 35) | namespace boost {
type serialization (line 36) | namespace serialization {
type basic_traits (line 39) | struct basic_traits {}
type extended_type_info_impl (line 42) | struct extended_type_info_impl
type traits (line 52) | struct traits : public basic_traits {
FILE: include/boost/serialization/type_info_implementation.hpp
type boost (line 29) | namespace boost {
type serialization (line 30) | namespace serialization {
type type_info_implementation (line 35) | struct type_info_implementation {
type traits_class_typeinfo_implementation (line 37) | struct traits_class_typeinfo_implementation {
FILE: include/boost/serialization/unique_ptr.hpp
type boost (line 22) | namespace boost {
type serialization (line 23) | namespace serialization {
function save (line 30) | inline void save(
function load (line 42) | inline void load(
function serialize (line 56) | inline void serialize(
FILE: include/boost/serialization/unordered_collections_load_imp.hpp
type std (line 27) | namespace std{
type boost (line 39) | namespace boost{
type serialization (line 40) | namespace serialization {
type stl (line 41) | namespace stl {
function load_unordered_collection (line 47) | inline void load_unordered_collection(Archive & ar, Container &s)
FILE: include/boost/serialization/unordered_collections_save_imp.hpp
type boost (line 30) | namespace boost{
type serialization (line 31) | namespace serialization {
type stl (line 32) | namespace stl {
function save_unordered_collection (line 39) | inline void save_unordered_collection(Archive & ar, const Containe...
FILE: include/boost/serialization/unordered_map.hpp
type boost (line 31) | namespace boost {
type serialization (line 32) | namespace serialization {
function save (line 42) | inline void save(
function load (line 61) | inline void load(
function serialize (line 86) | inline void serialize(
function save (line 103) | inline void save(
function load (line 122) | inline void load(
function serialize (line 147) | inline void serialize(
FILE: include/boost/serialization/unordered_set.hpp
type boost (line 29) | namespace boost {
type serialization (line 30) | namespace serialization {
function save (line 39) | inline void save(
function load (line 59) | inline void load(
function serialize (line 87) | inline void serialize(
function save (line 105) | inline void save(
function load (line 125) | inline void load(
function serialize (line 151) | inline void serialize(
FILE: include/boost/serialization/utility.hpp
type boost (line 28) | namespace boost {
type serialization (line 29) | namespace serialization {
function serialize (line 33) | inline void serialize(
type is_bitwise_serializable<std::pair<T,U> > (line 48) | struct is_bitwise_serializable<std::pair<T,U> >
FILE: include/boost/serialization/valarray.hpp
type boost (line 37) | namespace boost {
type serialization (line 38) | namespace serialization {
function save (line 44) | void save( Archive & ar, const STD::valarray<U> &t, const unsigned i...
function load (line 58) | void load( Archive & ar, STD::valarray<U> &t, const unsigned int /*...
function serialize (line 75) | inline void serialize( Archive & ar, STD::valarray<U> & t, const uns...
FILE: include/boost/serialization/variant.hpp
class T (line 61) | class T
function visit (line 62) | typename Visitor::result_type visit(
class T (line 68) | class T
function visit (line 69) | typename Visitor::result_type visit(
type boost (line 77) | namespace boost {
type serialization (line 78) | namespace serialization {
type variant_save_visitor (line 81) | struct variant_save_visitor :
method variant_save_visitor (line 84) | variant_save_visitor(Archive& ar) :
class T (line 95) | class T
function save (line 96) | void save(
function save (line 109) | void save(
function save (line 123) | void save(
type variant_impl (line 136) | struct variant_impl {
type load_null (line 138) | struct load_null {
method invoke (line 140) | static void invoke(
type load_member (line 148) | struct load_member {
method invoke (line 150) | static void invoke(
method load_impl (line 175) | static void load_impl(
class T (line 189) | class T
function load (line 190) | void load(
function load (line 211) | void load(
function load (line 233) | void load(
class T (line 253) | class T
function serialize (line 254) | inline void serialize(
function serialize (line 264) | inline void serialize(
function serialize (line 275) | inline void serialize(
class T (line 292) | class T
type tracking_level<
variant<BOOST_VARIANT_ENUM_PARAMS(T)>
> (line 293) | struct tracking_level<
type serialization (line 290) | namespace serialization {
type variant_save_visitor (line 81) | struct variant_save_visitor :
method variant_save_visitor (line 84) | variant_save_visitor(Archive& ar) :
class T (line 95) | class T
function save (line 96) | void save(
function save (line 109) | void save(
function save (line 123) | void save(
type variant_impl (line 136) | struct variant_impl {
type load_null (line 138) | struct load_null {
method invoke (line 140) | static void invoke(
type load_member (line 148) | struct load_member {
method invoke (line 150) | static void invoke(
method load_impl (line 175) | static void load_impl(
class T (line 189) | class T
function load (line 190) | void load(
function load (line 211) | void load(
function load (line 233) | void load(
class T (line 253) | class T
function serialize (line 254) | inline void serialize(
function serialize (line 264) | inline void serialize(
function serialize (line 275) | inline void serialize(
class T (line 292) | class T
type tracking_level<
variant<BOOST_VARIANT_ENUM_PARAMS(T)>
> (line 293) | struct tracking_level<
type boost (line 289) | namespace boost {
type serialization (line 78) | namespace serialization {
type variant_save_visitor (line 81) | struct variant_save_visitor :
method variant_save_visitor (line 84) | variant_save_visitor(Archive& ar) :
class T (line 95) | class T
function save (line 96) | void save(
function save (line 109) | void save(
function save (line 123) | void save(
type variant_impl (line 136) | struct variant_impl {
type load_null (line 138) | struct load_null {
method invoke (line 140) | static void invoke(
type load_member (line 148) | struct load_member {
method invoke (line 150) | static void invoke(
method load_impl (line 175) | static void load_impl(
class T (line 189) | class T
function load (line 190) | void load(
function load (line 211) | void load(
function load (line 233) | void load(
class T (line 253) | class T
function serialize (line 254) | inline void serialize(
function serialize (line 264) | inline void serialize(
function serialize (line 275) | inline void serialize(
class T (line 292) | class T
type tracking_level<
variant<BOOST_VARIANT_ENUM_PARAMS(T)>
> (line 293) | struct tracking_level<
type serialization (line 290) | namespace serialization {
type variant_save_visitor (line 81) | struct variant_save_visitor :
method variant_save_visitor (line 84) | variant_save_visitor(Archive& ar) :
class T (line 95) | class T
function save (line 96) | void save(
function save (line 109) | void save(
function save (line 123) | void save(
type variant_impl (line 136) | struct variant_impl {
type load_null (line 138) | struct load_null {
method invoke (line 140) | static void invoke(
type load_member (line 148) | struct load_member {
method invoke (line 150) | static void invoke(
method load_impl (line 175) | static void load_impl(
class T (line 189) | class T
function load (line 190) | void load(
function load (line 211) | void load(
function load (line 233) | void load(
class T (line 253) | class T
function serialize (line 254) | inline void serialize(
function serialize (line 264) | inline void serialize(
function serialize (line 275) | inline void serialize(
class T (line 292) | class T
type tracking_level<
variant<BOOST_VARIANT_ENUM_PARAMS(T)>
> (line 293) | struct tracking_level<
type tracking_level<
std::variant<Types...>
> (line 303) | struct tracking_level<
FILE: include/boost/serialization/variant2.hpp
type boost (line 33) | namespace boost {
type serialization (line 34) | namespace serialization {
type variant2_save_visitor (line 37) | struct variant2_save_visitor
method variant2_save_visitor (line 39) | variant2_save_visitor(Archive& ar) :
type variant2_load_visitor (line 53) | struct variant2_load_visitor
method variant2_load_visitor (line 55) | variant2_load_visitor(Archive& ar) :
function save (line 68) | void save(
type variant_impl (line 80) | struct variant_impl
method load (line 83) | static void load (
type variant_impl<Seq> (line 109) | struct variant_impl<Seq>
method load (line 112) | static void load (
function load (line 121) | void load(
function serialize (line 139) | inline void serialize(
function serialize (line 149) | void serialize(Archive &ar, variant2::monostate &, const unsigned in...
type serialization (line 160) | namespace serialization {
type variant2_save_visitor (line 37) | struct variant2_save_visitor
method variant2_save_visitor (line 39) | variant2_save_visitor(Archive& ar) :
type variant2_load_visitor (line 53) | struct variant2_load_visitor
method variant2_load_visitor (line 55) | variant2_load_visitor(Archive& ar) :
function save (line 68) | void save(
type variant_impl (line 80) | struct variant_impl
method load (line 83) | static void load (
type variant_impl<Seq> (line 109) | struct variant_impl<Seq>
method load (line 112) | static void load (
function load (line 121) | void load(
function serialize (line 139) | inline void serialize(
function serialize (line 149) | void serialize(Archive &ar, variant2::monostate &, const unsigned in...
type boost (line 159) | namespace boost {
type serialization (line 34) | namespace serialization {
type variant2_save_visitor (line 37) | struct variant2_save_visitor
method variant2_save_visitor (line 39) | variant2_save_visitor(Archive& ar) :
type variant2_load_visitor (line 53) | struct variant2_load_visitor
method variant2_load_visitor (line 55) | variant2_load_visitor(Archive& ar) :
function save (line 68) | void save(
type variant_impl (line 80) | struct variant_impl
method load (line 83) | static void load (
type variant_impl<Seq> (line 109) | struct variant_impl<Seq>
method load (line 112) | static void load (
function load (line 121) | void load(
function serialize (line 139) | inline void serialize(
function serialize (line 149) | void serialize(Archive &ar, variant2::monostate &, const unsigned in...
type serialization (line 160) | namespace serialization {
type variant2_save_visitor (line 37) | struct variant2_save_visitor
method variant2_save_visitor (line 39) | variant2_save_visitor(Archive& ar) :
type variant2_load_visitor (line 53) | struct variant2_load_visitor
method variant2_load_visitor (line 55) | variant2_load_visitor(Archive& ar) :
function save (line 68) | void save(
type variant_impl (line 80) | struct variant_impl
method load (line 83) | static void load (
type variant_impl<Seq> (line 109) | struct variant_impl<Seq>
method load (line 112) | static void load (
function load (line 121) | void load(
function serialize (line 139) | inline void serialize(
function serialize (line 149) | void serialize(Archive &ar, variant2::monostate &, const unsigned in...
type tracking_level<
variant2::variant<Types...>
> (line 163) | struct tracking_level<
FILE: include/boost/serialization/vector.hpp
type boost (line 52) | namespace boost {
type serialization (line 53) | namespace serialization {
function save (line 61) | inline void save(
function load (line 73) | inline void load(
function save (line 96) | inline void save(
function load (line 113) | inline void load(
function save (line 137) | inline void save(
function load (line 150) | inline void load(
function serialize (line 172) | inline void serialize(
function save (line 183) | inline void save(
function load (line 199) | inline void load(
function serialize (line 218) | inline void serialize(
FILE: include/boost/serialization/version.hpp
type boost (line 28) | namespace boost {
type serialization (line 29) | namespace serialization {
type basic_traits (line 31) | struct basic_traits
type version (line 36) | struct version
type traits_class_version (line 39) | struct traits_class_version {
FILE: include/boost/serialization/void_cast.hpp
type boost (line 41) | namespace boost {
type serialization (line 42) | namespace serialization {
class extended_type_info (line 44) | class extended_type_info
type void_cast_detail (line 91) | namespace void_cast_detail {
class BOOST_SYMBOL_VISIBLE (line 93) | class BOOST_SYMBOL_VISIBLE
function void_caster (line 128) | const void_caster & operator*(){
function void_caster (line 135) | void_caster(
function void_caster_primitive (line 155) | class BOOST_SYMBOL_VISIBLE void_caster_primitive :
function void_caster_virtual_base (line 206) | class BOOST_SYMBOL_VISIBLE void_caster_virtual_base :
function void_caster_base (line 251) | struct BOOST_SYMBOL_VISIBLE void_caster_base :
function BOOST_DLLEXPORT (line 269) | BOOST_DLLEXPORT
class BOOST_SYMBOL_VISIBLE (line 288) | class BOOST_SYMBOL_VISIBLE
FILE: include/boost/serialization/void_cast_fwd.hpp
type boost (line 23) | namespace boost {
type serialization (line 24) | namespace serialization {
type void_cast_detail (line 25) | namespace void_cast_detail{
class void_caster (line 26) | class void_caster
FILE: include/boost/serialization/weak_ptr.hpp
type boost (line 22) | namespace boost {
type serialization (line 23) | namespace serialization{
function save (line 26) | inline void save(
function load (line 36) | inline void load(
function serialize (line 47) | inline void serialize(
function save (line 65) | inline void save(
function load (line 75) | inline void load(
function serialize (line 86) | inline void serialize(
type serialization (line 62) | namespace serialization{
function save (line 26) | inline void save(
function load (line 36) | inline void load(
function serialize (line 47) | inline void serialize(
function save (line 65) | inline void save(
function load (line 75) | inline void load(
function serialize (line 86) | inline void serialize(
type boost (line 61) | namespace boost {
type serialization (line 23) | namespace serialization{
function save (line 26) | inline void save(
function load (line 36) | inline void load(
function serialize (line 47) | inline void serialize(
function save (line 65) | inline void save(
function load (line 75) | inline void load(
function serialize (line 86) | inline void serialize(
type serialization (line 62) | namespace serialization{
function save (line 26) | inline void save(
function load (line 36) | inline void load(
function serialize (line 47) | inline void serialize(
function save (line 65) | inline void save(
function load (line 75) | inline void load(
function serialize (line 86) | inline void serialize(
FILE: include/boost/serialization/wrapper.hpp
type boost (line 14) | namespace boost { namespace serialization {
type serialization (line 14) | namespace serialization {
type wrapper_traits (line 29) | struct wrapper_traits :
type is_wrapper_impl (line 34) | struct is_wrapper_impl :
type is_wrapper (line 43) | struct is_wrapper {
FILE: performance/peformance_array.cpp
type std (line 15) | namespace std{
type array_equal_to (line 36) | struct array_equal_to //: public std::binary_function<T, T, bool>
function test_array (line 62) | int test_array(T)
function BOOST_CATCH (line 102) | BOOST_CATCH (boost::archive::archive_exception ae){}
function test_main (line 109) | int test_main( int /* argc */, char* /* argv */[] )
FILE: performance/performance_binary.cpp
type std (line 17) | namespace std{
class A (line 34) | class A {
method serialize (line 41) | void serialize(Archive & ar, const unsigned int /* file_version */){
function test_main (line 67) | int test_main( int /* argc */, char* /* argv */[] )
FILE: performance/performance_codecvt_null.cpp
type std (line 24) | namespace std{
type test_data (line 37) | struct test_data
function test_main (line 71) | int test_main( int /* argc */, char* /* argv */[] ) {
FILE: performance/performance_iterators.cpp
type std (line 17) | namespace std{
function test_wchar_from_mb (line 41) | void test_wchar_from_mb(const wchar_t *la, const char * a, const unsigne...
function test_mb_from_wchar (line 52) | void test_mb_from_wchar(const char * a, const wchar_t *la, const unsigne...
function test_xml_escape (line 66) | void test_xml_escape(
function test_xml_unescape (line 83) | void test_xml_unescape(
function test_transform_width (line 102) | void test_transform_width(unsigned int size){
function test_stream_iterators (line 144) | void test_stream_iterators(
function test_main (line 160) | int
FILE: performance/performance_iterators_base64.cpp
type std (line 21) | namespace std{
function test_base64 (line 40) | void test_base64(){
function test_main (line 92) | int
FILE: performance/performance_no_rtti.cpp
type std (line 22) | namespace std{
class polymorphic_base (line 45) | class polymorphic_base
method serialize (line 49) | void serialize(Archive & /* ar */, const unsigned int /* file_version ...
class polymorphic_derived1 (line 64) | class polymorphic_derived1 : public polymorphic_base
method serialize (line 68) | void serialize(Archive &ar, const unsigned int /* file_version */){
class polymorphic_derived2 (line 88) | class polymorphic_derived2 : public polymorphic_base
method serialize (line 92) | void serialize(Archive &ar, const unsigned int /* file_version */){
function save_derived (line 116) | void save_derived(const char *testfile)
function load_derived (line 140) | void load_derived(const char *testfile)
function test_main (line 208) | int
FILE: performance/performance_polymorphic.cpp
type std (line 16) | namespace std{
function test_main (line 50) | int test_main(int /* argc */, char * /* argv */ [])
FILE: performance/performance_simple_class.cpp
type std (line 19) | namespace std{
function test_main (line 35) | int
FILE: performance/performance_utf8_codecvt.cpp
type std (line 20) | namespace std{
type std (line 27) | namespace std{ using ::wcslen; }
type test_data (line 38) | struct test_data
function test_main (line 98) | int
FILE: performance/performance_vector.cpp
type std (line 16) | namespace std{
function test_vector (line 33) | int test_vector(T)
function test_main (line 58) | int test_main( int /* argc */, char* /* argv */[] )
FILE: performance/xml/harness.hpp
type std (line 30) | namespace std {
type boost (line 54) | namespace boost {
type archive (line 55) | namespace archive {
type xml (line 56) | namespace xml {
function T (line 60) | T
function save_archive (line 80) | std::string
function restore_archive (line 99) | std::pair<double, T>
class result_set_exception (line 115) | class result_set_exception: public virtual archive_exception {
type exception_code (line 117) | enum exception_code {
method result_set_exception (line 121) | result_set_exception (exception_code c = invalid_archive_metadat...
type entry (line 137) | struct entry {
method serialize (line 143) | void serialize (ARC& ar, const unsigned int) {
method entry (line 150) | entry (void) { }
method entry (line 152) | entry (std::string type, std::size_t size, double data):
type result_set (line 156) | struct result_set {
method serialize (line 162) | void serialize (ARC& ar, const unsigned int) {
method result_set (line 173) | result_set (void):
method result_set (line 177) | result_set (std::list<entry> entries):
FILE: performance/xml/high_resolution_timer.hpp
type boost (line 24) | namespace boost {
type archive (line 25) | namespace archive {
type xml (line 26) | namespace xml {
class high_resolution_timer (line 34) | class high_resolution_timer
method high_resolution_timer (line 37) | high_resolution_timer()
method high_resolution_timer (line 42) | high_resolution_timer(double t)
method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
method now (line 56) | static double now()
method restart (line 72) | void restart()
method elapsed (line 77) | double elapsed() const // return elapsed time i...
method elapsed_max (line 90) | double elapsed_max() const // return estimated maximum value f...
method elapsed_min (line 100) | double elapsed_min() const // return minimum value fo...
method high_resolution_timer (line 134) | high_resolution_timer()
method high_resolution_timer (line 142) | high_resolution_timer(double t)
method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
method now (line 153) | static double now()
method restart (line 161) | void restart()
method elapsed (line 166) | double elapsed() const // return elapsed time i...
method elapsed_max (line 179) | double elapsed_max() const // return estimated maximum value f...
method elapsed_min (line 184) | double elapsed_min() const // return minimum value fo...
method high_resolution_timer (line 217) | high_resolution_timer()
method high_resolution_timer (line 227) | high_resolution_timer(double t)
method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
method now (line 242) | static double now()
method restart (line 253) | void restart()
method elapsed (line 260) | double elapsed() const // return elapsed time i...
method elapsed_max (line 276) | double elapsed_max() const // return estimated maximum value f...
method elapsed_min (line 284) | double elapsed_min() const // return minimum value fo...
method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
method high_resolution_timer (line 366) | high_resolution_timer()
method high_resolution_timer (line 374) | high_resolution_timer(double t)
method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
method now (line 385) | static double now()
method restart (line 399) | void restart()
method elapsed (line 405) | double elapsed() const // return elapsed time i...
method elapsed_max (line 413) | double elapsed_max() const // return estimated maximum value f...
method elapsed_min (line 418) | double elapsed_min() const // return minimum value fo...
method now (line 463) | static double now()
class high_resolution_timer (line 131) | class high_resolution_timer
method high_resolution_timer (line 37) | high_resolution_timer()
method high_resolution_timer (line 42) | high_resolution_timer(double t)
method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
method now (line 56) | static double now()
method restart (line 72) | void restart()
method elapsed (line 77) | double elapsed() const // return elapsed time i...
method elapsed_max (line 90) | double elapsed_max() const // return estimated maximum value f...
method elapsed_min (line 100) | double elapsed_min() const // return minimum value fo...
method high_resolution_timer (line 134) | high_resolution_timer()
method high_resolution_timer (line 142) | high_resolution_timer(double t)
method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
method now (line 153) | static double now()
method restart (line 161) | void restart()
method elapsed (line 166) | double elapsed() const // return elapsed time i...
method elapsed_max (line 179) | double elapsed_max() const // return estimated maximum value f...
method elapsed_min (line 184) | double elapsed_min() const // return minimum value fo...
method high_resolution_timer (line 217) | high_resolution_timer()
method high_resolution_timer (line 227) | high_resolution_timer(double t)
method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
method now (line 242) | static double now()
method restart (line 253) | void restart()
method elapsed (line 260) | double elapsed() const // return elapsed time i...
method elapsed_max (line 276) | double elapsed_max() const // return estimated maximum value f...
method elapsed_min (line 284) | double elapsed_min() const // return minimum value fo...
method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
method high_resolution_timer (line 366) | high_resolution_timer()
method high_resolution_timer (line 374) | high_resolution_timer(double t)
method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
method now (line 385) | static double now()
method restart (line 399) | void restart()
method elapsed (line 405) | double elapsed() const // return elapsed time i...
method elapsed_max (line 413) | double elapsed_max() const // return estimated maximum value f...
method elapsed_min (line 418) | double elapsed_min() const // return minimum value fo...
method now (line 463) | static double now()
class high_resolution_timer (line 214) | class high_resolution_timer
method high_resolution_timer (line 37) | high_resolution_timer()
method high_resolution_timer (line 42) | high_resolution_timer(double t)
method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
method now (line 56) | static double now()
method restart (line 72) | void restart()
method elapsed (line 77) | double elapsed() const // return elapsed time i...
method elapsed_max (line 90) | double elapsed_max() const // return estimated maximum value f...
method elapsed_min (line 100) | double elapsed_min() const // return minimum value fo...
method high_resolution_timer (line 134) | high_resolution_timer()
method high_resolution_timer (line 142) | high_resolution_timer(double t)
method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
method now (line 153) | static double now()
method restart (line 161) | void restart()
method elapsed (line 166) | double elapsed() const // return elapsed time i...
method elapsed_max (line 179) | double elapsed_max() const // return estimated maximum value f...
method elapsed_min (line 184) | double elapsed_min() const // return minimum value fo...
method high_resolution_timer (line 217) | high_resolution_timer()
method high_resolution_timer (line 227) | high_resolution_timer(double t)
method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
method now (line 242) | static double now()
method restart (line 253) | void restart()
method elapsed (line 260) | double elapsed() const // return elapsed time i...
method elapsed_max (line 276) | double elapsed_max() const // return estimated maximum value f...
method elapsed_min (line 284) | double elapsed_min() const // return minimum value fo...
method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
method high_resolution_timer (line 366) | high_resolution_timer()
method high_resolution_timer (line 374) | high_resolution_timer(double t)
method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
method now (line 385) | static double now()
method restart (line 399) | void restart()
method elapsed (line 405) | double elapsed() const // return elapsed time i...
method elapsed_max (line 413) | double elapsed_max() const // return estimated maximum value f...
method elapsed_min (line 418) | double elapsed_min() const // return minimum value fo...
method now (line 463) | static double now()
class high_resolution_timer (line 333) | class high_resolution_timer
method high_resolution_timer (line 37) | high_resolution_timer()
method high_resolution_timer (line 42) | high_resolution_timer(double t)
method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
method now (line 56) | static double now()
method restart (line 72) | void restart()
method elapsed (line 77) | double elapsed() const // return elapsed time i...
method elapsed_max (line 90) | double elapsed_max() const // return estimated maximum value f...
method elapsed_min (line 100) | double elapsed_min() const // return minimum value fo...
method high_resolution_timer (line 134) | high_resolution_timer()
method high_resolution_timer (line 142) | high_resolution_timer(double t)
method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
method now (line 153) | static double now()
method restart (line
Condensed preview — 540 files, each showing path, character count, and a content snippet. Download the .json file or copy for the full structured content (2,351K chars).
[
{
"path": ".drone/drone.sh",
"chars": 1172,
"preview": "#!/bin/bash\n\n# Copyright 2020 Rene Rivera, Sam Darwin\n# Distributed under the Boost Software License, Version 1.0.\n# (Se"
},
{
"path": ".drone.star",
"chars": 2819,
"preview": "# Use, modification, and distribution are\n# subject to the Boost Software License, Version 1.0. (See accompanying\n# file"
},
{
"path": ".gitattributes",
"chars": 3917,
"preview": "* text=auto !eol svneol=native#text/plain\n*.gitattributes text svneol=native#text/plain\n\n# Scriptish formats\n*.bat "
},
{
"path": ".github/workflows/posix.yml",
"chars": 16592,
"preview": "# Copyright 2020-2021 Peter Dimov\n# Copyright 2021 Andrey Semashev\n# Copyright 2021 Alexander Grund\n# Copyright 2022 Jam"
},
{
"path": ".github/workflows/windows.yml",
"chars": 2188,
"preview": "name: Windows\n\non:\n pull_request:\n push:\n branches:\n - master\n - develop\n - feature/**\n\nconcurrency:"
},
{
"path": ".gitignore",
"chars": 0,
"preview": ""
},
{
"path": ".travis.yml",
"chars": 2226,
"preview": "# Copyright 2016, 2017 Peter Dimov\n# Distributed under the Boost Software License, Version 1.0.\n# (See accompanying file"
},
{
"path": "CMake/CMakeLists.txt",
"chars": 13333,
"preview": "# CMake build control file for Serialization Library tests\n\ncmake_minimum_required(VERSION 3.5)\n\nif (POLICY CMP0054)\n c"
},
{
"path": "CMakeLists.txt",
"chars": 3592,
"preview": "# Copyright 2020, 2021 Peter Dimov\n# Distributed under the Boost Software License, Version 1.0.\n# https://www.boost.org/"
},
{
"path": "appveyor.yml",
"chars": 2502,
"preview": "# Copyright 2016 Peter Dimov\n# Copyright 2016 Robert Ramey\n# Distributed under the Boost Software License, Version 1.0.\n"
},
{
"path": "build/Jamfile.v2",
"chars": 3793,
"preview": "# Boost serialization Library Build Jamfile\n# (C) Copyright Robert Ramey 2002-2004.\n# Use, modification, and distribut"
},
{
"path": "build.jam",
"chars": 1369,
"preview": "# Copyright René Ferdinand Rivera Morell 2023-2024\n# Distributed under the Boost Software License, Version 1.0.\n# (See a"
},
{
"path": "doc/acknowledgments.html",
"chars": 5281,
"preview": "<!doctype HTML PUBLIC \"-//W3C//DTD HTML 4.01 Transitional//EN\" \"http://www.w3.org/TR/html4/loose.dtd\">\n<html>\n<!--\n(C) C"
},
{
"path": "doc/archive_reference.html",
"chars": 22136,
"preview": "<!doctype HTML PUBLIC \"-//W3C//DTD HTML 4.01 Transitional//EN\" \"http://www.w3.org/TR/html4/loose.dtd\">\n<html>\n<!--\n(C) C"
},
{
"path": "doc/archives.html",
"chars": 19890,
"preview": "<!doctype HTML PUBLIC \"-//W3C//DTD HTML 4.01 Transitional//EN\" \"http://www.w3.org/TR/html4/loose.dtd\">\n<html>\n<head>\n<me"
},
{
"path": "doc/bibliography.html",
"chars": 3304,
"preview": "<!doctype HTML PUBLIC \"-//W3C//DTD HTML 4.01 Transitional//EN\" \"http://www.w3.org/TR/html4/loose.dtd\">\n<html>\n<!--\n(C) C"
},
{
"path": "doc/class_diagram.html",
"chars": 8411,
"preview": "<!doctype HTML PUBLIC \"-//W3C//DTD HTML 4.01 Transitional//EN\" \"http://www.w3.org/TR/html4/loose.dtd\">\n<!--\n(C) Copyrigh"
},
{
"path": "doc/codecvt.html",
"chars": 5472,
"preview": "<!DOCTYPE HTML PUBLIC \"-//W3C//DTD HTML 4.01 Transitional//EN\" \"http://www.w3.org/TR/html4/loose.dtd\">\n<html>\n<!--\n == "
},
{
"path": "doc/configuration.html",
"chars": 661,
"preview": "<!doctype HTML PUBLIC \"-//W3C//DTD HTML 4.01 Transitional//EN\" \"http://www.w3.org/TR/html4/loose.dtd\">\n<html>\n<!--\n(C) C"
},
{
"path": "doc/contents.html",
"chars": 27818,
"preview": "<!doctype HTML PUBLIC \"-//W3C//DTD HTML 4.01 Transitional//EN\" \"http://www.w3.org/TR/html4/loose.dtd\">\n<html>\n<!--\n(C) C"
},
{
"path": "doc/dataflow.html",
"chars": 9128,
"preview": "<!doctype HTML PUBLIC \"-//W3C//DTD HTML 4.01 Transitional//EN\" \"http://www.w3.org/TR/html4/loose.dtd\">\n<html>\n<!--\n(C) C"
},
{
"path": "doc/definitions.html",
"chars": 659,
"preview": "<!doctype HTML PUBLIC \"-//W3C//DTD HTML 4.01 Transitional//EN\" \"http://www.w3.org/TR/html4/loose.dtd\">\n<html>\n<!--\n(C) C"
},
{
"path": "doc/derivation.html",
"chars": 6564,
"preview": "<!doctype HTML PUBLIC \"-//W3C//DTD HTML 4.01 Transitional//EN\" \"http://www.w3.org/TR/html4/loose.dtd\">\n<html>\n<!--\n(C) C"
},
{
"path": "doc/exception_safety.html",
"chars": 6345,
"preview": "<!doctype HTML PUBLIC \"-//W3C//DTD HTML 4.01 Transitional//EN\" \"http://www.w3.org/TR/html4/loose.dtd\">\n<html>\n<!--\n(C) C"
},
{
"path": "doc/exceptions.html",
"chars": 14620,
"preview": "<!doctype HTML PUBLIC \"-//W3C//DTD HTML 4.01 Transitional//EN\" \"http://www.w3.org/TR/html4/loose.dtd\">\n<html>\n<!--\n(C) C"
},
{
"path": "doc/extended_type_info.html",
"chars": 16858,
"preview": "<!doctype HTML PUBLIC \"-//W3C//DTD HTML 4.01 Transitional//EN\" \"http://www.w3.org/TR/html4/loose.dtd\">\n<html>\n<!--\n(C) C"
},
{
"path": "doc/faq.html",
"chars": 2129,
"preview": "<!doctype HTML PUBLIC \"-//W3C//DTD HTML 4.01 Transitional//EN\" \"http://www.w3.org/TR/html4/loose.dtd\">\n<html>\n<!--\n(C) C"
},
{
"path": "doc/headers.html",
"chars": 18739,
"preview": "<!doctype HTML PUBLIC \"-//W3C//DTD HTML 4.01 Transitional//EN\" \"http://www.w3.org/TR/html4/loose.dtd\">\n<html>\n<!--\n(C) C"
},
{
"path": "doc/history.html",
"chars": 5774,
"preview": "<!doctype HTML PUBLIC \"-//W3C//DTD HTML 4.01 Transitional//EN\" \"http://www.w3.org/TR/html4/loose.dtd\">\n<html>\n<!--\n(C) C"
},
{
"path": "doc/implementation.html",
"chars": 14363,
"preview": "<!doctype HTML PUBLIC \"-//W3C//DTD HTML 4.01 Transitional//EN\" \"http://www.w3.org/TR/html4/loose.dtd\">\n<html>\n<!--\n(C) C"
},
{
"path": "doc/index.html",
"chars": 771,
"preview": "<!doctype HTML PUBLIC \"-//W3C//DTD HTML 4.01 Frameset//EN\"\n \"http://www.w3.org/TR/html4/frameset.dtd\"><html>\n<head>\n<!"
},
{
"path": "doc/new_case_studies.html",
"chars": 3987,
"preview": "<!DOCTYPE HTML PUBLIC \"-//W3C//DTD HTML 4.01 Transitional//EN\" \"http://www.w3.org/TR/html4/loose.dtd\">\n<html>\n<!--\n(C) "
},
{
"path": "doc/overview.html",
"chars": 6925,
"preview": "<!DOCTYPE HTML PUBLIC \"-//W3C//DTD HTML 4.01 Transitional//EN\" \"http://www.w3.org/TR/html4/loose.dtd\">\n<html>\n<!--\n(C) C"
},
{
"path": "doc/performance_status.html",
"chars": 1299,
"preview": "<html>\n<head>\n<title>Boost Library Status Automatic Test</title>\n</head>\n<body bgcolor=\"#ffffff\" text=\"#000000\">\n<table "
},
{
"path": "doc/pimpl.html",
"chars": 4962,
"preview": "<!doctype HTML PUBLIC \"-//W3C//DTD HTML 4.01 Transitional//EN\" \"http://www.w3.org/TR/html4/loose.dtd\">\n<html>\n<!--\n(C) C"
},
{
"path": "doc/private_base.html",
"chars": 5724,
"preview": "<!doctype HTML PUBLIC \"-//W3C//DTD HTML 4.01 Transitional//EN\" \"http://www.w3.org/TR/html4/loose.dtd\">\n<html>\n<!--\n(C) C"
},
{
"path": "doc/profile1.txt",
"chars": 6403,
"preview": "Flat profile:\n\nEach sample counts as 0.01 seconds.\n no time accumulated\n\n % cumulative self self t"
},
{
"path": "doc/profile2.txt",
"chars": 14156,
"preview": "Flat profile:\n\nEach sample counts as 0.01 seconds.\n % cumulative self self total \n time "
},
{
"path": "doc/profile3.txt",
"chars": 7800,
"preview": "Flat profile:\n\nEach sample counts as 0.01 seconds.\n no time accumulated\n\n % cumulative self self t"
},
{
"path": "doc/rationale.html",
"chars": 6347,
"preview": "<!doctype HTML PUBLIC \"-//W3C//DTD HTML 4.01 Transitional//EN\" \"http://www.w3.org/TR/html4/loose.dtd\">\n<html>\n<!--\n(C) C"
},
{
"path": "doc/reference.html",
"chars": 1655,
"preview": "<!doctype HTML PUBLIC \"-//W3C//DTD HTML 4.01 Transitional//EN\" \"http://www.w3.org/TR/html4/loose.dtd\">\n<html>\n<!--\n(C) "
},
{
"path": "doc/release.html",
"chars": 15180,
"preview": "<!doctype HTML PUBLIC \"-//W3C//DTD HTML 4.01 Transitional//EN\" \"http://www.w3.org/TR/html4/loose.dtd\">\n<html>\n<!--\n(C) C"
},
{
"path": "doc/serialization.html",
"chars": 40522,
"preview": "<!doctype HTML PUBLIC \"-//W3C//DTD HTML 4.01 Transitional//EN\" \"http://www.w3.org/TR/html4/loose.dtd\">\n<html>\n<!--\n(C) C"
},
{
"path": "doc/shared_ptr.html",
"chars": 9026,
"preview": "<!doctype HTML PUBLIC \"-//W3C//DTD HTML 4.01 Transitional//EN\" \"http://www.w3.org/TR/html4/loose.dtd\">\n<html>\n<!--\n(C) C"
},
{
"path": "doc/shared_ptr2.html",
"chars": 4030,
"preview": "<!doctype HTML PUBLIC \"-//W3C//DTD HTML 4.01 Transitional//EN\" \"http://www.w3.org/TR/html4/loose.dtd\">\n<html>\n<!--\n(C) "
},
{
"path": "doc/simple_log.html",
"chars": 3120,
"preview": "<!doctype HTML PUBLIC \"-//W3C//DTD HTML 4.01 Transitional//EN\" \"http://www.w3.org/TR/html4/loose.dtd\">\n<html>\n<!--\n(C) C"
},
{
"path": "doc/singleton.html",
"chars": 9579,
"preview": "<!doctype HTML PUBLIC \"-//W3C//DTD HTML 4.01 Transitional//EN\" \"http://www.w3.org/TR/html4/loose.dtd\">\n<html>\n<!--\n(C) C"
},
{
"path": "doc/smart_cast.html",
"chars": 4748,
"preview": "<!doctype HTML PUBLIC \"-//W3C//DTD HTML 4.01 Transitional//EN\" \"http://www.w3.org/TR/html4/loose.dtd\">\n<html>\n<!--\n(C) C"
},
{
"path": "doc/special.html",
"chars": 30737,
"preview": "<!doctype HTML PUBLIC \"-//W3C//DTD HTML 4.01 Transitional//EN\" \"http://www.w3.org/TR/html4/loose.dtd\">\n<html>\n<!--\n(C) C"
},
{
"path": "doc/state_saver.html",
"chars": 2781,
"preview": "<!doctype HTML PUBLIC \"-//W3C//DTD HTML 4.01 Transitional//EN\" \"http://www.w3.org/TR/html4/loose.dtd\">\n<html>\n<!--\n(C) C"
},
{
"path": "doc/static_warning.html",
"chars": 2536,
"preview": "<!doctype HTML PUBLIC \"-//W3C//DTD HTML 4.01 Transitional//EN\" \"http://www.w3.org/TR/html4/loose.dtd\">\n<html>\n<!--\n(C) C"
},
{
"path": "doc/strong_typedef.html",
"chars": 3360,
"preview": "<!doctype HTML PUBLIC \"-//W3C//DTD HTML 4.01 Transitional//EN\" \"http://www.w3.org/TR/html4/loose.dtd\">\n<html>\n<!--\n(C) C"
},
{
"path": "doc/style.css",
"chars": 423,
"preview": "pre{\n BORDER-RIGHT: gray 1pt solid;\n BORDER-TOP: gray 1pt solid;\n BORDER-LEFT: gray 1pt solid;\n BORDER-BOTTOM: gray "
},
{
"path": "doc/todo.html",
"chars": 5067,
"preview": "<!DOCTYPE HTML PUBLIC \"-//W3C//DTD HTML 4.01 Transitional//EN\" \"http://www.w3.org/TR/html4/loose.dtd\">\n<html>\n<!--\n(C) C"
},
{
"path": "doc/traits.html",
"chars": 34771,
"preview": "<!doctype HTML PUBLIC \"-//W3C//DTD HTML 4.01 Transitional//EN\" \"http://www.w3.org/TR/html4/loose.dtd\">\n<html>\n<!--\n(C) C"
},
{
"path": "doc/tutorial.html",
"chars": 22557,
"preview": "<!doctype HTML PUBLIC \"-//W3C//DTD HTML 4.01 Transitional//EN\" \"http://www.w3.org/TR/html4/loose.dtd\">\n<html>\n<!--\n(C) C"
},
{
"path": "doc/void_cast.html",
"chars": 3840,
"preview": "<!doctype HTML PUBLIC \"-//W3C//DTD HTML 4.01 Transitional//EN\" \"http://www.w3.org/TR/html4/loose.dtd\">\n<html>\n<!--\n(C) "
},
{
"path": "doc/wrappers.html",
"chars": 9049,
"preview": "<!doctype HTML PUBLIC \"-//W3C//DTD HTML 4.01 Transitional//EN\" \"http://www.w3.org/TR/html4/loose.dtd\">\n<html>\n<!--\n(C) "
},
{
"path": "example/Jamfile.v2",
"chars": 1314,
"preview": "# Boost serialization Library Build Jamfile\n# (C) Copyright Robert Ramey 2002-2004.\n# Use, modification, and distribut"
},
{
"path": "example/demo.cpp",
"chars": 11463,
"preview": "/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8\n// demo.cpp\n//\n// (C) Copyright 2002-4 "
},
{
"path": "example/demo_auto_ptr.cpp",
"chars": 3626,
"preview": "/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8\n// demo_auto_ptr.cpp\n\n// (C) Copyright "
},
{
"path": "example/demo_dll_a.hpp",
"chars": 7813,
"preview": "#ifndef BOOST_SERIALIZATION_TEST_A_HPP\n#define BOOST_SERIALIZATION_TEST_A_HPP\n\n// MS compatible compilers support #pragm"
},
{
"path": "example/demo_dll_a.ipp",
"chars": 7777,
"preview": "#ifndef BOOST_SERIALIZATION_TEST_A_HPP\n#define BOOST_SERIALIZATION_TEST_A_HPP\n\n// MS compatible compilers support #pragm"
},
{
"path": "example/demo_dll_b.hpp",
"chars": 2965,
"preview": "#ifndef BOOST_SERIALIZATION_TEST_B_HPP\n#define BOOST_SERIALIZATION_TEST_B_HPP\n\n// MS compatible compilers support #pragm"
},
{
"path": "example/demo_dll_b.ipp",
"chars": 2922,
"preview": "#ifndef BOOST_SERIALIZATION_TEST_B_HPP\n#define BOOST_SERIALIZATION_TEST_B_HPP\n\n// MS compatible compilers support #pragm"
},
{
"path": "example/demo_exception.cpp",
"chars": 7534,
"preview": "/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8\n// demo_exception.cpp\n\n// (C) Copyright"
},
{
"path": "example/demo_fast_archive.cpp",
"chars": 5728,
"preview": "/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8\n// demo_fast_binary_archive.cpp\n\n// (C)"
},
{
"path": "example/demo_gps.hpp",
"chars": 9035,
"preview": "#ifndef BOOST_SERIALIZATION_EXAMPLE_DEMO_GPS_HPP\n#define BOOST_SERIALIZATION_EXAMPLE_DEMO_GPS_HPP\n\n/////////1/////////2/"
},
{
"path": "example/demo_log.cpp",
"chars": 2011,
"preview": "/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8\n//\n// demo_log.cpp\n//\n// (C) Copyright "
},
{
"path": "example/demo_output.txt",
"chars": 2417,
"preview": "original schedule\n6:24 bob \n0x003265C8 34135'52.56\" 13422'78.3\" 24th Street and 10th Avenue\n0x00326648 35137'23.456\" 1"
},
{
"path": "example/demo_pimpl.cpp",
"chars": 780,
"preview": "/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8\n// demo_pimpl.cpp\n\n// (C) Copyright 200"
},
{
"path": "example/demo_pimpl_A.cpp",
"chars": 1336,
"preview": "/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8\n// demo_pimpl_A.cpp\n\n// (C) Copyright 2"
},
{
"path": "example/demo_pimpl_A.hpp",
"chars": 775,
"preview": "#ifndef BOOST_SERIALIZATION_EXAMPLE_DEMO_PIMPL_A_HPP\n#define BOOST_SERIALIZATION_EXAMPLE_DEMO_PIMPL_A_HPP\n\n/////////1///"
},
{
"path": "example/demo_polymorphic.cpp",
"chars": 2028,
"preview": "/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8\n// demo_polymorphic.cpp\n\n// (C) Copyrig"
},
{
"path": "example/demo_polymorphic_A.cpp",
"chars": 847,
"preview": "/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8\n// demo_polymorphic_A.cpp\n\n// (C) Copyr"
},
{
"path": "example/demo_polymorphic_A.hpp",
"chars": 1022,
"preview": "#ifndef BOOST_SERIALIZATION_EXAMPLE_DEMO_POLYMORPHIC_A_HPP\n#define BOOST_SERIALIZATION_EXAMPLE_DEMO_POLYMORPHIC_A_HPP\n\n/"
},
{
"path": "example/demo_portable_archive.cpp",
"chars": 2325,
"preview": "/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8\n//\n// demo_portable_archive.cpp\n//\n// ("
},
{
"path": "example/demo_save.xml",
"chars": 3496,
"preview": "<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\" ?>\n<!DOCTYPE boost_serialization>\n<boost_serialization signature=\""
},
{
"path": "example/demo_shared_ptr.cpp",
"chars": 4467,
"preview": "// demo_shared_ptr.cpp : demonstrates adding serialization to a template\n\n// (C) Copyright 2002 Robert Ramey - http://ww"
},
{
"path": "example/demo_simple_log.cpp",
"chars": 1982,
"preview": "/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8\n//\n// demo_log.cpp\n//\n// (C) Copyright "
},
{
"path": "example/demo_trivial_archive.cpp",
"chars": 2646,
"preview": "/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8\n//\n// demo_trivial_archive.cpp\n//\n// (C"
},
{
"path": "example/demo_xml.cpp",
"chars": 3333,
"preview": "/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8\n//\n// demo_xml.cpp\n//\n// (C) Copyright "
},
{
"path": "example/demo_xml.hpp",
"chars": 8943,
"preview": "#ifndef BOOST_SERIALIZATION_EXAMPLE_DEMO_XML_HPP\n#define BOOST_SERIALIZATION_EXAMPLE_DEMO_XML_HPP\n\n/////////1/////////2/"
},
{
"path": "example/demo_xml_load.cpp",
"chars": 1118,
"preview": "/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8\n//\n// demo_xml_load.cpp\n//\n// (C) Copyr"
},
{
"path": "example/demo_xml_save.cpp",
"chars": 2510,
"preview": "/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8\n//\n// demo_xml_save.cpp\n//\n// (C) Copyr"
},
{
"path": "example/demofile.txt",
"chars": 381,
"preview": "22 serialization::archive 3 0 2 0 0 6 0 0 0 0 6 24 4 1 0\n0 0 0 3 5 1 0\n1 0 0 0 0 34 135 52.560001 134 22 78.300003 11 24"
},
{
"path": "example/fix_six.cpp",
"chars": 1116,
"preview": "#include <fstream>\n#include <ios>\n#include <iostream>\n#include <boost/integer_traits.hpp>\n#include <boost/archive/binary"
},
{
"path": "example/log_archive.cpp",
"chars": 1128,
"preview": "/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8\n// log_archive.cpp:\n\n// (C) Copyright 2"
},
{
"path": "example/log_archive.hpp",
"chars": 3300,
"preview": "#ifndef LOG_ARCHIVE_HPP\n#define LOG_ARCHIVE_HPP\n\n// MS compatible compilers support #pragma once\n#if defined(_MSC_VER)\n#"
},
{
"path": "example/polymorphic_portable_binary_iarchive.cpp",
"chars": 1109,
"preview": "/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8\n// polymorphic_portable_binary_iarchive"
},
{
"path": "example/polymorphic_portable_binary_iarchive.hpp",
"chars": 1161,
"preview": "#ifndef BOOST_ARCHIVE_POLYMORPHIC_PORTABLE_BINARY_IARCHIVE_HPP\n#define BOOST_ARCHIVE_POLYMORPHIC_PORTABLE_BINARY_IARCHIV"
},
{
"path": "example/polymorphic_portable_binary_oarchive.cpp",
"chars": 1166,
"preview": "/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8\n// polymorphic_portable_binary_oarchive"
},
{
"path": "example/polymorphic_portable_binary_oarchive.hpp",
"chars": 1161,
"preview": "#ifndef BOOST_ARCHIVE_POLYMORPHIC_PORTABLE_BINARY_OARCHIVE_HPP\n#define BOOST_ARCHIVE_POLYMORPHIC_PORTABLE_BINARY_OARCHIV"
},
{
"path": "example/portable_binary_archive.hpp",
"chars": 1146,
"preview": "#ifndef PORTABLE_BINARY_ARCHIVE_HPP\n#define PORTABLE_BINARY_ARCHIVE_HPP\n\n// (C) Copyright 2002 Robert Ramey - http://www"
},
{
"path": "example/portable_binary_iarchive.cpp",
"chars": 3901,
"preview": "/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8\n// portable_binary_iarchive.cpp\n\n// (C)"
},
{
"path": "example/portable_binary_iarchive.hpp",
"chars": 6429,
"preview": "#ifndef PORTABLE_BINARY_IARCHIVE_HPP\n#define PORTABLE_BINARY_IARCHIVE_HPP\n\n// MS compatible compilers support #pragma on"
},
{
"path": "example/portable_binary_oarchive.cpp",
"chars": 2574,
"preview": "/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8\n// portable_binary_oarchive.cpp\n\n// (C)"
},
{
"path": "example/portable_binary_oarchive.hpp",
"chars": 5883,
"preview": "#ifndef PORTABLE_BINARY_OARCHIVE_HPP\n#define PORTABLE_BINARY_OARCHIVE_HPP\n\n// MS compatible compilers support #pragma on"
},
{
"path": "example/simple_log_archive.hpp",
"chars": 5123,
"preview": "#ifndef BOOST_SIMPLE_LOG_ARCHIVE_HPP\n#define BOOST_SIMPLE_LOG_ARCHIVE_HPP\n\n// MS compatible compilers support #pragma on"
},
{
"path": "include/boost/archive/archive_exception.hpp",
"chars": 4138,
"preview": "#ifndef BOOST_ARCHIVE_ARCHIVE_EXCEPTION_HPP\n#define BOOST_ARCHIVE_ARCHIVE_EXCEPTION_HPP\n\n// MS compatible compilers supp"
},
{
"path": "include/boost/archive/basic_archive.hpp",
"chars": 8425,
"preview": "#ifndef BOOST_ARCHIVE_BASIC_ARCHIVE_HPP\n#define BOOST_ARCHIVE_BASIC_ARCHIVE_HPP\n\n// MS compatible compilers support #pra"
},
{
"path": "include/boost/archive/basic_binary_iarchive.hpp",
"chars": 7749,
"preview": "#ifndef BOOST_ARCHIVE_BASIC_BINARY_IARCHIVE_HPP\n#define BOOST_ARCHIVE_BASIC_BINARY_IARCHIVE_HPP\n\n// MS compatible compil"
},
{
"path": "include/boost/archive/basic_binary_iprimitive.hpp",
"chars": 6378,
"preview": "#ifndef BOOST_ARCHIVE_BINARY_IPRIMITIVE_HPP\n#define BOOST_ARCHIVE_BINARY_IPRIMITIVE_HPP\n\n// MS compatible compilers supp"
},
{
"path": "include/boost/archive/basic_binary_oarchive.hpp",
"chars": 6288,
"preview": "#ifndef BOOST_ARCHIVE_BASIC_BINARY_OARCHIVE_HPP\n#define BOOST_ARCHIVE_BASIC_BINARY_OARCHIVE_HPP\n\n// MS compatible compil"
},
{
"path": "include/boost/archive/basic_binary_oprimitive.hpp",
"chars": 6163,
"preview": "#ifndef BOOST_ARCHIVE_BASIC_BINARY_OPRIMITIVE_HPP\n#define BOOST_ARCHIVE_BASIC_BINARY_OPRIMITIVE_HPP\n\n// MS compatible co"
},
{
"path": "include/boost/archive/basic_streambuf_locale_saver.hpp",
"chars": 2853,
"preview": "#ifndef BOOST_ARCHIVE_BASIC_STREAMBUF_LOCALE_SAVER_HPP\n#define BOOST_ARCHIVE_BASIC_STREAMBUF_LOCALE_SAVER_HPP\n\n// MS com"
},
{
"path": "include/boost/archive/basic_text_iarchive.hpp",
"chars": 3009,
"preview": "#ifndef BOOST_ARCHIVE_BASIC_TEXT_IARCHIVE_HPP\n#define BOOST_ARCHIVE_BASIC_TEXT_IARCHIVE_HPP\n\n// MS compatible compilers "
},
{
"path": "include/boost/archive/basic_text_iprimitive.hpp",
"chars": 4010,
"preview": "#ifndef BOOST_ARCHIVE_BASIC_TEXT_IPRIMITIVE_HPP\n#define BOOST_ARCHIVE_BASIC_TEXT_IPRIMITIVE_HPP\n\n// MS compatible compil"
},
{
"path": "include/boost/archive/basic_text_oarchive.hpp",
"chars": 3412,
"preview": "#ifndef BOOST_ARCHIVE_BASIC_TEXT_OARCHIVE_HPP\n#define BOOST_ARCHIVE_BASIC_TEXT_OARCHIVE_HPP\n\n// MS compatible compilers "
},
{
"path": "include/boost/archive/basic_text_oprimitive.hpp",
"chars": 7260,
"preview": "#ifndef BOOST_ARCHIVE_BASIC_TEXT_OPRIMITIVE_HPP\n#define BOOST_ARCHIVE_BASIC_TEXT_OPRIMITIVE_HPP\n\n// MS compatible compil"
},
{
"path": "include/boost/archive/basic_xml_archive.hpp",
"chars": 1634,
"preview": "#ifndef BOOST_ARCHIVE_BASIC_XML_TEXT_ARCHIVE_HPP\n#define BOOST_ARCHIVE_BASIC_XML_TEXT_ARCHIVE_HPP\n\n// MS compatible comp"
},
{
"path": "include/boost/archive/basic_xml_iarchive.hpp",
"chars": 4018,
"preview": "#ifndef BOOST_ARCHIVE_BASIC_XML_IARCHIVE_HPP\n#define BOOST_ARCHIVE_BASIC_XML_IARCHIVE_HPP\n\n// MS compatible compilers su"
},
{
"path": "include/boost/archive/basic_xml_oarchive.hpp",
"chars": 4334,
"preview": "#ifndef BOOST_ARCHIVE_BASIC_XML_OARCHIVE_HPP\n#define BOOST_ARCHIVE_BASIC_XML_OARCHIVE_HPP\n\n// MS compatible compilers su"
},
{
"path": "include/boost/archive/binary_iarchive.hpp",
"chars": 2023,
"preview": "#ifndef BOOST_ARCHIVE_BINARY_IARCHIVE_HPP\n#define BOOST_ARCHIVE_BINARY_IARCHIVE_HPP\n\n// MS compatible compilers support "
},
{
"path": "include/boost/archive/binary_iarchive_impl.hpp",
"chars": 2930,
"preview": "#ifndef BOOST_ARCHIVE_BINARY_IARCHIVE_IMPL_HPP\n#define BOOST_ARCHIVE_BINARY_IARCHIVE_IMPL_HPP\n\n// MS compatible compiler"
},
{
"path": "include/boost/archive/binary_oarchive.hpp",
"chars": 2020,
"preview": "#ifndef BOOST_ARCHIVE_BINARY_OARCHIVE_HPP\n#define BOOST_ARCHIVE_BINARY_OARCHIVE_HPP\n\n// MS compatible compilers support "
},
{
"path": "include/boost/archive/binary_oarchive_impl.hpp",
"chars": 2959,
"preview": "#ifndef BOOST_ARCHIVE_BINARY_OARCHIVE_IMPL_HPP\n#define BOOST_ARCHIVE_BINARY_OARCHIVE_IMPL_HPP\n\n// MS compatible compiler"
},
{
"path": "include/boost/archive/binary_wiarchive.hpp",
"chars": 1701,
"preview": "#ifndef BOOST_ARCHIVE_BINARY_WIARCHIVE_HPP\n#define BOOST_ARCHIVE_BINARY_WIARCHIVE_HPP\n\n// MS compatible compilers suppor"
},
{
"path": "include/boost/archive/binary_woarchive.hpp",
"chars": 1888,
"preview": "#ifndef BOOST_ARCHIVE_BINARY_WOARCHIVE_HPP\n#define BOOST_ARCHIVE_BINARY_WOARCHIVE_HPP\n\n// MS compatible compilers suppor"
},
{
"path": "include/boost/archive/codecvt_null.hpp",
"chars": 3377,
"preview": "#ifndef BOOST_ARCHIVE_CODECVT_NULL_HPP\n#define BOOST_ARCHIVE_CODECVT_NULL_HPP\n\n// MS compatible compilers support #pragm"
},
{
"path": "include/boost/archive/detail/abi_prefix.hpp",
"chars": 592,
"preview": "/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8\n// abi_prefix.hpp\n\n// (C) Copyright 200"
},
{
"path": "include/boost/archive/detail/abi_suffix.hpp",
"chars": 544,
"preview": "/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8\n// abi_suffix.hpp\n\n// (C) Copyright 200"
},
{
"path": "include/boost/archive/detail/archive_serializer_map.hpp",
"chars": 1711,
"preview": "#ifndef BOOST_ARCHIVE_SERIALIZER_MAP_HPP\n#define BOOST_ARCHIVE_SERIALIZER_MAP_HPP\n\n// MS compatible compilers support #p"
},
{
"path": "include/boost/archive/detail/auto_link_archive.hpp",
"chars": 1687,
"preview": "#ifndef BOOST_ARCHIVE_DETAIL_AUTO_LINK_ARCHIVE_HPP\n#define BOOST_ARCHIVE_DETAIL_AUTO_LINK_ARCHIVE_HPP\n\n// MS compatible "
},
{
"path": "include/boost/archive/detail/auto_link_warchive.hpp",
"chars": 1550,
"preview": "#ifndef BOOST_ARCHIVE_DETAIL_AUTO_LINK_WARCHIVE_HPP\n#define BOOST_ARCHIVE_DETAIL_AUTO_LINK_WARCHIVE_HPP\n\n// MS compatibl"
},
{
"path": "include/boost/archive/detail/basic_iarchive.hpp",
"chars": 3612,
"preview": "#ifndef BOOST_ARCHIVE_DETAIL_BASIC_IARCHIVE_HPP\n#define BOOST_ARCHIVE_DETAIL_BASIC_IARCHIVE_HPP\n\n// MS compatible compil"
},
{
"path": "include/boost/archive/detail/basic_iserializer.hpp",
"chars": 2701,
"preview": "#ifndef BOOST_ARCHIVE_DETAIL_BASIC_ISERIALIZER_HPP\n#define BOOST_ARCHIVE_DETAIL_BASIC_ISERIALIZER_HPP\n\n// MS compatible "
},
{
"path": "include/boost/archive/detail/basic_oarchive.hpp",
"chars": 3308,
"preview": "#ifndef BOOST_ARCHIVE_BASIC_OARCHIVE_HPP\n#define BOOST_ARCHIVE_BASIC_OARCHIVE_HPP\n\n// MS compatible compilers support #p"
},
{
"path": "include/boost/archive/detail/basic_oserializer.hpp",
"chars": 2593,
"preview": "#ifndef BOOST_SERIALIZATION_BASIC_OSERIALIZER_HPP\n#define BOOST_SERIALIZATION_BASIC_OSERIALIZER_HPP\n\n// MS compatible co"
},
{
"path": "include/boost/archive/detail/basic_pointer_iserializer.hpp",
"chars": 2045,
"preview": "#ifndef BOOST_ARCHIVE_BASIC_POINTER_ISERIALIZER_HPP\n#define BOOST_ARCHIVE_BASIC_POINTER_ISERIALIZER_HPP\n\n// MS compatibl"
},
{
"path": "include/boost/archive/detail/basic_pointer_oserializer.hpp",
"chars": 1938,
"preview": "#ifndef BOOST_ARCHIVE_BASIC_POINTER_OSERIALIZER_HPP\n#define BOOST_ARCHIVE_BASIC_POINTER_OSERIALIZER_HPP\n\n// MS compatibl"
},
{
"path": "include/boost/archive/detail/basic_serializer.hpp",
"chars": 2154,
"preview": "#ifndef BOOST_ARCHIVE_BASIC_SERIALIZER_HPP\n#define BOOST_ARCHIVE_BASIC_SERIALIZER_HPP\n\n// MS compatible compilers suppo"
},
{
"path": "include/boost/archive/detail/basic_serializer_map.hpp",
"chars": 1921,
"preview": "#ifndef BOOST_SERIALIZER_MAP_HPP\n#define BOOST_SERIALIZER_MAP_HPP\n\n// MS compatible compilers support #pragma once\n#if "
},
{
"path": "include/boost/archive/detail/check.hpp",
"chars": 5420,
"preview": "#ifndef BOOST_ARCHIVE_DETAIL_CHECK_HPP\n#define BOOST_ARCHIVE_DETAIL_CHECK_HPP\n\n// MS compatible compilers support #pragm"
},
{
"path": "include/boost/archive/detail/common_iarchive.hpp",
"chars": 2513,
"preview": "#ifndef BOOST_ARCHIVE_DETAIL_COMMON_IARCHIVE_HPP\n#define BOOST_ARCHIVE_DETAIL_COMMON_IARCHIVE_HPP\n\n// MS compatible comp"
},
{
"path": "include/boost/archive/detail/common_oarchive.hpp",
"chars": 2498,
"preview": "#ifndef BOOST_ARCHIVE_DETAIL_COMMON_OARCHIVE_HPP\n#define BOOST_ARCHIVE_DETAIL_COMMON_OARCHIVE_HPP\n\n// MS compatible comp"
},
{
"path": "include/boost/archive/detail/decl.hpp",
"chars": 1741,
"preview": "#ifndef BOOST_ARCHIVE_DETAIL_DECL_HPP\n#define BOOST_ARCHIVE_DETAIL_DECL_HPP\n\n// MS compatible compilers support #pragma "
},
{
"path": "include/boost/archive/detail/helper_collection.hpp",
"chars": 2924,
"preview": "#ifndef BOOST_ARCHIVE_DETAIL_HELPER_COLLECTION_HPP\n#define BOOST_ARCHIVE_DETAIL_HELPER_COLLECTION_HPP\n\n// MS compatible "
},
{
"path": "include/boost/archive/detail/interface_iarchive.hpp",
"chars": 2525,
"preview": "#ifndef BOOST_ARCHIVE_DETAIL_INTERFACE_IARCHIVE_HPP\n#define BOOST_ARCHIVE_DETAIL_INTERFACE_IARCHIVE_HPP\n\n// MS compatibl"
},
{
"path": "include/boost/archive/detail/interface_oarchive.hpp",
"chars": 2530,
"preview": "#ifndef BOOST_ARCHIVE_DETAIL_INTERFACE_OARCHIVE_HPP\n#define BOOST_ARCHIVE_DETAIL_INTERFACE_OARCHIVE_HPP\n\n// MS compatibl"
},
{
"path": "include/boost/archive/detail/iserializer.hpp",
"chars": 21104,
"preview": "#ifndef BOOST_ARCHIVE_DETAIL_ISERIALIZER_HPP\n#define BOOST_ARCHIVE_DETAIL_ISERIALIZER_HPP\n\n// MS compatible compilers su"
},
{
"path": "include/boost/archive/detail/oserializer.hpp",
"chars": 17624,
"preview": "#ifndef BOOST_ARCHIVE_OSERIALIZER_HPP\n#define BOOST_ARCHIVE_OSERIALIZER_HPP\n\n// MS compatible compilers support #pragma "
},
{
"path": "include/boost/archive/detail/polymorphic_iarchive_route.hpp",
"chars": 6942,
"preview": "#ifndef BOOST_ARCHIVE_DETAIL_POLYMORPHIC_IARCHIVE_ROUTE_HPP\n#define BOOST_ARCHIVE_DETAIL_POLYMORPHIC_IARCHIVE_ROUTE_HPP\n"
},
{
"path": "include/boost/archive/detail/polymorphic_oarchive_route.hpp",
"chars": 6583,
"preview": "#ifndef BOOST_ARCHIVE_DETAIL_POLYMORPHIC_OARCHIVE_ROUTE_HPP\n#define BOOST_ARCHIVE_DETAIL_POLYMORPHIC_OARCHIVE_ROUTE_HPP\n"
},
{
"path": "include/boost/archive/detail/register_archive.hpp",
"chars": 3694,
"preview": "// Copyright David Abrahams 2006. Distributed under the Boost\n// Software License, Version 1.0. (See accompanying\n// fil"
},
{
"path": "include/boost/archive/detail/utf8_codecvt_facet.hpp",
"chars": 923,
"preview": "// Copyright (c) 2001 Ronald Garcia, Indiana University (garcia@osl.iu.edu)\n// Andrew Lumsdaine, Indiana University (lum"
},
{
"path": "include/boost/archive/dinkumware.hpp",
"chars": 5368,
"preview": "#ifndef BOOST_ARCHIVE_DINKUMWARE_HPP\n#define BOOST_ARCHIVE_DINKUMWARE_HPP\n\n// MS compatible compilers support #pragma on"
},
{
"path": "include/boost/archive/impl/archive_serializer_map.ipp",
"chars": 2347,
"preview": "/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8\n// archive_serializer_map.ipp:\n\n// (C) "
},
{
"path": "include/boost/archive/impl/basic_binary_iarchive.ipp",
"chars": 4362,
"preview": "/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8\n// basic_binary_iarchive.ipp:\n\n// (C) C"
},
{
"path": "include/boost/archive/impl/basic_binary_iprimitive.ipp",
"chars": 5097,
"preview": "/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8\n// basic_binary_iprimitive.ipp:\n\n// (C)"
},
{
"path": "include/boost/archive/impl/basic_binary_oarchive.ipp",
"chars": 1304,
"preview": "/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8\n// basic_binary_oarchive.ipp:\n\n// (C) C"
},
{
"path": "include/boost/archive/impl/basic_binary_oprimitive.ipp",
"chars": 3735,
"preview": "/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8\n// basic_binary_oprimitive.ipp:\n\n// (C)"
},
{
"path": "include/boost/archive/impl/basic_text_iarchive.ipp",
"chars": 2535,
"preview": "/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8\n// basic_text_iarchive.ipp:\n\n// (C) Cop"
},
{
"path": "include/boost/archive/impl/basic_text_iprimitive.ipp",
"chars": 3535,
"preview": "/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8\n// basic_text_iprimitive.ipp:\n\n// (C) C"
},
{
"path": "include/boost/archive/impl/basic_text_oarchive.ipp",
"chars": 1675,
"preview": "/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8\n// basic_text_oarchive.ipp:\n\n// (C) Cop"
},
{
"path": "include/boost/archive/impl/basic_text_oprimitive.ipp",
"chars": 2986,
"preview": "/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8\n// basic_text_oprimitive.ipp:\n\n// (C) C"
},
{
"path": "include/boost/archive/impl/basic_xml_grammar.hpp",
"chars": 5141,
"preview": "#ifndef BOOST_ARCHIVE_BASIC_XML_GRAMMAR_HPP\n#define BOOST_ARCHIVE_BASIC_XML_GRAMMAR_HPP\n\n// MS compatible compilers supp"
},
{
"path": "include/boost/archive/impl/basic_xml_iarchive.ipp",
"chars": 3721,
"preview": "/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8\n// basic_xml_iarchive.ipp:\n\n// (C) Copy"
},
{
"path": "include/boost/archive/impl/basic_xml_oarchive.ipp",
"chars": 7673,
"preview": "/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8\n// basic_xml_oarchive.ipp:\n\n// (C) Copy"
},
{
"path": "include/boost/archive/impl/text_iarchive_impl.ipp",
"chars": 3095,
"preview": "/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8\n// text_iarchive_impl.ipp:\n\n// (C) Copy"
},
{
"path": "include/boost/archive/impl/text_oarchive_impl.ipp",
"chars": 2884,
"preview": "/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8\n// text_oarchive_impl.ipp:\n\n// (C) Copy"
},
{
"path": "include/boost/archive/impl/text_wiarchive_impl.ipp",
"chars": 2802,
"preview": "/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8\n// text_text_wiarchive_impl.ipp:\n\n// (C"
},
{
"path": "include/boost/archive/impl/text_woarchive_impl.ipp",
"chars": 2155,
"preview": "/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8\n// text_woarchive_impl.ipp:\n\n// (C) Cop"
},
{
"path": "include/boost/archive/impl/xml_iarchive_impl.ipp",
"chars": 5713,
"preview": "/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8\n// xml_iarchive_impl.cpp:\n\n// (C) Copyr"
},
{
"path": "include/boost/archive/impl/xml_oarchive_impl.ipp",
"chars": 4094,
"preview": "/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8\n// xml_oarchive_impl.ipp:\n\n// (C) Copyr"
},
{
"path": "include/boost/archive/impl/xml_wiarchive_impl.ipp",
"chars": 5245,
"preview": "/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8\n// xml_wiarchive_impl.ipp:\n\n// (C) Copy"
},
{
"path": "include/boost/archive/impl/xml_woarchive_impl.ipp",
"chars": 4647,
"preview": "/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8\n// xml_woarchive_impl.ipp:\n\n// (C) Copy"
},
{
"path": "include/boost/archive/iterators/base64_exception.hpp",
"chars": 1895,
"preview": "#ifndef BOOST_ARCHIVE_ITERATORS_BASE64_EXCEPTION_HPP\n#define BOOST_ARCHIVE_ITERATORS_BASE64_EXCEPTION_HPP\n\n// MS compati"
},
{
"path": "include/boost/archive/iterators/base64_from_binary.hpp",
"chars": 3185,
"preview": "#ifndef BOOST_ARCHIVE_ITERATORS_BASE64_FROM_BINARY_HPP\n#define BOOST_ARCHIVE_ITERATORS_BASE64_FROM_BINARY_HPP\n\n// MS com"
},
{
"path": "include/boost/archive/iterators/binary_from_base64.hpp",
"chars": 3837,
"preview": "#ifndef BOOST_ARCHIVE_ITERATORS_BINARY_FROM_BASE64_HPP\n#define BOOST_ARCHIVE_ITERATORS_BINARY_FROM_BASE64_HPP\n\n// MS com"
},
{
"path": "include/boost/archive/iterators/dataflow.hpp",
"chars": 2705,
"preview": "#ifndef BOOST_ARCHIVE_ITERATORS_DATAFLOW_HPP\n#define BOOST_ARCHIVE_ITERATORS_DATAFLOW_HPP\n\n// MS compatible compilers su"
},
{
"path": "include/boost/archive/iterators/dataflow_exception.hpp",
"chars": 2290,
"preview": "#ifndef BOOST_ARCHIVE_ITERATORS_DATAFLOW_EXCEPTION_HPP\n#define BOOST_ARCHIVE_ITERATORS_DATAFLOW_EXCEPTION_HPP\n\n// MS com"
},
{
"path": "include/boost/archive/iterators/escape.hpp",
"chars": 3098,
"preview": "#ifndef BOOST_ARCHIVE_ITERATORS_ESCAPE_HPP\n#define BOOST_ARCHIVE_ITERATORS_ESCAPE_HPP\n\n// MS compatible compilers suppor"
},
{
"path": "include/boost/archive/iterators/insert_linebreaks.hpp",
"chars": 2664,
"preview": "#ifndef BOOST_ARCHIVE_ITERATORS_INSERT_LINEBREAKS_HPP\n#define BOOST_ARCHIVE_ITERATORS_INSERT_LINEBREAKS_HPP\n\n// MS compa"
},
{
"path": "include/boost/archive/iterators/istream_iterator.hpp",
"chars": 2519,
"preview": "#ifndef BOOST_ARCHIVE_ITERATORS_ISTREAM_ITERATOR_HPP\n#define BOOST_ARCHIVE_ITERATORS_ISTREAM_ITERATOR_HPP\n\n// MS compati"
},
{
"path": "include/boost/archive/iterators/mb_from_wchar.hpp",
"chars": 3936,
"preview": "#ifndef BOOST_ARCHIVE_ITERATORS_MB_FROM_WCHAR_HPP\n#define BOOST_ARCHIVE_ITERATORS_MB_FROM_WCHAR_HPP\n\n// MS compatible co"
},
{
"path": "include/boost/archive/iterators/ostream_iterator.hpp",
"chars": 2391,
"preview": "#ifndef BOOST_ARCHIVE_ITERATORS_OSTREAM_ITERATOR_HPP\n#define BOOST_ARCHIVE_ITERATORS_OSTREAM_ITERATOR_HPP\n\n// MS compati"
},
{
"path": "include/boost/archive/iterators/remove_whitespace.hpp",
"chars": 4544,
"preview": "#ifndef BOOST_ARCHIVE_ITERATORS_REMOVE_WHITESPACE_HPP\n#define BOOST_ARCHIVE_ITERATORS_REMOVE_WHITESPACE_HPP\n\n// MS compa"
},
{
"path": "include/boost/archive/iterators/transform_width.hpp",
"chars": 5531,
"preview": "#ifndef BOOST_ARCHIVE_ITERATORS_TRANSFORM_WIDTH_HPP\n#define BOOST_ARCHIVE_ITERATORS_TRANSFORM_WIDTH_HPP\n\n// MS compatibl"
},
{
"path": "include/boost/archive/iterators/unescape.hpp",
"chars": 2335,
"preview": "#ifndef BOOST_ARCHIVE_ITERATORS_UNESCAPE_HPP\n#define BOOST_ARCHIVE_ITERATORS_UNESCAPE_HPP\n\n// MS compatible compilers su"
},
{
"path": "include/boost/archive/iterators/wchar_from_mb.hpp",
"chars": 5764,
"preview": "#ifndef BOOST_ARCHIVE_ITERATORS_WCHAR_FROM_MB_HPP\n#define BOOST_ARCHIVE_ITERATORS_WCHAR_FROM_MB_HPP\n\n// MS compatible co"
},
{
"path": "include/boost/archive/iterators/xml_escape.hpp",
"chars": 2937,
"preview": "#ifndef BOOST_ARCHIVE_ITERATORS_XML_ESCAPE_HPP\n#define BOOST_ARCHIVE_ITERATORS_XML_ESCAPE_HPP\n\n// MS compatible compiler"
},
{
"path": "include/boost/archive/iterators/xml_unescape.hpp",
"chars": 3676,
"preview": "#ifndef BOOST_ARCHIVE_ITERATORS_XML_UNESCAPE_HPP\n#define BOOST_ARCHIVE_ITERATORS_XML_UNESCAPE_HPP\n\n// MS compatible comp"
},
{
"path": "include/boost/archive/iterators/xml_unescape_exception.hpp",
"chars": 1328,
"preview": "#ifndef BOOST_ARCHIVE_ITERATORS_XML_UNESCAPE_EXCEPTION_HPP\n#define BOOST_ARCHIVE_ITERATORS_XML_UNESCAPE_EXCEPTION_HPP\n\n/"
},
{
"path": "include/boost/archive/polymorphic_binary_iarchive.hpp",
"chars": 1511,
"preview": "#ifndef BOOST_ARCHIVE_POLYMORPHIC_BINARY_IARCHIVE_HPP\n#define BOOST_ARCHIVE_POLYMORPHIC_BINARY_IARCHIVE_HPP\n\n// MS compa"
},
{
"path": "include/boost/archive/polymorphic_binary_oarchive.hpp",
"chars": 1375,
"preview": "#ifndef BOOST_ARCHIVE_POLYMORPHIC_BINARY_OARCHIVE_HPP\n#define BOOST_ARCHIVE_POLYMORPHIC_BINARY_OARCHIVE_HPP\n\n// MS compa"
},
{
"path": "include/boost/archive/polymorphic_iarchive.hpp",
"chars": 5257,
"preview": "#ifndef BOOST_ARCHIVE_POLYMORPHIC_IARCHIVE_HPP\n#define BOOST_ARCHIVE_POLYMORPHIC_IARCHIVE_HPP\n\n// MS compatible compiler"
},
{
"path": "include/boost/archive/polymorphic_oarchive.hpp",
"chars": 4806,
"preview": "#ifndef BOOST_ARCHIVE_POLYMORPHIC_OARCHIVE_HPP\n#define BOOST_ARCHIVE_POLYMORPHIC_OARCHIVE_HPP\n\n// MS compatible compiler"
},
{
"path": "include/boost/archive/polymorphic_text_iarchive.hpp",
"chars": 1489,
"preview": "#ifndef BOOST_ARCHIVE_POLYMORPHIC_TEXT_IARCHIVE_HPP\n#define BOOST_ARCHIVE_POLYMORPHIC_TEXT_IARCHIVE_HPP\n\n// MS compatibl"
},
{
"path": "include/boost/archive/polymorphic_text_oarchive.hpp",
"chars": 1353,
"preview": "#ifndef BOOST_ARCHIVE_POLYMORPHIC_TEXT_OARCHIVE_HPP\n#define BOOST_ARCHIVE_POLYMORPHIC_TEXT_OARCHIVE_HPP\n\n// MS compatibl"
},
{
"path": "include/boost/archive/polymorphic_text_wiarchive.hpp",
"chars": 1627,
"preview": "#ifndef BOOST_ARCHIVE_POLYMORPHIC_TEXT_WIARCHIVE_HPP\n#define BOOST_ARCHIVE_POLYMORPHIC_TEXT_WIARCHIVE_HPP\n\n// MS compati"
},
{
"path": "include/boost/archive/polymorphic_text_woarchive.hpp",
"chars": 1490,
"preview": "#ifndef BOOST_ARCHIVE_POLYMORPHIC_TEXT_WOARCHIVE_HPP\n#define BOOST_ARCHIVE_POLYMORPHIC_TEXT_WOARCHIVE_HPP\n\n// MS compati"
},
{
"path": "include/boost/archive/polymorphic_xml_iarchive.hpp",
"chars": 1478,
"preview": "#ifndef BOOST_ARCHIVE_POLYMORPHIC_XML_IARCHIVE_HPP\n#define BOOST_ARCHIVE_POLYMORPHIC_XML_IARCHIVE_HPP\n\n// MS compatible "
},
{
"path": "include/boost/archive/polymorphic_xml_oarchive.hpp",
"chars": 1341,
"preview": "#ifndef BOOST_ARCHIVE_POLYMORPHIC_XML_OARCHIVE_HPP\n#define BOOST_ARCHIVE_POLYMORPHIC_XML_OARCHIVE_HPP\n\n// MS compatible "
},
{
"path": "include/boost/archive/polymorphic_xml_wiarchive.hpp",
"chars": 1480,
"preview": "#ifndef BOOST_ARCHIVE_POLYMORPHIC_XML_WIARCHIVE_HPP\n#define BOOST_ARCHIVE_POLYMORPHIC_XML_WIARCHIVE_HPP\n\n// MS compatibl"
},
{
"path": "include/boost/archive/polymorphic_xml_woarchive.hpp",
"chars": 1480,
"preview": "#ifndef BOOST_ARCHIVE_POLYMORPHIC_XML_WOARCHIVE_HPP\n#define BOOST_ARCHIVE_POLYMORPHIC_XML_WOARCHIVE_HPP\n\n// MS compatibl"
},
{
"path": "include/boost/archive/text_iarchive.hpp",
"chars": 3565,
"preview": "#ifndef BOOST_ARCHIVE_TEXT_IARCHIVE_HPP\n#define BOOST_ARCHIVE_TEXT_IARCHIVE_HPP\n\n// MS compatible compilers support #pra"
},
{
"path": "include/boost/archive/text_oarchive.hpp",
"chars": 3593,
"preview": "#ifndef BOOST_ARCHIVE_TEXT_OARCHIVE_HPP\n#define BOOST_ARCHIVE_TEXT_OARCHIVE_HPP\n\n// MS compatible compilers support #pra"
},
{
"path": "include/boost/archive/text_wiarchive.hpp",
"chars": 3718,
"preview": "#ifndef BOOST_ARCHIVE_TEXT_WIARCHIVE_HPP\n#define BOOST_ARCHIVE_TEXT_WIARCHIVE_HPP\n\n// MS compatible compilers support #p"
},
{
"path": "include/boost/archive/text_woarchive.hpp",
"chars": 4453,
"preview": "#ifndef BOOST_ARCHIVE_TEXT_WOARCHIVE_HPP\n#define BOOST_ARCHIVE_TEXT_WOARCHIVE_HPP\n\n// MS compatible compilers support #p"
}
]
// ... and 340 more files (download for full content)
About this extraction
This page contains the full source code of the boostorg/serialization GitHub repository, extracted and formatted as plain text for AI agents and large language models (LLMs). The extraction includes 540 files (2.1 MB), approximately 576.4k tokens, and a symbol index with 3195 extracted functions, classes, methods, constants, and types. Use this with OpenClaw, Claude, ChatGPT, Cursor, Windsurf, or any other AI tool that accepts text input. You can copy the full output to your clipboard or download it as a .txt file.
Extracted by GitExtract — free GitHub repo to text converter for AI. Built by Nikandr Surkov.