Implementation
The Archive concept specifies the functions that a class must implement to in order to be used to serialize -Serializable types. +Serializable types. + + The library implements a family of archives appropriate for different purposes. -This section describes how they have been implemented and how one can implement his own archive class. +This section describes how they have been implemented and one way one +can implement his own archive class. + Our discussion will focus on archives used for loading as the hierarchy is exactly analogous for archives used for saving data. + +Our archives have been factored in to a tree of classes in order to minimize repetition of code. This is shown in the accompanying class diagram. -All input archives should be derived from the following template: + +Any class which fullfills the following requirements will function as +a loading archive. + + +
Minimum Requirments
+The archive class is derived from:
template<class Archive>
detail::common_iarchive;
Minimum Requirments
An instance of the this template handles all the "bookkeeping" associated with serialization. In order to be a functional only the following additional -functions must be defined: +functions must be declared:void load(T &t);- This function must be implemented for all primitive data types. This can be -accomplished through the use of a member template or explict declarations -for all prmititive types. +accomplished through the use of a member template or explicit declarations +for all primitive types.
void load_binary(void *address, std::size_t size);
@@ -81,13 +92,12 @@ So, the most trivial implementation of an input archive would look like this:
#include <boost/archive/detail/common_iarchive.hpp>
-
/////////////////////////////////////////////////////////////////////////
// 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 priviledged access to permit
+ // permit serialization system privileged access to permit
// implementation of inline templates for maximum speed.
friend class boost::archive::load_access;
@@ -143,7 +153,7 @@ by XML archive to inject "</name>" after data.
-
Default:Does nothing.
Purpose:Called each time user data is saved. -Its not called when archive book keeping 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 @@ -226,7 +236,9 @@ One or more of the following issues may need to be addressed: all data objects.- Addressing any of the above may generate more issues to be addressed.
- The archives included with library are all templates which use a -
streamas a template parameter rather than simple classes. +streamor +streambuf+ as a template parameter rather than simple classes. Combined with the above, even more issues arise with non-conforming compilers. The attached class diagram @@ -241,17 +253,15 @@ EXCEPT for one special case.- Instances of a derived class are serialized through a base class pointer.
- Such instances are not "registered" neither implicitly nor explicitly. That
- is, the macro
BOOT_CLASS_EXPORTis used to instantiate the serialization - code for the included archives. + is, the macroBOOT_CLASS_EXPORTis used + to instantiate the serialization code for the included archives.
-before-#define BOOST_ARCHIVE_CUSTOM_OARCHIVE_TYPES trivial_oarchive -#define BOOST_ARCHIVE_CUSTOM_IARCHIVE_TYPES trivial_iarchive +#define BOOST_SERIALIZATION_REGISTER_ARCHIVE(Archive)BOOST_CLASS_EXPORTis invoked for any serializable class. Failure to do this will not inhibit the program from compiling, linking and executing properly - except in one case. If an instance of a derived class is serialized through a pointer to its base class, the program @@ -259,8 +269,7 @@ will throw anunregistered_classexception.-Only one of the above statements is permitted, However, any number of new archive -classes can be specified as list separated by commas. +
Testing
Exhaustive testing of the library requires testing the different aspects of object @@ -302,16 +311,16 @@ typedef std::ifstream test_istream; #define TEST_STREAM_FLAGS (std::ios_base::openmode)0 -To test a new archive, for example, portable binary archives, make a -header fileportable_binary_archive.hpp+To test a new archive, for example, portable binary archives, with the gcc compiler, +make a header fileportable_binary_archive.hppand invokebjamwith
-This process in encapsulated in the shell script --sBOOST_ARCHIVE_LIST=portable_binary_archive.hpprun_archive_testwhose command line is +This process in encapsulated in the shell or cmd script +library_testwhose command line is-run_archive_test <test header file> <toolset> [<boost root>] [<target directory>] +library_test --toolset=gcc -sBOOST_ARCHIVE_LIST=portable_binary_archive.hppPolymorphic Archives
@@ -367,9 +376,9 @@ As can be seen in the and the header files, this implementation is just a composition of the polymorphic interface and the standard template driven implementation. This composition is accomplished by the templates -polymorphic_iarchive_dispatch.hpp+polymorphic_iarchive_route.hppand -polymorphic_oarchive_dispatch.hpp. +polymorphic_oarchive_route.hpp. As these contain no code specific to the particular implementation archive, they can be used to create a polymorphic archive implementation from any functioning templated archive implementation.diff --git a/doc/archives.html b/doc/archives.html index 6444023d..7ac2886a 100644 --- a/doc/archives.html +++ b/doc/archives.html @@ -41,14 +41,14 @@ In the following descriptions
Saving Archive Concept
Associated Types
Intuitively, a type modeling this concept will generate a sequence of bytes -correpsonding to an arbitrary set of C++ data structures. Each type modeling the +corresponding to an arbitrary set of C++ data structures. Each type modeling the Saving Archive concept (SA) may be associated with another type modeling the Loading Archive Concept(LA). This associated type will perform the inverse operation. That is, given a sequence of bytes generated by SA, it will generate a set of -C++ data structures the is equivalent to the original. +C++ data structures that is equivalent to the original. The notion of equivalence is defined by the implementations of the pair of archives and the -way the data is are rendered serializable. +way the data are rendered serializable.Valid Expressions
-
@@ -190,8 +190,8 @@ equivalent to the original.
moved to address v.
When an object is loaded to a temporary variable and later moved to another location, - This function must be called in order communicate this fact. This is permits the - the archive to properly implement object tracking. Object tracking is required in order + this function must be called in order communicate this fact. This permits the + archive to properly implement object tracking. Object tracking is required in order to correctly implement serialization of pointers to instances of derived classes.
@@ -215,7 +215,7 @@ archives is discussed inThe existence of the
<<-and>>suggest +and>>suggests a relationship between archives and C++ i/o streams. Archives are not C++ i/o streams. All the archives included with this system take a stream as an argument in the constructor and that stream is used for output or input. @@ -224,7 +224,7 @@ archive interface. It just turns out that the archives written so far have found it useful to base their implementation on streams.Archive Models
-This library includes a various implementation of the Archive concept. +This library includes various implementations of the Archive concept. An archive is defined by two complementary classes. One is for saving data while the other is for loading it. @@ -307,7 +307,7 @@ public: text_oarchive(std::ostream & os, unsigned int flags = 0);-
-Contructs an archive given an open
streamas +Constructs an archive given an openstreamas an argument and optional flags. For most applications there will be no need to use flags. Flags are defined byenum archive_flagsenumerator. Multiple flags can be combined with the|operator. @@ -339,7 +339,7 @@ tags, useno_xml_tag_checkingflag.- Destructor for an archive. This should be called before the stream is closed. It restores any altered stream facets to their state before the -the archive was opened. +archive was opened.
Exceptions
All of the archive classes included may throw exceptions. The list of exceptions that might -be throw can be found in section Archive Exceptions +be thrown can be found in section Archive Exceptions of this documentation.Character Sets
This library includes two archive classes for XML. The wide character -version (xml_w?archive) renders it output as UTF-8 which can
+version (xml_w?archive) renders its output as UTF-8 which can
handle any wide character without loss of information.
std::string data is converted from multi-byte format to wide
character format using the current
diff --git a/doc/class_diagram.html b/doc/class_diagram.html
index e6a5f9a5..8d652879 100644
--- a/doc/class_diagram.html
+++ b/doc/class_diagram.html
@@ -52,14 +52,14 @@ common_iarchive<text_iarchive> text_iarchive_impl<text_iarchive> -> polymorphic_iarchive ->
+text_iarchive_impl<text_iarchive> -> polymorphic_iarchive_impl ->
| \ |
| \ |
- | \_____________________________________ |
+ | \_____________________________________ polymorphic_iarchive ->
| \ /
| \ /
| \ /
-text_iarchive -> polymorphic_iarchive_dispatch<text_iarchive_impl<text_iarchive> > ->
+text_iarchive -> polymorphic_iarchive_route<text_iarchive_impl<text_iarchive> > ->
|
|
|
@@ -68,7 +68,7 @@ common_iarchive<text_iarchive> blue
implement loading for a given archive type. (in this case its text archives).
Users include classes in red to load their data from a partcular
@@ -146,11 +146,11 @@ never change. They are in namespace boost::archive::detail
for all archives present and future.
- polymorphic_iarchive_dispatch<text_iarchive_impl<text_iarchive> >
+ polymorphic_iarchive_route<text_iarchive_impl<text_iarchive> >
This class implements the polymorphic_iarchive in terms of a specific
- concrete class. Virtual function calls are forwarded to the implementing class. In this example,
+ concrete class. Virtual function calls are routed to the implementing class. In this example,
that implementing class would be text_iarchive_impl.
@@ -158,7 +158,7 @@ never change. They are in namespace boost::archive::detail
this is just a typedef so we can write polymorphic_text_archive rather than
- polymorphic_iarchive_dispatch<text_iarchive_impl<text_iarchive> >
+ polymorphic_iarchive_route<text_iarchive_impl<text_iarchive> >
diff --git a/doc/codecvt.html b/doc/codecvt.html
index 5ff6c2df..85e9e797 100644
--- a/doc/codecvt.html
+++ b/doc/codecvt.html
@@ -28,7 +28,7 @@ width="277" height="86">
-UTF-8 Codecvt Facet
+utf8_codecvt_facet
diff --git a/doc/contents.html b/doc/contents.html
index a6ea530a..7c5b22d5 100644
--- a/doc/contents.html
+++ b/doc/contents.html
@@ -1,4 +1,4 @@
-
+
+
+
+
+
+Serialization - Proposed Case Studies
+
+
+
+
+
+ 
+
+
+ Serialization
+ Proposed Case Studies
+
+
+
+
+
+
+These are not part of the library itself, but rather
+techiques on how to use the library to address specific situations.
+
+Serializing a Function Object
+An example on how to serialize a function object. I believe this
+could be done by serializing pointer to the object in question. Since
+the Serialization library resurrects pointer of the correct type
+this should be easily implementable.
+
+If a group of function objects were all derived from the
+same polymorphic base class - perhaps via multiple inheritance,
+the the function object effectively becomes a "variable" which
+encapsulates code.
+
+This case study would show how to do this.
+
+
Archive Adaptors
+
+Often users want to add their own special functionality to an
+existing archive. Examples of this are performance enhancements
+for specific types, Adjustment of output syntax for xml archives,
+and logging/debug output as archives are written and/or read.
+If this functionalty is implemented as an "adaptor" template
+which takes the base class as a template argument, such functionality
+appended to any archive for which that funtionality makes sense.
+For example, an adaptor for generating an xml schema could be
+appended to both wide narrow character versions of xml archives.
+
+This case study would show how to make a useful archive adaptor.
+
+
Archive Helpers
+Some types are not serializable as they stand. That is - they
+do not fullfill the requirements of the "Serializable Concept".
+The iconic example of this is boost::shared_ptr. Sometimes
+these types could be made serializable by adding code inside
+the library. Of course, doing that would create a lifetime
+of unpaid employment for the library author. Rather than
+adding a bunch of special code to the library itself, this
+code can packaged as a "helper" or "mix-in" class. Then
+a new archive is derived from both the "base" archive class
+AND the "helper" class. This is how boost::shared_ptr
+has been implemented.
+
+It would also be possible to make a "generic runtime helper"
+which would effectively extend the API of the library. Previously
+the library included such a helper class. It was removed
+in favor of the current implementation. But this functionality
+should be added back in with another adaptor which would
+become part of the library.
+
+
+Revised 1 November, 2008
+
© Copyright Robert Ramey 2002-2008.
+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)
+
+
+
diff --git a/doc/performance_status.html b/doc/performance_status.html
new file mode 100644
index 00000000..6ac4196f
--- /dev/null
+++ b/doc/performance_status.html
@@ -0,0 +1,30 @@
+
+
+Boost Library Status Automatic Test
+
+
+
+
+
+Library Status: serialization
+Run Date: 02:42:48 UTC, Tuesday 10 June 2008
+
+
+
+
+
+Test Name
+gcc-3.4.4
+
+profile
+ peformance_array_binary_archive Pass Profile peformance_array_text_archive Pass Profile peformance_array_text_warchive Missing peformance_array_xml_archive Pass Profile peformance_array_xml_warchive Missing performance_iterators Pass Profile performance_iterators_base64 Pass Profile
+
+
diff --git a/doc/profile1.txt b/doc/profile1.txt
new file mode 100644
index 00000000..db95c841
--- /dev/null
+++ b/doc/profile1.txt
@@ -0,0 +1,149 @@
+Flat profile:
+
+Each sample counts as 0.01 seconds.
+ no time accumulated
+
+ % cumulative self self total
+ time seconds seconds calls Ts/call Ts/call name
+ 0.00 0.00 0.00 200 0.00 0.00 void accumulate(unsigned int&, unsigned long const&)
+ 0.00 0.00 0.00 150 0.00 0.00 _pei386_runtime_relocator
+ 0.00 0.00 0.00 1 0.00 0.00 std::ostream::operator<<(void const*)
+ 0.00 0.00 0.00 1 0.00 0.00 __divdi3
+
+ % the percentage of the total running time of the
+time program used by this function.
+
+cumulative a running sum of the number of seconds accounted
+ seconds for by this function and those listed above it.
+
+ self the number of seconds accounted for by this
+seconds function alone. This is the major sort for this
+ listing.
+
+calls the number of times this function was invoked, if
+ this function is profiled, else blank.
+
+ self the average number of milliseconds spent in this
+ms/call function per call, if this function is profiled,
+ else blank.
+
+ total the average number of milliseconds spent in this
+ms/call function and its descendents per call, if this
+ function is profiled, else blank.
+
+name the name of the function. This is the minor sort
+ for this listing. The index shows the location of
+ the function in the gprof listing. If the index is
+ in parenthesis it shows where it would appear in
+ the gprof listing if it were to be printed.
+
+ Call graph (explanation follows)
+
+
+granularity: each sample hit covers 4 byte(s) no time propagated
+
+index % time self children called name
+ 0.00 0.00 200/200 setvbuf [1286]
+[4] 0.0 0.00 0.00 200 void accumulate(unsigned int&, unsigned long const&) [4]
+-----------------------------------------------
+ 0.00 0.00 150/150 _cygwin_crt0_common@8 [1230]
+[5] 0.0 0.00 0.00 150 _pei386_runtime_relocator [5]
+-----------------------------------------------
+ 0.00 0.00 1/1 _lseek64 [1234]
+[6] 0.0 0.00 0.00 1 std::ostream::operator<<(void const*) [6]
+-----------------------------------------------
+ 0.00 0.00 1/1 __tcf_1 [1221]
+[7] 0.0 0.00 0.00 1 __divdi3 [7]
+-----------------------------------------------
+ 2 main [1263]
+[1263] 0.0 0.00 0.00 0+2 main [1263]
+ 2 main [1263]
+-----------------------------------------------
+
+ This table describes the call tree of the program, and was sorted by
+ the total amount of time spent in each function and its children.
+
+ Each entry in this table consists of several lines. The line with the
+ index number at the left hand margin lists the current function.
+ The lines above it list the functions that called this function,
+ and the lines below it list the functions this one called.
+ This line lists:
+ index A unique number given to each element of the table.
+ Index numbers are sorted numerically.
+ The index number is printed next to every function name so
+ it is easier to look up where the function in the table.
+
+ % time This is the percentage of the `total' time that was spent
+ in this function and its children. Note that due to
+ different viewpoints, functions excluded by options, etc,
+ these numbers will NOT add up to 100%.
+
+ self This is the total amount of time spent in this function.
+
+ children This is the total amount of time propagated into this
+ function by its children.
+
+ called This is the number of times the function was called.
+ If the function called itself recursively, the number
+ only includes non-recursive calls, and is followed by
+ a `+' and the number of recursive calls.
+
+ name The name of the current function. The index number is
+ printed after it. If the function is a member of a
+ cycle, the cycle number is printed between the
+ function's name and the index number.
+
+
+ For the function's parents, the fields have the following meanings:
+
+ self This is the amount of time that was propagated directly
+ from the function into this parent.
+
+ children This is the amount of time that was propagated from
+ the function's children into this parent.
+
+ called This is the number of times this parent called the
+ function `/' the total number of times the function
+ was called. Recursive calls to the function are not
+ included in the number after the `/'.
+
+ name This is the name of the parent. The parent's index
+ number is printed after it. If the parent is a
+ member of a cycle, the cycle number is printed between
+ the name and the index number.
+
+ If the parents of the function cannot be determined, the word
+ `' is printed in the `name' field, and all the other
+ fields are blank.
+
+ For the function's children, the fields have the following meanings:
+
+ self This is the amount of time that was propagated directly
+ from the child into the function.
+
+ children This is the amount of time that was propagated from the
+ child's children to the function.
+
+ called This is the number of times the function called
+ this child `/' the total number of times the child
+ was called. Recursive calls by the child are not
+ listed in the number after the `/'.
+
+ name This is the name of the child. The child's index
+ number is printed after it. If the child is a
+ member of a cycle, the cycle number is printed
+ between the name and the index number.
+
+ If there are any cycles (circles) in the call graph, there is an
+ entry for the cycle-as-a-whole. This entry shows who called the
+ cycle (as parents) and the members of the cycle (as children.)
+ The `+' recursive calls entry shows the number of function calls that
+ were internal to the cycle, and the calls entry for each member shows,
+ for that member, how many times it was called from other members of
+ the cycle.
+
+
+Index by function name
+
+ [4] void accumulate(unsigned int&, unsigned long const&) [7] __divdi3
+ [6] std::ostream::operator<<(void const*) [5] _pei386_runtime_relocator
diff --git a/doc/profile2.txt b/doc/profile2.txt
new file mode 100644
index 00000000..a2cac6d2
--- /dev/null
+++ b/doc/profile2.txt
@@ -0,0 +1,203 @@
+Flat profile:
+
+Each sample counts as 0.01 seconds.
+ % cumulative self self total
+ time seconds seconds calls Ts/call Ts/call name
+100.00 0.01 0.01 __gnu_cxx::__atomic_add(int volatile*, int)
+ 0.00 0.01 0.00 51 0.00 0.00 boost::archive::iterators::transform_width::fill()
+ 0.00 0.01 0.00 36 0.00 0.00 boost::archive::iterators::transform_width<__gnu_cxx::__normal_iterator > >, 8, 6, char>::fill()
+ 0.00 0.01 0.00 30 0.00 0.00 std::vector >::_M_insert_aux(__gnu_cxx::__normal_iterator > >, char const&)
+ 0.00 0.01 0.00 11 0.00 0.00 boost::archive::iterators::xml_escape::fill(char const*&, char const*&)
+ 0.00 0.01 0.00 9 0.00 0.00 void test_transform_width<6, 8>(unsigned int)
+ 0.00 0.01 0.00 9 0.00 0.00 boost::archive::iterators::xml_unescape::drain()
+ 0.00 0.01 0.00 5 0.00 0.00 boost::archive::iterators::xml_unescape::drain_residue(char const*)
+ 0.00 0.01 0.00 2 0.00 0.00 __static_initialization_and_destruction_0(int, int)
+ 0.00 0.01 0.00 1 0.00 0.00 void test_xml_escape(char const*, char const*, unsigned int)
+ 0.00 0.01 0.00 1 0.00 0.00 void test_xml_unescape(char const*, char const*, unsigned int)
+ 0.00 0.01 0.00 1 0.00 0.00 void test_stream_iterators(char const*, unsigned int)
+ 0.00 0.01 0.00 1 0.00 0.00 test_main(int, char**)
+ 0.00 0.01 0.00 1 0.00 0.00 char* std::string::_S_construct(char*, char*, std::allocator const&, std::forward_iterator_tag)
+ 0.00 0.01 0.00 1 0.00 0.00 std::basic_string, std::allocator >::basic_string(char*, char*, std::allocator const&)
+
+ % the percentage of the total running time of the
+time program used by this function.
+
+cumulative a running sum of the number of seconds accounted
+ seconds for by this function and those listed above it.
+
+ self the number of seconds accounted for by this
+seconds function alone. This is the major sort for this
+ listing.
+
+calls the number of times this function was invoked, if
+ this function is profiled, else blank.
+
+ self the average number of milliseconds spent in this
+ms/call function per call, if this function is profiled,
+ else blank.
+
+ total the average number of milliseconds spent in this
+ms/call function and its descendents per call, if this
+ function is profiled, else blank.
+
+name the name of the function. This is the minor sort
+ for this listing. The index shows the location of
+ the function in the gprof listing. If the index is
+ in parenthesis it shows where it would appear in
+ the gprof listing if it were to be printed.
+
+ Call graph (explanation follows)
+
+
+granularity: each sample hit covers 4 byte(s) for 100.00% of 0.01 seconds
+
+index % time self children called name
+
+[1] 100.0 0.01 0.00 __gnu_cxx::__atomic_add(int volatile*, int) [1]
+-----------------------------------------------
+ 0.00 0.00 51/51 void test_transform_width<6, 8>(unsigned int) [9]
+[5] 0.0 0.00 0.00 51 boost::archive::iterators::transform_width::fill() [5]
+-----------------------------------------------
+ 0.00 0.00 36/36 void test_transform_width<6, 8>(unsigned int) [9]
+[6] 0.0 0.00 0.00 36 boost::archive::iterators::transform_width<__gnu_cxx::__normal_iterator > >, 8, 6, char>::fill() [6]
+-----------------------------------------------
+ 0.00 0.00 30/30 void test_transform_width<6, 8>(unsigned int) [9]
+[7] 0.0 0.00 0.00 30 std::vector >::_M_insert_aux(__gnu_cxx::__normal_iterator > >, char const&) [7]
+-----------------------------------------------
+ 0.00 0.00 11/11 void test_xml_escape(char const*, char const*, unsigned int) [13]
+[8] 0.0 0.00 0.00 11 boost::archive::iterators::xml_escape::fill(char const*&, char const*&) [8]
+-----------------------------------------------
+ 0.00 0.00 9/9 test_main(int, char**) [16]
+[9] 0.0 0.00 0.00 9 void test_transform_width<6, 8>(unsigned int) [9]
+ 0.00 0.00 51/51 boost::archive::iterators::transform_width::fill() [5]
+ 0.00 0.00 36/36 boost::archive::iterators::transform_width<__gnu_cxx::__normal_iterator > >, 8, 6, char>::fill() [6]
+ 0.00 0.00 30/30 std::vector >::_M_insert_aux(__gnu_cxx::__normal_iterator > >, char const&) [7]
+-----------------------------------------------
+ 0.00 0.00 9/9 void test_xml_unescape(char const*, char const*, unsigned int) [14]
+[10] 0.0 0.00 0.00 9 boost::archive::iterators::xml_unescape::drain() [10]
+ 0.00 0.00 5/5 boost::archive::iterators::xml_unescape::drain_residue(char const*) [11]
+-----------------------------------------------
+ 0.00 0.00 5/5 boost::archive::iterators::xml_unescape::drain() [10]
+[11] 0.0 0.00 0.00 5 boost::archive::iterators::xml_unescape::drain_residue(char const*) [11]
+-----------------------------------------------
+ 0.00 0.00 1/2 global constructors keyed to main [38]
+ 0.00 0.00 1/2 global destructors keyed to main [35]
+[12] 0.0 0.00 0.00 2 __static_initialization_and_destruction_0(int, int) [12]
+-----------------------------------------------
+ 0.00 0.00 1/1 test_main(int, char**) [16]
+[13] 0.0 0.00 0.00 1 void test_xml_escape(char const*, char const*, unsigned int) [13]
+ 0.00 0.00 11/11 boost::archive::iterators::xml_escape::fill(char const*&, char const*&) [8]
+-----------------------------------------------
+ 0.00 0.00 1/1 test_main(int, char**) [16]
+[14] 0.0 0.00 0.00 1 void test_xml_unescape(char const*, char const*, unsigned int) [14]
+ 0.00 0.00 9/9 boost::archive::iterators::xml_unescape::drain() [10]
+-----------------------------------------------
+ 0.00 0.00 1/1 test_main(int, char**) [16]
+[15] 0.0 0.00 0.00 1 void test_stream_iterators(char const*, unsigned int) [15]
+ 0.00 0.00 1/1 std::basic_string, std::allocator >::basic_string(char*, char*, std::allocator const&) [18]
+-----------------------------------------------
+ 0.00 0.00 1/1 main [1211]
+[16] 0.0 0.00 0.00 1 test_main(int, char**) [16]
+ 0.00 0.00 9/9 void test_transform_width<6, 8>(unsigned int) [9]
+ 0.00 0.00 1/1 void test_xml_escape(char const*, char const*, unsigned int) [13]
+ 0.00 0.00 1/1 void test_xml_unescape(char const*, char const*, unsigned int) [14]
+ 0.00 0.00 1/1 void test_stream_iterators(char const*, unsigned int) [15]
+-----------------------------------------------
+ 0.00 0.00 1/1 std::basic_string, std::allocator >::basic_string(char*, char*, std::allocator const&) [18]
+[17] 0.0 0.00 0.00 1 char* std::string::_S_construct(char*, char*, std::allocator const&, std::forward_iterator_tag) [17]
+-----------------------------------------------
+ 0.00 0.00 1/1 void test_stream_iterators(char const*, unsigned int) [15]
+[18] 0.0 0.00 0.00 1 std::basic_string, std::allocator >::basic_string(char*, char*, std::allocator const&) [18]
+ 0.00 0.00 1/1 char* std::string::_S_construct(char*, char*, std::allocator const&, std::forward_iterator_tag) [17]
+-----------------------------------------------
+
+ This table describes the call tree of the program, and was sorted by
+ the total amount of time spent in each function and its children.
+
+ Each entry in this table consists of several lines. The line with the
+ index number at the left hand margin lists the current function.
+ The lines above it list the functions that called this function,
+ and the lines below it list the functions this one called.
+ This line lists:
+ index A unique number given to each element of the table.
+ Index numbers are sorted numerically.
+ The index number is printed next to every function name so
+ it is easier to look up where the function in the table.
+
+ % time This is the percentage of the `total' time that was spent
+ in this function and its children. Note that due to
+ different viewpoints, functions excluded by options, etc,
+ these numbers will NOT add up to 100%.
+
+ self This is the total amount of time spent in this function.
+
+ children This is the total amount of time propagated into this
+ function by its children.
+
+ called This is the number of times the function was called.
+ If the function called itself recursively, the number
+ only includes non-recursive calls, and is followed by
+ a `+' and the number of recursive calls.
+
+ name The name of the current function. The index number is
+ printed after it. If the function is a member of a
+ cycle, the cycle number is printed between the
+ function's name and the index number.
+
+
+ For the function's parents, the fields have the following meanings:
+
+ self This is the amount of time that was propagated directly
+ from the function into this parent.
+
+ children This is the amount of time that was propagated from
+ the function's children into this parent.
+
+ called This is the number of times this parent called the
+ function `/' the total number of times the function
+ was called. Recursive calls to the function are not
+ included in the number after the `/'.
+
+ name This is the name of the parent. The parent's index
+ number is printed after it. If the parent is a
+ member of a cycle, the cycle number is printed between
+ the name and the index number.
+
+ If the parents of the function cannot be determined, the word
+ `' is printed in the `name' field, and all the other
+ fields are blank.
+
+ For the function's children, the fields have the following meanings:
+
+ self This is the amount of time that was propagated directly
+ from the child into the function.
+
+ children This is the amount of time that was propagated from the
+ child's children to the function.
+
+ called This is the number of times the function called
+ this child `/' the total number of times the child
+ was called. Recursive calls by the child are not
+ listed in the number after the `/'.
+
+ name This is the name of the child. The child's index
+ number is printed after it. If the child is a
+ member of a cycle, the cycle number is printed
+ between the name and the index number.
+
+ If there are any cycles (circles) in the call graph, there is an
+ entry for the cycle-as-a-whole. This entry shows who called the
+ cycle (as parents) and the members of the cycle (as children.)
+ The `+' recursive calls entry shows the number of function calls that
+ were internal to the cycle, and the calls entry for each member shows,
+ for that member, how many times it was called from other members of
+ the cycle.
+
+
+Index by function name
+
+ [13] void test_xml_escape(char const*, char const*, unsigned int) [16] test_main(int, char**) [5] boost::archive::iterators::transform_width::fill()
+ [14] void test_xml_unescape(char const*, char const*, unsigned int) [8] boost::archive::iterators::xml_escape::fill(char const*&, char const*&) [1] __gnu_cxx::__atomic_add(int volatile*, int)
+ [9] void test_transform_width<6, 8>(unsigned int) [11] boost::archive::iterators::xml_unescape::drain_residue(char const*) [17] char* std::string::_S_construct(char*, char*, std::allocator const&, std::forward_iterator_tag)
+ [15] void test_stream_iterators(char const*, unsigned int) [10] boost::archive::iterators::xml_unescape::drain() [18] std::basic_string, std::allocator >::basic_string(char*, char*, std::allocator const&)
+ [12] __static_initialization_and_destruction_0(int, int) (performance_iterators.cpp) [6] boost::archive::iterators::transform_width<__gnu_cxx::__normal_iterator > >, 8, 6, char>::fill() [7] std::vector >::_M_insert_aux(__gnu_cxx::__normal_iterator > >, char const&)
diff --git a/doc/profile3.txt b/doc/profile3.txt
new file mode 100644
index 00000000..807e243c
--- /dev/null
+++ b/doc/profile3.txt
@@ -0,0 +1,153 @@
+Flat profile:
+
+Each sample counts as 0.01 seconds.
+ no time accumulated
+
+ % cumulative self self total
+ time seconds seconds calls Ts/call Ts/call name
+ 0.00 0.00 0.00 200 0.00 0.00 boost::archive::iterators::transform_width::fill()
+ 0.00 0.00 0.00 150 0.00 0.00 boost::archive::iterators::transform_width >, char>, 8, 6, char>::fill()
+ 0.00 0.00 0.00 2 0.00 0.00 __static_initialization_and_destruction_0(int, int)
+ 0.00 0.00 0.00 1 0.00 0.00 void test_base64()
+ 0.00 0.00 0.00 1 0.00 0.00 std::_List_base >::_M_clear()
+
+ % the percentage of the total running time of the
+time program used by this function.
+
+cumulative a running sum of the number of seconds accounted
+ seconds for by this function and those listed above it.
+
+ self the number of seconds accounted for by this
+seconds function alone. This is the major sort for this
+ listing.
+
+calls the number of times this function was invoked, if
+ this function is profiled, else blank.
+
+ self the average number of milliseconds spent in this
+ms/call function per call, if this function is profiled,
+ else blank.
+
+ total the average number of milliseconds spent in this
+ms/call function and its descendents per call, if this
+ function is profiled, else blank.
+
+name the name of the function. This is the minor sort
+ for this listing. The index shows the location of
+ the function in the gprof listing. If the index is
+ in parenthesis it shows where it would appear in
+ the gprof listing if it were to be printed.
+
+ Call graph (explanation follows)
+
+
+granularity: each sample hit covers 4 byte(s) no time propagated
+
+index % time self children called name
+ 0.00 0.00 200/200 void test_base64() [7]
+[4] 0.0 0.00 0.00 200 boost::archive::iterators::transform_width::fill() [4]
+-----------------------------------------------
+ 0.00 0.00 150/150 void test_base64() [7]
+[5] 0.0 0.00 0.00 150 boost::archive::iterators::transform_width >, char>, 8, 6, char>::fill() [5]
+-----------------------------------------------
+ 0.00 0.00 1/2 global constructors keyed to main [27]
+ 0.00 0.00 1/2 global destructors keyed to main [24]
+[6] 0.0 0.00 0.00 2 __static_initialization_and_destruction_0(int, int) [6]
+-----------------------------------------------
+ 0.00 0.00 1/1 main [1156]
+[7] 0.0 0.00 0.00 1 void test_base64() [7]
+ 0.00 0.00 200/200 boost::archive::iterators::transform_width::fill() [4]
+ 0.00 0.00 150/150 boost::archive::iterators::transform_width >, char>, 8, 6, char>::fill() [5]
+ 0.00 0.00 1/1 std::_List_base >::_M_clear() [8]
+-----------------------------------------------
+ 0.00 0.00 1/1 void test_base64() [7]
+[8] 0.0 0.00 0.00 1 std::_List_base >::_M_clear() [8]
+-----------------------------------------------
+
+ This table describes the call tree of the program, and was sorted by
+ the total amount of time spent in each function and its children.
+
+ Each entry in this table consists of several lines. The line with the
+ index number at the left hand margin lists the current function.
+ The lines above it list the functions that called this function,
+ and the lines below it list the functions this one called.
+ This line lists:
+ index A unique number given to each element of the table.
+ Index numbers are sorted numerically.
+ The index number is printed next to every function name so
+ it is easier to look up where the function in the table.
+
+ % time This is the percentage of the `total' time that was spent
+ in this function and its children. Note that due to
+ different viewpoints, functions excluded by options, etc,
+ these numbers will NOT add up to 100%.
+
+ self This is the total amount of time spent in this function.
+
+ children This is the total amount of time propagated into this
+ function by its children.
+
+ called This is the number of times the function was called.
+ If the function called itself recursively, the number
+ only includes non-recursive calls, and is followed by
+ a `+' and the number of recursive calls.
+
+ name The name of the current function. The index number is
+ printed after it. If the function is a member of a
+ cycle, the cycle number is printed between the
+ function's name and the index number.
+
+
+ For the function's parents, the fields have the following meanings:
+
+ self This is the amount of time that was propagated directly
+ from the function into this parent.
+
+ children This is the amount of time that was propagated from
+ the function's children into this parent.
+
+ called This is the number of times this parent called the
+ function `/' the total number of times the function
+ was called. Recursive calls to the function are not
+ included in the number after the `/'.
+
+ name This is the name of the parent. The parent's index
+ number is printed after it. If the parent is a
+ member of a cycle, the cycle number is printed between
+ the name and the index number.
+
+ If the parents of the function cannot be determined, the word
+ `' is printed in the `name' field, and all the other
+ fields are blank.
+
+ For the function's children, the fields have the following meanings:
+
+ self This is the amount of time that was propagated directly
+ from the child into the function.
+
+ children This is the amount of time that was propagated from the
+ child's children to the function.
+
+ called This is the number of times the function called
+ this child `/' the total number of times the child
+ was called. Recursive calls by the child are not
+ listed in the number after the `/'.
+
+ name This is the name of the child. The child's index
+ number is printed after it. If the child is a
+ member of a cycle, the cycle number is printed
+ between the name and the index number.
+
+ If there are any cycles (circles) in the call graph, there is an
+ entry for the cycle-as-a-whole. This entry shows who called the
+ cycle (as parents) and the members of the cycle (as children.)
+ The `+' recursive calls entry shows the number of function calls that
+ were internal to the cycle, and the calls entry for each member shows,
+ for that member, how many times it was called from other members of
+ the cycle.
+
+
+Index by function name
+
+ [7] void test_base64() [5] boost::archive::iterators::transform_width >, char>, 8, 6, char>::fill() [8] std::_List_base >::_M_clear()
+ [6] __static_initialization_and_destruction_0(int, int) (performance_iterators_base64.cpp) [4] boost::archive::iterators::transform_width::fill()
diff --git a/doc/rationale.html b/doc/rationale.html
index 3641bc03..c96fa139 100644
--- a/doc/rationale.html
+++ b/doc/rationale.html
@@ -228,7 +228,7 @@ its discovered
After a lot of investigation, it's discovered what the source of the problem
and class construct_from is marked "track_never" by including:
-BOOST_SERIALIZATION_TRACKING(construct_from, track_never)
+BOOST_CLASS_TRACKING(construct_from, track_never)
Now everything works again. Or - so it seems.
@@ -298,7 +298,7 @@ ar << x
might not even be written yet). OK, I'll add the following to my
construct_from.hpp to solve the problem.
-BOOST_SERIALIZATION_TRACKING(construct_from, track_never)
+BOOST_CLASS_TRACKING(construct_from, track_never)
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
- BOOST_SERIALIZATION_TRACKING that
+ BOOST_CLASS_TRACKING 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 construct_from
diff --git a/doc/release.html b/doc/release.html
index 82dd3912..6036d846 100644
--- a/doc/release.html
+++ b/doc/release.html
@@ -1,4 +1,4 @@
-
+
+
+Differences from Boost 1.35
+
+ - 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.
+
- 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.
+
- 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.
+
- All bug reports filed as TRAK tickets have been addressed.
+
- 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.
+
+
+Differences from Boost 1.34
+
+ - Enhanced support for fast serialization for native binary archives. By Mattias Troyer.
+
- Improved implementation of "export" functionality. Removes header ordering
+ requirement and eliminates the maintenance of a pre-determined list of "known archives"
+ By David Abrahams.
+
- Improved support for STLPort.
+
+
+Differences from Boost 1.33
+
+ - Native Binary archives use the
std::streambuf interface.
+ This should result in noticeably faster execution in many cases.
+
Differences from Boost 1.32
- Dynamic Linking Library (DLLs and shared libraries) for platforms which support them. See
- Automatic Linking on Windows.
+ Automatic Linking on Windows.
- Implementation of auto-link for compilers which can support this.
- Better support for Argument Dependent Lookup and two-phase lookup.
This results in simpler rules regarding the placing of serialization specializations
@@ -66,7 +103,7 @@ at the front of the list of include paths.
- Improved
const 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 serializaton system in a way which may introduce subtle bugs in
+ 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
here.
- A new implementation of serialization for
shared_ptr<T>. This
@@ -78,42 +115,24 @@ at the front of the list of include paths.
needs to load archives created with boost 1.32 libraries, include the above header
before each inclusion of boost/serialization/shared_ptr.hpp.
- More compilers tested and supported.
-
- Miscelleanous bug fixes.
-
-Differences from Boost 1.33
-
- - Native Binary archives use the
std::streambuf interface.
- This should result in noticibly faster execution in many cases.
-
-
-Differences from Boost 1.34
-
- - Ehanced support for fast serialiation for native binary archives. By Mattias Troyer.
-
- Improved implementation of "export" functionality. Removes header ordering
- requirement and eliminates the maintainence of a pre-determined list of "known archives"
- By David Abrahams.
-
- Improved support for STLPort.
+
- Miscellaneous bug fixes.
Pending issues
- - Compile, and test on more platforms
-
- implement
is_virtual_base<T> to automatically
- eliminate redundancy in virtual base class serialization.
- currently can't serialize through a pointer an object a of class
that implements its own
new/delete operators.
- Its possible that
std::string
and std::wstring contain characters such as
- '\0' which cannot be rendered in XML without an escape mechanism. Currently there is
- no such escape mechanism implemented.
- - A subtle error in the implementation of serialiaton of
std::map
+ '\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.
+ - A subtle error in the implementation of serializaton of
std::map
is fixed in this version. Unfortunately, the fix breaks serialization of
std::map for those compilers which do not support
partial template specialization.
- - Floating point values which are number cannot be serialized to text base archives.
-
+
-Aside from the above, there are a number of issus related to specific platforms.
+Aside from the above, there are a number of issues related to specific platforms.
These are listed in Specific Compiler/Library Issues.
diff --git a/doc/serialization.html b/doc/serialization.html
index ec9826ae..f71e1842 100644
--- a/doc/serialization.html
+++ b/doc/serialization.html
@@ -48,12 +48,13 @@ http://www.boost.org/LICENSE_1_0.txt)
Free Functions
- Pointers
+ Pointers
- Non-Default Constructors
- Pointers to Objects of Derived Classes
- Registration
+
- Export
- Instantiation
- Selective Tracking
- Runtime Casting
@@ -77,14 +78,15 @@ if and only if one of the following is true:
serialization traits,
any user type can also be designated as "primitive"
so that it is handled in this way.
-
- It is a class type and one of the following has been declared:
+
- It is a class type and one of the following has been declared according
+ to the prototypes detailed below:
- a class member function
serialize
- a global function
serialize
- it is a pointer to a Serializable type.
- it is a reference to a Serializable type.
-
- it is an native C++ Array of Serializable type.
+
- it is a native C++ Array of Serializable type.
Primitive Types
@@ -675,8 +677,9 @@ main(){
Note that if the serialization function is split between save and load, both
functions must include the registration. This is required to keep the save
and corresponding load in syncronization.
-
-This will work but may be inconvenient. We don't always know which derived
+
+
Export
+The above will work but may be inconvenient. We don't always know which derived
classes we are going to serialize when we write the code to serialize through
a base class pointer. Every time a new derived class is written we have to
go back to all the places where the base class is serialized and update the
@@ -791,8 +794,8 @@ 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<base *>(NULL),
- static_cast<derived *>(NULL)
+ static_cast<derived *>(NULL),
+ static_cast<base *>(NULL)
)
}
};
@@ -919,7 +922,7 @@ As of this writing, the library contains serialization of the following boost cl
- auto_ptr (demo)
Others are being added to the list so check the boost files section and headers for
-new implmentations!
+new implementations!
© Copyright Robert Ramey 2002-2004.
Distributed under the Boost Software License, Version 1.0. (See
diff --git a/doc/shared_ptr2.html b/doc/shared_ptr2.html
index 3c2ee360..0e831b79 100644
--- a/doc/shared_ptr2.html
+++ b/doc/shared_ptr2.html
@@ -20,7 +20,7 @@ http://www.boost.org/LICENSE_1_0.txt)
Serialization
- shared_ptr<class T> Revisted
+ shared_ptr<class T> Revisited
@@ -32,7 +32,7 @@ Unfortunately, this way of doing it suffered from some undesirable features
- It was dependent on the Boost implementation of
shared_ptr.
The shared_ptr interface has been included
in std::tr1 and may someday be included in the standard
- C++ library. An implementation which depends only on the public interface can be guarenteed to
+ C++ library. An implementation which depends only on the public interface can be guaranteed to
function with any other future implementation of shared_ptr.
- It required extra macros for export.
@@ -45,7 +45,7 @@ inline void save(
const unsigned int /* file_version */
){
const T * t_ptr = t.get();
- // just seriailize the underlying raw pointer
+ // just serialize the underlying raw pointer
ar <<: boost::serialization::make_nvp("px", t_ptr);
}
@@ -56,7 +56,7 @@ inline void load(
const unsigned int file_version
){
T* r;
- // recover the underlying raw poiter
+ // recover the underlying raw pointer
ar >> boost::serialization::make_nvp("px", r);
// To Do - match up with other shared pointers which
@@ -65,13 +65,13 @@ inline void load(
}
-In priniciple this is very much simpler than the original implementation. Completion of
+In principle, this is very much simpler than the original implementation. Completion of
this code requires:
- Filling in the "To Do". This required making an extra map for
shared_ptrinstances. - - A method for identifing pointers to the same objects from pointers to their base classes. +
- A method for identifying pointers to the same objects from pointers to their base classes.
- Backward compatibility with pointers serialized by the previous method. This exploits the serialization class versioning.
- Proper handling of
weak_ptr. diff --git a/doc/singleton.html b/doc/singleton.html new file mode 100644 index 00000000..737ccdde --- /dev/null +++ b/doc/singleton.html @@ -0,0 +1,241 @@ + + + + + + + +Serialization - singleton + + ++
++ ++ +
++ +Serialization
+
+singleton
+-
+
- Motivation
+
- Features +
- Class Interface +
- Requirements +
- Examples +
- Multi-Threading +
- Features +
Motivation
+The serialization library relies on the existence of a number +of static variables and tables to store information related +to runtime types. Examples are tables which relate exported +names to types and tables which relate base classes to derived +classes. Construction, destruction and usage of these variables +requires consideration of the following issues: +-
+
- Some static data variables and constants entries refer to others. + The sequence of initialization cannot be arbitrary but must be in proper + sequence. +
- A number of static variables aren't referred explicitly and, without + special precautions, will be stripped by most code optimizers +
- Many of these variables are created by templates and special care must + be taken to be sure that they are instantiated +
- In a multi-threading system, its possible that these static variables + will be accessed concurrently by separate threads. This would create a + race condition with unpredictabe behavior +
Features
+This singleton implementation has the following features: +-
+
- + Any instance will be constructed before any attempt is made to access it. +
- + Any instance created with a template is guarenteed to be instantiated. +
- + Regardless of whether or not an instance has been explicitly + referred to, it will not be stripped by the optimizer when the + executable is built in release mode. +
-
+ All instances are constructed before
+
mainis called + regardless of where they might be referenced within the program. + In a multi-tasking system, this guarentees that there will be no + race conditions during the construction of any instance. No + thread locking is required to guarentee this. + -
+ The above implies that any
const+ instances are thread-safe during the whole program. Again, no + thread locking is required. + -
+ If a mutable instance is created, and such an instance is modified
+ after main is called in a mult-threading system, there exists
+ the possibility that a race condition will occur. The serialization
+ library takes care that in the few places where a mutable
+ singleton is required, it is not altered after
+
mainis called. + For a more general purpose usage, thread locking on this + singleton could easily be implemented. But as the serialization + library didn't require it, it wasn't implemented. +
Class Interface
+
+ ++namespace boost { +namespace serialization { + +template+class singleton : public boost::noncopyable +{ +public: + static const T & get_const_instance(); + static T & get_mutable_instance(); +}; + +} // namespace serialization +} // namespace boost + -
+
+
+static const T & get_const_instance();
+- +Retrieve a constant reference to the singleton for this type. + + +
+static T & get_mutable_instance();
+- +Retrieve a mutable reference to the singleton for this type. + + +
Requirements
+In order to be used as + ++singleton<T> ++ +, the type T must be default constructable. +It doesn't require static variables - though it may have them. +Since the library guarentees that only one instance of + ++singleton<T> ++ +and all accesss is through the above static interface +functions, common member functions of T become +the functional equivalent of +staticfunctions. + +Examples
+There are at least two different ways to use this class template. +Both are used in the serialization library. ++The first way is illustrated by and excerpt from the file +
extended_type_info.cpp. +which contains the following code: + +
+Just by referring to the singleton instance anywhere in the program +will guarentee that one and only one instance for the specified +type (+typedef std::setktmap; +... +void +extended_type_info::key_register(const char *key) { + ... + result = singleton ::get_mutable_instance().insert(this); + ... +} + ktmapin this example) +will exist throughout the program. There is no need for anyother +declaration or definition. ++A second way is to use + +
+singleton<T> ++ +as one of the base classes of the type. This is illustrated by a simplified +excerpt from + ++extended_type_info_typeid.hpp ++ + +
+ +This usage will permit a more natural syntax to be used: ++template<class T> +class extended_type_info_typeid : + public detail::extended_type_info_typeid_0, + public singleton<extended_type_info_typeid<const T> > +{ + friend class singleton<extended_type_info_typeid<const T> >; +private: + // private constructor to inhibit any existence other than the + // static one. Note: not all compilers support this !!! + extended_type_info_typeid() : + detail::extended_type_info_typeid_0() + { + type_register(typeid(T)); + } + ~extended_type_info_typeid(){} + ... +}; +
+ +Again, including one or more of the above statements anywhere +in the program will guarentee that one and only one instance +is created and referred to. + ++extended_type_info_typeid<T>::get_const_instance() +Multi-Threading
+This singleton CAN be safely used in multi-threading applications if one +is careful follow a simple rule: ++Do not call get_mutable_instance when more than one thread is running! +
+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. +
+In a program compiled for debug, any invocation of ++boost::serialization::global_lock::get_mutable_instance().lock(); +boost::serialization::global_lock::get_mutable_instance().unlock(); +get_mutable_instance()+while the library is in a "locked" state will trap in an assertion. +The global_lock state is initialized as "unlocked" to permit +alteration of static variables before +mainis called. All +serialization tests invokelock()+at the start of the progam. For programs compiled in release +mode these functions have no effect. + +
+© Copyright Robert Ramey 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) +
+ + diff --git a/doc/special.html b/doc/special.html index b2e0efed..440e08c8 100644 --- a/doc/special.html +++ b/doc/special.html @@ -27,7 +27,6 @@ http://www.boost.org/LICENSE_1_0.txt)
- Object Tracking
-
- Exporting Class Serialization
- Class Information
- Archive Portability
- Exporting Class Serialization
- Binary Archives
- XML Archives +
- Exporting Class Serialization
- DLLS - Serialization and Runtime Linking +
- Plugins
- Multi-Threading
- Optimizations
- Archive Exceptions @@ -153,55 +154,6 @@ redundant save/load operations. BOOST_CLASS_TRACKING(my_virtual_base_class, boost::serialization::track_always) -
Exporting Class Serialization
-Elsewhere in this manual, we have described -BOOST_CLASS_EXPORT. This is used to make the serialization library aware -that code should be instantiated for serialization of a given class even though the -class hasn't been otherwise referred to by the program. This functionality -is necessary to implement serialization of pointers through a virtual base -class pointer. That is, a polymorphic pointer. --This macro specifies a "Globally Unique IDentifier". -This is an string which identifies the class to be created when data is loaded. -Generally a text representation of the class name is sufficient for this purpose, -but in certain cases it maybe necessary to specify a different string by using -
BOOST_CLASS_EXPORT_GUID-rather than a simple -BOOST_CLASS_EXPORT. - --
BOOST_CLASS_EXPORTwould usually -be specified in the same header file as the class declaration to which it -corresponds. That is,BOOST_CLASS_EXPORT(T)-is a "trait" of the class T. So a program using this class will look -something like: - -
- -These headers can be in any order. (In boost versions 1.34 -and earlier, the archive headers had to go before any headers which -contain-#include <boost/archive/xml_oarchive.hpp> -.... // any other archive classes -#include "my_class.hpp" // which contains BOOST_CLASS_EXPORT(my_class) -BOOST_CLASS_EXPORT.) -Any code required to serialize types specified -byBOOST_CLASS_EXPORTwill be -instantiated for each archive whose header is included. (note that the code -is instantiated regardless of whether or not it is actually invoked.) -If no archive headers are included - no code should be instantiated. -This will permitBOOST_CLASS_EXPORT-to be a permanent part of themy_class.hpp. - --Note that the implementation of this functionality depends upon vendor -specific extensions to the C++ language. So, there is no guarenteed portability -of programs which use this facility. However, all C++ compilers which -are tested with boost provide the required extensions. The library -includes the extra declarations required by each of these compilers. -It's reasonable to expect that future C++ compilers will support -these extensions or something equivalent. -
Class Information
By default, for each class serialized, class information is written to the archive. This information includes version number, implementation level and tracking @@ -286,7 +238,7 @@ struct my_wrapper { class my_class { wchar_t a; short unsigned b; - template<<class Archive> + template<class Archive> Archive & serialize(Archive & ar, unsigned int version){ ar & my_wrapper(a); ar & my_wrapper(b); @@ -345,13 +297,105 @@ just the value portion of the data is serialized. The name portion is discarded So by always using name-value pairs, it will be guarenteed that all data can be serialized to all archive classes with maximum efficiency. +Exporting Class Serialization
+Elsewhere in this manual, we have described +BOOST_CLASS_EXPORT. +Export implies two things: +-
+
- Instantiates code which is not otherwise referred to. +
- Associates an external identifier with the class to be serialized. +The fact that the class isn't explicitly referred to implies this +requirement. +
+
BOOST_CLASS_EXPORTin the same +source module that includes any of the archive class headers will +instantiate code required to serialize polymorphic pointers of +the indicated type to the all those archive classes. If no +archive class headers are included, then no code will be instantiated. + ++Note that the implemenation of this functionality requires +that the
BOOST_CLASS_EXPORT+macro appear after and the inclusion of any archive +class headers for which code is to be instantiated. +So, code that usesBOOST_CLASS_EXPORT+will look like the following: +
+This will be true regardless of whether the is part +of a stand alone executable, a static library or +a dyanmic or shared library. ++#include <boost/archive/text_oarchive.hpp> +#include <boost/archive/text_oarchive.hpp> +... // other archives + +#include "a.hpp" // header declaration for class a +BOOST_CLASS_EXPORT(a) +... // other class headers and exports ++Note that including +
BOOST_CLASS_EXPORT+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 +BOOST_CLASS_EXPORT+is invoked. This is different than other serialization +traits which would normally be included in same file +as the class declaration. + ++This system has certain implications for placing code in static or shared +libraries. Placing
BOOST_CLASS_EXPORT+in library code will have no effect unless archive class headers are +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 +Polymoprhic Archives. +Also, when making shared libraries, there is currently a restriction +that only one such library can useBOOST_CLASS_EXPORT+for any given type. All this will most likely make it inconvenient +to includeBOOST_CLASS_EXPORT+as part of the header of the class to be serialized. So, the +best way to useBOOST_CLASS_EXPORT+is to include it in the same module which implements the class. + ++Strictly speaking, export should not be necessary if all pointer serialization +occurs through the most derived class. However, in order to detect +what would be catastophic error, the library traps ALL serializations through +a pointer to a polymorphic which are not exported or otherwise registered. +So, in practice, be prepared to register or export all classes with one +or more virtual functions which are serialized through a pointer. + +
+Note that the implementation of this functionality depends upon vendor +specific extensions to the C++ language. So, there is no guarenteed portability +of programs which use this facility. However, all C++ compilers which +are tested with boost provide the required extensions. The library +includes the extra declarations required by each of these compilers. +It's reasonable to expect that future C++ compilers will support +these extensions or something equivalent. +
DLLS - Serialization and Runtime Linking
Serialization code can be placed in libraries to be linked at runtime. That is, -code can be placed in DLLS(Windows) or Shared Libraries(*nix). -Along with the "export" facility, this -permits a program to written without knowledge of the actual types to be serialized. -This package doesn't include an example of this technique - but coding would be -very similar to the example +code can be placed in DLLS(Windows) Shared Libraries(*nix), or static libraries +as well as the main executable. As long as + + +BOOST_CLASS_EXPORT+ + +is not used, The serialization library imposes no special requirements +that need be taken into account when distributing code among various modules. ++For static libraries, this is illustrated by
demo_pimpl.cpp, @@ -362,52 +406,91 @@ anddemo_pimpl_A.hpp-where implementation of serializaton is completely separate -from the main program. +where implementation of serializaton is in a static library +completely separate from the main program. + ++For runtime linked libraries this is illustrated by one of the tests: + + +
test_dll_simple+, +and + +dll_A.cpp+ +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. + +Plugins
+In order to implement the library, various facilities for runtime +manipulation of types are runtime were required. These +areextended_type_info+for associating classes with external identifying strings (GUID) +andvoid_cast+for casting between pointers of related types. + +To complete the functionality of +extended_type_info+the ability to construct and destroy corresponding types has been +added. In order to use this functionality, one must specify +how each type is created. This should be done at the time +a class is exported. So, a more complete example of the code above would be: + +
+ +With this in place, one can construct, serialize and destroy +about which only is know the GUID and a base class. ++#include <boost/archive/text_oarchive.hpp> +#include <boost/archive/text_oarchive.hpp> +... // other archives + +#include "a.hpp" // header declaration for class a + +// this class has a default constructor +BOOST_SERIALIZATION_FACTORY_0(a) +// as well as one that takes one integer argument +BOOST_SERIALIZATION_FACTORY_1(a, int) + +// specify the GUID for this class +BOOST_CLASS_EXPORT(a) +... // other class headers and exports +Multi-Threading
-The nature of serialization would conflict with multiple thread concurrently -writing/reading from/to a single open archive. Since each archive is -independent from ever other one, there should be no problem -in having multiple open archives from one or more threads. +The fundamental purpose of serialization would conflict with multiple +thread concurrently writing/reading from/to a single open archive instance. +The library implementation presumes that the application avoids such an situtation.-Well, not quite. +However, Writing/Reading different archives simultaneously +in different tasks is permitted as each archive instance is (almost) +completely independent from any other archive instance. The only shared +information are some type tables which have been implemented using a +lock-free thread-safe + +
singleton+ +described elsewhere in this documentation.-There are a couple of global data structures for holding -information of serializable types. These structures are -used to dispatch to correct code to handle each pair -of serializable types and archive types. Since this -information is shared among all archives, there is -potential for problems. This has been addressed -carefully implementing the library so that these -structures are all initialized before -
main(...)-is called. From then on they are never altered. So -there SHOULD be no problem having mulitple archives -open simultaneously - be it from the same or different -threads. --Well, almost. -
-With dynamically loaded code - DLLS or Shared Libraries, -these global data structures can be altered when a library -is loaded or unloaded. That is, in this case, these -globa data structures can be altered after -
main(...)-is called. So if a thread is dynamically loading/unloading -modules which contain serialization code while an -archive is open there could be problems. Also, if -such loading/unloading is happening concurrently -in different threads, there could also be problems. --It might not be easy to control this. Is possible that -some systems may not actually load modules until they -are actually needed. So even though we think that -there is not dynamic loading/unloading of such code -it could be occurring as "help" to manage resources. -On such systems, access to archive code would have -to be syncronized with some multi-threading construct -in order to be functional. +This singleton implementation guarentees that all of this shared +information is initialized when the code module which contains +them is loaded. The serialization library takes care to +ensure that these data structures are not subsequently +modified. The only time there could be a problem would +be if code is loaded/unloaded while another task is +serializing data. This could only occur for types whose +serialization is implemented in a dynamically loaded/unload DLL +or shared library. So if the following is avoided: +
-
+
- Accessing the same archive instance from different tasks. +
- Loading/Unloading DLLS or shared libraries while any archive + instances are open. +
Optimizations
In performance critical applications that serialize large sets of contiguous data of homogeneous diff --git a/doc/static_warning.html b/doc/static_warning.html index 8140c722..d3cf2835 100644 --- a/doc/static_warning.html +++ b/doc/static_warning.html @@ -25,7 +25,25 @@ http://www.boost.org/LICENSE_1_0.txt)
-To do. + +The header<boost/static_warning.hpp>supplies a single macro +BOOST_STATIC_WARNING(x), which generates a compile time warning message if +the integral-constant-expression x is not true. ++Note that if the condition is true, then the macro will generate neither +code nor data - and the macro can also be used at either namespace, +class or function scope. When used in a template, the expression x +will be evaluated at the time the template is instantiated; this is +particularly useful for validating template parameters. +
+It is intended that the functioning of
BOOST_STATIC_WARNING(x)+be identical to that ofBOOST_STATIC_ASSERT(x)+except that rather than resulting in a compilation error, it will result in +a compiler warning. In all other respects it should be the same. So +for more information on usingBOOST_STATIC_WARNING(x)+consult the documentation forBOOST_STATIC_ASSERT(x)+here. +
© Copyright Robert Ramey 2002-2004. Distributed under the Boost Software License, Version 1.0. (See diff --git a/doc/todo.html b/doc/todo.html new file mode 100644 index 00000000..15cb3339 --- /dev/null +++ b/doc/todo.html @@ -0,0 +1,113 @@ + + + + + + + +
Serialization - To Do + + ++
++ ++ +
++ +Serialization
+To Do
+
+-
+
- Portable Binary Archives +
- Performance Testing and Profiling +
- Back Versioning +
- Testing for Environments with No RTTI +
- Additional Case Studies +
Portable Binary Archives
+Currently there is a portable binary archive in the examples directory. +It is not regularly submitted to the exhaustive boost testing regimen +but it is tested occasionally and has been used in production code. ++Its missing the following: +
-
+
- Addition of portable floating point types. This is not trivial. In addition to + handling floating point types of varying sizes, It requires + handling invalid floating point numbers (NaNs) in a portable manner. +
- Some way to test archive portability within the Boost testing regimen. +
- Integration into the Boost testing similar to the other archive classes. +
Performance Testing and Profiling
+ +I've managed to setup performance profiling using the following: +-
+
- current (as I write this) Boost.Build tools. +
- the gcc compiler. +
- and a shell script - profile.sh +
- library_status program from the tools/regression/src directory +
+The first thing I did was include some of the serialization library tests. +It became immediatly apparent that these tests were totally unsuitable +for performance testing and that new tests needed to be written for this +purpose. These tests would highlight the location of any performance +bottlenecks in the serialization library. Whenever I've subjected my +code in the past to this type of analysis, I've always been suprised +to find bottlenecks in totally unanticipated places and fixing those +has always lead to large improvements in performance. I expect that +this project would have a huge impact on the utility of the serialization +library. + +
Back Versioning
+ +It has been suggested that a useful feature of the library would be +the ability to create "older versions" of archives. Currently, +the library permits one make programs that are guarenteed +the ability to load archives with classes of a previous version. +But there is not way to save classes in accordance with a +previous version. At first I dismissed this a a huge project +with small demand. A cursory examination of the code revealed +that this would not be very difficult. It would require some +small changes in code and some additional tests. Also it +would require special treatment in the documentation - perhaps +a case study. + + +Environments without RTTI
+ +I note that some have commented that this library requires RTTI. +This is not strictly true. The examples and almost all the +tests presume the existence of RTTI. But it should be possible +to use the library without it. The example used for testing is an +extended_typeinfo+implemenation which presumes that all classes names have been exported. +So, to make this library compatible for platforms without RTTI, +a set of tests, examples and new manual section would have to be created + +
+Revised 1 November, 2008 +
© Copyright Robert Ramey 2002-2008. +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) +
+ + diff --git a/doc/traits.html b/doc/traits.html index cb127e41..fc7ca62c 100644 --- a/doc/traits.html +++ b/doc/traits.html @@ -179,7 +179,7 @@ Default tracking traits are: That is, addresses of addresses are not tracked by default.- All current serialization wrappers such as
boost::serialization::nvp,track_never. -- For all other types,
track_selectivly. +- For all other types,
track_selectively. That is addresses of serialized objects are tracked if and only if one or more of the following is true:-
@@ -242,23 +242,20 @@ BOOST_CLASS_EXPORT_GUID(my_class, "my_class")
If the an external name is required somewhere in the program and none
has been assigned, a static assertion will be invoked.
+
- remove the =0 in the base classes so that the base class is no - longer abstract. -
- implement is_abstract for your compiler. (code written according to - the C++ standard is included with this library. But it is known to fail - on several compilers. -
- use the macro
BOOST_IS_ABSTRACT(my_class)to indicate - that the class is an abstract base class. This will cause the compiler - to avoid generating code that causes this error. - This macro must be used in the global namespace, with full namespace - qualification of the argument class. -
Abstract
-When serializing an object through a pointer to its base class -and that base class is abstract (i.e. has at least one virtual function -assigned a value of 0), A compile error will be emitted. This is -addressable in one over several ways: --
-
BOOST_IS_ABSTRACT(T)+to do this. Not all compilers support this type trait and corresponding +macro. To address this, the macro+BOOST_SERIALIZATION_ASSUME_ABSTRACT(T)has been +implemented to permit one to explicitly indicate that a specified +type is in fact abstract. This will guarentee that +BOOST_IS_ABSTRACT+will return the correct value for all compilers. +Type Information Implementation
This last trait is also related to the serialization of objects through a base class pointer. The implementation of this facility @@ -471,6 +468,34 @@ and template parameters should be assigned according to the following table:IsWrapperis the type a wrapper?mpl::false_
mpl::true_mpl::false_Bitwise serialization
+Some simple classes could be serialized just by directly copying all bits +of the class. This is, in particular, the case for POD data types containing +no pointer members, and which are neither versioned nor tracked. Some archives, +such as non-portable binary archives can make us of this information to +substantially speed up serialization. + +To indicate the possibility of bitwise serialization the type trait defined +in the header +file is_bitwise_serializable.hpp +is used: +
+is used, and can be specialized for other classes. The specialization +is made easy by the corresponding macro: ++namespace boost { namespace serialization { + template+ struct is_bitwise_serializable + : public is_arithmetic + {}; +} } +
+ +=======+BOOST_IS_BITWISE_SERIALIZABLE(my_class) +Bitwise serialization
Some simple classes could be serialized just by directly copying all bits @@ -497,6 +522,7 @@ is made easy by the corresponding macro: BOOST_IS_BITWISE_SERIALIZABLE(my_class) +>>>>>>> .merge-right.r41077
© Copyright Robert Ramey 2002-2004 and Matthias Troyer 2006. Distributed under the Boost Software License, Version 1.0. (See diff --git a/doc/tutorial.html b/doc/tutorial.html index b4fd3cdc..8154611f 100644 --- a/doc/tutorial.html +++ b/doc/tutorial.html @@ -123,7 +123,7 @@ int main() { gps_position newg; { // create and open an archive for input - std::ifstream ifs("filename", std::ios::binary); + std::ifstream ifs("filename"); boost::archive::text_iarchive ia(ifs); // read class state from archive ia >> newg; diff --git a/doc/void_cast.html b/doc/void_cast.html index 190964eb..51c0bae3 100644 --- a/doc/void_cast.html +++ b/doc/void_cast.html @@ -44,8 +44,8 @@ They are declared in the namespace template<class Derived, class Base> const void_cast_detail::void_caster & void_cast_register( - const Derived * derived = NULL, - const Base * base = NULL + Derived const * derived = NULL, + Base * const base = NULL )
- XML Archives +
-
diff --git a/example/Jamfile.v2 b/example/Jamfile.v2
new file mode 100644
index 00000000..a7b8fbd8
--- /dev/null
+++ b/example/Jamfile.v2
@@ -0,0 +1,55 @@
+# 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.
+
+project libs/serialization/example
+ : id serialization_test
+ : requirements
../build//boost_serialization + ; + +rule demo_bsl_run ( demo-name : othersources * : requirements * ) +{ + return [ run + # sources + $(demo-name).cpp + $(othersources).cpp + : # command + : # input files + : # requirements + # toolset suppress-warnings + gcc: "-Wno-non-virtual-dtor -Wno-ctor-dtor-privacy" + msvc-8.0: "-wd4996" + borland: "-w-8080 -w-8071 -w-8057 -w-8062 -w-8008 -w-0018 -w-8066" + # toolset optimizations + gcc: "-ftemplate-depth-255" + msvc: "-Gy" + # toolset shared library support + como, shared: no + msvc, stlport, shared: no + cw, static: no + $(requirements) + : # test name + $(demo-name) + ] + ; +} + +test-suite "demo-suite" : + # demos + [ demo_bsl_run demo ] + [ demo_bsl_run demo_auto_ptr ] + [ demo_bsl_run demo_exception ] + [ 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_xml ] + [ demo_bsl_run demo_xml_save ] + [ demo_bsl_run demo_xml_load : : demo_xml_save ] +; + diff --git a/example/demo.cpp b/example/demo.cpp index 2ee4e7fd..38e9f493 100644 --- a/example/demo.cpp +++ b/example/demo.cpp @@ -7,6 +7,7 @@ // http://www.boost.org/LICENSE_1_0.txt) +#include // NULL #include #include #include @@ -20,7 +21,7 @@ #include #include #include -#include +#include ///////////////////////////////////////////////////////////// // The intent of this program is to serve as a tutorial for @@ -93,7 +94,7 @@ public: virtual ~bus_stop(){} }; -BOOST_IS_ABSTRACT(bus_stop) +BOOST_SERIALIZATION_ASSUME_ABSTRACT(bus_stop) std::ostream & operator<<(std::ostream &os, const bus_stop &bs) { diff --git a/example/demo_dll.cpp b/example/demo_dll.cpp new file mode 100644 index 00000000..31556e7c --- /dev/null +++ b/example/demo_dll.cpp @@ -0,0 +1,50 @@ +/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8 +// test_derived_class.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) + +// should pass compilation and execution + +#include // NULL +#include + +#include // remove +#include +#if defined(BOOST_NO_STDC_NAMESPACE) +namespace std{ + using ::remove; +} +#endif + +#include "test_tools.hpp" + +#include "B.hpp" +#include "A.ipp" + +int test_main( int argc, char* argv[] ) +{ + const char * testfile = boost::archive::tmpnam(NULL); + + BOOST_REQUIRE(NULL != testfile); + + B b, b1; + + { + test_ostream os(testfile, TEST_STREAM_FLAGS); + test_oarchive oa(os, TEST_ARCHIVE_FLAGS); + oa << boost::serialization::make_nvp("b", b); + } + { + test_istream is(testfile, TEST_STREAM_FLAGS); + test_iarchive ia(is, TEST_ARCHIVE_FLAGS); + ia >> boost::serialization::make_nvp("b1", b1); + } + BOOST_CHECK(b == b1); + std::remove(testfile); + return EXIT_SUCCESS; +} + +// EOF diff --git a/example/demo_dll_a.hpp b/example/demo_dll_a.hpp new file mode 100644 index 00000000..222f0b21 --- /dev/null +++ b/example/demo_dll_a.hpp @@ -0,0 +1,321 @@ +#ifndef BOOST_SERIALIZATION_TEST_A_HPP +#define BOOST_SERIALIZATION_TEST_A_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 +// A.hpp simple class test + +// (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 +#include // for rand() +#include // for fabs() +#include // size_t + +#include +#if defined(BOOST_NO_STDC_NAMESPACE) +namespace std{ + using ::rand; + using ::fabs; + using ::size_t; +} +#endif + +//#include +#include +#include + +#include +#if BOOST_WORKAROUND(BOOST_DINKUMWARE_STDLIB, == 1) +#include +#endif + +#include +#include +#include + +class A +{ +private: + friend class boost::serialization::access; + // note: from an aesthetic perspective, I would much prefer to have this + // defined out of line. Unfortunately, this trips a bug in the VC 6.0 + // compiler. So hold our nose and put it her to permit running of tests. + template + void serialize( + Archive &ar, + const unsigned int /* file_version */ + ){ + ar & BOOST_SERIALIZATION_NVP(b); + #ifndef BOOST_NO_INT64_T + ar & BOOST_SERIALIZATION_NVP(f); + ar & BOOST_SERIALIZATION_NVP(g); + #endif + #if BOOST_WORKAROUND(__BORLANDC__, <= 0x551 ) + int i; + if(BOOST_DEDUCED_TYPENAME Archive::is_saving::value){ + i = l; + ar & BOOST_SERIALIZATION_NVP(i); + } + else{ + ar & BOOST_SERIALIZATION_NVP(i); + l = i; + } + #else + ar & BOOST_SERIALIZATION_NVP(l); + #endif + ar & BOOST_SERIALIZATION_NVP(m); + ar & BOOST_SERIALIZATION_NVP(n); + ar & BOOST_SERIALIZATION_NVP(o); + ar & BOOST_SERIALIZATION_NVP(p); + ar & BOOST_SERIALIZATION_NVP(q); + #ifndef BOOST_NO_CWCHAR + ar & BOOST_SERIALIZATION_NVP(r); + #endif + ar & BOOST_SERIALIZATION_NVP(c); + ar & BOOST_SERIALIZATION_NVP(s); + ar & BOOST_SERIALIZATION_NVP(t); + ar & BOOST_SERIALIZATION_NVP(u); + ar & BOOST_SERIALIZATION_NVP(v); + ar & BOOST_SERIALIZATION_NVP(w); + ar & BOOST_SERIALIZATION_NVP(x); + ar & BOOST_SERIALIZATION_NVP(y); + #ifndef BOOST_NO_STD_WSTRING + ar & BOOST_SERIALIZATION_NVP(z); + #endif + } + bool b; + #ifndef BOOST_NO_INT64_T + boost::int64_t f; + boost::uint64_t g; + #endif + enum h { + i = 0, + j, + k + } l; + std::size_t m; + signed long n; + unsigned long o; + signed short p; + unsigned short q; + #ifndef BOOST_NO_CWCHAR + wchar_t r; + #endif + char c; + signed char s; + unsigned char t; + signed int u; + unsigned int v; + float w; + double x; + std::string y; + #ifndef BOOST_NO_STD_WSTRING + std::wstring z; + #endif +public: + A(); + bool operator==(const A &rhs) const; + bool operator!=(const A &rhs) const; + bool operator<(const A &rhs) const; // used by less + // hash function for class A + operator std::size_t () const; + friend std::ostream & operator<<(std::ostream & os, A const & a); + friend std::istream & operator>>(std::istream & is, A & a); +}; + +//BOOST_TEST_DONT_PRINT_LOG_VALUE(A); + +template +void randomize(S &x) +{ + assert(0 == x.size()); + for(;;){ + unsigned int i = std::rand() % 27; + if(0 == i) + break; + x += static_cast ('a' - 1 + i); + } +} + +template +void accumulate(std::size_t & s, const T & t){ + const char * tptr = (const char *)(& t); + unsigned int count = sizeof(t); + while(count-- > 0){ + s += *tptr++; + } +} + +A::operator std::size_t () const { + std::size_t retval = 0; + accumulate(retval, b); + #ifndef BOOST_NO_INT64_T + accumulate(retval, f); + accumulate(retval, g); + #endif + accumulate(retval, l); + accumulate(retval, m); + accumulate(retval, n); + accumulate(retval, o); + accumulate(retval, p); + accumulate(retval, q); + #ifndef BOOST_NO_CWCHAR + accumulate(retval, r); + #endif + accumulate(retval, c); + accumulate(retval, s); + accumulate(retval, t); + accumulate(retval, u); + accumulate(retval, v); + return retval; +} + +inline A::A() : + b(true), + #ifndef BOOST_NO_INT64_T + f(std::rand() * std::rand()), + g(std::rand() * std::rand()), + #endif + l(static_cast (std::rand() % 3)), + m(std::rand()), + n(std::rand()), + o(std::rand()), + p(std::rand()), + q(std::rand()), + #ifndef BOOST_NO_CWCHAR + r(std::rand()), + #endif + c(std::rand()), + s(std::rand()), + t(std::rand()), + u(std::rand()), + v(std::rand()), + w((float)std::rand()), + x((double)std::rand()) +{ + randomize(y); + #ifndef BOOST_NO_STD_WSTRING + randomize(z); + #endif +} + +inline bool A::operator==(const A &rhs) const +{ + if(b != rhs.b) + return false; + if(l != rhs.l) + return false; + #ifndef BOOST_NO_INT64_T + if(f != rhs.f) + return false; + if(g != rhs.g) + return false; + #endif + if(m != rhs.m) + return false; + if(n != rhs.n) + return false; + if(o != rhs.o) + return false; + if(p != rhs.p) + return false; + if(q != rhs.q) + return false; + #ifndef BOOST_NO_CWCHAR + if(r != rhs.r) + return false; + #endif + if(c != rhs.c) + return false; + if(s != rhs.s) + return false; + if(t != rhs.t) + return false; + if(u != rhs.u) + return false; + if(v != rhs.v) + return false; + if(w == 0 && std::fabs(rhs.w) > std::numeric_limits ::epsilon()) + return false; + if(std::fabs(rhs.w/w - 1.0) > std::numeric_limits ::epsilon()) + return false; + if(x == 0 && std::fabs(rhs.x - x) > std::numeric_limits ::epsilon()) + return false; + if(std::fabs(rhs.x/x - 1.0) > std::numeric_limits ::epsilon()) + return false; + if(0 != y.compare(rhs.y)) + return false; + #ifndef BOOST_NO_STD_WSTRING + if(0 != z.compare(rhs.z)) + return false; + #endif + return true; +} + +inline bool A::operator!=(const A &rhs) const +{ + return ! (*this == rhs); +} + +inline bool A::operator<(const A &rhs) const +{ + if(b != rhs.b) + return b < rhs.b; + #ifndef BOOST_NO_INT64_T + if(f != rhs.f) + return f < rhs.f; + if(g != rhs.g) + return g < rhs.g; + #endif + if(l != rhs.l ) + return l < rhs.l; + if(m != rhs.m ) + return m < rhs.m; + if(n != rhs.n ) + return n < rhs.n; + if(o != rhs.o ) + return o < rhs.o; + if(p != rhs.p ) + return p < rhs.p; + if(q != rhs.q ) + return q < rhs.q; + #ifndef BOOST_NO_CWCHAR + if(r != rhs.r ) + return r < rhs.r; + #endif + if(c != rhs.c ) + return c < rhs.c; + if(s != rhs.s ) + return s < rhs.s; + if(t != rhs.t ) + return t < rhs.t; + if(u != rhs.u ) + return u < rhs.u; + if(v != rhs.v ) + return v < rhs.v; + if(w != rhs.w ) + return w < rhs.w; + if(x != rhs.x ) + return x < rhs.x; + int i = y.compare(rhs.y); + if(i != 0 ) + return i < 0; + #ifndef BOOST_NO_STD_WSTRING + int j = z.compare(rhs.z); + if(j != 0 ) + return j < 0; + #endif + return false; +} + +#endif // BOOST_SERIALIZATION_TEST_A_HPP diff --git a/example/demo_dll_a.ipp b/example/demo_dll_a.ipp new file mode 100644 index 00000000..222f0b21 --- /dev/null +++ b/example/demo_dll_a.ipp @@ -0,0 +1,321 @@ +#ifndef BOOST_SERIALIZATION_TEST_A_HPP +#define BOOST_SERIALIZATION_TEST_A_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 +// A.hpp simple class test + +// (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 +#include // for rand() +#include // for fabs() +#include // size_t + +#include +#if defined(BOOST_NO_STDC_NAMESPACE) +namespace std{ + using ::rand; + using ::fabs; + using ::size_t; +} +#endif + +//#include +#include +#include + +#include +#if BOOST_WORKAROUND(BOOST_DINKUMWARE_STDLIB, == 1) +#include +#endif + +#include +#include +#include + +class A +{ +private: + friend class boost::serialization::access; + // note: from an aesthetic perspective, I would much prefer to have this + // defined out of line. Unfortunately, this trips a bug in the VC 6.0 + // compiler. So hold our nose and put it her to permit running of tests. + template + void serialize( + Archive &ar, + const unsigned int /* file_version */ + ){ + ar & BOOST_SERIALIZATION_NVP(b); + #ifndef BOOST_NO_INT64_T + ar & BOOST_SERIALIZATION_NVP(f); + ar & BOOST_SERIALIZATION_NVP(g); + #endif + #if BOOST_WORKAROUND(__BORLANDC__, <= 0x551 ) + int i; + if(BOOST_DEDUCED_TYPENAME Archive::is_saving::value){ + i = l; + ar & BOOST_SERIALIZATION_NVP(i); + } + else{ + ar & BOOST_SERIALIZATION_NVP(i); + l = i; + } + #else + ar & BOOST_SERIALIZATION_NVP(l); + #endif + ar & BOOST_SERIALIZATION_NVP(m); + ar & BOOST_SERIALIZATION_NVP(n); + ar & BOOST_SERIALIZATION_NVP(o); + ar & BOOST_SERIALIZATION_NVP(p); + ar & BOOST_SERIALIZATION_NVP(q); + #ifndef BOOST_NO_CWCHAR + ar & BOOST_SERIALIZATION_NVP(r); + #endif + ar & BOOST_SERIALIZATION_NVP(c); + ar & BOOST_SERIALIZATION_NVP(s); + ar & BOOST_SERIALIZATION_NVP(t); + ar & BOOST_SERIALIZATION_NVP(u); + ar & BOOST_SERIALIZATION_NVP(v); + ar & BOOST_SERIALIZATION_NVP(w); + ar & BOOST_SERIALIZATION_NVP(x); + ar & BOOST_SERIALIZATION_NVP(y); + #ifndef BOOST_NO_STD_WSTRING + ar & BOOST_SERIALIZATION_NVP(z); + #endif + } + bool b; + #ifndef BOOST_NO_INT64_T + boost::int64_t f; + boost::uint64_t g; + #endif + enum h { + i = 0, + j, + k + } l; + std::size_t m; + signed long n; + unsigned long o; + signed short p; + unsigned short q; + #ifndef BOOST_NO_CWCHAR + wchar_t r; + #endif + char c; + signed char s; + unsigned char t; + signed int u; + unsigned int v; + float w; + double x; + std::string y; + #ifndef BOOST_NO_STD_WSTRING + std::wstring z; + #endif +public: + A(); + bool operator==(const A &rhs) const; + bool operator!=(const A &rhs) const; + bool operator<(const A &rhs) const; // used by less + // hash function for class A + operator std::size_t () const; + friend std::ostream & operator<<(std::ostream & os, A const & a); + friend std::istream & operator>>(std::istream & is, A & a); +}; + +//BOOST_TEST_DONT_PRINT_LOG_VALUE(A); + +template +void randomize(S &x) +{ + assert(0 == x.size()); + for(;;){ + unsigned int i = std::rand() % 27; + if(0 == i) + break; + x += static_cast ('a' - 1 + i); + } +} + +template +void accumulate(std::size_t & s, const T & t){ + const char * tptr = (const char *)(& t); + unsigned int count = sizeof(t); + while(count-- > 0){ + s += *tptr++; + } +} + +A::operator std::size_t () const { + std::size_t retval = 0; + accumulate(retval, b); + #ifndef BOOST_NO_INT64_T + accumulate(retval, f); + accumulate(retval, g); + #endif + accumulate(retval, l); + accumulate(retval, m); + accumulate(retval, n); + accumulate(retval, o); + accumulate(retval, p); + accumulate(retval, q); + #ifndef BOOST_NO_CWCHAR + accumulate(retval, r); + #endif + accumulate(retval, c); + accumulate(retval, s); + accumulate(retval, t); + accumulate(retval, u); + accumulate(retval, v); + return retval; +} + +inline A::A() : + b(true), + #ifndef BOOST_NO_INT64_T + f(std::rand() * std::rand()), + g(std::rand() * std::rand()), + #endif + l(static_cast (std::rand() % 3)), + m(std::rand()), + n(std::rand()), + o(std::rand()), + p(std::rand()), + q(std::rand()), + #ifndef BOOST_NO_CWCHAR + r(std::rand()), + #endif + c(std::rand()), + s(std::rand()), + t(std::rand()), + u(std::rand()), + v(std::rand()), + w((float)std::rand()), + x((double)std::rand()) +{ + randomize(y); + #ifndef BOOST_NO_STD_WSTRING + randomize(z); + #endif +} + +inline bool A::operator==(const A &rhs) const +{ + if(b != rhs.b) + return false; + if(l != rhs.l) + return false; + #ifndef BOOST_NO_INT64_T + if(f != rhs.f) + return false; + if(g != rhs.g) + return false; + #endif + if(m != rhs.m) + return false; + if(n != rhs.n) + return false; + if(o != rhs.o) + return false; + if(p != rhs.p) + return false; + if(q != rhs.q) + return false; + #ifndef BOOST_NO_CWCHAR + if(r != rhs.r) + return false; + #endif + if(c != rhs.c) + return false; + if(s != rhs.s) + return false; + if(t != rhs.t) + return false; + if(u != rhs.u) + return false; + if(v != rhs.v) + return false; + if(w == 0 && std::fabs(rhs.w) > std::numeric_limits ::epsilon()) + return false; + if(std::fabs(rhs.w/w - 1.0) > std::numeric_limits ::epsilon()) + return false; + if(x == 0 && std::fabs(rhs.x - x) > std::numeric_limits ::epsilon()) + return false; + if(std::fabs(rhs.x/x - 1.0) > std::numeric_limits ::epsilon()) + return false; + if(0 != y.compare(rhs.y)) + return false; + #ifndef BOOST_NO_STD_WSTRING + if(0 != z.compare(rhs.z)) + return false; + #endif + return true; +} + +inline bool A::operator!=(const A &rhs) const +{ + return ! (*this == rhs); +} + +inline bool A::operator<(const A &rhs) const +{ + if(b != rhs.b) + return b < rhs.b; + #ifndef BOOST_NO_INT64_T + if(f != rhs.f) + return f < rhs.f; + if(g != rhs.g) + return g < rhs.g; + #endif + if(l != rhs.l ) + return l < rhs.l; + if(m != rhs.m ) + return m < rhs.m; + if(n != rhs.n ) + return n < rhs.n; + if(o != rhs.o ) + return o < rhs.o; + if(p != rhs.p ) + return p < rhs.p; + if(q != rhs.q ) + return q < rhs.q; + #ifndef BOOST_NO_CWCHAR + if(r != rhs.r ) + return r < rhs.r; + #endif + if(c != rhs.c ) + return c < rhs.c; + if(s != rhs.s ) + return s < rhs.s; + if(t != rhs.t ) + return t < rhs.t; + if(u != rhs.u ) + return u < rhs.u; + if(v != rhs.v ) + return v < rhs.v; + if(w != rhs.w ) + return w < rhs.w; + if(x != rhs.x ) + return x < rhs.x; + int i = y.compare(rhs.y); + if(i != 0 ) + return i < 0; + #ifndef BOOST_NO_STD_WSTRING + int j = z.compare(rhs.z); + if(j != 0 ) + return j < 0; + #endif + return false; +} + +#endif // BOOST_SERIALIZATION_TEST_A_HPP diff --git a/example/demo_dll_b.hpp b/example/demo_dll_b.hpp new file mode 100644 index 00000000..245ce371 --- /dev/null +++ b/example/demo_dll_b.hpp @@ -0,0 +1,112 @@ +#ifndef BOOST_SERIALIZATION_TEST_B_HPP +#define BOOST_SERIALIZATION_TEST_B_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 +// B.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 // for rand() + +#include +#if defined(BOOST_NO_STDC_NAMESPACE) +namespace std{ + using ::rand; +} +#endif + +#include +#include +#include + +#include "A.hpp" + +/////////////////////////////////////////////////////// +// Derived class test +class B : public A +{ +private: + friend class boost::serialization::access; + template + void save(Archive &ar, const unsigned int /* file_version */) const + { + // write any base class info to the archive + ar << BOOST_SERIALIZATION_BASE_OBJECT_NVP(A); + + // write out members + ar << BOOST_SERIALIZATION_NVP(s); + ar << BOOST_SERIALIZATION_NVP(t); + ar << BOOST_SERIALIZATION_NVP(u); + ar << BOOST_SERIALIZATION_NVP(v); + ar << BOOST_SERIALIZATION_NVP(w); + ar << BOOST_SERIALIZATION_NVP(x); + } + + template + void load(Archive & ar, const unsigned int file_version) + { + // read any base class info to the archive + ar >> BOOST_SERIALIZATION_BASE_OBJECT_NVP(A); + switch(file_version){ + case 1: + case 2: + ar >> BOOST_SERIALIZATION_NVP(s); + ar >> BOOST_SERIALIZATION_NVP(t); + ar >> BOOST_SERIALIZATION_NVP(u); + ar >> BOOST_SERIALIZATION_NVP(v); + ar >> BOOST_SERIALIZATION_NVP(w); + ar >> BOOST_SERIALIZATION_NVP(x); + default: + break; + } + } + + BOOST_SERIALIZATION_SPLIT_MEMBER() + signed char s; + unsigned char t; + signed int u; + unsigned int v; + float w; + double x; +public: + B(); + virtual ~B(){}; + bool operator==(const B &rhs) const; +}; + +B::B() : + s(std::rand()), + t(std::rand()), + u(std::rand()), + v(std::rand()), + w((float)std::rand() / std::rand()), + x((double)std::rand() / std::rand()) +{ +} + +BOOST_CLASS_VERSION(B, 2) + +inline bool B::operator==(const B &rhs) const +{ + return + A::operator==(rhs) + && s == rhs.s + && t == rhs.t + && u == rhs.u + && v == rhs.v + && std::fabs(w - rhs.w) <= std::numeric_limits ::round_error() + && std::fabs(x - rhs.x) <= std::numeric_limits ::round_error() + ; +} + +#endif // BOOST_SERIALIZATION_TEST_B_HPP diff --git a/example/demo_dll_b.ipp b/example/demo_dll_b.ipp new file mode 100644 index 00000000..245ce371 --- /dev/null +++ b/example/demo_dll_b.ipp @@ -0,0 +1,112 @@ +#ifndef BOOST_SERIALIZATION_TEST_B_HPP +#define BOOST_SERIALIZATION_TEST_B_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 +// B.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 // for rand() + +#include +#if defined(BOOST_NO_STDC_NAMESPACE) +namespace std{ + using ::rand; +} +#endif + +#include +#include +#include + +#include "A.hpp" + +/////////////////////////////////////////////////////// +// Derived class test +class B : public A +{ +private: + friend class boost::serialization::access; + template + void save(Archive &ar, const unsigned int /* file_version */) const + { + // write any base class info to the archive + ar << BOOST_SERIALIZATION_BASE_OBJECT_NVP(A); + + // write out members + ar << BOOST_SERIALIZATION_NVP(s); + ar << BOOST_SERIALIZATION_NVP(t); + ar << BOOST_SERIALIZATION_NVP(u); + ar << BOOST_SERIALIZATION_NVP(v); + ar << BOOST_SERIALIZATION_NVP(w); + ar << BOOST_SERIALIZATION_NVP(x); + } + + template + void load(Archive & ar, const unsigned int file_version) + { + // read any base class info to the archive + ar >> BOOST_SERIALIZATION_BASE_OBJECT_NVP(A); + switch(file_version){ + case 1: + case 2: + ar >> BOOST_SERIALIZATION_NVP(s); + ar >> BOOST_SERIALIZATION_NVP(t); + ar >> BOOST_SERIALIZATION_NVP(u); + ar >> BOOST_SERIALIZATION_NVP(v); + ar >> BOOST_SERIALIZATION_NVP(w); + ar >> BOOST_SERIALIZATION_NVP(x); + default: + break; + } + } + + BOOST_SERIALIZATION_SPLIT_MEMBER() + signed char s; + unsigned char t; + signed int u; + unsigned int v; + float w; + double x; +public: + B(); + virtual ~B(){}; + bool operator==(const B &rhs) const; +}; + +B::B() : + s(std::rand()), + t(std::rand()), + u(std::rand()), + v(std::rand()), + w((float)std::rand() / std::rand()), + x((double)std::rand() / std::rand()) +{ +} + +BOOST_CLASS_VERSION(B, 2) + +inline bool B::operator==(const B &rhs) const +{ + return + A::operator==(rhs) + && s == rhs.s + && t == rhs.t + && u == rhs.u + && v == rhs.v + && std::fabs(w - rhs.w) <= std::numeric_limits ::round_error() + && std::fabs(x - rhs.x) <= std::numeric_limits ::round_error() + ; +} + +#endif // BOOST_SERIALIZATION_TEST_B_HPP diff --git a/example/demo_exception.cpp b/example/demo_exception.cpp index 17a2e97b..122a05a0 100644 --- a/example/demo_exception.cpp +++ b/example/demo_exception.cpp @@ -19,6 +19,7 @@ #include #include +#include // NULL #include #include diff --git a/example/demo_gps.hpp b/example/demo_gps.hpp index 5749eff1..3e9e6dd2 100644 --- a/example/demo_gps.hpp +++ b/example/demo_gps.hpp @@ -91,7 +91,7 @@ public: virtual ~bus_stop(){} }; -BOOST_IS_ABSTRACT(bus_stop) +BOOST_SERIALIZATION_ASSUME_ABSTRACT(bus_stop) std::ostream & operator<<(std::ostream &os, const bus_stop &bs) { diff --git a/example/demo_portable_archive.cpp b/example/demo_portable_archive.cpp index b3b983a2..5727acca 100644 --- a/example/demo_portable_archive.cpp +++ b/example/demo_portable_archive.cpp @@ -10,7 +10,6 @@ // should pass compilation and execution #include -#define BOOST_ARCHIVE_SOURCE #include "portable_binary_oarchive.hpp" #include "portable_binary_iarchive.hpp" @@ -20,30 +19,36 @@ namespace std{ using ::rand; } #endif -// the following is required to be sure the "EXPORT" works if it is used -#define CUSTOM_ARCHIVE_TYPES portable_binary_oarchive,portable_binary_iarchive - class A { friend class boost::serialization::access; + char c; int i; + int i2; // special tricky case to check sign extension unsigned int ui; long l; unsigned long ul; template void serialize(Archive & ar, const unsigned int /* version */){ - ar & i & ui & l & ul ; + ar & c & i & i2 & ui & l & ul ; } public: bool operator==(const A & rhs) const { return - i == rhs.i && ui == rhs.ui && l == rhs.l && ul == rhs.ul + c == rhs.c + && i == rhs.i + && i2 == rhs.i2 + && ui == rhs.ui + && l == rhs.l + && ul == rhs.ul ; } A() : + c(std::rand()), i(std::rand()), + i2(0x80), ui(std::rand()), - l(std::rand()), + l(std::rand() * std::rand()), ul(std::rand()) {} }; @@ -62,6 +67,31 @@ int main( int /* argc */, char* /* argv */[] ) portable_binary_iarchive pbia(ss); pbia >> a1; } + if(! (a == a1)) + return 1; + + ss.clear(); + { + portable_binary_oarchive pboa(ss, endian_big); + pboa << a; + } + { + portable_binary_iarchive pbia(ss, endian_big); + pbia >> a1; + } + if(! (a == a1)) + return 1; + + ss.clear(); + { + portable_binary_oarchive pboa(ss, endian_big); + pboa << a; + } + { + portable_binary_iarchive pbia(ss, endian_big); + pbia >> a1; + } + return !(a == a1); } diff --git a/example/demo_shared_ptr.cpp b/example/demo_shared_ptr.cpp index 2fda6e02..c4645169 100644 --- a/example/demo_shared_ptr.cpp +++ b/example/demo_shared_ptr.cpp @@ -11,6 +11,7 @@ #include #include +#include // NULL #include #include @@ -41,8 +42,8 @@ private: } public: static int count; - A::A(){++count;} // default constructor - virtual A::~A(){--count;} // default destructor + A(){++count;} // default constructor + virtual ~A(){--count;} // default destructor }; BOOST_SERIALIZATION_SHARED_PTR(A) @@ -60,8 +61,8 @@ private: } public: static int count; - B::B() : A() {}; - virtual B::~B() {}; + B() : A() {}; + virtual ~B() {}; }; BOOST_SERIALIZATION_SHARED_PTR(B) @@ -81,7 +82,7 @@ void display(boost::shared_ptr &spa, boost::shared_ptr &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"; diff --git a/example/demo_xml.hpp b/example/demo_xml.hpp new file mode 100644 index 00000000..408412a1 --- /dev/null +++ b/example/demo_xml.hpp @@ -0,0 +1,284 @@ +#ifndef BOOST_SERIALIZATION_EXAMPLE_DEMO_XML_HPP +#define BOOST_SERIALIZATION_EXAMPLE_DEMO_XML_HPP + +/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8 +// +// demo_xml.hpp +// +// (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) + + +#include +#include +#include +#include + +#include +#include +#include +#include + +// This illustration models the bus system of a small city. +// This includes, multiple bus stops, bus routes and schedules. +// There are different kinds of stops. Bus stops in general will +// will appear on multiple routes. A schedule will include +// muliple trips on the same route. + +///////////////////////////////////////////////////////////// +// gps coordinate +// +// llustrates serialization for a simple type +// +class gps_position +{ + friend class boost::serialization::access; + friend std::ostream & operator<<(std::ostream &os, const gps_position &gp); + + int degrees; + int minutes; + float seconds; + + template + void serialize(Archive & ar, const unsigned int /* file_version */){ + ar & BOOST_SERIALIZATION_NVP(degrees) + & BOOST_SERIALIZATION_NVP(minutes) + & BOOST_SERIALIZATION_NVP(seconds); + } + +public: + // every serializable class needs a constructor + gps_position(){}; + gps_position(int _d, int _m, float _s) : + degrees(_d), minutes(_m), seconds(_s) + {} +}; + +std::ostream & operator<<(std::ostream &os, const gps_position &gp) +{ + return os << ' ' << gp.degrees << (unsigned char)186 << gp.minutes << '\'' << gp.seconds << '"'; +} + +///////////////////////////////////////////////////////////// +// One bus stop +// +// illustrates serialization of serializable members +// + +class bus_stop +{ + friend class boost::serialization::access; + virtual std::string description() const = 0; + gps_position latitude; + gps_position longitude; + + template + void serialize(Archive &ar, const unsigned int version) + { + ar & BOOST_SERIALIZATION_NVP(latitude); + ar & BOOST_SERIALIZATION_NVP(longitude); + } + +protected: + bus_stop(const gps_position & _lat, const gps_position & _long) : + latitude(_lat), longitude(_long) + {} +public: + bus_stop(){} + friend std::ostream & operator<<(std::ostream &os, const bus_stop &gp); + virtual ~bus_stop(){} +}; + +BOOST_IS_ABSTRACT(bus_stop) + +std::ostream & operator<<(std::ostream &os, const bus_stop &bs) +{ + return os << bs.latitude << bs.longitude << ' ' << bs.description(); +} + +///////////////////////////////////////////////////////////// +// Several kinds of bus stops +// +// illustrates serialization of derived types +// +class bus_stop_corner : public bus_stop +{ + friend class boost::serialization::access; + std::string street1; + std::string street2; + virtual std::string description() const + { + return street1 + " and " + street2; + } + template + void serialize(Archive &ar, const unsigned int version) + { + // save/load base class information + ar & BOOST_SERIALIZATION_BASE_OBJECT_NVP(bus_stop); + ar & BOOST_SERIALIZATION_NVP(street1); + ar & BOOST_SERIALIZATION_NVP(street2); + } +public: + bus_stop_corner(){} + bus_stop_corner(const gps_position & _lat, const gps_position & _long, + const std::string & _s1, const std::string & _s2 + ) : + bus_stop(_lat, _long), street1(_s1), street2(_s2) + { + } +}; + +class bus_stop_destination : public bus_stop +{ + friend class boost::serialization::access; + std::string name; + virtual std::string description() const + { + return name; + } + template + void serialize(Archive &ar, const unsigned int version) + { + ar & BOOST_SERIALIZATION_BASE_OBJECT_NVP(bus_stop) + & BOOST_SERIALIZATION_NVP(name); + } +public: + bus_stop_destination(){} + bus_stop_destination( + const gps_position & _lat, const gps_position & _long, const std::string & _name + ) : + bus_stop(_lat, _long), name(_name) + { + } +}; + +///////////////////////////////////////////////////////////// +// a bus route is a collection of bus stops +// +// illustrates serialization of STL collection templates. +// +// illustrates serialzation of polymorphic pointer (bus stop *); +// +// illustrates storage and recovery of shared pointers is correct +// and efficient. That is objects pointed to by more than one +// pointer are stored only once. In such cases only one such +// object is restored and pointers are restored to point to it +// +class bus_route +{ + friend class boost::serialization::access; + friend std::ostream & operator<<(std::ostream &os, const bus_route &br); + typedef bus_stop * bus_stop_pointer; + std::list stops; + template + void serialize(Archive &ar, const unsigned int version) + { + // in this program, these classes are never serialized directly but rather + // through a pointer to the base class bus_stop. So we need a way to be + // sure that the archive contains information about these derived classes. + //ar.template register_type (); + ar.register_type(static_cast (NULL)); + //ar.template register_type (); + ar.register_type(static_cast (NULL)); + // serialization of stl collections is already defined + // in the header + ar & BOOST_SERIALIZATION_NVP(stops); + } +public: + bus_route(){} + void append(bus_stop *_bs) + { + stops.insert(stops.end(), _bs); + } +}; +std::ostream & operator<<(std::ostream &os, const bus_route &br) +{ + std::list ::const_iterator it; + // note: we're displaying the pointer to permit verification + // that duplicated pointers are properly restored. + for(it = br.stops.begin(); it != br.stops.end(); it++){ + os << '\n' << std::hex << "0x" << *it << std::dec << ' ' << **it; + } + return os; +} + +///////////////////////////////////////////////////////////// +// a bus schedule is a collection of routes each with a starting time +// +// Illustrates serialization of STL objects(pair) in a non-intrusive way. +// See definition of operator<< + void serialize(Archive &ar, const unsigned int version) + { + ar & BOOST_SERIALIZATION_NVP(schedule); + } + // note: this structure was made public. because the friend declarations + // didn't seem to work as expected. +public: + struct trip_info + { + template + void serialize(Archive &ar, const unsigned int file_version) + { + // in versions 2 or later + if(file_version >= 2) + // read the drivers name + ar & BOOST_SERIALIZATION_NVP(driver); + // all versions have the follwing info + ar & BOOST_SERIALIZATION_NVP(hour) + & BOOST_SERIALIZATION_NVP(minute); + } + + // starting time + int hour; + int minute; + // only after system shipped was the driver's name added to the class + std::string driver; + + trip_info(){} + trip_info(int _h, int _m, const std::string &_d) : + hour(_h), minute(_m), driver(_d) + {} + ~trip_info(){ + } + }; +// friend std::ostream & operator<<(std::ostream &os, const trip_info &ti); +private: + std::list + +#define BOOST_ARCHIVE_SOURCE +#include "polymorphic_portable_binary_iarchive.hpp" + +// explicitly instantiate for this type of text stream +#include +#include +#include + +namespace boost { +namespace archive { + +template class binary_iarchive_impl< + polymorphic_portable_binary_iarchive, + std::istream::char_type, + std::istream::traits_type +>; +template class detail::archive_pointer_iserializer< + polymorphic_portable_binary_iarchive +> ; + +} // namespace archive +} // namespace boost diff --git a/example/polymorphic_portable_binary_iarchive.hpp b/example/polymorphic_portable_binary_iarchive.hpp new file mode 100644 index 00000000..95c54695 --- /dev/null +++ b/example/polymorphic_portable_binary_iarchive.hpp @@ -0,0 +1,35 @@ +#ifndef BOOST_ARCHIVE_POLYMORPHIC_PORTABLE_BINARY_IARCHIVE_HPP +#define BOOST_ARCHIVE_POLYMORPHIC_PORTABLE_BINARY_IARCHIVE_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 +// polymorphic_portable_binary_iarchive.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 +#include "portable_binary_iarchive.hpp" + +typedef boost::archive::detail::polymorphic_iarchive_dispatch< + portable_binary_iarchive +> polymorphic_portable_binary_iarchive; + +#include +#if BOOST_VERSION > 103401 + // required by export + BOOST_SERIALIZATION_REGISTER_ARCHIVE( + polymorphic_portable_binary_iarchive + ) +#endif + +#endif // BOOST_ARCHIVE_POLYMORPHIC_PORTABLE_BINARY_OARCHIVE_HPP + diff --git a/example/polymorphic_portable_binary_oarchive.cpp b/example/polymorphic_portable_binary_oarchive.cpp new file mode 100644 index 00000000..f77b9021 --- /dev/null +++ b/example/polymorphic_portable_binary_oarchive.cpp @@ -0,0 +1,35 @@ +/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8 +// polymorphic_portable_binary_oarchive.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. + +#include + +#define BOOST_ARCHIVE_SOURCE +#include "polymorphic_portable_binary_oarchive.hpp" + +// explicitly instantiate for this type of text stream +#include +#include +#include + +namespace boost { +namespace archive { + +// explicitly instantiate for this type of binary stream +template class binary_oarchive_impl< + polymorphic_portable_binary_oarchive, + std::ostream::char_type, + std::ostream::traits_type +>; +template class detail::archive_pointer_oserializer< + polymorphic_portable_binary_oarchive +> ; + +} // namespace archive +} // namespace boost diff --git a/example/polymorphic_portable_binary_oarchive.hpp b/example/polymorphic_portable_binary_oarchive.hpp new file mode 100644 index 00000000..d2474640 --- /dev/null +++ b/example/polymorphic_portable_binary_oarchive.hpp @@ -0,0 +1,34 @@ +#ifndef BOOST_ARCHIVE_POLYMORPHIC_PORTABLE_BINARY_OARCHIVE_HPP +#define BOOST_ARCHIVE_POLYMORPHIC_PORTABLE_BINARY_OARCHIVE_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 +// polymorphic_portable_binary_oarchive.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 +#include "portable_binary_oarchive.hpp" + +typedef boost::archive::detail::polymorphic_oarchive_dispatch< + portable_binary_oarchive + > polymorphic_portable_binary_oarchive; + +#include +#if BOOST_VERSION > 103401 + // required by export + BOOST_SERIALIZATION_REGISTER_ARCHIVE( + polymorphic_portable_binary_oarchive + ) +#endif + +#endif // BOOST_ARCHIVE_POLYMORPHIC_PORTABLE_BINARY_OARCHIVE_HPP diff --git a/example/portable_binary_archive.hpp b/example/portable_binary_archive.hpp new file mode 100644 index 00000000..590a208e --- /dev/null +++ b/example/portable_binary_archive.hpp @@ -0,0 +1,42 @@ +#ifndef PORTABLE_BINARY_ARCHIVE_HPP +#define PORTABLE_BINARY_ARCHIVE_HPP + +// MS compatible compilers support #pragma once +#if defined(_MSC_VER) && (_MSC_VER >= 1020) +# pragma once +#endif + +#include +#include +#include +#include + +#include +#if CHAR_BIT != 8 +#error This code assumes an eight-bit byte. +#endif + +#include +#include + +enum portable_binary_archive_flags { + endian_big = 0x4000, + endian_little = 0x8000 +}; + +//#if ( endian_big <= boost::archive::flags_last ) +//#error archive flags conflict +//#endif + +inline void +reverse_bytes(char size, char *address){ + char * first = address; + char * last = first + size - 1; + for(;first < last;++first, --last){ + char x = *last; + *last = *first; + *first = x; + } +} + +#endif // PORTABLE_BINARY_ARCHIVE_HPP diff --git a/example/portable_binary_iarchive.cpp b/example/portable_binary_iarchive.cpp new file mode 100644 index 00000000..3491ab91 --- /dev/null +++ b/example/portable_binary_iarchive.cpp @@ -0,0 +1,130 @@ +/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8 +// portable_binary_iarchive.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. + +#include +#include +//#include // memcpy + +#include +#include +#include + +#include "portable_binary_iarchive.hpp" + +void +portable_binary_iarchive::load_impl(boost::intmax_t & l, char maxsize){ + char size; + l = 0; + this->primitive_base_t::load(size); + + if(0 == size){ + return; + } + + bool negative = (size < 0); + if(negative) + size = -size; + + if(size > maxsize) + boost::throw_exception( + portable_binary_iarchive_exception() + ); + + char * cptr = reinterpret_cast (& l); + #ifdef BOOST_BIG_ENDIAN + cptr += (sizeof(boost::intmax_t) - size); + #endif + this->primitive_base_t::load_binary(cptr, size); + + #ifdef BOOST_BIG_ENDIAN + if(m_flags & endian_little) + #else + if(m_flags & endian_big) + #endif + reverse_bytes(size, cptr); + + if(negative) + l = -l; +} + +void +portable_binary_iarchive::load_override( + boost::archive::class_name_type & t, int +){ + std::string cn; + cn.reserve(BOOST_SERIALIZATION_MAX_KEY_SIZE); + load_override(cn, 0); + if(cn.size() > (BOOST_SERIALIZATION_MAX_KEY_SIZE - 1)) + boost::throw_exception( + boost::archive::archive_exception( + boost::archive::archive_exception::invalid_class_name) + ); + std::memcpy(t, cn.data(), cn.size()); + // borland tweak + t.t[cn.size()] = '\0'; +} + +void +portable_binary_iarchive::init(unsigned int flags){ + if(0 == (flags & boost::archive::no_header)){ + // read signature in an archive version independent manner + std::string file_signature; + * this >> file_signature; + 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::version_type input_library_version; + * this >> input_library_version; + + // extra little .t is to get around borland quirk + if(boost::archive::ARCHIVE_VERSION() < input_library_version.t) + boost::throw_exception( + boost::archive::archive_exception( + boost::archive::archive_exception::unsupported_version + ) + ); + + #if BOOST_WORKAROUND(__MWERKS__, BOOST_TESTED_AT(0x3205)) + this->set_library_version(input_library_version); + //#else + //#if ! BOOST_WORKAROUND(BOOST_MSVC, <= 1200) + //detail:: + //#endif + boost::archive::detail::basic_iarchive::set_library_version( + input_library_version + ); + #endif + } + unsigned char x; + load(x); + m_flags = x << CHAR_BIT; +} + +// explicitly instantiate for this +#include +#include + +namespace boost { +namespace archive { + +template class detail::archive_pointer_iserializer ; +template class basic_binary_iprimitive< + portable_binary_iarchive, + std::istream::char_type, + std::istream::traits_type +> ; + +} // namespace archive +} // namespace boost diff --git a/example/portable_binary_iarchive.hpp b/example/portable_binary_iarchive.hpp index e5e93151..05d2199a 100644 --- a/example/portable_binary_iarchive.hpp +++ b/example/portable_binary_iarchive.hpp @@ -6,31 +6,42 @@ # pragma once #endif +#if defined(_MSC_VER) +#pragma warning( push ) +#pragma warning( disable : 4244 ) +#endif + /////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8 // portable_binary_iarchive.hpp -// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . +// (C) Copyright 2002-7 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 -#include -#include +#include +#include +#include +#include +#include +#include +#include + +#include "portable_binary_archive.hpp" /////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8 // exception to be thrown if integer read from archive doesn't fit // variable being loaded -class portable_binary_archive_exception : +class portable_binary_iarchive_exception : public virtual boost::archive::archive_exception { public: typedef enum { incompatible_integer_size } exception_code; - portable_binary_archive_exception(exception_code c = incompatible_integer_size ) + portable_binary_iarchive_exception(exception_code c = incompatible_integer_size ) {} virtual const char *what( ) const throw( ) { @@ -46,128 +57,132 @@ public: }; /////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8 -// "Portable" input binary archive. This is a variation of the native binary -// archive. it addresses integer size and endienness so that binary archives can -// be passed across systems. Note:floating point types not addressed here +// "Portable" input binary archive. It addresses integer size and endienness so +// that binary archives can be passed across systems. Note:floating point types +// not addressed here class portable_binary_iarchive : - // don't derive from binary_iarchive !!! - public boost::archive::binary_iarchive_impl< - portable_binary_iarchive, + public boost::archive::basic_binary_iprimitive< + portable_binary_iarchive, std::istream::char_type, std::istream::traits_type >, + public boost::archive::detail::common_iarchive< + portable_binary_iarchive + > + , public boost::archive::detail::shared_ptr_helper -{ - typedef boost::archive::binary_iarchive_impl< - portable_binary_iarchive, + { + typedef boost::archive::basic_binary_iprimitive< + portable_binary_iarchive, std::istream::char_type, std::istream::traits_type - > archive_base_t; - typedef boost::archive::basic_binary_iprimitive< - portable_binary_iarchive, - std::ostream::char_type, - std::ostream::traits_type > primitive_base_t; + typedef boost::archive::detail::common_iarchive< + portable_binary_iarchive + > archive_base_t; #ifndef BOOST_NO_MEMBER_TEMPLATE_FRIENDS public: #else friend archive_base_t; friend primitive_base_t; // since with override load below - friend class boost::archive::basic_binary_iarchive ; + friend class boost::archive::detail::interface_iarchive< + portable_binary_iarchive + >; friend class boost::archive::load_access; +protected: #endif - void load_impl(long & l, char maxsize){ - char size; - this->archive_base_t::load(size); - if(size > maxsize) - throw portable_binary_archive_exception() ; - l = 0; - load_binary(& l, size); - // we choose to use litle endian - #ifdef BOOST_BIG_ENDIAN - char * first = static_cast (static_cast (& l)); - char * last = first + sizeof(l) - 1; - for(;first < last;++first, --last){ - char x = *last; - *last = *first; - *first = x; - } - #endif + unsigned int m_flags; + void load_impl(boost::intmax_t & l, char maxsize); - // extend sign if necessary - if((l >> (size - 1) * 8) & 0x80){ - l |= (-1 << (size * 8)); - } - } // default fall through for any types not specified here template void load(T & t){ + boost::intmax_t l; + load_impl(l, sizeof(T)); + // use cast to avoid compile time warning + t = static_cast (l); + } + void load(std::string & t){ this->primitive_base_t::load(t); } - void load(unsigned short & t){ - long l; - load_impl(l, sizeof(unsigned short)); - t = l; + #ifndef BOOST_NO_STD_WSTRING + void load(std::wstring & t){ + this->primitive_base_t::load(t); } - void load(short & t){ - long l; - load_impl(l, sizeof(short)); - t = l; + #endif + void load(float & t){ + this->primitive_base_t::load(t); + // floats not supported + //BOOST_STATIC_ASSERT(false); } - void load(unsigned int & t){ - long l; - load_impl(l, sizeof(unsigned int)); - t = l; + void load(double & t){ + this->primitive_base_t::load(t); + // doubles not supported + //BOOST_STATIC_ASSERT(false); } - void load(int & t){ - long l; - load_impl(l, sizeof(int)); - t = l; + void load(char & t){ + this->primitive_base_t::load(t); } - void load(unsigned long & t){ - long l; - load_impl(l, sizeof(unsigned long)); - t = l; + void load(unsigned char & t){ + this->primitive_base_t::load(t); } - void load(long & t){ - long l; - load_impl(l, sizeof(long)); - t = l; + // intermediate level to support override of operators + // fot templates in the absence of partial function + // template ordering + typedef boost::archive::detail::common_iarchive + detail_common_iarchive; + template + void load_override(T & t, BOOST_PFTO int){ + this->detail_common_iarchive::load_override(t, 0); } + void load_override(boost::archive::class_name_type & t, int); + // binary files don't include the optional information + void load_override( + boost::archive::class_id_optional_type & /* t */, + int + ){} + + void init(unsigned int flags); public: portable_binary_iarchive(std::istream & is, unsigned flags = 0) : - archive_base_t( - is, - flags | boost::archive::no_header // skip default header checking - ) + primitive_base_t( + * is.rdbuf(), + 0 != (flags & boost::archive::no_codecvt) + ), + archive_base_t(flags), + m_flags(0) { - // use our own header checking - if(0 != (flags & boost::archive::no_header)){ - this->archive_base_t::init(flags); - // skip the following for "portable" binary archives - // boost::archive::basic_binary_oprimitive -#include -#include - -namespace boost { -namespace archive { - -template class binary_iarchive_impl< - portable_binary_iarchive, - std::istream::char_type, - std::istream::traits_type ->; -template class detail::archive_pointer_iserializer ; - -} // namespace archive -} // namespace boost +// required by export in boost version > 1.34 +#ifdef BOOST_SERIALIZATION_REGISTER_ARCHIVE + BOOST_SERIALIZATION_REGISTER_ARCHIVE(portable_binary_iarchive) +#endif +// required by export in boost <= 1.34 #define BOOST_ARCHIVE_CUSTOM_IARCHIVE_TYPES portable_binary_iarchive +#if defined(_MSC_VER) +#pragma warning( pop ) +#endif + #endif // PORTABLE_BINARY_IARCHIVE_HPP diff --git a/example/portable_binary_oarchive.cpp b/example/portable_binary_oarchive.cpp new file mode 100644 index 00000000..336a578a --- /dev/null +++ b/example/portable_binary_oarchive.cpp @@ -0,0 +1,96 @@ +/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8 +// portable_binary_oarchive.cpp + +// (C) Copyright 2002-7 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 +#include +#include "portable_binary_oarchive.hpp" + +void +portable_binary_oarchive::save_impl( + const boost::intmax_t l, + const char maxsize +){ + char size = 0; + + if(l == 0){ + this->primitive_base_t::save(size); + return; + } + + boost::intmax_t ll; + bool negative = (l < 0); + if(negative) + ll = -l; + else + ll = l; + + do{ + ll >>= CHAR_BIT; + ++size; + }while(ll != 0); + + this->primitive_base_t::save( + static_cast (negative ? -size : size) + ); + + if(negative) + ll = -l; + else + ll = l; + char * cptr = reinterpret_cast (& ll); + #ifdef BOOST_BIG_ENDIAN + cptr += (sizeof(boost::intmax_t) - size); + if(m_flags & endian_little) + reverse_bytes(size, cptr); + #else + if(m_flags & endian_big) + reverse_bytes(size, cptr); + #endif + this->primitive_base_t::save_binary(cptr, size); +} + +void +portable_binary_oarchive::init(unsigned int flags) { + if(m_flags == (endian_big | endian_little)){ + 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::ARCHIVE_SIGNATURE() + ); + * this << file_signature; + // write library version + const boost::archive::version_type v( + boost::archive::ARCHIVE_VERSION() + ); + * this << v; + } + save(static_cast (m_flags >> CHAR_BIT)); +} + +// explicitly instantiate for this type of stream +#include +#include + +namespace boost { +namespace archive { + +template class detail::archive_pointer_oserializer ; +template class basic_binary_oprimitive< + portable_binary_oarchive, + std::ostream::char_type, + std::ostream::traits_type +> ; + +} // namespace archive +} // namespace boost diff --git a/example/portable_binary_oarchive.hpp b/example/portable_binary_oarchive.hpp index 64acd389..05c9f80b 100644 --- a/example/portable_binary_oarchive.hpp +++ b/example/portable_binary_oarchive.hpp @@ -6,6 +6,11 @@ # pragma once #endif +#if defined(_MSC_VER) +#pragma warning( push ) +#pragma warning( disable : 4244 ) +#endif + /////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8 // portable_binary_oarchive.hpp @@ -17,9 +22,38 @@ // See http://www.boost.org for updates, documentation, and revision history. #include +#include #include -#include -#include +#include +#include +#include
-
@@ -36,7 +35,9 @@ http://www.boost.org/LICENSE_1_0.txt)
- Motivation
+