Boost-Commit :

Date view	Thread view	Subject view	Author view

Subject: [Boost-commit] svn:boost r56316 - in branches/release/libs/serialization: . build doc src test vc7ide
From: ramey_at_[hidden]
Date: 2009-09-19 22:18:07

Author: ramey
Date: 2009-09-19 22:18:02 EDT (Sat, 19 Sep 2009)
New Revision: 56316
URL: http://svn.boost.org/trac/boost/changeset/56316

Log:
Merge trunk to release
Added:
   branches/release/libs/serialization/src/archive_exception.cpp
      - copied unchanged from r56315, /trunk/libs/serialization/src/archive_exception.cpp
   branches/release/libs/serialization/src/shared_ptr_helper.cpp
      - copied unchanged from r56315, /trunk/libs/serialization/src/shared_ptr_helper.cpp
   branches/release/libs/serialization/src/xml_archive_exception.cpp
      - copied unchanged from r56315, /trunk/libs/serialization/src/xml_archive_exception.cpp
   branches/release/libs/serialization/test/test_check.cpp
      - copied unchanged from r56315, /trunk/libs/serialization/test/test_check.cpp
Properties modified:
   branches/release/libs/serialization/ (props changed)
   branches/release/libs/serialization/doc/release.html (props changed)
Text files modified:
   branches/release/libs/serialization/build/Jamfile.v2 | 3
   branches/release/libs/serialization/doc/acknowledgments.html | 6
   branches/release/libs/serialization/doc/archive_reference.html | 16
   branches/release/libs/serialization/doc/contents.html | 472 ++++++++++++++++++++-------------------
   branches/release/libs/serialization/doc/exceptions.html | 10
   branches/release/libs/serialization/doc/extended_type_info.html | 110 ++++++---
   branches/release/libs/serialization/doc/rationale.html | 220 ------------------
   branches/release/libs/serialization/doc/serialization.html | 6
   branches/release/libs/serialization/doc/special.html | 79 ++++--
   branches/release/libs/serialization/doc/traits.html | 401 +++++++++++++++++++++++++++++----
   branches/release/libs/serialization/module.cmake | 6
   branches/release/libs/serialization/src/basic_archive.cpp | 3
   branches/release/libs/serialization/src/basic_iarchive.cpp | 4
   branches/release/libs/serialization/src/basic_serializer_map.cpp | 77 +++--
   branches/release/libs/serialization/src/extended_type_info.cpp | 33 +-
   branches/release/libs/serialization/src/extended_type_info_no_rtti.cpp | 16
   branches/release/libs/serialization/src/extended_type_info_typeid.cpp | 14
   branches/release/libs/serialization/src/polymorphic_oarchive.cpp | 2
   branches/release/libs/serialization/src/void_cast.cpp | 11
   branches/release/libs/serialization/test/Jamfile.v2 | 5
   branches/release/libs/serialization/test/polymorphic_base.cpp | 2
   branches/release/libs/serialization/test/polymorphic_base.hpp | 5
   branches/release/libs/serialization/test/polymorphic_derived1.cpp | 5
   branches/release/libs/serialization/test/polymorphic_derived1.hpp | 3
   branches/release/libs/serialization/test/polymorphic_derived2.cpp | 2
   branches/release/libs/serialization/test/polymorphic_derived2.hpp | 13
   branches/release/libs/serialization/test/test_binary.cpp | 50 +++
   branches/release/libs/serialization/test/test_class_info_save.cpp | 2
   branches/release/libs/serialization/test/test_complex.cpp | 2
   branches/release/libs/serialization/test/test_derived.cpp | 11
   branches/release/libs/serialization/test/test_dll_exported.cpp | 5
   branches/release/libs/serialization/test/test_exported.cpp | 7
   branches/release/libs/serialization/test/test_no_rtti.cpp | 22 -
   branches/release/libs/serialization/test/test_non_default_ctor.cpp | 2
   branches/release/libs/serialization/test/test_non_intrusive.cpp | 2
   branches/release/libs/serialization/test/test_shared_ptr.cpp | 3
   branches/release/libs/serialization/test/test_simple_class_ptr.cpp | 2
   branches/release/libs/serialization/test/test_static_warning.cpp | 22 -
   branches/release/libs/serialization/test/test_tracking.cpp | 1
   branches/release/libs/serialization/test/test_utf8_codecvt.cpp | 2
   branches/release/libs/serialization/vc7ide/BoostSerializationLibrary.sln | 100 +++++++
   branches/release/libs/serialization/vc7ide/Library.vcproj | 39 ++-
   branches/release/libs/serialization/vc7ide/dll_a.vcproj | 77 ++++-
   branches/release/libs/serialization/vc7ide/dll_base.vcproj | 25 -
   branches/release/libs/serialization/vc7ide/dll_derived2.vcproj | 67 ++++-
   branches/release/libs/serialization/vc7ide/polymorphic_derived2.vcproj | 78 ++++-
   branches/release/libs/serialization/vc7ide/test_array.vcproj | 3
   branches/release/libs/serialization/vc7ide/test_dll_exported.vcproj | 35 +-
   branches/release/libs/serialization/vc7ide/test_dll_plugin.vcproj | 6
   branches/release/libs/serialization/vc7ide/test_exported.vcproj | 3
   branches/release/libs/serialization/vc7ide/test_multiple_ptrs.vcproj | 3
   51 files changed, 1258 insertions(+), 835 deletions(-)

Modified: branches/release/libs/serialization/build/Jamfile.v2
==============================================================================
--- branches/release/libs/serialization/build/Jamfile.v2 (original)
+++ branches/release/libs/serialization/build/Jamfile.v2 2009-09-19 22:18:02 EDT (Sat, 19 Sep 2009)
@@ -75,9 +75,12 @@
     text_iarchive
     text_oarchive
     void_cast
+ archive_exception
     xml_grammar
     xml_iarchive
     xml_oarchive
+ xml_archive_exception
+ shared_ptr_helper
;

WSOURCES =

Modified: branches/release/libs/serialization/doc/acknowledgments.html
==============================================================================
--- branches/release/libs/serialization/doc/acknowledgments.html (original)
+++ branches/release/libs/serialization/doc/acknowledgments.html 2009-09-19 22:18:02 EDT (Sat, 19 Sep 2009)
@@ -1,4 +1,4 @@
-ï»¿<!doctype HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
+<!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 .
@@ -27,6 +27,10 @@
</table>
<hr>
<ul>
+ <li>AutoForm Engineering GmbH supported
+ development efforts to extend correct serialization to objects stored in DLLS.
+ <li><a href"http://www.cadence.com/il">Cadence Israel</a> supported enhancement
+ and testing of the portable binary archive.
   <li>David Abrahams improved implementation of "export" functionality. This not
   only eliminated an annoying header sequencing requirement, but also the need to maintain
   a list of "known archives".

Modified: branches/release/libs/serialization/doc/archive_reference.html
==============================================================================
--- branches/release/libs/serialization/doc/archive_reference.html (original)
+++ branches/release/libs/serialization/doc/archive_reference.html 2009-09-19 22:18:02 EDT (Sat, 19 Sep 2009)
@@ -270,21 +270,19 @@
exception.
<p>

