mirror of
https://github.com/boostorg/serialization.git
synced 2026-07-21 13:33:32 +00:00
Compare commits
1 Commits
| Author | SHA1 | Date | |
|---|---|---|---|
 Beman Dawes
|
803040c8d4 |
-72
@@ -1,72 +0,0 @@
|
||||
# Copyright 2016 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
|
||||
|
||||
os:
|
||||
- linux
|
||||
- osx
|
||||
|
||||
branches:
|
||||
only:
|
||||
- master
|
||||
- develop
|
||||
|
||||
install:
|
||||
- cd ..
|
||||
- git clone -b $TRAVIS_BRANCH --depth 1 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/core
|
||||
- git submodule init libs/detail
|
||||
- git submodule init libs/filesystem
|
||||
- git submodule init libs/function
|
||||
- git submodule init libs/functional
|
||||
- git submodule init libs/integer
|
||||
- git submodule init libs/intrusive
|
||||
- git submodule init libs/io
|
||||
- git submodule init libs/iterator
|
||||
- git submodule init libs/lexical_cast
|
||||
- git submodule init libs/math
|
||||
- git submodule init libs/move
|
||||
- git submodule init libs/mpl
|
||||
- git submodule init libs/numeric/conversion
|
||||
- git submodule init libs/optional
|
||||
- git submodule init libs/predef
|
||||
- git submodule init libs/preprocessor
|
||||
- git submodule init libs/range
|
||||
- git submodule init libs/smart_ptr
|
||||
- git submodule init libs/spirit
|
||||
- git submodule init libs/static_assert
|
||||
- git submodule init libs/system
|
||||
- git submodule init libs/throw_exception
|
||||
- git submodule init libs/tuple
|
||||
- git submodule init libs/type_index
|
||||
- git submodule init libs/type_traits
|
||||
- git submodule init libs/unordered
|
||||
- git submodule init libs/utility
|
||||
- git submodule init libs/variant
|
||||
- git submodule init tools/build
|
||||
- git submodule update --depth 1
|
||||
- cp -r $TRAVIS_BUILD_DIR/* libs/serialization
|
||||
- ./bootstrap.sh
|
||||
- ./b2 headers
|
||||
|
||||
script:
|
||||
- TOOLSET=gcc,clang
|
||||
- if [ $TRAVIS_OS_NAME == osx ]; then TOOLSET=clang; fi
|
||||
- ./b2 libs/serialization/test toolset=$TOOLSET
|
||||
|
||||
notifications:
|
||||
email:
|
||||
on_success: always
|
||||
@@ -1,434 +0,0 @@
|
||||
# CMake build control file for Serialization Library tests
|
||||
|
||||
cmake_minimum_required(VERSION 3.0)
|
||||
|
||||
if (POLICY CMP0054)
|
||||
cmake_policy (SET CMP0054 NEW)
|
||||
endif (POLICY CMP0054)
|
||||
|
||||
if (POLICY CMP0063)
|
||||
cmake_policy (SET CMP0063 NEW)
|
||||
endif (POLICY CMP0063)
|
||||
|
||||
if(Boost_USE_STATIC_LIBS)
|
||||
project("Serialization-Static")
|
||||
else()
|
||||
project("Serialization-Shared")
|
||||
endif()
|
||||
|
||||
#
|
||||
# Compiler settings
|
||||
#
|
||||
|
||||
message(STATUS "compiler is ${CMAKE_CXX_COMPILER_ID}" )
|
||||
add_definitions(${Boost_LIB_DIAGNOSTIC_DEFINITIONS})
|
||||
|
||||
if( CMAKE_CXX_COMPILER_ID STREQUAL "GNU" )
|
||||
add_definitions( -ftemplate-depth=300 )
|
||||
# we use gcc to test for C++03 compatibility
|
||||
add_definitions( -std=c++03 )
|
||||
message(STATUS "compiler is g++ c++03")
|
||||
set(COMPILER_SUPPORTS_CXX11 FALSE)
|
||||
elseif( CMAKE_CXX_COMPILER_ID STREQUAL "MSVC" )
|
||||
add_definitions( /wd4996 )
|
||||
message(STATUS "compiler is MSVC")
|
||||
set(COMPILER_SUPPORTS_CXX11 TRUE)
|
||||
elseif( CMAKE_CXX_COMPILER_ID STREQUAL "AppleClang" )
|
||||
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -ftemplate-depth=300")
|
||||
#set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++98")
|
||||
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++11")
|
||||
set(CMAKE_CXX_FLAGS_DEBUG "-g -O0" )
|
||||
set(CMAKE_CXX_FLAGS_RELWITHDEBINFO "-g -O3" )
|
||||
set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -stdlib=libc++ -dead_strip")
|
||||
set(COMPILER_SUPPORTS_CXX11 TRUE)
|
||||
endif()
|
||||
|
||||
#
|
||||
# IDE settings
|
||||
#
|
||||
|
||||
if( CMAKE_HOST_APPLE )
|
||||
# note: it seems that bjam builds both address models in any case
|
||||
# so we can defer this decision to the IDE just as we do for debug/release
|
||||
# so we'll not use this now
|
||||
# set(Boost_ADDRESS_MODEL 64 CACHE INTEGER "32/64 bits")
|
||||
set(Boost_USE_STATIC_LIBS ON CACHE BOOL "Link to Boost static libraries")
|
||||
set(Boost_USE_MULTITHREADED ON)
|
||||
else()
|
||||
set(Boost_ADDRESS_MODEL 64 CACHE INTEGER "32/64 bits")
|
||||
set(Boost_USE_STATIC_LIBS ON CACHE BOOL "Link to Boost static libraries")
|
||||
set(Boost_USE_MULTITHREADED ON)
|
||||
endif()
|
||||
|
||||
#
|
||||
# Locate Project Prerequisites
|
||||
#
|
||||
|
||||
# Boost
|
||||
|
||||
# note: we're assuming that boost has been built with:
|
||||
# ./b2 —-layout=versioned toolset=clang-darwin link=static,shared variant=debug,release stage
|
||||
|
||||
###########################
|
||||
# special notes for Xcode.
|
||||
|
||||
# these three should result in CMake setting the variables
|
||||
# Boost_SERIALIZATION_LIBRARY_DEBUG … to the correct values.
|
||||
|
||||
# But my current version of CMake doesn't automatically set the library names
|
||||
# to point to the the libraries to be used. The variables are created
|
||||
# but they are not initialized. So be prepared to set these variables by hand.
|
||||
# If you want to use the static libraries - point to the boost libraries ending
|
||||
# in ".a". If you want to use the shared boost libraries - point to the libraries
|
||||
# ending in ".dylib".
|
||||
|
||||
# But wait - there's more.
|
||||
# if both lib.a and lib.dylib both exist in the library directory, Xcode will
|
||||
# automatically chose the *.dylib one - and there's nothing you can do to fix this.
|
||||
# So my recommendation is
|
||||
# a) to place the compiled libraries in two different directories
|
||||
# - e.g. stage/lib-static/*.a and stage/lib-shared/*.dylib
|
||||
# and set the CMake variable Boost_LIBRARY_DIR to point to one or the other
|
||||
# b) create two different CMake build directories - build-static and build-shared
|
||||
# and switch between projects as desired. I like to test both since
|
||||
# there are things like dead code elimination and visibility which vary
|
||||
# between the two environments.
|
||||
#
|
||||
# caveat - as I write this, I've been unable to get the tests on the shared
|
||||
# library to function. Problem is that one needs to either put the shared
|
||||
# libraries in a special known place or set an environmental
|
||||
# variable which points to the shared library directory. I prefer the latter
|
||||
# but I've been unable to figure out how to get Xcode to do on a global basis
|
||||
# and it's not practical to do this for 247 test targets one at a time.
|
||||
|
||||
# c) The targets in the project will by default be built as universal 32/64 binaries
|
||||
# I have yet to experiment with these yet so I just set the target to 64 bit.
|
||||
|
||||
# end special note for Xcode
|
||||
############################
|
||||
|
||||
set(Boost_DEBUG true)
|
||||
set(Boost_DETAILED_FAILURE_MSG true)
|
||||
set(Boost_FOUND true)
|
||||
|
||||
find_package(Boost REQUIRED COMPONENTS system filesystem program_options)
|
||||
include(CheckIncludeFileCXX)
|
||||
|
||||
message(STATUS "Boost_FOUND is ${Boost_FOUND}")
|
||||
|
||||
if(Boost_FOUND)
|
||||
message(STATUS "Boost Found!")
|
||||
message(STATUS "Boost is ${BOOST_ROOT}")
|
||||
message(STATUS "Boost directories found at ${Boost_INCLUDE_DIRS}")
|
||||
message(STATUS "Boost libraries found at ${Boost_LIBRARY_DIRS}")
|
||||
message(STATUS "Boost libraries prefix is ${Boost_LIB_PREFIX}")
|
||||
message(STATUS "Boost component libraries to be linked are ${Boost_LIBRARIES}")
|
||||
message(STATUS "Boost version found is ${Boost_VERSION}")
|
||||
#include_directories("../include" "${Boost_INCLUDE_DIRS}")
|
||||
#link_directories("${Boost_LIBRARY_DIRS}")
|
||||
else()
|
||||
message(STATUS "Boost NOT Found!")
|
||||
endif()
|
||||
|
||||
if(Boost_USE_STATIC_LIBS)
|
||||
message(STATUS "Use static libraries")
|
||||
set(LINK_TYPE "STATIC")
|
||||
else()
|
||||
message(STATUS "Building shared libraries")
|
||||
set(LINK_TYPE "SHARED")
|
||||
add_definitions( "-DBOOST_ALL_DYN_LINK=1")
|
||||
add_definitions( "-DBOOST_ALL_NO_LIB=1")
|
||||
add_definitions( "-DBOOST_LIB_DIAGNOSTICS=1")
|
||||
set(CMAKE_CXX_VISIBILITY_PRESET hidden)
|
||||
set(VISIBILITY_INLINES_HIDDEN)
|
||||
endif()
|
||||
|
||||
###########################
|
||||
# library builds
|
||||
|
||||
add_library(serialization ${LINK_TYPE}
|
||||
../src/archive_exception.cpp
|
||||
../src/basic_archive.cpp
|
||||
../src/basic_iarchive.cpp
|
||||
../src/basic_iserializer.cpp
|
||||
../src/basic_oarchive.cpp
|
||||
../src/basic_oserializer.cpp
|
||||
../src/basic_pointer_iserializer.cpp
|
||||
../src/basic_pointer_oserializer.cpp
|
||||
../src/basic_serializer_map.cpp
|
||||
../src/basic_text_iprimitive.cpp
|
||||
../src/basic_text_oprimitive.cpp
|
||||
../src/basic_xml_archive.cpp
|
||||
../src/binary_iarchive.cpp
|
||||
../src/binary_oarchive.cpp
|
||||
../src/extended_type_info_no_rtti.cpp
|
||||
../src/extended_type_info_typeid.cpp
|
||||
../src/extended_type_info.cpp
|
||||
../src/polymorphic_iarchive.cpp
|
||||
../src/polymorphic_oarchive.cpp
|
||||
../src/singleton.cpp
|
||||
../src/stl_port.cpp
|
||||
../src/text_iarchive.cpp
|
||||
../src/text_oarchive.cpp
|
||||
../src/void_cast.cpp
|
||||
../src/xml_archive_exception.cpp
|
||||
../src/xml_iarchive.cpp
|
||||
../src/xml_oarchive.cpp
|
||||
../src/xml_grammar.cpp
|
||||
../src/utf8_codecvt_facet.cpp
|
||||
../src/basic_xml_grammar.ipp # doesn't show up in "Source Files" in Xcode"'
|
||||
)
|
||||
|
||||
add_library(wserialization ${LINK_TYPE}
|
||||
../src/codecvt_null.cpp
|
||||
../src/basic_text_wiprimitive.cpp
|
||||
../src/basic_text_woprimitive.cpp
|
||||
../src/text_wiarchive.cpp
|
||||
../src/text_woarchive.cpp
|
||||
../src/xml_wiarchive.cpp
|
||||
../src/xml_woarchive.cpp
|
||||
../src/xml_wgrammar.cpp
|
||||
../src/basic_xml_grammar.ipp # doesn't show up in "Source Files" in Xcode"'
|
||||
)
|
||||
|
||||
# end library build
|
||||
###########################
|
||||
|
||||
###########################
|
||||
# test targets
|
||||
|
||||
function( serialization_test test_name)
|
||||
set(arglist)
|
||||
foreach(a IN ITEMS ${ARGN} )
|
||||
set(arglist ${arglist} ../test/${a}.cpp)
|
||||
endforeach()
|
||||
message(STATUS ${test_name})
|
||||
add_executable( ${test_name} ../test/${test_name}.cpp ${arglist} )
|
||||
target_link_libraries(${test_name} serialization wserialization ${Boost_LIBRARIES})
|
||||
add_test( ${test_name} ${test_name} )
|
||||
endfunction(serialization_test)
|
||||
|
||||
function(archive_test test_name)
|
||||
set(arglist)
|
||||
foreach(a IN ITEMS ${ARGN} )
|
||||
set(arglist ${arglist} ../test/${a}.cpp)
|
||||
endforeach()
|
||||
foreach(
|
||||
archive-name
|
||||
IN ITEMS portable_archive
|
||||
# text_archive text_warchive binary_archive xml_archive xml_warchive
|
||||
)
|
||||
set(amended_test_name ${test_name}_${archive-name})
|
||||
message(STATUS ${amended_test_name})
|
||||
add_executable(${amended_test_name} ../test/${test_name}.cpp ${arglist})
|
||||
set_property(
|
||||
TARGET ${amended_test_name}
|
||||
PROPERTY COMPILE_DEFINITIONS BOOST_ARCHIVE_TEST=${archive-name}.hpp
|
||||
)
|
||||
target_link_libraries(${amended_test_name} serialization wserialization ${Boost_LIBRARIES})
|
||||
add_test(${amended_test_name} ${amended_test_name})
|
||||
endforeach()
|
||||
endfunction(archive_test)
|
||||
|
||||
function(polymorphic_archive_test test_name)
|
||||
set(arglist)
|
||||
foreach(a IN ITEMS ${ARGN} )
|
||||
set(arglist ${arglist} ../test/${a}.cpp)
|
||||
endforeach()
|
||||
foreach(
|
||||
archive-name
|
||||
IN ITEMS portable_archive
|
||||
# text_archive text_warchive binary_archive xml_archive xml_warchive
|
||||
)
|
||||
set(amended_test_name ${test_name}_polymorphic_${archive-name})
|
||||
message(STATUS ${amended_test_name})
|
||||
add_executable(${amended_test_name} ../test/${test_name}.cpp ${arglist})
|
||||
set_property(
|
||||
TARGET ${amended_test_name}
|
||||
PROPERTY COMPILE_DEFINITIONS BOOST_ARCHIVE_TEST=polymorphic_${archive-name}.hpp
|
||||
)
|
||||
target_link_libraries(${amended_test_name} serialization wserialization ${Boost_LIBRARIES})
|
||||
add_test(${amended_test_name} ${amended_test_name})
|
||||
endforeach()
|
||||
endfunction(polymorphic_archive_test)
|
||||
|
||||
enable_testing()
|
||||
|
||||
# serialization(test_dll_exported dll_polymorphic_derived2_lib)
|
||||
# serialization(test_dll_simple dll_a_lib)
|
||||
# compile test_dll_plugin.cpp
|
||||
# Running the following test requires that the test know the directory
|
||||
# in which the dll is stored. I don't know how to extract this from bjam
|
||||
# serialization(test_dll_plugin : : dll_polymorphic_derived2_lib)
|
||||
|
||||
serialization_test(test_private_ctor)
|
||||
serialization_test(test_reset_object_address A)
|
||||
serialization_test(test_void_cast)
|
||||
serialization_test(test_mult_archive_types)
|
||||
serialization_test(test_iterators)
|
||||
serialization_test(test_iterators_base64)
|
||||
serialization_test(test_inclusion)
|
||||
serialization_test(test_smart_cast)
|
||||
serialization_test(test_codecvt_null ../src/codecvt_null)
|
||||
serialization_test(test_strong_typedef)
|
||||
|
||||
archive_test(test_native_array A)
|
||||
archive_test(test_boost_array A)
|
||||
if(COMPILER_SUPPORTS_CXX11)
|
||||
archive_test(test_array A)
|
||||
endif()
|
||||
archive_test(test_binary)
|
||||
archive_test(test_bitset)
|
||||
archive_test(test_class_info_save)
|
||||
archive_test(test_class_info_load)
|
||||
archive_test(test_complex)
|
||||
archive_test(test_contained_class A)
|
||||
archive_test(test_cyclic_ptrs A)
|
||||
archive_test(test_delete_pointer)
|
||||
archive_test(test_deque A)
|
||||
archive_test(test_derived)
|
||||
archive_test(test_derived_class A)
|
||||
archive_test(test_diamond)
|
||||
archive_test(test_diamond_complex)
|
||||
archive_test(test_exported polymorphic_base)
|
||||
archive_test(test_forward_list A)
|
||||
archive_test(test_forward_list_ptrs A)
|
||||
archive_test(test_helper_support)
|
||||
archive_test(test_interrupts)
|
||||
archive_test(test_list A)
|
||||
archive_test(test_list_ptrs A)
|
||||
archive_test(test_map A)
|
||||
archive_test(test_map_boost_unordered A)
|
||||
archive_test(test_mi)
|
||||
archive_test(test_multiple_ptrs A)
|
||||
archive_test(test_multiple_inheritance)
|
||||
archive_test(test_no_rtti polymorphic_base polymorphic_derived1)
|
||||
archive_test(test_new_operator A)
|
||||
archive_test(test_non_intrusive)
|
||||
archive_test(test_non_default_ctor)
|
||||
archive_test(test_non_default_ctor2)
|
||||
archive_test(test_null_ptr)
|
||||
archive_test(test_nvp A)
|
||||
archive_test(test_object)
|
||||
archive_test(test_optional)
|
||||
archive_test(test_primitive)
|
||||
archive_test(test_priority_queue A)
|
||||
archive_test(test_private_base)
|
||||
archive_test(test_private_base2)
|
||||
archive_test(test_queue A)
|
||||
archive_test(test_recursion A)
|
||||
archive_test(test_registered)
|
||||
archive_test(test_shared_ptr)
|
||||
archive_test(test_shared_ptr_multi_base)
|
||||
archive_test(test_shared_ptr_132)
|
||||
archive_test(test_simple_class A)
|
||||
archive_test(test_simple_class_ptr A)
|
||||
CHECK_INCLUDE_FILE_CXX(slist SLIST_FOUND)
|
||||
if(SLIST_FOUND)
|
||||
message(STATUS "slist header found")
|
||||
archive_test(test_slist A)
|
||||
archive_test(test_slist_ptr A)
|
||||
else()
|
||||
message(STATUS "slist header NOT found")
|
||||
endif()
|
||||
archive_test(test_stack A)
|
||||
archive_test(test_split)
|
||||
archive_test(test_tracking)
|
||||
archive_test(test_unregistered)
|
||||
archive_test(test_unique_ptr)
|
||||
archive_test(test_valarray)
|
||||
archive_test(test_variant A)
|
||||
archive_test(test_vector A)
|
||||
archive_test(test_set A)
|
||||
archive_test(test_set_boost_unordered A)
|
||||
if(COMPILER_SUPPORTS_CXX11)
|
||||
archive_test(test_set_unordered A)
|
||||
else()
|
||||
CHECK_INCLUDE_FILE_CXX(hash_set HASH_SET_FOUND)
|
||||
if(HASH_SET_FOUND)
|
||||
archive_test(test_set_hashed A)
|
||||
endif()
|
||||
endif()
|
||||
if(COMPILER_SUPPORTS_CXX11)
|
||||
archive_test(test_map_unordered A)
|
||||
else()
|
||||
CHECK_INCLUDE_FILE_CXX(hash_map HASH_MAP_FOUND)
|
||||
if(HASH_MAP_FOUND)
|
||||
archive_test(test_map_hashed A)
|
||||
endif()
|
||||
endif()
|
||||
|
||||
polymorphic_archive_test(test_polymorphic test_polymorphic_A A)
|
||||
polymorphic_archive_test(test_polymorphic2 test_polymorphic2imp)
|
||||
polymorphic_archive_test(test_polymorphic_helper)
|
||||
|
||||
# end test targets
|
||||
####################
|
||||
|
||||
####################
|
||||
# add headers in IDE
|
||||
|
||||
# for serialisation
|
||||
|
||||
file(GLOB x
|
||||
RELATIVE "${CMAKE_CURRENT_SOURCE_DIR}"
|
||||
"${CMAKE_CURRENT_SOURCE_DIR}/../include/boost/archive/*.hpp"
|
||||
)
|
||||
add_custom_target(archive SOURCES ${x})
|
||||
set_property(TARGET archive PROPERTY FOLDER "serialization")
|
||||
|
||||
file(GLOB x
|
||||
RELATIVE "${CMAKE_CURRENT_SOURCE_DIR}"
|
||||
"${CMAKE_CURRENT_SOURCE_DIR}/../include/boost/archive/detail/*.hpp"
|
||||
)
|
||||
add_custom_target(archive-detail SOURCES ${x})
|
||||
set_property(TARGET archive-detail PROPERTY FOLDER "serialization")
|
||||
|
||||
file(GLOB x
|
||||
RELATIVE "${CMAKE_CURRENT_SOURCE_DIR}"
|
||||
"${CMAKE_CURRENT_SOURCE_DIR}/../include/boost/archive/impl/*.ipp"
|
||||
)
|
||||
add_custom_target(archive-impl SOURCES ${x})
|
||||
set_property(TARGET archive-impl PROPERTY FOLDER "serialization")
|
||||
|
||||
file(GLOB x
|
||||
RELATIVE "${CMAKE_CURRENT_SOURCE_DIR}"
|
||||
"${CMAKE_CURRENT_SOURCE_DIR}/../include/boost/archive/iterators/*.hpp"
|
||||
)
|
||||
add_custom_target(archive-iterators SOURCES ${x})
|
||||
set_property(TARGET archive-iterators PROPERTY FOLDER "serialization")
|
||||
|
||||
file(GLOB x
|
||||
RELATIVE "${CMAKE_CURRENT_SOURCE_DIR}"
|
||||
"${CMAKE_CURRENT_SOURCE_DIR}/../include/boost/serialization/*.hpp"
|
||||
)
|
||||
add_custom_target(serialization-headers SOURCES ${x})
|
||||
set_property(TARGET serialization-headers PROPERTY FOLDER "serialization")
|
||||
|
||||
file(GLOB x
|
||||
RELATIVE "${CMAKE_CURRENT_SOURCE_DIR}"
|
||||
"${CMAKE_CURRENT_SOURCE_DIR}/../include/boost/serialization/detail/*.hpp"
|
||||
)
|
||||
add_custom_target(serialization-detail SOURCES ${x})
|
||||
set_property(TARGET serialization-detail PROPERTY FOLDER "serialization")
|
||||
|
||||
# for wserialization
|
||||
|
||||
file(GLOB x
|
||||
RELATIVE "${CMAKE_CURRENT_SOURCE_DIR}"
|
||||
"${CMAKE_CURRENT_SOURCE_DIR}/../include/boost/archive/*_w*.hpp"
|
||||
)
|
||||
add_custom_target(wserialization_headers SOURCES ${x})
|
||||
set_property(TARGET wserialization_headers PROPERTY FOLDER "wserialization")
|
||||
|
||||
# end headers in IDE
|
||||
####################
|
||||
|
||||
#####################
|
||||
# add test project to run misc tests
|
||||
|
||||
add_executable( test_z ../test/test_z.cpp)
|
||||
target_link_libraries(test_z serialization wserialization ${Boost_LIBRARIES})
|
||||
|
||||
# end test project
|
||||
#####################
|
||||
@@ -1,67 +0,0 @@
|
||||
# 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
|
||||
|
||||
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/core
|
||||
- git submodule init libs/detail
|
||||
- git submodule init libs/filesystem
|
||||
- git submodule init libs/function
|
||||
- git submodule init libs/functional
|
||||
- git submodule init libs/integer
|
||||
- git submodule init libs/intrusive
|
||||
- git submodule init libs/io
|
||||
- git submodule init libs/iterator
|
||||
- git submodule init libs/lexical_cast
|
||||
- git submodule init libs/math
|
||||
- git submodule init libs/move
|
||||
- git submodule init libs/mpl
|
||||
- git submodule init libs/numeric/conversion
|
||||
- git submodule init libs/optional
|
||||
- git submodule init libs/predef
|
||||
- git submodule init libs/preprocessor
|
||||
- git submodule init libs/range
|
||||
- git submodule init libs/smart_ptr
|
||||
- git submodule init libs/spirit
|
||||
- git submodule init libs/static_assert
|
||||
- git submodule init libs/system
|
||||
- git submodule init libs/throw_exception
|
||||
- git submodule init libs/tuple
|
||||
- git submodule init libs/type_index
|
||||
- git submodule init libs/type_traits
|
||||
- git submodule init libs/unordered
|
||||
- git submodule init libs/utility
|
||||
- git submodule init libs/variant
|
||||
- git submodule init 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 toolset=gcc link=static,shared
|
||||
+6
-19
@@ -80,9 +80,7 @@ SOURCES =
|
||||
xml_iarchive
|
||||
xml_oarchive
|
||||
xml_archive_exception
|
||||
codecvt_null
|
||||
utf8_codecvt_facet
|
||||
singleton
|
||||
shared_ptr_helper
|
||||
;
|
||||
|
||||
WSOURCES =
|
||||
@@ -90,22 +88,19 @@ WSOURCES =
|
||||
basic_text_woprimitive
|
||||
text_wiarchive
|
||||
text_woarchive
|
||||
utf8_codecvt_facet
|
||||
xml_wgrammar
|
||||
xml_wiarchive
|
||||
xml_woarchive
|
||||
codecvt_null
|
||||
;
|
||||
|
||||
|
||||
lib boost_serialization
|
||||
: $(SOURCES).cpp
|
||||
:
|
||||
<toolset>msvc:<cxxflags>/Gy
|
||||
<toolset>msvc:<define>_SCL_SECURE_NO_WARNINGS
|
||||
<toolset>clang:<cxxflags>"-fvisibility=hidden -fvisibility-inlines-hidden"
|
||||
<toolset>gcc:<cxxflags>"-fvisibility=hidden -fvisibility-inlines-hidden"
|
||||
<toolset>darwin:<cxxflags>"-fvisibility=hidden -fvisibility-inlines-hidden"
|
||||
<toolset>gcc:<cxxflags>"-ftemplate-depth-255"
|
||||
<toolset>clang:<cxxflags>"-ftemplate-depth-255"
|
||||
<toolset>darwin:<cxxflags>"-ftemplate-depth-255"
|
||||
#<toolset>gcc:<cxxflags>"-fvisibility=hidden"
|
||||
<link>shared:<define>BOOST_SERIALIZATION_DYN_LINK=1
|
||||
;
|
||||
|
||||
@@ -113,15 +108,7 @@ lib boost_wserialization
|
||||
: $(WSOURCES).cpp boost_serialization
|
||||
:
|
||||
<toolset>msvc:<cxxflags>/Gy
|
||||
<toolset>msvc:<define>_SCL_SECURE_NO_WARNINGS
|
||||
<toolset>clang:<cxxflags>"-fvisibility=hidden -fvisibility-inlines-hidden"
|
||||
<toolset>gcc:<cxxflags>"-fvisibility=hidden -fvisibility-inlines-hidden"
|
||||
<toolset>darwin:<cxxflags>"-fvisibility=hidden -fvisibility-inlines-hidden"
|
||||
<toolset>gcc:<cxxflags>"-ftemplate-depth-255"
|
||||
<toolset>clang:<cxxflags>"-ftemplate-depth-255"
|
||||
<toolset>darwin:<cxxflags>"-ftemplate-depth-255"
|
||||
# note: both serialization and wserialization are conditioned on the this
|
||||
# switch - don't change it to BOOST_WSERIALIZATION_DYN_LINK
|
||||
#<toolset>gcc:<cxxflags>"-fvisibility=hidden"
|
||||
<link>shared:<define>BOOST_SERIALIZATION_DYN_LINK=1
|
||||
;
|
||||
|
||||
|
||||
@@ -44,10 +44,10 @@ http://www.boost.org/LICENSE_1_0.txt)
|
||||
<li>Tonko Juricic helped refine and complete project files for VC 7.1 ide
|
||||
<li><a href="http://www.boost.org/people/rene_rivera.htm">Rene Rivera</a> tracked down several issues related to
|
||||
Code Warrior, toolset configuration and bjam and much else.
|
||||
<li>Martin Ecker detected (and fixed!) a number of subtle errors regarding cyclic
|
||||
<li>Martin Ecker detected (and fixed!) a number of sublte 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
|
||||
resulting in many improvements. In addition he help 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
|
||||
@@ -76,7 +76,7 @@ http://www.boost.org/LICENSE_1_0.txt)
|
||||
Mr. Rozenthal in particular wrote an incredibly insightful analysis
|
||||
that has driven all subsequent development that has resulted in the
|
||||
current package.
|
||||
<li>Dave Harris proposal and spirited defense of it led to a re-thinking
|
||||
<li>Dave Harris proposal and spirited defense of it lead 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.
|
||||
|
||||
+24
-38
@@ -35,7 +35,7 @@ http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
<h3><a name="trivial">Trivial Archive</a></h3>
|
||||
The <a href="archives.html"><strong>Archive</strong></a> concept specifies the functions that a
|
||||
class must implement in order to be used to serialize
|
||||
class must implement to 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
|
||||
@@ -57,7 +57,7 @@ public:
|
||||
// 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> register_type(){}
|
||||
template<class T> trivial_oarchive & operator<<(const T & t){
|
||||
return *this;
|
||||
}
|
||||
@@ -77,22 +77,22 @@ For an example see
|
||||
<a href="../example/demo_trivial_archive.cpp" target="demo_trivial_archive">
|
||||
<code style="white-space: normal">demo_trivial_archive.cpp</code></a>.
|
||||
Of course this program won't produce any output as it is. But it provides
|
||||
the starting point for a simple class which can be used to log formatted
|
||||
the starting point for a simple class which can be used to log formated
|
||||
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
|
||||
and others. This library implements a family of full featuared archive
|
||||
classes appropriate for a variety of purposes.
|
||||
|
||||
<p>
|
||||
Our archives have been factored into a tree of classes in order to minimize
|
||||
Our archives have been factored in to 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
|
||||
Any class which fullfills the following requirements will fit into
|
||||
this hierarchy and implement all the features we require. Deriving from
|
||||
the base class <a href="../../../boost/archive/detail/common_oarchive.hpp" target="common_oarchive_hpp">
|
||||
common_oarchive.hpp</a> provides all features we desire which
|
||||
@@ -113,7 +113,7 @@ class complete_oarchive :
|
||||
friend class boost::archive::save_access;
|
||||
|
||||
// member template for saving primitive types.
|
||||
// Specialize for any types/templates that require special treatment
|
||||
// Specialize for any types/templates that special treatment
|
||||
template<class T>
|
||||
void save(T & t);
|
||||
|
||||
@@ -140,15 +140,15 @@ to help render the archive in a particular form.
|
||||
|
||||
<dl>
|
||||
|
||||
<dt><h4><code>void save_start(char const *)</code></h4></dt>
|
||||
<dt><h4><code>void save_start()</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.
|
||||
by XML archive to inject "<name " before data.
|
||||
</dd>
|
||||
<p>
|
||||
|
||||
<dt><h4><code>void save_end(char const *)</code></h4></dt>
|
||||
<dt><h4><code>void save_end()</code></h4></dt>
|
||||
<dd>
|
||||
<strong>Default</strong>:Does nothing.<br>
|
||||
<strong>Purpose</strong>:To inject/retrieve an object name into the archive. Used
|
||||
@@ -161,12 +161,12 @@ by XML archive to inject "</name>" after data.
|
||||
<strong>Default</strong>:Does nothing.<br>
|
||||
<strong>Purpose</strong>:Called <strong>each time</strong> user data is saved.
|
||||
It's not called when archive bookkeeping data is saved. This is used by XML archives
|
||||
to determine when to inject a ">" character at the end of an XML header. XML output archives
|
||||
to determine when to inject a ">" character at end of 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
|
||||
implementation for <code style="white-space: normal">void end_preamble()</code> is a no-op there by permitting it
|
||||
to be optimised away for archive classes that don't use it.
|
||||
</dd>
|
||||
<p>
|
||||
@@ -183,7 +183,7 @@ name-value pairs by overriding this function template for name-value pairs.
|
||||
This replaces the default name-value pair handling, which is just to throw away the name,
|
||||
with one appropriate for XML which writes out the start of an XML tag with the correct object name.
|
||||
<p>
|
||||
The second argument must be part of the function signature even though it is not used.
|
||||
The second argument must be part of the function signature even this it is not used.
|
||||
Its purpose is to be sure that code is portable to compilers which fail to correctly
|
||||
implement partial function template ordering. For more information see
|
||||
<a href="implementation.html#functiontemplateordering">this</a>.
|
||||
@@ -242,7 +242,7 @@ One or more of the following issues may need to be addressed:
|
||||
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
|
||||
<li>The archives included with 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.
|
||||
@@ -281,7 +281,7 @@ exception.
|
||||
Exhaustive testing of the library requires testing the different aspects of object
|
||||
serialization with each archive. There are 46 different tests that can run with any archive.
|
||||
There are 5 "standard archives" included with the system.
|
||||
(3 in systems that don't support wide charactor i/o).
|
||||
(3 in systems don't support wide charactor i/o).
|
||||
<p>
|
||||
In addition, there are 28 other tests which aren't related to any particular archive class.
|
||||
<p>
|
||||
@@ -354,7 +354,7 @@ each time a new archive class is created.
|
||||
</ul>
|
||||
|
||||
<h4>Implementation</h4>
|
||||
The solution is the pair <code>polymorphic_oarchive</code>
|
||||
The solution is the the pair <code>polymorphic_oarchive</code>
|
||||
and <code>polymorphic_iarchive</code>. They present a common interface of virtual
|
||||
functions - no templates - that is equivalent to the standard templated one.
|
||||
|
||||
@@ -371,7 +371,7 @@ show how polymorphic archives are to be used. Note the following:
|
||||
<li><a target=demo_polymorphic_A_hpp href="../example/demo_polymorphic_A.hpp"><code style="white-space: normal">demo_polymorphic_A.hpp</code></a> and
|
||||
<a target=demo_polymorphic_A_cpp href="../example/demo_polymorphic_A.cpp"><code style="white-space: normal">demo_polymorphic_A.cpp</code></a>
|
||||
contain no templates and no reference to any specific archive implementation. That is, they will
|
||||
only have to be compiled once for all archive implementations. This even applies to archives classes
|
||||
only have to be compiled once for all archive implementations. The 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.
|
||||
@@ -383,13 +383,12 @@ 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.
|
||||
<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>.
|
||||
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
|
||||
<code style="white-space: normal">typedef</code> for 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
|
||||
@@ -400,29 +399,16 @@ of the standard text archive classes
|
||||
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.
|
||||
smaller DLLS. There is a
|
||||
penalty for calling archive functions through a virtual function dispatch table and there
|
||||
is no possibility for a compiler to <code style="white-space: normal">inline</code> archive functions. This will result
|
||||
in a detectable degradation in performance for saving and loading archives.
|
||||
<p>
|
||||
Note that the concept of polymophic archives is fundamentally incompatible with the
|
||||
serialization of new types that are marked "primitive" by the user with:
|
||||
<pre><code>
|
||||
BOOST_CLASS_IMPLEMENTATION(my_primitive_type, boost::serialization::primitive_type)
|
||||
</code></pre>
|
||||
|
||||
Code to implement serialization for these types is instantiated "on the fly" in the user's program.
|
||||
But this conflicts with the whole purpose of the polymorphic archive. An attempt to
|
||||
serialize such a primitive type will result in a compilation error since the common polymorhic
|
||||
interface is static and cannot instantiate code for a new type.
|
||||
|
||||
<p>
|
||||
The main utility of polymorphic archives will be to permit the building of class DLLs that will
|
||||
The main utility of polymorphic archives will be to permit the buiding 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.
|
||||
|
||||
+7
-33
@@ -29,13 +29,13 @@
|
||||
<h4>Notation</h4>
|
||||
In the following descriptions
|
||||
<ul>
|
||||
<li><code>SA</code> is an type modeling the <a href="#saving_interface">Saving Archive Concept</a>.
|
||||
<li><code>SA</code> is an type modeling the <a href="#saving_interface">Saving Archive Concept</a>
|
||||
<li><code>sa</code> is an instance of type SA.
|
||||
<li><code>LA</code> is an type modeling the <a href="#loading_interface">Loading Archive Concept</a>.
|
||||
<li><code>LA</code> is an type modeling the <a href="#loading_interface">Loading Archive Concept</a>
|
||||
<li><code>la</code> is an instance of type LA.
|
||||
<li><code>T</code> is an <a href="serialization.html"><strong>Serializable</strong></a> Type.
|
||||
<li><code>x</code> is an instance of type T Type.
|
||||
<li><code>u,v</code> is a pointer to a an instance of type T.
|
||||
<li><code>T</code> is an <a href="serialization.html"><strong>Serializable</strong></a> Type
|
||||
<li><code>x</code> is an instance of type T Type</li>.
|
||||
<li><code>u,v</code> is a pointer to a an instance of type T
|
||||
<li><code>count</code> is an instance of a type that can be converted to <code>std::size_t</code>.
|
||||
</ul>
|
||||
<h4><a name="saving_interface">Saving Archive Concept</a></h4>
|
||||
@@ -112,14 +112,6 @@ way the data are rendered <a href="serialization.html">serializable</a>.
|
||||
might be conditioned on the library version to make sure that libraries created by
|
||||
previous versions of the library can still be read.
|
||||
</dd>
|
||||
<dt><h4><code>
|
||||
sa.get_helper<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>
|
||||
@@ -190,24 +182,6 @@ equivalent to the original.
|
||||
The code that loads collections might be conditioned on the library version to make
|
||||
sure that libraries created by previous versions of the library can still be read.
|
||||
</dd>
|
||||
<dt><h4><code>
|
||||
la.get_helper<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>
|
||||
@@ -292,7 +266,7 @@ included in the code module containing the serialization code.
|
||||
|
||||
</code></pre>
|
||||
|
||||
All of these archives implement the same interface. Hence, it should suffice to describe only one
|
||||
All of these archives implement the same inteface. Hence, it should suffice to describe only one
|
||||
of them in detail. For this purpose we will use the text archive.
|
||||
|
||||
|
||||
@@ -405,7 +379,7 @@ above.
|
||||
</code></h4></dt>
|
||||
<dd>
|
||||
Destructor for an archive. This should be called before the stream is
|
||||
closed. It restores any altered stream facets to their state before the
|
||||
closed. It restores any altered stream facets to thier state before the
|
||||
the archive was opened.
|
||||
</dd>
|
||||
</dl>
|
||||
|
||||
@@ -36,7 +36,6 @@ http://www.boost.org/LICENSE_1_0.txt)
|
||||
<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>
|
||||
@@ -46,13 +45,13 @@ http://www.boost.org/LICENSE_1_0.txt)
|
||||
<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",
|
||||
<li>Jm 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",
|
||||
<li>Herb Sutter, "Pimples--Beauty Marks You Can Depend On",
|
||||
<u>C++ Report</u>, from <u>More C++ Gems</u>, Cambridge University Press, 2000
|
||||
<a name="11"></a>
|
||||
<li>James Coplien, "Curiously Recurring Template Patterns",
|
||||
@@ -63,7 +62,7 @@ http://www.boost.org/LICENSE_1_0.txt)
|
||||
<a name="13"></a>
|
||||
<li>Stephan Beal, "s11n serialization library", <a href="http://www.s11n.net">www.s11n.net</a>
|
||||
<a name="14"></a>
|
||||
<li>Vandevoorde and Josuttis, <b>C++ Templates - A Complete Guide</b>, Addison-Wesley, 2003</a>
|
||||
<li>Vandervoorde 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.
|
||||
|
||||
+2
-2
@@ -42,7 +42,7 @@ template<
|
||||
<h2>Rationale</h2>
|
||||
|
||||
|
||||
UTF-8 is a method of encoding Unicode text in environments
|
||||
UTF-8 is a method of encoding Unicode text in environments where
|
||||
where data is stored as 8-bit characters and some ascii characters
|
||||
are considered special (i.e. Unix filesystem filenames) and tend
|
||||
to appear more commonly than other characters. While
|
||||
@@ -88,7 +88,7 @@ template<
|
||||
<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
|
||||
it's external data type and <tt>wchar_t</tt> as it's 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>
|
||||
|
||||
+4
-3
@@ -169,6 +169,9 @@ function initialize() {
|
||||
<dt><img style="display:none" src="dot.gif"><a target="detail" href="traits.html#pointer_tracking">pointer_tracking</a>
|
||||
<dt><img style="display:none" src="dot.gif"><a target="detail" href="traits.html#const_loading">const_loading</a>
|
||||
</dl></div></dd>
|
||||
|
||||
|
||||
|
||||
</dl></div></dd>
|
||||
<dt><img style="display:none" src="plus.gif" id="wrappers"><a target="detail" href="wrappers.html">Serialization Wrappers</a>
|
||||
<dd><div id="wrappers_detail"><dl class="page-index">
|
||||
@@ -185,7 +188,6 @@ function initialize() {
|
||||
<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>
|
||||
@@ -253,7 +255,7 @@ function initialize() {
|
||||
<dd><div id="userincludes_detail"><dl class="page-index">
|
||||
<dt><img style="display:none" src="dot.gif"><a target="detail" href="headers.html#archiveimplementations">Archive Implementations</a>
|
||||
<dt><img style="display:none" src="dot.gif"><a target="detail" href="headers.html#serializationdeclarations">Serialization Declarations</a>
|
||||
<dt><img style="display:none" src="dot.gif"><a target="detail" href="headers.html#serializationimplementations">Serialization Implementations</a>
|
||||
<dt><img style="display:none" 'rc="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">
|
||||
@@ -269,7 +271,6 @@ function initialize() {
|
||||
<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>
|
||||
|
||||
+10
-10
@@ -35,26 +35,26 @@ 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>Composable. so we can used 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
|
||||
The fundamental feature of an Iterator Adaptor template that makes in 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
|
||||
insert_linebreaks< // insert line breaks every 72 characters
|
||||
base64_from_binary< // convert binary values ot base64 characters
|
||||
transform_width< // retrieve 6 bit integers from a sequence of 8 bit bytes
|
||||
const char *,
|
||||
6,
|
||||
8
|
||||
>
|
||||
>
|
||||
,76
|
||||
,72
|
||||
>
|
||||
base64_text; // compose all the above operations in to a new iterator
|
||||
|
||||
@@ -71,12 +71,12 @@ included is <a target="transform_iterator" href="../../iterator/doc/transform_it
|
||||
transform_iterator</a>, which can be used to implement 6 bit integer => base64 code.
|
||||
|
||||
<h3>Dataflow Iterators</h3>
|
||||
Unfortunately, not all iterators which inherit from Iterator Adaptors are guaranteed
|
||||
Unfortunately, not all iterators which inherit from Iterator Adaptors are guarenteed
|
||||
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.
|
||||
fulfills as a small set of additional requirements.
|
||||
|
||||
<h4>Templated Constructors</h4>
|
||||
<p>
|
||||
@@ -110,12 +110,12 @@ std::copy(
|
||||
The recursive application of this template is what automatically generates the
|
||||
constructor <code style="white-space: normal">base64_text(const char *)</code> in our example above. The original
|
||||
Iterator Adaptors include a <code style="white-space: normal">make_xxx_iterator</code> to fulfill this function.
|
||||
However, I believe these are unwieldy to use compared to the above solution using
|
||||
However, I believe these are unwieldy to use compared to the above solution usiing
|
||||
Templated constructors.
|
||||
<p>
|
||||
Unfortunately, some systems which fail to properly support partial function template
|
||||
ordering cannot support the concept of a templated constructor as implemented above.
|
||||
A special "wrapper" macro has been created to work around this problem. With this "wrapper"
|
||||
A special"wrapper" macro has been created to work around this problem. With this "wrapper"
|
||||
the above example is modified to:
|
||||
<pre><code>
|
||||
std::copy(
|
||||
@@ -195,7 +195,7 @@ The standard stream iterators don't quite work for us. On systems which impleme
|
||||
as unsigned short integers (E.G. VC 6) they didn't function as I expected. I also made some
|
||||
adjustments to be consistent with our concept of Dataflow Iterators. Like the rest of our
|
||||
iterators, they are found in the namespace <code style="white-space: normal">boost::archive::interators</code> to avoid
|
||||
conflicts with the standard library versions.
|
||||
conflict the standard library version.
|
||||
<dl class = "index">
|
||||
<dt><a target="istream_iterator" href="../../../boost/archive/iterators/istream_iterator.hpp">
|
||||
istream_iterator</a></dt>
|
||||
|
||||
+7
-6
@@ -47,7 +47,7 @@ The serialization library is
|
||||
implemented using the <b>C</b>uriously <b>R</b>ecurring <b>T</b>emplate
|
||||
<b>P</b>attern (<b>CRTP</b>). Also, all common code is factored out into
|
||||
separate modules to minimize code repetition. This makes derivation from
|
||||
an existing archive less straightforward than it would otherwise be.
|
||||
an existing archive less straight forward than it would otherwise be.
|
||||
<p>
|
||||
This example illustrates several issues that have to be addressed when doing
|
||||
something like this
|
||||
@@ -84,12 +84,13 @@ the base classes.
|
||||
<li><i></i>Reread <a target="detail" href="headers.html#archiveinternals">Archive Internals</a>.
|
||||
This describes the class hierarchy so that you know what to override.
|
||||
<li><i>Note the usage of PFTO.</i> Some compilers fail to provide support for
|
||||
partial function template ordering. The serialization library works around this by
|
||||
partial function template ordering. The serialization library works around by
|
||||
using <a target="detail" href="implementation.html#functiontemplateordering">
|
||||
<b>P</b>artial <b>F</b>unction <b>T</b>emplate <b>O</b>rdering</a> in several places.
|
||||
This is done
|
||||
In archive classes, this takes
|
||||
. This is done
|
||||
in several places, including the archive classes themselves.
|
||||
<li><i>Base class functions will usually need to be explicitly invoked.</i>
|
||||
<li><i>Base class functions will usually need to be explicitly invoked</i>
|
||||
We commonly specialize the function name <code style="white-space: normal">save_override</code>
|
||||
for saving primitives. Usage of a function name in a derived class
|
||||
"hides" similarly named functions of the base class. That is,
|
||||
@@ -120,7 +121,7 @@ so it's what I use.
|
||||
</code></pre>
|
||||
for just this purpose. Failure to include required template definitions
|
||||
will result in undefined symbol errors when the program is linked.
|
||||
<li><i>Without alteration, this class cannot be further derived from.</i><br>
|
||||
<li><i>Without alteration, this class cannot be further derived from</i><br>
|
||||
Base classes using <b>CRTP</b> must be templates with a parameter corresponding to
|
||||
the most derived class. As presented here, this class doesn't qualify, so
|
||||
it cannot be used as a base class. In order to derive further from this class,
|
||||
@@ -135,7 +136,7 @@ class log_archive_impl :
|
||||
...
|
||||
);
|
||||
|
||||
// do not derive from this class !!!
|
||||
// do not derived from this class !!!
|
||||
class log_archive :
|
||||
public log_archive_impl<log_archive>
|
||||
{
|
||||
|
||||
BIN
Binary file not shown.
|
Before Width: | Height: | Size: 846 B After Width: | Height: | Size: 838 B |
@@ -70,7 +70,7 @@ an invalid pointer, or creating a memory leak.
|
||||
If an exception occurs, <i>referenced</i> pointers will not need to be deleted
|
||||
so there will be no memory leaks. The destructor of this class won't attempt to
|
||||
delete these pointers so there will be no problem with dangling references.
|
||||
<i>Owned</i> pointers are handled exactly as described above.
|
||||
<i>owned</i> pointers are handled exactly as described above.
|
||||
<p>
|
||||
<li><h4>class contains <i>referenced</i> pointers which might be created by load</h4>
|
||||
If a <i>referenced</i> pointer is loaded before its corresponding <i>owned</i>
|
||||
@@ -81,7 +81,7 @@ an invalid pointer, or creating a memory leak.
|
||||
<li>Trap exceptions with a <code style="white-space: normal">try/catch</code> block.
|
||||
<li>Within the catch part, invoke the archive function
|
||||
<code style="white-space: normal">delete_created_pointers()</code> to delete any pointers
|
||||
created by the class load. Without other action, objects created in
|
||||
created by the class load. Without out 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
|
||||
|
||||
+10
-10
@@ -57,7 +57,7 @@ class archive_exception : public std::exception
|
||||
{
|
||||
public:
|
||||
typedef enum {
|
||||
unregistered_class, // attempt to serialize a pointer of
|
||||
unregistered_class, // attempt to serialize a pointer of an
|
||||
// an unregistered class
|
||||
invalid_signature, // first line of archive does not contain
|
||||
// expected string
|
||||
@@ -66,8 +66,8 @@ public:
|
||||
pointer_conflict // an attempt has been made to directly serialize
|
||||
// an object after having already serialized the same
|
||||
// object through a pointer. Were this permitted,
|
||||
// the archive load would result in the creation
|
||||
// of an extraneous object.
|
||||
// it the archive load would result in the creation
|
||||
// of 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
|
||||
@@ -109,7 +109,7 @@ public:
|
||||
<h3><a name="unregistered_class"><code style="white-space: normal">unregistered_class</code></a></h3>
|
||||
An attempt has been made to serialize a polymorphic class through a pointer
|
||||
without either registering it or associating it with an export key. This can also occur
|
||||
when using a new archive whose class name has not been added to the system with the
|
||||
when using a new archive how class name has not been added to the system with the
|
||||
<code style="white-space: normal">BOOST_ARCHIVE_CUSTOM_ARCHIVE_TYPES</code> macro.
|
||||
|
||||
<h3><a name="invalid_signature"><code style="white-space: normal">invalid_signature</code></a></h3>
|
||||
@@ -121,7 +121,7 @@ exception is thrown.
|
||||
This system records the current library version number to all archives created. Note that this is in
|
||||
no way related to version number of classes used by application programs. This refers
|
||||
to the version of the serialization system used to create the archive. Future versions
|
||||
of this serialization system will be able to identify archives created under a previous
|
||||
of this serialization system will be able to identify archives created under 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
|
||||
@@ -225,7 +225,7 @@ This, in turn, can result in the throwing of this exception.
|
||||
|
||||
<h3><a name="invalid_class_name"><code style="white-space: normal">invalid_class_name</code></a></h3>
|
||||
Class name length greater than the maximum permitted. Most likely cause is a corrupted
|
||||
archive or an attempt to insert a virus via the buffer overrun method.
|
||||
archive or an attempt to insert virus via buffer overrun method.
|
||||
|
||||
<h3><a name="unregistered_cast"><code style="white-space: normal">unregistered_cast</code></a></h3>
|
||||
In order to support casting between pointers of base and derived classes
|
||||
@@ -239,7 +239,7 @@ whose relationship has not been registered,
|
||||
|
||||
<h3><a name="multiple_code_instantiation"><code style="white-space: normal">multiple_code_instantiation</code></a></h3>
|
||||
This exception is thrown when it is detected that the serialization of the same type
|
||||
has been instantiated more than once. This might occur when
|
||||
has been instantiated more that once. This might occur when
|
||||
serialization code is instantiated in both the mainline and one or more DLLS.
|
||||
|
||||
<h3><a name="xml_archive_parsing_error"><code style="white-space: normal">xml_archive_parsing_error</code></a></h3>
|
||||
@@ -250,8 +250,8 @@ to the loading serialization and this exception might be thrown. This might
|
||||
occur for one of the following reasons:
|
||||
<ul>
|
||||
<li>The archive has been edited outside the serialization system. This might
|
||||
be possible if only the data is changed and the XML attributes and nesting
|
||||
structure are left unaltered. But any other editing is likely to render the
|
||||
be possible if only the data is changed and not the XML attributes and nesting
|
||||
structure is left unaltered. But any other editing is likely to render the
|
||||
archive unreadable by the serialization library.
|
||||
<li>The serialization has been altered and an archive generated by the old
|
||||
code is being read. That is, versioning has not been properly employed to
|
||||
@@ -259,7 +259,7 @@ properly deserialize previously created archives.
|
||||
</ul>
|
||||
|
||||
<h3><a name="xml_archive_tag_mismatch"><code style="white-space: normal">xml_archive_tag_mismatch</code></a></h3>
|
||||
This exception will be thrown if the start or end tag of an XML element doesn't match
|
||||
This exception will be thrown if the start or end tag of and 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>
|
||||
|
||||
+13
-13
@@ -57,14 +57,14 @@ the following functions
|
||||
and operating systems. This makes it unusable for support of portable archives.
|
||||
<li>
|
||||
Even if the type name string could somehow be made portable, there is no
|
||||
guarantee that class headers would be included in the same namespace accross
|
||||
guarentee that class headers would be included in the same name space accross
|
||||
different applications. In fact, including different headers in different
|
||||
namespaces is an accepted method used to avoid namespace conflicts.
|
||||
name spaces is an accepted method used to avoid name space 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. The class header might include this information. If we want to
|
||||
import class headers accross applications, its convenient that the type id
|
||||
mechanism support inter-operability accross different type id systems.
|
||||
</ul>
|
||||
<h3>Features</h3>
|
||||
@@ -135,7 +135,7 @@ instance created for each type. However, this is enforced only at the executabl
|
||||
module level. That is, if a program includes some shared libraries or DLLS,
|
||||
there may be more than one instance of this class correponding to a particular type.
|
||||
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
|
||||
this instance but rather must be programmed to compare the the actual information
|
||||
the instances contain.
|
||||
<dl>
|
||||
|
||||
@@ -193,7 +193,7 @@ 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
|
||||
These functions are used to compare 'wo
|
||||
<a target="extended_type_info.hpp" href = "../../../boost/serialization/extended_type_info.hpp">
|
||||
<code style="white-space: normal">
|
||||
extended_type_info
|
||||
@@ -213,7 +213,7 @@ Construct a new instance of the type to which this
|
||||
extended_type_info
|
||||
</code>
|
||||
</a>
|
||||
record corresponds. This function takes a variable list of up to 4 arguments
|
||||
record corresponds. This function takes variable list of up to 4 arguments
|
||||
of any type. These arguments are passed to the type's constructor
|
||||
at runtime. In order to use the facility,
|
||||
one must declare a type sequence for the constructor arguments.
|
||||
@@ -222,9 +222,9 @@ with those specified when the type was exported.
|
||||
This function permits one to create instances of
|
||||
any exported type given only the exported <strong>GUID</strong> assigned
|
||||
with BOOST_CLASS_EXPORT.
|
||||
If these types are defined in DLLS or shared libraries loaded at runtime,
|
||||
these constructors can be called until the module is unloaded.
|
||||
Such modules are referred to as <b>plugins</b>.
|
||||
If these types are defined in DLLS or shared libraries. When these modules
|
||||
are loaded at runtime, these constructor can be called until the module
|
||||
is unloaded. These modules are referred to as <b>plugin</b>.
|
||||
</code>
|
||||
</dd>
|
||||
|
||||
@@ -245,7 +245,7 @@ object.
|
||||
|
||||
</dl>
|
||||
|
||||
<h3><a name="requirements">Requirements for an Implementation</a></h3>
|
||||
<h3><a name="requirements">Requirements for and 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
|
||||
@@ -309,7 +309,7 @@ with the include argument list.
|
||||
</dd>
|
||||
|
||||
<dt><h4><code style="white-space: normal"><pre>
|
||||
virtual void * destroy(void const * const ptr ) const;
|
||||
virtual void * destroy(void const * const ptr ) ) const;
|
||||
</pre></code></h4></dt>
|
||||
<dd>
|
||||
Destroy an instance of this type. This calls the
|
||||
@@ -348,7 +348,7 @@ The test program <code style="white-space: normal"><a target="test_no_rtti" href
|
||||
implements this function in terms of the <code style="white-space: normal"><a target="extended_type_info_no_rtti.hpp" href="../../../boost/serialization/extended_type_info_no_rtti.hpp">
|
||||
extended_type_info</a></code> API above to return the export key associated with the class.
|
||||
This requires that non-abstract types be exported. It also demonstrates the
|
||||
inter-operability between two different implementations of
|
||||
inter-operability with between two different implementations of
|
||||
<code style="white-space: normal">extended_type_info</code>.
|
||||
|
||||
<h3><a name="type_requirements">Requirements for Each Type</a></h3>
|
||||
|
||||
+3
-3
@@ -29,10 +29,10 @@ http://www.boost.org/LICENSE_1_0.txt)
|
||||
</tr>
|
||||
</table>
|
||||
<hr>
|
||||
This section will be used to list answers to questions raised in the mailing
|
||||
This section will be used to list answers to questions raise in the mailing
|
||||
lists. Most of these are due to subtle aspects of the library which are
|
||||
overlooked even though they might be described in the documentation. Often,
|
||||
these issues are very easy to address - but can be excruciatingly difficult to
|
||||
overlooked even though they might be described in the documenation. Often,
|
||||
these issues are very easy to address - but can be excruciating difficult to
|
||||
find. Should you have such an experience, feel free to vent your frustration
|
||||
in a constructive way by adding in your own item. The best way to do this
|
||||
is to create a <a href="http://svn.boost.org/trac/boost/browser">"TRAK" item</a>
|
||||
|
||||
+20
-19
@@ -42,10 +42,10 @@ http://www.boost.org/LICENSE_1_0.txt)
|
||||
</dl>
|
||||
</dl>
|
||||
|
||||
This library includes a large number of files. They are organized and classified
|
||||
according to the purposes listed in the above index.
|
||||
This library includes a large number of files. The are organized and classified
|
||||
according to purpose listed in the above index.
|
||||
<p>
|
||||
<code style="white-space: normal">namespace</code> of classes and templates is synchronized
|
||||
<code style="white-space: normal">namespace</code> of a classes and templates is syncronized
|
||||
with the directory in which the file is found. For example, the class declaration
|
||||
<pre><code>
|
||||
boost::archive::text_oarchive
|
||||
@@ -95,7 +95,7 @@ boost/archive/text_oarchive.hpp
|
||||
<dt><a target="text_wiarchive" href="../../../boost/archive/text_wiarchive.hpp">
|
||||
boost/archive/text_wiarchive.hpp
|
||||
</a>
|
||||
<dd>wide character text input archive used for loading.</dd>
|
||||
<dd>wide character text input archive used forloading.</dd>
|
||||
|
||||
<dt><a target="text_woarchive" href="../../../boost/archive/text_woarchive.hpp">
|
||||
boost/archive/text_woarchive.hpp
|
||||
@@ -207,7 +207,7 @@ This group of headers includes templates which implement serialization for Stand
|
||||
Library or Boost Library templates. Any program which uses these templates can
|
||||
invoke serialization of objects of these types just by including the corresponding header.
|
||||
<p>
|
||||
By convention these header files are named:
|
||||
By convention' these header files are named:
|
||||
|
||||
boost/serialization/xxx.hpp
|
||||
|
||||
@@ -257,7 +257,7 @@ for in all archive implementations. The serialization system relies on
|
||||
certain special types such as <code style="white-space: normal">class_id_type</code> and others to
|
||||
record information in archives that is required to reconstruct the original
|
||||
data structure. These are handled exactly as any other serializable type.
|
||||
That is, they can be handled as simple primitives such as they are in simple
|
||||
That is, the can be handled as simple primitives such as they are in simple
|
||||
text files, or with special code as they are in xml archives.
|
||||
</dd>
|
||||
|
||||
@@ -269,7 +269,7 @@ boost/archive/basic_text_iprimitive.hpp
|
||||
</a>
|
||||
</dt>
|
||||
<dd>
|
||||
Implementation of serialization of primitive types in terms of character
|
||||
Implementation of serialization of primitive types in terms of an character
|
||||
or wide character text streams. This is used in the implementation of text and
|
||||
xml archives. Presumably this would be useful for implementations of other variations
|
||||
of text archives such as user friendly text or windows ini files.
|
||||
@@ -283,7 +283,7 @@ boost/archive/basic_binary_iprimitive.hpp
|
||||
</a>
|
||||
</dt>
|
||||
<dd>
|
||||
Implementation of serialization of primitive types in terms of character
|
||||
Implementation of serialization of primitive types in terms of an character
|
||||
or wide character binary streams.
|
||||
</dd>
|
||||
|
||||
@@ -294,10 +294,10 @@ boost/archive/basic_binary_oarchive.hpp
|
||||
boost/archive/basic_binary_iarchive.hpp
|
||||
</a>
|
||||
<dd>
|
||||
Implementation of serialization of all types in terms of character
|
||||
Implementation of serialization of all types in terms of an character
|
||||
or wide character binary streams. This is factored out separately from the
|
||||
implementation of binary primitives above. This may facilitate the creation of
|
||||
other types of binary archives in the future. It also preserves analogy and symmetry with
|
||||
other types of binary archives in the future. It also preserves analogy and symetry with
|
||||
the rest of the library which aids in understanding.
|
||||
</dd>
|
||||
<dt><a target="basic_text_oarchive" href="../../../boost/archive/basic_text_oarchive.hpp">
|
||||
@@ -315,10 +315,10 @@ boost/archive/basic_xml_iarchive.hpp
|
||||
</a>
|
||||
</dt>
|
||||
<dd>
|
||||
Implementation of serialization of all types in terms of character
|
||||
Implementation of serialization of all types in terms of an character
|
||||
or wide character text streams. These classes specify archive type specific
|
||||
behavior on a type by type basis. For example, <code style="white-space: normal">basic_xml_oarchive.hpp</code>
|
||||
includes code to guarantee that any object not attached to a name will
|
||||
includes code to guarentee that any object not attached to a name will
|
||||
trap during compile time. On the other hand, <code style="white-space: normal">basic_text_oarchive.hpp</code>
|
||||
contains code to strip out and ingore any names attached to objects.
|
||||
<p>
|
||||
@@ -345,7 +345,8 @@ These files are found in the directory
|
||||
<a target="boost_archive_detail" href="../../../boost/archive/detail">boost/archive/detail</a>.
|
||||
These are included as necessary by the archive class implemenations listed above.
|
||||
This has the unfortunate side effect of making the implementation less transparent.
|
||||
Users should never find it necessary to change these files.
|
||||
of the library in order to implement either a class serialization or a new
|
||||
archive type. Users should never find it necessary to change these files.
|
||||
<p>
|
||||
The following discussion is based on the
|
||||
<a target="class_diagram" href="class_diagram.html">class diagram</a>.
|
||||
@@ -355,7 +356,7 @@ boost/archive/detail/interface_iarchive.hpp</a>
|
||||
<dt><a target="interface_iarchive" href="../../../boost/archive/detail/interface_iarchive.hpp">
|
||||
boost/archive/detail/interface_iarchive.hpp</a>
|
||||
<dd>
|
||||
Here are the declarations and definitions for the
|
||||
Here are the declarations and definitions which for the
|
||||
<a href="archives.html">archive_concept</a>. This class redirects calls to the
|
||||
archive interface to a function named <code>save_override</code> in the most derived
|
||||
archive class.
|
||||
@@ -402,7 +403,7 @@ library code for that part of the code which only depends upon the archive type.
|
||||
Building of the library generates and compiles code for all archives implemented.
|
||||
|
||||
<ul>
|
||||
<li>Serialization of user and primitive types runs at top speed. This is a noticeable
|
||||
<li>Serialization of user and primitive types runs a top speed. This is a noticiable
|
||||
difference with a previous version of the library which did not use templates for archives.
|
||||
<li>Library implementation code that never changes need only be compiled once
|
||||
rather than each time a user's program is recompiled. This can save much
|
||||
@@ -417,22 +418,22 @@ Building of the library generates and compiles code for all archives implemented
|
||||
</ul>
|
||||
An example of this is the usage of the spirit library in the library.
|
||||
It takes a long time to compile and includes lots of other files. Having this
|
||||
only in the library is much more convenient that having to include it in every
|
||||
only in the library is much more convenient that having to include in every
|
||||
program which uses xml serialization.
|
||||
|
||||
<a name="dataflowiterators">
|
||||
<h4>Dataflow Iterators</h4>
|
||||
In the course of developing this library, it became convenient to make a set
|
||||
of composable iterator adaptors for handling archive text. Applications include
|
||||
escaping and unescaping xml text and implementing to/from base64 conversion among
|
||||
escaping and unescaping xml text, implementi'g to/from base64 conversion among
|
||||
others.
|
||||
<p>
|
||||
This is a ripe topic in itself. It's touched upon by the
|
||||
This is a ripe topic in itself. Its touched upon by the
|
||||
<a href="../../../libs/iterator/doc/index.html">boost iterator</a> libraries,
|
||||
<a href="http://www.zib.de/weiser/vtl/index.html">View Template Library</a>, and others.
|
||||
<p>
|
||||
The code for these iterators is really independent of this library. But since it
|
||||
hasn't been and probably won't be reviewed outside of this context. I've left it in a directory
|
||||
hasn't been and probably won't be reviewed outside of this context. I've left in a directory
|
||||
local to the serialization library:
|
||||
<a target="archiveiterators" href="../../../boost/archive/iterators">boost/archive/iterators</a>.
|
||||
These iterators are described in
|
||||
|
||||
+10
-10
@@ -30,24 +30,24 @@ http://www.boost.org/LICENSE_1_0.txt)
|
||||
<li>27 Feb 2002
|
||||
<ul>
|
||||
<li>divide interface from implementation for class
|
||||
serialization to permit compilation on gcc
|
||||
<li>improved template instantantation for type templates
|
||||
serialization to permit compiliation on gcc
|
||||
<li>improved template instantanciation for type templates
|
||||
</ul>
|
||||
<li>18 Mar 2002 - draft #2 uploaded to boost
|
||||
<ul>
|
||||
<li>elminated locale effects on archives
|
||||
<li>added signature and library version to archive header
|
||||
<li>improved detection of errors when objects are serialized
|
||||
as pointers and subsequently serialized as objects
|
||||
<li>improved detection of errors when objects are serializationed
|
||||
as pointers and subsequently serializationed as objects
|
||||
<li>permit non-portable binary archives
|
||||
<li>implement workaround for systems such as MSVC 6.0 that
|
||||
don't support partial ordering
|
||||
<li>implement work around for systems such as MSVC 6.0 that
|
||||
don'tsupport partial ordering
|
||||
</ul>
|
||||
<li>16 May 2002 - draft #3 uploaded to boost
|
||||
<ul>
|
||||
<li>Ability to specify serialization of other templates in a
|
||||
non-intrusive way.
|
||||
<li>Included an example which uses boost::shared_ptr.
|
||||
<li>Included and example which uses boost::shared_ptr.
|
||||
<li>improved documentation
|
||||
<li>More test cases
|
||||
<li>More testing and documentation of obscure situtations
|
||||
@@ -65,7 +65,7 @@ http://www.boost.org/LICENSE_1_0.txt)
|
||||
<li>minor corrections
|
||||
<li>Additions to documentation to explicitly address issues of
|
||||
exception safety.
|
||||
<li>More test cases/demos to illustrate handling of the above issues.
|
||||
<li>More test cases/demos to illustrate handlling of the above issues.
|
||||
<li>Additions to documentation to include rationale for not depending
|
||||
on type_id
|
||||
<li>Implementation of serialization of boost::shared_ptr.
|
||||
@@ -127,8 +127,8 @@ http://www.boost.org/LICENSE_1_0.txt)
|
||||
</ul>
|
||||
<li>1 November 2004 - final changes for first boost official release 1.32 .
|
||||
<ul>
|
||||
<li>Adjustments to address package compatible with two-phase lookup.
|
||||
<li>Many small adjustments to accommodate quirks of various compilers.
|
||||
<li>Adjustments to address make package compatible with two-phase lookup.
|
||||
<li>Many small adjustments to accomdate quirks of various compilers.
|
||||
<li>A few bug fixes.
|
||||
</ul>
|
||||
</ol>
|
||||
|
||||
+201
-13
@@ -26,13 +26,20 @@ http://www.boost.org/LICENSE_1_0.txt)
|
||||
</table>
|
||||
<hr>
|
||||
<dl class="page-index">
|
||||
<dt><a href="#functiontemplateordering">Partial Function Template Ordering</a>
|
||||
<dt><a href="#charencoding">Character Encoding</a>
|
||||
<dt><a href="#tempatesyntax">Template Invocation syntax</a>
|
||||
<dt><a href="#partialtemplatespecialization">Partial Template Specialization</a>
|
||||
<dt><a href="#othercompilerissues">Specific Compiler/Library Issues</a>
|
||||
<dl class="page-index">
|
||||
<dt><a href="#gcc4x">44.X</a>
|
||||
<dt><a href="#gcc3x">GCC 3.X, 4.X</a>
|
||||
<dt><a href="#gcc295">GCC 2.95</a>
|
||||
<dt><a href="#intel80">Intel 8.0</a>
|
||||
<dt><a href="#vc80">Visual C++ 8.0</a>
|
||||
<dt><a href="#vc71">Visual C++ 7.1</a>
|
||||
<dt><a href="#vc70">Visual C++ 7.0</a>
|
||||
<dt><a href="#vc6">Visual C++ 6.0</a>
|
||||
<dt><a href="#borland">Borland 5.64 and 5.51</a>
|
||||
<dt><a href="#comeau">Comeau 4.3.3</a>
|
||||
<dt><a href="#codewarrior9">Code Warrior 9.x</a>
|
||||
<dt><a href="#codewarrior">Code Warrior 8.3</a>
|
||||
@@ -42,11 +49,86 @@ http://www.boost.org/LICENSE_1_0.txt)
|
||||
</dl>
|
||||
</dl>
|
||||
|
||||
<h3><a name="functiontemplateordering">Partial Function Template Ordering</a></h3>
|
||||
Not all C++ compilers correctly support partial function template ordering (PFTO).
|
||||
For these compilers, the following code will fail to compile:
|
||||
<pre><code>
|
||||
template<class Archive, class T>
|
||||
void serialize(
|
||||
Archive & ar,
|
||||
T & t,
|
||||
const unsigned int file_version
|
||||
){
|
||||
...
|
||||
}
|
||||
|
||||
template<class Archive, class T>
|
||||
void serialize(
|
||||
Archive & ar,
|
||||
my_template<T> & t,
|
||||
const unsigned int file_version
|
||||
){
|
||||
...
|
||||
}
|
||||
</pre></code>
|
||||
The serialization library works around this issue by using a different
|
||||
default definition of the first template:
|
||||
<pre><code>
|
||||
template<class Archive, class T>
|
||||
void serialize(
|
||||
Archive & ar,
|
||||
T & t,
|
||||
const unsigned long int file_version // Note: change to long
|
||||
){
|
||||
...
|
||||
}
|
||||
</pre></code>
|
||||
Now, the second template is not matched with the first one so there
|
||||
is no PFTO and no compile error. When the serialization library invokes
|
||||
<pre><code>
|
||||
serialize(ar, t, 0);
|
||||
</pre></code>
|
||||
the function declaration is first matched against templates with
|
||||
an integer for the third argument. If there is a match, the matching
|
||||
template is instantiated and later invoked. If there is no match,
|
||||
an attempt is made to match other templates by converting arguments to other types.
|
||||
In this case the third argument can be converted to long to match
|
||||
the first template - which is the default. So in this case, the first
|
||||
template will be instantiated and later invoked. We have managed to
|
||||
use function overloading to achieve the same effect as PFTO
|
||||
were it correctly implemented.
|
||||
<p>
|
||||
This depends upon undefined behavior of a compiler already
|
||||
determined to be non-conforming. In other words, there is no
|
||||
guarantee that this will work on all compilers. If a compiler does not
|
||||
correctly support PFTO and this method cannot be used to workaround
|
||||
it, non-intrusive serialization cannot be supported for that compiler.
|
||||
As of this writing, such a compiler has not been encountered.
|
||||
<p>
|
||||
It turns out that using this "trick" can create problems with
|
||||
compilers that DO correctly support PFTO. For this reason we
|
||||
define a macro <code style="white-space: normal">BOOST_PTFO</code> which
|
||||
is defined to be <code style="white-space: normal">long</code>
|
||||
for non-conforming compilers and nothing for conforming ones. So
|
||||
the default definition is really:
|
||||
The serialization library works around this issue by using a different
|
||||
default definition of the first template:
|
||||
<pre><code>
|
||||
template<class Archive, class T>
|
||||
void serialize(
|
||||
Archive & ar,
|
||||
T & t,
|
||||
const unsigned BOOST_PFTO int file_version // Note: change to BOOST_PFTO
|
||||
){
|
||||
...
|
||||
}
|
||||
</pre></code>
|
||||
|
||||
<h3><a name="charencoding">Character Encoding</a></h3>
|
||||
The whole question of character encoding combined with wide characters
|
||||
is much more complicated than it would seem to be. The current library
|
||||
defines in 3 formats (text, binary, and XML), wide and narrow characters,
|
||||
and attempts to be portable between compiler libraries. The results of
|
||||
an attempts to be portable between compiler libraries. The results of
|
||||
a rather long consideration of all these factors has been to set
|
||||
default encoding according to the following rules.
|
||||
<ul>
|
||||
@@ -67,7 +149,7 @@ default encoding according to the following rules.
|
||||
</ul>
|
||||
This character encoding is implemented by changing the <code style="white-space: normal">locale</code> of the
|
||||
i/o stream used by an archive when the archive is constructed, the stream
|
||||
locale is changed back to its original value. This action can be overridden
|
||||
local is changed back to its original value. This action can be overridden
|
||||
by specifying <code style="white-space: normal">boost::archive::no_codecvt</code>
|
||||
when the archive is opened. In this case, the stream <code style="white-space: normal">locale</code> will
|
||||
not be changed by the serialization library.
|
||||
@@ -93,8 +175,32 @@ do the following.
|
||||
<li>Create the archive with the flag <code style="white-space: normal">no_codecvt</code>.
|
||||
</ul>
|
||||
Naturally, the input process has to be symmetrical.
|
||||
<h3><a name="partialtemplatespecialization">Partial Template Specialization</a></h3>
|
||||
Compilers which fail to support partial template specialization will fail to compile
|
||||
the following code. To make this compiler, the <code style="white-space: normal">const</code> has to be removed.
|
||||
<pre><code>
|
||||
void f(A const* a, text_oarchive& oa)
|
||||
{
|
||||
oa << a;
|
||||
}
|
||||
</code></pre>
|
||||
<h3><a name="tempatesyntax">Template Invocation syntax</a></h3>
|
||||
Some compilers may not recognize the syntax:
|
||||
<pre><code>
|
||||
ar.template register_type<T>();
|
||||
</code></pre>
|
||||
for "registering" derived pointers of polymorphic classes. The actual
|
||||
function prototype is:
|
||||
<pre><code>
|
||||
template<T>
|
||||
void register_type(T * t = NULL);
|
||||
</code></pre>
|
||||
so that one may write <code style="white-space: normal">ar.register_type(static_cast<T *>(NULL))</code> instead of
|
||||
the syntax described above.
|
||||
</ul>
|
||||
<h3><a name="othercompilerissues">Specific Compiler/Library Issues</a></h3>
|
||||
<h4><a name="gcc4x">GCC 4.X</a></h4>
|
||||
|
||||
<h4><a name="gcc3x">GCC 3.X, 4.X</a></h4>
|
||||
<ul>
|
||||
<li>GCC versions for Cygwin and MinGW fail to support wide character I/O.
|
||||
So all tests using wide char I/O fail. Note that if wide character I/O support
|
||||
@@ -114,6 +220,17 @@ Naturally, the input process has to be symmetrical.
|
||||
-Wno-ctor-dtor-privacy
|
||||
</code></pre>
|
||||
</ul>
|
||||
<h4><a name="gcc295">GCC 2.95</a></h4>
|
||||
All of the above plus:<br>
|
||||
<ul>
|
||||
<li>The serialization library depends on the templated stream
|
||||
implementation to function properly.
|
||||
to function properly. So STLPort must be used to build the library.
|
||||
<li>Polymorphic archive tests fail.
|
||||
<li>XML serialization only works with version 1.6x of spirit. In order to build
|
||||
and use this library with this compiler, one must use version 1.6x rather than the
|
||||
latest version shipped with boost. See <a href="release.html">Release Notes</a>.
|
||||
</ul>
|
||||
<h4><a name="intel80">Intel C++ 8.0</a></h4>
|
||||
No known issues. All tests compile and run in debug and release modes.
|
||||
|
||||
@@ -133,12 +250,12 @@ This is due to the way that VC++ handles templated code with __decl(dllexport) a
|
||||
__decl(dllimport) specifications. Basically, this compiler requires that all the
|
||||
instantiations have the same specification - even though they have different
|
||||
template arguments. The example <code style="white-space: normal">
|
||||
demo_portable_iarchive.cpp</code> would have to be reformulated as a library or dll
|
||||
demo_portable_iarchive.cpp</code> would have to reformulated as a library or dll
|
||||
similar to the pre-defined archives in order to function.
|
||||
<p>
|
||||
This compiler does not have RTTI or exception handling turned on by default. Although
|
||||
they are not strictly necessary to use the serialization package, the example and test
|
||||
programs presume that they are enabled. So be sure your command line or IDE settings
|
||||
program presume that they are enabled. So be sure your command line or IDE settings
|
||||
enable these features if you want to build and run these programs.
|
||||
<p>
|
||||
This compiler can treat <code style="white-space: normal">wchar_t</code> as either
|
||||
@@ -154,14 +271,14 @@ includes this switch by default. So if want to use the libraries that
|
||||
when you compile your own applications.
|
||||
<h5>Using the Visual C++ IDE</h5>
|
||||
The library includes a VC++ 7.1 "Solution" - <code style="white-space: normal">BoostSerializationLibrary</code>
|
||||
along with a set of project files - one for each demo and test. Consider the following if you
|
||||
decide to use these configurations.
|
||||
along with of a set of project files - one for each demo and test. Consider the following if you
|
||||
decided to use these configurations.
|
||||
<ul>
|
||||
<li>The projects assume that the tests have been built with bjam using the default
|
||||
locations. This will result in a <code style="white-space: normal">bin</code> subdirectory
|
||||
within one's main boost directory. Below this there is a whole structure which maintains
|
||||
object and library files according to the type of build. The easiest way to build this is to
|
||||
invoke the runtest script which uses bjam (see below). If the libraries are not in these locations,
|
||||
invoke the runtest script which uses bjam. (see below) If the libraries are not in these locations,
|
||||
the projects will have to be modified accordingly.
|
||||
<li>There are project configurations for all the combinations of build variants that boost
|
||||
supports. That is for release, debug, static, static multi-threading, etc..
|
||||
@@ -195,6 +312,77 @@ decide to use these configurations.
|
||||
in sync with those included here.
|
||||
</ul>
|
||||
|
||||
<h4><a name="vc70">Visual C++ 7.0</a></h4>
|
||||
<ul>
|
||||
<li>The "pimpl" demo fails to link. Cause and workaround for this is unknown
|
||||
<li>XML serialization only works with version 1.6x of spirit. In order to build and use this
|
||||
library with this compiler, one must use version 1.6x rather than the latest version
|
||||
shipped with boost. See <a href="release.html">Release Notes</a>.
|
||||
<li>This compiler does not support partial template specialization.
|
||||
The implementation of the new <code>shared_ptr</code> serialization depends upon
|
||||
compiler support for partial template specialization. This compiler doesn't implement this
|
||||
feature. In order to serialize <code style="white-space: normal">shared_ptr<A></code>,
|
||||
invoke the macro <code style="white-space: normal">BOOST_SERIALIZATION_SHARED_PTR(A)</code>
|
||||
in the header code.
|
||||
<li>Lack of support for partial template specialization also creates problems for
|
||||
serialization of <code style="white-space: normal">std::map</code>. In order to serialize
|
||||
instances of this type include the invocation of BOOST_BROKEN_COMPILER_TYPE_TRAITS_SPECIALIZATION
|
||||
for the key type of the map.
|
||||
</ul>
|
||||
<h4><a name="vc6">Visual C++ 6.5</a></h4>
|
||||
all the above issues for Visual C++ 7.0 plus:
|
||||
<ul>
|
||||
<li>Out of line template definitions are not recognized and fail with a confusing
|
||||
error message. To function save/load/serialize member function templates must be defined
|
||||
within the class definition. This feature is essential to <code style="white-space: normal">demo_pimpl</code>. Hence,
|
||||
this program will fail to compile. In this case the problem can't be worked around and
|
||||
still demonstrate this facility.
|
||||
<li>This compiler does not support <code style="white-space: normal">wchar_t</code> as a separate type. It defines
|
||||
<code style="white-space: normal">wchar_t</code> as an alias for <code style="white-space: normal">short int</code>. In general things will still
|
||||
function. However certain customization, such as overloading archive operators for
|
||||
saving/loading wide character arrays would produce surprises in this environment.
|
||||
<li>Under certain circumstances, a program will fail to link with the message:
|
||||
LIN1179 - "invalid or corrupt file: duplicate comdat". According
|
||||
to <a href="http://groups.google.com/groups?th=8a05c82c4ffee280">
|
||||
http://groups.google.com/groups?th=8a05c82c4ffee280
|
||||
</a> (look for P78)
|
||||
A LNK1179 error occurs when:
|
||||
<ul>
|
||||
<li>The template class takes at least two arguments.
|
||||
<li>The template is used at least two times with identical first
|
||||
and different second arguments.
|
||||
<li>The static member variable is of an object type with at least one
|
||||
base class. (In another scenario it also occurred using a member
|
||||
without a base class.)
|
||||
</ul>
|
||||
Working around this in the implementation of the library for this compiler
|
||||
entailed a ridiculous amount of effort. Even so, the effort wasn't entirely successful.
|
||||
With this compiler, this message will still appear under the following conditions:
|
||||
<ul>
|
||||
<li>When serializing a class with multiple base classes. This problem causes two
|
||||
failure in the test suite. I have been unable to devise a way to work around this.
|
||||
<li>Using more than one kind of archive in the same code module. This should be easy
|
||||
to work around in practice.
|
||||
</ul>
|
||||
<li>Code modules exceeding some undetermined size that use the library will fail with
|
||||
<i>fatal error C1204: compiler limit : internal structure overflow</i>. This can be addressed
|
||||
by dividing the module into smaller ones.
|
||||
</ul>
|
||||
<h4><a name="borland">Borland 5.64 and 5.51</a></h4>
|
||||
<ul>
|
||||
<li><code style="white-space: normal">enum</code> data members cannot be serialized.
|
||||
Conversion to/from integers will work around the problem.
|
||||
<li>If class serialize functions are not accessible either by making them public or by
|
||||
including <code style="white-space: normal">friend</code> declarations as described in
|
||||
<a href="serialization.html#member">Class Serialization - Member Function</a>, the
|
||||
will compile but fail at runtime.
|
||||
<li>Tests using custom extended type which doesn't use RTTI fails. (5.64 only !).
|
||||
<li>Tests built in release mode fail. This seems to be an issue with the boost test system
|
||||
with this compiler.
|
||||
<li>XML serialization only works with version 1.6x of spirit. In order to build
|
||||
and use this library with this compiler, one must use version 1.6x rather than the
|
||||
latest version shipped with boost. See <a href="release.html">Release Notes</a>.
|
||||
</ul>
|
||||
<h4><a name="comeau">Comeau 4.3.3</a></h4>
|
||||
<ul>
|
||||
<li>This compiler fails to make a DLL with export under windows.
|
||||
@@ -205,7 +393,7 @@ decide to use these configurations.
|
||||
|
||||
<h4><a name="codewarrior9">Code Warrior 9.x</a></h4>
|
||||
<ul>
|
||||
<li>Some tests and demos fail - still under investigation
|
||||
<li>Some tests and demos demos fail - still under investigation
|
||||
</ul>
|
||||
|
||||
<h4><a name="codewarrior">Code Warrior 8.3</a></h4>
|
||||
@@ -225,7 +413,7 @@ Several compilers, including Visual C++ 6.0, use an older dinkumware library.
|
||||
These platforms have several issues:
|
||||
<ul>
|
||||
<li>The dinkumware library shipped with this compiler does not change the locale facet
|
||||
of an i/o stream unless the <code style="white-space: normal">imbue</code> function is called before the
|
||||
of an i/o stream unless the <code style="white-space: normal">imbue</code> function is called before the the
|
||||
stream is opened. In order to use this library with this environment to generate UTF-8
|
||||
files, one cannot depend on the "automatic" setting of locale that archives implement. The
|
||||
stream locale must be set explicitly on the stream before an archive is opened on it. The
|
||||
@@ -237,7 +425,7 @@ These platforms have several issues:
|
||||
|
||||
<h4><a name="stlport">STLPort 4.5.3</a></h4>
|
||||
<ul>
|
||||
<li>when built to use the dynamic linking versions of the C++ runtime code (<runtime-link>dynamic)
|
||||
<li>when built to use dynamic linking versions of C++ runtime code (<runtime-link>dynamic)
|
||||
all tests fail to link. This is due to a missing symbol in the stlport library related
|
||||
to custom codecvt facets.
|
||||
<li>the test_set fails to run correctly. It seems the hashed set iterator doesn't
|
||||
@@ -247,7 +435,7 @@ These platforms have several issues:
|
||||
|
||||
<hr>
|
||||
<p>Revised 1 November, 2004
|
||||
<p><i>© Copyright <a href="http://www.rrsd.com">Robert Ramey</a> 2002-2015.
|
||||
<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>
|
||||
|
||||
Binary file not shown.
|
Before Width: | Height: | Size: 849 B After Width: | Height: | Size: 839 B |
@@ -36,13 +36,13 @@ techiques on how to use the library to address specific situations.
|
||||
|
||||
<h2><a name="functionobject"></a>Serializing a Function Object</h2>
|
||||
An example on how to serialize a function object. I believe this
|
||||
could be done by serializing a pointer to the object in question. Since
|
||||
the Serialization library resurrects a pointer of the correct type
|
||||
could be done by serializing pointer to the object in question. Since
|
||||
the Serialization library resurrects pointer of the correct type
|
||||
this should be easily implementable.
|
||||
<p>
|
||||
If a group of function objects were all derived from the
|
||||
same polymorphic base class - perhaps via multiple inheritance,
|
||||
then the function object effectively becomes a "variable" which
|
||||
the the function object effectively becomes a "variable" which
|
||||
encapsulates code.
|
||||
<p>
|
||||
This case study would show how to do this.
|
||||
@@ -51,19 +51,19 @@ This case study would show how to do this.
|
||||
|
||||
Often users want to add their own special functionality to an
|
||||
existing archive. Examples of this are performance enhancements
|
||||
for specific types, adjustment of output syntax for xml archives,
|
||||
for specific types, Adjustment of output syntax for xml archives,
|
||||
and logging/debug output as archives are written and/or read.
|
||||
If this functionality is implemented as an "adaptor" template
|
||||
which takes the base class as a template argument, such functionality could be
|
||||
appended to any archive for which that functionality makes sense.
|
||||
If this functionalty is implemented as an "adaptor" template
|
||||
which takes the base class as a template argument, such functionality
|
||||
appended to any archive for which that funtionality makes sense.
|
||||
For example, an adaptor for generating an xml schema could be
|
||||
appended to both wide and narrow character versions of xml archives.
|
||||
appended to both wide narrow character versions of xml archives.
|
||||
<p>
|
||||
This case study would show how to make a useful archive adaptor.
|
||||
|
||||
<h2><a name="archivehelper"></a>Archive Helpers</h2>
|
||||
Some types are not serializable as they stand. That is - they
|
||||
do not fulfill the requirements of the "Serializable Concept".
|
||||
do not fullfill the requirements of the "Serializable Concept".
|
||||
The iconic example of this is boost::shared_ptr. Sometimes
|
||||
these types could be made serializable by adding code inside
|
||||
the library. Of course, doing that would create a lifetime
|
||||
|
||||
+4
-7
@@ -31,7 +31,7 @@ the "Handle Body Idiom". Included in this library is a program called
|
||||
<a href="../example/demo_pimpl.cpp" target="demo_impl_cpp">demo_pimpl.cpp</a>
|
||||
which illustrates how this is used. The file
|
||||
<a href="../example/demo_pimpl_A.cpp" target="demo_impl__Acpp">demo_pimpl_A.hpp</a>
|
||||
contains the declaration of the A class that hides its implementation
|
||||
contains the declaration of the a class that hides its implementation
|
||||
by including a pointer to struct B that is only defined as a pointer.
|
||||
<pre><code>
|
||||
// class whose declaration is hidden by a pointer
|
||||
@@ -45,11 +45,8 @@ struct A {
|
||||
A();
|
||||
};
|
||||
</code></pre>
|
||||
Serialization of A requires access to the definition of B. But that doesn't mean
|
||||
that it requires the this access from the header file. Since B is a pointer,
|
||||
a declaration of class B is sufficient. The implemenation of the serialization
|
||||
of A includes the definition of class B defined in the separately compiled module:
|
||||
|
||||
Serialization of A requires access to the definition of B in order so it
|
||||
is defined in the separately compiled module:
|
||||
<a href="../example/demo_pimpl_A.cpp" target="demo_impl_A_cpp">demo_pimpl_A.cpp</a>
|
||||
by:
|
||||
<pre><code>
|
||||
@@ -93,7 +90,7 @@ void A::serialize(boost::archive::text_iarchive & ar, const unsigned int file_ve
|
||||
</code></pre>
|
||||
The problem is that when compiling the above code,
|
||||
there is no instantiation of the <code style="white-space: normal">serialize</code> template.
|
||||
There can't be as it's not "known" what types of archives
|
||||
There can't be as its not "known" what types of archives
|
||||
the serialization is going to be used with. So these functions are "missing"
|
||||
when an attempt to link is made. The solution is to explicitly instantiate
|
||||
serialization code for those archives which are going to be used. In this
|
||||
|
||||
Binary file not shown.
|
Before Width: | Height: | Size: 855 B After Width: | Height: | Size: 844 B |
@@ -1,170 +0,0 @@
|
||||
<!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 - Private Base Classes</title>
|
||||
</head>
|
||||
<body link="#0000ff" vlink="#800080">
|
||||
<table border="0" cellpadding="7" cellspacing="0" width="100%" summary="header">
|
||||
<tr>
|
||||
<td valign="top" width="300">
|
||||
<h3><a href="../../../index.htm"><img height="86" width="277" alt="C++ Boost" src="../../../boost.png" border="0"></a></h3>
|
||||
</td>
|
||||
<td valign="top">
|
||||
<h1 align="center">Serialization</h1>
|
||||
<h2 align="center">Private Base Classes</h2>
|
||||
</td>
|
||||
</tr>
|
||||
</table>
|
||||
<hr>
|
||||
In many cases, serialization of private or protected base classes present no special problems.
|
||||
This is true for both simple classes and types as well as pointers to those
|
||||
classes and types. That is, the following program compiles and runs exactly as one would expect.
|
||||
<pre><code>
|
||||
/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
|
||||
// test_private_base.cpp
|
||||
|
||||
// (C) Copyright 2009 Eric Moyer - http://www.rrsd.com .
|
||||
// Use, modification and distribution is subject to the Boost Software
|
||||
// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
#include <fstream>
|
||||
#include <boost/config.hpp>
|
||||
#if defined(BOOST_NO_STDC_NAMESPACE)
|
||||
namespace std{
|
||||
using ::remove;
|
||||
}
|
||||
#endif
|
||||
|
||||
#include <boost/serialization/access.hpp>
|
||||
#include <boost/serialization/base_object.hpp>
|
||||
#include <boost/serialization/export.hpp>
|
||||
|
||||
class Base {
|
||||
friend class boost::serialization::access;
|
||||
int m_i;
|
||||
template<class Archive>
|
||||
void serialize(Archive & ar, const unsigned int version){
|
||||
ar & BOOST_SERIALIZATION_NVP(m_i);
|
||||
}
|
||||
protected:
|
||||
bool equals(const Base &rhs) const {
|
||||
return m_i == rhs.m_i;
|
||||
}
|
||||
Base(int i = 0) :
|
||||
m_i(i)
|
||||
{}
|
||||
};
|
||||
|
||||
class Derived : private Base {
|
||||
friend class boost::serialization::access;
|
||||
private:
|
||||
Base & base_cast(){
|
||||
return static_cast<Base &>(*this);
|
||||
}
|
||||
template<class Archive>
|
||||
void serialize(Archive & ar, const unsigned int version){
|
||||
ar & BOOST_SERIALIZATION_BASE_OBJECT_NVP(Base);
|
||||
}
|
||||
public:
|
||||
bool operator==(const Derived &rhs) const {
|
||||
return Base::equals(static_cast<const Base &>(rhs));
|
||||
}
|
||||
Derived(int i = 0) :
|
||||
Base(i)
|
||||
{}
|
||||
};
|
||||
|
||||
int
|
||||
main( int /* argc */, char* /* argv */[] )
|
||||
{
|
||||
const char * testfile = boost::archive::tmpnam(NULL);
|
||||
|
||||
// serialize Derived and Base
|
||||
Derived a(1), a1(2);
|
||||
{
|
||||
test_ostream os(testfile);
|
||||
test_oarchive oa(os);
|
||||
oa << boost::serialization::make_nvp("a", a);
|
||||
}
|
||||
{
|
||||
test_istream is(testfile, TEST_STREAM_FLAGS);
|
||||
test_iarchive ia(is, TEST_ARCHIVE_FLAGS);
|
||||
ia >> boost::serialization::make_nvp("a", a1);
|
||||
}
|
||||
std::remove(testfile);
|
||||
|
||||
if(a != a1)
|
||||
return 1;
|
||||
|
||||
// serialize Derived and Base
|
||||
Derived *ta = &a;
|
||||
Derived *ta1 = NULL;
|
||||
{
|
||||
test_ostream os(testfile);
|
||||
test_oarchive oa(os);
|
||||
oa << boost::serialization::make_nvp("ta", ta);
|
||||
}
|
||||
{
|
||||
test_istream is(testfile, TEST_STREAM_FLAGS);
|
||||
test_iarchive ia(is, TEST_ARCHIVE_FLAGS);
|
||||
ia >> boost::serialization::make_nvp("ta", ta1);
|
||||
}
|
||||
std::remove(testfile);
|
||||
if(*ta != *ta1)
|
||||
return 1;
|
||||
|
||||
return 0;
|
||||
}
|
||||
</code></pre>
|
||||
Difficulties start to occur when the base class is made polymorphic by the designation
|
||||
of one or more functions as "virtual". If a class is polymorphic, the library
|
||||
presumes that one will want the ability to serialize a derived class through
|
||||
a pointer to the base class. Included in the macro
|
||||
<code>
|
||||
BOOST_SERIALIZATION_BASE_OBJECT_NVP
|
||||
</code>
|
||||
is code which links derived and base class definitions in tables used to serialize
|
||||
derived classes through pointers to a polymorphinc base class. This code requires
|
||||
the ability to invoke
|
||||
<code>
|
||||
static_cast<Base &>(Derived &)
|
||||
</code>
|
||||
which C++ will only permit from within the derived class if the base class is
|
||||
private or protected. The program will fail to compile with an error message
|
||||
indicating invalid cast.
|
||||
<p>
|
||||
In order for this
|
||||
code compiler the following alteration must be made:
|
||||
<pre><code>
|
||||
template<class Archive>
|
||||
void serialize(Archive & ar, const unsigned int version){
|
||||
//ar & BOOST_SERIALIZATION_BASE_OBJECT_NVP(Base);
|
||||
ar & boost::serialization::make_nvp(
|
||||
"Base",
|
||||
static_cast<Base &>(*this)
|
||||
);
|
||||
}
|
||||
</code></pre>
|
||||
With this change the program will now compile.
|
||||
<p>
|
||||
If we made one of the functions of <code>Base></code> <code>virtual</code>
|
||||
in order to use the "export" functionality of the serialization library and permit serialization through
|
||||
a pointer the the base class, we'll be disappointed. Without the ability to
|
||||
cast to the base class, we can't use the functionality.
|
||||
<hr>
|
||||
<p><i>© Copyright <a href="http://www.rrsd.com">Robert Ramey</a> 2015.
|
||||
Distributed under the Boost Software License, Version 1.0. (See
|
||||
accompanying file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
|
||||
</i></p>
|
||||
</body>
|
||||
</html>
|
||||
+1
-1
@@ -49,7 +49,7 @@ streams even though they have similar syntax rules.
|
||||
<ul>
|
||||
<li>Archive classes are not kinds of streams though they
|
||||
are implemented in terms of streams. This
|
||||
distinction is addressed in <a href="bibliography.html#5">[5]</a> item number 41.
|
||||
distinction is addressed in <a href="bibliography.html#5">[5]</a> item number item 41 .
|
||||
<li>We don't want users to insert/extract data
|
||||
directly into/from the stream . This could
|
||||
create a corrupted archive. Were archives
|
||||
|
||||
+1
-19
@@ -29,8 +29,6 @@ http://www.boost.org/LICENSE_1_0.txt)
|
||||
</table>
|
||||
<hr>
|
||||
<dl class="index">
|
||||
<dt><a href="#differences_1_59">Differences from version 1.58</a></dt>
|
||||
<dt><a href="#differences_1_58">Differences from version 1.48</a></dt>
|
||||
<dt><a href="#differences_1_45">Differences from version 1.45</a></dt>
|
||||
<dt><a href="#differences_1_43">Differences from version 1.43</a></dt>
|
||||
<dt><a href="#differences_1_42">Differences from version 1.42</a></dt>
|
||||
@@ -41,28 +39,12 @@ http://www.boost.org/LICENSE_1_0.txt)
|
||||
<dt><a href="#differences_1_35">Differences from version 1.35</a></dt>
|
||||
<dt><a href="#differences_1_34">Differences from version 1.34</a></dt>
|
||||
<dt><a href="#differences_1_33">Differences from version 1.33</a></dt>
|
||||
<dt><a href="#differences_1_32">Differences from version 1.32</a></dt>
|
||||
<dt><a href="#differences_1_32">Differences from version 1.32</a></dt>
|
||||
<dt><a href="#todo">Pending Issues</a></dt>
|
||||
</dl>
|
||||
As of this writing, there are no known bugs. However, due to compiler/library
|
||||
quirks and or bugs, some tests fail with some combinations of compilers and
|
||||
libraries.
|
||||
<h2><a name="differences_1_59"></a>Differences from Boost 1.58</h2>
|
||||
<ul>
|
||||
<li>Eliminated support for Borland compilers and Microsoft compilers prior to version
|
||||
7.1.
|
||||
<li>Eliminated support for compilers which do not support Partial Function Template
|
||||
Ordering (pfto).
|
||||
<li>Added support for "visibility hidden" for GCC compilers. Shared libraries
|
||||
will only expose symbols actually needed rather than all sympols in the library. This
|
||||
should result in smaller shared libraries which are faster to load.
|
||||
</ul>
|
||||
<h2><a name="differences_1_58"></a>Differences from Boost 1.48</h2>
|
||||
<ul>
|
||||
<li>Added support for C++11 types such as std::shared_ptr, std::array, and others.
|
||||
<li>Implemented the concept of a "Helper" which can be used to implement serialization of types which are otherwise not serializable."
|
||||
<li>Made library compatible with C++11, Compatibility with C++03 has been maintained.
|
||||
</ul>
|
||||
<h2><a name="differences_1_45"></a>Differences from Boost 1.45</h2>
|
||||
Since the release of version 1.42, it has been discovered that binary
|
||||
archives created by versions 1.42-1.44 cannot always be read by the
|
||||
|
||||
+11
-11
@@ -136,7 +136,7 @@ be made accessible to the serialization library by including:
|
||||
friend class boost::serialization::access;
|
||||
</code></pre>
|
||||
in the class definition. This latter method should be preferred over the option
|
||||
of making the member function public. This will prevent serialization functions from
|
||||
of making member function public. This will prevent serialization functions from
|
||||
being called from outside the library. This is almost certainly an error. Unfortunately,
|
||||
it may appear to function but fail in a way that is very difficult to find.
|
||||
<p>
|
||||
@@ -196,7 +196,7 @@ templates can be in any of the following namespaces:
|
||||
Note that, at first glance, this suggestion may seem to be wrong for compilers which implement
|
||||
two phase lookup. In fact, the serialization library used a perhaps overly clever
|
||||
method to support this rule even for such compilers. Those with an interest in studying
|
||||
this further will find more information in
|
||||
this furter will find more information in
|
||||
<a target=serialization_hpp href="../../../boost/serialization/serialization.hpp">serialization.hpp</a>
|
||||
|
||||
<h3><a name="classmembers">Serialization of Class Members</a></h3>
|
||||
@@ -262,7 +262,7 @@ the question about what <code style="white-space: normal">const</code> means in
|
||||
of serialization.
|
||||
|
||||
<h4><a name="templates"></a>Templates</h4>
|
||||
Implementation of serialization for templates is exactly the same process
|
||||
Implementation serialization for templates is exactly the same process
|
||||
as for normal classes and requires no additional considerations. Among
|
||||
other things, this implies that serialization of compositions of templates
|
||||
are automatically generated when required if serialization of the
|
||||
@@ -273,7 +273,7 @@ class <code style="white-space: normal">my_t</code>, then serialization for
|
||||
<code style="white-space: normal">std::list< boost::shared_ptr< my_t> ></code> is already available
|
||||
for use.
|
||||
<p>
|
||||
For an example that shows how this idea might be implemented for your own
|
||||
See for an example that shows how this idea might be implemented for your own
|
||||
class templates, see
|
||||
<a href="../example/demo_auto_ptr.cpp" target="demo_auto_ptr.cpp">
|
||||
demo_auto_ptr.cpp</a>.
|
||||
@@ -434,7 +434,7 @@ is preferred. The key to the serialization implementation is that objects are s
|
||||
and loaded in exactly the same sequence. Using the <code style="white-space: normal">&</code>
|
||||
operator and <code style="white-space: normal">serialize</code>
|
||||
function guarantees that this is always the case and will minimize the
|
||||
occurrence of hard to find errors related to synchronization of
|
||||
occurence of hard to find errors related to synchronization of
|
||||
<code style="white-space: normal">save</code> and <code style="white-space: normal">load</code>
|
||||
functions.
|
||||
<p>
|
||||
@@ -482,7 +482,7 @@ Loading a pointer:
|
||||
<ol>
|
||||
<li>read a tag from the archive.
|
||||
<li>determine the type of object to be created
|
||||
<li>if the object has already been loaded, return its address.
|
||||
<li>if the object has already been loaded, return it's address.
|
||||
<li>otherwise, create a new instance of the object
|
||||
<li>read the data back in using the operators described above
|
||||
<li>return the address of the newly created object.
|
||||
@@ -496,7 +496,7 @@ and <code style="white-space: normal">>></code> operators
|
||||
<li>Loading the same pointer object multiple times
|
||||
results in only one object being created, thereby replicating
|
||||
the original pointer configuration.
|
||||
<li>Structures, such as collections of polymorphic pointers,
|
||||
<li>Structures such as collections of polymorphic pointers,
|
||||
are handled with no special effort on the part of users of this library.
|
||||
</ul>
|
||||
Serialization of pointers of derived types through a pointer to the
|
||||
@@ -789,10 +789,10 @@ class derived : public base {
|
||||
template<class Archive>
|
||||
void serialize(Archive & ar, const unsigned int file_version){
|
||||
// method 1 : invoke base class serialization
|
||||
ar & boost::serialization::base_object<base>(*this);
|
||||
boost::serialization::base_object<base>(*this);
|
||||
// method 2 : explicitly register base/derived relationship
|
||||
boost::serialization::void_cast_register<derived, base>(
|
||||
static_cast<derived *>(NULL),
|
||||
static_cast<derived *>=NULL),
|
||||
static_cast<base *>(NULL)
|
||||
)
|
||||
}
|
||||
@@ -907,11 +907,11 @@ rather than
|
||||
<pre><code>
|
||||
#include <list>
|
||||
</code></pre>
|
||||
Since the former includes the latter, this is all that is necessary.
|
||||
Since the former includes the latter, this all that is necessary.
|
||||
The same holds true for all STL collections as well as templates
|
||||
required to support them (e.g. <code style="white-space: normal">std::pair</code>).
|
||||
<p>
|
||||
As of this writing, the library contains serialization of the following boost classes:
|
||||
As of this writing, the library contains serialization of the following boost clases:
|
||||
<ul>
|
||||
<li>optional
|
||||
<li>variant
|
||||
|
||||
+5
-5
@@ -121,7 +121,7 @@ the same pointer deserialzed above. Default object tracking will ensure
|
||||
that no more than one instance of the object is created and that the
|
||||
pointer returned by multiple deserializations are all the same. Hence,
|
||||
regardless of how many instances of <code style="white-space: normal">shared_ptr/shared_count</code>
|
||||
corresponding to a particular object are created, they will all point
|
||||
corresponding to a particular object are created, the will all point
|
||||
to the same object.
|
||||
<p>
|
||||
Since <code style="white-space: normal">sp_counted_base_impl<P, D></code> is derived from
|
||||
@@ -150,7 +150,7 @@ inline void serialize(
|
||||
){
|
||||
}
|
||||
</code></pre>
|
||||
It would seem we're done, but running the test program,
|
||||
It would seem we're done, running the test program,
|
||||
<a href="../example/demo_shared_ptr.cpp" target="demo_shared_ptr_cpp">
|
||||
demo_shared_ptr.cpp
|
||||
</a>,
|
||||
@@ -197,7 +197,7 @@ void_cast_register<
|
||||
boost::detail::sp_counted_base,
|
||||
>();
|
||||
</code></pre>
|
||||
and we don't have to include a trival serializer for <code style="white-space: normal">sp_counted_base</code>.
|
||||
and we don't have to include a trival serializer for <code style="white-space: normal">sp_counted_base</code>
|
||||
<p>
|
||||
Finally we need to specify name-value pair wrappers if we want to be able
|
||||
to use this serialization with XML archives.
|
||||
@@ -219,9 +219,9 @@ shared pointers:
|
||||
BOOST_SHARED_POINTER_EXPORT(T)
|
||||
BOOST_SHARED_POINTER_EXPORT_GUID(T, K)
|
||||
</pre></code>
|
||||
These are specialized versions of the macros used for exporting classes serialized through raw pointers.
|
||||
These are specialize versions of the macros used for exporting classes serialized through raw pointers.
|
||||
<p>
|
||||
Clear, complete, correct and exception safe serialization of smart pointers is going to
|
||||
Clearly, complete, correct and exception safe serialization of smart pointers is going to
|
||||
be a challenge. I hope that this implementation provides a useful
|
||||
starting point for such an effort.
|
||||
<hr>
|
||||
|
||||
+1
-1
@@ -25,7 +25,7 @@ http://www.boost.org/LICENSE_1_0.txt)
|
||||
</tr>
|
||||
</table>
|
||||
<hr>
|
||||
The purpose of this example is to help clarify the usage of the
|
||||
The purpose of this example help clarify the usage of the
|
||||
<a href="archives.html"><strong>Archive Concept</strong></a>
|
||||
so that one can implement his own archive classes.
|
||||
<a href="../example/simple_log_archive.hpp" target="simple_archive_hpp">
|
||||
|
||||
+22
-20
@@ -42,10 +42,10 @@ names to types and tables which relate base classes to derived
|
||||
classes. Construction, destruction and usage of these variables
|
||||
requires consideration of the following issues:
|
||||
<ul>
|
||||
<li>Some static data variable and constant entries refer to others.
|
||||
<li>Some static data variables and constants entries refer to others.
|
||||
The sequence of initialization cannot be arbitrary but must be in proper
|
||||
sequence.</li>
|
||||
<li>A number of static variables aren't referred to explicitly and, without
|
||||
<li>A number of static variables aren't referred explicitly and, without
|
||||
special precautions, will be stripped by most code optimizers</li>
|
||||
<li>Many of these variables are created by templates and special care must
|
||||
be taken to be sure that they are instantiated</li>
|
||||
@@ -61,7 +61,7 @@ This singleton implementation has the following features:
|
||||
<li>
|
||||
Any instance will be constructed before any attempt is made to access it.</li>
|
||||
<li>
|
||||
Any instance created with a template is guaranteed to be instantiated.
|
||||
Any instance created with a template is guarenteed to be instantiated.
|
||||
<li>
|
||||
Regardless of whether or not an instance has been explicitly
|
||||
referred to, it will not be stripped by the optimizer when the
|
||||
@@ -70,16 +70,16 @@ This singleton implementation has the following features:
|
||||
All instances are constructed before
|
||||
<code style="white-space: normal">main</code> is called
|
||||
regardless of where they might be referenced within the program.
|
||||
In a multi-tasking system, this guarantees that there will be no
|
||||
In a multi-tasking system, this guarentees that there will be no
|
||||
race conditions during the construction of any instance. No
|
||||
thread locking is required to guarantee this.
|
||||
thread locking is required to guarentee this.
|
||||
<li>
|
||||
The above implies that any <code style="white-space: normal">const</code>
|
||||
instances are thread-safe during the whole program. Again, no
|
||||
thread locking is required.
|
||||
<li>
|
||||
If a mutable instance is created, and such an instance is modified
|
||||
after main is called in a multi-threading system, there exists
|
||||
after main is called in a mult-threading system, there exists
|
||||
the possibility that a race condition will occur. The serialization
|
||||
library takes care that in the few places where a mutable
|
||||
singleton is required, it is not altered after
|
||||
@@ -138,16 +138,17 @@ In order to be used as
|
||||
<a target="singleton.hpp" href = "../../../boost/serialization/singleton.hpp">
|
||||
<code style="white-space: normal">
|
||||
singleton<T>
|
||||
</code>
|
||||
</a>, the type T must be default constructable.
|
||||
</code>
|
||||
</a>
|
||||
, the type T must be default constructable.
|
||||
It doesn't require static variables - though it may have them.
|
||||
Since the library guarantees that only one instance of
|
||||
Since the library guarentees that only one instance of
|
||||
<a target="singleton.hpp" href = "../../../boost/serialization/singleton.hpp">
|
||||
<code style="white-space: normal">
|
||||
singleton<T>
|
||||
</code>
|
||||
</a>
|
||||
exists and all accesss is through the above static interface
|
||||
</code>
|
||||
</a>
|
||||
and all accesss is through the above static interface
|
||||
functions, common member functions of T become
|
||||
the functional equivalent of
|
||||
<code style="white-space: normal">static</code> functions.
|
||||
@@ -156,24 +157,24 @@ the functional equivalent of
|
||||
There are at least two different ways to use this class template.
|
||||
Both are used in the serialization library.
|
||||
<p>
|
||||
The first way is illustrated by an excerpt from the file
|
||||
The first way is illustrated by and excerpt from the file
|
||||
<code style="white-space: normal"><a target="extended_type_info" href="../src/extended_type_info.cpp">extended_type_info.cpp</a></code>.
|
||||
which contains the following code:
|
||||
|
||||
<pre><code>
|
||||
typedef std::set<const extended_type_info *, key_compare> ktmap;
|
||||
typedef std::set<const extended_type_info *, key_compare> ktmap;
|
||||
...
|
||||
void
|
||||
extended_type_info::key_register(const char *key) {
|
||||
...
|
||||
result = singleton<ktmap>::get_mutable_instance().insert(this);
|
||||
result = singleton<ktmap>::get_mutable_instance().insert(this);
|
||||
...
|
||||
}
|
||||
</code></pre>
|
||||
Just by referring to the singleton instance anywhere in the program
|
||||
will guarantee that one and only one instance for the specified
|
||||
will guarentee that one and only one instance for the specified
|
||||
type (<code style="white-space: normal">ktmap</code> in this example)
|
||||
will exist throughout the program. There is no need for any other
|
||||
will exist throughout the program. There is no need for anyother
|
||||
declaration or definition.
|
||||
<p>
|
||||
A second way is to use
|
||||
@@ -216,7 +217,7 @@ extended_type_info_typeid<T>::get_const_instance()
|
||||
</code></pre>
|
||||
|
||||
Again, including one or more of the above statements anywhere
|
||||
in the program will guarantee that one and only one instance
|
||||
in the program will guarentee that one and only one instance
|
||||
is created and referred to.
|
||||
|
||||
<h3><a name="multithreading">Multi-Threading</a></h3>
|
||||
@@ -224,9 +225,10 @@ This singleton CAN be safely used in multi-threading applications if one
|
||||
is careful follow a simple rule:
|
||||
<p>
|
||||
<b>Do not call get_mutable_instance when more than one thread is running!</b>
|
||||
<'>
|
||||
All singletons used in the serialization library follow this rule.
|
||||
In order to help detect accidental violations of this rule there
|
||||
exist singleton lock/unlock functions.
|
||||
exists an singleton lock/unlock functions.
|
||||
<pre><code>
|
||||
void boost::serialization::singleton_module::lock();
|
||||
void boost::serialization::singleton_module::unlock();
|
||||
@@ -240,7 +242,7 @@ alteration of static variables before
|
||||
<code style="white-space: normal">main</code> is called.
|
||||
The <code style="white-space: normal">lock()</code> and
|
||||
<code style="white-space: normal">unlock()</code> are "global"
|
||||
in that they affect ALL the singletons defined by this template.
|
||||
in they affect ALL the singletons defined by this template.
|
||||
All serialization tests invoke <code style="white-space: normal">lock()</code>
|
||||
at the start of the progam. For programs compiled in release
|
||||
mode these functions have no effect.
|
||||
|
||||
+9
-9
@@ -33,9 +33,9 @@ operators:
|
||||
<dt><code>static_cast<T *<>(U *)<br>static_cast<T &<>(U &)</code></dt>
|
||||
<dd>
|
||||
<ul>
|
||||
<li>required if neither T nor U are polymorphic
|
||||
<li>required if neither T nor U are not polymorphic
|
||||
<li>permitted in other cases.
|
||||
<li>fails to detect erroneous casts of polymophic pointers/references at runtime.
|
||||
<li>fails to detect erroneas casts of polymophic pointers/references at runtime.
|
||||
<li>does not permit "cross casting"
|
||||
<li>inline function calls can be optimized away during compile time.
|
||||
</ul>
|
||||
@@ -46,7 +46,7 @@ operators:
|
||||
<ul>
|
||||
<li>permitted if either T or U are polymorphic
|
||||
<li>prohibited in other cases.
|
||||
<li>throws exception on detecting erroneous casts of polymorphic pointers/references
|
||||
<li>throws exception on detecting erroneas casts of polymorphic pointers/references
|
||||
at runtime.
|
||||
<li>permits "cross casting"
|
||||
<li>cannot optimise inline virtual functions at compile time.
|
||||
@@ -91,14 +91,14 @@ template<class T>
|
||||
bool is_storable(T &t){
|
||||
// what type of cast to use here?
|
||||
|
||||
// this fails at compile time when T == base2
|
||||
// this fails at compiler time when T == base2
|
||||
// return static_cast<base1 &>(t).is_storable();
|
||||
|
||||
// this fails at compile time when T == top
|
||||
// this fails at compiler time when T == top
|
||||
// otherwise it works but cannot optimize inline function call
|
||||
// return dynamic_cast<base1 &>(t).is_storable();
|
||||
|
||||
// this always works - and is guaranteed to generate the fastest code !
|
||||
// this always works - and is guarenteed to generate the fastest code !
|
||||
return (boost::smart_cast_reference<base1 &>(t)).is_storable();
|
||||
}
|
||||
|
||||
@@ -121,7 +121,7 @@ The serialization library includes a mix of classes which use
|
||||
both static polymorphism (<strong>CRTP</strong>) and dynamic
|
||||
polymorphism via virtual functions. <code style="white-space: normal">smart_cast</code>
|
||||
was written to address the more problematic manifestations of the
|
||||
situation exemplified above.
|
||||
situation exmplified above.
|
||||
|
||||
<h3>Usage</h3>
|
||||
The following syntax is supported:
|
||||
@@ -134,14 +134,14 @@ Note that the above syntax doesn't include
|
||||
<pre><code>
|
||||
smart_cast<Target & >(Source & s)
|
||||
</code></pre>
|
||||
but the same functionality is supported with the following special syntax
|
||||
but the same functionality is supported the the following special syntax
|
||||
<pre><code>
|
||||
smart_cast_reference<Target &>(Source & s)
|
||||
</code></pre>
|
||||
|
||||
<h3>Requirements</h3>
|
||||
<code style="white-space: normal">smart_cast</code> can be used only on compilers that support partial
|
||||
template specialization or on types for which the
|
||||
template specialization or on types for which have be specified with the
|
||||
macro <code style="white-space: normal">
|
||||
BOOST_BROKEN_COMPILER_TYPE_TRAITS_SPECIALIZATION(<type>)</code>
|
||||
has been applied.
|
||||
|
||||
+31
-122
@@ -28,7 +28,6 @@ http://www.boost.org/LICENSE_1_0.txt)
|
||||
<dl class="page-index">
|
||||
<dt><a href="#objecttracking">Object Tracking</a>
|
||||
<dt><a href="#classinfo">Class Information</a>
|
||||
<dt><a href="#helpersupport">Helper Support</a>
|
||||
<dt><a href="#portability">Archive Portability</a>
|
||||
<dl class="page-index">
|
||||
<dt><a href="#numerics">Numerics</a>
|
||||
@@ -97,7 +96,7 @@ and a likely source of very subtle bugs.
|
||||
Unfortunately, implementation issues currently prevent the detection of this kind of
|
||||
error when the data item is wrapped as a name-value pair.
|
||||
<p>
|
||||
A similar problem can occur when different objects are loaded to an address
|
||||
A similar problem can occur when different objects are loaded to and address
|
||||
which is different from the final location:
|
||||
<pre><code>
|
||||
template<class Archive>
|
||||
@@ -112,7 +111,7 @@ void load(boost::basic_oarchive & ar, const unsigned int version) const
|
||||
</code></pre>
|
||||
In this case, the address of <code>x</code> is the one that is tracked rather than
|
||||
the address of the new item added to the set. Left unaddressed
|
||||
this will break the features that depend on tracking such as loading an object through a pointer.
|
||||
this will break the features that depend on tracking such as loading object through a pointer.
|
||||
Subtle bugs will be introduced into the program. This can be
|
||||
addressed by altering the above code thusly:
|
||||
|
||||
@@ -137,7 +136,7 @@ values are duplicated, overhead associated with object tracking can
|
||||
be eliminated by setting the object tracking class serialization trait
|
||||
appropriately.
|
||||
<p>
|
||||
By default, data types designated primitive by the
|
||||
By default, data types designated primitive by
|
||||
<a target="detail" href="traits.html#level">Implementation Level</a>
|
||||
class serialization trait are never tracked. If it is desired to
|
||||
track a shared primitive object through a pointer (e.g. a
|
||||
@@ -156,96 +155,6 @@ redundant save/load operations.
|
||||
BOOST_CLASS_TRACKING(my_virtual_base_class, boost::serialization::track_always)
|
||||
</code></pre>
|
||||
|
||||
<h3><a name="helpersupport">Helper Support</a></h3>
|
||||
Some types, specially those with complicated lifetime behavior or limited
|
||||
access to their internal state, might need or benefit from elaborate serialization
|
||||
algorithms. The prinicple motivating case is that of shared_ptr. As instances
|
||||
are loaded, they have to be "matched up" with any other instances which have
|
||||
already been loaded. Thus, a table of previously loaded instances has to be
|
||||
maintained while the archive containing the shared_ptr instances is being loaded.
|
||||
Without maintaining such a table, the shared_ptr would be a serializable type.
|
||||
<p>
|
||||
To implement this facility, one declares a <i>helper object</i>
|
||||
associated to the current archive that can be used to store contextual
|
||||
information relevant to the particular type serialization algorithm.
|
||||
|
||||
<pre><code>
|
||||
template<class T>
|
||||
class shared_ptr
|
||||
{
|
||||
...
|
||||
};
|
||||
|
||||
BOOST_SERIALIZATION_SPLIT_FREE(shared_ptr)
|
||||
|
||||
class shared_ptr_serialization_helper
|
||||
{
|
||||
// table of previously loaded shared_ptr
|
||||
// lookup a shared_ptr from the object address
|
||||
shared_ptr<T> lookup(const T *);
|
||||
// insert a new shared_ptr
|
||||
void insert<shared_ptr<T> >(const shared_ptr<T> *);
|
||||
};
|
||||
|
||||
namespace boost {
|
||||
namespace serialization {
|
||||
|
||||
template<class Archive>
|
||||
void save(Archive & ar, const shared_ptr & x, const unsigned int /* version */)
|
||||
{
|
||||
// save shared ptr
|
||||
...
|
||||
}
|
||||
|
||||
template<class Archive>
|
||||
void load(Archive & ar, shared_ptr & x, const unsigned int /* version */)
|
||||
{
|
||||
// get a unique identifier. Using a constant means that all shared pointers
|
||||
// are held in the same set. Thus we detect handle multiple pointers to the
|
||||
// same value instances in the archive.
|
||||
const void * shared_ptr_helper_id = 0;
|
||||
|
||||
shared_ptr_serialization_helper & hlp =
|
||||
ar.template get_helper<shared_ptr_serialization_helper>(helper_instance_id);
|
||||
|
||||
// load shared pointer object
|
||||
...
|
||||
|
||||
shared_ptr_serialization_helper & hlp =
|
||||
ar.template get_helper<shared_ptr_serialization_helper>(shared_ptr_helper_id);
|
||||
|
||||
// look up object in helper object
|
||||
T * shared_object hlp.lookup(...);
|
||||
|
||||
// if found, return the one from the table
|
||||
|
||||
// load the shared_ptr data
|
||||
shared_ptr<T> sp = ...
|
||||
|
||||
// and add it to the table
|
||||
hlp.insert(sp);
|
||||
// implement shared_ptr_serialization_helper load algorithm with the aid of hlp
|
||||
}
|
||||
|
||||
} // namespace serialization
|
||||
} // namespace boost
|
||||
</code></pre>
|
||||
<code style="white-space: normal">get_helper<shared_ptr_serialization_helper>();</code>
|
||||
creates a helper object associated to the archive the first time it is invoked;
|
||||
subsequent invocations return a reference to the object created in the first
|
||||
place, so that <code style="white-space: normal">hlp</code> can effectively be
|
||||
used to store contextual information persisting through the serialization
|
||||
of different <code style="white-space: normal">complex_type</code> objects on
|
||||
the same archive.
|
||||
|
||||
<p>
|
||||
Helpers may be created for saving and loading archives.
|
||||
The same program might have several different helpers or the same helper instantiated
|
||||
separately from different parts of the program. This is what makes the helper_instance_id
|
||||
necessary. In principle it could be any unique integer. In practice it seems
|
||||
easiest to use the address of the serialization function which contains it. The
|
||||
above example uses this technique.
|
||||
|
||||
<h3><a name="classinfo">Class Information</a></h3>
|
||||
By default, for each class serialized, class information is written to the archive.
|
||||
This information includes version number, implementation level and tracking
|
||||
@@ -267,7 +176,7 @@ in this manner comes at a cost. Once archives are released to users, the
|
||||
class serialization traits cannot be changed without invalidating the old
|
||||
archives. Including the class information in the archive assures us
|
||||
that they will be readable in the future even if the class definition
|
||||
is revised. A light weight structure such as a display pixel might be
|
||||
is revised. A light weight structure such as display pixel might be
|
||||
declared in a header like this:
|
||||
|
||||
<pre><code>
|
||||
@@ -295,14 +204,14 @@ BOOST_CLASS_TRACKING(pixel, boost::serialization::track_never)
|
||||
</code></pre>
|
||||
|
||||
<h3><a name="portability">Archive Portability</a></h3>
|
||||
Several archive classes create their data in the form of text or a portable binary format.
|
||||
It should be possible to save such a class on one platform and load it on another.
|
||||
Several archive classes create their data in the form of text or portable a binary format.
|
||||
It should be possible to save such an of such a class on one platform and load it on another.
|
||||
This is subject to a couple of conditions.
|
||||
<h4><a name="numerics">Numerics</a></h4>
|
||||
The architecture of the machine reading the archive must be able hold the data
|
||||
saved. For example, the gcc compiler reserves 4 bytes to store a variable of type
|
||||
<code style="white-space: normal">wchar_t</code> while other compilers reserve only 2 bytes.
|
||||
So it's possible that a value could be written that couldn't be represented by the loading program. This is a
|
||||
So its possible that a value could be written that couldn't be represented by the loading program. This is a
|
||||
fairly obvious situation and easily handled by using the numeric types in
|
||||
<a target="cstding" href="../../../boost/cstdint.hpp"><boost/cstdint.hpp></a>
|
||||
<P>
|
||||
@@ -387,7 +296,7 @@ not wrapped in a in a <a target="detail" href="wrappers.html#nvp">name-value pai
|
||||
be trapped at compile time. The system is implemented in such a way that for other archive classes,
|
||||
just the value portion of the data is serialized. The name portion is discarded during compilation.
|
||||
So by always using <a target="detail" href="wrappers.html#nvp">name-value pairs</a>, it will
|
||||
be guaranteed that all data can be serialized to all archive classes with maximum efficiency.
|
||||
be guarenteed that all data can be serialized to all archive classes with maximum efficiency.
|
||||
|
||||
<h3><a name="export">Exporting Class Serialization</a></h3>
|
||||
<a target="detail" href="traits.html#export">Elsewhere</a> in this manual, we have described
|
||||
@@ -402,7 +311,7 @@ requirement.
|
||||
In C++, usage of code not explicitly referred to is implemented via
|
||||
virtual functions. Hence, the need for export is implied by the
|
||||
usage of a derived class that is manipulated via a pointer or
|
||||
reference to its base class.
|
||||
reference to it's base class.
|
||||
|
||||
<p>
|
||||
<code style="white-space: normal">BOOST_CLASS_EXPORT</code> in the same
|
||||
@@ -414,7 +323,7 @@ archive class headers are included, then no code will be instantiated.
|
||||
<p>
|
||||
Note that the implemenation of this functionality requires
|
||||
that the <code style="white-space: normal">BOOST_CLASS_EXPORT</code>
|
||||
macro appear <b>after</b> the inclusion of any archive
|
||||
macro appear <b>after</b> and the inclusion of any archive
|
||||
class headers for which code is to be instantiated.
|
||||
So, code that uses <code style="white-space: normal">BOOST_CLASS_EXPORT</code>
|
||||
will look like the following:
|
||||
@@ -427,7 +336,7 @@ will look like the following:
|
||||
BOOST_CLASS_EXPORT(a)
|
||||
... // other class headers and exports
|
||||
</code></pre>
|
||||
This will be true regardless of whether the code is part
|
||||
This will be true regardless of whether the is part
|
||||
of a stand alone executable, a static library or
|
||||
a dyanmic or shared library.
|
||||
<p>
|
||||
@@ -456,14 +365,14 @@ one can include headers for just the
|
||||
<p>
|
||||
Strictly speaking, export should not be necessary if all pointer serialization
|
||||
occurs through the most derived class. However, in order to detect
|
||||
what would be a catastophic error, the library traps ALL serializations through
|
||||
a pointer to a polymorphic class which are not exported or otherwise registered.
|
||||
what would be catastophic error, the library traps ALL serializations through
|
||||
a pointer to a polymorphic which are not exported or otherwise registered.
|
||||
So, in practice, be prepared to register or export all classes with one
|
||||
or more virtual functions which are serialized through a pointer.
|
||||
|
||||
<p>
|
||||
Note that the implementation of this functionality depends upon vendor
|
||||
specific extensions to the C++ language. So, there is no guaranteed portability
|
||||
specific extensions to the C++ language. So, there is no guarenteed portability
|
||||
of programs which use this facility. However, all C++ compilers which
|
||||
are tested with boost provide the required extensions. The library
|
||||
includes the extra declarations required by each of these compilers.
|
||||
@@ -473,7 +382,7 @@ these extensions or something equivalent.
|
||||
<h3><a name="static_libraries">Static Libraries and Serialization</a></h3>
|
||||
Code for serialization of data types can be saved in libraries
|
||||
just as it can for the rest of the type implementation.
|
||||
This works well, and can save a huge amount of compilation time.
|
||||
This works well, and can save huge amount of compilation time.
|
||||
<ul>
|
||||
<li>Only compile serialization definitions in the library.
|
||||
<li>Explicitly instantiate serialization code for ALL
|
||||
@@ -549,9 +458,9 @@ guidelines:
|
||||
<li>Don't include <code>inline</code> code in classes used in DLLS.
|
||||
This will generate duplicate code in the DLLS and mainline. This
|
||||
needlessly duplicates code. Worse, it makes is possible for
|
||||
different versions of the same code to exist simultaneously. This
|
||||
different versions of the same code exist simultaneously. This
|
||||
type of error turns out to be excruciatingly difficult to debug.
|
||||
Finally, it opens the possibility that a module being referred to
|
||||
Finally, it opens the possibility that module being referred to
|
||||
might be explictly unloaded which would (hopefully) result in
|
||||
a runtime error. This is another bug that is not always
|
||||
reproducible or easy to find. For class member templates use something like
|
||||
@@ -568,26 +477,26 @@ void myclass::serialize(Archive & ar, const unsigned int version){
|
||||
...
|
||||
}
|
||||
|
||||
BOOST_CLASS_EXPORT_IMPLEMENT(my_class)
|
||||
BOOST_EXPORT_CLASS_IMPLEMENT(my_class)
|
||||
|
||||
#include <boost/archive/text_oarchive>
|
||||
#include <boost/archive/text_iarchive>
|
||||
#include <boost/archive/text_iarchive<
|
||||
template myclass::serialize(boost::archive::text_oarchive & ar, const unsigned int version);
|
||||
template myclass::serialize(boost::archive::text_iarchive & ar, const unsigned int version);
|
||||
... // repeat for each archive class to be used.
|
||||
</code></pre>
|
||||
in the implementation file. This will result in generation of all code
|
||||
required in only one place. The library does not detect this type of error for you.
|
||||
<li>If DLLS are to be loaded and unloaded explicitly (e.g. using <code>dlopen</code> in *nix or
|
||||
<li>If DLLS are to be loaded an unloaded explicitly (e.g. using <code>dlopen</code> in *nix or
|
||||
<code>LoadLibrary</code> in Windows). Try to arrange that they are unloaded in the reverse
|
||||
sequence. This should guarantee that problems are avoided even if the
|
||||
above guideline hasn't been followed.
|
||||
sequence. This should guarentee that problems are avoided even if the
|
||||
above guidline hasn't been followed.
|
||||
|
||||
</ul>
|
||||
|
||||
<h3><a name="plugins">Plugins</a></h3>
|
||||
In order to implement the library, various facilities for runtime
|
||||
manipulation of types at runtime were required. These
|
||||
manipulation of types are runtime were required. These
|
||||
are <a target="detail" href="extended_type_info.html"><code>extended_type_info</code></a>
|
||||
for associating classes with external identifying strings (<b>GUID</b>)
|
||||
and <a target="detail" href="void_cast.html"><code>void_cast</code></a>
|
||||
@@ -617,33 +526,33 @@ BOOST_CLASS_EXPORT(a)
|
||||
... // other class headers and exports
|
||||
</code></pre>
|
||||
|
||||
With this in place, one can construct, serialize and destroy a class
|
||||
about which is known only the <b>GUID</b> and a base class.
|
||||
With this in place, one can construct, serialize and destroy
|
||||
about which only is know the <b>GUID</b> and a base class.
|
||||
|
||||
|
||||
<h3><a name="multi_threading">Multi-Threading</a></h3>
|
||||
The fundamental purpose of serialization would conflict with multiple
|
||||
threads concurrently writing/reading from/to a single open archive instance.
|
||||
The library implementation presumes that the application avoids such a situtation.
|
||||
thread concurrently writing/reading from/to a single open archive instance.
|
||||
The library implementation presumes that the application avoids such an situtation.
|
||||
<p>
|
||||
However, Writing/Reading different archives simultaneously
|
||||
in different tasks is permitted as each archive instance is (almost)
|
||||
completely independent from any other archive instance. The only shared
|
||||
information is some type tables which have been implemented using a
|
||||
information are some type tables which have been implemented using a
|
||||
lock-free thread-safe
|
||||
<a target="detail" href="singleton.html">
|
||||
<code style="white-space: normal">singleton</code>
|
||||
</a>
|
||||
described elsewhere in this documentation.
|
||||
<p>
|
||||
This singleton implementation guarantees that all of this shared
|
||||
This singleton implementation guarentees that all of this shared
|
||||
information is initialized when the code module which contains
|
||||
it is loaded. The serialization library takes care to
|
||||
them is loaded. The serialization library takes care to
|
||||
ensure that these data structures are not subsequently
|
||||
modified. The only time there could be a problem would
|
||||
be if code is loaded/unloaded while another task is
|
||||
serializing data. This could only occur for types whose
|
||||
serialization is implemented in a dynamically loaded/unloaded DLL
|
||||
serialization is implemented in a dynamically loaded/unload DLL
|
||||
or shared library. So if the following is avoided:
|
||||
<ul>
|
||||
<li>Accessing the same archive instance from different tasks.
|
||||
|
||||
@@ -78,7 +78,7 @@ type but still of distinct type.
|
||||
|
||||
<h3>Implemenation</h3>
|
||||
<code style="white-space: normal">BOOST_STRONG_TYPEDEF</code> is a macro
|
||||
which generates a class named "name" which wraps an instance of its
|
||||
which generates a class named "name" wraps and instance of its
|
||||
primitive type and provides appropriate conversion operators in order
|
||||
to make the new type substitutable for the one that it wraps.
|
||||
|
||||
|
||||
+10
-9
@@ -43,12 +43,13 @@ Currently there is a portable binary archive in the examples directory.
|
||||
It is not regularly submitted to the exhaustive boost testing regimen
|
||||
but it is tested occasionally and has been used in production code.
|
||||
<p>
|
||||
It's missing the following:
|
||||
Its missing the following:
|
||||
<ul>
|
||||
<li>Addition of portable floating point types. This is not trivial. In addition to
|
||||
handling floating point types of varying sizes, It requires
|
||||
handling invalid floating point numbers (NaNs) in a portable manner.
|
||||
<li>Integration into the Boost testing regimen similar to the other archive classes.
|
||||
<li>Some way to test archive portability within the Boost testing regimen.
|
||||
<li>Integration into the Boost testing similar to the other archive classes.
|
||||
</ul>
|
||||
|
||||
<h2><a name="performancetesting"></a>Performance Testing and Profiling</h2>
|
||||
@@ -66,13 +67,13 @@ which shows the results of each test and links to the actual
|
||||
profile.
|
||||
<p>
|
||||
The first thing I did was include some of the serialization library tests.
|
||||
It became immediately apparent that these tests were totally unsuitable
|
||||
It became immediatly apparent that these tests were totally unsuitable
|
||||
for performance testing and that new tests needed to be written for this
|
||||
purpose. These tests would highlight the location of any performance
|
||||
bottlenecks in the serialization library. Whenever I've subjected my
|
||||
code in the past to this type of analysis, I've always been surprised
|
||||
code in the past to this type of analysis, I've always been suprised
|
||||
to find bottlenecks in totally unanticipated places and fixing those
|
||||
has always led to large improvements in performance. I expect that
|
||||
has always lead to large improvements in performance. I expect that
|
||||
this project would have a huge impact on the utility of the serialization
|
||||
library.
|
||||
|
||||
@@ -80,10 +81,10 @@ library.
|
||||
|
||||
It has been suggested that a useful feature of the library would be
|
||||
the ability to create "older versions" of archives. Currently,
|
||||
the library permits one to make programs that are guaranteed
|
||||
the library permits one make programs that are guarenteed
|
||||
the ability to load archives with classes of a previous version.
|
||||
But there is no way to save classes in accordance with a
|
||||
previous version. At first I dismissed this as a huge project
|
||||
But there is not way to save classes in accordance with a
|
||||
previous version. At first I dismissed this a a huge project
|
||||
with small demand. A cursory examination of the code revealed
|
||||
that this would not be very difficult. It would require some
|
||||
small changes in code and some additional tests. Also it
|
||||
@@ -100,7 +101,7 @@ to use the library without it. The example used for testing is an
|
||||
<code style="white-space: normal">extended_typeinfo</code>
|
||||
implemenation which presumes that all classes names have been exported.
|
||||
So, to make this library compatible for platforms without RTTI,
|
||||
a set of tests, examples and new manual section would have to be created.
|
||||
a set of tests, examples and new manual section would have to be created
|
||||
|
||||
<hr>
|
||||
<p>Revised 1 November, 2008
|
||||
|
||||
+25
-24
@@ -38,7 +38,7 @@ http://www.boost.org/LICENSE_1_0.txt)
|
||||
<dt><a href="#compiletime_messages">Compile Time Warnings and Errors</a>
|
||||
</dl>
|
||||
Serialization of data depends on the type of the data. For example, for
|
||||
primitive types such as <code style="white-space: normal">int</code>, it wouldn't make sense to save
|
||||
primitive types such as an <code style="white-space: normal">int</code>, it wouldn't make sense to save
|
||||
a version number in the archive. Likewise, for a data type that is never
|
||||
serialized through a pointer, it would (almost) never make sense to track
|
||||
the address of objects saved to/loaded from the archive as it will never
|
||||
@@ -232,12 +232,12 @@ statisfactory for our purposes for the following reasons:
|
||||
<li>There might be classes locally defined in different code modules
|
||||
that have the same name.
|
||||
<li>There might be classes with different names that we want to
|
||||
consider equivalent for purposes of serialization.
|
||||
consider equivalent for purposes of of serialization.
|
||||
</ul>
|
||||
<p>
|
||||
So in the serialization library, this is addressed by invoking
|
||||
<code style="white-space: normal">BOOST_CLASS_EXPORT_KEY2(my_class, "my_class_external_identifier")</code>
|
||||
in the header file which declares the class.
|
||||
in the header file which declares he class.
|
||||
In a large majority of applications, the class name works just fine
|
||||
for the external identifier string so the following short cut is
|
||||
defined -
|
||||
@@ -248,8 +248,8 @@ programs which do not use DLLS, one can specify
|
||||
<code style="white-space: normal">BOOST_CLASS_EXPORT(my_class)</code>
|
||||
or
|
||||
<code style="white-space: normal">BOOST_CLASS_EXPORT_GUID(my_class, "my_class_external_identifier")</code>
|
||||
in either the declaration header or definition. These macros
|
||||
expand to invocation of both of the macros described above.
|
||||
in either he declaration header or definition. These macros
|
||||
expand to invocation of the of both of the macros described above.
|
||||
<i>(<b>GUID</b> stands for <b>G</b>lobally <b>U</b>nique <b>ID</b>entfier.)</i>
|
||||
<p>
|
||||
<i>(<a target="detail" href="special.html#export">Elsewhere</a>
|
||||
@@ -267,7 +267,7 @@ in more than one module (or DLL).
|
||||
|
||||
<h3><a name="abstract">Abstract</a></h3>
|
||||
When serializing an object through a pointer to its base class,
|
||||
the library needs to determine whether or not the base is abstract
|
||||
the library needs to determine whether or not the bas is abstract
|
||||
(i.e. has at least one virtual function). The library uses the
|
||||
type trait macro <code style="white-space: normal">BOOST_IS_ABSTRACT(T)</code>
|
||||
to do this. Not all compilers support this type trait and corresponding
|
||||
@@ -333,9 +333,10 @@ This is illustrated by the test program
|
||||
Other implementations are possible and might be necessary for
|
||||
certain special cases.
|
||||
|
||||
version.hpp</a>.
|
||||
<h3><a name="wrappers">Wrappers</a></h3>
|
||||
Archives need to treat wrappers differently from other types since, for example,
|
||||
they usually are non-const objects while output archives require that any
|
||||
Archives need to treat wrappers diffently from other types since, for example,
|
||||
they usually are non-const object while output archives require that any
|
||||
serialized object (with the exception of a wrapper) be const.
|
||||
|
||||
This header file <a href="../../../boost/serialization/wrapper.hpp">wrapper.hpp</a>
|
||||
@@ -470,7 +471,7 @@ struct tracking_level<nvp<T> >
|
||||
#endif
|
||||
</code></pre>
|
||||
This can be problematic when one wants to make his code <strong>and archives</strong>
|
||||
portable to other platforms. It means the objects will be serialized differently
|
||||
portable to other platforms. It means the she objects will be serialized differently
|
||||
depending on the platform used. This implies that objects saved from one platform
|
||||
won't be loaded properly on another. In other words, archives won't be portable.
|
||||
<p>
|
||||
@@ -516,13 +517,13 @@ and template parameters should be assigned according to the following table:
|
||||
Some serialization traits can conflict with other ones. Sometimes these conflicts
|
||||
will result in erroneous behavior (E.G. creating of archives which could not be read)
|
||||
and other times they represent a probable misconception on the part of the
|
||||
library user which could result in suprising behavior. To the extent possible,
|
||||
library user which could result in suprising behavior. The extent possible,
|
||||
these conflicts are detected at compile time and errors (BOOST_STATIC_ASSERT)
|
||||
or warnings (BOOST_STATIC_WARNING) are generated. They are generated in a
|
||||
compiler dependent manner which should show a chain of instantiation
|
||||
or warnings (BOOST_STATIC_WARNING) are generated. The are generated in a
|
||||
compiler dependent way manner which should show an chain of instantiation
|
||||
to the point where the error/warning is detected. Without this capability,
|
||||
it would be very hard to track down errors or unexpected behavior in library
|
||||
usage. Here is a list of the conflicts trapped:
|
||||
usage. Here is list of the conflicts trapped:
|
||||
|
||||
<dl>
|
||||
<dt><h2><a name="object_level">object_level</a> - error</h2></dt>
|
||||
@@ -631,9 +632,9 @@ class K {
|
||||
discovered that when loading the archives made in the last month (reading the
|
||||
log). Things don't work. The second log entry is always the same as the
|
||||
first. After a series of very long and increasingly acrimonius email exchanges,
|
||||
it's discovered
|
||||
that programmer(3) accidently broke programmer(2)'s code .This is because by
|
||||
serializing via a pointer, the "log" object is now being tracked. This is because
|
||||
its discovered
|
||||
that programmer (3) accidently broke programmer(2)'s code .This is because by
|
||||
serializing via a pointer, the "log" object now being tracked. This is because
|
||||
the default tracking behavior is "track_selectively". This means that class
|
||||
instances are tracked only if they are serialized through pointers anywhere in
|
||||
the program. Now multiple saves from the same address result in only the first one
|
||||
@@ -641,11 +642,11 @@ it's discovered
|
||||
data might have been changed. When it comes time to load the data, all instances of the log record show the same data.
|
||||
In this way, the behavior of a functioning piece of code is changed due the side
|
||||
effect of a change in an otherwise disjoint module.
|
||||
Worse yet, the data has been lost and cannot be recovered from the archives.
|
||||
Worse yet, the data has been lost and cannot not be now recovered from the archives.
|
||||
People are really upset and disappointed with boost (at least the serialization system).
|
||||
<p>
|
||||
<li>
|
||||
After a lot of investigation, it's discovered what the source of the problem is
|
||||
After a lot of investigation, it's discovered what the source of the problem
|
||||
and class construct_from is marked "track_never" by including:
|
||||
<code style="white-space: normal"><pre>
|
||||
BOOST_CLASS_TRACKING(construct_from, track_never)
|
||||
@@ -659,7 +660,7 @@ have its own distinct raw pointer. This will break
|
||||
<code style="white-space: normal">shared_ptr</code> and cause a memory leak. Again,
|
||||
The cause of this problem is very far removed from the point of discovery. It could
|
||||
well be that the problem is not even discovered until after the archives are loaded.
|
||||
Now we not only have a difficult to find and fix program bug, but we have a bunch of
|
||||
Now we not only have difficult to find and fix program bug, but we have a bunch of
|
||||
invalid archives and lost data.
|
||||
</ol>
|
||||
|
||||
@@ -672,7 +673,7 @@ invalid archives and lost data.
|
||||
ar << x;
|
||||
</pre></code>
|
||||
<p>
|
||||
<li>The programmer curses (another %^&*&* hoop to jump through). He's in a
|
||||
<li>The programmer curses (another %^&*&* hoop to jump through). If he's in a
|
||||
hurry (and who isn't) and would prefer not to <code style="white-space: normal">const_cast</code>
|
||||
- because it looks bad. So he'll just make the following change an move on.
|
||||
<code style="white-space: normal"><pre>
|
||||
@@ -696,8 +697,8 @@ ar << x
|
||||
<p>
|
||||
He's mildly annoyed now he tries the following:
|
||||
<ul>
|
||||
<li>He considers making f() a const - but presumably that shifts the const
|
||||
error to somewhere else. And he doesn't want to fiddle with "his" code to
|
||||
<li>He considers making f() a const - but presumable that shifts the const
|
||||
error to somewhere else. And his doesn't want to fiddle with "his" code to
|
||||
work around a quirk in the serializaition system
|
||||
<p>
|
||||
<li>He removes the <code style="white-space: normal">const</code>
|
||||
@@ -747,7 +748,7 @@ Note that in this second scenario
|
||||
|
||||
It's true that these messages may sometimes flag code that is currently correct and
|
||||
that this may be annoying to some programmers. However, this example illustrates
|
||||
my view that these messages are useful and that any such annoyance is a small price to
|
||||
my view that these messages are useful and that any such annoyance is small price to
|
||||
pay to avoid particularly vexing programming errors.
|
||||
|
||||
</dd>
|
||||
@@ -764,7 +765,7 @@ level <= object_serializable.
|
||||
in this case, indication that an object is tracked is
|
||||
not stored in the archive itself - see level == object_serializable.
|
||||
Since class information is not saved in the archive, the existence
|
||||
or absence of the operation ar << T * anywhere else in the
|
||||
or absense of the operation ar << T * anywhere else in the
|
||||
program is used to infer that an object of this type should be tracked.
|
||||
<p>
|
||||
A problem arises when a program which reads an archive
|
||||
|
||||
+2
-2
@@ -327,7 +327,7 @@ clas pointer may require explicit enumeration of the derived
|
||||
classes to be serialized. This is referred to as "registration" or "export"
|
||||
of derived classes. This requirement and the methods of
|
||||
satisfying it are explained in detail
|
||||
<a href="serialization.html#derivedpointers">here</a>.
|
||||
<a href="serialization.html#derivedpointers">here</a>
|
||||
<p>
|
||||
All this is accomplished automatically by the serialization
|
||||
library. The above code is all that is necessary to accomplish
|
||||
@@ -569,7 +569,7 @@ anywhere in the program - a memory leak.
|
||||
There are couple of ways of fixing this. One way is to explicitly manage the bus stops.
|
||||
However, a more robust and transparent is to use
|
||||
<code style="white-space: normal">shared_ptr</code> rather than raw pointers. Along
|
||||
with serialization implementations for the Standard Library, the serialization library
|
||||
with serialization implemenations for the Standard Library, the serialization library
|
||||
includes implementation of serialization for
|
||||
<code style="white-space: normal">boost::shared ptr</code>. Given this, it should be
|
||||
easy to alter any of these examples to eliminate the memory leak. This is left
|
||||
|
||||
@@ -1,38 +0,0 @@
|
||||
IMPORTANT:
|
||||
|
||||
This is the last release from me as EOS employee. I plan to contribute all of this
|
||||
work to the official boost libraries distribution and will continue to support users.
|
||||
Francois Mauger joined me recently and already added a valuable tutorial for you!
|
||||
|
||||
Changelog:
|
||||
|
||||
07.11.2015 5.1 Small fix to get it running up to 1.59.
|
||||
|
||||
26.06.2012 5.0 Ported to boost versions up to 1.49.
|
||||
Added support for wstring, added tutorial by Francois Mauger.
|
||||
|
||||
01.04.2011 4.2 Ported to boost versions up to 1.46.1.
|
||||
Allow serialization of inf and nan values.
|
||||
|
||||
17.12.2009 4.1 Ported to boost versions up to 1.41.
|
||||
|
||||
4.0 Changes in inheritance make arrays work.
|
||||
|
||||
13.02.2009 3.1 Shared pointer serialization capabilities added
|
||||
Ported to recent boost versions (up to 1.38)
|
||||
|
||||
25.09.2008 3.0 Refactored, fixed and ported to recent boost versions
|
||||
Archives are now named eos::portable_[io]archive
|
||||
|
||||
17.09.2008 2.1 Improved floating point handling and error detection.
|
||||
Extracted the exception class into an extra file.
|
||||
|
||||
28.04.2008 2.0 Major Bugfix resolving negative number collision!
|
||||
|
||||
28.11.2007 1.1 Small Bugfix in portable_binary_archive_exception class:
|
||||
throwing specifiers did not match base class declaration
|
||||
|
||||
12.11.2007 1.0 Initial Release to boost-users!
|
||||
|
||||
Christian Pfligersdorffer
|
||||
christian.pfligersdorffer@gmx.at
|
||||
@@ -1,56 +0,0 @@
|
||||
/** tutorial_pba_0.cpp
|
||||
*
|
||||
* (C) Copyright 2011 François Mauger, Christian Pfligersdorffer
|
||||
*
|
||||
* 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)
|
||||
*
|
||||
*/
|
||||
|
||||
/**
|
||||
* The intent of this program is to serve as a tutorial for
|
||||
* users of the portable binary archive in the framework of
|
||||
* the Boost/Serialization library.
|
||||
*
|
||||
* This quick start example shows how to store some variables
|
||||
* of basic types (bool, integer, floating point numbers, STL string)
|
||||
* using the portable binary archive format associated to a
|
||||
* standard output file stream.
|
||||
*
|
||||
*/
|
||||
|
||||
#include <string>
|
||||
#include <fstream>
|
||||
|
||||
#include <boost/cstdint.hpp>
|
||||
#include <boost/archive/portable_binary_oarchive.hpp>
|
||||
|
||||
int main (void)
|
||||
{
|
||||
// The name for the example data file :
|
||||
std::string filename = "pba_0.data";
|
||||
|
||||
// Some variables of various primitive types :
|
||||
bool b = true;
|
||||
char c = 'B';
|
||||
uint32_t answer = 42;
|
||||
float computing_time = 7.5e6;
|
||||
double e = 2.71828182845905;
|
||||
std::string slogan = "DON'T PANIC";
|
||||
|
||||
// Open an output file stream in binary mode :
|
||||
std::ofstream fout (filename.c_str (), std::ios_base::binary);
|
||||
|
||||
{
|
||||
// Create an output portable binary archive attached to the output file :
|
||||
boost::archive::portable_binary_oarchive opba (fout);
|
||||
|
||||
// Store (serializing) variables :
|
||||
opba & b & c & answer & computing_time & e & slogan;
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
// end of tutorial_pba_0.cpp
|
||||
@@ -1,68 +0,0 @@
|
||||
/** tutorial_pba_1.cpp
|
||||
*
|
||||
* (C) Copyright 2011 François Mauger, Christian Pfligersdorffer
|
||||
*
|
||||
* 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)
|
||||
*
|
||||
*/
|
||||
|
||||
/**
|
||||
* The intent of this program is to serve as a tutorial for
|
||||
* users of the portable binary archive in the framework of
|
||||
* the Boost/Serialization package.
|
||||
*
|
||||
* This quick start example shows how to load some variables
|
||||
* of basic types (bool, integer, floating point numbers, STL string)
|
||||
* using the portable binary archive format associated to a
|
||||
* standard input file stream.
|
||||
*
|
||||
*/
|
||||
|
||||
#include <iostream>
|
||||
#include <string>
|
||||
#include <fstream>
|
||||
|
||||
#include <boost/cstdint.hpp>
|
||||
#include <boost/archive/portable_binary_iarchive.hpp>
|
||||
|
||||
int main (void)
|
||||
{
|
||||
using namespace std;
|
||||
|
||||
// The name for the example data file :
|
||||
string filename = "pba_0.data";
|
||||
|
||||
// Some variables of various types :
|
||||
bool b;
|
||||
char c;
|
||||
uint32_t answer;
|
||||
float computing_time;
|
||||
double e;
|
||||
string slogan;
|
||||
|
||||
// Open an input file stream in binary mode :
|
||||
ifstream fin (filename.c_str (), ios_base::binary);
|
||||
|
||||
{
|
||||
// Create an input portable binary archive attached to the input file :
|
||||
boost::archive::portable_binary_iarchive ipba (fin);
|
||||
|
||||
// Loading (de-serializing) variables using the same
|
||||
// order than for serialization (see tutorial_pba_0.cpp) :
|
||||
ipba & b & c & answer & computing_time & e & slogan;
|
||||
}
|
||||
|
||||
cout.precision (15);
|
||||
cout << "Variable 'b' is : " << b << " " << "(bool)" << endl;
|
||||
cout << "Variable 'c' is : '" << c << "' " << " " << "(char)" << endl;
|
||||
cout << "Variable 'answer' is : " << answer << " " << "(unsigned 32-bit integer)" << endl;
|
||||
cout << "Variable 'computing_time' is : " << computing_time << " " << "(single precision 32-bit float)" << endl;
|
||||
cout << "Variable 'e' is : " << e << " " << "(double precision 64-bit float)" << endl;
|
||||
cout << "Variable 'slogan' is : \"" << slogan << "\" " << "(std::string)" << endl;
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
// end of tutorial_pba_1.cpp
|
||||
@@ -1,162 +0,0 @@
|
||||
/** tutorial_pba_10.cpp
|
||||
*
|
||||
* (C) Copyright 2011 François Mauger, Christian Pfligersdorffer
|
||||
*
|
||||
* 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)
|
||||
*
|
||||
*/
|
||||
|
||||
/**
|
||||
* The intent of this program is to serve as a tutorial for
|
||||
* users of the portable binary archive in the framework of
|
||||
* the Boost/Serialization library.
|
||||
*
|
||||
* This example shows how use PBAs combined with on-the-fly
|
||||
* compressed I/O streams.
|
||||
*
|
||||
*/
|
||||
|
||||
#include <string>
|
||||
#include <fstream>
|
||||
#include <limits>
|
||||
#include <vector>
|
||||
|
||||
#include <boost/cstdint.hpp>
|
||||
#include <boost/archive/portable_binary_oarchive.hpp>
|
||||
#include <boost/archive/portable_binary_iarchive.hpp>
|
||||
#include <boost/iostreams/filtering_stream.hpp>
|
||||
#include <boost/iostreams/filter/gzip.hpp>
|
||||
#include <boost/serialization/access.hpp>
|
||||
#include <boost/serialization/vector.hpp>
|
||||
|
||||
using namespace std;
|
||||
|
||||
class data_type
|
||||
{
|
||||
private:
|
||||
friend class boost::serialization::access;
|
||||
template<class Archive>
|
||||
void serialize (Archive & ar, const unsigned int version);
|
||||
public:
|
||||
void print (ostream & out, const string & title) const;
|
||||
public:
|
||||
vector<double> values;
|
||||
data_type ();
|
||||
};
|
||||
|
||||
data_type::data_type () : values ()
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
void data_type::print (ostream & out, const string & title) const
|
||||
{
|
||||
out << endl;
|
||||
out << title << " :" << endl;
|
||||
for (int i = 0; i < this->values.size (); ++i)
|
||||
{
|
||||
out.precision (16);
|
||||
out.width (18);
|
||||
out << this->values [i] << ' ' ;
|
||||
if ((i%4) == 3) clog << endl;
|
||||
}
|
||||
out << endl;
|
||||
return;
|
||||
}
|
||||
|
||||
template<class Archive>
|
||||
void data_type::serialize (Archive & ar, const unsigned int version)
|
||||
{
|
||||
ar & values;
|
||||
return;
|
||||
}
|
||||
|
||||
void do_gzipped_out (void)
|
||||
{
|
||||
// The name for the output data file :
|
||||
string filename = "pba_10.data.gz";
|
||||
|
||||
// A data structure to be stored :
|
||||
data_type my_data;
|
||||
|
||||
// Fill the vector with arbitrary (possibly non-finite) values :
|
||||
size_t dim = 1000;
|
||||
my_data.values.reserve (dim);
|
||||
for (int i = 0; i < dim; ++i)
|
||||
{
|
||||
double val = (i + 1) * (1.0 + 3 * numeric_limits<double>::epsilon ());
|
||||
if (i == 4) val = numeric_limits<double>::quiet_NaN ();
|
||||
if (i == 23) val = numeric_limits<double>::infinity ();
|
||||
if (i == 73) val = -numeric_limits<double>::infinity ();
|
||||
if (i == 90) val = 0.0;
|
||||
my_data.values.push_back (val);
|
||||
}
|
||||
|
||||
// Print:
|
||||
my_data.print (clog, "Stored data");
|
||||
|
||||
// Create an output filtering stream :
|
||||
boost::iostreams::filtering_ostream zout;
|
||||
zout.push (boost::iostreams::gzip_compressor ());
|
||||
|
||||
// Open an output file stream in binary mode :
|
||||
ofstream fout (filename.c_str (), ios_base::binary);
|
||||
zout.push (fout);
|
||||
|
||||
// Save to PBA :
|
||||
{
|
||||
// Create an output portable binary archive attached to the output file :
|
||||
boost::archive::portable_binary_oarchive opba (zout);
|
||||
|
||||
// Store (serializing) the data :
|
||||
opba & my_data;
|
||||
}
|
||||
|
||||
// Clean termination of the streams :
|
||||
zout.flush ();
|
||||
zout.reset ();
|
||||
|
||||
return;
|
||||
}
|
||||
|
||||
void do_gzipped_in (void)
|
||||
{
|
||||
// The name for the input data file :
|
||||
string filename = "pba_10.data.gz";
|
||||
|
||||
// A data structure to be loaded :
|
||||
data_type my_data;
|
||||
|
||||
// Create an input filtering stream :
|
||||
boost::iostreams::filtering_istream zin;
|
||||
zin.push (boost::iostreams::gzip_decompressor ());
|
||||
|
||||
// Open an input file stream in binary mode :
|
||||
ifstream fin (filename.c_str (), ios_base::binary);
|
||||
zin.push (fin);
|
||||
|
||||
// Load from PBA :
|
||||
{
|
||||
// Create an input portable binary archive attached to the input file :
|
||||
boost::archive::portable_binary_iarchive ipba (zin);
|
||||
|
||||
// Load (deserializing) the data :
|
||||
ipba & my_data;
|
||||
}
|
||||
|
||||
// Print:
|
||||
my_data.print (clog, "Loaded data");
|
||||
|
||||
return;
|
||||
}
|
||||
|
||||
int main (void)
|
||||
{
|
||||
do_gzipped_out ();
|
||||
do_gzipped_in ();
|
||||
return 0;
|
||||
}
|
||||
|
||||
// end of tutorial_pba_10.cpp
|
||||
@@ -1,198 +0,0 @@
|
||||
/** tutorial_pba_10b.cpp
|
||||
*
|
||||
* (C) Copyright 2011 François Mauger, Christian Pfligersdorffer
|
||||
*
|
||||
* 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)
|
||||
*
|
||||
*/
|
||||
|
||||
/**
|
||||
* The intent of this program is to serve as a tutorial for
|
||||
* users of the portable binary archive in the framework of
|
||||
* the Boost/Serialization library.
|
||||
*
|
||||
* This example shows how use PBAs combined with on-the-fly
|
||||
* compressed I/O streams.
|
||||
*
|
||||
*/
|
||||
|
||||
#include <string>
|
||||
#include <fstream>
|
||||
#include <limits>
|
||||
#include <vector>
|
||||
|
||||
#include <boost/cstdint.hpp>
|
||||
#include <boost/archive/portable_binary_oarchive.hpp>
|
||||
#include <boost/archive/portable_binary_iarchive.hpp>
|
||||
#include <boost/archive/xml_oarchive.hpp>
|
||||
#include <boost/iostreams/filtering_stream.hpp>
|
||||
#include <boost/iostreams/filter/gzip.hpp>
|
||||
#include <boost/serialization/access.hpp>
|
||||
#include <boost/serialization/vector.hpp>
|
||||
#include <boost/serialization/nvp.hpp>
|
||||
#include <boost/serialization/version.hpp>
|
||||
|
||||
using namespace std;
|
||||
|
||||
class data_type
|
||||
{
|
||||
private:
|
||||
friend class boost::serialization::access;
|
||||
template<class Archive>
|
||||
void serialize (Archive & ar, const unsigned int version);
|
||||
public:
|
||||
void print (ostream & out, const string & title) const;
|
||||
public:
|
||||
vector<double> values;
|
||||
data_type ();
|
||||
};
|
||||
|
||||
//BOOST_CLASS_VERSION(data_type, 7)
|
||||
|
||||
data_type::data_type () : values ()
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
void data_type::print (ostream & out, const string & title) const
|
||||
{
|
||||
out << endl;
|
||||
out << title << " :" << endl;
|
||||
for (int i = 0; i < this->values.size (); ++i)
|
||||
{
|
||||
out.precision (16);
|
||||
out.width (18);
|
||||
out << this->values [i] << ' ' ;
|
||||
if ((i%4) == 3) clog << endl;
|
||||
}
|
||||
out << endl;
|
||||
return;
|
||||
}
|
||||
|
||||
template<class Archive>
|
||||
void data_type::serialize (Archive & ar, const unsigned int version)
|
||||
{
|
||||
ar & BOOST_SERIALIZATION_NVP (values);
|
||||
return;
|
||||
}
|
||||
|
||||
class data_type2
|
||||
{
|
||||
private:
|
||||
friend class boost::serialization::access;
|
||||
template<class Archive>
|
||||
void serialize (Archive & ar, const unsigned int version);
|
||||
public:
|
||||
double value;
|
||||
data_type2 ();
|
||||
};
|
||||
|
||||
BOOST_CLASS_VERSION(data_type2, 99)
|
||||
|
||||
data_type2::data_type2 () : value (666.666)
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
template<class Archive>
|
||||
void data_type2::serialize (Archive & ar, const unsigned int version)
|
||||
{
|
||||
ar & BOOST_SERIALIZATION_NVP (value);
|
||||
return;
|
||||
}
|
||||
|
||||
class data_type3
|
||||
{
|
||||
private:
|
||||
friend class boost::serialization::access;
|
||||
template<class Archive>
|
||||
void serialize (Archive & ar, const unsigned int version);
|
||||
public:
|
||||
vector<data_type2> values;
|
||||
data_type3 ();
|
||||
};
|
||||
|
||||
BOOST_CLASS_VERSION(data_type3, 33)
|
||||
|
||||
data_type3::data_type3 ()
|
||||
{
|
||||
{
|
||||
data_type2 d;
|
||||
d.value = 6.66;
|
||||
values.push_back (d);
|
||||
}
|
||||
{
|
||||
data_type2 d;
|
||||
d.value = 66.66;
|
||||
values.push_back (d);
|
||||
}
|
||||
{
|
||||
data_type2 d;
|
||||
d.value = 666.66;
|
||||
values.push_back (d);
|
||||
}
|
||||
return;
|
||||
}
|
||||
|
||||
template<class Archive>
|
||||
void data_type3::serialize (Archive & ar, const unsigned int version)
|
||||
{
|
||||
ar & BOOST_SERIALIZATION_NVP (values);
|
||||
return;
|
||||
}
|
||||
|
||||
/********************/
|
||||
|
||||
void do_xml_out (void)
|
||||
{
|
||||
// The name for the output data file :
|
||||
string filename = "pba_10.xml";
|
||||
|
||||
// A data structure to be stored :
|
||||
data_type my_data;
|
||||
|
||||
// Fill the vector with arbitrary (possibly non-finite) values :
|
||||
size_t dim = 6;
|
||||
my_data.values.reserve (dim);
|
||||
for (int i = 0; i < dim; ++i)
|
||||
{
|
||||
double val = (i + 1) * (1.0 + 3 * numeric_limits<double>::epsilon ());
|
||||
if (i == 4) val = numeric_limits<double>::quiet_NaN ();
|
||||
if (i == 7) val = numeric_limits<double>::infinity ();
|
||||
if (i == 9) val = -numeric_limits<double>::infinity ();
|
||||
if (i == 13) val = 0.0;
|
||||
my_data.values.push_back (val);
|
||||
}
|
||||
|
||||
// Print:
|
||||
my_data.print (clog, "Stored data");
|
||||
|
||||
data_type2 my_data2;
|
||||
data_type3 my_data3;
|
||||
|
||||
// Open an output file stream in binary mode :
|
||||
ofstream fout (filename.c_str ());
|
||||
|
||||
// Save to PBA :
|
||||
{
|
||||
// Create an output XML archive attached to the output file :
|
||||
boost::archive::xml_oarchive oxa (fout);
|
||||
|
||||
// Store (serializing) the data :
|
||||
oxa & BOOST_SERIALIZATION_NVP(my_data);
|
||||
oxa & BOOST_SERIALIZATION_NVP(my_data2);
|
||||
oxa & BOOST_SERIALIZATION_NVP(my_data3);
|
||||
}
|
||||
|
||||
return;
|
||||
}
|
||||
|
||||
int main (void)
|
||||
{
|
||||
do_xml_out ();
|
||||
return 0;
|
||||
}
|
||||
|
||||
// end of tutorial_pba_10b.cpp
|
||||
@@ -1,187 +0,0 @@
|
||||
/** tutorial_pba_11.cpp
|
||||
*
|
||||
* (C) Copyright 2011 François Mauger, Christian Pfligersdorffer
|
||||
*
|
||||
* 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)
|
||||
*
|
||||
*/
|
||||
|
||||
/**
|
||||
* The intent of this program is to serve as a tutorial for
|
||||
* users of the portable binary archive in the framework of
|
||||
* the Boost/Serialization library.
|
||||
*
|
||||
* This example program compares the times needed to serialize
|
||||
* and deserialize some large amount of data using PBA and
|
||||
* text archives.
|
||||
*
|
||||
*/
|
||||
|
||||
#include <string>
|
||||
#include <fstream>
|
||||
#include <vector>
|
||||
|
||||
#include <boost/archive/portable_binary_oarchive.hpp>
|
||||
#include <boost/archive/portable_binary_iarchive.hpp>
|
||||
#include <boost/archive/text_oarchive.hpp>
|
||||
#include <boost/archive/text_iarchive.hpp>
|
||||
#include <boost/serialization/access.hpp>
|
||||
#include <boost/serialization/vector.hpp>
|
||||
#include <boost/random/mersenne_twister.hpp>
|
||||
#include <boost/random/uniform_real_distribution.hpp>
|
||||
#include <boost/timer.hpp>
|
||||
|
||||
using namespace std;
|
||||
|
||||
class data_type
|
||||
{
|
||||
private:
|
||||
friend class boost::serialization::access;
|
||||
template<class Archive>
|
||||
void serialize (Archive & ar, const unsigned int version);
|
||||
public:
|
||||
void print (ostream & out, const string & title) const;
|
||||
public:
|
||||
vector<double> values;
|
||||
data_type ();
|
||||
};
|
||||
|
||||
data_type::data_type () : values ()
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
void data_type::print (ostream & out, const string & title) const
|
||||
{
|
||||
out << endl;
|
||||
out << title << " :" << endl;
|
||||
bool skip = false;
|
||||
for (int i = 0; i < this->values.size (); ++i)
|
||||
{
|
||||
if ((i >= 12) && (i < (int) this->values.size () - 8))
|
||||
{
|
||||
if (! skip) out << " ..." << endl;
|
||||
skip = true;
|
||||
continue;
|
||||
}
|
||||
out.precision (16);
|
||||
out.width (18);
|
||||
out << this->values [i] << ' ' ;
|
||||
if ((i%4) == 3) clog << endl;
|
||||
}
|
||||
out << endl;
|
||||
return;
|
||||
}
|
||||
|
||||
template<class Archive>
|
||||
void data_type::serialize (Archive & ar, const unsigned int version)
|
||||
{
|
||||
ar & values;
|
||||
return;
|
||||
}
|
||||
|
||||
double do_pba_out (const data_type & a_data)
|
||||
{
|
||||
string filename = "pba_11.data";
|
||||
ofstream fout (filename.c_str (), ios_base::binary);
|
||||
boost::timer io_timer;
|
||||
{
|
||||
boost::archive::portable_binary_oarchive opba (fout);
|
||||
opba & a_data;
|
||||
}
|
||||
return io_timer.elapsed ();
|
||||
}
|
||||
|
||||
double do_pba_in (data_type & a_data)
|
||||
{
|
||||
string filename = "pba_11.data";
|
||||
ifstream fin (filename.c_str (), ios_base::binary);
|
||||
boost::timer io_timer;
|
||||
{
|
||||
boost::archive::portable_binary_iarchive ipba (fin);
|
||||
ipba & a_data;
|
||||
}
|
||||
return io_timer.elapsed ();
|
||||
}
|
||||
|
||||
double do_text_out (const data_type & a_data)
|
||||
{
|
||||
string filename = "pba_11.txt";
|
||||
ofstream fout (filename.c_str ());
|
||||
boost::timer io_timer;
|
||||
{
|
||||
boost::archive::text_oarchive ota (fout);
|
||||
ota & a_data;
|
||||
}
|
||||
return io_timer.elapsed ();
|
||||
}
|
||||
|
||||
double do_text_in (data_type & a_data)
|
||||
{
|
||||
string filename = "pba_11.txt";
|
||||
ifstream fin (filename.c_str ());
|
||||
boost::timer io_timer;
|
||||
{
|
||||
boost::archive::text_iarchive ita (fin);
|
||||
ita & a_data;
|
||||
}
|
||||
return io_timer.elapsed ();
|
||||
}
|
||||
|
||||
int main (void)
|
||||
{
|
||||
double elapsed_time_pba_out;
|
||||
double elapsed_time_text_out;
|
||||
double elapsed_time_pba_in;
|
||||
double elapsed_time_text_in;
|
||||
data_type my_data; // A data structure to be stored then loaded.
|
||||
|
||||
{
|
||||
// Fill the vector with random values :
|
||||
size_t dim = 10000000;
|
||||
my_data.values.reserve (dim);
|
||||
boost::random::mt19937 rng;
|
||||
boost::random::uniform_real_distribution<> flat (0.0, 100.0);
|
||||
for (int i = 0; i < dim; ++i)
|
||||
{
|
||||
double val = flat (rng);
|
||||
my_data.values.push_back (val);
|
||||
}
|
||||
my_data.print (clog, "Stored data in PBA and text archive");
|
||||
}
|
||||
|
||||
{
|
||||
// Store in PBA :
|
||||
elapsed_time_pba_out = do_pba_out (my_data);
|
||||
}
|
||||
|
||||
{
|
||||
// Store in text archive :
|
||||
elapsed_time_text_out = do_text_out (my_data);
|
||||
}
|
||||
|
||||
{
|
||||
my_data.values.clear ();
|
||||
// Load from PBA :
|
||||
elapsed_time_pba_in = do_pba_in (my_data);
|
||||
my_data.print (clog, "Loaded data from PBA");
|
||||
}
|
||||
|
||||
{
|
||||
my_data.values.clear ();
|
||||
// Load from text archive :
|
||||
elapsed_time_text_in = do_text_in (my_data);
|
||||
my_data.print (clog, "Loaded data from text archive");
|
||||
}
|
||||
|
||||
clog << "PBA store I/O elapsed time : " << elapsed_time_pba_out << " (second)" << endl;
|
||||
clog << "Text store I/O elapsed time : " << elapsed_time_text_out << " (second)" << endl;
|
||||
clog << "PBA load I/O elapsed time : " << elapsed_time_pba_in << " (second)" << endl;
|
||||
clog << "Text load I/O elapsed time : " << elapsed_time_text_in << " (second)" << endl;
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
// end of tutorial_pba_11.cpp
|
||||
@@ -1,105 +0,0 @@
|
||||
/** tutorial_pba_2.cpp
|
||||
*
|
||||
* (C) Copyright 2011 François Mauger, Christian Pfligersdorffer
|
||||
*
|
||||
* 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)
|
||||
*
|
||||
*/
|
||||
|
||||
/**
|
||||
* The intent of this program is to serve as a tutorial for
|
||||
* users of the portable binary archive in the framework of
|
||||
* the Boost/Serialization library.
|
||||
*
|
||||
* This sample program shows how to use a portable binary archive
|
||||
* to store/load floating point numbers including non-finite and
|
||||
* special (denormalized) values.
|
||||
*
|
||||
*/
|
||||
|
||||
#include <string>
|
||||
#include <fstream>
|
||||
#include <limits>
|
||||
|
||||
#include <boost/archive/portable_binary_oarchive.hpp>
|
||||
#include <boost/archive/portable_binary_iarchive.hpp>
|
||||
|
||||
int main (void)
|
||||
{
|
||||
using namespace std;
|
||||
|
||||
// The name for the example data file :
|
||||
string filename = "pba_2.data";
|
||||
|
||||
{
|
||||
// A normal single precision floating point number :
|
||||
float pi = 3.14159265;
|
||||
|
||||
// Single precision zeroed floating point number :
|
||||
float zero = 0.0;
|
||||
|
||||
// A denormalized single precision floating point number :
|
||||
float tiny = 1.e-40;
|
||||
|
||||
// A single precision floating point number with `+Infinity' value :
|
||||
float plus_infinity = numeric_limits<float>::infinity ();
|
||||
|
||||
// A single precision floating point number with `-Infinity' value :
|
||||
float minus_infinity = -numeric_limits<float>::infinity ();
|
||||
|
||||
// A single precision `Not-a-Number' (NaN):
|
||||
float nan = numeric_limits<float>::quiet_NaN ();
|
||||
|
||||
// Open an output file stream in binary mode :
|
||||
ofstream fout (filename.c_str (), ios_base::binary);
|
||||
|
||||
{
|
||||
// Create an output portable binary archive attached to the output file :
|
||||
boost::archive::portable_binary_oarchive opba (fout);
|
||||
|
||||
// Store (serialize) variables :
|
||||
opba & pi & zero & tiny & plus_infinity & minus_infinity & nan;
|
||||
}
|
||||
}
|
||||
|
||||
{
|
||||
// Single precision floating point numbers to be loaded :
|
||||
float x[6];
|
||||
|
||||
// Open an input file stream in binary mode :
|
||||
ifstream fin (filename.c_str (), ios_base::binary);
|
||||
|
||||
{
|
||||
// Create an input portable binary archive attached to the input file :
|
||||
boost::archive::portable_binary_iarchive ipba (fin);
|
||||
|
||||
// Load (de-serialize) variables using the same
|
||||
// order than for serialization :
|
||||
for (int i = 0; i < 6; ++i)
|
||||
{
|
||||
ipba & x[i];
|
||||
}
|
||||
}
|
||||
|
||||
// Print :
|
||||
for (int i = 0; i < 6; ++i)
|
||||
{
|
||||
cout.precision (8);
|
||||
cout << "Loaded x[" << i << "] = " << x[i];
|
||||
switch (fp::fpclassify(x[i]))
|
||||
{
|
||||
case FP_NAN: cout << " (NaN)"; break;
|
||||
case FP_INFINITE: cout << " (infinite)"; break;
|
||||
case FP_SUBNORMAL: cout << " (denormalized)"; break;
|
||||
case FP_NORMAL: cout << " (normalized)"; break;
|
||||
}
|
||||
cout << endl;
|
||||
}
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
// end of tutorial_pba_2.cpp
|
||||
@@ -1,70 +0,0 @@
|
||||
/** tutorial_pba_3.cpp
|
||||
*
|
||||
* (C) Copyright 2011 François Mauger, Christian Pfligersdorffer
|
||||
*
|
||||
* 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)
|
||||
*
|
||||
*/
|
||||
|
||||
/**
|
||||
* The intent of this program is to serve as a tutorial for
|
||||
* users of the portable binary archive in the framework of
|
||||
* the Boost/Serialization library.
|
||||
*
|
||||
* This sample program shows how to use a portable binary archive
|
||||
* and prevent the serialization of non-finite floating numbers.
|
||||
*
|
||||
*/
|
||||
|
||||
#include <string>
|
||||
#include <fstream>
|
||||
#include <limits>
|
||||
|
||||
#include <boost/archive/portable_binary_oarchive.hpp>
|
||||
|
||||
int main (void)
|
||||
{
|
||||
using namespace std;
|
||||
|
||||
// The name for the example data file :
|
||||
string filename = "pba_3.data";
|
||||
|
||||
try
|
||||
{
|
||||
// An array of single precision floating numbers:
|
||||
float x[5];
|
||||
x[0] = 3.14159; // Pi
|
||||
x[1] = 6.022e22; // Avogadro constant
|
||||
x[2] = 1.6e-19; // Electron charge magnitude
|
||||
x[3] = 1.e-40; // A tiny (denormalized) value
|
||||
x[4] = numeric_limits<float>::infinity (); // This will fail while serializing...
|
||||
|
||||
// Open an output file stream in binary mode :
|
||||
ofstream fout (filename.c_str (), ios_base::binary);
|
||||
|
||||
{
|
||||
// Create an output portable binary archive attached to the output file,
|
||||
// using the special 'boost::archive::no_infnan' flag :
|
||||
boost::archive::portable_binary_oarchive opba (fout, boost::archive::no_infnan);
|
||||
|
||||
// Store (serialize) variables :
|
||||
for (int i = 0; i < 5; ++i)
|
||||
{
|
||||
clog << "Serializing value : " << x[i] << " ... ";
|
||||
opba & x[i];
|
||||
clog << "Ok !" << endl;
|
||||
}
|
||||
}
|
||||
}
|
||||
catch (exception & x)
|
||||
{
|
||||
cerr << "ERROR: " << x.what () << endl;
|
||||
return 1;
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
// end of tutorial_pba_3.cpp
|
||||
@@ -1,105 +0,0 @@
|
||||
/** tutorial_pba_4.cpp
|
||||
*
|
||||
* (C) Copyright 2011 François Mauger, Christian Pfligersdorffer
|
||||
*
|
||||
* 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)
|
||||
*
|
||||
*/
|
||||
|
||||
/**
|
||||
* The intent of this program is to serve as a tutorial for
|
||||
* users of the portable binary archive in the framework of
|
||||
* the Boost/Serialization library.
|
||||
*
|
||||
* This sample program shows how to use a portable binary archive
|
||||
* to store/load integer numbers of various sizes using the Boost
|
||||
* portable integer typedefs.
|
||||
*
|
||||
*/
|
||||
|
||||
#include <string>
|
||||
#include <fstream>
|
||||
|
||||
#include <boost/cstdint.hpp>
|
||||
#include <boost/archive/portable_binary_oarchive.hpp>
|
||||
#include <boost/archive/portable_binary_iarchive.hpp>
|
||||
|
||||
int main (void)
|
||||
{
|
||||
using namespace std;
|
||||
|
||||
// The name for the example data file :
|
||||
string filename = "pba_4.data";
|
||||
|
||||
{
|
||||
// Some integer numbers :
|
||||
bool t = true;
|
||||
char c = 'c';
|
||||
unsigned char u = 'u';
|
||||
int8_t b = -3; // char
|
||||
uint8_t B = +6; // unsigned char
|
||||
int16_t s = -16;
|
||||
uint16_t S = +32;
|
||||
int32_t l = -128;
|
||||
uint32_t L = +127;
|
||||
int64_t ll = -1024;
|
||||
uint64_t LL = +2048;
|
||||
|
||||
// Open an output file stream in binary mode :
|
||||
ofstream fout (filename.c_str (), ios_base::binary);
|
||||
|
||||
{
|
||||
// Create an output portable binary archive attached to the output file :
|
||||
boost::archive::portable_binary_oarchive opba (fout);
|
||||
|
||||
// Store (serialize) variables :
|
||||
opba & t & c & u & b & B & s & S & l & L & ll & LL;
|
||||
}
|
||||
}
|
||||
|
||||
{
|
||||
// Single precision floating numbers to be loaded :
|
||||
// Some integer numbers :
|
||||
bool t;
|
||||
char c;
|
||||
unsigned char u;
|
||||
int8_t b;
|
||||
uint8_t B;
|
||||
int16_t s;
|
||||
uint16_t S;
|
||||
int32_t l;
|
||||
uint32_t L;
|
||||
int64_t ll;
|
||||
uint64_t LL;
|
||||
|
||||
// Open an input file stream in binary mode :
|
||||
ifstream fin (filename.c_str (), ios_base::binary);
|
||||
|
||||
{
|
||||
// Create an input portable binary archive attached to the input file :
|
||||
boost::archive::portable_binary_iarchive ipba (fin);
|
||||
|
||||
// Load (de-serialize) variables using the same
|
||||
// order than for serialization :
|
||||
ipba & t & c & u & b & B & s & S & l & L & ll & LL;
|
||||
}
|
||||
|
||||
clog << "t = " << t << " (bool)" << endl;
|
||||
clog << "c = '" << c << "' (char)" << endl;
|
||||
clog << "u = '" << u << "' (unsigned char)" << endl;
|
||||
clog << "b = " << (int) b << " (int8_t)" << endl;
|
||||
clog << "B = " << (int) B << " (uint8_t)" << endl;
|
||||
clog << "s = " << s << " (int16_t)" << endl;
|
||||
clog << "S = " << S << " (uint16_t)" << endl;
|
||||
clog << "l = " << l << " (int32_t)" << endl;
|
||||
clog << "L = " << L << " (uint32_t)" << endl;
|
||||
clog << "ll = " << ll << " (int64_t)" << endl;
|
||||
clog << "LL = " << LL << " (uint64_t)" << endl;
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
// end of tutorial_pba_4.cpp
|
||||
@@ -1,111 +0,0 @@
|
||||
/** tutorial_pba_5.cpp
|
||||
*
|
||||
* (C) Copyright 2011 François Mauger, Christian Pfligersdorffer
|
||||
*
|
||||
* 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)
|
||||
*
|
||||
*/
|
||||
|
||||
/**
|
||||
* The intent of this program is to serve as a tutorial for
|
||||
* users of the portable binary archive in the framework of
|
||||
* the Boost/Serialization library.
|
||||
*
|
||||
* This sample program shows how to use a portable binary archive
|
||||
* to store/load data in a memory buffer.
|
||||
*
|
||||
*/
|
||||
|
||||
#include <string>
|
||||
#include <vector>
|
||||
|
||||
#include <boost/iostreams/stream.hpp>
|
||||
#include <boost/iostreams/device/back_inserter.hpp>
|
||||
#include <boost/iostreams/device/array.hpp>
|
||||
|
||||
#include <boost/cstdint.hpp>
|
||||
#include <boost/archive/portable_binary_oarchive.hpp>
|
||||
#include <boost/archive/portable_binary_iarchive.hpp>
|
||||
|
||||
int main (void)
|
||||
{
|
||||
using namespace std;
|
||||
|
||||
// The memory buffer is implemented using a STL vector :
|
||||
typedef std::vector<char> buffer_type;
|
||||
buffer_type buffer;
|
||||
|
||||
{
|
||||
// Some data to be stored :
|
||||
bool t = true;
|
||||
char c = 'c';
|
||||
int16_t s = +16;
|
||||
int32_t l = -128;
|
||||
int64_t ll = +10000000000;
|
||||
float pi = 3.14159;
|
||||
double nan = numeric_limits<double>::quiet_NaN ();
|
||||
string hello = "World !";
|
||||
|
||||
buffer.reserve (1024); // pre-allocate some memory
|
||||
|
||||
// The output stream interface to the buffer :
|
||||
boost::iostreams::stream<boost::iostreams::back_insert_device<buffer_type> > output_stream (buffer);
|
||||
|
||||
{
|
||||
// Create an output portable binary archive attached to the output file :
|
||||
boost::archive::portable_binary_oarchive opba (output_stream);
|
||||
|
||||
// Store (serialize) variables :
|
||||
opba & t & c & s & l & ll & pi & nan & hello;
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
clog << "Buffer content is " << buffer.size () << " bytes : " << endl << " ";
|
||||
for (int i = 0; i < buffer.size (); ++i)
|
||||
{
|
||||
clog << (int) ((unsigned char) buffer[i]) << ' ';
|
||||
if ((i + 1) % 20 == 0) clog << endl << " ";
|
||||
}
|
||||
clog << endl;
|
||||
|
||||
{
|
||||
// Some data to be loaded :
|
||||
bool t;
|
||||
char c;
|
||||
int16_t s;
|
||||
int32_t l;
|
||||
int64_t ll;
|
||||
float pi;
|
||||
double nan;
|
||||
string hello;
|
||||
|
||||
// The input stream interface to the buffer :
|
||||
boost::iostreams::stream<boost::iostreams::array_source> input_stream (&buffer[0],
|
||||
buffer.size ());
|
||||
|
||||
{
|
||||
// Create an input portable binary archive attached to the input file :
|
||||
boost::archive::portable_binary_iarchive ipba (input_stream);
|
||||
|
||||
// Load (de-serialize) variables :
|
||||
ipba & t & c & s & l & ll & pi & nan & hello;
|
||||
}
|
||||
|
||||
clog << "Loaded values from the buffer are: " << endl;
|
||||
clog << " t = " << t << " (bool)" << endl;
|
||||
clog << " c = '" << c << "' (char)" << endl;
|
||||
clog << " s = " << s << " (int16_t)" << endl;
|
||||
clog << " l = " << l << " (int32_t)" << endl;
|
||||
clog << " ll = " << ll << " (int64_t)" << endl;
|
||||
clog << " pi = " << pi << " (float)" << endl;
|
||||
clog << " nan = " << nan << " (double)" << endl;
|
||||
clog << " hello = \"" << hello << "\" (std::string)" << endl;
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
// end of tutorial_pba_5.cpp
|
||||
@@ -1,112 +0,0 @@
|
||||
/** tutorial_pba_6.cpp
|
||||
*
|
||||
* (C) Copyright 2011 François Mauger, Christian Pfligersdorffer
|
||||
*
|
||||
* 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)
|
||||
*
|
||||
*/
|
||||
|
||||
/**
|
||||
* The intent of this program is to serve as a tutorial for
|
||||
* users of the portable binary archive in the framework of
|
||||
* the Boost/Serialization library.
|
||||
*
|
||||
* This sample program shows how to use a portable binary archive
|
||||
* associated to a memory buffer to copy a non-copyable object.
|
||||
*
|
||||
*/
|
||||
|
||||
#include <iostream>
|
||||
#include <string>
|
||||
#include <sstream>
|
||||
#include <vector>
|
||||
|
||||
#include <boost/utility.hpp>
|
||||
#include <boost/iostreams/stream.hpp>
|
||||
#include <boost/iostreams/device/back_inserter.hpp>
|
||||
#include <boost/iostreams/device/array.hpp>
|
||||
|
||||
#include <boost/cstdint.hpp>
|
||||
#include <boost/archive/portable_binary_oarchive.hpp>
|
||||
#include <boost/archive/portable_binary_iarchive.hpp>
|
||||
|
||||
using namespace std;
|
||||
|
||||
/* A foo noncopyable class */
|
||||
struct foo : boost::noncopyable
|
||||
{
|
||||
uint32_t status;
|
||||
double value;
|
||||
double special;
|
||||
|
||||
string to_string () const
|
||||
{
|
||||
ostringstream sout;
|
||||
sout << "foo={status=" << status << "; value=" << value << "; special=" << special<< "}";
|
||||
return sout.str();
|
||||
}
|
||||
|
||||
template<class Archive>
|
||||
void serialize (Archive & ar, const unsigned int version)
|
||||
{
|
||||
ar & status;
|
||||
ar & value;
|
||||
ar & special;
|
||||
return;
|
||||
}
|
||||
|
||||
};
|
||||
|
||||
// A templatized copy function for Boost/Serialization equipped classes.
|
||||
// Here we use PBAs associated to a memory buffer :
|
||||
template <class Serializable>
|
||||
void copy (const Serializable & source, Serializable & target)
|
||||
{
|
||||
namespace io = boost::iostreams;
|
||||
namespace ba = boost::archive;
|
||||
if (&source == &target) return; // self-copy guard
|
||||
typedef std::vector<char> buffer_type;
|
||||
buffer_type buffer;
|
||||
buffer.reserve (1024);
|
||||
{
|
||||
io::stream<io::back_insert_device<buffer_type> > output_stream (buffer);
|
||||
ba::portable_binary_oarchive opba (output_stream);
|
||||
opba & source;
|
||||
}
|
||||
{
|
||||
io::stream<io::array_source> input_stream (&buffer[0], buffer.size ());
|
||||
ba::portable_binary_iarchive ipba (input_stream);
|
||||
ipba & target;
|
||||
}
|
||||
return;
|
||||
}
|
||||
|
||||
int main (void)
|
||||
{
|
||||
// Some instance of the 'foo' class :
|
||||
foo dummy;
|
||||
dummy.status = 1;
|
||||
dummy.value = 3.14159;
|
||||
dummy.special = numeric_limits<double>::quiet_NaN ();
|
||||
clog << "dummy is : " << dummy.to_string () << endl;
|
||||
|
||||
// Another instance of the 'foo' class :
|
||||
foo clone;
|
||||
|
||||
/* The following instruction is forbidden because foo
|
||||
inherits 'boost::noncopyable' :
|
||||
|
||||
clone = dummy; // this ends in a compilation error.
|
||||
|
||||
*/
|
||||
|
||||
// Anyway, we can use this workaround :
|
||||
copy (dummy, clone);
|
||||
clog << "clone is : " << clone.to_string () << endl;
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
// end of tutorial_pba_6.cpp
|
||||
@@ -1,54 +0,0 @@
|
||||
/** tutorial_pba_7.cpp
|
||||
*
|
||||
* (C) Copyright 2011 François Mauger, Christian Pfligersdorffer
|
||||
*
|
||||
* 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)
|
||||
*
|
||||
*/
|
||||
|
||||
/**
|
||||
* The intent of this program is to serve as a tutorial for
|
||||
* users of the portable binary archive in the framework of
|
||||
* the Boost/Serialization library.
|
||||
*
|
||||
* This example shows how the default behaviour of standard
|
||||
* I/O streams does not support the read/write operations of
|
||||
* non-finite floating point values in a portable way.
|
||||
*
|
||||
*/
|
||||
|
||||
#include <string>
|
||||
#include <iostream>
|
||||
#include <sstream>
|
||||
#include <limits>
|
||||
|
||||
using namespace std;
|
||||
|
||||
int main (void)
|
||||
{
|
||||
{
|
||||
float x = numeric_limits<float>::infinity ();
|
||||
double y = numeric_limits<double>::quiet_NaN ();
|
||||
cout.precision (8);
|
||||
cout << "x = " << x << endl;
|
||||
cout.precision (16);
|
||||
cout << "y = " << y << endl;
|
||||
}
|
||||
|
||||
{
|
||||
string input ("inf nan");
|
||||
istringstream iss (input);
|
||||
float x;
|
||||
double y;
|
||||
iss >> x >> y;
|
||||
if (! iss)
|
||||
{
|
||||
cerr << "Cannot read 'x' or 'y' : non finite values are not supported !" << endl;
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
// end of tutorial_pba_7.cpp
|
||||
@@ -1,118 +0,0 @@
|
||||
/** tutorial_pba_8.cpp
|
||||
*
|
||||
* (C) Copyright 2011 François Mauger, Christian Pfligersdorffer
|
||||
*
|
||||
* 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)
|
||||
*
|
||||
*/
|
||||
|
||||
/**
|
||||
* The intent of this program is to serve as a tutorial for
|
||||
* users of the portable binary archive in the framework of
|
||||
* the Boost/Serialization library.
|
||||
*
|
||||
* This example shows how to store some variables
|
||||
* of basic types (bool, integer, floating point numbers, STL string)
|
||||
* using the text or XML archive format associated to a
|
||||
* standard output file stream supporting portable non-finite
|
||||
* floating point values.
|
||||
*
|
||||
*/
|
||||
|
||||
#include <string>
|
||||
#include <fstream>
|
||||
#include <limits>
|
||||
#include <locale>
|
||||
|
||||
#include <boost/cstdint.hpp>
|
||||
#include <boost/archive/xml_oarchive.hpp>
|
||||
#include <boost/archive/text_oarchive.hpp>
|
||||
#include <boost/serialization/nvp.hpp>
|
||||
#include <boost/archive/codecvt_null.hpp>
|
||||
#include <boost/math/special_functions/nonfinite_num_facets.hpp>
|
||||
|
||||
using namespace std;
|
||||
|
||||
void do_text_out (void)
|
||||
{
|
||||
// The name for the example data text file :
|
||||
string filename = "pba_8.txt";
|
||||
|
||||
// Some variables of various primitive types :
|
||||
bool b = true;
|
||||
char c = 'B';
|
||||
uint32_t answer = 42;
|
||||
float value = numeric_limits<float>::infinity ();
|
||||
double precision = numeric_limits<double>::quiet_NaN ();
|
||||
string question = "What makes you think she's a witch?";
|
||||
|
||||
// Open an output file stream :
|
||||
ofstream fout (filename.c_str ());
|
||||
|
||||
// Prepare the output file stream for inf/NaN support :
|
||||
locale default_locale (locale::classic (),
|
||||
new boost::archive::codecvt_null<char>);
|
||||
locale infnan_locale (default_locale,
|
||||
new boost::math::nonfinite_num_put<char>);
|
||||
fout.imbue (infnan_locale);
|
||||
|
||||
{
|
||||
// Create an output text archive attached to the output file :
|
||||
boost::archive::text_oarchive ota (fout, boost::archive::no_codecvt);
|
||||
|
||||
// Store (serializing) variables :
|
||||
ota & b & c & answer & value & precision & question;
|
||||
}
|
||||
|
||||
return;
|
||||
}
|
||||
|
||||
void do_xml_out (void)
|
||||
{
|
||||
// The name for the example data XML file :
|
||||
string filename = "pba_8.xml";
|
||||
|
||||
// Some variables of various primitive types :
|
||||
bool b = true;
|
||||
char c = 'B';
|
||||
uint32_t answer = 42;
|
||||
float value = numeric_limits<float>::infinity ();
|
||||
double precision = numeric_limits<double>::quiet_NaN ();
|
||||
string question = "What makes you think she's a witch?";
|
||||
|
||||
// Open an output file stream :
|
||||
ofstream fout (filename.c_str ());
|
||||
|
||||
// Prepare the output file stream for inf/NaN support :
|
||||
locale default_locale (locale::classic (),
|
||||
new boost::archive::codecvt_null<char>);
|
||||
locale infnan_locale (default_locale,
|
||||
new boost::math::nonfinite_num_put<char>);
|
||||
fout.imbue (infnan_locale);
|
||||
|
||||
{
|
||||
// Create an output text archive attached to the output file :
|
||||
boost::archive::xml_oarchive oxa (fout, boost::archive::no_codecvt);
|
||||
|
||||
// Store (serializing) variables :
|
||||
oxa & BOOST_SERIALIZATION_NVP(b)
|
||||
& BOOST_SERIALIZATION_NVP(c)
|
||||
& BOOST_SERIALIZATION_NVP(answer)
|
||||
& BOOST_SERIALIZATION_NVP(value)
|
||||
& BOOST_SERIALIZATION_NVP(precision)
|
||||
& BOOST_SERIALIZATION_NVP(question);
|
||||
}
|
||||
|
||||
return;
|
||||
}
|
||||
|
||||
int main (void)
|
||||
{
|
||||
do_text_out ();
|
||||
do_xml_out ();
|
||||
return 0;
|
||||
}
|
||||
|
||||
// end of tutorial_pba_8.cpp
|
||||
@@ -1,134 +0,0 @@
|
||||
/** tutorial_pba_9.cpp
|
||||
*
|
||||
* (C) Copyright 2011 François Mauger, Christian Pfligersdorffer
|
||||
*
|
||||
* 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)
|
||||
*
|
||||
*/
|
||||
|
||||
/**
|
||||
* The intent of this program is to serve as a tutorial for
|
||||
* users of the portable binary archive in the framework of
|
||||
* the Boost/Serialization library.
|
||||
*
|
||||
* This example shows how to load some variables of basic
|
||||
* types (bool, char, integer, floating point numbers, STL string)
|
||||
* using the text or XML archive format associated to a
|
||||
* standard file input stream supporting portable non-finite
|
||||
* floating point values.
|
||||
*
|
||||
*/
|
||||
|
||||
#include <string>
|
||||
#include <fstream>
|
||||
#include <limits>
|
||||
#include <locale>
|
||||
|
||||
#include <boost/cstdint.hpp>
|
||||
#include <boost/archive/xml_iarchive.hpp>
|
||||
#include <boost/archive/text_iarchive.hpp>
|
||||
#include <boost/serialization/nvp.hpp>
|
||||
#include <boost/scoped_ptr.hpp>
|
||||
#include <boost/archive/codecvt_null.hpp>
|
||||
#include <boost/math/special_functions/nonfinite_num_facets.hpp>
|
||||
|
||||
using namespace std;
|
||||
|
||||
void do_text_in (void)
|
||||
{
|
||||
// The name for the example data text file :
|
||||
string filename = "pba_8.txt";
|
||||
// Some variables of various primitive types :
|
||||
bool b;
|
||||
char c;
|
||||
uint32_t answer;
|
||||
float value;
|
||||
double precision;
|
||||
string question;
|
||||
|
||||
// Open an input file stream :
|
||||
ifstream fin (filename.c_str ());
|
||||
|
||||
// Prepare the input file stream for inf/NaN support :
|
||||
locale default_locale (locale::classic (),
|
||||
new boost::archive::codecvt_null<char>);
|
||||
locale infnan_locale (default_locale,
|
||||
new boost::math::nonfinite_num_get<char>);
|
||||
fin.imbue (infnan_locale);
|
||||
|
||||
{
|
||||
// Create an input text archive attached to the input file :
|
||||
boost::archive::text_iarchive ita (fin, boost::archive::no_codecvt);
|
||||
|
||||
// Store (serializing) variables :
|
||||
ita & b & c & answer & value & precision & question;
|
||||
}
|
||||
|
||||
clog << "Loaded values from text archive are: " << endl;
|
||||
clog << " b = " << b << endl;
|
||||
clog << " c = '" << c << "'" << endl;
|
||||
clog << " answer = " << answer << endl;
|
||||
clog << " value = " << value << endl;
|
||||
clog << " precision = " << precision << endl;
|
||||
clog << " question = \"" << question << "\"" << endl;
|
||||
|
||||
return;
|
||||
}
|
||||
|
||||
void do_xml_in (void)
|
||||
{
|
||||
// The name for the example data text file :
|
||||
string filename = "pba_8.xml";
|
||||
|
||||
// Some variables of various primitive types :
|
||||
bool b;
|
||||
char c;
|
||||
uint32_t answer;
|
||||
float value;
|
||||
double precision;
|
||||
string question;
|
||||
|
||||
// Open an input file stream :
|
||||
ifstream fin (filename.c_str ());
|
||||
|
||||
// Prepare the input file stream for inf/NaN support :
|
||||
locale default_locale (locale::classic (),
|
||||
new boost::archive::codecvt_null<char>);
|
||||
locale infnan_locale (default_locale,
|
||||
new boost::math::nonfinite_num_get<char>);
|
||||
fin.imbue (infnan_locale);
|
||||
|
||||
{
|
||||
// Create an output text archive attached to the output file :
|
||||
boost::archive::xml_iarchive ixa (fin, boost::archive::no_codecvt);
|
||||
|
||||
// Store (serializing) variables :
|
||||
ixa & BOOST_SERIALIZATION_NVP(b)
|
||||
& BOOST_SERIALIZATION_NVP(c)
|
||||
& BOOST_SERIALIZATION_NVP(answer)
|
||||
& BOOST_SERIALIZATION_NVP(value)
|
||||
& BOOST_SERIALIZATION_NVP(precision)
|
||||
& BOOST_SERIALIZATION_NVP(question);
|
||||
}
|
||||
|
||||
clog << "Loaded values from XML archive are: " << endl;
|
||||
clog << " b = " << b << endl;
|
||||
clog << " c = '" << c << "'" << endl;
|
||||
clog << " answer = " << answer << endl;
|
||||
clog << " value = " << value << endl;
|
||||
clog << " precision = " << precision << endl;
|
||||
clog << " question = \"" << question << "\"" << endl;
|
||||
|
||||
return;
|
||||
}
|
||||
|
||||
int main (void)
|
||||
{
|
||||
do_text_in ();
|
||||
do_xml_in ();
|
||||
return 0;
|
||||
}
|
||||
|
||||
// end of tutorial_pba_9.cpp
|
||||
Binary file not shown.
|
Before Width: | Height: | Size: 6.2 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 1.3 KiB |
@@ -1,36 +0,0 @@
|
||||
IMPORTANT:
|
||||
|
||||
This is the last release from me as EOS employee. I plan to contribute all of this
|
||||
work to the official boost libraries distribution and will continue to support users.
|
||||
Francois Mauger joined me recently and already added a valuable tutorial for you!
|
||||
|
||||
|
||||
Dear user,
|
||||
|
||||
I am proud to announce the very first release of our portable_binary_[io]archive
|
||||
which we use here at EOS to move data between different platforms. It really is
|
||||
a conglomerate of pieces that already were there - as is most often the case in
|
||||
OO world - we simply put them together in a way that seemed to make sense. I know
|
||||
a lot of people were interested in portable binary archives, so here you are -
|
||||
give it a try and let me know what you think about it!
|
||||
|
||||
We rely heavily on boost::serialization and really appreciate the amount of time
|
||||
and knowledge that went into it. By publishing this small missing piece we hope
|
||||
to contribute our mite to this great library.
|
||||
|
||||
The work extends the portable binary example which was done by Robert Ramey and
|
||||
uses Beman Dawes' endian library plus the fp_utilities by Johan Rade. You will
|
||||
need to get those two libraries in order to use our classes - look for them at
|
||||
the boost vault (http://www.boost-consulting.com/vault/) in categories 'integer'
|
||||
and 'math - numerics'. Finally you will find the portable binary archive in
|
||||
category 'serialization' as well.
|
||||
|
||||
Regards,
|
||||
Christian Pfligersdorffer
|
||||
|
||||
Munich, End of 2007
|
||||
|
||||
--
|
||||
christian.pfligersdorffer@eos.info
|
||||
christian.pfligersdorffer@gmx.at
|
||||
http://www.eos.info
|
||||
-151
@@ -1,151 +0,0 @@
|
||||
/*!
|
||||
* jQuery JavaScript Library v1.4
|
||||
* http://jquery.com/
|
||||
*
|
||||
* Copyright 2010, John Resig
|
||||
* Dual licensed under the MIT or GPL Version 2 licenses.
|
||||
* http://docs.jquery.com/License
|
||||
*
|
||||
* Includes Sizzle.js
|
||||
* http://sizzlejs.com/
|
||||
* Copyright 2010, The Dojo Foundation
|
||||
* Released under the MIT, BSD, and GPL Licenses.
|
||||
*
|
||||
* Date: Wed Jan 13 15:23:05 2010 -0500
|
||||
*/
|
||||
(function(A,w){function oa(){if(!c.isReady){try{s.documentElement.doScroll("left")}catch(a){setTimeout(oa,1);return}c.ready()}}function La(a,b){b.src?c.ajax({url:b.src,async:false,dataType:"script"}):c.globalEval(b.text||b.textContent||b.innerHTML||"");b.parentNode&&b.parentNode.removeChild(b)}function $(a,b,d,f,e,i){var j=a.length;if(typeof b==="object"){for(var o in b)$(a,o,b[o],f,e,d);return a}if(d!==w){f=!i&&f&&c.isFunction(d);for(o=0;o<j;o++)e(a[o],b,f?d.call(a[o],o,e(a[o],b)):d,i);return a}return j?
|
||||
e(a[0],b):null}function K(){return(new Date).getTime()}function aa(){return false}function ba(){return true}function pa(a,b,d){d[0].type=a;return c.event.handle.apply(b,d)}function qa(a){var b=true,d=[],f=[],e=arguments,i,j,o,p,n,t=c.extend({},c.data(this,"events").live);for(p in t){j=t[p];if(j.live===a.type||j.altLive&&c.inArray(a.type,j.altLive)>-1){i=j.data;i.beforeFilter&&i.beforeFilter[a.type]&&!i.beforeFilter[a.type](a)||f.push(j.selector)}else delete t[p]}i=c(a.target).closest(f,a.currentTarget);
|
||||
n=0;for(l=i.length;n<l;n++)for(p in t){j=t[p];o=i[n].elem;f=null;if(i[n].selector===j.selector){if(j.live==="mouseenter"||j.live==="mouseleave")f=c(a.relatedTarget).closest(j.selector)[0];if(!f||f!==o)d.push({elem:o,fn:j})}}n=0;for(l=d.length;n<l;n++){i=d[n];a.currentTarget=i.elem;a.data=i.fn.data;if(i.fn.apply(i.elem,e)===false){b=false;break}}return b}function ra(a,b){return["live",a,b.replace(/\./g,"`").replace(/ /g,"&")].join(".")}function sa(a){return!a||!a.parentNode||a.parentNode.nodeType===
|
||||
11}function ta(a,b){var d=0;b.each(function(){if(this.nodeName===(a[d]&&a[d].nodeName)){var f=c.data(a[d++]),e=c.data(this,f);if(f=f&&f.events){delete e.handle;e.events={};for(var i in f)for(var j in f[i])c.event.add(this,i,f[i][j],f[i][j].data)}}})}function ua(a,b,d){var f,e,i;if(a.length===1&&typeof a[0]==="string"&&a[0].length<512&&a[0].indexOf("<option")<0){e=true;if(i=c.fragments[a[0]])if(i!==1)f=i}if(!f){b=b&&b[0]?b[0].ownerDocument||b[0]:s;f=b.createDocumentFragment();c.clean(a,b,f,d)}if(e)c.fragments[a[0]]=
|
||||
i?f:1;return{fragment:f,cacheable:e}}function T(a){for(var b=0,d,f;(d=a[b])!=null;b++)if(!c.noData[d.nodeName.toLowerCase()]&&(f=d[H]))delete c.cache[f]}function L(a,b){var d={};c.each(va.concat.apply([],va.slice(0,b)),function(){d[this]=a});return d}function wa(a){return"scrollTo"in a&&a.document?a:a.nodeType===9?a.defaultView||a.parentWindow:false}var c=function(a,b){return new c.fn.init(a,b)},Ma=A.jQuery,Na=A.$,s=A.document,U,Oa=/^[^<]*(<[\w\W]+>)[^>]*$|^#([\w-]+)$/,Pa=/^.[^:#\[\.,]*$/,Qa=/\S/,
|
||||
Ra=/^(\s|\u00A0)+|(\s|\u00A0)+$/g,Sa=/^<(\w+)\s*\/?>(?:<\/\1>)?$/,P=navigator.userAgent,xa=false,Q=[],M,ca=Object.prototype.toString,da=Object.prototype.hasOwnProperty,ea=Array.prototype.push,R=Array.prototype.slice,V=Array.prototype.indexOf;c.fn=c.prototype={init:function(a,b){var d,f;if(!a)return this;if(a.nodeType){this.context=this[0]=a;this.length=1;return this}if(typeof a==="string")if((d=Oa.exec(a))&&(d[1]||!b))if(d[1]){f=b?b.ownerDocument||b:s;if(a=Sa.exec(a))if(c.isPlainObject(b)){a=[s.createElement(a[1])];
|
||||
c.fn.attr.call(a,b,true)}else a=[f.createElement(a[1])];else{a=ua([d[1]],[f]);a=(a.cacheable?a.fragment.cloneNode(true):a.fragment).childNodes}}else{if(b=s.getElementById(d[2])){if(b.id!==d[2])return U.find(a);this.length=1;this[0]=b}this.context=s;this.selector=a;return this}else if(!b&&/^\w+$/.test(a)){this.selector=a;this.context=s;a=s.getElementsByTagName(a)}else return!b||b.jquery?(b||U).find(a):c(b).find(a);else if(c.isFunction(a))return U.ready(a);if(a.selector!==w){this.selector=a.selector;
|
||||
this.context=a.context}return c.isArray(a)?this.setArray(a):c.makeArray(a,this)},selector:"",jquery:"1.4",length:0,size:function(){return this.length},toArray:function(){return R.call(this,0)},get:function(a){return a==null?this.toArray():a<0?this.slice(a)[0]:this[a]},pushStack:function(a,b,d){a=c(a||null);a.prevObject=this;a.context=this.context;if(b==="find")a.selector=this.selector+(this.selector?" ":"")+d;else if(b)a.selector=this.selector+"."+b+"("+d+")";return a},setArray:function(a){this.length=
|
||||
0;ea.apply(this,a);return this},each:function(a,b){return c.each(this,a,b)},ready:function(a){c.bindReady();if(c.isReady)a.call(s,c);else Q&&Q.push(a);return this},eq:function(a){return a===-1?this.slice(a):this.slice(a,+a+1)},first:function(){return this.eq(0)},last:function(){return this.eq(-1)},slice:function(){return this.pushStack(R.apply(this,arguments),"slice",R.call(arguments).join(","))},map:function(a){return this.pushStack(c.map(this,function(b,d){return a.call(b,d,b)}))},end:function(){return this.prevObject||
|
||||
c(null)},push:ea,sort:[].sort,splice:[].splice};c.fn.init.prototype=c.fn;c.extend=c.fn.extend=function(){var a=arguments[0]||{},b=1,d=arguments.length,f=false,e,i,j,o;if(typeof a==="boolean"){f=a;a=arguments[1]||{};b=2}if(typeof a!=="object"&&!c.isFunction(a))a={};if(d===b){a=this;--b}for(;b<d;b++)if((e=arguments[b])!=null)for(i in e){j=a[i];o=e[i];if(a!==o)if(f&&o&&(c.isPlainObject(o)||c.isArray(o))){j=j&&(c.isPlainObject(j)||c.isArray(j))?j:c.isArray(o)?[]:{};a[i]=c.extend(f,j,o)}else if(o!==w)a[i]=
|
||||
o}return a};c.extend({noConflict:function(a){A.$=Na;if(a)A.jQuery=Ma;return c},isReady:false,ready:function(){if(!c.isReady){if(!s.body)return setTimeout(c.ready,13);c.isReady=true;if(Q){for(var a,b=0;a=Q[b++];)a.call(s,c);Q=null}c.fn.triggerHandler&&c(s).triggerHandler("ready")}},bindReady:function(){if(!xa){xa=true;if(s.readyState==="complete")return c.ready();if(s.addEventListener){s.addEventListener("DOMContentLoaded",M,false);A.addEventListener("load",c.ready,false)}else if(s.attachEvent){s.attachEvent("onreadystatechange",
|
||||
M);A.attachEvent("onload",c.ready);var a=false;try{a=A.frameElement==null}catch(b){}s.documentElement.doScroll&&a&&oa()}}},isFunction:function(a){return ca.call(a)==="[object Function]"},isArray:function(a){return ca.call(a)==="[object Array]"},isPlainObject:function(a){if(!a||ca.call(a)!=="[object Object]"||a.nodeType||a.setInterval)return false;if(a.constructor&&!da.call(a,"constructor")&&!da.call(a.constructor.prototype,"isPrototypeOf"))return false;var b;for(b in a);return b===w||da.call(a,b)},
|
||||
isEmptyObject:function(a){for(var b in a)return false;return true},noop:function(){},globalEval:function(a){if(a&&Qa.test(a)){var b=s.getElementsByTagName("head")[0]||s.documentElement,d=s.createElement("script");d.type="text/javascript";if(c.support.scriptEval)d.appendChild(s.createTextNode(a));else d.text=a;b.insertBefore(d,b.firstChild);b.removeChild(d)}},nodeName:function(a,b){return a.nodeName&&a.nodeName.toUpperCase()===b.toUpperCase()},each:function(a,b,d){var f,e=0,i=a.length,j=i===w||c.isFunction(a);
|
||||
if(d)if(j)for(f in a){if(b.apply(a[f],d)===false)break}else for(;e<i;){if(b.apply(a[e++],d)===false)break}else if(j)for(f in a){if(b.call(a[f],f,a[f])===false)break}else for(d=a[0];e<i&&b.call(d,e,d)!==false;d=a[++e]);return a},trim:function(a){return(a||"").replace(Ra,"")},makeArray:function(a,b){b=b||[];if(a!=null)a.length==null||typeof a==="string"||c.isFunction(a)||typeof a!=="function"&&a.setInterval?ea.call(b,a):c.merge(b,a);return b},inArray:function(a,b){if(b.indexOf)return b.indexOf(a);for(var d=
|
||||
0,f=b.length;d<f;d++)if(b[d]===a)return d;return-1},merge:function(a,b){var d=a.length,f=0;if(typeof b.length==="number")for(var e=b.length;f<e;f++)a[d++]=b[f];else for(;b[f]!==w;)a[d++]=b[f++];a.length=d;return a},grep:function(a,b,d){for(var f=[],e=0,i=a.length;e<i;e++)!d!==!b(a[e],e)&&f.push(a[e]);return f},map:function(a,b,d){for(var f=[],e,i=0,j=a.length;i<j;i++){e=b(a[i],i,d);if(e!=null)f[f.length]=e}return f.concat.apply([],f)},guid:1,proxy:function(a,b,d){if(arguments.length===2)if(typeof b===
|
||||
"string"){d=a;a=d[b];b=w}else if(b&&!c.isFunction(b)){d=b;b=w}if(!b&&a)b=function(){return a.apply(d||this,arguments)};if(a)b.guid=a.guid=a.guid||b.guid||c.guid++;return b},uaMatch:function(a){var b={browser:""};a=a.toLowerCase();if(/webkit/.test(a))b={browser:"webkit",version:/webkit[\/ ]([\w.]+)/};else if(/opera/.test(a))b={browser:"opera",version:/version/.test(a)?/version[\/ ]([\w.]+)/:/opera[\/ ]([\w.]+)/};else if(/msie/.test(a))b={browser:"msie",version:/msie ([\w.]+)/};else if(/mozilla/.test(a)&&
|
||||
!/compatible/.test(a))b={browser:"mozilla",version:/rv:([\w.]+)/};b.version=(b.version&&b.version.exec(a)||[0,"0"])[1];return b},browser:{}});P=c.uaMatch(P);if(P.browser){c.browser[P.browser]=true;c.browser.version=P.version}if(c.browser.webkit)c.browser.safari=true;if(V)c.inArray=function(a,b){return V.call(b,a)};U=c(s);if(s.addEventListener)M=function(){s.removeEventListener("DOMContentLoaded",M,false);c.ready()};else if(s.attachEvent)M=function(){if(s.readyState==="complete"){s.detachEvent("onreadystatechange",
|
||||
M);c.ready()}};if(V)c.inArray=function(a,b){return V.call(b,a)};(function(){c.support={};var a=s.documentElement,b=s.createElement("script"),d=s.createElement("div"),f="script"+K();d.style.display="none";d.innerHTML=" <link/><table></table><a href='/a' style='color:red;float:left;opacity:.55;'>a</a><input type='checkbox'/>";var e=d.getElementsByTagName("*"),i=d.getElementsByTagName("a")[0];if(!(!e||!e.length||!i)){c.support={leadingWhitespace:d.firstChild.nodeType===3,tbody:!d.getElementsByTagName("tbody").length,
|
||||
htmlSerialize:!!d.getElementsByTagName("link").length,style:/red/.test(i.getAttribute("style")),hrefNormalized:i.getAttribute("href")==="/a",opacity:/^0.55$/.test(i.style.opacity),cssFloat:!!i.style.cssFloat,checkOn:d.getElementsByTagName("input")[0].value==="on",optSelected:s.createElement("select").appendChild(s.createElement("option")).selected,scriptEval:false,noCloneEvent:true,boxModel:null};b.type="text/javascript";try{b.appendChild(s.createTextNode("window."+f+"=1;"))}catch(j){}a.insertBefore(b,
|
||||
a.firstChild);if(A[f]){c.support.scriptEval=true;delete A[f]}a.removeChild(b);if(d.attachEvent&&d.fireEvent){d.attachEvent("onclick",function o(){c.support.noCloneEvent=false;d.detachEvent("onclick",o)});d.cloneNode(true).fireEvent("onclick")}c(function(){var o=s.createElement("div");o.style.width=o.style.paddingLeft="1px";s.body.appendChild(o);c.boxModel=c.support.boxModel=o.offsetWidth===2;s.body.removeChild(o).style.display="none"});a=function(o){var p=s.createElement("div");o="on"+o;var n=o in
|
||||
p;if(!n){p.setAttribute(o,"return;");n=typeof p[o]==="function"}return n};c.support.submitBubbles=a("submit");c.support.changeBubbles=a("change");a=b=d=e=i=null}})();c.props={"for":"htmlFor","class":"className",readonly:"readOnly",maxlength:"maxLength",cellspacing:"cellSpacing",rowspan:"rowSpan",colspan:"colSpan",tabindex:"tabIndex",usemap:"useMap",frameborder:"frameBorder"};var H="jQuery"+K(),Ta=0,ya={},Ua={};c.extend({cache:{},expando:H,noData:{embed:true,object:true,applet:true},data:function(a,
|
||||
b,d){if(!(a.nodeName&&c.noData[a.nodeName.toLowerCase()])){a=a==A?ya:a;var f=a[H],e=c.cache;if(!b&&!f)return null;f||(f=++Ta);if(typeof b==="object"){a[H]=f;e=e[f]=c.extend(true,{},b)}else e=e[f]?e[f]:typeof d==="undefined"?Ua:(e[f]={});if(d!==w){a[H]=f;e[b]=d}return typeof b==="string"?e[b]:e}},removeData:function(a,b){if(!(a.nodeName&&c.noData[a.nodeName.toLowerCase()])){a=a==A?ya:a;var d=a[H],f=c.cache,e=f[d];if(b){if(e){delete e[b];c.isEmptyObject(e)&&c.removeData(a)}}else{try{delete a[H]}catch(i){a.removeAttribute&&
|
||||
a.removeAttribute(H)}delete f[d]}}}});c.fn.extend({data:function(a,b){if(typeof a==="undefined"&&this.length)return c.data(this[0]);else if(typeof a==="object")return this.each(function(){c.data(this,a)});var d=a.split(".");d[1]=d[1]?"."+d[1]:"";if(b===w){var f=this.triggerHandler("getData"+d[1]+"!",[d[0]]);if(f===w&&this.length)f=c.data(this[0],a);return f===w&&d[1]?this.data(d[0]):f}else return this.trigger("setData"+d[1]+"!",[d[0],b]).each(function(){c.data(this,a,b)})},removeData:function(a){return this.each(function(){c.removeData(this,
|
||||
a)})}});c.extend({queue:function(a,b,d){if(a){b=(b||"fx")+"queue";var f=c.data(a,b);if(!d)return f||[];if(!f||c.isArray(d))f=c.data(a,b,c.makeArray(d));else f.push(d);return f}},dequeue:function(a,b){b=b||"fx";var d=c.queue(a,b),f=d.shift();if(f==="inprogress")f=d.shift();if(f){b==="fx"&&d.unshift("inprogress");f.call(a,function(){c.dequeue(a,b)})}}});c.fn.extend({queue:function(a,b){if(typeof a!=="string"){b=a;a="fx"}if(b===w)return c.queue(this[0],a);return this.each(function(){var d=c.queue(this,
|
||||
a,b);a==="fx"&&d[0]!=="inprogress"&&c.dequeue(this,a)})},dequeue:function(a){return this.each(function(){c.dequeue(this,a)})},delay:function(a,b){a=c.fx?c.fx.speeds[a]||a:a;b=b||"fx";return this.queue(b,function(){var d=this;setTimeout(function(){c.dequeue(d,b)},a)})},clearQueue:function(a){return this.queue(a||"fx",[])}});var za=/[\n\t]/g,fa=/\s+/,Va=/\r/g,Wa=/href|src|style/,Xa=/(button|input)/i,Ya=/(button|input|object|select|textarea)/i,Za=/^(a|area)$/i,Aa=/radio|checkbox/;c.fn.extend({attr:function(a,
|
||||
b){return $(this,a,b,true,c.attr)},removeAttr:function(a){return this.each(function(){c.attr(this,a,"");this.nodeType===1&&this.removeAttribute(a)})},addClass:function(a){if(c.isFunction(a))return this.each(function(p){var n=c(this);n.addClass(a.call(this,p,n.attr("class")))});if(a&&typeof a==="string")for(var b=(a||"").split(fa),d=0,f=this.length;d<f;d++){var e=this[d];if(e.nodeType===1)if(e.className)for(var i=" "+e.className+" ",j=0,o=b.length;j<o;j++){if(i.indexOf(" "+b[j]+" ")<0)e.className+=
|
||||
" "+b[j]}else e.className=a}return this},removeClass:function(a){if(c.isFunction(a))return this.each(function(p){var n=c(this);n.removeClass(a.call(this,p,n.attr("class")))});if(a&&typeof a==="string"||a===w)for(var b=(a||"").split(fa),d=0,f=this.length;d<f;d++){var e=this[d];if(e.nodeType===1&&e.className)if(a){for(var i=(" "+e.className+" ").replace(za," "),j=0,o=b.length;j<o;j++)i=i.replace(" "+b[j]+" "," ");e.className=i.substring(1,i.length-1)}else e.className=""}return this},toggleClass:function(a,
|
||||
b){var d=typeof a,f=typeof b==="boolean";if(c.isFunction(a))return this.each(function(e){var i=c(this);i.toggleClass(a.call(this,e,i.attr("class"),b),b)});return this.each(function(){if(d==="string")for(var e,i=0,j=c(this),o=b,p=a.split(fa);e=p[i++];){o=f?o:!j.hasClass(e);j[o?"addClass":"removeClass"](e)}else if(d==="undefined"||d==="boolean"){this.className&&c.data(this,"__className__",this.className);this.className=this.className||a===false?"":c.data(this,"__className__")||""}})},hasClass:function(a){a=
|
||||
" "+a+" ";for(var b=0,d=this.length;b<d;b++)if((" "+this[b].className+" ").replace(za," ").indexOf(a)>-1)return true;return false},val:function(a){if(a===w){var b=this[0];if(b){if(c.nodeName(b,"option"))return(b.attributes.value||{}).specified?b.value:b.text;if(c.nodeName(b,"select")){var d=b.selectedIndex,f=[],e=b.options;b=b.type==="select-one";if(d<0)return null;var i=b?d:0;for(d=b?d+1:e.length;i<d;i++){var j=e[i];if(j.selected){a=c(j).val();if(b)return a;f.push(a)}}return f}if(Aa.test(b.type)&&
|
||||
!c.support.checkOn)return b.getAttribute("value")===null?"on":b.value;return(b.value||"").replace(Va,"")}return w}var o=c.isFunction(a);return this.each(function(p){var n=c(this),t=a;if(this.nodeType===1){if(o)t=a.call(this,p,n.val());if(typeof t==="number")t+="";if(c.isArray(t)&&Aa.test(this.type))this.checked=c.inArray(n.val(),t)>=0;else if(c.nodeName(this,"select")){var z=c.makeArray(t);c("option",this).each(function(){this.selected=c.inArray(c(this).val(),z)>=0});if(!z.length)this.selectedIndex=
|
||||
-1}else this.value=t}})}});c.extend({attrFn:{val:true,css:true,html:true,text:true,data:true,width:true,height:true,offset:true},attr:function(a,b,d,f){if(!a||a.nodeType===3||a.nodeType===8)return w;if(f&&b in c.attrFn)return c(a)[b](d);f=a.nodeType!==1||!c.isXMLDoc(a);var e=d!==w;b=f&&c.props[b]||b;if(a.nodeType===1){var i=Wa.test(b);if(b in a&&f&&!i){if(e){if(b==="type"&&Xa.test(a.nodeName)&&a.parentNode)throw"type property can't be changed";a[b]=d}if(c.nodeName(a,"form")&&a.getAttributeNode(b))return a.getAttributeNode(b).nodeValue;
|
||||
if(b==="tabIndex")return(b=a.getAttributeNode("tabIndex"))&&b.specified?b.value:Ya.test(a.nodeName)||Za.test(a.nodeName)&&a.href?0:w;return a[b]}if(!c.support.style&&f&&b==="style"){if(e)a.style.cssText=""+d;return a.style.cssText}e&&a.setAttribute(b,""+d);a=!c.support.hrefNormalized&&f&&i?a.getAttribute(b,2):a.getAttribute(b);return a===null?w:a}return c.style(a,b,d)}});var $a=function(a){return a.replace(/[^\w\s\.\|`]/g,function(b){return"\\"+b})};c.event={add:function(a,b,d,f){if(!(a.nodeType===
|
||||
3||a.nodeType===8)){if(a.setInterval&&a!==A&&!a.frameElement)a=A;if(!d.guid)d.guid=c.guid++;if(f!==w){d=c.proxy(d);d.data=f}var e=c.data(a,"events")||c.data(a,"events",{}),i=c.data(a,"handle"),j;if(!i){j=function(){return typeof c!=="undefined"&&!c.event.triggered?c.event.handle.apply(j.elem,arguments):w};i=c.data(a,"handle",j)}if(i){i.elem=a;b=b.split(/\s+/);for(var o,p=0;o=b[p++];){var n=o.split(".");o=n.shift();d.type=n.slice(0).sort().join(".");var t=e[o],z=this.special[o]||{};if(!t){t=e[o]={};
|
||||
if(!z.setup||z.setup.call(a,f,n,d)===false)if(a.addEventListener)a.addEventListener(o,i,false);else a.attachEvent&&a.attachEvent("on"+o,i)}if(z.add)if((n=z.add.call(a,d,f,n,t))&&c.isFunction(n)){n.guid=n.guid||d.guid;d=n}t[d.guid]=d;this.global[o]=true}a=null}}},global:{},remove:function(a,b,d){if(!(a.nodeType===3||a.nodeType===8)){var f=c.data(a,"events"),e,i,j;if(f){if(b===w||typeof b==="string"&&b.charAt(0)===".")for(i in f)this.remove(a,i+(b||""));else{if(b.type){d=b.handler;b=b.type}b=b.split(/\s+/);
|
||||
for(var o=0;i=b[o++];){var p=i.split(".");i=p.shift();var n=!p.length,t=c.map(p.slice(0).sort(),$a);t=new RegExp("(^|\\.)"+t.join("\\.(?:.*\\.)?")+"(\\.|$)");var z=this.special[i]||{};if(f[i]){if(d){j=f[i][d.guid];delete f[i][d.guid]}else for(var B in f[i])if(n||t.test(f[i][B].type))delete f[i][B];z.remove&&z.remove.call(a,p,j);for(e in f[i])break;if(!e){if(!z.teardown||z.teardown.call(a,p)===false)if(a.removeEventListener)a.removeEventListener(i,c.data(a,"handle"),false);else a.detachEvent&&a.detachEvent("on"+
|
||||
i,c.data(a,"handle"));e=null;delete f[i]}}}}for(e in f)break;if(!e){if(B=c.data(a,"handle"))B.elem=null;c.removeData(a,"events");c.removeData(a,"handle")}}}},trigger:function(a,b,d,f){var e=a.type||a;if(!f){a=typeof a==="object"?a[H]?a:c.extend(c.Event(e),a):c.Event(e);if(e.indexOf("!")>=0){a.type=e=e.slice(0,-1);a.exclusive=true}if(!d){a.stopPropagation();this.global[e]&&c.each(c.cache,function(){this.events&&this.events[e]&&c.event.trigger(a,b,this.handle.elem)})}if(!d||d.nodeType===3||d.nodeType===
|
||||
8)return w;a.result=w;a.target=d;b=c.makeArray(b);b.unshift(a)}a.currentTarget=d;var i=c.data(d,"handle");i&&i.apply(d,b);var j,o;try{if(!(d&&d.nodeName&&c.noData[d.nodeName.toLowerCase()])){j=d[e];o=d["on"+e]}}catch(p){}i=c.nodeName(d,"a")&&e==="click";if(!f&&j&&!a.isDefaultPrevented()&&!i){this.triggered=true;try{d[e]()}catch(n){}}else if(o&&d["on"+e].apply(d,b)===false)a.result=false;this.triggered=false;if(!a.isPropagationStopped())(d=d.parentNode||d.ownerDocument)&&c.event.trigger(a,b,d,true)},
|
||||
handle:function(a){var b,d;a=arguments[0]=c.event.fix(a||A.event);a.currentTarget=this;d=a.type.split(".");a.type=d.shift();b=!d.length&&!a.exclusive;var f=new RegExp("(^|\\.)"+d.slice(0).sort().join("\\.(?:.*\\.)?")+"(\\.|$)");d=(c.data(this,"events")||{})[a.type];for(var e in d){var i=d[e];if(b||f.test(i.type)){a.handler=i;a.data=i.data;i=i.apply(this,arguments);if(i!==w){a.result=i;if(i===false){a.preventDefault();a.stopPropagation()}}if(a.isImmediatePropagationStopped())break}}return a.result},
|
||||
props:"altKey attrChange attrName bubbles button cancelable charCode clientX clientY ctrlKey currentTarget data detail eventPhase fromElement handler keyCode layerX layerY metaKey newValue offsetX offsetY originalTarget pageX pageY prevValue relatedNode relatedTarget screenX screenY shiftKey srcElement target toElement view wheelDelta which".split(" "),fix:function(a){if(a[H])return a;var b=a;a=c.Event(b);for(var d=this.props.length,f;d;){f=this.props[--d];a[f]=b[f]}if(!a.target)a.target=a.srcElement||
|
||||
s;if(a.target.nodeType===3)a.target=a.target.parentNode;if(!a.relatedTarget&&a.fromElement)a.relatedTarget=a.fromElement===a.target?a.toElement:a.fromElement;if(a.pageX==null&&a.clientX!=null){b=s.documentElement;d=s.body;a.pageX=a.clientX+(b&&b.scrollLeft||d&&d.scrollLeft||0)-(b&&b.clientLeft||d&&d.clientLeft||0);a.pageY=a.clientY+(b&&b.scrollTop||d&&d.scrollTop||0)-(b&&b.clientTop||d&&d.clientTop||0)}if(!a.which&&(a.charCode||a.charCode===0?a.charCode:a.keyCode))a.which=a.charCode||a.keyCode;if(!a.metaKey&&
|
||||
a.ctrlKey)a.metaKey=a.ctrlKey;if(!a.which&&a.button!==w)a.which=a.button&1?1:a.button&2?3:a.button&4?2:0;return a},guid:1E8,proxy:c.proxy,special:{ready:{setup:c.bindReady,teardown:c.noop},live:{add:function(a,b){c.extend(a,b||{});a.guid+=b.selector+b.live;c.event.add(this,b.live,qa,b)},remove:function(a){if(a.length){var b=0,d=new RegExp("(^|\\.)"+a[0]+"(\\.|$)");c.each(c.data(this,"events").live||{},function(){d.test(this.type)&&b++});b<1&&c.event.remove(this,a[0],qa)}},special:{}},beforeunload:{setup:function(a,
|
||||
b,d){if(this.setInterval)this.onbeforeunload=d;return false},teardown:function(a,b){if(this.onbeforeunload===b)this.onbeforeunload=null}}}};c.Event=function(a){if(!this.preventDefault)return new c.Event(a);if(a&&a.type){this.originalEvent=a;this.type=a.type}else this.type=a;this.timeStamp=K();this[H]=true};c.Event.prototype={preventDefault:function(){this.isDefaultPrevented=ba;var a=this.originalEvent;if(a){a.preventDefault&&a.preventDefault();a.returnValue=false}},stopPropagation:function(){this.isPropagationStopped=
|
||||
ba;var a=this.originalEvent;if(a){a.stopPropagation&&a.stopPropagation();a.cancelBubble=true}},stopImmediatePropagation:function(){this.isImmediatePropagationStopped=ba;this.stopPropagation()},isDefaultPrevented:aa,isPropagationStopped:aa,isImmediatePropagationStopped:aa};var Ba=function(a){for(var b=a.relatedTarget;b&&b!==this;)try{b=b.parentNode}catch(d){break}if(b!==this){a.type=a.data;c.event.handle.apply(this,arguments)}},Ca=function(a){a.type=a.data;c.event.handle.apply(this,arguments)};c.each({mouseenter:"mouseover",
|
||||
mouseleave:"mouseout"},function(a,b){c.event.special[a]={setup:function(d){c.event.add(this,b,d&&d.selector?Ca:Ba,a)},teardown:function(d){c.event.remove(this,b,d&&d.selector?Ca:Ba)}}});if(!c.support.submitBubbles)c.event.special.submit={setup:function(a,b,d){if(this.nodeName.toLowerCase()!=="form"){c.event.add(this,"click.specialSubmit."+d.guid,function(f){var e=f.target,i=e.type;if((i==="submit"||i==="image")&&c(e).closest("form").length)return pa("submit",this,arguments)});c.event.add(this,"keypress.specialSubmit."+
|
||||
d.guid,function(f){var e=f.target,i=e.type;if((i==="text"||i==="password")&&c(e).closest("form").length&&f.keyCode===13)return pa("submit",this,arguments)})}else return false},remove:function(a,b){c.event.remove(this,"click.specialSubmit"+(b?"."+b.guid:""));c.event.remove(this,"keypress.specialSubmit"+(b?"."+b.guid:""))}};if(!c.support.changeBubbles){var ga=/textarea|input|select/i;function Da(a){var b=a.type,d=a.value;if(b==="radio"||b==="checkbox")d=a.checked;else if(b==="select-multiple")d=a.selectedIndex>
|
||||
-1?c.map(a.options,function(f){return f.selected}).join("-"):"";else if(a.nodeName.toLowerCase()==="select")d=a.selectedIndex;return d}function ha(a,b){var d=a.target,f,e;if(!(!ga.test(d.nodeName)||d.readOnly)){f=c.data(d,"_change_data");e=Da(d);if(e!==f){if(a.type!=="focusout"||d.type!=="radio")c.data(d,"_change_data",e);if(d.type!=="select"&&(f!=null||e)){a.type="change";return c.event.trigger(a,b,this)}}}}c.event.special.change={filters:{focusout:ha,click:function(a){var b=a.target,d=b.type;if(d===
|
||||
"radio"||d==="checkbox"||b.nodeName.toLowerCase()==="select")return ha.call(this,a)},keydown:function(a){var b=a.target,d=b.type;if(a.keyCode===13&&b.nodeName.toLowerCase()!=="textarea"||a.keyCode===32&&(d==="checkbox"||d==="radio")||d==="select-multiple")return ha.call(this,a)},beforeactivate:function(a){a=a.target;a.nodeName.toLowerCase()==="input"&&a.type==="radio"&&c.data(a,"_change_data",Da(a))}},setup:function(a,b,d){for(var f in W)c.event.add(this,f+".specialChange."+d.guid,W[f]);return ga.test(this.nodeName)},
|
||||
remove:function(a,b){for(var d in W)c.event.remove(this,d+".specialChange"+(b?"."+b.guid:""),W[d]);return ga.test(this.nodeName)}};var W=c.event.special.change.filters}s.addEventListener&&c.each({focus:"focusin",blur:"focusout"},function(a,b){function d(f){f=c.event.fix(f);f.type=b;return c.event.handle.call(this,f)}c.event.special[b]={setup:function(){this.addEventListener(a,d,true)},teardown:function(){this.removeEventListener(a,d,true)}}});c.each(["bind","one"],function(a,b){c.fn[b]=function(d,
|
||||
f,e){if(typeof d==="object"){for(var i in d)this[b](i,f,d[i],e);return this}if(c.isFunction(f)){thisObject=e;e=f;f=w}var j=b==="one"?c.proxy(e,function(o){c(this).unbind(o,j);return e.apply(this,arguments)}):e;return d==="unload"&&b!=="one"?this.one(d,f,e,thisObject):this.each(function(){c.event.add(this,d,j,f)})}});c.fn.extend({unbind:function(a,b){if(typeof a==="object"&&!a.preventDefault){for(var d in a)this.unbind(d,a[d]);return this}return this.each(function(){c.event.remove(this,a,b)})},trigger:function(a,
|
||||
b){return this.each(function(){c.event.trigger(a,b,this)})},triggerHandler:function(a,b){if(this[0]){a=c.Event(a);a.preventDefault();a.stopPropagation();c.event.trigger(a,b,this[0]);return a.result}},toggle:function(a){for(var b=arguments,d=1;d<b.length;)c.proxy(a,b[d++]);return this.click(c.proxy(a,function(f){var e=(c.data(this,"lastToggle"+a.guid)||0)%d;c.data(this,"lastToggle"+a.guid,e+1);f.preventDefault();return b[e].apply(this,arguments)||false}))},hover:function(a,b){return this.mouseenter(a).mouseleave(b||
|
||||
a)},live:function(a,b,d){if(c.isFunction(b)){d=b;b=w}c(this.context).bind(ra(a,this.selector),{data:b,selector:this.selector,live:a},d);return this},die:function(a,b){c(this.context).unbind(ra(a,this.selector),b?{guid:b.guid+this.selector+a}:null);return this}});c.each("blur focus focusin focusout load resize scroll unload click dblclick mousedown mouseup mousemove mouseover mouseout mouseenter mouseleave change select submit keydown keypress keyup error".split(" "),function(a,b){c.fn[b]=function(d){return d?
|
||||
this.bind(b,d):this.trigger(b)};if(c.attrFn)c.attrFn[b]=true});A.attachEvent&&!A.addEventListener&&A.attachEvent("onunload",function(){for(var a in c.cache)if(c.cache[a].handle)try{c.event.remove(c.cache[a].handle.elem)}catch(b){}});(function(){function a(g){for(var h="",k,m=0;g[m];m++){k=g[m];if(k.nodeType===3||k.nodeType===4)h+=k.nodeValue;else if(k.nodeType!==8)h+=a(k.childNodes)}return h}function b(g,h,k,m,r,q){r=0;for(var v=m.length;r<v;r++){var u=m[r];if(u){u=u[g];for(var y=false;u;){if(u.sizcache===
|
||||
k){y=m[u.sizset];break}if(u.nodeType===1&&!q){u.sizcache=k;u.sizset=r}if(u.nodeName.toLowerCase()===h){y=u;break}u=u[g]}m[r]=y}}}function d(g,h,k,m,r,q){r=0;for(var v=m.length;r<v;r++){var u=m[r];if(u){u=u[g];for(var y=false;u;){if(u.sizcache===k){y=m[u.sizset];break}if(u.nodeType===1){if(!q){u.sizcache=k;u.sizset=r}if(typeof h!=="string"){if(u===h){y=true;break}}else if(p.filter(h,[u]).length>0){y=u;break}}u=u[g]}m[r]=y}}}var f=/((?:\((?:\([^()]+\)|[^()]+)+\)|\[(?:\[[^[\]]*\]|['"][^'"]*['"]|[^[\]'"]+)+\]|\\.|[^ >+~,(\[\\]+)+|[>+~])(\s*,\s*)?((?:.|\r|\n)*)/g,
|
||||
e=0,i=Object.prototype.toString,j=false,o=true;[0,0].sort(function(){o=false;return 0});var p=function(g,h,k,m){k=k||[];var r=h=h||s;if(h.nodeType!==1&&h.nodeType!==9)return[];if(!g||typeof g!=="string")return k;for(var q=[],v,u,y,S,I=true,N=x(h),J=g;(f.exec(""),v=f.exec(J))!==null;){J=v[3];q.push(v[1]);if(v[2]){S=v[3];break}}if(q.length>1&&t.exec(g))if(q.length===2&&n.relative[q[0]])u=ia(q[0]+q[1],h);else for(u=n.relative[q[0]]?[h]:p(q.shift(),h);q.length;){g=q.shift();if(n.relative[g])g+=q.shift();
|
||||
u=ia(g,u)}else{if(!m&&q.length>1&&h.nodeType===9&&!N&&n.match.ID.test(q[0])&&!n.match.ID.test(q[q.length-1])){v=p.find(q.shift(),h,N);h=v.expr?p.filter(v.expr,v.set)[0]:v.set[0]}if(h){v=m?{expr:q.pop(),set:B(m)}:p.find(q.pop(),q.length===1&&(q[0]==="~"||q[0]==="+")&&h.parentNode?h.parentNode:h,N);u=v.expr?p.filter(v.expr,v.set):v.set;if(q.length>0)y=B(u);else I=false;for(;q.length;){var E=q.pop();v=E;if(n.relative[E])v=q.pop();else E="";if(v==null)v=h;n.relative[E](y,v,N)}}else y=[]}y||(y=u);if(!y)throw"Syntax error, unrecognized expression: "+
|
||||
(E||g);if(i.call(y)==="[object Array]")if(I)if(h&&h.nodeType===1)for(g=0;y[g]!=null;g++){if(y[g]&&(y[g]===true||y[g].nodeType===1&&F(h,y[g])))k.push(u[g])}else for(g=0;y[g]!=null;g++)y[g]&&y[g].nodeType===1&&k.push(u[g]);else k.push.apply(k,y);else B(y,k);if(S){p(S,r,k,m);p.uniqueSort(k)}return k};p.uniqueSort=function(g){if(D){j=o;g.sort(D);if(j)for(var h=1;h<g.length;h++)g[h]===g[h-1]&&g.splice(h--,1)}return g};p.matches=function(g,h){return p(g,null,null,h)};p.find=function(g,h,k){var m,r;if(!g)return[];
|
||||
for(var q=0,v=n.order.length;q<v;q++){var u=n.order[q];if(r=n.leftMatch[u].exec(g)){var y=r[1];r.splice(1,1);if(y.substr(y.length-1)!=="\\"){r[1]=(r[1]||"").replace(/\\/g,"");m=n.find[u](r,h,k);if(m!=null){g=g.replace(n.match[u],"");break}}}}m||(m=h.getElementsByTagName("*"));return{set:m,expr:g}};p.filter=function(g,h,k,m){for(var r=g,q=[],v=h,u,y,S=h&&h[0]&&x(h[0]);g&&h.length;){for(var I in n.filter)if((u=n.leftMatch[I].exec(g))!=null&&u[2]){var N=n.filter[I],J,E;E=u[1];y=false;u.splice(1,1);if(E.substr(E.length-
|
||||
1)!=="\\"){if(v===q)q=[];if(n.preFilter[I])if(u=n.preFilter[I](u,v,k,q,m,S)){if(u===true)continue}else y=J=true;if(u)for(var X=0;(E=v[X])!=null;X++)if(E){J=N(E,u,X,v);var Ea=m^!!J;if(k&&J!=null)if(Ea)y=true;else v[X]=false;else if(Ea){q.push(E);y=true}}if(J!==w){k||(v=q);g=g.replace(n.match[I],"");if(!y)return[];break}}}if(g===r)if(y==null)throw"Syntax error, unrecognized expression: "+g;else break;r=g}return v};var n=p.selectors={order:["ID","NAME","TAG"],match:{ID:/#((?:[\w\u00c0-\uFFFF-]|\\.)+)/,
|
||||
CLASS:/\.((?:[\w\u00c0-\uFFFF-]|\\.)+)/,NAME:/\[name=['"]*((?:[\w\u00c0-\uFFFF-]|\\.)+)['"]*\]/,ATTR:/\[\s*((?:[\w\u00c0-\uFFFF-]|\\.)+)\s*(?:(\S?=)\s*(['"]*)(.*?)\3|)\s*\]/,TAG:/^((?:[\w\u00c0-\uFFFF\*-]|\\.)+)/,CHILD:/:(only|nth|last|first)-child(?:\((even|odd|[\dn+-]*)\))?/,POS:/:(nth|eq|gt|lt|first|last|even|odd)(?:\((\d*)\))?(?=[^-]|$)/,PSEUDO:/:((?:[\w\u00c0-\uFFFF-]|\\.)+)(?:\((['"]?)((?:\([^\)]+\)|[^\(\)]*)+)\2\))?/},leftMatch:{},attrMap:{"class":"className","for":"htmlFor"},attrHandle:{href:function(g){return g.getAttribute("href")}},
|
||||
relative:{"+":function(g,h){var k=typeof h==="string",m=k&&!/\W/.test(h);k=k&&!m;if(m)h=h.toLowerCase();m=0;for(var r=g.length,q;m<r;m++)if(q=g[m]){for(;(q=q.previousSibling)&&q.nodeType!==1;);g[m]=k||q&&q.nodeName.toLowerCase()===h?q||false:q===h}k&&p.filter(h,g,true)},">":function(g,h){var k=typeof h==="string";if(k&&!/\W/.test(h)){h=h.toLowerCase();for(var m=0,r=g.length;m<r;m++){var q=g[m];if(q){k=q.parentNode;g[m]=k.nodeName.toLowerCase()===h?k:false}}}else{m=0;for(r=g.length;m<r;m++)if(q=g[m])g[m]=
|
||||
k?q.parentNode:q.parentNode===h;k&&p.filter(h,g,true)}},"":function(g,h,k){var m=e++,r=d;if(typeof h==="string"&&!/\W/.test(h)){var q=h=h.toLowerCase();r=b}r("parentNode",h,m,g,q,k)},"~":function(g,h,k){var m=e++,r=d;if(typeof h==="string"&&!/\W/.test(h)){var q=h=h.toLowerCase();r=b}r("previousSibling",h,m,g,q,k)}},find:{ID:function(g,h,k){if(typeof h.getElementById!=="undefined"&&!k)return(g=h.getElementById(g[1]))?[g]:[]},NAME:function(g,h){if(typeof h.getElementsByName!=="undefined"){var k=[];
|
||||
h=h.getElementsByName(g[1]);for(var m=0,r=h.length;m<r;m++)h[m].getAttribute("name")===g[1]&&k.push(h[m]);return k.length===0?null:k}},TAG:function(g,h){return h.getElementsByTagName(g[1])}},preFilter:{CLASS:function(g,h,k,m,r,q){g=" "+g[1].replace(/\\/g,"")+" ";if(q)return g;q=0;for(var v;(v=h[q])!=null;q++)if(v)if(r^(v.className&&(" "+v.className+" ").replace(/[\t\n]/g," ").indexOf(g)>=0))k||m.push(v);else if(k)h[q]=false;return false},ID:function(g){return g[1].replace(/\\/g,"")},TAG:function(g){return g[1].toLowerCase()},
|
||||
CHILD:function(g){if(g[1]==="nth"){var h=/(-?)(\d*)n((?:\+|-)?\d*)/.exec(g[2]==="even"&&"2n"||g[2]==="odd"&&"2n+1"||!/\D/.test(g[2])&&"0n+"+g[2]||g[2]);g[2]=h[1]+(h[2]||1)-0;g[3]=h[3]-0}g[0]=e++;return g},ATTR:function(g,h,k,m,r,q){h=g[1].replace(/\\/g,"");if(!q&&n.attrMap[h])g[1]=n.attrMap[h];if(g[2]==="~=")g[4]=" "+g[4]+" ";return g},PSEUDO:function(g,h,k,m,r){if(g[1]==="not")if((f.exec(g[3])||"").length>1||/^\w/.test(g[3]))g[3]=p(g[3],null,null,h);else{g=p.filter(g[3],h,k,true^r);k||m.push.apply(m,
|
||||
g);return false}else if(n.match.POS.test(g[0])||n.match.CHILD.test(g[0]))return true;return g},POS:function(g){g.unshift(true);return g}},filters:{enabled:function(g){return g.disabled===false&&g.type!=="hidden"},disabled:function(g){return g.disabled===true},checked:function(g){return g.checked===true},selected:function(g){return g.selected===true},parent:function(g){return!!g.firstChild},empty:function(g){return!g.firstChild},has:function(g,h,k){return!!p(k[3],g).length},header:function(g){return/h\d/i.test(g.nodeName)},
|
||||
text:function(g){return"text"===g.type},radio:function(g){return"radio"===g.type},checkbox:function(g){return"checkbox"===g.type},file:function(g){return"file"===g.type},password:function(g){return"password"===g.type},submit:function(g){return"submit"===g.type},image:function(g){return"image"===g.type},reset:function(g){return"reset"===g.type},button:function(g){return"button"===g.type||g.nodeName.toLowerCase()==="button"},input:function(g){return/input|select|textarea|button/i.test(g.nodeName)}},
|
||||
setFilters:{first:function(g,h){return h===0},last:function(g,h,k,m){return h===m.length-1},even:function(g,h){return h%2===0},odd:function(g,h){return h%2===1},lt:function(g,h,k){return h<k[3]-0},gt:function(g,h,k){return h>k[3]-0},nth:function(g,h,k){return k[3]-0===h},eq:function(g,h,k){return k[3]-0===h}},filter:{PSEUDO:function(g,h,k,m){var r=h[1],q=n.filters[r];if(q)return q(g,k,h,m);else if(r==="contains")return(g.textContent||g.innerText||a([g])||"").indexOf(h[3])>=0;else if(r==="not"){h=
|
||||
h[3];k=0;for(m=h.length;k<m;k++)if(h[k]===g)return false;return true}else throw"Syntax error, unrecognized expression: "+r;},CHILD:function(g,h){var k=h[1],m=g;switch(k){case "only":case "first":for(;m=m.previousSibling;)if(m.nodeType===1)return false;if(k==="first")return true;m=g;case "last":for(;m=m.nextSibling;)if(m.nodeType===1)return false;return true;case "nth":k=h[2];var r=h[3];if(k===1&&r===0)return true;h=h[0];var q=g.parentNode;if(q&&(q.sizcache!==h||!g.nodeIndex)){var v=0;for(m=q.firstChild;m;m=
|
||||
m.nextSibling)if(m.nodeType===1)m.nodeIndex=++v;q.sizcache=h}g=g.nodeIndex-r;return k===0?g===0:g%k===0&&g/k>=0}},ID:function(g,h){return g.nodeType===1&&g.getAttribute("id")===h},TAG:function(g,h){return h==="*"&&g.nodeType===1||g.nodeName.toLowerCase()===h},CLASS:function(g,h){return(" "+(g.className||g.getAttribute("class"))+" ").indexOf(h)>-1},ATTR:function(g,h){var k=h[1];g=n.attrHandle[k]?n.attrHandle[k](g):g[k]!=null?g[k]:g.getAttribute(k);k=g+"";var m=h[2];h=h[4];return g==null?m==="!=":m===
|
||||
"="?k===h:m==="*="?k.indexOf(h)>=0:m==="~="?(" "+k+" ").indexOf(h)>=0:!h?k&&g!==false:m==="!="?k!==h:m==="^="?k.indexOf(h)===0:m==="$="?k.substr(k.length-h.length)===h:m==="|="?k===h||k.substr(0,h.length+1)===h+"-":false},POS:function(g,h,k,m){var r=n.setFilters[h[2]];if(r)return r(g,k,h,m)}}},t=n.match.POS;for(var z in n.match){n.match[z]=new RegExp(n.match[z].source+/(?![^\[]*\])(?![^\(]*\))/.source);n.leftMatch[z]=new RegExp(/(^(?:.|\r|\n)*?)/.source+n.match[z].source.replace(/\\(\d+)/g,function(g,
|
||||
h){return"\\"+(h-0+1)}))}var B=function(g,h){g=Array.prototype.slice.call(g,0);if(h){h.push.apply(h,g);return h}return g};try{Array.prototype.slice.call(s.documentElement.childNodes,0)}catch(C){B=function(g,h){h=h||[];if(i.call(g)==="[object Array]")Array.prototype.push.apply(h,g);else if(typeof g.length==="number")for(var k=0,m=g.length;k<m;k++)h.push(g[k]);else for(k=0;g[k];k++)h.push(g[k]);return h}}var D;if(s.documentElement.compareDocumentPosition)D=function(g,h){if(!g.compareDocumentPosition||
|
||||
!h.compareDocumentPosition){if(g==h)j=true;return g.compareDocumentPosition?-1:1}g=g.compareDocumentPosition(h)&4?-1:g===h?0:1;if(g===0)j=true;return g};else if("sourceIndex"in s.documentElement)D=function(g,h){if(!g.sourceIndex||!h.sourceIndex){if(g==h)j=true;return g.sourceIndex?-1:1}g=g.sourceIndex-h.sourceIndex;if(g===0)j=true;return g};else if(s.createRange)D=function(g,h){if(!g.ownerDocument||!h.ownerDocument){if(g==h)j=true;return g.ownerDocument?-1:1}var k=g.ownerDocument.createRange(),m=
|
||||
h.ownerDocument.createRange();k.setStart(g,0);k.setEnd(g,0);m.setStart(h,0);m.setEnd(h,0);g=k.compareBoundaryPoints(Range.START_TO_END,m);if(g===0)j=true;return g};(function(){var g=s.createElement("div"),h="script"+(new Date).getTime();g.innerHTML="<a name='"+h+"'/>";var k=s.documentElement;k.insertBefore(g,k.firstChild);if(s.getElementById(h)){n.find.ID=function(m,r,q){if(typeof r.getElementById!=="undefined"&&!q)return(r=r.getElementById(m[1]))?r.id===m[1]||typeof r.getAttributeNode!=="undefined"&&
|
||||
r.getAttributeNode("id").nodeValue===m[1]?[r]:w:[]};n.filter.ID=function(m,r){var q=typeof m.getAttributeNode!=="undefined"&&m.getAttributeNode("id");return m.nodeType===1&&q&&q.nodeValue===r}}k.removeChild(g);k=g=null})();(function(){var g=s.createElement("div");g.appendChild(s.createComment(""));if(g.getElementsByTagName("*").length>0)n.find.TAG=function(h,k){k=k.getElementsByTagName(h[1]);if(h[1]==="*"){h=[];for(var m=0;k[m];m++)k[m].nodeType===1&&h.push(k[m]);k=h}return k};g.innerHTML="<a href='#'></a>";
|
||||
if(g.firstChild&&typeof g.firstChild.getAttribute!=="undefined"&&g.firstChild.getAttribute("href")!=="#")n.attrHandle.href=function(h){return h.getAttribute("href",2)};g=null})();s.querySelectorAll&&function(){var g=p,h=s.createElement("div");h.innerHTML="<p class='TEST'></p>";if(!(h.querySelectorAll&&h.querySelectorAll(".TEST").length===0)){p=function(m,r,q,v){r=r||s;if(!v&&r.nodeType===9&&!x(r))try{return B(r.querySelectorAll(m),q)}catch(u){}return g(m,r,q,v)};for(var k in g)p[k]=g[k];h=null}}();
|
||||
(function(){var g=s.createElement("div");g.innerHTML="<div class='test e'></div><div class='test'></div>";if(!(!g.getElementsByClassName||g.getElementsByClassName("e").length===0)){g.lastChild.className="e";if(g.getElementsByClassName("e").length!==1){n.order.splice(1,0,"CLASS");n.find.CLASS=function(h,k,m){if(typeof k.getElementsByClassName!=="undefined"&&!m)return k.getElementsByClassName(h[1])};g=null}}})();var F=s.compareDocumentPosition?function(g,h){return g.compareDocumentPosition(h)&16}:function(g,
|
||||
h){return g!==h&&(g.contains?g.contains(h):true)},x=function(g){return(g=(g?g.ownerDocument||g:0).documentElement)?g.nodeName!=="HTML":false},ia=function(g,h){var k=[],m="",r;for(h=h.nodeType?[h]:h;r=n.match.PSEUDO.exec(g);){m+=r[0];g=g.replace(n.match.PSEUDO,"")}g=n.relative[g]?g+"*":g;r=0;for(var q=h.length;r<q;r++)p(g,h[r],k);return p.filter(m,k)};c.find=p;c.expr=p.selectors;c.expr[":"]=c.expr.filters;c.unique=p.uniqueSort;c.getText=a;c.isXMLDoc=x;c.contains=F})();var ab=/Until$/,bb=/^(?:parents|prevUntil|prevAll)/,
|
||||
cb=/,/;R=Array.prototype.slice;var Fa=function(a,b,d){if(c.isFunction(b))return c.grep(a,function(e,i){return!!b.call(e,i,e)===d});else if(b.nodeType)return c.grep(a,function(e){return e===b===d});else if(typeof b==="string"){var f=c.grep(a,function(e){return e.nodeType===1});if(Pa.test(b))return c.filter(b,f,!d);else b=c.filter(b,a)}return c.grep(a,function(e){return c.inArray(e,b)>=0===d})};c.fn.extend({find:function(a){for(var b=this.pushStack("","find",a),d=0,f=0,e=this.length;f<e;f++){d=b.length;
|
||||
c.find(a,this[f],b);if(f>0)for(var i=d;i<b.length;i++)for(var j=0;j<d;j++)if(b[j]===b[i]){b.splice(i--,1);break}}return b},has:function(a){var b=c(a);return this.filter(function(){for(var d=0,f=b.length;d<f;d++)if(c.contains(this,b[d]))return true})},not:function(a){return this.pushStack(Fa(this,a,false),"not",a)},filter:function(a){return this.pushStack(Fa(this,a,true),"filter",a)},is:function(a){return!!a&&c.filter(a,this).length>0},closest:function(a,b){if(c.isArray(a)){var d=[],f=this[0],e,i=
|
||||
{},j;if(f&&a.length){e=0;for(var o=a.length;e<o;e++){j=a[e];i[j]||(i[j]=c.expr.match.POS.test(j)?c(j,b||this.context):j)}for(;f&&f.ownerDocument&&f!==b;){for(j in i){e=i[j];if(e.jquery?e.index(f)>-1:c(f).is(e)){d.push({selector:j,elem:f});delete i[j]}}f=f.parentNode}}return d}var p=c.expr.match.POS.test(a)?c(a,b||this.context):null;return this.map(function(n,t){for(;t&&t.ownerDocument&&t!==b;){if(p?p.index(t)>-1:c(t).is(a))return t;t=t.parentNode}return null})},index:function(a){if(!a||typeof a===
|
||||
"string")return c.inArray(this[0],a?c(a):this.parent().children());return c.inArray(a.jquery?a[0]:a,this)},add:function(a,b){a=typeof a==="string"?c(a,b||this.context):c.makeArray(a);b=c.merge(this.get(),a);return this.pushStack(sa(a[0])||sa(b[0])?b:c.unique(b))},andSelf:function(){return this.add(this.prevObject)}});c.each({parent:function(a){return(a=a.parentNode)&&a.nodeType!==11?a:null},parents:function(a){return c.dir(a,"parentNode")},parentsUntil:function(a,b,d){return c.dir(a,"parentNode",
|
||||
d)},next:function(a){return c.nth(a,2,"nextSibling")},prev:function(a){return c.nth(a,2,"previousSibling")},nextAll:function(a){return c.dir(a,"nextSibling")},prevAll:function(a){return c.dir(a,"previousSibling")},nextUntil:function(a,b,d){return c.dir(a,"nextSibling",d)},prevUntil:function(a,b,d){return c.dir(a,"previousSibling",d)},siblings:function(a){return c.sibling(a.parentNode.firstChild,a)},children:function(a){return c.sibling(a.firstChild)},contents:function(a){return c.nodeName(a,"iframe")?
|
||||
a.contentDocument||a.contentWindow.document:c.makeArray(a.childNodes)}},function(a,b){c.fn[a]=function(d,f){var e=c.map(this,b,d);ab.test(a)||(f=d);if(f&&typeof f==="string")e=c.filter(f,e);e=this.length>1?c.unique(e):e;if((this.length>1||cb.test(f))&&bb.test(a))e=e.reverse();return this.pushStack(e,a,R.call(arguments).join(","))}});c.extend({filter:function(a,b,d){if(d)a=":not("+a+")";return c.find.matches(a,b)},dir:function(a,b,d){var f=[];for(a=a[b];a&&a.nodeType!==9&&(d===w||!c(a).is(d));){a.nodeType===
|
||||
1&&f.push(a);a=a[b]}return f},nth:function(a,b,d){b=b||1;for(var f=0;a;a=a[d])if(a.nodeType===1&&++f===b)break;return a},sibling:function(a,b){for(var d=[];a;a=a.nextSibling)a.nodeType===1&&a!==b&&d.push(a);return d}});var Ga=/ jQuery\d+="(?:\d+|null)"/g,Y=/^\s+/,db=/(<([\w:]+)[^>]*?)\/>/g,eb=/^(?:area|br|col|embed|hr|img|input|link|meta|param)$/i,Ha=/<([\w:]+)/,fb=/<tbody/i,gb=/<|&\w+;/,hb=function(a,b,d){return eb.test(d)?a:b+"></"+d+">"},G={option:[1,"<select multiple='multiple'>","</select>"],
|
||||
legend:[1,"<fieldset>","</fieldset>"],thead:[1,"<table>","</table>"],tr:[2,"<table><tbody>","</tbody></table>"],td:[3,"<table><tbody><tr>","</tr></tbody></table>"],col:[2,"<table><tbody></tbody><colgroup>","</colgroup></table>"],area:[1,"<map>","</map>"],_default:[0,"",""]};G.optgroup=G.option;G.tbody=G.tfoot=G.colgroup=G.caption=G.thead;G.th=G.td;if(!c.support.htmlSerialize)G._default=[1,"div<div>","</div>"];c.fn.extend({text:function(a){if(c.isFunction(a))return this.each(function(b){var d=c(this);
|
||||
return d.text(a.call(this,b,d.text()))});if(typeof a!=="object"&&a!==w)return this.empty().append((this[0]&&this[0].ownerDocument||s).createTextNode(a));return c.getText(this)},wrapAll:function(a){if(c.isFunction(a))return this.each(function(d){c(this).wrapAll(a.call(this,d))});if(this[0]){var b=c(a,this[0].ownerDocument).eq(0).clone(true);this[0].parentNode&&b.insertBefore(this[0]);b.map(function(){for(var d=this;d.firstChild&&d.firstChild.nodeType===1;)d=d.firstChild;return d}).append(this)}return this},
|
||||
wrapInner:function(a){return this.each(function(){var b=c(this),d=b.contents();d.length?d.wrapAll(a):b.append(a)})},wrap:function(a){return this.each(function(){c(this).wrapAll(a)})},unwrap:function(){return this.parent().each(function(){c.nodeName(this,"body")||c(this).replaceWith(this.childNodes)}).end()},append:function(){return this.domManip(arguments,true,function(a){this.nodeType===1&&this.appendChild(a)})},prepend:function(){return this.domManip(arguments,true,function(a){this.nodeType===1&&
|
||||
this.insertBefore(a,this.firstChild)})},before:function(){if(this[0]&&this[0].parentNode)return this.domManip(arguments,false,function(b){this.parentNode.insertBefore(b,this)});else if(arguments.length){var a=c(arguments[0]);a.push.apply(a,this.toArray());return this.pushStack(a,"before",arguments)}},after:function(){if(this[0]&&this[0].parentNode)return this.domManip(arguments,false,function(b){this.parentNode.insertBefore(b,this.nextSibling)});else if(arguments.length){var a=this.pushStack(this,
|
||||
"after",arguments);a.push.apply(a,c(arguments[0]).toArray());return a}},clone:function(a){var b=this.map(function(){if(!c.support.noCloneEvent&&!c.isXMLDoc(this)){var d=this.outerHTML,f=this.ownerDocument;if(!d){d=f.createElement("div");d.appendChild(this.cloneNode(true));d=d.innerHTML}return c.clean([d.replace(Ga,"").replace(Y,"")],f)[0]}else return this.cloneNode(true)});if(a===true){ta(this,b);ta(this.find("*"),b.find("*"))}return b},html:function(a){if(a===w)return this[0]&&this[0].nodeType===
|
||||
1?this[0].innerHTML.replace(Ga,""):null;else if(typeof a==="string"&&!/<script/i.test(a)&&(c.support.leadingWhitespace||!Y.test(a))&&!G[(Ha.exec(a)||["",""])[1].toLowerCase()])try{for(var b=0,d=this.length;b<d;b++)if(this[b].nodeType===1){T(this[b].getElementsByTagName("*"));this[b].innerHTML=a}}catch(f){this.empty().append(a)}else c.isFunction(a)?this.each(function(e){var i=c(this),j=i.html();i.empty().append(function(){return a.call(this,e,j)})}):this.empty().append(a);return this},replaceWith:function(a){if(this[0]&&
|
||||
this[0].parentNode){c.isFunction(a)||(a=c(a).detach());return this.each(function(){var b=this.nextSibling,d=this.parentNode;c(this).remove();b?c(b).before(a):c(d).append(a)})}else return this.pushStack(c(c.isFunction(a)?a():a),"replaceWith",a)},detach:function(a){return this.remove(a,true)},domManip:function(a,b,d){function f(t){return c.nodeName(t,"table")?t.getElementsByTagName("tbody")[0]||t.appendChild(t.ownerDocument.createElement("tbody")):t}var e,i,j=a[0],o=[];if(c.isFunction(j))return this.each(function(t){var z=
|
||||
c(this);a[0]=j.call(this,t,b?z.html():w);return z.domManip(a,b,d)});if(this[0]){e=a[0]&&a[0].parentNode&&a[0].parentNode.nodeType===11?{fragment:a[0].parentNode}:ua(a,this,o);if(i=e.fragment.firstChild){b=b&&c.nodeName(i,"tr");for(var p=0,n=this.length;p<n;p++)d.call(b?f(this[p],i):this[p],e.cacheable||this.length>1||p>0?e.fragment.cloneNode(true):e.fragment)}o&&c.each(o,La)}return this}});c.fragments={};c.each({appendTo:"append",prependTo:"prepend",insertBefore:"before",insertAfter:"after",replaceAll:"replaceWith"},
|
||||
function(a,b){c.fn[a]=function(d){var f=[];d=c(d);for(var e=0,i=d.length;e<i;e++){var j=(e>0?this.clone(true):this).get();c.fn[b].apply(c(d[e]),j);f=f.concat(j)}return this.pushStack(f,a,d.selector)}});c.each({remove:function(a,b){if(!a||c.filter(a,[this]).length){if(!b&&this.nodeType===1){T(this.getElementsByTagName("*"));T([this])}this.parentNode&&this.parentNode.removeChild(this)}},empty:function(){for(this.nodeType===1&&T(this.getElementsByTagName("*"));this.firstChild;)this.removeChild(this.firstChild)}},
|
||||
function(a,b){c.fn[a]=function(){return this.each(b,arguments)}});c.extend({clean:function(a,b,d,f){b=b||s;if(typeof b.createElement==="undefined")b=b.ownerDocument||b[0]&&b[0].ownerDocument||s;var e=[];c.each(a,function(i,j){if(typeof j==="number")j+="";if(j){if(typeof j==="string"&&!gb.test(j))j=b.createTextNode(j);else if(typeof j==="string"){j=j.replace(db,hb);var o=(Ha.exec(j)||["",""])[1].toLowerCase(),p=G[o]||G._default,n=p[0];i=b.createElement("div");for(i.innerHTML=p[1]+j+p[2];n--;)i=i.lastChild;
|
||||
if(!c.support.tbody){n=fb.test(j);o=o==="table"&&!n?i.firstChild&&i.firstChild.childNodes:p[1]==="<table>"&&!n?i.childNodes:[];for(p=o.length-1;p>=0;--p)c.nodeName(o[p],"tbody")&&!o[p].childNodes.length&&o[p].parentNode.removeChild(o[p])}!c.support.leadingWhitespace&&Y.test(j)&&i.insertBefore(b.createTextNode(Y.exec(j)[0]),i.firstChild);j=c.makeArray(i.childNodes)}if(j.nodeType)e.push(j);else e=c.merge(e,j)}});if(d)for(a=0;e[a];a++)if(f&&c.nodeName(e[a],"script")&&(!e[a].type||e[a].type.toLowerCase()===
|
||||
"text/javascript"))f.push(e[a].parentNode?e[a].parentNode.removeChild(e[a]):e[a]);else{e[a].nodeType===1&&e.splice.apply(e,[a+1,0].concat(c.makeArray(e[a].getElementsByTagName("script"))));d.appendChild(e[a])}return e}});var ib=/z-?index|font-?weight|opacity|zoom|line-?height/i,Ia=/alpha\([^)]*\)/,Ja=/opacity=([^)]*)/,ja=/float/i,ka=/-([a-z])/ig,jb=/([A-Z])/g,kb=/^-?\d+(?:px)?$/i,lb=/^-?\d/,mb={position:"absolute",visibility:"hidden",display:"block"},nb=["Left","Right"],ob=["Top","Bottom"],pb=s.defaultView&&
|
||||
s.defaultView.getComputedStyle,Ka=c.support.cssFloat?"cssFloat":"styleFloat",la=function(a,b){return b.toUpperCase()};c.fn.css=function(a,b){return $(this,a,b,true,function(d,f,e){if(e===w)return c.curCSS(d,f);if(typeof e==="number"&&!ib.test(f))e+="px";c.style(d,f,e)})};c.extend({style:function(a,b,d){if(!a||a.nodeType===3||a.nodeType===8)return w;if((b==="width"||b==="height")&&parseFloat(d)<0)d=w;var f=a.style||a,e=d!==w;if(!c.support.opacity&&b==="opacity"){if(e){f.zoom=1;b=parseInt(d,10)+""===
|
||||
"NaN"?"":"alpha(opacity="+d*100+")";a=f.filter||c.curCSS(a,"filter")||"";f.filter=Ia.test(a)?a.replace(Ia,b):b}return f.filter&&f.filter.indexOf("opacity=")>=0?parseFloat(Ja.exec(f.filter)[1])/100+"":""}if(ja.test(b))b=Ka;b=b.replace(ka,la);if(e)f[b]=d;return f[b]},css:function(a,b,d,f){if(b==="width"||b==="height"){var e,i=b==="width"?nb:ob;function j(){e=b==="width"?a.offsetWidth:a.offsetHeight;f!=="border"&&c.each(i,function(){f||(e-=parseFloat(c.curCSS(a,"padding"+this,true))||0);if(f==="margin")e+=
|
||||
parseFloat(c.curCSS(a,"margin"+this,true))||0;else e-=parseFloat(c.curCSS(a,"border"+this+"Width",true))||0})}a.offsetWidth!==0?j():c.swap(a,mb,j);return Math.max(0,Math.round(e))}return c.curCSS(a,b,d)},curCSS:function(a,b,d){var f,e=a.style;if(!c.support.opacity&&b==="opacity"&&a.currentStyle){f=Ja.test(a.currentStyle.filter||"")?parseFloat(RegExp.$1)/100+"":"";return f===""?"1":f}if(ja.test(b))b=Ka;if(!d&&e&&e[b])f=e[b];else if(pb){if(ja.test(b))b="float";b=b.replace(jb,"-$1").toLowerCase();e=
|
||||
a.ownerDocument.defaultView;if(!e)return null;if(a=e.getComputedStyle(a,null))f=a.getPropertyValue(b);if(b==="opacity"&&f==="")f="1"}else if(a.currentStyle){d=b.replace(ka,la);f=a.currentStyle[b]||a.currentStyle[d];if(!kb.test(f)&&lb.test(f)){b=e.left;var i=a.runtimeStyle.left;a.runtimeStyle.left=a.currentStyle.left;e.left=d==="fontSize"?"1em":f||0;f=e.pixelLeft+"px";e.left=b;a.runtimeStyle.left=i}}return f},swap:function(a,b,d){var f={};for(var e in b){f[e]=a.style[e];a.style[e]=b[e]}d.call(a);for(e in b)a.style[e]=
|
||||
f[e]}});if(c.expr&&c.expr.filters){c.expr.filters.hidden=function(a){var b=a.offsetWidth,d=a.offsetHeight,f=a.nodeName.toLowerCase()==="tr";return b===0&&d===0&&!f?true:b>0&&d>0&&!f?false:c.curCSS(a,"display")==="none"};c.expr.filters.visible=function(a){return!c.expr.filters.hidden(a)}}var qb=K(),rb=/<script(.|\s)*?\/script>/gi,sb=/select|textarea/i,tb=/color|date|datetime|email|hidden|month|number|password|range|search|tel|text|time|url|week/i,O=/=\?(&|$)/,ma=/\?/,ub=/(\?|&)_=.*?(&|$)/,vb=/^(\w+:)?\/\/([^\/?#]+)/,
|
||||
wb=/%20/g;c.fn.extend({_load:c.fn.load,load:function(a,b,d){if(typeof a!=="string")return this._load(a);else if(!this.length)return this;var f=a.indexOf(" ");if(f>=0){var e=a.slice(f,a.length);a=a.slice(0,f)}f="GET";if(b)if(c.isFunction(b)){d=b;b=null}else if(typeof b==="object"){b=c.param(b,c.ajaxSettings.traditional);f="POST"}c.ajax({url:a,type:f,dataType:"html",data:b,context:this,complete:function(i,j){if(j==="success"||j==="notmodified")this.html(e?c("<div />").append(i.responseText.replace(rb,
|
||||
"")).find(e):i.responseText);d&&this.each(d,[i.responseText,j,i])}});return this},serialize:function(){return c.param(this.serializeArray())},serializeArray:function(){return this.map(function(){return this.elements?c.makeArray(this.elements):this}).filter(function(){return this.name&&!this.disabled&&(this.checked||sb.test(this.nodeName)||tb.test(this.type))}).map(function(a,b){a=c(this).val();return a==null?null:c.isArray(a)?c.map(a,function(d){return{name:b.name,value:d}}):{name:b.name,value:a}}).get()}});
|
||||
c.each("ajaxStart ajaxStop ajaxComplete ajaxError ajaxSuccess ajaxSend".split(" "),function(a,b){c.fn[b]=function(d){return this.bind(b,d)}});c.extend({get:function(a,b,d,f){if(c.isFunction(b)){f=f||d;d=b;b=null}return c.ajax({type:"GET",url:a,data:b,success:d,dataType:f})},getScript:function(a,b){return c.get(a,null,b,"script")},getJSON:function(a,b,d){return c.get(a,b,d,"json")},post:function(a,b,d,f){if(c.isFunction(b)){f=f||d;d=b;b={}}return c.ajax({type:"POST",url:a,data:b,success:d,dataType:f})},
|
||||
ajaxSetup:function(a){c.extend(c.ajaxSettings,a)},ajaxSettings:{url:location.href,global:true,type:"GET",contentType:"application/x-www-form-urlencoded",processData:true,async:true,xhr:A.XMLHttpRequest&&(A.location.protocol!=="file:"||!A.ActiveXObject)?function(){return new A.XMLHttpRequest}:function(){try{return new A.ActiveXObject("Microsoft.XMLHTTP")}catch(a){}},accepts:{xml:"application/xml, text/xml",html:"text/html",script:"text/javascript, application/javascript",json:"application/json, text/javascript",
|
||||
text:"text/plain",_default:"*/*"}},lastModified:{},etag:{},ajax:function(a){function b(){e.success&&e.success.call(p,o,j,x);e.global&&f("ajaxSuccess",[x,e])}function d(){e.complete&&e.complete.call(p,x,j);e.global&&f("ajaxComplete",[x,e]);e.global&&!--c.active&&c.event.trigger("ajaxStop")}function f(r,q){(e.context?c(e.context):c.event).trigger(r,q)}var e=c.extend(true,{},c.ajaxSettings,a),i,j,o,p=e.context||e,n=e.type.toUpperCase();if(e.data&&e.processData&&typeof e.data!=="string")e.data=c.param(e.data,
|
||||
e.traditional);if(e.dataType==="jsonp"){if(n==="GET")O.test(e.url)||(e.url+=(ma.test(e.url)?"&":"?")+(e.jsonp||"callback")+"=?");else if(!e.data||!O.test(e.data))e.data=(e.data?e.data+"&":"")+(e.jsonp||"callback")+"=?";e.dataType="json"}if(e.dataType==="json"&&(e.data&&O.test(e.data)||O.test(e.url))){i=e.jsonpCallback||"jsonp"+qb++;if(e.data)e.data=(e.data+"").replace(O,"="+i+"$1");e.url=e.url.replace(O,"="+i+"$1");e.dataType="script";A[i]=A[i]||function(r){o=r;b();d();A[i]=w;try{delete A[i]}catch(q){}B&&
|
||||
B.removeChild(C)}}if(e.dataType==="script"&&e.cache===null)e.cache=false;if(e.cache===false&&n==="GET"){var t=K(),z=e.url.replace(ub,"$1_="+t+"$2");e.url=z+(z===e.url?(ma.test(e.url)?"&":"?")+"_="+t:"")}if(e.data&&n==="GET")e.url+=(ma.test(e.url)?"&":"?")+e.data;e.global&&!c.active++&&c.event.trigger("ajaxStart");t=(t=vb.exec(e.url))&&(t[1]&&t[1]!==location.protocol||t[2]!==location.host);if(e.dataType==="script"&&n==="GET"&&t){var B=s.getElementsByTagName("head")[0]||s.documentElement,C=s.createElement("script");
|
||||
C.src=e.url;if(e.scriptCharset)C.charset=e.scriptCharset;if(!i){var D=false;C.onload=C.onreadystatechange=function(){if(!D&&(!this.readyState||this.readyState==="loaded"||this.readyState==="complete")){D=true;b();d();C.onload=C.onreadystatechange=null;B&&C.parentNode&&B.removeChild(C)}}}B.insertBefore(C,B.firstChild);return w}var F=false,x=e.xhr();if(x){e.username?x.open(n,e.url,e.async,e.username,e.password):x.open(n,e.url,e.async);try{if(e.data||a&&a.contentType)x.setRequestHeader("Content-Type",
|
||||
e.contentType);if(e.ifModified){c.lastModified[e.url]&&x.setRequestHeader("If-Modified-Since",c.lastModified[e.url]);c.etag[e.url]&&x.setRequestHeader("If-None-Match",c.etag[e.url])}t||x.setRequestHeader("X-Requested-With","XMLHttpRequest");x.setRequestHeader("Accept",e.dataType&&e.accepts[e.dataType]?e.accepts[e.dataType]+", */*":e.accepts._default)}catch(ia){}if(e.beforeSend&&e.beforeSend.call(p,x,e)===false){e.global&&!--c.active&&c.event.trigger("ajaxStop");x.abort();return false}e.global&&f("ajaxSend",
|
||||
[x,e]);var g=x.onreadystatechange=function(r){if(!x||x.readyState===0){F||d();F=true;if(x)x.onreadystatechange=c.noop}else if(!F&&x&&(x.readyState===4||r==="timeout")){F=true;x.onreadystatechange=c.noop;j=r==="timeout"?"timeout":!c.httpSuccess(x)?"error":e.ifModified&&c.httpNotModified(x,e.url)?"notmodified":"success";if(j==="success")try{o=c.httpData(x,e.dataType,e)}catch(q){j="parsererror"}if(j==="success"||j==="notmodified")i||b();else c.handleError(e,x,j);d();r==="timeout"&&x.abort();if(e.async)x=
|
||||
null}};try{var h=x.abort;x.abort=function(){if(x){h.call(x);if(x)x.readyState=0}g()}}catch(k){}e.async&&e.timeout>0&&setTimeout(function(){x&&!F&&g("timeout")},e.timeout);try{x.send(n==="POST"||n==="PUT"||n==="DELETE"?e.data:null)}catch(m){c.handleError(e,x,null,m);d()}e.async||g();return x}},handleError:function(a,b,d,f){if(a.error)a.error.call(a.context||A,b,d,f);if(a.global)(a.context?c(a.context):c.event).trigger("ajaxError",[b,a,f])},active:0,httpSuccess:function(a){try{return!a.status&&location.protocol===
|
||||
"file:"||a.status>=200&&a.status<300||a.status===304||a.status===1223||a.status===0}catch(b){}return false},httpNotModified:function(a,b){var d=a.getResponseHeader("Last-Modified"),f=a.getResponseHeader("Etag");if(d)c.lastModified[b]=d;if(f)c.etag[b]=f;return a.status===304||a.status===0},httpData:function(a,b,d){var f=a.getResponseHeader("content-type")||"",e=b==="xml"||!b&&f.indexOf("xml")>=0;a=e?a.responseXML:a.responseText;if(e&&a.documentElement.nodeName==="parsererror")throw"parsererror";if(d&&
|
||||
d.dataFilter)a=d.dataFilter(a,b);if(typeof a==="string")if(b==="json"||!b&&f.indexOf("json")>=0)if(/^[\],:{}\s]*$/.test(a.replace(/\\(?:["\\\/bfnrt]|u[0-9a-fA-F]{4})/g,"@").replace(/"[^"\\\n\r]*"|true|false|null|-?\d+(?:\.\d*)?(?:[eE][+\-]?\d+)?/g,"]").replace(/(?:^|:|,)(?:\s*\[)+/g,"")))a=A.JSON&&A.JSON.parse?A.JSON.parse(a):(new Function("return "+a))();else throw"Invalid JSON: "+a;else if(b==="script"||!b&&f.indexOf("javascript")>=0)c.globalEval(a);return a},param:function(a,b){function d(e,i){i=
|
||||
c.isFunction(i)?i():i;f[f.length]=encodeURIComponent(e)+"="+encodeURIComponent(i)}var f=[];if(b===w)b=c.ajaxSettings.traditional;c.isArray(a)||a.jquery?c.each(a,function(){d(this.name,this.value)}):c.each(a,function e(i,j){if(c.isArray(j))c.each(j,function(o,p){b?d(i,p):e(i+"["+(typeof p==="object"||c.isArray(p)?o:"")+"]",p)});else!b&&j!=null&&typeof j==="object"?c.each(j,function(o,p){e(i+"["+o+"]",p)}):d(i,j)});return f.join("&").replace(wb,"+")}});var na={},xb=/toggle|show|hide/,yb=/^([+-]=)?([\d+-.]+)(.*)$/,
|
||||
Z,va=[["height","marginTop","marginBottom","paddingTop","paddingBottom"],["width","marginLeft","marginRight","paddingLeft","paddingRight"],["opacity"]];c.fn.extend({show:function(a,b){if(a!=null)return this.animate(L("show",3),a,b);else{a=0;for(b=this.length;a<b;a++){var d=c.data(this[a],"olddisplay");this[a].style.display=d||"";if(c.css(this[a],"display")==="none"){d=this[a].nodeName;var f;if(na[d])f=na[d];else{var e=c("<"+d+" />").appendTo("body");f=e.css("display");if(f==="none")f="block";e.remove();
|
||||
na[d]=f}c.data(this[a],"olddisplay",f)}}a=0;for(b=this.length;a<b;a++)this[a].style.display=c.data(this[a],"olddisplay")||"";return this}},hide:function(a,b){if(a!=null)return this.animate(L("hide",3),a,b);else{a=0;for(b=this.length;a<b;a++){var d=c.data(this[a],"olddisplay");!d&&d!=="none"&&c.data(this[a],"olddisplay",c.css(this[a],"display"))}a=0;for(b=this.length;a<b;a++)this[a].style.display="none";return this}},_toggle:c.fn.toggle,toggle:function(a,b){var d=typeof a==="boolean";if(c.isFunction(a)&&
|
||||
c.isFunction(b))this._toggle.apply(this,arguments);else a==null||d?this.each(function(){var f=d?a:c(this).is(":hidden");c(this)[f?"show":"hide"]()}):this.animate(L("toggle",3),a,b);return this},fadeTo:function(a,b,d){return this.filter(":hidden").css("opacity",0).show().end().animate({opacity:b},a,d)},animate:function(a,b,d,f){var e=c.speed(b,d,f);if(c.isEmptyObject(a))return this.each(e.complete);return this[e.queue===false?"each":"queue"](function(){var i=c.extend({},e),j,o=this.nodeType===1&&c(this).is(":hidden"),
|
||||
p=this;for(j in a){var n=j.replace(ka,la);if(j!==n){a[n]=a[j];delete a[j];j=n}if(a[j]==="hide"&&o||a[j]==="show"&&!o)return i.complete.call(this);if((j==="height"||j==="width")&&this.style){i.display=c.css(this,"display");i.overflow=this.style.overflow}if(c.isArray(a[j])){(i.specialEasing=i.specialEasing||{})[j]=a[j][1];a[j]=a[j][0]}}if(i.overflow!=null)this.style.overflow="hidden";i.curAnim=c.extend({},a);c.each(a,function(t,z){var B=new c.fx(p,i,t);if(xb.test(z))B[z==="toggle"?o?"show":"hide":z](a);
|
||||
else{var C=yb.exec(z),D=B.cur(true)||0;if(C){z=parseFloat(C[2]);var F=C[3]||"px";if(F!=="px"){p.style[t]=(z||1)+F;D=(z||1)/B.cur(true)*D;p.style[t]=D+F}if(C[1])z=(C[1]==="-="?-1:1)*z+D;B.custom(D,z,F)}else B.custom(D,z,"")}});return true})},stop:function(a,b){var d=c.timers;a&&this.queue([]);this.each(function(){for(var f=d.length-1;f>=0;f--)if(d[f].elem===this){b&&d[f](true);d.splice(f,1)}});b||this.dequeue();return this}});c.each({slideDown:L("show",1),slideUp:L("hide",1),slideToggle:L("toggle",
|
||||
1),fadeIn:{opacity:"show"},fadeOut:{opacity:"hide"}},function(a,b){c.fn[a]=function(d,f){return this.animate(b,d,f)}});c.extend({speed:function(a,b,d){var f=a&&typeof a==="object"?a:{complete:d||!d&&b||c.isFunction(a)&&a,duration:a,easing:d&&b||b&&!c.isFunction(b)&&b};f.duration=c.fx.off?0:typeof f.duration==="number"?f.duration:c.fx.speeds[f.duration]||c.fx.speeds._default;f.old=f.complete;f.complete=function(){f.queue!==false&&c(this).dequeue();c.isFunction(f.old)&&f.old.call(this)};return f},easing:{linear:function(a,
|
||||
b,d,f){return d+f*a},swing:function(a,b,d,f){return(-Math.cos(a*Math.PI)/2+0.5)*f+d}},timers:[],fx:function(a,b,d){this.options=b;this.elem=a;this.prop=d;if(!b.orig)b.orig={}}});c.fx.prototype={update:function(){this.options.step&&this.options.step.call(this.elem,this.now,this);(c.fx.step[this.prop]||c.fx.step._default)(this);if((this.prop==="height"||this.prop==="width")&&this.elem.style)this.elem.style.display="block"},cur:function(a){if(this.elem[this.prop]!=null&&(!this.elem.style||this.elem.style[this.prop]==
|
||||
null))return this.elem[this.prop];return(a=parseFloat(c.css(this.elem,this.prop,a)))&&a>-10000?a:parseFloat(c.curCSS(this.elem,this.prop))||0},custom:function(a,b,d){function f(i){return e.step(i)}this.startTime=K();this.start=a;this.end=b;this.unit=d||this.unit||"px";this.now=this.start;this.pos=this.state=0;var e=this;f.elem=this.elem;if(f()&&c.timers.push(f)&&!Z)Z=setInterval(c.fx.tick,13)},show:function(){this.options.orig[this.prop]=c.style(this.elem,this.prop);this.options.show=true;this.custom(this.prop===
|
||||
"width"||this.prop==="height"?1:0,this.cur());c(this.elem).show()},hide:function(){this.options.orig[this.prop]=c.style(this.elem,this.prop);this.options.hide=true;this.custom(this.cur(),0)},step:function(a){var b=K(),d=true;if(a||b>=this.options.duration+this.startTime){this.now=this.end;this.pos=this.state=1;this.update();this.options.curAnim[this.prop]=true;for(var f in this.options.curAnim)if(this.options.curAnim[f]!==true)d=false;if(d){if(this.options.display!=null){this.elem.style.overflow=
|
||||
this.options.overflow;a=c.data(this.elem,"olddisplay");this.elem.style.display=a?a:this.options.display;if(c.css(this.elem,"display")==="none")this.elem.style.display="block"}this.options.hide&&c(this.elem).hide();if(this.options.hide||this.options.show)for(var e in this.options.curAnim)c.style(this.elem,e,this.options.orig[e]);this.options.complete.call(this.elem)}return false}else{e=b-this.startTime;this.state=e/this.options.duration;a=this.options.easing||(c.easing.swing?"swing":"linear");this.pos=
|
||||
c.easing[this.options.specialEasing&&this.options.specialEasing[this.prop]||a](this.state,e,0,1,this.options.duration);this.now=this.start+(this.end-this.start)*this.pos;this.update()}return true}};c.extend(c.fx,{tick:function(){for(var a=c.timers,b=0;b<a.length;b++)a[b]()||a.splice(b--,1);a.length||c.fx.stop()},stop:function(){clearInterval(Z);Z=null},speeds:{slow:600,fast:200,_default:400},step:{opacity:function(a){c.style(a.elem,"opacity",a.now)},_default:function(a){if(a.elem.style&&a.elem.style[a.prop]!=
|
||||
null)a.elem.style[a.prop]=(a.prop==="width"||a.prop==="height"?Math.max(0,a.now):a.now)+a.unit;else a.elem[a.prop]=a.now}}});if(c.expr&&c.expr.filters)c.expr.filters.animated=function(a){return c.grep(c.timers,function(b){return a===b.elem}).length};c.fn.offset="getBoundingClientRect"in s.documentElement?function(a){var b=this[0];if(!b||!b.ownerDocument)return null;if(a)return this.each(function(e){c.offset.setOffset(this,a,e)});if(b===b.ownerDocument.body)return c.offset.bodyOffset(b);var d=b.getBoundingClientRect(),
|
||||
f=b.ownerDocument;b=f.body;f=f.documentElement;return{top:d.top+(self.pageYOffset||c.support.boxModel&&f.scrollTop||b.scrollTop)-(f.clientTop||b.clientTop||0),left:d.left+(self.pageXOffset||c.support.boxModel&&f.scrollLeft||b.scrollLeft)-(f.clientLeft||b.clientLeft||0)}}:function(a){var b=this[0];if(!b||!b.ownerDocument)return null;if(a)return this.each(function(t){c.offset.setOffset(this,a,t)});if(b===b.ownerDocument.body)return c.offset.bodyOffset(b);c.offset.initialize();var d=b.offsetParent,f=
|
||||
b,e=b.ownerDocument,i,j=e.documentElement,o=e.body;f=(e=e.defaultView)?e.getComputedStyle(b,null):b.currentStyle;for(var p=b.offsetTop,n=b.offsetLeft;(b=b.parentNode)&&b!==o&&b!==j;){if(c.offset.supportsFixedPosition&&f.position==="fixed")break;i=e?e.getComputedStyle(b,null):b.currentStyle;p-=b.scrollTop;n-=b.scrollLeft;if(b===d){p+=b.offsetTop;n+=b.offsetLeft;if(c.offset.doesNotAddBorder&&!(c.offset.doesAddBorderForTableAndCells&&/^t(able|d|h)$/i.test(b.nodeName))){p+=parseFloat(i.borderTopWidth)||
|
||||
0;n+=parseFloat(i.borderLeftWidth)||0}f=d;d=b.offsetParent}if(c.offset.subtractsBorderForOverflowNotVisible&&i.overflow!=="visible"){p+=parseFloat(i.borderTopWidth)||0;n+=parseFloat(i.borderLeftWidth)||0}f=i}if(f.position==="relative"||f.position==="static"){p+=o.offsetTop;n+=o.offsetLeft}if(c.offset.supportsFixedPosition&&f.position==="fixed"){p+=Math.max(j.scrollTop,o.scrollTop);n+=Math.max(j.scrollLeft,o.scrollLeft)}return{top:p,left:n}};c.offset={initialize:function(){var a=s.body,b=s.createElement("div"),
|
||||
d,f,e,i=parseFloat(c.curCSS(a,"marginTop",true))||0;c.extend(b.style,{position:"absolute",top:0,left:0,margin:0,border:0,width:"1px",height:"1px",visibility:"hidden"});b.innerHTML="<div style='position:absolute;top:0;left:0;margin:0;border:5px solid #000;padding:0;width:1px;height:1px;'><div></div></div><table style='position:absolute;top:0;left:0;margin:0;border:5px solid #000;padding:0;width:1px;height:1px;' cellpadding='0' cellspacing='0'><tr><td></td></tr></table>";a.insertBefore(b,a.firstChild);
|
||||
d=b.firstChild;f=d.firstChild;e=d.nextSibling.firstChild.firstChild;this.doesNotAddBorder=f.offsetTop!==5;this.doesAddBorderForTableAndCells=e.offsetTop===5;f.style.position="fixed";f.style.top="20px";this.supportsFixedPosition=f.offsetTop===20||f.offsetTop===15;f.style.position=f.style.top="";d.style.overflow="hidden";d.style.position="relative";this.subtractsBorderForOverflowNotVisible=f.offsetTop===-5;this.doesNotIncludeMarginInBodyOffset=a.offsetTop!==i;a.removeChild(b);c.offset.initialize=c.noop},
|
||||
bodyOffset:function(a){var b=a.offsetTop,d=a.offsetLeft;c.offset.initialize();if(c.offset.doesNotIncludeMarginInBodyOffset){b+=parseFloat(c.curCSS(a,"marginTop",true))||0;d+=parseFloat(c.curCSS(a,"marginLeft",true))||0}return{top:b,left:d}},setOffset:function(a,b,d){if(/static/.test(c.curCSS(a,"position")))a.style.position="relative";var f=c(a),e=f.offset(),i=parseInt(c.curCSS(a,"top",true),10)||0,j=parseInt(c.curCSS(a,"left",true),10)||0;if(c.isFunction(b))b=b.call(a,d,e);d={top:b.top-e.top+i,left:b.left-
|
||||
e.left+j};"using"in b?b.using.call(a,d):f.css(d)}};c.fn.extend({position:function(){if(!this[0])return null;var a=this[0],b=this.offsetParent(),d=this.offset(),f=/^body|html$/i.test(b[0].nodeName)?{top:0,left:0}:b.offset();d.top-=parseFloat(c.curCSS(a,"marginTop",true))||0;d.left-=parseFloat(c.curCSS(a,"marginLeft",true))||0;f.top+=parseFloat(c.curCSS(b[0],"borderTopWidth",true))||0;f.left+=parseFloat(c.curCSS(b[0],"borderLeftWidth",true))||0;return{top:d.top-f.top,left:d.left-f.left}},offsetParent:function(){return this.map(function(){for(var a=
|
||||
this.offsetParent||s.body;a&&!/^body|html$/i.test(a.nodeName)&&c.css(a,"position")==="static";)a=a.offsetParent;return a})}});c.each(["Left","Top"],function(a,b){var d="scroll"+b;c.fn[d]=function(f){var e=this[0],i;if(!e)return null;if(f!==w)return this.each(function(){if(i=wa(this))i.scrollTo(!a?f:c(i).scrollLeft(),a?f:c(i).scrollTop());else this[d]=f});else return(i=wa(e))?"pageXOffset"in i?i[a?"pageYOffset":"pageXOffset"]:c.support.boxModel&&i.document.documentElement[d]||i.document.body[d]:e[d]}});
|
||||
c.each(["Height","Width"],function(a,b){var d=b.toLowerCase();c.fn["inner"+b]=function(){return this[0]?c.css(this[0],d,false,"padding"):null};c.fn["outer"+b]=function(f){return this[0]?c.css(this[0],d,false,f?"margin":"border"):null};c.fn[d]=function(f){var e=this[0];if(!e)return f==null?null:this;return"scrollTo"in e&&e.document?e.document.compatMode==="CSS1Compat"&&e.document.documentElement["client"+b]||e.document.body["client"+b]:e.nodeType===9?Math.max(e.documentElement["client"+b],e.body["scroll"+
|
||||
b],e.documentElement["scroll"+b],e.body["offset"+b],e.documentElement["offset"+b]):f===w?c.css(e,d):this.css(d,typeof f==="string"?f:f+"px")}});A.jQuery=A.$=c})(window);
|
||||
@@ -1,39 +0,0 @@
|
||||
/*=============================================================================
|
||||
Copyright 2002 William E. Kempf
|
||||
Distributed under the Boost Software License, Version 1.0. (See accompany-
|
||||
ing file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
|
||||
=============================================================================*/
|
||||
|
||||
H1
|
||||
{
|
||||
FONT-SIZE: 200%;
|
||||
COLOR: #00008B;
|
||||
}
|
||||
H2
|
||||
{
|
||||
FONT-SIZE: 150%;
|
||||
}
|
||||
H3
|
||||
{
|
||||
FONT-SIZE: 125%;
|
||||
}
|
||||
H4
|
||||
{
|
||||
FONT-SIZE: 108%;
|
||||
}
|
||||
/*
|
||||
BODY
|
||||
{
|
||||
FONT-SIZE: 100%;
|
||||
BACKGROUND-COLOR: #ffffff;
|
||||
COLOR: #000000;
|
||||
}
|
||||
*/
|
||||
/*
|
||||
PRE
|
||||
{
|
||||
MARGIN-LEFT: 2em;
|
||||
FONT-FAMILY: Courier,
|
||||
monospace;
|
||||
}
|
||||
*/
|
||||
@@ -1,92 +0,0 @@
|
||||
|
||||
body
|
||||
{
|
||||
font-size: 12pt;
|
||||
}
|
||||
|
||||
pre
|
||||
{
|
||||
border-right: gray 1pt solid;
|
||||
border-top: gray 1pt solid;
|
||||
border-left: gray 1pt solid;
|
||||
border-bottom: gray 1pt solid;
|
||||
margin-left: 0pt;
|
||||
background-color: #EEEEEE;
|
||||
font-size: smaller;
|
||||
}
|
||||
|
||||
.button
|
||||
{
|
||||
color : black;
|
||||
background-color : #FFFFFF;
|
||||
border-radius: 0px;
|
||||
border: outset 3px #d6d6d6;
|
||||
text-decoration : none;
|
||||
outline:none;
|
||||
}
|
||||
|
||||
.fs
|
||||
{
|
||||
font-family: courier;
|
||||
font-size: 11pt;
|
||||
font-weight: bold;
|
||||
color: maroon;
|
||||
}
|
||||
|
||||
.code_string
|
||||
{
|
||||
font-family: courier;
|
||||
font-size: 11pt;
|
||||
font-weight: bold;
|
||||
color: #bc8f8f;
|
||||
}
|
||||
|
||||
.code
|
||||
{
|
||||
/*
|
||||
top: 0;
|
||||
border-style: inset;
|
||||
margin-top: 5pt;
|
||||
margin-bottom: 5pt;
|
||||
margin-left: 5pt;
|
||||
margin-right: 5pt;
|
||||
border-width: 2px 2px 2px 2px ;
|
||||
*/
|
||||
font-family: courier;
|
||||
font-size: 11pt;
|
||||
font-weight: bold;
|
||||
color: #228b22;
|
||||
}
|
||||
|
||||
.byte
|
||||
{
|
||||
border-right: gray 1pt solid;
|
||||
border-top: gray 1pt solid;
|
||||
border-left: gray 1pt solid;
|
||||
border-bottom: gray 1pt solid;
|
||||
margin-left: 2pt;
|
||||
margin-right: 2pt;
|
||||
font-family: courier;
|
||||
font-size: 11pt;
|
||||
font-weight: bold;
|
||||
color: #000000;
|
||||
background-color: #eeeeee;
|
||||
}
|
||||
|
||||
#pre
|
||||
{
|
||||
border-right: gray 1pt solid;
|
||||
border-top: gray 1pt solid;
|
||||
border-left: gray 1pt solid;
|
||||
border-bottom: gray 1pt solid;
|
||||
margin-left: 1pt;
|
||||
margin-right: 1pt;
|
||||
background-color: #EEEEEE;
|
||||
}
|
||||
|
||||
/*
|
||||
(C) Copyright 2011 François Mauger.
|
||||
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)
|
||||
*/
|
||||
File diff suppressed because it is too large
Load Diff
+2
-2
@@ -29,7 +29,7 @@ http://www.boost.org/LICENSE_1_0.txt)
|
||||
C++ includes the operator <code style="white-space: normal">dynamic_cast<T>(U * u)</code>
|
||||
for casting a pointer at runtime between two related types. However, this can only be
|
||||
used for polymorphic classes. That is, it can only be used with related classes which have at least one virtual function.
|
||||
Limiting the serializaton of pointers to only such classes would diminish the applicability
|
||||
Limiting the serializaton of pointers to only such class would diminish the applicability
|
||||
of the library.
|
||||
|
||||
<h3>Usage</h3>
|
||||
@@ -46,7 +46,7 @@ const void_cast_detail::void_caster &
|
||||
void_cast_register(
|
||||
Derived const * derived = NULL,
|
||||
Base * const base = NULL
|
||||
);
|
||||
)
|
||||
</code></pre></h4></dt>
|
||||
<dd>
|
||||
This function "registers" a pair of related types. It stores the fact that
|
||||
|
||||
+4
-4
@@ -43,7 +43,7 @@ the <A href="traits.html#wrappers"><code>is_wrapper</code></a> trait for
|
||||
these wrapper classes is set to true.
|
||||
|
||||
<h3><a name="binaryobjects">Binary Objects</a></h3>
|
||||
A binary object is just a sequence of bytes stored as raw
|
||||
A binary object is just an sequence of bytes stored as raw
|
||||
binary data. This would most likely be used for a large amount
|
||||
of "light weight" data such as a pixel map or embedded binary file.
|
||||
The header file
|
||||
@@ -59,7 +59,7 @@ which will construct a temporary binary object that can be serialized just like
|
||||
Its default serialization is to use archive class primitives
|
||||
<code style="white-space: normal">save_binary</code> and <code>load_binary</code>.
|
||||
Note that it doesn't allocated any storage or create any objects.
|
||||
Its sole purpose is to pass the data size and address as a pair to the archive class.
|
||||
Its sole purpose is to pass the data size and address as pair to the archive class.
|
||||
|
||||
|
||||
<h3><a name="arrays">Arrays</a></h3>
|
||||
@@ -91,7 +91,7 @@ public:
|
||||
};
|
||||
</code></pre>
|
||||
that can be serialized just like any other object.
|
||||
Its default serialization is to serialize each array element.
|
||||
Its default serialization is to use serialize each array element.
|
||||
Note that it doesn't allocated any storage or create any objects.
|
||||
Its sole purpose is to pass the data type, size and address to the archive class.
|
||||
|
||||
@@ -171,7 +171,7 @@ xml_oarchive & operator&(const boost::serialization::nvp<T> & t)
|
||||
}
|
||||
</code></pre>
|
||||
The most obvious and convient name to assign to as the XML data item name
|
||||
is - surprise! - the name of the C++ class data member. So our serialization
|
||||
is - surpise! - the name of the C++ class data member. So our serialization
|
||||
code will look like:
|
||||
<pre><code>
|
||||
ar & make_nvp("my_variable", my_variable);
|
||||
|
||||
+39
-24
@@ -11,32 +11,47 @@ project libs/serialization/example
|
||||
: requirements <library>../build//boost_serialization
|
||||
;
|
||||
|
||||
import ../util/test :
|
||||
run-template
|
||||
run-invoke
|
||||
run-winvoke
|
||||
test-bsl-run-no-lib
|
||||
test-bsl-run
|
||||
test-bsl-run_archive
|
||||
test-bsl-run_files
|
||||
test-bsl-run_polymorphic_archive
|
||||
;
|
||||
rule demo_bsl_run ( demo-name : othersources * : requirements * )
|
||||
{
|
||||
return [ run
|
||||
# sources
|
||||
$(demo-name).cpp
|
||||
$(othersources).cpp
|
||||
: # command
|
||||
: # input files
|
||||
: # requirements
|
||||
# toolset suppress-warnings
|
||||
<toolset>gcc:<cxxflags>"-Wno-non-virtual-dtor -Wno-ctor-dtor-privacy"
|
||||
<toolset>msvc-8.0:<cxxflags>"-wd4996"
|
||||
<toolset>borland:<cxxflags>"-w-8080 -w-8071 -w-8057 -w-8062 -w-8008 -w-0018 -w-8066"
|
||||
# toolset optimizations
|
||||
<toolset>gcc:<cxxflags>"-ftemplate-depth-255"
|
||||
<toolset>msvc:<cxxflags>"-Gy"
|
||||
# toolset shared library support
|
||||
<toolset>como,<runtime-link>shared:<build>no
|
||||
<toolset>msvc,<stdlib>stlport,<runtime-link>shared:<build>no
|
||||
<toolset>cw,<runtime-link>static:<build>no
|
||||
$(requirements)
|
||||
: # test name
|
||||
$(demo-name)
|
||||
]
|
||||
;
|
||||
}
|
||||
|
||||
test-suite "demo-suite" :
|
||||
# demos
|
||||
[ test-bsl-run demo ]
|
||||
[ test-bsl-run demo_auto_ptr ]
|
||||
[ test-bsl-run demo_exception ]
|
||||
[ test-bsl-run demo_fast_archive ]
|
||||
[ test-bsl-run demo_log : log_archive ]
|
||||
[ test-bsl-run demo_pimpl : demo_pimpl_A ]
|
||||
[ test-bsl-run demo_polymorphic : demo_polymorphic_A ]
|
||||
[ test-bsl-run demo_portable_archive : portable_binary_iarchive portable_binary_oarchive ]
|
||||
[ test-bsl-run demo_shared_ptr ]
|
||||
[ test-bsl-run demo_simple_log ]
|
||||
[ test-bsl-run demo_trivial_archive ]
|
||||
[ test-bsl-run demo_xml ]
|
||||
[ test-bsl-run demo_xml_save ]
|
||||
[ test-bsl-run demo_xml_load : : : <dependency>demo_xml_save ]
|
||||
[ demo_bsl_run demo ]
|
||||
[ demo_bsl_run demo_auto_ptr ]
|
||||
[ demo_bsl_run demo_exception ]
|
||||
[ demo_bsl_run demo_log : log_archive ]
|
||||
[ demo_bsl_run demo_pimpl : demo_pimpl_A ]
|
||||
[ demo_bsl_run demo_polymorphic : demo_polymorphic_A ]
|
||||
[ demo_bsl_run demo_portable_archive : portable_binary_iarchive portable_binary_oarchive ]
|
||||
[ demo_bsl_run demo_shared_ptr ]
|
||||
[ demo_bsl_run demo_simple_log ]
|
||||
[ demo_bsl_run demo_trivial_archive ]
|
||||
[ demo_bsl_run demo_xml ]
|
||||
[ demo_bsl_run demo_xml_save ]
|
||||
[ demo_bsl_run demo_xml_load : : <dependency>demo_xml_save ]
|
||||
;
|
||||
|
||||
|
||||
@@ -1,5 +1,5 @@
|
||||
/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
|
||||
// test_forward_list.cpp
|
||||
// test_derived_class.cpp
|
||||
|
||||
// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
|
||||
// Use, modification and distribution is subject to the Boost Software
|
||||
@@ -10,42 +10,41 @@
|
||||
|
||||
#include <cstddef> // NULL
|
||||
#include <fstream>
|
||||
|
||||
#include <cstdio> // remove
|
||||
#include <boost/config.hpp>
|
||||
#if defined(BOOST_NO_STDC_NAMESPACE)
|
||||
namespace std{
|
||||
using ::remove;
|
||||
}
|
||||
#endif
|
||||
|
||||
#include <boost/config.hpp>
|
||||
#include <boost/serialization/forward_list.hpp>
|
||||
|
||||
#include <boost/archive/archive_exception.hpp>
|
||||
#include "test_tools.hpp"
|
||||
|
||||
#include "A.hpp"
|
||||
#include "B.hpp"
|
||||
#include "A.ipp"
|
||||
|
||||
int test_main( int /* argc */, char* /* argv */[] )
|
||||
int test_main( int argc, char* argv[] )
|
||||
{
|
||||
const char * testfile = boost::archive::tmpnam(NULL);
|
||||
std::forward_list<A> aslist;
|
||||
aslist.push_front(A());
|
||||
aslist.push_front(A());
|
||||
const char * testfile = boost::archive::tmpnam(NULL);
|
||||
|
||||
BOOST_REQUIRE(NULL != testfile);
|
||||
|
||||
B b, b1;
|
||||
|
||||
{
|
||||
test_ostream os(testfile, TEST_STREAM_FLAGS);
|
||||
test_oarchive oa(os, TEST_ARCHIVE_FLAGS);
|
||||
oa << boost::serialization::make_nvp("aslist", aslist);
|
||||
oa << boost::serialization::make_nvp("b", b);
|
||||
}
|
||||
std::forward_list<A> aslist1;{
|
||||
{
|
||||
test_istream is(testfile, TEST_STREAM_FLAGS);
|
||||
test_iarchive ia(is, TEST_ARCHIVE_FLAGS);
|
||||
ia >> boost::serialization::make_nvp("aslist", aslist1);
|
||||
ia >> boost::serialization::make_nvp("b1", b1);
|
||||
}
|
||||
BOOST_CHECK(aslist == aslist1);
|
||||
BOOST_CHECK(b == b1);
|
||||
std::remove(testfile);
|
||||
return EXIT_SUCCESS;
|
||||
}
|
||||
|
||||
// EOF
|
||||
|
||||
@@ -2,7 +2,7 @@
|
||||
#define BOOST_SERIALIZATION_TEST_A_HPP
|
||||
|
||||
// MS compatible compilers support #pragma once
|
||||
#if defined(_MSC_VER)
|
||||
#if defined(_MSC_VER) && (_MSC_VER >= 1020)
|
||||
# pragma once
|
||||
#endif
|
||||
|
||||
@@ -20,7 +20,6 @@
|
||||
#include <cstdlib> // for rand()
|
||||
#include <cmath> // for fabs()
|
||||
#include <cstddef> // size_t
|
||||
#include <boost/math/special_functions/next.hpp>
|
||||
|
||||
#include <boost/config.hpp>
|
||||
#if defined(BOOST_NO_STDC_NAMESPACE)
|
||||
@@ -246,9 +245,13 @@ inline bool A::operator==(const A &rhs) const
|
||||
return false;
|
||||
if(v != rhs.v)
|
||||
return false;
|
||||
if(std::abs( boost::math::float_distance(w, rhs.w)) > 1)
|
||||
if(w == 0 && std::fabs(rhs.w) > std::numeric_limits<float>::epsilon())
|
||||
return false;
|
||||
if(std::abs( boost::math::float_distance(x, rhs.x)) > 1)
|
||||
if(std::fabs(rhs.w/w - 1.0) > std::numeric_limits<float>::epsilon())
|
||||
return false;
|
||||
if(x == 0 && std::fabs(rhs.x - x) > std::numeric_limits<float>::epsilon())
|
||||
return false;
|
||||
if(std::fabs(rhs.x/x - 1.0) > std::numeric_limits<float>::epsilon())
|
||||
return false;
|
||||
if(0 != y.compare(rhs.y))
|
||||
return false;
|
||||
|
||||
@@ -2,7 +2,7 @@
|
||||
#define BOOST_SERIALIZATION_TEST_A_HPP
|
||||
|
||||
// MS compatible compilers support #pragma once
|
||||
#if defined(_MSC_VER)
|
||||
#if defined(_MSC_VER) && (_MSC_VER >= 1020)
|
||||
# pragma once
|
||||
#endif
|
||||
|
||||
@@ -244,10 +244,14 @@ inline bool A::operator==(const A &rhs) const
|
||||
if(u != rhs.u)
|
||||
return false;
|
||||
if(v != rhs.v)
|
||||
return false;
|
||||
if(w == 0 && std::fabs(rhs.w) > std::numeric_limits<float>::epsilon())
|
||||
return false;
|
||||
if(std::abs( boost::math::float_distance(w, rhs.w)) > 1)
|
||||
if(std::fabs(rhs.w/w - 1.0) > std::numeric_limits<float>::epsilon())
|
||||
return false;
|
||||
if(std::abs( boost::math::float_distance(x, rhs.x)) > 1)
|
||||
if(x == 0 && std::fabs(rhs.x - x) > std::numeric_limits<float>::epsilon())
|
||||
return false;
|
||||
if(std::fabs(rhs.x/x - 1.0) > std::numeric_limits<float>::epsilon())
|
||||
return false;
|
||||
if(0 != y.compare(rhs.y))
|
||||
return false;
|
||||
|
||||
@@ -2,7 +2,7 @@
|
||||
#define BOOST_SERIALIZATION_TEST_B_HPP
|
||||
|
||||
// MS compatible compilers support #pragma once
|
||||
#if defined(_MSC_VER)
|
||||
#if defined(_MSC_VER) && (_MSC_VER >= 1020)
|
||||
# pragma once
|
||||
#endif
|
||||
|
||||
@@ -17,7 +17,6 @@
|
||||
// See http://www.boost.org for updates, documentation, and revision history.
|
||||
|
||||
#include <cstdlib> // for rand()
|
||||
#include <boost/math/special_functions/next.hpp>
|
||||
|
||||
#include <boost/config.hpp>
|
||||
#if defined(BOOST_NO_STDC_NAMESPACE)
|
||||
@@ -105,8 +104,8 @@ inline bool B::operator==(const B &rhs) const
|
||||
&& t == rhs.t
|
||||
&& u == rhs.u
|
||||
&& v == rhs.v
|
||||
&& std::abs( boost::math::float_distance(w, rhs.w)) < 2
|
||||
&& std::abs( boost::math::float_distance(x, rhs.x)) < 2
|
||||
&& std::fabs(w - rhs.w) <= std::numeric_limits<float>::round_error()
|
||||
&& std::fabs(x - rhs.x) <= std::numeric_limits<float>::round_error()
|
||||
;
|
||||
}
|
||||
|
||||
|
||||
@@ -2,7 +2,7 @@
|
||||
#define BOOST_SERIALIZATION_TEST_B_HPP
|
||||
|
||||
// MS compatible compilers support #pragma once
|
||||
#if defined(_MSC_VER)
|
||||
#if defined(_MSC_VER) && (_MSC_VER >= 1020)
|
||||
# pragma once
|
||||
#endif
|
||||
|
||||
@@ -104,8 +104,8 @@ inline bool B::operator==(const B &rhs) const
|
||||
&& t == rhs.t
|
||||
&& u == rhs.u
|
||||
&& v == rhs.v
|
||||
&& std::abs( boost::math::float_distance(w, rhs.w)) < 2
|
||||
&& std::abs( boost::math::float_distance(x, rhs.x)) < 2
|
||||
&& std::fabs(w - rhs.w) <= std::numeric_limits<float>::round_error()
|
||||
&& std::fabs(x - rhs.x) <= std::numeric_limits<float>::round_error()
|
||||
;
|
||||
}
|
||||
|
||||
|
||||
@@ -11,6 +11,7 @@
|
||||
|
||||
#include <boost/static_assert.hpp>
|
||||
#include <boost/type_traits/is_array.hpp>
|
||||
#include <boost/serialization/pfto.hpp>
|
||||
|
||||
#define BOOST_ARCHIVE_SOURCE
|
||||
#include <boost/archive/binary_oarchive_impl.hpp>
|
||||
@@ -60,26 +61,26 @@ public:
|
||||
// binary_oarchive_impl<derived_t>::load_override;
|
||||
// so we use the sure-fire method below. This failed to work as well
|
||||
template<class T>
|
||||
void save_override(T & t){
|
||||
base_t::save_override(t);
|
||||
void save_override(T & t, BOOST_PFTO int){
|
||||
base_t::save_override(t, 0);
|
||||
// verify that this program is in fact working by making sure
|
||||
// that arrays are getting passed here
|
||||
BOOST_STATIC_ASSERT(! (boost::is_array<T>::value) );
|
||||
}
|
||||
template<int N>
|
||||
void save_override(const int (& t)[N]){
|
||||
void save_override(const int (& t)[N] , int){
|
||||
save_binary(t, sizeof(t));
|
||||
}
|
||||
template<int N>
|
||||
void save_override(const unsigned int (& t)[N]){
|
||||
void save_override(const unsigned int (& t)[N], int){
|
||||
save_binary(t, sizeof(t));
|
||||
}
|
||||
template<int N>
|
||||
void save_override(const long (& t)[N]){
|
||||
void save_override(const long (& t)[N], int){
|
||||
save_binary(t, sizeof(t));
|
||||
}
|
||||
template<int N>
|
||||
void save_override(const unsigned long (& t)[N]){
|
||||
void save_override(const unsigned long (& t)[N], int){
|
||||
save_binary(t, sizeof(t));
|
||||
}
|
||||
public:
|
||||
@@ -128,24 +129,24 @@ public:
|
||||
// binary_oarchive_impl<derived_t>::load_override;
|
||||
// so we use the sure-fire method below. This failed to work as well
|
||||
template<class T>
|
||||
void load_override(T & t){
|
||||
base_t::load_override(t);
|
||||
void load_override(T & t, BOOST_PFTO int){
|
||||
base_t::load_override(t, 0);
|
||||
BOOST_STATIC_ASSERT(! (boost::is_array<T>::value) );
|
||||
}
|
||||
template<int N>
|
||||
void load_override(int (& t)[N]){
|
||||
void load_override(int (& t)[N], int){
|
||||
load_binary(t, sizeof(t));
|
||||
}
|
||||
template<int N>
|
||||
void load_override(unsigned int (& t)[N]){
|
||||
void load_override(unsigned int (& t)[N], int){
|
||||
load_binary(t, sizeof(t));
|
||||
}
|
||||
template<int N>
|
||||
void load_override(long (& t)[N]){
|
||||
void load_override(long (& t)[N], int){
|
||||
load_binary(t, sizeof(t));
|
||||
}
|
||||
template<int N>
|
||||
void load_override(unsigned long (& t)[N]){
|
||||
void load_override(unsigned long (& t)[N], int){
|
||||
load_binary(t, sizeof(t));
|
||||
}
|
||||
public:
|
||||
|
||||
@@ -13,7 +13,8 @@
|
||||
#include "demo_gps.hpp"
|
||||
#include "log_archive.hpp"
|
||||
|
||||
int main(int argc, char *argv[]){
|
||||
int main(int argc, char *argv[])
|
||||
{
|
||||
// make the schedule
|
||||
bus_schedule schedule;
|
||||
|
||||
@@ -64,7 +65,7 @@ int main(int argc, char *argv[]){
|
||||
|
||||
// display the complete schedule
|
||||
log_archive oa(std::cout);
|
||||
oa << BOOST_SERIALIZATION_NVP(schedule);
|
||||
//oa << BOOST_SERIALIZATION_NVP(schedule);
|
||||
oa << schedule;
|
||||
|
||||
delete bs0;
|
||||
@@ -73,4 +74,3 @@ int main(int argc, char *argv[]){
|
||||
delete bs3;
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
+17
-22
@@ -2,7 +2,7 @@
|
||||
#define LOG_ARCHIVE_HPP
|
||||
|
||||
// MS compatible compilers support #pragma once
|
||||
#if defined(_MSC_VER)
|
||||
#if defined(_MSC_VER) && (_MSC_VER >= 1020)
|
||||
# pragma once
|
||||
#endif
|
||||
|
||||
@@ -18,14 +18,6 @@
|
||||
|
||||
#include <boost/archive/xml_oarchive.hpp>
|
||||
|
||||
namespace boost {
|
||||
namespace archive {
|
||||
namespace detail {
|
||||
template<class Archive> class interface_oarchive;
|
||||
} // namespace detail
|
||||
} // namespace archive
|
||||
} // boost
|
||||
|
||||
/////////////////////////////////////////////////////////////////////////
|
||||
// log data to an output stream. This illustrates a simpler implemenation
|
||||
// of text output which is useful for getting a formatted display of
|
||||
@@ -44,31 +36,34 @@ class log_archive :
|
||||
// Override functions defined in basic_xml_oarchive
|
||||
|
||||
// Anything not an attribute and not a name-value pair is an
|
||||
// error and should be trapped here.
|
||||
// error and should be trapped here. Note the usage of
|
||||
// function argument matching (BOOST_PFTO) to permit usage
|
||||
// with compilers which fail to properly support
|
||||
// function template ordering
|
||||
template<class T>
|
||||
void save_override(T & t){
|
||||
void save_override(T & t, BOOST_PFTO int){
|
||||
// make it a name-value pair and pass it on.
|
||||
// this permits this to be used even with data types which
|
||||
// are not wrapped with the name
|
||||
base::save_override(boost::serialization::make_nvp(NULL, t));
|
||||
base::save_override(boost::serialization::make_nvp(NULL, t), 0);
|
||||
}
|
||||
template<class T>
|
||||
void save_override(const boost::serialization::nvp< T > & t){
|
||||
void save_override(const boost::serialization::nvp< T > & t, int){
|
||||
// this is here to remove the "const" requirement. Since
|
||||
// this class is to be used only for output, it's not required.
|
||||
base::save_override(t);
|
||||
base::save_override(t, 0);
|
||||
}
|
||||
// specific overrides for attributes - not name value pairs so we
|
||||
// want to trap them before the above "fall through"
|
||||
// since we don't want to see these in the output - make them no-ops.
|
||||
void save_override(const boost::archive::object_id_type & t){}
|
||||
void save_override(const boost::archive::object_reference_type & t){}
|
||||
void save_override(const boost::archive::version_type & t){}
|
||||
void save_override(const boost::archive::class_id_type & t){}
|
||||
void save_override(const boost::archive::class_id_optional_type & t){}
|
||||
void save_override(const boost::archive::class_id_reference_type & t){}
|
||||
void save_override(const boost::archive::class_name_type & t){}
|
||||
void save_override(const boost::archive::tracking_type & t){}
|
||||
void save_override(const boost::archive::object_id_type & t, int){}
|
||||
void save_override(const boost::archive::object_reference_type & t, int){}
|
||||
void save_override(const boost::archive::version_type & t, int){}
|
||||
void save_override(const boost::archive::class_id_type & t, int){}
|
||||
void save_override(const boost::archive::class_id_optional_type & t, int){}
|
||||
void save_override(const boost::archive::class_id_reference_type & t, int){}
|
||||
void save_override(const boost::archive::class_name_type & t, int){}
|
||||
void save_override(const boost::archive::tracking_type & t, int){}
|
||||
public:
|
||||
log_archive(std::ostream & os, unsigned int flags = 0) :
|
||||
boost::archive::xml_oarchive_impl<log_archive>(
|
||||
|
||||
@@ -2,7 +2,7 @@
|
||||
#define BOOST_ARCHIVE_POLYMORPHIC_PORTABLE_BINARY_IARCHIVE_HPP
|
||||
|
||||
// MS compatible compilers support #pragma once
|
||||
#if defined(_MSC_VER)
|
||||
#if defined(_MSC_VER) && (_MSC_VER >= 1020)
|
||||
# pragma once
|
||||
#endif
|
||||
|
||||
|
||||
@@ -2,7 +2,7 @@
|
||||
#define BOOST_ARCHIVE_POLYMORPHIC_PORTABLE_BINARY_OARCHIVE_HPP
|
||||
|
||||
// MS compatible compilers support #pragma once
|
||||
#if defined(_MSC_VER)
|
||||
#if defined(_MSC_VER) && (_MSC_VER >= 1020)
|
||||
# pragma once
|
||||
#endif
|
||||
|
||||
|
||||
@@ -7,12 +7,13 @@
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
// MS compatible compilers support #pragma once
|
||||
#if defined(_MSC_VER)
|
||||
#if defined(_MSC_VER) && (_MSC_VER >= 1020)
|
||||
# pragma once
|
||||
#endif
|
||||
|
||||
#include <boost/config.hpp>
|
||||
#include <boost/cstdint.hpp>
|
||||
#include <boost/serialization/pfto.hpp>
|
||||
#include <boost/static_assert.hpp>
|
||||
|
||||
#include <climits>
|
||||
|
||||
@@ -47,7 +47,7 @@ portable_binary_iarchive::load_impl(boost::intmax_t & l, char maxsize){
|
||||
#else
|
||||
if(m_flags & endian_big)
|
||||
#endif
|
||||
reverse_bytes(size, cptr);
|
||||
reverse_bytes(size, cptr);
|
||||
|
||||
if(negative)
|
||||
l = -l;
|
||||
@@ -55,11 +55,11 @@ portable_binary_iarchive::load_impl(boost::intmax_t & l, char maxsize){
|
||||
|
||||
void
|
||||
portable_binary_iarchive::load_override(
|
||||
boost::archive::class_name_type & t
|
||||
boost::archive::class_name_type & t, int
|
||||
){
|
||||
std::string cn;
|
||||
cn.reserve(BOOST_SERIALIZATION_MAX_KEY_SIZE);
|
||||
load_override(cn);
|
||||
load_override(cn, 0);
|
||||
if(cn.size() > (BOOST_SERIALIZATION_MAX_KEY_SIZE - 1))
|
||||
boost::serialization::throw_exception(
|
||||
boost::archive::archive_exception(
|
||||
|
||||
@@ -2,7 +2,7 @@
|
||||
#define PORTABLE_BINARY_IARCHIVE_HPP
|
||||
|
||||
// MS compatible compilers support #pragma once
|
||||
#if defined(_MSC_VER)
|
||||
#if defined(_MSC_VER) && (_MSC_VER >= 1020)
|
||||
# pragma once
|
||||
#endif
|
||||
|
||||
@@ -27,6 +27,7 @@
|
||||
#include <boost/archive/archive_exception.hpp>
|
||||
#include <boost/archive/basic_binary_iprimitive.hpp>
|
||||
#include <boost/archive/detail/common_iarchive.hpp>
|
||||
#include <boost/archive/shared_ptr_helper.hpp>
|
||||
#include <boost/archive/detail/register_archive.hpp>
|
||||
|
||||
#include "portable_binary_archive.hpp"
|
||||
@@ -35,20 +36,19 @@
|
||||
// exception to be thrown if integer read from archive doesn't fit
|
||||
// variable being loaded
|
||||
class portable_binary_iarchive_exception :
|
||||
public boost::archive::archive_exception
|
||||
public virtual boost::archive::archive_exception
|
||||
{
|
||||
public:
|
||||
enum exception_code {
|
||||
incompatible_integer_size
|
||||
} m_exception_code ;
|
||||
typedef enum {
|
||||
incompatible_integer_size
|
||||
} exception_code;
|
||||
portable_binary_iarchive_exception(exception_code c = incompatible_integer_size ) :
|
||||
boost::archive::archive_exception(boost::archive::archive_exception::other_exception),
|
||||
m_exception_code(c)
|
||||
boost::archive::archive_exception(boost::archive::archive_exception::other_exception)
|
||||
{}
|
||||
virtual const char *what( ) const throw( )
|
||||
{
|
||||
const char *msg = "programmer error";
|
||||
switch(m_exception_code){
|
||||
switch(code){
|
||||
case incompatible_integer_size:
|
||||
msg = "integer cannot be represented";
|
||||
break;
|
||||
@@ -74,6 +74,8 @@ class portable_binary_iarchive :
|
||||
public boost::archive::detail::common_iarchive<
|
||||
portable_binary_iarchive
|
||||
>
|
||||
,
|
||||
public boost::archive::detail::shared_ptr_helper
|
||||
{
|
||||
typedef boost::archive::basic_binary_iprimitive<
|
||||
portable_binary_iarchive,
|
||||
@@ -148,15 +150,21 @@ protected:
|
||||
void load(unsigned char & t){
|
||||
this->primitive_base_t::load(t);
|
||||
}
|
||||
// intermediate level to support override of operators
|
||||
// fot templates in the absence of partial function
|
||||
// template ordering
|
||||
typedef boost::archive::detail::common_iarchive<portable_binary_iarchive>
|
||||
detail_common_iarchive;
|
||||
template<class T>
|
||||
void load_override(T & t){
|
||||
this->detail_common_iarchive::load_override(t);
|
||||
void load_override(T & t, BOOST_PFTO int){
|
||||
this->detail_common_iarchive::load_override(t, 0);
|
||||
}
|
||||
void load_override(boost::archive::class_name_type & t);
|
||||
void load_override(boost::archive::class_name_type & t, int);
|
||||
// binary files don't include the optional information
|
||||
void load_override(boost::archive::class_id_optional_type &){}
|
||||
void load_override(
|
||||
boost::archive::class_id_optional_type & /* t */,
|
||||
int
|
||||
){}
|
||||
|
||||
void init(unsigned int flags);
|
||||
public:
|
||||
|
||||
@@ -2,7 +2,7 @@
|
||||
#define PORTABLE_BINARY_OARCHIVE_HPP
|
||||
|
||||
// MS compatible compilers support #pragma once
|
||||
#if defined(_MSC_VER)
|
||||
#if defined(_MSC_VER) && (_MSC_VER >= 1020)
|
||||
# pragma once
|
||||
#endif
|
||||
|
||||
@@ -34,7 +34,7 @@
|
||||
// exception to be thrown if integer read from archive doesn't fit
|
||||
// variable being loaded
|
||||
class portable_binary_oarchive_exception :
|
||||
public boost::archive::archive_exception
|
||||
public virtual boost::archive::archive_exception
|
||||
{
|
||||
public:
|
||||
typedef enum {
|
||||
@@ -131,17 +131,18 @@ protected:
|
||||
typedef boost::archive::detail::common_oarchive<portable_binary_oarchive>
|
||||
detail_common_oarchive;
|
||||
template<class T>
|
||||
void save_override(T & t){
|
||||
this->detail_common_oarchive::save_override(t);
|
||||
void save_override(T & t, BOOST_PFTO int){
|
||||
this->detail_common_oarchive::save_override(t, 0);
|
||||
}
|
||||
// explicitly convert to char * to avoid compile ambiguities
|
||||
void save_override(const boost::archive::class_name_type & t){
|
||||
void save_override(const boost::archive::class_name_type & t, int){
|
||||
const std::string s(t);
|
||||
* this << s;
|
||||
}
|
||||
// binary files don't include the optional information
|
||||
void save_override(
|
||||
const boost::archive::class_id_optional_type & /* t */
|
||||
const boost::archive::class_id_optional_type & /* t */,
|
||||
int
|
||||
){}
|
||||
|
||||
void init(unsigned int flags);
|
||||
|
||||
@@ -2,7 +2,7 @@
|
||||
#define BOOST_SIMPLE_LOG_ARCHIVE_HPP
|
||||
|
||||
// MS compatible compilers support #pragma once
|
||||
#if defined(_MSC_VER)
|
||||
#if defined(_MSC_VER) && (_MSC_VER >= 1020)
|
||||
# pragma once
|
||||
#endif
|
||||
|
||||
|
||||
@@ -0,0 +1,55 @@
|
||||
#ifndef BOOST_ARCHIVE_ADD_FACET_HPP
|
||||
#define BOOST_ARCHIVE_ADD_FACET_HPP
|
||||
|
||||
// MS compatible compilers support #pragma once
|
||||
#if defined(_MSC_VER) && (_MSC_VER >= 1020)
|
||||
# pragma once
|
||||
#endif
|
||||
|
||||
/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
|
||||
// add_facet.hpp
|
||||
|
||||
// (C) Copyright 2003 Robert Ramey - http://www.rrsd.com .
|
||||
// Use, modification and distribution is subject to the Boost Software
|
||||
// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
// See http://www.boost.org for updates, documentation, and revision history.
|
||||
|
||||
#include <locale>
|
||||
#include <boost/config.hpp>
|
||||
#include <boost/detail/workaround.hpp>
|
||||
|
||||
// does STLport uses native STL for locales?
|
||||
#if (defined(__SGI_STL_PORT)&& defined(_STLP_NO_OWN_IOSTREAMS))
|
||||
// and this native STL lib is old Dinkumware (has not defined _CPPLIB_VER)
|
||||
# if (defined(_YVALS) && !defined(__IBMCPP__)) || !defined(_CPPLIB_VER)
|
||||
# define BOOST_ARCHIVE_OLD_DINKUMWARE_BENEATH_STLPORT
|
||||
# endif
|
||||
#endif
|
||||
|
||||
namespace boost {
|
||||
namespace archive {
|
||||
|
||||
template<class Facet>
|
||||
inline std::locale *
|
||||
add_facet(const std::locale &l, Facet * f){
|
||||
return
|
||||
#if defined BOOST_ARCHIVE_OLD_DINKUMWARE_BENEATH_STLPORT
|
||||
// std namespace used for native locale
|
||||
new std::locale(std::_Addfac(l, f));
|
||||
#elif BOOST_WORKAROUND(BOOST_DINKUMWARE_STDLIB, == 1) // old Dinkumwar
|
||||
// std namespace used for native locale
|
||||
new std::locale(std::_Addfac(l, f));
|
||||
#else
|
||||
// standard compatible
|
||||
new std::locale(l, f);
|
||||
#endif
|
||||
}
|
||||
|
||||
} // namespace archive
|
||||
} // namespace boost
|
||||
|
||||
#undef BOOST_ARCHIVE_OLD_DINKUMWARE_BENEATH_STLPORT
|
||||
|
||||
#endif // BOOST_ARCHIVE_ADD_FACET_HPP
|
||||
@@ -2,7 +2,7 @@
|
||||
#define BOOST_ARCHIVE_ARCHIVE_EXCEPTION_HPP
|
||||
|
||||
// MS compatible compilers support #pragma once
|
||||
#if defined(_MSC_VER)
|
||||
#if defined(_MSC_VER) && (_MSC_VER >= 1020)
|
||||
# pragma once
|
||||
#endif
|
||||
|
||||
@@ -21,6 +21,7 @@
|
||||
#include <string>
|
||||
|
||||
#include <boost/config.hpp>
|
||||
#include <boost/preprocessor/empty.hpp>
|
||||
#include <boost/archive/detail/decl.hpp>
|
||||
|
||||
// note: the only reason this is in here is that windows header
|
||||
@@ -39,21 +40,14 @@ namespace archive {
|
||||
//////////////////////////////////////////////////////////////////////
|
||||
// exceptions thrown by archives
|
||||
//
|
||||
class BOOST_SYMBOL_VISIBLE archive_exception :
|
||||
class BOOST_ARCHIVE_DECL(BOOST_PP_EMPTY()) archive_exception :
|
||||
public virtual std::exception
|
||||
{
|
||||
private:
|
||||
char m_buffer[128];
|
||||
protected:
|
||||
BOOST_ARCHIVE_DECL unsigned int
|
||||
append(unsigned int l, const char * a);
|
||||
BOOST_ARCHIVE_DECL
|
||||
archive_exception() BOOST_NOEXCEPT;
|
||||
public:
|
||||
typedef enum {
|
||||
no_exception, // initialized without code
|
||||
other_exception, // any excepton not listed below
|
||||
unregistered_class, // attempt to serialize a pointer of
|
||||
unregistered_class, // attempt to serialize a pointer of an
|
||||
// an unregistered class
|
||||
invalid_signature, // first line of archive does not contain
|
||||
// expected string
|
||||
@@ -61,8 +55,8 @@ public:
|
||||
// subsequent to this one
|
||||
pointer_conflict, // an attempt has been made to directly
|
||||
// serialize an object which has
|
||||
// already been serialized through a pointer.
|
||||
// Were this permitted, the archive load would result
|
||||
// already been serialzed through a pointer.
|
||||
// Were this permited, the archive load would result
|
||||
// in the creation of an extra copy of the obect.
|
||||
incompatible_native_format, // attempt to read native binary format
|
||||
// on incompatible platform
|
||||
@@ -74,22 +68,25 @@ public:
|
||||
unregistered_cast, // base - derived relationship not registered with
|
||||
// void_cast_register
|
||||
unsupported_class_version, // type saved with a version # greater than the
|
||||
// one used by the program. This indicates that the program
|
||||
// one used by the program. This indicates that the proggram
|
||||
// needs to be rebuilt.
|
||||
multiple_code_instantiation, // code for implementing serialization for some
|
||||
// type has been instantiated in more than one module.
|
||||
output_stream_error // error on input stream
|
||||
} exception_code;
|
||||
protected:
|
||||
std::string m_msg;
|
||||
public:
|
||||
exception_code code;
|
||||
|
||||
BOOST_ARCHIVE_DECL archive_exception(
|
||||
archive_exception(
|
||||
exception_code c,
|
||||
const char * e1 = NULL,
|
||||
const char * e2 = NULL
|
||||
) BOOST_NOEXCEPT;
|
||||
BOOST_ARCHIVE_DECL archive_exception(archive_exception const &) BOOST_NOEXCEPT ;
|
||||
virtual BOOST_ARCHIVE_DECL ~archive_exception() BOOST_NOEXCEPT_OR_NOTHROW ;
|
||||
virtual BOOST_ARCHIVE_DECL const char * what() const BOOST_NOEXCEPT_OR_NOTHROW ;
|
||||
);
|
||||
~archive_exception() throw ();
|
||||
virtual const char *what( ) const throw();
|
||||
protected:
|
||||
archive_exception();
|
||||
};
|
||||
|
||||
}// namespace archive
|
||||
|
||||
@@ -2,7 +2,7 @@
|
||||
#define BOOST_ARCHIVE_BASIC_ARCHIVE_HPP
|
||||
|
||||
// MS compatible compilers support #pragma once
|
||||
#if defined(_MSC_VER)
|
||||
#if defined(_MSC_VER) && (_MSC_VER >= 1020)
|
||||
# pragma once
|
||||
#endif
|
||||
|
||||
@@ -15,7 +15,7 @@
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
// See http://www.boost.org for updates, documentation, and revision history.
|
||||
#include <cstring> // count
|
||||
|
||||
#include <boost/assert.hpp>
|
||||
#include <boost/config.hpp>
|
||||
#include <boost/cstdint.hpp> // size_t
|
||||
@@ -69,7 +69,7 @@ public:
|
||||
}
|
||||
};
|
||||
|
||||
BOOST_ARCHIVE_DECL library_version_type
|
||||
BOOST_ARCHIVE_DECL(library_version_type)
|
||||
BOOST_ARCHIVE_VERSION();
|
||||
|
||||
class version_type {
|
||||
@@ -127,11 +127,11 @@ public:
|
||||
}
|
||||
|
||||
// used for text output
|
||||
operator base_type () const {
|
||||
operator int () const {
|
||||
return t;
|
||||
}
|
||||
// used for text input
|
||||
operator base_type &() {
|
||||
operator int_least16_t &() {
|
||||
return t;
|
||||
}
|
||||
bool operator==(const class_id_type & rhs) const {
|
||||
@@ -150,8 +150,7 @@ private:
|
||||
base_type t;
|
||||
public:
|
||||
object_id_type(): t(0) {};
|
||||
// note: presumes that size_t >= unsigned int.
|
||||
explicit object_id_type(const std::size_t & t_) : t(t_){
|
||||
explicit object_id_type(const unsigned int & t_) : t(t_){
|
||||
BOOST_ASSERT(t_ <= boost::integer_traits<base_type>::const_max);
|
||||
}
|
||||
object_id_type(const object_id_type & t_) :
|
||||
@@ -162,11 +161,11 @@ public:
|
||||
return *this;
|
||||
}
|
||||
// used for text output
|
||||
operator base_type () const {
|
||||
operator uint_least32_t () const {
|
||||
return t;
|
||||
}
|
||||
// used for text input
|
||||
operator base_type & () {
|
||||
operator uint_least32_t & () {
|
||||
return t;
|
||||
}
|
||||
bool operator==(const object_id_type & rhs) const {
|
||||
@@ -221,9 +220,6 @@ struct class_name_type :
|
||||
operator char * () {
|
||||
return t;
|
||||
}
|
||||
std::size_t size() const {
|
||||
return std::strlen(t);
|
||||
}
|
||||
explicit class_name_type(const char *key_)
|
||||
: t(const_cast<char *>(key_)){}
|
||||
explicit class_name_type(char *key_)
|
||||
@@ -242,7 +238,7 @@ enum archive_flags {
|
||||
flags_last = 8
|
||||
};
|
||||
|
||||
BOOST_ARCHIVE_DECL const char *
|
||||
BOOST_ARCHIVE_DECL(const char *)
|
||||
BOOST_ARCHIVE_SIGNATURE();
|
||||
|
||||
/* NOTE : Warning : Warning : Warning : Warning : Warning
|
||||
|
||||
@@ -2,7 +2,7 @@
|
||||
#define BOOST_ARCHIVE_BASIC_BINARY_IARCHIVE_HPP
|
||||
|
||||
// MS compatible compilers support #pragma once
|
||||
#if defined(_MSC_VER)
|
||||
#if defined(_MSC_VER) && (_MSC_VER >= 1020)
|
||||
# pragma once
|
||||
#endif
|
||||
|
||||
@@ -25,6 +25,7 @@
|
||||
|
||||
#include <boost/config.hpp>
|
||||
#include <boost/detail/workaround.hpp>
|
||||
#include <boost/serialization/pfto.hpp>
|
||||
|
||||
#include <boost/archive/basic_archive.hpp>
|
||||
#include <boost/archive/detail/common_iarchive.hpp>
|
||||
@@ -43,27 +44,21 @@
|
||||
namespace boost {
|
||||
namespace archive {
|
||||
|
||||
namespace detail {
|
||||
template<class Archive> class interface_iarchive;
|
||||
} // namespace detail
|
||||
|
||||
/////////////////////////////////////////////////////////////////////////
|
||||
// class basic_binary_iarchive - read serialized objects from a input binary stream
|
||||
template<class Archive>
|
||||
class BOOST_SYMBOL_VISIBLE basic_binary_iarchive :
|
||||
class basic_binary_iarchive :
|
||||
public detail::common_iarchive<Archive>
|
||||
{
|
||||
#ifdef BOOST_NO_MEMBER_TEMPLATE_FRIENDS
|
||||
public:
|
||||
#else
|
||||
protected:
|
||||
#if BOOST_WORKAROUND(BOOST_MSVC, < 1500)
|
||||
// for some inexplicable reason insertion of "class" generates compile erro
|
||||
// on msvc 7.1
|
||||
friend detail::interface_iarchive<Archive>;
|
||||
#else
|
||||
friend class detail::interface_iarchive<Archive>;
|
||||
#endif
|
||||
#if BOOST_WORKAROUND(BOOST_MSVC, <= 1300)
|
||||
public:
|
||||
#elif defined(BOOST_MSVC)
|
||||
// for some inexplicable reason insertion of "class" generates compile erro
|
||||
// on msvc 7.1
|
||||
friend detail::interface_iarchive<Archive>;
|
||||
#else
|
||||
friend class detail::interface_iarchive<Archive>;
|
||||
#endif
|
||||
// intermediate level to support override of operators
|
||||
// fot templates in the absence of partial function
|
||||
@@ -71,8 +66,8 @@ protected:
|
||||
// note extra nonsense to sneak it pass the borland compiers
|
||||
typedef detail::common_iarchive<Archive> detail_common_iarchive;
|
||||
template<class T>
|
||||
void load_override(T & t){
|
||||
this->detail_common_iarchive::load_override(t);
|
||||
void load_override(T & t, BOOST_PFTO int version){
|
||||
this->detail_common_iarchive::load_override(t, static_cast<int>(version));
|
||||
}
|
||||
|
||||
// include these to trap a change in binary format which
|
||||
@@ -85,7 +80,7 @@ protected:
|
||||
BOOST_STATIC_ASSERT(sizeof(object_reference_type) == sizeof(uint_least32_t));
|
||||
|
||||
// binary files don't include the optional information
|
||||
void load_override(class_id_optional_type & /* t */){}
|
||||
void load_override(class_id_optional_type & /* t */, int){}
|
||||
|
||||
void load_override(tracking_type & t, int /*version*/){
|
||||
library_version_type lvt = this->get_library_version();
|
||||
@@ -100,10 +95,10 @@ protected:
|
||||
t = boost::archive::tracking_type(x);
|
||||
}
|
||||
}
|
||||
void load_override(class_id_type & t){
|
||||
void load_override(class_id_type & t, int version){
|
||||
library_version_type lvt = this->get_library_version();
|
||||
if(boost::archive::library_version_type(7) < lvt){
|
||||
this->detail_common_iarchive::load_override(t);
|
||||
this->detail_common_iarchive::load_override(t, version);
|
||||
}
|
||||
else
|
||||
if(boost::archive::library_version_type(6) < lvt){
|
||||
@@ -117,14 +112,37 @@ protected:
|
||||
t = boost::archive::class_id_type(x);
|
||||
}
|
||||
}
|
||||
void load_override(class_id_reference_type & t){
|
||||
load_override(static_cast<class_id_type &>(t));
|
||||
void load_override(class_id_reference_type & t, int version){
|
||||
load_override(static_cast<class_id_type &>(t), version);
|
||||
}
|
||||
|
||||
void load_override(version_type & t){
|
||||
#if 0
|
||||
void load_override(class_id_reference_type & t, int version){
|
||||
library_version_type lvt = this->get_library_version();
|
||||
if(boost::archive::library_version_type(7) < lvt){
|
||||
this->detail_common_iarchive::load_override(t);
|
||||
this->detail_common_iarchive::load_override(t, version);
|
||||
}
|
||||
else
|
||||
if(boost::archive::library_version_type(6) < lvt){
|
||||
int_least16_t x=0;
|
||||
* this->This() >> x;
|
||||
t = boost::archive::class_id_reference_type(
|
||||
boost::archive::class_id_type(x)
|
||||
);
|
||||
}
|
||||
else{
|
||||
int x=0;
|
||||
* this->This() >> x;
|
||||
t = boost::archive::class_id_reference_type(
|
||||
boost::archive::class_id_type(x)
|
||||
);
|
||||
}
|
||||
}
|
||||
#endif
|
||||
|
||||
void load_override(version_type & t, int version){
|
||||
library_version_type lvt = this->get_library_version();
|
||||
if(boost::archive::library_version_type(7) < lvt){
|
||||
this->detail_common_iarchive::load_override(t, version);
|
||||
}
|
||||
else
|
||||
if(boost::archive::library_version_type(6) < lvt){
|
||||
@@ -152,11 +170,11 @@ protected:
|
||||
}
|
||||
}
|
||||
|
||||
void load_override(boost::serialization::item_version_type & t){
|
||||
void load_override(boost::serialization::item_version_type & t, int version){
|
||||
library_version_type lvt = this->get_library_version();
|
||||
// if(boost::archive::library_version_type(7) < lvt){
|
||||
if(boost::archive::library_version_type(6) < lvt){
|
||||
this->detail_common_iarchive::load_override(t);
|
||||
this->detail_common_iarchive::load_override(t, version);
|
||||
}
|
||||
else
|
||||
if(boost::archive::library_version_type(6) < lvt){
|
||||
@@ -171,9 +189,9 @@ protected:
|
||||
}
|
||||
}
|
||||
|
||||
void load_override(serialization::collection_size_type & t){
|
||||
void load_override(serialization::collection_size_type & t, int version){
|
||||
if(boost::archive::library_version_type(5) < this->get_library_version()){
|
||||
this->detail_common_iarchive::load_override(t);
|
||||
this->detail_common_iarchive::load_override(t, version);
|
||||
}
|
||||
else{
|
||||
unsigned int x=0;
|
||||
@@ -182,9 +200,9 @@ protected:
|
||||
}
|
||||
}
|
||||
|
||||
BOOST_ARCHIVE_OR_WARCHIVE_DECL void
|
||||
load_override(class_name_type & t);
|
||||
BOOST_ARCHIVE_OR_WARCHIVE_DECL void
|
||||
BOOST_ARCHIVE_OR_WARCHIVE_DECL(void)
|
||||
load_override(class_name_type & t, int);
|
||||
BOOST_ARCHIVE_OR_WARCHIVE_DECL(void)
|
||||
init();
|
||||
|
||||
basic_binary_iarchive(unsigned int flags) :
|
||||
|
||||
@@ -2,7 +2,7 @@
|
||||
#define BOOST_ARCHIVE_BINARY_IPRIMITIVE_HPP
|
||||
|
||||
// MS compatible compilers support #pragma once
|
||||
#if defined(_MSC_VER)
|
||||
#if defined(_MSC_VER) && (_MSC_VER >= 1020)
|
||||
# pragma once
|
||||
#endif
|
||||
|
||||
@@ -44,17 +44,16 @@ namespace std{
|
||||
#endif
|
||||
|
||||
#include <boost/cstdint.hpp>
|
||||
#include <boost/scoped_ptr.hpp>
|
||||
#include <boost/serialization/throw_exception.hpp>
|
||||
#include <boost/integer.hpp>
|
||||
#include <boost/integer_traits.hpp>
|
||||
|
||||
//#include <boost/mpl/placeholders.hpp>
|
||||
#include <boost/serialization/is_bitwise_serializable.hpp>
|
||||
#include <boost/serialization/array_wrapper.hpp>
|
||||
|
||||
#include <boost/archive/basic_streambuf_locale_saver.hpp>
|
||||
#include <boost/archive/codecvt_null.hpp>
|
||||
#include <boost/archive/archive_exception.hpp>
|
||||
#include <boost/mpl/placeholders.hpp>
|
||||
#include <boost/serialization/is_bitwise_serializable.hpp>
|
||||
#include <boost/serialization/array.hpp>
|
||||
#include <boost/archive/detail/auto_link_archive.hpp>
|
||||
#include <boost/archive/detail/abi_prefix.hpp> // must be the last header
|
||||
|
||||
@@ -64,7 +63,8 @@ namespace archive {
|
||||
/////////////////////////////////////////////////////////////////////////////
|
||||
// class binary_iarchive - read serialized objects from a input binary stream
|
||||
template<class Archive, class Elem, class Tr>
|
||||
class BOOST_SYMBOL_VISIBLE basic_binary_iprimitive {
|
||||
class basic_binary_iprimitive
|
||||
{
|
||||
#ifndef BOOST_NO_MEMBER_TEMPLATE_FRIENDS
|
||||
friend class load_access;
|
||||
protected:
|
||||
@@ -78,16 +78,8 @@ public:
|
||||
}
|
||||
|
||||
#ifndef BOOST_NO_STD_LOCALE
|
||||
// note order! - if you change this, libstd++ will fail!
|
||||
// a) create new locale with new codecvt facet
|
||||
// b) save current locale
|
||||
// c) change locale to new one
|
||||
// d) use stream buffer
|
||||
// e) change locale back to original
|
||||
// f) destroy new codecvt facet
|
||||
boost::archive::codecvt_null<Elem> codecvt_null_facet;
|
||||
boost::scoped_ptr<std::locale> archive_locale;
|
||||
basic_streambuf_locale_saver<Elem, Tr> locale_saver;
|
||||
std::locale archive_locale;
|
||||
#endif
|
||||
|
||||
// main template for serilization of primitive types
|
||||
@@ -106,25 +98,25 @@ public:
|
||||
BOOST_ASSERT(0 == i || 1 == i);
|
||||
(void)i; // warning suppression for release builds.
|
||||
}
|
||||
BOOST_ARCHIVE_OR_WARCHIVE_DECL void
|
||||
BOOST_ARCHIVE_OR_WARCHIVE_DECL(void)
|
||||
load(std::string &s);
|
||||
#ifndef BOOST_NO_STD_WSTRING
|
||||
BOOST_ARCHIVE_OR_WARCHIVE_DECL void
|
||||
BOOST_ARCHIVE_OR_WARCHIVE_DECL(void)
|
||||
load(std::wstring &ws);
|
||||
#endif
|
||||
BOOST_ARCHIVE_OR_WARCHIVE_DECL void
|
||||
BOOST_ARCHIVE_OR_WARCHIVE_DECL(void)
|
||||
load(char * t);
|
||||
BOOST_ARCHIVE_OR_WARCHIVE_DECL void
|
||||
BOOST_ARCHIVE_OR_WARCHIVE_DECL(void)
|
||||
load(wchar_t * t);
|
||||
|
||||
BOOST_ARCHIVE_OR_WARCHIVE_DECL void
|
||||
BOOST_ARCHIVE_OR_WARCHIVE_DECL(void)
|
||||
init();
|
||||
BOOST_ARCHIVE_OR_WARCHIVE_DECL
|
||||
BOOST_ARCHIVE_OR_WARCHIVE_DECL(BOOST_PP_EMPTY())
|
||||
basic_binary_iprimitive(
|
||||
std::basic_streambuf<Elem, Tr> & sb,
|
||||
bool no_codecvt
|
||||
);
|
||||
BOOST_ARCHIVE_OR_WARCHIVE_DECL
|
||||
BOOST_ARCHIVE_OR_WARCHIVE_DECL(BOOST_PP_EMPTY())
|
||||
~basic_binary_iprimitive();
|
||||
public:
|
||||
// we provide an optimized load for all fundamental types
|
||||
@@ -134,7 +126,7 @@ public:
|
||||
template <class T>
|
||||
#if defined(BOOST_NO_DEPENDENT_NESTED_DERIVATIONS)
|
||||
struct apply {
|
||||
typedef typename boost::serialization::is_bitwise_serializable< T >::type type;
|
||||
typedef BOOST_DEDUCED_TYPENAME boost::serialization::is_bitwise_serializable< T >::type type;
|
||||
};
|
||||
#else
|
||||
struct apply : public boost::serialization::is_bitwise_serializable< T > {};
|
||||
@@ -143,7 +135,7 @@ public:
|
||||
|
||||
// the optimized load_array dispatches to load_binary
|
||||
template <class ValueType>
|
||||
void load_array(serialization::array_wrapper<ValueType>& a, unsigned int)
|
||||
void load_array(serialization::array<ValueType>& a, unsigned int)
|
||||
{
|
||||
load_binary(a.address(),a.count()*sizeof(ValueType));
|
||||
}
|
||||
@@ -186,7 +178,7 @@ basic_binary_iprimitive<Archive, Elem, Tr>::load_binary(
|
||||
boost::serialization::throw_exception(
|
||||
archive_exception(archive_exception::input_stream_error)
|
||||
);
|
||||
std::memcpy(static_cast<char*>(address) + (count - s), &t, static_cast<std::size_t>(s));
|
||||
std::memcpy(static_cast<char*>(address) + (count - s), &t, s);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@@ -2,7 +2,7 @@
|
||||
#define BOOST_ARCHIVE_BASIC_BINARY_OARCHIVE_HPP
|
||||
|
||||
// MS compatible compilers support #pragma once
|
||||
#if defined(_MSC_VER)
|
||||
#if defined(_MSC_VER) && (_MSC_VER >= 1020)
|
||||
# pragma once
|
||||
#endif
|
||||
|
||||
@@ -26,6 +26,7 @@
|
||||
#include <boost/assert.hpp>
|
||||
#include <boost/config.hpp>
|
||||
#include <boost/detail/workaround.hpp>
|
||||
#include <boost/serialization/pfto.hpp>
|
||||
|
||||
#include <boost/integer.hpp>
|
||||
#include <boost/integer_traits.hpp>
|
||||
@@ -45,10 +46,6 @@
|
||||
namespace boost {
|
||||
namespace archive {
|
||||
|
||||
namespace detail {
|
||||
template<class Archive> class interface_oarchive;
|
||||
} // namespace detail
|
||||
|
||||
//////////////////////////////////////////////////////////////////////
|
||||
// class basic_binary_oarchive - write serialized objects to a binary output stream
|
||||
// note: this archive has no pretensions to portability. Archive format
|
||||
@@ -58,26 +55,24 @@ namespace detail {
|
||||
// does have the virtue of buiding the smalles archive in the minimum amount
|
||||
// of time. So under some circumstances it may be he right choice.
|
||||
template<class Archive>
|
||||
class BOOST_SYMBOL_VISIBLE basic_binary_oarchive :
|
||||
public detail::common_oarchive<Archive>
|
||||
class basic_binary_oarchive :
|
||||
public archive::detail::common_oarchive<Archive>
|
||||
{
|
||||
#ifdef BOOST_NO_MEMBER_TEMPLATE_FRIENDS
|
||||
public:
|
||||
#else
|
||||
protected:
|
||||
#if BOOST_WORKAROUND(BOOST_MSVC, < 1500)
|
||||
// for some inexplicable reason insertion of "class" generates compile erro
|
||||
// on msvc 7.1
|
||||
friend detail::interface_oarchive<Archive>;
|
||||
#else
|
||||
friend class detail::interface_oarchive<Archive>;
|
||||
#endif
|
||||
#if BOOST_WORKAROUND(BOOST_MSVC, <= 1300)
|
||||
public:
|
||||
#elif defined(BOOST_MSVC)
|
||||
// for some inexplicable reason insertion of "class" generates compile erro
|
||||
// on msvc 7.1
|
||||
friend detail::interface_oarchive<Archive>;
|
||||
#else
|
||||
friend class detail::interface_oarchive<Archive>;
|
||||
#endif
|
||||
// any datatype not specifed below will be handled by base class
|
||||
typedef detail::common_oarchive<Archive> detail_common_oarchive;
|
||||
template<class T>
|
||||
void save_override(const T & t){
|
||||
this->detail_common_oarchive::save_override(t);
|
||||
void save_override(const T & t, BOOST_PFTO int version){
|
||||
this->detail_common_oarchive::save_override(t, static_cast<int>(version));
|
||||
}
|
||||
|
||||
// include these to trap a change in binary format which
|
||||
@@ -91,14 +86,14 @@ protected:
|
||||
BOOST_STATIC_ASSERT(sizeof(object_reference_type) == sizeof(uint_least32_t));
|
||||
|
||||
// binary files don't include the optional information
|
||||
void save_override(const class_id_optional_type & /* t */){}
|
||||
void save_override(const class_id_optional_type & /* t */, int){}
|
||||
|
||||
// enable this if we decide to support generation of previous versions
|
||||
#if 0
|
||||
void save_override(const boost::archive::version_type & t){
|
||||
void save_override(const boost::archive::version_type & t, int version){
|
||||
library_version_type lvt = this->get_library_version();
|
||||
if(boost::archive::library_version_type(7) < lvt){
|
||||
this->detail_common_oarchive::save_override(t);
|
||||
this->detail_common_oarchive::save_override(t, version);
|
||||
}
|
||||
else
|
||||
if(boost::archive::library_version_type(6) < lvt){
|
||||
@@ -110,10 +105,10 @@ protected:
|
||||
* this->This() << x;
|
||||
}
|
||||
}
|
||||
void save_override(const boost::serialization::item_version_type & t){
|
||||
void save_override(const boost::serialization::item_version_type & t, int version){
|
||||
library_version_type lvt = this->get_library_version();
|
||||
if(boost::archive::library_version_type(7) < lvt){
|
||||
this->detail_common_oarchive::save_override(t);
|
||||
this->detail_common_oarchive::save_override(t, version);
|
||||
}
|
||||
else
|
||||
if(boost::archive::library_version_type(6) < lvt){
|
||||
@@ -126,10 +121,10 @@ protected:
|
||||
}
|
||||
}
|
||||
|
||||
void save_override(class_id_type & t){
|
||||
void save_override(class_id_type & t, int version){
|
||||
library_version_type lvt = this->get_library_version();
|
||||
if(boost::archive::library_version_type(7) < lvt){
|
||||
this->detail_common_oarchive::save_override(t);
|
||||
this->detail_common_oarchive::save_override(t, version);
|
||||
}
|
||||
else
|
||||
if(boost::archive::library_version_type(6) < lvt){
|
||||
@@ -141,20 +136,20 @@ protected:
|
||||
* this->This() << x;
|
||||
}
|
||||
}
|
||||
void save_override(class_id_reference_type & t){
|
||||
save_override(static_cast<class_id_type &>(t));
|
||||
void save_override(class_id_reference_type & t, int version){
|
||||
save_override(static_cast<class_id_type &>(t), version);
|
||||
}
|
||||
|
||||
#endif
|
||||
|
||||
// explicitly convert to char * to avoid compile ambiguities
|
||||
void save_override(const class_name_type & t){
|
||||
void save_override(const class_name_type & t, int){
|
||||
const std::string s(t);
|
||||
* this->This() << s;
|
||||
}
|
||||
|
||||
#if 0
|
||||
void save_override(const serialization::collection_size_type & t){
|
||||
void save_override(const serialization::collection_size_type & t, int){
|
||||
if (get_library_version() < boost::archive::library_version_type(6)){
|
||||
unsigned int x=0;
|
||||
* this->This() >> x;
|
||||
@@ -165,7 +160,7 @@ protected:
|
||||
}
|
||||
}
|
||||
#endif
|
||||
BOOST_ARCHIVE_OR_WARCHIVE_DECL void
|
||||
BOOST_ARCHIVE_OR_WARCHIVE_DECL(void)
|
||||
init();
|
||||
|
||||
basic_binary_oarchive(unsigned int flags) :
|
||||
|
||||
@@ -2,7 +2,7 @@
|
||||
#define BOOST_ARCHIVE_BASIC_BINARY_OPRIMITIVE_HPP
|
||||
|
||||
// MS compatible compilers support #pragma once
|
||||
#if defined(_MSC_VER)
|
||||
#if defined(_MSC_VER) && (_MSC_VER >= 1020)
|
||||
# pragma once
|
||||
#endif
|
||||
|
||||
@@ -43,13 +43,11 @@ namespace std{
|
||||
#include <boost/scoped_ptr.hpp>
|
||||
#include <boost/serialization/throw_exception.hpp>
|
||||
|
||||
//#include <boost/mpl/placeholders.hpp>
|
||||
#include <boost/serialization/is_bitwise_serializable.hpp>
|
||||
#include <boost/serialization/array_wrapper.hpp>
|
||||
|
||||
#include <boost/archive/basic_streambuf_locale_saver.hpp>
|
||||
#include <boost/archive/codecvt_null.hpp>
|
||||
#include <boost/archive/archive_exception.hpp>
|
||||
#include <boost/serialization/is_bitwise_serializable.hpp>
|
||||
#include <boost/mpl/placeholders.hpp>
|
||||
#include <boost/serialization/array.hpp>
|
||||
#include <boost/archive/detail/auto_link_archive.hpp>
|
||||
#include <boost/archive/detail/abi_prefix.hpp> // must be the last header
|
||||
|
||||
@@ -60,7 +58,8 @@ namespace archive {
|
||||
// class basic_binary_oprimitive - binary output of prmitives
|
||||
|
||||
template<class Archive, class Elem, class Tr>
|
||||
class BOOST_SYMBOL_VISIBLE basic_binary_oprimitive {
|
||||
class basic_binary_oprimitive
|
||||
{
|
||||
#ifndef BOOST_NO_MEMBER_TEMPLATE_FRIENDS
|
||||
friend class save_access;
|
||||
protected:
|
||||
@@ -73,16 +72,8 @@ public:
|
||||
return static_cast<Archive *>(this);
|
||||
}
|
||||
#ifndef BOOST_NO_STD_LOCALE
|
||||
// note order! - if you change this, libstd++ will fail!
|
||||
// a) create new locale with new codecvt facet
|
||||
// b) save current locale
|
||||
// c) change locale to new one
|
||||
// d) use stream buffer
|
||||
// e) change locale back to original
|
||||
// f) destroy new codecvt facet
|
||||
boost::archive::codecvt_null<Elem> codecvt_null_facet;
|
||||
boost::scoped_ptr<std::locale> archive_locale;
|
||||
basic_streambuf_locale_saver<Elem, Tr> locale_saver;
|
||||
std::locale archive_locale;
|
||||
#endif
|
||||
// default saving of primitives.
|
||||
template<class T>
|
||||
@@ -100,26 +91,26 @@ public:
|
||||
BOOST_ASSERT(0 == static_cast<int>(t) || 1 == static_cast<int>(t));
|
||||
save_binary(& t, sizeof(t));
|
||||
}
|
||||
BOOST_ARCHIVE_OR_WARCHIVE_DECL void
|
||||
BOOST_ARCHIVE_OR_WARCHIVE_DECL(void)
|
||||
save(const std::string &s);
|
||||
#ifndef BOOST_NO_STD_WSTRING
|
||||
BOOST_ARCHIVE_OR_WARCHIVE_DECL void
|
||||
BOOST_ARCHIVE_OR_WARCHIVE_DECL(void)
|
||||
save(const std::wstring &ws);
|
||||
#endif
|
||||
BOOST_ARCHIVE_OR_WARCHIVE_DECL void
|
||||
BOOST_ARCHIVE_OR_WARCHIVE_DECL(void)
|
||||
save(const char * t);
|
||||
BOOST_ARCHIVE_OR_WARCHIVE_DECL void
|
||||
BOOST_ARCHIVE_OR_WARCHIVE_DECL(void)
|
||||
save(const wchar_t * t);
|
||||
|
||||
BOOST_ARCHIVE_OR_WARCHIVE_DECL void
|
||||
BOOST_ARCHIVE_OR_WARCHIVE_DECL(void)
|
||||
init();
|
||||
|
||||
BOOST_ARCHIVE_OR_WARCHIVE_DECL
|
||||
BOOST_ARCHIVE_OR_WARCHIVE_DECL(BOOST_PP_EMPTY())
|
||||
basic_binary_oprimitive(
|
||||
std::basic_streambuf<Elem, Tr> & sb,
|
||||
bool no_codecvt
|
||||
);
|
||||
BOOST_ARCHIVE_OR_WARCHIVE_DECL
|
||||
BOOST_ARCHIVE_OR_WARCHIVE_DECL(BOOST_PP_EMPTY())
|
||||
~basic_binary_oprimitive();
|
||||
public:
|
||||
|
||||
@@ -131,16 +122,17 @@ public:
|
||||
template <class T>
|
||||
#if defined(BOOST_NO_DEPENDENT_NESTED_DERIVATIONS)
|
||||
struct apply {
|
||||
typedef typename boost::serialization::is_bitwise_serializable< T >::type type;
|
||||
typedef BOOST_DEDUCED_TYPENAME boost::serialization::is_bitwise_serializable< T >::type type;
|
||||
};
|
||||
#else
|
||||
struct apply : public boost::serialization::is_bitwise_serializable< T > {};
|
||||
#endif
|
||||
};
|
||||
|
||||
|
||||
// the optimized save_array dispatches to save_binary
|
||||
template <class ValueType>
|
||||
void save_array(boost::serialization::array_wrapper<ValueType> const& a, unsigned int)
|
||||
void save_array(boost::serialization::array<ValueType> const& a, unsigned int)
|
||||
{
|
||||
save_binary(a.address(),a.count()*sizeof(ValueType));
|
||||
}
|
||||
@@ -154,7 +146,9 @@ basic_binary_oprimitive<Archive, Elem, Tr>::save_binary(
|
||||
const void *address,
|
||||
std::size_t count
|
||||
){
|
||||
// BOOST_ASSERT(count <= std::size_t(boost::integer_traits<std::streamsize>::const_max));
|
||||
//BOOST_ASSERT(
|
||||
// static_cast<std::size_t>((std::numeric_limits<std::streamsize>::max)()) >= count
|
||||
//);
|
||||
// note: if the following assertions fail
|
||||
// a likely cause is that the output stream is set to "text"
|
||||
// mode where by cr characters recieve special treatment.
|
||||
@@ -164,7 +158,9 @@ basic_binary_oprimitive<Archive, Elem, Tr>::save_binary(
|
||||
// archive_exception(archive_exception::output_stream_error)
|
||||
// );
|
||||
// figure number of elements to output - round up
|
||||
count = ( count + sizeof(Elem) - 1) / sizeof(Elem);
|
||||
count = ( count + sizeof(Elem) - 1)
|
||||
/ sizeof(Elem);
|
||||
BOOST_ASSERT(count <= std::size_t(boost::integer_traits<std::streamsize>::const_max));
|
||||
std::streamsize scount = m_sb.sputn(
|
||||
static_cast<const Elem *>(address),
|
||||
static_cast<std::streamsize>(count)
|
||||
@@ -174,7 +170,7 @@ basic_binary_oprimitive<Archive, Elem, Tr>::save_binary(
|
||||
archive_exception(archive_exception::output_stream_error)
|
||||
);
|
||||
//os.write(
|
||||
// static_cast<const typename OStream::char_type *>(address),
|
||||
// static_cast<const BOOST_DEDUCED_TYPENAME OStream::char_type *>(address),
|
||||
// count
|
||||
//);
|
||||
//BOOST_ASSERT(os.good());
|
||||
|
||||
@@ -2,12 +2,12 @@
|
||||
#define BOOST_ARCHIVE_BASIC_STREAMBUF_LOCALE_SAVER_HPP
|
||||
|
||||
// MS compatible compilers support #pragma once
|
||||
#if defined(_MSC_VER)
|
||||
#if defined(_MSC_VER) && (_MSC_VER >= 1020)
|
||||
# pragma once
|
||||
#endif
|
||||
|
||||
/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
|
||||
// basic_streambuf_locale_saver.hpp
|
||||
// basic_streambuf_local_saver.hpp
|
||||
|
||||
// (C) Copyright 2005 Robert Ramey - http://www.rrsd.com
|
||||
|
||||
@@ -27,7 +27,6 @@
|
||||
#ifndef BOOST_NO_STD_LOCALE
|
||||
|
||||
#include <locale> // for std::locale
|
||||
#include <ios>
|
||||
#include <streambuf> // for std::basic_streambuf
|
||||
|
||||
#include <boost/config.hpp>
|
||||
@@ -46,57 +45,23 @@ class basic_streambuf_locale_saver :
|
||||
private boost::noncopyable
|
||||
{
|
||||
public:
|
||||
explicit basic_streambuf_locale_saver(std::basic_streambuf<Ch, Tr> &s) :
|
||||
m_streambuf(s),
|
||||
m_locale(s.getloc())
|
||||
{}
|
||||
~basic_streambuf_locale_saver(){
|
||||
m_streambuf.pubsync();
|
||||
m_streambuf.pubimbue(m_locale);
|
||||
}
|
||||
typedef ::std::basic_streambuf<Ch, Tr> state_type;
|
||||
typedef ::std::locale aspect_type;
|
||||
explicit basic_streambuf_locale_saver( state_type &s )
|
||||
: s_save_( s ), a_save_( s.getloc() )
|
||||
{}
|
||||
basic_streambuf_locale_saver( state_type &s, aspect_type const &a )
|
||||
: s_save_( s ), a_save_( s.pubimbue(a) )
|
||||
{}
|
||||
~basic_streambuf_locale_saver()
|
||||
{ this->restore(); }
|
||||
void restore()
|
||||
{ s_save_.pubimbue( a_save_ ); }
|
||||
private:
|
||||
std::basic_streambuf<Ch, Tr> & m_streambuf;
|
||||
std::locale const m_locale;
|
||||
state_type & s_save_;
|
||||
aspect_type const a_save_;
|
||||
};
|
||||
|
||||
template < typename Ch, class Tr >
|
||||
class basic_istream_locale_saver :
|
||||
private boost::noncopyable
|
||||
{
|
||||
public:
|
||||
explicit basic_istream_locale_saver(std::basic_istream<Ch, Tr> &s) :
|
||||
m_istream(s),
|
||||
m_locale(s.getloc())
|
||||
{}
|
||||
~basic_istream_locale_saver(){
|
||||
// libstdc++ crashes without this
|
||||
m_istream.sync();
|
||||
m_istream.imbue(m_locale);
|
||||
}
|
||||
private:
|
||||
std::basic_istream<Ch, Tr> & m_istream;
|
||||
std::locale const m_locale;
|
||||
};
|
||||
|
||||
template < typename Ch, class Tr >
|
||||
class basic_ostream_locale_saver :
|
||||
private boost::noncopyable
|
||||
{
|
||||
public:
|
||||
explicit basic_ostream_locale_saver(std::basic_ostream<Ch, Tr> &s) :
|
||||
m_ostream(s),
|
||||
m_locale(s.getloc())
|
||||
{}
|
||||
~basic_ostream_locale_saver(){
|
||||
m_ostream.flush();
|
||||
m_ostream.imbue(m_locale);
|
||||
}
|
||||
private:
|
||||
std::basic_ostream<Ch, Tr> & m_ostream;
|
||||
std::locale const m_locale;
|
||||
};
|
||||
|
||||
|
||||
} // archive
|
||||
} // boost
|
||||
|
||||
|
||||
@@ -2,7 +2,7 @@
|
||||
#define BOOST_ARCHIVE_BASIC_TEXT_IARCHIVE_HPP
|
||||
|
||||
// MS compatible compilers support #pragma once
|
||||
#if defined(_MSC_VER)
|
||||
#if defined(_MSC_VER) && (_MSC_VER >= 1020)
|
||||
# pragma once
|
||||
#endif
|
||||
|
||||
@@ -21,10 +21,11 @@
|
||||
//
|
||||
// note the fact that on libraries without wide characters, ostream is
|
||||
// is not a specialization of basic_ostream which in fact is not defined
|
||||
// in such cases. So we can't use basic_istream<IStream::char_type> but rather
|
||||
// in such cases. So we can't use basic_ostream<IStream::char_type> but rather
|
||||
// use two template parameters
|
||||
|
||||
#include <boost/config.hpp>
|
||||
#include <boost/serialization/pfto.hpp>
|
||||
#include <boost/detail/workaround.hpp>
|
||||
|
||||
#include <boost/archive/detail/common_iarchive.hpp>
|
||||
@@ -39,43 +40,37 @@
|
||||
namespace boost {
|
||||
namespace archive {
|
||||
|
||||
namespace detail {
|
||||
template<class Archive> class interface_iarchive;
|
||||
} // namespace detail
|
||||
|
||||
/////////////////////////////////////////////////////////////////////////
|
||||
// class basic_text_iarchive - read serialized objects from a input text stream
|
||||
template<class Archive>
|
||||
class BOOST_SYMBOL_VISIBLE basic_text_iarchive :
|
||||
class basic_text_iarchive :
|
||||
public detail::common_iarchive<Archive>
|
||||
{
|
||||
#ifdef BOOST_NO_MEMBER_TEMPLATE_FRIENDS
|
||||
public:
|
||||
#else
|
||||
protected:
|
||||
#if BOOST_WORKAROUND(BOOST_MSVC, < 1500)
|
||||
// for some inexplicable reason insertion of "class" generates compile erro
|
||||
// on msvc 7.1
|
||||
friend detail::interface_iarchive<Archive>;
|
||||
#else
|
||||
friend class detail::interface_iarchive<Archive>;
|
||||
#endif
|
||||
#if BOOST_WORKAROUND(BOOST_MSVC, <= 1300)
|
||||
public:
|
||||
#elif defined(BOOST_MSVC)
|
||||
// for some inexplicable reason insertion of "class" generates compile erro
|
||||
// on msvc 7.1
|
||||
friend detail::interface_iarchive<Archive>;
|
||||
#else
|
||||
friend class detail::interface_iarchive<Archive>;
|
||||
#endif
|
||||
// intermediate level to support override of operators
|
||||
// fot templates in the absence of partial function
|
||||
// template ordering
|
||||
typedef detail::common_iarchive<Archive> detail_common_iarchive;
|
||||
template<class T>
|
||||
void load_override(T & t){
|
||||
this->detail_common_iarchive::load_override(t);
|
||||
void load_override(T & t, BOOST_PFTO int){
|
||||
this->detail_common_iarchive::load_override(t, 0);
|
||||
}
|
||||
// text file don't include the optional information
|
||||
void load_override(class_id_optional_type & /*t*/){}
|
||||
void load_override(class_id_optional_type & /*t*/, int){}
|
||||
|
||||
BOOST_ARCHIVE_OR_WARCHIVE_DECL void
|
||||
load_override(class_name_type & t);
|
||||
BOOST_ARCHIVE_OR_WARCHIVE_DECL(void)
|
||||
load_override(class_name_type & t, int);
|
||||
|
||||
BOOST_ARCHIVE_OR_WARCHIVE_DECL void
|
||||
BOOST_ARCHIVE_OR_WARCHIVE_DECL(void)
|
||||
init(void);
|
||||
|
||||
basic_text_iarchive(unsigned int flags) :
|
||||
|
||||
@@ -2,7 +2,7 @@
|
||||
#define BOOST_ARCHIVE_BASIC_TEXT_IPRIMITIVE_HPP
|
||||
|
||||
// MS compatible compilers support #pragma once
|
||||
#if defined(_MSC_VER)
|
||||
#if defined(_MSC_VER) && (_MSC_VER >= 1020)
|
||||
# pragma once
|
||||
#endif
|
||||
|
||||
@@ -24,6 +24,7 @@
|
||||
// in such cases. So we can't use basic_ostream<IStream::char_type> but rather
|
||||
// use two template parameters
|
||||
|
||||
#include <boost/assert.hpp>
|
||||
#include <locale>
|
||||
#include <cstddef> // size_t
|
||||
|
||||
@@ -37,15 +38,17 @@ namespace std{
|
||||
} // namespace std
|
||||
#endif
|
||||
|
||||
#include <boost/io/ios_state.hpp>
|
||||
#include <boost/static_assert.hpp>
|
||||
|
||||
#include <boost/detail/workaround.hpp>
|
||||
#if BOOST_WORKAROUND(BOOST_DINKUMWARE_STDLIB, == 1)
|
||||
#include <boost/archive/dinkumware.hpp>
|
||||
#endif
|
||||
|
||||
#include <boost/limits.hpp>
|
||||
#include <boost/io/ios_state.hpp>
|
||||
#include <boost/scoped_ptr.hpp>
|
||||
#include <boost/static_assert.hpp>
|
||||
|
||||
#include <boost/serialization/throw_exception.hpp>
|
||||
#include <boost/archive/codecvt_null.hpp>
|
||||
#include <boost/archive/archive_exception.hpp>
|
||||
#include <boost/archive/basic_streambuf_locale_saver.hpp>
|
||||
#include <boost/archive/detail/abi_prefix.hpp> // must be the last header
|
||||
@@ -61,33 +64,32 @@ namespace archive {
|
||||
#endif
|
||||
|
||||
template<class IStream>
|
||||
class BOOST_SYMBOL_VISIBLE basic_text_iprimitive {
|
||||
class basic_text_iprimitive
|
||||
{
|
||||
#ifndef BOOST_NO_MEMBER_TEMPLATE_FRIENDS
|
||||
protected:
|
||||
#else
|
||||
public:
|
||||
#endif
|
||||
IStream &is;
|
||||
io::ios_flags_saver flags_saver;
|
||||
io::ios_precision_saver precision_saver;
|
||||
|
||||
#ifndef BOOST_NO_STD_LOCALE
|
||||
// note order! - if you change this, libstd++ will fail!
|
||||
// a) create new locale with new codecvt facet
|
||||
// b) save current locale
|
||||
// c) change locale to new one
|
||||
// d) use stream buffer
|
||||
// e) change locale back to original
|
||||
// f) destroy new codecvt facet
|
||||
boost::archive::codecvt_null<typename IStream::char_type> codecvt_null_facet;
|
||||
std::locale archive_locale;
|
||||
basic_istream_locale_saver<
|
||||
typename IStream::char_type,
|
||||
typename IStream::traits_type
|
||||
boost::scoped_ptr<std::locale> archive_locale;
|
||||
basic_streambuf_locale_saver<
|
||||
BOOST_DEDUCED_TYPENAME IStream::char_type,
|
||||
BOOST_DEDUCED_TYPENAME IStream::traits_type
|
||||
> locale_saver;
|
||||
#endif
|
||||
|
||||
template<class T>
|
||||
void load(T & t)
|
||||
{
|
||||
if(is >> t)
|
||||
if(! is.fail()){
|
||||
is >> t;
|
||||
return;
|
||||
}
|
||||
boost::serialization::throw_exception(
|
||||
archive_exception(archive_exception::input_stream_error)
|
||||
);
|
||||
@@ -121,12 +123,12 @@ protected:
|
||||
t = i;
|
||||
}
|
||||
#endif
|
||||
BOOST_ARCHIVE_OR_WARCHIVE_DECL
|
||||
BOOST_ARCHIVE_OR_WARCHIVE_DECL(BOOST_PP_EMPTY())
|
||||
basic_text_iprimitive(IStream &is, bool no_codecvt);
|
||||
BOOST_ARCHIVE_OR_WARCHIVE_DECL
|
||||
BOOST_ARCHIVE_OR_WARCHIVE_DECL(BOOST_PP_EMPTY())
|
||||
~basic_text_iprimitive();
|
||||
public:
|
||||
BOOST_ARCHIVE_OR_WARCHIVE_DECL void
|
||||
BOOST_ARCHIVE_OR_WARCHIVE_DECL(void)
|
||||
load_binary(void *address, std::size_t count);
|
||||
};
|
||||
|
||||
|
||||
@@ -2,7 +2,7 @@
|
||||
#define BOOST_ARCHIVE_BASIC_TEXT_OARCHIVE_HPP
|
||||
|
||||
// MS compatible compilers support #pragma once
|
||||
#if defined(_MSC_VER)
|
||||
#if defined(_MSC_VER) && (_MSC_VER >= 1020)
|
||||
# pragma once
|
||||
#endif
|
||||
|
||||
@@ -24,8 +24,11 @@
|
||||
// in such cases. So we can't use basic_ostream<OStream::char_type> but rather
|
||||
// use two template parameters
|
||||
|
||||
#include <boost/assert.hpp>
|
||||
#include <boost/config.hpp>
|
||||
#include <boost/serialization/pfto.hpp>
|
||||
#include <boost/detail/workaround.hpp>
|
||||
|
||||
#include <boost/archive/detail/common_oarchive.hpp>
|
||||
#include <boost/serialization/string.hpp>
|
||||
|
||||
@@ -39,36 +42,30 @@
|
||||
namespace boost {
|
||||
namespace archive {
|
||||
|
||||
namespace detail {
|
||||
template<class Archive> class interface_oarchive;
|
||||
} // namespace detail
|
||||
|
||||
/////////////////////////////////////////////////////////////////////////
|
||||
// class basic_text_oarchive
|
||||
template<class Archive>
|
||||
class BOOST_SYMBOL_VISIBLE basic_text_oarchive :
|
||||
class basic_text_oarchive :
|
||||
public detail::common_oarchive<Archive>
|
||||
{
|
||||
#ifdef BOOST_NO_MEMBER_TEMPLATE_FRIENDS
|
||||
public:
|
||||
#else
|
||||
protected:
|
||||
#if BOOST_WORKAROUND(BOOST_MSVC, < 1500)
|
||||
// for some inexplicable reason insertion of "class" generates compile erro
|
||||
// on msvc 7.1
|
||||
friend detail::interface_oarchive<Archive>;
|
||||
#else
|
||||
friend class detail::interface_oarchive<Archive>;
|
||||
#endif
|
||||
#if BOOST_WORKAROUND(BOOST_MSVC, <= 1300) \
|
||||
|| BOOST_WORKAROUND(__BORLANDC__,BOOST_TESTED_AT(0x560))
|
||||
public:
|
||||
#elif defined(BOOST_MSVC)
|
||||
// for some inexplicable reason insertion of "class" generates compile erro
|
||||
// on msvc 7.1
|
||||
friend detail::interface_oarchive<Archive>;
|
||||
#else
|
||||
friend class detail::interface_oarchive<Archive>;
|
||||
#endif
|
||||
|
||||
enum {
|
||||
none,
|
||||
eol,
|
||||
space
|
||||
} delimiter;
|
||||
|
||||
BOOST_ARCHIVE_OR_WARCHIVE_DECL void
|
||||
BOOST_ARCHIVE_OR_WARCHIVE_DECL(void)
|
||||
newtoken();
|
||||
|
||||
void newline(){
|
||||
@@ -79,25 +76,25 @@ protected:
|
||||
// extra stuff to get it passed borland compilers
|
||||
typedef detail::common_oarchive<Archive> detail_common_oarchive;
|
||||
template<class T>
|
||||
void save_override(T & t){
|
||||
this->detail_common_oarchive::save_override(t);
|
||||
void save_override(T & t, BOOST_PFTO int){
|
||||
this->detail_common_oarchive::save_override(t, 0);
|
||||
}
|
||||
|
||||
// start new objects on a new line
|
||||
void save_override(const object_id_type & t){
|
||||
void save_override(const object_id_type & t, int){
|
||||
this->This()->newline();
|
||||
this->detail_common_oarchive::save_override(t);
|
||||
this->detail_common_oarchive::save_override(t, 0);
|
||||
}
|
||||
|
||||
// text file don't include the optional information
|
||||
void save_override(const class_id_optional_type & /* t */){}
|
||||
void save_override(const class_id_optional_type & /* t */, int){}
|
||||
|
||||
void save_override(const class_name_type & t){
|
||||
void save_override(const class_name_type & t, int){
|
||||
const std::string s(t);
|
||||
* this->This() << s;
|
||||
}
|
||||
|
||||
BOOST_ARCHIVE_OR_WARCHIVE_DECL void
|
||||
BOOST_ARCHIVE_OR_WARCHIVE_DECL(void)
|
||||
init();
|
||||
|
||||
basic_text_oarchive(unsigned int flags) :
|
||||
|
||||
@@ -2,7 +2,7 @@
|
||||
#define BOOST_ARCHIVE_BASIC_TEXT_OPRIMITIVE_HPP
|
||||
|
||||
// MS compatible compilers support #pragma once
|
||||
#if defined(_MSC_VER)
|
||||
#if defined(_MSC_VER) && (_MSC_VER >= 1020)
|
||||
# pragma once
|
||||
#endif
|
||||
|
||||
@@ -26,12 +26,12 @@
|
||||
|
||||
#include <iomanip>
|
||||
#include <locale>
|
||||
#include <boost/config/no_tr1/cmath.hpp> // isnan
|
||||
#include <boost/assert.hpp>
|
||||
#include <cstddef> // size_t
|
||||
|
||||
#include <boost/config.hpp>
|
||||
#include <boost/static_assert.hpp>
|
||||
#include <boost/io/ios_state.hpp>
|
||||
|
||||
#include <boost/detail/workaround.hpp>
|
||||
#if BOOST_WORKAROUND(BOOST_DINKUMWARE_STDLIB, == 1)
|
||||
#include <boost/archive/dinkumware.hpp>
|
||||
@@ -46,46 +46,52 @@ namespace std{
|
||||
} // namespace std
|
||||
#endif
|
||||
|
||||
#include <boost/type_traits/is_floating_point.hpp>
|
||||
#include <boost/mpl/bool.hpp>
|
||||
#include <boost/limits.hpp>
|
||||
#include <boost/integer.hpp>
|
||||
#include <boost/io/ios_state.hpp>
|
||||
#include <boost/scoped_ptr.hpp>
|
||||
#include <boost/serialization/throw_exception.hpp>
|
||||
#include <boost/archive/basic_streambuf_locale_saver.hpp>
|
||||
#include <boost/archive/codecvt_null.hpp>
|
||||
#include <boost/archive/archive_exception.hpp>
|
||||
#include <boost/archive/basic_streambuf_locale_saver.hpp>
|
||||
#include <boost/archive/detail/abi_prefix.hpp> // must be the last header
|
||||
|
||||
namespace boost {
|
||||
namespace archive {
|
||||
|
||||
class save_access;
|
||||
|
||||
/////////////////////////////////////////////////////////////////////////
|
||||
// class basic_text_oprimitive - output of prmitives to stream
|
||||
template<class OStream>
|
||||
class BOOST_SYMBOL_VISIBLE basic_text_oprimitive
|
||||
class basic_text_oprimitive
|
||||
{
|
||||
#ifndef BOOST_NO_MEMBER_TEMPLATE_FRIENDS
|
||||
protected:
|
||||
#else
|
||||
public:
|
||||
#endif
|
||||
OStream &os;
|
||||
io::ios_flags_saver flags_saver;
|
||||
io::ios_precision_saver precision_saver;
|
||||
|
||||
#ifndef BOOST_NO_STD_LOCALE
|
||||
// note order! - if you change this, libstd++ will fail!
|
||||
// a) create new locale with new codecvt facet
|
||||
// b) save current locale
|
||||
// c) change locale to new one
|
||||
// d) use stream buffer
|
||||
// e) change locale back to original
|
||||
// f) destroy new codecvt facet
|
||||
boost::archive::codecvt_null<typename OStream::char_type> codecvt_null_facet;
|
||||
std::locale archive_locale;
|
||||
basic_ostream_locale_saver<
|
||||
typename OStream::char_type,
|
||||
typename OStream::traits_type
|
||||
boost::scoped_ptr<std::locale> archive_locale;
|
||||
basic_streambuf_locale_saver<
|
||||
BOOST_DEDUCED_TYPENAME OStream::char_type,
|
||||
BOOST_DEDUCED_TYPENAME OStream::traits_type
|
||||
> locale_saver;
|
||||
#endif
|
||||
|
||||
// default saving of primitives.
|
||||
template<class T>
|
||||
void save(const T &t){
|
||||
if(os.fail())
|
||||
boost::serialization::throw_exception(
|
||||
archive_exception(archive_exception::output_stream_error)
|
||||
);
|
||||
os << t;
|
||||
}
|
||||
|
||||
/////////////////////////////////////////////////////////
|
||||
// fundamental types that need special treatment
|
||||
void save(const bool t){
|
||||
@@ -117,75 +123,33 @@ protected:
|
||||
save(static_cast<int>(t));
|
||||
}
|
||||
#endif
|
||||
|
||||
/////////////////////////////////////////////////////////
|
||||
// saving of any types not listed above
|
||||
|
||||
template<class T>
|
||||
void save_impl(const T &t, boost::mpl::bool_<false> &){
|
||||
if(os.fail())
|
||||
boost::serialization::throw_exception(
|
||||
archive_exception(archive_exception::output_stream_error)
|
||||
);
|
||||
os << t;
|
||||
}
|
||||
|
||||
/////////////////////////////////////////////////////////
|
||||
// floating point types need even more special treatment
|
||||
// the following determines whether the type T is some sort
|
||||
// of floating point type. Note that we then assume that
|
||||
// the stream << operator is defined on that type - if not
|
||||
// we'll get a compile time error. This is meant to automatically
|
||||
// support synthesized types which support floating point
|
||||
// operations. Also it should handle compiler dependent types
|
||||
// such long double. Due to John Maddock.
|
||||
|
||||
template<class T>
|
||||
struct is_float {
|
||||
typedef typename mpl::bool_<
|
||||
boost::is_floating_point<T>::value
|
||||
|| (std::numeric_limits<T>::is_specialized
|
||||
&& !std::numeric_limits<T>::is_integer
|
||||
&& !std::numeric_limits<T>::is_exact
|
||||
&& std::numeric_limits<T>::max_exponent)
|
||||
>::type type;
|
||||
};
|
||||
|
||||
template<class T>
|
||||
void save_impl(const T &t, boost::mpl::bool_<true> &){
|
||||
void save(const float t)
|
||||
{
|
||||
// must be a user mistake - can't serialize un-initialized data
|
||||
if(os.fail())
|
||||
boost::serialization::throw_exception(
|
||||
archive_exception(archive_exception::output_stream_error)
|
||||
);
|
||||
// The formulae for the number of decimla digits required is given in
|
||||
// http://www2.open-std.org/JTC1/SC22/WG21/docs/papers/2005/n1822.pdf
|
||||
// which is derived from Kahan's paper:
|
||||
// www.eecs.berkeley.edu/~wkahan/ieee754status/ieee754.ps
|
||||
// const unsigned int digits = (std::numeric_limits<T>::digits * 3010) / 10000;
|
||||
// note: I've commented out the above because I didn't get good results. e.g.
|
||||
// in one case I got a difference of 19 units.
|
||||
#ifndef BOOST_NO_CXX11_NUMERIC_LIMITS
|
||||
const unsigned int digits = std::numeric_limits<T>::max_digits10;
|
||||
#else
|
||||
const unsigned int digits = std::numeric_limits<T>::digits10 + 2;
|
||||
#endif
|
||||
os << std::setprecision(digits) << std::scientific << t;
|
||||
os << std::setprecision(std::numeric_limits<float>::digits10 + 2);
|
||||
os << t;
|
||||
}
|
||||
|
||||
template<class T>
|
||||
void save(const T & t){
|
||||
typename is_float<T>::type tf;
|
||||
save_impl(t, tf);
|
||||
void save(const double t)
|
||||
{
|
||||
// must be a user mistake - can't serialize un-initialized data
|
||||
if(os.fail())
|
||||
boost::serialization::throw_exception(
|
||||
archive_exception(archive_exception::output_stream_error)
|
||||
);
|
||||
os << std::setprecision(std::numeric_limits<double>::digits10 + 2);
|
||||
os << t;
|
||||
}
|
||||
|
||||
BOOST_ARCHIVE_OR_WARCHIVE_DECL
|
||||
BOOST_ARCHIVE_OR_WARCHIVE_DECL(BOOST_PP_EMPTY())
|
||||
basic_text_oprimitive(OStream & os, bool no_codecvt);
|
||||
BOOST_ARCHIVE_OR_WARCHIVE_DECL
|
||||
BOOST_ARCHIVE_OR_WARCHIVE_DECL(BOOST_PP_EMPTY())
|
||||
~basic_text_oprimitive();
|
||||
public:
|
||||
// unformatted append of one character
|
||||
void put(typename OStream::char_type c){
|
||||
void put(BOOST_DEDUCED_TYPENAME OStream::char_type c){
|
||||
if(os.fail())
|
||||
boost::serialization::throw_exception(
|
||||
archive_exception(archive_exception::output_stream_error)
|
||||
@@ -197,7 +161,7 @@ public:
|
||||
while('\0' != *s)
|
||||
os.put(*s++);
|
||||
}
|
||||
BOOST_ARCHIVE_OR_WARCHIVE_DECL void
|
||||
BOOST_ARCHIVE_OR_WARCHIVE_DECL(void)
|
||||
save_binary(const void *address, std::size_t count);
|
||||
};
|
||||
|
||||
|
||||
@@ -2,7 +2,7 @@
|
||||
#define BOOST_ARCHIVE_BASIC_XML_TEXT_ARCHIVE_HPP
|
||||
|
||||
// MS compatible compilers support #pragma once
|
||||
#if defined(_MSC_VER)
|
||||
#if defined(_MSC_VER) && (_MSC_VER >= 1020)
|
||||
# pragma once
|
||||
#endif
|
||||
|
||||
@@ -27,35 +27,35 @@ namespace archive {
|
||||
// constant strings used in xml i/o
|
||||
|
||||
extern
|
||||
BOOST_ARCHIVE_DECL const char *
|
||||
BOOST_ARCHIVE_DECL(const char *)
|
||||
BOOST_ARCHIVE_XML_OBJECT_ID();
|
||||
|
||||
extern
|
||||
BOOST_ARCHIVE_DECL const char *
|
||||
BOOST_ARCHIVE_DECL(const char *)
|
||||
BOOST_ARCHIVE_XML_OBJECT_REFERENCE();
|
||||
|
||||
extern
|
||||
BOOST_ARCHIVE_DECL const char *
|
||||
BOOST_ARCHIVE_DECL(const char *)
|
||||
BOOST_ARCHIVE_XML_CLASS_ID();
|
||||
|
||||
extern
|
||||
BOOST_ARCHIVE_DECL const char *
|
||||
BOOST_ARCHIVE_DECL(const char *)
|
||||
BOOST_ARCHIVE_XML_CLASS_ID_REFERENCE();
|
||||
|
||||
extern
|
||||
BOOST_ARCHIVE_DECL const char *
|
||||
BOOST_ARCHIVE_DECL(const char *)
|
||||
BOOST_ARCHIVE_XML_CLASS_NAME();
|
||||
|
||||
extern
|
||||
BOOST_ARCHIVE_DECL const char *
|
||||
BOOST_ARCHIVE_DECL(const char *)
|
||||
BOOST_ARCHIVE_XML_TRACKING();
|
||||
|
||||
extern
|
||||
BOOST_ARCHIVE_DECL const char *
|
||||
BOOST_ARCHIVE_DECL(const char *)
|
||||
BOOST_ARCHIVE_XML_VERSION();
|
||||
|
||||
extern
|
||||
BOOST_ARCHIVE_DECL const char *
|
||||
BOOST_ARCHIVE_DECL(const char *)
|
||||
BOOST_ARCHIVE_XML_SIGNATURE();
|
||||
|
||||
}// namespace archive
|
||||
|
||||
@@ -2,7 +2,7 @@
|
||||
#define BOOST_ARCHIVE_BASIC_XML_IARCHIVE_HPP
|
||||
|
||||
// MS compatible compilers support #pragma once
|
||||
#if defined(_MSC_VER)
|
||||
#if defined(_MSC_VER) && (_MSC_VER >= 1020)
|
||||
# pragma once
|
||||
#endif
|
||||
|
||||
@@ -17,12 +17,16 @@
|
||||
// See http://www.boost.org for updates, documentation, and revision history.
|
||||
|
||||
#include <boost/config.hpp>
|
||||
#include <boost/mpl/assert.hpp>
|
||||
#include <boost/serialization/pfto.hpp>
|
||||
#include <boost/detail/workaround.hpp>
|
||||
|
||||
#include <boost/archive/detail/common_iarchive.hpp>
|
||||
|
||||
#include <boost/serialization/nvp.hpp>
|
||||
#include <boost/serialization/string.hpp>
|
||||
|
||||
#include <boost/mpl/assert.hpp>
|
||||
|
||||
#include <boost/archive/detail/abi_prefix.hpp> // must be the last header
|
||||
|
||||
#ifdef BOOST_MSVC
|
||||
@@ -33,38 +37,38 @@
|
||||
namespace boost {
|
||||
namespace archive {
|
||||
|
||||
namespace detail {
|
||||
template<class Archive> class interface_iarchive;
|
||||
} // namespace detail
|
||||
|
||||
/////////////////////////////////////////////////////////////////////////
|
||||
// class basic_xml_iarchive - read serialized objects from a input text stream
|
||||
// class xml_iarchive - read serialized objects from a input text stream
|
||||
template<class Archive>
|
||||
class BOOST_SYMBOL_VISIBLE basic_xml_iarchive :
|
||||
class basic_xml_iarchive :
|
||||
public detail::common_iarchive<Archive>
|
||||
{
|
||||
unsigned int depth;
|
||||
#ifdef BOOST_NO_MEMBER_TEMPLATE_FRIENDS
|
||||
public:
|
||||
#else
|
||||
protected:
|
||||
friend class detail::interface_iarchive<Archive>;
|
||||
#if BOOST_WORKAROUND(BOOST_MSVC, <= 1300)
|
||||
public:
|
||||
#elif defined(BOOST_MSVC)
|
||||
// for some inexplicable reason insertion of "class" generates compile erro
|
||||
// on msvc 7.1
|
||||
friend detail::interface_oarchive<Archive>;
|
||||
#else
|
||||
friend class detail::interface_oarchive<Archive>;
|
||||
#endif
|
||||
BOOST_ARCHIVE_OR_WARCHIVE_DECL void
|
||||
unsigned int depth;
|
||||
BOOST_ARCHIVE_OR_WARCHIVE_DECL(void)
|
||||
load_start(const char *name);
|
||||
BOOST_ARCHIVE_OR_WARCHIVE_DECL void
|
||||
BOOST_ARCHIVE_OR_WARCHIVE_DECL(void)
|
||||
load_end(const char *name);
|
||||
|
||||
// Anything not an attribute and not a name-value pair is an
|
||||
// should be trapped here.
|
||||
template<class T>
|
||||
void load_override(T & t)
|
||||
void load_override(T & t, BOOST_PFTO int)
|
||||
{
|
||||
// If your program fails to compile here, its most likely due to
|
||||
// not specifying an nvp wrapper around the variable to
|
||||
// be serialized.
|
||||
BOOST_MPL_ASSERT((serialization::is_wrapper< T >));
|
||||
this->detail_common_iarchive::load_override(t);
|
||||
this->detail_common_iarchive::load_override(t, 0);
|
||||
}
|
||||
|
||||
// Anything not an attribute - see below - should be a name value
|
||||
@@ -72,10 +76,14 @@ protected:
|
||||
typedef detail::common_iarchive<Archive> detail_common_iarchive;
|
||||
template<class T>
|
||||
void load_override(
|
||||
const boost::serialization::nvp< T > & t
|
||||
#ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING
|
||||
const
|
||||
#endif
|
||||
boost::serialization::nvp< T > & t,
|
||||
int
|
||||
){
|
||||
this->This()->load_start(t.name());
|
||||
this->detail_common_iarchive::load_override(t.value());
|
||||
this->detail_common_iarchive::load_override(t.value(), 0);
|
||||
this->This()->load_end(t.name());
|
||||
}
|
||||
|
||||
@@ -87,23 +95,23 @@ protected:
|
||||
// an xml archive. So we can skip it here. Note: we MUST override
|
||||
// it otherwise it will be loaded as a normal primitive w/o tag and
|
||||
// leaving the archive in an undetermined state
|
||||
BOOST_ARCHIVE_OR_WARCHIVE_DECL void
|
||||
load_override(class_id_type & t);
|
||||
void load_override(class_id_optional_type & /* t */){}
|
||||
BOOST_ARCHIVE_OR_WARCHIVE_DECL void
|
||||
load_override(object_id_type & t);
|
||||
BOOST_ARCHIVE_OR_WARCHIVE_DECL void
|
||||
load_override(version_type & t);
|
||||
BOOST_ARCHIVE_OR_WARCHIVE_DECL void
|
||||
load_override(tracking_type & t);
|
||||
void load_override(class_id_optional_type & /* t */, int){}
|
||||
BOOST_ARCHIVE_OR_WARCHIVE_DECL(void)
|
||||
load_override(object_id_type & t, int);
|
||||
BOOST_ARCHIVE_OR_WARCHIVE_DECL(void)
|
||||
load_override(version_type & t, int);
|
||||
BOOST_ARCHIVE_OR_WARCHIVE_DECL(void)
|
||||
load_override(class_id_type & t, int);
|
||||
BOOST_ARCHIVE_OR_WARCHIVE_DECL(void)
|
||||
load_override(tracking_type & t, int);
|
||||
// class_name_type can't be handled here as it depends upon the
|
||||
// char type used by the stream. So require the derived implementation
|
||||
// handle this.
|
||||
// void load_override(class_name_type & t);
|
||||
// void load_override(class_name_type & t, int);
|
||||
|
||||
BOOST_ARCHIVE_OR_WARCHIVE_DECL
|
||||
BOOST_ARCHIVE_OR_WARCHIVE_DECL(BOOST_PP_EMPTY())
|
||||
basic_xml_iarchive(unsigned int flags);
|
||||
BOOST_ARCHIVE_OR_WARCHIVE_DECL
|
||||
BOOST_ARCHIVE_OR_WARCHIVE_DECL(BOOST_PP_EMPTY())
|
||||
~basic_xml_iarchive();
|
||||
};
|
||||
|
||||
|
||||
@@ -2,7 +2,7 @@
|
||||
#define BOOST_ARCHIVE_BASIC_XML_OARCHIVE_HPP
|
||||
|
||||
// MS compatible compilers support #pragma once
|
||||
#if defined(_MSC_VER)
|
||||
#if defined(_MSC_VER) && (_MSC_VER >= 1020)
|
||||
# pragma once
|
||||
#endif
|
||||
|
||||
@@ -17,12 +17,15 @@
|
||||
// See http://www.boost.org for updates, documentation, and revision history.
|
||||
|
||||
#include <boost/config.hpp>
|
||||
#include <boost/mpl/assert.hpp>
|
||||
|
||||
#include <boost/archive/detail/common_oarchive.hpp>
|
||||
|
||||
#include <boost/serialization/nvp.hpp>
|
||||
#include <boost/serialization/tracking.hpp>
|
||||
#include <boost/serialization/string.hpp>
|
||||
|
||||
#include <boost/mpl/assert.hpp>
|
||||
|
||||
#include <boost/archive/detail/abi_prefix.hpp> // must be the last header
|
||||
|
||||
#ifdef BOOST_MSVC
|
||||
@@ -33,96 +36,100 @@
|
||||
namespace boost {
|
||||
namespace archive {
|
||||
|
||||
namespace detail {
|
||||
template<class Archive> class interface_oarchive;
|
||||
} // namespace detail
|
||||
|
||||
//////////////////////////////////////////////////////////////////////
|
||||
// class basic_xml_oarchive - write serialized objects to a xml output stream
|
||||
template<class Archive>
|
||||
class BOOST_SYMBOL_VISIBLE basic_xml_oarchive :
|
||||
class basic_xml_oarchive :
|
||||
public detail::common_oarchive<Archive>
|
||||
{
|
||||
protected:
|
||||
#if BOOST_WORKAROUND(BOOST_MSVC, <= 1300)
|
||||
public:
|
||||
#elif defined(BOOST_MSVC)
|
||||
// for some inexplicable reason insertion of "class" generates compile erro
|
||||
// on msvc 7.1
|
||||
friend detail::interface_oarchive<Archive>;
|
||||
friend class save_access;
|
||||
#else
|
||||
friend class detail::interface_oarchive<Archive>;
|
||||
friend class save_access;
|
||||
#endif
|
||||
// special stuff for xml output
|
||||
unsigned int depth;
|
||||
bool pending_preamble;
|
||||
#ifdef BOOST_NO_MEMBER_TEMPLATE_FRIENDS
|
||||
public:
|
||||
#else
|
||||
protected:
|
||||
friend class detail::interface_oarchive<Archive>;
|
||||
#endif
|
||||
bool indent_next;
|
||||
BOOST_ARCHIVE_OR_WARCHIVE_DECL void
|
||||
bool pending_preamble;
|
||||
BOOST_ARCHIVE_OR_WARCHIVE_DECL(void)
|
||||
indent();
|
||||
BOOST_ARCHIVE_OR_WARCHIVE_DECL void
|
||||
BOOST_ARCHIVE_OR_WARCHIVE_DECL(void)
|
||||
init();
|
||||
BOOST_ARCHIVE_OR_WARCHIVE_DECL void
|
||||
windup();
|
||||
BOOST_ARCHIVE_OR_WARCHIVE_DECL void
|
||||
BOOST_ARCHIVE_OR_WARCHIVE_DECL(void)
|
||||
write_attribute(
|
||||
const char *attribute_name,
|
||||
int t,
|
||||
const char *conjunction = "=\""
|
||||
);
|
||||
BOOST_ARCHIVE_OR_WARCHIVE_DECL void
|
||||
BOOST_ARCHIVE_OR_WARCHIVE_DECL(void)
|
||||
write_attribute(
|
||||
const char *attribute_name,
|
||||
const char *key
|
||||
);
|
||||
// helpers used below
|
||||
BOOST_ARCHIVE_OR_WARCHIVE_DECL void
|
||||
BOOST_ARCHIVE_OR_WARCHIVE_DECL(void)
|
||||
save_start(const char *name);
|
||||
BOOST_ARCHIVE_OR_WARCHIVE_DECL void
|
||||
BOOST_ARCHIVE_OR_WARCHIVE_DECL(void)
|
||||
save_end(const char *name);
|
||||
BOOST_ARCHIVE_OR_WARCHIVE_DECL void
|
||||
BOOST_ARCHIVE_OR_WARCHIVE_DECL(void)
|
||||
end_preamble();
|
||||
|
||||
// Anything not an attribute and not a name-value pair is an
|
||||
// error and should be trapped here.
|
||||
template<class T>
|
||||
void save_override(T & t)
|
||||
void save_override(T & t, BOOST_PFTO int)
|
||||
{
|
||||
// If your program fails to compile here, its most likely due to
|
||||
// not specifying an nvp wrapper around the variable to
|
||||
// be serialized.
|
||||
BOOST_MPL_ASSERT((serialization::is_wrapper< T >));
|
||||
this->detail_common_oarchive::save_override(t);
|
||||
this->detail_common_oarchive::save_override(t, 0);
|
||||
}
|
||||
|
||||
// special treatment for name-value pairs.
|
||||
typedef detail::common_oarchive<Archive> detail_common_oarchive;
|
||||
template<class T>
|
||||
void save_override(
|
||||
const ::boost::serialization::nvp< T > & t
|
||||
#ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING
|
||||
const
|
||||
#endif
|
||||
::boost::serialization::nvp< T > & t,
|
||||
int
|
||||
){
|
||||
this->This()->save_start(t.name());
|
||||
this->detail_common_oarchive::save_override(t.const_value());
|
||||
this->detail_common_oarchive::save_override(t.const_value(), 0);
|
||||
this->This()->save_end(t.name());
|
||||
}
|
||||
|
||||
// specific overrides for attributes - not name value pairs so we
|
||||
// want to trap them before the above "fall through"
|
||||
BOOST_ARCHIVE_OR_WARCHIVE_DECL void
|
||||
save_override(const class_id_type & t);
|
||||
BOOST_ARCHIVE_OR_WARCHIVE_DECL void
|
||||
save_override(const class_id_optional_type & t);
|
||||
BOOST_ARCHIVE_OR_WARCHIVE_DECL void
|
||||
save_override(const class_id_reference_type & t);
|
||||
BOOST_ARCHIVE_OR_WARCHIVE_DECL void
|
||||
save_override(const object_id_type & t);
|
||||
BOOST_ARCHIVE_OR_WARCHIVE_DECL void
|
||||
save_override(const object_reference_type & t);
|
||||
BOOST_ARCHIVE_OR_WARCHIVE_DECL void
|
||||
save_override(const version_type & t);
|
||||
BOOST_ARCHIVE_OR_WARCHIVE_DECL void
|
||||
save_override(const class_name_type & t);
|
||||
BOOST_ARCHIVE_OR_WARCHIVE_DECL void
|
||||
save_override(const tracking_type & t);
|
||||
BOOST_ARCHIVE_OR_WARCHIVE_DECL(void)
|
||||
save_override(const object_id_type & t, int);
|
||||
BOOST_ARCHIVE_OR_WARCHIVE_DECL(void)
|
||||
save_override(const object_reference_type & t, int);
|
||||
BOOST_ARCHIVE_OR_WARCHIVE_DECL(void)
|
||||
save_override(const version_type & t, int);
|
||||
BOOST_ARCHIVE_OR_WARCHIVE_DECL(void)
|
||||
save_override(const class_id_type & t, int);
|
||||
BOOST_ARCHIVE_OR_WARCHIVE_DECL(void)
|
||||
save_override(const class_id_optional_type & t, int);
|
||||
BOOST_ARCHIVE_OR_WARCHIVE_DECL(void)
|
||||
save_override(const class_id_reference_type & t, int);
|
||||
BOOST_ARCHIVE_OR_WARCHIVE_DECL(void)
|
||||
save_override(const class_name_type & t, int);
|
||||
BOOST_ARCHIVE_OR_WARCHIVE_DECL(void)
|
||||
save_override(const tracking_type & t, int);
|
||||
|
||||
BOOST_ARCHIVE_OR_WARCHIVE_DECL
|
||||
BOOST_ARCHIVE_OR_WARCHIVE_DECL(BOOST_PP_EMPTY())
|
||||
basic_xml_oarchive(unsigned int flags);
|
||||
BOOST_ARCHIVE_OR_WARCHIVE_DECL
|
||||
BOOST_ARCHIVE_OR_WARCHIVE_DECL(BOOST_PP_EMPTY())
|
||||
~basic_xml_oarchive();
|
||||
};
|
||||
|
||||
|
||||
@@ -2,7 +2,7 @@
|
||||
#define BOOST_ARCHIVE_BINARY_IARCHIVE_HPP
|
||||
|
||||
// MS compatible compilers support #pragma once
|
||||
#if defined(_MSC_VER)
|
||||
#if defined(_MSC_VER) && (_MSC_VER >= 1020)
|
||||
# pragma once
|
||||
#endif
|
||||
|
||||
@@ -25,18 +25,57 @@
|
||||
# pragma warning(disable : 4511 4512)
|
||||
#endif
|
||||
|
||||
namespace boost {
|
||||
namespace boost {
|
||||
namespace archive {
|
||||
|
||||
// do not derive from the classes below. If you want to extend this functionality
|
||||
// via inhertance, derived from text_iarchive_impl instead. This will
|
||||
// preserve correct static polymorphism.
|
||||
|
||||
// same as binary_iarchive below - without the shared_ptr_helper
|
||||
class naked_binary_iarchive :
|
||||
public binary_iarchive_impl<
|
||||
boost::archive::naked_binary_iarchive,
|
||||
std::istream::char_type,
|
||||
std::istream::traits_type
|
||||
>
|
||||
{
|
||||
public:
|
||||
naked_binary_iarchive(std::istream & is, unsigned int flags = 0) :
|
||||
binary_iarchive_impl<
|
||||
naked_binary_iarchive, std::istream::char_type, std::istream::traits_type
|
||||
>(is, flags)
|
||||
{}
|
||||
naked_binary_iarchive(std::streambuf & bsb, unsigned int flags = 0) :
|
||||
binary_iarchive_impl<
|
||||
naked_binary_iarchive, std::istream::char_type, std::istream::traits_type
|
||||
>(bsb, flags)
|
||||
{}
|
||||
};
|
||||
|
||||
} // namespace archive
|
||||
} // namespace boost
|
||||
|
||||
// note special treatment of shared_ptr. This type needs a special
|
||||
// structure associated with every archive. We created a "mix-in"
|
||||
// class to provide this functionality. Since shared_ptr holds a
|
||||
// special esteem in the boost library - we included it here by default.
|
||||
#include <boost/archive/shared_ptr_helper.hpp>
|
||||
|
||||
namespace boost {
|
||||
namespace archive {
|
||||
|
||||
// do not derive from this class. If you want to extend this functionality
|
||||
// via inhertance, derived from binary_iarchive_impl instead. This will
|
||||
// preserve correct static polymorphism.
|
||||
class BOOST_SYMBOL_VISIBLE binary_iarchive :
|
||||
class binary_iarchive :
|
||||
public binary_iarchive_impl<
|
||||
boost::archive::binary_iarchive,
|
||||
std::istream::char_type,
|
||||
std::istream::traits_type
|
||||
>{
|
||||
>,
|
||||
public detail::shared_ptr_helper
|
||||
{
|
||||
public:
|
||||
binary_iarchive(std::istream & is, unsigned int flags = 0) :
|
||||
binary_iarchive_impl<
|
||||
|
||||
@@ -2,7 +2,7 @@
|
||||
#define BOOST_ARCHIVE_BINARY_IARCHIVE_IMPL_HPP
|
||||
|
||||
// MS compatible compilers support #pragma once
|
||||
#if defined(_MSC_VER)
|
||||
#if defined(_MSC_VER) && (_MSC_VER >= 1020)
|
||||
# pragma once
|
||||
#endif
|
||||
|
||||
@@ -17,6 +17,7 @@
|
||||
// See http://www.boost.org for updates, documentation, and revision history.
|
||||
|
||||
#include <istream>
|
||||
#include <boost/serialization/pfto.hpp>
|
||||
#include <boost/archive/basic_binary_iprimitive.hpp>
|
||||
#include <boost/archive/basic_binary_iarchive.hpp>
|
||||
|
||||
@@ -28,39 +29,29 @@
|
||||
namespace boost {
|
||||
namespace archive {
|
||||
|
||||
namespace detail {
|
||||
template<class Archive> class interface_iarchive;
|
||||
} // namespace detail
|
||||
|
||||
template<class Archive, class Elem, class Tr>
|
||||
class BOOST_SYMBOL_VISIBLE binary_iarchive_impl :
|
||||
class binary_iarchive_impl :
|
||||
public basic_binary_iprimitive<Archive, Elem, Tr>,
|
||||
public basic_binary_iarchive<Archive>
|
||||
{
|
||||
#ifdef BOOST_NO_MEMBER_TEMPLATE_FRIENDS
|
||||
public:
|
||||
#else
|
||||
friend class detail::interface_iarchive<Archive>;
|
||||
friend class basic_binary_iarchive<Archive>;
|
||||
friend class load_access;
|
||||
protected:
|
||||
#if BOOST_WORKAROUND(BOOST_MSVC, < 1500)
|
||||
// for some inexplicable reason insertion of "class" generates compile erro
|
||||
// on msvc 7.1
|
||||
friend detail::interface_iarchive<Archive>;
|
||||
friend basic_binary_iarchive<Archive>;
|
||||
friend load_access;
|
||||
#else
|
||||
friend class detail::interface_iarchive<Archive>;
|
||||
friend class basic_binary_iarchive<Archive>;
|
||||
friend class load_access;
|
||||
#endif
|
||||
#endif
|
||||
// note: the following should not needed - but one compiler (vc 7.1)
|
||||
// fails to compile one test (test_shared_ptr) without it !!!
|
||||
// make this protected so it can be called from a derived archive
|
||||
template<class T>
|
||||
void load_override(T & t){
|
||||
this->basic_binary_iarchive<Archive>::load_override(t);
|
||||
void load_override(T & t, BOOST_PFTO int){
|
||||
this->basic_binary_iarchive<Archive>::load_override(t, 0L);
|
||||
}
|
||||
void init(unsigned int flags){
|
||||
if(0 != (flags & no_header)){
|
||||
if(0 != (flags & no_header))
|
||||
return;
|
||||
}
|
||||
#if ! defined(__MWERKS__)
|
||||
this->basic_binary_iarchive<Archive>::init();
|
||||
this->basic_binary_iprimitive<Archive, Elem, Tr>::init();
|
||||
|
||||
@@ -2,7 +2,7 @@
|
||||
#define BOOST_ARCHIVE_BINARY_OARCHIVE_HPP
|
||||
|
||||
// MS compatible compilers support #pragma once
|
||||
#if defined(_MSC_VER)
|
||||
#if defined(_MSC_VER) && (_MSC_VER >= 1020)
|
||||
# pragma once
|
||||
#endif
|
||||
|
||||
@@ -32,7 +32,7 @@ namespace archive {
|
||||
// do not derive from this class. If you want to extend this functionality
|
||||
// via inhertance, derived from binary_oarchive_impl instead. This will
|
||||
// preserve correct static polymorphism.
|
||||
class BOOST_SYMBOL_VISIBLE binary_oarchive :
|
||||
class binary_oarchive :
|
||||
public binary_oarchive_impl<
|
||||
binary_oarchive, std::ostream::char_type, std::ostream::traits_type
|
||||
>
|
||||
@@ -50,6 +50,8 @@ public:
|
||||
{}
|
||||
};
|
||||
|
||||
typedef binary_oarchive naked_binary_oarchive;
|
||||
|
||||
} // namespace archive
|
||||
} // namespace boost
|
||||
|
||||
|
||||
@@ -2,7 +2,7 @@
|
||||
#define BOOST_ARCHIVE_BINARY_OARCHIVE_IMPL_HPP
|
||||
|
||||
// MS compatible compilers support #pragma once
|
||||
#if defined(_MSC_VER)
|
||||
#if defined(_MSC_VER) && (_MSC_VER >= 1020)
|
||||
# pragma once
|
||||
#endif
|
||||
|
||||
@@ -18,6 +18,7 @@
|
||||
|
||||
#include <ostream>
|
||||
#include <boost/config.hpp>
|
||||
#include <boost/serialization/pfto.hpp>
|
||||
#include <boost/archive/basic_binary_oprimitive.hpp>
|
||||
#include <boost/archive/basic_binary_oarchive.hpp>
|
||||
|
||||
@@ -29,39 +30,29 @@
|
||||
namespace boost {
|
||||
namespace archive {
|
||||
|
||||
namespace detail {
|
||||
template<class Archive> class interface_oarchive;
|
||||
} // namespace detail
|
||||
|
||||
template<class Archive, class Elem, class Tr>
|
||||
class BOOST_SYMBOL_VISIBLE binary_oarchive_impl :
|
||||
class binary_oarchive_impl :
|
||||
public basic_binary_oprimitive<Archive, Elem, Tr>,
|
||||
public basic_binary_oarchive<Archive>
|
||||
{
|
||||
#ifdef BOOST_NO_MEMBER_TEMPLATE_FRIENDS
|
||||
public:
|
||||
#else
|
||||
friend class detail::interface_oarchive<Archive>;
|
||||
friend class basic_binary_oarchive<Archive>;
|
||||
friend class save_access;
|
||||
protected:
|
||||
#if BOOST_WORKAROUND(BOOST_MSVC, < 1500)
|
||||
// for some inexplicable reason insertion of "class" generates compile erro
|
||||
// on msvc 7.1
|
||||
friend detail::interface_oarchive<Archive>;
|
||||
friend basic_binary_oarchive<Archive>;
|
||||
friend save_access;
|
||||
#else
|
||||
friend class detail::interface_oarchive<Archive>;
|
||||
friend class basic_binary_oarchive<Archive>;
|
||||
friend class save_access;
|
||||
#endif
|
||||
#endif
|
||||
// note: the following should not needed - but one compiler (vc 7.1)
|
||||
// fails to compile one test (test_shared_ptr) without it !!!
|
||||
// make this protected so it can be called from a derived archive
|
||||
template<class T>
|
||||
void save_override(T & t){
|
||||
this->basic_binary_oarchive<Archive>::save_override(t);
|
||||
void save_override(T & t, BOOST_PFTO int){
|
||||
this->basic_binary_oarchive<Archive>::save_override(t, 0L);
|
||||
}
|
||||
void init(unsigned int flags) {
|
||||
if(0 != (flags & no_header)){
|
||||
if(0 != (flags & no_header))
|
||||
return;
|
||||
}
|
||||
#if ! defined(__MWERKS__)
|
||||
this->basic_binary_oarchive<Archive>::init();
|
||||
this->basic_binary_oprimitive<Archive, Elem, Tr>::init();
|
||||
|
||||
@@ -2,7 +2,7 @@
|
||||
#define BOOST_ARCHIVE_BINARY_WIARCHIVE_HPP
|
||||
|
||||
// MS compatible compilers support #pragma once
|
||||
#if defined(_MSC_VER)
|
||||
#if defined(_MSC_VER) && (_MSC_VER >= 1020)
|
||||
# pragma once
|
||||
#endif
|
||||
|
||||
@@ -28,6 +28,43 @@
|
||||
namespace boost {
|
||||
namespace archive {
|
||||
|
||||
// same as binary_wiarchive below - without the shared_ptr_helper
|
||||
class naked_binary_wiarchive :
|
||||
public binary_iarchive_impl<
|
||||
boost::archive::naked_binary_wiarchive,
|
||||
std::wistream::char_type,
|
||||
std::wistream::traits_type
|
||||
>
|
||||
{
|
||||
public:
|
||||
naked_binary_wiarchive(std::wistream & is, unsigned int flags = 0) :
|
||||
binary_iarchive_impl<
|
||||
naked_binary_wiarchive,
|
||||
std::wistream::char_type,
|
||||
std::wistream::traits_type
|
||||
>(is, flags)
|
||||
{}
|
||||
naked_binary_wiarchive(std::wstreambuf & bsb, unsigned int flags = 0) :
|
||||
binary_iarchive_impl<
|
||||
naked_binary_wiarchive,
|
||||
std::wistream::char_type,
|
||||
std::wistream::traits_type
|
||||
>(bsb, flags)
|
||||
{}
|
||||
};
|
||||
|
||||
} // namespace archive
|
||||
} // namespace boost
|
||||
|
||||
// note special treatment of shared_ptr. This type needs a special
|
||||
// structure associated with every archive. We created a "mix-in"
|
||||
// class to provide this functionality. Since shared_ptr holds a
|
||||
// special esteem in the boost library - we included it here by default.
|
||||
#include <boost/archive/shared_ptr_helper.hpp>
|
||||
|
||||
namespace boost {
|
||||
namespace archive {
|
||||
|
||||
class binary_wiarchive :
|
||||
public binary_iarchive_impl<
|
||||
binary_wiarchive, std::wistream::char_type, std::wistream::traits_type
|
||||
|
||||
@@ -2,7 +2,7 @@
|
||||
#define BOOST_ARCHIVE_BINARY_WOARCHIVE_HPP
|
||||
|
||||
// MS compatible compilers support #pragma once
|
||||
#if defined(_MSC_VER)
|
||||
#if defined(_MSC_VER) && (_MSC_VER >= 1020)
|
||||
# pragma once
|
||||
#endif
|
||||
|
||||
@@ -49,6 +49,8 @@ public:
|
||||
{}
|
||||
};
|
||||
|
||||
typedef binary_woarchive naked_binary_woarchive;
|
||||
|
||||
} // namespace archive
|
||||
} // namespace boost
|
||||
|
||||
|
||||
@@ -2,7 +2,7 @@
|
||||
#define BOOST_ARCHIVE_CODECVT_NULL_HPP
|
||||
|
||||
// MS compatible compilers support #pragma once
|
||||
#if defined(_MSC_VER)
|
||||
#if defined(_MSC_VER) && (_MSC_VER >= 1020)
|
||||
# pragma once
|
||||
#endif
|
||||
|
||||
@@ -18,11 +18,8 @@
|
||||
|
||||
#include <locale>
|
||||
#include <cstddef> // NULL, size_t
|
||||
#ifndef BOOST_NO_CWCHAR
|
||||
#include <cwchar> // for mbstate_t
|
||||
#endif
|
||||
#include <boost/config.hpp>
|
||||
#include <boost/serialization/force_include.hpp>
|
||||
#include <boost/archive/detail/auto_link_archive.hpp>
|
||||
#include <boost/archive/detail/abi_prefix.hpp> // must be the last header
|
||||
|
||||
@@ -59,14 +56,12 @@ public:
|
||||
explicit codecvt_null(std::size_t no_locale_manage = 0) :
|
||||
std::codecvt<char, char, std::mbstate_t>(no_locale_manage)
|
||||
{}
|
||||
virtual ~codecvt_null(){};
|
||||
};
|
||||
|
||||
template<>
|
||||
class BOOST_SYMBOL_VISIBLE codecvt_null<wchar_t> :
|
||||
public std::codecvt<wchar_t, char, std::mbstate_t>
|
||||
class codecvt_null<wchar_t> : public std::codecvt<wchar_t, char, std::mbstate_t>
|
||||
{
|
||||
virtual BOOST_WARCHIVE_DECL std::codecvt_base::result
|
||||
virtual BOOST_WARCHIVE_DECL(std::codecvt_base::result)
|
||||
do_out(
|
||||
std::mbstate_t & state,
|
||||
const wchar_t * first1,
|
||||
@@ -76,7 +71,7 @@ class BOOST_SYMBOL_VISIBLE codecvt_null<wchar_t> :
|
||||
char * last2,
|
||||
char * & next2
|
||||
) const;
|
||||
virtual BOOST_WARCHIVE_DECL std::codecvt_base::result
|
||||
virtual BOOST_WARCHIVE_DECL(std::codecvt_base::result)
|
||||
do_in(
|
||||
std::mbstate_t & state,
|
||||
const char * first1,
|
||||
@@ -92,11 +87,6 @@ class BOOST_SYMBOL_VISIBLE codecvt_null<wchar_t> :
|
||||
virtual int do_max_length( ) const throw( ){
|
||||
return do_encoding();
|
||||
}
|
||||
public:
|
||||
explicit codecvt_null(std::size_t no_locale_manage = 0) :
|
||||
std::codecvt<wchar_t, char, std::mbstate_t>(no_locale_manage)
|
||||
{}
|
||||
virtual ~codecvt_null(){};
|
||||
};
|
||||
|
||||
} // namespace archive
|
||||
|
||||
@@ -14,3 +14,7 @@
|
||||
# pragma warning(disable : 4251 4231 4660 4275)
|
||||
#endif
|
||||
|
||||
#if defined( __BORLANDC__ )
|
||||
#pragma nopushoptwarn
|
||||
#endif
|
||||
|
||||
|
||||
@@ -13,3 +13,7 @@
|
||||
#endif
|
||||
#include <boost/config/abi_suffix.hpp> // pops abi_suffix.hpp pragmas
|
||||
|
||||
#if defined( __BORLANDC__ )
|
||||
#pragma nopushoptwarn
|
||||
#endif
|
||||
|
||||
|
||||
Some files were not shown because too many files have changed in this diff Show More
Reference in New Issue
Block a user