Merge branch 'develop' into portable_binary_archive

a) appveyor for mingw
b) usage of macros "defined" in iserializer.hpp
c) extra decl... in codecvt_null
d) get_lock not found in singleton.hpp

.travis.yml

@@ -0,0 +1,72 @@
+# 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

CMake/CMakeLists.txt

@@ -2,6 +2,13 @@
 
 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")
@@ -14,15 +21,18 @@ endif()
 #
 
 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 )
+  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")
@@ -30,6 +40,7 @@ elseif( CMAKE_CXX_COMPILER_ID STREQUAL "AppleClang" )
   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()
 
 #
@@ -96,30 +107,46 @@ endif()
 # end special note for Xcode
 ############################
 
-find_package(Boost REQUIRED COMPONENTS system filesystem)
+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}")
-elseif()
-    message("Boost NOT Found!")
+    #include_directories("../include" "${Boost_INCLUDE_DIRS}")
+    #link_directories("${Boost_LIBRARY_DIRS}")
+else()
+    message(STATUS "Boost NOT Found!")
 endif()
 
 if(Boost_USE_STATIC_LIBS)
-  set(BUILD_SHARED_LIBRARIES OFF)
+  message(STATUS "Use static libraries")
+  set(LINK_TYPE "STATIC")
 else()
-  set(BUILD_SHARED_LIBRARIES ON)
+  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
+add_library(serialization ${LINK_TYPE}
   ../src/archive_exception.cpp
   ../src/basic_archive.cpp
   ../src/basic_iarchive.cpp
@@ -134,36 +161,34 @@ add_library(serialization
   ../src/basic_xml_archive.cpp
   ../src/binary_iarchive.cpp
   ../src/binary_oarchive.cpp
-  ../src/codecvt_null.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/text_wiarchive.cpp
-  ../src/text_woarchive.cpp
-  ../src/utf8_codecvt_facet.cpp
   ../src/void_cast.cpp
   ../src/xml_archive_exception.cpp
   ../src/xml_iarchive.cpp
   ../src/xml_oarchive.cpp
   ../src/xml_grammar.cpp
-  # ../src/basic_xml_grammar.ipp # doesn't show up in "Source Files" in Xcode"'
+  ../src/utf8_codecvt_facet.cpp
+  ../src/basic_xml_grammar.ipp # doesn't show up in "Source Files" in Xcode"'
 )
 
-add_library(wserialization
+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/utf8_codecvt_facet.cpp
   ../src/xml_wiarchive.cpp
   ../src/xml_woarchive.cpp
-  ../src/codecvt_null.cpp
   ../src/xml_wgrammar.cpp
+  ../src/basic_xml_grammar.ipp # doesn't show up in "Source Files" in Xcode"'
 )
 
 # end library build
@@ -190,7 +215,8 @@ function(archive_test test_name)
   endforeach()
   foreach(
     archive-name
-    IN ITEMS text_archive text_warchive binary_archive xml_archive xml_warchive
+    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})
@@ -211,7 +237,8 @@ function(polymorphic_archive_test test_name)
   endforeach()
   foreach(
     archive-name
-    IN ITEMS text_archive text_warchive binary_archive xml_archive xml_warchive
+    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})
@@ -242,10 +269,14 @@ serialization_test(test_iterators)
 serialization_test(test_iterators_base64)
 serialization_test(test_inclusion)
 serialization_test(test_smart_cast)
-serialization_test(test_utf8_codecvt ../src/utf8_codecvt_facet)
 serialization_test(test_codecvt_null ../src/codecvt_null)
+serialization_test(test_strong_typedef)
 
-archive_test(test_array A)
+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)
@@ -260,11 +291,14 @@ 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)
@@ -279,16 +313,24 @@ 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_base)
+archive_test(test_private_base2)
 archive_test(test_queue A)
 archive_test(test_recursion A)
 archive_test(test_registered)
-archive_test(test_set A)
 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)
@@ -297,9 +339,28 @@ 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_polymorphic test_polymorphic_A A)
 polymorphic_archive_test(test_polymorphic2 test_polymorphic2imp)
+polymorphic_archive_test(test_polymorphic_helper)
 
 # end test targets
 ####################
@@ -357,8 +418,7 @@ file(GLOB x
   RELATIVE "${CMAKE_CURRENT_SOURCE_DIR}" 
   "${CMAKE_CURRENT_SOURCE_DIR}/../include/boost/archive/*_w*.hpp"
 )
-
-add_custom_target(wserialization_headers SOURCES ${x} "${CMAKE_CURRENT_SOURCE_DIR}/../include/boost/archive/codecvt_null.hpp")
+add_custom_target(wserialization_headers SOURCES ${x})
 set_property(TARGET wserialization_headers PROPERTY FOLDER "wserialization")
 
 # end headers in IDE

appveyor.yml

@@ -0,0 +1,67 @@
+# 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

build/Jamfile.v2

@@ -80,6 +80,9 @@ SOURCES =
     xml_iarchive
     xml_oarchive
     xml_archive_exception
+    codecvt_null
+    utf8_codecvt_facet
+    singleton
 ;
     
 WSOURCES = 
@@ -87,19 +90,22 @@ 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>gcc:<cxxflags>"-fvisibility=hidden"
+    <toolset>msvc:<define>_SCL_SECURE_NO_WARNINGS
+    <toolset>clang:<cxxflags>"-fvisibility=hidden -fvisibility-inlines-hidden"
+    <toolset>gcc:<cxxflags>"-fvisibility=hidden -fvisibility-inlines-hidden"
+    <toolset>darwin:<cxxflags>"-fvisibility=hidden -fvisibility-inlines-hidden"
+    <toolset>gcc:<cxxflags>"-ftemplate-depth-255"
+    <toolset>clang:<cxxflags>"-ftemplate-depth-255"
+    <toolset>darwin:<cxxflags>"-ftemplate-depth-255"
     <link>shared:<define>BOOST_SERIALIZATION_DYN_LINK=1
     ;
 
@@ -107,7 +113,15 @@ lib boost_wserialization
     : $(WSOURCES).cpp boost_serialization 
     :     
     <toolset>msvc:<cxxflags>/Gy 
-    #<toolset>gcc:<cxxflags>"-fvisibility=hidden"
+    <toolset>msvc:<define>_SCL_SECURE_NO_WARNINGS
+    <toolset>clang:<cxxflags>"-fvisibility=hidden -fvisibility-inlines-hidden"
+    <toolset>gcc:<cxxflags>"-fvisibility=hidden -fvisibility-inlines-hidden"
+    <toolset>darwin:<cxxflags>"-fvisibility=hidden -fvisibility-inlines-hidden"
+    <toolset>gcc:<cxxflags>"-ftemplate-depth-255"
+    <toolset>clang:<cxxflags>"-ftemplate-depth-255"
+    <toolset>darwin:<cxxflags>"-ftemplate-depth-255"
+    # note: both serialization and wserialization are conditioned on the this
+    # switch - don't change it to BOOST_WSERIALIZATION_DYN_LINK
     <link>shared:<define>BOOST_SERIALIZATION_DYN_LINK=1
     ;
 

doc/archives.html

@@ -292,7 +292,7 @@ included in the code module containing the serialization code.
 
 </code></pre>
 
-All of these archives implement the same inteface. Hence, it should suffice to describe only one
+All of these archives implement the same interface. Hence, it should suffice to describe only one
 of them in detail.  For this purpose we will use the text archive.
 
 

doc/contents.html

@@ -253,7 +253,7 @@ function initialize() {
       <dd><div id="userincludes_detail"><dl class="page-index">
         <dt><img style="display:none" src="dot.gif"><a target="detail" href="headers.html#archiveimplementations">Archive Implementations</a>
         <dt><img style="display:none" src="dot.gif"><a target="detail" href="headers.html#serializationdeclarations">Serialization Declarations</a>
-        <dt><img style="display:none" 'rc="dot.gif"><a target="detail" href="headers.html#serializationimplementations">Serialization Implementations</a>
+        <dt><img style="display:none" src="dot.gif"><a target="detail" href="headers.html#serializationimplementations">Serialization Implementations</a>
       </dl></div>
       <dt><img style="display:none" src="plus.gif" id="libraryimplementation"><a target="detail" href="headers.html#libraryimplementation">Files Which Implement the Library</a>
       <dd><div id="libraryimplementation_detail"><dl class="page-index">
@@ -269,6 +269,7 @@ function initialize() {
     <dt><img style="display:none" src="dot.gif"><a target="detail" href="shared_ptr.html">Template serialization - <code>shared_ptr&lt;class T&gt;</code></a>
     <dt><img style="display:none" src="dot.gif"><a target="detail" href="shared_ptr2.html"><code>shared_ptr&lt;class T&gt;</code>Revisited</a>
     <dt><img style="display:none" src="dot.gif"><a target="detail" href="pimpl.html">PIMPL</a>
+    <dt><img style="display:none" src="dot.gif"><a target="detail" href="private_base.html">Private Base Classes</a>
     <dt><img style="display:none" src="dot.gif"><a target="detail" href="simple_log.html">A Simple Logging Archive Class</a>
     <dt><img style="display:none" src="dot.gif"><a target="detail" href="derivation.html">Derivation from an Existing Archive Class</a>
   </dl></div></dd>

doc/implementation.html

@@ -26,20 +26,13 @@ http://www.boost.org/LICENSE_1_0.txt)
 </table>
 <hr>
 <dl class="page-index">
-  <dt><a href="#functiontemplateordering">Partial Function Template Ordering</a>
   <dt><a href="#charencoding">Character Encoding</a>
-  <dt><a href="#tempatesyntax">Template Invocation syntax</a>
-  <dt><a href="#partialtemplatespecialization">Partial Template Specialization</a>
   <dt><a href="#othercompilerissues">Specific Compiler/Library Issues</a>
   <dl class="page-index">
-    <dt><a href="#gcc3x">GCC 3.X, 4.X</a>
-    <dt><a href="#gcc295">GCC 2.95</a>
+    <dt><a href="#gcc4x">44.X</a>
     <dt><a href="#intel80">Intel 8.0</a>
     <dt><a href="#vc80">Visual C++ 8.0</a>
     <dt><a href="#vc71">Visual C++ 7.1</a>
-    <dt><a href="#vc70">Visual C++ 7.0</a>
-    <dt><a href="#vc6">Visual C++ 6.0</a>
-    <dt><a href="#borland">Borland 5.64 and 5.51</a>
     <dt><a href="#comeau">Comeau 4.3.3</a>
     <dt><a href="#codewarrior9">Code Warrior 9.x</a>
     <dt><a href="#codewarrior">Code Warrior 8.3</a>
@@ -49,81 +42,6 @@ http://www.boost.org/LICENSE_1_0.txt)
   </dl>
 </dl>
 
-<h3><a name="functiontemplateordering">Partial Function Template Ordering</a></h3>
-Not all C++ compilers correctly support partial function template ordering (PFTO).
-For these compilers, the following code will fail to compile:
-<pre><code>
-template&lt;class Archive, class T&gt;
-void serialize(
-    Archive & ar, 
-    T & t, 
-    const unsigned int file_version
-){
-    ...
-}
-
-template&lt;class Archive, class T&gt;
-void serialize(
-    Archive & ar, 
-    my_template&lt;T&gt & t, 
-    const unsigned int file_version
-){
-    ...
-}
-</pre></code>
-The serialization library works around this issue by using a different
-default definition of the first template:
-<pre><code>
-template&lt;class Archive, class T&gt;
-void serialize(
-    Archive & ar, 
-    T & t, 
-    const unsigned long int file_version  // Note: change to long
-){
-    ...
-}
-</pre></code>
-Now, the second template is not matched with the first one so there
-is no PFTO and no compile error.  When the serialization library invokes
-<pre><code>
-serialize(ar, t, 0);
-</pre></code>
-the function declaration is first matched against templates with
-an integer for the third argument.  If there is a match, the matching
-template is instantiated and later invoked.  If there is no match,
-an attempt is made to match other templates by converting arguments to other types.
-In this case the third argument can be converted to long to match
-the first template - which is the default.  So in this case, the first
-template will be instantiated and later invoked.  We have managed to
-use function overloading to achieve the same effect as PFTO
-were it correctly implemented.
-<p>
-This depends upon undefined behavior of a compiler already
-determined to be non-conforming.  In other words, there is no 
-guarantee that this will work on all compilers.  If a compiler does not
-correctly support PFTO and this method cannot be used to workaround
-it, non-intrusive serialization cannot be supported for that compiler.
-As of this writing, such a compiler has not been encountered.
-<p>
-It turns out that using this "trick" can create problems with
-compilers that DO correctly support PFTO.  For this reason we
-define a macro <code style="white-space: normal">BOOST_PTFO</code> which 
-is defined to be <code style="white-space: normal">long</code>
-for non-conforming compilers and nothing for conforming ones. So
-the default definition is really:
-The serialization library works around this issue by using a different
-default definition of the first template:
-<pre><code>
-template&lt;class Archive, class T&gt;
-void serialize(
-    Archive & ar, 
-    T & t, 
-    const unsigned BOOST_PFTO int file_version  // Note: change to BOOST_PFTO
-){
-    ...
-}
-</pre></code>
-
 <h3><a name="charencoding">Character Encoding</a></h3>
 The whole question of character encoding combined with wide characters
 is much more complicated than it would seem to be. The current library
@@ -175,31 +93,8 @@ do the following.
   <li>Create the archive with the flag <code style="white-space: normal">no_codecvt</code>.
 </ul>
 Naturally, the input process has to be symmetrical.
-<h3><a name="partialtemplatespecialization">Partial Template Specialization</a></h3>
-Compilers which fail to support partial template specialization will fail to compile
-the following code.  To make this compile, the <code style="white-space: normal">const</code> has to be removed.
-<pre><code>
-void f(A const* a, text_oarchive& oa)
-{
-  oa << a;
-}
-</code></pre>
-<h3><a name="tempatesyntax">Template Invocation syntax</a></h3>
-Some compilers may not recognize the syntax:
-<pre><code>
-ar.template register_type&lt;T&gt;();
-</code></pre>
-for "registering" derived pointers of polymorphic classes.  The actual 
-function prototype is:
-<pre><code>
-template&lt;T&gt;
-void register_type(T * t = NULL);
-</code></pre>
-so that one may write <code style="white-space: normal">ar.register_type(static_cast&lt;T *&gt;(NULL))</code> instead of
-the syntax described above.
-</ul>
 <h3><a name="othercompilerissues">Specific Compiler/Library Issues</a></h3>
-<h4><a name="gcc3x">GCC 3.X, 4.X</a></h4>
+<h4><a name="gcc4x">GCC 4.X</a></h4>
 <ul>
     <li>GCC versions for Cygwin and MinGW fail to support wide character I/O.  
     So all tests using wide char I/O fail.  Note that if wide character I/O support
@@ -219,17 +114,6 @@ the syntax described above.
     -Wno-ctor-dtor-privacy
     </code></pre>
 </ul>
-<h4><a name="gcc295">GCC 2.95</a></h4>
-All of the above plus:<br>
-<ul>
-    <li>The serialization library depends on the templated stream 
-    implementation to function properly.
-    So STLPort must be used to build the library.
-    <li>Polymorphic archive tests fail.
-    <li>XML serialization only works with version 1.6x of spirit. In order to build 
-    and use this library with this compiler, one must use version 1.6x rather than the 
-    latest version shipped with boost. See <a href="release.html">Release Notes</a>. 
-</ul>
 <h4><a name="intel80">Intel C++ 8.0</a></h4>
 No known issues. All tests compile and run in debug and release modes.
 
@@ -311,77 +195,6 @@ 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&lt;A&gt;</code>,
-    invoke the macro <code style="white-space: normal">BOOST_SERIALIZATION_SHARED_PTR(A)</code>
-    in the header code.
-    <li>Lack of support for partial template specialization also creates problems for
-    serialization of <code style="white-space: normal">std::map</code>.  In order to serialize
-    instances of this type include the invocation of BOOST_BROKEN_COMPILER_TYPE_TRAITS_SPECIALIZATION
-    for the key type of the map.
-</ul>
-<h4><a name="vc6">Visual C++ 6.5</a></h4>
-all the above issues for Visual C++ 7.0 plus:
-<ul>
-    <li>Out of line template definitions are not recognized and fail with a confusing
-    error message.  To function save/load/serialize member function templates must be defined
-    within the class definition.  This feature is essential to <code style="white-space: normal">demo_pimpl</code>. Hence,
-    this program will fail to compile.  In this case the problem can't be worked around and
-    still demonstrate this facility.
-    <li>This compiler does not support <code style="white-space: normal">wchar_t</code> as a separate type.  It defines
-    <code style="white-space: normal">wchar_t</code> as an alias for <code style="white-space: normal">short int</code>.  In general things will still
-    function.  However certain customizations, 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 code
-    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.
@@ -434,7 +247,7 @@ These platforms have several issues:
 
 <hr>
 <p>Revised 1 November, 2004 
-<p><i>&copy; Copyright <a href="http://www.rrsd.com">Robert Ramey</a> 2002-2004. 
+<p><i>&copy; Copyright <a href="http://www.rrsd.com">Robert Ramey</a> 2002-2015.
 Distributed under the Boost Software License, Version 1.0. (See
 accompanying file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 </i></p>

doc/private_base.html

@@ -0,0 +1,170 @@
+<!doctype HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
+<html>
+<!--
+(C) Copyright 2002-4 Robert Ramey - http://www.rrsd.com . 
+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&lt;Base &&gt;(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&lt;Base &&gt;(*this)
+        );
+    }
+</code></pre>
+With this change the program will now compile.
+<p>
+If we made one of the functions of <code>Base></code> <code>virtual</code>
+in order to use the "export" functionality of the serialization library and permit serialization through
+a pointer the the base class, we'll be disappointed. Without the ability to
+cast to the base class, we can't use the functionality.
+<hr>
+<p><i>&copy; Copyright <a href="http://www.rrsd.com">Robert Ramey</a> 2015.
+Distributed under the Boost Software License, Version 1.0. (See
+accompanying file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+</i></p>
+</body>
+</html>

doc/release.html

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

doc/serialization.html

@@ -792,7 +792,7 @@ class derived : public base {
         ar & 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)
         )
     }

doc/special.html

@@ -568,10 +568,10 @@ void myclass::serialize(Archive & ar, const unsigned int version){
 	...
 }
 
-BOOST_EXPORT_CLASS_IMPLEMENT(my_class)
+BOOST_CLASS_EXPORT_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.

doc/tutorial/change_log.txt

@@ -0,0 +1,38 @@
+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

doc/tutorial/code/tutorial_pba_0.cpp

@@ -0,0 +1,56 @@
+/** 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

doc/tutorial/code/tutorial_pba_1.cpp

@@ -0,0 +1,68 @@
+/** 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

doc/tutorial/code/tutorial_pba_10.cpp

@@ -0,0 +1,162 @@
+/** 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

doc/tutorial/code/tutorial_pba_10b.cpp

@@ -0,0 +1,198 @@
+/** 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

doc/tutorial/code/tutorial_pba_11.cpp

@@ -0,0 +1,187 @@
+/** 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

doc/tutorial/code/tutorial_pba_2.cpp

@@ -0,0 +1,105 @@
+/** 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

doc/tutorial/code/tutorial_pba_3.cpp

@@ -0,0 +1,70 @@
+/** 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

doc/tutorial/code/tutorial_pba_4.cpp

@@ -0,0 +1,105 @@
+/** 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

doc/tutorial/code/tutorial_pba_5.cpp

@@ -0,0 +1,111 @@
+/** 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

doc/tutorial/code/tutorial_pba_6.cpp

@@ -0,0 +1,112 @@
+/** 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

doc/tutorial/code/tutorial_pba_7.cpp

@@ -0,0 +1,54 @@
+/** 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

doc/tutorial/code/tutorial_pba_8.cpp

@@ -0,0 +1,118 @@
+/** 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

doc/tutorial/code/tutorial_pba_9.cpp

@@ -0,0 +1,134 @@
+/** 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

doc/tutorial/release_notes.txt

@@ -0,0 +1,36 @@
+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

doc/tutorial/scripts/jquery-1.4.min.js

@@ -0,0 +1,151 @@
+/*!
+ * 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);

doc/tutorial/styles/boost.css

@@ -0,0 +1,39 @@
+/*=============================================================================
+    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;
+}
+*/

doc/tutorial/styles/style.css

@@ -0,0 +1,92 @@
+
+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)
+*/