-
<h4><a name="testing">Testing</h4>
Exhaustive testing of the library requires testing the different aspects of object
-serialization with each archive. There are 36 different tests that can run with any archive. There are
-5 "standard archives" included with the system. (3 in systems which don't support wide
-charactor i/o).
+serialization with each archive. There are 46 different tests that can run with any archive.
+There are 5 "standard archives" included with the system.
+(3 in systems don't support wide charactor i/o).
<p>
-In addition, there are 22 other tests which aren't related to any particular archive
-class.
+In addition, there are 28 other tests which aren't related to any particular archive class.
<p>
The default <code style="white-space: normal">bjam</code> testing setup will run all
-the above described tests. This will result in as many as 39 archive tests * 5
-standard archives + 25 general tests = 220 tests. Note that a complete test of the
+the above described tests. This will result in as many as 46 archive tests * 5
+standard archives + 28 general tests = 258 tests. Note that a complete test of the
library would include DLL vs static library, release vs debug so the actual total
-would be closer to 880 tests.
+would be closer to 1032 tests.
<p>
For each archive there is a header file in the test directory similar to the one below.
The name of this archive is passed to the test program by setting the

Modified: branches/release/libs/serialization/doc/contents.html
==============================================================================
--- branches/release/libs/serialization/doc/contents.html (original)
+++ branches/release/libs/serialization/doc/contents.html 2009-09-19 22:18:02 EDT (Sat, 19 Sep 2009)
@@ -1,4 +1,4 @@
-ï»¿<!doctype HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
+<!doctype HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>

<p>
- <dl class="page-index">
- <dt><img style="display:none" src="plus.gif" id="release_notes"><a target="detail" href="release.html">Release Notes</a></dt>
- <dd><div id="release_notes_detail"><dl class="page-index">
- <dt><img style="display:none" src="dot.gif"><a target="detail" href="release.html#requirements">Requirements</a></dt>
- <dt><img style="display:none" src="dot.gif"><a target="detail" href="release.html#difference_1_36">Differences from version 1.36</a></dt>
- <dt><img style="display:none" src="dot.gif"><a target="detail" href="release.html#difference_1_35">Differences from version 1.35</a></dt>
- <dt><img style="display:none" src="dot.gif"><a target="detail" href="release.html#difference_1_34">Differences from version 1.34</a></dt>
- <dt><img style="display:none" src="dot.gif"><a target="detail" href="release.html#difference_1_33">Differences from version 1.33</a></dt>
- <dt><img style="display:none" src="dot.gif"><a target="detail" href="release.html#difference_1_32">Differences from version 1.32</a></dt>
-
- <dt><img style="display:none" src="dot.gif"><a target="detail" href="release.html#todo">Pending Issues</a></dt>
- </dl></div></dd>
- <dt><img style="display:none" src="plus.gif" id="overview"><a target="detail" href="overview.html">Overview</a></dt>
- <dd><div id="overview_detail"><dl class="page-index">
- <dt><img style="display:none" src="dot.gif"><a target="detail" href="overview.html#Requirements">Requirements</a></dt>
- <dt><img style="display:none" src="dot.gif"><a target="detail" href="overview.html#Otherimplementations">Other Implementations</a></dt>
- </dl></div></dd>
- <dt><img style="display:none" src="plus.gif" id="tutorial"><a target="detail" href="tutorial.html">Tutorial</a></dt>
- <dd><div id="tutorial_detail"><dl class="page-index">
- <dt><img style="display:none" src="dot.gif"><a target="detail" href="tutorial.html#simplecase">A Very Simple Case</a>
- <dt><img style="display:none" src="dot.gif"><a target="detail" href="tutorial.html#nonintrusiveversion">Non Intrusive Version</a>
- <dt><img style="display:none" src="dot.gif"><a target="detail" href="tutorial.html#serializablemembers">Serializable Members</a>
- <dt><img style="display:none" src="dot.gif"><a target="detail" href="tutorial.html#derivedclasses">Derived Classes</a>
- <dt><img style="display:none" src="dot.gif"><a target="detail" href="tutorial.html#pointers">Pointers</a>
- <dt><img style="display:none" src="dot.gif"><a target="detail" href="tutorial.html#arrays">Arrays</a>
-
- <dt><img style="display:none" src="dot.gif"><a target="detail" href="tutorial.html#stl">STL Collections</a>
- <dt><img style="display:none" src="dot.gif"><a target="detail" href="tutorial.html#versioning">Class Versioning</a>
- <dt><img style="display:none" src="dot.gif"><a target="detail" href="tutorial.html#splitting">Splitting <code>serialize</code> into <code>save/load</code></a>
- <dt><img style="display:none" src="dot.gif"><a target="detail" href="tutorial.html#archives">Archives</a>
- <dt><img style="display:none" src="dot.gif"><a target="detail" href="tutorial.html#examples">List of Examples</a>
+<dl class="page-index">
+ <dt><img style="display:none" src="plus.gif" id="release_notes"><a target="detail" href="release.html">Release Notes</a></dt>
+ <dd><div id="release_notes_detail"><dl class="page-index">
+ <dt><img style="display:none" src="dot.gif"><a target="detail" href="release.html#requirements">Requirements</a></dt>
+ <dt><img style="display:none" src="dot.gif"><a target="detail" href="release.html#difference_1_36">Differences from version 1.36</a></dt>
+ <dt><img style="display:none" src="dot.gif"><a target="detail" href="release.html#difference_1_35">Differences from version 1.35</a></dt>
+ <dt><img style="display:none" src="dot.gif"><a target="detail" href="release.html#difference_1_34">Differences from version 1.34</a></dt>
+ <dt><img style="display:none" src="dot.gif"><a target="detail" href="release.html#difference_1_33">Differences from version 1.33</a></dt>
+ <dt><img style="display:none" src="dot.gif"><a target="detail" href="release.html#difference_1_32">Differences from version 1.32</a></dt>
+
+ <dt><img style="display:none" src="dot.gif"><a target="detail" href="release.html#todo">Pending Issues</a></dt>
+ </dl></div></dd>
+ <dt><img style="display:none" src="plus.gif" id="overview"><a target="detail" href="overview.html">Overview</a></dt>
+ <dd><div id="overview_detail"><dl class="page-index">
+ <dt><img style="display:none" src="dot.gif"><a target="detail" href="overview.html#Requirements">Requirements</a></dt>
+ <dt><img style="display:none" src="dot.gif"><a target="detail" href="overview.html#Otherimplementations">Other Implementations</a></dt>
+ </dl></div></dd>
+ <dt><img style="display:none" src="plus.gif" id="tutorial"><a target="detail" href="tutorial.html">Tutorial</a></dt>
+ <dd><div id="tutorial_detail"><dl class="page-index">
+ <dt><img style="display:none" src="dot.gif"><a target="detail" href="tutorial.html#simplecase">A Very Simple Case</a>
+ <dt><img style="display:none" src="dot.gif"><a target="detail" href="tutorial.html#nonintrusiveversion">Non Intrusive Version</a>
+ <dt><img style="display:none" src="dot.gif"><a target="detail" href="tutorial.html#serializablemembers">Serializable Members</a>
+ <dt><img style="display:none" src="dot.gif"><a target="detail" href="tutorial.html#derivedclasses">Derived Classes</a>
+ <dt><img style="display:none" src="dot.gif"><a target="detail" href="tutorial.html#pointers">Pointers</a>
+ <dt><img style="display:none" src="dot.gif"><a target="detail" href="tutorial.html#arrays">Arrays</a>
+
+ <dt><img style="display:none" src="dot.gif"><a target="detail" href="tutorial.html#stl">STL Collections</a>
+ <dt><img style="display:none" src="dot.gif"><a target="detail" href="tutorial.html#versioning">Class Versioning</a>
+ <dt><img style="display:none" src="dot.gif"><a target="detail" href="tutorial.html#splitting">Splitting <code>serialize</code> into <code>save/load</code></a>
+ <dt><img style="display:none" src="dot.gif"><a target="detail" href="tutorial.html#archives">Archives</a>
+ <dt><img style="display:none" src="dot.gif"><a target="detail" href="tutorial.html#examples">List of Examples</a>
+ </dl></div></dd>
+
+ <dt><img style="display:none" src="plus.gif" id="reference"><a target="detail" href="reference.html">Reference</a></dt>
+ <dd><div id="reference_detail"><dl class="page-index">
+ <dt><img style="display:none" src="plus.gif" id="archive_concept"><a target="detail" href="archives.html">Archive Concepts</a>
+ <dd><div id="archive_concept_detail"><dl class="page-index">
+ <dt><img style="display:none" src="dot.gif"><a target="detail" href="archives.html#saving_interface">Saving Archive Concept</a>
+ <dt><img style="display:none" src="dot.gif"><a target="detail" href="archives.html#loading_interface">Loading Archive Concept</a>
+ <dt><img style="display:none" src="dot.gif"><a target="detail" href="archives.html#archive_models">Archive Models</a>
+ <dt><img style="display:none" src="dot.gif"><a target="detail" href="archives.html#exceptions">Exceptions</a>
+ <dt><img style="display:none" src="dot.gif"><a target="detail" href="archives.html#charactersets">Character Sets</a>
     </dl></div></dd>
-
- <dt><img style="display:none" src="plus.gif" id="reference"><a target="detail" href="reference.html">Reference</a></dt>
- <dd><div id="reference_detail"><dl class="page-index">
- <dt><img style="display:none" src="plus.gif" id="archive_concept"><a target="detail" href="archives.html">Archive Concepts</a>
- <dd><div id="archive_concept_detail"><dl class="page-index">
- <dt><img style="display:none" src="dot.gif"><a target="detail" href="archives.html#saving_interface">Saving Archive Concept</a>
- <dt><img style="display:none" src="dot.gif"><a target="detail" href="archives.html#loading_interface">Loading Archive Concept</a>
- <dt><img style="display:none" src="dot.gif"><a target="detail" href="archives.html#archive_models">Archive Models</a>
- <dt><img style="display:none" src="dot.gif"><a target="detail" href="archives.html#exceptions">Exceptions</a>
- <dt><img style="display:none" src="dot.gif"><a target="detail" href="archives.html#charactersets">Character Sets</a>
- </dl></div></dd>
- <dt><img style="display:none" src="plus.gif" id="serialization"><a target="detail" href="serialization.html">Serializable Concept</a>
- <dd><div id="serialization_detail"><dl class="page-index">
- <dt><img style="display:none" src="dot.gif"><a target="detail" href="serialization.html#primitiveoperators">Primitive Types</a>
- <dt><img style="display:none" src="dot.gif" id="class"><a target="detail" href="serialization.html#classoperators">Class Types</a>
- <dd><div id="class_detail"><dl class="page-index">
- <dt><img style="display:none" src="dot.gif"><a target="detail" href="serialization.html#member">Member Function</a>
- <dt><img style="display:none" src="plus.gif" id="splitfree"><a target="detail" href="serialization.html#free">Free Function</a>
- <dd><div id="splitfree_detail"><dl class="page-index">
- <dt><img style="display:none" src="dot.gif"><a target="detail" href="serialization.html#namespaces">Namespaces for Free Function Overrides</a>
- </dl></div></dd>
- <dt><img style="display:none" src="plus.gif" id="members"><a target="detail" href="serialization.html#classmembers">Class Members</a>
- <dd><div id="members_detail"><dl class="page-index">
- <dt><img style="display:none" src="dot.gif"><a target="detail" href="serialization.html#base">Base Classes</a>
- <dt><img style="display:none" src="dot.gif"><a target="detail" href="serialization.html#const"><code>const</code> Members</a>
- <dt><img style="display:none" src="dot.gif"><a target="detail" href="serialization.html#templates">Templates</a>
- </dl></div></dd>
- <dt><img style="display:none" src="dot.gif"><a target="detail" href="serialization.html#versioning">Versioning</a>
- <dt><img style="display:none" src="dot.gif"><a target="detail" href="serialization.html#splitting">Splitting <code>serialize</code> into <code>save/load</code></a>
+ <dt><img style="display:none" src="plus.gif" id="serialization"><a target="detail" href="serialization.html">Serializable Concept</a>
+ <dd><div id="serialization_detail"><dl class="page-index">
+ <dt><img style="display:none" src="dot.gif"><a target="detail" href="serialization.html#primitiveoperators">Primitive Types</a>
+ <dt><img style="display:none" src="dot.gif" id="class"><a target="detail" href="serialization.html#classoperators">Class Types</a>
+ <dd><div id="class_detail"><dl class="page-index">
+ <dt><img style="display:none" src="dot.gif"><a target="detail" href="serialization.html#member">Member Function</a>
+ <dt><img style="display:none" src="plus.gif" id="splitfree"><a target="detail" href="serialization.html#free">Free Function</a>
+ <dd><div id="splitfree_detail"><dl class="page-index">
+ <dt><img style="display:none" src="dot.gif"><a target="detail" href="serialization.html#namespaces">Namespaces for Free Function Overrides</a>
         </dl></div></dd>
- <dt><img style="display:none" src="plus.gif" id="pointers"><a target="detail" href="serialization.html#pointeroperators">Pointers</a>
- <dd><div id="pointers_detail"><dl class="page-index">
- <dt><img style="display:none" src="dot.gif"><a target="detail" href="serialization.html#constructors">Non-Default Constructors</a>
- <dt><img style="display:none" src="plus.gif" id="derivedpointers"><a target="detail" href="serialization.html#derivedpointers">Pointers to Objects of Derived Classes</a>
- <dd><div id="derivedpointers_detail"><dl class="page-index">
- <dt><img style="display:none" src="dot.gif"><a target="detail" href="serialization.html#registration">Registration</a>
- <dt><img style="display:none" src="dot.gif"><a target="detail" href="serialization.html#export">Export</a>
- <dt><img style="display:none" src="dot.gif"><a target="detail" href="serialization.html#instantiation">Instantiation</a>
- <dt><img style="display:none" src="dot.gif"><a target="detail" href="serialization.html#selectivetracking">Selective Tracking</a>
- <dt><img style="display:none" src="dot.gif"><a target="detail" href="serialization.html#runtimecasting">Runtime Casting</a>
- </dl></div></dd>
+ <dt><img style="display:none" src="plus.gif" id="members"><a target="detail" href="serialization.html#classmembers">Class Members</a>
+ <dd><div id="members_detail"><dl class="page-index">
+ <dt><img style="display:none" src="dot.gif"><a target="detail" href="serialization.html#base">Base Classes</a>
+ <dt><img style="display:none" src="dot.gif"><a target="detail" href="serialization.html#const"><code>const</code> Members</a>
+ <dt><img style="display:none" src="dot.gif"><a target="detail" href="serialization.html#templates">Templates</a>
         </dl></div></dd>
- <dt><img style="display:none" src="dot.gif"><a target="detail" href="serialization.html#references">References</a>
- <dt><img style="display:none" src="plus.gif" id="wrappers"><a target="detail" href="wrappers.html">Serialization Wrappers</a>
- <dd><div id="wrappers_detail"><dl class="page-index">
- <dt><img style="display:none" src="dot.gif"><a target="detail" href="wrappers.html#binaryobjects">Binary Objects</a>
- <dt><img style="display:none" src="dot.gif"><a target="detail" href="wrappers.html#arrays">Arrays</a>
- <dt><img style="display:none" src="dot.gif"><a target="detail" href="wrappers.html#strong_type"><code style="white-space: normal">strong_type</code></a>
- <dt><img style="display:none" src="dot.gif"><a target="detail" href="wrappers.html#collection_size_type">Collection Sizes</a>
- <dt><img style="display:none" src="dot.gif"><a target="detail" href="wrappers.html#nvp">Name-Value Pairs</a>
- <dt><img style="display:none" src="dot.gif"><a target="detail" href="wrappers.html#composition">Composition</a>
- </dl></div></dd>
- <dt><img style="display:none" src="plus.gif" id="traits"><a target="detail" href="traits.html">Class Serialization Traits</a>
- <dd><div id="traits_detail"><dl class="page-index">
- <dt><img style="display:none" src="dot.gif"><a target="detail" href="traits.html#version">Version</a>
- <dt><img style="display:none" src="dot.gif"><a target="detail" href="traits.html#level">Implementation Level</a>
- <dt><img style="display:none" src="dot.gif"><a target="detail" href="traits.html#tracking">Object Tracking</a>
- <dt><img style="display:none" src="dot.gif"><a target="detail" href="traits.html#export">Export Key</a>
- <dt><img style="display:none" src="dot.gif"><a target="detail" href="traits.html#Abstract">Abstract</a>
- <dt><img style="display:none" src="dot.gif"><a target="detail" href="traits.html#typeinfo">Type Information Implementation</a>
- <dt><img style="display:none" src="dot.gif"><a target="detail" href="traits.html#wrappers">Wrappers</a>
- <dt><img style="display:none" src="dot.gif"><a target="detail" href="traits.html#templates">Template Serialization Traits</a>
- </dl></div></dd>
- <dt><img style="display:none" src="dot.gif"><a target="detail" href="serialization.html#models">Models - Serialization Implementations Included in the Library</a>
+ <dt><img style="display:none" src="dot.gif"><a target="detail" href="serialization.html#versioning">Versioning</a>
+ <dt><img style="display:none" s'c="dot.gif"><a target="detail" href="serialization.html#splitting">Splitting <code>serialize</code> into <code>save/load</code></a>
       </dl></div></dd>
- <dt><img style="display:none" src="plus.gif" id="special"><a target="detail" href="special.html">Special Considerations</a>
- <dd><div id="special_detail"><dl class="page-index">
- <dt><img style="display:none" src="dot.gif"><a target="detail" href="special.html#objecttracking">Object Tracking</a>
- <dt><img style="display:none" src="dot.gif"><a target="detail" href="special.html#classinfo">Class Information</a>
- <dt><img style="display:none" src="plus.gif" id="portability"><a target="detail" href="special.html#portability">Archive Portability</a>
- <dd><div id="portability_detail"><dl class="page-index">
- <dt><img style="display:none" src="dot.gif"><a target="detail" href="special.html#numerics">Numerics</a>
- <dt><img style="display:none" src="dot.gif"><a target="detail" href="special.html#traits">Traits</a>
+ <dt><img style="display:none" src="plus.gif" id="pointers"><a target="detail" href="serialization.html#pointeroperators">Pointers</a>
+ <dd><div id="pointers_detail"><dl class="page-index">
+ <dt><img style="display:none" src="dot.gif"><a target="detail" href="serialization.html#constructors">Non-Default Constructors</a>
+ <dt><img style="display:none" src="plus.gif" id="derivedpointers"><a target="detail" href="serialization.html#derivedpointers">Pointers to Objects of Derived Classes</a>
+ <dd><div id="derivedpointers_detail"><dl class="page-index">
+ <dt><img style="display:none" src="dot.gif"><a target="detail" href="serialization.html#registration">Registration</a>
+ <dt><img style="display:none" src="dot.gif"><a target="detail" href="serialization.html#export">Export</a>
+ <dt><img style="display:none" src="dot.gif"><a target="detail" href="serialization.html#instantiation">Instantiation</a>
+ <dt><img style="display:none" src="dot.gif"><a target="detail" href="serialization.html#selectivetracking">Selective Tracking</a>
+ <dt><img style="display:none" src="dot.gif"><a target="detail" href="serialization.html#runtimecasting">Runtime Casting</a>
         </dl></div></dd>
- <dt><img style="display:none" src="dot.gif"><a target="detail" href="special.html#binary_archives">Binary Archives</a>
- <dt><img style="display:none" src="dot.gif"><a target="detail" href="special.html#xml_archives">XML Archives</a>
- <dt><img style="display:none" src="dot.gif"><a target="detail" href="special.html#export">Exporting Class Serialization</a>
- <dt><img style="display:none" src="dot.gif"><a target="detail" href="special.html#dlls">DLLS - Serialization and Runtime Linking</a>
- <dt><img style="display:none" src="dot.gif"><a target="detail" href="special.html#plugins">Plugins</a>
- <dt><img style="display:none" src="dot.gif"><a target="detail" href="special.html#multi_threading">Multi-Threading</a>
- <dt><img style="display:none" src="dot.gif"><a target="detail" href="special.html#optimizations">Optimzations</a>
- <dt><img style="display:none" src="plus.gif" id="exceptions"><a target="detail" href="exceptions.html">Archive Exceptions</a>
- <dd><div id="exceptions_detail"><dl class="page-index">
- <dt><img style="display:none" src="dot.gif"><a target="detail" href="exceptions.html#unregistered_class"><code>unregistered_class</code></a>
- <dt><img style="display:none" src="dot.gif"><a target="detail" href="exceptions.html#invalid_signature"><code>invalid_signature</code></a>
- <dt><img style="display:none" src="dot.gif"><a target="detail" href="exceptions.html#unsupported_version"><code>unsupported_version</code></a>
- <dt><img style="display:none" src="dot.gif"><a target="detail" href="exceptions.html#pointer_conflict"><code>pointer_conflict</code></a>
- <dt><img style="display:none" src="dot.gif"><a target="detail" href="exceptions.html#incompatible_native_format"><code>incompatible_format</code></a>
- <dt><img style="display:none" src="dot.gif"><a target="detail" href="exceptions.html#array_size_too_short"><code>array_size_too_short</code></a>
- <dt><img style="display:none" src="dot.gif"><a target="detail" href="exceptions.html#stream_error"><code>stream_error</code></a>
- <dt><img style="display:none" src="dot.gif"><a target="detail" href="exceptions.html#invalid_class_name"><code>invalid_class_name</code></a>
- <dt><img style="display:none" src="dot.gif"><a target="detail" href="exceptions.html#unregistered_cast"><code>unregistered_cast</code></a>
- <dt><img style="display:none" src="dot.gif"><a target="detail" href="exceptions.html#xml_archive_parsing_error"><code>xml_archive_parsing_error</code></a>
- <dt><img style="display:none" src="dot.gif"><a target="detail" href="exceptions.html#xml_archive_tag_mismatch"><code>xml_archive_tag_mismatch</code></a>
- <dt><img style="display:none" src="dot.gif"><a target="detail" href="exceptions.html#xml_archive_tag_name_error"><code>xml_archive_tag_name_error</code></a>
+ </dl></div></dd>
+ <dt><img style="display:none" src="dot.gif"><a target="detail" href="serialization.html#references">References</a>
+ <dt><img style="display:none" src="plus.gif" id="traits"><a target="detail" href="traits.html">Class Serialization Traits</a>
+ <dd><div id="traits_detail"><dl class="page-index">
+ <dt><img style="display:none" src="dot.gif"><a target="detail" href="traits.html#version">Version</a>
+ <dt><img style="display:none" src="dot.gif"><a target="detail" href="traits.html#level">Implementation Level</a>
+ <dt><img style="display:none" src="dot.gif"><a target="detail" href="traits.html#tracking">Object Tracking</a>
+ <dt><img style="display:none" src="dot.gif"><a target="detail" href="traits.html#export">Export Key</a>
+ <dt><img style="display:none" src="dot.gif"><a target="detail" href="traits.html#Abstract">Abstract</a>
+ <dt><img style="display:none" src="dot.gif"><a target="detail" href="traits.html#typeinfo">Type Information Implementation</a>
+ <dt><img style="display:none" src="dot.gif"><a target="detail" href="traits.html#wrappers">Wrappers</a>
+ <dt><img style="display:none" src="dot.gif"><a target="detail" href="traits.html#bitwise">Bitwise Serialization</a>
+ <dt><img style="display:none" src="dot.gif"><a target="detail" href="traits.html#templates">Template Serialization Traits</a>
+
+ <dt><img style="display:none" src="plus.gif" id="compiletimemessages"><a target="detail" href="traits.html#compiletime_messages">Compile Time Warnings and Errors</a>
+ <dd><div id="compiletimemessages_detail"><dl class="page-index">
+ <dt><img style="display:none" src="dot.gif"><a target="detail" href="traits.html#object_level">object_level</a>
+ <dt><img style="display:none" src="dot.gif"><a target="detail" href="traits.html#object_versioning">object_versioning</a>
+ <dt><img style="display:none" src="dot.gif"><a target="detail" href="traits.html#object_tracking">object_tracking</a>
+ <dt><img style="display:none" src="dot.gif"><a target="detail" href="traits.html#pointer_level">pointer_level</a>
+ <dt><img style="display:none" src="dot.gif"><a target="detail" href="traits.html#pointer_tracking">pointer_tracking</a>
+ <dt><img style="display:none" src="dot.gif"><a target="detail" href="traits.html#const_loading">const_loading</a>
         </dl></div></dd>
- <dt><img style="display:none" src="dot.gif"><a target="detail" href="exception_safety.html">Exception Safety</a>
+
+
+
+ </dl></div></dd>
+ <dt><img style="display:none" src="plus.gif" id="wrappers"><a target="detail" href="wrappers.html">Serialization Wrappers</a>
+ <dd><div id="wrappers_detail"><dl class="page-index">
+ <dt><img style="display:none" src="dot.gif"><a target="detail" href="wrappers.html#binaryobjects">Binary Objects</a>
+ <dt><img style="display:none" src="dot.gif"><a target="detail" href="wrappers.html#arrays">Arrays</a>
+ <dt><img style="display:none" src="dot.gif"><a target="detail" href="wrappers.html#strong_type"><code style="white-space: normal">strong_type</code></a>
+ <dt><img style="display:none" src="dot.gif"><a target="detail" href="wrappers.html#collection_size_type">Collection Sizes</a>
+ <dt><img style="display:none" src="dot.gif"><a target="detail" href="wrappers.html#nvp">Name-Value Pairs</a>
+ <dt><img style="display:none" src="dot.gif"><a target="detail" href="wrappers.html#composition">Composition</a>
       </dl></div></dd>
- <dt><img style="display:none" src="plus.gif" id="archive_reference"><a target="detail" href="archive_reference.html">Archive Class Reference</a>
- <dd><div id="archive_reference_detail"><dl class="page-index">
- <dt><img style="display:none" src="dot.gif"><a target="detail" href="archive_reference.html#implementation">Implementation</a>
- <dt><img style="display:none" src="dot.gif"><a target="detail" href="archive_reference.html#usage">Usage</a>
- <dt><img style="display:none" src="dot.gif"><a target="detail" href="archive_reference.html#testing">Testing</a>
- <dt><img style="display:none" src="dot.gif"><a target="detail" href="archive_reference.html#polymorphic">Polymorphic Archives</a>
+ <dt><img style="display:none" src="dot.gif"><a target="detail" href="serialization.html#models">Models - Serialization Implementations Included in the Library</a>
+ </dl></div></dd>
+ <dt><img style="display:none" src="plus.gif" id="special"><a target="detail" 'ref="special.html">Special Considerations</a>
+ <dd><div id="special_detail"><dl class="page-index">
+ <dt><img style="display:none" src="dot.gif"><a target="detail" href="special.html#objecttracking">Object Tracking</a>
+ <dt><img style="display:none" src="dot.gif"><a target="detail" href="special.html#classinfo">Class Information</a>
+ <dt><img style="display:none" src="plus.gif" id="portability"><a target="detail" href="special.html#portability">Archive Portability</a>
+ <dd><div id="portability_detail"><dl class="page-index">
+ <dt><img style="display:none" src="dot.gif"><a target="detail" href="special.html#numerics">Numerics</a>
+ <dt><img style="display:none" src="dot.gif"><a target="detail" href="special.html#traits">Traits</a>
       </dl></div></dd>
- <dt><img style="display:none" src="plus.gif" id="implementation"><a target="detail" href="implementation.html">Implementation Notes</a>
- <dd><div id="implementation_detail"><dl class="page-index">
- <dt><img style="display:none" src="dot.gif"><a target="detail" href="implementation.html#functiontemplateordering">Partial Function Template Ordering</a>
- <dt><img style="display:none" src="dot.gif"><a target="detail" href="implementation.html#charencoding">Character Encoding</a>
- <dt><img style="display:none" src="dot.gif"><a target="detail" href="implementation.html#tempatesyntax">Template Invocation syntax</a>
- <dt><img style="display:none" src="dot.gif"><a target="detail" href="implementation.html#partialtemplatespecialization">Partial Template Specialization</a>
- <dt><img style="display:none" src="plus.gif" id="othercompilerissues"><a target="detail" href="implementation.html#othercompilerissues">Specific Compiler/Library Issues</a>
- <div id="othercompilerissues_detail"><dl class="page-index">
- <dt><img style="display:none" src="dot.gif"><a target="detail" href="implementation.html#gcc3x">GCC 3.X,4.X</a>
- <dt><img style="display:none" src="dot.gif"><a target="detail" href="implementation.html#gcc295">GCC 2.95</a>
- <dt><img style="display:none" src="dot.gif"><a target="detail" href="implementation.html#intel80">Intel 8.0</a>
- <dt><img style="display:none" src="dot.gif"><a target="detail" href="implementation.html#vc80">Visual C++ 8.0</a>
- <dt><img style="display:none" src="dot.gif"><a target="detail" href="implementation.html#vc71">Visual C++ 7.1</a>
- <dt><img style="display:none" src="dot.gif"><a target="detail" href="implementation.html#vc70">Visual C++ 7.0</a>
- <dt><img style="display:none" src="dot.gif"><a target="detail" href="implementation.html#vc6">Visual C++ 6.0</a>
- <dt><img style="display:none" src="dot.gif"><a target="detail" href="implementation.html#borland">Borland 5.64 and 5.51</a>
- <dt><img style="display:none" src="dot.gif"><a target="detail" href="implementation.html#comeau">Comeau 4.3.3</a>
- <dt><img style="display:none" src="dot.gif"><a target="detail" href="implementation.html#codewarrior">Code Warrior 8.3</a>
- <dt><img style="display:none" src="dot.gif"><a target="detail" href="implementation.html#tru64">TRU64</a>
- <dt><img style="display:none" src="dot.gif"><a target="detail" href="implementation.html#dinkumware">Dinkumware Library</a>
- <dt><img style="display:none" src="dot.gif"><a target="detail" href="implementation.html#stlport">STLPort 4.5.3</a>
- </dl></div>
- <dt><img style="display:none" src="plus.gif" id="headers"><a target="detail" href="headers.html">Code Structure</a>
- <div id="headers_detail"><dl class="page-index">
- <dt><img style="display:none" src="plus.gif" id="userincludes"><a target="detail" href="headers.html#userincludes">Files Included by User Programs</a>
- <div id="userincludes_detail"><dl class="page-index">
- <dt><img style="display:none" src="dot.gif"><a target="detail" href="headers.html#archiveimplementations">Archive Implementations</a>
- <dt><img style="display:none" src="dot.gif"><a target="detail" href="headers.html#serializationdeclarations">Serialization Declarations</a>
- <dt><img style="display:none" src="dot.gif"><a target="detail" href="headers.html#serializationimplementations">Serialization Implementations</a>
- </dl></div>
- <dt><img style="display:none" src="plus.gif" id="libraryimplementation"><a target="detail" href="headers.html#libraryimplementation">Files Which Implement the Library</a>
- <div id="libraryimplementation_detail"><dl class="page-index">
- <dt><img style="display:none" src="dot.gif"><a target="detail" href="headers.html#archivedevelopment">Archive Development</a>
- <dt><img style="display:none" src="dot.gif"><a target="detail" href="headers.html#archiveinternals">Archive Internals</a>
- <dt><img style="display:none" src="dot.gif"><a target="detail" href="headers.html#codemodules">Archive Library Code Modules</a>
- <dt><img style="display:none" src="dot.gif"><a target="detail" href="headers.html#dataflowiterators">Dataflow Iterators</a>
- </dl></div>
- </dl></div>
+ <dt><img style="display:none" src="dot.gif"><a target="detail" href="special.html#binary_archives">Binary Archives</a>
+ <dt><img style="display:none" src="dot.gif"><a target="detail" href="special.html#xml_archives">XML Archives</a>
+ <dt><img style="display:none" src="dot.gif"><a target="detail" href="special.html#export">Exporting Class Serialization</a>
+ <dt><img style="display:none" src="dot.gif"><a target="detail" href="special.html#static_libraries">Static Libraries and Serialization</a>
+ <dt><img style="display:none" src="dot.gif"><a target="detail" href="special.html#dlls">DLLS - Serialization and Runtime Linking</a>
+ <dt><img style="display:none" src="dot.gif"><a target="detail" href="special.html#plugins">Plugins</a>
+ <dt><img style="display:none" src="dot.gif"><a target="detail" href="special.html#multi_threading">Multi-Threading</a>
+ <dt><img style="display:none" src="dot.gif"><a target="detail" href="special.html#optimizations">Optimzations</a>
+ <dt><img style="display:none" src="plus.gif" id="exceptions"><a target="detail" href="exceptions.html">Archive Exceptions</a>
+ <dd><div id="exceptions_detail"><dl class="page-index">
+ <dt><img style="display:none" src="dot.gif"><a target="detail" href="exceptions.html#unregistered_class"><code>unregistered_class</code></a>
+ <dt><img style="display:none" src="dot.gif"><a target="detail" href="exceptions.html#invalid_signature"><code>invalid_signature</code></a>
+ <dt><img style="display:none" src="dot.gif"><a target="detail" href="exceptions.html#unsupported_version"><code>unsupported_version</code></a>
+ <dt><img style="display:none" src="dot.gif"><a target="detail" href="exceptions.html#pointer_conflict"><code>pointer_conflict</code></a>
+ <dt><img style="display:none" src="dot.gif"><a target="detail" href="exceptions.html#incompatible_native_format"><code>incompatible_format</code></a>
+ <dt><img style="display:none" src="dot.gif"><a target="detail" href="exceptions.html#array_size_too_short"><code>array_size_too_short</code></a>
+ <dt><img style="display:none" src="dot.gif"><a target="detail" href="exceptions.html#stream_error"><code>stream_error</code></a>
+ <dt><img style="display:none" src="dot.gif"><a target="detail" href="exceptions.html#invalid_class_name"><code>invalid_class_name</code></a>
+ <dt><img style="display:none" src="dot.gif"><a target="detail" href="exceptions.html#unregistered_cast"><code>unregistered_cast</code></a>
+ <dt><img style="display:none" src="dot.gif"><a target="detail" href="exceptions.html#xml_archive_parsing_error"><code>xml_archive_parsing_error</code></a>
+ <dt><img style="display:none" src="dot.gif"><a target="detail" href="exceptions.html#xml_archive_tag_mismatch"><code>xml_archive_tag_mismatch</code></a>
+ <dt><img style="display:none" src="dot.gif"><a target="detail" href="exceptions.html#xml_archive_tag_name_error"><code>xml_archive_tag_name_error</code></a>
       </dl></div></dd>
+ <dt><img style="display:none" src="dot.gif"><a target="detail" href="exception_safety.html">Exception Safety</a>
     </dl></div></dd>
- <dt><img style="display:none" src="plus.gif" id="case_studies">Case Studies
- <dd><div id="case_studies_detail"><dl class="page-index">
- <dt><img style="display:none" src="dot.gif"><a target="detail" href="shared_ptr.html">Template serialization - <code>shared_ptr<class T></code></a>
- <dt><img style="display:none" src="dot.gif"><a target="detail" href="shared_ptr2.html"><code>shared_ptr<class T></code>Revisited</a>
- <dt><img style="display:none" src="dot.gif"><a target="detail" href="pimpl.html">PIMPL</a>
- <dt><img style="display:none" src="dot.gif"><a target="detail" href="derivation.html">Derivation from an Existing Archive Class</a>
+ <dt><img style="display:none" src="plus.gif" id="archive_reference"><a target="detail" href="archive_reference.html">Archive Class Reference</a>
+ <dd><div id="archive_reference_detail"><dl class="page-index">
+ <dt><img style="display:none" src="dot.gif"><a target="detail" href="archive_reference.html#implementation">Implementation</a>
+ <dt><img style="display:none" src="dot.gif"><a target="detail" href="archive_reference.html#usage">Usage</a>
+ <dt><img style="display:none" src="dot.gif"><a target="detail" href="archive_reference.html#testing">Testing</a>
+ <dt><img style="display:none" src="dot.gif"><a target="detail" href="archive_reference.html#polymorphic">Polymorphic Archives</a>
     </dl></div></dd>
- <dt><img style="display:none" src="plus.gif" id="otherclasses">Other Classes
- <dd><div id="otherclasses_detail"><dl class="page-index">
- <dt><img style="display:none" src="plus.gif" id="extended_type_info"><a target="detail" href="extended_type_info.html"><code>extended_type_info</code></a>
- <dd><div id="extended_type_info_detail"><dl class="page-index">
- <dt><img style="display:none" src="dot.gif"><a target="detail" href="extended_type_info.html#motivation">Motivation</a>
- <dt><img style="display:none" src="dot.gif"><a target="detail" href="extended_type_info.html#runtime">Runtime Interface</a>
- <dt><img style="display:none" src="dot.gif"><a target="detail" href="extended_type_info.html#requirements">Requirements</a>
- <dt><img style="display:none" src="dot.gif"><a target="detail" href="extended_type_info.html#models">Models</a>
- </dl></div></dd>
- <dt><img style="display:none" src="dot.gif"><a target="detail" href="void_cast.html"><code>void_cast</code></a>
- <dt><img style="display:none" src="dot.gif"><a target="detail" href="codecvt.html"><code>utf8_codecvt_facet</code></a>
- <dt><img style="display:none" src="dot.gif"><a target="detail" href="strong_typedef.html"><code>BOOST_STRONG_TYPEDEF</code></a>
- <dt><img style="display:none" src="dot.gif"><a target="detail" href="state_saver.html"><code>state_saver</code></a>
- <dt><img style="display:none" src="dot.gif"><a target="detail" href="dataflow.html">Dataflow Iterators</a>
- <dt><img style="display:none" src="dot.gif"><a target="detail" href="smart_cast.html"><code>smart_cast</code></a>
- <dt><img style="display:none" src="dot.gif"><a target="detail" href="static_warning.html"><code>BOOST_STATIC_WARNING</code></a>
- <dt><img style="display:none" src="plus.gif" id="singleton"><a target="detail" href="singleton.html"><code>singleton</code></a>
- <dd><div id="singleton_detail"><dl class="page-index">
- <dt><img style="display:none" src="dot.gif"><a target="detail" href="singleton.html#motivation">Motivation</a>
- <dt><img style="display:none" src="dot.gif"><a target="detail" href="singleton.html#features">Features</a>
- <dt><img style="display:none" src="dot.gif"><a target="detail" href="singleton.html#classinterface">Class Interface</a>
- <dt><img style="display:none" src="dot.gif"><a target="detail" href="singleton.html#requirements">Requirements</a>
- <dt><img style="display:none" src="dot.gif"><a target="detail" href="singleton.html#examples">Examples</a>
- <dt><img style="display:none" src="dot.gif"><a target="detail" href="singleton.html#multithreading">Multi-Threading</a>
+ </dl></div></dd>
+ <dt><img style="display:none" src="plus.gif" id="implementation"><a target="detail" href="implementation.html">Implementation Notes</a>
+ <dd><div id="implementation_detail"><dl class="page-index">
+ <dt><img style="display:none" src="dot.gif"><a target="detail" href="implementation.html#functiontemplateordering">Partial Function Template Ordering</a>
+ <dt><img style="display:none" src="dot.gif"><a target="detail" href="implementation.html#charencoding">Character Encoding</a>
+ <dt><img style="display:none" src="dot.gif"><a target="detail" href="implementation.html#tempatesyntax">Template Invocation syntax</a>
+ <dt><img style="display:none" src="dot.gif"><a target="detail" href="implementation.html#partialtemplatespecialization">Partial Template Specialization</a>
+ <dt><img style="display:none" src="plus.gif" id="othercompilerissues"><a target="detail" href="implementation.html#othercompilerissues">Specific Compiler/Library Issues</a>
+ <dd><div id="othercompilerissues_detail"><dl class="page-index">
+ <dt><img style="display:none" src="dot.gif"><a target="detail" href="implementation.html#gcc3x">GCC 3.X,4.X</a>
+ <dt><img style="display:none" src="dot.gif"><a target="detail" href="implementation.html#gcc295">GCC 2.95</a>
+ <dt><img style="display:none" src="dot.gif"><a target="detail" href="implementation.html#intel80">Intel 8.0</a>
+ <dt><img style="display:none" src="dot.gif"><a target="detail" href="implementation.html#vc80">Visual C++ 8.0</a>
+ <dt><img style="display:none" src="dot.gif"><a target="detail" href="implementation.html#vc71">Visual C++ 7.1</a>
+ <dt><img style="display:none" src="dot.gif"><a target="detail" href="implementation.html#vc70">Visual C++ 7.0</a>
+ <dt><img style="display:none" src="dot.gif"><a target="detail" href="implementation.html#vc6">Visual C++ 6.0</a>
+ <dt><img style="display:none" src="dot.gif"><a target="detail" href="implementation.html#borland">Borland 5.64 and 5.51</a>
+ <dt><img style="display:none" src="dot.gif"><a target="detail" href="implementation.html#comeau">Comeau 4.3.3</a>
+ <dt><img style="display:none" src="dot.gif"><a target="detail" href="implementation.html#codewarrior">Code Warrior 8.3</a>
+ <dt><img style="display:none" src="dot.gif"><a target="detail" href="implementation.html#tru64">TRU64</a>
+ <dt><img style="display:none" src="dot.gif"><a target="detail" href="implementation.html#dinkumware">Dinkumware Library</a>
+ <dt><img style="display:none" src="dot.gif"><a target="detail" href="implementation.html#stlport">STLPort 4.5.3</a>
+ </dl></div></dd>
+ <dt><img style="display:none" src="plus.gif" id="headers"><a target="detail" href="headers.html">Code Structure</a>
+ <dd><div id="headers_detail"><dl class="page-index">
+ <dt><img style="display:none" src="plus.gif" id="userincludes"><a target="detail" href="headers.html#userincludes">Files Included by User Programs</a>
+ <dd><div id="userincludes_detail"><dl class="page-index">
+ <dt><img style="display:none" src="dot.gif"><a target="detail" href="headers.html#archiveimplementations">Archive Implementations</a>
+ <dt><img style="display:none" src="dot.gif"><a target="detail" href="headers.html#serializationdeclarations">Serialization Declarations</a>
+ <dt><img style="display:none" 'rc="dot.gif"><a target="detail" href="headers.html#serializationimplementations">Serialization Implementations</a>
+ </dl></div>
+ <dt><img style="display:none" src="plus.gif" id="libraryimplementation"><a target="detail" href="headers.html#libraryimplementation">Files Which Implement the Library</a>
+ <dd><div id="libraryimplementation_detail"><dl class="page-index">
+ <dt><img style="display:none" src="dot.gif"><a target="detail" href="headers.html#archivedevelopment">Archive Development</a>
+ <dt><img style="display:none" src="dot.gif"><a target="detail" href="headers.html#archiveinternals">Archive Internals</a>
+ <dt><img style="display:none" src="dot.gif"><a target="detail" href="headers.html#codemodules">Archive Library Code Modules</a>
+ <dt><img style="display:none" src="dot.gif"><a target="detail" href="headers.html#dataflowiterators">Dataflow Iterators</a>
       </dl></div></dd>
     </dl></div></dd>
- 
- <dt><img style="display:none" src="dot.gif"><a target="detail" href="faq.html">Tips and Tricks</a>
- <dt><img style="display:none" src="plus.gif" id="rationale"><a target="detail" href="rationale.html">Rationale</a></dt>
- <dd><div id="rationale_detail"><dl class="page-index">
- <dt><img style="display:none" src="dot.gif"><a target="detail" href="rationale.html#serialization">The term "serialization" is preferred to "persistence"</a></dt>
- <dt><img style="display:none" src="dot.gif"><a target="detail" href="rationale.html#archives">Archives are not streams</a></dt>
- <dt><img style="display:none" src="dot.gif"><a target="detail" href="rationale.html#typeid"><code style="white-space: normal">typeid</code> information is not included in archives</a></dt>
- <dt><img style="display:none" src="dot.gif"><a target="detail" href="rationale.html#trap">Compile time trap when saving a non-const value</a></dt>
+ <dt><img style="display:none" src="dot.gif"><a target="detail" href="faq.html">Tips and Tricks</a>
+ <dt><img style="display:none" src="plus.gif" id="rationale"><a target="detail" href="rationale.html">Rationale</a></dt>
+ <dd><div id="rationale_detail"><dl class="page-index">
+ <dt><img style="display:none" src="dot.gif"><a target="detail" href="rationale.html#serialization">The term "serialization" is preferred to "persistence"</a></dt>
+ <dt><img style="display:none" src="dot.gif"><a target="detail" href="rationale.html#archives">Archives are not streams</a></dt>
+ <dt><img style="display:none" src="dot.gif"><a target="detail" href="rationale.html#typeid"><code style="white-space: normal">typeid</code> information is not included in archives</a></dt>
+ </dl></div></dd>
+
+ <dt><img style="display:none" src="plus.gif" id="todo"><a target="detail" href="todo.html">To Do</a></dt>
+ <dd><div id="todo_detail"><dl class="page-index">
+ <dt><img style="display:none" src="dot.gif"><a target="detail" href="todo.html#portablebinaryarchive">Portable Binary Archive</a></dt>
+ <dt><img style="display:none" src="dot.gif"><a target="detail" href="todo.html#performancetesting">Performance Testing and Profiling</a></dt>
+ <dt><img style="display:none" src="dot.gif"><a target="detail" href="todo.html#backversioning">Back Versioning</a></dt>
+ <dt><img style="display:none" src="dot.gif"><a target="detail" href="todo.html#nortti">Environments without RTTI</a></dt>
+
+ <dt><img style="display:none" src="plus.gif" id="newcasestudies"><a target="detail" href="new_case_studies.html">Proposed Case Studies</a></dt>
+ <dd><div id="newcasestudies_detail"><dl class="page-index">
+ <dt><img style="display:none" src="dot.gif"><a target="detail" href="new_case_studies.html#functionobject">Serializing a Function Object</a></dt>
+ <dt><img style="display:none" src="dot.gif"><a target="detail" href="new_case_studies.html#archiveadaptor">Archive Adaptors</a></dt>
+ <dt><img style="display:none" src="dot.gif"><a target="detail" href="new_case_studies.html#archivehelper">Archive Helpers</a></dt>
     </dl></div></dd>

- <dt><img style="display:none" src="plus.gif" id="todo"><a target="detail" href="todo.html">To Do</a></dt>
- <dd><div id="todo_detail"><dl class="page-index">
- <dt><img style="display:none" src="dot.gif"><a target="detail" href="todo.html#portablebinaryarchive">Portable Binary Archive</a></dt>
- <dt><img style="display:none" src="dot.gif"><a target="detail" href="todo.html#performancetesting">Performance Testing and Profiling</a></dt>
- <dt><img style="display:none" src="dot.gif"><a target="detail" href="todo.html#backversioning">Back Versioning</a></dt>
- <dt><img style="display:none" src="dot.gif"><a target="detail" href="todo.html#nortti">Environments without RTTI</a></dt>
-
- <dt><img style="display:none" src="plus.gif" id="newcasestudies"><a target="detail" href="new_case_studies.html">Proposed Case Studies</a></dt>
- <dd><div id="newcasestudies_detail"><dl class="page-index">
- <dt><img style="display:none" src="dot.gif"><a target="detail" href="new_case_studies.html#functionobject">Serializing a Function Object</a></dt>
- <dt><img style="display:none" src="dot.gif"><a target="detail" href="new_case_studies.html#archiveadaptor">Archive Adaptors</a></dt>
- <dt><img style="display:none" src="dot.gif"><a target="detail" href="new_case_studies.html#archivehelper">Archive Helpers</a></dt>
- </dl></div></dd>
-
- </dl></div></dd>
+ </dl></div></dd>

- <dt><img style="display:none" src="dot.gif"><a target="detail" href="history.html">History</a>
- 
- <dt><img style="display:none" src="dot.gif"><a target="detail" href="bibliography.html">Bibliography</a></dt>
- <dt><img style="display:none" src="dot.gif"><a target="detail" href="acknowledgments.html">Acknowledgments</a></dt>
- </dl></div>
+ <dt><img style="display:none" src="dot.gif"><a target="detail" href="bibliography.html">Bibliography</a></dt>
+ <dt><img style="display:none" src="dot.gif"><a target="detail" href="acknowledgments.html">Acknowledgments</a></dt>
+</dl></div>
</small>
</body>
</html>

Modified: branches/release/libs/serialization/doc/exceptions.html
==============================================================================
--- branches/release/libs/serialization/doc/exceptions.html (original)
+++ branches/release/libs/serialization/doc/exceptions.html 2009-09-19 22:18:02 EDT (Sat, 19 Sep 2009)
@@ -36,6 +36,7 @@
   <dt>stream_error
   <dt>invalid_class_name
   <dt>unregistered_class
+ <dt>multiple_code_instantiation
   <dt>xml_archive_parsing_error
   <dt>xml_archive_tag_mismatch
   <dt>xml_archive_tag_name_error
@@ -75,9 +76,11 @@
                                 // to insert virus via buffer overrun method.
         unregistered_cast, // base - derived relationship not registered with
                                 // void_cast_register
- unsupported_class_version // type saved with a version # greater than the
+ unsupported_class_version, // type saved with a version # greater than the
                             // one used by the program. This indicates that the proggram
                             // needs to be rebuilt.
+ multiple_code_instantiation // code for implementing serialization for some
+ // type has been instantiated in more than one module.
     } exception_code;
     exception_code code;
     archive_exception(exception_code c) : code(c) {}
