mirror of
https://github.com/boostorg/serialization.git
synced 2026-07-22 13:43:39 +00:00
Compare commits
1 Commits
| Author | SHA1 | Date | |
|---|---|---|---|
 Beman Dawes
|
76ffe41573 |
+3
-9
@@ -8,7 +8,7 @@
|
||||
|
||||
project boost/serialization
|
||||
: source-location ../src
|
||||
: requirements
|
||||
: requirements <dependency>../../config/test/all//BOOST_NO_STD_LOCALE
|
||||
<conditional>@include-spirit
|
||||
;
|
||||
|
||||
@@ -18,11 +18,7 @@ rule include-spirit ( properties * )
|
||||
local old-compiler ;
|
||||
if <toolset>borland in $(properties)
|
||||
{
|
||||
if ! <toolset-borland:version>6.1.0 in $(properties)
|
||||
{
|
||||
old-compiler = true ;
|
||||
}
|
||||
|
||||
old-compiler = true ;
|
||||
}
|
||||
else if <toolset>msvc in $(properties)
|
||||
{
|
||||
@@ -75,12 +71,9 @@ SOURCES =
|
||||
text_iarchive
|
||||
text_oarchive
|
||||
void_cast
|
||||
archive_exception
|
||||
xml_grammar
|
||||
xml_iarchive
|
||||
xml_oarchive
|
||||
xml_archive_exception
|
||||
shared_ptr_helper
|
||||
;
|
||||
|
||||
WSOURCES =
|
||||
@@ -107,6 +100,7 @@ lib boost_wserialization
|
||||
: $(WSOURCES).cpp boost_serialization
|
||||
:
|
||||
<toolset>msvc:<cxxflags>/Gy
|
||||
<dependency>../../config/test/all//BOOST_NO_STD_WSTREAMBUF
|
||||
<link>shared:<define>BOOST_SERIALIZATION_DYN_LINK=1
|
||||
;
|
||||
|
||||
|
||||
@@ -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,12 +27,6 @@ http://www.boost.org/LICENSE_1_0.txt)
|
||||
</table>
|
||||
<hr>
|
||||
<ul>
|
||||
<li>Takatoshi Kondo found and corrected a very obscure and difficult bug in the
|
||||
serialization of virtual base classes.
|
||||
<li><a href="http://www.autoform.com">AutoForm Engineering GmbH</a> supported
|
||||
development efforts to extend correct serialization to objects stored in DLLS.
|
||||
<li><a href"http://www.cadence.com/il">Cadence Israel</a> supported enhancement
|
||||
and testing of the portable binary archive.
|
||||
<li>David Abrahams improved implementation of "export" functionality. This not
|
||||
only eliminated an annoying header sequencing requirement, but also the need to maintain
|
||||
a list of "known archives".
|
||||
|
||||
+82
-87
@@ -1,7 +1,7 @@
|
||||
<!doctype HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
|
||||
<html>
|
||||
<!--
|
||||
(C) Copyright 2002-10 Robert Ramey - http://www.rrsd.com .
|
||||
(C) Copyright 2002-4 Robert Ramey - http://www.rrsd.com .
|
||||
Use, modification and distribution is subject to the Boost Software
|
||||
License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
|
||||
http://www.boost.org/LICENSE_1_0.txt)
|
||||
@@ -26,96 +26,85 @@ http://www.boost.org/LICENSE_1_0.txt)
|
||||
</table>
|
||||
<hr>
|
||||
<dl class="page-index">
|
||||
<dt><a href="#trivial">Trivial Archive</a>
|
||||
<dt><a href="#implementation">More Useful Archive Classes</a>
|
||||
<dt><a href="#implementation">Implementation</a>
|
||||
<dt><a href="#usage">Usage</a>
|
||||
<dt><a href="#testing">Testing</a>
|
||||
<dt><a href="#polymorphic">Polymorphic Archives</a>
|
||||
</dl>
|
||||
|
||||
<h3><a name="trivial">Trivial Archive</a></h3>
|
||||
<h3><a name="implementation">Implementation</a></h3>
|
||||
The <a href="archives.html"><strong>Archive</strong></a> concept specifies the functions that a
|
||||
class must implement to in order to be used to serialize
|
||||
<a href="serialization.html"><strong>Serializable</strong></a> types.
|
||||
|
||||
Our discussion will focus on archives used for saving as the hierarchy is exactly analogous
|
||||
for archives used for loading data.
|
||||
|
||||
The library implements a family of archives appropriate for different purposes.
|
||||
This section describes how they have been implemented and one way one
|
||||
can implement his own archive class.
|
||||
|
||||
<h4>Minimum Requirments</h4>
|
||||
Our discussion will focus on archives used for loading as the hierarchy is exactly analogous
|
||||
for archives used for saving data.
|
||||
|
||||
The simplest class which will model the <a href="archives.html"><strong>Archive</strong></a> concept specifies the functions that a
|
||||
class will look like:
|
||||
|
||||
<pre><code>
|
||||
#include <cstddef> // std::size_t
|
||||
//////////////////////////////////////////////////////////////
|
||||
// class trivial_oarchive
|
||||
class trivial_oarchive {
|
||||
public:
|
||||
//////////////////////////////////////////////////////////
|
||||
// public interface used by programs that use the
|
||||
// serialization library
|
||||
typedef boost::mpl::bool_<true> is_saving;
|
||||
typedef boost::mpl::bool_<false> is_loading;
|
||||
template<class T> register_type(){}
|
||||
template<class T> trivial_oarchive & operator<<(const T & t){
|
||||
return *this;
|
||||
}
|
||||
template<class T> trivial_oarchive & operator&(const T & t){
|
||||
return *this << t;
|
||||
}
|
||||
void save_binary(void *address, std::size_t count){};
|
||||
};
|
||||
</code></pre>
|
||||
The simplest possible input archive class is analogous to the above.
|
||||
In the following discussion, only output archives will be addressed.
|
||||
Input archives are exactly symmetrical to output archives.
|
||||
<p>
|
||||
This archive will compile and execute with any types which implement the
|
||||
<a href="serialization.html"><strong>Serializable</strong></a> concept.
|
||||
For an example see
|
||||
<a href="../example/demo_trivial_archive.cpp" target="demo_trivial_archive">
|
||||
<code style="white-space: normal">demo_trivial_archive.cpp</code></a>.
|
||||
Of course this program won't produce any output as it is. But it provides
|
||||
the starting point for a simple class which can be used to log formated
|
||||
output. See the implementation of a <a href="simple_log.html">simple
|
||||
log archive</a> to how this has been done.
|
||||
|
||||
<h3><a name="implementation">More Useful Archive Classes</a></h3>
|
||||
The above example is fine as far as it goes. But it doesn't implement
|
||||
useful features such as serialization of pointers, class versioning
|
||||
and others. This library implements a family of full featuared archive
|
||||
classes appropriate for a variety of purposes.
|
||||
|
||||
<p>
|
||||
Our archives have been factored in to a tree of classes in order to minimize
|
||||
repetition of code. This is shown in the accompanying
|
||||
<a target="class_diagram" href="class_diagram.html">class diagram</a>.
|
||||
|
||||
Any class which fullfills the following requirements will fit into
|
||||
this hierarchy and implement all the features we require. Deriving from
|
||||
the base class <a href="../../../boost/archive/detail/common_oarchive.hpp" target="common_oarchive_hpp">
|
||||
common_oarchive.hpp</a> provides all features we desire which
|
||||
are missing from trivial_oarchive above.
|
||||
Any class which fullfills the following requirements will function as
|
||||
a loading archive.
|
||||
|
||||
|
||||
<h4>Minimum Requirments</h4>
|
||||
The archive class is derived from:
|
||||
<pre><code>
|
||||
template<class Archive>
|
||||
detail::common_iarchive;
|
||||
</code></pre>
|
||||
An instance of the this template handles all the "bookkeeping" associated
|
||||
with serialization. In order to be a functional only the following additional
|
||||
functions <strong>must</strong> be declared:
|
||||
<dl>
|
||||
<dt><h4><code>void load(T &t);</code></h4></dt>
|
||||
<dd>
|
||||
This function must be implemented for all primitive data types. This can be
|
||||
accomplished through the use of a member template or explicit declarations
|
||||
for all primitive types.
|
||||
</dd>
|
||||
|
||||
<dt><h4><code>void load_binary(void *address, std::size_t size);</code></h4></dt>
|
||||
<dd>
|
||||
This function should <code style="white-space: normal">size</code> bytes from the archive, and
|
||||
copy them in to memory starting at address <code style="white-space: normal">address</code>.
|
||||
</dd>
|
||||
|
||||
<dt><h4><code>friend class boost::archive::load_access;</code></h4></dt>
|
||||
<dd>
|
||||
In addition, such a class <strong>must</strong> provide a the following
|
||||
friend declaration grant access to the core serialization library to the functions
|
||||
of this class.
|
||||
</dd>
|
||||
|
||||
</dl>
|
||||
|
||||
So, the most trivial implementation of an input archive would look like this:
|
||||
|
||||
<pre><code>
|
||||
<a href="../../../boost/archive/detail/common_oarchive.hpp" target="common_oarchive_hpp">
|
||||
#include <cstddef> // std::size_t
|
||||
#include <boost/archive/detail/common_oarchive.hpp>
|
||||
<a href="../../../boost/archive/detail/common_iarchive.hpp" target="common_iarchive_hpp">
|
||||
#include <boost/archive/detail/common_iarchive.hpp>
|
||||
</a>
|
||||
/////////////////////////////////////////////////////////////////////////
|
||||
// class complete_oarchive
|
||||
class complete_oarchive :
|
||||
public boost::archive::detail::common_oarchive<complete_oarchive>
|
||||
// class trivial_iarchive - read serialized objects from a input text stream
|
||||
class trivial_iarchive :
|
||||
public boost::archive::detail::common_iarchive<trivial_iarchive>
|
||||
{
|
||||
// permit serialization system privileged access to permit
|
||||
// implementation of inline templates for maximum speed.
|
||||
friend class boost::archive::save_access;
|
||||
friend class boost::archive::load_access;
|
||||
|
||||
// member template for saving primitive types.
|
||||
// Specialize for any types/templates that special treatment
|
||||
// member template for loading primitive types.
|
||||
// Override for any types/templates that special treatment
|
||||
template<class T>
|
||||
void save(T & t);
|
||||
void load(T & t);
|
||||
|
||||
public:
|
||||
//////////////////////////////////////////////////////////
|
||||
@@ -123,24 +112,28 @@ public:
|
||||
// serialization library
|
||||
|
||||
// archives are expected to support this function
|
||||
void save_binary(void *address, std::size_t count);
|
||||
void load_binary(void *address, std::size_t count);
|
||||
};
|
||||
</code></pre>
|
||||
|
||||
Given a suitable definitions of <code style="white-space: normal">save</code>
|
||||
and <code style="white-space: normal">save_binary</code>,
|
||||
</code></pre>
|
||||
The simplest possible output archive class is exactly analogous to the above.
|
||||
In the following discussion, only input archives will be addressed.
|
||||
Output archives are exactly symmetrical to input archives.
|
||||
<p>
|
||||
Given a suitable definitions of <code style="white-space: normal">load</code>
|
||||
and <code style="white-space: normal">load_binary</code>,
|
||||
any program using serialization with a conforming C++ compiler should compile
|
||||
and run with this archive class.
|
||||
|
||||
<h4>Optional Overrides</h4>
|
||||
|
||||
The <code style="white-space: normal">detail::common_oarchive</code> class contains
|
||||
The <code style="white-space: normal">detail::common_iarchive</code> class contains
|
||||
a number of functions that are used by various parts of the serialization library
|
||||
to help render the archive in a particular form.
|
||||
|
||||
<dl>
|
||||
|
||||
<dt><h4><code>void save_start()</code></h4></dt>
|
||||
<dt><h4><code>void load_start()</code></h4></dt>
|
||||
<dd>
|
||||
<strong>Default</strong>:Does nothing.<br>
|
||||
<strong>Purpose</strong>:To inject/retrieve an object name into the archive. Used
|
||||
@@ -148,7 +141,7 @@ by XML archive to inject "<name " before data.
|
||||
</dd>
|
||||
<p>
|
||||
|
||||
<dt><h4><code>void save_end()</code></h4></dt>
|
||||
<dt><h4><code>void load_end()</code></h4></dt>
|
||||
<dd>
|
||||
<strong>Default</strong>:Does nothing.<br>
|
||||
<strong>Purpose</strong>:To inject/retrieve an object name into the archive. Used
|
||||
@@ -160,7 +153,7 @@ by XML archive to inject "</name>" after data.
|
||||
<dd>
|
||||
<strong>Default</strong>:Does nothing.<br>
|
||||
<strong>Purpose</strong>:Called <strong>each time</strong> user data is saved.
|
||||
It's not called when archive bookkeeping data is saved. This is used by XML archives
|
||||
It's not called when archive book keeping data is saved. This is used by XML archives
|
||||
to determine when to inject a ">" character at end of XML header. XML output archives
|
||||
keep their own internal flag indicating that data being written is header data. This
|
||||
internal flag is reset when an object start tag is written. When
|
||||
@@ -172,12 +165,12 @@ to be optimised away for archive classes that don't use it.
|
||||
<p>
|
||||
<dt><h4><code>
|
||||
template<class T>
|
||||
void save_override(T & t, int);
|
||||
void load_override(T & t, int);
|
||||
</code></h4></dt>
|
||||
<dd>
|
||||
<strong>Default</strong>:Invokes <code style="white-space: normal">archive::save(Archive & ar, t)</code><br>
|
||||
<strong>Default</strong>:Invokes <code style="white-space: normal">archive::load(Archive & ar, t)</code><br>
|
||||
This is the main entry into the serialization library.<br>
|
||||
<strong>Purpose</strong>:This can be specialized in cases where the data is to be written
|
||||
<strong>Purpose</strong>:This can be overridden in cases where the data is to be written
|
||||
to the archive in some special way. For example, XML archives implement special handling for
|
||||
name-value pairs by overriding this function template for name-value pairs.
|
||||
This replaces the default name-value pair handling, which is just to throw away the name,
|
||||
@@ -195,14 +188,14 @@ implement partial function template ordering. For more information see
|
||||
The serialization library injects bookkeeping data into the serialization archive.
|
||||
This data includes things like object ids, version numbers, class names etc. Each
|
||||
of these objects is included in a wrapper so that the archive class can override the
|
||||
implementation of <code style="white-space: normal">void save_override(T & t, int);</code>.
|
||||
implementation of <code style="white-space: normal">void load_override(T & t, int);</code>.
|
||||
For example, in the XML archive, the override for this type renders an object_id equal to 23 as
|
||||
"object_id=_23". The following table lists the types defined in the
|
||||
<code style="white-space: normal">boost::archive namespace</code>
|
||||
used internally by the serialization library:
|
||||
<p>
|
||||
<table border>
|
||||
<tr><th align=left>type</th><th align=left><code style="white-space: normal">default<br>serialized as</code></th>
|
||||
<tr><th align=left>type</th><th align=left><code style="white-space: normal">default<br>serialed as</code></th>
|
||||
<tr><td><code style="white-space: normal">version_type</code></td><td><code style="white-space: normal">unsigned int</code></td>
|
||||
<tr><td><code style="white-space: normal">object_id_type</code></td><td><code style="white-space: normal">unsigned int</code></td>
|
||||
<tr><td><code style="white-space: normal">object_id_reference_type</code></td><td><code style="white-space: normal">unsigned int</code></td>
|
||||
@@ -214,7 +207,7 @@ used internally by the serialization library:
|
||||
</table>
|
||||
<p>
|
||||
All of these are associated with a default serialization defined in terms of primitive types
|
||||
so it isn't a requirement to define <code style="white-space: normal">save_override</code>
|
||||
so it isn't a requirement to define <code style="white-space: normal">load_override</code>
|
||||
for these types.
|
||||
<p>
|
||||
These are defined in
|
||||
@@ -277,19 +270,21 @@ will throw an
|
||||
exception.
|
||||
<p>
|
||||
|
||||
|
||||
<h4><a name="testing">Testing</h4>
|
||||
Exhaustive testing of the library requires testing the different aspects of object
|
||||
serialization with each archive. There are 46 different tests that can run with any archive.
|
||||
There are 5 "standard archives" included with the system.
|
||||
(3 in systems don't support wide charactor i/o).
|
||||
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).
|
||||
<p>
|
||||
In addition, there are 28 other tests which aren't related to any particular archive class.
|
||||
In addition, there are 22 other tests which aren't related to any particular archive
|
||||
class.
|
||||
<p>
|
||||
The default <code style="white-space: normal">bjam</code> testing setup will run all
|
||||
the above described tests. This will result in as many as 46 archive tests * 5
|
||||
standard archives + 28 general tests = 258 tests. Note that a complete test of the
|
||||
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
|
||||
library would include DLL vs static library, release vs debug so the actual total
|
||||
would be closer to 1032 tests.
|
||||
would be closer to 880 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
|
||||
|
||||
+2
-2
@@ -102,7 +102,7 @@ way the data are rendered <a href="serialization.html">serializable</a>.
|
||||
For more information, see <a target="detail" href="implementation.html#tempatesyntax">Template Invocation syntax</a>
|
||||
</dd>
|
||||
<dt><h4><code>
|
||||
sa.get_library_version()
|
||||
sa.library_version()
|
||||
</code></h4></dt>
|
||||
<dd>
|
||||
Returns an unsigned integer containing the current version number of the serialization
|
||||
@@ -172,7 +172,7 @@ equivalent to the original.
|
||||
For more information, see <a target="detail" href="implementation.html#tempatesyntax">Template Invocation syntax</a>
|
||||
</dd>
|
||||
<dt><h4><code>
|
||||
la.get_library_version()
|
||||
la.library_version()
|
||||
</code></h4></dt>
|
||||
<dd>
|
||||
Returns an unsigned integer containing the version number of the serialization
|
||||
|
||||
+36
-36
@@ -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">
|
||||
<!--
|
||||
(C) Copyright 2002-4 Robert Ramey - http://www.rrsd.com .
|
||||
Use, modification and distribution is subject to the Boost Software
|
||||
@@ -29,136 +29,136 @@ http://www.boost.org/LICENSE_1_0.txt)
|
||||
<pre><code>
|
||||
|
||||
|
||||
basic_oarchive <a href="../../../boost/archive/detail/basic_oarchive.hpp">-></a>
|
||||
basic_iarchive <a href="../../../boost/archive/detail/basic_iarchive.hpp">-></a>
|
||||
|
|
||||
|
|
||||
| interface_oarchive<text_oarchive> <a href="../../../boost/archive/detail/interface_oarchive.hpp">-></a>
|
||||
| interface_iarchive<text_iarchive> <a href="../../../boost/archive/detail/interface_iarchive.hpp">-></a>
|
||||
| /
|
||||
| /
|
||||
| _________/
|
||||
| /
|
||||
| /
|
||||
| /
|
||||
common_oarchive<text_oarchive> <a href="../../../boost/archive/detail/common_oarchive.hpp">-></a>
|
||||
common_iarchive<text_iarchive> <a href="../../../boost/archive/detail/common_iarchive.hpp">-></a>
|
||||
|
|
||||
|
|
||||
<font color="blue">basic_text_oarchive<text_oarchive></font> <a href="../../../boost/archive/basic_text_oarchive.hpp">-></a>
|
||||
<font color="blue">basic_text_iarchive<text_iarchive></font> <a href="../../../boost/archive/basic_text_iarchive.hpp">-></a>
|
||||
|
|
||||
|
|
||||
| <font color="blue">basic_text_oprimitive<basic_ostream></font> <a href="../../../boost/archive/basic_text_oprimitive.hpp">-></a>
|
||||
| <font color="blue">basic_text_iprimitive<basic_istream></font> <a href="../../../boost/archive/basic_text_iprimitive.hpp">-></a>
|
||||
| /
|
||||
| /
|
||||
| _________/ interface_oarchive<polymorphic_oarchive> <a href="../../../boost/archive/detail/interface_oarchive.hpp">-></a>
|
||||
| _________/ interface_iarchive<polymorphic_iarchive> <a href="../../../boost/archive/detail/interface_iarchive.hpp">-></a>
|
||||
| / |
|
||||
| / |
|
||||
| / |
|
||||
<font color="blue">text_oarchive_impl<text_oarchive></font> <a href="../../../boost/archive/text_oarchive.hpp">-></a> polymorphic_oarchive_impl <a href="../../../boost/archive/polymorphic_oarchive.hpp">-></a>
|
||||
<font color="blue">text_iarchive_impl<text_iarchive></font> <a href="../../../boost/archive/text_iarchive.hpp">-></a> polymorphic_iarchive_impl <a href="../../../boost/archive/polymorphic_iarchive.hpp">-></a>
|
||||
| \ |
|
||||
| \ |
|
||||
| \_____________________________________ <font color="red">polymorphic_oarchive</font> <a href="../../../boost/archive/polymorphic_oarchive.hpp">-></a>
|
||||
| \_____________________________________ <font color="red">polymorphic_iarchive</font> <a href="../../../boost/archive/polymorphic_iarchive.hpp">-></a>
|
||||
| \ /
|
||||
| \ /
|
||||
| \ /
|
||||
<font color="red">text_oarchive</font> <a href="../../../boost/archive/text_oarchive.hpp">-></a> polymorphic_oarchive_route<text_oarchive_impl<text_oarchive> > <a href="../../../boost/archive/detail/polymorphic_oarchive_route.hpp">-></a>
|
||||
<font color="red">text_iarchive</font> <a href="../../../boost/archive/text_iarchive.hpp">-></a> polymorphic_iarchive_route<text_iarchive_impl<text_iarchive> > <a href="../../../boost/archive/detail/polymorphic_iarchive_route.hpp">-></a>
|
||||
|
|
||||
|
|
||||
|
|
||||
<font color="red">polymorphic_text_oarchive</font> <a href="../../../boost/archive/polymorphic_text_oarchive.hpp">-></a>
|
||||
<font color="red">polymorphic_text_iarchive</font> <a href="../../../boost/archive/polymorphic_text_iarchive.hpp">-></a>
|
||||
|
||||
|
||||
</code></pre>
|
||||
This diagram shows the relationship between the various classes that implement saving (output
|
||||
serialization) for text archives. The hierachy and organization is similar for loading and for
|
||||
This diagram shows the relationship between the various classes that implement loading (input
|
||||
serialization) for text files. The hierachy and organization is similar for saving and for
|
||||
other types of archives as well. In the diagram, classes written in <font color="blue">blue</font>
|
||||
implement saving for a given archive type. (in this case its text archives).
|
||||
Users include classes in <font color="red">red</font> to save their data from a partcular
|
||||
implement loading for a given archive type. (in this case its text archives).
|
||||
Users include classes in <font color="red">red</font> to load their data from a partcular
|
||||
type of archive. Other classes whose names are in black implement the library and should
|
||||
never change. They are in <code>namespace boost::archive::detail</code>
|
||||
<dl>
|
||||
<dt><code>
|
||||
<a href="../../../boost/archive/detail/basic_oarchive.hpp">basic_oarchive</a>
|
||||
<a href="../../../boost/archive/detail/basic_iarchive.hpp">basic_iarchive</a>
|
||||
</code></dt>
|
||||
<dd>
|
||||
Implements the core library functions for class export, versioning, and object tracking. It is compiled
|
||||
into the library as it has no template parameters.
|
||||
</dd>
|
||||
<p><dt><code>
|
||||
<a href="../../../boost/archive/detail/interface_oarchive.hpp">interface_oarchive<text_oarchive></a>
|
||||
<a href="../../../boost/archive/detail/interface_iarchive.hpp">interface_iarchive<text_iarchive></a>
|
||||
</code></dt>
|
||||
<dd>
|
||||
A class that declares the standard archive interface. This has been factored out so that it
|
||||
can be used as a base class for <code style="white-space: normal">polymorphic_oarchive</code>
|
||||
can be used as a base class for <code style="white-space: normal">polymorphic_iarchive</code>
|
||||
as well as for archive implementations.
|
||||
|
||||
<p><dt><code>
|
||||
<a href="../../../boost/archive/detail/common_oarchive.hpp">common_oarchive<text_oarchive></a>
|
||||
<a href="../../../boost/archive/detail/common_iarchive.hpp">common_iarchive<text_iarchive></a>
|
||||
</code></dt>
|
||||
<dd>
|
||||
The function of this class is to make the connection between the virtual function
|
||||
interface used by <code>basic_oarchive</code> and the template interface used by archive
|
||||
interface used by <code>basic_iarchive</code> and the template interface used by archive
|
||||
class implementations.
|
||||
|
||||
<p><dt><code>
|
||||
<a href="../../../boost/archive/basic_text_oarchive.hpp">basic_text_oarchive<text_oarchive></a>
|
||||
<a href="../../../boost/archive/basic_text_iarchive.hpp">basic_text_iarchive<text_iarchive></a>
|
||||
</code></dt>
|
||||
<dd>
|
||||
Implements the basic functionality for simple text archives. The primitive save functions have been
|
||||
Implements the basic functionality for simple text archives. The primitive load functions have been
|
||||
factored out so it can be used in other text based archives like XML archives.
|
||||
|
||||
<p><dt><code>
|
||||
<a href="../../../boost/archive/basic_text_oprimitive.hpp">basic_text_oprimitive<basic_ostream></a>
|
||||
<a href="../../../boost/archive/basic_text_iprimitive.hpp">basic_text_iprimitive<basic_istream></a>
|
||||
</code></dt>
|
||||
<dd>
|
||||
Implements the save oversaves for all primitive types. This is a template with a parameter
|
||||
Implements the save overloads for all primitive types. This is a template with a parameter
|
||||
which describes the stream.
|
||||
|
||||
<p><dt><code>
|
||||
<a href="../../../boost/archive/text_oarchive.hpp">text_oarchive_impl<text_oarchive></a>
|
||||
<a href="../../../boost/archive/text_iarchive.hpp">text_iarchive_impl<text_iarchive></a>
|
||||
</code></dt>
|
||||
<dd>
|
||||
Inherits from the above two classes to implement text archives.
|
||||
</dd>
|
||||
|
||||
<p><dt><code>
|
||||
<a href="../../../boost/archive/text_oarchive.hpp">text_oarchive</a>
|
||||
<a href="../../../boost/archive/text_iarchive.hpp">text_iarchive</a>
|
||||
</code></dt>
|
||||
<dd>
|
||||
This is just a short hand for <code style="white-space: normal">text_oarchive_impl<text_oarchive></code> .
|
||||
This is just a short hand for <code style="white-space: normal">text_iarchive_impl<text_iarchive></code> .
|
||||
We can't use <code style="white-space: normal">typedef</code> because a
|
||||
<code style="white-space: normal">typedef</code> can't refer to it self in its definition.
|
||||
This is the class name that is used to serialize to a text archive.
|
||||
</dd>
|
||||
|
||||
<p><dt><code>
|
||||
<a href="../../../boost/archive/detail/interface_oarchive.hpp">interface_oarchive<polymorphic_oarchive></a>
|
||||
<a href="../../../boost/archive/detail/interface_iarchive.hpp">interface_iarchive<polymorphic_iarchive></a>
|
||||
</code></dt>
|
||||
<dd>
|
||||
Same template as above. However, this time the Archive parameter refers to the polymorphic archive
|
||||
with a virtual function interface rather than that the template interface that
|
||||
<code style="white-space: normal">common_oarchive</code> uses.
|
||||
<code style="white-space: normal">common_iarchive</code> uses.
|
||||
|
||||
<p><dt><code>
|
||||
<a href="../../../boost/archive/polymorphic_oarchive.hpp">polymorphic_oarchive</a>
|
||||
<a href="../../../boost/archive/polymorphic_iarchive.hpp">polymorphic_iarchive</a>
|
||||
</code></dt>
|
||||
<dd>
|
||||
A class with a list of virtual <code style="white-space: normal">save(T &t)</code>
|
||||
A class with a list of virtual <code style="white-space: normal">load(T &t)</code>
|
||||
for all primitive types T. This is the class that is used to do pre-compile serialization of classes
|
||||
for all archives present and future.
|
||||
|
||||
<p><dt><code>
|
||||
<a href="../../../boost/archive/detail/polymorphic_oarchive_route.hpp">polymorphic_oarchive_route<text_oarchive_impl<text_oarchive> ></a>
|
||||
<a href="../../../boost/archive/detail/polymorphic_iarchive_route.hpp">polymorphic_iarchive_route<text_iarchive_impl<text_iarchive> ></a>
|
||||
</code></dt>
|
||||
<dd><p>
|
||||
This class implements the <code style="white-space: normal">polymorphic_oarchive</code> in terms of a specific
|
||||
This class implements the <code style="white-space: normal">polymorphic_iarchive</code> in terms of a specific
|
||||
concrete class. Virtual function calls are routed to the implementing class. In this example,
|
||||
that implementing class would be text_oarchive_impl.
|
||||
that implementing class would be text_iarchive_impl.
|
||||
|
||||
<p><dt><code>
|
||||
<a href="../../../boost/archive/polymorphic_text_oarchive.hpp">polymorphic_text_oarchive</a>
|
||||
<a href="../../../boost/archive/polymorphic_text_iarchive.hpp">polymorphic_text_iarchive</a>
|
||||
</code></dt>
|
||||
<dd>
|
||||
this is just a typedef so we can write polymorphic_text_archive rather than
|
||||
<code style="white-space: normal">polymorphic_oarchive_route<text_oarchive_impl&'t;text_oarchive> ></code>
|
||||
<code style="white-space: normal">polymorphic_iarchive_route<text_iarchive_impl<text_iarchive> ></code>
|
||||
|
||||
</dl>
|
||||
<hr>
|
||||
|
||||
+227
-248
@@ -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 .
|
||||
@@ -83,270 +83,249 @@ function initialize() {
|
||||
<img src="dot.gif" onclick="collapse_all()">Collapse All
|
||||
-->
|
||||
<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#difference_1_41">Differences from version 1.41</a></dt>
|
||||
<dt><img style="display:none" src="dot.gif"><a target="detail" href="release.html#difference_1_40">Differences from version 1.40</a></dt>
|
||||
<dt><img style="display:none" src="dot.gif"><a target="detail" href="release.html#difference_1_39">Differences from version 1.39</a></dt>
|
||||
<dt><img style="display:none" src="dot.gif"><a target="detail" href="release.html#difference_1_37">Differences from version 1.37</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 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_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_32">Differences from version 1.32</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#todo">Pending Issues</a></dt>
|
||||
</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>
|
||||
<dt><img style="display:none" src="plus.gif" id="overview"><a target="detail" href="overview.html">Overview</a></dt>
|
||||
<dd><div id="overview_detail"><dl class="page-index">
|
||||
<dt><img style="display:none" src="dot.gif"><a target="detail" href="overview.html#Requirements">Requirements</a></dt>
|
||||
<dt><img style="display:none" src="dot.gif"><a target="detail" href="overview.html#Otherimplementations">Other Implementations</a></dt>
|
||||
</dl></div></dd>
|
||||
<dt><img style="display:none" src="plus.gif" id="tutorial"><a target="detail" href="tutorial.html">Tutorial</a></dt>
|
||||
<dd><div id="tutorial_detail"><dl class="page-index">
|
||||
<dt><img style="display:none" src="dot.gif"><a target="detail" href="tutorial.html#simplecase">A Very Simple Case</a>
|
||||
<dt><img style="display:none" src="dot.gif"><a target="detail" href="tutorial.html#nonintrusiveversion">Non Intrusive Version</a>
|
||||
<dt><img style="display:none" src="dot.gif"><a target="detail" href="tutorial.html#serializablemembers">Serializable Members</a>
|
||||
<dt><img style="display:none" src="dot.gif"><a target="detail" href="tutorial.html#derivedclasses">Derived Classes</a>
|
||||
<dt><img style="display:none" src="dot.gif"><a target="detail" href="tutorial.html#pointers">Pointers</a>
|
||||
<dt><img style="display:none" src="dot.gif"><a target="detail" href="tutorial.html#arrays">Arrays</a>
|
||||
|
||||
<dt><img style="display:none" src="dot.gif"><a target="detail" href="tutorial.html#stl">STL Collections</a>
|
||||
<dt><img style="display:none" src="dot.gif"><a target="detail" href="tutorial.html#versioning">Class Versioning</a>
|
||||
<dt><img style="display:none" src="dot.gif"><a target="detail" href="tutorial.html#splitting">Splitting <code>serialize</code> into <code>save/load</code></a>
|
||||
<dt><img style="display:none" src="dot.gif"><a target="detail" href="tutorial.html#archives">Archives</a>
|
||||
<dt><img style="display:none" src="dot.gif"><a target="detail" href="tutorial.html#examples">List of Examples</a>
|
||||
</dl></div></dd>
|
||||
|
||||
<dt><img style="display:none" src="plus.gif" id="reference"><a target="detail" href="reference.html">Reference</a></dt>
|
||||
<dd><div id="reference_detail"><dl class="page-index">
|
||||
<dt><img style="display:none" src="plus.gif" id="archive_concept"><a target="detail" href="archives.html">Archive Concepts</a>
|
||||
<dd><div id="archive_concept_detail"><dl class="page-index">
|
||||
<dt><img style="display:none" src="dot.gif"><a target="detail" href="archives.html#saving_interface">Saving Archive Concept</a>
|
||||
<dt><img style="display:none" src="dot.gif"><a target="detail" href="archives.html#loading_interface">Loading Archive Concept</a>
|
||||
<dt><img style="display:none" src="dot.gif"><a target="detail" href="archives.html#archive_models">Archive Models</a>
|
||||
<dt><img style="display:none" src="dot.gif"><a target="detail" href="archives.html#exceptions">Exceptions</a>
|
||||
<dt><img style="display:none" src="dot.gif"><a target="detail" href="archives.html#charactersets">Character Sets</a>
|
||||
</dl></div></dd>
|
||||
<dt><img style="display:none" src="plus.gif" id="serialization"><a target="detail" href="serialization.html">Serializable Concept</a>
|
||||
<dd><div id="serialization_detail"><dl class="page-index">
|
||||
<dt><img style="display:none" src="dot.gif"><a target="detail" href="serialization.html#primitiveoperators">Primitive Types</a>
|
||||
<dt><img style="display:none" src="dot.gif" id="class"><a target="detail" href="serialization.html#classoperators">Class Types</a>
|
||||
<dd><div id="class_detail"><dl class="page-index">
|
||||
<dt><img style="display:none" src="dot.gif"><a target="detail" href="serialization.html#member">Member Function</a>
|
||||
<dt><img style="display:none" src="plus.gif" id="splitfree"><a target="detail" href="serialization.html#free">Free Function</a>
|
||||
<dd><div id="splitfree_detail"><dl class="page-index">
|
||||
<dt><img style="display:none" src="dot.gif"><a target="detail" href="serialization.html#namespaces">Namespaces for Free Function Overrides</a>
|
||||
</dl></div></dd>
|
||||
<dt><img style="display:none" src="plus.gif" id="members"><a target="detail" href="serialization.html#classmembers">Class Members</a>
|
||||
<dd><div id="members_detail"><dl class="page-index">
|
||||
<dt><img style="display:none" src="dot.gif"><a target="detail" href="serialization.html#base">Base Classes</a>
|
||||
<dt><img style="display:none" src="dot.gif"><a target="detail" href="serialization.html#const"><code>const</code> Members</a>
|
||||
<dt><img style="display:none" src="dot.gif"><a target="detail" href="serialization.html#templates">Templates</a>
|
||||
</dl></div></dd>
|
||||
<dt><img style="display:none" src="dot.gif"><a target="detail" href="serialization.html#versioning">Versioning</a>
|
||||
<dt><img style="display:none" src="dot.gif"><a target="detail" href="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="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>
|
||||
<dt><img style="display:none" src="plus.gif" id="pointers"><a target="detail" href="serialization.html#pointeroperators">Pointers</a>
|
||||
<dd><div id="pointers_detail"><dl class="page-index">
|
||||
<dt><img style="display:none" src="dot.gif"><a target="detail" href="serialization.html#constructors">Non-Default Constructors</a>
|
||||
<dt><img style="display:none" src="plus.gif" id="derivedpointers"><a target="detail" href="serialization.html#derivedpointers">Pointers to Objects of Derived Classes</a>
|
||||
<dd><div id="derivedpointers_detail"><dl class="page-index">
|
||||
<dt><img style="display:none" src="dot.gif"><a target="detail" href="serialization.html#registration">Registration</a>
|
||||
<dt><img style="display:none" src="dot.gif"><a target="detail" href="serialization.html#export">Export</a>
|
||||
<dt><img style="display:none" src="dot.gif"><a target="detail" href="serialization.html#instantiation">Instantiation</a>
|
||||
<dt><img style="display:none" src="dot.gif"><a target="detail" href="serialization.html#selectivetracking">Selective Tracking</a>
|
||||
<dt><img style="display:none" src="dot.gif"><a target="detail" href="serialization.html#runtimecasting">Runtime Casting</a>
|
||||
</dl></div></dd>
|
||||
</dl></div></dd>
|
||||
<dt><img style="display:none" src="dot.gif"><a target="detail" href="serialization.html#versioning">Versioning</a>
|
||||
<dt><img style="display:none" s'c="dot.gif"><a target="detail" href="serialization.html#splitting">Splitting <code>serialize</code> into <code>save/load</code></a>
|
||||
</dl></div></dd>
|
||||
<dt><img style="display:none" src="plus.gif" id="pointers"><a target="detail" href="serialization.html#pointeroperators">Pointers</a>
|
||||
<dd><div id="pointers_detail"><dl class="page-index">
|
||||
<dt><img style="display:none" src="dot.gif"><a target="detail" href="serialization.html#constructors">Non-Default Constructors</a>
|
||||
<dt><img style="display:none" src="plus.gif" id="derivedpointers"><a target="detail" href="serialization.html#derivedpointers">Pointers to Objects of Derived Classes</a>
|
||||
<dd><div id="derivedpointers_detail"><dl class="page-index">
|
||||
<dt><img style="display:none" src="dot.gif"><a target="detail" href="serialization.html#registration">Registration</a>
|
||||
<dt><img style="display:none" src="dot.gif"><a target="detail" href="serialization.html#export">Export</a>
|
||||
<dt><img style="display:none" src="dot.gif"><a target="detail" href="serialization.html#instantiation">Instantiation</a>
|
||||
<dt><img style="display:none" src="dot.gif"><a target="detail" href="serialization.html#selectivetracking">Selective Tracking</a>
|
||||
<dt><img style="display:none" src="dot.gif"><a target="detail" href="serialization.html#runtimecasting">Runtime Casting</a>
|
||||
<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>
|
||||
</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>
|
||||
<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>
|
||||
</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>
|
||||
<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>
|
||||
</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="exception_safety.html">Exception Safety</a>
|
||||
</dl></div></dd>
|
||||
<dt><img style="display:none" src="dot.gif"><a target="detail" href="serialization.html#models">Models - Serialization Implementations Included in the Library</a>
|
||||
</dl></div></dd>
|
||||
<dt><img style="display:none" src="plus.gif" id="special"><a target="detail" 'ref="special.html">Special Considerations</a>
|
||||
<dd><div id="special_detail"><dl class="page-index">
|
||||
<dt><img style="display:none" src="dot.gif"><a target="detail" href="special.html#objecttracking">Object Tracking</a>
|
||||
<dt><img style="display:none" src="dot.gif"><a target="detail" href="special.html#classinfo">Class Information</a>
|
||||
<dt><img style="display:none" src="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="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="dot.gif"><a target="detail" href="special.html#binary_archives">Binary Archives</a>
|
||||
<dt><img style="display:none" src="dot.gif"><a target="detail" href="special.html#xml_archives">XML Archives</a>
|
||||
<dt><img style="display:none" src="dot.gif"><a target="detail" href="special.html#export">Exporting Class Serialization</a>
|
||||
<dt><img style="display:none" src="dot.gif"><a target="detail" href="special.html#static_libraries">Static Libraries and Serialization</a>
|
||||
<dt><img style="display:none" src="dot.gif"><a target="detail" href="special.html#dlls">DLLS - Serialization and Runtime Linking</a>
|
||||
<dt><img style="display:none" src="dot.gif"><a target="detail" href="special.html#plugins">Plugins</a>
|
||||
<dt><img style="display:none" src="dot.gif"><a target="detail" href="special.html#multi_threading">Multi-Threading</a>
|
||||
<dt><img style="display:none" src="dot.gif"><a target="detail" href="special.html#optimizations">Optimzations</a>
|
||||
<dt><img style="display:none" src="plus.gif" id="exceptions"><a target="detail" href="exceptions.html">Archive Exceptions</a>
|
||||
<dd><div id="exceptions_detail"><dl class="page-index">
|
||||
<dt><img style="display:none" src="dot.gif"><a target="detail" href="exceptions.html#unregistered_class"><code>unregistered_class</code></a>
|
||||
<dt><img style="display:none" src="dot.gif"><a target="detail" href="exceptions.html#invalid_signature"><code>invalid_signature</code></a>
|
||||
<dt><img style="display:none" src="dot.gif"><a target="detail" href="exceptions.html#unsupported_version"><code>unsupported_version</code></a>
|
||||
<dt><img style="display:none" src="dot.gif"><a target="detail" href="exceptions.html#pointer_conflict"><code>pointer_conflict</code></a>
|
||||
<dt><img style="display:none" src="dot.gif"><a target="detail" href="exceptions.html#incompatible_native_format"><code>incompatible_format</code></a>
|
||||
<dt><img style="display:none" src="dot.gif"><a target="detail" href="exceptions.html#array_size_too_short"><code>array_size_too_short</code></a>
|
||||
<dt><img style="display:none" src="dot.gif"><a target="detail" href="exceptions.html#stream_error"><code>stream_error</code></a>
|
||||
<dt><img style="display:none" src="dot.gif"><a target="detail" href="exceptions.html#invalid_class_name"><code>invalid_class_name</code></a>
|
||||
<dt><img style="display:none" src="dot.gif"><a target="detail" href="exceptions.html#unregistered_cast"><code>unregistered_cast</code></a>
|
||||
<dt><img style="display:none" src="dot.gif"><a target="detail" href="exceptions.html#xml_archive_parsing_error"><code>xml_archive_parsing_error</code></a>
|
||||
<dt><img style="display:none" src="dot.gif"><a target="detail" href="exceptions.html#xml_archive_tag_mismatch"><code>xml_archive_tag_mismatch</code></a>
|
||||
<dt><img style="display:none" src="dot.gif"><a target="detail" href="exceptions.html#xml_archive_tag_name_error"><code>xml_archive_tag_name_error</code></a>
|
||||
</dl></div></dd>
|
||||
<dt><img style="display:none" src="dot.gif"><a target="detail" href="exception_safety.html">Exception Safety</a>
|
||||
</dl></div></dd>
|
||||
<dt><img style="display:none" src="plus.gif" id="archive_reference"><a target="detail" href="archive_reference.html">Archive Class Reference</a>
|
||||
<dd><div id="archive_reference_detail"><dl class="page-index">
|
||||
<dt><img style="display:none" src="dot.gif"><a target="detail" href="archive_reference.html#trivial">Trivial Archive</a>
|
||||
<dt><img style="display:none" src="dot.gif"><a target="detail" href="archive_reference.html#implementation">More Useful Archive Classes</a>
|
||||
<dt><img style="display:none" src="dot.gif"><a target="detail" href="archive_reference.html#usage">Usage</a>
|
||||
<dt><img style="display:none" src="dot.gif"><a target="detail" href="archive_reference.html#testing">Testing</a>
|
||||
<dt><img style="display:none" src="dot.gif"><a target="detail" href="archive_reference.html#polymorphic">Polymorphic Archives</a>
|
||||
</dl></div></dd>
|
||||
</dl></div></dd>
|
||||
<dt><img style="display:none" src="plus.gif" id="implementation"><a target="detail" href="implementation.html">Implementation Notes</a>
|
||||
<dd><div id="implementation_detail"><dl class="page-index">
|
||||
<dt><img style="display:none" src="dot.gif"><a target="detail" href="implementation.html#functiontemplateordering">Partial Function Template Ordering</a>
|
||||
<dt><img style="display:none" src="dot.gif"><a target="detail" href="implementation.html#charencoding">Character Encoding</a>
|
||||
<dt><img style="display:none" src="dot.gif"><a target="detail" href="implementation.html#tempatesyntax">Template Invocation syntax</a>
|
||||
<dt><img style="display:none" src="dot.gif"><a target="detail" href="implementation.html#partialtemplatespecialization">Partial Template Specialization</a>
|
||||
<dt><img style="display:none" src="plus.gif" id="othercompilerissues"><a target="detail" href="implementation.html#othercompilerissues">Specific Compiler/Library Issues</a>
|
||||
<dd><div id="othercompilerissues_detail"><dl class="page-index">
|
||||
<dt><img style="display:none" src="dot.gif"><a target="detail" href="implementation.html#gcc3x">GCC 3.X,4.X</a>
|
||||
<dt><img style="display:none" src="dot.gif"><a target="detail" href="implementation.html#gcc295">GCC 2.95</a>
|
||||
<dt><img style="display:none" src="dot.gif"><a target="detail" href="implementation.html#intel80">Intel 8.0</a>
|
||||
<dt><img style="display:none" src="dot.gif"><a target="detail" href="implementation.html#vc80">Visual C++ 8.0</a>
|
||||
<dt><img style="display:none" src="dot.gif"><a target="detail" href="implementation.html#vc71">Visual C++ 7.1</a>
|
||||
<dt><img style="display:none" src="dot.gif"><a target="detail" href="implementation.html#vc70">Visual C++ 7.0</a>
|
||||
<dt><img style="display:none" src="dot.gif"><a target="detail" href="implementation.html#vc6">Visual C++ 6.0</a>
|
||||
<dt><img style="display:none" src="dot.gif"><a target="detail" href="implementation.html#borland">Borland 5.64 and 5.51</a>
|
||||
<dt><img style="display:none" src="dot.gif"><a target="detail" href="implementation.html#comeau">Comeau 4.3.3</a>
|
||||
<dt><img style="display:none" src="dot.gif"><a target="detail" href="implementation.html#codewarrior">Code Warrior 8.3</a>
|
||||
<dt><img style="display:none" src="dot.gif"><a target="detail" href="implementation.html#tru64">TRU64</a>
|
||||
<dt><img style="display:none" src="dot.gif"><a target="detail" href="implementation.html#dinkumware">Dinkumware Library</a>
|
||||
<dt><img style="display:none" src="dot.gif"><a target="detail" href="implementation.html#stlport">STLPort 4.5.3</a>
|
||||
</dl></div></dd>
|
||||
<dt><img style="display:none" src="plus.gif" id="headers"><a target="detail" href="headers.html">Code Structure</a>
|
||||
<dd><div id="headers_detail"><dl class="page-index">
|
||||
<dt><img style="display:none" src="plus.gif" id="userincludes"><a target="detail" href="headers.html#userincludes">Files Included by User Programs</a>
|
||||
<dd><div id="userincludes_detail"><dl class="page-index">
|
||||
<dt><img style="display:none" src="dot.gif"><a target="detail" href="headers.html#archiveimplementations">Archive Implementations</a>
|
||||
<dt><img style="display:none" src="dot.gif"><a target="detail" href="headers.html#serializationdeclarations">Serialization Declarations</a>
|
||||
<dt><img style="display:none" '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>
|
||||
<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>
|
||||
</dl></div></dd>
|
||||
</dl></div></dd>
|
||||
</dl></div></dd>
|
||||
<dt><img style="display:none" src="plus.gif" id="case_studies">Case Studies
|
||||
<dd><div id="case_studies_detail"><dl class="page-index">
|
||||
<dt><img style="display:none" src="dot.gif"><a target="detail" href="shared_ptr.html">Template serialization - <code>shared_ptr<class T></code></a>
|
||||
<dt><img style="display:none" src="dot.gif"><a target="detail" href="shared_ptr2.html"><code>shared_ptr<class T></code>Revisited</a>
|
||||
<dt><img style="display:none" src="dot.gif"><a target="detail" href="pimpl.html">PIMPL</a>
|
||||
<dt><img style="display:none" src="dot.gif"><a target="detail" href="simple_log.html">A Simple Logging Archive Class</a>
|
||||
<dt><img style="display:none" src="dot.gif"><a target="detail" href="derivation.html">Derivation from an Existing Archive Class</a>
|
||||
</dl></div></dd>
|
||||
<dt><img style="display:none" src="plus.gif" id="otherclasses">Other Classes
|
||||
<dd><div id="otherclasses_detail"><dl class="page-index">
|
||||
<dt><img style="display:none" src="plus.gif" id="extended_type_info"><a target="detail" href="extended_type_info.html"><code>extended_type_info</code></a>
|
||||
<dd><div id="extended_type_info_detail"><dl class="page-index">
|
||||
<dt><img style="display:none" src="dot.gif"><a target="detail" href="extended_type_info.html#motivation">Motivation</a>
|
||||
<dt><img style="display:none" src="dot.gif"><a target="detail" href="extended_type_info.html#runtime">Runtime Interface</a>
|
||||
<dt><img style="display:none" src="dot.gif"><a target="detail" href="extended_type_info.html#requirements">Requirements</a>
|
||||
<dt><img style="display:none" src="dot.gif"><a target="detail" href="extended_type_info.html#models">Models</a>
|
||||
<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>
|
||||
</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>
|
||||
<dt><img style="display:none" src="plus.gif" id="otherclasses">Other Classes
|
||||
<dd><div id="otherclasses_detail"><dl class="page-index">
|
||||
<dt><img style="display:none" src="plus.gif" id="extended_type_info"><a target="detail" href="extended_type_info.html"><code>extended_type_info</code></a>
|
||||
<dd><div id="extended_type_info_detail"><dl class="page-index">
|
||||
<dt><img style="display:none" src="dot.gif"><a target="detail" href="extended_type_info.html#motivation">Motivation</a>
|
||||
<dt><img style="display:none" src="dot.gif"><a target="detail" href="extended_type_info.html#runtime">Runtime Interface</a>
|
||||
<dt><img style="display:none" src="dot.gif"><a target="detail" href="extended_type_info.html#requirements">Requirements</a>
|
||||
<dt><img style="display:none" src="dot.gif"><a target="detail" href="extended_type_info.html#models">Models</a>
|
||||
</dl></div></dd>
|
||||
<dt><img style="display:none" src="dot.gif"><a target="detail" href="void_cast.html"><code>void_cast</code></a>
|
||||
<dt><img style="display:none" src="dot.gif"><a target="detail" href="codecvt.html"><code>utf8_codecvt_facet</code></a>
|
||||
<dt><img style="display:none" src="dot.gif"><a target="detail" href="strong_typedef.html"><code>BOOST_STRONG_TYPEDEF</code></a>
|
||||
<dt><img style="display:none" src="dot.gif"><a target="detail" href="state_saver.html"><code>state_saver</code></a>
|
||||
<dt><img style="display:none" src="dot.gif"><a target="detail" href="dataflow.html">Dataflow Iterators</a>
|
||||
<dt><img style="display:none" src="dot.gif"><a target="detail" href="smart_cast.html"><code>smart_cast</code></a>
|
||||
<dt><img style="display:none" src="dot.gif"><a target="detail" href="static_warning.html"><code>BOOST_STATIC_WARNING</code></a>
|
||||
<dt><img style="display:none" src="plus.gif" id="singleton"><a target="detail" href="singleton.html"><code>singleton</code></a>
|
||||
<dd><div id="singleton_detail"><dl class="page-index">
|
||||
<dt><img style="display:none" src="dot.gif"><a target="detail" href="singleton.html#motivation">Motivation</a>
|
||||
<dt><img style="display:none" src="dot.gif"><a target="detail" href="singleton.html#features">Features</a>
|
||||
<dt><img style="display:none" src="dot.gif"><a target="detail" href="singleton.html#classinterface">Class Interface</a>
|
||||
<dt><img style="display:none" src="dot.gif"><a target="detail" href="singleton.html#requirements">Requirements</a>
|
||||
<dt><img style="display:none" src="dot.gif"><a target="detail" href="singleton.html#examples">Examples</a>
|
||||
<dt><img style="display:none" src="dot.gif"><a target="detail" href="singleton.html#multithreading">Multi-Threading</a>
|
||||
</dl></div></dd>
|
||||
</dl></div></dd>
|
||||
</dl></div></dd>
|
||||
<!--
|
||||
<dt><img style="display:none" src="dot.gif"><a target="detail" href="configuration.html">Configuration Information</a></dt>
|
||||
<!--
|
||||
<dt><img style="display:none" src="dot.gif"><a target="detail" href="configuration.html">Configuration Information</a></dt>
|
||||
-->
|
||||
<dt><img style="display:none" src="dot.gif"><a target="detail" href="faq.html">Tips and Tricks</a>
|
||||
<dt><img style="display:none" src="plus.gif" id="rationale"><a target="detail" href="rationale.html">Rationale</a></dt>
|
||||
<dd><div id="rationale_detail"><dl class="page-index">
|
||||
<dt><img style="display:none" src="dot.gif"><a target="detail" href="rationale.html#serialization">The term "serialization" is preferred to "persistence"</a></dt>
|
||||
<dt><img style="display:none" src="dot.gif"><a target="detail" href="rationale.html#archives">Archives are not streams</a></dt>
|
||||
<dt><img style="display:none" src="dot.gif"><a target="detail" href="rationale.html#typeid"><code style="white-space: normal">typeid</code> information is not included in archives</a></dt>
|
||||
</dl></div></dd>
|
||||
|
||||
<dt><img style="display:none" src="plus.gif" id="todo"><a target="detail" href="todo.html">To Do</a></dt>
|
||||
<dd><div id="todo_detail"><dl class="page-index">
|
||||
<dt><img style="display:none" src="dot.gif"><a target="detail" href="todo.html#portablebinaryarchive">Portable Binary Archive</a></dt>
|
||||
<dt><img style="display:none" src="dot.gif"><a target="detail" href="todo.html#performancetesting">Performance Testing and Profiling</a></dt>
|
||||
<dt><img style="display:none" src="dot.gif"><a target="detail" href="todo.html#backversioning">Back Versioning</a></dt>
|
||||
<dt><img style="display:none" src="dot.gif"><a target="detail" href="todo.html#nortti">Environments without RTTI</a></dt>
|
||||
|
||||
<dt><img style="display:none" src="plus.gif" id="newcasestudies"><a target="detail" href="new_case_studies.html">Proposed Case Studies</a></dt>
|
||||
<dd><div id="newcasestudies_detail"><dl class="page-index">
|
||||
<dt><img style="display:none" src="dot.gif"><a target="detail" href="new_case_studies.html#functionobject">Serializing a Function Object</a></dt>
|
||||
<dt><img style="display:none" src="dot.gif"><a target="detail" href="new_case_studies.html#archiveadaptor">Archive Adaptors</a></dt>
|
||||
<dt><img style="display:none" src="dot.gif"><a target="detail" href="new_case_studies.html#archivehelper">Archive Helpers</a></dt>
|
||||
<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>
|
||||
</dl></div></dd>
|
||||
|
||||
</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="dot.gif"><a target="detail" href="history.html">History</a>
|
||||
<!--
|
||||
<dt><img style="display:none" src="dot.gif"><a target="detail" href="definitions.html">Definitions</a></dt>
|
||||
<dt><img style="display:none" src="dot.gif"><a target="detail" href="faq.html">Frequently Asked Questions (FAQs)</a></dt>
|
||||
<dt><img style="display:none" src="plus.gif" id="newcasestudies"><a target="detail" href="new_case_studies.html">Proposed Case Studies</a></dt>
|
||||
<dd><div id="newcasestudies_detail"><dl class="page-index">
|
||||
<dt><img style="display:none" src="dot.gif"><a target="detail" href="new_case_studies.html#functionobject">Serializing a Function Object</a></dt>
|
||||
<dt><img style="display:none" src="dot.gif"><a target="detail" href="new_case_studies.html#archiveadaptor">Archive Adaptors</a></dt>
|
||||
<dt><img style="display:none" src="dot.gif"><a target="detail" href="new_case_studies.html#archivehelper">Archive Helpers</a></dt>
|
||||
</dl></div></dd>
|
||||
|
||||
</dl></div></dd>
|
||||
|
||||
<dt><img style="display:none" src="dot.gif"><a target="detail" href="history.html">History</a>
|
||||
<!--
|
||||
<dt><img style="display:none" src="dot.gif"><a target="detail" href="definitions.html">Definitions</a></dt>
|
||||
<dt><img style="display:none" src="dot.gif"><a target="detail" href="faq.html">Frequently Asked Questions (FAQs)</a></dt>
|
||||
-->
|
||||
<dt><img style="display:none" src="dot.gif"><a target="detail" href="bibliography.html">Bibliography</a></dt>
|
||||
<dt><img style="display:none" src="dot.gif"><a target="detail" href="acknowledgments.html">Acknowledgments</a></dt>
|
||||
</dl></div>
|
||||
<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>
|
||||
|
||||
+1
-1
@@ -124,7 +124,7 @@ std::copy(
|
||||
ostream_iterator<char>(os)
|
||||
);
|
||||
</code></pre>
|
||||
This macro is defined in <a target="pfto" href="../../../boost/serialization/pfto.hpp"><boost/serialization/pfto.hpp></a>.
|
||||
This macro is defined in <a target="pfto" href="../../../boost/pfto.hpp"><boost/pfto.hpp></a>.
|
||||
For more information about this topic, check the source.
|
||||
|
||||
<h4>Dereferencing</h4>
|
||||
|
||||
+60
-56
@@ -26,48 +26,42 @@ http://www.boost.org/LICENSE_1_0.txt)
|
||||
</table>
|
||||
<hr>
|
||||
<dl class="page-index">
|
||||
<dt><a target="detail" href="#portable_archives">Portable Binary Archives</a>
|
||||
<dt><a target="detail" href="#fast_archives">Fast Binary Archives</a>
|
||||
</dl>
|
||||
|
||||
<h3>Log Archive</h3>
|
||||
<a name=portable_archives>
|
||||
<h3>Portable Binary Archives</h3>
|
||||
It may happen that one wants to create a new archive class by derivation from one
|
||||
of the included ones. Included is a sample program that shows how to derive a
|
||||
new archive from one of the ones included with the library. The first example is
|
||||
<a href="../example/demo_log.cpp" target="demo_log_cpp">
|
||||
demo_log.cpp</a>.
|
||||
<p>
|
||||
This derivation from the xml archive writes output in xml without the extra
|
||||
information required to read the data back into the application. It might be
|
||||
used to export one's data as simple xml for other applications or for logging
|
||||
data while debugging.
|
||||
<p>
|
||||
To this end it is derived from the included xml archive and the save functions for
|
||||
some types are specialized for this application.
|
||||
<p>
|
||||
The serialization library is
|
||||
implemented using the <b>C</b>uriously <b>R</b>ecurring <b>T</b>emplate
|
||||
<b>P</b>attern (<b>CRTP</b>). Also, all common code is factored out into
|
||||
separate modules to minimize code repetition. This makes derivation from
|
||||
an existing archive less straight forward than it would otherwise be.
|
||||
<p>
|
||||
This example illustrates several issues that have to be addressed when doing
|
||||
something like this
|
||||
<a href="../example/demo_portable_archive.cpp" target="demo_portable_archive_cpp">demo_portable_archive.cpp</a>.
|
||||
This binary archive save/loads integers in a portable format. To this end
|
||||
it is derived from the native binary archive and the save/load functions for
|
||||
integers are overridden with special versions which convert to big endian
|
||||
format if necessary. It also implements an exception for the case where an
|
||||
integer saved on one platform is too large for the platform which is loading
|
||||
the archive. This example doesn't address floating point types.
|
||||
This examples illustrates several issues that have to be addressed when doing
|
||||
something like this. The discussion below refers to the output archive only but it
|
||||
applies equally to input archives as well.
|
||||
<ol>
|
||||
<li><i>It is derived from</i> <code style="white-space: normal">xml_oarchive_impl<log_archive></code>
|
||||
<b>NOT</b> <code style="white-space: normal">xml_oarchive</code> <br>
|
||||
<li><i>It is derived from</i> <code style="white-space: normal">binary_oarchive_impl<portable_binary_oarchive></code>
|
||||
<b>NOT</b> <code style="white-space: normal">binary_oarchive</code> <br>
|
||||
As described in the comments in
|
||||
<a href="../../../boost/archive/xml_oarchive.hpp" target="xml_oarchive_hpp">xml_oarchive.hpp</a>.
|
||||
<code style="white-space: normal">xml_oarchive</code> really a shorthand name for
|
||||
<code style="white-space: normal">xml_oarchive_impl<xml_oarchive></code>. So we should derive
|
||||
from <code style="white-space: normal">xml_oarchive_impl<log_archive></code> rather
|
||||
than <code style="white-space: normal">xml_oarchive</code>.
|
||||
<a href="../../../boost/archive/binary_oarchive.hpp" target="binary_oarchive_hpp">binary_oarchive.hpp</a>.
|
||||
<code style="white-space: normal">binary_oarchive</code> really a shorthand name for
|
||||
<code style="white-space: normal">binary_oarchive_impl<binary_oarchive></code>. So we should derive
|
||||
from <code style="white-space: normal">binary_oarchive_impl<portable_binary_oarchive></code> rather
|
||||
than <code style="white-space: normal">binary_oarchive</code>.
|
||||
<pre><code>
|
||||
class log_archive :
|
||||
// don't derive from xml_oarchive !!!
|
||||
public xml_oarchive_impl<log_archive>
|
||||
class portable_binary_oarchive :
|
||||
// don't derive from binary_oarchive !!!
|
||||
public binary_oarchive_impl<portable_binary_oarchive>
|
||||
{
|
||||
...
|
||||
</code></pre>
|
||||
<li><i>Note the</i> <code style="white-space: normal">log_archive</code> <i>between the</i> <>
|
||||
<li><i>Note the</i> <code style="white-space: normal">portable_binary_oarchive</code> <i>between the</i> <>
|
||||
This is required so that base classes can downcast their <code style="white-space: normal">this</code> pointer
|
||||
to the most derived class. This is referred to as <b>C</b>uriously <b>R</b>ecurring
|
||||
<b>T</b>emplate <b>P</b>attern (<b>CRTP</b>) <a href="bibliography.html#11">[11]</a>.
|
||||
@@ -76,28 +70,24 @@ It is used to implement static polymorphism.
|
||||
This can be done by making members public or by including friend declarations for
|
||||
the base classes.
|
||||
<pre><code>
|
||||
friend class detail::common_oarchive<log_archive>;
|
||||
friend class basic_xml_oarchive<log_archive>;
|
||||
typedef portable_binary_oarchive derived_t;
|
||||
friend class detail::common_oarchive<derived_t>;
|
||||
friend class basic_binary_oarchive<derived_t>;
|
||||
friend class basic_binary_oprimitive<
|
||||
derived_t,
|
||||
std::ostream::char_type,
|
||||
std::ostream::traits_type
|
||||
>;
|
||||
friend class boost::serialization::save_access;
|
||||
</code></pre>
|
||||
|
||||
<li><i></i>Reread <a target="detail" href="headers.html#archiveinternals">Archive Internals</a>.
|
||||
This describes the class hierarchy so that you know what to override.
|
||||
<li><i>Note the usage of PFTO.</i> Some compilers fail to provide support for
|
||||
partial function template ordering. The serialization library works around by
|
||||
using <a target="detail" href="implementation.html#functiontemplateordering">
|
||||
<b>P</b>artial <b>F</b>unction <b>T</b>emplate <b>O</b>rdering</a> in several places.
|
||||
In archive classes, this takes
|
||||
. This is done
|
||||
in several places, including the archive classes themselves.
|
||||
<li><i>Base class functions will usually need to be explicitly invoked</i>
|
||||
We commonly specialize the function name <code style="white-space: normal">save_override</code>
|
||||
for saving primitives. Usage of a function name in a derived class
|
||||
We commonly overload the function name <code style="white-space: normal">save</code> for saving primitives.
|
||||
This is very convenient. Usage of a function name in a derived class
|
||||
"hides" similarly named functions of the base class. That is,
|
||||
function name overloading doesn't automatically
|
||||
include base classes. To address this, we can use:
|
||||
<pre><code>
|
||||
using xml_oarchive_impl<derived_t>::save;
|
||||
using binary_oarchive_impl<derived_t>::save;
|
||||
void save(const unsigned int t);
|
||||
...
|
||||
</code></pre>
|
||||
@@ -107,13 +97,13 @@ that the following equivalent works on more compilers.
|
||||
// default fall through for any types not specified here
|
||||
template<class T>
|
||||
void save(const T & t){
|
||||
xml_oarchive_impl<derived_t>::save(t);
|
||||
binary_oarchive_impl<derived_t>::save(t);
|
||||
}
|
||||
void save(const unsigned int t);
|
||||
...
|
||||
</code></pre>
|
||||
so it's what I use.
|
||||
<li><i>Template definitions of base classes may have to be explicitly instantiated.</i>
|
||||
<li><i>Template definitions of base classes may have to be included.</i>
|
||||
The demo includes
|
||||
<pre><code>
|
||||
// explicitly instantiate for this type of binary stream
|
||||
@@ -125,30 +115,44 @@ will result in undefined symbol errors when the program is linked.
|
||||
Base classes using <b>CRTP</b> must be templates with a parameter corresponding to
|
||||
the most derived class. As presented here, this class doesn't qualify, so
|
||||
it cannot be used as a base class. In order to derive further from this class,
|
||||
it would have to be reorganized along the lines of the original <code style="white-space: normal">xml_oarchive</code>.
|
||||
it would have to be reorganized along the lines of the original <code style="white-space: normal">binary_oarchive</code>.
|
||||
Specifically, it would look something like:
|
||||
<pre><code>
|
||||
template<class Archive>
|
||||
class log_archive_impl :
|
||||
// don't derive from xml_oarchive !!!
|
||||
public xml_oarchive_impl<Archive>
|
||||
class portable_binary_oarchive_impl :
|
||||
// don't derive from binary_oarchive !!!
|
||||
public binary_oarchive_impl<Archive>
|
||||
{
|
||||
...
|
||||
);
|
||||
|
||||
// do not derived from this class !!!
|
||||
class log_archive :
|
||||
public log_archive_impl<log_archive>
|
||||
class portable_binary_oarchive :
|
||||
public portable_binary_oarchive_impl<portable_binary_oarchive>
|
||||
{
|
||||
public:
|
||||
log_archive(std::ostream & os, unsigned int flags = 0) :
|
||||
log_archive_impl<xml_oarchive>(os, flags)
|
||||
portable_binary_oarchive(std::ostream & os, unsigned int flags = 0) :
|
||||
portable_binary_oarchive_impl<binary_oarchive>(os, flags)
|
||||
{}
|
||||
};
|
||||
</code></pre>
|
||||
|
||||
</ol>
|
||||
|
||||
<a name=fast_archives>
|
||||
<h3>Fast Binary Archives</h3>
|
||||
The second example
|
||||
<a href="../example/demo_fast_archive.cpp" target="demo_fast_archive_cpp">demo_fast_archive.cpp</a>.
|
||||
is similar to the first one. The difference is that it intercepts the serialization before
|
||||
the default serialization is invoked. In this case we want to replace the default
|
||||
serialization of C arrays of integers with a faster one. The default version
|
||||
will invoke serialization of each element of the array. If its an array of
|
||||
integers, and we're not concerned with the archive being portable to another platform
|
||||
we can just save/load the whole array as a binary string of bytes. This should
|
||||
be faster than the default element by element method.
|
||||
<p>
|
||||
The same considerations that applied when overriding the the save/load of primitives
|
||||
above apply here, and the code is very similar.
|
||||
<hr>
|
||||
<p><i>© Copyright <a href="http://www.rrsd.com">Robert Ramey</a> 2002-2004.
|
||||
Distributed under the Boost Software License, Version 1.0. (See
|
||||
|
||||
+5
-31
@@ -29,15 +29,12 @@ http://www.boost.org/LICENSE_1_0.txt)
|
||||
<dt><a href="#unregistered_class"><code style="white-space: normal">unregistered_class</code></a>
|
||||
<dt><a href="#invalid_signature"><code style="white-space: normal">invalid_signature</code></a>
|
||||
<dt><a href="#unsupported_version"><code style="white-space: normal">unsupported_version</code></a>
|
||||
<dt><a href="#unsupported_class_version"><code style="white-space: normal">unsupported_class_version</code></a>
|
||||
<dt><a href="#pointer_conflict"><code style="white-space: normal">pointer_conflict</code></a>
|
||||
<dt><a href="#incompatible_native_format"><code style="white-space: normal">incompatible_native_format</code></a>
|
||||
<dt><a href="#array_size_too_short"><code style="white-space: normal">array_size_too_short</code></a>
|
||||
<dt><a href="#input_stream_error"><code style="white-space: normal">input_stream_error</code></a>
|
||||
<dt><a href="#output_stream_error"><code style="white-space: normal">output_stream_error</code></a>
|
||||
<dt><a href="#stream_error"><code style="white-space: normal">stream_error</code></a>
|
||||
<dt><a href="#invalid_class_name"><code style="white-space: normal">invalid_class_name</code></a>
|
||||
<dt><a href="#unregistered_class"><code style="white-space: normal">unregistered_class</code></a>
|
||||
<dt><a href="#multiple_code_instantiation"><code style="white-space: normal">multiple_code_instantiation</code></a>
|
||||
<dt><a href="#xml_archive_parsing_error"><code style="white-space: normal">xml_archive_parsing_error</code></a>
|
||||
<dt><a href="#xml_archive_tag_mismatch"><code style="white-space: normal">xml_archive_tag_mismatch</code></a>
|
||||
<dt><a href="#xml_archive_tag_name_error"><code style="white-space: normal">xml_archive_tag_name_error</code></a>
|
||||
@@ -71,18 +68,12 @@ public:
|
||||
incompatible_native_format, // attempt to read native binary format
|
||||
// on incompatible platform
|
||||
array_size_too_short, // array being loaded doesn't fit in array allocated
|
||||
input_stream_error // error on stream input
|
||||
stream_error // i/o error on stream
|
||||
invalid_class_name, // class name greater than the maximum permitted.
|
||||
// most likely a corrupted archive or an attempt
|
||||
// to insert virus via buffer overrun method.
|
||||
unregistered_cast, // base - derived relationship not registered with
|
||||
unregistered_cast // base - derived relationship not registered with
|
||||
// void_cast_register
|
||||
unsupported_class_version, // type saved with a version # greater than the
|
||||
// one used by the program. This indicates that the proggram
|
||||
// needs to be rebuilt.
|
||||
multiple_code_instantiation, // code for implementing serialization for some
|
||||
// type has been instantiated in more than one module.
|
||||
output_stream_error // error on stream output
|
||||
} exception_code;
|
||||
exception_code code;
|
||||
archive_exception(exception_code c) : code(c) {}
|
||||
@@ -118,7 +109,7 @@ the archive is opened, It is presumed that this file is not a valid archive and
|
||||
exception is thrown.
|
||||
|
||||
<h3><a name="unsupported_version"><code style="white-space: normal">unsupported_version</code></a></h3>
|
||||
This system assigns a version number of 3 to all archives created. Note that this is in
|
||||
This system assigns a version number of 2 to all archives created. Note that this is in
|
||||
no way related to version number of classes used by application programs. This refers
|
||||
to the version of the serialization system used to create the archive. Future versions
|
||||
of this serialization system will be able to identify archives created under previous
|
||||
@@ -129,14 +120,6 @@ incompatible in format with the current one.
|
||||
<p>Should it ever occur that an older program attempts to read newer archives whose
|
||||
format has changed, this exception is thrown.
|
||||
|
||||
<h3><a name="unsupported_class_version"><code style="white-space: normal">unsupported_class_version</code></a></h3>
|
||||
An attempt has been made to load a class whose version has been incremented since the
|
||||
program was written. Suppose that a class has been assigned version number 3 and the program
|
||||
has been built and sent to third parties. Now suppose that the definition of that class
|
||||
has been altered, the version number has been incremented to 4 and new archives have been
|
||||
built. If one attempts to load these new archives with the original program, this
|
||||
exception will be thrown.
|
||||
|
||||
<h3><a name="pointer_conflict"><code style="white-space: normal">pointer_conflict</code></a></h3>
|
||||
To understand what this exception means consider the following scenario
|
||||
<pre><code>
|
||||
@@ -179,11 +162,7 @@ An attempt has been made to read an array that is larger than the array size.
|
||||
This should only occur when the size of an array in code is reduced after an
|
||||
archive has already been created.
|
||||
|
||||
<h3>
|
||||
<a name="input_stream_error"><code style="white-space: normal">input_stream_error</code></a>
|
||||
<br>
|
||||
<a name="output_stream_error"><code style="white-space: normal">output_stream_error</code></a>
|
||||
</h3>
|
||||
<h3><a name="stream_error"><code style="white-space: normal">stream_error</code></a></h3>
|
||||
An error has occured during stream input or ouput. Aside from the common
|
||||
situations such as a corrupted or truncated input file, there are
|
||||
several less obvious ones that sometimes occur.
|
||||
@@ -237,11 +216,6 @@ is described in <a href="serialization.html#runtimecasting">Runtime Casting</a>.
|
||||
This exception is thrown if an attempt is made to convert between two pointers
|
||||
whose relationship has not been registered,
|
||||
|
||||
<h3><a name="multiple_code_instantiation"><code style="white-space: normal">multiple_code_instantiation</code></a></h3>
|
||||
This exception is thrown when it is detected that the serialization of the same type
|
||||
has been instantiated more 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
|
||||
|
||||
+42
-138
@@ -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 .
|
||||
@@ -105,15 +105,14 @@ protected:
|
||||
// this class can't be used as is. It's just the
|
||||
// common functionality for all type_info replacement
|
||||
// systems. Hence, make these protected
|
||||
extended_type_info(
|
||||
const unsigned int type_info_key,
|
||||
const char * key
|
||||
);
|
||||
const char * m_key;
|
||||
extended_type_info(const unsigned int type_info_key);
|
||||
~extended_type_info();
|
||||
void key_register();
|
||||
void key_unregister();
|
||||
public:
|
||||
const char * get_key() const;
|
||||
void key_register(const char *key);
|
||||
const char * get_key() const {
|
||||
return m_key;
|
||||
}
|
||||
bool operator<(const extended_type_info &rhs) const;
|
||||
bool operator==(const extended_type_info &rhs) const;
|
||||
bool operator!=(const extended_type_info &rhs) const {
|
||||
@@ -140,43 +139,30 @@ the instances contain.
|
||||
<dl>
|
||||
|
||||
<dt><h4><pre><code>
|
||||
extended_type_info(unsigned int type_info_key, const char *key);
|
||||
extended_type_info(unsigned int type_info_key);
|
||||
</code></pre></h4></dt>
|
||||
<dd>
|
||||
This constructor should be called by all derived classes.
|
||||
The first argument should be the particular implementation.
|
||||
For this default implementation base on typeid(), this is the
|
||||
The argument should be the particular implementation. For
|
||||
this default implementation base on typeid(), this is the
|
||||
value 1. Each system must have its own integer. This value
|
||||
is used to permit the inter-operability of different typeinfo
|
||||
systems.
|
||||
<p>
|
||||
The second argument is a const string which is the external
|
||||
name of the type to which this record corresponds.
|
||||
It may sometimes be referred to as a GUID - a <b>G</b>lobal <b>U</b>nique <b>ID</b>entifier.
|
||||
It is passed through archives from one program invocation to
|
||||
another to uniquely identify the types that the archive contains.
|
||||
If the "export" facility is not going to be used,
|
||||
this value may be NULL.
|
||||
</dd>
|
||||
|
||||
<dt><h4><pre><code>
|
||||
void key_register();
|
||||
void key_unregister();
|
||||
void key_register(const char *key);
|
||||
</code></pre></h4></dt>
|
||||
<dd>
|
||||
This system maintains a global table which relates
|
||||
external strings to
|
||||
<code style="white-space: normal">extended_type_info</code> records.
|
||||
This table is used when loading pointers to objects serialized
|
||||
through a base class pointer. In this case, the archive
|
||||
contains a string which is looked up in this table to
|
||||
determine which <code style="white-space: normal">extended_type_info</code>
|
||||
to use for creating a new object.
|
||||
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.
|
||||
<p>
|
||||
These functions are called by constructors and
|
||||
destructors of classes which implement
|
||||
<code style="white-space: normal">extended_type_info</code>
|
||||
to add and remove entries from this table.
|
||||
It may sometimes be referred to as a GUID - a <b>G</b>lobal <b>U</b>nique <b>ID</b>entifier.
|
||||
</dd>
|
||||
|
||||
<dt><h4><pre><code>
|
||||
@@ -193,14 +179,13 @@ bool operator==(const extended_type_info & rhs) const;
|
||||
bool operator!=(const extended_type_info & rhs) const;
|
||||
</code></pre></h4></dt>
|
||||
<dd>
|
||||
These functions are used to compare 'wo
|
||||
These functions are used to compare two
|
||||
<a target="extended_type_info.hpp" href = "../../../boost/serialization/extended_type_info.hpp">
|
||||
<code style="white-space: normal">
|
||||
extended_type_info
|
||||
</code>
|
||||
</a>
|
||||
objects. They impose a strict total ordering on all
|
||||
<code style="white-space: normal">extended_type_info</code> records.
|
||||
objects. They a strict total ordering on all instances of this class.
|
||||
</dd>
|
||||
|
||||
<dt><h4><pre><code>
|
||||
@@ -245,7 +230,7 @@ object.
|
||||
|
||||
</dl>
|
||||
|
||||
<h3><a name="requirements">Requirements for and Implementation</a></h3>
|
||||
<h3><a name="requirements">Requirements</a></h3>
|
||||
In order to be used by the serialization library, an implementation of
|
||||
<code style="white-space: normal">extended_type_info</code>,
|
||||
(referred to as ETI here), must be derived from
|
||||
@@ -258,6 +243,20 @@ and also implement the following:
|
||||
|
||||
<dl>
|
||||
|
||||
<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 *
|
||||
@@ -269,53 +268,18 @@ Return a pointer to the
|
||||
instance that corresponds to
|
||||
the "true type" of the type T. The "true type" is the lowest type in the
|
||||
hierarchy of classes. The type T can always be cast to the "true type" with
|
||||
a static cast. Implementation of this function will vary among type id systems
|
||||
a static cast. Implemention of this function will vary among type id systems
|
||||
and sometimes will make presumptions about the type T than can be identified
|
||||
with a particular <code style="white-space: normal">extended_type_info</code> implementation.
|
||||
</dd>
|
||||
|
||||
<dt><h4><code style="white-space: normal"><pre>
|
||||
virtual bool ETI::is_less_than(const extended_type_info &rhs) const;
|
||||
bool ETI::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>
|
||||
@@ -330,8 +294,7 @@ by the compiler.
|
||||
<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.
|
||||
Instead, it requires that all polymorphic types be explictly exported.
|
||||
In addition, if the export facility is to be used to serialize types
|
||||
However, 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:
|
||||
|
||||
@@ -341,76 +304,17 @@ virtual const char * get_key();
|
||||
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">
|
||||
extended_type_info</a></code> API above to return the export key associated with the class.
|
||||
This requires that non-abstract types be exported. It also demonstrates the
|
||||
This requires that non-abstract types be exported. It also demostrates the
|
||||
inter-operability with between two different implementations of
|
||||
<code style="white-space: normal">extended_type_info</code>.
|
||||
|
||||
<h3><a name="type_requirements">Requirements for Each Type</a></h3>
|
||||
Each type to be managed by the system must be
|
||||
"registered" individually. This is accomplished by instantiating
|
||||
templates. For example, if the type T is to use the type_info system
|
||||
one would include the following code:
|
||||
|
||||
<code style="white-space: normal"><pre>
|
||||
namespace boost {
|
||||
namespace serialization {
|
||||
template
|
||||
struct extended_type_info_typeid>T>;
|
||||
template
|
||||
struct extended_type_info_typeid>const T>;
|
||||
} // serialization
|
||||
} // boost
|
||||
</pre></code>
|
||||
|
||||
For those using the serialization library, this step can be skipped
|
||||
as it is done automatically. The serialization library includes
|
||||
the macro:
|
||||
|
||||
<code style="white-space: normal"><pre>
|
||||
BOOST_CLASS_TYPE_INFO(
|
||||
my_type,
|
||||
extended_type_info_typeid>my_class>
|
||||
)
|
||||
</pre></code>
|
||||
|
||||
which is used to specify which <code>extended_type_info</code> system is to
|
||||
be used for a given type.
|
||||
<p>
|
||||
<code>extended_type_info</code> includes a facility for constructing
|
||||
instances of types without knowing what the exact types are. This is done
|
||||
with the function
|
||||
<code>
|
||||
virtual void * extended_type_info::construct(unsigned int count = 0, ...) const;
|
||||
</code>
|
||||
. For example:
|
||||
<br>
|
||||
<code><pre>
|
||||
struct base {
|
||||
...
|
||||
};
|
||||
struct derived : public base {
|
||||
...
|
||||
};
|
||||
...
|
||||
extended_type_info *eti = extended_type_info::find("my_class")
|
||||
base * b = eti->construct(...);
|
||||
</pre></code>
|
||||
<br>
|
||||
The <code>construct</code> takes an argument count and up to
|
||||
four parameters of any type. The arguments are passed to the
|
||||
constructor of "my_class".
|
||||
|
||||
|
||||
A complete example of this can be found
|
||||
<a target="test_dll_plugin.cpp" href="../test/test_dll_plugin.cpp">here</a>
|
||||
<hr>
|
||||
<p><i>© Copyright <a href="http://www.rrsd.com">Robert Ramey</a> 2005-2009.
|
||||
<p><i>© Copyright <a href="http://www.rrsd.com">Robert Ramey</a> 2005.
|
||||
Distributed under the Boost Software License, Version 1.0. (See
|
||||
accompanying file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
|
||||
</i></p>
|
||||
|
||||
+4
-38
@@ -7,45 +7,11 @@ License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
|
||||
http://www.boost.org/LICENSE_1_0.txt)
|
||||
-->
|
||||
<head>
|
||||
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
|
||||
<link rel="stylesheet" type="text/css" href="../../../boost.css">
|
||||
<link rel="stylesheet" type="text/css" href="style.css">
|
||||
<title>Serialization - Tips and Tricks</title>
|
||||
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
|
||||
<link rel="stylesheet" type="text/css" href="../../../boost.css">
|
||||
<link rel="stylesheet" type="text/css" href="style.css">
|
||||
<title>Serialization - FAQ</title>
|
||||
</head>
|
||||
<body link="#0000ff" vlink="#800080">
|
||||
<table border="0" cellpadding="7" cellspacing="0" width="100%" summary="header">
|
||||
<tr>
|
||||
<td valign="top" width="300">
|
||||
<h3>
|
||||
<a href="../../../index.htm">
|
||||
<img height="86" width="277" alt="C++ Boost" src="../../../boost.png" border="0"></a></h3>
|
||||
</td>
|
||||
<td valign="top">
|
||||
<h1 align="center">
|
||||
Serialization</h1>
|
||||
<h2 align="center">
|
||||
Tips and Tricks</h2>
|
||||
</td>
|
||||
</tr>
|
||||
</table>
|
||||
<hr>
|
||||
This section will be used to list answers to questions raise in the mailing
|
||||
lists. Most of these are due to subtle aspects of the library which are
|
||||
overlooked even though they might be described in the documenation. Often,
|
||||
these issues are very easy to address - but can be excruciating difficult to
|
||||
find. Should you have such an experience, feel free to vent your frustration
|
||||
in a constructive way by adding in your own item. The best way to do this
|
||||
is to create a <a href="http://svn.boost.org/trac/boost/browser">"TRAK" item</a>
|
||||
which includes the text you want to add to this list.
|
||||
|
||||
<ul>
|
||||
<li><h4>
|
||||
</h4></li>
|
||||
</ul>
|
||||
<hr>
|
||||
<p>
|
||||
<i>© Copyright <a href="http://www.rrsd.com">Robert Ramey</a> 2002-2009. Distributed
|
||||
under the Boost Software License, Version 1.0. (See accompanying file LICENSE_1_0.txt
|
||||
or copy at http://www.boost.org/LICENSE_1_0.txt) </i></p>
|
||||
</body>
|
||||
</html>
|
||||
|
||||
+14
-59
@@ -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 .
|
||||
@@ -161,14 +161,13 @@ boost/serialization/export.hpp
|
||||
</a>
|
||||
<dd>For serialization of pointers to derived classes via key export.</dd>
|
||||
|
||||
<dt><a target="assume_abstract" href="../../../boost/serialization/assume_abstract.hpp">
|
||||
boost/serialization/assume_abstract.hpp
|
||||
<dt><a target="is_abstract" href="../../../boost/serialization/is_abstract.hpp">
|
||||
boost/serialization/is_abstract.hpp
|
||||
</a>
|
||||
<dd>This is just a thin wrapper which permits one to explicitly specify that a
|
||||
particular type is an abstract base class. It is necessary to use this
|
||||
for compilers which don't support the boost type traits implementation of
|
||||
is_abstact.
|
||||
</dd>
|
||||
<dd>For serialization of pointers to abstract base classes. A generic implementation
|
||||
of this is functional only on the most modern compilers. This one is just
|
||||
a thin wrapper which permits one to specify "by hand" whether or not a base class
|
||||
is abstract or not.</dd>
|
||||
|
||||
</dl>
|
||||
|
||||
@@ -207,7 +206,7 @@ This group of headers includes templates which implement serialization for Stand
|
||||
Library or Boost Library templates. Any program which uses these templates can
|
||||
invoke serialization of objects of these types just by including the corresponding header.
|
||||
<p>
|
||||
By convention' these header files are named:
|
||||
By convention, these header files are named:
|
||||
|
||||
boost/serialization/xxx.hpp
|
||||
|
||||
@@ -303,7 +302,7 @@ the rest of the library which aids in understanding.
|
||||
<dt><a target="basic_text_oarchive" href="../../../boost/archive/basic_text_oarchive.hpp">
|
||||
boost/archive/basic_text_oarchive.hpp
|
||||
</a>
|
||||
<dt><a target="basic_te't_iarchive" href="../../../boost/archive/basic_text_iarchive.hpp">
|
||||
<dt><a target="basic_text_iarchive" href="../../../boost/archive/basic_text_iarchive.hpp">
|
||||
boost/archive/basic_text_iarchive.hpp
|
||||
</a>
|
||||
</dt>
|
||||
@@ -337,55 +336,11 @@ the interface to the internal implementation details of the library.
|
||||
|
||||
<a name="archiveinternals">
|
||||
<h4>Archive Internals</h4>
|
||||
|
||||
The interface (see <a target="detail" href="archives.html">Archive Concepts</a>)
|
||||
and implementation are factored out into separate classes to minimize code duplication.
|
||||
|
||||
These files are found in the directory
|
||||
<a target="boost_archive_detail" href="../../../boost/archive/detail">boost/archive/detail</a>.
|
||||
These are included as necessary by the archive class implemenations listed above.
|
||||
This has the unfortunate side effect of making the implementation less transparent.
|
||||
The header files in the directory
|
||||
<a target="basic_xml_iarchive" href="../../../boost/archive/detail">boost/archive/detail</a>
|
||||
implement parts of the library itself. The should never need to be changed by users
|
||||
of the library in order to implement either a class serialization or a new
|
||||
archive type. Users should never find it necessary to change these files.
|
||||
<p>
|
||||
The following discussion is based on the
|
||||
<a target="class_diagram" href="class_diagram.html">class diagram</a>.
|
||||
<p>
|
||||
<dt><a target="interface_iarchive" href="../../../boost/archive/detail/interface_iarchive.hpp">
|
||||
boost/archive/detail/interface_iarchive.hpp</a>
|
||||
<dt><a target="interface_iarchive" href="../../../boost/archive/detail/interface_iarchive.hpp">
|
||||
boost/archive/detail/interface_iarchive.hpp</a>
|
||||
<dd>
|
||||
Here are the declarations and definitions which for the
|
||||
<a href="archives.html">archive_concept</a>. This class redirects calls to the
|
||||
archive interface to a function named <code>save_override</code> in the most derived
|
||||
archive class.
|
||||
</dd>
|
||||
<code>save_override</code> is declared and implemented in each class in
|
||||
the archive hierarchy.
|
||||
|
||||
<pre><code>
|
||||
template<class T>
|
||||
void save_override(T & t, BOOST_PFTO int){
|
||||
// All for otherwise unhandled types are forwarded to the base class.
|
||||
// This emulates behavior for function overloading.
|
||||
this->base::save_override(t, 0);
|
||||
}
|
||||
void save_override(const some_type & t, int){
|
||||
// any special handling for some type
|
||||
// this will usually entail forwarding some other operation
|
||||
// in the most derived class.
|
||||
this->This()->...
|
||||
// or in one of its parents basic_text_oprimitive
|
||||
this->This()->save(static_cast<int>(t));
|
||||
}
|
||||
... // other special type handling
|
||||
</code></pre>
|
||||
|
||||
Note the usage of
|
||||
<a target="detail" href="implementation.html#functiontemplateordering">Partial Function Template Ordering</a>
|
||||
to permit the correct save implementation to be selected.
|
||||
</dd>
|
||||
archive type.
|
||||
|
||||
<a name="codemodules">
|
||||
<h4>Archive Library Code Modules</h4>
|
||||
@@ -425,7 +380,7 @@ program which uses xml serialization.
|
||||
<h4>Dataflow Iterators</h4>
|
||||
In the course of developing this library, it became convenient to make a set
|
||||
of composable iterator adaptors for handling archive text. Applications include
|
||||
escaping and unescaping xml text, implementi'g to/from base64 conversion among
|
||||
escaping and unescaping xml text, implementing to/from base64 conversion among
|
||||
others.
|
||||
<p>
|
||||
This is a ripe topic in itself. Its touched upon by the
|
||||
|
||||
@@ -231,7 +231,7 @@ All of the above plus:<br>
|
||||
and use this library with this compiler, one must use version 1.6x rather than the
|
||||
latest version shipped with boost. See <a href="release.html">Release Notes</a>.
|
||||
</ul>
|
||||
<h4><a name="intel80">Intel C++ 8.0</a></h4>
|
||||
<h4><a name="Intel80">Intel C++ 8.0</a></h4>
|
||||
No known issues. All tests compile and run in debug and release modes.
|
||||
|
||||
<h4><a name="vc80">Visual C++ 8.0</a></h4>
|
||||
|
||||
@@ -28,6 +28,9 @@ http://www.boost.org/LICENSE_1_0.txt)
|
||||
<dl class="index">
|
||||
<dt><a href="#Requirements">Requirements</a></dt>
|
||||
<dt><a href="#otherimplementations">Other Implementations</a></dt>
|
||||
<!--
|
||||
<dt><a href="#footnotes">Footnotes</a></dt>
|
||||
-->
|
||||
</dl>
|
||||
<p>Here, we use the term <strong>"serialization"</strong> to mean
|
||||
the reversible deconstruction of an arbitrary set of C++ data structures
|
||||
|
||||
@@ -5,7 +5,7 @@
|
||||
<body bgcolor="#ffffff" text="#000000">
|
||||
<table border="0">
|
||||
<tr>
|
||||
<td><img border="0" src="../../../boost.png" width="277" height="86"></td>
|
||||
<td><img border="0" src="C:/BoostTrunk/boost.png" width="277" height="86"></td>
|
||||
<td>
|
||||
<h1>Library Status: serialization</h1>
|
||||
<b>Run Date:</b> 02:42:48 UTC, Tuesday 10 June 2008
|
||||
|
||||
@@ -31,6 +31,7 @@ http://www.boost.org/LICENSE_1_0.txt)
|
||||
<dt><a href="#archives">Archives are not streams</a></dt>
|
||||
<dt><a href="#strings">Strings are treated specially in text archives</a></dt>
|
||||
<dt><a href="#typeid"><code style="white-space: normal">typeid</code> information is not included in archives</a></dt>
|
||||
<dt><a href="#trap">Compile time trap when saving a non-const value</a></dt>
|
||||
<!--
|
||||
<dt><a href="#footnotes">Footnotes</a></dt>
|
||||
-->
|
||||
@@ -109,6 +110,226 @@ and/or <code style="white-space: normal">export</code> facilities described in t
|
||||
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>
|
||||
|
||||
+93
-200
@@ -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 .
|
||||
@@ -9,95 +9,35 @@ http://www.boost.org/LICENSE_1_0.txt)
|
||||
<head>
|
||||
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
|
||||
<link rel="stylesheet" type="text/css" href="../../../boost.css">
|
||||
<link rel="stylesheet" type="text/css" href="style.css">
|
||||
<title>Serialization - Release Notes</title>
|
||||
<link rel="stylesheet" type="text/css" href="style.css">
|
||||
<title>Serialization - Release Notes</title>
|
||||
</head>
|
||||
<body link="#0000ff" vlink="#800080">
|
||||
<table border="0" cellpadding="7" cellspacing="0" width="100%" summary="header">
|
||||
<tr>
|
||||
<td valign="top" width="300">
|
||||
<h3>
|
||||
<a href="../../../index.htm"><img height="86" width="277" alt="C++ Boost" src="../../../boost.png" border="0"></a></h3>
|
||||
</td>
|
||||
<td valign="top">
|
||||
<h1 align="center">
|
||||
Serialization</h1>
|
||||
<h2 align="center">
|
||||
Release Notes</h2>
|
||||
</td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td valign="top" width="300">
|
||||
<h3><a href="../../../index.htm"><img height="86" width="277" alt="C++ Boost" src="../../../boost.png" border="0"></a></h3>
|
||||
</td>
|
||||
<td valign="top">
|
||||
<h1 align="center">Serialization</h1>
|
||||
<h2 align="center">Release Notes</h2>
|
||||
</td>
|
||||
</tr>
|
||||
</table>
|
||||
<hr>
|
||||
<dl class="index">
|
||||
<dt><a href="#differences_1_43">Differences from version 1.43</a></dt>
|
||||
<dt><a href="#differences_1_42">Differences from version 1.42</a></dt>
|
||||
<dt><a href="#differences_1_41">Differences from version 1.41</a></dt>
|
||||
<dt><a href="#differences_1_40">Differences from version 1.40</a></dt>
|
||||
<dt><a href="#differences_1_39">Differences from version 1.39</a></dt>
|
||||
<dt><a href="#differences_1_37">Differences from version 1.37</a></dt>
|
||||
<dt><a href="#differences_1_35">Differences from version 1.35</a></dt>
|
||||
<dt><a href="#differences_1_34">Differences from version 1.34</a></dt>
|
||||
<dt><a href="#differences_1_33">Differences from version 1.33</a></dt>
|
||||
<dt><a href="#differences_1_32">Differences from version 1.32</a></dt>
|
||||
<dt><a href="#todo">Pending Issues</a></dt>
|
||||
<dt><a href="#requirements">Requirements</a></dt>
|
||||
<dt><a href="#differences_1_35">Differences from version 1.35</a></dt>
|
||||
<dt><a href="#differences_1_34">Differences from version 1.34</a></dt>
|
||||
<dt><a href="#differences_1_33">Differences from version 1.33</a></dt>
|
||||
<dt><a href="#differences_1_32">Differences from version 1.32</a></dt>
|
||||
<dt><a href="#todo">Pending Issues</a></dt>
|
||||
</dl>
|
||||
As of this writing, there are no known bugs. However, due to compiler/library
|
||||
quirks and or bugs, some tests fail with some combinations of compilers and
|
||||
libraries.
|
||||
<h2><a name="differences_1_43"></a>Differences from Boost 1.43</h2>
|
||||
<ul>
|
||||
<li>fixed bug in the serialization of virtual base classes. Due
|
||||
to heroic efforts by Takatoshi Kondo.
|
||||
</ul>
|
||||
<h2><a name="differences_1_42"></a>Differences from Boost 1.42</h2>
|
||||
<ul>
|
||||
<li>fixed failure of shared_ptr serialization when serializing pointers
|
||||
created from enable_shared_from_this.
|
||||
<li>added example for a simple archive which can be used as a debug log.
|
||||
This example illustrates the implemenation of the archive concept to aid
|
||||
understanding required to create one's own archive classes. The resulting
|
||||
archive is useful for debugging in that it only 160 lines of code and is
|
||||
header only - that is, it doesn't required linking to the serialization library.
|
||||
<li>replaced example used to show how to derive from an existing archive.
|
||||
This example creates an XML archive class which doesn't include serialization
|
||||
traits such as class_id, class_version, etc. It might be useful for exporting
|
||||
one's class information to osme XML processor and/or debugging programs.
|
||||
<li>compile time warnings have been implemented to detect practices which
|
||||
though correct, will result in operation or side effects different than
|
||||
a user probably intends.
|
||||
<li>Some memory leaks associated with void_cast have been fixed.
|
||||
</ul>
|
||||
<h2><a name="differences_1_41"></a>Differences from Boost 1.41</h2>
|
||||
<ul>
|
||||
<li>adjustments have been made to minimize compile time warnings.
|
||||
<li>compile time warnings have been implemented to detect practices which
|
||||
though correct, will result in operation or side effects different than
|
||||
a user probably intends.
|
||||
<li>Some memory leaks associated with void_cast have been fixed.
|
||||
</ul>
|
||||
<h2><a name="differences_1_40"></a>Differences from Boost 1.40</h2>
|
||||
This library has been tested against Boost version 1.39 and 1.40.
|
||||
<p>
|
||||
Changes have been made to archive classes included with the library. Users who
|
||||
have used these a guide to making their own archive classes will find that
|
||||
these will likely no longer compile. This can be remedied by making the
|
||||
following changes in the code which instantiates these archive classes.
|
||||
</p>
|
||||
Old Code:<br>
|
||||
<code><pre>
|
||||
...
|
||||
#include <boost/archive/impl/archive_pointer_iserializer.ipp>
|
||||
...
|
||||
template class detail::archive_pointer_iserializer<naked_text_iarchive> ;
|
||||
...
|
||||
template class detail::archive_pointer_iserializer<text_iarchive> ;
|
||||
</pre></code>should be replaced with this new code: <code><pre>
|
||||
#include <boost/archive/impl/archive_serializer_map.ipp>
|
||||
...
|
||||
template class detail::archive_serializer_map<naked_text_iarchive> ;
|
||||
...
|
||||
template class detail::archive_serializer_map<text_iarchive> ;
|
||||
</pre></code>
|
||||
As of this is written, there are no known bugs. However, due to compiler/library quirks and or
|
||||
bugs, some tests fail with some combinations of compilers and libraries.
|
||||
<h2><a name="requirements"></a>Requirements</h2>
|
||||
This library has been tested on Boost version 1.34 and 1.35.
|
||||
|
||||
<!--
|
||||
<p>
|
||||
The serialization library uses the boost spirit package to load XML archives.
|
||||
@@ -115,137 +55,90 @@ If you're not using bjam and the Jamfile to build the library, be sure that
|
||||
the directory which contains the version of spirit you plan to use is placed
|
||||
at the front of the list of include paths.
|
||||
-->
|
||||
<h2><a name="differences_1_39"></a>Differences from Boost 1.39</h2>
|
||||
<ul>
|
||||
<li>
|
||||
It is now possible to serialize an object through a pointer to a class which
|
||||
implements its own <code style="white-space: normal">new/delete</code>
|
||||
operators. This functionaly is not available on some compilers.
|
||||
<li>
|
||||
serialization of polymorphic objects has been sped up considerably.
|
||||
</ul>
|
||||
As of this writing, all bug reports filed as TRAK tickets have been addressed.
|
||||
There are some TRAK tickets pending which would best be described as feature
|
||||
requests. See <a href="#todo">Pending Issues</a>.
|
||||
<h2><a name="differences_1_37"></a>Differences from Boost 1.37</h2>
|
||||
There are no new features in this version. As of this writing, all bug reports
|
||||
filed as TRAK tickets have been addressed. There are some TRAK tickets pending
|
||||
which would best be described as feature requests. See <a href="#todo">Pending
|
||||
Issues</a>.
|
||||
<h2><a name="differences_1_36"></a>Differences from Boost 1.36</h2>
|
||||
There are no new features in this version. As of this writing, all bug reports
|
||||
filed as TRAK tickets have been addressed.
|
||||
|
||||
<h2><a name="differences_1_35"></a>Differences from Boost 1.35</h2>
|
||||
<ul>
|
||||
<li>
|
||||
The library is now thread safe. That is, multiple archives can be open in
|
||||
different threads. This has been implmented with a lock-free algorithm to avoid
|
||||
any performance bottlenecks.
|
||||
<li>
|
||||
Serialization of types defined in shared libraries is now supported. shared
|
||||
libraries (DLLS) can be loaded/unloaded dynamically at runtime. This includes
|
||||
the serialization of instances of abstract base classes so that a program can
|
||||
be written so as to be compatible with as yet undefined and un-implemented
|
||||
code.
|
||||
<li>
|
||||
The extended type info system has been enhanced to in order to implement the
|
||||
above. It is now a general purpose system for creating and casting of types
|
||||
about which is only known a string ID and an abstract base class.
|
||||
<li>
|
||||
All bug reports filed as TRAK tickets have been addressed.
|
||||
<li>
|
||||
As of this writing, the library will fail build on older compilers such as MSVC
|
||||
before version 7.1 and older versions of Borland compilers. This might or might
|
||||
not change in the future.
|
||||
<li>The library is now thread safe. That is, multiple archives can be open
|
||||
in different threads. This has been implmented with a lock-free algorithm
|
||||
to avoid any performance bottlenecks.
|
||||
<li>Serialization of types defined in shared libraries is now supported.
|
||||
shared libraries (DLLS) can be loaded/unloaded dynamically at runtime.
|
||||
This includes the serialization of instances of abstract base classes so that
|
||||
a program can be written so as to be compatible with as yet undefined
|
||||
and un-implemented code.
|
||||
<li>The extended type info system has been enhanced to in order to implement
|
||||
the above. It is now a general purpose system for creating and casting of
|
||||
types about which is only known a string ID and an abstract base class.
|
||||
<li>All bug reports filed as TRAK tickets have been addressed.
|
||||
<li>As of this writing, the library will fail build on older compilers such
|
||||
as MSVC before version 7.1 and older versions of Borland compilers. This
|
||||
might or might not change in the future.
|
||||
</ul>
|
||||
|
||||
<h2><a name="differences_1_34"></a>Differences from Boost 1.34</h2>
|
||||
<ul>
|
||||
<li>
|
||||
Enhanced support for fast serialization for native binary archives. By Mattias
|
||||
Troyer.
|
||||
<li>
|
||||
Improved implementation of "export" functionality. Removes header ordering
|
||||
requirement and eliminates the maintenance of a pre-determined list of "known
|
||||
archives" By David Abrahams.
|
||||
<li>
|
||||
Improved support for STLPort.
|
||||
<li>Enhanced support for fast serialization for native binary archives. By Mattias Troyer.
|
||||
<li>Improved implementation of "export" functionality. Removes header ordering
|
||||
requirement and eliminates the maintenance of a pre-determined list of "known archives"
|
||||
By David Abrahams.
|
||||
<li>Improved support for STLPort.
|
||||
</ul>
|
||||
|
||||
<h2><a name="differences_1_33"></a>Differences from Boost 1.33</h2>
|
||||
<ul>
|
||||
<li>
|
||||
Native Binary archives use the <code style="white-space: normal">std::streambuf</code>
|
||||
interface. This should result in noticeably faster execution in many cases.
|
||||
<li>Native Binary archives use the <code style="white-space: normal">std::streambuf</code> interface.
|
||||
This should result in noticeably faster execution in many cases.
|
||||
</ul>
|
||||
|
||||
<h2><a name="differences_1_32"></a>Differences from Boost 1.32</h2>
|
||||
<ul>
|
||||
<li>
|
||||
Dynamic Linking Library (DLLs and shared libraries) for platforms which support
|
||||
them. See <a href="../../../more/getting_started/windows.html#auto-linking">Automatic
|
||||
Linking on Windows</a>.
|
||||
<li>
|
||||
Implementation of auto-link for compilers which can support this.
|
||||
<li>
|
||||
Better support for <em>Argument Dependent Lookup</em>
|
||||
and two-phase lookup. This results in simpler rules regarding the placing of
|
||||
serialization specializations namespaces.
|
||||
<li>
|
||||
Enhanced documentation to help explain usage of the above.
|
||||
<li>
|
||||
Adjustments to improve support for less conformant compilers.
|
||||
<li>
|
||||
Improved <code>const</code> correctness for save/load operators. Note that this
|
||||
may produce compile time errors in code which compiled without problem in
|
||||
earlier boost releases. In most cases the fix is trivial. In other cases, code
|
||||
should be scrutinized to be sure that it doesn't use the serialization system
|
||||
in a way which may introduce subtle bugs in to the program. A fuller
|
||||
explanation of this issue can be found <a target="detail" href="traits.html#tracking">
|
||||
here</a>.
|
||||
<li>
|
||||
A new implementation of serialization for <code style="white-space: normal">shared_ptr<T></code>.
|
||||
This is compatible with public interface of <code style="white-space: normal">shared_ptr<T></code>
|
||||
so it should be more robust and not have to change in the future. The
|
||||
implementation optionally includes code to load <code style="white-space: normal">shared_ptr<T></code>
|
||||
stored in archives created with boost 1.32. This code is stored in 'he header: <code style="white-space: normal">
|
||||
boost/serialization/shared_ptr_132.hpp</code>. If your application needs to
|
||||
load archives created with boost 1.32 libraries, include the above header
|
||||
before each inclusion of <code style="white-space: normal">boost/serialization/shared_ptr.hpp</code>.
|
||||
<li>
|
||||
More compilers tested and supported.
|
||||
<li>
|
||||
Miscellaneous bug fixes.
|
||||
<li>Dynamic Linking Library (DLLs and shared libraries) for platforms which support them. See
|
||||
<a href="../../../more/getting_started/windows.html#auto-linking">Automatic Linking on Windows</a>.
|
||||
<li>Implementation of auto-link for compilers which can support this.
|
||||
<li>Better support for <em>Argument Dependent Lookup</em> and two-phase lookup.
|
||||
This results in simpler rules regarding the placing of serialization specializations
|
||||
namespaces.
|
||||
<li>Enhanced documentation to help explain usage of the above.
|
||||
<li>Adjustments to improve support for less conformant compilers.
|
||||
<li>Improved <code>const</code> correctness for save/load operators. Note that this may
|
||||
produce compile time errors in code which compiled without problem in earlier boost releases.
|
||||
In most cases the fix is trivial. In other cases, code should be scrutinized to be
|
||||
sure that it doesn't use the serialization system in a way which may introduce subtle bugs in
|
||||
to the program. A fuller explanation of this issue can be found
|
||||
<a target="detail" href="traits.html#tracking">here</a>.
|
||||
<li>A new implementation of serialization for <code style="white-space: normal">shared_ptr<T></code>. This
|
||||
is compatible with public interface of <code style="white-space: normal">shared_ptr<T></code>
|
||||
so it should be more robust and not have to change in the future. The implementation optionally
|
||||
includes code to load <code style="white-space: normal">shared_ptr<T></code> stored in
|
||||
archives created with boost 1.32. This code is stored in the header:
|
||||
<code style="white-space: normal">boost/serialization/shared_ptr_132.hpp</code>. If your application
|
||||
needs to load archives created with boost 1.32 libraries, include the above header
|
||||
before each inclusion of <code style="white-space: normal">boost/serialization/shared_ptr.hpp</code>.
|
||||
<li>More compilers tested and supported.
|
||||
<li>Miscellaneous bug fixes.
|
||||
</ul>
|
||||
|
||||
<h2><a name="todo"></a>Pending issues</h2>
|
||||
<ul>
|
||||
<li>
|
||||
Rvalues cannot be serialized. It would be possible to implement this for
|
||||
untracked types, but this has not been done.
|
||||
<li>
|
||||
Pointers to pointers cannot currently be serialized
|
||||
<li>
|
||||
It's possible that <code style="white-space: normal">std::string</code> and <code style="white-space: normal">
|
||||
std::wstring</code>
|
||||
contain characters such as '\0' and -1 (EOF) which cannot be rendered in text
|
||||
and XML archives without an escape mechanism. Currently there is no such escape
|
||||
mechanism implemented.
|
||||
<li>
|
||||
A subtle error in the implementation of serializaton of <code style="white-space: normal">
|
||||
std::map</code> is fixed in this version. Unfortunately, the fix breaks
|
||||
serialization of <code style="white-space: normal">std::map</code>
|
||||
for those compilers which do not support partial template specialization. Also,
|
||||
types which contain pointers or tracked types might not work correctly.
|
||||
<li>
|
||||
Serialization of virtual base classes relies upon RTTI. It will fail when used on
|
||||
systems which don't have RTTI enabled.
|
||||
</ul>
|
||||
<li>currently can't serialize through a pointer an object a of class
|
||||
that implements its own <code style="white-space: normal">new/delete</code> operators.
|
||||
<li>Its possible that <code style="white-space: normal">std::string</code>
|
||||
and <code style="white-space: normal">std::wstring</code> contain characters such as
|
||||
'\0' and -1 (EOF) which cannot be rendered in text and XML archives without an escape mechanism.
|
||||
Currently there is no such escape mechanism implemented.
|
||||
<li>A subtle error in the implementation of serializaton of <code style="white-space: normal">std::map</code>
|
||||
is fixed in this version. Unfortunately, the fix breaks serialization of
|
||||
<code style="white-space: normal">std::map</code> for those compilers which do not support
|
||||
partial template specialization.
|
||||
</ul>
|
||||
<p>
|
||||
Aside from the above, there are a number of issues related to specific
|
||||
platforms. These are listed in <a href="implementation.html#othercompilerissues">Specific
|
||||
Compiler/Library Issues</a>.
|
||||
<hr>
|
||||
<p>
|
||||
<i>© Copyright <a href="http://www.rrsd.com">Robert Ramey</a> 2002-2009.
|
||||
Distributed under the Boost Software License, Version 1.0. (See accompanying
|
||||
file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) </i>
|
||||
</p>
|
||||
Aside from the above, there are a number of issues related to specific platforms.
|
||||
These are listed in <a href="implementation.html#othercompilerissues">Specific Compiler/Library Issues</a>.
|
||||
|
||||
<hr>
|
||||
<p><i>© Copyright <a href="http://www.rrsd.com">Robert Ramey</a> 2002-2007.
|
||||
Distributed under the Boost Software License, Version 1.0. (See
|
||||
accompanying file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
|
||||
</i></p>
|
||||
</body>
|
||||
</html>
|
||||
|
||||
@@ -1,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 @@ http://www.boost.org/LICENSE_1_0.txt)
|
||||
</dl>
|
||||
<dt><a href="#references">References</a>
|
||||
<dt><a href="#arrays">Arrays</a>
|
||||
<dt><a href="traits.html">Class Serialization Traits</a>
|
||||
<dt><a href="wrappers.html">Serialization Wrappers</a>
|
||||
<dt><a href="traits.html">Class Serialization Traits</a>
|
||||
<dt><a href="#models">Models - Serialization Implementations Included in the Library</a>
|
||||
</dl>
|
||||
|
||||
@@ -794,7 +794,7 @@ class derived : public base {
|
||||
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)
|
||||
)
|
||||
}
|
||||
|
||||
@@ -1,95 +0,0 @@
|
||||
<!doctype HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
|
||||
<html>
|
||||
<!--
|
||||
(C) Copyright 2002-10 Robert Ramey - http://www.rrsd.com .
|
||||
Use, modification and distribution is subject to the Boost Software
|
||||
License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
|
||||
http://www.boost.org/LICENSE_1_0.txt)
|
||||
-->
|
||||
<head>
|
||||
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
|
||||
<link rel="stylesheet" type="text/css" href="../../../boost.css">
|
||||
<link rel="stylesheet" type="text/css" href="style.css">
|
||||
<title>Serialization - Derivation from an Existing Archive</title>
|
||||
</head>
|
||||
<body link="#0000ff" vlink="#800080">
|
||||
<table border="0" cellpadding="7" cellspacing="0" width="100%" summary="header">
|
||||
<tr>
|
||||
<td valign="top" width="300">
|
||||
<h3><a href="../../../index.htm"><img height="86" width="277" alt="C++ Boost" src="../../../boost.png" border="0"></a></h3>
|
||||
</td>
|
||||
<td valign="top">
|
||||
<h1 align="center">Serialization</h1>
|
||||
<h2 align="center">A Simple Logging Archive Class</h2>
|
||||
</td>
|
||||
</tr>
|
||||
</table>
|
||||
<hr>
|
||||
The purpose of this example help clarify the usage of the
|
||||
<a href="archives.html"><strong>Archive Concept</strong></a>
|
||||
so that one can implement his own archive classes.
|
||||
<a href="../example/simple_log_archive.hpp" target="simple_archive_hpp">
|
||||
<code>simple_log_archive.hpp</code></a> implements a simple but useful
|
||||
archive class. This class can be used to send any serializable types
|
||||
on an output text stream in a readable format. Usage of this facility
|
||||
is trivially easy:
|
||||
|
||||
<pre><code>
|
||||
#include "simple_log_archive.hpp"
|
||||
...
|
||||
// display the complete schedule
|
||||
simple_log_archive log(std::cout);
|
||||
log << schedule;
|
||||
</code></pre>
|
||||
|
||||
and it produces the following output
|
||||
|
||||
<pre><code>
|
||||
schedule
|
||||
count 6
|
||||
item
|
||||
first
|
||||
driver bob
|
||||
hour 6
|
||||
minute 24
|
||||
second ->
|
||||
stops
|
||||
count 3
|
||||
item ->
|
||||
latitude
|
||||
degrees 34
|
||||
minutes 135
|
||||
seconds 52.56
|
||||
longitude
|
||||
degrees 134
|
||||
minutes 22
|
||||
seconds 78.3
|
||||
...
|
||||
</code></pre>
|
||||
|
||||
The complete example is <a href="../example/demo_simple_log.cpp" target="demo_simple_log_cpp">
|
||||
<code>demo_simple_log.cpp</code></a>. Look at
|
||||
<a href="archive_reference.html#trivial">Trivial Archive</a> to get a
|
||||
better understanding of how this works.
|
||||
|
||||
Also, note the following:
|
||||
<ul>
|
||||
<li>Only 160 lines of code.
|
||||
<li>Header only - linking with the serialization library not required.
|
||||
<li>Displays ALL <a href="serialization.html"><strong>Serializable</strong></a> types.
|
||||
<li>Lacks some features.
|
||||
<ul>
|
||||
<li>it will not display the data from the derived type given the pointer to a
|
||||
polymorphic base class. That is, only displays the information of the base class.
|
||||
To add that see the next example.
|
||||
<li>doesn't display information serialized as binary data
|
||||
</ul>
|
||||
</ul>
|
||||
|
||||
<hr>
|
||||
<p><i>© Copyright <a href="http://www.rrsd.com">Robert Ramey</a> 2002-2010.
|
||||
Distributed under the Boost Software License, Version 1.0. (See
|
||||
accompanying file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
|
||||
</i></p>
|
||||
</body>
|
||||
</html>
|
||||
+9
-24
@@ -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 .
|
||||
@@ -100,7 +100,6 @@ class singleton : public boost::noncopyable
|
||||
public:
|
||||
static const T & get_const_instance();
|
||||
static T & get_mutable_instance();
|
||||
static bool is_destroyed();
|
||||
};
|
||||
|
||||
} // namespace serialization
|
||||
@@ -110,27 +109,17 @@ public:
|
||||
<dl>
|
||||
|
||||
<dt><h4><pre><code>
|
||||
static const T & get_const_instance();
|
||||
</code></pre></h4></dt>
|
||||
static const T & get_const_instance();</code></pre></h4></dt>
|
||||
<dd>
|
||||
Retrieve a constant reference to the singleton for this type.
|
||||
</dd>
|
||||
|
||||
<dt><h4><pre><code>
|
||||
static T & get_mutable_instance();
|
||||
</code></pre></h4></dt>
|
||||
static T & get_mutable_instance();</code></pre></h4></dt>
|
||||
<dd>
|
||||
Retrieve a mutable reference to the singleton for this type.
|
||||
</dd>
|
||||
|
||||
<dt><h4><pre><code>
|
||||
static bool is_destroyed();
|
||||
</code></pre></h4></dt>
|
||||
<dd>
|
||||
Return <code>true</code> if the destructor on this singleton has been
|
||||
called. Otherwise, return <code>false</code>.
|
||||
</dd>
|
||||
|
||||
</dl>
|
||||
|
||||
<h3><a name="requirements">Requirements</a></h3>
|
||||
@@ -225,25 +214,21 @@ This singleton CAN be safely used in multi-threading applications if one
|
||||
is careful follow a simple rule:
|
||||
<p>
|
||||
<b>Do not call get_mutable_instance when more than one thread is running!</b>
|
||||
<'>
|
||||
<p>
|
||||
All singletons used in the serialization library follow this rule.
|
||||
In order to help detect accidental violations of this rule there
|
||||
exists an singleton lock/unlock functions.
|
||||
<pre><code>
|
||||
void boost::serialization::singleton_module::lock();
|
||||
void boost::serialization::singleton_module::unlock();
|
||||
bool boost::serialization::singleton_module::is_locked();
|
||||
boost::serialization::global_lock::get_mutable_instance().lock();
|
||||
boost::serialization::global_lock::get_mutable_instance().unlock();
|
||||
</code></pre>
|
||||
In a program compiled for debug, any invocation of
|
||||
<code style="white-space: normal">get_mutable_instance()</code>
|
||||
while the library is in a "locked" state will trap in an assertion.
|
||||
The singleton module lock state is initialized as "unlocked" to permit
|
||||
The global_lock state is initialized as "unlocked" to permit
|
||||
alteration of static variables before
|
||||
<code style="white-space: normal">main</code> is called.
|
||||
The <code style="white-space: normal">lock()</code> and
|
||||
<code style="white-space: normal">unlock()</code> are "global"
|
||||
in they affect ALL the singletons defined by this template.
|
||||
All serialization tests invoke <code style="white-space: normal">lock()</code>
|
||||
<code style="white-space: normal">main</code> is called. All
|
||||
serialization tests invoke <code style="white-space: normal">lock()</code>
|
||||
at the start of the progam. For programs compiled in release
|
||||
mode these functions have no effect.
|
||||
|
||||
|
||||
+1
-1
@@ -58,7 +58,7 @@ These rules can make it difficult to use casting with a function template argume
|
||||
Consider the following example:
|
||||
|
||||
<pre><code>
|
||||
#include <boost/serialization/smart_cast.hpp>
|
||||
#include <boost/smart_cast.hpp>
|
||||
|
||||
struct top {
|
||||
};
|
||||
|
||||
+28
-97
@@ -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,7 +36,6 @@ http://www.boost.org/LICENSE_1_0.txt)
|
||||
<dt><a href="#binary_archives">Binary Archives</a>
|
||||
<dt><a href="#xml_archives">XML Archives</a>
|
||||
<dt><a href="#export">Exporting Class Serialization</a>
|
||||
<dt><a href="#static_libraries">Static Libraries and Serialization</a>
|
||||
<dt><a href="#dlls">DLLS - Serialization and Runtime Linking</a>
|
||||
<dt><a href="#plugins">Plugins</a>
|
||||
<dt><a href="#multi_threading">Multi-Threading</a>
|
||||
@@ -340,18 +339,16 @@ This will be true regardless of whether the is part
|
||||
of a stand alone executable, a static library or
|
||||
a dyanmic or shared library.
|
||||
<p>
|
||||
Including
|
||||
Note that 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 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.
|
||||
is invoked. This is different than other serialization
|
||||
traits which would normally be included in same file
|
||||
as the class declaration.
|
||||
|
||||
<p>
|
||||
This system has certain implications for placing code in static or shared
|
||||
@@ -361,6 +358,13 @@ also included. So when building a library, one should include all headers
|
||||
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
|
||||
@@ -379,33 +383,19 @@ includes the extra declarations required by each of these compilers.
|
||||
It's reasonable to expect that future C++ compilers will support
|
||||
these extensions or something equivalent.
|
||||
|
||||
<h3><a name="static_libraries">Static Libraries and Serialization</a></h3>
|
||||
Code for serialization of data types can be saved in libraries
|
||||
just as it can for the rest of the type implementation.
|
||||
This works well, and can save 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
|
||||
<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
|
||||
<a href = "../example/demo_pimpl.cpp" target="demo_pimpl">
|
||||
<code style="white-space: normal">demo_pimpl.cpp</code>
|
||||
</a>,
|
||||
@@ -419,80 +409,21 @@ and
|
||||
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>
|
||||
</a>,
|
||||
and
|
||||
<a href = "../test/dll_a.cpp" target="dll_a">
|
||||
<code style="white-space: normal">dll_a.cpp</code>
|
||||
<a href = "../test/dll_A.cpp" target="dll_A">
|
||||
<code style="white-space: normal">dll_A.cpp</code>
|
||||
</a>
|
||||
where implementation of serializaton is also completely separate
|
||||
from the main program but the code is loaded at runtime. In this
|
||||
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.
|
||||
<p>
|
||||
For best results, write your code to conform to the following
|
||||
guidelines:
|
||||
<ul>
|
||||
<li>Don't include <code>inline</code> code in classes used in DLLS.
|
||||
This will generate duplicate code in the DLLS and mainline. This
|
||||
needlessly duplicates code. Worse, it makes is possible for
|
||||
different versions of the same code exist simultaneously. This
|
||||
type of error turns out to be excruciatingly difficult to debug.
|
||||
Finally, it opens the possibility that module being referred to
|
||||
might be explictly unloaded which would (hopefully) result in
|
||||
a runtime error. This is another bug that is not always
|
||||
reproducible or easy to find. For class member templates use something like
|
||||
|
||||
<pre><code>
|
||||
template<class Archive>
|
||||
void serialize(Archive & ar, const unsigned int version);
|
||||
</code></pre>
|
||||
in the header, and
|
||||
|
||||
<pre><code>
|
||||
template<class Archive>
|
||||
void myclass::serialize(Archive & ar, const unsigned int version){
|
||||
...
|
||||
}
|
||||
|
||||
BOOST_EXPORT_CLASS_IMPLEMENT(my_class)
|
||||
|
||||
#include <boost/archive/text_oarchive>
|
||||
#include <boost/archive/text_iarchive<
|
||||
template myclass::serialize(boost::archive::text_oarchive & ar, const unsigned int version);
|
||||
template myclass::serialize(boost::archive::text_iarchive & ar, const unsigned int version);
|
||||
... // repeat for each archive class to be used.
|
||||
</code></pre>
|
||||
in the implementation file. This will result in generation of all code
|
||||
required in only one place. The library does not detect this type of error for you.
|
||||
<li>If DLLS are to be loaded an unloaded explicitly (e.g. using <code>dlopen</code> in *nix or
|
||||
<code>LoadLibrary</code> in Windows). Try to arrange that they are unloaded in the reverse
|
||||
sequence. This should guarentee that problems are avoided even if the
|
||||
above guidline hasn't been followed.
|
||||
|
||||
</ul>
|
||||
|
||||
<h3><a name="plugins">Plugins</a></h3>
|
||||
In order to implement the library, various facilities for runtime
|
||||
|
||||
@@ -49,7 +49,7 @@ public:
|
||||
</code></pre>
|
||||
|
||||
The complete implementation can be found
|
||||
<a target="state_saver" href="../../../boost/serialization/state_saver.hpp">here</a>
|
||||
<a target="state_saver" href="../../../boost/state_saver.hpp">here</a>
|
||||
|
||||
The following illustrates how this is expected to be used.
|
||||
|
||||
|
||||
@@ -26,7 +26,7 @@ http://www.boost.org/LICENSE_1_0.txt)
|
||||
</table>
|
||||
<hr>
|
||||
|
||||
The header <code><boost/serialization/static_warning.hpp></code> supplies a single macro
|
||||
The header <code><boost/static_warning.hpp></code> supplies a single macro
|
||||
<code style="white-space: normal">BOOST_STATIC_WARNING(x)</code>, which generates a compile time warning message if
|
||||
the integral-constant-expression x is not true.
|
||||
<p>
|
||||
|
||||
@@ -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 .
|
||||
@@ -48,7 +48,7 @@ Usage of BOOST_STRONG_TYPEDEF
|
||||
addresses this.
|
||||
<pre></code>
|
||||
<a target="strong_typedef" href="../../../boost/strong_typedef.hpp">
|
||||
#include <boost/serialization/strong_typedef.hpp>
|
||||
#include <boost/strong_typedef.hpp>
|
||||
</a>
|
||||
|
||||
BOOST_STRONG_TYPEDEF(int, a)
|
||||
|
||||
@@ -6,10 +6,3 @@ pre{
|
||||
MARGIN-LEFT: 0pt;
|
||||
background-color: #EEEEEE;
|
||||
}
|
||||
|
||||
/*
|
||||
(C) Copyright 2008 Robert Ramey - http://www.rrsd.com .
|
||||
Use, modification and distribution is subject to the Boost Software
|
||||
License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
|
||||
http://www.boost.org/LICENSE_1_0.txt)
|
||||
*/
|
||||
+2
-2
@@ -30,7 +30,7 @@ http://www.boost.org/LICENSE_1_0.txt)
|
||||
<dt><a href="#performancetesting">Performance Testing and Profiling</a></dt>
|
||||
<dt><a href="#backversioning">Back Versioning</a></dt>
|
||||
<dt><a href="#nortti">Testing for Environments with No RTTI</a></dt>
|
||||
<dt><a href="new_case_studies.html">Additional Case Studies</a></dt>
|
||||
<dt><a href="new_case_studies.htm">Additional Case Studies</a></dt>
|
||||
</dl>
|
||||
|
||||
These are enhancements that the serialization library needs but have not been done.
|
||||
@@ -62,7 +62,7 @@ I've managed to setup performance profiling using the following:
|
||||
<li>library_status program from the tools/regression/src directory
|
||||
</ul>
|
||||
Invoking profile script produces a
|
||||
<a href="performance_status.html">table</a>
|
||||
<a href=performance_status.html">table</a>
|
||||
which shows the results of each test and links to the actual
|
||||
profile.
|
||||
<p>
|
||||
|
||||
+74
-349
@@ -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,9 +33,7 @@ http://www.boost.org/LICENSE_1_0.txt)
|
||||
<dt><a href="#abstract">Abstract</a>
|
||||
<dt><a href="#typeinfo">Type Information Implementation</a>
|
||||
<dt><a href="#wrappers">Wrappers</a>
|
||||
<dt><a href="#bitwise">Bitwise Serialization</a>
|
||||
<dt><a href="#templates">Template Serialization Traits</a>
|
||||
<dt><a href="#compiletime_messages">Compile Time Warnings and Errors</a>
|
||||
</dl>
|
||||
Serialization of data depends on the type of the data. For example, for
|
||||
primitive types such as an <code style="white-space: normal">int</code>, it wouldn't make sense to save
|
||||
@@ -204,23 +202,13 @@ to automatically track classes used as virtual bases).</i> This
|
||||
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 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.
|
||||
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>
|
||||
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:
|
||||
@@ -234,36 +222,26 @@ statisfactory for our purposes for the following reasons:
|
||||
<li>There might be classes with different names that we want to
|
||||
consider equivalent for purposes of of serialization.
|
||||
</ul>
|
||||
<p>
|
||||
So in the serialization library, this is addressed by invoking
|
||||
<code style="white-space: normal">BOOST_CLASS_EXPORT_KEY2(my_class, "my_class_external_identifier")</code>
|
||||
in the header file which declares he class.
|
||||
So the header file
|
||||
<a href="../../../boost/serialization/export.hpp" target="export_hpp">export.hpp</a>
|
||||
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>
|
||||
In a large majority of applications, the class name works just fine
|
||||
for the external identifier string so the following short cut is
|
||||
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
|
||||
<a href="../../../boost/serialization/export.hpp" target="export_hpp">export.hpp</a>
|
||||
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>
|
||||
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.
|
||||
|
||||
<h3><a name="abstract">Abstract</a></h3>
|
||||
When serializing an object through a pointer to its base class,
|
||||
@@ -375,30 +353,7 @@ BOOST_CLASS_IS_WRAPPER(my_class)
|
||||
</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 <a href="../../../boost/serialization/is_bitwise_serializable.hpp" target="is_bitwise_serializable">is_bitwise_serializable.hpp</a>
|
||||
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
|
||||
@@ -513,291 +468,61 @@ and template parameters should be assigned according to the following table:
|
||||
<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="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:
|
||||
<<<<<<< .working
|
||||
|
||||
<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>
|
||||
<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.
|
||||
|
||||
<dt><h2><a name="object_tracking">object_tracking</a> - warning</h2></dt>
|
||||
<dd>
|
||||
The following code will display a message when compiled:
|
||||
To indicate the possibility of bitwise serialization the type trait defined
|
||||
in the header
|
||||
file <a href="../../../boost/serialization/is_bitwise_serializable.hpp" target="is_bitwise_serializable">is_bitwise_serializable.hpp</a>
|
||||
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>
|
||||
|
||||
<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:
|
||||
<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.
|
||||
|
||||
<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>
|
||||
|
||||
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>
|
||||
To indicate the possibility of bitwise serialization the type trait defined
|
||||
in the header
|
||||
file <a href="../../../boost/serialization/is_bitwise_serializable.hpp" target="is_bitwise_serializable">is_bitwise_serializable.hpp</a>
|
||||
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>
|
||||
|
||||
>>>>>>> .merge-right.r41077
|
||||
<hr>
|
||||
<p><i>© Copyright <a href="http://www.rrsd.com">Robert Ramey</a> 2002-2004 and Matthias Troyer 2006.
|
||||
Distributed under the Boost Software License, Version 1.0. (See
|
||||
|
||||
@@ -0,0 +1,41 @@
|
||||
# Boost serialization Library Build Jamfile
|
||||
# (C) Copyright Robert Ramey 2002-2004.
|
||||
# Use, modification, and distribution are subject to the
|
||||
# Boost Software License, Version 1.0. (See accompanying file
|
||||
# LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
|
||||
#
|
||||
# See http://www.boost.org/libs/serialization for the library home page.
|
||||
|
||||
subproject libs/serialization/example ;
|
||||
|
||||
rule demo-bsl-build ( demo-name )
|
||||
{
|
||||
exe $(demo-name)
|
||||
: # sources
|
||||
$(demo-name).cpp
|
||||
<lib>../build/boost_serialization
|
||||
: # requirements
|
||||
# copy to a path rooted at BOOST_ROOT:
|
||||
<locate>$(BOOST_ROOT)
|
||||
<include>$(BOOST_ROOT)
|
||||
<sysinclude>$(BOOST_ROOT)
|
||||
<borland><*><cxxflags>-w-8080
|
||||
<msvc><release><cxxflags>-Gy
|
||||
<vc7><release><cxxflags>-Gy
|
||||
<vc-7_0><release><cxxflags>-Gy
|
||||
<vc-7_1><release><cxxflags>-Gy
|
||||
: # default build
|
||||
debug
|
||||
;
|
||||
}
|
||||
|
||||
demo-bsl-build demo ;
|
||||
demo-bsl-build demo_auto_ptr ;
|
||||
demo-bsl-build demo_exception ;
|
||||
demo-bsl-build demo_fast_archive ;
|
||||
demo-bsl-build demo_pimpl ;
|
||||
demo-bsl-build demo_portable_archive ;
|
||||
demo-bsl-build demo_shared_ptr ;
|
||||
demo-bsl-build demo_xml ;
|
||||
demo-bsl-build demo_xml_save ;
|
||||
demo-bsl-build demo_xml_load ;
|
||||
+2
-4
@@ -7,7 +7,7 @@
|
||||
# See http://www.boost.org/libs/serialization for the library home page.
|
||||
|
||||
project libs/serialization/example
|
||||
: id serialization_example
|
||||
: id serialization_test
|
||||
: requirements <library>../build//boost_serialization
|
||||
;
|
||||
|
||||
@@ -43,13 +43,11 @@ test-suite "demo-suite" :
|
||||
[ demo_bsl_run demo ]
|
||||
[ demo_bsl_run demo_auto_ptr ]
|
||||
[ demo_bsl_run demo_exception ]
|
||||
[ demo_bsl_run demo_log : log_archive ]
|
||||
[ demo_bsl_run demo_fast_archive ]
|
||||
[ demo_bsl_run demo_pimpl : demo_pimpl_A ]
|
||||
[ demo_bsl_run demo_polymorphic : demo_polymorphic_A ]
|
||||
[ demo_bsl_run demo_portable_archive : portable_binary_iarchive portable_binary_oarchive ]
|
||||
[ demo_bsl_run demo_shared_ptr ]
|
||||
[ demo_bsl_run demo_simple_log ]
|
||||
[ demo_bsl_run demo_trivial_archive ]
|
||||
[ demo_bsl_run demo_xml ]
|
||||
[ demo_bsl_run demo_xml_save ]
|
||||
[ demo_bsl_run demo_xml_load : : <dependency>demo_xml_save ]
|
||||
|
||||
+1
-2
@@ -7,7 +7,6 @@
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
|
||||
#include <cstddef> // NULL
|
||||
#include <iomanip>
|
||||
#include <iostream>
|
||||
#include <fstream>
|
||||
@@ -265,7 +264,7 @@ public:
|
||||
}
|
||||
bus_schedule(){}
|
||||
};
|
||||
BOOST_CLASS_VERSION(bus_schedule::trip_info, 2)
|
||||
BOOST_CLASS_VERSION(bus_schedule, 2)
|
||||
|
||||
std::ostream & operator<<(std::ostream &os, const bus_schedule::trip_info &ti)
|
||||
{
|
||||
|
||||
@@ -8,7 +8,6 @@
|
||||
|
||||
// should pass compilation and execution
|
||||
|
||||
#include <cstddef> // NULL
|
||||
#include <fstream>
|
||||
|
||||
#include <cstdio> // remove
|
||||
|
||||
@@ -62,7 +62,7 @@ private:
|
||||
#endif
|
||||
#if BOOST_WORKAROUND(__BORLANDC__, <= 0x551 )
|
||||
int i;
|
||||
if(BOOST_DEDUCED_TYPENAME Archive::is_saving::value){
|
||||
if(Archive::is_saving::value){
|
||||
i = l;
|
||||
ar & BOOST_SERIALIZATION_NVP(i);
|
||||
}
|
||||
|
||||
@@ -62,7 +62,7 @@ private:
|
||||
#endif
|
||||
#if BOOST_WORKAROUND(__BORLANDC__, <= 0x551 )
|
||||
int i;
|
||||
if(BOOST_DEDUCED_TYPENAME Archive::is_saving::value){
|
||||
if(Archive::is_saving::value){
|
||||
i = l;
|
||||
ar & BOOST_SERIALIZATION_NVP(i);
|
||||
}
|
||||
|
||||
@@ -19,7 +19,6 @@
|
||||
|
||||
#include <algorithm>
|
||||
#include <iostream>
|
||||
#include <cstddef> // NULL
|
||||
#include <fstream>
|
||||
#include <string>
|
||||
|
||||
|
||||
@@ -11,12 +11,11 @@
|
||||
|
||||
#include <boost/static_assert.hpp>
|
||||
#include <boost/type_traits/is_array.hpp>
|
||||
#include <boost/serialization/pfto.hpp>
|
||||
#include <boost/pfto.hpp>
|
||||
|
||||
#define BOOST_ARCHIVE_SOURCE
|
||||
#include <boost/archive/binary_oarchive_impl.hpp>
|
||||
#include <boost/archive/binary_iarchive_impl.hpp>
|
||||
#include <boost/archive/detail/register_archive.hpp>
|
||||
|
||||
// include template definitions for base classes used. Otherwise
|
||||
// you'll get link failure with undefined symbols
|
||||
@@ -25,6 +24,9 @@
|
||||
#include <boost/archive/impl/basic_binary_oarchive.ipp>
|
||||
#include <boost/archive/impl/basic_binary_iarchive.ipp>
|
||||
|
||||
#include <boost/archive/impl/archive_pointer_iserializer.ipp>
|
||||
#include <boost/archive/impl/archive_pointer_oserializer.ipp>
|
||||
|
||||
using namespace boost::archive;
|
||||
|
||||
/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
|
||||
@@ -92,9 +94,6 @@ public:
|
||||
{}
|
||||
};
|
||||
|
||||
// required by export
|
||||
BOOST_SERIALIZATION_REGISTER_ARCHIVE(fast_binary_oarchive)
|
||||
|
||||
/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
|
||||
// "Fast" input binary archive. This is a variation of the native binary
|
||||
class fast_binary_iarchive :
|
||||
@@ -158,9 +157,6 @@ public:
|
||||
{}
|
||||
};
|
||||
|
||||
// required by export
|
||||
BOOST_SERIALIZATION_REGISTER_ARCHIVE(fast_binary_iarchive)
|
||||
|
||||
int main( int argc, char* argv[] )
|
||||
{
|
||||
const int a[3] = {1, 2, 3};
|
||||
|
||||
@@ -10,16 +10,16 @@
|
||||
// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
|
||||
#include <string>
|
||||
#include <iomanip>
|
||||
#include <iostream>
|
||||
#include <fstream>
|
||||
|
||||
#include <boost/serialization/string.hpp>
|
||||
#include <boost/serialization/nvp.hpp>
|
||||
#include <boost/serialization/utility.hpp>
|
||||
#include <boost/serialization/list.hpp>
|
||||
#include <boost/serialization/version.hpp>
|
||||
#include <boost/serialization/assume_abstract.hpp>
|
||||
|
||||
// This illustration models the bus system of a small city.
|
||||
// This includes, multiple bus stops, bus routes and schedules.
|
||||
|
||||
@@ -1,76 +0,0 @@
|
||||
/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
|
||||
//
|
||||
// demo_log.cpp
|
||||
//
|
||||
// (C) Copyright 2009 Robert Ramey - http://www.rrsd.com .
|
||||
// Use, modification and distribution is subject to the Boost Software
|
||||
// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
#include <iostream>
|
||||
#include <cstdio>
|
||||
|
||||
#include "demo_gps.hpp"
|
||||
#include "log_archive.hpp"
|
||||
|
||||
int main(int argc, char *argv[])
|
||||
{
|
||||
// make the schedule
|
||||
bus_schedule schedule;
|
||||
|
||||
// fill in the data
|
||||
// make a few stops
|
||||
bus_stop *bs0 = new bus_stop_corner(
|
||||
gps_position(34, 135, 52.560f),
|
||||
gps_position(134, 22, 78.30f),
|
||||
"24th Street", "10th Avenue"
|
||||
);
|
||||
bus_stop *bs1 = new bus_stop_corner(
|
||||
gps_position(35, 137, 23.456f),
|
||||
gps_position(133, 35, 54.12f),
|
||||
"State street", "Cathedral Vista Lane"
|
||||
);
|
||||
bus_stop *bs2 = new bus_stop_destination(
|
||||
gps_position(35, 136, 15.456f),
|
||||
gps_position(133, 32, 15.300f),
|
||||
"White House"
|
||||
);
|
||||
bus_stop *bs3 = new bus_stop_destination(
|
||||
gps_position(35, 134, 48.789f),
|
||||
gps_position(133, 32, 16.230f),
|
||||
"Lincoln Memorial"
|
||||
);
|
||||
|
||||
// make a routes
|
||||
bus_route route0;
|
||||
route0.append(bs0);
|
||||
route0.append(bs1);
|
||||
route0.append(bs2);
|
||||
|
||||
// add trips to schedule
|
||||
schedule.append("bob", 6, 24, &route0);
|
||||
schedule.append("bob", 9, 57, &route0);
|
||||
schedule.append("alice", 11, 02, &route0);
|
||||
|
||||
// make aother routes
|
||||
bus_route route1;
|
||||
route1.append(bs3);
|
||||
route1.append(bs2);
|
||||
route1.append(bs1);
|
||||
|
||||
// add trips to schedule
|
||||
schedule.append("ted", 7, 17, &route1);
|
||||
schedule.append("ted", 9, 38, &route1);
|
||||
schedule.append("alice", 11, 47, &route1);
|
||||
|
||||
// display the complete schedule
|
||||
log_archive oa(std::cout);
|
||||
//oa << BOOST_SERIALIZATION_NVP(schedule);
|
||||
oa << schedule;
|
||||
|
||||
delete bs0;
|
||||
delete bs1;
|
||||
delete bs2;
|
||||
delete bs3;
|
||||
return 0;
|
||||
}
|
||||
@@ -12,15 +12,16 @@
|
||||
|
||||
#include "demo_polymorphic_A.hpp"
|
||||
|
||||
// explicitly instantiate templates for polymorphic archives
|
||||
// used by this demo.
|
||||
template
|
||||
void A::serialize<boost::archive::polymorphic_iarchive>(
|
||||
boost::archive::polymorphic_iarchive &,
|
||||
const unsigned int
|
||||
);
|
||||
template
|
||||
void A::serialize<boost::archive::polymorphic_oarchive>(
|
||||
boost::archive::polymorphic_oarchive &,
|
||||
const unsigned int
|
||||
);
|
||||
// now we can define the serialization for class A
|
||||
void A::serialize(
|
||||
boost::archive::polymorphic_iarchive & ar,
|
||||
const unsigned int file_version
|
||||
){
|
||||
ar & data;
|
||||
}
|
||||
void A::serialize(
|
||||
boost::archive::polymorphic_oarchive & ar,
|
||||
const unsigned int file_version
|
||||
){
|
||||
ar & data;
|
||||
}
|
||||
|
||||
@@ -20,13 +20,8 @@ class polymorphic_oarchive;
|
||||
|
||||
struct A {
|
||||
// class a contains a pointer to a "hidden" declaration
|
||||
template<class Archive>
|
||||
void serialize(
|
||||
Archive & ar,
|
||||
const unsigned int file_version
|
||||
){
|
||||
ar & data;
|
||||
}
|
||||
void serialize(boost::archive::polymorphic_iarchive & ar, const unsigned int file_version);
|
||||
void serialize(boost::archive::polymorphic_oarchive & ar, const unsigned int file_version);
|
||||
int data;
|
||||
bool operator==(const A & rhs) const {
|
||||
return data == rhs.data;
|
||||
|
||||
@@ -8,10 +8,6 @@
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
// should pass compilation and execution
|
||||
|
||||
// note:: this example can only be built with the static library
|
||||
// (at least with MSVC - due to conflicts related to import of library
|
||||
// code and instantiation of templates.
|
||||
#include <sstream>
|
||||
|
||||
#include "portable_binary_oarchive.hpp"
|
||||
@@ -27,7 +23,6 @@ class A
|
||||
{
|
||||
friend class boost::serialization::access;
|
||||
char c;
|
||||
A *pa;
|
||||
int i;
|
||||
int i2; // special tricky case to check sign extension
|
||||
unsigned int ui;
|
||||
@@ -49,8 +44,7 @@ public:
|
||||
;
|
||||
}
|
||||
A() :
|
||||
c(0xFF & std::rand()),
|
||||
pa(0),
|
||||
c(std::rand()),
|
||||
i(std::rand()),
|
||||
i2(0x80),
|
||||
ui(std::rand()),
|
||||
|
||||
@@ -11,7 +11,6 @@
|
||||
|
||||
#include <iomanip>
|
||||
#include <iostream>
|
||||
#include <cstddef> // NULL
|
||||
#include <fstream>
|
||||
#include <string>
|
||||
|
||||
@@ -82,7 +81,7 @@ void display(boost::shared_ptr<A> &spa, boost::shared_ptr<A> &spa1)
|
||||
std::cout << "unique element count = " << A::count << std::endl;
|
||||
}
|
||||
|
||||
int main(int /* argc */, char * /*argv*/[])
|
||||
int main(int /* argc */, char /* *argv[] */)
|
||||
{
|
||||
std::string filename(boost::archive::tmpdir());
|
||||
filename += "/testfile";
|
||||
|
||||
@@ -1,75 +0,0 @@
|
||||
/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
|
||||
//
|
||||
// demo_log.cpp
|
||||
//
|
||||
// (C) Copyright 2009 Robert Ramey - http://www.rrsd.com .
|
||||
// Use, modification and distribution is subject to the Boost Software
|
||||
// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
#include <iostream>
|
||||
#include <cstdio>
|
||||
|
||||
#include "demo_gps.hpp"
|
||||
#include "simple_log_archive.hpp"
|
||||
|
||||
int main(int argc, char *argv[])
|
||||
{
|
||||
// make the schedule
|
||||
bus_schedule schedule;
|
||||
|
||||
// fill in the data
|
||||
// make a few stops
|
||||
bus_stop *bs0 = new bus_stop_corner(
|
||||
gps_position(34, 135, 52.560f),
|
||||
gps_position(134, 22, 78.30f),
|
||||
"24th Street", "10th Avenue"
|
||||
);
|
||||
bus_stop *bs1 = new bus_stop_corner(
|
||||
gps_position(35, 137, 23.456f),
|
||||
gps_position(133, 35, 54.12f),
|
||||
"State street", "Cathedral Vista Lane"
|
||||
);
|
||||
bus_stop *bs2 = new bus_stop_destination(
|
||||
gps_position(35, 136, 15.456f),
|
||||
gps_position(133, 32, 15.300f),
|
||||
"White House"
|
||||
);
|
||||
bus_stop *bs3 = new bus_stop_destination(
|
||||
gps_position(35, 134, 48.789f),
|
||||
gps_position(133, 32, 16.230f),
|
||||
"Lincoln Memorial"
|
||||
);
|
||||
|
||||
// make a routes
|
||||
bus_route route0;
|
||||
route0.append(bs0);
|
||||
route0.append(bs1);
|
||||
route0.append(bs2);
|
||||
|
||||
// add trips to schedule
|
||||
schedule.append("bob", 6, 24, &route0);
|
||||
schedule.append("bob", 9, 57, &route0);
|
||||
schedule.append("alice", 11, 02, &route0);
|
||||
|
||||
// make aother routes
|
||||
bus_route route1;
|
||||
route1.append(bs3);
|
||||
route1.append(bs2);
|
||||
route1.append(bs1);
|
||||
|
||||
// add trips to schedule
|
||||
schedule.append("ted", 7, 17, &route1);
|
||||
schedule.append("ted", 9, 38, &route1);
|
||||
schedule.append("alice", 11, 47, &route1);
|
||||
|
||||
// display the complete schedule
|
||||
simple_log_archive log(std::cout);
|
||||
log << schedule;
|
||||
|
||||
delete bs0;
|
||||
delete bs1;
|
||||
delete bs2;
|
||||
delete bs3;
|
||||
return 0;
|
||||
}
|
||||
@@ -1,94 +0,0 @@
|
||||
/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
|
||||
//
|
||||
// demo_trivial_archive.cpp
|
||||
//
|
||||
// (C) Copyright 2009 Robert Ramey - http://www.rrsd.com .
|
||||
// Use, modification and distribution is subject to the Boost Software
|
||||
// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
#include <cstddef> // std::size_t
|
||||
#include <boost/mpl/bool.hpp>
|
||||
|
||||
/////////////////////////////////////////////////////////////////////////
|
||||
// class trivial_oarchive
|
||||
class trivial_oarchive {
|
||||
|
||||
public:
|
||||
//////////////////////////////////////////////////////////
|
||||
// public interface used by programs that use the
|
||||
// serialization library
|
||||
typedef boost::mpl::bool_<true> is_saving;
|
||||
typedef boost::mpl::bool_<false> is_loading;
|
||||
template<class T> void register_type(){}
|
||||
template<class T> trivial_oarchive & operator<<(const T & t){
|
||||
return *this;
|
||||
}
|
||||
template<class T> trivial_oarchive & operator&(const T & t){
|
||||
return *this << t;
|
||||
}
|
||||
void save_binary(void *address, std::size_t count){};
|
||||
};
|
||||
|
||||
#include "demo_gps.hpp"
|
||||
|
||||
int main(int argc, char *argv[])
|
||||
{
|
||||
// make the schedule
|
||||
bus_schedule schedule;
|
||||
|
||||
// fill in the data
|
||||
// make a few stops
|
||||
bus_stop *bs0 = new bus_stop_corner(
|
||||
gps_position(34, 135, 52.560f),
|
||||
gps_position(134, 22, 78.30f),
|
||||
"24th Street", "10th Avenue"
|
||||
);
|
||||
bus_stop *bs1 = new bus_stop_corner(
|
||||
gps_position(35, 137, 23.456f),
|
||||
gps_position(133, 35, 54.12f),
|
||||
"State street", "Cathedral Vista Lane"
|
||||
);
|
||||
bus_stop *bs2 = new bus_stop_destination(
|
||||
gps_position(35, 136, 15.456f),
|
||||
gps_position(133, 32, 15.300f),
|
||||
"White House"
|
||||
);
|
||||
bus_stop *bs3 = new bus_stop_destination(
|
||||
gps_position(35, 134, 48.789f),
|
||||
gps_position(133, 32, 16.230f),
|
||||
"Lincoln Memorial"
|
||||
);
|
||||
|
||||
// make a routes
|
||||
bus_route route0;
|
||||
route0.append(bs0);
|
||||
route0.append(bs1);
|
||||
route0.append(bs2);
|
||||
|
||||
// add trips to schedule
|
||||
schedule.append("bob", 6, 24, &route0);
|
||||
schedule.append("bob", 9, 57, &route0);
|
||||
schedule.append("alice", 11, 02, &route0);
|
||||
|
||||
// make aother routes
|
||||
bus_route route1;
|
||||
route1.append(bs3);
|
||||
route1.append(bs2);
|
||||
route1.append(bs1);
|
||||
|
||||
// add trips to schedule
|
||||
schedule.append("ted", 7, 17, &route1);
|
||||
schedule.append("ted", 9, 38, &route1);
|
||||
schedule.append("alice", 11, 47, &route1);
|
||||
|
||||
// display the complete schedule
|
||||
trivial_oarchive ta;
|
||||
ta << schedule;
|
||||
|
||||
delete bs0;
|
||||
delete bs1;
|
||||
delete bs2;
|
||||
delete bs3;
|
||||
return 0;
|
||||
}
|
||||
@@ -1,32 +0,0 @@
|
||||
/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
|
||||
// log_archive.cpp:
|
||||
|
||||
// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
|
||||
// Use, modification and distribution is subject to the Boost Software
|
||||
// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
// See http://www.boost.org for updates, documentation, and revision history.
|
||||
|
||||
#if (defined _MSC_VER) && (_MSC_VER == 1200)
|
||||
# pragma warning (disable : 4786) // too long name, harmless warning
|
||||
#endif
|
||||
|
||||
//#define BOOST_ARCHIVE_SOURCE
|
||||
#include "log_archive.hpp"
|
||||
#include <boost/archive/detail/archive_serializer_map.hpp>
|
||||
|
||||
// explicitly instantiate for this type of xml stream
|
||||
#include <boost/archive/impl/archive_serializer_map.ipp>
|
||||
#include <boost/archive/impl/basic_xml_oarchive.ipp>
|
||||
#include <boost/archive/impl/xml_oarchive_impl.ipp>
|
||||
|
||||
namespace boost {
|
||||
namespace archive {
|
||||
|
||||
template class detail::archive_serializer_map<log_archive>;
|
||||
template class basic_xml_oarchive<log_archive> ;
|
||||
template class xml_oarchive_impl<log_archive> ;
|
||||
|
||||
} // namespace archive
|
||||
} // namespace boost
|
||||
@@ -1,76 +0,0 @@
|
||||
#ifndef LOG_ARCHIVE_HPP
|
||||
#define LOG_ARCHIVE_HPP
|
||||
|
||||
// MS compatible compilers support #pragma once
|
||||
#if defined(_MSC_VER) && (_MSC_VER >= 1020)
|
||||
# pragma once
|
||||
#endif
|
||||
|
||||
/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
|
||||
// log_archive.hpp
|
||||
|
||||
// (C) Copyright 2010 Robert Ramey - http://www.rrsd.com .
|
||||
// Use, modification and distribution is subject to the Boost Software
|
||||
// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
// See http://www.boost.org for updates, documentation, and revision history.
|
||||
|
||||
#include <boost/archive/xml_oarchive.hpp>
|
||||
|
||||
/////////////////////////////////////////////////////////////////////////
|
||||
// log data to an output stream. This illustrates a simpler implemenation
|
||||
// of text output which is useful for getting a formatted display of
|
||||
// any serializable class. Intended to be useful as a debugging aid.
|
||||
class log_archive :
|
||||
/* protected ? */
|
||||
public boost::archive::xml_oarchive_impl<log_archive>
|
||||
{
|
||||
typedef boost::archive::xml_oarchive_impl<log_archive> base;
|
||||
// give serialization implementation access to this clas
|
||||
friend class boost::archive::detail::interface_oarchive<log_archive>;
|
||||
friend class boost::archive::basic_xml_oarchive<log_archive>;
|
||||
friend class boost::archive::save_access;
|
||||
|
||||
/////////////////////////////////////////////////////////////////////
|
||||
// Override functions defined in basic_xml_oarchive
|
||||
|
||||
// Anything not an attribute and not a name-value pair is an
|
||||
// error and should be trapped here. Note the usage of
|
||||
// function argument matching (BOOST_PFTO) to permit usage
|
||||
// with compilers which fail to properly support
|
||||
// function template ordering
|
||||
template<class T>
|
||||
void save_override(T & t, BOOST_PFTO int){
|
||||
// make it a name-value pair and pass it on.
|
||||
// this permits this to be used even with data types which
|
||||
// are not wrapped with the name
|
||||
base::save_override(boost::serialization::make_nvp(NULL, t), 0);
|
||||
}
|
||||
template<class T>
|
||||
void save_override(const boost::serialization::nvp<T> & t, int){
|
||||
// this is here to remove the "const" requirement. Since
|
||||
// this class is to be used only for output, it's not required.
|
||||
base::save_override(t, 0);
|
||||
}
|
||||
// specific overrides for attributes - not name value pairs so we
|
||||
// want to trap them before the above "fall through"
|
||||
// since we don't want to see these in the output - make them no-ops.
|
||||
void save_override(const boost::archive::object_id_type & t, int){}
|
||||
void save_override(const boost::archive::object_reference_type & t, int){}
|
||||
void save_override(const boost::archive::version_type & t, int){}
|
||||
void save_override(const boost::archive::class_id_type & t, int){}
|
||||
void save_override(const boost::archive::class_id_optional_type & t, int){}
|
||||
void save_override(const boost::archive::class_id_reference_type & t, int){}
|
||||
void save_override(const boost::archive::class_name_type & t, int){}
|
||||
void save_override(const boost::archive::tracking_type & t, int){}
|
||||
public:
|
||||
log_archive(std::ostream & os, unsigned int flags = 0) :
|
||||
boost::archive::xml_oarchive_impl<log_archive>(
|
||||
os,
|
||||
flags | boost::archive::no_header
|
||||
)
|
||||
{}
|
||||
};
|
||||
|
||||
#endif // LOG_ARCHIVE_HPP
|
||||
@@ -1,11 +1,6 @@
|
||||
#ifndef PORTABLE_BINARY_ARCHIVE_HPP
|
||||
#define PORTABLE_BINARY_ARCHIVE_HPP
|
||||
|
||||
// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
|
||||
// Use, modification and distribution is subject to the Boost Software
|
||||
// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
// MS compatible compilers support #pragma once
|
||||
#if defined(_MSC_VER) && (_MSC_VER >= 1020)
|
||||
# pragma once
|
||||
@@ -13,7 +8,7 @@
|
||||
|
||||
#include <boost/config.hpp>
|
||||
#include <boost/cstdint.hpp>
|
||||
#include <boost/serialization/pfto.hpp>
|
||||
#include <boost/pfto.hpp>
|
||||
#include <boost/static_assert.hpp>
|
||||
|
||||
#include <climits>
|
||||
|
||||
@@ -10,9 +10,10 @@
|
||||
|
||||
#include <istream>
|
||||
#include <string>
|
||||
//#include <cstring> // memcpy
|
||||
|
||||
#include <boost/detail/endian.hpp>
|
||||
#include <boost/serialization/throw_exception.hpp>
|
||||
#include <boost/throw_exception.hpp>
|
||||
#include <boost/archive/archive_exception.hpp>
|
||||
|
||||
#include "portable_binary_iarchive.hpp"
|
||||
@@ -32,7 +33,7 @@ portable_binary_iarchive::load_impl(boost::intmax_t & l, char maxsize){
|
||||
size = -size;
|
||||
|
||||
if(size > maxsize)
|
||||
boost::serialization::throw_exception(
|
||||
boost::throw_exception(
|
||||
portable_binary_iarchive_exception()
|
||||
);
|
||||
|
||||
@@ -61,7 +62,7 @@ portable_binary_iarchive::load_override(
|
||||
cn.reserve(BOOST_SERIALIZATION_MAX_KEY_SIZE);
|
||||
load_override(cn, 0);
|
||||
if(cn.size() > (BOOST_SERIALIZATION_MAX_KEY_SIZE - 1))
|
||||
boost::serialization::throw_exception(
|
||||
boost::throw_exception(
|
||||
boost::archive::archive_exception(
|
||||
boost::archive::archive_exception::invalid_class_name)
|
||||
);
|
||||
@@ -76,20 +77,20 @@ portable_binary_iarchive::init(unsigned int flags){
|
||||
// read signature in an archive version independent manner
|
||||
std::string file_signature;
|
||||
* this >> file_signature;
|
||||
if(file_signature != boost::archive::BOOST_ARCHIVE_SIGNATURE())
|
||||
boost::serialization::throw_exception(
|
||||
if(file_signature != boost::archive::ARCHIVE_SIGNATURE())
|
||||
boost::throw_exception(
|
||||
boost::archive::archive_exception(
|
||||
boost::archive::archive_exception::invalid_signature
|
||||
)
|
||||
);
|
||||
// make sure the version of the reading archive library can
|
||||
// support the format of the archive being read
|
||||
boost::archive::library_version_type input_library_version;
|
||||
boost::archive::version_type input_library_version;
|
||||
* this >> input_library_version;
|
||||
|
||||
// extra little .t is to get around borland quirk
|
||||
if(boost::archive::BOOST_ARCHIVE_VERSION() < input_library_version)
|
||||
boost::serialization::throw_exception(
|
||||
if(boost::archive::ARCHIVE_VERSION() < input_library_version.t)
|
||||
boost::throw_exception(
|
||||
boost::archive::archive_exception(
|
||||
boost::archive::archive_exception::unsupported_version
|
||||
)
|
||||
@@ -111,16 +112,14 @@ portable_binary_iarchive::init(unsigned int flags){
|
||||
m_flags = x << CHAR_BIT;
|
||||
}
|
||||
|
||||
#include <boost/archive/impl/archive_serializer_map.ipp>
|
||||
// explicitly instantiate for this
|
||||
#include <boost/archive/impl/archive_pointer_iserializer.ipp>
|
||||
#include <boost/archive/impl/basic_binary_iprimitive.ipp>
|
||||
|
||||
namespace boost {
|
||||
namespace archive {
|
||||
|
||||
namespace detail {
|
||||
template class archive_serializer_map<portable_binary_iarchive>;
|
||||
}
|
||||
|
||||
template class detail::archive_pointer_iserializer<portable_binary_iarchive> ;
|
||||
template class basic_binary_iprimitive<
|
||||
portable_binary_iarchive,
|
||||
std::istream::char_type,
|
||||
|
||||
@@ -23,7 +23,6 @@
|
||||
|
||||
#include <istream>
|
||||
#include <boost/serialization/string.hpp>
|
||||
#include <boost/serialization/item_version_type.hpp>
|
||||
#include <boost/archive/archive_exception.hpp>
|
||||
#include <boost/archive/basic_binary_iprimitive.hpp>
|
||||
#include <boost/archive/detail/common_iarchive.hpp>
|
||||
@@ -42,8 +41,7 @@ public:
|
||||
typedef enum {
|
||||
incompatible_integer_size
|
||||
} exception_code;
|
||||
portable_binary_iarchive_exception(exception_code c = incompatible_integer_size ) :
|
||||
boost::archive::archive_exception(boost::archive::archive_exception::other_exception)
|
||||
portable_binary_iarchive_exception(exception_code c = incompatible_integer_size )
|
||||
{}
|
||||
virtual const char *what( ) const throw( )
|
||||
{
|
||||
@@ -51,11 +49,8 @@ public:
|
||||
switch(code){
|
||||
case incompatible_integer_size:
|
||||
msg = "integer cannot be represented";
|
||||
break;
|
||||
default:
|
||||
msg = boost::archive::archive_exception::what();
|
||||
assert(false);
|
||||
break;
|
||||
boost::archive::archive_exception::what();
|
||||
}
|
||||
return msg;
|
||||
}
|
||||
@@ -74,9 +69,9 @@ class portable_binary_iarchive :
|
||||
public boost::archive::detail::common_iarchive<
|
||||
portable_binary_iarchive
|
||||
>
|
||||
,
|
||||
,
|
||||
public boost::archive::detail::shared_ptr_helper
|
||||
{
|
||||
{
|
||||
typedef boost::archive::basic_binary_iprimitive<
|
||||
portable_binary_iarchive,
|
||||
std::istream::char_type,
|
||||
@@ -105,26 +100,7 @@ protected:
|
||||
boost::intmax_t l;
|
||||
load_impl(l, sizeof(T));
|
||||
// use cast to avoid compile time warning
|
||||
//t = static_cast<T>(l);
|
||||
t = T(l);
|
||||
}
|
||||
void load(boost::serialization::item_version_type & t){
|
||||
boost::intmax_t l;
|
||||
load_impl(l, sizeof(boost::serialization::item_version_type));
|
||||
// use cast to avoid compile time warning
|
||||
t = boost::serialization::item_version_type(l);
|
||||
}
|
||||
void load(boost::archive::version_type & t){
|
||||
boost::intmax_t l;
|
||||
load_impl(l, sizeof(boost::archive::version_type));
|
||||
// use cast to avoid compile time warning
|
||||
t = boost::archive::version_type(l);
|
||||
}
|
||||
void load(boost::archive::class_id_type & t){
|
||||
boost::intmax_t l;
|
||||
load_impl(l, sizeof(boost::archive::class_id_type));
|
||||
// use cast to avoid compile time warning
|
||||
t = boost::archive::class_id_type(static_cast<int>(l));
|
||||
t = static_cast<T>(l);
|
||||
}
|
||||
void load(std::string & t){
|
||||
this->primitive_base_t::load(t);
|
||||
|
||||
@@ -59,35 +59,33 @@ portable_binary_oarchive::save_impl(
|
||||
void
|
||||
portable_binary_oarchive::init(unsigned int flags) {
|
||||
if(m_flags == (endian_big | endian_little)){
|
||||
boost::serialization::throw_exception(
|
||||
boost::throw_exception(
|
||||
portable_binary_oarchive_exception()
|
||||
);
|
||||
}
|
||||
if(0 == (flags & boost::archive::no_header)){
|
||||
// write signature in an archive version independent manner
|
||||
const std::string file_signature(
|
||||
boost::archive::BOOST_ARCHIVE_SIGNATURE()
|
||||
boost::archive::ARCHIVE_SIGNATURE()
|
||||
);
|
||||
* this << file_signature;
|
||||
// write library version
|
||||
const boost::archive::library_version_type v(
|
||||
boost::archive::BOOST_ARCHIVE_VERSION()
|
||||
const boost::archive::version_type v(
|
||||
boost::archive::ARCHIVE_VERSION()
|
||||
);
|
||||
* this << v;
|
||||
}
|
||||
save(static_cast<unsigned char>(m_flags >> CHAR_BIT));
|
||||
}
|
||||
|
||||
#include <boost/archive/impl/archive_serializer_map.ipp>
|
||||
// explicitly instantiate for this type of stream
|
||||
#include <boost/archive/impl/archive_pointer_oserializer.ipp>
|
||||
#include <boost/archive/impl/basic_binary_oprimitive.ipp>
|
||||
|
||||
namespace boost {
|
||||
namespace archive {
|
||||
|
||||
namespace detail {
|
||||
template class archive_serializer_map<portable_binary_oarchive>;
|
||||
}
|
||||
|
||||
template class detail::archive_pointer_oserializer<portable_binary_oarchive> ;
|
||||
template class basic_binary_oprimitive<
|
||||
portable_binary_oarchive,
|
||||
std::ostream::char_type,
|
||||
|
||||
@@ -1,167 +0,0 @@
|
||||
#ifndef BOOST_SIMPLE_LOG_ARCHIVE_HPP
|
||||
#define BOOST_SIMPLE_LOG_ARCHIVE_HPP
|
||||
|
||||
// MS compatible compilers support #pragma once
|
||||
#if defined(_MSC_VER) && (_MSC_VER >= 1020)
|
||||
# pragma once
|
||||
#endif
|
||||
|
||||
/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
|
||||
// simple_log_archive.hpp
|
||||
|
||||
// (C) Copyright 2010 Robert Ramey - http://www.rrsd.com .
|
||||
// Use, modification and distribution is subject to the Boost Software
|
||||
// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
// See http://www.boost.org for updates, documentation, and revision history.
|
||||
|
||||
#include <ostream>
|
||||
#include <cstddef> // std::size_t
|
||||
|
||||
#include <boost/config.hpp>
|
||||
#if defined(BOOST_NO_STDC_NAMESPACE)
|
||||
namespace std{
|
||||
using ::size_t;
|
||||
} // namespace std
|
||||
#endif
|
||||
|
||||
#include <boost/type_traits/is_enum.hpp>
|
||||
#include <boost/mpl/bool.hpp>
|
||||
#include <boost/mpl/eval_if.hpp>
|
||||
#include <boost/mpl/int.hpp>
|
||||
#include <boost/mpl/equal_to.hpp>
|
||||
#include <boost/serialization/nvp.hpp>
|
||||
#include <boost/serialization/array.hpp>
|
||||
#include <boost/serialization/string.hpp>
|
||||
#include <boost/serialization/access.hpp>
|
||||
|
||||
/////////////////////////////////////////////////////////////////////////
|
||||
// log data to an output stream. This illustrates a simpler implemenation
|
||||
// of text output which is useful for getting a formatted display of
|
||||
// any serializable class. Intended to be useful as a debugging aid.
|
||||
class simple_log_archive {
|
||||
std::ostream & m_os;
|
||||
unsigned int m_depth;
|
||||
|
||||
template<class Archive>
|
||||
struct save_enum_type {
|
||||
template<class T>
|
||||
static void invoke(Archive &ar, const T &t){
|
||||
ar.m_os << static_cast<int>(t);
|
||||
}
|
||||
};
|
||||
template<class Archive>
|
||||
struct save_primitive {
|
||||
template<class T>
|
||||
static void invoke(Archive & ar, const T & t){
|
||||
ar.m_os << t;
|
||||
}
|
||||
};
|
||||
template<class Archive>
|
||||
struct save_only {
|
||||
template<class T>
|
||||
static void invoke(Archive & ar, const T & t){
|
||||
// make sure call is routed through the highest interface that might
|
||||
// be specialized by the user.
|
||||
boost::serialization::serialize_adl(
|
||||
ar,
|
||||
const_cast<T &>(t),
|
||||
::boost::serialization::version<T>::value
|
||||
);
|
||||
}
|
||||
};
|
||||
template<class T>
|
||||
void save(const T &t){
|
||||
typedef
|
||||
BOOST_DEDUCED_TYPENAME boost::mpl::eval_if<boost::is_enum<T>,
|
||||
boost::mpl::identity<save_enum_type<simple_log_archive> >,
|
||||
//else
|
||||
BOOST_DEDUCED_TYPENAME boost::mpl::eval_if<
|
||||
// if its primitive
|
||||
boost::mpl::equal_to<
|
||||
boost::serialization::implementation_level<T>,
|
||||
boost::mpl::int_<boost::serialization::primitive_type>
|
||||
>,
|
||||
boost::mpl::identity<save_primitive<simple_log_archive> >,
|
||||
// else
|
||||
boost::mpl::identity<save_only<simple_log_archive> >
|
||||
> >::type typex;
|
||||
typex::invoke(*this, t);
|
||||
}
|
||||
#ifndef BOOST_NO_STD_WSTRING
|
||||
void save(const std::wstring &ws){
|
||||
m_os << "wide string types not suported in log archive";
|
||||
}
|
||||
#endif
|
||||
|
||||
public:
|
||||
///////////////////////////////////////////////////
|
||||
// Implement requirements for archive concept
|
||||
|
||||
typedef boost::mpl::bool_<false> is_loading;
|
||||
typedef boost::mpl::bool_<true> is_saving;
|
||||
|
||||
// this can be a no-op since we ignore pointer polymorphism
|
||||
template<class T>
|
||||
void register_type(const T * = NULL){}
|
||||
|
||||
unsigned int get_library_version(){
|
||||
return 0;
|
||||
}
|
||||
|
||||
void
|
||||
save_binary(const void *address, std::size_t count){
|
||||
m_os << "save_binary not implemented";
|
||||
}
|
||||
|
||||
// the << operators
|
||||
template<class T>
|
||||
simple_log_archive & operator<<(T const & t){
|
||||
m_os << ' ';
|
||||
save(t);
|
||||
return * this;
|
||||
}
|
||||
template<class T>
|
||||
simple_log_archive & operator<<(T * const t){
|
||||
m_os << " ->";
|
||||
if(NULL == t)
|
||||
m_os << " null";
|
||||
else
|
||||
*this << * t;
|
||||
return * this;
|
||||
}
|
||||
template<class T, int N>
|
||||
simple_log_archive & operator<<(const T (&t)[N]){
|
||||
return *this << boost::serialization::make_array(
|
||||
static_cast<const T *>(&t[0]),
|
||||
N
|
||||
);
|
||||
}
|
||||
template<class T>
|
||||
simple_log_archive & operator<<(const boost::serialization::nvp<T> & t){
|
||||
m_os << '\n'; // start line with each named object
|
||||
// indent according to object depth
|
||||
for(unsigned int i = 0; i < m_depth; ++i)
|
||||
m_os << ' ';
|
||||
++m_depth;
|
||||
m_os << t.name(); // output the name of the object
|
||||
* this << t.const_value();
|
||||
--m_depth;
|
||||
return * this;
|
||||
}
|
||||
|
||||
// the & operator
|
||||
template<class T>
|
||||
simple_log_archive & operator&(const T & t){
|
||||
return * this << t;
|
||||
}
|
||||
///////////////////////////////////////////////
|
||||
|
||||
simple_log_archive(std::ostream & os) :
|
||||
m_os(os),
|
||||
m_depth(0)
|
||||
{}
|
||||
};
|
||||
|
||||
#endif // BOOST_SIMPLE_LOG_ARCHIVE_HPP
|
||||
@@ -18,21 +18,6 @@
|
||||
|
||||
#include <exception>
|
||||
#include <cassert>
|
||||
#include <string>
|
||||
|
||||
#include <boost/config.hpp>
|
||||
#include <boost/preprocessor/empty.hpp>
|
||||
#include <boost/archive/detail/decl.hpp>
|
||||
|
||||
// note: the only reason this is in here is that windows header
|
||||
// includes #define exception_code _exception_code (arrrgghhhh!).
|
||||
// the most expedient way to address this is be sure that this
|
||||
// header is always included whenever this header file is included.
|
||||
#if defined(BOOST_WINDOWS)
|
||||
#include <excpt.h>
|
||||
#endif
|
||||
|
||||
#include <boost/archive/detail/abi_prefix.hpp> // must be the last header
|
||||
|
||||
namespace boost {
|
||||
namespace archive {
|
||||
@@ -40,7 +25,7 @@ namespace archive {
|
||||
//////////////////////////////////////////////////////////////////////
|
||||
// exceptions thrown by archives
|
||||
//
|
||||
class BOOST_ARCHIVE_DECL(BOOST_PP_EMPTY()) archive_exception :
|
||||
class archive_exception :
|
||||
public virtual std::exception
|
||||
{
|
||||
public:
|
||||
@@ -54,44 +39,77 @@ public:
|
||||
unsupported_version,// archive created with library version
|
||||
// subsequent to this one
|
||||
pointer_conflict, // an attempt has been made to directly
|
||||
// serialize an object which has
|
||||
// already been serialzed through a pointer.
|
||||
// Were this permited, the archive load would result
|
||||
// in the creation of an extra copy of the obect.
|
||||
// serialization::detail an object
|
||||
// after having already serialzed the same
|
||||
// object through a pointer. Were this permited,
|
||||
// it the archive load would result in the
|
||||
// creation of an extra copy of the obect.
|
||||
incompatible_native_format, // attempt to read native binary format
|
||||
// on incompatible platform
|
||||
array_size_too_short,// array being loaded doesn't fit in array allocated
|
||||
input_stream_error, // error on input stream
|
||||
stream_error, // i/o error on stream
|
||||
invalid_class_name, // class name greater than the maximum permitted.
|
||||
// most likely a corrupted archive or an attempt
|
||||
// to insert virus via buffer overrun method.
|
||||
unregistered_cast, // base - derived relationship not registered with
|
||||
unregistered_cast // base - derived relationship not registered with
|
||||
// void_cast_register
|
||||
unsupported_class_version, // type saved with a version # greater than the
|
||||
// one used by the program. This indicates that the proggram
|
||||
// needs to be rebuilt.
|
||||
multiple_code_instantiation, // code for implementing serialization for some
|
||||
// type has been instantiated in more than one module.
|
||||
output_stream_error // error on input stream
|
||||
} exception_code;
|
||||
protected:
|
||||
std::string m_msg;
|
||||
public:
|
||||
exception_code code;
|
||||
archive_exception(
|
||||
exception_code c,
|
||||
const char * e1 = NULL,
|
||||
const char * e2 = NULL
|
||||
);
|
||||
~archive_exception() throw ();
|
||||
virtual const char *what( ) const throw();
|
||||
archive_exception(exception_code c) :
|
||||
code(c)
|
||||
{}
|
||||
virtual const char *what( ) const throw( )
|
||||
{
|
||||
const char *msg = "programming error";
|
||||
switch(code){
|
||||
case no_exception:
|
||||
msg = "uninitialized exception";
|
||||
break;
|
||||
case unregistered_class:
|
||||
msg = "unregistered class";
|
||||
break;
|
||||
case invalid_signature:
|
||||
msg = "invalid signature";
|
||||
break;
|
||||
case unsupported_version:
|
||||
msg = "unsupported version";
|
||||
break;
|
||||
case pointer_conflict:
|
||||
msg = "pointer conflict";
|
||||
break;
|
||||
case incompatible_native_format:
|
||||
msg = "incompatible native format";
|
||||
break;
|
||||
case array_size_too_short:
|
||||
msg = "array size too short";
|
||||
break;
|
||||
case stream_error:
|
||||
msg = "stream error";
|
||||
break;
|
||||
case invalid_class_name:
|
||||
msg = "class name too long";
|
||||
break;
|
||||
case unregistered_cast:
|
||||
msg = "unregistered void cast";
|
||||
break;
|
||||
case other_exception:
|
||||
// if get here - it indicates a derived exception
|
||||
// was sliced by passing by value in catch
|
||||
msg = "unknown derived exception";
|
||||
break;
|
||||
default:
|
||||
assert(false);
|
||||
break;
|
||||
}
|
||||
return msg;
|
||||
}
|
||||
protected:
|
||||
archive_exception();
|
||||
archive_exception() :
|
||||
code(no_exception)
|
||||
{}
|
||||
};
|
||||
|
||||
}// namespace archive
|
||||
}// namespace boost
|
||||
|
||||
#include <boost/archive/detail/abi_suffix.hpp> // pops abi_suffix.hpp pragmas
|
||||
|
||||
#endif //BOOST_ARCHIVE_ARCHIVE_EXCEPTION_HPP
|
||||
|
||||
@@ -16,11 +16,9 @@
|
||||
|
||||
// See http://www.boost.org for updates, documentation, and revision history.
|
||||
|
||||
#include <cassert>
|
||||
#include <boost/config.hpp>
|
||||
#include <boost/cstdint.hpp> // size_t
|
||||
#include <boost/strong_typedef.hpp>
|
||||
#include <boost/noncopyable.hpp>
|
||||
#include <boost/integer_traits.hpp>
|
||||
|
||||
#include <boost/archive/detail/auto_link_archive.hpp>
|
||||
#include <boost/archive/detail/abi_prefix.hpp> // must be the last header
|
||||
@@ -28,159 +26,15 @@
|
||||
namespace boost {
|
||||
namespace archive {
|
||||
|
||||
#if defined(_MSC_VER)
|
||||
#pragma warning( push )
|
||||
#pragma warning( disable : 4244 4267 )
|
||||
#endif
|
||||
|
||||
/* NOTE : Warning : Warning : Warning : Warning : Warning
|
||||
* Don't ever changes this. If you do, they previously created
|
||||
* binary archives won't be readable !!!
|
||||
*/
|
||||
class library_version_type {
|
||||
private:
|
||||
typedef uint_least16_t base_type;
|
||||
base_type t;
|
||||
public:
|
||||
library_version_type(): t(0) {};
|
||||
explicit library_version_type(const unsigned int & t_) : t(t_){
|
||||
assert(t_ <= boost::integer_traits<base_type>::const_max);
|
||||
}
|
||||
library_version_type(const library_version_type & t_) :
|
||||
t(t_.t)
|
||||
{}
|
||||
library_version_type & operator=(const library_version_type & rhs){
|
||||
t = rhs.t;
|
||||
return *this;
|
||||
}
|
||||
// used for text output
|
||||
operator const base_type () const {
|
||||
return t;
|
||||
}
|
||||
// used for text input
|
||||
operator base_type & (){
|
||||
return t;
|
||||
}
|
||||
bool operator==(const library_version_type & rhs) const {
|
||||
return t == rhs.t;
|
||||
}
|
||||
bool operator<(const library_version_type & rhs) const {
|
||||
return t < rhs.t;
|
||||
}
|
||||
};
|
||||
|
||||
BOOST_ARCHIVE_DECL(library_version_type)
|
||||
BOOST_ARCHIVE_VERSION();
|
||||
|
||||
class version_type {
|
||||
private:
|
||||
typedef uint_least32_t base_type;
|
||||
base_type t;
|
||||
public:
|
||||
// should be private - but MPI fails if it's not!!!
|
||||
version_type(): t(0) {};
|
||||
explicit version_type(const unsigned int & t_) : t(t_){
|
||||
assert(t_ <= boost::integer_traits<base_type>::const_max);
|
||||
}
|
||||
version_type(const version_type & t_) :
|
||||
t(t_.t)
|
||||
{}
|
||||
version_type & operator=(const version_type & rhs){
|
||||
t = rhs.t;
|
||||
return *this;
|
||||
}
|
||||
// used for text output
|
||||
operator const base_type () const {
|
||||
return t;
|
||||
}
|
||||
// used for text intput
|
||||
operator base_type & (){
|
||||
return t;
|
||||
}
|
||||
bool operator==(const version_type & rhs) const {
|
||||
return t == rhs.t;
|
||||
}
|
||||
bool operator<(const version_type & rhs) const {
|
||||
return t < rhs.t;
|
||||
}
|
||||
};
|
||||
|
||||
class class_id_type {
|
||||
private:
|
||||
typedef int_least16_t base_type;
|
||||
base_type t;
|
||||
public:
|
||||
// should be private - but then can't use BOOST_STRONG_TYPE below
|
||||
class_id_type() : t(0) {};
|
||||
explicit class_id_type(const int t_) : t(t_){
|
||||
assert(t_ <= boost::integer_traits<base_type>::const_max);
|
||||
}
|
||||
explicit class_id_type(const std::size_t t_) : t(t_){
|
||||
// assert(t_ <= boost::integer_traits<base_type>::const_max);
|
||||
}
|
||||
class_id_type(const class_id_type & t_) :
|
||||
t(t_.t)
|
||||
{}
|
||||
class_id_type & operator=(const class_id_type & rhs){
|
||||
t = rhs.t;
|
||||
return *this;
|
||||
}
|
||||
|
||||
// used for text output
|
||||
operator const int () const {
|
||||
return t;
|
||||
}
|
||||
// used for text input
|
||||
operator int_least16_t &() {
|
||||
return t;
|
||||
}
|
||||
bool operator==(const class_id_type & rhs) const {
|
||||
return t == rhs.t;
|
||||
}
|
||||
bool operator<(const class_id_type & rhs) const {
|
||||
return t < rhs.t;
|
||||
}
|
||||
};
|
||||
|
||||
#define NULL_POINTER_TAG boost::archive::class_id_type(-1)
|
||||
|
||||
class object_id_type {
|
||||
private:
|
||||
typedef uint_least32_t base_type;
|
||||
base_type t;
|
||||
public:
|
||||
object_id_type(): t(0) {};
|
||||
explicit object_id_type(const unsigned int & t_) : t(t_){
|
||||
assert(t_ <= boost::integer_traits<base_type>::const_max);
|
||||
}
|
||||
object_id_type(const object_id_type & t_) :
|
||||
t(t_.t)
|
||||
{}
|
||||
object_id_type & operator=(const object_id_type & rhs){
|
||||
t = rhs.t;
|
||||
return *this;
|
||||
}
|
||||
// used for text output
|
||||
operator const uint_least32_t () const {
|
||||
return t;
|
||||
}
|
||||
// used for text input
|
||||
operator uint_least32_t & () {
|
||||
return t;
|
||||
}
|
||||
bool operator==(const object_id_type & rhs) const {
|
||||
return t == rhs.t;
|
||||
}
|
||||
bool operator<(const object_id_type & rhs) const {
|
||||
return t < rhs.t;
|
||||
}
|
||||
};
|
||||
|
||||
#if defined(_MSC_VER)
|
||||
#pragma warning( pop )
|
||||
#endif
|
||||
BOOST_STRONG_TYPEDEF(unsigned int, version_type)
|
||||
BOOST_STRONG_TYPEDEF(int, class_id_type)
|
||||
BOOST_STRONG_TYPEDEF(int, class_id_optional_type)
|
||||
BOOST_STRONG_TYPEDEF(int, class_id_reference_type)
|
||||
BOOST_STRONG_TYPEDEF(unsigned int, object_id_type)
|
||||
BOOST_STRONG_TYPEDEF(unsigned int, object_reference_type)
|
||||
|
||||
struct tracking_type {
|
||||
typedef bool value_type;
|
||||
bool t;
|
||||
explicit tracking_type(const bool t_ = false)
|
||||
: t(t_)
|
||||
@@ -210,9 +64,7 @@ struct tracking_type {
|
||||
}
|
||||
};
|
||||
|
||||
struct class_name_type :
|
||||
private boost::noncopyable
|
||||
{
|
||||
struct class_name_type : private boost::noncopyable {
|
||||
char *t;
|
||||
operator const char * & () const {
|
||||
return const_cast<const char * &>(t);
|
||||
@@ -238,29 +90,13 @@ enum archive_flags {
|
||||
flags_last = 8
|
||||
};
|
||||
|
||||
#define NULL_POINTER_TAG class_id_type(-1)
|
||||
|
||||
BOOST_ARCHIVE_DECL(const char *)
|
||||
BOOST_ARCHIVE_SIGNATURE();
|
||||
ARCHIVE_SIGNATURE();
|
||||
|
||||
/* NOTE : Warning : Warning : Warning : Warning : Warning
|
||||
* If any of these are changed to different sized types,
|
||||
* binary_iarchive won't be able to read older archives
|
||||
* unless you rev the library version and include conditional
|
||||
* code based on the library version. There is nothing
|
||||
* inherently wrong in doing this - but you have to be super
|
||||
* careful because it's easy to get wrong and start breaking
|
||||
* old archives !!!
|
||||
*/
|
||||
|
||||
#define BOOST_ARCHIVE_STRONG_TYPEDEF(T, D) \
|
||||
class D : public T { \
|
||||
public: \
|
||||
explicit D(const T t) : T(t){} \
|
||||
}; \
|
||||
/**/
|
||||
|
||||
BOOST_ARCHIVE_STRONG_TYPEDEF(class_id_type, class_id_reference_type)
|
||||
BOOST_ARCHIVE_STRONG_TYPEDEF(class_id_type, class_id_optional_type)
|
||||
BOOST_ARCHIVE_STRONG_TYPEDEF(object_id_type, object_reference_type)
|
||||
BOOST_ARCHIVE_DECL(unsigned char)
|
||||
ARCHIVE_VERSION();
|
||||
|
||||
}// namespace archive
|
||||
}// namespace boost
|
||||
@@ -272,7 +108,6 @@ BOOST_ARCHIVE_STRONG_TYPEDEF(object_id_type, object_reference_type)
|
||||
// set implementation level to primitive for all types
|
||||
// used internally by the serialization library
|
||||
|
||||
BOOST_CLASS_IMPLEMENTATION(boost::archive::library_version_type, primitive_type)
|
||||
BOOST_CLASS_IMPLEMENTATION(boost::archive::version_type, primitive_type)
|
||||
BOOST_CLASS_IMPLEMENTATION(boost::archive::class_id_type, primitive_type)
|
||||
BOOST_CLASS_IMPLEMENTATION(boost::archive::class_id_reference_type, primitive_type)
|
||||
|
||||
@@ -25,18 +25,11 @@
|
||||
|
||||
#include <boost/config.hpp>
|
||||
#include <boost/detail/workaround.hpp>
|
||||
#include <boost/serialization/pfto.hpp>
|
||||
#include <boost/pfto.hpp>
|
||||
|
||||
#include <boost/archive/basic_archive.hpp>
|
||||
#include <boost/archive/detail/common_iarchive.hpp>
|
||||
#include <boost/serialization/collection_size_type.hpp>
|
||||
#include <boost/serialization/string.hpp>
|
||||
#include <boost/serialization/item_version_type.hpp>
|
||||
|
||||
#ifdef BOOST_MSVC
|
||||
# pragma warning(push)
|
||||
# pragma warning(disable : 4511 4512)
|
||||
#endif
|
||||
|
||||
#include <boost/archive/detail/abi_prefix.hpp> // must be the last header
|
||||
|
||||
@@ -68,52 +61,51 @@ public:
|
||||
void load_override(T & t, BOOST_PFTO int version){
|
||||
this->detail_common_iarchive::load_override(t, static_cast<int>(version));
|
||||
}
|
||||
|
||||
// include these to trap a change in binary format which
|
||||
// isn't specifically handled
|
||||
BOOST_STATIC_ASSERT(sizeof(tracking_type) == sizeof(char));
|
||||
// upto 32K classes
|
||||
BOOST_STATIC_ASSERT(sizeof(class_id_type) == sizeof(int_least16_t));
|
||||
BOOST_STATIC_ASSERT(sizeof(class_id_reference_type) == sizeof(int_least16_t));
|
||||
// upto 2G objects
|
||||
BOOST_STATIC_ASSERT(sizeof(object_id_type) == sizeof(uint_least32_t));
|
||||
BOOST_STATIC_ASSERT(sizeof(object_reference_type) == sizeof(uint_least32_t));
|
||||
|
||||
// binary files don't include the optional information
|
||||
void load_override(class_id_optional_type & /* t */, int){}
|
||||
|
||||
void load_override(boost::serialization::item_version_type & t, int version){
|
||||
if(library_version_type(6) < this->get_library_version()){
|
||||
this->detail_common_iarchive::load_override(t, version);
|
||||
}
|
||||
else{
|
||||
unsigned int x=0;
|
||||
* this->This() >> x;
|
||||
t = boost::serialization::item_version_type(x);
|
||||
}
|
||||
// the following have been overridden to provide specific sizes
|
||||
// for these pseudo prmitive types.
|
||||
void load_override(version_type & t, int){
|
||||
// upto 255 versions
|
||||
unsigned char x=0;
|
||||
* this->This() >> x;
|
||||
t = version_type(x);
|
||||
}
|
||||
|
||||
void load_override(version_type & t, int version){
|
||||
if(boost::archive::library_version_type(6) < this->get_library_version()){
|
||||
this->detail_common_iarchive::load_override(t, version);
|
||||
}
|
||||
else{
|
||||
unsigned int x=0;
|
||||
* this->This() >> x;
|
||||
t = boost::archive::version_type(x);
|
||||
}
|
||||
void load_override(class_id_type & t, int){
|
||||
// upto 32K classes
|
||||
int_least16_t x=0;
|
||||
* this->This() >> x;
|
||||
t = class_id_type(x);
|
||||
}
|
||||
|
||||
void load_override(serialization::collection_size_type & t, int version){
|
||||
if(boost::archive::library_version_type(5) < this->get_library_version()){
|
||||
this->detail_common_iarchive::load_override(t, version);
|
||||
}
|
||||
else{
|
||||
unsigned int x=0;
|
||||
* this->This() >> x;
|
||||
t = serialization::collection_size_type(x);
|
||||
}
|
||||
void load_override(class_id_reference_type & t, int){
|
||||
// upto 32K classes
|
||||
int_least16_t x=0;
|
||||
* this->This() >> x;
|
||||
t = class_id_reference_type(x);
|
||||
}
|
||||
void load_override(object_id_type & t, int){
|
||||
// upto 2G objects
|
||||
uint_least32_t x=0;
|
||||
* this->This() >> x;
|
||||
t = object_id_type(x);
|
||||
}
|
||||
void load_override(object_reference_type & t, int){
|
||||
// upto 2G objects
|
||||
uint_least32_t x=0;
|
||||
* this->This() >> x;
|
||||
t = object_reference_type(x);
|
||||
}
|
||||
void load_override(tracking_type & t, int){
|
||||
char x=0;
|
||||
* this->This() >> x;
|
||||
t = (0 != x);
|
||||
}
|
||||
void load_override(serialization::collection_size_type & t, int){
|
||||
unsigned int x=0;
|
||||
* this->This() >> x;
|
||||
t = serialization::collection_size_type(x);
|
||||
}
|
||||
|
||||
BOOST_ARCHIVE_OR_WARCHIVE_DECL(void)
|
||||
load_override(class_name_type & t, int);
|
||||
@@ -128,10 +120,6 @@ public:
|
||||
} // namespace archive
|
||||
} // namespace boost
|
||||
|
||||
#ifdef BOOST_MSVC
|
||||
#pragma warning(pop)
|
||||
#endif
|
||||
|
||||
#include <boost/archive/detail/abi_suffix.hpp> // pops abi_suffix.hpp pragmas
|
||||
|
||||
#endif // BOOST_ARCHIVE_BASIC_BINARY_IARCHIVE_HPP
|
||||
|
||||
@@ -45,16 +45,16 @@ namespace std{
|
||||
|
||||
#include <boost/cstdint.hpp>
|
||||
#include <boost/scoped_ptr.hpp>
|
||||
#include <boost/serialization/throw_exception.hpp>
|
||||
#include <boost/integer.hpp>
|
||||
#include <boost/integer_traits.hpp>
|
||||
#include <boost/throw_exception.hpp>
|
||||
//#include <boost/limits.hpp>
|
||||
//#include <boost/io/ios_state.hpp>
|
||||
|
||||
#include <boost/archive/basic_streambuf_locale_saver.hpp>
|
||||
#include <boost/archive/archive_exception.hpp>
|
||||
#include <boost/archive/detail/auto_link_archive.hpp>
|
||||
#include <boost/mpl/placeholders.hpp>
|
||||
#include <boost/serialization/is_bitwise_serializable.hpp>
|
||||
#include <boost/serialization/array.hpp>
|
||||
#include <boost/archive/detail/auto_link_archive.hpp>
|
||||
#include <boost/archive/detail/abi_prefix.hpp> // must be the last header
|
||||
|
||||
namespace boost {
|
||||
@@ -120,17 +120,11 @@ public:
|
||||
~basic_binary_iprimitive();
|
||||
public:
|
||||
// we provide an optimized load for all fundamental types
|
||||
// typedef serialization::is_bitwise_serializable<mpl::_1>
|
||||
// use_array_optimization;
|
||||
struct use_array_optimization {
|
||||
template <class T>
|
||||
#if defined(BOOST_NO_DEPENDENT_NESTED_DERIVATIONS)
|
||||
struct apply {
|
||||
typedef BOOST_DEDUCED_TYPENAME boost::serialization::is_bitwise_serializable<T>::type type;
|
||||
};
|
||||
#else
|
||||
struct apply : public boost::serialization::is_bitwise_serializable<T> {};
|
||||
#endif
|
||||
//typedef serialization::is_bitwise_serializable<mpl::_1>
|
||||
// use_array_optimization;
|
||||
struct use_array_optimization {
|
||||
template <class T>
|
||||
struct apply : public serialization::is_bitwise_serializable<T> {};
|
||||
};
|
||||
|
||||
// the optimized load_array dispatches to load_binary
|
||||
@@ -151,32 +145,25 @@ basic_binary_iprimitive<Archive, Elem, Tr>::load_binary(
|
||||
std::size_t count
|
||||
){
|
||||
// note: an optimizer should eliminate the following for char files
|
||||
assert(
|
||||
static_cast<std::streamsize>(count / sizeof(Elem))
|
||||
<= boost::integer_traits<std::streamsize>::const_max
|
||||
);
|
||||
std::streamsize s = static_cast<std::streamsize>(count / sizeof(Elem));
|
||||
std::streamsize s = count / sizeof(Elem);
|
||||
std::streamsize scount = m_sb.sgetn(
|
||||
static_cast<Elem *>(address),
|
||||
s
|
||||
);
|
||||
if(scount != s)
|
||||
boost::serialization::throw_exception(
|
||||
archive_exception(archive_exception::input_stream_error)
|
||||
if(scount != static_cast<std::streamsize>(s))
|
||||
boost::throw_exception(
|
||||
archive_exception(archive_exception::stream_error)
|
||||
);
|
||||
// note: an optimizer should eliminate the following for char files
|
||||
assert(count % sizeof(Elem) <= boost::integer_traits<std::streamsize>::const_max);
|
||||
s = static_cast<std::streamsize>(count % sizeof(Elem));
|
||||
s = count % sizeof(Elem);
|
||||
if(0 < s){
|
||||
// if(is.fail())
|
||||
// boost::serialization::throw_exception(
|
||||
// archive_exception(archive_exception::stream_error)
|
||||
// );
|
||||
// boost::throw_exception(archive_exception(archive_exception::stream_error));
|
||||
Elem t;
|
||||
scount = m_sb.sgetn(& t, 1);
|
||||
if(scount != 1)
|
||||
boost::serialization::throw_exception(
|
||||
archive_exception(archive_exception::input_stream_error)
|
||||
boost::throw_exception(
|
||||
archive_exception(archive_exception::stream_error)
|
||||
);
|
||||
std::memcpy(static_cast<char*>(address) + (count - s), &t, s);
|
||||
}
|
||||
@@ -185,6 +172,6 @@ basic_binary_iprimitive<Archive, Elem, Tr>::load_binary(
|
||||
} // namespace archive
|
||||
} // namespace boost
|
||||
|
||||
#include <boost/archive/detail/abi_suffix.hpp> // pop pragmas
|
||||
#include <boost/archive/detail/abi_suffix.hpp> // pop pragams
|
||||
|
||||
#endif // BOOST_ARCHIVE_BINARY_IPRIMITIVE_HPP
|
||||
|
||||
@@ -23,25 +23,14 @@
|
||||
// IN GENERAL, ARCHIVES CREATED WITH THIS CLASS WILL NOT BE READABLE
|
||||
// ON PLATFORM APART FROM THE ONE THEY ARE CREATE ON
|
||||
|
||||
#include <cassert>
|
||||
#include <boost/config.hpp>
|
||||
#include <boost/pfto.hpp>
|
||||
|
||||
#include <boost/detail/workaround.hpp>
|
||||
#include <boost/serialization/pfto.hpp>
|
||||
|
||||
#include <boost/integer.hpp>
|
||||
#include <boost/integer_traits.hpp>
|
||||
|
||||
#include <boost/archive/detail/common_oarchive.hpp>
|
||||
#include <boost/serialization/string.hpp>
|
||||
#include <boost/serialization/collection_size_type.hpp>
|
||||
|
||||
#include <boost/archive/detail/abi_prefix.hpp> // must be the last header
|
||||
|
||||
#ifdef BOOST_MSVC
|
||||
# pragma warning(push)
|
||||
# pragma warning(disable : 4511 4512)
|
||||
#endif
|
||||
|
||||
namespace boost {
|
||||
namespace archive {
|
||||
|
||||
@@ -74,28 +63,39 @@ public:
|
||||
this->detail_common_oarchive::save_override(t, static_cast<int>(version));
|
||||
}
|
||||
|
||||
// include these to trap a change in binary format which
|
||||
// isn't specifically handled
|
||||
BOOST_STATIC_ASSERT(sizeof(tracking_type) == sizeof(char));
|
||||
// upto 32K classes
|
||||
BOOST_STATIC_ASSERT(sizeof(class_id_type) == sizeof(int_least16_t));
|
||||
BOOST_STATIC_ASSERT(sizeof(class_id_reference_type) == sizeof(int_least16_t));
|
||||
// upto 2G objects
|
||||
BOOST_STATIC_ASSERT(sizeof(object_id_type) == sizeof(uint_least32_t));
|
||||
BOOST_STATIC_ASSERT(sizeof(object_reference_type) == sizeof(uint_least32_t));
|
||||
|
||||
// binary files don't include the optional information
|
||||
void save_override(const class_id_optional_type & /* t */, int){}
|
||||
|
||||
#if 0 // enable this if we decide to support generation of previous versions
|
||||
void save_override(const boost::archive::version_type & t, int version){
|
||||
if(this->get_library_version() < boost::archive::library_version_type(7)){
|
||||
* this->This() << static_cast<int_least16_t >(t);
|
||||
}
|
||||
else
|
||||
this->detail_common_oarchive::save_override(t, version);
|
||||
void save_override(const version_type & t, int){
|
||||
// upto 255 versions
|
||||
// note:t.t resolves borland ambguity
|
||||
const unsigned char x = t.t;
|
||||
* this->This() << x;
|
||||
}
|
||||
void save_override(const class_id_type & t, int){
|
||||
// upto 32K classes
|
||||
const int_least16_t x = t.t;
|
||||
* this->This() << x;
|
||||
}
|
||||
void save_override(const class_id_reference_type & t, int){
|
||||
// upto 32K classes
|
||||
const int_least16_t x = t.t;
|
||||
* this->This() << x;
|
||||
}
|
||||
void save_override(const object_id_type & t, int){
|
||||
// upto 2G objects
|
||||
const uint_least32_t x = t.t;
|
||||
* this->This() << x;
|
||||
}
|
||||
void save_override(const object_reference_type & t, int){
|
||||
// upto 2G objects
|
||||
uint_least32_t x = t.t;
|
||||
* this->This() << x;
|
||||
}
|
||||
void save_override(const tracking_type & t, int){
|
||||
const char x = t.t;
|
||||
* this->This() << x;
|
||||
}
|
||||
#endif
|
||||
|
||||
// explicitly convert to char * to avoid compile ambiguities
|
||||
void save_override(const class_name_type & t, int){
|
||||
@@ -103,18 +103,12 @@ public:
|
||||
* this->This() << s;
|
||||
}
|
||||
|
||||
#if 0
|
||||
void save_override(const serialization::collection_size_type & t, int){
|
||||
if (get_library_version() < boost::archive::library_version_type(6)){
|
||||
unsigned int x=0;
|
||||
* this->This() >> x;
|
||||
t = serialization::collection_size_type(x);
|
||||
}
|
||||
else{
|
||||
* this->This() >> t;
|
||||
}
|
||||
}
|
||||
#endif
|
||||
// for backward compatibility, 64 bit integer or variable length integer would be preferred
|
||||
unsigned int x = t.t;
|
||||
* this->This() << x;
|
||||
}
|
||||
|
||||
BOOST_ARCHIVE_OR_WARCHIVE_DECL(void)
|
||||
init();
|
||||
|
||||
@@ -126,10 +120,4 @@ public:
|
||||
} // namespace archive
|
||||
} // namespace boost
|
||||
|
||||
#ifdef BOOST_MSVC
|
||||
#pragma warning(pop)
|
||||
#endif
|
||||
|
||||
#include <boost/archive/detail/abi_suffix.hpp> // pops abi_suffix.hpp pragmas
|
||||
|
||||
#endif // BOOST_ARCHIVE_BASIC_BINARY_OARCHIVE_HPP
|
||||
|
||||
@@ -26,9 +26,9 @@
|
||||
#include <iosfwd>
|
||||
#include <cassert>
|
||||
#include <locale>
|
||||
#include <cstddef> // size_t
|
||||
#include <streambuf> // basic_streambuf
|
||||
#include <string>
|
||||
#include <cstddef> // size_t
|
||||
|
||||
#include <boost/config.hpp>
|
||||
#if defined(BOOST_NO_STDC_NAMESPACE)
|
||||
@@ -38,17 +38,17 @@ namespace std{
|
||||
#endif
|
||||
|
||||
#include <boost/cstdint.hpp>
|
||||
#include <boost/integer.hpp>
|
||||
#include <boost/integer_traits.hpp>
|
||||
//#include <boost/limits.hpp>
|
||||
//#include <boost/io/ios_state.hpp>
|
||||
#include <boost/scoped_ptr.hpp>
|
||||
#include <boost/serialization/throw_exception.hpp>
|
||||
#include <boost/throw_exception.hpp>
|
||||
|
||||
#include <boost/archive/basic_streambuf_locale_saver.hpp>
|
||||
#include <boost/archive/archive_exception.hpp>
|
||||
#include <boost/archive/detail/auto_link_archive.hpp>
|
||||
#include <boost/serialization/is_bitwise_serializable.hpp>
|
||||
#include <boost/mpl/placeholders.hpp>
|
||||
#include <boost/serialization/array.hpp>
|
||||
#include <boost/archive/detail/auto_link_archive.hpp>
|
||||
#include <boost/archive/detail/abi_prefix.hpp> // must be the last header
|
||||
|
||||
namespace boost {
|
||||
@@ -116,23 +116,17 @@ public:
|
||||
|
||||
// we provide an optimized save for all fundamental types
|
||||
// typedef serialization::is_bitwise_serializable<mpl::_1>
|
||||
// use_array_optimization;
|
||||
// use_array_optimization;
|
||||
// workaround without using mpl lambdas
|
||||
struct use_array_optimization {
|
||||
template <class T>
|
||||
#if defined(BOOST_NO_DEPENDENT_NESTED_DERIVATIONS)
|
||||
struct apply {
|
||||
typedef BOOST_DEDUCED_TYPENAME boost::serialization::is_bitwise_serializable<T>::type type;
|
||||
};
|
||||
#else
|
||||
struct apply : public boost::serialization::is_bitwise_serializable<T> {};
|
||||
#endif
|
||||
template <class T>
|
||||
struct apply : public serialization::is_bitwise_serializable<T> {};
|
||||
};
|
||||
|
||||
|
||||
// the optimized save_array dispatches to save_binary
|
||||
template <class ValueType>
|
||||
void save_array(boost::serialization::array<ValueType> const& a, unsigned int)
|
||||
void save_array(serialization::array<ValueType> const& a, unsigned int)
|
||||
{
|
||||
save_binary(a.address(),a.count()*sizeof(ValueType));
|
||||
}
|
||||
@@ -154,21 +148,16 @@ basic_binary_oprimitive<Archive, Elem, Tr>::save_binary(
|
||||
// mode where by cr characters recieve special treatment.
|
||||
// be sure that the output stream is opened with ios::binary
|
||||
//if(os.fail())
|
||||
// boost::serialization::throw_exception(
|
||||
// archive_exception(archive_exception::output_stream_error)
|
||||
// );
|
||||
// boost::throw_exception(archive_exception(archive_exception::stream_error));
|
||||
// figure number of elements to output - round up
|
||||
count = ( count + sizeof(Elem) - 1)
|
||||
/ sizeof(Elem);
|
||||
assert(count <= std::size_t(boost::integer_traits<std::streamsize>::const_max));
|
||||
std::streamsize scount = m_sb.sputn(
|
||||
static_cast<const Elem *>(address),
|
||||
static_cast<std::streamsize>(count)
|
||||
count
|
||||
);
|
||||
if(count != static_cast<std::size_t>(scount))
|
||||
boost::serialization::throw_exception(
|
||||
archive_exception(archive_exception::output_stream_error)
|
||||
);
|
||||
boost::throw_exception(archive_exception(archive_exception::stream_error));
|
||||
//os.write(
|
||||
// static_cast<const BOOST_DEDUCED_TYPENAME OStream::char_type *>(address),
|
||||
// count
|
||||
@@ -179,6 +168,6 @@ basic_binary_oprimitive<Archive, Elem, Tr>::save_binary(
|
||||
} //namespace boost
|
||||
} //namespace archive
|
||||
|
||||
#include <boost/archive/detail/abi_suffix.hpp> // pop pragmas
|
||||
#include <boost/archive/detail/abi_suffix.hpp> // pop pragams
|
||||
|
||||
#endif // BOOST_ARCHIVE_BASIC_BINARY_OPRIMITIVE_HPP
|
||||
|
||||
@@ -29,20 +29,11 @@
|
||||
#include <locale> // for std::locale
|
||||
#include <streambuf> // for std::basic_streambuf
|
||||
|
||||
#include <boost/config.hpp>
|
||||
#include <boost/noncopyable.hpp>
|
||||
|
||||
#ifdef BOOST_MSVC
|
||||
# pragma warning(push)
|
||||
# pragma warning(disable : 4511 4512)
|
||||
#endif
|
||||
|
||||
namespace boost{
|
||||
namespace archive{
|
||||
|
||||
template < typename Ch, class Tr >
|
||||
class basic_streambuf_locale_saver :
|
||||
private boost::noncopyable
|
||||
class basic_streambuf_locale_saver
|
||||
{
|
||||
public:
|
||||
typedef ::std::basic_streambuf<Ch, Tr> state_type;
|
||||
@@ -65,9 +56,5 @@ private:
|
||||
} // archive
|
||||
} // boost
|
||||
|
||||
#ifdef BOOST_MSVC
|
||||
#pragma warning(pop)
|
||||
#endif
|
||||
|
||||
#endif // BOOST_NO_STD_LOCALE
|
||||
#endif // BOOST_ARCHIVE_BASIC_STREAMBUF_LOCALE_SAVER_HPP
|
||||
|
||||
@@ -25,18 +25,14 @@
|
||||
// use two template parameters
|
||||
|
||||
#include <boost/config.hpp>
|
||||
#include <boost/serialization/pfto.hpp>
|
||||
#include <boost/pfto.hpp>
|
||||
#include <boost/detail/workaround.hpp>
|
||||
|
||||
#include <boost/archive/detail/common_iarchive.hpp>
|
||||
#include <boost/serialization/string.hpp>
|
||||
|
||||
#include <boost/archive/detail/abi_prefix.hpp> // must be the last header
|
||||
|
||||
#ifdef BOOST_MSVC
|
||||
# pragma warning(push)
|
||||
# pragma warning(disable : 4511 4512)
|
||||
#endif
|
||||
|
||||
namespace boost {
|
||||
namespace archive {
|
||||
|
||||
@@ -61,7 +57,8 @@ public:
|
||||
// template ordering
|
||||
typedef detail::common_iarchive<Archive> detail_common_iarchive;
|
||||
template<class T>
|
||||
void load_override(T & t, BOOST_PFTO int){
|
||||
void load_override(T & t, BOOST_PFTO int)
|
||||
{
|
||||
this->detail_common_iarchive::load_override(t, 0);
|
||||
}
|
||||
// text file don't include the optional information
|
||||
@@ -82,10 +79,6 @@ public:
|
||||
} // namespace archive
|
||||
} // namespace boost
|
||||
|
||||
#ifdef BOOST_MSVC
|
||||
#pragma warning(pop)
|
||||
#endif
|
||||
|
||||
#include <boost/archive/detail/abi_suffix.hpp> // pops abi_suffix.hpp pragmas
|
||||
|
||||
#endif // BOOST_ARCHIVE_BASIC_TEXT_IARCHIVE_HPP
|
||||
|
||||
@@ -16,11 +16,11 @@
|
||||
|
||||
// See http://www.boost.org for updates, documentation, and revision history.
|
||||
|
||||
// archives stored as text - note these are templated on the basic
|
||||
// archives stored as text - note these ar templated on the basic
|
||||
// stream templates to accommodate wide (and other?) kind of characters
|
||||
//
|
||||
// Note the fact that on libraries without wide characters, ostream is
|
||||
// not a specialization of basic_ostream which in fact is not defined
|
||||
// note the fact that on libraries without wide characters, ostream is
|
||||
// is not a specialization of basic_ostream which in fact is not defined
|
||||
// in such cases. So we can't use basic_ostream<IStream::char_type> but rather
|
||||
// use two template parameters
|
||||
|
||||
@@ -43,14 +43,13 @@ namespace std{
|
||||
#include <boost/archive/dinkumware.hpp>
|
||||
#endif
|
||||
|
||||
#include <boost/throw_exception.hpp>
|
||||
#include <boost/limits.hpp>
|
||||
#include <boost/io/ios_state.hpp>
|
||||
#include <boost/scoped_ptr.hpp>
|
||||
#include <boost/static_assert.hpp>
|
||||
|
||||
#include <boost/serialization/throw_exception.hpp>
|
||||
#include <boost/archive/archive_exception.hpp>
|
||||
#include <boost/archive/basic_streambuf_locale_saver.hpp>
|
||||
|
||||
#include <boost/archive/detail/abi_prefix.hpp> // must be the last header
|
||||
|
||||
namespace boost {
|
||||
@@ -58,11 +57,6 @@ namespace archive {
|
||||
|
||||
/////////////////////////////////////////////////////////////////////////
|
||||
// class basic_text_iarchive - load serialized objects from a input text stream
|
||||
#if defined(_MSC_VER)
|
||||
#pragma warning( push )
|
||||
#pragma warning( disable : 4244 4267 )
|
||||
#endif
|
||||
|
||||
template<class IStream>
|
||||
class basic_text_iprimitive
|
||||
{
|
||||
@@ -77,50 +71,50 @@ public:
|
||||
|
||||
#ifndef BOOST_NO_STD_LOCALE
|
||||
boost::scoped_ptr<std::locale> archive_locale;
|
||||
basic_streambuf_locale_saver<
|
||||
BOOST_DEDUCED_TYPENAME IStream::char_type,
|
||||
BOOST_DEDUCED_TYPENAME IStream::traits_type
|
||||
io::basic_ios_locale_saver<
|
||||
BOOST_DEDUCED_TYPENAME IStream::char_type, BOOST_DEDUCED_TYPENAME IStream::traits_type
|
||||
> locale_saver;
|
||||
#endif
|
||||
|
||||
template<class T>
|
||||
void load(T & t)
|
||||
{
|
||||
if(! is.fail()){
|
||||
is >> t;
|
||||
return;
|
||||
}
|
||||
boost::serialization::throw_exception(
|
||||
archive_exception(archive_exception::input_stream_error)
|
||||
);
|
||||
}
|
||||
|
||||
void load(char & t)
|
||||
{
|
||||
short int i;
|
||||
load(i);
|
||||
t = i;
|
||||
}
|
||||
void load(signed char & t)
|
||||
{
|
||||
short int i;
|
||||
load(i);
|
||||
t = i;
|
||||
if(is.fail())
|
||||
boost::throw_exception(archive_exception(archive_exception::stream_error));
|
||||
is >> t;
|
||||
}
|
||||
void load(unsigned char & t)
|
||||
{
|
||||
if(is.fail())
|
||||
boost::throw_exception(archive_exception(archive_exception::stream_error));
|
||||
unsigned short int i;
|
||||
load(i);
|
||||
t = i;
|
||||
is >> i;
|
||||
t = static_cast<unsigned char>(i);
|
||||
}
|
||||
void load(signed char & t)
|
||||
{
|
||||
if(is.fail())
|
||||
boost::throw_exception(archive_exception(archive_exception::stream_error));
|
||||
signed short int i;
|
||||
is >> i;
|
||||
t = static_cast<signed char>(i);
|
||||
}
|
||||
void load(char & t)
|
||||
{
|
||||
if(is.fail())
|
||||
boost::throw_exception(archive_exception(archive_exception::stream_error));
|
||||
short int i;
|
||||
is >> i;
|
||||
t = static_cast<char>(i);
|
||||
}
|
||||
|
||||
#ifndef BOOST_NO_INTRINSIC_WCHAR_T
|
||||
void load(wchar_t & t)
|
||||
{
|
||||
BOOST_STATIC_ASSERT(sizeof(wchar_t) <= sizeof(int));
|
||||
int i;
|
||||
load(i);
|
||||
t = i;
|
||||
if(is.fail())
|
||||
boost::throw_exception(archive_exception(archive_exception::stream_error));
|
||||
unsigned i;
|
||||
is >> i;
|
||||
t = static_cast<wchar_t>(i);
|
||||
}
|
||||
#endif
|
||||
BOOST_ARCHIVE_OR_WARCHIVE_DECL(BOOST_PP_EMPTY())
|
||||
@@ -132,13 +126,9 @@ public:
|
||||
load_binary(void *address, std::size_t count);
|
||||
};
|
||||
|
||||
#if defined(_MSC_VER)
|
||||
#pragma warning( pop )
|
||||
#endif
|
||||
|
||||
} // namespace archive
|
||||
} // namespace boost
|
||||
|
||||
#include <boost/archive/detail/abi_suffix.hpp> // pop pragmas
|
||||
#include <boost/archive/detail/abi_suffix.hpp> // pop pragams
|
||||
|
||||
#endif // BOOST_ARCHIVE_BASIC_TEXT_IPRIMITIVE_HPP
|
||||
|
||||
@@ -26,7 +26,7 @@
|
||||
|
||||
#include <cassert>
|
||||
#include <boost/config.hpp>
|
||||
#include <boost/serialization/pfto.hpp>
|
||||
#include <boost/pfto.hpp>
|
||||
#include <boost/detail/workaround.hpp>
|
||||
|
||||
#include <boost/archive/detail/common_oarchive.hpp>
|
||||
@@ -34,11 +34,6 @@
|
||||
|
||||
#include <boost/archive/detail/abi_prefix.hpp> // must be the last header
|
||||
|
||||
#ifdef BOOST_MSVC
|
||||
# pragma warning(push)
|
||||
# pragma warning(disable : 4511 4512)
|
||||
#endif
|
||||
|
||||
namespace boost {
|
||||
namespace archive {
|
||||
|
||||
@@ -83,7 +78,34 @@ public:
|
||||
// start new objects on a new line
|
||||
void save_override(const object_id_type & t, int){
|
||||
this->This()->newline();
|
||||
this->detail_common_oarchive::save_override(t, 0);
|
||||
// note extra .t to funciton with Borland 5.51 compiler
|
||||
// and invoke prmitive to underlying value
|
||||
this->This()->save(t.t);
|
||||
}
|
||||
|
||||
void save_override(const object_reference_type & t, int){
|
||||
this->This()->newline();
|
||||
// note extra .t to funciton with Borland 5.51 compiler
|
||||
// and invoke prmitive to underlying value
|
||||
this->This()->save(t.t);
|
||||
}
|
||||
|
||||
// note the following four overrides are necessary for some borland
|
||||
// compilers(5.51) which don't handle BOOST_STRONG_TYPE properly.
|
||||
void save_override(const version_type & t, int){
|
||||
// note:t.t resolves borland ambguity
|
||||
const unsigned int x = t.t;
|
||||
* this->This() << x;
|
||||
}
|
||||
void save_override(const class_id_type & t, int){
|
||||
// note:t.t resolves borland ambguity
|
||||
const int x = t.t;
|
||||
* this->This() << x;
|
||||
}
|
||||
void save_override(const class_id_reference_type & t, int){
|
||||
// note:t.t resolves borland ambguity
|
||||
const int x = t.t;
|
||||
* this->This() << x;
|
||||
}
|
||||
|
||||
// text file don't include the optional information
|
||||
@@ -107,10 +129,6 @@ public:
|
||||
} // namespace archive
|
||||
} // namespace boost
|
||||
|
||||
#ifdef BOOST_MSVC
|
||||
#pragma warning(pop)
|
||||
#endif
|
||||
|
||||
#include <boost/archive/detail/abi_suffix.hpp> // pops abi_suffix.hpp pragmas
|
||||
|
||||
#endif // BOOST_ARCHIVE_BASIC_TEXT_OARCHIVE_HPP
|
||||
|
||||
@@ -26,12 +26,11 @@
|
||||
|
||||
#include <iomanip>
|
||||
#include <locale>
|
||||
#include <boost/config/no_tr1/cmath.hpp> // isnan
|
||||
#include <cassert>
|
||||
#include <cstddef> // size_t
|
||||
#include <cmath> // isnan
|
||||
#include <cassert>
|
||||
|
||||
#include <boost/config.hpp>
|
||||
#include <boost/static_assert.hpp>
|
||||
#include <boost/detail/workaround.hpp>
|
||||
#if BOOST_WORKAROUND(BOOST_DINKUMWARE_STDLIB, == 1)
|
||||
#include <boost/archive/dinkumware.hpp>
|
||||
@@ -47,12 +46,11 @@ namespace std{
|
||||
#endif
|
||||
|
||||
#include <boost/limits.hpp>
|
||||
#include <boost/integer.hpp>
|
||||
#include <boost/io/ios_state.hpp>
|
||||
#include <boost/scoped_ptr.hpp>
|
||||
#include <boost/serialization/throw_exception.hpp>
|
||||
#include <boost/throw_exception.hpp>
|
||||
#include <boost/archive/archive_exception.hpp>
|
||||
#include <boost/archive/basic_streambuf_locale_saver.hpp>
|
||||
|
||||
#include <boost/archive/detail/abi_prefix.hpp> // must be the last header
|
||||
|
||||
namespace boost {
|
||||
@@ -76,9 +74,8 @@ public:
|
||||
|
||||
#ifndef BOOST_NO_STD_LOCALE
|
||||
boost::scoped_ptr<std::locale> archive_locale;
|
||||
basic_streambuf_locale_saver<
|
||||
BOOST_DEDUCED_TYPENAME OStream::char_type,
|
||||
BOOST_DEDUCED_TYPENAME OStream::traits_type
|
||||
io::basic_ios_locale_saver<
|
||||
BOOST_DEDUCED_TYPENAME OStream::char_type, BOOST_DEDUCED_TYPENAME OStream::traits_type
|
||||
> locale_saver;
|
||||
#endif
|
||||
|
||||
@@ -86,9 +83,7 @@ public:
|
||||
template<class T>
|
||||
void save(const T &t){
|
||||
if(os.fail())
|
||||
boost::serialization::throw_exception(
|
||||
archive_exception(archive_exception::output_stream_error)
|
||||
);
|
||||
boost::throw_exception(archive_exception(archive_exception::stream_error));
|
||||
os << t;
|
||||
}
|
||||
|
||||
@@ -99,37 +94,40 @@ public:
|
||||
// otherwise crash on load.
|
||||
assert(0 == static_cast<int>(t) || 1 == static_cast<int>(t));
|
||||
if(os.fail())
|
||||
boost::serialization::throw_exception(
|
||||
archive_exception(archive_exception::output_stream_error)
|
||||
);
|
||||
boost::throw_exception(archive_exception(archive_exception::stream_error));
|
||||
os << t;
|
||||
}
|
||||
void save(const signed char t)
|
||||
{
|
||||
save(static_cast<short int>(t));
|
||||
if(os.fail())
|
||||
boost::throw_exception(archive_exception(archive_exception::stream_error));
|
||||
os << static_cast<short int>(t);
|
||||
}
|
||||
void save(const unsigned char t)
|
||||
{
|
||||
save(static_cast<short unsigned int>(t));
|
||||
if(os.fail())
|
||||
boost::throw_exception(archive_exception(archive_exception::stream_error));
|
||||
os << static_cast<short unsigned int>(t);
|
||||
}
|
||||
void save(const char t)
|
||||
{
|
||||
save(static_cast<short int>(t));
|
||||
if(os.fail())
|
||||
boost::throw_exception(archive_exception(archive_exception::stream_error));
|
||||
os << static_cast<short int>(t);
|
||||
}
|
||||
#ifndef BOOST_NO_INTRINSIC_WCHAR_T
|
||||
void save(const wchar_t t)
|
||||
{
|
||||
BOOST_STATIC_ASSERT(sizeof(wchar_t) <= sizeof(int));
|
||||
save(static_cast<int>(t));
|
||||
if(os.fail())
|
||||
boost::throw_exception(archive_exception(archive_exception::stream_error));
|
||||
os << static_cast<int>(t);
|
||||
}
|
||||
#endif
|
||||
void save(const float t)
|
||||
{
|
||||
// must be a user mistake - can't serialize un-initialized data
|
||||
if(os.fail())
|
||||
boost::serialization::throw_exception(
|
||||
archive_exception(archive_exception::output_stream_error)
|
||||
);
|
||||
boost::throw_exception(archive_exception(archive_exception::stream_error));
|
||||
os << std::setprecision(std::numeric_limits<float>::digits10 + 2);
|
||||
os << t;
|
||||
}
|
||||
@@ -137,9 +135,7 @@ public:
|
||||
{
|
||||
// must be a user mistake - can't serialize un-initialized data
|
||||
if(os.fail())
|
||||
boost::serialization::throw_exception(
|
||||
archive_exception(archive_exception::output_stream_error)
|
||||
);
|
||||
boost::throw_exception(archive_exception(archive_exception::stream_error));
|
||||
os << std::setprecision(std::numeric_limits<double>::digits10 + 2);
|
||||
os << t;
|
||||
}
|
||||
@@ -149,15 +145,15 @@ public:
|
||||
~basic_text_oprimitive();
|
||||
public:
|
||||
// unformatted append of one character
|
||||
void put(BOOST_DEDUCED_TYPENAME OStream::char_type c){
|
||||
void put(int c){
|
||||
if(os.fail())
|
||||
boost::serialization::throw_exception(
|
||||
archive_exception(archive_exception::output_stream_error)
|
||||
);
|
||||
boost::throw_exception(archive_exception(archive_exception::stream_error));
|
||||
os.put(c);
|
||||
}
|
||||
// unformatted append of null terminated string
|
||||
void put(const char * s){
|
||||
if(os.fail())
|
||||
boost::throw_exception(archive_exception(archive_exception::stream_error));
|
||||
while('\0' != *s)
|
||||
os.put(*s++);
|
||||
}
|
||||
|
||||
@@ -16,9 +16,9 @@
|
||||
|
||||
// See http://www.boost.org for updates, documentation, and revision history.
|
||||
|
||||
#include <boost/archive/detail/auto_link_archive.hpp>
|
||||
#include <boost/archive/archive_exception.hpp>
|
||||
|
||||
#include <boost/archive/detail/auto_link_archive.hpp>
|
||||
#include <boost/archive/detail/abi_prefix.hpp> // must be the last header
|
||||
|
||||
namespace boost {
|
||||
@@ -28,35 +28,35 @@ namespace archive {
|
||||
|
||||
extern
|
||||
BOOST_ARCHIVE_DECL(const char *)
|
||||
BOOST_ARCHIVE_XML_OBJECT_ID();
|
||||
OBJECT_ID();
|
||||
|
||||
extern
|
||||
BOOST_ARCHIVE_DECL(const char *)
|
||||
BOOST_ARCHIVE_XML_OBJECT_REFERENCE();
|
||||
OBJECT_REFERENCE();
|
||||
|
||||
extern
|
||||
BOOST_ARCHIVE_DECL(const char *)
|
||||
BOOST_ARCHIVE_XML_CLASS_ID();
|
||||
CLASS_ID();
|
||||
|
||||
extern
|
||||
BOOST_ARCHIVE_DECL(const char *)
|
||||
BOOST_ARCHIVE_XML_CLASS_ID_REFERENCE();
|
||||
CLASS_ID_REFERENCE();
|
||||
|
||||
extern
|
||||
BOOST_ARCHIVE_DECL(const char *)
|
||||
BOOST_ARCHIVE_XML_CLASS_NAME();
|
||||
CLASS_NAME();
|
||||
|
||||
extern
|
||||
BOOST_ARCHIVE_DECL(const char *)
|
||||
BOOST_ARCHIVE_XML_TRACKING();
|
||||
TRACKING();
|
||||
|
||||
extern
|
||||
BOOST_ARCHIVE_DECL(const char *)
|
||||
BOOST_ARCHIVE_XML_VERSION();
|
||||
VERSION();
|
||||
|
||||
extern
|
||||
BOOST_ARCHIVE_DECL(const char *)
|
||||
BOOST_ARCHIVE_XML_SIGNATURE();
|
||||
SIGNATURE();
|
||||
|
||||
}// namespace archive
|
||||
}// namespace boost
|
||||
|
||||
@@ -17,7 +17,7 @@
|
||||
// See http://www.boost.org for updates, documentation, and revision history.
|
||||
|
||||
#include <boost/config.hpp>
|
||||
#include <boost/serialization/pfto.hpp>
|
||||
#include <boost/pfto.hpp>
|
||||
#include <boost/detail/workaround.hpp>
|
||||
|
||||
#include <boost/archive/detail/common_iarchive.hpp>
|
||||
@@ -29,11 +29,6 @@
|
||||
|
||||
#include <boost/archive/detail/abi_prefix.hpp> // must be the last header
|
||||
|
||||
#ifdef BOOST_MSVC
|
||||
# pragma warning(push)
|
||||
# pragma warning(disable : 4511 4512)
|
||||
#endif
|
||||
|
||||
namespace boost {
|
||||
namespace archive {
|
||||
|
||||
@@ -82,9 +77,9 @@ public:
|
||||
boost::serialization::nvp<T> & t,
|
||||
int
|
||||
){
|
||||
this->This()->load_start(t.name());
|
||||
load_start(t.name());
|
||||
this->detail_common_iarchive::load_override(t.value(), 0);
|
||||
this->This()->load_end(t.name());
|
||||
load_end(t.name());
|
||||
}
|
||||
|
||||
// specific overrides for attributes - handle as
|
||||
@@ -118,10 +113,6 @@ public:
|
||||
} // namespace archive
|
||||
} // namespace boost
|
||||
|
||||
#ifdef BOOST_MSVC
|
||||
#pragma warning(pop)
|
||||
#endif
|
||||
|
||||
#include <boost/archive/detail/abi_suffix.hpp> // pops abi_suffix.hpp pragmas
|
||||
|
||||
#endif // BOOST_ARCHIVE_BASIC_XML_IARCHIVE_HPP
|
||||
|
||||
@@ -28,10 +28,6 @@
|
||||
|
||||
#include <boost/archive/detail/abi_prefix.hpp> // must be the last header
|
||||
|
||||
#ifdef BOOST_MSVC
|
||||
# pragma warning(push)
|
||||
# pragma warning(disable : 4511 4512)
|
||||
#endif
|
||||
|
||||
namespace boost {
|
||||
namespace archive {
|
||||
@@ -93,7 +89,7 @@ public:
|
||||
this->detail_common_oarchive::save_override(t, 0);
|
||||
}
|
||||
|
||||
// special treatment for name-value pairs.
|
||||
// special treatment for name-value pairs.
|
||||
typedef detail::common_oarchive<Archive> detail_common_oarchive;
|
||||
template<class T>
|
||||
void save_override(
|
||||
@@ -103,9 +99,9 @@ public:
|
||||
::boost::serialization::nvp<T> & t,
|
||||
int
|
||||
){
|
||||
this->This()->save_start(t.name());
|
||||
save_start(t.name());
|
||||
this->detail_common_oarchive::save_override(t.const_value(), 0);
|
||||
this->This()->save_end(t.name());
|
||||
save_end(t.name());
|
||||
}
|
||||
|
||||
// specific overrides for attributes - not name value pairs so we
|
||||
@@ -136,10 +132,6 @@ public:
|
||||
} // namespace archive
|
||||
} // namespace boost
|
||||
|
||||
#ifdef BOOST_MSVC
|
||||
#pragma warning(pop)
|
||||
#endif
|
||||
|
||||
#include <boost/archive/detail/abi_suffix.hpp> // pops abi_suffix.hpp pragmas
|
||||
|
||||
#endif // BOOST_ARCHIVE_BASIC_XML_OARCHIVE_HPP
|
||||
|
||||
@@ -18,12 +18,6 @@
|
||||
|
||||
#include <istream>
|
||||
#include <boost/archive/binary_iarchive_impl.hpp>
|
||||
#include <boost/archive/detail/register_archive.hpp>
|
||||
|
||||
#ifdef BOOST_MSVC
|
||||
# pragma warning(push)
|
||||
# pragma warning(disable : 4511 4512)
|
||||
#endif
|
||||
|
||||
namespace boost {
|
||||
namespace archive {
|
||||
@@ -96,8 +90,4 @@ public:
|
||||
BOOST_SERIALIZATION_REGISTER_ARCHIVE(boost::archive::binary_iarchive)
|
||||
BOOST_SERIALIZATION_USE_ARRAY_OPTIMIZATION(boost::archive::binary_iarchive)
|
||||
|
||||
#ifdef BOOST_MSVC
|
||||
#pragma warning(pop)
|
||||
#endif
|
||||
|
||||
#endif // BOOST_ARCHIVE_BINARY_IARCHIVE_HPP
|
||||
|
||||
@@ -17,15 +17,10 @@
|
||||
// See http://www.boost.org for updates, documentation, and revision history.
|
||||
|
||||
#include <istream>
|
||||
#include <boost/serialization/pfto.hpp>
|
||||
#include <boost/pfto.hpp>
|
||||
#include <boost/archive/basic_binary_iprimitive.hpp>
|
||||
#include <boost/archive/basic_binary_iarchive.hpp>
|
||||
|
||||
#ifdef BOOST_MSVC
|
||||
# pragma warning(push)
|
||||
# pragma warning(disable : 4511 4512)
|
||||
#endif
|
||||
|
||||
namespace boost {
|
||||
namespace archive {
|
||||
|
||||
@@ -89,8 +84,4 @@ protected:
|
||||
} // namespace archive
|
||||
} // namespace boost
|
||||
|
||||
#ifdef BOOST_MSVC
|
||||
#pragma warning(pop)
|
||||
#endif
|
||||
|
||||
#endif // BOOST_ARCHIVE_BINARY_IARCHIVE_IMPL_HPP
|
||||
|
||||
@@ -17,14 +17,7 @@
|
||||
// See http://www.boost.org for updates, documentation, and revision history.
|
||||
|
||||
#include <ostream>
|
||||
#include <boost/config.hpp>
|
||||
#include <boost/archive/binary_oarchive_impl.hpp>
|
||||
#include <boost/archive/detail/register_archive.hpp>
|
||||
|
||||
#ifdef BOOST_MSVC
|
||||
# pragma warning(push)
|
||||
# pragma warning(disable : 4511 4512)
|
||||
#endif
|
||||
|
||||
namespace boost {
|
||||
namespace archive {
|
||||
@@ -59,8 +52,4 @@ typedef binary_oarchive naked_binary_oarchive;
|
||||
BOOST_SERIALIZATION_REGISTER_ARCHIVE(boost::archive::binary_oarchive)
|
||||
BOOST_SERIALIZATION_USE_ARRAY_OPTIMIZATION(boost::archive::binary_oarchive)
|
||||
|
||||
#ifdef BOOST_MSVC
|
||||
#pragma warning(pop)
|
||||
#endif
|
||||
|
||||
#endif // BOOST_ARCHIVE_BINARY_OARCHIVE_HPP
|
||||
|
||||
@@ -17,16 +17,10 @@
|
||||
// See http://www.boost.org for updates, documentation, and revision history.
|
||||
|
||||
#include <ostream>
|
||||
#include <boost/config.hpp>
|
||||
#include <boost/serialization/pfto.hpp>
|
||||
#include <boost/pfto.hpp>
|
||||
#include <boost/archive/basic_binary_oprimitive.hpp>
|
||||
#include <boost/archive/basic_binary_oarchive.hpp>
|
||||
|
||||
#ifdef BOOST_MSVC
|
||||
# pragma warning(push)
|
||||
# pragma warning(disable : 4511 4512)
|
||||
#endif
|
||||
|
||||
namespace boost {
|
||||
namespace archive {
|
||||
|
||||
@@ -90,8 +84,4 @@ protected:
|
||||
} // namespace archive
|
||||
} // namespace boost
|
||||
|
||||
#ifdef BOOST_MSVC
|
||||
#pragma warning(pop)
|
||||
#endif
|
||||
|
||||
#endif // BOOST_ARCHIVE_BINARY_OARCHIVE_IMPL_HPP
|
||||
|
||||
@@ -23,7 +23,6 @@
|
||||
|
||||
#include <istream> // wistream
|
||||
#include <boost/archive/binary_iarchive_impl.hpp>
|
||||
#include <boost/archive/detail/register_archive.hpp>
|
||||
|
||||
namespace boost {
|
||||
namespace archive {
|
||||
|
||||
@@ -23,7 +23,6 @@
|
||||
|
||||
#include <ostream>
|
||||
#include <boost/archive/binary_oarchive_impl.hpp>
|
||||
#include <boost/archive/detail/register_archive.hpp>
|
||||
|
||||
namespace boost {
|
||||
namespace archive {
|
||||
|
||||
@@ -17,27 +17,14 @@
|
||||
// See http://www.boost.org for updates, documentation, and revision history.
|
||||
|
||||
#include <locale>
|
||||
#include <cstddef> // NULL, size_t
|
||||
#include <cstddef>
|
||||
#include <cwchar> // for mbstate_t
|
||||
#include <boost/config.hpp>
|
||||
#include <boost/archive/detail/auto_link_archive.hpp>
|
||||
#include <boost/archive/detail/abi_prefix.hpp> // must be the last header
|
||||
|
||||
#if defined(BOOST_NO_STDC_NAMESPACE)
|
||||
namespace std {
|
||||
// For STLport on WinCE, BOOST_NO_STDC_NAMESPACE can get defined if STLport is putting symbols in its own namespace.
|
||||
// In the case of codecvt, however, this does not mean that codecvt is in the global namespace (it will be in STLport's namespace)
|
||||
# if !defined(__SGI_STL_PORT) && !defined(_STLPORT_VERSION)
|
||||
using ::codecvt;
|
||||
# endif
|
||||
using ::mbstate_t;
|
||||
using ::size_t;
|
||||
} // namespace
|
||||
#endif
|
||||
|
||||
#ifdef BOOST_MSVC
|
||||
# pragma warning(push)
|
||||
# pragma warning(disable : 4511 4512)
|
||||
#endif
|
||||
|
||||
namespace boost {
|
||||
@@ -92,9 +79,4 @@ class codecvt_null<wchar_t> : public std::codecvt<wchar_t, char, std::mbstate_t>
|
||||
} // namespace archive
|
||||
} // namespace boost
|
||||
|
||||
#ifdef BOOST_MSVC
|
||||
# pragma warning(pop)
|
||||
#endif
|
||||
#include <boost/archive/detail/abi_suffix.hpp> // pop pragmas
|
||||
|
||||
#endif //BOOST_ARCHIVE_CODECVT_NULL_HPP
|
||||
|
||||
@@ -8,12 +8,12 @@
|
||||
|
||||
// See http://www.boost.org for updates, documentation, and revision history.
|
||||
|
||||
#if defined( __BORLANDC__ )
|
||||
#pragma nopushoptwarn
|
||||
#endif
|
||||
|
||||
#ifdef BOOST_MSVC
|
||||
#pragma warning(pop)
|
||||
#endif
|
||||
#include <boost/config/abi_suffix.hpp> // pops abi_suffix.hpp pragmas
|
||||
|
||||
#if defined( __BORLANDC__ )
|
||||
#pragma nopushoptwarn
|
||||
#endif
|
||||
|
||||
|
||||
@@ -0,0 +1,91 @@
|
||||
#ifndef BOOST_ARCHIVE_ARCHIVE_POINTER_ISERIALIZER_POINTER_HPP
|
||||
#define BOOST_ARCHIVE_ARCHIVE_POINTER_ISERIALIZER_POINTER_HPP
|
||||
|
||||
// MS compatible compilers support #pragma once
|
||||
#if defined(_MSC_VER) && (_MSC_VER >= 1020)
|
||||
# pragma once
|
||||
#endif
|
||||
|
||||
/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
|
||||
// archive_pointer_iserializer.hpp
|
||||
|
||||
// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
|
||||
// Use, modification and distribution is subject to the Boost Software
|
||||
// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
// See http://www.boost.org for updates, documentation, and revision history.
|
||||
|
||||
#include <cassert>
|
||||
#include <boost/config.hpp>
|
||||
#include <boost/detail/workaround.hpp>
|
||||
|
||||
#include <boost/archive/detail/basic_serializer.hpp>
|
||||
#include <boost/archive/detail/basic_pointer_iserializer.hpp>
|
||||
|
||||
#include <boost/archive/detail/abi_prefix.hpp> // must be the last header
|
||||
|
||||
namespace boost {
|
||||
|
||||
namespace serialization {
|
||||
class extended_type_info;
|
||||
} // namespace serialization
|
||||
|
||||
namespace archive {
|
||||
namespace detail {
|
||||
|
||||
template<class Archive>
|
||||
class archive_pointer_iserializer :
|
||||
public basic_pointer_iserializer {
|
||||
protected:
|
||||
explicit BOOST_ARCHIVE_OR_WARCHIVE_DECL(BOOST_PP_EMPTY())
|
||||
archive_pointer_iserializer(
|
||||
const boost::serialization::extended_type_info & eti
|
||||
);
|
||||
BOOST_ARCHIVE_OR_WARCHIVE_DECL(BOOST_PP_EMPTY())
|
||||
// account for bogus gcc warning
|
||||
#if defined(__GNUC__)
|
||||
virtual
|
||||
#endif
|
||||
~archive_pointer_iserializer();
|
||||
public:
|
||||
virtual const basic_iserializer & get_basic_serializer() const
|
||||
// mscvc 6.0 requires template functions to be implemented. For this
|
||||
// reason we can't make abstract.
|
||||
#if BOOST_WORKAROUND(BOOST_MSVC, <= 1300) || defined(__MWERKS__)
|
||||
{
|
||||
assert(false);
|
||||
return *static_cast<const basic_iserializer *>(NULL);
|
||||
}
|
||||
#else
|
||||
= 0;
|
||||
#endif
|
||||
virtual void load_object_ptr(
|
||||
basic_iarchive & ar,
|
||||
void * & x,
|
||||
const unsigned int file_version
|
||||
) const
|
||||
#if BOOST_WORKAROUND(BOOST_MSVC, <= 1300) || defined(__MWERKS__)
|
||||
{
|
||||
assert(false);
|
||||
}
|
||||
#else
|
||||
= 0;
|
||||
#endif
|
||||
// return the type_extended load pointer corresponding to a given
|
||||
// type_info. returns NULL if there is no such instance. This
|
||||
// would indicate that the no object of the specified type was loaded
|
||||
// any where in the code.
|
||||
static BOOST_ARCHIVE_OR_WARCHIVE_DECL(const basic_pointer_iserializer *)
|
||||
find(
|
||||
const boost::serialization::extended_type_info & eti
|
||||
);
|
||||
};
|
||||
|
||||
} // namespace detail
|
||||
} // namespace archive
|
||||
} // namespace boost
|
||||
|
||||
#include <boost/archive/detail/abi_suffix.hpp> // pops abi_suffix.hpp pragmas
|
||||
|
||||
#endif // BOOST_ARCHIVE_ARCHIVE_POINTER_ISERIALIZER_POINTER_HPP
|
||||
@@ -0,0 +1,66 @@
|
||||
#ifndef BOOST_ARCHIVE_ARCHIVE_POINTER_OSERIALIZER_POINTER_HPP
|
||||
#define BOOST_ARCHIVE_ARCHIVE_POINTER_OSERIALIZER_POINTER_HPP
|
||||
|
||||
// MS compatible compilers support #pragma once
|
||||
#if defined(_MSC_VER) && (_MSC_VER >= 1020)
|
||||
# pragma once
|
||||
#endif
|
||||
|
||||
/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
|
||||
// archive_pointer_oserializer.hpp: extenstion of type_info required for
|
||||
// serialization.
|
||||
|
||||
// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
|
||||
// Use, modification and distribution is subject to the Boost Software
|
||||
// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
// See http://www.boost.org for updates, documentation, and revision history.
|
||||
|
||||
#include <boost/config.hpp>
|
||||
#include <boost/archive/detail/basic_serializer.hpp>
|
||||
#include <boost/archive/detail/basic_pointer_oserializer.hpp>
|
||||
|
||||
#include <boost/archive/detail/abi_prefix.hpp> // must be the last header
|
||||
|
||||
namespace boost {
|
||||
|
||||
namespace serialization {
|
||||
class extended_type_info;
|
||||
} // namespace serialization
|
||||
|
||||
namespace archive {
|
||||
namespace detail {
|
||||
|
||||
template<class Archive>
|
||||
class archive_pointer_oserializer :
|
||||
public basic_pointer_oserializer {
|
||||
protected:
|
||||
explicit BOOST_ARCHIVE_OR_WARCHIVE_DECL(BOOST_PP_EMPTY())
|
||||
archive_pointer_oserializer(
|
||||
const boost::serialization::extended_type_info & eti
|
||||
);
|
||||
BOOST_ARCHIVE_OR_WARCHIVE_DECL(BOOST_PP_EMPTY())
|
||||
// account for bogus gcc warning
|
||||
#if defined(__GNUC__)
|
||||
virtual
|
||||
#endif
|
||||
~archive_pointer_oserializer();
|
||||
public:
|
||||
// return the type_extended save pointer corresponding to a give
|
||||
// type_info. returns NULL, if there is no such instance. This
|
||||
// would indicate that the no object of the specified type was saved
|
||||
// any where in the code.
|
||||
static BOOST_ARCHIVE_OR_WARCHIVE_DECL(const basic_pointer_oserializer *)
|
||||
find(
|
||||
const boost::serialization::extended_type_info & eti
|
||||
);
|
||||
};
|
||||
|
||||
} // namespace detail
|
||||
} // namespace archive
|
||||
} // namespace boost
|
||||
|
||||
#include <boost/archive/detail/abi_suffix.hpp> // pops abi_suffix.hpp pragmas
|
||||
|
||||
#endif // BOOST_ARCHIVE_ARCHIVE_POINTER_OSERIALIZER_POINTER_HPP
|
||||
@@ -1,55 +0,0 @@
|
||||
#ifndef BOOST_ARCHIVE_SERIALIZER_MAP_HPP
|
||||
#define BOOST_ARCHIVE_SERIALIZER_MAP_HPP
|
||||
|
||||
// MS compatible compilers support #pragma once
|
||||
#if defined(_MSC_VER) && (_MSC_VER >= 1020)
|
||||
# pragma once
|
||||
#endif
|
||||
|
||||
/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
|
||||
// archive_serializer_map.hpp: extenstion of type_info required for
|
||||
// serialization.
|
||||
|
||||
// (C) Copyright 2009 Robert Ramey - http://www.rrsd.com .
|
||||
// Use, modification and distribution is subject to the Boost Software
|
||||
// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
// See http://www.boost.org for updates, documentation, and revision history.
|
||||
|
||||
// note: this is nothing more than the thinest of wrappers around
|
||||
// basic_serializer_map so we can have a one map / archive type.
|
||||
|
||||
#include <boost/config.hpp>
|
||||
#include <boost/archive/detail/auto_link_archive.hpp>
|
||||
#include <boost/archive/detail/abi_prefix.hpp> // must be the last header
|
||||
|
||||
namespace boost {
|
||||
|
||||
namespace serialization {
|
||||
class extended_type_info;
|
||||
} // namespace serialization
|
||||
|
||||
namespace archive {
|
||||
namespace detail {
|
||||
|
||||
class basic_serializer;
|
||||
|
||||
template<class Archive>
|
||||
class BOOST_ARCHIVE_OR_WARCHIVE_DECL(BOOST_PP_EMPTY())
|
||||
archive_serializer_map {
|
||||
public:
|
||||
static bool insert(const basic_serializer * bs);
|
||||
static void erase(const basic_serializer * bs);
|
||||
static const basic_serializer * find(
|
||||
const boost::serialization::extended_type_info & type_
|
||||
);
|
||||
};
|
||||
|
||||
} // namespace detail
|
||||
} // namespace archive
|
||||
} // namespace boost
|
||||
|
||||
#include <boost/archive/detail/abi_suffix.hpp> // must be the last header
|
||||
|
||||
#endif //BOOST_ARCHIVE_SERIALIZER_MAP_HPP
|
||||
@@ -45,4 +45,4 @@
|
||||
#include <boost/config/auto_link.hpp>
|
||||
#endif // auto-linking disabled
|
||||
|
||||
#endif // BOOST_ARCHIVE_DETAIL_AUTO_LINK_ARCHIVE_HPP
|
||||
#endif // ARCHIVE_DETAIL_AUTO_LINK_ARCHIVE_HPP
|
||||
|
||||
@@ -20,8 +20,6 @@
|
||||
// #include <boost/scoped_ptr.hpp>
|
||||
|
||||
#include <boost/config.hpp>
|
||||
#include <boost/noncopyable.hpp>
|
||||
|
||||
#include <boost/type_traits/broken_compiler_spec.hpp>
|
||||
#include <boost/serialization/tracking_enum.hpp>
|
||||
#include <boost/archive/basic_archive.hpp>
|
||||
@@ -41,8 +39,7 @@ class BOOST_ARCHIVE_DECL(BOOST_PP_EMPTY()) basic_iserializer;
|
||||
class BOOST_ARCHIVE_DECL(BOOST_PP_EMPTY()) basic_pointer_iserializer;
|
||||
//////////////////////////////////////////////////////////////////////
|
||||
// class basic_iarchive - read serialized objects from a input stream
|
||||
class BOOST_ARCHIVE_DECL(BOOST_PP_EMPTY()) basic_iarchive :
|
||||
private boost::noncopyable
|
||||
class BOOST_ARCHIVE_DECL(BOOST_PP_EMPTY()) basic_iarchive
|
||||
{
|
||||
friend class basic_iarchive_impl;
|
||||
// hide implementation of this class to minimize header conclusion
|
||||
@@ -67,25 +64,26 @@ public:
|
||||
// note: NOT part of the public API.
|
||||
void next_object_pointer(void *t);
|
||||
void register_basic_serializer(
|
||||
const basic_iserializer & bis
|
||||
const /* BOOST_ARCHIVE_DECL(BOOST_PP_EMPTY()) */ basic_iserializer & bis
|
||||
);
|
||||
void load_object(
|
||||
void *t,
|
||||
const basic_iserializer & bis
|
||||
const /* BOOST_ARCHIVE_DECL(BOOST_PP_EMPTY()) */ basic_iserializer & bis
|
||||
);
|
||||
const basic_pointer_iserializer *
|
||||
const /* BOOST_ARCHIVE_DECL(BOOST_PP_EMPTY()) */ basic_pointer_iserializer *
|
||||
load_pointer(
|
||||
void * & t,
|
||||
const basic_pointer_iserializer * bpis_ptr,
|
||||
const basic_pointer_iserializer * (*finder)(
|
||||
const /* BOOST_ARCHIVE_DECL(BOOST_PP_EMPTY()) */
|
||||
basic_pointer_iserializer * bpis_ptr,
|
||||
const /* BOOST_ARCHIVE_DECL(BOOST_PP_EMPTY()) */
|
||||
basic_pointer_iserializer * (*finder)(
|
||||
const boost::serialization::extended_type_info & eti
|
||||
)
|
||||
|
||||
);
|
||||
// real public API starts here
|
||||
void
|
||||
set_library_version(library_version_type archive_library_version);
|
||||
library_version_type
|
||||
set_library_version(unsigned int archive_library_version);
|
||||
unsigned int
|
||||
get_library_version() const;
|
||||
unsigned int
|
||||
get_flags() const;
|
||||
|
||||
@@ -19,18 +19,13 @@
|
||||
#include <cstdlib> // NULL
|
||||
#include <boost/config.hpp>
|
||||
|
||||
#include <boost/archive/basic_archive.hpp>
|
||||
#include <boost/archive/detail/decl.hpp>
|
||||
#include <boost/archive/detail/basic_serializer.hpp>
|
||||
#include <boost/archive/detail/auto_link_archive.hpp>
|
||||
#include <boost/archive/detail/abi_prefix.hpp> // must be the last header
|
||||
|
||||
#ifdef BOOST_MSVC
|
||||
# pragma warning(push)
|
||||
# pragma warning(disable : 4511 4512)
|
||||
#endif
|
||||
|
||||
namespace boost {
|
||||
|
||||
namespace serialization {
|
||||
class extended_type_info;
|
||||
} // namespace serialization
|
||||
@@ -76,7 +71,7 @@ public:
|
||||
// returns true if objects should be tracked
|
||||
virtual bool tracking(const unsigned int) const = 0 ;
|
||||
// returns class version
|
||||
virtual version_type version() const = 0 ;
|
||||
virtual unsigned int version() const = 0 ;
|
||||
// returns true if this class is polymorphic
|
||||
virtual bool is_polymorphic() const = 0;
|
||||
virtual void destroy(/*const*/ void *address) const = 0 ;
|
||||
@@ -86,10 +81,6 @@ public:
|
||||
} // namespace archive
|
||||
} // namespace boost
|
||||
|
||||
#ifdef BOOST_MSVC
|
||||
#pragma warning(pop)
|
||||
#endif
|
||||
|
||||
#include <boost/archive/detail/abi_suffix.hpp> // pops abi_suffix.hpp pragmas
|
||||
|
||||
#endif // BOOST_ARCHIVE_DETAIL_BASIC_ISERIALIZER_HPP
|
||||
|
||||
@@ -16,10 +16,7 @@
|
||||
|
||||
// See http://www.boost.org for updates, documentation, and revision history.
|
||||
|
||||
#include <cstddef> // NULL
|
||||
#include <boost/config.hpp>
|
||||
#include <boost/noncopyable.hpp>
|
||||
|
||||
#include <boost/type_traits/broken_compiler_spec.hpp>
|
||||
|
||||
// can't use this - much as I'd like to as borland doesn't support it
|
||||
@@ -38,13 +35,12 @@ namespace serialization {
|
||||
namespace archive {
|
||||
namespace detail {
|
||||
|
||||
class basic_oarchive_impl;
|
||||
class BOOST_ARCHIVE_DECL(BOOST_PP_EMPTY()) basic_oarchive_impl;
|
||||
class BOOST_ARCHIVE_DECL(BOOST_PP_EMPTY()) basic_oserializer;
|
||||
class BOOST_ARCHIVE_DECL(BOOST_PP_EMPTY()) basic_pointer_oserializer;
|
||||
//////////////////////////////////////////////////////////////////////
|
||||
// class basic_oarchive - write serialized objects to an output stream
|
||||
class BOOST_ARCHIVE_OR_WARCHIVE_DECL(BOOST_PP_EMPTY()) basic_oarchive :
|
||||
private boost::noncopyable
|
||||
class BOOST_ARCHIVE_OR_WARCHIVE_DECL(BOOST_PP_EMPTY()) basic_oarchive
|
||||
{
|
||||
friend class basic_oarchive_impl;
|
||||
// hide implementation of this class to minimize header conclusion
|
||||
@@ -87,7 +83,7 @@ public:
|
||||
}
|
||||
// real public interface starts here
|
||||
void end_preamble(); // default implementation does nothing
|
||||
library_version_type get_library_version() const;
|
||||
unsigned int get_library_version() const;
|
||||
unsigned int get_flags() const;
|
||||
};
|
||||
|
||||
|
||||
@@ -16,22 +16,16 @@
|
||||
|
||||
// See http://www.boost.org for updates, documentation, and revision history.
|
||||
|
||||
#include <cstddef> // NULL
|
||||
#include <cstdlib> // NULL
|
||||
#include <boost/config.hpp>
|
||||
#include <boost/noncopyable.hpp>
|
||||
|
||||
#include <boost/archive/basic_archive.hpp>
|
||||
#include <boost/archive/detail/auto_link_archive.hpp>
|
||||
#include <boost/archive/detail/basic_serializer.hpp>
|
||||
|
||||
#include <boost/archive/detail/abi_prefix.hpp> // must be the last header
|
||||
|
||||
#ifdef BOOST_MSVC
|
||||
# pragma warning(push)
|
||||
# pragma warning(disable : 4511 4512)
|
||||
#endif
|
||||
|
||||
namespace boost {
|
||||
|
||||
namespace serialization {
|
||||
class extended_type_info;
|
||||
} // namespace serialization
|
||||
@@ -75,7 +69,7 @@ public:
|
||||
// returns true if objects should be tracked
|
||||
virtual bool tracking(const unsigned int flags) const = 0;
|
||||
// returns class version
|
||||
virtual version_type version() const = 0;
|
||||
virtual unsigned int version() const = 0;
|
||||
// returns true if this class is polymorphic
|
||||
virtual bool is_polymorphic() const = 0;
|
||||
};
|
||||
@@ -84,10 +78,6 @@ public:
|
||||
} // namespace serialization
|
||||
} // namespace boost
|
||||
|
||||
#ifdef BOOST_MSVC
|
||||
#pragma warning(pop)
|
||||
#endif
|
||||
|
||||
#include <boost/archive/detail/abi_suffix.hpp> // pops abi_suffix.hpp pragmas
|
||||
|
||||
#endif // BOOST_SERIALIZATION_BASIC_OSERIALIZER_HPP
|
||||
|
||||
@@ -17,18 +17,13 @@
|
||||
|
||||
// See http://www.boost.org for updates, documentation, and revision history.
|
||||
#include <boost/config.hpp>
|
||||
#include <boost/noncopyable.hpp>
|
||||
#include <boost/archive/detail/auto_link_archive.hpp>
|
||||
#include <boost/archive/detail/basic_serializer.hpp>
|
||||
|
||||
#include <boost/archive/detail/abi_prefix.hpp> // must be the last header
|
||||
|
||||
#ifdef BOOST_MSVC
|
||||
# pragma warning(push)
|
||||
# pragma warning(disable : 4511 4512)
|
||||
#endif
|
||||
|
||||
namespace boost {
|
||||
|
||||
namespace serialization {
|
||||
class extended_type_info;
|
||||
} // namespace serialization
|
||||
@@ -64,10 +59,6 @@ public:
|
||||
} // namespace archive
|
||||
} // namespace boost
|
||||
|
||||
#ifdef BOOST_MSVC
|
||||
#pragma warning(pop)
|
||||
#endif
|
||||
|
||||
#include <boost/archive/detail/abi_suffix.hpp> // pops abi_suffix.hpp pragmas
|
||||
|
||||
#endif // BOOST_ARCHIVE_BASIC_POINTER_ISERIALIZER_HPP
|
||||
|
||||
@@ -17,18 +17,13 @@
|
||||
|
||||
// See http://www.boost.org for updates, documentation, and revision history.
|
||||
#include <boost/config.hpp>
|
||||
#include <boost/noncopyable.hpp>
|
||||
#include <boost/archive/detail/auto_link_archive.hpp>
|
||||
#include <boost/archive/detail/basic_serializer.hpp>
|
||||
|
||||
#include <boost/archive/detail/abi_prefix.hpp> // must be the last header
|
||||
|
||||
#ifdef BOOST_MSVC
|
||||
# pragma warning(push)
|
||||
# pragma warning(disable : 4511 4512)
|
||||
#endif
|
||||
|
||||
namespace boost {
|
||||
|
||||
namespace serialization {
|
||||
class extended_type_info;
|
||||
} // namespace serialization
|
||||
@@ -40,8 +35,7 @@ class BOOST_ARCHIVE_DECL(BOOST_PP_EMPTY()) basic_oarchive;
|
||||
class BOOST_ARCHIVE_DECL(BOOST_PP_EMPTY()) basic_oserializer;
|
||||
|
||||
class BOOST_ARCHIVE_DECL(BOOST_PP_EMPTY()) basic_pointer_oserializer :
|
||||
public basic_serializer
|
||||
{
|
||||
public basic_serializer {
|
||||
protected:
|
||||
explicit basic_pointer_oserializer(
|
||||
const boost::serialization::extended_type_info & type_
|
||||
@@ -63,10 +57,6 @@ public:
|
||||
} // namespace archive
|
||||
} // namespace boost
|
||||
|
||||
#ifdef BOOST_MSVC
|
||||
#pragma warning(pop)
|
||||
#endif
|
||||
|
||||
#include <boost/archive/detail/abi_suffix.hpp> // pops abi_suffix.hpp pragmas
|
||||
|
||||
#endif // BOOST_ARCHIVE_BASIC_POINTER_OSERIALIZER_HPP
|
||||
|
||||
@@ -17,50 +17,37 @@
|
||||
// See http://www.boost.org for updates, documentation, and revision history.
|
||||
|
||||
#include <cassert>
|
||||
#include <cstddef> // NULL
|
||||
|
||||
#include <boost/noncopyable.hpp>
|
||||
#include <boost/config.hpp>
|
||||
#include <boost/serialization/extended_type_info.hpp>
|
||||
|
||||
#ifdef BOOST_MSVC
|
||||
# pragma warning(push)
|
||||
# pragma warning(disable : 4511 4512)
|
||||
#endif
|
||||
|
||||
namespace boost {
|
||||
namespace archive {
|
||||
namespace detail {
|
||||
|
||||
class basic_serializer :
|
||||
private boost::noncopyable
|
||||
class basic_serializer : private boost::noncopyable
|
||||
{
|
||||
const boost::serialization::extended_type_info * m_eti;
|
||||
const boost::serialization::extended_type_info & m_eti;
|
||||
protected:
|
||||
explicit basic_serializer(
|
||||
const boost::serialization::extended_type_info & eti
|
||||
) :
|
||||
m_eti(& eti)
|
||||
m_eti(eti)
|
||||
{
|
||||
assert(NULL != & eti);
|
||||
}
|
||||
public:
|
||||
inline bool
|
||||
operator<(const basic_serializer & rhs) const {
|
||||
// can't compare address since there can be multiple eti records
|
||||
// for the same type in different execution modules (that is, DLLS)
|
||||
// leave this here as a reminder not to do this!
|
||||
// return & lhs.get_eti() < & rhs.get_eti();
|
||||
return get_eti() < rhs.get_eti();
|
||||
}
|
||||
const char * get_debug_info() const {
|
||||
return m_eti->get_debug_info();
|
||||
}
|
||||
const boost::serialization::extended_type_info & get_eti() const {
|
||||
return * m_eti;
|
||||
return m_eti;
|
||||
}
|
||||
};
|
||||
|
||||
inline bool
|
||||
operator<(const basic_serializer & lhs, const basic_serializer & rhs) {
|
||||
return & lhs.get_eti() < & rhs.get_eti();
|
||||
}
|
||||
|
||||
class basic_serializer_arg : public basic_serializer {
|
||||
public:
|
||||
basic_serializer_arg(const serialization::extended_type_info & eti) :
|
||||
@@ -72,8 +59,4 @@ public:
|
||||
} // namespace archive
|
||||
} // namespace boost
|
||||
|
||||
#ifdef BOOST_MSVC
|
||||
#pragma warning(pop)
|
||||
#endif
|
||||
|
||||
#endif // BOOST_ARCHIVE_BASIC_SERIALIZER_HPP
|
||||
|
||||
@@ -1,5 +1,5 @@
|
||||
#ifndef BOOST_SERIALIZER_MAP_HPP
|
||||
#define BOOST_SERIALIZER_MAP_HPP
|
||||
#ifndef BOOST_TYPEINFO_EXTENDED_MAP_HPP
|
||||
#define BOOST_TYPEINFO_EXTENDED_MAP_HPP
|
||||
|
||||
// MS compatible compilers support #pragma once
|
||||
#if defined(_MSC_VER) && (_MSC_VER >= 1020)
|
||||
@@ -30,40 +30,30 @@ namespace serialization {
|
||||
}
|
||||
|
||||
namespace archive {
|
||||
namespace detail {
|
||||
namespace detail {
|
||||
|
||||
class basic_serializer;
|
||||
class BOOST_ARCHIVE_DECL(BOOST_PP_EMPTY()) basic_serializer;
|
||||
|
||||
class BOOST_ARCHIVE_OR_WARCHIVE_DECL(BOOST_PP_EMPTY())
|
||||
basic_serializer_map : public
|
||||
boost::noncopyable
|
||||
bool operator<(const basic_serializer & lhs, const basic_serializer & rhs);
|
||||
|
||||
struct BOOST_ARCHIVE_DECL(BOOST_PP_EMPTY()) type_info_pointer_compare
|
||||
{
|
||||
struct type_info_pointer_compare
|
||||
{
|
||||
bool operator()(
|
||||
const basic_serializer * lhs, const basic_serializer * rhs
|
||||
) const ;
|
||||
};
|
||||
typedef std::set<
|
||||
const basic_serializer *,
|
||||
type_info_pointer_compare
|
||||
> map_type;
|
||||
map_type m_map;
|
||||
public:
|
||||
bool insert(const basic_serializer * bs);
|
||||
void erase(const basic_serializer * bs);
|
||||
const basic_serializer * find(
|
||||
const boost::serialization::extended_type_info & type_
|
||||
) const;
|
||||
private:
|
||||
// cw 8.3 requires this
|
||||
basic_serializer_map& operator=(basic_serializer_map const&);
|
||||
bool operator()(
|
||||
const basic_serializer * lhs, const basic_serializer * rhs
|
||||
) const {
|
||||
return *lhs < *rhs;
|
||||
}
|
||||
};
|
||||
|
||||
typedef BOOST_ARCHIVE_DECL(BOOST_PP_EMPTY()) std::set<
|
||||
const basic_serializer *,
|
||||
type_info_pointer_compare
|
||||
> basic_serializer_map;
|
||||
|
||||
} // namespace detail
|
||||
} // namespace archive
|
||||
} // namespace boost
|
||||
|
||||
#include <boost/archive/detail/abi_suffix.hpp> // must be the last header
|
||||
#include <boost/archive/detail/abi_suffix.hpp> // pops abi_suffix.hpp pragmas
|
||||
|
||||
#endif // BOOST_SERIALIZER_MAP_HPP
|
||||
#endif // BOOST_TYPEINFO_EXTENDED_MAP_HPP
|
||||
|
||||
@@ -1,169 +0,0 @@
|
||||
#ifndef BOOST_ARCHIVE_DETAIL_CHECK_HPP
|
||||
#define BOOST_ARCHIVE_DETAIL_CHECK_HPP
|
||||
|
||||
// MS compatible compilers support #pragma once
|
||||
#if defined(_MSC_VER) && (_MSC_VER >= 1020)
|
||||
# pragma once
|
||||
#pragma inline_depth(511)
|
||||
#pragma inline_recursion(on)
|
||||
#endif
|
||||
|
||||
#if defined(__MWERKS__)
|
||||
#pragma inline_depth(511)
|
||||
#endif
|
||||
|
||||
/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
|
||||
// check.hpp: interface for serialization system.
|
||||
|
||||
// (C) Copyright 2009 Robert Ramey - http://www.rrsd.com .
|
||||
// Use, modification and distribution is subject to the Boost Software
|
||||
// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
// See http://www.boost.org for updates, documentation, and revision history.
|
||||
|
||||
#include <boost/config.hpp>
|
||||
|
||||
#include <boost/static_assert.hpp>
|
||||
#include <boost/type_traits/is_const.hpp>
|
||||
|
||||
#include <boost/mpl/eval_if.hpp>
|
||||
#include <boost/mpl/or.hpp>
|
||||
#include <boost/mpl/equal_to.hpp>
|
||||
#include <boost/mpl/int.hpp>
|
||||
#include <boost/mpl/not.hpp>
|
||||
#include <boost/mpl/greater.hpp>
|
||||
#include <boost/mpl/assert.hpp>
|
||||
|
||||
#include <boost/serialization/static_warning.hpp>
|
||||
#include <boost/serialization/version.hpp>
|
||||
#include <boost/serialization/level.hpp>
|
||||
#include <boost/serialization/tracking.hpp>
|
||||
#include <boost/serialization/wrapper.hpp>
|
||||
|
||||
namespace boost {
|
||||
namespace archive {
|
||||
namespace detail {
|
||||
|
||||
// checks for objects
|
||||
|
||||
template<class T>
|
||||
inline void check_object_level(){
|
||||
typedef
|
||||
BOOST_DEDUCED_TYPENAME mpl::greater_equal<
|
||||
serialization::implementation_level<T>,
|
||||
mpl::int_<serialization::primitive_type>
|
||||
>::type typex;
|
||||
|
||||
// trap attempts to serialize objects marked
|
||||
// not_serializable
|
||||
BOOST_STATIC_ASSERT(typex::value);
|
||||
}
|
||||
|
||||
template<class T>
|
||||
inline void check_object_versioning(){
|
||||
typedef
|
||||
BOOST_DEDUCED_TYPENAME mpl::or_<
|
||||
BOOST_DEDUCED_TYPENAME mpl::greater<
|
||||
serialization::implementation_level<T>,
|
||||
mpl::int_<serialization::object_serializable>
|
||||
>,
|
||||
BOOST_DEDUCED_TYPENAME mpl::equal_to<
|
||||
serialization::version<T>,
|
||||
mpl::int_<0>
|
||||
>
|
||||
> typex;
|
||||
// trap attempts to serialize with objects that don't
|
||||
// save class information in the archive with versioning.
|
||||
BOOST_STATIC_ASSERT(typex::value);
|
||||
}
|
||||
|
||||
template<class T>
|
||||
inline void check_object_tracking(){
|
||||
// presume it has already been determined that
|
||||
// T is not a const
|
||||
BOOST_STATIC_ASSERT(! boost::is_const<T>::value);
|
||||
typedef BOOST_DEDUCED_TYPENAME mpl::equal_to<
|
||||
serialization::tracking_level<T>,
|
||||
mpl::int_<serialization::track_never>
|
||||
>::type typex;
|
||||
// saving an non-const object of a type not marked "track_never)
|
||||
|
||||
// may be an indicator of an error usage of the
|
||||
// serialization library and should be double checked.
|
||||
// See documentation on object tracking. Also, see the
|
||||
// "rationale" section of the documenation
|
||||
// for motivation for this checking.
|
||||
|
||||
BOOST_STATIC_WARNING(typex::value);
|
||||
}
|
||||
|
||||
// checks for pointers
|
||||
|
||||
template<class T>
|
||||
inline void check_pointer_level(){
|
||||
// we should only invoke this once we KNOW that T
|
||||
// has been used as a pointer!!
|
||||
typedef
|
||||
BOOST_DEDUCED_TYPENAME mpl::or_<
|
||||
BOOST_DEDUCED_TYPENAME mpl::greater<
|
||||
serialization::implementation_level<T>,
|
||||
mpl::int_<serialization::object_serializable>
|
||||
>,
|
||||
BOOST_DEDUCED_TYPENAME mpl::not_<
|
||||
BOOST_DEDUCED_TYPENAME mpl::equal_to<
|
||||
serialization::tracking_level<T>,
|
||||
mpl::int_<serialization::track_selectively>
|
||||
>
|
||||
>
|
||||
> typex;
|
||||
// Address the following when serializing to a pointer:
|
||||
|
||||
// a) This type doesn't save class information in the
|
||||
// archive. That is, the serialization trait implementation
|
||||
// level <= object_serializable.
|
||||
// b) 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
|
||||
// but rather the existence of the operation ar >> T * is used to
|
||||
// infer that an object of this type should be tracked. So, if
|
||||
// you save via a pointer but don't load via a pointer the operation
|
||||
// will fail on load without given any valid reason for the failure.
|
||||
|
||||
// So if your program traps here, consider changing the
|
||||
// tracking or implementation level traits - or not
|
||||
// serializing via a pointer.
|
||||
BOOST_STATIC_WARNING(typex::value);
|
||||
}
|
||||
|
||||
template<class T>
|
||||
void inline check_pointer_tracking(){
|
||||
typedef BOOST_DEDUCED_TYPENAME mpl::greater<
|
||||
serialization::tracking_level<T>,
|
||||
mpl::int_<serialization::track_never>
|
||||
>::type typex;
|
||||
// serializing an object of a type marked "track_never" through a pointer
|
||||
// could result in creating more objects than were saved!
|
||||
BOOST_STATIC_WARNING(typex::value);
|
||||
}
|
||||
|
||||
template<class T>
|
||||
inline void check_const_loading(){
|
||||
typedef
|
||||
BOOST_DEDUCED_TYPENAME mpl::or_<
|
||||
BOOST_DEDUCED_TYPENAME boost::serialization::is_wrapper<T>,
|
||||
BOOST_DEDUCED_TYPENAME mpl::not_<
|
||||
BOOST_DEDUCED_TYPENAME boost::is_const<T>
|
||||
>
|
||||
>::type typex;
|
||||
// cannot load data into a "const" object unless it's a
|
||||
// wrapper around some other non-const object.
|
||||
BOOST_STATIC_ASSERT(typex::value);
|
||||
}
|
||||
|
||||
} // detail
|
||||
} // archive
|
||||
} // boost
|
||||
|
||||
#endif // BOOST_ARCHIVE_DETAIL_CHECK_HPP
|
||||
@@ -16,23 +16,16 @@
|
||||
|
||||
// See http://www.boost.org for updates, documentation, and revision history.
|
||||
|
||||
#include <boost/config.hpp>
|
||||
|
||||
#include <boost/archive/detail/basic_iarchive.hpp>
|
||||
#include <boost/archive/detail/basic_pointer_iserializer.hpp>
|
||||
#include <boost/archive/detail/interface_iarchive.hpp>
|
||||
|
||||
#ifdef BOOST_MSVC
|
||||
# pragma warning(push)
|
||||
# pragma warning(disable : 4511 4512)
|
||||
#endif
|
||||
#include <boost/archive/detail/iserializer.hpp>
|
||||
#include <boost/archive/detail/register_archive.hpp>
|
||||
#include <boost/pfto.hpp>
|
||||
|
||||
namespace boost {
|
||||
namespace archive {
|
||||
namespace detail {
|
||||
|
||||
class extended_type_info;
|
||||
|
||||
// note: referred to as Curiously Recurring Template Patter (CRTP)
|
||||
template<class Archive>
|
||||
class common_iarchive :
|
||||
@@ -80,9 +73,5 @@ protected:
|
||||
} // namespace archive
|
||||
} // namespace boost
|
||||
|
||||
#ifdef BOOST_MSVC
|
||||
#pragma warning(pop)
|
||||
#endif
|
||||
|
||||
#endif // BOOST_ARCHIVE_DETAIL_COMMON_IARCHIVE_HPP
|
||||
|
||||
|
||||
@@ -16,15 +16,10 @@
|
||||
|
||||
// See http://www.boost.org for updates, documentation, and revision history.
|
||||
|
||||
#include <boost/config.hpp>
|
||||
|
||||
#include <boost/archive/detail/basic_oarchive.hpp>
|
||||
#include <boost/archive/detail/interface_oarchive.hpp>
|
||||
|
||||
#ifdef BOOST_MSVC
|
||||
# pragma warning(push)
|
||||
# pragma warning(disable : 4511 4512)
|
||||
#endif
|
||||
#include <boost/archive/detail/oserializer.hpp>
|
||||
#include <boost/archive/detail/register_archive.hpp>
|
||||
|
||||
namespace boost {
|
||||
namespace archive {
|
||||
@@ -80,8 +75,4 @@ protected:
|
||||
} // namespace archive
|
||||
} // namespace boost
|
||||
|
||||
#ifdef BOOST_MSVC
|
||||
#pragma warning(pop)
|
||||
#endif
|
||||
|
||||
#endif // BOOST_ARCHIVE_DETAIL_COMMON_OARCHIVE_HPP
|
||||
|
||||
@@ -15,7 +15,7 @@
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
// See http://www.boost.org for updates, documentation, and revision history.
|
||||
#include <cstddef> // NULL
|
||||
#include <string>
|
||||
#include <boost/cstdint.hpp>
|
||||
#include <boost/mpl/bool.hpp>
|
||||
#include <boost/archive/detail/auto_link_archive.hpp>
|
||||
|
||||
@@ -15,7 +15,7 @@
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
// See http://www.boost.org for updates, documentation, and revision history.
|
||||
#include <cstddef> // NULL
|
||||
#include <string>
|
||||
#include <boost/cstdint.hpp>
|
||||
#include <boost/mpl/bool.hpp>
|
||||
|
||||
|
||||
@@ -24,7 +24,7 @@
|
||||
|
||||
#include <new> // for placement new
|
||||
#include <memory> // for auto_ptr
|
||||
#include <cstddef> // size_t, NULL
|
||||
#include <cstddef> // size_t
|
||||
|
||||
#include <boost/config.hpp>
|
||||
#include <boost/detail/workaround.hpp>
|
||||
@@ -33,42 +33,41 @@ namespace std{
|
||||
using ::size_t;
|
||||
} // namespace std
|
||||
#endif
|
||||
|
||||
#include <boost/throw_exception.hpp>
|
||||
#include <boost/smart_cast.hpp>
|
||||
#include <boost/static_assert.hpp>
|
||||
|
||||
#include <boost/mpl/eval_if.hpp>
|
||||
#include <boost/mpl/identity.hpp>
|
||||
#include <boost/mpl/greater_equal.hpp>
|
||||
#include <boost/mpl/equal_to.hpp>
|
||||
#include <boost/mpl/bool.hpp>
|
||||
#include <boost/static_warning.hpp>
|
||||
#include <boost/detail/no_exceptions_support.hpp>
|
||||
|
||||
#ifndef BOOST_SERIALIZATION_DEFAULT_TYPE_INFO
|
||||
#include <boost/serialization/extended_type_info_typeid.hpp>
|
||||
#endif
|
||||
#include <boost/serialization/throw_exception.hpp>
|
||||
#include <boost/serialization/smart_cast.hpp>
|
||||
#include <boost/serialization/static_warning.hpp>
|
||||
|
||||
#include <boost/type_traits/is_pointer.hpp>
|
||||
#include <boost/type_traits/is_enum.hpp>
|
||||
#include <boost/type_traits/is_const.hpp>
|
||||
#include <boost/type_traits/remove_const.hpp>
|
||||
#include <boost/type_traits/remove_extent.hpp>
|
||||
#include <boost/serialization/assume_abstract.hpp>
|
||||
#include <boost/type_traits/is_polymorphic.hpp>
|
||||
|
||||
#include <boost/serialization/assume_abstract.hpp>
|
||||
#include <boost/mpl/eval_if.hpp>
|
||||
#include <boost/mpl/if.hpp>
|
||||
#include <boost/mpl/identity.hpp>
|
||||
#include <boost/mpl/or.hpp>
|
||||
#include <boost/mpl/and.hpp>
|
||||
#include <boost/mpl/less.hpp>
|
||||
#include <boost/mpl/greater_equal.hpp>
|
||||
#include <boost/mpl/int.hpp>
|
||||
#include <boost/mpl/list.hpp>
|
||||
#include <boost/mpl/empty.hpp>
|
||||
#include <boost/mpl/not.hpp>
|
||||
#include <boost/mpl/bool.hpp>
|
||||
|
||||
#define DONT_USE_HAS_NEW_OPERATOR ( \
|
||||
defined(__BORLANDC__) \
|
||||
|| defined(__IBMCPP__) \
|
||||
|| defined(BOOST_MSVC) && (BOOST_MSVC <= 1300) \
|
||||
|| defined(__SUNPRO_CC) && (__SUNPRO_CC < 0x590) \
|
||||
)
|
||||
|
||||
#if ! DONT_USE_HAS_NEW_OPERATOR
|
||||
#include <boost/type_traits/has_new_operator.hpp>
|
||||
#endif
|
||||
#ifndef BOOST_SERIALIZATION_DEFAULT_TYPE_INFO
|
||||
#include <boost/serialization/extended_type_info_typeid.hpp>
|
||||
#endif
|
||||
// the following is need only for dynamic cast of polymorphic pointers
|
||||
#include <boost/archive/detail/basic_iarchive.hpp>
|
||||
#include <boost/archive/detail/basic_iserializer.hpp>
|
||||
#include <boost/archive/detail/archive_pointer_iserializer.hpp>
|
||||
#include <boost/archive/archive_exception.hpp>
|
||||
|
||||
#include <boost/serialization/serialization.hpp>
|
||||
#include <boost/serialization/version.hpp>
|
||||
@@ -80,15 +79,6 @@ namespace std{
|
||||
#include <boost/serialization/array.hpp>
|
||||
#include <boost/serialization/collection_size_type.hpp>
|
||||
#include <boost/serialization/singleton.hpp>
|
||||
#include <boost/serialization/wrapper.hpp>
|
||||
|
||||
// the following is need only for dynamic cast of polymorphic pointers
|
||||
#include <boost/archive/archive_exception.hpp>
|
||||
#include <boost/archive/detail/basic_iarchive.hpp>
|
||||
#include <boost/archive/detail/basic_iserializer.hpp>
|
||||
#include <boost/archive/detail/basic_pointer_iserializer.hpp>
|
||||
#include <boost/archive/detail/archive_serializer_map.hpp>
|
||||
#include <boost/archive/detail/check.hpp>
|
||||
|
||||
namespace boost {
|
||||
|
||||
@@ -110,11 +100,6 @@ public:
|
||||
|
||||
namespace detail {
|
||||
|
||||
#ifdef BOOST_MSVC
|
||||
# pragma warning(push)
|
||||
# pragma warning(disable : 4511 4512)
|
||||
#endif
|
||||
|
||||
template<class Archive, class T>
|
||||
class iserializer : public basic_iserializer
|
||||
{
|
||||
@@ -122,22 +107,20 @@ private:
|
||||
virtual void destroy(/*const*/ void *address) const {
|
||||
boost::serialization::access::destroy(static_cast<T *>(address));
|
||||
}
|
||||
protected:
|
||||
// protected constructor since it's always created by singleton
|
||||
// private constructor to inhibit any existence other than the
|
||||
// static one
|
||||
public:
|
||||
explicit iserializer() :
|
||||
basic_iserializer(
|
||||
boost::serialization::singleton<
|
||||
BOOST_DEDUCED_TYPENAME
|
||||
boost::serialization::type_info_implementation<T>::type
|
||||
>::get_const_instance()
|
||||
boost::serialization::type_info_implementation<T>::type
|
||||
::get_const_instance()
|
||||
)
|
||||
{}
|
||||
public:
|
||||
virtual BOOST_DLLEXPORT void load_object_data(
|
||||
virtual void load_object_data(
|
||||
basic_iarchive & ar,
|
||||
void *x,
|
||||
const unsigned int file_version
|
||||
) const BOOST_USED;
|
||||
) const;
|
||||
virtual bool class_info() const {
|
||||
return boost::serialization::implementation_level<T>::value
|
||||
>= boost::serialization::object_class_info;
|
||||
@@ -149,8 +132,8 @@ public:
|
||||
== boost::serialization::track_selectively
|
||||
&& serialized_as_pointer());
|
||||
}
|
||||
virtual version_type version() const {
|
||||
return version_type(::boost::serialization::version<T>::value);
|
||||
virtual unsigned int version() const {
|
||||
return ::boost::serialization::version<T>::value;
|
||||
}
|
||||
virtual bool is_polymorphic() const {
|
||||
return boost::is_polymorphic<T>::value;
|
||||
@@ -158,42 +141,24 @@ public:
|
||||
virtual ~iserializer(){};
|
||||
};
|
||||
|
||||
#ifdef BOOST_MSVC
|
||||
# pragma warning(pop)
|
||||
#endif
|
||||
|
||||
template<class Archive, class T>
|
||||
BOOST_DLLEXPORT void iserializer<Archive, T>::load_object_data(
|
||||
void iserializer<Archive, T>::load_object_data(
|
||||
basic_iarchive & ar,
|
||||
void *x,
|
||||
const unsigned int file_version
|
||||
) const {
|
||||
// trap case where the program cannot handle the current version
|
||||
if(file_version > static_cast<const unsigned int>(version()))
|
||||
boost::serialization::throw_exception(
|
||||
archive::archive_exception(
|
||||
boost::archive::archive_exception::unsupported_class_version,
|
||||
get_debug_info()
|
||||
)
|
||||
);
|
||||
|
||||
// make sure call is routed through the higest interface that might
|
||||
// be specialized by the user.
|
||||
boost::serialization::serialize_adl(
|
||||
boost::serialization::smart_cast_reference<Archive &>(ar),
|
||||
boost::smart_cast_reference<Archive &>(ar),
|
||||
* static_cast<T *>(x),
|
||||
file_version
|
||||
);
|
||||
}
|
||||
|
||||
#ifdef BOOST_MSVC
|
||||
# pragma warning(push)
|
||||
# pragma warning(disable : 4511 4512)
|
||||
#endif
|
||||
|
||||
template<class Archive, class T>
|
||||
class pointer_iserializer :
|
||||
public basic_pointer_iserializer
|
||||
class pointer_iserializer
|
||||
: public archive_pointer_iserializer<Archive>
|
||||
{
|
||||
private:
|
||||
virtual const basic_iserializer & get_basic_serializer() const {
|
||||
@@ -201,21 +166,15 @@ private:
|
||||
iserializer<Archive, T>
|
||||
>::get_const_instance();
|
||||
}
|
||||
BOOST_DLLEXPORT virtual void load_object_ptr(
|
||||
virtual void load_object_ptr(
|
||||
basic_iarchive & ar,
|
||||
void * & x,
|
||||
const unsigned int file_version
|
||||
) const BOOST_USED;
|
||||
protected:
|
||||
// this should alway be a singleton so make the constructor protected
|
||||
) const ;
|
||||
public:
|
||||
pointer_iserializer();
|
||||
~pointer_iserializer();
|
||||
};
|
||||
|
||||
#ifdef BOOST_MSVC
|
||||
# pragma warning(pop)
|
||||
#endif
|
||||
|
||||
// note trick to be sure that operator new is using class specific
|
||||
// version if such exists. Due to Peter Dimov.
|
||||
// note: the following fails if T has no default constructor.
|
||||
@@ -227,34 +186,36 @@ protected:
|
||||
// }
|
||||
//}
|
||||
|
||||
// note: this should really be a member of the load_ptr function
|
||||
// below but some compilers still complain about this.
|
||||
template<class T>
|
||||
struct heap_allocator
|
||||
{
|
||||
// boost::has_new_operator<T> doesn't work on these compilers
|
||||
#if DONT_USE_HAS_NEW_OPERATOR
|
||||
// This doesn't handle operator new overload for class T
|
||||
static T * invoke(){
|
||||
#if 0
|
||||
// note: this fails on msvc 7.0 and gcc 3.2
|
||||
template <class U, U x> struct test;
|
||||
typedef char* yes;
|
||||
typedef int* no;
|
||||
template <class U>
|
||||
yes has_op_new(U*, test<void* (*)(std::size_t), &U::operator new>* = 0);
|
||||
no has_op_new(...);
|
||||
|
||||
template<class U>
|
||||
T * new_operator(U);
|
||||
|
||||
T * new_operator(yes){
|
||||
return (T::operator new)(sizeof(T));
|
||||
}
|
||||
T * new_operator(no){
|
||||
return static_cast<T *>(operator new(sizeof(T)));
|
||||
}
|
||||
static T * invoke(){
|
||||
return new_operator(has_op_new(static_cast<T *>(NULL)));
|
||||
}
|
||||
#else
|
||||
struct has_new_operator {
|
||||
static T* invoke() {
|
||||
return static_cast<T *>((T::operator new)(sizeof(T)));
|
||||
}
|
||||
};
|
||||
struct doesnt_have_new_operator {
|
||||
static T* invoke() {
|
||||
return static_cast<T *>(operator new(sizeof(T)));
|
||||
}
|
||||
};
|
||||
static T * invoke() {
|
||||
typedef BOOST_DEDUCED_TYPENAME
|
||||
mpl::eval_if<
|
||||
boost::has_new_operator<T>,
|
||||
mpl::identity<has_new_operator >,
|
||||
mpl::identity<doesnt_have_new_operator >
|
||||
>::type typex;
|
||||
return typex::invoke();
|
||||
// while this doesn't handle operator new overload for class T
|
||||
static T * invoke(){
|
||||
return static_cast<T *>(operator new(sizeof(T)));
|
||||
}
|
||||
#endif
|
||||
};
|
||||
@@ -284,21 +245,18 @@ private:
|
||||
T* m_p;
|
||||
};
|
||||
|
||||
// note: BOOST_DLLEXPORT is so that code for polymorphic class
|
||||
// serialized only through base class won't get optimized out
|
||||
template<class Archive, class T>
|
||||
BOOST_DLLEXPORT void pointer_iserializer<Archive, T>::load_object_ptr(
|
||||
void pointer_iserializer<Archive, T>::load_object_ptr(
|
||||
basic_iarchive & ar,
|
||||
void * & x,
|
||||
const unsigned int file_version
|
||||
) const
|
||||
{
|
||||
Archive & ar_impl =
|
||||
boost::serialization::smart_cast_reference<Archive &>(ar);
|
||||
Archive & ar_impl = boost::smart_cast_reference<Archive &>(ar);
|
||||
|
||||
auto_ptr_with_deleter<T> ap(heap_allocator<T>::invoke());
|
||||
if(NULL == ap.get())
|
||||
boost::serialization::throw_exception(std::bad_alloc()) ;
|
||||
boost::throw_exception(std::bad_alloc()) ;
|
||||
|
||||
T * t = ap.get();
|
||||
x = t;
|
||||
@@ -328,30 +286,21 @@ BOOST_DLLEXPORT void pointer_iserializer<Archive, T>::load_object_ptr(
|
||||
|
||||
template<class Archive, class T>
|
||||
pointer_iserializer<Archive, T>::pointer_iserializer() :
|
||||
basic_pointer_iserializer(
|
||||
boost::serialization::singleton<
|
||||
BOOST_DEDUCED_TYPENAME
|
||||
boost::serialization::type_info_implementation<T>::type
|
||||
>::get_const_instance()
|
||||
archive_pointer_iserializer<Archive>(
|
||||
boost::serialization::type_info_implementation<T>::type
|
||||
::get_const_instance()
|
||||
)
|
||||
{
|
||||
boost::serialization::singleton<
|
||||
iserializer<Archive, T>
|
||||
>::get_mutable_instance().set_bpis(this);
|
||||
archive_serializer_map<Archive>::insert(this);
|
||||
}
|
||||
|
||||
template<class Archive, class T>
|
||||
pointer_iserializer<Archive, T>::~pointer_iserializer(){
|
||||
archive_serializer_map<Archive>::erase(this);
|
||||
}
|
||||
|
||||
template<class Archive>
|
||||
struct load_non_pointer_type {
|
||||
// note this bounces the call right back to the archive
|
||||
// with no runtime overhead
|
||||
struct load_primitive {
|
||||
template<class T>
|
||||
static void invoke(Archive & ar, T & t){
|
||||
load_access::load_primitive(ar, t);
|
||||
}
|
||||
@@ -359,15 +308,12 @@ struct load_non_pointer_type {
|
||||
// note this bounces the call right back to the archive
|
||||
// with no runtime overhead
|
||||
struct load_only {
|
||||
template<class T>
|
||||
static void invoke(Archive & ar, const T & t){
|
||||
static void invoke(Archive & ar, T & t){
|
||||
// short cut to user's serializer
|
||||
// make sure call is routed through the higest interface that might
|
||||
// be specialized by the user.
|
||||
boost::serialization::serialize_adl(
|
||||
ar,
|
||||
const_cast<T &>(t),
|
||||
boost::serialization::version<T>::value
|
||||
ar, t, boost::serialization::version<T>::value
|
||||
);
|
||||
}
|
||||
};
|
||||
@@ -375,9 +321,12 @@ struct load_non_pointer_type {
|
||||
// note this save class information including version
|
||||
// and serialization level to the archive
|
||||
struct load_standard {
|
||||
template<class T>
|
||||
static void invoke(Archive &ar, const T & t){
|
||||
void * x = & const_cast<T &>(t);
|
||||
static void invoke(Archive &ar, T &t){
|
||||
//BOOST_STATIC_ASSERT(! boost::is_const<T>::value);
|
||||
// borland - for some reason T is const here - even though
|
||||
// its not called that way - so fix it her
|
||||
typedef BOOST_DEDUCED_TYPENAME boost::remove_const<T>::type typex;
|
||||
void * x = & const_cast<typex &>(t);
|
||||
ar.load_object(
|
||||
x,
|
||||
boost::serialization::singleton<
|
||||
@@ -388,7 +337,6 @@ struct load_non_pointer_type {
|
||||
};
|
||||
|
||||
struct load_conditional {
|
||||
template<class T>
|
||||
static void invoke(Archive &ar, T &t){
|
||||
//if(0 == (ar.get_flags() & no_tracking))
|
||||
load_standard::invoke(ar, t);
|
||||
@@ -397,48 +345,57 @@ struct load_non_pointer_type {
|
||||
}
|
||||
};
|
||||
|
||||
template<class T>
|
||||
static void invoke(Archive & ar, T &t){
|
||||
typedef BOOST_DEDUCED_TYPENAME mpl::eval_if<
|
||||
// if its primitive
|
||||
mpl::equal_to<
|
||||
boost::serialization::implementation_level<T>,
|
||||
mpl::int_<boost::serialization::primitive_type>
|
||||
>,
|
||||
mpl::identity<load_primitive>,
|
||||
// else
|
||||
BOOST_DEDUCED_TYPENAME mpl::eval_if<
|
||||
// class info / version
|
||||
mpl::greater_equal<
|
||||
boost::serialization::implementation_level<T>,
|
||||
mpl::int_<boost::serialization::object_class_info>
|
||||
>,
|
||||
// do standard load
|
||||
mpl::identity<load_standard>,
|
||||
typedef BOOST_DEDUCED_TYPENAME mpl::eval_if<
|
||||
// if its primitive
|
||||
mpl::equal_to<
|
||||
boost::serialization::implementation_level<T>,
|
||||
mpl::int_<boost::serialization::primitive_type>
|
||||
>,
|
||||
mpl::identity<load_primitive>,
|
||||
// else
|
||||
BOOST_DEDUCED_TYPENAME mpl::eval_if<
|
||||
// no tracking
|
||||
mpl::equal_to<
|
||||
boost::serialization::tracking_level<T>,
|
||||
mpl::int_<boost::serialization::track_never>
|
||||
// class info / version
|
||||
mpl::greater_equal<
|
||||
boost::serialization::implementation_level<T>,
|
||||
mpl::int_<boost::serialization::object_class_info>
|
||||
>,
|
||||
// do a fast load
|
||||
mpl::identity<load_only>,
|
||||
// else
|
||||
// do a fast load only tracking is turned off
|
||||
mpl::identity<load_conditional>
|
||||
> > >::type typex;
|
||||
check_object_versioning<T>();
|
||||
check_object_level<T>();
|
||||
// do standard load
|
||||
mpl::identity<load_standard>,
|
||||
// else
|
||||
BOOST_DEDUCED_TYPENAME mpl::eval_if<
|
||||
// no tracking
|
||||
mpl::equal_to<
|
||||
boost::serialization::tracking_level<T>,
|
||||
mpl::int_<boost::serialization::track_never>
|
||||
>,
|
||||
// do a fast load
|
||||
mpl::identity<load_only>,
|
||||
// else
|
||||
// do a fast load only tracking is turned off
|
||||
mpl::identity<load_conditional>
|
||||
> > >::type typex;
|
||||
|
||||
static void invoke(Archive & ar, T &t){
|
||||
// check that we're not trying to serialize something that
|
||||
// has been marked not to be serialized. If this your program
|
||||
// traps here, you've tried to serialize a class whose trait
|
||||
// has been marked "non-serializable". Either reset the trait
|
||||
// (see level.hpp) or change program not to serialize items of this class
|
||||
BOOST_STATIC_ASSERT((
|
||||
mpl::greater_equal<
|
||||
boost::serialization::implementation_level<T>,
|
||||
mpl::int_<boost::serialization::primitive_type>
|
||||
>::value
|
||||
));
|
||||
typex::invoke(ar, t);
|
||||
}
|
||||
};
|
||||
|
||||
template<class Archive>
|
||||
template<class Archive, class Tptr>
|
||||
struct load_pointer_type {
|
||||
template<class T>
|
||||
struct abstract
|
||||
{
|
||||
template<class T>
|
||||
static const basic_pointer_iserializer * register_type(Archive & /* ar */){
|
||||
// it has? to be polymorphic
|
||||
BOOST_STATIC_ASSERT(boost::is_polymorphic<T>::value);
|
||||
@@ -446,16 +403,16 @@ struct load_pointer_type {
|
||||
}
|
||||
};
|
||||
|
||||
template<class T>
|
||||
struct non_abstract
|
||||
{
|
||||
template<class T>
|
||||
static const basic_pointer_iserializer * register_type(Archive & ar){
|
||||
return ar.register_type(static_cast<T *>(NULL));
|
||||
}
|
||||
};
|
||||
|
||||
template<class T>
|
||||
static const basic_pointer_iserializer * register_type(Archive &ar, const T & /*t*/){
|
||||
static const basic_pointer_iserializer * register_type(Archive &ar, T & /*t*/){
|
||||
// there should never be any need to load an abstract polymorphic
|
||||
// class pointer. Inhibiting code generation for this
|
||||
// permits abstract base classes to be used - note: exception
|
||||
@@ -463,58 +420,35 @@ struct load_pointer_type {
|
||||
typedef BOOST_DEDUCED_TYPENAME
|
||||
mpl::eval_if<
|
||||
boost::serialization::is_abstract<const T>,
|
||||
boost::mpl::identity<abstract>,
|
||||
boost::mpl::identity<non_abstract>
|
||||
mpl::identity<abstract<T> >,
|
||||
mpl::identity<non_abstract<T> >
|
||||
>::type typex;
|
||||
return typex::template register_type<T>(ar);
|
||||
return typex::register_type(ar);
|
||||
}
|
||||
|
||||
template<class T>
|
||||
static T * pointer_tweak(
|
||||
const boost::serialization::extended_type_info & eti,
|
||||
void const * const t,
|
||||
const T &
|
||||
void * t,
|
||||
T &
|
||||
) {
|
||||
// tweak the pointer back to the base class
|
||||
return static_cast<T *>(
|
||||
const_cast<void *>(
|
||||
boost::serialization::void_upcast(
|
||||
eti,
|
||||
boost::serialization::singleton<
|
||||
BOOST_DEDUCED_TYPENAME
|
||||
boost::serialization::type_info_implementation<T>::type
|
||||
>::get_const_instance(),
|
||||
t
|
||||
)
|
||||
boost::serialization::void_upcast(
|
||||
eti,
|
||||
boost::serialization::type_info_implementation<T>::type
|
||||
::get_const_instance(),
|
||||
t
|
||||
)
|
||||
);
|
||||
}
|
||||
|
||||
template<class T>
|
||||
static void check_load(T & /* t */){
|
||||
check_pointer_level<T>();
|
||||
check_pointer_tracking<T>();
|
||||
}
|
||||
|
||||
static const basic_pointer_iserializer *
|
||||
find(const boost::serialization::extended_type_info & type){
|
||||
return static_cast<const basic_pointer_iserializer *>(
|
||||
archive_serializer_map<Archive>::find(type)
|
||||
);
|
||||
}
|
||||
|
||||
template<class Tptr>
|
||||
static void invoke(Archive & ar, Tptr & t){
|
||||
check_load(*t);
|
||||
const basic_pointer_iserializer * bpis_ptr = register_type(ar, *t);
|
||||
const basic_pointer_iserializer * newbpis_ptr = ar.load_pointer(
|
||||
// note major hack here !!!
|
||||
// I tried every way to convert Tptr &t (where Tptr might
|
||||
// include const) to void * &. This is the only way
|
||||
// I could make it work. RR
|
||||
(void * & )t,
|
||||
* reinterpret_cast<void **>(&t),
|
||||
bpis_ptr,
|
||||
find
|
||||
archive_pointer_iserializer<Archive>::find
|
||||
);
|
||||
// if the pointer isn't that of the base class
|
||||
if(newbpis_ptr != bpis_ptr){
|
||||
@@ -523,9 +457,8 @@ struct load_pointer_type {
|
||||
}
|
||||
};
|
||||
|
||||
template<class Archive>
|
||||
template<class Archive, class T>
|
||||
struct load_enum_type {
|
||||
template<class T>
|
||||
static void invoke(Archive &ar, T &t){
|
||||
// convert integers to correct enum to load
|
||||
int i;
|
||||
@@ -534,28 +467,22 @@ struct load_enum_type {
|
||||
}
|
||||
};
|
||||
|
||||
template<class Archive>
|
||||
template<class Archive, class T>
|
||||
struct load_array_type {
|
||||
template<class T>
|
||||
static void invoke(Archive &ar, T &t){
|
||||
typedef BOOST_DEDUCED_TYPENAME remove_extent<T>::type value_type;
|
||||
|
||||
// convert integers to correct enum to load
|
||||
// determine number of elements in the array. Consider the
|
||||
// fact that some machines will align elements on boundries
|
||||
// other than characters.
|
||||
std::size_t current_count = sizeof(t) / (
|
||||
int current_count = sizeof(t) / (
|
||||
static_cast<char *>(static_cast<void *>(&t[1]))
|
||||
- static_cast<char *>(static_cast<void *>(&t[0]))
|
||||
);
|
||||
boost::serialization::collection_size_type count;
|
||||
int count;
|
||||
ar >> BOOST_SERIALIZATION_NVP(count);
|
||||
if(static_cast<std::size_t>(count) > current_count)
|
||||
boost::serialization::throw_exception(
|
||||
archive::archive_exception(
|
||||
boost::archive::archive_exception::array_size_too_short
|
||||
)
|
||||
);
|
||||
if(count > current_count)
|
||||
boost::throw_exception(archive::archive_exception(
|
||||
boost::archive::archive_exception::array_size_too_short
|
||||
));
|
||||
ar >> serialization::make_array(static_cast<value_type*>(&t[0]),count);
|
||||
}
|
||||
};
|
||||
@@ -563,35 +490,33 @@ struct load_array_type {
|
||||
} // detail
|
||||
|
||||
template<class Archive, class T>
|
||||
inline void load(Archive & ar, T &t){
|
||||
inline void load(Archive &ar, T &t){
|
||||
// if this assertion trips. It means we're trying to load a
|
||||
// const object with a compiler that doesn't have correct
|
||||
// funtion template ordering. On other compilers, this is
|
||||
// handled below.
|
||||
detail::check_const_loading<T>();
|
||||
BOOST_STATIC_ASSERT(! boost::is_const<T>::value);
|
||||
typedef
|
||||
BOOST_DEDUCED_TYPENAME mpl::eval_if<is_pointer<T>,
|
||||
mpl::identity<detail::load_pointer_type<Archive> >
|
||||
mpl::identity<detail::load_pointer_type<Archive, T> >
|
||||
,//else
|
||||
BOOST_DEDUCED_TYPENAME mpl::eval_if<is_array<T>,
|
||||
mpl::identity<detail::load_array_type<Archive> >
|
||||
mpl::identity<detail::load_array_type<Archive, T> >
|
||||
,//else
|
||||
BOOST_DEDUCED_TYPENAME mpl::eval_if<is_enum<T>,
|
||||
mpl::identity<detail::load_enum_type<Archive> >
|
||||
mpl::identity<detail::load_enum_type<Archive, T> >
|
||||
,//else
|
||||
mpl::identity<detail::load_non_pointer_type<Archive> >
|
||||
mpl::identity<detail::load_non_pointer_type<Archive, T> >
|
||||
>
|
||||
>
|
||||
>::type typex;
|
||||
typex::invoke(ar, t);
|
||||
}
|
||||
|
||||
#if 0
|
||||
|
||||
// BORLAND
|
||||
#if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x560))
|
||||
// borland has a couple of problems
|
||||
// a) if function is partially specialized - see below
|
||||
// a) if function is partiall specialized - see below
|
||||
// const paramters are transformed to non-const ones
|
||||
// b) implementation of base_object can't be made to work
|
||||
// correctly which results in all base_object s being const.
|
||||
@@ -618,8 +543,6 @@ inline void load(Archive &ar, const T&t){
|
||||
#endif
|
||||
#endif
|
||||
|
||||
#endif
|
||||
|
||||
} // namespace archive
|
||||
} // namespace boost
|
||||
|
||||
|
||||
@@ -23,30 +23,41 @@
|
||||
// See http://www.boost.org for updates, documentation, and revision history.
|
||||
|
||||
#include <cassert>
|
||||
#include <cstddef> // NULL
|
||||
|
||||
#include <boost/config.hpp>
|
||||
#include <boost/static_assert.hpp>
|
||||
#include <boost/detail/workaround.hpp>
|
||||
|
||||
#include <boost/mpl/eval_if.hpp>
|
||||
#include <boost/mpl/equal_to.hpp>
|
||||
#include <boost/mpl/greater_equal.hpp>
|
||||
#include <boost/mpl/identity.hpp>
|
||||
|
||||
#ifndef BOOST_SERIALIZATION_DEFAULT_TYPE_INFO
|
||||
#include <boost/serialization/extended_type_info_typeid.hpp>
|
||||
#endif
|
||||
#include <boost/serialization/throw_exception.hpp>
|
||||
#include <boost/serialization/smart_cast.hpp>
|
||||
#include <boost/serialization/assume_abstract.hpp>
|
||||
#include <boost/serialization/static_warning.hpp>
|
||||
#include <boost/throw_exception.hpp>
|
||||
#include <boost/smart_cast.hpp>
|
||||
#include <boost/static_assert.hpp>
|
||||
#include <boost/static_warning.hpp>
|
||||
|
||||
#include <boost/type_traits/is_pointer.hpp>
|
||||
#include <boost/type_traits/is_enum.hpp>
|
||||
//#include <boost/type_traits/is_volatile.hpp>
|
||||
#include <boost/type_traits/is_const.hpp>
|
||||
//#include <boost/type_traits/is_same.hpp>
|
||||
#include <boost/type_traits/is_polymorphic.hpp>
|
||||
#include <boost/type_traits/remove_extent.hpp>
|
||||
#include <boost/serialization/assume_abstract.hpp>
|
||||
|
||||
#include <boost/mpl/eval_if.hpp>
|
||||
#include <boost/mpl/and.hpp>
|
||||
//#include <boost/mpl/less.hpp>
|
||||
#include <boost/mpl/greater_equal.hpp>
|
||||
#include <boost/mpl/equal_to.hpp>
|
||||
#include <boost/mpl/int.hpp>
|
||||
#include <boost/mpl/identity.hpp>
|
||||
//#include <boost/mpl/list.hpp>
|
||||
//#include <boost/mpl/empty.hpp>
|
||||
#include <boost/mpl/not.hpp>
|
||||
|
||||
#ifndef BOOST_SERIALIZATION_DEFAULT_TYPE_INFO
|
||||
#include <boost/serialization/extended_type_info_typeid.hpp>
|
||||
#endif
|
||||
// the following is need only for dynamic cast of polymorphic pointers
|
||||
#include <boost/archive/detail/basic_oarchive.hpp>
|
||||
#include <boost/archive/detail/basic_oserializer.hpp>
|
||||
#include <boost/archive/detail/archive_pointer_oserializer.hpp>
|
||||
|
||||
#include <boost/serialization/serialization.hpp>
|
||||
#include <boost/serialization/version.hpp>
|
||||
@@ -60,11 +71,6 @@
|
||||
#include <boost/serialization/singleton.hpp>
|
||||
|
||||
#include <boost/archive/archive_exception.hpp>
|
||||
#include <boost/archive/detail/basic_oarchive.hpp>
|
||||
#include <boost/archive/detail/basic_oserializer.hpp>
|
||||
#include <boost/archive/detail/basic_pointer_oserializer.hpp>
|
||||
#include <boost/archive/detail/archive_serializer_map.hpp>
|
||||
#include <boost/archive/detail/check.hpp>
|
||||
|
||||
namespace boost {
|
||||
|
||||
@@ -91,11 +97,6 @@ public:
|
||||
|
||||
namespace detail {
|
||||
|
||||
#ifdef BOOST_MSVC
|
||||
# pragma warning(push)
|
||||
# pragma warning(disable : 4511 4512)
|
||||
#endif
|
||||
|
||||
template<class Archive, class T>
|
||||
class oserializer : public basic_oserializer
|
||||
{
|
||||
@@ -103,18 +104,16 @@ private:
|
||||
// private constructor to inhibit any existence other than the
|
||||
// static one
|
||||
public:
|
||||
explicit BOOST_DLLEXPORT oserializer() :
|
||||
explicit oserializer() :
|
||||
basic_oserializer(
|
||||
boost::serialization::singleton<
|
||||
BOOST_DEDUCED_TYPENAME
|
||||
boost::serialization::type_info_implementation<T>::type
|
||||
>::get_const_instance()
|
||||
boost::serialization::type_info_implementation<T>::type
|
||||
::get_const_instance()
|
||||
)
|
||||
{}
|
||||
virtual BOOST_DLLEXPORT void save_object_data(
|
||||
virtual void save_object_data(
|
||||
basic_oarchive & ar,
|
||||
const void *x
|
||||
) const BOOST_USED;
|
||||
) const ;
|
||||
virtual bool class_info() const {
|
||||
return boost::serialization::implementation_level<T>::value
|
||||
>= boost::serialization::object_class_info;
|
||||
@@ -124,8 +123,8 @@ public:
|
||||
|| (boost::serialization::tracking_level<T>::value == boost::serialization::track_selectively
|
||||
&& serialized_as_pointer());
|
||||
}
|
||||
virtual version_type version() const {
|
||||
return version_type(::boost::serialization::version<T>::value);
|
||||
virtual unsigned int version() const {
|
||||
return ::boost::serialization::version<T>::value;
|
||||
}
|
||||
virtual bool is_polymorphic() const {
|
||||
return boost::is_polymorphic<T>::value;
|
||||
@@ -133,12 +132,8 @@ public:
|
||||
virtual ~oserializer(){}
|
||||
};
|
||||
|
||||
#ifdef BOOST_MSVC
|
||||
# pragma warning(pop)
|
||||
#endif
|
||||
|
||||
template<class Archive, class T>
|
||||
BOOST_DLLEXPORT void oserializer<Archive, T>::save_object_data(
|
||||
void oserializer<Archive, T>::save_object_data(
|
||||
basic_oarchive & ar,
|
||||
const void *x
|
||||
) const {
|
||||
@@ -146,43 +141,36 @@ BOOST_DLLEXPORT void oserializer<Archive, T>::save_object_data(
|
||||
// be specialized by the user.
|
||||
BOOST_STATIC_ASSERT(boost::is_const<T>::value == false);
|
||||
boost::serialization::serialize_adl(
|
||||
boost::serialization::smart_cast_reference<Archive &>(ar),
|
||||
boost::smart_cast_reference<Archive &>(ar),
|
||||
* static_cast<T *>(const_cast<void *>(x)),
|
||||
version()
|
||||
);
|
||||
}
|
||||
|
||||
#ifdef BOOST_MSVC
|
||||
# pragma warning(push)
|
||||
# pragma warning(disable : 4511 4512)
|
||||
#endif
|
||||
|
||||
template<class Archive, class T>
|
||||
class pointer_oserializer :
|
||||
public basic_pointer_oserializer
|
||||
class pointer_oserializer
|
||||
: public archive_pointer_oserializer<Archive>
|
||||
{
|
||||
const basic_oserializer & get_basic_serializer() const;
|
||||
private:
|
||||
const basic_oserializer &
|
||||
get_basic_serializer() const {
|
||||
return boost::serialization::singleton<
|
||||
oserializer<Archive, T>
|
||||
>::get_const_instance();
|
||||
}
|
||||
virtual BOOST_DLLEXPORT void save_object_ptr(
|
||||
virtual void save_object_ptr(
|
||||
basic_oarchive & ar,
|
||||
const void * x
|
||||
) const BOOST_USED;
|
||||
) const ;
|
||||
public:
|
||||
pointer_oserializer();
|
||||
~pointer_oserializer();
|
||||
explicit pointer_oserializer();
|
||||
};
|
||||
|
||||
#ifdef BOOST_MSVC
|
||||
# pragma warning(pop)
|
||||
#endif
|
||||
template<class Archive, class T>
|
||||
const basic_oserializer &
|
||||
pointer_oserializer<Archive, T>::get_basic_serializer() const {
|
||||
return boost::serialization::singleton<
|
||||
oserializer<Archive, T>
|
||||
>::get_const_instance();
|
||||
}
|
||||
|
||||
template<class Archive, class T>
|
||||
BOOST_DLLEXPORT void pointer_oserializer<Archive, T>::save_object_ptr(
|
||||
void pointer_oserializer<Archive, T>::save_object_ptr(
|
||||
basic_oarchive & ar,
|
||||
const void * x
|
||||
) const {
|
||||
@@ -191,8 +179,7 @@ BOOST_DLLEXPORT void pointer_oserializer<Archive, T>::save_object_ptr(
|
||||
// be specialized by the user.
|
||||
T * t = static_cast<T *>(const_cast<void *>(x));
|
||||
const unsigned int file_version = boost::serialization::version<T>::value;
|
||||
Archive & ar_impl
|
||||
= boost::serialization::smart_cast_reference<Archive &>(ar);
|
||||
Archive & ar_impl = boost::smart_cast_reference<Archive &>(ar);
|
||||
boost::serialization::save_construct_data_adl<Archive, T>(
|
||||
ar_impl,
|
||||
t,
|
||||
@@ -203,38 +190,28 @@ BOOST_DLLEXPORT void pointer_oserializer<Archive, T>::save_object_ptr(
|
||||
|
||||
template<class Archive, class T>
|
||||
pointer_oserializer<Archive, T>::pointer_oserializer() :
|
||||
basic_pointer_oserializer(
|
||||
boost::serialization::singleton<
|
||||
BOOST_DEDUCED_TYPENAME
|
||||
boost::serialization::type_info_implementation<T>::type
|
||||
>::get_const_instance()
|
||||
archive_pointer_oserializer<Archive>(
|
||||
boost::serialization::type_info_implementation<T>::type
|
||||
::get_const_instance()
|
||||
)
|
||||
{
|
||||
// make sure appropriate member function is instantiated
|
||||
boost::serialization::singleton<
|
||||
oserializer<Archive, T>
|
||||
>::get_mutable_instance().set_bpos(this);
|
||||
archive_serializer_map<Archive>::insert(this);
|
||||
}
|
||||
|
||||
template<class Archive, class T>
|
||||
pointer_oserializer<Archive, T>::~pointer_oserializer(){
|
||||
archive_serializer_map<Archive>::erase(this);
|
||||
}
|
||||
|
||||
template<class Archive>
|
||||
struct save_non_pointer_type {
|
||||
// note this bounces the call right back to the archive
|
||||
// with no runtime overhead
|
||||
struct save_primitive {
|
||||
template<class T>
|
||||
static void invoke(Archive & ar, const T & t){
|
||||
save_access::save_primitive(ar, t);
|
||||
}
|
||||
};
|
||||
// same as above but passes through serialization
|
||||
struct save_only {
|
||||
template<class T>
|
||||
static void invoke(Archive & ar, const T & t){
|
||||
// make sure call is routed through the highest interface that might
|
||||
// be specialized by the user.
|
||||
@@ -248,7 +225,6 @@ struct save_non_pointer_type {
|
||||
// adds class information to the archive. This includes
|
||||
// serialization level and class version
|
||||
struct save_standard {
|
||||
template<class T>
|
||||
static void invoke(Archive &ar, const T & t){
|
||||
ar.save_object(
|
||||
& t,
|
||||
@@ -262,7 +238,6 @@ struct save_non_pointer_type {
|
||||
// adds class information to the archive. This includes
|
||||
// serialization level and class version
|
||||
struct save_conditional {
|
||||
template<class T>
|
||||
static void invoke(Archive &ar, const T &t){
|
||||
//if(0 == (ar.get_flags() & no_tracking))
|
||||
save_standard::invoke(ar, t);
|
||||
@@ -271,55 +246,58 @@ struct save_non_pointer_type {
|
||||
}
|
||||
};
|
||||
|
||||
typedef
|
||||
BOOST_DEDUCED_TYPENAME mpl::eval_if<
|
||||
// if its primitive
|
||||
mpl::equal_to<
|
||||
boost::serialization::implementation_level<T>,
|
||||
mpl::int_<boost::serialization::primitive_type>
|
||||
>,
|
||||
mpl::identity<save_primitive>,
|
||||
// else
|
||||
BOOST_DEDUCED_TYPENAME mpl::eval_if<
|
||||
// class info / version
|
||||
mpl::greater_equal<
|
||||
boost::serialization::implementation_level<T>,
|
||||
mpl::int_<boost::serialization::object_class_info>
|
||||
>,
|
||||
// do standard save
|
||||
mpl::identity<save_standard>,
|
||||
// else
|
||||
BOOST_DEDUCED_TYPENAME mpl::eval_if<
|
||||
// no tracking
|
||||
mpl::equal_to<
|
||||
boost::serialization::tracking_level<T>,
|
||||
mpl::int_<boost::serialization::track_never>
|
||||
>,
|
||||
// do a fast save
|
||||
mpl::identity<save_only>,
|
||||
// else
|
||||
// do a fast save only tracking is turned off
|
||||
mpl::identity<save_conditional>
|
||||
> > >::type typex;
|
||||
|
||||
template<class T>
|
||||
static void invoke(Archive & ar, const T & t){
|
||||
typedef
|
||||
BOOST_DEDUCED_TYPENAME mpl::eval_if<
|
||||
// if its primitive
|
||||
mpl::equal_to<
|
||||
boost::serialization::implementation_level<T>,
|
||||
mpl::int_<boost::serialization::primitive_type>
|
||||
>,
|
||||
mpl::identity<save_primitive>,
|
||||
// else
|
||||
BOOST_DEDUCED_TYPENAME mpl::eval_if<
|
||||
// class info / version
|
||||
mpl::greater_equal<
|
||||
boost::serialization::implementation_level<T>,
|
||||
mpl::int_<boost::serialization::object_class_info>
|
||||
>,
|
||||
// do standard save
|
||||
mpl::identity<save_standard>,
|
||||
// else
|
||||
BOOST_DEDUCED_TYPENAME mpl::eval_if<
|
||||
// no tracking
|
||||
mpl::equal_to<
|
||||
boost::serialization::tracking_level<T>,
|
||||
mpl::int_<boost::serialization::track_never>
|
||||
>,
|
||||
// do a fast save
|
||||
mpl::identity<save_only>,
|
||||
// else
|
||||
// do a fast save only tracking is turned off
|
||||
mpl::identity<save_conditional>
|
||||
> > >::type typex;
|
||||
check_object_versioning<T>();
|
||||
// check that we're not trying to serialize something that
|
||||
// has been marked not to be serialized. If this your program
|
||||
// traps here, you've tried to serialize a class whose trait
|
||||
// has been marked "non-serializable". Either reset the trait
|
||||
// (see level.hpp) or change program not to serialize items of this class
|
||||
BOOST_STATIC_ASSERT((
|
||||
mpl::greater_equal<
|
||||
boost::serialization::implementation_level<T>,
|
||||
mpl::int_<boost::serialization::primitive_type>
|
||||
>::value
|
||||
));
|
||||
typex::invoke(ar, t);
|
||||
}
|
||||
template<class T>
|
||||
static void invoke(Archive & ar, T & t){
|
||||
check_object_level<T>();
|
||||
check_object_tracking<T>();
|
||||
invoke(ar, const_cast<const T &>(t));
|
||||
}
|
||||
};
|
||||
};
|
||||
|
||||
template<class Archive>
|
||||
template<class Archive, class TPtr>
|
||||
struct save_pointer_type {
|
||||
template<class T>
|
||||
struct abstract
|
||||
{
|
||||
template<class T>
|
||||
static const basic_pointer_oserializer * register_type(Archive & /* ar */){
|
||||
// it has? to be polymorphic
|
||||
BOOST_STATIC_ASSERT(boost::is_polymorphic<T>::value);
|
||||
@@ -327,9 +305,9 @@ struct save_pointer_type {
|
||||
}
|
||||
};
|
||||
|
||||
template<class T>
|
||||
struct non_abstract
|
||||
{
|
||||
template<class T>
|
||||
static const basic_pointer_oserializer * register_type(Archive & ar){
|
||||
return ar.register_type(static_cast<T *>(NULL));
|
||||
}
|
||||
@@ -344,15 +322,15 @@ struct save_pointer_type {
|
||||
typedef
|
||||
BOOST_DEDUCED_TYPENAME mpl::eval_if<
|
||||
boost::serialization::is_abstract<T>,
|
||||
mpl::identity<abstract>,
|
||||
mpl::identity<non_abstract>
|
||||
mpl::identity<abstract<T> >,
|
||||
mpl::identity<non_abstract<T> >
|
||||
>::type typex;
|
||||
return typex::template register_type<T>(ar);
|
||||
return typex::register_type(ar);
|
||||
}
|
||||
|
||||
template<class T>
|
||||
struct non_polymorphic
|
||||
{
|
||||
template<class T>
|
||||
static void save(
|
||||
Archive &ar,
|
||||
T & t
|
||||
@@ -366,19 +344,16 @@ struct save_pointer_type {
|
||||
}
|
||||
};
|
||||
|
||||
template<class T>
|
||||
struct polymorphic
|
||||
{
|
||||
template<class T>
|
||||
static void save(
|
||||
Archive &ar,
|
||||
T & t
|
||||
){
|
||||
BOOST_DEDUCED_TYPENAME
|
||||
boost::serialization::type_info_implementation<T>::type const
|
||||
& i = boost::serialization::singleton<
|
||||
BOOST_DEDUCED_TYPENAME
|
||||
boost::serialization::type_info_implementation<T>::type
|
||||
>::get_const_instance();
|
||||
BOOST_DEDUCED_TYPENAME boost::serialization::type_info_implementation<T>::type
|
||||
const & i = boost::serialization::type_info_implementation<T>::type
|
||||
::get_const_instance();
|
||||
|
||||
boost::serialization::extended_type_info const * const this_type = & i;
|
||||
|
||||
@@ -392,11 +367,8 @@ struct save_pointer_type {
|
||||
// note:if this exception is thrown, be sure that derived pointer
|
||||
// is either registered or exported.
|
||||
if(NULL == true_type){
|
||||
boost::serialization::throw_exception(
|
||||
archive_exception(
|
||||
archive_exception::unregistered_class,
|
||||
"derived class not registered or exported"
|
||||
)
|
||||
boost::throw_exception(
|
||||
archive_exception(archive_exception::unregistered_class)
|
||||
);
|
||||
}
|
||||
|
||||
@@ -409,75 +381,78 @@ struct save_pointer_type {
|
||||
}
|
||||
// convert pointer to more derived type. if this is thrown
|
||||
// it means that the base/derived relationship hasn't be registered
|
||||
vp = serialization::void_downcast(
|
||||
*true_type,
|
||||
*this_type,
|
||||
static_cast<const void *>(&t)
|
||||
);
|
||||
vp = serialization::void_downcast(*true_type, *this_type, &t);
|
||||
if(NULL == vp){
|
||||
boost::serialization::throw_exception(
|
||||
archive_exception(
|
||||
archive_exception::unregistered_cast,
|
||||
true_type->get_debug_info(),
|
||||
this_type->get_debug_info()
|
||||
)
|
||||
boost::throw_exception(
|
||||
archive_exception(archive_exception::unregistered_cast)
|
||||
);
|
||||
}
|
||||
|
||||
// since true_type is valid, and this only gets made if the
|
||||
// pointer oserializer object has been created, this should never
|
||||
// fail
|
||||
const basic_pointer_oserializer * bpos
|
||||
= static_cast<const basic_pointer_oserializer *>(
|
||||
boost::serialization::singleton<
|
||||
archive_serializer_map<Archive>
|
||||
>::get_const_instance().find(*true_type)
|
||||
);
|
||||
const basic_pointer_oserializer * bpos
|
||||
= archive_pointer_oserializer<Archive>::find(* true_type);
|
||||
assert(NULL != bpos);
|
||||
if(NULL == bpos)
|
||||
boost::serialization::throw_exception(
|
||||
archive_exception(
|
||||
archive_exception::unregistered_class,
|
||||
bpos->get_debug_info()
|
||||
)
|
||||
boost::throw_exception(
|
||||
archive_exception(archive_exception::unregistered_class)
|
||||
);
|
||||
ar.save_pointer(vp, bpos);
|
||||
}
|
||||
};
|
||||
|
||||
// out of line selector works around borland quirk
|
||||
template<class T>
|
||||
struct conditional {
|
||||
typedef BOOST_DEDUCED_TYPENAME mpl::eval_if<
|
||||
is_polymorphic<T>,
|
||||
mpl::identity<polymorphic<T> >,
|
||||
mpl::identity<non_polymorphic<T> >
|
||||
>::type type;
|
||||
};
|
||||
|
||||
// used to convert TPtr in to a pointer to a T
|
||||
template<class T>
|
||||
static void save(
|
||||
Archive & ar,
|
||||
const T & t
|
||||
){
|
||||
check_pointer_level<T>();
|
||||
check_pointer_tracking<T>();
|
||||
typedef BOOST_DEDUCED_TYPENAME mpl::eval_if<
|
||||
is_polymorphic<T>,
|
||||
mpl::identity<polymorphic>,
|
||||
mpl::identity<non_polymorphic>
|
||||
>::type type;
|
||||
type::save(ar, const_cast<T &>(t));
|
||||
conditional<T>::type::save(ar, const_cast<T &>(t));
|
||||
}
|
||||
|
||||
template<class T>
|
||||
static void const_check(T & t){
|
||||
BOOST_STATIC_ASSERT(! boost::is_const<T>::value);
|
||||
}
|
||||
|
||||
template<class TPtr>
|
||||
static void invoke(Archive &ar, const TPtr t){
|
||||
#ifdef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
|
||||
// if your program traps here, its because you tried to do
|
||||
// something like ar << t where t is a pointer to a const value
|
||||
// void f3(A const* a, text_oarchive& oa)
|
||||
// {
|
||||
// oa << a;
|
||||
// }
|
||||
// with a compiler which doesn't support remove_const
|
||||
// const_check(* t);
|
||||
#else
|
||||
// otherwise remove the const
|
||||
#endif
|
||||
register_type(ar, * t);
|
||||
if(NULL == t){
|
||||
basic_oarchive & boa
|
||||
= boost::serialization::smart_cast_reference<basic_oarchive &>(ar);
|
||||
basic_oarchive & boa = boost::smart_cast_reference<basic_oarchive &>(ar);
|
||||
boa.save_null_pointer();
|
||||
save_access::end_preamble(ar);
|
||||
return;
|
||||
}
|
||||
save(ar, * t);
|
||||
}
|
||||
};
|
||||
};
|
||||
|
||||
template<class Archive>
|
||||
template<class Archive, class T>
|
||||
struct save_enum_type
|
||||
{
|
||||
template<class T>
|
||||
static void invoke(Archive &ar, const T &t){
|
||||
// convert enum to integers on save
|
||||
const int i = static_cast<int>(t);
|
||||
@@ -485,20 +460,18 @@ struct save_enum_type
|
||||
}
|
||||
};
|
||||
|
||||
template<class Archive>
|
||||
template<class Archive, class T>
|
||||
struct save_array_type
|
||||
{
|
||||
template<class T>
|
||||
static void invoke(Archive &ar, const T &t){
|
||||
typedef BOOST_DEDUCED_TYPENAME boost::remove_extent<T>::type value_type;
|
||||
|
||||
save_access::end_preamble(ar);
|
||||
// consider alignment
|
||||
std::size_t c = sizeof(t) / (
|
||||
int count = sizeof(t) / (
|
||||
static_cast<const char *>(static_cast<const void *>(&t[1]))
|
||||
- static_cast<const char *>(static_cast<const void *>(&t[0]))
|
||||
);
|
||||
boost::serialization::collection_size_type count(c);
|
||||
ar << BOOST_SERIALIZATION_NVP(count);
|
||||
ar << serialization::make_array(static_cast<value_type const*>(&t[0]),count);
|
||||
}
|
||||
@@ -507,24 +480,58 @@ struct save_array_type
|
||||
} // detail
|
||||
|
||||
template<class Archive, class T>
|
||||
inline void save(Archive & ar, /*const*/ T &t){
|
||||
inline void save(Archive & ar, const T &t){
|
||||
typedef
|
||||
BOOST_DEDUCED_TYPENAME mpl::eval_if<is_pointer<T>,
|
||||
mpl::identity<detail::save_pointer_type<Archive> >,
|
||||
mpl::identity<detail::save_pointer_type<Archive, T> >,
|
||||
//else
|
||||
BOOST_DEDUCED_TYPENAME mpl::eval_if<is_enum<T>,
|
||||
mpl::identity<detail::save_enum_type<Archive> >,
|
||||
mpl::identity<detail::save_enum_type<Archive, T> >,
|
||||
//else
|
||||
BOOST_DEDUCED_TYPENAME mpl::eval_if<is_array<T>,
|
||||
mpl::identity<detail::save_array_type<Archive> >,
|
||||
mpl::identity<detail::save_array_type<Archive, T> >,
|
||||
//else
|
||||
mpl::identity<detail::save_non_pointer_type<Archive> >
|
||||
mpl::identity<detail::save_non_pointer_type<Archive, T> >
|
||||
>
|
||||
>
|
||||
>::type typex;
|
||||
typex::invoke(ar, t);
|
||||
}
|
||||
|
||||
#ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING
|
||||
|
||||
template<class T>
|
||||
struct check_tracking {
|
||||
typedef BOOST_DEDUCED_TYPENAME mpl::if_<
|
||||
// if its never tracked.
|
||||
BOOST_DEDUCED_TYPENAME mpl::equal_to<
|
||||
serialization::tracking_level<T>,
|
||||
mpl::int_<serialization::track_never>
|
||||
>,
|
||||
// it better not be a pointer
|
||||
mpl::not_<is_pointer<T> >,
|
||||
//else
|
||||
// otherwise if it might be tracked. So there shouldn't
|
||||
// be any problem making a const
|
||||
is_const<T>
|
||||
>::type typex;
|
||||
BOOST_STATIC_CONSTANT(bool, value = typex::value);
|
||||
};
|
||||
|
||||
template<class Archive, class T>
|
||||
inline void save(Archive & ar, T &t){
|
||||
// if your program traps here, it indicates that your doing one of the following:
|
||||
// a) serializing an object of a type marked "track_never" through a pointer.
|
||||
// b) saving an non-const object of a type not markd "track_never)
|
||||
// Either of these conditions may be an indicator of an error usage of the
|
||||
// serialization library and should be double checked. See documentation on
|
||||
// object tracking. Also, see the "rationale" section of the documenation
|
||||
// for motivation for this checking.
|
||||
BOOST_STATIC_WARNING(check_tracking<T>::value);
|
||||
save(ar, const_cast<const T &>(t));
|
||||
}
|
||||
#endif
|
||||
|
||||
} // namespace archive
|
||||
} // namespace boost
|
||||
|
||||
|
||||
@@ -16,9 +16,11 @@
|
||||
|
||||
// See http://www.boost.org for updates, documentation, and revision history.
|
||||
|
||||
#include <cstddef>
|
||||
#include <string>
|
||||
#include <ostream>
|
||||
#include <cstddef>
|
||||
#include <boost/noncopyable.hpp>
|
||||
#include <boost/cstdint.hpp>
|
||||
|
||||
#include <boost/config.hpp>
|
||||
#if defined(BOOST_NO_STDC_NAMESPACE)
|
||||
@@ -27,8 +29,6 @@ namespace std{
|
||||
} // namespace std
|
||||
#endif
|
||||
|
||||
#include <boost/cstdint.hpp>
|
||||
#include <boost/integer_traits.hpp>
|
||||
#include <boost/archive/polymorphic_iarchive.hpp>
|
||||
#include <boost/archive/detail/abi_prefix.hpp> // must be the last header
|
||||
|
||||
@@ -42,17 +42,13 @@ namespace detail{
|
||||
class BOOST_ARCHIVE_DECL(BOOST_PP_EMPTY()) basic_iserializer;
|
||||
class BOOST_ARCHIVE_DECL(BOOST_PP_EMPTY()) basic_pointer_iserializer;
|
||||
|
||||
#ifdef BOOST_MSVC
|
||||
# pragma warning(push)
|
||||
# pragma warning(disable : 4511 4512)
|
||||
#endif
|
||||
|
||||
template<class ArchiveImplementation>
|
||||
class polymorphic_iarchive_route :
|
||||
public polymorphic_iarchive,
|
||||
// note: gcc dynamic cross cast fails if the the derivation below is
|
||||
// not public. I think this is a mistake.
|
||||
public /*protected*/ ArchiveImplementation
|
||||
public /*protected*/ ArchiveImplementation,
|
||||
private boost::noncopyable
|
||||
{
|
||||
private:
|
||||
// these are used by the serialization library.
|
||||
@@ -71,10 +67,10 @@ private:
|
||||
){
|
||||
return ArchiveImplementation::load_pointer(t, bpis_ptr, finder);
|
||||
}
|
||||
virtual void set_library_version(library_version_type archive_library_version){
|
||||
virtual void set_library_version(unsigned int archive_library_version){
|
||||
ArchiveImplementation::set_library_version(archive_library_version);
|
||||
}
|
||||
virtual library_version_type get_library_version() const{
|
||||
virtual unsigned int get_library_version() const{
|
||||
return ArchiveImplementation::get_library_version();
|
||||
}
|
||||
virtual unsigned int get_flags() const {
|
||||
@@ -130,18 +126,11 @@ private:
|
||||
virtual void load(unsigned long & t){
|
||||
ArchiveImplementation::load(t);
|
||||
}
|
||||
#if defined(BOOST_HAS_LONG_LONG)
|
||||
virtual void load(boost::long_long_type & t){
|
||||
#if !defined(BOOST_NO_INTRINSIC_INT64_T)
|
||||
virtual void load(boost::int64_t & t){
|
||||
ArchiveImplementation::load(t);
|
||||
}
|
||||
virtual void load(boost::ulong_long_type & t){
|
||||
ArchiveImplementation::load(t);
|
||||
}
|
||||
#elif defined(BOOST_HAS_MS_INT64)
|
||||
virtual void load(__int64 & t){
|
||||
ArchiveImplementation::load(t);
|
||||
}
|
||||
virtual void load(unsigned __int64 & t){
|
||||
virtual void load(boost::uint64_t & t){
|
||||
ArchiveImplementation::load(t);
|
||||
}
|
||||
#endif
|
||||
@@ -202,10 +191,6 @@ public:
|
||||
} // namespace archive
|
||||
} // namespace boost
|
||||
|
||||
#ifdef BOOST_MSVC
|
||||
#pragma warning(pop)
|
||||
#endif
|
||||
|
||||
#include <boost/archive/detail/abi_suffix.hpp> // pops abi_suffix.hpp pragmas
|
||||
|
||||
#endif // BOOST_ARCHIVE_DETAIL_POLYMORPHIC_IARCHIVE_DISPATCH_HPP
|
||||
|
||||
@@ -18,6 +18,8 @@
|
||||
|
||||
#include <string>
|
||||
#include <ostream>
|
||||
#include <boost/noncopyable.hpp>
|
||||
#include <boost/cstdint.hpp>
|
||||
#include <cstddef> // size_t
|
||||
|
||||
#include <boost/config.hpp>
|
||||
@@ -27,8 +29,6 @@ namespace std{
|
||||
} // namespace std
|
||||
#endif
|
||||
|
||||
#include <boost/cstdint.hpp>
|
||||
#include <boost/integer_traits.hpp>
|
||||
#include <boost/archive/polymorphic_oarchive.hpp>
|
||||
#include <boost/archive/detail/abi_prefix.hpp> // must be the last header
|
||||
|
||||
@@ -42,17 +42,13 @@ namespace detail{
|
||||
class BOOST_ARCHIVE_DECL(BOOST_PP_EMPTY()) basic_oserializer;
|
||||
class BOOST_ARCHIVE_DECL(BOOST_PP_EMPTY()) basic_pointer_oserializer;
|
||||
|
||||
#ifdef BOOST_MSVC
|
||||
# pragma warning(push)
|
||||
# pragma warning(disable : 4511 4512)
|
||||
#endif
|
||||
|
||||
template<class ArchiveImplementation>
|
||||
class polymorphic_oarchive_route :
|
||||
public polymorphic_oarchive,
|
||||
// note: gcc dynamic cross cast fails if the the derivation below is
|
||||
// not public. I think this is a mistake.
|
||||
public /*protected*/ ArchiveImplementation
|
||||
public /*protected*/ ArchiveImplementation,
|
||||
private boost::noncopyable
|
||||
{
|
||||
private:
|
||||
// these are used by the serialization library.
|
||||
@@ -109,14 +105,7 @@ private:
|
||||
virtual void save(const unsigned long t){
|
||||
ArchiveImplementation::save(t);
|
||||
}
|
||||
#if defined(BOOST_HAS_LONG_LONG)
|
||||
virtual void save(const boost::long_long_type t){
|
||||
ArchiveImplementation::save(t);
|
||||
}
|
||||
virtual void save(const boost::ulong_long_type t){
|
||||
ArchiveImplementation::save(t);
|
||||
}
|
||||
#elif defined(BOOST_HAS_MS_INT64)
|
||||
#if !defined(BOOST_NO_INTRINSIC_INT64_T)
|
||||
virtual void save(const boost::int64_t t){
|
||||
ArchiveImplementation::save(t);
|
||||
}
|
||||
@@ -138,7 +127,7 @@ private:
|
||||
ArchiveImplementation::save(t);
|
||||
}
|
||||
#endif
|
||||
virtual library_version_type get_library_version() const{
|
||||
virtual unsigned int get_library_version() const{
|
||||
return ArchiveImplementation::get_library_version();
|
||||
}
|
||||
virtual unsigned int get_flags() const {
|
||||
@@ -190,10 +179,6 @@ public:
|
||||
} // namespace archive
|
||||
} // namespace boost
|
||||
|
||||
#ifdef BOOST_MSVC
|
||||
#pragma warning(pop)
|
||||
#endif
|
||||
|
||||
#include <boost/archive/detail/abi_suffix.hpp> // pops abi_suffix.hpp pragmas
|
||||
|
||||
#endif // BOOST_ARCHIVE_DETAIL_POLYMORPHIC_OARCHIVE_DISPATCH_HPP
|
||||
|
||||
@@ -28,44 +28,6 @@ struct _ptr_serialization_support
|
||||
typedef int type;
|
||||
};
|
||||
|
||||
#ifdef __SUNPRO_CC
|
||||
|
||||
template<int N>
|
||||
struct counter : counter<N-1> {};
|
||||
template<>
|
||||
struct counter<0> {};
|
||||
|
||||
template<class Serializable>
|
||||
void instantiate_ptr_serialization(Serializable* s, int, adl_tag) {
|
||||
instantiate_ptr_serialization(s, counter<20>());
|
||||
}
|
||||
|
||||
template<class Archive>
|
||||
struct get_counter {
|
||||
static const int value = sizeof(adjust_counter(counter<20>()));
|
||||
typedef counter<value> type;
|
||||
typedef counter<value - 1> prior;
|
||||
typedef char (&next)[value+1];
|
||||
};
|
||||
|
||||
char adjust_counter(counter<0>);
|
||||
template<class Serializable>
|
||||
void instantiate_ptr_serialization(Serializable*, counter<0>) {}
|
||||
|
||||
#define BOOST_SERIALIZATION_REGISTER_ARCHIVE(Archive) \
|
||||
namespace boost { namespace archive { namespace detail { \
|
||||
get_counter<Archive >::next adjust_counter(get_counter<Archive >::type);\
|
||||
template<class Serializable> \
|
||||
void instantiate_ptr_serialization(Serializable* s, \
|
||||
get_counter<Archive >::type) { \
|
||||
ptr_serialization_support<Archive, Serializable> x; \
|
||||
instantiate_ptr_serialization(s, get_counter<Archive >::prior()); \
|
||||
}\
|
||||
}}}
|
||||
|
||||
|
||||
#else
|
||||
|
||||
// This function gets called, but its only purpose is to participate
|
||||
// in overload resolution with the functions declared by
|
||||
// BOOST_SERIALIZATION_REGISTER_ARCHIVE, below.
|
||||
@@ -85,7 +47,7 @@ BOOST_DEDUCED_TYPENAME _ptr_serialization_support<Archive, Serializable>::type
|
||||
instantiate_ptr_serialization( Serializable*, Archive*, adl_tag ); \
|
||||
\
|
||||
}}}
|
||||
#endif
|
||||
|
||||
}}} // namespace boost::archive::detail
|
||||
|
||||
#endif // BOOST_ARCHIVE_DETAIL_INSTANTIATE_SERIALIZE_DWA2006521_HPP
|
||||
|
||||
@@ -0,0 +1,79 @@
|
||||
/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
|
||||
// pointer_iserializer.ipp:
|
||||
|
||||
// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
|
||||
// Use, modification and distribution is subject to the Boost Software
|
||||
// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
// See http://www.boost.org for updates, documentation, and revision history.
|
||||
|
||||
#include <utility>
|
||||
#include <cassert>
|
||||
|
||||
#include <boost/config.hpp> // msvc 6.0 needs this for warning suppression
|
||||
|
||||
#include <boost/serialization/singleton.hpp>
|
||||
#include <boost/archive/detail/basic_serializer_map.hpp>
|
||||
#include <boost/archive/detail/archive_pointer_iserializer.hpp>
|
||||
|
||||
namespace boost {
|
||||
namespace archive {
|
||||
namespace detail {
|
||||
|
||||
namespace { // anon
|
||||
template<class Archive>
|
||||
class iserializer_map : public basic_serializer_map
|
||||
{
|
||||
};
|
||||
}
|
||||
|
||||
template<class Archive>
|
||||
BOOST_ARCHIVE_OR_WARCHIVE_DECL(BOOST_PP_EMPTY())
|
||||
archive_pointer_iserializer<Archive>::archive_pointer_iserializer(
|
||||
const boost::serialization::extended_type_info & eti
|
||||
) :
|
||||
basic_pointer_iserializer(eti)
|
||||
{
|
||||
std::pair<BOOST_DEDUCED_TYPENAME iserializer_map<Archive>::iterator, bool> result;
|
||||
result = serialization::singleton<
|
||||
iserializer_map<Archive>
|
||||
>::get_mutable_instance().insert(this);
|
||||
assert(result.second);
|
||||
}
|
||||
|
||||
template<class Archive>
|
||||
BOOST_ARCHIVE_OR_WARCHIVE_DECL(const basic_pointer_iserializer *)
|
||||
archive_pointer_iserializer<Archive>::find(
|
||||
const boost::serialization::extended_type_info & eti
|
||||
){
|
||||
const basic_serializer_arg bs(eti);
|
||||
BOOST_DEDUCED_TYPENAME iserializer_map<Archive>::const_iterator it;
|
||||
it = boost::serialization::singleton<
|
||||
iserializer_map<Archive>
|
||||
>::get_const_instance().find(& bs);
|
||||
assert(
|
||||
it
|
||||
!=
|
||||
boost::serialization::singleton<
|
||||
iserializer_map<Archive>
|
||||
>::get_const_instance().end()
|
||||
);
|
||||
return static_cast<const basic_pointer_iserializer *>(*it);
|
||||
}
|
||||
|
||||
template<class Archive>
|
||||
BOOST_ARCHIVE_OR_WARCHIVE_DECL(BOOST_PP_EMPTY())
|
||||
archive_pointer_iserializer<Archive>::~archive_pointer_iserializer(){
|
||||
// note: we need to check that the map still exists as we can't depend
|
||||
// on static variables being constructed in a specific sequence
|
||||
unsigned int count;
|
||||
count = serialization::singleton<
|
||||
iserializer_map<Archive>
|
||||
>::get_mutable_instance().erase(this);
|
||||
assert(count);
|
||||
}
|
||||
|
||||
} // namespace detail
|
||||
} // namespace archive
|
||||
} // namespace boost
|
||||
@@ -0,0 +1,82 @@
|
||||
/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
|
||||
// archive_pointer_oserializer.ipp:
|
||||
|
||||
// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
|
||||
// Use, modification and distribution is subject to the Boost Software
|
||||
// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
// See http://www.boost.org for updates, documentation, and revision history.
|
||||
|
||||
#include <utility>
|
||||
#include <cassert>
|
||||
|
||||
#include <boost/config.hpp> // msvc 6.0 needs this for warning suppression
|
||||
|
||||
#include <boost/archive/detail/archive_pointer_oserializer.hpp>
|
||||
#include <boost/archive/detail/basic_serializer_map.hpp>
|
||||
#include <boost/serialization/singleton.hpp>
|
||||
|
||||
namespace boost {
|
||||
namespace archive {
|
||||
namespace detail {
|
||||
|
||||
namespace { // anon
|
||||
template<class Archive>
|
||||
class oserializer_map : public basic_serializer_map
|
||||
{
|
||||
};
|
||||
}
|
||||
|
||||
template<class Archive>
|
||||
BOOST_ARCHIVE_OR_WARCHIVE_DECL(BOOST_PP_EMPTY())
|
||||
archive_pointer_oserializer<Archive>::archive_pointer_oserializer(
|
||||
const boost::serialization::extended_type_info & eti
|
||||
) :
|
||||
basic_pointer_oserializer(eti)
|
||||
{
|
||||
std::pair<
|
||||
BOOST_DEDUCED_TYPENAME oserializer_map<Archive>::iterator,
|
||||
bool
|
||||
> result;
|
||||
result = serialization::singleton<
|
||||
oserializer_map<Archive>
|
||||
>::get_mutable_instance().insert(this);
|
||||
assert(result.second);
|
||||
}
|
||||
|
||||
template<class Archive>
|
||||
BOOST_ARCHIVE_OR_WARCHIVE_DECL(const basic_pointer_oserializer *)
|
||||
archive_pointer_oserializer<Archive>::find(
|
||||
const boost::serialization::extended_type_info & eti
|
||||
){
|
||||
const basic_serializer_arg bs(eti);
|
||||
basic_serializer_map::const_iterator it;
|
||||
it = boost::serialization::singleton<
|
||||
oserializer_map<Archive>
|
||||
>::get_const_instance().find(& bs);
|
||||
assert(
|
||||
it
|
||||
!=
|
||||
boost::serialization::singleton<
|
||||
oserializer_map<Archive>
|
||||
>::get_const_instance().end()
|
||||
);
|
||||
return static_cast<const basic_pointer_oserializer *>(*it);
|
||||
}
|
||||
|
||||
template<class Archive>
|
||||
BOOST_ARCHIVE_OR_WARCHIVE_DECL(BOOST_PP_EMPTY())
|
||||
archive_pointer_oserializer<Archive>::~archive_pointer_oserializer(){
|
||||
// note: we need to check that the map still exists as we can't depend
|
||||
// on static variables being constructed in a specific sequence
|
||||
unsigned int count;
|
||||
count = serialization::singleton<
|
||||
oserializer_map<Archive>
|
||||
>::get_mutable_instance().erase(this);
|
||||
assert(count);
|
||||
}
|
||||
|
||||
} // namespace detail
|
||||
} // namespace archive
|
||||
} // namespace boost
|
||||
@@ -1,71 +0,0 @@
|
||||
/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
|
||||
// archive_serializer_map.ipp:
|
||||
|
||||
// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
|
||||
// Distributed under the Boost Software License, Version 1.0. (See
|
||||
// accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
// See http://www.boost.org for updates, documentation, and revision history.
|
||||
|
||||
//////////////////////////////////////////////////////////////////////
|
||||
// implementation of basic_text_iprimitive overrides for the combination
|
||||
// of template parameters used to implement a text_iprimitive
|
||||
|
||||
#include <boost/config.hpp>
|
||||
#include <boost/archive/detail/archive_serializer_map.hpp>
|
||||
#include <boost/archive/detail/basic_serializer_map.hpp>
|
||||
#include <boost/serialization/singleton.hpp>
|
||||
|
||||
namespace boost {
|
||||
namespace archive {
|
||||
namespace detail {
|
||||
|
||||
#ifdef BOOST_MSVC
|
||||
# pragma warning(push)
|
||||
# pragma warning(disable : 4511 4512)
|
||||
#endif
|
||||
|
||||
namespace { // anon
|
||||
template<class Archive>
|
||||
class map : public basic_serializer_map
|
||||
{};
|
||||
}
|
||||
|
||||
#ifdef BOOST_MSVC
|
||||
# pragma warning(pop)
|
||||
#endif
|
||||
|
||||
template<class Archive>
|
||||
BOOST_ARCHIVE_OR_WARCHIVE_DECL(bool)
|
||||
archive_serializer_map<Archive>::insert(const basic_serializer * bs){
|
||||
return boost::serialization::singleton<
|
||||
map<Archive>
|
||||
>::get_mutable_instance().insert(bs);
|
||||
}
|
||||
|
||||
template<class Archive>
|
||||
BOOST_ARCHIVE_OR_WARCHIVE_DECL(void)
|
||||
archive_serializer_map<Archive>::erase(const basic_serializer * bs){
|
||||
if(boost::serialization::singleton<
|
||||
map<Archive>
|
||||
>::is_destroyed())
|
||||
return;
|
||||
boost::serialization::singleton<
|
||||
map<Archive>
|
||||
>::get_mutable_instance().erase(bs);
|
||||
}
|
||||
|
||||
template<class Archive>
|
||||
BOOST_ARCHIVE_OR_WARCHIVE_DECL(const basic_serializer *)
|
||||
archive_serializer_map<Archive>::find(
|
||||
const boost::serialization::extended_type_info & eti
|
||||
) {
|
||||
return boost::serialization::singleton<
|
||||
map<Archive>
|
||||
>::get_const_instance().find(eti);
|
||||
}
|
||||
|
||||
} // namespace detail
|
||||
} // namespace archive
|
||||
} // namespace boost
|
||||
@@ -16,8 +16,6 @@
|
||||
#if defined(BOOST_NO_STDC_NAMESPACE)
|
||||
namespace std{
|
||||
using ::memcpy;
|
||||
using ::strlen;
|
||||
using ::size_t;
|
||||
}
|
||||
#endif
|
||||
|
||||
@@ -37,7 +35,7 @@ basic_binary_iarchive<Archive>::load_override(class_name_type & t, int){
|
||||
cn.reserve(BOOST_SERIALIZATION_MAX_KEY_SIZE);
|
||||
load_override(cn, 0);
|
||||
if(cn.size() > (BOOST_SERIALIZATION_MAX_KEY_SIZE - 1))
|
||||
boost::serialization::throw_exception(
|
||||
boost::throw_exception(
|
||||
archive_exception(archive_exception::invalid_class_name)
|
||||
);
|
||||
std::memcpy(t, cn.data(), cn.size());
|
||||
@@ -50,32 +48,15 @@ BOOST_ARCHIVE_OR_WARCHIVE_DECL(void)
|
||||
basic_binary_iarchive<Archive>::init(){
|
||||
// read signature in an archive version independent manner
|
||||
std::string file_signature;
|
||||
try {
|
||||
std::size_t l;
|
||||
this->This()->load(l);
|
||||
if(l == std::strlen(BOOST_ARCHIVE_SIGNATURE())) {
|
||||
// borland de-allocator fixup
|
||||
#if BOOST_WORKAROUND(_RWSTD_VER, BOOST_TESTED_AT(20101))
|
||||
if(NULL != file_signature.data())
|
||||
#endif
|
||||
file_signature.resize(l);
|
||||
// note breaking a rule here - could be a problem on some platform
|
||||
if(0 < l)
|
||||
this->This()->load_binary(&(*file_signature.begin()), l);
|
||||
}
|
||||
}
|
||||
catch(archive_exception const &) { // catch stream_error archive exceptions
|
||||
// will cause invalid_signature archive exception to be thrown below
|
||||
file_signature = "";
|
||||
}
|
||||
if(file_signature != BOOST_ARCHIVE_SIGNATURE())
|
||||
boost::serialization::throw_exception(
|
||||
* this->This() >> file_signature;
|
||||
if(file_signature != ARCHIVE_SIGNATURE())
|
||||
boost::throw_exception(
|
||||
archive_exception(archive_exception::invalid_signature)
|
||||
);
|
||||
|
||||
// make sure the version of the reading archive library can
|
||||
// support the format of the archive being read
|
||||
library_version_type input_library_version;
|
||||
version_type input_library_version;
|
||||
* this->This() >> input_library_version;
|
||||
|
||||
#if BOOST_WORKAROUND(__MWERKS__, BOOST_TESTED_AT(0x3205))
|
||||
@@ -87,8 +68,9 @@ basic_binary_iarchive<Archive>::init(){
|
||||
basic_iarchive::set_library_version(input_library_version);
|
||||
#endif
|
||||
|
||||
if(BOOST_ARCHIVE_VERSION() < input_library_version)
|
||||
boost::serialization::throw_exception(
|
||||
// extra little .t is to get around borland quirk
|
||||
if(ARCHIVE_VERSION() < input_library_version.t)
|
||||
boost::throw_exception(
|
||||
archive_exception(archive_exception::unsupported_version)
|
||||
);
|
||||
}
|
||||
|
||||
@@ -9,7 +9,7 @@
|
||||
// See http://www.boost.org for updates, documentation, and revision history.
|
||||
|
||||
#include <cassert>
|
||||
#include <cstddef> // size_t, NULL
|
||||
#include <cstddef> // size_t
|
||||
#include <cstring> // memcpy
|
||||
|
||||
#include <boost/config.hpp>
|
||||
@@ -22,7 +22,7 @@ namespace std{
|
||||
|
||||
#include <boost/detail/workaround.hpp> // fixup for RogueWave
|
||||
|
||||
#include <boost/serialization/throw_exception.hpp>
|
||||
#include <boost/throw_exception.hpp>
|
||||
#include <boost/scoped_ptr.hpp>
|
||||
|
||||
#include <boost/archive/archive_exception.hpp>
|
||||
@@ -45,46 +45,31 @@ basic_binary_iprimitive<Archive, Elem, Tr>::init()
|
||||
unsigned char size;
|
||||
this->This()->load(size);
|
||||
if(sizeof(int) != size)
|
||||
boost::serialization::throw_exception(
|
||||
archive_exception(
|
||||
archive_exception::incompatible_native_format,
|
||||
"size of int"
|
||||
)
|
||||
boost::throw_exception(
|
||||
archive_exception(archive_exception::incompatible_native_format)
|
||||
);
|
||||
this->This()->load(size);
|
||||
if(sizeof(long) != size)
|
||||
boost::serialization::throw_exception(
|
||||
archive_exception(
|
||||
archive_exception::incompatible_native_format,
|
||||
"size of long"
|
||||
)
|
||||
boost::throw_exception(
|
||||
archive_exception(archive_exception::incompatible_native_format)
|
||||
);
|
||||
this->This()->load(size);
|
||||
if(sizeof(float) != size)
|
||||
boost::serialization::throw_exception(
|
||||
archive_exception(
|
||||
archive_exception::incompatible_native_format,
|
||||
"size of float"
|
||||
)
|
||||
boost::throw_exception(
|
||||
archive_exception(archive_exception::incompatible_native_format)
|
||||
);
|
||||
this->This()->load(size);
|
||||
if(sizeof(double) != size)
|
||||
boost::serialization::throw_exception(
|
||||
archive_exception(
|
||||
archive_exception::incompatible_native_format,
|
||||
"size of double"
|
||||
)
|
||||
boost::throw_exception(
|
||||
archive_exception(archive_exception::incompatible_native_format)
|
||||
);
|
||||
|
||||
// for checking endian
|
||||
int i;
|
||||
this->This()->load(i);
|
||||
if(1 != i)
|
||||
boost::serialization::throw_exception(
|
||||
archive_exception(
|
||||
archive_exception::incompatible_native_format,
|
||||
"endian setting"
|
||||
)
|
||||
boost::throw_exception(
|
||||
archive_exception(archive_exception::incompatible_native_format)
|
||||
);
|
||||
}
|
||||
|
||||
@@ -92,10 +77,10 @@ template<class Archive, class Elem, class Tr>
|
||||
BOOST_ARCHIVE_OR_WARCHIVE_DECL(void)
|
||||
basic_binary_iprimitive<Archive, Elem, Tr>::load(wchar_t * ws)
|
||||
{
|
||||
std::size_t l; // number of wchar_t !!!
|
||||
std::size_t l;
|
||||
this->This()->load(l);
|
||||
load_binary(ws, l * sizeof(wchar_t) / sizeof(char));
|
||||
ws[l] = L'\0';
|
||||
ws[l / sizeof(wchar_t)] = L'\0';
|
||||
}
|
||||
|
||||
template<class Archive, class Elem, class Tr>
|
||||
@@ -197,11 +182,13 @@ template<class Archive, class Elem, class Tr>
|
||||
BOOST_ARCHIVE_OR_WARCHIVE_DECL(BOOST_PP_EMPTY())
|
||||
basic_binary_iprimitive<Archive, Elem, Tr>::~basic_binary_iprimitive(){
|
||||
// push back unread characters
|
||||
//destructor can't throw !
|
||||
try{
|
||||
static_cast<detail::input_streambuf_access<Elem, Tr> &>(m_sb).sync();
|
||||
}
|
||||
catch(...){
|
||||
int result = static_cast<detail::input_streambuf_access<Elem, Tr> &>(
|
||||
m_sb
|
||||
).sync();
|
||||
if(0 != result){
|
||||
boost::throw_exception(
|
||||
archive_exception(archive_exception::stream_error)
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
Some files were not shown because too many files have changed in this diff Show More
Reference in New Issue
Block a user