example/Jamfile.v2

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

example/demo_fast_archive.cpp

@@ -11,7 +11,6 @@
 
 #include <boost/static_assert.hpp>
 #include <boost/type_traits/is_array.hpp>
-#include <boost/serialization/pfto.hpp>
 
 #define BOOST_ARCHIVE_SOURCE
 #include <boost/archive/binary_oarchive_impl.hpp>
@@ -61,26 +60,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, BOOST_PFTO int){
-        base_t::save_override(t, 0);
+    void save_override(T & t){
+        base_t::save_override(t);
         // verify that this program is in fact working by making sure
         // that arrays are getting passed here
         BOOST_STATIC_ASSERT(! (boost::is_array<T>::value) );
     }
     template<int N>
-    void save_override(const int (& t)[N] , int){
+    void save_override(const int (& t)[N]){
         save_binary(t, sizeof(t));
     }
     template<int N>
-    void save_override(const unsigned int (& t)[N], int){
+    void save_override(const unsigned int (& t)[N]){
         save_binary(t, sizeof(t));
     }
     template<int N>
-    void save_override(const long (& t)[N], int){
+    void save_override(const long (& t)[N]){
         save_binary(t, sizeof(t));
     }
     template<int N>
-    void save_override(const unsigned long (& t)[N], int){
+    void save_override(const unsigned long (& t)[N]){
         save_binary(t, sizeof(t));
     }
 public:
@@ -129,24 +128,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, BOOST_PFTO int){
-        base_t::load_override(t, 0);
+    void load_override(T & t){
+        base_t::load_override(t);
         BOOST_STATIC_ASSERT(! (boost::is_array<T>::value) );
     }
     template<int N>
-    void load_override(int (& t)[N], int){
+    void load_override(int (& t)[N]){
         load_binary(t, sizeof(t));
     }
     template<int N>
-    void load_override(unsigned int (& t)[N], int){
+    void load_override(unsigned int (& t)[N]){
         load_binary(t, sizeof(t));
     }
     template<int N>
-    void load_override(long (& t)[N], int){
+    void load_override(long (& t)[N]){
         load_binary(t, sizeof(t));
     }
     template<int N>
-    void load_override(unsigned long (& t)[N], int){
+    void load_override(unsigned long (& t)[N]){
         load_binary(t, sizeof(t));
     }
 public:

example/demo_log.cpp

@@ -13,8 +13,7 @@
 #include "demo_gps.hpp"
 #include "log_archive.hpp"
 
-int main(int argc, char *argv[])
-{   
+int main(int argc, char *argv[]){
     // make the schedule
     bus_schedule schedule;
 
@@ -65,7 +64,7 @@ int main(int argc, char *argv[])
 
     // display the complete schedule
     log_archive oa(std::cout);
-    //oa << BOOST_SERIALIZATION_NVP(schedule);
+    oa << BOOST_SERIALIZATION_NVP(schedule);
     oa << schedule;
 
     delete bs0;
@@ -74,3 +73,4 @@ int main(int argc, char *argv[])
     delete bs3;
     return 0;
 }
+

example/log_archive.hpp

@@ -19,11 +19,12 @@
 #include <boost/archive/xml_oarchive.hpp>
 
 namespace boost {
-namespace archive {
-    namespace detail {
-        template<class Archive> class interface_oarchive;
-    } // namespace detail
-} // namespace archive
+    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
@@ -43,34 +44,31 @@ class log_archive :
     // Override functions defined in basic_xml_oarchive
 
     // Anything not an attribute and not a name-value pair is an
-    // error and should be trapped here.  Note the usage of
-    // function argument matching (BOOST_PFTO) to permit usage
-    // with compilers which fail to properly support 
-    // function template ordering
+    // error and should be trapped here.
     template<class T>
-    void save_override(T & t, BOOST_PFTO int){
+    void save_override(T & t){
         // make it a name-value pair and pass it on.
         // this permits this to be used even with data types which
         // are not wrapped with the name
-        base::save_override(boost::serialization::make_nvp(NULL, t), 0);
+        base::save_override(boost::serialization::make_nvp(NULL, t));
     }
     template<class T>
-    void save_override(const boost::serialization::nvp< T > & t, int){
+    void save_override(const boost::serialization::nvp< T > & t){
         // this is here to remove the "const" requirement.  Since
         // this class is to be used only for output, it's not required.
-        base::save_override(t, 0);
+        base::save_override(t);
     }
     // specific overrides for attributes - not name value pairs so we
     // want to trap them before the above "fall through"
     // since we don't want to see these in the output - make them no-ops.
-    void save_override(const boost::archive::object_id_type & t, int){}
-    void save_override(const boost::archive::object_reference_type & t, int){}
-    void save_override(const boost::archive::version_type & t, int){}
-    void save_override(const boost::archive::class_id_type & t, int){}
-    void save_override(const boost::archive::class_id_optional_type & t, int){}
-    void save_override(const boost::archive::class_id_reference_type & t, int){}
-    void save_override(const boost::archive::class_name_type & t, int){}
-    void save_override(const boost::archive::tracking_type & t, int){}
+    void save_override(const boost::archive::object_id_type & t){}
+    void save_override(const boost::archive::object_reference_type & t){}
+    void save_override(const boost::archive::version_type & t){}
+    void save_override(const boost::archive::class_id_type & t){}
+    void save_override(const boost::archive::class_id_optional_type & t){}
+    void save_override(const boost::archive::class_id_reference_type & t){}
+    void save_override(const boost::archive::class_name_type & t){}
+    void save_override(const boost::archive::tracking_type & t){}
 public:
     log_archive(std::ostream & os, unsigned int flags = 0) :
         boost::archive::xml_oarchive_impl<log_archive>(

example/portable_binary_archive.hpp

@@ -13,7 +13,6 @@
 
 #include <boost/config.hpp>
 #include <boost/cstdint.hpp>
-#include <boost/serialization/pfto.hpp>
 #include <boost/static_assert.hpp>
 
 #include <climits>

example/portable_binary_iarchive.cpp

@@ -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, int
+    boost::archive::class_name_type & t
 ){
     std::string cn;
     cn.reserve(BOOST_SERIALIZATION_MAX_KEY_SIZE);
-    load_override(cn, 0);
+    load_override(cn);
     if(cn.size() > (BOOST_SERIALIZATION_MAX_KEY_SIZE - 1))
         boost::serialization::throw_exception(
             boost::archive::archive_exception(

example/portable_binary_iarchive.hpp

@@ -148,21 +148,15 @@ 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, BOOST_PFTO int){
-        this->detail_common_iarchive::load_override(t, 0);
+    void load_override(T & t){
+        this->detail_common_iarchive::load_override(t);
     }
-    void load_override(boost::archive::class_name_type & t, int);
+    void load_override(boost::archive::class_name_type & t);
     // binary files don't include the optional information 
-    void load_override(
-        boost::archive::class_id_optional_type & /* t */, 
-        int
-    ){}
+    void load_override(boost::archive::class_id_optional_type &){}
 
     void init(unsigned int flags);
 public:

example/portable_binary_oarchive.hpp

@@ -131,18 +131,17 @@ protected:
     typedef boost::archive::detail::common_oarchive<portable_binary_oarchive> 
         detail_common_oarchive;
     template<class T>
-    void save_override(T & t, BOOST_PFTO int){
-        this->detail_common_oarchive::save_override(t, 0);
+    void save_override(T & t){
+        this->detail_common_oarchive::save_override(t);
     }
     // explicitly convert to char * to avoid compile ambiguities
-    void save_override(const boost::archive::class_name_type & t, int){
+    void save_override(const boost::archive::class_name_type & t){
         const std::string s(t);
         * this << s;
     }
     // binary files don't include the optional information 
     void save_override(
-        const boost::archive::class_id_optional_type & /* t */, 
-        int
+        const boost::archive::class_id_optional_type & /* t */
     ){}
 
     void init(unsigned int flags);

include/boost/archive/add_facet.hpp

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

include/boost/archive/archive_exception.hpp

@@ -21,7 +21,6 @@
 #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
@@ -40,11 +39,16 @@ namespace archive {
 //////////////////////////////////////////////////////////////////////
 // exceptions thrown by archives
 //
-class BOOST_ARCHIVE_DECL(BOOST_PP_EMPTY()) archive_exception : 
+class BOOST_SYMBOL_VISIBLE archive_exception : 
     public virtual std::exception
 {
-protected:
+private:
     char m_buffer[128];
+protected:
+    BOOST_ARCHIVE_DECL unsigned int
+    append(unsigned int l, const char * a);
+    BOOST_ARCHIVE_DECL
+    archive_exception() BOOST_NOEXCEPT;
 public:
     typedef enum {
         no_exception,       // initialized without code
@@ -76,19 +80,16 @@ public:
                             // type has been instantiated in more than one module.
         output_stream_error // error on input stream
     } exception_code;
-public:
     exception_code code;
-    archive_exception(
+
+    BOOST_ARCHIVE_DECL archive_exception(
         exception_code c, 
         const char * e1 = NULL,
         const char * e2 = NULL
-    );
-    virtual ~archive_exception() throw();
-    virtual const char *what() const throw();
-protected:
-    unsigned int
-    append(unsigned int l, const char * a);
-    archive_exception();
+    ) BOOST_NOEXCEPT;
+    BOOST_ARCHIVE_DECL archive_exception(archive_exception const &) BOOST_NOEXCEPT ;
+    virtual BOOST_ARCHIVE_DECL ~archive_exception() BOOST_NOEXCEPT_OR_NOTHROW ;
+    virtual BOOST_ARCHIVE_DECL const char * what() const BOOST_NOEXCEPT_OR_NOTHROW ;
 };
 
 }// namespace archive

include/boost/archive/basic_archive.hpp

@@ -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 int () const {
+    operator base_type () const {
         return t;
     }                
     // used for text input
-    operator int_least16_t &() {
+    operator base_type &() {
         return t;
     }                
     bool operator==(const class_id_type & rhs) const {
@@ -162,11 +162,11 @@ public:
         return *this;
     }
     // used for text output
-    operator uint_least32_t () const {
+    operator base_type () const {
         return t;
     }                
     // used for text input
-    operator uint_least32_t & () {
+    operator base_type & () {
         return t;
     }                
     bool operator==(const object_id_type & rhs) const {
@@ -242,7 +242,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

include/boost/archive/basic_binary_iarchive.hpp

@@ -25,7 +25,6 @@
 
 #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>
@@ -51,7 +50,7 @@ namespace detail {
 /////////////////////////////////////////////////////////////////////////
 // class basic_binary_iarchive - read serialized objects from a input binary stream
 template<class Archive>
-class basic_binary_iarchive : 
+class BOOST_SYMBOL_VISIBLE basic_binary_iarchive : 
     public detail::common_iarchive<Archive>
 {
 #ifdef BOOST_NO_MEMBER_TEMPLATE_FRIENDS
@@ -72,8 +71,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, BOOST_PFTO int version){
-      this->detail_common_iarchive::load_override(t, static_cast<int>(version));
+    void load_override(T & t){
+      this->detail_common_iarchive::load_override(t);
     }
 
     // include these to trap a change in binary format which
@@ -86,7 +85,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 */, int){}
+    void load_override(class_id_optional_type & /* t */){}
 
     void load_override(tracking_type & t, int /*version*/){
         library_version_type lvt = this->get_library_version();
@@ -101,10 +100,10 @@ protected:
             t = boost::archive::tracking_type(x);
         }
     }
-    void load_override(class_id_type & t, int version){
+    void load_override(class_id_type & t){
         library_version_type lvt = this->get_library_version();
         if(boost::archive::library_version_type(7) < lvt){
-            this->detail_common_iarchive::load_override(t, version);
+            this->detail_common_iarchive::load_override(t);
         }
         else
         if(boost::archive::library_version_type(6) < lvt){
@@ -118,37 +117,14 @@ protected:
             t = boost::archive::class_id_type(x);
         }
     }
-    void load_override(class_id_reference_type & t, int version){
-        load_override(static_cast<class_id_type &>(t), version);
+    void load_override(class_id_reference_type & t){
+        load_override(static_cast<class_id_type &>(t));
     }
-#if 0
-    void load_override(class_id_reference_type & t, int version){
-        library_version_type lvt = this->get_library_version();
-        if(boost::archive::library_version_type(7) < lvt){
-            this->detail_common_iarchive::load_override(t, version);
-        }
-        else
-        if(boost::archive::library_version_type(6) < lvt){
-            int_least16_t x=0;
-            * this->This() >> x;
-            t = boost::archive::class_id_reference_type(
-                boost::archive::class_id_type(x)
-            );
-        }
-        else{
-            int x=0;
-            * this->This() >> x;
-            t = boost::archive::class_id_reference_type(
-                boost::archive::class_id_type(x)
-            );
-        }
-    }
-#endif
 
-    void load_override(version_type & t, int version){
+    void load_override(version_type & t){
         library_version_type lvt = this->get_library_version();
         if(boost::archive::library_version_type(7) < lvt){
-            this->detail_common_iarchive::load_override(t, version);
+            this->detail_common_iarchive::load_override(t);
         }
         else
         if(boost::archive::library_version_type(6) < lvt){
@@ -176,11 +152,11 @@ protected:
         }
     }
 
-    void load_override(boost::serialization::item_version_type & t, int version){
+    void load_override(boost::serialization::item_version_type & t){
         library_version_type lvt = this->get_library_version();
 //        if(boost::archive::library_version_type(7) < lvt){
         if(boost::archive::library_version_type(6) < lvt){
-            this->detail_common_iarchive::load_override(t, version);
+            this->detail_common_iarchive::load_override(t);
         }
         else
         if(boost::archive::library_version_type(6) < lvt){
@@ -195,9 +171,9 @@ protected:
         }
     }
 
-    void load_override(serialization::collection_size_type & t, int version){
+    void load_override(serialization::collection_size_type & t){
         if(boost::archive::library_version_type(5) < this->get_library_version()){
-            this->detail_common_iarchive::load_override(t, version);
+            this->detail_common_iarchive::load_override(t);
         }
         else{
             unsigned int x=0;
@@ -206,9 +182,9 @@ protected:
         } 
     }
 
-    BOOST_ARCHIVE_OR_WARCHIVE_DECL(void)
-    load_override(class_name_type & t, int);
-    BOOST_ARCHIVE_OR_WARCHIVE_DECL(void)
+    BOOST_ARCHIVE_OR_WARCHIVE_DECL void
+    load_override(class_name_type & t);
+    BOOST_ARCHIVE_OR_WARCHIVE_DECL void
     init();
    
     basic_binary_iarchive(unsigned int flags) :

include/boost/archive/basic_binary_iprimitive.hpp

@@ -44,16 +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/mpl/placeholders.hpp>
 #include <boost/serialization/is_bitwise_serializable.hpp>
-#include <boost/serialization/array.hpp>
+#include <boost/serialization/array_wrapper.hpp>
 
 #include <boost/archive/basic_streambuf_locale_saver.hpp>
+#include <boost/archive/codecvt_null.hpp>
 #include <boost/archive/archive_exception.hpp>
 #include <boost/archive/detail/auto_link_archive.hpp>
 #include <boost/archive/detail/abi_prefix.hpp> // must be the last header
@@ -61,14 +61,10 @@ namespace std{
 namespace boost { 
 namespace archive {
 
-template<class Ch>
-class codecvt_null;
-
 /////////////////////////////////////////////////////////////////////////////
 // class binary_iarchive - read serialized objects from a input binary stream
 template<class Archive, class Elem, class Tr>
-class basic_binary_iprimitive
-{
+class BOOST_SYMBOL_VISIBLE basic_binary_iprimitive {
 #ifndef BOOST_NO_MEMBER_TEMPLATE_FRIENDS
     friend class load_access;
 protected:
@@ -82,9 +78,16 @@ public:
     }
 
     #ifndef BOOST_NO_STD_LOCALE
-    boost::scoped_ptr<codecvt_null<Elem> > codecvt_facet;
-    boost::scoped_ptr<std::locale> archive_locale;
+    // note order! - if you change this, libstd++ will fail!
+    // a) create new locale with new codecvt facet
+    // b) save current locale
+    // c) change locale to new one
+    // d) use stream buffer
+    // e) change locale back to original
+    // f) destroy new codecvt facet
+    boost::archive::codecvt_null<Elem> codecvt_null_facet;
     basic_streambuf_locale_saver<Elem, Tr> locale_saver;
+    std::locale archive_locale;
     #endif
 
     // main template for serilization of primitive types
@@ -103,25 +106,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_PP_EMPTY()) 
+    BOOST_ARCHIVE_OR_WARCHIVE_DECL 
     basic_binary_iprimitive(
         std::basic_streambuf<Elem, Tr> & sb, 
         bool no_codecvt
     );
-    BOOST_ARCHIVE_OR_WARCHIVE_DECL(BOOST_PP_EMPTY()) 
+    BOOST_ARCHIVE_OR_WARCHIVE_DECL 
     ~basic_binary_iprimitive();
 public:
     // we provide an optimized load for all fundamental types
@@ -140,7 +143,7 @@ public:
 
     // the optimized load_array dispatches to load_binary 
     template <class ValueType>
-    void load_array(serialization::array<ValueType>& a, unsigned int)
+    void load_array(serialization::array_wrapper<ValueType>& a, unsigned int)
     {
       load_binary(a.address(),a.count()*sizeof(ValueType));
     }

include/boost/archive/basic_binary_oarchive.hpp

@@ -26,7 +26,6 @@
 #include <boost/assert.hpp>
 #include <boost/config.hpp>
 #include <boost/detail/workaround.hpp>
-#include <boost/serialization/pfto.hpp>
 
 #include <boost/integer.hpp>
 #include <boost/integer_traits.hpp>
@@ -59,8 +58,8 @@ 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 basic_binary_oarchive : 
-    public archive::detail::common_oarchive<Archive>
+class BOOST_SYMBOL_VISIBLE basic_binary_oarchive : 
+    public detail::common_oarchive<Archive>
 {
 #ifdef BOOST_NO_MEMBER_TEMPLATE_FRIENDS
 public:
@@ -77,8 +76,8 @@ protected:
     // 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, BOOST_PFTO int version){
-      this->detail_common_oarchive::save_override(t, static_cast<int>(version));
+    void save_override(const T & t){
+      this->detail_common_oarchive::save_override(t);
     }
 
     // include these to trap a change in binary format which
@@ -92,14 +91,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 */, int){}
+    void save_override(const class_id_optional_type & /* t */){}
 
     // enable this if we decide to support generation of previous versions
     #if 0
-    void save_override(const boost::archive::version_type & t, int version){
+    void save_override(const boost::archive::version_type & t){
         library_version_type lvt = this->get_library_version();
         if(boost::archive::library_version_type(7) < lvt){
-            this->detail_common_oarchive::save_override(t, version);
+            this->detail_common_oarchive::save_override(t);
         }
         else
         if(boost::archive::library_version_type(6) < lvt){
@@ -111,10 +110,10 @@ protected:
             * this->This() << x;
         }
     }
-    void save_override(const boost::serialization::item_version_type & t, int version){
+    void save_override(const boost::serialization::item_version_type & t){
         library_version_type lvt = this->get_library_version();
         if(boost::archive::library_version_type(7) < lvt){
-            this->detail_common_oarchive::save_override(t, version);
+            this->detail_common_oarchive::save_override(t);
         }
         else
         if(boost::archive::library_version_type(6) < lvt){
@@ -127,10 +126,10 @@ protected:
         }
     }
 
-    void save_override(class_id_type & t, int version){
+    void save_override(class_id_type & t){
         library_version_type lvt = this->get_library_version();
         if(boost::archive::library_version_type(7) < lvt){
-            this->detail_common_oarchive::save_override(t, version);
+            this->detail_common_oarchive::save_override(t);
         }
         else
         if(boost::archive::library_version_type(6) < lvt){
@@ -142,20 +141,20 @@ protected:
             * this->This() << x;
         }
     }
-    void save_override(class_id_reference_type & t, int version){
-        save_override(static_cast<class_id_type &>(t), version);
+    void save_override(class_id_reference_type & t){
+        save_override(static_cast<class_id_type &>(t));
     }
 
     #endif
 
     // explicitly convert to char * to avoid compile ambiguities
-    void save_override(const class_name_type & t, int){
+    void save_override(const class_name_type & t){
         const std::string s(t);
         * this->This() << s;
     }
 
     #if 0
-    void save_override(const serialization::collection_size_type & t, int){
+    void save_override(const serialization::collection_size_type & t){
         if (get_library_version() < boost::archive::library_version_type(6)){
             unsigned int x=0;
             * this->This() >> x;
@@ -166,7 +165,7 @@ protected:
         }
     }
     #endif
-    BOOST_ARCHIVE_OR_WARCHIVE_DECL(void)
+    BOOST_ARCHIVE_OR_WARCHIVE_DECL void
     init();
 
     basic_binary_oarchive(unsigned int flags) :

include/boost/archive/basic_binary_oprimitive.hpp

@@ -43,25 +43,24 @@ namespace std{
 #include <boost/scoped_ptr.hpp>
 #include <boost/serialization/throw_exception.hpp>
 
-#include <boost/archive/basic_streambuf_locale_saver.hpp>
-#include <boost/archive/archive_exception.hpp>
+//#include <boost/mpl/placeholders.hpp>
 #include <boost/serialization/is_bitwise_serializable.hpp>
-#include <boost/mpl/placeholders.hpp>
-#include <boost/serialization/array.hpp>
+#include <boost/serialization/array_wrapper.hpp>
+
+#include <boost/archive/basic_streambuf_locale_saver.hpp>
+#include <boost/archive/codecvt_null.hpp>
+#include <boost/archive/archive_exception.hpp>
 #include <boost/archive/detail/auto_link_archive.hpp>
 #include <boost/archive/detail/abi_prefix.hpp> // must be the last header
 
 namespace boost {
 namespace archive {
 
-template<class Ch>
-class codecvt_null;
-
 /////////////////////////////////////////////////////////////////////////
 // class basic_binary_oprimitive - binary output of prmitives
 
 template<class Archive, class Elem, class Tr>
-class basic_binary_oprimitive {
+class BOOST_SYMBOL_VISIBLE basic_binary_oprimitive {
 #ifndef BOOST_NO_MEMBER_TEMPLATE_FRIENDS
     friend class save_access;
 protected:
@@ -74,9 +73,16 @@ public:
         return static_cast<Archive *>(this);
     }
     #ifndef BOOST_NO_STD_LOCALE
-    boost::scoped_ptr<codecvt_null<Elem> > codecvt_facet;
-    boost::scoped_ptr<std::locale> archive_locale;
+    // note order! - if you change this, libstd++ will fail!
+    // a) create new locale with new codecvt facet
+    // b) save current locale
+    // c) change locale to new one
+    // d) use stream buffer
+    // e) change locale back to original
+    // f) destroy new codecvt facet
+    boost::archive::codecvt_null<Elem> codecvt_null_facet;
     basic_streambuf_locale_saver<Elem, Tr> locale_saver;
+    std::locale archive_locale;
     #endif
     // default saving of primitives.
     template<class T>
@@ -94,26 +100,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_PP_EMPTY()) 
+    BOOST_ARCHIVE_OR_WARCHIVE_DECL 
     basic_binary_oprimitive(
         std::basic_streambuf<Elem, Tr> & sb, 
         bool no_codecvt
     );
-    BOOST_ARCHIVE_OR_WARCHIVE_DECL(BOOST_PP_EMPTY()) 
+    BOOST_ARCHIVE_OR_WARCHIVE_DECL 
     ~basic_binary_oprimitive();
 public:
 
@@ -131,11 +137,10 @@ public:
             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<ValueType> const& a, unsigned int)
+    void save_array(boost::serialization::array_wrapper<ValueType> const& a, unsigned int)
     {
       save_binary(a.address(),a.count()*sizeof(ValueType));
     }
@@ -149,9 +154,7 @@ basic_binary_oprimitive<Archive, Elem, Tr>::save_binary(
     const void *address, 
     std::size_t count
 ){
-    //BOOST_ASSERT(
-    //    static_cast<std::size_t>((std::numeric_limits<std::streamsize>::max)()) >= count
-    //);
+    // BOOST_ASSERT(count <= std::size_t(boost::integer_traits<std::streamsize>::const_max));
     // note: if the following assertions fail
     // a likely cause is that the output stream is set to "text"
     // mode where by cr characters recieve special treatment.
@@ -161,9 +164,7 @@ 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);
-    BOOST_ASSERT(count <= std::size_t(boost::integer_traits<std::streamsize>::const_max));
+    count = ( count + sizeof(Elem) - 1) / sizeof(Elem);
     std::streamsize scount = m_sb.sputn(
         static_cast<const Elem *>(address), 
         static_cast<std::streamsize>(count)

include/boost/archive/basic_streambuf_locale_saver.hpp

@@ -27,6 +27,7 @@
 #ifndef BOOST_NO_STD_LOCALE
 
 #include <locale>     // for std::locale
+#include <ios>
 #include <streambuf>  // for std::basic_streambuf
 
 #include <boost/config.hpp>
@@ -45,25 +46,57 @@ class basic_streambuf_locale_saver :
     private boost::noncopyable
 {
 public:
-    typedef ::std::basic_streambuf<Ch, Tr> state_type;
-    typedef ::std::locale aspect_type;
-    explicit basic_streambuf_locale_saver( state_type &s )
-        : s_save_( s ), a_save_( s.getloc() )
-        {}
-    explicit 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_.pubsync();
-        s_save_.pubimbue( a_save_ );
+    explicit basic_streambuf_locale_saver(std::basic_streambuf<Ch, Tr> &s) :
+        m_streambuf(s),
+        m_locale(s.getloc())
+    {}
+    ~basic_streambuf_locale_saver(){
+        m_streambuf.pubsync();
+        m_streambuf.pubimbue(m_locale);
     }
 private:
-    state_type &       s_save_;
-    aspect_type const  a_save_;
+    std::basic_streambuf<Ch, Tr> &       m_streambuf;
+    std::locale const  m_locale;
 };
 
+template < typename Ch, class Tr >
+class basic_istream_locale_saver :
+    private boost::noncopyable
+{
+public:
+    explicit basic_istream_locale_saver(std::basic_istream<Ch, Tr> &s) :
+        m_istream(s),
+        m_locale(s.getloc())
+    {}
+    ~basic_istream_locale_saver(){
+        // libstdc++ crashes without this
+        m_istream.sync();
+        m_istream.imbue(m_locale);
+    }
+private:
+    std::basic_istream<Ch, Tr> & m_istream;
+    std::locale const  m_locale;
+};
+
+template < typename Ch, class Tr >
+class basic_ostream_locale_saver :
+    private boost::noncopyable
+{
+public:
+    explicit basic_ostream_locale_saver(std::basic_ostream<Ch, Tr> &s) :
+        m_ostream(s),
+        m_locale(s.getloc())
+    {}
+    ~basic_ostream_locale_saver(){
+        m_ostream.flush();
+        m_ostream.imbue(m_locale);
+    }
+private:
+    std::basic_ostream<Ch, Tr> & m_ostream;
+    std::locale const  m_locale;
+};
+
+
 } // archive
 } // boost
 

include/boost/archive/basic_text_iarchive.hpp

@@ -21,11 +21,10 @@
 //
 // 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_ostream<IStream::char_type> but rather
+// in such cases.   So we can't use basic_istream<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>
@@ -47,7 +46,7 @@ namespace detail {
 /////////////////////////////////////////////////////////////////////////
 // class basic_text_iarchive - read serialized objects from a input text stream
 template<class Archive>
-class basic_text_iarchive : 
+class BOOST_SYMBOL_VISIBLE basic_text_iarchive : 
     public detail::common_iarchive<Archive>
 {
 #ifdef BOOST_NO_MEMBER_TEMPLATE_FRIENDS
@@ -67,16 +66,16 @@ protected:
     // template ordering
     typedef detail::common_iarchive<Archive> detail_common_iarchive;
     template<class T>
-    void load_override(T & t, BOOST_PFTO int){
-        this->detail_common_iarchive::load_override(t, 0);
+    void load_override(T & t){
+        this->detail_common_iarchive::load_override(t);
     }
     // text file don't include the optional information 
-    void load_override(class_id_optional_type & /*t*/, int){}
+    void load_override(class_id_optional_type & /*t*/){}
 
-    BOOST_ARCHIVE_OR_WARCHIVE_DECL(void)
-    load_override(class_name_type & t, int);
+    BOOST_ARCHIVE_OR_WARCHIVE_DECL void
+    load_override(class_name_type & t);
 
-    BOOST_ARCHIVE_OR_WARCHIVE_DECL(void)
+    BOOST_ARCHIVE_OR_WARCHIVE_DECL void
     init(void);
 
     basic_text_iarchive(unsigned int flags) : 

include/boost/archive/basic_text_iprimitive.hpp

@@ -24,7 +24,6 @@
 // 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
 
@@ -38,17 +37,15 @@ 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
@@ -64,16 +61,24 @@ namespace archive {
 #endif
 
 template<class IStream>
-class basic_text_iprimitive {
+class BOOST_SYMBOL_VISIBLE basic_text_iprimitive {
 protected:
     IStream &is;
     io::ios_flags_saver flags_saver;
     io::ios_precision_saver precision_saver;
 
     #ifndef BOOST_NO_STD_LOCALE
-    boost::scoped_ptr<std::locale> archive_locale;
-    basic_streambuf_locale_saver<
-        typename IStream::char_type, 
+    // 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
     > locale_saver;
     #endif
@@ -116,12 +121,12 @@ protected:
         t = i;
     }
     #endif
-    BOOST_ARCHIVE_OR_WARCHIVE_DECL(BOOST_PP_EMPTY()) 
+    BOOST_ARCHIVE_OR_WARCHIVE_DECL 
     basic_text_iprimitive(IStream  &is, bool no_codecvt);
-    BOOST_ARCHIVE_OR_WARCHIVE_DECL(BOOST_PP_EMPTY()) 
+    BOOST_ARCHIVE_OR_WARCHIVE_DECL 
     ~basic_text_iprimitive();
 public:
-    BOOST_ARCHIVE_OR_WARCHIVE_DECL(void)
+    BOOST_ARCHIVE_OR_WARCHIVE_DECL void
     load_binary(void *address, std::size_t count);
 };
 

include/boost/archive/basic_text_oarchive.hpp

@@ -25,7 +25,6 @@
 // use two template parameters
 
 #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>
@@ -47,7 +46,7 @@ namespace detail {
 /////////////////////////////////////////////////////////////////////////
 // class basic_text_oarchive 
 template<class Archive>
-class basic_text_oarchive : 
+class BOOST_SYMBOL_VISIBLE basic_text_oarchive : 
     public detail::common_oarchive<Archive>
 {
 #ifdef BOOST_NO_MEMBER_TEMPLATE_FRIENDS
@@ -69,7 +68,7 @@ protected:
         space
     } delimiter;
 
-    BOOST_ARCHIVE_OR_WARCHIVE_DECL(void)
+    BOOST_ARCHIVE_OR_WARCHIVE_DECL void
     newtoken();
 
     void newline(){
@@ -80,25 +79,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, BOOST_PFTO int){
-        this->detail_common_oarchive::save_override(t, 0);
+    void save_override(T & t){
+        this->detail_common_oarchive::save_override(t);
     }
 
     // start new objects on a new line
-    void save_override(const object_id_type & t, int){
+    void save_override(const object_id_type & t){
         this->This()->newline();
-        this->detail_common_oarchive::save_override(t, 0);
+        this->detail_common_oarchive::save_override(t);
     }
 
     // text file don't include the optional information 
-    void save_override(const class_id_optional_type & /* t */, int){}
+    void save_override(const class_id_optional_type & /* t */){}
 
-    void save_override(const class_name_type & t, int){
+    void save_override(const class_name_type & t){
         const std::string s(t);
         * this->This() << s;
     }
 
-    BOOST_ARCHIVE_OR_WARCHIVE_DECL(void)
+    BOOST_ARCHIVE_OR_WARCHIVE_DECL void
     init();
 
     basic_text_oarchive(unsigned int flags) :

include/boost/archive/basic_text_oprimitive.hpp

@@ -26,14 +26,13 @@
 
 #include <iomanip>
 #include <locale>
-#include <boost/assert.hpp>
 #include <cstddef> // size_t
 
 #include <boost/config.hpp>
 #include <boost/static_assert.hpp>
-#include <boost/detail/workaround.hpp>
 #include <boost/io/ios_state.hpp>
 
+#include <boost/detail/workaround.hpp>
 #if BOOST_WORKAROUND(BOOST_DINKUMWARE_STDLIB, == 1)
 #include <boost/archive/dinkumware.hpp>
 #endif
@@ -52,10 +51,10 @@ namespace std{
 #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/archive_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/detail/abi_prefix.hpp> // must be the last header
 
 namespace boost {
@@ -64,7 +63,7 @@ namespace archive {
 /////////////////////////////////////////////////////////////////////////
 // class basic_text_oprimitive - output of prmitives to stream
 template<class OStream>
-class basic_text_oprimitive
+class BOOST_SYMBOL_VISIBLE basic_text_oprimitive
 {
 protected:
     OStream &os;
@@ -72,9 +71,17 @@ protected:
     io::ios_precision_saver precision_saver;
 
     #ifndef BOOST_NO_STD_LOCALE
-    boost::scoped_ptr<std::locale> archive_locale;
-    basic_streambuf_locale_saver<
-        typename OStream::char_type, 
+    // 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
     > locale_saver;
     #endif
@@ -168,15 +175,13 @@ protected:
 
     template<class T>
     void save(const T & t){
-        boost::io::ios_flags_saver fs(os);
-        boost::io::ios_precision_saver ps(os);
         typename is_float<T>::type tf;
         save_impl(t, tf);
     }
 
-    BOOST_ARCHIVE_OR_WARCHIVE_DECL(BOOST_PP_EMPTY())
+    BOOST_ARCHIVE_OR_WARCHIVE_DECL
     basic_text_oprimitive(OStream & os, bool no_codecvt);
-    BOOST_ARCHIVE_OR_WARCHIVE_DECL(BOOST_PP_EMPTY()) 
+    BOOST_ARCHIVE_OR_WARCHIVE_DECL 
     ~basic_text_oprimitive();
 public:
     // unformatted append of one character
@@ -192,7 +197,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);
 };
 

include/boost/archive/basic_xml_archive.hpp

@@ -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

include/boost/archive/basic_xml_iarchive.hpp

@@ -17,16 +17,12 @@
 //  See http://www.boost.org for updates, documentation, and revision history.
 
 #include <boost/config.hpp>
-#include <boost/serialization/pfto.hpp>
-#include <boost/detail/workaround.hpp>
+#include <boost/mpl/assert.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
@@ -42,39 +38,33 @@ namespace detail {
 } // namespace detail
 
 /////////////////////////////////////////////////////////////////////////
-// class xml_iarchive - read serialized objects from a input text stream
+// class basic_xml_iarchive - read serialized objects from a input text stream
 template<class Archive>
-class basic_xml_iarchive :
+class BOOST_SYMBOL_VISIBLE basic_xml_iarchive :
     public detail::common_iarchive<Archive>
 {
+    unsigned int depth;
 #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
+    friend class detail::interface_iarchive<Archive>;
 #endif
-    unsigned int depth;
-    BOOST_ARCHIVE_OR_WARCHIVE_DECL(void)
+    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,  BOOST_PFTO int)
+    void load_override(T & t)
     {
         // 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, 0);
+        this->detail_common_iarchive::load_override(t);
     }
 
     // Anything not an attribute - see below - should be a name value
@@ -82,14 +72,10 @@ protected:
     typedef detail::common_iarchive<Archive> detail_common_iarchive;
     template<class T>
     void load_override(
-        #ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING
-        const
-        #endif
-        boost::serialization::nvp< T > & t,
-        int
+        const boost::serialization::nvp< T > & t
     ){
         this->This()->load_start(t.name());
-        this->detail_common_iarchive::load_override(t.value(), 0);
+        this->detail_common_iarchive::load_override(t.value());
         this->This()->load_end(t.name());
     }
 
@@ -101,23 +87,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
-    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);
+    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);
     // 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, int);
+    // void load_override(class_name_type & t);
 
-    BOOST_ARCHIVE_OR_WARCHIVE_DECL(BOOST_PP_EMPTY())
+    BOOST_ARCHIVE_OR_WARCHIVE_DECL
     basic_xml_iarchive(unsigned int flags);
-    BOOST_ARCHIVE_OR_WARCHIVE_DECL(BOOST_PP_EMPTY())
+    BOOST_ARCHIVE_OR_WARCHIVE_DECL
     ~basic_xml_iarchive();
 };
 

include/boost/archive/basic_xml_oarchive.hpp

@@ -18,16 +18,11 @@
 
 #include <boost/config.hpp>
 #include <boost/mpl/assert.hpp>
-#include <boost/serialization/pfto.hpp>
-#include <boost/detail/workaround.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/archive/detail/abi_prefix.hpp> // must be the last header
 
 #ifdef BOOST_MSVC
@@ -45,98 +40,89 @@ namespace detail {
 //////////////////////////////////////////////////////////////////////
 // class basic_xml_oarchive - write serialized objects to a xml output stream
 template<class Archive>
-class basic_xml_oarchive :
+class BOOST_SYMBOL_VISIBLE basic_xml_oarchive :
     public detail::common_oarchive<Archive>
 {
+    // special stuff for xml output
+    unsigned int depth;
+    bool pending_preamble;
 #ifdef BOOST_NO_MEMBER_TEMPLATE_FRIENDS
 public:
 #else
 protected:
-#endif
-#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
-    friend class save_access;
-    // special stuff for xml output
-    unsigned int depth;
     bool indent_next;
-    bool pending_preamble;
-    BOOST_ARCHIVE_OR_WARCHIVE_DECL(void)
+    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)
+    BOOST_ARCHIVE_OR_WARCHIVE_DECL void
+    windup();
+    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, BOOST_PFTO int)
+    void save_override(T & t)
     {
         // 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, 0);
+        this->detail_common_oarchive::save_override(t);
     }
 
     // special treatment for name-value pairs.
     typedef detail::common_oarchive<Archive> detail_common_oarchive;
     template<class T>
     void save_override(
-        #ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING
-        const
-        #endif
-        ::boost::serialization::nvp< T > & t,
-        int
+        const ::boost::serialization::nvp< T > & t
     ){
         this->This()->save_start(t.name());
-        this->detail_common_oarchive::save_override(t.const_value(), 0);
+        this->detail_common_oarchive::save_override(t.const_value());
         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 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 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(BOOST_PP_EMPTY())
+    BOOST_ARCHIVE_OR_WARCHIVE_DECL
     basic_xml_oarchive(unsigned int flags);
-    BOOST_ARCHIVE_OR_WARCHIVE_DECL(BOOST_PP_EMPTY())
+    BOOST_ARCHIVE_OR_WARCHIVE_DECL
     ~basic_xml_oarchive();
 };
 

include/boost/archive/binary_iarchive.hpp

@@ -31,7 +31,7 @@ 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 binary_iarchive : 
+class BOOST_SYMBOL_VISIBLE binary_iarchive :
     public binary_iarchive_impl<
         boost::archive::binary_iarchive, 
         std::istream::char_type, 

include/boost/archive/binary_iarchive_impl.hpp

@@ -17,7 +17,6 @@
 //  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>
 
@@ -34,7 +33,7 @@ namespace detail {
 } // namespace detail
 
 template<class Archive, class Elem, class Tr>
-class binary_iarchive_impl : 
+class BOOST_SYMBOL_VISIBLE binary_iarchive_impl : 
     public basic_binary_iprimitive<Archive, Elem, Tr>,
     public basic_binary_iarchive<Archive>
 {
@@ -54,16 +53,14 @@ protected:
         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, BOOST_PFTO int){
-        this->basic_binary_iarchive<Archive>::load_override(t, 0L);
+    void load_override(T & t){
+        this->basic_binary_iarchive<Archive>::load_override(t);
     }
     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();

include/boost/archive/binary_oarchive.hpp

@@ -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 binary_oarchive : 
+class BOOST_SYMBOL_VISIBLE binary_oarchive : 
     public binary_oarchive_impl<
         binary_oarchive, std::ostream::char_type, std::ostream::traits_type
     >

include/boost/archive/binary_oarchive_impl.hpp

@@ -18,7 +18,6 @@
 
 #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>
 
@@ -35,7 +34,7 @@ namespace detail {
 } // namespace detail
 
 template<class Archive, class Elem, class Tr>
-class binary_oarchive_impl : 
+class BOOST_SYMBOL_VISIBLE binary_oarchive_impl : 
     public basic_binary_oprimitive<Archive, Elem, Tr>,
     public basic_binary_oarchive<Archive>
 {
@@ -55,16 +54,14 @@ protected:
         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, BOOST_PFTO int){
-        this->basic_binary_oarchive<Archive>::save_override(t, 0L);
+    void save_override(T & t){
+        this->basic_binary_oarchive<Archive>::save_override(t);
     }
     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();

include/boost/archive/codecvt_null.hpp

@@ -18,8 +18,11 @@
 
 #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
 
@@ -56,12 +59,14 @@ 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 codecvt_null<wchar_t> : public std::codecvt<wchar_t, char, std::mbstate_t>
+class BOOST_SYMBOL_VISIBLE 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,
@@ -71,7 +76,7 @@ class codecvt_null<wchar_t> : public std::codecvt<wchar_t, char, std::mbstate_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,
@@ -91,6 +96,7 @@ 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

include/boost/archive/detail/abi_prefix.hpp

@@ -14,7 +14,3 @@
 #  pragma warning(disable : 4251 4231 4660 4275)
 #endif
 
-#if defined( __BORLANDC__ )
-#pragma nopushoptwarn
-#endif
-

include/boost/archive/detail/abi_suffix.hpp

@@ -13,7 +13,3 @@
 #endif
 #include <boost/config/abi_suffix.hpp> // pops abi_suffix.hpp pragmas
 
-#if defined( __BORLANDC__ )
-#pragma nopushoptwarn
-#endif
-

include/boost/archive/detail/archive_serializer_map.hpp

@@ -36,12 +36,11 @@ namespace detail {
 class basic_serializer;
 
 template<class Archive>
-class BOOST_ARCHIVE_OR_WARCHIVE_DECL(BOOST_PP_EMPTY()) 
-archive_serializer_map {
+class BOOST_SYMBOL_VISIBLE archive_serializer_map {
 public:
-    static bool insert(const basic_serializer * bs);
-    static void erase(const basic_serializer * bs);
-    static const basic_serializer * find(
+    static BOOST_ARCHIVE_OR_WARCHIVE_DECL bool insert(const basic_serializer * bs);
+    static BOOST_ARCHIVE_OR_WARCHIVE_DECL void erase(const basic_serializer * bs);
+    static BOOST_ARCHIVE_OR_WARCHIVE_DECL const basic_serializer * find(
         const boost::serialization::extended_type_info & type_
     );
 };

include/boost/archive/detail/basic_archive_impl.hpp

@@ -1,45 +0,0 @@
-#ifndef BOOST_ARCHIVE_DETAIL_BASIC_ARCHIVE_IMPL_HPP
-#define BOOST_ARCHIVE_DETAIL_BASIC_ARCHIVE_IMPL_HPP
-
-// MS compatible compilers support #pragma once
-#if defined(_MSC_VER)
-# pragma once
-#endif
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// basic_archive_impl.hpp:
-
-// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
-// http://www.boost.org/LICENSE_1_0.txt)
-
-//  See http://www.boost.org for updates, documentation, and revision history.
-
-#include <set>
-
-#include <boost/archive/detail/abi_prefix.hpp> // must be the last header
-
-namespace boost {
-namespace serialization {
-    class extended_type_info;
-} // namespace serialization
-
-namespace archive {
-namespace detail {
-
-//////////////////////////////////////////////////////////////////////
-class BOOST_ARCHIVE_DECL(BOOST_PP_EMPTY()) basic_archive_impl
-{
-};
-
-} // namespace detail
-} // namespace serialization
-} // namespace boost
-
-#include <boost/archive/detail/abi_suffix.hpp> // pops abi_suffix.hpp pragmas
-
-#endif //BOOST_ARCHIVE_DETAIL_BASIC_ARCHIVE_IMPL_HPP
-
-
-

include/boost/archive/detail/basic_config.hpp

@@ -1,45 +0,0 @@
-#ifndef BOOST_ARCHIVE_DETAIL_BASIC_CONFIG_HPP
-#define BOOST_ARCHIVE_DETAIL_BASIC_CONFIG_HPP
-
-// MS compatible compilers support #pragma once
-#if defined(_MSC_VER)
-# pragma once
-#endif
-
-//  basic_config.hpp  ---------------------------------------------//
-
-//  (c) Copyright Robert Ramey 2004
-//  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 library home page at http://www.boost.org/libs/serialization
-
-//----------------------------------------------------------------------------// 
-
-// This header implements separate compilation features as described in
-// http://www.boost.org/more/separate_compilation.html
-
-#include <boost/config.hpp>
-
-#ifdef BOOST_HAS_DECLSPEC // defined in config system
-// we need to import/export our code only if the user has specifically
-// asked for it by defining either BOOST_ALL_DYN_LINK if they want all boost
-// libraries to be dynamically linked, or BOOST_ARCHIVE_DYN_LINK
-// if they want just this one to be dynamically linked:
-#if defined(BOOST_ALL_DYN_LINK) || defined(BOOST_ARCHIVE_DYN_LINK)
-// export if this is our own source, otherwise import:
-#ifdef BOOST_ARCHIVE_SOURCE
-# define BOOST_ARCHIVE_DECL __declspec(dllexport)
-#else
-# define BOOST_ARCHIVE_DECL __declspec(dllimport)
-#endif  // BOOST_ARCHIVE_SOURCE
-#endif  // DYN_LINK
-#endif  // BOOST_HAS_DECLSPEC
-//
-// if BOOST_ARCHIVE_DECL isn't defined yet define it now:
-#ifndef BOOST_ARCHIVE_DECL
-#define BOOST_ARCHIVE_DECL
-#endif
-
-#endif // BOOST_ARCHIVE_DETAIL_BASIC_CONFIG_HPP

include/boost/archive/detail/basic_iarchive.hpp

@@ -37,11 +37,12 @@ namespace archive {
 namespace detail {
 
 class basic_iarchive_impl;
-class BOOST_ARCHIVE_DECL(BOOST_PP_EMPTY()) basic_iserializer;
-class BOOST_ARCHIVE_DECL(BOOST_PP_EMPTY()) basic_pointer_iserializer;
+class basic_iserializer;
+class basic_pointer_iserializer;
+
 //////////////////////////////////////////////////////////////////////
 // class basic_iarchive - read serialized objects from a input stream
-class BOOST_ARCHIVE_DECL(BOOST_PP_EMPTY()) basic_iarchive :
+class BOOST_SYMBOL_VISIBLE basic_iarchive :
     private boost::noncopyable,
     public boost::archive::detail::helper_collection
 {
@@ -56,41 +57,42 @@ class BOOST_ARCHIVE_DECL(BOOST_PP_EMPTY()) basic_iarchive :
     virtual void vload(class_name_type &t) = 0;
     virtual void vload(tracking_type &t) = 0;
 protected:
-    basic_iarchive(unsigned int flags);
+    BOOST_ARCHIVE_DECL basic_iarchive(unsigned int flags);
+    boost::archive::detail::helper_collection &
+    get_helper_collection(){
+        return *this;
+    }
 public:
-    // account for bogus gcc warning
-    #if defined(__GNUC__)
-    virtual
-    #endif
-    ~basic_iarchive();
+    // some msvc versions require that the following function be public
+    // otherwise it should really protected.
+    virtual BOOST_ARCHIVE_DECL ~basic_iarchive();
     // note: NOT part of the public API.
-    void next_object_pointer(void *t);
-    void register_basic_serializer(
+    BOOST_ARCHIVE_DECL void next_object_pointer(void *t);
+    BOOST_ARCHIVE_DECL void register_basic_serializer(
         const basic_iserializer & bis
     );
-    void load_object(
+    BOOST_ARCHIVE_DECL void load_object(
         void *t, 
         const basic_iserializer & bis
     );
-    const basic_pointer_iserializer * 
+    BOOST_ARCHIVE_DECL const basic_pointer_iserializer * 
     load_pointer(
         void * & t, 
         const basic_pointer_iserializer * bpis_ptr,
         const basic_pointer_iserializer * (*finder)(
             const boost::serialization::extended_type_info & eti
         )
-
     );
     // real public API starts here
-    void 
+    BOOST_ARCHIVE_DECL void 
     set_library_version(library_version_type archive_library_version);
-    library_version_type 
+    BOOST_ARCHIVE_DECL library_version_type 
     get_library_version() const;
-    unsigned int
+    BOOST_ARCHIVE_DECL unsigned int
     get_flags() const;
-    void 
+    BOOST_ARCHIVE_DECL void 
     reset_object_address(const void * new_address, const void * old_address);
-    void 
+    BOOST_ARCHIVE_DECL void 
     delete_created_pointers();
 };
 

include/boost/archive/detail/basic_iserializer.hpp

@@ -39,23 +39,19 @@ namespace serialization {
 namespace archive {
 namespace detail {
 
-class BOOST_ARCHIVE_DECL(BOOST_PP_EMPTY()) basic_iarchive;
-class BOOST_ARCHIVE_DECL(BOOST_PP_EMPTY()) basic_pointer_iserializer;
+class basic_iarchive;
+class basic_pointer_iserializer;
 
-class BOOST_ARCHIVE_DECL(BOOST_PP_EMPTY()) basic_iserializer : 
+class BOOST_SYMBOL_VISIBLE basic_iserializer : 
     public basic_serializer
 {
 private:
     basic_pointer_iserializer *m_bpis;
 protected:
-    explicit basic_iserializer(
+    explicit BOOST_ARCHIVE_DECL basic_iserializer(
         const boost::serialization::extended_type_info & type
     );
-    // account for bogus gcc warning
-    #if defined(__GNUC__)
-    virtual
-    #endif
-    ~basic_iserializer();
+    virtual BOOST_ARCHIVE_DECL ~basic_iserializer();
 public:
     bool serialized_as_pointer() const {
         return m_bpis != NULL;

include/boost/archive/detail/basic_oarchive.hpp

@@ -35,12 +35,12 @@ namespace archive {
 namespace detail {
 
 class basic_oarchive_impl;
-class BOOST_ARCHIVE_DECL(BOOST_PP_EMPTY()) basic_oserializer;
-class BOOST_ARCHIVE_DECL(BOOST_PP_EMPTY()) basic_pointer_oserializer;
+class basic_oserializer;
+class basic_pointer_oserializer;
 
 //////////////////////////////////////////////////////////////////////
 // class basic_oarchive - write serialized objects to an output stream
-class BOOST_ARCHIVE_OR_WARCHIVE_DECL(BOOST_PP_EMPTY()) basic_oarchive :
+class BOOST_SYMBOL_VISIBLE basic_oarchive :
     private boost::noncopyable,
     public boost::archive::detail::helper_collection
 {
@@ -59,22 +59,20 @@ class BOOST_ARCHIVE_OR_WARCHIVE_DECL(BOOST_PP_EMPTY()) basic_oarchive :
     virtual void vsave(const class_name_type & t) = 0;
     virtual void vsave(const tracking_type t) = 0;
 protected:
-    basic_oarchive(unsigned int flags = 0);
-    // account for bogus gcc warning
-    #if defined(__GNUC__)
-    virtual
-    #endif
-    ~basic_oarchive();
+    BOOST_ARCHIVE_DECL basic_oarchive(unsigned int flags = 0);
+    BOOST_ARCHIVE_DECL boost::archive::detail::helper_collection &
+    get_helper_collection();
+    virtual BOOST_ARCHIVE_DECL ~basic_oarchive();
 public:
     // note: NOT part of the public interface
-    void register_basic_serializer(
+    BOOST_ARCHIVE_DECL void register_basic_serializer(
         const basic_oserializer & bos
     );
-    void save_object(
+    BOOST_ARCHIVE_DECL void save_object(
         const void *x, 
         const basic_oserializer & bos
     );
-    void save_pointer(
+    BOOST_ARCHIVE_DECL void save_pointer(
         const void * t, 
         const basic_pointer_oserializer * bpos_ptr
     );
@@ -82,9 +80,9 @@ public:
         vsave(NULL_POINTER_TAG);
     }
     // real public interface starts here
-    void end_preamble(); // default implementation does nothing
-    library_version_type get_library_version() const;
-    unsigned int get_flags() const;
+    BOOST_ARCHIVE_DECL void end_preamble(); // default implementation does nothing
+    BOOST_ARCHIVE_DECL library_version_type get_library_version() const;
+    BOOST_ARCHIVE_DECL unsigned int get_flags() const;
 };
 
 } // namespace detail

include/boost/archive/detail/basic_oserializer.hpp

@@ -40,23 +40,19 @@ namespace serialization {
 namespace archive {
 namespace detail {
 
-class BOOST_ARCHIVE_DECL(BOOST_PP_EMPTY()) basic_oarchive;
-class BOOST_ARCHIVE_DECL(BOOST_PP_EMPTY()) basic_pointer_oserializer;
+class basic_oarchive;
+class basic_pointer_oserializer;
 
-class BOOST_ARCHIVE_DECL(BOOST_PP_EMPTY()) basic_oserializer : 
+class BOOST_SYMBOL_VISIBLE basic_oserializer :
     public basic_serializer
 {
 private:
     basic_pointer_oserializer *m_bpos;
 protected:
-    explicit basic_oserializer(
+    explicit BOOST_ARCHIVE_DECL basic_oserializer(
         const boost::serialization::extended_type_info & type_
     );
-    // account for bogus gcc warning
-    #if defined(__GNUC__)
-    virtual
-    #endif
-    ~basic_oserializer();
+    virtual BOOST_ARCHIVE_DECL ~basic_oserializer();
 public:
     bool serialized_as_pointer() const {
         return m_bpos != NULL;

include/boost/archive/detail/basic_pointer_iserializer.hpp

@@ -37,20 +37,16 @@ namespace serialization {
 namespace archive {
 namespace detail {
 
-class BOOST_ARCHIVE_DECL(BOOST_PP_EMPTY()) basic_iarchive;
-class BOOST_ARCHIVE_DECL(BOOST_PP_EMPTY()) basic_iserializer;
+class basic_iarchive;
+class basic_iserializer;
 
-class BOOST_ARCHIVE_DECL(BOOST_PP_EMPTY()) basic_pointer_iserializer 
+class BOOST_SYMBOL_VISIBLE basic_pointer_iserializer
     : public basic_serializer {
 protected:
-    explicit basic_pointer_iserializer(
+    explicit BOOST_ARCHIVE_DECL basic_pointer_iserializer(
         const boost::serialization::extended_type_info & type_
     );
-    // account for bogus gcc warning
-    #if defined(__GNUC__)
-    virtual
-    #endif
-    ~basic_pointer_iserializer();
+    virtual BOOST_ARCHIVE_DECL ~basic_pointer_iserializer();
 public:
     virtual void * heap_allocation() const = 0;
     virtual const basic_iserializer & get_basic_serializer() const = 0;

include/boost/archive/detail/basic_pointer_oserializer.hpp

@@ -36,22 +36,18 @@ namespace serialization {
 namespace archive {
 namespace detail {
 
-class BOOST_ARCHIVE_DECL(BOOST_PP_EMPTY()) basic_oarchive;
-class BOOST_ARCHIVE_DECL(BOOST_PP_EMPTY()) basic_oserializer;
+class basic_oarchive;
+class basic_oserializer;
 
-class BOOST_ARCHIVE_DECL(BOOST_PP_EMPTY()) basic_pointer_oserializer : 
+class BOOST_SYMBOL_VISIBLE basic_pointer_oserializer : 
     public basic_serializer
 {
 protected:
-    explicit basic_pointer_oserializer(
+    explicit BOOST_ARCHIVE_DECL basic_pointer_oserializer(
         const boost::serialization::extended_type_info & type_
     );
 public:
-    // account for bogus gcc warning
-    #if defined(__GNUC__)
-    virtual
-    #endif
-    ~basic_pointer_oserializer();
+    virtual BOOST_ARCHIVE_DECL ~basic_pointer_oserializer();
     virtual const basic_oserializer & get_basic_serializer() const = 0;
     virtual void save_object_ptr(
         basic_oarchive & ar,

include/boost/archive/detail/basic_serializer.hpp

@@ -41,9 +41,7 @@ protected:
         const boost::serialization::extended_type_info & eti
     ) : 
         m_eti(& eti)
-    {
-        BOOST_ASSERT(NULL != & eti);
-    }
+    {}
 public:
     inline bool 
     operator<(const basic_serializer & rhs) const {

include/boost/archive/detail/basic_serializer_map.hpp

@@ -34,7 +34,7 @@ namespace detail {
 
 class basic_serializer;
 
-class BOOST_ARCHIVE_OR_WARCHIVE_DECL(BOOST_PP_EMPTY())
+class BOOST_SYMBOL_VISIBLE
 basic_serializer_map : public
     boost::noncopyable
 {
@@ -50,9 +50,9 @@ basic_serializer_map : public
     > map_type;
     map_type m_map;
 public:
-    bool insert(const basic_serializer * bs);
-    void erase(const basic_serializer * bs);
-    const basic_serializer * find(
+    BOOST_ARCHIVE_DECL bool insert(const basic_serializer * bs);
+    BOOST_ARCHIVE_DECL void erase(const basic_serializer * bs);
+    BOOST_ARCHIVE_DECL const basic_serializer * find(
         const boost::serialization::extended_type_info & type_
     ) const;
 private:

include/boost/archive/detail/common_iarchive.hpp

@@ -35,7 +35,7 @@ class extended_type_info;
 
 // note: referred to as Curiously Recurring Template Patter (CRTP)
 template<class Archive>
-class common_iarchive : 
+class BOOST_SYMBOL_VISIBLE common_iarchive : 
     public basic_iarchive,
     public interface_iarchive<Archive>
 {
@@ -62,7 +62,7 @@ private:
 protected:
     // default processing - invoke serialization library
     template<class T>
-    void load_override(T & t, BOOST_PFTO int){
+    void load_override(T & t){
         archive::load(* this->This(), t);
     }
     // default implementations of functions which emit start/end tags for

include/boost/archive/detail/common_oarchive.hpp

@@ -32,7 +32,8 @@ namespace detail {
 
 // note: referred to as Curiously Recurring Template Patter (CRTP)
 template<class Archive>
-class common_oarchive : 
+
+class BOOST_SYMBOL_VISIBLE common_oarchive :
     public basic_oarchive,
     public interface_oarchive<Archive>
 {
@@ -65,7 +66,7 @@ private:
 protected:
     // default processing - invoke serialization library
     template<class T>
-    void save_override(T & t, BOOST_PFTO int){
+    void save_override(T & t){
         archive::save(* this->This(), t);
     }
     void save_start(const char * /*name*/){}

include/boost/archive/detail/decl.hpp

@@ -22,58 +22,36 @@
 // http://www.boost.org/more/separate_compilation.html
 
 #include <boost/config.hpp>
-#include <boost/preprocessor/facilities/empty.hpp>
 
-#if defined(BOOST_HAS_DECLSPEC)
-    #if (defined(BOOST_ALL_DYN_LINK) || defined(BOOST_SERIALIZATION_DYN_LINK))
-        #if defined(BOOST_ARCHIVE_SOURCE)
-            #if defined(__BORLANDC__)
-            #define BOOST_ARCHIVE_DECL(T) T __export
-            #define BOOST_ARCHIVE_OR_WARCHIVE_DECL(T)  T __export
-            #else
-            #define BOOST_ARCHIVE_DECL(T) __declspec(dllexport) T
-            #define BOOST_ARCHIVE_OR_WARCHIVE_DECL(T)  __declspec(dllexport) T
-            #endif
-        #else
-            #if defined(__BORLANDC__)
-            #define BOOST_ARCHIVE_DECL(T) T __import
-            #else
-            #define BOOST_ARCHIVE_DECL(T) __declspec(dllimport) T
-            #endif
-        #endif
-        #if defined(BOOST_WARCHIVE_SOURCE)
-            #if defined(__BORLANDC__)
-            #define BOOST_WARCHIVE_DECL(T) T __export
-            #define BOOST_ARCHIVE_OR_WARCHIVE_DECL(T) T __export
-            #else
-            #define BOOST_WARCHIVE_DECL(T) __declspec(dllexport) T
-            #define BOOST_ARCHIVE_OR_WARCHIVE_DECL(T) __declspec(dllexport) T
-            #endif
-        #else
-            #if defined(__BORLANDC__)
-            #define BOOST_WARCHIVE_DECL(T) T __import
-            #else
-            #define BOOST_WARCHIVE_DECL(T) __declspec(dllimport) T
-            #endif
-        #endif
-        #if !defined(BOOST_WARCHIVE_SOURCE) && !defined(BOOST_ARCHIVE_SOURCE)
-            #if defined(__BORLANDC__)
-            #define BOOST_ARCHIVE_OR_WARCHIVE_DECL(T) T __import
-            #else
-            #define BOOST_ARCHIVE_OR_WARCHIVE_DECL(T) __declspec(dllimport) T
-            #endif
-        #endif
+#if (defined(BOOST_ALL_DYN_LINK) || defined(BOOST_SERIALIZATION_DYN_LINK))
+    #if defined(BOOST_ARCHIVE_SOURCE)
+        #define BOOST_ARCHIVE_DECL BOOST_SYMBOL_EXPORT
+    #else
+        #define BOOST_ARCHIVE_DECL BOOST_SYMBOL_IMPORT
     #endif
-#endif // BOOST_HAS_DECLSPEC
+
+    #if defined(BOOST_WARCHIVE_SOURCE)
+        #define BOOST_WARCHIVE_DECL BOOST_SYMBOL_EXPORT
+    #else
+        #define BOOST_WARCHIVE_DECL BOOST_SYMBOL_IMPORT
+    #endif
+
+    #if defined(BOOST_WARCHIVE_SOURCE) || defined(BOOST_ARCHIVE_SOURCE)
+        #define BOOST_ARCHIVE_OR_WARCHIVE_DECL BOOST_SYMBOL_EXPORT
+    #else
+        #define BOOST_ARCHIVE_OR_WARCHIVE_DECL BOOST_SYMBOL_IMPORT
+    #endif
+
+#endif
 
 #if ! defined(BOOST_ARCHIVE_DECL)
-    #define BOOST_ARCHIVE_DECL(T) T
+    #define BOOST_ARCHIVE_DECL
 #endif
 #if ! defined(BOOST_WARCHIVE_DECL)
-    #define BOOST_WARCHIVE_DECL(T) T
+    #define BOOST_WARCHIVE_DECL
 #endif
 #if ! defined(BOOST_ARCHIVE_OR_WARCHIVE_DECL)
-    #define BOOST_ARCHIVE_OR_WARCHIVE_DECL(T) T
+    #define BOOST_ARCHIVE_OR_WARCHIVE_DECL
 #endif
 
 #endif // BOOST_ARCHIVE_DETAIL_DECL_HPP

include/boost/archive/detail/helper_collection.hpp

@@ -55,11 +55,12 @@ class helper_collection
     collection m_collection;
 
     struct predicate {
+        BOOST_DELETED_FUNCTION(predicate & operator=(const predicate & rhs))
+    public:
         const void * const m_ti;
         bool operator()(helper_value_type const &rhs) const {
             return m_ti == rhs.first;
         }
-        predicate & operator=(const void * ti); // to suppress warning
         predicate(const void * ti) :
             m_ti(ti)
         {}
@@ -69,7 +70,7 @@ protected:
     ~helper_collection(){}
 public:
     template<typename Helper>
-    Helper& get_helper(void * const id = 0) {
+    Helper& find_helper(void * const id = 0) {
         collection::const_iterator it =
             std::find_if(
                 m_collection.begin(),

include/boost/archive/detail/interface_iarchive.hpp

@@ -20,6 +20,7 @@
 #include <boost/mpl/bool.hpp>
 #include <boost/archive/detail/auto_link_archive.hpp>
 #include <boost/archive/detail/iserializer.hpp>
+#include <boost/archive/detail/helper_collection.hpp>
 #include <boost/serialization/singleton.hpp>
 #include <boost/archive/detail/abi_prefix.hpp> // must be the last header
 
@@ -27,7 +28,7 @@ namespace boost {
 namespace archive {
 namespace detail {
 
-class BOOST_ARCHIVE_OR_WARCHIVE_DECL(BOOST_PP_EMPTY()) basic_pointer_iserializer;
+class basic_pointer_iserializer;
 
 template<class Archive>
 class interface_iarchive 
@@ -55,9 +56,16 @@ public:
         this->This()->register_basic_serializer(bpis.get_basic_serializer());
         return & bpis;
     }
+    template<class Helper>
+    Helper &
+    get_helper(void * const id = 0){
+        helper_collection & hc = this->This()->get_helper_collection();
+        return hc.template find_helper<Helper>(id);
+    }
+    
     template<class T>
     Archive & operator>>(T & t){
-        this->This()->load_override(t, 0);
+        this->This()->load_override(t);
         return * this->This();
     }
 

include/boost/archive/detail/interface_oarchive.hpp

@@ -29,7 +29,7 @@ namespace boost {
 namespace archive {
 namespace detail {
 
-class BOOST_ARCHIVE_OR_WARCHIVE_DECL(BOOST_PP_EMPTY()) basic_pointer_oserializer;
+class basic_pointer_oserializer;
 
 template<class Archive>
 class interface_oarchive 
@@ -57,21 +57,24 @@ public:
         this->This()->register_basic_serializer(bpos.get_basic_serializer());
         return & bpos;
     }
+    
+    template<class Helper>
+    Helper &
+    get_helper(void * const id = 0){
+        helper_collection & hc = this->This()->get_helper_collection();
+        return hc.template find_helper<Helper>(id);
+    }
 
     template<class T>
-    Archive & operator<<(T & t){
-        this->This()->save_override(t, 0);
+    Archive & operator<<(const T & t){
+        this->This()->save_override(t);
         return * this->This();
     }
     
     // the & operator 
     template<class T>
-    Archive & operator&(T & t){
-        #ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING
-            return * this->This() << const_cast<const T &>(t);
-        #else
-            return * this->This() << t;
-        #endif
+    Archive & operator&(const T & t){
+        return * this ->This() << t;
     }
 };
 

include/boost/archive/detail/iserializer.hpp

@@ -39,7 +39,6 @@ namespace std{
 #include <boost/mpl/identity.hpp>
 #include <boost/mpl/greater_equal.hpp>
 #include <boost/mpl/equal_to.hpp>
-#include <boost/mpl/bool.hpp>
 #include <boost/core/no_exceptions_support.hpp>
 
 #ifndef BOOST_SERIALIZATION_DEFAULT_TYPE_INFO   
@@ -57,11 +56,16 @@ namespace std{
 #include <boost/type_traits/is_polymorphic.hpp>
 
 #include <boost/serialization/assume_abstract.hpp>
-#define DONT_USE_HAS_NEW_OPERATOR (                    \
-    defined(__BORLANDC__)                              \
-    || BOOST_WORKAROUND(__IBMCPP__, < 1210)            \
-    || defined(__SUNPRO_CC) && (__SUNPRO_CC < 0x590)   \
-)
+
+#if BOOST_WORKAROUND(__IBMCPP__, < 1210)          \
+|| (                                              \
+    defined(__SUNPRO_CC) && (__SUNPRO_CC < 0x590) \
+)                                                 
+        #define DONT_USE_HAS_NEW_OPERATOR 1
+#else
+    #define DONT_USE_HAS_NEW_OPERATOR 0
+#endif
+
 #if ! DONT_USE_HAS_NEW_OPERATOR
 #include <boost/type_traits/has_new_operator.hpp>
 #endif
@@ -73,10 +77,10 @@ namespace std{
 #include <boost/serialization/type_info_implementation.hpp>
 #include <boost/serialization/nvp.hpp>
 #include <boost/serialization/void_cast.hpp>
-#include <boost/serialization/array.hpp>
 #include <boost/serialization/collection_size_type.hpp>
 #include <boost/serialization/singleton.hpp>
 #include <boost/serialization/wrapper.hpp>
+#include <boost/serialization/array_wrapper.hpp>
 
 // the following is need only for dynamic cast of polymorphic pointers
 #include <boost/archive/archive_exception.hpp>
@@ -224,17 +228,13 @@ struct heap_allocation {
             static void invoke_delete(T * t) {
                 // if compilation fails here, the likely cause that the class
                 // T has a class specific new operator but no class specific
-                // delete operator which matches the following signature.  Fix
-                // your program to have this.  Note that adding operator delete
-                // with only one parameter doesn't seem correct to me since 
-                // the standard(3.7.4.2) says "
-                // "If a class T has a member deallocation function named
-                // 'operator delete' with exactly one parameter, then that function 
-                // is a usual (non-placement) deallocation function" which I take
-                // to mean that it will call the destructor of type T which we don't
-                // want to do here.
-                // Note: reliance upon automatic conversion from T * to void * here
-                (T::operator delete)(t, sizeof(T));
+                // delete operator which matches the following signature.
+                // note that this solution addresses the issue that two
+                // possible signatures.  But it doesn't address the possibility
+                // that the class might have class specific new with NO
+                // class specific delete at all.  Patches (compatible with
+                // C++03) welcome!
+                delete t;
             }
         };
         struct doesnt_have_new_operator {
@@ -243,7 +243,7 @@ struct heap_allocation {
             }
             static void invoke_delete(T * t) {
                 // Note: I'm reliance upon automatic conversion from T * to void * here
-                (operator delete)(t);
+                delete t;
             }
         };
         static T * invoke_new() {
@@ -588,7 +588,14 @@ struct load_array_type {
                     boost::archive::archive_exception::array_size_too_short
                 )
             );
-        ar >> serialization::make_array(static_cast<value_type*>(&t[0]),count);
+        // explict template arguments to pass intel C++ compiler
+        ar >> serialization::make_array<
+            value_type,
+            boost::serialization::collection_size_type
+        >(
+            static_cast<value_type *>(&t[0]),
+            count
+        );
     }
 };
 
@@ -598,7 +605,7 @@ template<class Archive, class T>
 inline void load(Archive & ar, T &t){
     // if this assertion trips. It means we're trying to load a
     // const object with a compiler that doesn't have correct
-    // funtion template ordering.  On other compilers, this is
+    // function template ordering.  On other compilers, this is
     // handled below.
     detail::check_const_loading< T >();
     typedef
@@ -618,40 +625,6 @@ inline void load(Archive & ar, T &t){
     typex::invoke(ar, t);
 }
 
-#if 0
-
-// BORLAND
-#if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x560))
-// borland has a couple of problems
-// a) if function is partially specialized - see below
-// const paramters are transformed to non-const ones
-// b) implementation of base_object can't be made to work
-// correctly which results in all base_object s being const.
-// So, strip off the const for borland.  This breaks the trap
-// for loading const objects - but I see no alternative
-template<class Archive, class T>
-inline void load(Archive &ar, const T & t){
-    load(ar, const_cast<T &>(t));
-}
-#endif
-
-// let wrappers through.
-#ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING
-template<class Archive, class T>
-inline void load_wrapper(Archive &ar, const T&t, mpl::true_){
-    boost::archive::load(ar, const_cast<T&>(t));
-}
-
-#if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x560))
-template<class Archive, class T>
-inline void load(Archive &ar, const T&t){
-  load_wrapper(ar,t,serialization::is_wrapper< T >());
-}
-#endif 
-#endif
-
-#endif
-
 } // namespace archive
 } // namespace boost
 

include/boost/archive/detail/oserializer.hpp

@@ -33,6 +33,7 @@
 #include <boost/mpl/equal_to.hpp>
 #include <boost/mpl/greater_equal.hpp>
 #include <boost/mpl/identity.hpp>
+#include <boost/mpl/bool_fwd.hpp>
 
 #ifndef BOOST_SERIALIZATION_DEFAULT_TYPE_INFO   
     #include <boost/serialization/extended_type_info_typeid.hpp>   
@@ -55,8 +56,9 @@
 #include <boost/serialization/type_info_implementation.hpp>
 #include <boost/serialization/nvp.hpp>
 #include <boost/serialization/void_cast.hpp>
-#include <boost/serialization/array.hpp>
 #include <boost/serialization/collection_size_type.hpp>
+#include <boost/serialization/array_wrapper.hpp>
+
 #include <boost/serialization/singleton.hpp>
 
 #include <boost/archive/archive_exception.hpp>
@@ -336,7 +338,7 @@ struct save_pointer_type {
     };
 
     template<class T>
-    static const basic_pointer_oserializer * register_type(Archive &ar, T & /*t*/){
+    static const basic_pointer_oserializer * register_type(Archive &ar, T* const /*t*/){
         // there should never be any need to save an abstract polymorphic 
         // class pointer.  Inhibiting code generation for this
         // permits abstract base classes to be used - note: exception
@@ -403,7 +405,7 @@ struct save_pointer_type {
             // if its not a pointer to a more derived type
             const void *vp = static_cast<const void *>(&t);
             if(*this_type == *true_type){
-                const basic_pointer_oserializer * bpos = register_type(ar, t);
+                const basic_pointer_oserializer * bpos = register_type(ar, &t);
                 ar.save_pointer(vp, bpos);
                 return;
             }
@@ -462,7 +464,7 @@ struct save_pointer_type {
 
     template<class TPtr>
     static void invoke(Archive &ar, const TPtr t){
-        register_type(ar, * t);
+        register_type(ar, t);
         if(NULL == t){
             basic_oarchive & boa 
                 = boost::serialization::smart_cast_reference<basic_oarchive &>(ar);
@@ -500,7 +502,14 @@ struct save_array_type
         );
         boost::serialization::collection_size_type count(c);
         ar << BOOST_SERIALIZATION_NVP(count);
-        ar << serialization::make_array(static_cast<value_type const*>(&t[0]),count);
+        // explict template arguments to pass intel C++ compiler
+        ar << serialization::make_array<
+            const value_type,
+            boost::serialization::collection_size_type
+        >(
+            static_cast<const value_type *>(&t[0]),
+            count
+        );
     }
 };
 

include/boost/archive/detail/polymorphic_iarchive_route.hpp

@@ -39,8 +39,8 @@ namespace serialization {
 namespace archive {
 namespace detail{
 
-class BOOST_ARCHIVE_DECL(BOOST_PP_EMPTY()) basic_iserializer;
-class BOOST_ARCHIVE_DECL(BOOST_PP_EMPTY()) basic_pointer_iserializer;
+class basic_iserializer;
+class basic_pointer_iserializer;
 
 #ifdef BOOST_MSVC
 #  pragma warning(push)
@@ -166,10 +166,13 @@ private:
     virtual void load_end(const char * name){
         ArchiveImplementation::load_end(name);
     }
-
     virtual void register_basic_serializer(const basic_iserializer & bis){
         ArchiveImplementation::register_basic_serializer(bis);
     }
+    virtual helper_collection &
+    get_helper_collection(){
+        return ArchiveImplementation::get_helper_collection();
+    }
 public:
     // this can't be inheriteded because they appear in mulitple
     // parents

include/boost/archive/detail/polymorphic_oarchive_route.hpp

@@ -39,8 +39,8 @@ namespace serialization {
 namespace archive {
 namespace detail{
 
-class BOOST_ARCHIVE_DECL(BOOST_PP_EMPTY()) basic_oserializer;
-class BOOST_ARCHIVE_DECL(BOOST_PP_EMPTY()) basic_pointer_oserializer;
+class basic_oserializer;
+class basic_pointer_oserializer;
 
 #ifdef BOOST_MSVC
 #  pragma warning(push)
@@ -160,6 +160,10 @@ private:
     virtual void register_basic_serializer(const detail::basic_oserializer & bos){
         ArchiveImplementation::register_basic_serializer(bos);
     }
+    virtual helper_collection &
+    get_helper_collection(){
+        return ArchiveImplementation::get_helper_collection();
+    }
 public:
     // this can't be inheriteded because they appear in mulitple
     // parents

include/boost/archive/detail/utf8_codecvt_facet.hpp

@@ -7,10 +7,20 @@
 #ifndef BOOST_ARCHIVE_DETAIL_UTF8_CODECVT_FACET_HPP
 #define BOOST_ARCHIVE_DETAIL_UTF8_CODECVT_FACET_HPP
 
-#ifdef BOOST_NO_CXX11_HDR_CODECVT
+#include <boost/config.hpp>
+
+#ifdef BOOST_NO_STD_WSTREAMBUF
+#error "wide char i/o not supported on this platform"
+#endif
+
+// std::codecvt_utf8 doesn't seem to work for any versions of msvc
+
+#if defined(_MSC_VER) || defined(BOOST_NO_CXX11_HDR_CODECVT)
+    // use boost's utf8 codecvt facet
+    #include <boost/archive/detail/decl.hpp>
     #define BOOST_UTF8_BEGIN_NAMESPACE \
          namespace boost { namespace archive { namespace detail {
-    #define BOOST_UTF8_DECL
+    #define BOOST_UTF8_DECL BOOST_ARCHIVE_DECL
     #define BOOST_UTF8_END_NAMESPACE }}}
 
     #include <boost/detail/utf8_codecvt_facet.hpp>
@@ -18,6 +28,12 @@
     #undef BOOST_UTF8_END_NAMESPACE
     #undef BOOST_UTF8_DECL
     #undef BOOST_UTF8_BEGIN_NAMESPACE
-#endif // BOOST_NO_CXX11_HDR_CODECVT
-#endif // BOOST_ARCHIVE_DETAIL_UTF8_CODECVT_FACET_HPP
+#else
+    // use the standard vendor supplied facet
+    #include <codecvt>
+    namespace boost { namespace archive { namespace detail {
+        typedef std::codecvt_utf8<wchar_t> utf8_codecvt_facet;
+    } } }
+#endif
 
+#endif // BOOST_ARCHIVE_DETAIL_UTF8_CODECVT_FACET_HPP

include/boost/archive/impl/archive_serializer_map.ipp

@@ -37,7 +37,7 @@ namespace extra_detail { // anon
 #endif
 
 template<class Archive>
-BOOST_ARCHIVE_OR_WARCHIVE_DECL(bool)
+BOOST_ARCHIVE_OR_WARCHIVE_DECL bool
 archive_serializer_map<Archive>::insert(const basic_serializer * bs){
     return boost::serialization::singleton<
         extra_detail::map<Archive>
@@ -45,8 +45,12 @@ archive_serializer_map<Archive>::insert(const basic_serializer * bs){
 }
 
 template<class Archive>
-BOOST_ARCHIVE_OR_WARCHIVE_DECL(void)
+BOOST_ARCHIVE_OR_WARCHIVE_DECL void
 archive_serializer_map<Archive>::erase(const basic_serializer * bs){
+    BOOST_ASSERT(! boost::serialization::singleton<
+            extra_detail::map<Archive>
+        >::is_destroyed()
+    );
     if(boost::serialization::singleton<
         extra_detail::map<Archive>
     >::is_destroyed())
@@ -57,7 +61,7 @@ archive_serializer_map<Archive>::erase(const basic_serializer * bs){
 }
 
 template<class Archive>
-BOOST_ARCHIVE_OR_WARCHIVE_DECL(const basic_serializer *) 
+BOOST_ARCHIVE_OR_WARCHIVE_DECL const basic_serializer *
 archive_serializer_map<Archive>::find(
     const boost::serialization::extended_type_info & eti
 ) {

include/boost/archive/impl/basic_binary_iarchive.ipp

@@ -32,11 +32,11 @@ namespace archive {
 /////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
 // implementation of binary_binary_archive
 template<class Archive>
-BOOST_ARCHIVE_OR_WARCHIVE_DECL(void)
-basic_binary_iarchive<Archive>::load_override(class_name_type & t, int){
+BOOST_ARCHIVE_OR_WARCHIVE_DECL void
+basic_binary_iarchive<Archive>::load_override(class_name_type & t){
     std::string cn;
     cn.reserve(BOOST_SERIALIZATION_MAX_KEY_SIZE);
-    load_override(cn, 0);
+    load_override(cn);
     if(cn.size() > (BOOST_SERIALIZATION_MAX_KEY_SIZE - 1))
         boost::serialization::throw_exception(
             archive_exception(archive_exception::invalid_class_name)
@@ -47,8 +47,8 @@ basic_binary_iarchive<Archive>::load_override(class_name_type & t, int){
 }
 
 template<class Archive>
-BOOST_ARCHIVE_OR_WARCHIVE_DECL(void)
-basic_binary_iarchive<Archive>::init(){
+BOOST_ARCHIVE_OR_WARCHIVE_DECL void
+basic_binary_iarchive<Archive>::init(void){
     // read signature in an archive version independent manner
     std::string file_signature;
     

include/boost/archive/impl/basic_binary_iprimitive.ipp

@@ -20,14 +20,9 @@ namespace std{
 } // namespace std
 #endif
 
-#include <boost/detail/workaround.hpp> // fixup for RogueWave
-
 #include <boost/serialization/throw_exception.hpp>
-
 #include <boost/core/no_exceptions_support.hpp>
 #include <boost/archive/archive_exception.hpp>
-#include <boost/archive/codecvt_null.hpp>
-#include <boost/archive/add_facet.hpp>
 #include <boost/archive/basic_binary_iprimitive.hpp> 
 
 namespace boost {
@@ -37,7 +32,7 @@ namespace archive {
 // implementation of basic_binary_iprimitive
 
 template<class Archive, class Elem, class Tr>
-BOOST_ARCHIVE_OR_WARCHIVE_DECL(void)
+BOOST_ARCHIVE_OR_WARCHIVE_DECL void
 basic_binary_iprimitive<Archive, Elem, Tr>::init()
 {
     // Detect  attempts to pass native binary archives across
@@ -89,8 +84,10 @@ basic_binary_iprimitive<Archive, Elem, Tr>::init()
         );
 }
 
+#ifndef BOOST_NO_CWCHAR
+#ifndef BOOST_NO_INTRINSIC_WCHAR_T
 template<class Archive, class Elem, class Tr>
-BOOST_ARCHIVE_OR_WARCHIVE_DECL(void)
+BOOST_ARCHIVE_OR_WARCHIVE_DECL void
 basic_binary_iprimitive<Archive, Elem, Tr>::load(wchar_t * ws)
 {
     std::size_t l; // number of wchar_t !!!
@@ -98,9 +95,11 @@ basic_binary_iprimitive<Archive, Elem, Tr>::load(wchar_t * ws)
     load_binary(ws, l * sizeof(wchar_t) / sizeof(char));
     ws[l] = L'\0';
 }
+#endif
+#endif
 
 template<class Archive, class Elem, class Tr>
-BOOST_ARCHIVE_OR_WARCHIVE_DECL(void)
+BOOST_ARCHIVE_OR_WARCHIVE_DECL void
 basic_binary_iprimitive<Archive, Elem, Tr>::load(std::string & s)
 {
     std::size_t l;
@@ -115,9 +114,8 @@ basic_binary_iprimitive<Archive, Elem, Tr>::load(std::string & s)
         load_binary(&(*s.begin()), l);
 }
 
-#ifndef BOOST_NO_CWCHAR
 template<class Archive, class Elem, class Tr>
-BOOST_ARCHIVE_OR_WARCHIVE_DECL(void)
+BOOST_ARCHIVE_OR_WARCHIVE_DECL void
 basic_binary_iprimitive<Archive, Elem, Tr>::load(char * s)
 {
     std::size_t l;
@@ -125,11 +123,10 @@ basic_binary_iprimitive<Archive, Elem, Tr>::load(char * s)
     load_binary(s, l);
     s[l] = '\0';
 }
-#endif
 
 #ifndef BOOST_NO_STD_WSTRING
 template<class Archive, class Elem, class Tr>
-BOOST_ARCHIVE_OR_WARCHIVE_DECL(void)
+BOOST_ARCHIVE_OR_WARCHIVE_DECL void
 basic_binary_iprimitive<Archive, Elem, Tr>::load(std::wstring & ws)
 {
     std::size_t l;
@@ -145,23 +142,20 @@ basic_binary_iprimitive<Archive, Elem, Tr>::load(std::wstring & ws)
 #endif
 
 template<class Archive, class Elem, class Tr>
-BOOST_ARCHIVE_OR_WARCHIVE_DECL(BOOST_PP_EMPTY())
+BOOST_ARCHIVE_OR_WARCHIVE_DECL
 basic_binary_iprimitive<Archive, Elem, Tr>::basic_binary_iprimitive(
     std::basic_streambuf<Elem, Tr> & sb, 
     bool no_codecvt
 ) :
 #ifndef BOOST_NO_STD_LOCALE
     m_sb(sb),
-    locale_saver(m_sb)
+    codecvt_null_facet(1),
+    locale_saver(m_sb),
+    archive_locale(sb.getloc(), & codecvt_null_facet)
 {
     if(! no_codecvt){
-        archive_locale.reset(
-            add_facet(
-                std::locale::classic(),
-                new codecvt_null<Elem>
-            )
-        );
-        //m_sb.pubimbue(* archive_locale);
+        m_sb.pubsync();
+        m_sb.pubimbue(archive_locale);
     }
 }
 #else
@@ -169,42 +163,11 @@ basic_binary_iprimitive<Archive, Elem, Tr>::basic_binary_iprimitive(
 {}
 #endif
 
-// some libraries including stl and libcomo fail if the
-// buffer isn't flushed before the code_cvt facet is changed.
-// I think this is a bug.  We explicity invoke sync to when
-// we're done with the streambuf to work around this problem.
-// Note that sync is a protected member of stream buff so we
-// have to invoke it through a contrived derived class.
-namespace detail {
-// note: use "using" to get past msvc bug
-using namespace std;
-template<class Elem, class Tr>
-class input_streambuf_access : public std::basic_streambuf<Elem, Tr> {
-    public:
-        virtual int sync(){
-#if BOOST_WORKAROUND(__MWERKS__, BOOST_TESTED_AT(0x3206))
-            return this->basic_streambuf::sync();
-#else
-            return this->basic_streambuf<Elem, Tr>::sync();
-#endif
-        }
-};
-} // detail
-
-// scoped_ptr requires that archive_locale be a complete type at time of
+// scoped_ptr requires that g be a complete type at time of
 // destruction so define destructor here rather than in the header
 template<class Archive, class Elem, class Tr>
-BOOST_ARCHIVE_OR_WARCHIVE_DECL(BOOST_PP_EMPTY())
-basic_binary_iprimitive<Archive, Elem, Tr>::~basic_binary_iprimitive(){
-    // push back unread characters
-    //destructor can't throw !
-    BOOST_TRY{
-        static_cast<detail::input_streambuf_access<Elem, Tr> &>(m_sb).sync();
-    }
-    BOOST_CATCH(...){
-    }
-    BOOST_CATCH_END
-}
+BOOST_ARCHIVE_OR_WARCHIVE_DECL
+basic_binary_iprimitive<Archive, Elem, Tr>::~basic_binary_iprimitive(){}
 
 } // namespace archive
 } // namespace boost

include/boost/archive/impl/basic_binary_oarchive.ipp

@@ -28,11 +28,7 @@ namespace archive {
 // implementation of binary_binary_oarchive
 
 template<class Archive>
-#if !defined(__BORLANDC__)
-BOOST_ARCHIVE_OR_WARCHIVE_DECL(void)
-#else
-void
-#endif
+BOOST_ARCHIVE_OR_WARCHIVE_DECL void
 basic_binary_oarchive<Archive>::init(){
     // write signature in an archive version independent manner
     const std::string file_signature(BOOST_ARCHIVE_SIGNATURE());

include/boost/archive/impl/basic_binary_oprimitive.ipp

@@ -27,10 +27,6 @@ namespace std{ using ::wcslen; }
 #endif
 #endif
 
-#include <boost/detail/workaround.hpp>
-
-#include <boost/archive/add_facet.hpp>
-#include <boost/archive/codecvt_null.hpp>
 #include <boost/archive/basic_binary_oprimitive.hpp>
 #include <boost/core/no_exceptions_support.hpp>
 
@@ -41,7 +37,7 @@ namespace archive {
 // implementation of basic_binary_oprimitive
 
 template<class Archive, class Elem, class Tr>
-BOOST_ARCHIVE_OR_WARCHIVE_DECL(void)
+BOOST_ARCHIVE_OR_WARCHIVE_DECL void
 basic_binary_oprimitive<Archive, Elem, Tr>::init()
 {
     // record native sizes of fundamental types
@@ -57,7 +53,7 @@ basic_binary_oprimitive<Archive, Elem, Tr>::init()
 }
 
 template<class Archive, class Elem, class Tr>
-BOOST_ARCHIVE_OR_WARCHIVE_DECL(void)
+BOOST_ARCHIVE_OR_WARCHIVE_DECL void
 basic_binary_oprimitive<Archive, Elem, Tr>::save(const char * s)
 {
     std::size_t l = std::strlen(s);
@@ -66,7 +62,7 @@ basic_binary_oprimitive<Archive, Elem, Tr>::save(const char * s)
 }
 
 template<class Archive, class Elem, class Tr>
-BOOST_ARCHIVE_OR_WARCHIVE_DECL(void)
+BOOST_ARCHIVE_OR_WARCHIVE_DECL void
 basic_binary_oprimitive<Archive, Elem, Tr>::save(const std::string &s)
 {
     std::size_t l = static_cast<std::size_t>(s.size());
@@ -75,8 +71,9 @@ basic_binary_oprimitive<Archive, Elem, Tr>::save(const std::string &s)
 }
 
 #ifndef BOOST_NO_CWCHAR
+#ifndef BOOST_NO_INTRINSIC_WCHAR_T
 template<class Archive, class Elem, class Tr>
-BOOST_ARCHIVE_OR_WARCHIVE_DECL(void)
+BOOST_ARCHIVE_OR_WARCHIVE_DECL void
 basic_binary_oprimitive<Archive, Elem, Tr>::save(const wchar_t * ws)
 {
     std::size_t l = std::wcslen(ws);
@@ -87,7 +84,7 @@ basic_binary_oprimitive<Archive, Elem, Tr>::save(const wchar_t * ws)
 
 #ifndef BOOST_NO_STD_WSTRING
 template<class Archive, class Elem, class Tr>
-BOOST_ARCHIVE_OR_WARCHIVE_DECL(void)
+BOOST_ARCHIVE_OR_WARCHIVE_DECL void
 basic_binary_oprimitive<Archive, Elem, Tr>::save(const std::wstring &ws)
 {
     std::size_t l = ws.size();
@@ -95,25 +92,23 @@ basic_binary_oprimitive<Archive, Elem, Tr>::save(const std::wstring &ws)
     save_binary(ws.data(), l * sizeof(wchar_t) / sizeof(char));
 }
 #endif
+#endif // BOOST_NO_CWCHAR
 
 template<class Archive, class Elem, class Tr>
-BOOST_ARCHIVE_OR_WARCHIVE_DECL(BOOST_PP_EMPTY())
+BOOST_ARCHIVE_OR_WARCHIVE_DECL
 basic_binary_oprimitive<Archive, Elem, Tr>::basic_binary_oprimitive(
     std::basic_streambuf<Elem, Tr> & sb, 
     bool no_codecvt
 ) : 
 #ifndef BOOST_NO_STD_LOCALE
     m_sb(sb),
-    locale_saver(m_sb)
+    codecvt_null_facet(1),
+    locale_saver(m_sb),
+    archive_locale(sb.getloc(), & codecvt_null_facet)
 {
     if(! no_codecvt){
-        archive_locale.reset(
-            add_facet(
-                std::locale::classic(),
-                new codecvt_null<Elem>
-            )
-        );
-        //m_sb.pubimbue(* archive_locale);
+        m_sb.pubsync();
+        m_sb.pubimbue(archive_locale);
     }
 }
 #else
@@ -121,42 +116,11 @@ basic_binary_oprimitive<Archive, Elem, Tr>::basic_binary_oprimitive(
 {}
 #endif
 
-// some libraries including stl and libcomo fail if the
-// buffer isn't flushed before the code_cvt facet is changed.
-// I think this is a bug.  We explicity invoke sync to when
-// we're done with the streambuf to work around this problem.
-// Note that sync is a protected member of stream buff so we
-// have to invoke it through a contrived derived class.
-namespace detail {
-// note: use "using" to get past msvc bug
-using namespace std;
-template<class Elem, class Tr>
-class output_streambuf_access : public std::basic_streambuf<Elem, Tr> {
-    public:
-        virtual int sync(){
-#if BOOST_WORKAROUND(__MWERKS__, BOOST_TESTED_AT(0x3206))
-            return this->basic_streambuf::sync();
-#else
-            return this->basic_streambuf<Elem, Tr>::sync();
-#endif
-        }
-};
-} // detail
-
 // scoped_ptr requires that g be a complete type at time of
 // destruction so define destructor here rather than in the header
 template<class Archive, class Elem, class Tr>
-BOOST_ARCHIVE_OR_WARCHIVE_DECL(BOOST_PP_EMPTY())
-basic_binary_oprimitive<Archive, Elem, Tr>::~basic_binary_oprimitive(){
-    // flush buffer
-    //destructor can't throw
-    BOOST_TRY{
-        static_cast<detail::output_streambuf_access<Elem, Tr> &>(m_sb).sync();
-    }
-    BOOST_CATCH(...){
-    }
-    BOOST_CATCH_END
-}
+BOOST_ARCHIVE_OR_WARCHIVE_DECL
+basic_binary_oprimitive<Archive, Elem, Tr>::~basic_binary_oprimitive(){}
 
 } // namespace archive
 } // namespace boost

include/boost/archive/impl/basic_text_iarchive.ipp

@@ -29,11 +29,11 @@ namespace archive {
 // implementation of text_text_archive
 
 template<class Archive>
-BOOST_ARCHIVE_OR_WARCHIVE_DECL(void)
-basic_text_iarchive<Archive>::load_override(class_name_type & t, int){
+BOOST_ARCHIVE_OR_WARCHIVE_DECL void
+basic_text_iarchive<Archive>::load_override(class_name_type & t){
     std::string cn;
     cn.reserve(BOOST_SERIALIZATION_MAX_KEY_SIZE);
-    load_override(cn, 0);
+    load_override(cn);
     if(cn.size() > (BOOST_SERIALIZATION_MAX_KEY_SIZE - 1))
         boost::serialization::throw_exception(
             archive_exception(archive_exception::invalid_class_name)
@@ -44,7 +44,7 @@ basic_text_iarchive<Archive>::load_override(class_name_type & t, int){
 }
 
 template<class Archive>
-BOOST_ARCHIVE_OR_WARCHIVE_DECL(void)
+BOOST_ARCHIVE_OR_WARCHIVE_DECL void
 basic_text_iarchive<Archive>::init(void){
     // read signature in an archive version independent manner
     std::string file_signature;

include/boost/archive/impl/basic_text_iprimitive.ipp

@@ -8,8 +8,8 @@
 
 //  See http://www.boost.org for updates, documentation, and revision history.
 
-#include <cstddef> // size_t
-#include <cstddef> // NULL
+#include <cstddef> // size_t, NULL
+#include <limits> // NULL
 
 #include <boost/config.hpp>
 #if defined(BOOST_NO_STDC_NAMESPACE)
@@ -19,11 +19,8 @@ namespace std{
 #endif
 
 #include <boost/serialization/throw_exception.hpp>
-#include <boost/serialization/pfto.hpp>
 
 #include <boost/archive/basic_text_iprimitive.hpp>
-#include <boost/archive/codecvt_null.hpp>
-#include <boost/archive/add_facet.hpp>
 
 #include <boost/archive/iterators/remove_whitespace.hpp>
 #include <boost/archive/iterators/istream_iterator.hpp>
@@ -53,7 +50,7 @@ namespace detail {
 // translate base64 text into binary and copy into buffer
 // until buffer is full.
 template<class IStream>
-BOOST_ARCHIVE_OR_WARCHIVE_DECL(void)
+BOOST_ARCHIVE_OR_WARCHIVE_DECL void
 basic_text_iprimitive<IStream>::load_binary(
     void *address, 
     std::size_t count
@@ -79,7 +76,7 @@ basic_text_iprimitive<IStream>::load_binary(
                 iterators::remove_whitespace<
                     iterators::istream_iterator<CharType>
                 >
-                ,CharType
+                ,typename IStream::int_type
             >
             ,8
             ,6
@@ -87,11 +84,7 @@ basic_text_iprimitive<IStream>::load_binary(
         > 
         binary;
         
-    binary i = binary(
-        BOOST_MAKE_PFTO_WRAPPER(
-            iterators::istream_iterator<CharType>(is)
-        )
-    );
+    binary i = binary(iterators::istream_iterator<CharType>(is));
 
     char * caddr = static_cast<char *>(address);
     
@@ -112,39 +105,32 @@ basic_text_iprimitive<IStream>::load_binary(
 }
     
 template<class IStream>
-BOOST_ARCHIVE_OR_WARCHIVE_DECL(BOOST_PP_EMPTY())
+BOOST_ARCHIVE_OR_WARCHIVE_DECL
 basic_text_iprimitive<IStream>::basic_text_iprimitive(
     IStream  &is_,
     bool no_codecvt
 ) :
-#ifndef BOOST_NO_STD_LOCALE
     is(is_),
     flags_saver(is_),
     precision_saver(is_),
-    locale_saver(* is_.rdbuf())
+#ifndef BOOST_NO_STD_LOCALE
+    codecvt_null_facet(1),
+    archive_locale(is.getloc(), & codecvt_null_facet),
+    locale_saver(is)
 {
     if(! no_codecvt){
-        archive_locale.reset(
-            add_facet(
-                std::locale::classic(),
-                new boost::archive::codecvt_null<typename IStream::char_type>
-            )
-        );
-        //is.imbue(* archive_locale);
+        is_.sync();
+        is_.imbue(archive_locale);
     }
-    is >> std::noboolalpha;
+    is_ >> std::noboolalpha;
 }
 #else
-    is(is_),
-    flags_saver(is_),
-    precision_saver(is_)
 {}
 #endif
 
 template<class IStream>
-BOOST_ARCHIVE_OR_WARCHIVE_DECL(BOOST_PP_EMPTY())
+BOOST_ARCHIVE_OR_WARCHIVE_DECL
 basic_text_iprimitive<IStream>::~basic_text_iprimitive(){
-    is.sync();
 }
 
 } // namespace archive

include/boost/archive/impl/basic_text_oarchive.ipp

@@ -27,7 +27,7 @@ namespace archive {
 // implementation of basic_text_oarchive
 
 template<class Archive>
-BOOST_ARCHIVE_OR_WARCHIVE_DECL(void)
+BOOST_ARCHIVE_OR_WARCHIVE_DECL void
 basic_text_oarchive<Archive>::newtoken()
 {
     switch(delimiter){
@@ -48,7 +48,7 @@ basic_text_oarchive<Archive>::newtoken()
 }
 
 template<class Archive>
-BOOST_ARCHIVE_OR_WARCHIVE_DECL(void)
+BOOST_ARCHIVE_OR_WARCHIVE_DECL void
 basic_text_oarchive<Archive>::init(){
     // write signature in an archive version independent manner
     const std::string file_signature(BOOST_ARCHIVE_SIGNATURE());

include/boost/archive/impl/basic_text_oprimitive.ipp

@@ -10,11 +10,15 @@
 
 #include <cstddef> // NULL
 #include <algorithm> // std::copy
-#include <boost/serialization/pfto.hpp>
+#include <exception> // std::uncaught_exception
+#include <boost/config.hpp>
+#if defined(BOOST_NO_STDC_NAMESPACE)
+namespace std{ 
+    using ::size_t; 
+} // namespace std
+#endif
 
 #include <boost/archive/basic_text_oprimitive.hpp>
-#include <boost/archive/codecvt_null.hpp>
-#include <boost/archive/add_facet.hpp>
 
 #include <boost/archive/iterators/base64_from_binary.hpp>
 #include <boost/archive/iterators/insert_linebreaks.hpp>
@@ -26,7 +30,7 @@ namespace archive {
 
 // translate to base64 and copy in to buffer.
 template<class OStream>
-BOOST_ARCHIVE_OR_WARCHIVE_DECL(void)
+BOOST_ARCHIVE_OR_WARCHIVE_DECL void
 basic_text_oprimitive<OStream>::save_binary(
     const void *address, 
     std::size_t count
@@ -59,9 +63,9 @@ basic_text_oprimitive<OStream>::save_binary(
 
     boost::archive::iterators::ostream_iterator<CharType> oi(os);
     std::copy(
-        base64_text(BOOST_MAKE_PFTO_WRAPPER(static_cast<const char *>(address))),
+        base64_text(static_cast<const char *>(address)),
         base64_text(
-            BOOST_MAKE_PFTO_WRAPPER(static_cast<const char *>(address) + count)
+            static_cast<const char *>(address) + count
         ),
         oi
     );
@@ -75,38 +79,35 @@ basic_text_oprimitive<OStream>::save_binary(
 }
 
 template<class OStream>
-BOOST_ARCHIVE_OR_WARCHIVE_DECL(BOOST_PP_EMPTY())
+BOOST_ARCHIVE_OR_WARCHIVE_DECL
 basic_text_oprimitive<OStream>::basic_text_oprimitive(
     OStream & os_,
     bool no_codecvt
 ) : 
-#ifndef BOOST_NO_STD_LOCALE
     os(os_),
     flags_saver(os_),
     precision_saver(os_),
-    locale_saver(* os_.rdbuf())
+#ifndef BOOST_NO_STD_LOCALE
+    codecvt_null_facet(1),
+    archive_locale(os.getloc(), & codecvt_null_facet),
+    locale_saver(os)
 {
     if(! no_codecvt){
-        archive_locale.reset(
-            add_facet(
-                std::locale::classic(),
-                new boost::archive::codecvt_null<typename OStream::char_type>
-            )
-        );
-        //os.imbue(* archive_locale);
+        os_.flush();
+        os_.imbue(archive_locale);
     }
-    os << std::noboolalpha;
+    os_ << std::noboolalpha;
 }
 #else
-    os(os_),
-    flags_saver(os_),
-    precision_saver(os_)
 {}
 #endif
 
+
 template<class OStream>
-BOOST_ARCHIVE_OR_WARCHIVE_DECL(BOOST_PP_EMPTY())
+BOOST_ARCHIVE_OR_WARCHIVE_DECL
 basic_text_oprimitive<OStream>::~basic_text_oprimitive(){
+    if(std::uncaught_exception())
+        return;
     os << std::endl;
 }
 

include/boost/archive/impl/basic_xml_grammar.hpp

@@ -72,14 +72,14 @@ public:
     friend struct return_values;
     
 private:
-    typedef BOOST_DEDUCED_TYPENAME std::basic_istream<CharType> IStream;
-    typedef BOOST_DEDUCED_TYPENAME std::basic_string<CharType> StringType;
-    typedef BOOST_DEDUCED_TYPENAME boost::spirit::classic::chset<CharType> chset_t;
-    typedef BOOST_DEDUCED_TYPENAME boost::spirit::classic::chlit<CharType> chlit_t;
-    typedef BOOST_DEDUCED_TYPENAME boost::spirit::classic::scanner<
-        BOOST_DEDUCED_TYPENAME  std::basic_string<CharType>::iterator
+    typedef typename std::basic_istream<CharType> IStream;
+    typedef typename std::basic_string<CharType> StringType;
+    typedef typename boost::spirit::classic::chset<CharType> chset_t;
+    typedef typename boost::spirit::classic::chlit<CharType> chlit_t;
+    typedef typename boost::spirit::classic::scanner<
+        typename  std::basic_string<CharType>::iterator
     > scanner_t;
-    typedef BOOST_DEDUCED_TYPENAME boost::spirit::classic::rule<scanner_t> rule_t;
+    typedef typename boost::spirit::classic::rule<scanner_t> rule_t;
     // Start grammar definition
     rule_t    
         Reference,
@@ -163,7 +163,7 @@ public:
     bool parse_end_tag(IStream & is) const;
     bool parse_string(IStream & is, StringType & s) /*const*/;
     void init(IStream & is);
-    void windup(IStream & is);
+    bool windup(IStream & is);
     basic_xml_grammar();
 };
 

include/boost/archive/impl/basic_xml_iarchive.ipp

@@ -24,7 +24,7 @@ namespace archive {
 // implementation of xml_text_archive
 
 template<class Archive>
-BOOST_ARCHIVE_OR_WARCHIVE_DECL(void)
+BOOST_ARCHIVE_OR_WARCHIVE_DECL void
 basic_xml_iarchive<Archive>::load_start(const char *name){
     // if there's no name
     if(NULL == name)
@@ -41,7 +41,7 @@ basic_xml_iarchive<Archive>::load_start(const char *name){
 }
 
 template<class Archive>
-BOOST_ARCHIVE_OR_WARCHIVE_DECL(void)
+BOOST_ARCHIVE_OR_WARCHIVE_DECL void
 basic_xml_iarchive<Archive>::load_end(const char *name){
     // if there's no name
     if(NULL == name)
@@ -77,38 +77,39 @@ basic_xml_iarchive<Archive>::load_end(const char *name){
 }
 
 template<class Archive>
-BOOST_ARCHIVE_OR_WARCHIVE_DECL(void)
-basic_xml_iarchive<Archive>::load_override(object_id_type & t, int){
+BOOST_ARCHIVE_OR_WARCHIVE_DECL void
+basic_xml_iarchive<Archive>::load_override(object_id_type & t){
     t = object_id_type(this->This()->gimpl->rv.object_id);
 }
 
 template<class Archive>
-BOOST_ARCHIVE_OR_WARCHIVE_DECL(void)
-basic_xml_iarchive<Archive>::load_override(version_type & t, int){
+BOOST_ARCHIVE_OR_WARCHIVE_DECL void
+basic_xml_iarchive<Archive>::load_override(version_type & t){
     t = version_type(this->This()->gimpl->rv.version);
 }
 
 template<class Archive>
-BOOST_ARCHIVE_OR_WARCHIVE_DECL(void)
-basic_xml_iarchive<Archive>::load_override(class_id_type & t, int){
+BOOST_ARCHIVE_OR_WARCHIVE_DECL void
+basic_xml_iarchive<Archive>::load_override(class_id_type & t){
     t = class_id_type(this->This()->gimpl->rv.class_id);
 }
 
 template<class Archive>
-BOOST_ARCHIVE_OR_WARCHIVE_DECL(void)
-basic_xml_iarchive<Archive>::load_override(tracking_type & t, int){
+BOOST_ARCHIVE_OR_WARCHIVE_DECL void
+basic_xml_iarchive<Archive>::load_override(tracking_type & t){
     t = this->This()->gimpl->rv.tracking_level;
 }
 
 template<class Archive>
-BOOST_ARCHIVE_OR_WARCHIVE_DECL(BOOST_PP_EMPTY())
+BOOST_ARCHIVE_OR_WARCHIVE_DECL
 basic_xml_iarchive<Archive>::basic_xml_iarchive(unsigned int flags) :
     detail::common_iarchive<Archive>(flags),
     depth(0)
 {}
 template<class Archive>
-BOOST_ARCHIVE_OR_WARCHIVE_DECL(BOOST_PP_EMPTY())
-basic_xml_iarchive<Archive>::~basic_xml_iarchive(){}
+BOOST_ARCHIVE_OR_WARCHIVE_DECL
+basic_xml_iarchive<Archive>::~basic_xml_iarchive(){
+}
 
 } // namespace archive
 } // namespace boost

include/boost/archive/impl/basic_xml_oarchive.ipp

@@ -58,7 +58,7 @@ struct XML_name {
 // implemenations of functions common to both types of xml output
 
 template<class Archive>
-BOOST_ARCHIVE_OR_WARCHIVE_DECL(void)
+BOOST_ARCHIVE_OR_WARCHIVE_DECL void
 basic_xml_oarchive<Archive>::write_attribute(
     const char *attribute_name,
     int t,
@@ -72,7 +72,7 @@ basic_xml_oarchive<Archive>::write_attribute(
 }
 
 template<class Archive>
-BOOST_ARCHIVE_OR_WARCHIVE_DECL(void)
+BOOST_ARCHIVE_OR_WARCHIVE_DECL void
 basic_xml_oarchive<Archive>::write_attribute(
     const char *attribute_name,
     const char *key
@@ -85,7 +85,7 @@ basic_xml_oarchive<Archive>::write_attribute(
 }
 
 template<class Archive>
-BOOST_ARCHIVE_OR_WARCHIVE_DECL(void)
+BOOST_ARCHIVE_OR_WARCHIVE_DECL void
 basic_xml_oarchive<Archive>::indent(){
     int i;
     for(i = depth; i-- > 0;)
@@ -93,7 +93,7 @@ basic_xml_oarchive<Archive>::indent(){
 }
 
 template<class Archive>
-BOOST_ARCHIVE_OR_WARCHIVE_DECL(void)
+BOOST_ARCHIVE_OR_WARCHIVE_DECL void
 basic_xml_oarchive<Archive>::save_start(const char *name)
 {
     if(NULL == name)
@@ -115,7 +115,7 @@ basic_xml_oarchive<Archive>::save_start(const char *name)
 }
 
 template<class Archive>
-BOOST_ARCHIVE_OR_WARCHIVE_DECL(void)
+BOOST_ARCHIVE_OR_WARCHIVE_DECL void
 basic_xml_oarchive<Archive>::save_end(const char *name)
 {
     if(NULL == name)
@@ -139,7 +139,7 @@ basic_xml_oarchive<Archive>::save_end(const char *name)
 }
 
 template<class Archive>
-BOOST_ARCHIVE_OR_WARCHIVE_DECL(void)
+BOOST_ARCHIVE_OR_WARCHIVE_DECL void
 basic_xml_oarchive<Archive>::end_preamble(){
     if(pending_preamble){
         this->This()->put('>');
@@ -148,14 +148,14 @@ basic_xml_oarchive<Archive>::end_preamble(){
 }
 #if 0
 template<class Archive>
-BOOST_ARCHIVE_OR_WARCHIVE_DECL(void)
-basic_xml_oarchive<Archive>::save_override(const object_id_type & t, int)
+BOOST_ARCHIVE_OR_WARCHIVE_DECL void
+basic_xml_oarchive<Archive>::save_override(const object_id_type & t)
 {
     int i = t.t; // extra .t is for borland
     write_attribute(BOOST_ARCHIVE_XML_OBJECT_ID(), i, "=\"_");
 }
 template<class Archive>
-BOOST_ARCHIVE_OR_WARCHIVE_DECL(void)
+BOOST_ARCHIVE_OR_WARCHIVE_DECL void
 basic_xml_oarchive<Archive>::save_override(
     const object_reference_type & t,
     int
@@ -164,8 +164,8 @@ basic_xml_oarchive<Archive>::save_override(
     write_attribute(BOOST_ARCHIVE_XML_OBJECT_REFERENCE(), i, "=\"_");
 }
 template<class Archive>
-BOOST_ARCHIVE_OR_WARCHIVE_DECL(void)
-basic_xml_oarchive<Archive>::save_override(const version_type & t, int)
+BOOST_ARCHIVE_OR_WARCHIVE_DECL void
+basic_xml_oarchive<Archive>::save_override(const version_type & t)
 {
     int i = t.t; // extra .t is for borland
     write_attribute(BOOST_ARCHIVE_XML_VERSION(), i);
@@ -173,55 +173,52 @@ basic_xml_oarchive<Archive>::save_override(const version_type & t, int)
 #endif
 
 template<class Archive>
-BOOST_ARCHIVE_OR_WARCHIVE_DECL(void)
-basic_xml_oarchive<Archive>::save_override(const object_id_type & t, int)
+BOOST_ARCHIVE_OR_WARCHIVE_DECL void
+basic_xml_oarchive<Archive>::save_override(const object_id_type & t)
 {
     // borland doesn't do conversion of STRONG_TYPEDEFs very well
     const unsigned int i = t;
     write_attribute(BOOST_ARCHIVE_XML_OBJECT_ID(), i, "=\"_");
 }
 template<class Archive>
-BOOST_ARCHIVE_OR_WARCHIVE_DECL(void)
+BOOST_ARCHIVE_OR_WARCHIVE_DECL void
 basic_xml_oarchive<Archive>::save_override(
-    const object_reference_type & t,
-    int
+    const object_reference_type & t
 ){
     const unsigned int i = t;
     write_attribute(BOOST_ARCHIVE_XML_OBJECT_REFERENCE(), i, "=\"_");
 }
 template<class Archive>
-BOOST_ARCHIVE_OR_WARCHIVE_DECL(void)
-basic_xml_oarchive<Archive>::save_override(const version_type & t, int)
+BOOST_ARCHIVE_OR_WARCHIVE_DECL void
+basic_xml_oarchive<Archive>::save_override(const version_type & t)
 {
     const unsigned int i = t;
     write_attribute(BOOST_ARCHIVE_XML_VERSION(), i);
 }
 
 template<class Archive>
-BOOST_ARCHIVE_OR_WARCHIVE_DECL(void)
-basic_xml_oarchive<Archive>::save_override(const class_id_type & t, int)
+BOOST_ARCHIVE_OR_WARCHIVE_DECL void
+basic_xml_oarchive<Archive>::save_override(const class_id_type & t)
 {
     write_attribute(BOOST_ARCHIVE_XML_CLASS_ID(), t);
 }
 template<class Archive>
-BOOST_ARCHIVE_OR_WARCHIVE_DECL(void)
+BOOST_ARCHIVE_OR_WARCHIVE_DECL void
 basic_xml_oarchive<Archive>::save_override(
-    const class_id_reference_type & t,
-    int
+    const class_id_reference_type & t
 ){
     write_attribute(BOOST_ARCHIVE_XML_CLASS_ID_REFERENCE(), t);
 }
 template<class Archive>
-BOOST_ARCHIVE_OR_WARCHIVE_DECL(void)
+BOOST_ARCHIVE_OR_WARCHIVE_DECL void
 basic_xml_oarchive<Archive>::save_override(
-    const class_id_optional_type & t,
-    int
+    const class_id_optional_type & t
 ){
     write_attribute(BOOST_ARCHIVE_XML_CLASS_ID(), t);
 }
 template<class Archive>
-BOOST_ARCHIVE_OR_WARCHIVE_DECL(void)
-basic_xml_oarchive<Archive>::save_override(const class_name_type & t, int)
+BOOST_ARCHIVE_OR_WARCHIVE_DECL void
+basic_xml_oarchive<Archive>::save_override(const class_name_type & t)
 {
     const char * key = t;
     if(NULL == key)
@@ -230,14 +227,14 @@ basic_xml_oarchive<Archive>::save_override(const class_name_type & t, int)
 }
 
 template<class Archive>
-BOOST_ARCHIVE_OR_WARCHIVE_DECL(void)
-basic_xml_oarchive<Archive>::save_override(const tracking_type & t, int)
+BOOST_ARCHIVE_OR_WARCHIVE_DECL void
+basic_xml_oarchive<Archive>::save_override(const tracking_type & t)
 {
     write_attribute(BOOST_ARCHIVE_XML_TRACKING(), t.t);
 }
 
 template<class Archive>
-BOOST_ARCHIVE_OR_WARCHIVE_DECL(void)
+BOOST_ARCHIVE_OR_WARCHIVE_DECL void
 basic_xml_oarchive<Archive>::init(){
     // xml header
     this->This()->put("<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\" ?>\n");
@@ -250,25 +247,25 @@ basic_xml_oarchive<Archive>::init(){
 }
 
 template<class Archive>
-BOOST_ARCHIVE_OR_WARCHIVE_DECL(BOOST_PP_EMPTY())
+BOOST_ARCHIVE_OR_WARCHIVE_DECL void
+basic_xml_oarchive<Archive>::windup(){
+    // xml_trailer
+    this->This()->put("</boost_serialization>\n");
+}
+
+template<class Archive>
+BOOST_ARCHIVE_OR_WARCHIVE_DECL
 basic_xml_oarchive<Archive>::basic_xml_oarchive(unsigned int flags) :
     detail::common_oarchive<Archive>(flags),
     depth(0),
-    indent_next(false),
-    pending_preamble(false)
+    pending_preamble(false),
+    indent_next(false)
 {
 }
 
 template<class Archive>
-BOOST_ARCHIVE_OR_WARCHIVE_DECL(BOOST_PP_EMPTY())
+BOOST_ARCHIVE_OR_WARCHIVE_DECL
 basic_xml_oarchive<Archive>::~basic_xml_oarchive(){
-    if(0 == (this->get_flags() & no_header)){
-        BOOST_TRY{
-                this->This()->put("</boost_serialization>\n");
-        }
-        BOOST_CATCH(...){}
-        BOOST_CATCH_END
-    }
 }
 
 } // namespace archive

include/boost/archive/impl/text_iarchive_impl.ipp

@@ -28,7 +28,7 @@ namespace boost {
 namespace archive {
 
 template<class Archive>
-BOOST_ARCHIVE_DECL(void)
+BOOST_ARCHIVE_DECL void
 text_iarchive_impl<Archive>::load(char *s)
 {
     std::size_t size;
@@ -41,7 +41,7 @@ text_iarchive_impl<Archive>::load(char *s)
 }
 
 template<class Archive>
-BOOST_ARCHIVE_DECL(void)
+BOOST_ARCHIVE_DECL void
 text_iarchive_impl<Archive>::load(std::string &s)
 {
     std::size_t size;
@@ -60,7 +60,7 @@ text_iarchive_impl<Archive>::load(std::string &s)
 #ifndef BOOST_NO_CWCHAR
 #ifndef BOOST_NO_INTRINSIC_WCHAR_T
 template<class Archive>
-BOOST_ARCHIVE_DECL(void)
+BOOST_ARCHIVE_DECL void
 text_iarchive_impl<Archive>::load(wchar_t *ws)
 {
     std::size_t size;
@@ -74,7 +74,7 @@ text_iarchive_impl<Archive>::load(wchar_t *ws)
 
 #ifndef BOOST_NO_STD_WSTRING
 template<class Archive>
-BOOST_ARCHIVE_DECL(void)
+BOOST_ARCHIVE_DECL void
 text_iarchive_impl<Archive>::load(std::wstring &ws)
 {
     std::size_t size;
@@ -93,19 +93,19 @@ text_iarchive_impl<Archive>::load(std::wstring &ws)
 #endif // BOOST_NO_CWCHAR
 
 template<class Archive>
-BOOST_ARCHIVE_DECL(void)
-text_iarchive_impl<Archive>::load_override(class_name_type & t, int){
-    basic_text_iarchive<Archive>::load_override(t, 0);
+BOOST_ARCHIVE_DECL void
+text_iarchive_impl<Archive>::load_override(class_name_type & t){
+    basic_text_iarchive<Archive>::load_override(t);
 }
 
 template<class Archive>
-BOOST_ARCHIVE_DECL(void)
+BOOST_ARCHIVE_DECL void
 text_iarchive_impl<Archive>::init(){
     basic_text_iarchive<Archive>::init();
 }
 
 template<class Archive>
-BOOST_ARCHIVE_DECL(BOOST_PP_EMPTY()) 
+BOOST_ARCHIVE_DECL 
 text_iarchive_impl<Archive>::text_iarchive_impl(
     std::istream & is, 
     unsigned int flags

include/boost/archive/impl/text_oarchive_impl.ipp

@@ -10,7 +10,6 @@
 
 #include <string>
 #include <boost/config.hpp>
-#include <locale>
 #include <cstddef> // size_t
 
 #include <boost/config.hpp>
@@ -27,7 +26,6 @@ namespace std{ using ::wcslen; }
 #endif
 #endif
 
-#include <boost/archive/add_facet.hpp>
 #include <boost/archive/text_oarchive.hpp>
 
 namespace boost { 
@@ -38,7 +36,7 @@ namespace archive {
 // of template parameters used to create a text_oprimitive
 
 template<class Archive>
-BOOST_ARCHIVE_DECL(void)
+BOOST_ARCHIVE_DECL void
 text_oarchive_impl<Archive>::save(const char * s)
 {
     const std::size_t len = std::ostream::traits_type::length(s);
@@ -48,7 +46,7 @@ text_oarchive_impl<Archive>::save(const char * s)
 }
 
 template<class Archive>
-BOOST_ARCHIVE_DECL(void)
+BOOST_ARCHIVE_DECL void
 text_oarchive_impl<Archive>::save(const std::string &s)
 {
     const std::size_t size = s.size();
@@ -60,7 +58,7 @@ text_oarchive_impl<Archive>::save(const std::string &s)
 #ifndef BOOST_NO_CWCHAR
 #ifndef BOOST_NO_INTRINSIC_WCHAR_T
 template<class Archive>
-BOOST_ARCHIVE_DECL(void)
+BOOST_ARCHIVE_DECL void
 text_oarchive_impl<Archive>::save(const wchar_t * ws)
 {
     const std::size_t l = std::wcslen(ws);
@@ -72,7 +70,7 @@ text_oarchive_impl<Archive>::save(const wchar_t * ws)
 
 #ifndef BOOST_NO_STD_WSTRING
 template<class Archive>
-BOOST_ARCHIVE_DECL(void)
+BOOST_ARCHIVE_DECL void
 text_oarchive_impl<Archive>::save(const std::wstring &ws)
 {
     const std::size_t l = ws.size();
@@ -84,7 +82,7 @@ text_oarchive_impl<Archive>::save(const std::wstring &ws)
 #endif // BOOST_NO_CWCHAR
 
 template<class Archive>
-BOOST_ARCHIVE_DECL(BOOST_PP_EMPTY()) 
+BOOST_ARCHIVE_DECL 
 text_oarchive_impl<Archive>::text_oarchive_impl(
     std::ostream & os, 
     unsigned int flags
@@ -104,7 +102,7 @@ text_oarchive_impl<Archive>::text_oarchive_impl(
 }
 
 template<class Archive>
-BOOST_ARCHIVE_DECL(void)
+BOOST_ARCHIVE_DECL void
 text_oarchive_impl<Archive>::save_binary(const void *address, std::size_t count){
     put('\n');
     this->end_preamble();

include/boost/archive/impl/text_wiarchive_impl.ipp

@@ -29,7 +29,7 @@ namespace archive {
 // implementation of wiprimtives functions
 //
 template<class Archive>
-BOOST_WARCHIVE_DECL(void)
+BOOST_WARCHIVE_DECL void
 text_wiarchive_impl<Archive>::load(char *s)
 {
     std::size_t size;
@@ -43,7 +43,7 @@ text_wiarchive_impl<Archive>::load(char *s)
 }
 
 template<class Archive>
-BOOST_WARCHIVE_DECL(void)
+BOOST_WARCHIVE_DECL void
 text_wiarchive_impl<Archive>::load(std::string &s)
 {
     std::size_t size;
@@ -56,14 +56,14 @@ text_wiarchive_impl<Archive>::load(std::string &s)
         s.resize(0);
     s.reserve(size);
     while(size-- > 0){
-        int x = is.narrow(is.get(), '\0');
+        char x = is.narrow(is.get(), '\0');
         s += x;
     }
 }
 
 #ifndef BOOST_NO_INTRINSIC_WCHAR_T
 template<class Archive>
-BOOST_WARCHIVE_DECL(void)
+BOOST_WARCHIVE_DECL void
 text_wiarchive_impl<Archive>::load(wchar_t *s)
 {
     std::size_t size;
@@ -78,7 +78,7 @@ text_wiarchive_impl<Archive>::load(wchar_t *s)
 
 #ifndef BOOST_NO_STD_WSTRING
 template<class Archive>
-BOOST_WARCHIVE_DECL(void)
+BOOST_WARCHIVE_DECL void
 text_wiarchive_impl<Archive>::load(std::wstring &ws)
 {
     std::size_t size;
@@ -97,7 +97,7 @@ text_wiarchive_impl<Archive>::load(std::wstring &ws)
 #endif
 
 template<class Archive>
-BOOST_WARCHIVE_DECL(BOOST_PP_EMPTY()) 
+BOOST_WARCHIVE_DECL 
 text_wiarchive_impl<Archive>::text_wiarchive_impl(
     std::wistream & is, 
     unsigned int flags

include/boost/archive/impl/text_woarchive_impl.ipp

@@ -31,7 +31,7 @@ namespace archive {
 // implementation of woarchive functions
 //
 template<class Archive>
-BOOST_WARCHIVE_DECL(void)
+BOOST_WARCHIVE_DECL void
 text_woarchive_impl<Archive>::save(const char *s)
 {
     // note: superfluous local variable fixes borland warning
@@ -43,7 +43,7 @@ text_woarchive_impl<Archive>::save(const char *s)
 }
 
 template<class Archive>
-BOOST_WARCHIVE_DECL(void)
+BOOST_WARCHIVE_DECL void
 text_woarchive_impl<Archive>::save(const std::string &s)
 {
     const std::size_t size = s.size();
@@ -56,7 +56,7 @@ text_woarchive_impl<Archive>::save(const std::string &s)
 
 #ifndef BOOST_NO_INTRINSIC_WCHAR_T
 template<class Archive>
-BOOST_WARCHIVE_DECL(void)
+BOOST_WARCHIVE_DECL void
 text_woarchive_impl<Archive>::save(const wchar_t *ws)
 {
     const std::size_t size = std::wostream::traits_type::length(ws);
@@ -68,7 +68,7 @@ text_woarchive_impl<Archive>::save(const wchar_t *ws)
 
 #ifndef BOOST_NO_STD_WSTRING
 template<class Archive>
-BOOST_WARCHIVE_DECL(void)
+BOOST_WARCHIVE_DECL void
 text_woarchive_impl<Archive>::save(const std::wstring &ws)
 {
     const std::size_t size = ws.length();