@@ -228,6 +231,11 @@
This exception is thrown if an attempt is made to convert between two pointers
whose relationship has not been registered,

+<h3><a name="multiple_code_instantiation"><code style="white-space: normal">multiple_code_instantiation</code></a></h3>
+This exception is thrown when it is detected that the serialization of the same type
+has been instantiated more that once. This might occur when
+serialization code is instantiated in both the mainline and one or more DLLS.
+
<h3><a name="xml_archive_parsing_error"><code style="white-space: normal">xml_archive_parsing_error</code></a></h3>
The XML generated by the serialization process is intimately coupled to the
C++ class structure, relationships between objects and the serialization

Modified: branches/release/libs/serialization/doc/extended_type_info.html
==============================================================================
--- branches/release/libs/serialization/doc/extended_type_info.html (original)
+++ branches/release/libs/serialization/doc/extended_type_info.html 2009-09-19 22:18:02 EDT (Sat, 19 Sep 2009)
@@ -105,14 +105,15 @@
     // this class can't be used as is. It's just the
     // common functionality for all type_info replacement
     // systems. Hence, make these protected
- const char * m_key;
- extended_type_info(const unsigned int type_info_key);
+ extended_type_info(
+ const unsigned int type_info_key,
+ const char * key
+ );
     ~extended_type_info();
+ void key_register();
+ void key_unregister();
public:
- void key_register(const char *key);
- const char * get_key() const {
- return m_key;
- }
+ const char * get_key() const;
     bool operator<(const extended_type_info &rhs) const;
     bool operator==(const extended_type_info &rhs) const;
     bool operator!=(const extended_type_info &rhs) const {
@@ -139,30 +140,43 @@
<dl>

<dt><h4><pre><code>
-extended_type_info(unsigned int type_info_key);
+extended_type_info(unsigned int type_info_key, const char *key);
</code></pre></h4></dt>
<dd>
This constructor should be called by all derived classes.
-The argument should be the particular implementation. For
-this default implementation base on typeid(), this is the
+The first argument should be the particular implementation.
+For this default implementation base on typeid(), this is the
value 1. Each system must have its own integer. This value
is used to permit the inter-operability of different typeinfo
systems.
+<p>
+The second argument is a const string which is the external
+name of the type to which this record corresponds.
+It may sometimes be referred to as a GUID - a <b>G</b>lobal <b>U</b>nique <b>ID</b>entifier.
+It is passed through archives from one program invocation to
+another to uniquely identify the types that the archive contains.
+If the "export" facility is not going to be used,
+this value may be NULL.
</dd>

<dt><h4><pre><code>
-void key_register(const char *key);
+void key_register();
+void key_unregister();
</code></pre></h4></dt>
<dd>
-Assign a unique character string identifier to this
-<code style="white-space: normal"><a target="extended_type_info.hpp" href = "../../../boost/serialization/extended_type_info.hpp">extended_type_info</a></code>
-instance and add it to the corresponding global trable.
-This key is used to identify a type accross different instances of the program.
-In this way, one instance may know what type to create when necessary.
-For this purpose, it must be the same in all program instances which
-refer to the same type.
+This system maintains a global table which relates
+external strings to
+<code style="white-space: normal">extended_type_info</code> records.
+This table is used when loading pointers to objects serialized
+through a base class pointer. In this case, the archive
+contains a string which is looked up in this table to
+determine which <code style="white-space: normal">extended_type_info</code>
+to use for creating a new object.
<p>
-It may sometimes be referred to as a GUID - a <b>G</b>lobal <b>U</b>nique <b>ID</b>entifier.
+These functions are called by constructors and
+destructors of classes which implement
+<code style="white-space: normal">extended_type_info</code>
+to add and remove entries from this table.
</dd>

<dt><h4><pre><code>
@@ -185,7 +199,8 @@
extended_type_info
</code>
</a>
-objects. They a strict total ordering on all instances of this class.
+objects. They impose a strict total ordering on all
+<code style="white-space: normal">extended_type_info</code> records.
</dd>

<dt><h4><pre><code>
@@ -245,20 +260,6 @@

<dt><h4><code style="white-space: normal"><pre>
template<class ETI>
-static extended_type_info &
-ETI::get_mutable_instance();
-static const extended_type_info &
-ETI::get_const:instance();
-</pre></code></h4></dt>
-<dd>
-Return a pointer to the instance of
-<code style="white-space: normal">extended_type_info</code>
-which corresponds to type T. Normally these instances are static objects so
-this just amounts to returning the address of this static object.
-</dd>
-
-<dt><h4><code style="white-space: normal"><pre>
-template<class ETI>
const extended_type_info *
ETI::get_derived_extended_type_info(const T & t) const;
</pre></code></h4></dt>
@@ -274,12 +275,47 @@
</dd>

<dt><h4><code style="white-space: normal"><pre>
-bool ETI::less_than(const extended_type_info &rhs) const;
+virtual bool ETI::is_less_than(const extended_type_info &rhs) const;
</pre></code></h4></dt>
<dd>
Compare this instance to another one using the same
<code style="white-space: normal">extended_type_info</code> implementation.
</dd>
+
+<dt><h4><code style="white-space: normal"><pre>
+virtual bool ETI::is_equal(const extended_type_info &rhs) const;
+</pre></code></h4></dt>
+<dd>
+Compare this instance to another one using the same
+<code style="white-space: normal">extended_type_info</code> implementation.
+Return <code style="white-space: normal">true</code> if the types referred
+to are the same. Otherwise return
+<code style="white-space: normal">false</code>
+</dd>
+
+<dt><h4><code style="white-space: normal"><pre>
+const char ETI::get_key() const;
+</pre></code></h4></dt>
+<dd>
+Retrieve the external key (aka GUID) for this class.
+</dd>
+
+<dt><h4><code style="white-space: normal"><pre>
+virtual void * construct(unsigned int count, ...) const;
+</pre></code></h4></dt>
+<dd>
+Construct an instance of the corresponding type
+with the include argument list.
+</dd>
+
+<dt><h4><code style="white-space: normal"><pre>
+virtual void * destroy(void const * const ptr ) ) const;
+</pre></code></h4></dt>
+<dd>
+Destroy an instance of this type. This calls the
+proper destructor and recovers allocated memory.
+</dd>
+
</dl>

<h3><a name="models">Models</a></h3>
@@ -294,7 +330,8 @@
<code style="white-space: normal"><h4><a target="extended_type_info_no_rtti.hpp" href="../../../boost/serialization/extended_type_info_no_rtti.hpp">
extended_type_info_no_rtti</a></h4></code>
is implemented in a way that doesn't rely on the existence RTTI.
-However, if the export facility is to be used to serialize types
+Instead, it requires that all polymorphic types be explictly exported.
+In addition, if the export facility is to be used to serialize types
through base class pointers, those types are required to implement
a virtual function with the signature:

@@ -304,7 +341,8 @@
which returns a unique string the most derived object this class.
This function must be virtual in order to implement the functionality required by
<code style="white-space: normal">ETI::get_derived_extended_type_info</code>
-as described above.
+as described above.
+
<h3><a name="example">Example</a></h3>
The test program <code style="white-space: normal"><a target="test_no_rtti" href="../test/test_no_rtti.cpp">test_no_rtti</a></code>
implements this function in terms of the <code style="white-space: normal"><a target="extended_type_info_no_rtti.hpp" href="../../../boost/serialization/extended_type_info_no_rtti.hpp">

Modified: branches/release/libs/serialization/doc/rationale.html
==============================================================================
--- branches/release/libs/serialization/doc/rationale.html (original)
+++ branches/release/libs/serialization/doc/rationale.html 2009-09-19 22:18:02 EDT (Sat, 19 Sep 2009)
@@ -110,226 +110,6 @@
In effect, <code style="white-space: normal">export</code> generates a portable equivalent to
<code style="white-space: normal">typeid</code> information.

-<h2><a name="trap"></a>Compile time trap when saving a non-const value</h2>
-</p>
-The following code will fail to compile. The failure will occur on a line with a
-<code style="white-space: normal">BOOST_STATIC_ASSERT</code>.
-Here, we refer to this as a compile time trap.
-<code style="white-space: normal"><pre>
-T t;
-ar << t;
-</pre></code>
-
-unless the tracking_level serialization trait is set to "track_never". The following
-will compile without problem:
-
-<code style="white-space: normal"><pre>
-const T t
-ar << t;
-</pre></code>
-
-Likewise, the following code will trap at compile time:
-
-<code style="white-space: normal"><pre>
-T * t;
-ar >> t;
-</pre></code>
-
-if the tracking_level serialization trait is set to "track_never".
-<p>
-
-This behavior has been contraversial and may be revised in the future. The criticism
-is that it will flag code that is in fact correct and force users to insert
-<code style="white-space: normal">const_cast</code>. My view is that:
-<ul>
- <li>The trap is useful in detecting a certain class of programming errors.
- <li>Such errors would otherwise be difficult to detect.
- <li>The incovenience caused by including this trap is very small in relation
- to its benefits.
-</ul>
-
-The following case illustrates my position. It was originally used as an example in the
-mailing list by Peter Dimov.
-
-<code style="white-space: normal"><pre>
-class construct_from
-{
- ...
-};
-
-void main(){
- ...
- Y y;
- construct_from x(y);
- ar << x;
-}
-</pre></code>
-
-Suppose that there is no trap as described above.
-<ol>
- <li>this example compiles and executes fine. No tracking is done because
- construct_from has never been serialized through a pointer. Now some time
- later, the next programmer(2) comes along and makes an enhancement. He
- wants the archive to be sort of a log.
-
-<code style="white-space: normal"><pre>
-void main(){
- ...
- Y y;
- construct_from x(y);
- ar << x;
- ...
- x.f(); // change x in some way
- ...
- ar << x
-}
-</pre></code>
- <p>
- Again no problem. He gets two different of copies in the archive, each one is different.
- That is he gets exactly what he expects and is naturally delighted.
- <p>
- <li>Now sometime later, a third programmer(3) sees construct_from and says -
- oh cool, just what I need. He writes a function in a totally disjoint
- module. (The project is so big, he doesn't even realize the existence of
- the original usage) and writes something like:
-
-<code style="white-space: normal"><pre>
-class K {
- shared_ptr <construct_from> z;
- template <class Archive>
- void serialize(Archive & ar, const unsigned version){
- ar << z;
- }
-};
-</pre></code>
-
- <p>
- He builds and runs the program and tests his new functionality. It works
- great and he's delighted.
- <p>
- <li>Things continue smoothly as before. A month goes by and it's
- discovered that when loading the archives made in the last month (reading the
- log). Things don't work. The second log entry is always the same as the
- first. After a series of very long and increasingly acrimonius email exchanges,
-its discovered
- that programmer (3) accidently broke programmer(2)'s code .This is because by
- serializing via a pointer, the "log" object now being tracked. This is because
- the default tracking behavior is "track_selectively". This means that class
- instances are tracked only if they are serialized through pointers anywhere in
- the program. Now multiple saves from the same address result in only the first one
- being written to the archive. Subsequent saves only add the address - even though the
- data might have been changed. When it comes time to load the data, all instances of the log record show the same data.
- In this way, the behavior of a functioning piece of code is changed due the side
- effect of a change in an otherwise disjoint module.
- Worse yet, the data has been lost and cannot not be now recovered from the archives.
- People are really upset and disappointed with boost (at least the serialization system).
- <p>
- <li>
- After a lot of investigation, it's discovered what the source of the problem
- and class construct_from is marked "track_never" by including:
-<code style="white-space: normal"><pre>
-BOOST_CLASS_TRACKING(construct_from, track_never)
-</pre></code>
- <li>Now everything works again. Or - so it seems.
- <p>
- <li><code style="white-space: normal">shared_ptr<construct_from></code>
-is not going to have a single raw pointer shared amongst the instances. Each loaded
-<code style="white-space: normal">shared_ptr<construct_from></code> is going to
-have its own distinct raw pointer. This will break
-<code style="white-space: normal">shared_ptr</code> and cause a memory leak. Again,
-The cause of this problem is very far removed from the point of discovery. It could
-well be that the problem is not even discovered until after the archives are loaded.
-Now we not only have difficult to find and fix program bug, but we have a bunch of
-invalid archives and lost data.
-</ol>
-
-Now consider what happens when the trap is enabled:.
-
-<ol>
- <p>
- <li>Right away, the program traps at
-<code style="white-space: normal"><pre>
-ar << x;
-</pre></code>
- <p>
- <li>The programmer curses (another %^&*&* hoop to jump through). If he's in a
- hurry (and who isn't) and would prefer not to <code style="white-space: normal">const_cast</code>
- - because it looks bad. So he'll just make the following change an move on.
-<code style="white-space: normal"><pre>
-Y y;
-const construct_from x(y);
-ar << x;
-</pre></code>
- <p>
- Things work fine and he moves on.
- <p>
- <li>Now programer (2) wants to make his change - and again another
- annoying const issue;
-<code style="white-space: normal"><pre>
-Y y;
-const construct_from x(y);
-...
-x.f(); // change x in some way ; compile error f() is not const
-...
-ar << x
-</pre></code>
- <p>
- He's mildly annoyed now he tries the following:
- <ul>
- <li>He considers making f() a const - but presumable that shifts the const
- error to somewhere else. And his doesn't want to fiddle with "his" code to
- work around a quirk in the serializaition system
- <p>
- <li>He removes the <code style="white-space: normal">const</code>
- from <code style="white-space: normal">const construct_from</code> above - damn now he
- gets the trap. If he looks at the comment code where the
- <code style="white-space: normal">BOOST_STATIC_ASSERT</code>
- occurs, he'll do one of two things
- <ol>
- <p>
- <li>This is just crazy. Its making my life needlessly difficult and flagging
- code that is just fine. So I'll fix this with a <code style="white-space: normal">const_cast</code>
- and fire off a complaint to the list and mabe they will fix it.
- In this case, the story branches off to the previous scenario.
- <p>
- <li>Oh, this trap is suggesting that the default serialization isn't really
- what I want. Of course in this particular program it doesn't matter. But
- then the code in the trap can't really evaluate code in other modules (which
- might not even be written yet). OK, I'll add the following to my
- construct_from.hpp to solve the problem.
-<code style="white-space: normal"><pre>
-BOOST_CLASS_TRACKING(construct_from, track_never)
-</pre></code>
- </ol>
- </ul>
- <p>
- <li>Now programmer (3) comes along and make his change. The behavior of the
- original (and distant module) remains unchanged because the
- <code style="white-space: normal">construct_from</code> trait has been set to
- "track_never" so he should always get copies and the log should be what we expect.
- <p>
- <li>But now he gets another trap - trying to save an object of a
- class marked "track_never" through a pointer. So he goes back to
- construct_from.hpp and comments out the
- <code style="white-space: normal">BOOST_CLASS_TRACKING</code> that
- was inserted. Now the second trap is avoided, But damn - the first trap is
- popping up again. Eventually, after some code restructuring, the differing
- requirements of serializating <code style="white-space: normal">construct_from</code>
- are reconciled.
-</ol>
-Note that in this second scenario
-<ul>
- <li>all errors are trapped at compile time.
- <li>no invalid archives are created.
- <li>no data is lost.
- <li>no runtime errors occur.
-</ul>
-
-It's true that these traps may sometimes flag code that is currently correct and
-that this may be annoying to some programmers. However, this example illustrates
-my view that these traps are useful and that any such annoyance is small price to
-pay to avoid particularly vexing programming errors.
-
<!--
<h2><a name="footnotes"></a>Footnotes</h2>
<dl>

Modified: branches/release/libs/serialization/doc/serialization.html
==============================================================================
--- branches/release/libs/serialization/doc/serialization.html (original)
+++ branches/release/libs/serialization/doc/serialization.html 2009-09-19 22:18:02 EDT (Sat, 19 Sep 2009)
@@ -1,4 +1,4 @@
-ï»¿<!doctype HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
+<!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 .
@@ -62,8 +62,8 @@
     </dl>
   <dt>References
   <dt>Arrays
- <dt>Serialization Wrappers
   <dt>Class Serialization Traits
+ <dt>Serialization Wrappers
   <dt>Models - Serialization Implementations Included in the Library
</dl>

@@ -794,7 +794,7 @@
         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)
         )
     }

Modified: branches/release/libs/serialization/doc/special.html
==============================================================================
--- branches/release/libs/serialization/doc/special.html (original)
+++ branches/release/libs/serialization/doc/special.html 2009-09-19 22:18:02 EDT (Sat, 19 Sep 2009)
@@ -1,4 +1,4 @@
-ï»¿<!doctype HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
+<!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 .
@@ -36,6 +36,7 @@
   <dt>Binary Archives
   <dt>XML Archives
   <dt>Exporting Class Serialization
+ <dt>Static Libraries and Serialization
   <dt>DLLS - Serialization and Runtime Linking
   <dt>Plugins
   <dt>Multi-Threading
@@ -339,16 +340,18 @@
of a stand alone executable, a static library or
a dyanmic or shared library.
<p>
-Note that including
+Including
<code style="white-space: normal">BOOST_CLASS_EXPORT</code>
in the "a.hpp" header itself as one would do with
other serialization traits will make it difficult
or impossible to follow the rule above regarding
inclusion of archive headers before
<code style="white-space: normal">BOOST_CLASS_EXPORT</code>
-is invoked. This is different than other serialization
-traits which would normally be included in same file
-as the class declaration.
+is invoked. This can best be addressed by using
+<code style="white-space: normal">BOOST_CLASS_EXPORT_KEY</code>
+in the header declarations and
+<code style="white-space: normal">BOOST_CLASS_EXPORT_IMPLEMENT</code>
+in the class definition file.

<p>
This system has certain implications for placing code in static or shared
@@ -358,13 +361,6 @@
for all the archive classes which he anticipates using. Alternatively,
one can include headers for just the
<a href="archive_reference.html#polymorphic">Polymoprhic Archives</a>.
-Also, when making shared libraries, there is currently a restriction
-that only one such library can use <code style="white-space: normal">BOOST_CLASS_EXPORT</code>
-for any given type. All this will most likely make it inconvenient
-to include <code style="white-space: normal">BOOST_CLASS_EXPORT</code>
-as part of the header of the class to be serialized. So, <b>the
-best way to use <code style="white-space: normal">BOOST_CLASS_EXPORT</code>
-is to include it in the same module which implements the class</b>.

<p>
Strictly speaking, export should not be necessary if all pointer serialization
@@ -383,19 +379,33 @@
It's reasonable to expect that future C++ compilers will support
these extensions or something equivalent.

-<h3><a name="dlls">DLLS - Serialization and Runtime Linking</a></h3>
-Serialization code can be placed in libraries to be linked at runtime. That is,
-code can be placed in DLLS(Windows) Shared Libraries(*nix), or static libraries
-as well as the main executable. As long as
-
-<a target="detail" href="serialization.html#export">
-<code style="white-space: normal">BOOST_CLASS_EXPORT</code>
-</a>
-
-is not used, The serialization library imposes no special requirements
-that need be taken into account when distributing code among various modules.
-<p>
-For static libraries, this is illustrated by
+<h3><a name="static_libraries">Static Libraries and Serialization</a></h3>
+Code for serialization of data types can be saved in libraries
+just as it can for the rest of the type implementation.
+This works well, and can save huge amount of compilation time.
+<ul>
+<li>Only compile serialization definitions in the library.
+<li>Explicitly instantiate serialization code for ALL
+archive classes you intend to use in the library.
+<li>For exported types, only use <code style="white-space: normal">BOOST_CLASS_EXPORT_KEY</code>
+in headers.
+<li>For exported types, only use <code style="white-space: normal">BOOST_CLASS_EXPORT_IMPLEMENT</code>
+in definitions compiled in the library. For any particular type,
+there should be only one file which contains
+<code style="white-space: normal">BOOST_CLASS_EXPORT_IMPLEMENT</code>
+for that type. This ensures that only one copy
+of serialization code will exist within the program. It avoids
+wasted space and the possibility of having different
+versions of the serialization code in the same program.
+Including
+<code style="white-space: normal">BOOST_CLASS_EXPORT_IMPLEMENT</code>
+in multiple files could result in a failure
+to link due to duplicated symbols or the throwing
+of a runtime exception.
+<li> Code for serialization should be only in the library,
+<li>Familiarize yourself with the <b>PIMPL</b> idiom.
+</ul>
+This is illustrated by
<a href = "../example/demo_pimpl.cpp" target="demo_pimpl">
<code style="white-space: normal">demo_pimpl.cpp</code>
</a>,
@@ -409,8 +419,14 @@
where implementation of serializaton is in a static library
completely separate from the main program.

+<h3><a name="dlls">DLLS - Serialization and Runtime Linking</a></h3>
+Serialization code can be placed in libraries to be linked at runtime. That is,
+code can be placed in DLLS(Windows) Shared Libraries(*nix), or static libraries
+as well as the main executable. The best technique is the
+same as that described above for libraries. The serialization
+library test suite includes the following programs
+to illustrate how this works:
<p>
-For runtime linked libraries this is illustrated by one of the tests:

<a href = "../test/test_dll_simple.cpp" target="test_dll_simple">
<code style="white-space: normal">test_dll_simple</code>
@@ -424,6 +440,17 @@
example, this code is loaded automatically when the program which
uses it starts up, but it could just as well be loaded and unloaded
with an OS dependent API call.
+<p>
+Also included are
+<a href = "../test/test_dll_exported.cpp" target="test_dll_exported">
+<code style="white-space: normal">test_dll_exported.cpp</code>
+</a>,
+and
+<a href = "../test/polymorphic_derived2.cpp" target="polymorphic_derived2">
+<code style="white-space: normal">polymorphic_derived2.cpp</code>
+</a>
+which are similar to the above but include tests of the export
+and no_rtti facilities in the context of DLLS.

<h3><a name="plugins">Plugins</a></h3>
In order to implement the library, various facilities for runtime

Modified: branches/release/libs/serialization/doc/traits.html
==============================================================================
--- branches/release/libs/serialization/doc/traits.html (original)
+++ branches/release/libs/serialization/doc/traits.html 2009-09-19 22:18:02 EDT (Sat, 19 Sep 2009)
@@ -1,4 +1,4 @@
-ï»¿<!doctype HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
+<!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 .
@@ -33,7 +33,9 @@
   <dt>Abstract
   <dt>Type Information Implementation
   <dt>Wrappers
+ <dt>Bitwise Serialization
   <dt>Template Serialization Traits
+ <dt>Compile Time Warnings and Errors
</dl>
Serialization of data depends on the type of the data. For example, for
primitive types such as an <code style="white-space: normal">int</code>, it wouldn't make sense to save
@@ -202,13 +204,23 @@
situation is demonstrated by
<a href="../test/test_diamond.cpp" target="test_diamond_cpp">test_diamond.cpp</a>
included with the library.
+
<h3><a name="export">Export Key</a></h3>
-When serializing a derived class through a base class pointer, it
-may be convenient to define an external name by which the
-derived class can be identified.
-<i>(<a target="detail" href="special.html#derivedpointers">Elsewhere</a>
-in this manual, the
-serialization of derived classes is addressed in detail.)</i>
+
+When serializing a derived class through a virtual base class pointer,
+two issues may arise.
+<ul>
+<li> The code in the derived class might never be explicitly
+referred to. Such code will never be instantiated.
+<p>
+This is addressed by invoking
+<code style="white-space: normal">BOOST_CLASS_EXPORT_IMPLEMENT(T)</code>
+in the file which defines (implements) the class T.
+This ensures that code for the derived class T will
+be explicity instantiated.
+<li> There needs to be some sort of identifier which can
+be used to select the code to be invoked when the object
+is loaded.
Standard C++ does implement <code style="white-space: normal">typeid()</code> which can be
used to return a unique string for the class. This is not entirely
statisfactory for our purposes for the following reasons:
@@ -222,26 +234,36 @@
   <li>There might be classes with different names that we want to
   consider equivalent for purposes of of serialization.
</ul>
-So the header file
-export.hpp
-includes macro definitions to specify the external string used
-to identify the class.
-<i>(<b>GUID</b> stands for <b>G</b>lobally <b>U</b>nique <b>ID</b>entfier.)</i>
-<pre><code>
-BOOST_CLASS_EXPORT_GUID(my_class, "my_class_external_identifier")
-</code></pre>
+<p>
+So in the serialization library, this is addressed by invoking
+<code style="white-space: normal">BOOST_CLASS_EXPORT_KEY2(my_class, "my_class_external_identifier")</code>
+in the header file which declares he class.
In a large majority of applications, the class name works just fine
for the external identifier string so the following short cut is
-defined
-<pre><code>
-BOOST_CLASS_EXPORT(my_class)
-</code></pre>
-which expands to:
-<pre><code>
-BOOST_CLASS_EXPORT_GUID(my_class, "my_class")
-</code></pre>
-If the an external name is required somewhere in the program and none
-has been assigned, a static assertion will be invoked.
+defined -
+<code style="white-space: normal">BOOST_CLASS_EXPORT_KEY(my_class)</code>.
+</ul>
+For programs which consist of only one module - that is
+programs which do not use DLLS, one can specify
+<code style="white-space: normal">BOOST_CLASS_EXPORT(my_class)</code>
+or
+<code style="white-space: normal">BOOST_CLASS_EXPORT_GUID(my_class, "my_class_external_identifier")</code>
+in either he declaration header or definition. These macros
+expand to invocation of the of both of the macros described above.
+<i>(<b>GUID</b> stands for <b>G</b>lobally <b>U</b>nique <b>ID</b>entfier.)</i>
+<p>
+<i>(<a target="detail" href="special.html#export">Elsewhere</a>
+in this manual, the serialization of derived classes is addressed in detail.)</i>
+<p>
+The header file
+export.hpp
+contains all macro definitions described here.
+The library will throw a runtime exception if
+<ul>
+<li> A type not explicitly referred to is not exported.
+<li> Serialization code for the same type is instantiated
+in more than one module (or DLL).
+</ul>

<h3><a name="abstract">Abstract</a></h3>
When serializing an object through a pointer to its base class,
@@ -353,7 +375,30 @@
</code></pre>
which expands to the code above.

+<h3><a name="bitwise">Bitwise Serialization</a></h3>
+Some simple classes could be serialized just by directly copying all bits
+of the class. This is, in particular, the case for POD data types containing
+no pointer members, and which are neither versioned nor tracked. Some archives,
+such as non-portable binary archives can make us of this information to
+substantially speed up serialization.

+To indicate the possibility of bitwise serialization the type trait defined
+in the header
+file is_bitwise_serializable.hpp
+is used:
+<pre><code>
+namespace boost { namespace serialization {
+ template<class T>
+ struct is_bitwise_serializable
+ : public is_arithmetic<T>
+ {};
+} }
+</code></pre>
+is used, and can be specialized for other classes. The specialization
+is made easy by the corresponding macro:
+<pre><code>
+BOOST_IS_BITWISE_SERIALIZABLE(my_class)
+</code></pre>

<h3><a name="templates">Template Serialization Traits</a></h3>
In some instances it might be convenient to assign serialization traits
@@ -468,30 +513,290 @@
<tr><td><code>IsWrapper</code></td><td><code></code>is the type a wrapper?</td><td><code>mpl::false_<br>mpl::true_</code></td><td><code>mpl::false_</code></td></tr>
</table>

-<h3><a name="tracking">Bitwise serialization</a></h3>
-Some simple classes could be serialized just by directly copying all bits
-of the class. This is, in particular, the case for POD data types containing
-no pointer members, and which are neither versioned nor tracked. Some archives,
-such as non-portable binary archives can make us of this information to
-substantially speed up serialization.
+<h3><a name="compiletime_messages">Compile Time Warnings and Errors</a></h3>
+Some serialization traits can conflict with other ones. Sometimes these conflicts
+will result in erroneous behavior (E.G. creating of archives which could not be read)
+and other times they represent a probable misconception on the part of the
+library user which could result in suprising behavior. The extent possible,
+these conflicts are detected at compile time and errors (BOOST_STATIC_ASSERT)
+or warnings (BOOST_STATIC_WARNING) are generated. The are generated in a
+compiler dependent way manner which should show an chain of instantiation
+to the point where the error/warning is detected. Without this capability,
+it would be very hard to track down errors or unexpected behavior in library
+usage. Here is list of the conflicts trapped:
+
+<dl>
+<dt><h2><a name="object_level">object_level</a> - error</h2></dt>
+<dd>
+This error traps attempts to serialize types whose
+implentation level is set to non_serializable.
+</dd>
+<dt><h2><a name="object_versioning">object_versioning</a> - error</h2></dt>
+<dd>
+It's possible that for efficiency reasons, a type can be
+assigned a serialization level which doesn't include type information
+in the archive. This would preclude the assignment
+of a new version number to the type. This error
+traps attempts to assign a version number in this case.
+This has to be a user error.
+</dd>
+
+<dt><h2><a name="object_tracking">object_tracking</a> - warning</h2></dt>
+<dd>
+The following code will display a message when compiled:
+
+<code style="white-space: normal"><pre>
+T t;
+ar << t;
+</pre></code>
+
+unless the tracking_level serialization trait is set to "track_never". The following
+will compile without problem:
+
+<code style="white-space: normal"><pre>
+const T t
+ar << t;
+</pre></code>
+
+Likewise, the following code will trap at compile time:
+
+<code style="white-space: normal"><pre>
+T * t;
+ar >> t;
+</pre></code>
+
+if the tracking_level serialization trait is set to "track_never".
+<p>
+
+The following case illustrates the function of this message.
+It was originally used as an example in the
+mailing list by Peter Dimov.
+
+<code style="white-space: normal"><pre>
+class construct_from
+{
+ ...
+};
+
+void main(){
+ ...
+ Y y;
+ construct_from x(y);
+ ar << x;
+}
+</pre></code>
+
+Suppose that the above message is not displayed and the code is used as is.
+<ol>
+ <li>this example compiles and executes fine. No tracking is done because
+ construct_from has never been serialized through a pointer. Now some time
+ later, the next programmer(2) comes along and makes an enhancement. He
+ wants the archive to be sort of a log.
+
+<code style="white-space: normal"><pre>
+void main(){
+ ...
+ Y y;
+ construct_from x(y);
+ ar << x;
+ ...
+ x.f(); // change x in some way
+ ...
+ ar << x
+}
+</pre></code>
+ <p>
+ Again no problem. He gets two different of copies in the archive, each one is different.
+ That is he gets exactly what he expects and is naturally delighted.
+ <p>
+ <li>Now sometime later, a third programmer(3) sees construct_from and says -
+ oh cool, just what I need. He writes a function in a totally disjoint
+ module. (The project is so big, he doesn't even realize the existence of
+ the original usage) and writes something like:
+
+<code style="white-space: normal"><pre>
+class K {
+ shared_ptr <construct_from> z;
+ template <class Archive>
+ void serialize(Archive & ar, const unsigned version){
+ ar << z;
+ }
+};
+</pre></code>
+
+ <p>
+ He builds and runs the program and tests his new functionality. It works
+ great and he's delighted.
+ <p>
+ <li>Things continue smoothly as before. A month goes by and it's
+ discovered that when loading the archives made in the last month (reading the
+ log). Things don't work. The second log entry is always the same as the
+ first. After a series of very long and increasingly acrimonius email exchanges,
+its discovered
+ that programmer (3) accidently broke programmer(2)'s code .This is because by
+ serializing via a pointer, the "log" object now being tracked. This is because
+ the default tracking behavior is "track_selectively". This means that class
+ instances are tracked only if they are serialized through pointers anywhere in
+ the program. Now multiple saves from the same address result in only the first one
+ being written to the archive. Subsequent saves only add the address - even though the
+ data might have been changed. When it comes time to load the data, all instances of the log record show the same data.
+ In this way, the behavior of a functioning piece of code is changed due the side
+ effect of a change in an otherwise disjoint module.
+ Worse yet, the data has been lost and cannot not be now recovered from the archives.
+ People are really upset and disappointed with boost (at least the serialization system).
+ <p>
+ <li>
+ After a lot of investigation, it's discovered what the source of the problem
+ and class construct_from is marked "track_never" by including:
+<code style="white-space: normal"><pre>
+BOOST_CLASS_TRACKING(construct_from, track_never)
+</pre></code>
+ <li>Now everything works again. Or - so it seems.
+ <p>
+ <li><code style="white-space: normal">shared_ptr<construct_from></code>
+is not going to have a single raw pointer shared amongst the instances. Each loaded
+<code style="white-space: normal">shared_ptr<construct_from></code> is going to
+have its own distinct raw pointer. This will break
+<code style="white-space: normal">shared_ptr</code> and cause a memory leak. Again,
+The cause of this problem is very far removed from the point of discovery. It could
+well be that the problem is not even discovered until after the archives are loaded.
+Now we not only have difficult to find and fix program bug, but we have a bunch of
+invalid archives and lost data.
+</ol>
+
+<p>Now consider what happens when the message is displayed:
+
+<ol>
+ <p>
+ <li>Right away, the program traps at
+<code style="white-space: normal"><pre>
+ar << x;
+</pre></code>
+ <p>
+ <li>The programmer curses (another %^&*&* hoop to jump through). If he's in a
+ hurry (and who isn't) and would prefer not to <code style="white-space: normal">const_cast</code>
+ - because it looks bad. So he'll just make the following change an move on.
+<code style="white-space: normal"><pre>
+Y y;
+const construct_from x(y);
+ar << x;
+</pre></code>
+ <p>
+ Things work fine and he moves on.
+ <p>
+ <li>Now programer (2) wants to make his change - and again another
+ annoying const issue;
+<code style="white-space: normal"><pre>
+Y y;
+const construct_from x(y);
+...
+x.f(); // change x in some way ; compile error f() is not const
+...
+ar << x
+</pre></code>
+ <p>
+ He's mildly annoyed now he tries the following:
+ <ul>
+ <li>He considers making f() a const - but presumable that shifts the const
+ error to somewhere else. And his doesn't want to fiddle with "his" code to
+ work around a quirk in the serializaition system
+ <p>
+ <li>He removes the <code style="white-space: normal">const</code>
+ from <code style="white-space: normal">const construct_from</code> above - damn now he
+ gets the trap. If he looks at the comment code where the
+ <code style="white-space: normal">BOOST_STATIC_ASSERT</code>
+ occurs, he'll do one of two things
+ <ol>
+ <p>
+ <li>This is just crazy. Its making my life needlessly difficult and flagging
+ code that is just fine. So I'll fix this with a <code style="white-space: normal">const_cast</code>
+ and fire off a complaint to the list and mabe they will fix it.
+ In this case, the story branches off to the previous scenario.
+ <p>
+ <li>Oh, this trap is suggesting that the default serialization isn't really
+ what I want. Of course in this particular program it doesn't matter. But
+ then the code in the trap can't really evaluate code in other modules (which
+ might not even be written yet). OK, I'll add the following to my
+ construct_from.hpp to solve the problem.
+<code style="white-space: normal"><pre>
+BOOST_CLASS_TRACKING(construct_from, track_never)
+</pre></code>
+ </ol>
+ </ul>
+ <p>
+ <li>Now programmer (3) comes along and make his change. The behavior of the
+ original (and distant module) remains unchanged because the
+ <code style="white-space: normal">construct_from</code> trait has been set to
+ "track_never" so he should always get copies and the log should be what we expect.
+ <p>
+ <li>But now he gets another trap - trying to save an object of a
+ class marked "track_never" through a pointer. So he goes back to
+ construct_from.hpp and comments out the
+ <code style="white-space: normal">BOOST_CLASS_TRACKING</code> that
+ was inserted. Now the second trap is avoided, But damn - the first trap is
+ popping up again. Eventually, after some code restructuring, the differing
+ requirements of serializating <code style="white-space: normal">construct_from</code>
+ are reconciled.
+</ol>
+Note that in this second scenario
+<ul>
+ <li>all errors are trapped at compile time.
+ <li>no invalid archives are created.
+ <li>no data is lost.
+ <li>no runtime errors occur.
+</ul>

-To indicate the possibility of bitwise serialization the type trait defined
-in the header
-file is_bitwise_serializable.hpp
-is used:
-<pre><code>
-namespace boost { namespace serialization {
- template<class T>
- struct is_bitwise_serializable
- : public is_arithmetic<T>
- {};
-} }
-</code></pre>
-is used, and can be specialized for other classes. The specialization
-is made easy by the corresponding macro:
-<pre><code>
-BOOST_IS_BITWISE_SERIALIZABLE(my_class)
-</code></pre>
+It's true that these messages may sometimes flag code that is currently correct and
+that this may be annoying to some programmers. However, this example illustrates
+my view that these messages are useful and that any such annoyance is small price to
+pay to avoid particularly vexing programming errors.
+
+</dd>
+
+<dt><h2><a name="pointer_level">pointer_level</a> - warning</h2></dt>
+<dd>
+This trap addresses the following situaion when serializing
+a pointer:
+<ul>
+<li>A type doesn't save class information in the
+archive. That is, the serialization trait implementation
+level <= object_serializable.
+<li>Tracking for this type is set to "track selectively"
+in this case, indication that an object is tracked is
+not stored in the archive itself - see level == object_serializable.
+Since class information is not saved in the archive, the existence
+or absense of the operation ar << T * anywhere else in the
+program is used to infer that an object of this type should be tracked.
+<p>
+A problem arises when a program which reads an archive
+includes the operation ar >> T * so that tracking information
+will be included in the archive. When a program which
+creates the archive doesn't include ar << T it is presumed
+that the archive doesn't include tracking information and
+the archive will fail to load. Also the reverse situation could
+trigger a similar problem.
+<p>
+Though this situation is unlikely for several reasones,
+it is possible - hence this warning.
+</ul>
+So if your program traps here, consider changing the
+tracking or implementation level traits - or not
+serializing via a pointer.
+</dd>
+
+<dt><h2><a name="pointer_tracking">pointer_tracking</a> - warning</h2></dt>
+<dd>
+Serializing an object of a type marked "track_never" through a pointer
+could result in creating more objects than were saved! There are cases
+in which a user might really want to do this so we leave it as a warning.
+</dd>
+
+<dt><h2><a name="const_loading">const_loading</a> - error</h2></dt>
+<dd>
+One cannot load data into a "const" object unless it's a
+wrapper around some other non-const object.
+</dd>
+</dl>

<hr>
<p><i>© Copyright Robert Ramey 2002-2004 and Matthias Troyer 2006.

Modified: branches/release/libs/serialization/module.cmake
==============================================================================
--- branches/release/libs/serialization/module.cmake (original)
+++ branches/release/libs/serialization/module.cmake 2009-09-19 22:18:02 EDT (Sat, 19 Sep 2009)
@@ -1,3 +1,3 @@
-boost_module(serialization DEPENDS spirit io bind array variant)
-
-# bind is in there because we have a dependency on boost/mem_fn.hpp
+boost_module(serialization DEPENDS spirit io bind array variant)
+
+# bind is in there because we have a dependency on boost/mem_fn.hpp

Modified: branches/release/libs/serialization/src/basic_archive.cpp
==============================================================================
--- branches/release/libs/serialization/src/basic_archive.cpp (original)
+++ branches/release/libs/serialization/src/basic_archive.cpp 2009-09-19 22:18:02 EDT (Sat, 19 Sep 2009)
@@ -57,10 +57,11 @@
// 5 - Boost 1.36
// changed serialization of collections: adding version even for primitive
// types caused backwards compatibility breaking change in 1.35
+// 6 - Boost 1.41, serializing collection sizes as std::size_t

BOOST_ARCHIVE_DECL(unsigned char)
BOOST_ARCHIVE_VERSION(){
- return 5;
+ return 6;
}

} // namespace archive

Modified: branches/release/libs/serialization/src/basic_iarchive.cpp
==============================================================================
--- branches/release/libs/serialization/src/basic_iarchive.cpp (original)
+++ branches/release/libs/serialization/src/basic_iarchive.cpp 2009-09-19 22:18:02 EDT (Sat, 19 Sep 2009)
@@ -28,11 +28,11 @@
#include <boost/serialization/throw_exception.hpp>
#include <boost/serialization/tracking.hpp>

-#include <boost/archive/archive_exception.hpp>
-
#define BOOST_ARCHIVE_SOURCE
#define BOOST_SERIALIZATION_SOURCE

+#include <boost/archive/archive_exception.hpp>
+
#include <boost/archive/detail/decl.hpp>
#include <boost/archive/basic_archive.hpp>
#include <boost/archive/detail/basic_iserializer.hpp>

Modified: branches/release/libs/serialization/src/basic_serializer_map.cpp
==============================================================================
--- branches/release/libs/serialization/src/basic_serializer_map.cpp (original)
+++ branches/release/libs/serialization/src/basic_serializer_map.cpp 2009-09-19 22:18:02 EDT (Sat, 19 Sep 2009)
@@ -12,7 +12,13 @@
# pragma warning (disable : 4786) // too long name, harmless warning
#endif

+#include <set>
+#include <utility>
+
#define BOOST_ARCHIVE_SOURCE
+#include <boost/archive/archive_exception.hpp>
+#include <boost/serialization/throw_exception.hpp>
+
#include <boost/archive/detail/basic_serializer.hpp>
#include <boost/archive/detail/basic_serializer_map.hpp>

@@ -23,52 +29,59 @@
namespace archive {
namespace detail {

-// note: We can't implement this as an associative
-// container as such a container might be dependent
-// upon the extended_type_info::m_key which might not
-// be assigned until later. So we use a "slower" method.
-// This not a big deal however as the slower "find" operations
-// operations are only called occasionally:
-// a) At module unloading
-// b) Once per input archive - the value is cached in the archive
-// implemenation.
+bool
+basic_serializer_map::type_info_pointer_compare::operator()(
+ const basic_serializer * lhs, const basic_serializer * rhs
+) const {
+ return *lhs < *rhs;
+}

-BOOST_ARCHIVE_DECL(void)
+BOOST_ARCHIVE_DECL(bool)
basic_serializer_map::insert(const basic_serializer * bs){
- m_map.push_back(bs);
+ // attempt to insert serializer into it's map
+ const std::pair<map_type::iterator, bool> result =
+ m_map.insert(bs);
+ // if this fails, it's because it's been instantiated
+ // in multiple modules - DLLS - a recipe for problems.
+ // So trap this here
+ if(!result.second){
+ boost::serialization::throw_exception(
+ archive_exception(
+ archive_exception::multiple_code_instantiation,
+ bs->get_debug_info()
+ )
+ );
+ }
+ return true;
}

BOOST_ARCHIVE_DECL(void)
basic_serializer_map::erase(const basic_serializer * bs){
     map_type::iterator it = m_map.begin();
     map_type::iterator it_end = m_map.end();
- it = std::find(it, it_end, bs);
- if(it != it_end){
- m_map.erase(it);
- }
- else
- assert(false); // this should never occur
-}

-class equals {
- const boost::serialization::extended_type_info * m_eti;
-public:
- bool operator()(const basic_serializer * bs) const {
- return *m_eti == bs->get_eti();
+ while(it != it_end){
+ // note item 9 from Effective STL !!! it++
+ if(*it == bs)
+ m_map.erase(it++);
+ else
+ it++;
     }
- equals(const boost::serialization::extended_type_info * eti) :
- m_eti(eti)
- {}
-};
-
-// find the "oldest" matching pointer serializer
+ // note: we can't do this since some of the eti records
+ // we're pointing to might be expired and the comparison
+ // won't work. Leave this as a reminder not to "optimize" this.
+ //it = m_map.find(bs);
+ //assert(it != m_map.end());
+ //if(*it == bs)
+ // m_map.erase(it);
+}
BOOST_ARCHIVE_DECL(const basic_serializer *)
basic_serializer_map::find(
     const boost::serialization::extended_type_info & eti
) const {
- map_type::const_iterator it = m_map.begin();
- map_type::const_iterator it_end = m_map.end();
- it = std::find_if(it, it_end, equals(& eti));
+ const basic_serializer_arg bs(eti);
+ map_type::const_iterator it;
+ it = m_map.find(& bs);
     assert(it != m_map.end());
     return *it;
}

Modified: branches/release/libs/serialization/src/extended_type_info.cpp
==============================================================================
--- branches/release/libs/serialization/src/extended_type_info.cpp (original)
+++ branches/release/libs/serialization/src/extended_type_info.cpp 2009-09-19 22:18:02 EDT (Sat, 19 Sep 2009)
@@ -75,40 +75,39 @@
         assert(false);
         return false;
     };
+ virtual const char * get_debug_info() const {
+ return get_key();
+ }
public:
     extended_type_info_arg(const char * key) :
- extended_type_info()
- {
- m_key = key;
- }
+ extended_type_info(0, key)
+ {}
+
     ~extended_type_info_arg(){
- m_key = NULL;
     }
};

} // namespace detail

BOOST_SERIALIZATION_DECL(void)
-extended_type_info::key_register(const char *key) {
- assert(NULL != key);
- m_key = key;
+extended_type_info::key_register() const{
+ if(NULL == get_key())
+ return;
     singleton<detail::ktmap>::get_mutable_instance().insert(this);
}

BOOST_SERIALIZATION_DECL(void)
-extended_type_info::key_unregister() {
- assert(NULL != m_key);
+extended_type_info::key_unregister() const{
+ if(NULL == get_key())
+ return;
     if(! singleton<detail::ktmap>::is_destroyed()){
         detail::ktmap & x = singleton<detail::ktmap>::get_mutable_instance();
         detail::ktmap::iterator start = x.lower_bound(this);
         detail::ktmap::iterator end = x.upper_bound(this);
- assert(start != end);
-
         // remove entry in map which corresponds to this type
         for(;start != end; ++start){
             if(this == *start){
                 x.erase(start);
- m_key = NULL;
                 break;
             }
         }
@@ -135,19 +134,17 @@

BOOST_SERIALIZATION_DECL(BOOST_PP_EMPTY())
extended_type_info::extended_type_info(
- const unsigned int type_info_key
+ const unsigned int type_info_key,
+ const char * key
) :
     m_this(this, null_deleter()),
     m_type_info_key(type_info_key),
- m_key(NULL)
+ m_key(key)
{
}

BOOST_SERIALIZATION_DECL(BOOST_PP_EMPTY())
extended_type_info::~extended_type_info(){
- if(NULL == m_key)
- return;
- key_unregister();
}

BOOST_SERIALIZATION_DECL(bool)

Modified: branches/release/libs/serialization/src/extended_type_info_no_rtti.cpp
==============================================================================
--- branches/release/libs/serialization/src/extended_type_info_no_rtti.cpp (original)
+++ branches/release/libs/serialization/src/extended_type_info_no_rtti.cpp 2009-09-19 22:18:02 EDT (Sat, 19 Sep 2009)
@@ -25,11 +25,13 @@

namespace boost {
namespace serialization {
-namespace detail {
+namespace no_rtti_system {

BOOST_SERIALIZATION_DECL(BOOST_PP_EMPTY())
-extended_type_info_no_rtti_0::extended_type_info_no_rtti_0() :
- extended_type_info(EXTENDED_TYPE_INFO_NO_RTTI_KEY)
+extended_type_info_no_rtti_0::extended_type_info_no_rtti_0(
+ const char * key
+) :
+ extended_type_info(EXTENDED_TYPE_INFO_NO_RTTI_KEY, key)
{}

BOOST_SERIALIZATION_DECL(bool)
@@ -39,7 +41,7 @@
     // shortcut for common case
     if(this == & rhs)
         return false;
- const char * l = m_key;
+ const char * l = get_key();
     const char * r = rhs.get_key();
     // if this assertion is triggered, it could mean one of the following
     // a) This class was never exported - make sure all calls which use
@@ -63,14 +65,14 @@
     if(this == & rhs)
         return true;
     // null keys don't match with anything
- const char * l = m_key;
- //assert(NULL != l);
+ const char * l = get_key();
+ assert(NULL != l);
     if(NULL == l)
         return false;
     const char * r = rhs.get_key();
+ assert(NULL != r);
     if(NULL == r)
         return false;
- assert(NULL != r);
     return 0 == std::strcmp(l, r);
}

Modified: branches/release/libs/serialization/src/extended_type_info_typeid.cpp
==============================================================================
--- branches/release/libs/serialization/src/extended_type_info_typeid.cpp (original)
+++ branches/release/libs/serialization/src/extended_type_info_typeid.cpp 2009-09-19 22:18:02 EDT (Sat, 19 Sep 2009)
@@ -24,7 +24,7 @@

namespace boost {
namespace serialization {
-namespace detail {
+namespace typeid_system {

#define EXTENDED_TYPE_INFO_TYPE_KEY 1

@@ -70,8 +70,10 @@
}

BOOST_SERIALIZATION_DECL(BOOST_PP_EMPTY())
-extended_type_info_typeid_0::extended_type_info_typeid_0() :
- extended_type_info(EXTENDED_TYPE_INFO_TYPE_KEY),
+extended_type_info_typeid_0::extended_type_info_typeid_0(
+ const char * key
+) :
+ extended_type_info(EXTENDED_TYPE_INFO_TYPE_KEY, key),
     m_ti(NULL)
{}

@@ -112,7 +114,9 @@
     public extended_type_info_typeid_0
{
public:
- extended_type_info_typeid_arg(const std::type_info & ti){
+ extended_type_info_typeid_arg(const std::type_info & ti) :
+ extended_type_info_typeid_0(NULL)
+ {
         // note absense of self register and key as this is used only as
         // search argument given a type_info reference and is not to
         // be added to the map.
@@ -127,7 +131,7 @@
extended_type_info_typeid_0::get_extended_type_info(
     const std::type_info & ti
) const {
- detail::extended_type_info_typeid_arg etia(ti);
+ typeid_system::extended_type_info_typeid_arg etia(ti);
     const tkmap & t = singleton<tkmap>::get_const_instance();
     const tkmap::const_iterator it = t.find(& etia);
     if(t.end() == it)

Modified: branches/release/libs/serialization/src/polymorphic_oarchive.cpp
==============================================================================
--- branches/release/libs/serialization/src/polymorphic_oarchive.cpp (original)
+++ branches/release/libs/serialization/src/polymorphic_oarchive.cpp 2009-09-19 22:18:02 EDT (Sat, 19 Sep 2009)
@@ -14,8 +14,6 @@

#define BOOST_ARCHIVE_SOURCE
#include <boost/archive/detail/archive_serializer_map.hpp>
-#define BOOST_ARCHIVE_SOURCE
-#include <boost/archive/detail/archive_serializer_map.hpp>

#include <boost/archive/impl/archive_serializer_map.ipp>
#include <boost/archive/polymorphic_oarchive.hpp>

Modified: branches/release/libs/serialization/src/void_cast.cpp
==============================================================================
--- branches/release/libs/serialization/src/void_cast.cpp (original)
+++ branches/release/libs/serialization/src/void_cast.cpp 2009-09-19 22:18:02 EDT (Sat, 19 Sep 2009)
@@ -15,6 +15,9 @@

#include <cassert>
#include <cstddef> // NULL
+#ifdef BOOST_SERIALIZATION_LOG
+#include <iostream>
+#endif

// STL
#include <set>
@@ -190,6 +193,14 @@
     void_cast_detail::set_type & s
         = void_cast_detail::void_caster_registry::get_mutable_instance();

+ #ifdef BOOST_SERIALIZATION_LOG
+ std::clog << "recursive_register\n";
+ std::clog << m_derived->get_debug_info();
+ std::clog << "<-";
+ std::clog << m_base->get_debug_info();
+ std::clog << "\n";
+ #endif
+
     s.insert(this);

     // generate all implied void_casts.

Modified: branches/release/libs/serialization/test/Jamfile.v2
==============================================================================
--- branches/release/libs/serialization/test/Jamfile.v2 (original)
+++ branches/release/libs/serialization/test/Jamfile.v2 2009-09-19 22:18:02 EDT (Sat, 19 Sep 2009)
@@ -83,9 +83,7 @@
      [ test-bsl-run_files test_mi ]
      [ test-bsl-run_files test_multiple_ptrs : A ]
      [ test-bsl-run_files test_multiple_inheritance ]
- [ test-bsl-run_files test_no_rtti
- : polymorphic_base polymorphic_derived1
- ]
+ [ test-bsl-run_files test_no_rtti : polymorphic_base polymorphic_derived1 ]
      [ test-bsl-run_files test_non_intrusive ]
      [ test-bsl-run_files test_non_default_ctor ]
      [ test-bsl-run_files test_non_default_ctor2 ]
@@ -144,6 +142,7 @@
         [ compile-fail test_const_load_fail1_nvp.cpp ]
         [ compile-fail test_const_load_fail2_nvp.cpp ]
         [ compile-fail test_const_load_fail3_nvp.cpp ]
+ [ compile-fail test_check.cpp ]

         # should compile with a warning message
         [ compile test_static_warning.cpp ]

Modified: branches/release/libs/serialization/test/polymorphic_base.cpp
==============================================================================
--- branches/release/libs/serialization/test/polymorphic_base.cpp (original)
+++ branches/release/libs/serialization/test/polymorphic_base.cpp 2009-09-19 22:18:02 EDT (Sat, 19 Sep 2009)
@@ -11,7 +11,7 @@
#include <boost/serialization/export.hpp>
#include "polymorphic_base.hpp"

-BOOST_CLASS_EXPORT(polymorphic_base)
+BOOST_CLASS_EXPORT_IMPLEMENT(polymorphic_base)

const char * polymorphic_base::get_key() const{
return

Modified: branches/release/libs/serialization/test/polymorphic_base.hpp
==============================================================================
--- branches/release/libs/serialization/test/polymorphic_base.hpp (original)
+++ branches/release/libs/serialization/test/polymorphic_base.hpp 2009-09-19 22:18:02 EDT (Sat, 19 Sep 2009)
@@ -17,6 +17,8 @@
// See http://www.boost.org for updates, documentation, and revision history.

#include <boost/serialization/access.hpp>
+#include <boost/serialization/assume_abstract.hpp>
+#include <boost/serialization/export.hpp>
#include <boost/serialization/type_info_implementation.hpp>
#include <boost/serialization/extended_type_info_no_rtti.hpp>

@@ -38,6 +40,9 @@

BOOST_SERIALIZATION_ASSUME_ABSTRACT(polymorphic_base)

+// the no_rtti system requires this !!!
+BOOST_CLASS_EXPORT_KEY(polymorphic_base)
+
BOOST_CLASS_TYPE_INFO(
polymorphic_base,
boost::serialization::extended_type_info_no_rtti<polymorphic_base>

Modified: branches/release/libs/serialization/test/polymorphic_derived1.cpp
==============================================================================
--- branches/release/libs/serialization/test/polymorphic_derived1.cpp (original)
+++ branches/release/libs/serialization/test/polymorphic_derived1.cpp 2009-09-19 22:18:02 EDT (Sat, 19 Sep 2009)
@@ -9,16 +9,15 @@
// See http://www.boost.org for updates, documentation, and revision history.

#include <boost/serialization/type_info_implementation.hpp>
-#include <boost/serialization/extended_type_info_no_rtti.hpp>
#include <boost/serialization/export.hpp>

#include "polymorphic_derived1.hpp"

const char * polymorphic_derived1::get_key() const {
- return
+ return
boost::serialization::type_info_implementation<
polymorphic_derived1
>::type::get_const_instance().get_key();
}

-BOOST_CLASS_EXPORT(polymorphic_derived1)
+BOOST_CLASS_EXPORT_IMPLEMENT(polymorphic_derived1)

Modified: branches/release/libs/serialization/test/polymorphic_derived1.hpp
==============================================================================
--- branches/release/libs/serialization/test/polymorphic_derived1.hpp (original)
+++ branches/release/libs/serialization/test/polymorphic_derived1.hpp 2009-09-19 22:18:02 EDT (Sat, 19 Sep 2009)
@@ -23,6 +23,7 @@
#include <boost/serialization/extended_type_info_no_rtti.hpp>

#include "polymorphic_base.hpp"
+
class polymorphic_derived1 : public polymorphic_base
{
     friend class boost::serialization::access;
@@ -34,6 +35,8 @@
     virtual const char * get_key() const ;
};

+BOOST_CLASS_EXPORT_KEY(polymorphic_derived1)
+
BOOST_CLASS_TYPE_INFO(
     polymorphic_derived1,
     extended_type_info_no_rtti<polymorphic_derived1>

Modified: branches/release/libs/serialization/test/polymorphic_derived2.cpp
==============================================================================
--- branches/release/libs/serialization/test/polymorphic_derived2.cpp (original)
+++ branches/release/libs/serialization/test/polymorphic_derived2.cpp 2009-09-19 22:18:02 EDT (Sat, 19 Sep 2009)
@@ -45,7 +45,7 @@
BOOST_SERIALIZATION_MWERKS_BASE_AND_DERIVED(polymorphic_base, polymorphic_derived2)

// note: export has to be AFTER #includes for all archive classes
-BOOST_CLASS_EXPORT(polymorphic_derived2)
+BOOST_CLASS_EXPORT_IMPLEMENT(polymorphic_derived2)

// export plug-in not yet working !!!
#if 0

Modified: branches/release/libs/serialization/test/polymorphic_derived2.hpp
==============================================================================
--- branches/release/libs/serialization/test/polymorphic_derived2.hpp (original)
+++ branches/release/libs/serialization/test/polymorphic_derived2.hpp 2009-09-19 22:18:02 EDT (Sat, 19 Sep 2009)
@@ -1,5 +1,5 @@
-#ifndef DERIVED2_HPP
-#define DERIVED2_HPP
+#ifndef POLYMORPHIC_DERIVED2_HPP
+#define POLYMORPHIC_DERIVED2_HPP

// MS compatible compilers support #pragma once
#if defined(_MSC_VER) && (_MSC_VER >= 1020)
@@ -51,6 +51,13 @@
}
};

+// we use this because we want to assign a key to this type
+// but we don't want to explicitly instantiate code every time
+// we do so!!!. If we don't do this, we end up with the same
+// code in BOTH the DLL which implements polymorphic_derived2
+// as well as the main program.
+BOOST_CLASS_EXPORT_KEY(polymorphic_derived2)
+
// note the mixing of type_info systems is supported.
BOOST_CLASS_TYPE_INFO(
polymorphic_derived2,
@@ -59,5 +66,5 @@

#undef DLL_DECL

-#endif // DERIVED2_HPP
+#endif // POLYMORPHIC_DERIVED2_HPP

Modified: branches/release/libs/serialization/test/test_binary.cpp
==============================================================================
--- branches/release/libs/serialization/test/test_binary.cpp (original)
+++ branches/release/libs/serialization/test/test_binary.cpp 2009-09-19 22:18:02 EDT (Sat, 19 Sep 2009)
@@ -76,20 +76,36 @@
     char s1_3[10];
     char s1_4[10];
     int i1 = 34790;
- {
+ {
         test_ostream os(testfile, TEST_STREAM_FLAGS);
         test_oarchive oa(os, TEST_ARCHIVE_FLAGS);
         boost::serialization::make_nvp(
- "s1", boost::serialization::make_binary_object(s1, sizeof(s1))
+ "s1",
+ boost::serialization::make_binary_object(
+ s1,
+ sizeof(s1)
+ )
         );
         oa << boost::serialization::make_nvp(
- "s2", boost::serialization::make_binary_object(s2, sizeof(s2))
+ "s2",
+ boost::serialization::make_binary_object(
+ s2,
+ sizeof(s2)
+ )
         );
         oa << boost::serialization::make_nvp(
- "s3", boost::serialization::make_binary_object(s3, sizeof(s3))
+ "s3",
+ boost::serialization::make_binary_object(
+ s3,
+ sizeof(s3)
+ )
         );
         oa << boost::serialization::make_nvp(
- "s4", boost::serialization::make_binary_object(s4, sizeof(s4))
+ "s4",
+ boost::serialization::make_binary_object(
+ s4,
+ sizeof(s4)
+ )
         );
         oa << BOOST_SERIALIZATION_NVP(a);
         // note: add a little bit on the end of the archive to detect
@@ -100,16 +116,32 @@
         test_istream is(testfile, TEST_STREAM_FLAGS);
         test_iarchive ia(is, TEST_ARCHIVE_FLAGS);
         boost::serialization::make_nvp(
- "s1", boost::serialization::make_binary_object(s1_1, sizeof(s1))
+ "s1",
+ boost::serialization::make_binary_object(
+ s1_1,
+ sizeof(s1)
+ )
         );
         ia >> boost::serialization::make_nvp(
- "s2", boost::serialization::make_binary_object(s1_2, sizeof(s2))
+ "s2",
+ boost::serialization::make_binary_object(
+ s1_2,
+ sizeof(s2)
+ )
         );
         ia >> boost::serialization::make_nvp(
- "s3", boost::serialization::make_binary_object(s1_3, sizeof(s3))
+ "s3",
+ boost::serialization::make_binary_object(
+ s1_3,
+ sizeof(s3)
+ )
         );
         ia >> boost::serialization::make_nvp(
- "s4", boost::serialization::make_binary_object(s1_4, sizeof(s4))
+ "s4",
+ boost::serialization::make_binary_object(
+ s1_4,
+ sizeof(s4)
+ )
         );
         ia >> BOOST_SERIALIZATION_NVP(a1);
         // note: add a little bit on the end of the archive to detect

Modified: branches/release/libs/serialization/test/test_class_info_save.cpp
==============================================================================
--- branches/release/libs/serialization/test/test_class_info_save.cpp (original)
+++ branches/release/libs/serialization/test/test_class_info_save.cpp 2009-09-19 22:18:02 EDT (Sat, 19 Sep 2009)
@@ -42,6 +42,7 @@
BOOST_CLASS_TRACKING(A, ::boost::serialization::track_never)

// second case : serialize WITH class information
+// note: GCC compile fails if this is after the class declaration
class B;
BOOST_CLASS_VERSION(B, 2)

@@ -79,7 +80,6 @@
std::cout << "b.count=" << b.count << '\n' ;
}

-
int
test_main( int /* argc */, char* /* argv */[] )
{

Modified: branches/release/libs/serialization/test/test_complex.cpp
==============================================================================
--- branches/release/libs/serialization/test/test_complex.cpp (original)
+++ branches/release/libs/serialization/test/test_complex.cpp 2009-09-19 22:18:02 EDT (Sat, 19 Sep 2009)
@@ -19,7 +19,9 @@
#if defined(BOOST_NO_STDC_NAMESPACE)
namespace std{
using ::remove;
+#ifndef UNDER_CE
using ::numeric_limits;
+#endif
}
#endif

Modified: branches/release/libs/serialization/test/test_derived.cpp
==============================================================================
--- branches/release/libs/serialization/test/test_derived.cpp (original)
+++ branches/release/libs/serialization/test/test_derived.cpp 2009-09-19 22:18:02 EDT (Sat, 19 Sep 2009)
@@ -31,6 +31,8 @@
     template<class Archive>
     void serialize(Archive & /* ar */, const unsigned int /* file_version */){
     }
+protected:
+ virtual ~base(){};
};

class derived1 : public base
@@ -105,6 +107,10 @@
     base *b1 = NULL;
     base *b2 = NULL;

+ // note: this will produce incorrect results for non-polymorphic classes
+ ia >> BOOST_SERIALIZATION_NVP(b1);
+ ia >> BOOST_SERIALIZATION_NVP(b2);
+
     // Warning, the current type id system does not yield true
     // type id for non-polymorphic types
     const boost::serialization::extended_type_info & this_type
@@ -120,9 +126,8 @@
         "current type id system does fails for non-polymorphic types"
     );

- // note: this will produce incorrect results for non-polymorphic classes
- ia >> BOOST_SERIALIZATION_NVP(b1);
- ia >> BOOST_SERIALIZATION_NVP(b2);
+ BOOST_CHECK(b1 == static_cast<base *>(d1));
+ BOOST_CHECK(b2 == static_cast<base *>(d2));

     delete d1;
     delete d2;

Modified: branches/release/libs/serialization/test/test_dll_exported.cpp
==============================================================================
--- branches/release/libs/serialization/test/test_dll_exported.cpp (original)
+++ branches/release/libs/serialization/test/test_dll_exported.cpp 2009-09-19 22:18:02 EDT (Sat, 19 Sep 2009)
@@ -43,7 +43,6 @@

#include <boost/serialization/base_object.hpp>
#include <boost/serialization/export.hpp>
-#include <boost/serialization/type_info_implementation.hpp>
#include <boost/serialization/access.hpp>

#include "polymorphic_base.hpp"
@@ -62,11 +61,11 @@
virtual ~polymorphic_derived1(){}
};

+BOOST_CLASS_EXPORT(polymorphic_derived1)
+
// MWerks users can do this to make their code work
BOOST_SERIALIZATION_MWERKS_BASE_AND_DERIVED(polymorphic_base, polymorphic_derived1)

-BOOST_CLASS_EXPORT(polymorphic_derived1)
-
#define POLYMORPHIC_DERIVED2_IMPORT
#include "polymorphic_derived2.hpp"

Modified: branches/release/libs/serialization/test/test_exported.cpp
==============================================================================
--- branches/release/libs/serialization/test/test_exported.cpp (original)
+++ branches/release/libs/serialization/test/test_exported.cpp 2009-09-19 22:18:02 EDT (Sat, 19 Sep 2009)
@@ -24,12 +24,15 @@
#include <boost/serialization/type_info_implementation.hpp>
#include <boost/serialization/extended_type_info_typeid.hpp>

+#include <boost/serialization/force_include.hpp>
+
#include <boost/archive/archive_exception.hpp>
#include "test_tools.hpp"

#include "polymorphic_base.hpp"

-class polymorphic_derived1 : public polymorphic_base
+class polymorphic_derived1 :
+ public polymorphic_base
{
friend class boost::serialization::access;
template<class Archive>
@@ -50,7 +53,7 @@

#include "polymorphic_derived2.hpp"

-BOOST_CLASS_EXPORT(polymorphic_derived2)
+BOOST_CLASS_EXPORT_IMPLEMENT(polymorphic_derived2)

// MWerks users can do this to make their code work
BOOST_SERIALIZATION_MWERKS_BASE_AND_DERIVED(polymorphic_base, polymorphic_derived2)

Modified: branches/release/libs/serialization/test/test_no_rtti.cpp
==============================================================================
--- branches/release/libs/serialization/test/test_no_rtti.cpp (original)
+++ branches/release/libs/serialization/test/test_no_rtti.cpp 2009-09-19 22:18:02 EDT (Sat, 19 Sep 2009)
@@ -30,20 +30,19 @@
#include <boost/type_traits/is_same.hpp>

#include <boost/archive/archive_exception.hpp>
-#include "test_tools.hpp"
-#include <boost/preprocessor/stringize.hpp>
-#include BOOST_PP_STRINGIZE(BOOST_ARCHIVE_TEST)

#include <boost/serialization/type_info_implementation.hpp>
#include <boost/serialization/extended_type_info_no_rtti.hpp>
#include <boost/serialization/export.hpp>
#include <boost/serialization/nvp.hpp>

+#include "test_tools.hpp"
+#include <boost/preprocessor/stringize.hpp>
+#include BOOST_PP_STRINGIZE(BOOST_ARCHIVE_TEST)
+
#include "polymorphic_base.hpp"
#include "polymorphic_derived1.hpp"
-
#include "polymorphic_derived2.hpp"
-BOOST_CLASS_EXPORT(polymorphic_derived2)

template void polymorphic_derived2::serialize(
     test_oarchive & ar,
@@ -65,24 +64,21 @@

     std::cout << "saving polymorphic_derived1 (no_rtti)\n";
     oa << BOOST_SERIALIZATION_NVP(rd1);
+
     std::cout << "saving polymorphic_derived2\n";
     oa << BOOST_SERIALIZATION_NVP(rd2);

- // the above opereration registers the derived classes as a side
- // effect. Hence, instances can now be correctly serialized through
- // a base class pointer.
- polymorphic_base *rb1 = rd1;
+ const polymorphic_base *rb1 = rd1;
     polymorphic_base *rb2 = rd2;
     std::cout << "saving polymorphic_derived1 (no_rtti) through base (no_rtti)\n";
     oa << BOOST_SERIALIZATION_NVP(rb1);
- std::cout << "saving polymorphic_derived2 through base (no_rtti)\n";
+ std::cout << "saving polymorphic_derived2 through base\n";
     oa << BOOST_SERIALIZATION_NVP(rb2);

     delete rd1;
     delete rd2;
}

-// save derived polymorphic class
void load_derived(const char *testfile)
{
     test_istream is(testfile, TEST_STREAM_FLAGS);
@@ -93,7 +89,6 @@

     std::cout << "loading polymorphic_derived1 (no_rtti)\n";
     ia >> BOOST_SERIALIZATION_NVP(rd1);
-
     BOOST_CHECK_MESSAGE(
         boost::serialization::type_info_implementation<
             polymorphic_derived1
@@ -144,7 +139,6 @@
         ,
         "restored pointer b1 not of correct type"
     );
-
     std::cout << "loading polymorphic_derived2 through base (no_rtti)\n";
     ia >> BOOST_SERIALIZATION_NVP(rb2);

@@ -152,7 +146,6 @@
         rb2 == dynamic_cast<polymorphic_base *>(rd2),
         "serialized pointers not correctly restored"
     );
-
     BOOST_CHECK_MESSAGE(
         boost::serialization::type_info_implementation<
             polymorphic_derived2
@@ -164,7 +157,6 @@
         ,
         "restored pointer b2 not of correct type"
     );
-
     delete rb1;
     delete rb2;
}

Modified: branches/release/libs/serialization/test/test_non_default_ctor.cpp
==============================================================================
--- branches/release/libs/serialization/test/test_non_default_ctor.cpp (original)
+++ branches/release/libs/serialization/test/test_non_default_ctor.cpp 2009-09-19 22:18:02 EDT (Sat, 19 Sep 2009)
@@ -25,7 +25,9 @@
     using ::rand;
     using ::fabs;
     using ::remove;
+#ifndef UNDER_CE
     using ::numeric_limits;
+#endif
}
#endif

Modified: branches/release/libs/serialization/test/test_non_intrusive.cpp
==============================================================================
--- branches/release/libs/serialization/test/test_non_intrusive.cpp (original)
+++ branches/release/libs/serialization/test/test_non_intrusive.cpp 2009-09-19 22:18:02 EDT (Sat, 19 Sep 2009)
@@ -24,7 +24,9 @@
     using ::rand;
     using ::fabs;
     using ::remove;
+#ifndef UNDER_CE
     using ::numeric_limits;
+#endif
}
#endif

Modified: branches/release/libs/serialization/test/test_shared_ptr.cpp
==============================================================================
--- branches/release/libs/serialization/test/test_shared_ptr.cpp (original)
+++ branches/release/libs/serialization/test/test_shared_ptr.cpp 2009-09-19 22:18:02 EDT (Sat, 19 Sep 2009)
@@ -23,11 +23,10 @@
#include <boost/serialization/shared_ptr.hpp>
#include <boost/serialization/weak_ptr.hpp>
#include <boost/serialization/nvp.hpp>
+#include <boost/serialization/export.hpp>

#include "test_tools.hpp"

-#include <boost/serialization/export.hpp>
-
// This is a simple class. It contains a counter of the number
// of objects of this class which have been instantiated.
class A

Modified: branches/release/libs/serialization/test/test_simple_class_ptr.cpp
==============================================================================
--- branches/release/libs/serialization/test/test_simple_class_ptr.cpp (original)
+++ branches/release/libs/serialization/test/test_simple_class_ptr.cpp 2009-09-19 22:18:02 EDT (Sat, 19 Sep 2009)
@@ -30,7 +30,7 @@

     BOOST_REQUIRE(NULL != testfile);

- A *ta = new A();
+ const A *ta = new A();
     A *ta1 = NULL;

     {

Modified: branches/release/libs/serialization/test/test_static_warning.cpp
==============================================================================
--- branches/release/libs/serialization/test/test_static_warning.cpp (original)
+++ branches/release/libs/serialization/test/test_static_warning.cpp 2009-09-19 22:18:02 EDT (Sat, 19 Sep 2009)
@@ -8,10 +8,10 @@
// note: this is a compile only test.

#include <boost/config.hpp> // BOOST_STATIC_CONST
-#include <boost/serialization/static_warning.hpp>
+#include <boost/static_assert.hpp>
#include <boost/type_traits/is_polymorphic.hpp>

-#pragma warning(disable:4094)
+#include <boost/serialization/static_warning.hpp>

typedef char a1[2];
typedef char a2[3];
@@ -23,18 +23,14 @@
class non_polymorphic {
};

-class test_class {
-};
-
-template <class T>
-int f()
-{
+template<class T>
+int f(){
     BOOST_STATIC_WARNING(T::value);
     return 0;
-}
+}

struct A {
- BOOST_STATIC_CONSTANT(bool, value = 0);
+ BOOST_STATIC_CONSTANT(bool, value = false);
};

/////////////////////////////////////////////////////////////////////////
@@ -44,7 +40,10 @@
BOOST_STATIC_WARNING(true);

// the following should show 5 warning message
-int x = f<A>();
+int x = f<A>(); // Warn
+int y = f<boost::is_polymorphic<non_polymorphic> >(); // Warn.
+int z = f<boost::is_polymorphic<polymorphic> >();
+
BOOST_STATIC_WARNING(sizeof(a1) == sizeof(a2)); // Warn.
BOOST_STATIC_WARNING(sizeof(a1) != sizeof(a1)); // Warn.
BOOST_STATIC_WARNING(! boost::is_polymorphic<polymorphic>::value); // Warn.
@@ -62,4 +61,3 @@
     BOOST_STATIC_WARNING(boost::is_polymorphic<non_polymorphic>::value); // Warn.
     return 0;
}
-

Modified: branches/release/libs/serialization/test/test_tracking.cpp
==============================================================================
--- branches/release/libs/serialization/test/test_tracking.cpp (original)
+++ branches/release/libs/serialization/test/test_tracking.cpp 2009-09-19 22:18:02 EDT (Sat, 19 Sep 2009)
@@ -128,4 +128,3 @@
return EXIT_SUCCESS;
}

-// EOF

Modified: branches/release/libs/serialization/test/test_utf8_codecvt.cpp
==============================================================================
--- branches/release/libs/serialization/test/test_utf8_codecvt.cpp (original)
+++ branches/release/libs/serialization/test/test_utf8_codecvt.cpp 2009-09-19 22:18:02 EDT (Sat, 19 Sep 2009)
@@ -22,7 +22,9 @@
namespace std{
     using ::size_t;
     using ::wcslen;
+#ifndef UNDER_CE
     using ::w_int;
+#endif
} // namespace std
#endif

Modified: branches/release/libs/serialization/vc7ide/BoostSerializationLibrary.sln
==============================================================================
--- branches/release/libs/serialization/vc7ide/BoostSerializationLibrary.sln (original)
+++ branches/release/libs/serialization/vc7ide/BoostSerializationLibrary.sln 2009-09-19 22:18:02 EDT (Sat, 19 Sep 2009)
@@ -344,6 +344,10 @@
         ProjectSection(ProjectDependencies) = postProject
         EndProjectSection
EndProject
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "test_check", "test_check.vcproj", "{A7D4CC95-F2AC-11D6-9E47-525400E2CF85}"
+ ProjectSection(ProjectDependencies) = postProject
+ EndProjectSection
+EndProject
Global
         GlobalSection(SolutionConfiguration) = preSolution
                 Debug = Debug
@@ -6004,8 +6008,8 @@
                 {CED1BD64-563F-485D-AE69-668797013AA0}.Debug runtime-dynamic xml_archive.Build.0 = Debug|Win32
                 {CED1BD64-563F-485D-AE69-668797013AA0}.Debug runtime-dynamic xml_warchive.ActiveCfg = Debug|Win32
                 {CED1BD64-563F-485D-AE69-668797013AA0}.Debug runtime-dynamic xml_warchive.Build.0 = Debug|Win32
- {CED1BD64-563F-485D-AE69-668797013AA0}.Debug runtime-static.ActiveCfg = Debug|Win32
- {CED1BD64-563F-485D-AE69-668797013AA0}.Debug runtime-static.Build.0 = Debug|Win32
+ {CED1BD64-563F-485D-AE69-668797013AA0}.Debug runtime-static.ActiveCfg = Debug runtime-static|Win32
+ {CED1BD64-563F-485D-AE69-668797013AA0}.Debug runtime-static.Build.0 = Debug runtime-static|Win32
                 {CED1BD64-563F-485D-AE69-668797013AA0}.Debug runtime-static binary_archive.ActiveCfg = Debug|Win32
                 {CED1BD64-563F-485D-AE69-668797013AA0}.Debug runtime-static binary_archive.Build.0 = Debug|Win32
                 {CED1BD64-563F-485D-AE69-668797013AA0}.Debug runtime-static text_archive.ActiveCfg = Debug|Win32
@@ -6964,8 +6968,8 @@
                 {CED1BD64-563F-485D-AE69-668797013AA0}.Debug runtime-dynamic xml_archive.Build.0 = Debug|Win32
                 {CED1BD64-563F-485D-AE69-668797013AA0}.Debug runtime-dynamic xml_warchive.ActiveCfg = Debug|Win32
                 {CED1BD64-563F-485D-AE69-668797013AA0}.Debug runtime-dynamic xml_warchive.Build.0 = Debug|Win32
- {CED1BD64-563F-485D-AE69-668797013AA0}.Debug runtime-static.ActiveCfg = Debug|Win32
- {CED1BD64-563F-485D-AE69-668797013AA0}.Debug runtime-static.Build.0 = Debug|Win32
+ {CED1BD64-563F-485D-AE69-668797013AA0}.Debug runtime-static.ActiveCfg = Debug runtime-static|Win32
+ {CED1BD64-563F-485D-AE69-668797013AA0}.Debug runtime-static.Build.0 = Debug runtime-static|Win32
                 {CED1BD64-563F-485D-AE69-668797013AA0}.Debug runtime-static binary_archive.ActiveCfg = Debug|Win32
                 {CED1BD64-563F-485D-AE69-668797013AA0}.Debug runtime-static binary_archive.Build.0 = Debug|Win32
                 {CED1BD64-563F-485D-AE69-668797013AA0}.Debug runtime-static text_archive.ActiveCfg = Debug|Win32
@@ -7044,8 +7048,8 @@
                 {CED1BD64-563F-485D-AE69-668797013AA0}.Debug runtime-dynamic xml_archive.Build.0 = Debug|Win32
                 {CED1BD64-563F-485D-AE69-668797013AA0}.Debug runtime-dynamic xml_warchive.ActiveCfg = Debug|Win32
                 {CED1BD64-563F-485D-AE69-668797013AA0}.Debug runtime-dynamic xml_warchive.Build.0 = Debug|Win32
- {CED1BD64-563F-485D-AE69-668797013AA0}.Debug runtime-static.ActiveCfg = Debug|Win32
- {CED1BD64-563F-485D-AE69-668797013AA0}.Debug runtime-static.Build.0 = Debug|Win32
+ {CED1BD64-563F-485D-AE69-668797013AA0}.Debug runtime-static.ActiveCfg = Debug runtime-static|Win32
+ {CED1BD64-563F-485D-AE69-668797013AA0}.Debug runtime-static.Build.0 = Debug runtime-static|Win32
                 {CED1BD64-563F-485D-AE69-668797013AA0}.Debug runtime-static binary_archive.ActiveCfg = Debug|Win32
                 {CED1BD64-563F-485D-AE69-668797013AA0}.Debug runtime-static binary_archive.Build.0 = Debug|Win32
                 {CED1BD64-563F-485D-AE69-668797013AA0}.Debug runtime-static text_archive.ActiveCfg = Debug|Win32
@@ -7124,8 +7128,8 @@
                 {CED1BD64-563F-485D-AE69-668797013AA0}.Debug runtime-dynamic xml_archive.Build.0 = Debug|Win32
                 {CED1BD64-563F-485D-AE69-668797013AA0}.Debug runtime-dynamic xml_warchive.ActiveCfg = Debug|Win32
                 {CED1BD64-563F-485D-AE69-668797013AA0}.Debug runtime-dynamic xml_warchive.Build.0 = Debug|Win32
- {CED1BD64-563F-485D-AE69-668797013AA0}.Debug runtime-static.ActiveCfg = Debug|Win32
- {CED1BD64-563F-485D-AE69-668797013AA0}.Debug runtime-static.Build.0 = Debug|Win32
+ {CED1BD64-563F-485D-AE69-668797013AA0}.Debug runtime-static.ActiveCfg = Debug runtime-static|Win32
+ {CED1BD64-563F-485D-AE69-668797013AA0}.Debug runtime-static.Build.0 = Debug runtime-static|Win32
                 {CED1BD64-563F-485D-AE69-668797013AA0}.Debug runtime-static binary_archive.ActiveCfg = Debug|Win32
                 {CED1BD64-563F-485D-AE69-668797013AA0}.Debug runtime-static binary_archive.Build.0 = Debug|Win32
                 {CED1BD64-563F-485D-AE69-668797013AA0}.Debug runtime-static text_archive.ActiveCfg = Debug|Win32
@@ -7188,6 +7192,86 @@
                 {CED1BD64-563F-485D-AE69-668797013AA0}.Release runtime-static xml_archive.Build.0 = Release|Win32
                 {CED1BD64-563F-485D-AE69-668797013AA0}.Release runtime-static xml_warchive.ActiveCfg = Release|Win32
                 {CED1BD64-563F-485D-AE69-668797013AA0}.Release runtime-static xml_warchive.Build.0 = Release|Win32
+ {A7D4CC95-F2AC-11D6-9E47-525400E2CF85}.Debug.ActiveCfg = Debug runtime-static threading-multi|Win32
+ {A7D4CC95-F2AC-11D6-9E47-525400E2CF85}.Debug.Build.0 = Debug runtime-static threading-multi|Win32
+ {A7D4CC95-F2AC-11D6-9E47-525400E2CF85}.Debug runtime-dynamic.ActiveCfg = Debug runtime-dynamic|Win32
+ {A7D4CC95-F2AC-11D6-9E47-525400E2CF85}.Debug runtime-dynamic.Build.0 = Debug runtime-dynamic|Win32
+ {A7D4CC95-F2AC-11D6-9E47-525400E2CF85}.Debug runtime-dynamic binary_archive.ActiveCfg = Debug runtime-dynamic|Win32
+ {A7D4CC95-F2AC-11D6-9E47-525400E2CF85}.Debug runtime-dynamic binary_archive.Build.0 = Debug runtime-dynamic|Win32
+ {A7D4CC95-F2AC-11D6-9E47-525400E2CF85}.Debug runtime-dynamic text_archive.ActiveCfg = Debug runtime-dynamic|Win32
+ {A7D4CC95-F2AC-11D6-9E47-525400E2CF85}.Debug runtime-dynamic text_archive.Build.0 = Debug runtime-dynamic|Win32
+ {A7D4CC95-F2AC-11D6-9E47-525400E2CF85}.Debug runtime-dynamic text_warchive.ActiveCfg = Debug runtime-dynamic|Win32
+ {A7D4CC95-F2AC-11D6-9E47-525400E2CF85}.Debug runtime-dynamic text_warchive.Build.0 = Debug runtime-dynamic|Win32
+ {A7D4CC95-F2AC-11D6-9E47-525400E2CF85}.Debug runtime-dynamic threading-multi.ActiveCfg = Debug runtime-dynamic threading-multi|Win32
+ {A7D4CC95-F2AC-11D6-9E47-525400E2CF85}.Debug runtime-dynamic threading-multi.Build.0 = Debug runtime-dynamic threading-multi|Win32
+ {A7D4CC95-F2AC-11D6-9E47-525400E2CF85}.Debug runtime-dynamic xml_archive.ActiveCfg = Debug runtime-dynamic|Win32
+ {A7D4CC95-F2AC-11D6-9E47-525400E2CF85}.Debug runtime-dynamic xml_archive.Build.0 = Debug runtime-dynamic|Win32
+ {A7D4CC95-F2AC-11D6-9E47-525400E2CF85}.Debug runtime-dynamic xml_warchive.ActiveCfg = Debug runtime-dynamic|Win32
+ {A7D4CC95-F2AC-11D6-9E47-525400E2CF85}.Debug runtime-dynamic xml_warchive.Build.0 = Debug runtime-dynamic|Win32
+ {A7D4CC95-F2AC-11D6-9E47-525400E2CF85}.Debug runtime-static.ActiveCfg = Debug runtime-static|Win32
+ {A7D4CC95-F2AC-11D6-9E47-525400E2CF85}.Debug runtime-static.Build.0 = Debug runtime-static|Win32
+ {A7D4CC95-F2AC-11D6-9E47-525400E2CF85}.Debug runtime-static binary_archive.ActiveCfg = Debug runtime-static threading-multi|Win32
+ {A7D4CC95-F2AC-11D6-9E47-525400E2CF85}.Debug runtime-static binary_archive.Build.0 = Debug runtime-static threading-multi|Win32
+ {A7D4CC95-F2AC-11D6-9E47-525400E2CF85}.Debug runtime-static text_archive.ActiveCfg = Debug runtime-static threading-multi|Win32
+ {A7D4CC95-F2AC-11D6-9E47-525400E2CF85}.Debug runtime-static text_archive.Build.0 = Debug runtime-static threading-multi|Win32
+ {A7D4CC95-F2AC-11D6-9E47-525400E2CF85}.Debug runtime-static text_warchive.ActiveCfg = Debug runtime-static threading-multi|Win32
+ {A7D4CC95-F2AC-11D6-9E47-525400E2CF85}.Debug runtime-static text_warchive.Build.0 = Debug runtime-static threading-multi|Win32
+ {A7D4CC95-F2AC-11D6-9E47-525400E2CF85}.Debug runtime-static threading-multi.ActiveCfg = Debug runtime-static threading-multi|Win32
+ {A7D4CC95-F2AC-11D6-9E47-525400E2CF85}.Debug runtime-static threading-multi.Build.0 = Debug runtime-static threading-multi|Win32
+ {A7D4CC95-F2AC-11D6-9E47-525400E2CF85}.Debug runtime-static threading-multi binary_archive.ActiveCfg = Debug runtime-static threading-multi|Win32
+ {A7D4CC95-F2AC-11D6-9E47-525400E2CF85}.Debug runtime-static threading-multi binary_archive.Build.0 = Debug runtime-static threading-multi|Win32
+ {A7D4CC95-F2AC-11D6-9E47-525400E2CF85}.Debug runtime-static threading-multi text_archive.ActiveCfg = Debug runtime-static threading-multi|Win32
+ {A7D4CC95-F2AC-11D6-9E47-525400E2CF85}.Debug runtime-static threading-multi text_archive.Build.0 = Debug runtime-static threading-multi|Win32
+ {A7D4CC95-F2AC-11D6-9E47-525400E2CF85}.Debug runtime-static threading-multi text_warchive.ActiveCfg = Debug runtime-static threading-multi|Win32
+ {A7D4CC95-F2AC-11D6-9E47-525400E2CF85}.Debug runtime-static threading-multi text_warchive.Build.0 = Debug runtime-static threading-multi|Win32
+ {A7D4CC95-F2AC-11D6-9E47-525400E2CF85}.Debug runtime-static threading-multi xml_archive.ActiveCfg = Debug runtime-static threading-multi|Win32
+ {A7D4CC95-F2AC-11D6-9E47-525400E2CF85}.Debug runtime-static threading-multi xml_archive.Build.0 = Debug runtime-static threading-multi|Win32
+ {A7D4CC95-F2AC-11D6-9E47-525400E2CF85}.Debug runtime-static threading-multi xml_warchive.ActiveCfg = Debug runtime-static threading-multi|Win32
+ {A7D4CC95-F2AC-11D6-9E47-525400E2CF85}.Debug runtime-static threading-multi xml_warchive.Build.0 = Debug runtime-static threading-multi|Win32
+ {A7D4CC95-F2AC-11D6-9E47-525400E2CF85}.Debug runtime-static xml_archive.ActiveCfg = Debug runtime-static threading-multi|Win32
+ {A7D4CC95-F2AC-11D6-9E47-525400E2CF85}.Debug runtime-static xml_archive.Build.0 = Debug runtime-static threading-multi|Win32
+ {A7D4CC95-F2AC-11D6-9E47-525400E2CF85}.Debug runtime-static xml_warchive.ActiveCfg = Debug runtime-static threading-multi|Win32
+ {A7D4CC95-F2AC-11D6-9E47-525400E2CF85}.Debug runtime-static xml_warchive.Build.0 = Debug runtime-static threading-multi|Win32
+ {A7D4CC95-F2AC-11D6-9E47-525400E2CF85}.Default runtime-dynamic.ActiveCfg = Debug runtime-dynamic threading-multi|Win32
+ {A7D4CC95-F2AC-11D6-9E47-525400E2CF85}.Default runtime-dynamic.Build.0 = Debug runtime-dynamic threading-multi|Win32
+ {A7D4CC95-F2AC-11D6-9E47-525400E2CF85}.Release.ActiveCfg = Release runtime-dynamic|Win32
+ {A7D4CC95-F2AC-11D6-9E47-525400E2CF85}.Release.Build.0 = Release runtime-dynamic|Win32
+ {A7D4CC95-F2AC-11D6-9E47-525400E2CF85}.Release runtime-dynamic.ActiveCfg = Release runtime-dynamic|Win32
+ {A7D4CC95-F2AC-11D6-9E47-525400E2CF85}.Release runtime-dynamic.Build.0 = Release runtime-dynamic|Win32
+ {A7D4CC95-F2AC-11D6-9E47-525400E2CF85}.Release runtime-dynamic binary_archive.ActiveCfg = Release runtime-dynamic|Win32
+ {A7D4CC95-F2AC-11D6-9E47-525400E2CF85}.Release runtime-dynamic binary_archive.Build.0 = Release runtime-dynamic|Win32
+ {A7D4CC95-F2AC-11D6-9E47-525400E2CF85}.Release runtime-dynamic text_archive.ActiveCfg = Release runtime-dynamic|Win32
+ {A7D4CC95-F2AC-11D6-9E47-525400E2CF85}.Release runtime-dynamic text_archive.Build.0 = Release runtime-dynamic|Win32
+ {A7D4CC95-F2AC-11D6-9E47-525400E2CF85}.Release runtime-dynamic text_warchive.ActiveCfg = Release runtime-dynamic|Win32
+ {A7D4CC95-F2AC-11D6-9E47-525400E2CF85}.Release runtime-dynamic text_warchive.Build.0 = Release runtime-dynamic|Win32
+ {A7D4CC95-F2AC-11D6-9E47-525400E2CF85}.Release runtime-dynamic xml_archive.ActiveCfg = Release runtime-dynamic|Win32
+ {A7D4CC95-F2AC-11D6-9E47-525400E2CF85}.Release runtime-dynamic xml_archive.Build.0 = Release runtime-dynamic|Win32
+ {A7D4CC95-F2AC-11D6-9E47-525400E2CF85}.Release runtime-dynamic xml_warchive.ActiveCfg = Release runtime-dynamic|Win32
+ {A7D4CC95-F2AC-11D6-9E47-525400E2CF85}.Release runtime-dynamic xml_warchive.Build.0 = Release runtime-dynamic|Win32
+ {A7D4CC95-F2AC-11D6-9E47-525400E2CF85}.Release runtime-static.ActiveCfg = Release runtime-static|Win32
+ {A7D4CC95-F2AC-11D6-9E47-525400E2CF85}.Release runtime-static.Build.0 = Release runtime-static|Win32
+ {A7D4CC95-F2AC-11D6-9E47-525400E2CF85}.Release runtime-static binary_archive.ActiveCfg = Release runtime-static threading-multi|Win32
+ {A7D4CC95-F2AC-11D6-9E47-525400E2CF85}.Release runtime-static binary_archive.Build.0 = Release runtime-static threading-multi|Win32
+ {A7D4CC95-F2AC-11D6-9E47-525400E2CF85}.Release runtime-static text_archive.ActiveCfg = Release runtime-static threading-multi|Win32
+ {A7D4CC95-F2AC-11D6-9E47-525400E2CF85}.Release runtime-static text_archive.Build.0 = Release runtime-static threading-multi|Win32
+ {A7D4CC95-F2AC-11D6-9E47-525400E2CF85}.Release runtime-static text_warchive.ActiveCfg = Release runtime-static threading-multi|Win32
+ {A7D4CC95-F2AC-11D6-9E47-525400E2CF85}.Release runtime-static text_warchive.Build.0 = Release runtime-static threading-multi|Win32
+ {A7D4CC95-F2AC-11D6-9E47-525400E2CF85}.Release runtime-static threading-multi.ActiveCfg = Release runtime-static threading-multi|Win32
+ {A7D4CC95-F2AC-11D6-9E47-525400E2CF85}.Release runtime-static threading-multi.Build.0 = Release runtime-static threading-multi|Win32
+ {A7D4CC95-F2AC-11D6-9E47-525400E2CF85}.Release runtime-static threading-multi binary_archive.ActiveCfg = Release runtime-static threading-multi|Win32
+ {A7D4CC95-F2AC-11D6-9E47-525400E2CF85}.Release runtime-static threading-multi binary_archive.Build.0 = Release runtime-static threading-multi|Win32
+ {A7D4CC95-F2AC-11D6-9E47-525400E2CF85}.Release runtime-static threading-multi text_archive.ActiveCfg = Release runtime-static threading-multi|Win32
+ {A7D4CC95-F2AC-11D6-9E47-525400E2CF85}.Release runtime-static threading-multi text_archive.Build.0 = Release runtime-static threading-multi|Win32
+ {A7D4CC95-F2AC-11D6-9E47-525400E2CF85}.Release runtime-static threading-multi text_warchive.ActiveCfg = Release runtime-static threading-multi|Win32
+ {A7D4CC95-F2AC-11D6-9E47-525400E2CF85}.Release runtime-static threading-multi text_warchive.Build.0 = Release runtime-static threading-multi|Win32
+ {A7D4CC95-F2AC-11D6-9E47-525400E2CF85}.Release runtime-static threading-multi xml_archive.ActiveCfg = Release runtime-static threading-multi|Win32
+ {A7D4CC95-F2AC-11D6-9E47-525400E2CF85}.Release runtime-static threading-multi xml_archive.Build.0 = Release runtime-static threading-multi|Win32
+ {A7D4CC95-F2AC-11D6-9E47-525400E2CF85}.Release runtime-static threading-multi xml_warchive.ActiveCfg = Release runtime-static threading-multi|Win32
+ {A7D4CC95-F2AC-11D6-9E47-525400E2CF85}.Release runtime-static threading-multi xml_warchive.Build.0 = Release runtime-static threading-multi|Win32
+ {A7D4CC95-F2AC-11D6-9E47-525400E2CF85}.Release runtime-static xml_archive.ActiveCfg = Release runtime-static threading-multi|Win32
+ {A7D4CC95-F2AC-11D6-9E47-525400E2CF85}.Release runtime-static xml_archive.Build.0 = Release runtime-static threading-multi|Win32
+ {A7D4CC95-F2AC-11D6-9E47-525400E2CF85}.Release runtime-static xml_warchive.ActiveCfg = Release runtime-static threading-multi|Win32
+ {A7D4CC95-F2AC-11D6-9E47-525400E2CF85}.Release runtime-static xml_warchive.Build.0 = Release runtime-static threading-multi|Win32
                 {A7D4CC95-F2AC-11D6-9E47-525400E2CF85}.Debug.ActiveCfg = Debug runtime-static|Win32
                 {A7D4CC95-F2AC-11D6-9E47-525400E2CF85}.Debug.Build.0 = Debug runtime-static|Win32
                 {A7D4CC95-F2AC-11D6-9E47-525400E2CF85}.Debug runtime-dynamic.ActiveCfg = Debug runtime-dynamic|Win32

Modified: branches/release/libs/serialization/vc7ide/Library.vcproj
==============================================================================
--- branches/release/libs/serialization/vc7ide/Library.vcproj (original)
+++ branches/release/libs/serialization/vc7ide/Library.vcproj 2009-09-19 22:18:02 EDT (Sat, 19 Sep 2009)
@@ -45,7 +45,8 @@
                         <Tool
                                 Name="VCLinkerTool"
                                 OutputFile="$(ConfigurationName)\boost_serialization-vc71-mt-gd-1_39.dll"
- GenerateDebugInformation="TRUE"/>
+ GenerateDebugInformation="TRUE"
+ GenerateMapFile="TRUE"/>
                         <Tool
                                 Name="VCMIDLTool"/>
                         <Tool
@@ -394,13 +395,16 @@
                                 RelativePath="..\..\..\boost\serialization\access.hpp">
                         </File>
                         <File
- RelativePath="..\..\..\boost\serialization\base_object.hpp">
+ RelativePath="..\..\..\boost\archive\archive_exception.hpp">
                         </File>
                         <File
- RelativePath="..\..\..\boost\serialization\export.hpp">
+ RelativePath="..\..\..\boost\serialization\assume_abstract.hpp">
                         </File>
                         <File
- RelativePath="..\..\..\boost\serialization\is_abstract.hpp">
+ RelativePath="..\..\..\boost\serialization\base_object.hpp">
+ </File>
+ <File
+ RelativePath="..\..\..\boost\serialization\export.hpp">
                         </File>
                         <File
                                 RelativePath="..\..\..\boost\serialization\level.hpp">
@@ -429,6 +433,12 @@
                         <File
                                 RelativePath="..\..\..\boost\serialization\version.hpp">
                         </File>
+ <File
+ RelativePath="..\..\..\boost\serialization\wrapper.hpp">
+ </File>
+ <File
+ RelativePath="..\..\..\boost\archive\xml_archive_exception.hpp">
+ </File>
                 </Filter>
                 <Filter
                         Name="Serialization Implementations"
@@ -514,9 +524,6 @@
                         <File
                                 RelativePath="..\..\..\boost\serialization\weak_ptr.hpp">
                         </File>
- <File
- RelativePath="..\..\..\boost\serialization\wrapper.hpp">
- </File>
                         <Filter
                                 Name="detail"
                                 Filter="">
@@ -614,6 +621,9 @@
                                 RelativePath="..\..\..\boost\archive\detail\basic_serializer_map.hpp">
                         </File>
                         <File
+ RelativePath="..\..\..\boost\archive\detail\check.hpp">
+ </File>
+ <File
                                 RelativePath="..\..\..\boost\archive\detail\common_iarchive.hpp">
                         </File>
                         <File
@@ -767,9 +777,6 @@
                         Name="Archive Implementations"
                         Filter="">
                         <File
- RelativePath="..\..\..\boost\archive\archive_exception.hpp">
- </File>
- <File
                                 RelativePath="..\..\..\boost\archive\binary_iarchive.hpp">
                         </File>
                         <File
@@ -812,9 +819,6 @@
                                 RelativePath="..\..\..\boost\archive\text_oarchive.hpp">
                         </File>
                         <File
- RelativePath="..\..\..\boost\archive\xml_archive_exception.hpp">
- </File>
- <File
                                 RelativePath="..\..\..\boost\archive\xml_iarchive.hpp">
                         </File>
                         <File
@@ -877,6 +881,9 @@
                         Name="Source"
                         Filter="">
                         <File
+ RelativePath="..\src\archive_exception.cpp">
+ </File>
+ <File
                                 RelativePath="..\src\basic_archive.cpp">
                         </File>
                         <File
@@ -952,6 +959,9 @@
                                 RelativePath="..\src\polymorphic_oarchive.cpp">
                         </File>
                         <File
+ RelativePath="..\src\shared_ptr_helper.cpp">
+ </File>
+ <File
                                 RelativePath="..\src\stl_port.cpp">
                         </File>
                         <File
@@ -964,6 +974,9 @@
                                 RelativePath="..\src\void_cast.cpp">
                         </File>
                         <File
+ RelativePath="..\src\xml_archive_exception.cpp">
+ </File>
+ <File
                                 RelativePath="..\src\xml_grammar.cpp">
                         </File>
                         <File

Modified: branches/release/libs/serialization/vc7ide/dll_a.vcproj
==============================================================================
--- branches/release/libs/serialization/vc7ide/dll_a.vcproj (original)
+++ branches/release/libs/serialization/vc7ide/dll_a.vcproj 2009-09-19 22:18:02 EDT (Sat, 19 Sep 2009)
@@ -208,32 +208,65 @@
                         <Tool
                                 Name="VCAuxiliaryManagedWrapperGeneratorTool"/>
                 </Configuration>
+ <Configuration
+ Name="Debug runtime-static|Win32"
+ OutputDirectory="$(SolutionDir)$(ConfigurationName)"
+ IntermediateDirectory="$(ConfigurationName)"
+ ConfigurationType="2">
+ <Tool
+ Name="VCCLCompilerTool"
+ Optimization="0"
+ AdditionalIncludeDirectories=""$(ProjectDir)..\..\..\""
+ PreprocessorDefinitions="WIN32;_DEBUG;BOOST_ALL_DYN_LINK=1;BOOST_LIB_DIAGNOSTIC=1;"
+ RuntimeLibrary="3"
+ TreatWChar_tAsBuiltInType="TRUE"
+ ForceConformanceInForLoopScope="TRUE"
+ RuntimeTypeInfo="TRUE"
+ DebugInformationFormat="4"/>
+ <Tool
+ Name="VCCustomBuildTool"/>
+ <Tool
+ Name="VCLinkerTool"
+ OutputFile="$(OutDir)/$(ProjectName).dll"
+ AdditionalLibraryDirectories="$(ConfigurationName)"
+ GenerateDebugInformation="TRUE"/>
+ <Tool
+ Name="VCMIDLTool"/>
+ <Tool
+ Name="VCPostBuildEventTool"/>
+ <Tool
+ Name="VCPreBuildEventTool"/>
+ <Tool
+ Name="VCPreLinkEventTool"/>
+ <Tool
+ Name="VCResourceCompilerTool"/>
+ <Tool
+ Name="VCWebServiceProxyGeneratorTool"/>
+ <Tool
+ Name="VCXMLDataGeneratorTool"/>
+ <Tool
+ Name="VCWebDeploymentTool"/>
+ <Tool
+ Name="VCManagedWrapperGeneratorTool"/>
+ <Tool
+ Name="VCAuxiliaryManagedWrapperGeneratorTool"/>
+ </Configuration>
         </Configurations>
         <References>
         </References>
         <Files>
- <Filter
- Name="Source Files"
- Filter="cpp;c;cxx;def;odl;idl;hpj;bat;asm;asmx"
- UniqueIdentifier="{4FC737F1-C7A5-4376-A066-2A32D752A2FF}">
- <File
- RelativePath="..\test\dll_a.cpp">
- </File>
- </Filter>
- <Filter
- Name="Header Files"
- Filter="h;hpp;hxx;hm;inl;inc;xsd"
- UniqueIdentifier="{93995380-89BD-4b04-88EB-625FBE52EBFB}">
- <File
- RelativePath="..\test\A.hpp">
- </File>
- <File
- RelativePath="..\test\A.ipp">
- </File>
- <File
- RelativePath="..\test\test_decl.hpp">
- </File>
- </Filter>
+ <File
+ RelativePath="..\test\A.hpp">
+ </File>
+ <File
+ RelativePath="..\test\A.ipp">
+ </File>
+ <File
+ RelativePath="..\test\dll_a.cpp">
+ </File>
+ <File
+ RelativePath="..\test\test_decl.hpp">
+ </File>
         </Files>
         <Globals>
         </Globals>

Modified: branches/release/libs/serialization/vc7ide/dll_base.vcproj
==============================================================================
--- branches/release/libs/serialization/vc7ide/dll_base.vcproj (original)
+++ branches/release/libs/serialization/vc7ide/dll_base.vcproj 2009-09-19 22:18:02 EDT (Sat, 19 Sep 2009)
@@ -171,7 +171,8 @@
                         IntermediateDirectory="$(ConfigurationName)"
                         ConfigurationType="1">
                         <Tool
- Name="VCCLCompilerTool"/>
+ Name="VCCLCompilerTool"
+ RuntimeLibrary="3"/>
                         <Tool
                                 Name="VCCustomBuildTool"/>
                         <Tool
@@ -245,22 +246,12 @@
         <References>
         </References>
         <Files>
- <Filter
- Name="Source Files"
- Filter="cpp;c;cxx;def;odl;idl;hpj;bat;asm;asmx"
- UniqueIdentifier="{4FC737F1-C7A5-4376-A066-2A32D752A2FF}">
- <File
- RelativePath="..\test\dll_base.cpp">
- </File>
- </Filter>
- <Filter
- Name="Header Files"
- Filter="h;hpp;hxx;hm;inl;inc;xsd"
- UniqueIdentifier="{93995380-89BD-4b04-88EB-625FBE52EBFB}">
- <File
- RelativePath="..\test\base.hpp">
- </File>
- </Filter>
+ <File
+ RelativePath="..\test\base.hpp">
+ </File>
+ <File
+ RelativePath="..\test\dll_base.cpp">
+ </File>
         </Files>
         <Globals>
         </Globals>

Modified: branches/release/libs/serialization/vc7ide/dll_derived2.vcproj
==============================================================================
--- branches/release/libs/serialization/vc7ide/dll_derived2.vcproj (original)
+++ branches/release/libs/serialization/vc7ide/dll_derived2.vcproj 2009-09-19 22:18:02 EDT (Sat, 19 Sep 2009)
@@ -157,26 +157,61 @@
                         <Tool
                                 Name="VCAuxiliaryManagedWrapperGeneratorTool"/>
                 </Configuration>
+ <Configuration
+ Name="Debug runtime-static|Win32"
+ OutputDirectory="$(ConfigurationName)"
+ IntermediateDirectory="$(ConfigurationName)"
+ ConfigurationType="2"
+ ReferencesPath="$(ConfigurationName)">
+ <Tool
+ Name="VCCLCompilerTool"
+ Optimization="0"
+ AdditionalIncludeDirectories=""$(ProjectDir)..\..\..\""
+ PreprocessorDefinitions="WIN32;_DEBUG;BOOST_ALL_DYN_LINK=1;BOOST_LIB_DIAGNOSTIC=1;"
+ RuntimeLibrary="3"
+ TreatWChar_tAsBuiltInType="TRUE"
+ ForceConformanceInForLoopScope="TRUE"
+ RuntimeTypeInfo="TRUE"
+ WarningLevel="3"
+ DebugInformationFormat="4"/>
+ <Tool
+ Name="VCCustomBuildTool"/>
+ <Tool
+ Name="VCLinkerTool"
+ AdditionalDependencies="dll_base.lib"
+ AdditionalLibraryDirectories="$(ConfigurationName)"
+ GenerateDebugInformation="TRUE"/>
+ <Tool
+ Name="VCMIDLTool"/>
+ <Tool
+ Name="VCPostBuildEventTool"/>
+ <Tool
+ Name="VCPreBuildEventTool"/>
+ <Tool
+ Name="VCPreLinkEventTool"/>
+ <Tool
+ Name="VCResourceCompilerTool"/>
+ <Tool
+ Name="VCWebServiceProxyGeneratorTool"/>
+ <Tool
+ Name="VCXMLDataGeneratorTool"/>
+ <Tool
+ Name="VCWebDeploymentTool"/>
+ <Tool
+ Name="VCManagedWrapperGeneratorTool"/>
+ <Tool
+ Name="VCAuxiliaryManagedWrapperGeneratorTool"/>
+ </Configuration>
         </Configurations>
         <References>
         </References>
         <Files>
- <Filter
- Name="Source Files"
- Filter="cpp;c;cxx;def;odl;idl;hpj;bat;asm;asmx"
- UniqueIdentifier="{4FC737F1-C7A5-4376-A066-2A32D752A2FF}">
- <File
- RelativePath="..\test\dll_derived2.cpp">
- </File>
- </Filter>
- <Filter
- Name="Header Files"
- Filter="h;hpp;hxx;hm;inl;inc;xsd"
- UniqueIdentifier="{93995380-89BD-4b04-88EB-625FBE52EBFB}">
- <File
- RelativePath="..\test\derived2.hpp">
- </File>
- </Filter>
+ <File
+ RelativePath="..\test\derived2.hpp">
+ </File>
+ <File
+ RelativePath="..\test\dll_derived2.cpp">
+ </File>
         </Files>
         <Globals>
         </Globals>

Modified: branches/release/libs/serialization/vc7ide/polymorphic_derived2.vcproj
==============================================================================
--- branches/release/libs/serialization/vc7ide/polymorphic_derived2.vcproj (original)
+++ branches/release/libs/serialization/vc7ide/polymorphic_derived2.vcproj 2009-09-19 22:18:02 EDT (Sat, 19 Sep 2009)
@@ -156,32 +156,66 @@
                         <Tool
                                 Name="VCAuxiliaryManagedWrapperGeneratorTool"/>
                 </Configuration>
+ <Configuration
+ Name="Debug runtime-static|Win32"
+ OutputDirectory="$(ConfigurationName)"
+ IntermediateDirectory="$(ConfigurationName)"
+ ConfigurationType="2"
+ ReferencesPath="$(ConfigurationName)">
+ <Tool
+ Name="VCCLCompilerTool"
+ Optimization="0"
+ AdditionalIncludeDirectories=""$(ProjectDir)..\..\..\""
+ PreprocessorDefinitions="WIN32;_DEBUG;BOOST_ALL_DYN_LINK=1;BOOST_LIB_DIAGNOSTIC=1;"
+ RuntimeLibrary="3"
+ TreatWChar_tAsBuiltInType="TRUE"
+ ForceConformanceInForLoopScope="TRUE"
+ RuntimeTypeInfo="TRUE"
+ WarningLevel="3"
+ DebugInformationFormat="4"/>
+ <Tool
+ Name="VCCustomBuildTool"/>
+ <Tool
+ Name="VCLinkerTool"
+ AdditionalLibraryDirectories="$(ConfigurationName)"
+ GenerateDebugInformation="TRUE"/>
+ <Tool
+ Name="VCMIDLTool"/>
+ <Tool
+ Name="VCPostBuildEventTool"/>
+ <Tool
+ Name="VCPreBuildEventTool"/>
+ <Tool
+ Name="VCPreLinkEventTool"/>
+ <Tool
+ Name="VCResourceCompilerTool"/>
+ <Tool
+ Name="VCWebServiceProxyGeneratorTool"/>
+ <Tool
+ Name="VCXMLDataGeneratorTool"/>
+ <Tool
+ Name="VCWebDeploymentTool"/>
+ <Tool
+ Name="VCManagedWrapperGeneratorTool"/>
+ <Tool
+ Name="VCAuxiliaryManagedWrapperGeneratorTool"/>
+ </Configuration>
         </Configurations>
         <References>
         </References>
         <Files>
- <Filter
- Name="Source Files"
- Filter="cpp;c;cxx;def;odl;idl;hpj;bat;asm;asmx"
- UniqueIdentifier="{4FC737F1-C7A5-4376-A066-2A32D752A2FF}">
- <File
- RelativePath="..\test\polymorphic_base.cpp">
- </File>
- <File
- RelativePath="..\test\polymorphic_derived2.cpp">
- </File>
- </Filter>
- <Filter
- Name="Header Files"
- Filter="h;hpp;hxx;hm;inl;inc;xsd"
- UniqueIdentifier="{93995380-89BD-4b04-88EB-625FBE52EBFB}">
- <File
- RelativePath="..\test\polymorphic_base.hpp">
- </File>
- <File
- RelativePath="..\test\polymorphic_derived2.hpp">
- </File>
- </Filter>
+ <File
+ RelativePath="..\test\polymorphic_base.cpp">
+ </File>
+ <File
+ RelativePath="..\test\polymorphic_base.hpp">
+ </File>
+ <File
+ RelativePath="..\test\polymorphic_derived2.cpp">
+ </File>
+ <File
+ RelativePath="..\test\polymorphic_derived2.hpp">
+ </File>
         </Files>
         <Globals>
         </Globals>

Modified: branches/release/libs/serialization/vc7ide/test_array.vcproj
==============================================================================
--- branches/release/libs/serialization/vc7ide/test_array.vcproj (original)
+++ branches/release/libs/serialization/vc7ide/test_array.vcproj 2009-09-19 22:18:02 EDT (Sat, 19 Sep 2009)
@@ -1756,9 +1756,6 @@
                         RelativePath="..\test\A.hpp">
                 </File>
                 <File
- RelativePath="..\test\A.ipp">
- </File>
- <File
                         RelativePath="..\test\test_array.cpp">
                         <FileConfiguration
                                 Name="Debug runtime-dynamic threading-multi|Win32">

Modified: branches/release/libs/serialization/vc7ide/test_dll_exported.vcproj
==============================================================================
--- branches/release/libs/serialization/vc7ide/test_dll_exported.vcproj (original)
+++ branches/release/libs/serialization/vc7ide/test_dll_exported.vcproj 2009-09-19 22:18:02 EDT (Sat, 19 Sep 2009)
@@ -130,29 +130,18 @@
                         Name="Library"/>
         </References>
         <Files>
- <Filter
- Name="Headers"
- Filter="">
- <File
- RelativePath="..\test\polymorphic_base.hpp">
- </File>
- <File
- RelativePath="..\test\polymorphic_derived1.hpp">
- </File>
- <File
- RelativePath="..\test\polymorphic_derived2.hpp">
- </File>
- </Filter>
- <Filter
- Name="Source"
- Filter="">
- <File
- RelativePath="..\test\polymorphic_base.cpp">
- </File>
- <File
- RelativePath="..\test\test_dll_exported.cpp">
- </File>
- </Filter>
+ <File
+ RelativePath="..\test\polymorphic_base.cpp">
+ </File>
+ <File
+ RelativePath="..\test\polymorphic_base.hpp">
+ </File>
+ <File
+ RelativePath="..\test\polymorphic_derived2.hpp">
+ </File>
+ <File
+ RelativePath="..\test\test_dll_exported.cpp">
+ </File>
         </Files>
         <Globals>
         </Globals>

Modified: branches/release/libs/serialization/vc7ide/test_dll_plugin.vcproj
==============================================================================
--- branches/release/libs/serialization/vc7ide/test_dll_plugin.vcproj (original)
+++ branches/release/libs/serialization/vc7ide/test_dll_plugin.vcproj 2009-09-19 22:18:02 EDT (Sat, 19 Sep 2009)
@@ -127,12 +127,6 @@
         </References>
         <Files>
                 <File
- RelativePath="..\test\base.hpp">
- </File>
- <File
- RelativePath="..\test\derived2.hpp">
- </File>
- <File
                         RelativePath="..\test\polymorphic_base.hpp">
                 </File>
                 <File

Modified: branches/release/libs/serialization/vc7ide/test_exported.vcproj
==============================================================================
--- branches/release/libs/serialization/vc7ide/test_exported.vcproj (original)
+++ branches/release/libs/serialization/vc7ide/test_exported.vcproj 2009-09-19 22:18:02 EDT (Sat, 19 Sep 2009)
@@ -130,6 +130,9 @@
                         RelativePath="..\test\polymorphic_base.cpp">
                 </File>
                 <File
+ RelativePath="..\test\polymorphic_base.hpp">
+ </File>
+ <File
                         RelativePath="..\test\test_exported.cpp">
                 </File>
         </Files>

Modified: branches/release/libs/serialization/vc7ide/test_multiple_ptrs.vcproj
==============================================================================
--- branches/release/libs/serialization/vc7ide/test_multiple_ptrs.vcproj (original)
+++ branches/release/libs/serialization/vc7ide/test_multiple_ptrs.vcproj 2009-09-19 22:18:02 EDT (Sat, 19 Sep 2009)
@@ -77,7 +77,7 @@
                                 ImproveFloatingPointConsistency="TRUE"
                                 AdditionalIncludeDirectories=""$(ProjectDir)..\..\..\""
                                 PreprocessorDefinitions="WIN32;_DEBUG;_CONSOLE;BOOST_LIB_DIAGNOSTIC=1"
- SmallerTypeCheck="TRUE"
+ SmallerTypeCheck="FALSE"
                                 RuntimeLibrary="1"
                                 BufferSecurityCheck="TRUE"
                                 EnableFunctionLevelLinking="FALSE"
@@ -93,7 +93,6 @@
                         <Tool
                                 Name="VCLinkerTool"
                                 IgnoreImportLibrary="TRUE"
- AdditionalDependencies="Library"
                                 LinkIncremental="2"
                                 SuppressStartupBanner="TRUE"
                                 AdditionalLibraryDirectories="$(ConfigurationName)"

Date view	Thread view	Subject view	Author view

Boost-Commit list run by bdawes at acm.org, david.abrahams at rcn.com, gregod at cs.rpi.edu, cpdaniel at pacbell.net, john at johnmaddock.co.uk