Squashed 'third_party/boostorg/serialization/' content from commit 738695b
Change-Id: I48528198ad1f62b90288d249eb2243d4db02fd5d
git-subtree-dir: third_party/boostorg/serialization
git-subtree-split: 738695b70733f9d592a570fb17a505d6a029b48a
diff --git a/include/boost/archive/archive_exception.hpp b/include/boost/archive/archive_exception.hpp
new file mode 100644
index 0000000..fabcdb5
--- /dev/null
+++ b/include/boost/archive/archive_exception.hpp
@@ -0,0 +1,100 @@
+#ifndef BOOST_ARCHIVE_ARCHIVE_EXCEPTION_HPP
+#define BOOST_ARCHIVE_ARCHIVE_EXCEPTION_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER)
+# pragma once
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// archive/archive_exception.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 <exception>
+#include <boost/assert.hpp>
+#include <string>
+
+#include <boost/config.hpp>
+#include <boost/archive/detail/decl.hpp>
+
+// note: the only reason this is in here is that windows header
+// includes #define exception_code _exception_code (arrrgghhhh!).
+// the most expedient way to address this is be sure that this
+// header is always included whenever this header file is included.
+#if defined(BOOST_WINDOWS)
+#include <excpt.h>
+#endif
+
+#include <boost/archive/detail/abi_prefix.hpp> // must be the last header
+
+namespace boost {
+namespace archive {
+
+//////////////////////////////////////////////////////////////////////
+// exceptions thrown by archives
+//
+class BOOST_SYMBOL_VISIBLE archive_exception :
+ public virtual std::exception
+{
+private:
+ char m_buffer[128];
+protected:
+ BOOST_ARCHIVE_DECL unsigned int
+ append(unsigned int l, const char * a);
+ BOOST_ARCHIVE_DECL
+ archive_exception() BOOST_NOEXCEPT;
+public:
+ typedef enum {
+ no_exception, // initialized without code
+ other_exception, // any excepton not listed below
+ unregistered_class, // attempt to serialize a pointer of
+ // an unregistered class
+ invalid_signature, // first line of archive does not contain
+ // expected string
+ unsupported_version,// archive created with library version
+ // subsequent to this one
+ pointer_conflict, // an attempt has been made to directly
+ // serialize an object which has
+ // already been serialized through a pointer.
+ // Were this permitted, the archive load would result
+ // in the creation of an extra copy of the obect.
+ incompatible_native_format, // attempt to read native binary format
+ // on incompatible platform
+ array_size_too_short,// array being loaded doesn't fit in array allocated
+ input_stream_error, // error on input stream
+ invalid_class_name, // class name greater than the maximum permitted.
+ // most likely a corrupted archive or an attempt
+ // to insert virus via buffer overrun method.
+ unregistered_cast, // base - derived relationship not registered with
+ // void_cast_register
+ unsupported_class_version, // type saved with a version # greater than the
+ // one used by the program. This indicates that the program
+ // needs to be rebuilt.
+ multiple_code_instantiation, // code for implementing serialization for some
+ // type has been instantiated in more than one module.
+ output_stream_error // error on input stream
+ } exception_code;
+ exception_code code;
+
+ BOOST_ARCHIVE_DECL archive_exception(
+ exception_code c,
+ const char * e1 = NULL,
+ const char * e2 = NULL
+ ) BOOST_NOEXCEPT;
+ BOOST_ARCHIVE_DECL archive_exception(archive_exception const &) BOOST_NOEXCEPT ;
+ virtual BOOST_ARCHIVE_DECL ~archive_exception() BOOST_NOEXCEPT_OR_NOTHROW ;
+ virtual BOOST_ARCHIVE_DECL const char * what() const BOOST_NOEXCEPT_OR_NOTHROW ;
+};
+
+}// namespace archive
+}// namespace boost
+
+#include <boost/archive/detail/abi_suffix.hpp> // pops abi_suffix.hpp pragmas
+
+#endif //BOOST_ARCHIVE_ARCHIVE_EXCEPTION_HPP
diff --git a/include/boost/archive/basic_archive.hpp b/include/boost/archive/basic_archive.hpp
new file mode 100644
index 0000000..9283974
--- /dev/null
+++ b/include/boost/archive/basic_archive.hpp
@@ -0,0 +1,307 @@
+#ifndef BOOST_ARCHIVE_BASIC_ARCHIVE_HPP
+#define BOOST_ARCHIVE_BASIC_ARCHIVE_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER)
+# pragma once
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// basic_archive.hpp:
+
+// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
+// Use, modification and distribution is subject to the Boost Software
+// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+
+// See http://www.boost.org for updates, documentation, and revision history.
+#include <cstring> // count
+#include <boost/assert.hpp>
+#include <boost/config.hpp>
+#include <boost/cstdint.hpp> // size_t
+#include <boost/noncopyable.hpp>
+#include <boost/integer_traits.hpp>
+
+#include <boost/archive/detail/auto_link_archive.hpp>
+#include <boost/archive/detail/abi_prefix.hpp> // must be the last header
+
+namespace boost {
+namespace archive {
+
+#if defined(_MSC_VER)
+#pragma warning( push )
+#pragma warning( disable : 4244 4267 )
+#endif
+
+/* NOTE : Warning : Warning : Warning : Warning : Warning
+ * Don't ever changes this. If you do, they previously created
+ * binary archives won't be readable !!!
+ */
+class library_version_type {
+private:
+ typedef uint_least16_t base_type;
+ base_type t;
+public:
+ library_version_type(): t(0) {};
+ explicit library_version_type(const unsigned int & t_) : t(t_){
+ BOOST_ASSERT(t_ <= boost::integer_traits<base_type>::const_max);
+ }
+ library_version_type(const library_version_type & t_) :
+ t(t_.t)
+ {}
+ library_version_type & operator=(const library_version_type & rhs){
+ t = rhs.t;
+ return *this;
+ }
+ // used for text output
+ operator base_type () const {
+ return t;
+ }
+ // used for text input
+ operator base_type & (){
+ return t;
+ }
+ bool operator==(const library_version_type & rhs) const {
+ return t == rhs.t;
+ }
+ bool operator<(const library_version_type & rhs) const {
+ return t < rhs.t;
+ }
+};
+
+BOOST_ARCHIVE_DECL library_version_type
+BOOST_ARCHIVE_VERSION();
+
+class version_type {
+private:
+ typedef uint_least32_t base_type;
+ base_type t;
+public:
+ // should be private - but MPI fails if it's not!!!
+ version_type(): t(0) {};
+ explicit version_type(const unsigned int & t_) : t(t_){
+ BOOST_ASSERT(t_ <= boost::integer_traits<base_type>::const_max);
+ }
+ version_type(const version_type & t_) :
+ t(t_.t)
+ {}
+ version_type & operator=(const version_type & rhs){
+ t = rhs.t;
+ return *this;
+ }
+ // used for text output
+ operator base_type () const {
+ return t;
+ }
+ // used for text intput
+ operator base_type & (){
+ return t;
+ }
+ bool operator==(const version_type & rhs) const {
+ return t == rhs.t;
+ }
+ bool operator<(const version_type & rhs) const {
+ return t < rhs.t;
+ }
+};
+
+class class_id_type {
+private:
+ typedef int_least16_t base_type;
+ base_type t;
+public:
+ // should be private - but then can't use BOOST_STRONG_TYPE below
+ class_id_type() : t(0) {};
+ explicit class_id_type(const int t_) : t(t_){
+ BOOST_ASSERT(t_ <= boost::integer_traits<base_type>::const_max);
+ }
+ explicit class_id_type(const std::size_t t_) : t(t_){
+ // BOOST_ASSERT(t_ <= boost::integer_traits<base_type>::const_max);
+ }
+ class_id_type(const class_id_type & t_) :
+ t(t_.t)
+ {}
+ class_id_type & operator=(const class_id_type & rhs){
+ t = rhs.t;
+ return *this;
+ }
+
+ // used for text output
+ operator base_type () const {
+ return t;
+ }
+ // used for text input
+ operator base_type &() {
+ return t;
+ }
+ bool operator==(const class_id_type & rhs) const {
+ return t == rhs.t;
+ }
+ bool operator<(const class_id_type & rhs) const {
+ return t < rhs.t;
+ }
+};
+
+#define NULL_POINTER_TAG boost::archive::class_id_type(-1)
+
+class object_id_type {
+private:
+ typedef uint_least32_t base_type;
+ base_type t;
+public:
+ object_id_type(): t(0) {};
+ // note: presumes that size_t >= unsigned int.
+ // use explicit cast to silence useless warning
+ explicit object_id_type(const std::size_t & t_) : t(static_cast<base_type>(t_)){
+ // make quadriple sure that we haven't lost any real integer
+ // precision
+ BOOST_ASSERT(t_ <= boost::integer_traits<base_type>::const_max);
+ }
+ object_id_type(const object_id_type & t_) :
+ t(t_.t)
+ {}
+ object_id_type & operator=(const object_id_type & rhs){
+ t = rhs.t;
+ return *this;
+ }
+ // used for text output
+ operator base_type () const {
+ return t;
+ }
+ // used for text input
+ operator base_type & () {
+ return t;
+ }
+ bool operator==(const object_id_type & rhs) const {
+ return t == rhs.t;
+ }
+ bool operator<(const object_id_type & rhs) const {
+ return t < rhs.t;
+ }
+};
+
+#if defined(_MSC_VER)
+#pragma warning( pop )
+#endif
+
+struct tracking_type {
+ bool t;
+ explicit tracking_type(const bool t_ = false)
+ : t(t_)
+ {};
+ tracking_type(const tracking_type & t_)
+ : t(t_.t)
+ {}
+ operator bool () const {
+ return t;
+ };
+ operator bool & () {
+ return t;
+ };
+ tracking_type & operator=(const bool t_){
+ t = t_;
+ return *this;
+ }
+ bool operator==(const tracking_type & rhs) const {
+ return t == rhs.t;
+ }
+ bool operator==(const bool & rhs) const {
+ return t == rhs;
+ }
+ tracking_type & operator=(const tracking_type & rhs){
+ t = rhs.t;
+ return *this;
+ }
+};
+
+struct class_name_type :
+ private boost::noncopyable
+{
+ char *t;
+ operator const char * & () const {
+ return const_cast<const char * &>(t);
+ }
+ operator char * () {
+ return t;
+ }
+ std::size_t size() const {
+ return std::strlen(t);
+ }
+ explicit class_name_type(const char *key_)
+ : t(const_cast<char *>(key_)){}
+ explicit class_name_type(char *key_)
+ : t(key_){}
+ class_name_type & operator=(const class_name_type & rhs){
+ t = rhs.t;
+ return *this;
+ }
+};
+
+enum archive_flags {
+ no_header = 1, // suppress archive header info
+ no_codecvt = 2, // suppress alteration of codecvt facet
+ no_xml_tag_checking = 4, // suppress checking of xml tags
+ no_tracking = 8, // suppress ALL tracking
+ flags_last = 8
+};
+
+BOOST_ARCHIVE_DECL const char *
+BOOST_ARCHIVE_SIGNATURE();
+
+/* NOTE : Warning : Warning : Warning : Warning : Warning
+ * If any of these are changed to different sized types,
+ * binary_iarchive won't be able to read older archives
+ * unless you rev the library version and include conditional
+ * code based on the library version. There is nothing
+ * inherently wrong in doing this - but you have to be super
+ * careful because it's easy to get wrong and start breaking
+ * old archives !!!
+ */
+
+#define BOOST_ARCHIVE_STRONG_TYPEDEF(T, D) \
+ class D : public T { \
+ public: \
+ explicit D(const T tt) : T(tt){} \
+ }; \
+/**/
+
+BOOST_ARCHIVE_STRONG_TYPEDEF(class_id_type, class_id_reference_type)
+BOOST_ARCHIVE_STRONG_TYPEDEF(class_id_type, class_id_optional_type)
+BOOST_ARCHIVE_STRONG_TYPEDEF(object_id_type, object_reference_type)
+
+}// namespace archive
+}// namespace boost
+
+#include <boost/archive/detail/abi_suffix.hpp> // pops abi_suffix.hpp pragmas
+
+#include <boost/serialization/level.hpp>
+
+// set implementation level to primitive for all types
+// used internally by the serialization library
+
+BOOST_CLASS_IMPLEMENTATION(boost::archive::library_version_type, primitive_type)
+BOOST_CLASS_IMPLEMENTATION(boost::archive::version_type, primitive_type)
+BOOST_CLASS_IMPLEMENTATION(boost::archive::class_id_type, primitive_type)
+BOOST_CLASS_IMPLEMENTATION(boost::archive::class_id_reference_type, primitive_type)
+BOOST_CLASS_IMPLEMENTATION(boost::archive::class_id_optional_type, primitive_type)
+BOOST_CLASS_IMPLEMENTATION(boost::archive::class_name_type, primitive_type)
+BOOST_CLASS_IMPLEMENTATION(boost::archive::object_id_type, primitive_type)
+BOOST_CLASS_IMPLEMENTATION(boost::archive::object_reference_type, primitive_type)
+BOOST_CLASS_IMPLEMENTATION(boost::archive::tracking_type, primitive_type)
+
+#include <boost/serialization/is_bitwise_serializable.hpp>
+
+// set types used internally by the serialization library
+// to be bitwise serializable
+
+BOOST_IS_BITWISE_SERIALIZABLE(boost::archive::library_version_type)
+BOOST_IS_BITWISE_SERIALIZABLE(boost::archive::version_type)
+BOOST_IS_BITWISE_SERIALIZABLE(boost::archive::class_id_type)
+BOOST_IS_BITWISE_SERIALIZABLE(boost::archive::class_id_reference_type)
+BOOST_IS_BITWISE_SERIALIZABLE(boost::archive::class_id_optional_type)
+BOOST_IS_BITWISE_SERIALIZABLE(boost::archive::class_name_type)
+BOOST_IS_BITWISE_SERIALIZABLE(boost::archive::object_id_type)
+BOOST_IS_BITWISE_SERIALIZABLE(boost::archive::object_reference_type)
+BOOST_IS_BITWISE_SERIALIZABLE(boost::archive::tracking_type)
+
+#endif //BOOST_ARCHIVE_BASIC_ARCHIVE_HPP
diff --git a/include/boost/archive/basic_binary_iarchive.hpp b/include/boost/archive/basic_binary_iarchive.hpp
new file mode 100644
index 0000000..c0cc655
--- /dev/null
+++ b/include/boost/archive/basic_binary_iarchive.hpp
@@ -0,0 +1,204 @@
+#ifndef BOOST_ARCHIVE_BASIC_BINARY_IARCHIVE_HPP
+#define BOOST_ARCHIVE_BASIC_BINARY_IARCHIVE_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER)
+# pragma once
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// basic_binary_iarchive.hpp
+//
+// archives stored as native binary - this should be the fastest way
+// to archive the state of a group of obects. It makes no attempt to
+// convert to any canonical form.
+
+// IN GENERAL, ARCHIVES CREATED WITH THIS CLASS WILL NOT BE READABLE
+// ON PLATFORM APART FROM THE ONE THEY ARE CREATED ON
+
+// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
+// Use, modification and distribution is subject to the Boost Software
+// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+
+// See http://www.boost.org for updates, documentation, and revision history.
+
+#include <boost/config.hpp>
+#include <boost/detail/workaround.hpp>
+
+#include <boost/archive/basic_archive.hpp>
+#include <boost/archive/detail/common_iarchive.hpp>
+#include <boost/serialization/collection_size_type.hpp>
+#include <boost/serialization/string.hpp>
+#include <boost/serialization/item_version_type.hpp>
+#include <boost/integer_traits.hpp>
+
+#ifdef BOOST_MSVC
+# pragma warning(push)
+# pragma warning(disable : 4511 4512)
+#endif
+
+#include <boost/archive/detail/abi_prefix.hpp> // must be the last header
+
+namespace boost {
+namespace archive {
+
+namespace detail {
+ template<class Archive> class interface_iarchive;
+} // namespace detail
+
+/////////////////////////////////////////////////////////////////////////
+// class basic_binary_iarchive - read serialized objects from a input binary stream
+template<class Archive>
+class BOOST_SYMBOL_VISIBLE basic_binary_iarchive :
+ public detail::common_iarchive<Archive>
+{
+#ifdef BOOST_NO_MEMBER_TEMPLATE_FRIENDS
+public:
+#else
+protected:
+ #if BOOST_WORKAROUND(BOOST_MSVC, < 1500)
+ // for some inexplicable reason insertion of "class" generates compile erro
+ // on msvc 7.1
+ friend detail::interface_iarchive<Archive>;
+ #else
+ friend class detail::interface_iarchive<Archive>;
+ #endif
+#endif
+ // intermediate level to support override of operators
+ // fot templates in the absence of partial function
+ // template ordering. If we get here pass to base class
+ // note extra nonsense to sneak it pass the borland compiers
+ typedef detail::common_iarchive<Archive> detail_common_iarchive;
+ template<class T>
+ void load_override(T & t){
+ this->detail_common_iarchive::load_override(t);
+ }
+
+ // include these to trap a change in binary format which
+ // isn't specifically handled
+ // upto 32K classes
+ BOOST_STATIC_ASSERT(sizeof(class_id_type) == sizeof(int_least16_t));
+ BOOST_STATIC_ASSERT(sizeof(class_id_reference_type) == sizeof(int_least16_t));
+ // upto 2G objects
+ BOOST_STATIC_ASSERT(sizeof(object_id_type) == sizeof(uint_least32_t));
+ BOOST_STATIC_ASSERT(sizeof(object_reference_type) == sizeof(uint_least32_t));
+
+ // binary files don't include the optional information
+ void load_override(class_id_optional_type & /* t */){}
+
+ void load_override(tracking_type & t, int /*version*/){
+ library_version_type lvt = this->get_library_version();
+ if(boost::archive::library_version_type(6) < lvt){
+ int_least8_t x=0;
+ * this->This() >> x;
+ t = boost::archive::tracking_type(x);
+ }
+ else{
+ bool x=0;
+ * this->This() >> x;
+ t = boost::archive::tracking_type(x);
+ }
+ }
+ void load_override(class_id_type & t){
+ library_version_type lvt = this->get_library_version();
+ if(boost::archive::library_version_type(7) < lvt){
+ this->detail_common_iarchive::load_override(t);
+ }
+ else
+ if(boost::archive::library_version_type(6) < lvt){
+ int_least16_t x=0;
+ * this->This() >> x;
+ t = boost::archive::class_id_type(x);
+ }
+ else{
+ int x=0;
+ * this->This() >> x;
+ t = boost::archive::class_id_type(x);
+ }
+ }
+ void load_override(class_id_reference_type & t){
+ load_override(static_cast<class_id_type &>(t));
+ }
+
+ void load_override(version_type & t){
+ library_version_type lvt = this->get_library_version();
+ if(boost::archive::library_version_type(7) < lvt){
+ this->detail_common_iarchive::load_override(t);
+ }
+ else
+ if(boost::archive::library_version_type(6) < lvt){
+ uint_least8_t x=0;
+ * this->This() >> x;
+ t = boost::archive::version_type(x);
+ }
+ else
+ if(boost::archive::library_version_type(5) < lvt){
+ uint_least16_t x=0;
+ * this->This() >> x;
+ t = boost::archive::version_type(x);
+ }
+ else
+ if(boost::archive::library_version_type(2) < lvt){
+ // upto 255 versions
+ unsigned char x=0;
+ * this->This() >> x;
+ t = version_type(x);
+ }
+ else{
+ unsigned int x=0;
+ * this->This() >> x;
+ t = boost::archive::version_type(x);
+ }
+ }
+
+ void load_override(boost::serialization::item_version_type & t){
+ library_version_type lvt = this->get_library_version();
+// if(boost::archive::library_version_type(7) < lvt){
+ if(boost::archive::library_version_type(6) < lvt){
+ this->detail_common_iarchive::load_override(t);
+ }
+ else
+ if(boost::archive::library_version_type(6) < lvt){
+ uint_least16_t x=0;
+ * this->This() >> x;
+ t = boost::serialization::item_version_type(x);
+ }
+ else{
+ unsigned int x=0;
+ * this->This() >> x;
+ t = boost::serialization::item_version_type(x);
+ }
+ }
+
+ void load_override(serialization::collection_size_type & t){
+ if(boost::archive::library_version_type(5) < this->get_library_version()){
+ this->detail_common_iarchive::load_override(t);
+ }
+ else{
+ unsigned int x=0;
+ * this->This() >> x;
+ t = serialization::collection_size_type(x);
+ }
+ }
+
+ BOOST_ARCHIVE_OR_WARCHIVE_DECL void
+ load_override(class_name_type & t);
+ BOOST_ARCHIVE_OR_WARCHIVE_DECL void
+ init();
+
+ basic_binary_iarchive(unsigned int flags) :
+ detail::common_iarchive<Archive>(flags)
+ {}
+};
+
+} // namespace archive
+} // namespace boost
+
+#ifdef BOOST_MSVC
+#pragma warning(pop)
+#endif
+
+#include <boost/archive/detail/abi_suffix.hpp> // pops abi_suffix.hpp pragmas
+
+#endif // BOOST_ARCHIVE_BASIC_BINARY_IARCHIVE_HPP
diff --git a/include/boost/archive/basic_binary_iprimitive.hpp b/include/boost/archive/basic_binary_iprimitive.hpp
new file mode 100644
index 0000000..665d3e8
--- /dev/null
+++ b/include/boost/archive/basic_binary_iprimitive.hpp
@@ -0,0 +1,198 @@
+#ifndef BOOST_ARCHIVE_BINARY_IPRIMITIVE_HPP
+#define BOOST_ARCHIVE_BINARY_IPRIMITIVE_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER)
+# pragma once
+#endif
+
+#if defined(_MSC_VER)
+#pragma warning( disable : 4800 )
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// basic_binary_iprimitive.hpp
+//
+// archives stored as native binary - this should be the fastest way
+// to archive the state of a group of obects. It makes no attempt to
+// convert to any canonical form.
+
+// IN GENERAL, ARCHIVES CREATED WITH THIS CLASS WILL NOT BE READABLE
+// ON PLATFORM APART FROM THE ONE THEY ARE CREATED ON
+
+// (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 <iosfwd>
+#include <boost/assert.hpp>
+#include <locale>
+#include <cstring> // std::memcpy
+#include <cstddef> // std::size_t
+#include <streambuf> // basic_streambuf
+#include <string>
+
+#include <boost/config.hpp>
+#if defined(BOOST_NO_STDC_NAMESPACE)
+namespace std{
+ using ::memcpy;
+ using ::size_t;
+} // namespace std
+#endif
+
+#include <boost/cstdint.hpp>
+#include <boost/serialization/throw_exception.hpp>
+#include <boost/integer.hpp>
+#include <boost/integer_traits.hpp>
+
+//#include <boost/mpl/placeholders.hpp>
+#include <boost/serialization/is_bitwise_serializable.hpp>
+#include <boost/serialization/array_wrapper.hpp>
+
+#include <boost/archive/basic_streambuf_locale_saver.hpp>
+#include <boost/archive/codecvt_null.hpp>
+#include <boost/archive/archive_exception.hpp>
+#include <boost/archive/detail/auto_link_archive.hpp>
+#include <boost/archive/detail/abi_prefix.hpp> // must be the last header
+
+namespace boost {
+namespace archive {
+
+/////////////////////////////////////////////////////////////////////////////
+// class binary_iarchive - read serialized objects from a input binary stream
+template<class Archive, class Elem, class Tr>
+class BOOST_SYMBOL_VISIBLE basic_binary_iprimitive {
+#ifndef BOOST_NO_MEMBER_TEMPLATE_FRIENDS
+ friend class load_access;
+protected:
+#else
+public:
+#endif
+ std::basic_streambuf<Elem, Tr> & m_sb;
+ // return a pointer to the most derived class
+ Archive * This(){
+ return static_cast<Archive *>(this);
+ }
+
+ #ifndef BOOST_NO_STD_LOCALE
+ // note order! - if you change this, libstd++ will fail!
+ // a) create new locale with new codecvt facet
+ // b) save current locale
+ // c) change locale to new one
+ // d) use stream buffer
+ // e) change locale back to original
+ // f) destroy new codecvt facet
+ boost::archive::codecvt_null<Elem> codecvt_null_facet;
+ basic_streambuf_locale_saver<Elem, Tr> locale_saver;
+ std::locale archive_locale;
+ #endif
+
+ // main template for serilization of primitive types
+ template<class T>
+ void load(T & t){
+ load_binary(& t, sizeof(T));
+ }
+
+ /////////////////////////////////////////////////////////
+ // fundamental types that need special treatment
+
+ // trap usage of invalid uninitialized boolean
+ void load(bool & t){
+ load_binary(& t, sizeof(t));
+ int i = t;
+ BOOST_ASSERT(0 == i || 1 == i);
+ (void)i; // warning suppression for release builds.
+ }
+ BOOST_ARCHIVE_OR_WARCHIVE_DECL void
+ load(std::string &s);
+ #ifndef BOOST_NO_STD_WSTRING
+ BOOST_ARCHIVE_OR_WARCHIVE_DECL void
+ load(std::wstring &ws);
+ #endif
+ BOOST_ARCHIVE_OR_WARCHIVE_DECL void
+ load(char * t);
+ BOOST_ARCHIVE_OR_WARCHIVE_DECL void
+ load(wchar_t * t);
+
+ BOOST_ARCHIVE_OR_WARCHIVE_DECL void
+ init();
+ BOOST_ARCHIVE_OR_WARCHIVE_DECL
+ basic_binary_iprimitive(
+ std::basic_streambuf<Elem, Tr> & sb,
+ bool no_codecvt
+ );
+ BOOST_ARCHIVE_OR_WARCHIVE_DECL
+ ~basic_binary_iprimitive();
+public:
+ // we provide an optimized load for all fundamental types
+ // typedef serialization::is_bitwise_serializable<mpl::_1>
+ // use_array_optimization;
+ struct use_array_optimization {
+ template <class T>
+ #if defined(BOOST_NO_DEPENDENT_NESTED_DERIVATIONS)
+ struct apply {
+ typedef typename boost::serialization::is_bitwise_serializable< T >::type type;
+ };
+ #else
+ struct apply : public boost::serialization::is_bitwise_serializable< T > {};
+ #endif
+ };
+
+ // the optimized load_array dispatches to load_binary
+ template <class ValueType>
+ void load_array(serialization::array_wrapper<ValueType>& a, unsigned int)
+ {
+ load_binary(a.address(),a.count()*sizeof(ValueType));
+ }
+
+ void
+ load_binary(void *address, std::size_t count);
+};
+
+template<class Archive, class Elem, class Tr>
+inline void
+basic_binary_iprimitive<Archive, Elem, Tr>::load_binary(
+ void *address,
+ std::size_t count
+){
+ // note: an optimizer should eliminate the following for char files
+ BOOST_ASSERT(
+ static_cast<std::streamsize>(count / sizeof(Elem))
+ <= boost::integer_traits<std::streamsize>::const_max
+ );
+ std::streamsize s = static_cast<std::streamsize>(count / sizeof(Elem));
+ std::streamsize scount = m_sb.sgetn(
+ static_cast<Elem *>(address),
+ s
+ );
+ if(scount != s)
+ boost::serialization::throw_exception(
+ archive_exception(archive_exception::input_stream_error)
+ );
+ // note: an optimizer should eliminate the following for char files
+ BOOST_ASSERT(count % sizeof(Elem) <= boost::integer_traits<std::streamsize>::const_max);
+ s = static_cast<std::streamsize>(count % sizeof(Elem));
+ if(0 < s){
+// if(is.fail())
+// boost::serialization::throw_exception(
+// archive_exception(archive_exception::stream_error)
+// );
+ Elem t;
+ scount = m_sb.sgetn(& t, 1);
+ if(scount != 1)
+ boost::serialization::throw_exception(
+ archive_exception(archive_exception::input_stream_error)
+ );
+ std::memcpy(static_cast<char*>(address) + (count - s), &t, static_cast<std::size_t>(s));
+ }
+}
+
+} // namespace archive
+} // namespace boost
+
+#include <boost/archive/detail/abi_suffix.hpp> // pop pragmas
+
+#endif // BOOST_ARCHIVE_BINARY_IPRIMITIVE_HPP
diff --git a/include/boost/archive/basic_binary_oarchive.hpp b/include/boost/archive/basic_binary_oarchive.hpp
new file mode 100644
index 0000000..f05f2f8
--- /dev/null
+++ b/include/boost/archive/basic_binary_oarchive.hpp
@@ -0,0 +1,185 @@
+#ifndef BOOST_ARCHIVE_BASIC_BINARY_OARCHIVE_HPP
+#define BOOST_ARCHIVE_BASIC_BINARY_OARCHIVE_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER)
+# pragma once
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// basic_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.
+
+// archives stored as native binary - this should be the fastest way
+// to archive the state of a group of obects. It makes no attempt to
+// convert to any canonical form.
+
+// IN GENERAL, ARCHIVES CREATED WITH THIS CLASS WILL NOT BE READABLE
+// ON PLATFORM APART FROM THE ONE THEY ARE CREATE ON
+
+#include <boost/assert.hpp>
+#include <boost/config.hpp>
+#include <boost/detail/workaround.hpp>
+
+#include <boost/integer.hpp>
+#include <boost/integer_traits.hpp>
+
+#include <boost/archive/detail/common_oarchive.hpp>
+#include <boost/serialization/string.hpp>
+#include <boost/serialization/collection_size_type.hpp>
+#include <boost/serialization/item_version_type.hpp>
+
+#include <boost/archive/detail/abi_prefix.hpp> // must be the last header
+
+#ifdef BOOST_MSVC
+# pragma warning(push)
+# pragma warning(disable : 4511 4512)
+#endif
+
+namespace boost {
+namespace archive {
+
+namespace detail {
+ template<class Archive> class interface_oarchive;
+} // namespace detail
+
+//////////////////////////////////////////////////////////////////////
+// class basic_binary_oarchive - write serialized objects to a binary output stream
+// note: this archive has no pretensions to portability. Archive format
+// may vary across machine architectures and compilers. About the only
+// guarentee is that an archive created with this code will be readable
+// by a program built with the same tools for the same machne. This class
+// does have the virtue of buiding the smalles archive in the minimum amount
+// of time. So under some circumstances it may be he right choice.
+template<class Archive>
+class BOOST_SYMBOL_VISIBLE basic_binary_oarchive :
+ public detail::common_oarchive<Archive>
+{
+#ifdef BOOST_NO_MEMBER_TEMPLATE_FRIENDS
+public:
+#else
+protected:
+ #if BOOST_WORKAROUND(BOOST_MSVC, < 1500)
+ // for some inexplicable reason insertion of "class" generates compile erro
+ // on msvc 7.1
+ friend detail::interface_oarchive<Archive>;
+ #else
+ friend class detail::interface_oarchive<Archive>;
+ #endif
+#endif
+ // any datatype not specifed below will be handled by base class
+ typedef detail::common_oarchive<Archive> detail_common_oarchive;
+ template<class T>
+ void save_override(const T & t){
+ this->detail_common_oarchive::save_override(t);
+ }
+
+ // include these to trap a change in binary format which
+ // isn't specifically handled
+ BOOST_STATIC_ASSERT(sizeof(tracking_type) == sizeof(bool));
+ // upto 32K classes
+ BOOST_STATIC_ASSERT(sizeof(class_id_type) == sizeof(int_least16_t));
+ BOOST_STATIC_ASSERT(sizeof(class_id_reference_type) == sizeof(int_least16_t));
+ // upto 2G objects
+ BOOST_STATIC_ASSERT(sizeof(object_id_type) == sizeof(uint_least32_t));
+ BOOST_STATIC_ASSERT(sizeof(object_reference_type) == sizeof(uint_least32_t));
+
+ // binary files don't include the optional information
+ void save_override(const class_id_optional_type & /* t */){}
+
+ // enable this if we decide to support generation of previous versions
+ #if 0
+ void save_override(const boost::archive::version_type & t){
+ library_version_type lvt = this->get_library_version();
+ if(boost::archive::library_version_type(7) < lvt){
+ this->detail_common_oarchive::save_override(t);
+ }
+ else
+ if(boost::archive::library_version_type(6) < lvt){
+ const boost::uint_least16_t x = t;
+ * this->This() << x;
+ }
+ else{
+ const unsigned int x = t;
+ * this->This() << x;
+ }
+ }
+ void save_override(const boost::serialization::item_version_type & t){
+ library_version_type lvt = this->get_library_version();
+ if(boost::archive::library_version_type(7) < lvt){
+ this->detail_common_oarchive::save_override(t);
+ }
+ else
+ if(boost::archive::library_version_type(6) < lvt){
+ const boost::uint_least16_t x = t;
+ * this->This() << x;
+ }
+ else{
+ const unsigned int x = t;
+ * this->This() << x;
+ }
+ }
+
+ void save_override(class_id_type & t){
+ library_version_type lvt = this->get_library_version();
+ if(boost::archive::library_version_type(7) < lvt){
+ this->detail_common_oarchive::save_override(t);
+ }
+ else
+ if(boost::archive::library_version_type(6) < lvt){
+ const boost::int_least16_t x = t;
+ * this->This() << x;
+ }
+ else{
+ const int x = t;
+ * this->This() << x;
+ }
+ }
+ void save_override(class_id_reference_type & t){
+ save_override(static_cast<class_id_type &>(t));
+ }
+
+ #endif
+
+ // explicitly convert to char * to avoid compile ambiguities
+ void save_override(const class_name_type & t){
+ const std::string s(t);
+ * this->This() << s;
+ }
+
+ #if 0
+ void save_override(const serialization::collection_size_type & t){
+ if (get_library_version() < boost::archive::library_version_type(6)){
+ unsigned int x=0;
+ * this->This() >> x;
+ t = serialization::collection_size_type(x);
+ }
+ else{
+ * this->This() >> t;
+ }
+ }
+ #endif
+ BOOST_ARCHIVE_OR_WARCHIVE_DECL void
+ init();
+
+ basic_binary_oarchive(unsigned int flags) :
+ detail::common_oarchive<Archive>(flags)
+ {}
+};
+
+} // namespace archive
+} // namespace boost
+
+#ifdef BOOST_MSVC
+#pragma warning(pop)
+#endif
+
+#include <boost/archive/detail/abi_suffix.hpp> // pops abi_suffix.hpp pragmas
+
+#endif // BOOST_ARCHIVE_BASIC_BINARY_OARCHIVE_HPP
diff --git a/include/boost/archive/basic_binary_oprimitive.hpp b/include/boost/archive/basic_binary_oprimitive.hpp
new file mode 100644
index 0000000..6dc770c
--- /dev/null
+++ b/include/boost/archive/basic_binary_oprimitive.hpp
@@ -0,0 +1,188 @@
+#ifndef BOOST_ARCHIVE_BASIC_BINARY_OPRIMITIVE_HPP
+#define BOOST_ARCHIVE_BASIC_BINARY_OPRIMITIVE_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER)
+# pragma once
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// basic_binary_oprimitive.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.
+
+// archives stored as native binary - this should be the fastest way
+// to archive the state of a group of obects. It makes no attempt to
+// convert to any canonical form.
+
+// IN GENERAL, ARCHIVES CREATED WITH THIS CLASS WILL NOT BE READABLE
+// ON PLATFORM APART FROM THE ONE THEY ARE CREATE ON
+
+#include <iosfwd>
+#include <boost/assert.hpp>
+#include <locale>
+#include <streambuf> // basic_streambuf
+#include <string>
+#include <cstddef> // size_t
+
+#include <boost/config.hpp>
+#if defined(BOOST_NO_STDC_NAMESPACE)
+namespace std{
+ using ::size_t;
+} // namespace std
+#endif
+
+#include <boost/cstdint.hpp>
+#include <boost/integer.hpp>
+#include <boost/integer_traits.hpp>
+#include <boost/scoped_ptr.hpp>
+#include <boost/serialization/throw_exception.hpp>
+
+//#include <boost/mpl/placeholders.hpp>
+#include <boost/serialization/is_bitwise_serializable.hpp>
+#include <boost/serialization/array_wrapper.hpp>
+
+#include <boost/archive/basic_streambuf_locale_saver.hpp>
+#include <boost/archive/codecvt_null.hpp>
+#include <boost/archive/archive_exception.hpp>
+#include <boost/archive/detail/auto_link_archive.hpp>
+#include <boost/archive/detail/abi_prefix.hpp> // must be the last header
+
+namespace boost {
+namespace archive {
+
+/////////////////////////////////////////////////////////////////////////
+// class basic_binary_oprimitive - binary output of prmitives
+
+template<class Archive, class Elem, class Tr>
+class BOOST_SYMBOL_VISIBLE basic_binary_oprimitive {
+#ifndef BOOST_NO_MEMBER_TEMPLATE_FRIENDS
+ friend class save_access;
+protected:
+#else
+public:
+#endif
+ std::basic_streambuf<Elem, Tr> & m_sb;
+ // return a pointer to the most derived class
+ Archive * This(){
+ return static_cast<Archive *>(this);
+ }
+ #ifndef BOOST_NO_STD_LOCALE
+ // note order! - if you change this, libstd++ will fail!
+ // a) create new locale with new codecvt facet
+ // b) save current locale
+ // c) change locale to new one
+ // d) use stream buffer
+ // e) change locale back to original
+ // f) destroy new codecvt facet
+ boost::archive::codecvt_null<Elem> codecvt_null_facet;
+ basic_streambuf_locale_saver<Elem, Tr> locale_saver;
+ std::locale archive_locale;
+ #endif
+ // default saving of primitives.
+ template<class T>
+ void save(const T & t)
+ {
+ save_binary(& t, sizeof(T));
+ }
+
+ /////////////////////////////////////////////////////////
+ // fundamental types that need special treatment
+
+ // trap usage of invalid uninitialized boolean which would
+ // otherwise crash on load.
+ void save(const bool t){
+ BOOST_ASSERT(0 == static_cast<int>(t) || 1 == static_cast<int>(t));
+ save_binary(& t, sizeof(t));
+ }
+ BOOST_ARCHIVE_OR_WARCHIVE_DECL void
+ save(const std::string &s);
+ #ifndef BOOST_NO_STD_WSTRING
+ BOOST_ARCHIVE_OR_WARCHIVE_DECL void
+ save(const std::wstring &ws);
+ #endif
+ BOOST_ARCHIVE_OR_WARCHIVE_DECL void
+ save(const char * t);
+ BOOST_ARCHIVE_OR_WARCHIVE_DECL void
+ save(const wchar_t * t);
+
+ BOOST_ARCHIVE_OR_WARCHIVE_DECL void
+ init();
+
+ BOOST_ARCHIVE_OR_WARCHIVE_DECL
+ basic_binary_oprimitive(
+ std::basic_streambuf<Elem, Tr> & sb,
+ bool no_codecvt
+ );
+ BOOST_ARCHIVE_OR_WARCHIVE_DECL
+ ~basic_binary_oprimitive();
+public:
+
+ // we provide an optimized save for all fundamental types
+ // typedef serialization::is_bitwise_serializable<mpl::_1>
+ // use_array_optimization;
+ // workaround without using mpl lambdas
+ struct use_array_optimization {
+ template <class T>
+ #if defined(BOOST_NO_DEPENDENT_NESTED_DERIVATIONS)
+ struct apply {
+ typedef typename boost::serialization::is_bitwise_serializable< T >::type type;
+ };
+ #else
+ struct apply : public boost::serialization::is_bitwise_serializable< T > {};
+ #endif
+ };
+
+ // the optimized save_array dispatches to save_binary
+ template <class ValueType>
+ void save_array(boost::serialization::array_wrapper<ValueType> const& a, unsigned int)
+ {
+ save_binary(a.address(),a.count()*sizeof(ValueType));
+ }
+
+ void save_binary(const void *address, std::size_t count);
+};
+
+template<class Archive, class Elem, class Tr>
+inline void
+basic_binary_oprimitive<Archive, Elem, Tr>::save_binary(
+ const void *address,
+ std::size_t count
+){
+ // BOOST_ASSERT(count <= std::size_t(boost::integer_traits<std::streamsize>::const_max));
+ // note: if the following assertions fail
+ // a likely cause is that the output stream is set to "text"
+ // mode where by cr characters recieve special treatment.
+ // be sure that the output stream is opened with ios::binary
+ //if(os.fail())
+ // boost::serialization::throw_exception(
+ // archive_exception(archive_exception::output_stream_error)
+ // );
+ // figure number of elements to output - round up
+ count = ( count + sizeof(Elem) - 1) / sizeof(Elem);
+ std::streamsize scount = m_sb.sputn(
+ static_cast<const Elem *>(address),
+ static_cast<std::streamsize>(count)
+ );
+ if(count != static_cast<std::size_t>(scount))
+ boost::serialization::throw_exception(
+ archive_exception(archive_exception::output_stream_error)
+ );
+ //os.write(
+ // static_cast<const typename OStream::char_type *>(address),
+ // count
+ //);
+ //BOOST_ASSERT(os.good());
+}
+
+} //namespace boost
+} //namespace archive
+
+#include <boost/archive/detail/abi_suffix.hpp> // pop pragmas
+
+#endif // BOOST_ARCHIVE_BASIC_BINARY_OPRIMITIVE_HPP
diff --git a/include/boost/archive/basic_streambuf_locale_saver.hpp b/include/boost/archive/basic_streambuf_locale_saver.hpp
new file mode 100644
index 0000000..5cd4b36
--- /dev/null
+++ b/include/boost/archive/basic_streambuf_locale_saver.hpp
@@ -0,0 +1,108 @@
+#ifndef BOOST_ARCHIVE_BASIC_STREAMBUF_LOCALE_SAVER_HPP
+#define BOOST_ARCHIVE_BASIC_STREAMBUF_LOCALE_SAVER_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER)
+# pragma once
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// basic_streambuf_locale_saver.hpp
+
+// (C) Copyright 2005 Robert Ramey - http://www.rrsd.com
+
+// Use, modification and distribution is subject to the Boost Software
+// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+
+// See http://www.boost.org for updates, documentation, and revision history.
+
+// note derived from boost/io/ios_state.hpp
+// Copyright 2002, 2005 Daryle Walker. Use, modification, and distribution
+// are subject to the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or a copy at <http://www.boost.org/LICENSE_1_0.txt>.)
+
+// See <http://www.boost.org/libs/io/> for the library's home page.
+
+#ifndef BOOST_NO_STD_LOCALE
+
+#include <locale> // for std::locale
+#include <ios>
+#include <streambuf> // for std::basic_streambuf
+
+#include <boost/config.hpp>
+#include <boost/noncopyable.hpp>
+
+#ifdef BOOST_MSVC
+# pragma warning(push)
+# pragma warning(disable : 4511 4512)
+#endif
+
+namespace boost{
+namespace archive{
+
+template < typename Ch, class Tr >
+class basic_streambuf_locale_saver :
+ private boost::noncopyable
+{
+public:
+ explicit basic_streambuf_locale_saver(std::basic_streambuf<Ch, Tr> &s) :
+ m_streambuf(s),
+ m_locale(s.getloc())
+ {}
+ ~basic_streambuf_locale_saver(){
+ m_streambuf.pubsync();
+ m_streambuf.pubimbue(m_locale);
+ }
+private:
+ std::basic_streambuf<Ch, Tr> & m_streambuf;
+ std::locale const m_locale;
+};
+
+template < typename Ch, class Tr >
+class basic_istream_locale_saver :
+ private boost::noncopyable
+{
+public:
+ explicit basic_istream_locale_saver(std::basic_istream<Ch, Tr> &s) :
+ m_istream(s),
+ m_locale(s.getloc())
+ {}
+ ~basic_istream_locale_saver(){
+ // libstdc++ crashes without this
+ m_istream.sync();
+ m_istream.imbue(m_locale);
+ }
+private:
+ std::basic_istream<Ch, Tr> & m_istream;
+ std::locale const m_locale;
+};
+
+template < typename Ch, class Tr >
+class basic_ostream_locale_saver :
+ private boost::noncopyable
+{
+public:
+ explicit basic_ostream_locale_saver(std::basic_ostream<Ch, Tr> &s) :
+ m_ostream(s),
+ m_locale(s.getloc())
+ {}
+ ~basic_ostream_locale_saver(){
+ m_ostream.flush();
+ m_ostream.imbue(m_locale);
+ }
+private:
+ std::basic_ostream<Ch, Tr> & m_ostream;
+ std::locale const m_locale;
+};
+
+
+} // archive
+} // boost
+
+#ifdef BOOST_MSVC
+#pragma warning(pop)
+#endif
+
+#endif // BOOST_NO_STD_LOCALE
+#endif // BOOST_ARCHIVE_BASIC_STREAMBUF_LOCALE_SAVER_HPP
diff --git a/include/boost/archive/basic_text_iarchive.hpp b/include/boost/archive/basic_text_iarchive.hpp
new file mode 100644
index 0000000..48a646c
--- /dev/null
+++ b/include/boost/archive/basic_text_iarchive.hpp
@@ -0,0 +1,96 @@
+#ifndef BOOST_ARCHIVE_BASIC_TEXT_IARCHIVE_HPP
+#define BOOST_ARCHIVE_BASIC_TEXT_IARCHIVE_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER)
+# pragma once
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// basic_text_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.
+
+// archives stored as text - note these ar templated on the basic
+// stream templates to accommodate wide (and other?) kind of characters
+//
+// note the fact that on libraries without wide characters, ostream is
+// is not a specialization of basic_ostream which in fact is not defined
+// in such cases. So we can't use basic_istream<IStream::char_type> but rather
+// use two template parameters
+
+#include <boost/config.hpp>
+#include <boost/detail/workaround.hpp>
+
+#include <boost/archive/detail/common_iarchive.hpp>
+
+#include <boost/archive/detail/abi_prefix.hpp> // must be the last header
+
+#ifdef BOOST_MSVC
+# pragma warning(push)
+# pragma warning(disable : 4511 4512)
+#endif
+
+namespace boost {
+namespace archive {
+
+namespace detail {
+ template<class Archive> class interface_iarchive;
+} // namespace detail
+
+/////////////////////////////////////////////////////////////////////////
+// class basic_text_iarchive - read serialized objects from a input text stream
+template<class Archive>
+class BOOST_SYMBOL_VISIBLE basic_text_iarchive :
+ public detail::common_iarchive<Archive>
+{
+#ifdef BOOST_NO_MEMBER_TEMPLATE_FRIENDS
+public:
+#else
+protected:
+ #if BOOST_WORKAROUND(BOOST_MSVC, < 1500)
+ // for some inexplicable reason insertion of "class" generates compile erro
+ // on msvc 7.1
+ friend detail::interface_iarchive<Archive>;
+ #else
+ friend class detail::interface_iarchive<Archive>;
+ #endif
+#endif
+ // intermediate level to support override of operators
+ // fot templates in the absence of partial function
+ // template ordering
+ typedef detail::common_iarchive<Archive> detail_common_iarchive;
+ template<class T>
+ void load_override(T & t){
+ this->detail_common_iarchive::load_override(t);
+ }
+ // text file don't include the optional information
+ void load_override(class_id_optional_type & /*t*/){}
+
+ BOOST_ARCHIVE_OR_WARCHIVE_DECL void
+ load_override(class_name_type & t);
+
+ BOOST_ARCHIVE_OR_WARCHIVE_DECL void
+ init(void);
+
+ basic_text_iarchive(unsigned int flags) :
+ detail::common_iarchive<Archive>(flags)
+ {}
+ ~basic_text_iarchive(){}
+};
+
+} // namespace archive
+} // namespace boost
+
+#ifdef BOOST_MSVC
+#pragma warning(pop)
+#endif
+
+#include <boost/archive/detail/abi_suffix.hpp> // pops abi_suffix.hpp pragmas
+
+#endif // BOOST_ARCHIVE_BASIC_TEXT_IARCHIVE_HPP
diff --git a/include/boost/archive/basic_text_iprimitive.hpp b/include/boost/archive/basic_text_iprimitive.hpp
new file mode 100644
index 0000000..bf936b5
--- /dev/null
+++ b/include/boost/archive/basic_text_iprimitive.hpp
@@ -0,0 +1,142 @@
+#ifndef BOOST_ARCHIVE_BASIC_TEXT_IPRIMITIVE_HPP
+#define BOOST_ARCHIVE_BASIC_TEXT_IPRIMITIVE_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER)
+# pragma once
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// basic_text_iprimitive.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.
+
+// archives stored as text - note these are templated on the basic
+// stream templates to accommodate wide (and other?) kind of characters
+//
+// Note the fact that on libraries without wide characters, ostream is
+// not a specialization of basic_ostream which in fact is not defined
+// in such cases. So we can't use basic_ostream<IStream::char_type> but rather
+// use two template parameters
+
+#include <locale>
+#include <cstddef> // size_t
+
+#include <boost/config.hpp>
+#if defined(BOOST_NO_STDC_NAMESPACE)
+namespace std{
+ using ::size_t;
+ #if ! defined(BOOST_DINKUMWARE_STDLIB) && ! defined(__SGI_STL_PORT)
+ using ::locale;
+ #endif
+} // namespace std
+#endif
+
+#include <boost/io/ios_state.hpp>
+#include <boost/static_assert.hpp>
+
+#include <boost/detail/workaround.hpp>
+#if BOOST_WORKAROUND(BOOST_DINKUMWARE_STDLIB, == 1)
+#include <boost/archive/dinkumware.hpp>
+#endif
+#include <boost/serialization/throw_exception.hpp>
+#include <boost/archive/codecvt_null.hpp>
+#include <boost/archive/archive_exception.hpp>
+#include <boost/archive/basic_streambuf_locale_saver.hpp>
+#include <boost/archive/detail/abi_prefix.hpp> // must be the last header
+
+namespace boost {
+namespace archive {
+
+/////////////////////////////////////////////////////////////////////////
+// class basic_text_iarchive - load serialized objects from a input text stream
+#if defined(_MSC_VER)
+#pragma warning( push )
+#pragma warning( disable : 4244 4267 )
+#endif
+
+template<class IStream>
+class BOOST_SYMBOL_VISIBLE basic_text_iprimitive {
+protected:
+ IStream &is;
+ io::ios_flags_saver flags_saver;
+ io::ios_precision_saver precision_saver;
+
+ #ifndef BOOST_NO_STD_LOCALE
+ // note order! - if you change this, libstd++ will fail!
+ // a) create new locale with new codecvt facet
+ // b) save current locale
+ // c) change locale to new one
+ // d) use stream buffer
+ // e) change locale back to original
+ // f) destroy new codecvt facet
+ boost::archive::codecvt_null<typename IStream::char_type> codecvt_null_facet;
+ std::locale archive_locale;
+ basic_istream_locale_saver<
+ typename IStream::char_type,
+ typename IStream::traits_type
+ > locale_saver;
+ #endif
+
+ template<class T>
+ void load(T & t)
+ {
+ if(is >> t)
+ return;
+ boost::serialization::throw_exception(
+ archive_exception(archive_exception::input_stream_error)
+ );
+ }
+
+ void load(char & t)
+ {
+ short int i;
+ load(i);
+ t = i;
+ }
+ void load(signed char & t)
+ {
+ short int i;
+ load(i);
+ t = i;
+ }
+ void load(unsigned char & t)
+ {
+ unsigned short int i;
+ load(i);
+ t = i;
+ }
+
+ #ifndef BOOST_NO_INTRINSIC_WCHAR_T
+ void load(wchar_t & t)
+ {
+ BOOST_STATIC_ASSERT(sizeof(wchar_t) <= sizeof(int));
+ int i;
+ load(i);
+ t = i;
+ }
+ #endif
+ BOOST_ARCHIVE_OR_WARCHIVE_DECL
+ basic_text_iprimitive(IStream &is, bool no_codecvt);
+ BOOST_ARCHIVE_OR_WARCHIVE_DECL
+ ~basic_text_iprimitive();
+public:
+ BOOST_ARCHIVE_OR_WARCHIVE_DECL void
+ load_binary(void *address, std::size_t count);
+};
+
+#if defined(_MSC_VER)
+#pragma warning( pop )
+#endif
+
+} // namespace archive
+} // namespace boost
+
+#include <boost/archive/detail/abi_suffix.hpp> // pop pragmas
+
+#endif // BOOST_ARCHIVE_BASIC_TEXT_IPRIMITIVE_HPP
diff --git a/include/boost/archive/basic_text_oarchive.hpp b/include/boost/archive/basic_text_oarchive.hpp
new file mode 100644
index 0000000..6f7f8fb
--- /dev/null
+++ b/include/boost/archive/basic_text_oarchive.hpp
@@ -0,0 +1,119 @@
+#ifndef BOOST_ARCHIVE_BASIC_TEXT_OARCHIVE_HPP
+#define BOOST_ARCHIVE_BASIC_TEXT_OARCHIVE_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER)
+# pragma once
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// basic_text_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.
+
+// archives stored as text - note these ar templated on the basic
+// stream templates to accommodate wide (and other?) kind of characters
+//
+// note the fact that on libraries without wide characters, ostream is
+// is not a specialization of basic_ostream which in fact is not defined
+// in such cases. So we can't use basic_ostream<OStream::char_type> but rather
+// use two template parameters
+
+#include <boost/config.hpp>
+#include <boost/detail/workaround.hpp>
+#include <boost/archive/detail/common_oarchive.hpp>
+#include <boost/serialization/string.hpp>
+
+#include <boost/archive/detail/abi_prefix.hpp> // must be the last header
+
+#ifdef BOOST_MSVC
+# pragma warning(push)
+# pragma warning(disable : 4511 4512)
+#endif
+
+namespace boost {
+namespace archive {
+
+namespace detail {
+ template<class Archive> class interface_oarchive;
+} // namespace detail
+
+/////////////////////////////////////////////////////////////////////////
+// class basic_text_oarchive
+template<class Archive>
+class BOOST_SYMBOL_VISIBLE basic_text_oarchive :
+ public detail::common_oarchive<Archive>
+{
+#ifdef BOOST_NO_MEMBER_TEMPLATE_FRIENDS
+public:
+#else
+protected:
+ #if BOOST_WORKAROUND(BOOST_MSVC, < 1500)
+ // for some inexplicable reason insertion of "class" generates compile erro
+ // on msvc 7.1
+ friend detail::interface_oarchive<Archive>;
+ #else
+ friend class detail::interface_oarchive<Archive>;
+ #endif
+#endif
+
+ enum {
+ none,
+ eol,
+ space
+ } delimiter;
+
+ BOOST_ARCHIVE_OR_WARCHIVE_DECL void
+ newtoken();
+
+ void newline(){
+ delimiter = eol;
+ }
+
+ // default processing - kick back to base class. Note the
+ // extra stuff to get it passed borland compilers
+ typedef detail::common_oarchive<Archive> detail_common_oarchive;
+ template<class T>
+ void save_override(T & t){
+ this->detail_common_oarchive::save_override(t);
+ }
+
+ // start new objects on a new line
+ void save_override(const object_id_type & t){
+ this->This()->newline();
+ this->detail_common_oarchive::save_override(t);
+ }
+
+ // text file don't include the optional information
+ void save_override(const class_id_optional_type & /* t */){}
+
+ void save_override(const class_name_type & t){
+ const std::string s(t);
+ * this->This() << s;
+ }
+
+ BOOST_ARCHIVE_OR_WARCHIVE_DECL void
+ init();
+
+ basic_text_oarchive(unsigned int flags) :
+ detail::common_oarchive<Archive>(flags),
+ delimiter(none)
+ {}
+ ~basic_text_oarchive(){}
+};
+
+} // namespace archive
+} // namespace boost
+
+#ifdef BOOST_MSVC
+#pragma warning(pop)
+#endif
+
+#include <boost/archive/detail/abi_suffix.hpp> // pops abi_suffix.hpp pragmas
+
+#endif // BOOST_ARCHIVE_BASIC_TEXT_OARCHIVE_HPP
diff --git a/include/boost/archive/basic_text_oprimitive.hpp b/include/boost/archive/basic_text_oprimitive.hpp
new file mode 100644
index 0000000..45f0935
--- /dev/null
+++ b/include/boost/archive/basic_text_oprimitive.hpp
@@ -0,0 +1,209 @@
+#ifndef BOOST_ARCHIVE_BASIC_TEXT_OPRIMITIVE_HPP
+#define BOOST_ARCHIVE_BASIC_TEXT_OPRIMITIVE_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER)
+# pragma once
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// basic_text_oprimitive.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.
+
+// archives stored as text - note these ar templated on the basic
+// stream templates to accommodate wide (and other?) kind of characters
+//
+// note the fact that on libraries without wide characters, ostream is
+// is not a specialization of basic_ostream which in fact is not defined
+// in such cases. So we can't use basic_ostream<OStream::char_type> but rather
+// use two template parameters
+
+#include <iomanip>
+#include <locale>
+#include <cstddef> // size_t
+
+#include <boost/config.hpp>
+#include <boost/static_assert.hpp>
+#include <boost/io/ios_state.hpp>
+
+#include <boost/detail/workaround.hpp>
+#if BOOST_WORKAROUND(BOOST_DINKUMWARE_STDLIB, == 1)
+#include <boost/archive/dinkumware.hpp>
+#endif
+
+#if defined(BOOST_NO_STDC_NAMESPACE)
+namespace std{
+ using ::size_t;
+ #if ! defined(BOOST_DINKUMWARE_STDLIB) && ! defined(__SGI_STL_PORT)
+ using ::locale;
+ #endif
+} // namespace std
+#endif
+
+#include <boost/type_traits/is_floating_point.hpp>
+#include <boost/mpl/bool.hpp>
+#include <boost/limits.hpp>
+#include <boost/integer.hpp>
+#include <boost/io/ios_state.hpp>
+#include <boost/serialization/throw_exception.hpp>
+#include <boost/archive/basic_streambuf_locale_saver.hpp>
+#include <boost/archive/codecvt_null.hpp>
+#include <boost/archive/archive_exception.hpp>
+#include <boost/archive/detail/abi_prefix.hpp> // must be the last header
+
+namespace boost {
+namespace archive {
+
+/////////////////////////////////////////////////////////////////////////
+// class basic_text_oprimitive - output of prmitives to stream
+template<class OStream>
+class BOOST_SYMBOL_VISIBLE basic_text_oprimitive
+{
+protected:
+ OStream &os;
+ io::ios_flags_saver flags_saver;
+ io::ios_precision_saver precision_saver;
+
+ #ifndef BOOST_NO_STD_LOCALE
+ // note order! - if you change this, libstd++ will fail!
+ // a) create new locale with new codecvt facet
+ // b) save current locale
+ // c) change locale to new one
+ // d) use stream buffer
+ // e) change locale back to original
+ // f) destroy new codecvt facet
+ boost::archive::codecvt_null<typename OStream::char_type> codecvt_null_facet;
+ std::locale archive_locale;
+ basic_ostream_locale_saver<
+ typename OStream::char_type,
+ typename OStream::traits_type
+ > locale_saver;
+ #endif
+
+ /////////////////////////////////////////////////////////
+ // fundamental types that need special treatment
+ void save(const bool t){
+ // trap usage of invalid uninitialized boolean which would
+ // otherwise crash on load.
+ BOOST_ASSERT(0 == static_cast<int>(t) || 1 == static_cast<int>(t));
+ if(os.fail())
+ boost::serialization::throw_exception(
+ archive_exception(archive_exception::output_stream_error)
+ );
+ os << t;
+ }
+ void save(const signed char t)
+ {
+ save(static_cast<short int>(t));
+ }
+ void save(const unsigned char t)
+ {
+ save(static_cast<short unsigned int>(t));
+ }
+ void save(const char t)
+ {
+ save(static_cast<short int>(t));
+ }
+ #ifndef BOOST_NO_INTRINSIC_WCHAR_T
+ void save(const wchar_t t)
+ {
+ BOOST_STATIC_ASSERT(sizeof(wchar_t) <= sizeof(int));
+ save(static_cast<int>(t));
+ }
+ #endif
+
+ /////////////////////////////////////////////////////////
+ // saving of any types not listed above
+
+ template<class T>
+ void save_impl(const T &t, boost::mpl::bool_<false> &){
+ if(os.fail())
+ boost::serialization::throw_exception(
+ archive_exception(archive_exception::output_stream_error)
+ );
+ os << t;
+ }
+
+ /////////////////////////////////////////////////////////
+ // floating point types need even more special treatment
+ // the following determines whether the type T is some sort
+ // of floating point type. Note that we then assume that
+ // the stream << operator is defined on that type - if not
+ // we'll get a compile time error. This is meant to automatically
+ // support synthesized types which support floating point
+ // operations. Also it should handle compiler dependent types
+ // such long double. Due to John Maddock.
+
+ template<class T>
+ struct is_float {
+ typedef typename mpl::bool_<
+ boost::is_floating_point<T>::value
+ || (std::numeric_limits<T>::is_specialized
+ && !std::numeric_limits<T>::is_integer
+ && !std::numeric_limits<T>::is_exact
+ && std::numeric_limits<T>::max_exponent)
+ >::type type;
+ };
+
+ template<class T>
+ void save_impl(const T &t, boost::mpl::bool_<true> &){
+ // must be a user mistake - can't serialize un-initialized data
+ if(os.fail())
+ boost::serialization::throw_exception(
+ archive_exception(archive_exception::output_stream_error)
+ );
+ // The formulae for the number of decimla digits required is given in
+ // http://www2.open-std.org/JTC1/SC22/WG21/docs/papers/2005/n1822.pdf
+ // which is derived from Kahan's paper:
+ // www.eecs.berkeley.edu/~wkahan/ieee754status/ieee754.ps
+ // const unsigned int digits = (std::numeric_limits<T>::digits * 3010) / 10000;
+ // note: I've commented out the above because I didn't get good results. e.g.
+ // in one case I got a difference of 19 units.
+ #ifndef BOOST_NO_CXX11_NUMERIC_LIMITS
+ const unsigned int digits = std::numeric_limits<T>::max_digits10;
+ #else
+ const unsigned int digits = std::numeric_limits<T>::digits10 + 2;
+ #endif
+ os << std::setprecision(digits) << std::scientific << t;
+ }
+
+ template<class T>
+ void save(const T & t){
+ typename is_float<T>::type tf;
+ save_impl(t, tf);
+ }
+
+ BOOST_ARCHIVE_OR_WARCHIVE_DECL
+ basic_text_oprimitive(OStream & os, bool no_codecvt);
+ BOOST_ARCHIVE_OR_WARCHIVE_DECL
+ ~basic_text_oprimitive();
+public:
+ // unformatted append of one character
+ void put(typename OStream::char_type c){
+ if(os.fail())
+ boost::serialization::throw_exception(
+ archive_exception(archive_exception::output_stream_error)
+ );
+ os.put(c);
+ }
+ // unformatted append of null terminated string
+ void put(const char * s){
+ while('\0' != *s)
+ os.put(*s++);
+ }
+ BOOST_ARCHIVE_OR_WARCHIVE_DECL void
+ save_binary(const void *address, std::size_t count);
+};
+
+} //namespace boost
+} //namespace archive
+
+#include <boost/archive/detail/abi_suffix.hpp> // pops abi_suffix.hpp pragmas
+
+#endif // BOOST_ARCHIVE_BASIC_TEXT_OPRIMITIVE_HPP
diff --git a/include/boost/archive/basic_xml_archive.hpp b/include/boost/archive/basic_xml_archive.hpp
new file mode 100644
index 0000000..bef368b
--- /dev/null
+++ b/include/boost/archive/basic_xml_archive.hpp
@@ -0,0 +1,67 @@
+#ifndef BOOST_ARCHIVE_BASIC_XML_TEXT_ARCHIVE_HPP
+#define BOOST_ARCHIVE_BASIC_XML_TEXT_ARCHIVE_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER)
+# pragma once
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// basic_xml_archive.hpp:
+
+// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
+// Use, modification and distribution is subject to the Boost Software
+// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+
+// See http://www.boost.org for updates, documentation, and revision history.
+
+#include <boost/archive/archive_exception.hpp>
+
+#include <boost/archive/detail/auto_link_archive.hpp>
+#include <boost/archive/detail/abi_prefix.hpp> // must be the last header
+
+namespace boost {
+namespace archive {
+
+// constant strings used in xml i/o
+
+extern
+BOOST_ARCHIVE_DECL const char *
+BOOST_ARCHIVE_XML_OBJECT_ID();
+
+extern
+BOOST_ARCHIVE_DECL const char *
+BOOST_ARCHIVE_XML_OBJECT_REFERENCE();
+
+extern
+BOOST_ARCHIVE_DECL const char *
+BOOST_ARCHIVE_XML_CLASS_ID();
+
+extern
+BOOST_ARCHIVE_DECL const char *
+BOOST_ARCHIVE_XML_CLASS_ID_REFERENCE();
+
+extern
+BOOST_ARCHIVE_DECL const char *
+BOOST_ARCHIVE_XML_CLASS_NAME();
+
+extern
+BOOST_ARCHIVE_DECL const char *
+BOOST_ARCHIVE_XML_TRACKING();
+
+extern
+BOOST_ARCHIVE_DECL const char *
+BOOST_ARCHIVE_XML_VERSION();
+
+extern
+BOOST_ARCHIVE_DECL const char *
+BOOST_ARCHIVE_XML_SIGNATURE();
+
+}// namespace archive
+}// namespace boost
+
+#include <boost/archive/detail/abi_suffix.hpp> // pops abi_suffix.hpp pragmas
+
+#endif // BOOST_ARCHIVE_BASIC_XML_TEXT_ARCHIVE_HPP
+
diff --git a/include/boost/archive/basic_xml_iarchive.hpp b/include/boost/archive/basic_xml_iarchive.hpp
new file mode 100644
index 0000000..e9f7482
--- /dev/null
+++ b/include/boost/archive/basic_xml_iarchive.hpp
@@ -0,0 +1,119 @@
+#ifndef BOOST_ARCHIVE_BASIC_XML_IARCHIVE_HPP
+#define BOOST_ARCHIVE_BASIC_XML_IARCHIVE_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER)
+# pragma once
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// basic_xml_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 <boost/config.hpp>
+#include <boost/mpl/assert.hpp>
+
+#include <boost/archive/detail/common_iarchive.hpp>
+#include <boost/serialization/nvp.hpp>
+#include <boost/serialization/string.hpp>
+
+#include <boost/archive/detail/abi_prefix.hpp> // must be the last header
+
+#ifdef BOOST_MSVC
+# pragma warning(push)
+# pragma warning(disable : 4511 4512)
+#endif
+
+namespace boost {
+namespace archive {
+
+namespace detail {
+ template<class Archive> class interface_iarchive;
+} // namespace detail
+
+/////////////////////////////////////////////////////////////////////////
+// class basic_xml_iarchive - read serialized objects from a input text stream
+template<class Archive>
+class BOOST_SYMBOL_VISIBLE basic_xml_iarchive :
+ public detail::common_iarchive<Archive>
+{
+ unsigned int depth;
+#ifdef BOOST_NO_MEMBER_TEMPLATE_FRIENDS
+public:
+#else
+protected:
+ friend class detail::interface_iarchive<Archive>;
+#endif
+ BOOST_ARCHIVE_OR_WARCHIVE_DECL void
+ load_start(const char *name);
+ BOOST_ARCHIVE_OR_WARCHIVE_DECL void
+ load_end(const char *name);
+
+ // Anything not an attribute and not a name-value pair is an
+ // should be trapped here.
+ template<class T>
+ void load_override(T & t)
+ {
+ // If your program fails to compile here, its most likely due to
+ // not specifying an nvp wrapper around the variable to
+ // be serialized.
+ BOOST_MPL_ASSERT((serialization::is_wrapper< T >));
+ this->detail_common_iarchive::load_override(t);
+ }
+
+ // Anything not an attribute - see below - should be a name value
+ // pair and be processed here
+ typedef detail::common_iarchive<Archive> detail_common_iarchive;
+ template<class T>
+ void load_override(
+ const boost::serialization::nvp< T > & t
+ ){
+ this->This()->load_start(t.name());
+ this->detail_common_iarchive::load_override(t.value());
+ this->This()->load_end(t.name());
+ }
+
+ // specific overrides for attributes - handle as
+ // primitives. These are not name-value pairs
+ // so they have to be intercepted here and passed on to load.
+ // although the class_id is included in the xml text file in order
+ // to make the file self describing, it isn't used when loading
+ // an xml archive. So we can skip it here. Note: we MUST override
+ // it otherwise it will be loaded as a normal primitive w/o tag and
+ // leaving the archive in an undetermined state
+ BOOST_ARCHIVE_OR_WARCHIVE_DECL void
+ load_override(class_id_type & t);
+ void load_override(class_id_optional_type & /* t */){}
+ BOOST_ARCHIVE_OR_WARCHIVE_DECL void
+ load_override(object_id_type & t);
+ BOOST_ARCHIVE_OR_WARCHIVE_DECL void
+ load_override(version_type & t);
+ BOOST_ARCHIVE_OR_WARCHIVE_DECL void
+ load_override(tracking_type & t);
+ // class_name_type can't be handled here as it depends upon the
+ // char type used by the stream. So require the derived implementation
+ // handle this.
+ // void load_override(class_name_type & t);
+
+ BOOST_ARCHIVE_OR_WARCHIVE_DECL
+ basic_xml_iarchive(unsigned int flags);
+ BOOST_ARCHIVE_OR_WARCHIVE_DECL
+ ~basic_xml_iarchive();
+};
+
+} // namespace archive
+} // namespace boost
+
+#ifdef BOOST_MSVC
+#pragma warning(pop)
+#endif
+
+#include <boost/archive/detail/abi_suffix.hpp> // pops abi_suffix.hpp pragmas
+
+#endif // BOOST_ARCHIVE_BASIC_XML_IARCHIVE_HPP
diff --git a/include/boost/archive/basic_xml_oarchive.hpp b/include/boost/archive/basic_xml_oarchive.hpp
new file mode 100644
index 0000000..107fca4
--- /dev/null
+++ b/include/boost/archive/basic_xml_oarchive.hpp
@@ -0,0 +1,138 @@
+#ifndef BOOST_ARCHIVE_BASIC_XML_OARCHIVE_HPP
+#define BOOST_ARCHIVE_BASIC_XML_OARCHIVE_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER)
+# pragma once
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// basic_xml_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 <boost/config.hpp>
+#include <boost/mpl/assert.hpp>
+
+#include <boost/archive/detail/common_oarchive.hpp>
+#include <boost/serialization/nvp.hpp>
+#include <boost/serialization/string.hpp>
+
+#include <boost/archive/detail/abi_prefix.hpp> // must be the last header
+
+#ifdef BOOST_MSVC
+# pragma warning(push)
+# pragma warning(disable : 4511 4512)
+#endif
+
+namespace boost {
+namespace archive {
+
+namespace detail {
+ template<class Archive> class interface_oarchive;
+} // namespace detail
+
+//////////////////////////////////////////////////////////////////////
+// class basic_xml_oarchive - write serialized objects to a xml output stream
+template<class Archive>
+class BOOST_SYMBOL_VISIBLE basic_xml_oarchive :
+ public detail::common_oarchive<Archive>
+{
+ // special stuff for xml output
+ unsigned int depth;
+ bool pending_preamble;
+#ifdef BOOST_NO_MEMBER_TEMPLATE_FRIENDS
+public:
+#else
+protected:
+ friend class detail::interface_oarchive<Archive>;
+#endif
+ bool indent_next;
+ BOOST_ARCHIVE_OR_WARCHIVE_DECL void
+ indent();
+ BOOST_ARCHIVE_OR_WARCHIVE_DECL void
+ init();
+ BOOST_ARCHIVE_OR_WARCHIVE_DECL void
+ windup();
+ BOOST_ARCHIVE_OR_WARCHIVE_DECL void
+ write_attribute(
+ const char *attribute_name,
+ int t,
+ const char *conjunction = "=\""
+ );
+ BOOST_ARCHIVE_OR_WARCHIVE_DECL void
+ write_attribute(
+ const char *attribute_name,
+ const char *key
+ );
+ // helpers used below
+ BOOST_ARCHIVE_OR_WARCHIVE_DECL void
+ save_start(const char *name);
+ BOOST_ARCHIVE_OR_WARCHIVE_DECL void
+ save_end(const char *name);
+ BOOST_ARCHIVE_OR_WARCHIVE_DECL void
+ end_preamble();
+
+ // Anything not an attribute and not a name-value pair is an
+ // error and should be trapped here.
+ template<class T>
+ void save_override(T & t)
+ {
+ // If your program fails to compile here, its most likely due to
+ // not specifying an nvp wrapper around the variable to
+ // be serialized.
+ BOOST_MPL_ASSERT((serialization::is_wrapper< T >));
+ this->detail_common_oarchive::save_override(t);
+ }
+
+ // special treatment for name-value pairs.
+ typedef detail::common_oarchive<Archive> detail_common_oarchive;
+ template<class T>
+ void save_override(
+ const ::boost::serialization::nvp< T > & t
+ ){
+ this->This()->save_start(t.name());
+ this->detail_common_oarchive::save_override(t.const_value());
+ this->This()->save_end(t.name());
+ }
+
+ // specific overrides for attributes - not name value pairs so we
+ // want to trap them before the above "fall through"
+ BOOST_ARCHIVE_OR_WARCHIVE_DECL void
+ save_override(const class_id_type & t);
+ BOOST_ARCHIVE_OR_WARCHIVE_DECL void
+ save_override(const class_id_optional_type & t);
+ BOOST_ARCHIVE_OR_WARCHIVE_DECL void
+ save_override(const class_id_reference_type & t);
+ BOOST_ARCHIVE_OR_WARCHIVE_DECL void
+ save_override(const object_id_type & t);
+ BOOST_ARCHIVE_OR_WARCHIVE_DECL void
+ save_override(const object_reference_type & t);
+ BOOST_ARCHIVE_OR_WARCHIVE_DECL void
+ save_override(const version_type & t);
+ BOOST_ARCHIVE_OR_WARCHIVE_DECL void
+ save_override(const class_name_type & t);
+ BOOST_ARCHIVE_OR_WARCHIVE_DECL void
+ save_override(const tracking_type & t);
+
+ BOOST_ARCHIVE_OR_WARCHIVE_DECL
+ basic_xml_oarchive(unsigned int flags);
+ BOOST_ARCHIVE_OR_WARCHIVE_DECL
+ ~basic_xml_oarchive();
+};
+
+} // namespace archive
+} // namespace boost
+
+#ifdef BOOST_MSVC
+#pragma warning(pop)
+#endif
+
+#include <boost/archive/detail/abi_suffix.hpp> // pops abi_suffix.hpp pragmas
+
+#endif // BOOST_ARCHIVE_BASIC_XML_OARCHIVE_HPP
diff --git a/include/boost/archive/binary_iarchive.hpp b/include/boost/archive/binary_iarchive.hpp
new file mode 100644
index 0000000..785ce76
--- /dev/null
+++ b/include/boost/archive/binary_iarchive.hpp
@@ -0,0 +1,64 @@
+#ifndef BOOST_ARCHIVE_BINARY_IARCHIVE_HPP
+#define BOOST_ARCHIVE_BINARY_IARCHIVE_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER)
+# pragma once
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// 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 <istream>
+#include <boost/archive/binary_iarchive_impl.hpp>
+#include <boost/archive/detail/register_archive.hpp>
+
+#ifdef BOOST_MSVC
+# pragma warning(push)
+# pragma warning(disable : 4511 4512)
+#endif
+
+namespace boost {
+namespace archive {
+
+// do not derive from this class. If you want to extend this functionality
+// via inhertance, derived from binary_iarchive_impl instead. This will
+// preserve correct static polymorphism.
+class BOOST_SYMBOL_VISIBLE binary_iarchive :
+ public binary_iarchive_impl<
+ boost::archive::binary_iarchive,
+ std::istream::char_type,
+ std::istream::traits_type
+ >{
+public:
+ binary_iarchive(std::istream & is, unsigned int flags = 0) :
+ binary_iarchive_impl<
+ binary_iarchive, std::istream::char_type, std::istream::traits_type
+ >(is, flags)
+ {}
+ binary_iarchive(std::streambuf & bsb, unsigned int flags = 0) :
+ binary_iarchive_impl<
+ binary_iarchive, std::istream::char_type, std::istream::traits_type
+ >(bsb, flags)
+ {}
+};
+
+} // namespace archive
+} // namespace boost
+
+// required by export
+BOOST_SERIALIZATION_REGISTER_ARCHIVE(boost::archive::binary_iarchive)
+BOOST_SERIALIZATION_USE_ARRAY_OPTIMIZATION(boost::archive::binary_iarchive)
+
+#ifdef BOOST_MSVC
+#pragma warning(pop)
+#endif
+
+#endif // BOOST_ARCHIVE_BINARY_IARCHIVE_HPP
diff --git a/include/boost/archive/binary_iarchive_impl.hpp b/include/boost/archive/binary_iarchive_impl.hpp
new file mode 100644
index 0000000..b4747c9
--- /dev/null
+++ b/include/boost/archive/binary_iarchive_impl.hpp
@@ -0,0 +1,105 @@
+#ifndef BOOST_ARCHIVE_BINARY_IARCHIVE_IMPL_HPP
+#define BOOST_ARCHIVE_BINARY_IARCHIVE_IMPL_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER)
+# pragma once
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// binary_iarchive_impl.hpp
+
+// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
+// Use, modification and distribution is subject to the Boost Software
+// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+
+// See http://www.boost.org for updates, documentation, and revision history.
+
+#include <istream>
+#include <boost/archive/basic_binary_iprimitive.hpp>
+#include <boost/archive/basic_binary_iarchive.hpp>
+
+#ifdef BOOST_MSVC
+# pragma warning(push)
+# pragma warning(disable : 4511 4512)
+#endif
+
+namespace boost {
+namespace archive {
+
+namespace detail {
+ template<class Archive> class interface_iarchive;
+} // namespace detail
+
+template<class Archive, class Elem, class Tr>
+class BOOST_SYMBOL_VISIBLE binary_iarchive_impl :
+ public basic_binary_iprimitive<Archive, Elem, Tr>,
+ public basic_binary_iarchive<Archive>
+{
+#ifdef BOOST_NO_MEMBER_TEMPLATE_FRIENDS
+public:
+#else
+protected:
+ #if BOOST_WORKAROUND(BOOST_MSVC, < 1500)
+ // for some inexplicable reason insertion of "class" generates compile erro
+ // on msvc 7.1
+ friend detail::interface_iarchive<Archive>;
+ friend basic_binary_iarchive<Archive>;
+ friend load_access;
+ #else
+ friend class detail::interface_iarchive<Archive>;
+ friend class basic_binary_iarchive<Archive>;
+ friend class load_access;
+ #endif
+#endif
+ template<class T>
+ void load_override(T & t){
+ this->basic_binary_iarchive<Archive>::load_override(t);
+ }
+ void init(unsigned int flags){
+ if(0 != (flags & no_header)){
+ return;
+ }
+ #if ! defined(__MWERKS__)
+ this->basic_binary_iarchive<Archive>::init();
+ this->basic_binary_iprimitive<Archive, Elem, Tr>::init();
+ #else
+ basic_binary_iarchive<Archive>::init();
+ basic_binary_iprimitive<Archive, Elem, Tr>::init();
+ #endif
+ }
+ binary_iarchive_impl(
+ std::basic_streambuf<Elem, Tr> & bsb,
+ unsigned int flags
+ ) :
+ basic_binary_iprimitive<Archive, Elem, Tr>(
+ bsb,
+ 0 != (flags & no_codecvt)
+ ),
+ basic_binary_iarchive<Archive>(flags)
+ {
+ init(flags);
+ }
+ binary_iarchive_impl(
+ std::basic_istream<Elem, Tr> & is,
+ unsigned int flags
+ ) :
+ basic_binary_iprimitive<Archive, Elem, Tr>(
+ * is.rdbuf(),
+ 0 != (flags & no_codecvt)
+ ),
+ basic_binary_iarchive<Archive>(flags)
+ {
+ init(flags);
+ }
+};
+
+} // namespace archive
+} // namespace boost
+
+#ifdef BOOST_MSVC
+#pragma warning(pop)
+#endif
+
+#endif // BOOST_ARCHIVE_BINARY_IARCHIVE_IMPL_HPP
diff --git a/include/boost/archive/binary_oarchive.hpp b/include/boost/archive/binary_oarchive.hpp
new file mode 100644
index 0000000..e8313fd
--- /dev/null
+++ b/include/boost/archive/binary_oarchive.hpp
@@ -0,0 +1,64 @@
+#ifndef BOOST_ARCHIVE_BINARY_OARCHIVE_HPP
+#define BOOST_ARCHIVE_BINARY_OARCHIVE_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER)
+# pragma once
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// 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 <ostream>
+#include <boost/config.hpp>
+#include <boost/archive/binary_oarchive_impl.hpp>
+#include <boost/archive/detail/register_archive.hpp>
+
+#ifdef BOOST_MSVC
+# pragma warning(push)
+# pragma warning(disable : 4511 4512)
+#endif
+
+namespace boost {
+namespace archive {
+
+// do not derive from this class. If you want to extend this functionality
+// via inhertance, derived from binary_oarchive_impl instead. This will
+// preserve correct static polymorphism.
+class BOOST_SYMBOL_VISIBLE binary_oarchive :
+ public binary_oarchive_impl<
+ binary_oarchive, std::ostream::char_type, std::ostream::traits_type
+ >
+{
+public:
+ binary_oarchive(std::ostream & os, unsigned int flags = 0) :
+ binary_oarchive_impl<
+ binary_oarchive, std::ostream::char_type, std::ostream::traits_type
+ >(os, flags)
+ {}
+ binary_oarchive(std::streambuf & bsb, unsigned int flags = 0) :
+ binary_oarchive_impl<
+ binary_oarchive, std::ostream::char_type, std::ostream::traits_type
+ >(bsb, flags)
+ {}
+};
+
+} // namespace archive
+} // namespace boost
+
+// required by export
+BOOST_SERIALIZATION_REGISTER_ARCHIVE(boost::archive::binary_oarchive)
+BOOST_SERIALIZATION_USE_ARRAY_OPTIMIZATION(boost::archive::binary_oarchive)
+
+#ifdef BOOST_MSVC
+#pragma warning(pop)
+#endif
+
+#endif // BOOST_ARCHIVE_BINARY_OARCHIVE_HPP
diff --git a/include/boost/archive/binary_oarchive_impl.hpp b/include/boost/archive/binary_oarchive_impl.hpp
new file mode 100644
index 0000000..6b4d018
--- /dev/null
+++ b/include/boost/archive/binary_oarchive_impl.hpp
@@ -0,0 +1,106 @@
+#ifndef BOOST_ARCHIVE_BINARY_OARCHIVE_IMPL_HPP
+#define BOOST_ARCHIVE_BINARY_OARCHIVE_IMPL_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER)
+# pragma once
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// binary_oarchive_impl.hpp
+
+// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
+// Use, modification and distribution is subject to the Boost Software
+// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+
+// See http://www.boost.org for updates, documentation, and revision history.
+
+#include <ostream>
+#include <boost/config.hpp>
+#include <boost/archive/basic_binary_oprimitive.hpp>
+#include <boost/archive/basic_binary_oarchive.hpp>
+
+#ifdef BOOST_MSVC
+# pragma warning(push)
+# pragma warning(disable : 4511 4512)
+#endif
+
+namespace boost {
+namespace archive {
+
+namespace detail {
+ template<class Archive> class interface_oarchive;
+} // namespace detail
+
+template<class Archive, class Elem, class Tr>
+class BOOST_SYMBOL_VISIBLE binary_oarchive_impl :
+ public basic_binary_oprimitive<Archive, Elem, Tr>,
+ public basic_binary_oarchive<Archive>
+{
+#ifdef BOOST_NO_MEMBER_TEMPLATE_FRIENDS
+public:
+#else
+protected:
+ #if BOOST_WORKAROUND(BOOST_MSVC, < 1500)
+ // for some inexplicable reason insertion of "class" generates compile erro
+ // on msvc 7.1
+ friend detail::interface_oarchive<Archive>;
+ friend basic_binary_oarchive<Archive>;
+ friend save_access;
+ #else
+ friend class detail::interface_oarchive<Archive>;
+ friend class basic_binary_oarchive<Archive>;
+ friend class save_access;
+ #endif
+#endif
+ template<class T>
+ void save_override(T & t){
+ this->basic_binary_oarchive<Archive>::save_override(t);
+ }
+ void init(unsigned int flags) {
+ if(0 != (flags & no_header)){
+ return;
+ }
+ #if ! defined(__MWERKS__)
+ this->basic_binary_oarchive<Archive>::init();
+ this->basic_binary_oprimitive<Archive, Elem, Tr>::init();
+ #else
+ basic_binary_oarchive<Archive>::init();
+ basic_binary_oprimitive<Archive, Elem, Tr>::init();
+ #endif
+ }
+ binary_oarchive_impl(
+ std::basic_streambuf<Elem, Tr> & bsb,
+ unsigned int flags
+ ) :
+ basic_binary_oprimitive<Archive, Elem, Tr>(
+ bsb,
+ 0 != (flags & no_codecvt)
+ ),
+ basic_binary_oarchive<Archive>(flags)
+ {
+ init(flags);
+ }
+ binary_oarchive_impl(
+ std::basic_ostream<Elem, Tr> & os,
+ unsigned int flags
+ ) :
+ basic_binary_oprimitive<Archive, Elem, Tr>(
+ * os.rdbuf(),
+ 0 != (flags & no_codecvt)
+ ),
+ basic_binary_oarchive<Archive>(flags)
+ {
+ init(flags);
+ }
+};
+
+} // namespace archive
+} // namespace boost
+
+#ifdef BOOST_MSVC
+#pragma warning(pop)
+#endif
+
+#endif // BOOST_ARCHIVE_BINARY_OARCHIVE_IMPL_HPP
diff --git a/include/boost/archive/binary_wiarchive.hpp b/include/boost/archive/binary_wiarchive.hpp
new file mode 100644
index 0000000..775d8f8
--- /dev/null
+++ b/include/boost/archive/binary_wiarchive.hpp
@@ -0,0 +1,56 @@
+#ifndef BOOST_ARCHIVE_BINARY_WIARCHIVE_HPP
+#define BOOST_ARCHIVE_BINARY_WIARCHIVE_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER)
+# pragma once
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// binary_wiarchive.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 <boost/config.hpp>
+#ifdef BOOST_NO_STD_WSTREAMBUF
+#error "wide char i/o not supported on this platform"
+#else
+
+#include <istream> // wistream
+#include <boost/archive/binary_iarchive_impl.hpp>
+#include <boost/archive/detail/register_archive.hpp>
+
+namespace boost {
+namespace archive {
+
+class binary_wiarchive :
+ public binary_iarchive_impl<
+ binary_wiarchive, std::wistream::char_type, std::wistream::traits_type
+ >
+{
+public:
+ binary_wiarchive(std::wistream & is, unsigned int flags = 0) :
+ binary_iarchive_impl<
+ binary_wiarchive, std::wistream::char_type, std::wistream::traits_type
+ >(is, flags)
+ {}
+ binary_wiarchive(std::wstreambuf & bsb, unsigned int flags = 0) :
+ binary_iarchive_impl<
+ binary_wiarchive, std::wistream::char_type, std::wistream::traits_type
+ >(bsb, flags)
+ {}
+};
+
+} // namespace archive
+} // namespace boost
+
+// required by export
+BOOST_SERIALIZATION_REGISTER_ARCHIVE(boost::archive::binary_wiarchive)
+
+#endif // BOOST_NO_STD_WSTREAMBUF
+#endif // BOOST_ARCHIVE_BINARY_WIARCHIVE_HPP
diff --git a/include/boost/archive/binary_woarchive.hpp b/include/boost/archive/binary_woarchive.hpp
new file mode 100644
index 0000000..a8817d6
--- /dev/null
+++ b/include/boost/archive/binary_woarchive.hpp
@@ -0,0 +1,59 @@
+#ifndef BOOST_ARCHIVE_BINARY_WOARCHIVE_HPP
+#define BOOST_ARCHIVE_BINARY_WOARCHIVE_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER)
+# pragma once
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// binary_woarchive.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 <boost/config.hpp>
+#ifdef BOOST_NO_STD_WSTREAMBUF
+#error "wide char i/o not supported on this platform"
+#else
+
+#include <ostream>
+#include <boost/archive/binary_oarchive_impl.hpp>
+#include <boost/archive/detail/register_archive.hpp>
+
+namespace boost {
+namespace archive {
+
+// do not derive from this class. If you want to extend this functionality
+// via inhertance, derived from binary_oarchive_impl instead. This will
+// preserve correct static polymorphism.
+class binary_woarchive :
+ public binary_oarchive_impl<
+ binary_woarchive, std::wostream::char_type, std::wostream::traits_type
+ >
+{
+public:
+ binary_woarchive(std::wostream & os, unsigned int flags = 0) :
+ binary_oarchive_impl<
+ binary_woarchive, std::wostream::char_type, std::wostream::traits_type
+ >(os, flags)
+ {}
+ binary_woarchive(std::wstreambuf & bsb, unsigned int flags = 0) :
+ binary_oarchive_impl<
+ binary_woarchive, std::wostream::char_type, std::wostream::traits_type
+ >(bsb, flags)
+ {}
+};
+
+} // namespace archive
+} // namespace boost
+
+// required by export
+BOOST_SERIALIZATION_REGISTER_ARCHIVE(boost::archive::binary_woarchive)
+
+#endif // BOOST_NO_STD_WSTREAMBUF
+#endif // BOOST_ARCHIVE_BINARY_WOARCHIVE_HPP
diff --git a/include/boost/archive/codecvt_null.hpp b/include/boost/archive/codecvt_null.hpp
new file mode 100644
index 0000000..3b39c8e
--- /dev/null
+++ b/include/boost/archive/codecvt_null.hpp
@@ -0,0 +1,110 @@
+#ifndef BOOST_ARCHIVE_CODECVT_NULL_HPP
+#define BOOST_ARCHIVE_CODECVT_NULL_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER)
+# pragma once
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// codecvt_null.hpp:
+
+// (C) Copyright 2004 Robert Ramey - http://www.rrsd.com .
+// Use, modification and distribution is subject to the Boost Software
+// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+
+// See http://www.boost.org for updates, documentation, and revision history.
+
+#include <locale>
+#include <cstddef> // NULL, size_t
+#ifndef BOOST_NO_CWCHAR
+#include <cwchar> // for mbstate_t
+#endif
+#include <boost/config.hpp>
+#include <boost/serialization/force_include.hpp>
+#include <boost/archive/detail/auto_link_archive.hpp>
+#include <boost/archive/detail/abi_prefix.hpp> // must be the last header
+
+#if defined(BOOST_NO_STDC_NAMESPACE)
+namespace std {
+// For STLport on WinCE, BOOST_NO_STDC_NAMESPACE can get defined if STLport is putting symbols in its own namespace.
+// In the case of codecvt, however, this does not mean that codecvt is in the global namespace (it will be in STLport's namespace)
+# if !defined(__SGI_STL_PORT) && !defined(_STLPORT_VERSION)
+ using ::codecvt;
+# endif
+ using ::mbstate_t;
+ using ::size_t;
+} // namespace
+#endif
+
+#ifdef BOOST_MSVC
+# pragma warning(push)
+# pragma warning(disable : 4511 4512)
+#endif
+
+namespace boost {
+namespace archive {
+
+template<class Ch>
+class codecvt_null;
+
+template<>
+class codecvt_null<char> : public std::codecvt<char, char, std::mbstate_t>
+{
+ virtual bool do_always_noconv() const throw() {
+ return true;
+ }
+public:
+ explicit codecvt_null(std::size_t no_locale_manage = 0) :
+ std::codecvt<char, char, std::mbstate_t>(no_locale_manage)
+ {}
+ virtual ~codecvt_null(){};
+};
+
+template<>
+class BOOST_WARCHIVE_DECL codecvt_null<wchar_t> :
+ public std::codecvt<wchar_t, char, std::mbstate_t>
+{
+ virtual std::codecvt_base::result
+ do_out(
+ std::mbstate_t & state,
+ const wchar_t * first1,
+ const wchar_t * last1,
+ const wchar_t * & next1,
+ char * first2,
+ char * last2,
+ char * & next2
+ ) const;
+ virtual std::codecvt_base::result
+ do_in(
+ std::mbstate_t & state,
+ const char * first1,
+ const char * last1,
+ const char * & next1,
+ wchar_t * first2,
+ wchar_t * last2,
+ wchar_t * & next2
+ ) const;
+ virtual int do_encoding( ) const throw( ){
+ return sizeof(wchar_t) / sizeof(char);
+ }
+ virtual int do_max_length( ) const throw( ){
+ return do_encoding();
+ }
+public:
+ explicit codecvt_null(std::size_t no_locale_manage = 0) :
+ std::codecvt<wchar_t, char, std::mbstate_t>(no_locale_manage)
+ {}
+ //virtual ~codecvt_null(){};
+};
+
+} // namespace archive
+} // namespace boost
+
+#ifdef BOOST_MSVC
+# pragma warning(pop)
+#endif
+#include <boost/archive/detail/abi_suffix.hpp> // pop pragmas
+
+#endif //BOOST_ARCHIVE_CODECVT_NULL_HPP
diff --git a/include/boost/archive/detail/abi_prefix.hpp b/include/boost/archive/detail/abi_prefix.hpp
new file mode 100644
index 0000000..debf79e
--- /dev/null
+++ b/include/boost/archive/detail/abi_prefix.hpp
@@ -0,0 +1,16 @@
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// abi_prefix.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 <boost/config/abi_prefix.hpp> // must be the last header
+#ifdef BOOST_MSVC
+# pragma warning(push)
+# pragma warning(disable : 4251 4231 4660 4275)
+#endif
+
diff --git a/include/boost/archive/detail/abi_suffix.hpp b/include/boost/archive/detail/abi_suffix.hpp
new file mode 100644
index 0000000..4e054d6
--- /dev/null
+++ b/include/boost/archive/detail/abi_suffix.hpp
@@ -0,0 +1,15 @@
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// abi_suffix.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.
+
+#ifdef BOOST_MSVC
+#pragma warning(pop)
+#endif
+#include <boost/config/abi_suffix.hpp> // pops abi_suffix.hpp pragmas
+
diff --git a/include/boost/archive/detail/archive_serializer_map.hpp b/include/boost/archive/detail/archive_serializer_map.hpp
new file mode 100644
index 0000000..5432bfc
--- /dev/null
+++ b/include/boost/archive/detail/archive_serializer_map.hpp
@@ -0,0 +1,54 @@
+#ifndef BOOST_ARCHIVE_SERIALIZER_MAP_HPP
+#define BOOST_ARCHIVE_SERIALIZER_MAP_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER)
+# pragma once
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// archive_serializer_map.hpp: extenstion of type_info required for
+// serialization.
+
+// (C) Copyright 2009 Robert Ramey - http://www.rrsd.com .
+// Use, modification and distribution is subject to the Boost Software
+// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+
+// See http://www.boost.org for updates, documentation, and revision history.
+
+// note: this is nothing more than the thinest of wrappers around
+// basic_serializer_map so we can have a one map / archive type.
+
+#include <boost/config.hpp>
+#include <boost/archive/detail/auto_link_archive.hpp>
+#include <boost/archive/detail/abi_prefix.hpp> // must be the last header
+
+namespace boost {
+
+namespace serialization {
+ class extended_type_info;
+} // namespace serialization
+
+namespace archive {
+namespace detail {
+
+class basic_serializer;
+
+template<class Archive>
+class BOOST_SYMBOL_VISIBLE archive_serializer_map {
+public:
+ static BOOST_ARCHIVE_OR_WARCHIVE_DECL bool insert(const basic_serializer * bs);
+ static BOOST_ARCHIVE_OR_WARCHIVE_DECL void erase(const basic_serializer * bs);
+ static BOOST_ARCHIVE_OR_WARCHIVE_DECL const basic_serializer * find(
+ const boost::serialization::extended_type_info & type_
+ );
+};
+
+} // namespace detail
+} // namespace archive
+} // namespace boost
+
+#include <boost/archive/detail/abi_suffix.hpp> // must be the last header
+
+#endif //BOOST_ARCHIVE_SERIALIZER_MAP_HPP
diff --git a/include/boost/archive/detail/auto_link_archive.hpp b/include/boost/archive/detail/auto_link_archive.hpp
new file mode 100644
index 0000000..79b0e49
--- /dev/null
+++ b/include/boost/archive/detail/auto_link_archive.hpp
@@ -0,0 +1,48 @@
+#ifndef BOOST_ARCHIVE_DETAIL_AUTO_LINK_ARCHIVE_HPP
+#define BOOST_ARCHIVE_DETAIL_AUTO_LINK_ARCHIVE_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER)
+# pragma once
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// auto_link_archive.hpp
+//
+// (c) Copyright Robert Ramey 2004
+// Use, modification, and distribution is subject to the Boost Software
+// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+
+// See library home page at http://www.boost.org/libs/serialization
+
+//----------------------------------------------------------------------------//
+
+// This header implements separate compilation features as described in
+// http://www.boost.org/more/separate_compilation.html
+
+// enable automatic library variant selection ------------------------------//
+
+#include <boost/archive/detail/decl.hpp>
+
+#if !defined(BOOST_ALL_NO_LIB) && !defined(BOOST_SERIALIZATION_NO_LIB) \
+&& !defined(BOOST_ARCHIVE_SOURCE) && !defined(BOOST_WARCHIVE_SOURCE) \
+&& !defined(BOOST_SERIALIZATION_SOURCE)
+
+ // Set the name of our library, this will get undef'ed by auto_link.hpp
+ // once it's done with it:
+ //
+ #define BOOST_LIB_NAME boost_serialization
+ //
+ // If we're importing code from a dll, then tell auto_link.hpp about it:
+ //
+ #if defined(BOOST_ALL_DYN_LINK) || defined(BOOST_SERIALIZATION_DYN_LINK)
+ # define BOOST_DYN_LINK
+ #endif
+ //
+ // And include the header that does the work:
+ //
+ #include <boost/config/auto_link.hpp>
+#endif // auto-linking disabled
+
+#endif // BOOST_ARCHIVE_DETAIL_AUTO_LINK_ARCHIVE_HPP
diff --git a/include/boost/archive/detail/auto_link_warchive.hpp b/include/boost/archive/detail/auto_link_warchive.hpp
new file mode 100644
index 0000000..683d191
--- /dev/null
+++ b/include/boost/archive/detail/auto_link_warchive.hpp
@@ -0,0 +1,47 @@
+#ifndef BOOST_ARCHIVE_DETAIL_AUTO_LINK_WARCHIVE_HPP
+#define BOOST_ARCHIVE_DETAIL_AUTO_LINK_WARCHIVE_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER)
+# pragma once
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// auto_link_warchive.hpp
+//
+// (c) Copyright Robert Ramey 2004
+// Use, modification, and distribution is subject to the Boost Software
+// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+
+// See library home page at http://www.boost.org/libs/serialization
+
+//----------------------------------------------------------------------------//
+
+// This header implements separate compilation features as described in
+// http://www.boost.org/more/separate_compilation.html
+
+// enable automatic library variant selection ------------------------------//
+
+#include <boost/archive/detail/decl.hpp>
+
+#if !defined(BOOST_WARCHIVE_SOURCE) \
+&& !defined(BOOST_ALL_NO_LIB) && !defined(BOOST_SERIALIZATION_NO_LIB)
+
+// Set the name of our library, this will get undef'ed by auto_link.hpp
+// once it's done with it:
+//
+#define BOOST_LIB_NAME boost_wserialization
+//
+// If we're importing code from a dll, then tell auto_link.hpp about it:
+//
+#if defined(BOOST_ALL_DYN_LINK) || defined(BOOST_SERIALIZATION_DYN_LINK)
+# define BOOST_DYN_LINK
+#endif
+//
+// And include the header that does the work:
+//
+#include <boost/config/auto_link.hpp>
+#endif // auto-linking disabled
+
+#endif // ARCHIVE_DETAIL_AUTO_LINK_ARCHIVE_HPP
diff --git a/include/boost/archive/detail/basic_iarchive.hpp b/include/boost/archive/detail/basic_iarchive.hpp
new file mode 100644
index 0000000..1f5a8bf
--- /dev/null
+++ b/include/boost/archive/detail/basic_iarchive.hpp
@@ -0,0 +1,105 @@
+#ifndef BOOST_ARCHIVE_DETAIL_BASIC_IARCHIVE_HPP
+#define BOOST_ARCHIVE_DETAIL_BASIC_IARCHIVE_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER)
+# pragma once
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// basic_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.
+
+// can't use this - much as I'd like to as borland doesn't support it
+
+#include <boost/config.hpp>
+#include <boost/noncopyable.hpp>
+#include <boost/scoped_ptr.hpp>
+
+#include <boost/serialization/tracking_enum.hpp>
+#include <boost/archive/basic_archive.hpp>
+#include <boost/archive/detail/decl.hpp>
+#include <boost/archive/detail/helper_collection.hpp>
+#include <boost/archive/detail/abi_prefix.hpp> // must be the last header
+
+namespace boost {
+namespace serialization {
+ class extended_type_info;
+} // namespace serialization
+
+namespace archive {
+namespace detail {
+
+class basic_iarchive_impl;
+class basic_iserializer;
+class basic_pointer_iserializer;
+
+//////////////////////////////////////////////////////////////////////
+// class basic_iarchive - read serialized objects from a input stream
+class BOOST_SYMBOL_VISIBLE basic_iarchive :
+ private boost::noncopyable,
+ public boost::archive::detail::helper_collection
+{
+ friend class basic_iarchive_impl;
+ // hide implementation of this class to minimize header conclusion
+ boost::scoped_ptr<basic_iarchive_impl> pimpl;
+
+ virtual void vload(version_type &t) = 0;
+ virtual void vload(object_id_type &t) = 0;
+ virtual void vload(class_id_type &t) = 0;
+ virtual void vload(class_id_optional_type &t) = 0;
+ virtual void vload(class_name_type &t) = 0;
+ virtual void vload(tracking_type &t) = 0;
+protected:
+ BOOST_ARCHIVE_DECL basic_iarchive(unsigned int flags);
+ boost::archive::detail::helper_collection &
+ get_helper_collection(){
+ return *this;
+ }
+public:
+ // some msvc versions require that the following function be public
+ // otherwise it should really protected.
+ virtual BOOST_ARCHIVE_DECL ~basic_iarchive();
+ // note: NOT part of the public API.
+ BOOST_ARCHIVE_DECL void next_object_pointer(void *t);
+ BOOST_ARCHIVE_DECL void register_basic_serializer(
+ const basic_iserializer & bis
+ );
+ BOOST_ARCHIVE_DECL void load_object(
+ void *t,
+ const basic_iserializer & bis
+ );
+ BOOST_ARCHIVE_DECL const basic_pointer_iserializer *
+ load_pointer(
+ void * & t,
+ const basic_pointer_iserializer * bpis_ptr,
+ const basic_pointer_iserializer * (*finder)(
+ const boost::serialization::extended_type_info & eti
+ )
+ );
+ // real public API starts here
+ BOOST_ARCHIVE_DECL void
+ set_library_version(library_version_type archive_library_version);
+ BOOST_ARCHIVE_DECL library_version_type
+ get_library_version() const;
+ BOOST_ARCHIVE_DECL unsigned int
+ get_flags() const;
+ BOOST_ARCHIVE_DECL void
+ reset_object_address(const void * new_address, const void * old_address);
+ BOOST_ARCHIVE_DECL void
+ delete_created_pointers();
+};
+
+} // namespace detail
+} // namespace archive
+} // namespace boost
+
+#include <boost/archive/detail/abi_suffix.hpp> // pops abi_suffix.hpp pragmas
+
+#endif //BOOST_ARCHIVE_DETAIL_BASIC_IARCHIVE_HPP
diff --git a/include/boost/archive/detail/basic_iserializer.hpp b/include/boost/archive/detail/basic_iserializer.hpp
new file mode 100644
index 0000000..0d66674
--- /dev/null
+++ b/include/boost/archive/detail/basic_iserializer.hpp
@@ -0,0 +1,91 @@
+#ifndef BOOST_ARCHIVE_DETAIL_BASIC_ISERIALIZER_HPP
+#define BOOST_ARCHIVE_DETAIL_BASIC_ISERIALIZER_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER)
+# pragma once
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// basic_iserializer.hpp: extenstion of type_info required for serialization.
+
+// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
+// Use, modification and distribution is subject to the Boost Software
+// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+
+// See http://www.boost.org for updates, documentation, and revision history.
+
+#include <cstdlib> // NULL
+#include <boost/config.hpp>
+
+#include <boost/archive/basic_archive.hpp>
+#include <boost/archive/detail/decl.hpp>
+#include <boost/archive/detail/basic_serializer.hpp>
+#include <boost/archive/detail/auto_link_archive.hpp>
+#include <boost/archive/detail/abi_prefix.hpp> // must be the last header
+
+#ifdef BOOST_MSVC
+# pragma warning(push)
+# pragma warning(disable : 4511 4512)
+#endif
+
+namespace boost {
+namespace serialization {
+ class extended_type_info;
+} // namespace serialization
+
+// forward declarations
+namespace archive {
+namespace detail {
+
+class basic_iarchive;
+class basic_pointer_iserializer;
+
+class BOOST_SYMBOL_VISIBLE basic_iserializer :
+ public basic_serializer
+{
+private:
+ basic_pointer_iserializer *m_bpis;
+protected:
+ explicit BOOST_ARCHIVE_DECL basic_iserializer(
+ const boost::serialization::extended_type_info & type
+ );
+ virtual BOOST_ARCHIVE_DECL ~basic_iserializer();
+public:
+ bool serialized_as_pointer() const {
+ return m_bpis != NULL;
+ }
+ void set_bpis(basic_pointer_iserializer *bpis){
+ m_bpis = bpis;
+ }
+ const basic_pointer_iserializer * get_bpis_ptr() const {
+ return m_bpis;
+ }
+ virtual void load_object_data(
+ basic_iarchive & ar,
+ void *x,
+ const unsigned int file_version
+ ) const = 0;
+ // returns true if class_info should be saved
+ virtual bool class_info() const = 0 ;
+ // returns true if objects should be tracked
+ virtual bool tracking(const unsigned int) const = 0 ;
+ // returns class version
+ virtual version_type version() const = 0 ;
+ // returns true if this class is polymorphic
+ virtual bool is_polymorphic() const = 0;
+ virtual void destroy(/*const*/ void *address) const = 0 ;
+};
+
+} // namespae detail
+} // namespace archive
+} // namespace boost
+
+#ifdef BOOST_MSVC
+#pragma warning(pop)
+#endif
+
+#include <boost/archive/detail/abi_suffix.hpp> // pops abi_suffix.hpp pragmas
+
+#endif // BOOST_ARCHIVE_DETAIL_BASIC_ISERIALIZER_HPP
diff --git a/include/boost/archive/detail/basic_oarchive.hpp b/include/boost/archive/detail/basic_oarchive.hpp
new file mode 100644
index 0000000..c379108
--- /dev/null
+++ b/include/boost/archive/detail/basic_oarchive.hpp
@@ -0,0 +1,94 @@
+#ifndef BOOST_ARCHIVE_BASIC_OARCHIVE_HPP
+#define BOOST_ARCHIVE_BASIC_OARCHIVE_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER)
+# pragma once
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// basic_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 <cstddef> // NULL
+#include <boost/config.hpp>
+#include <boost/noncopyable.hpp>
+#include <boost/scoped_ptr.hpp>
+
+#include <boost/archive/basic_archive.hpp>
+#include <boost/serialization/tracking_enum.hpp>
+#include <boost/archive/detail/helper_collection.hpp>
+#include <boost/archive/detail/abi_prefix.hpp> // must be the last header
+
+namespace boost {
+namespace serialization {
+ class extended_type_info;
+} // namespace serialization
+
+namespace archive {
+namespace detail {
+
+class basic_oarchive_impl;
+class basic_oserializer;
+class basic_pointer_oserializer;
+
+//////////////////////////////////////////////////////////////////////
+// class basic_oarchive - write serialized objects to an output stream
+class BOOST_SYMBOL_VISIBLE basic_oarchive :
+ private boost::noncopyable,
+ public boost::archive::detail::helper_collection
+{
+ friend class basic_oarchive_impl;
+ // hide implementation of this class to minimize header conclusion
+ boost::scoped_ptr<basic_oarchive_impl> pimpl;
+
+ // overload these to bracket object attributes. Used to implement
+ // xml archives
+ virtual void vsave(const version_type t) = 0;
+ virtual void vsave(const object_id_type t) = 0;
+ virtual void vsave(const object_reference_type t) = 0;
+ virtual void vsave(const class_id_type t) = 0;
+ virtual void vsave(const class_id_optional_type t) = 0;
+ virtual void vsave(const class_id_reference_type t) = 0;
+ virtual void vsave(const class_name_type & t) = 0;
+ virtual void vsave(const tracking_type t) = 0;
+protected:
+ BOOST_ARCHIVE_DECL basic_oarchive(unsigned int flags = 0);
+ BOOST_ARCHIVE_DECL boost::archive::detail::helper_collection &
+ get_helper_collection();
+ virtual BOOST_ARCHIVE_DECL ~basic_oarchive();
+public:
+ // note: NOT part of the public interface
+ BOOST_ARCHIVE_DECL void register_basic_serializer(
+ const basic_oserializer & bos
+ );
+ BOOST_ARCHIVE_DECL void save_object(
+ const void *x,
+ const basic_oserializer & bos
+ );
+ BOOST_ARCHIVE_DECL void save_pointer(
+ const void * t,
+ const basic_pointer_oserializer * bpos_ptr
+ );
+ void save_null_pointer(){
+ vsave(NULL_POINTER_TAG);
+ }
+ // real public interface starts here
+ BOOST_ARCHIVE_DECL void end_preamble(); // default implementation does nothing
+ BOOST_ARCHIVE_DECL library_version_type get_library_version() const;
+ BOOST_ARCHIVE_DECL unsigned int get_flags() const;
+};
+
+} // namespace detail
+} // namespace archive
+} // namespace boost
+
+#include <boost/archive/detail/abi_suffix.hpp> // pops abi_suffix.hpp pragmas
+
+#endif //BOOST_ARCHIVE_BASIC_OARCHIVE_HPP
diff --git a/include/boost/archive/detail/basic_oserializer.hpp b/include/boost/archive/detail/basic_oserializer.hpp
new file mode 100644
index 0000000..94247e9
--- /dev/null
+++ b/include/boost/archive/detail/basic_oserializer.hpp
@@ -0,0 +1,89 @@
+#ifndef BOOST_SERIALIZATION_BASIC_OSERIALIZER_HPP
+#define BOOST_SERIALIZATION_BASIC_OSERIALIZER_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER)
+# pragma once
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// basic_oserializer.hpp: extenstion of type_info required for serialization.
+
+// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
+// Use, modification and distribution is subject to the Boost Software
+// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+
+// See http://www.boost.org for updates, documentation, and revision history.
+
+#include <cstddef> // NULL
+#include <boost/config.hpp>
+#include <boost/noncopyable.hpp>
+
+#include <boost/archive/basic_archive.hpp>
+#include <boost/archive/detail/auto_link_archive.hpp>
+#include <boost/archive/detail/basic_serializer.hpp>
+
+#include <boost/archive/detail/abi_prefix.hpp> // must be the last header
+
+#ifdef BOOST_MSVC
+# pragma warning(push)
+# pragma warning(disable : 4511 4512)
+#endif
+
+namespace boost {
+namespace serialization {
+ class extended_type_info;
+} // namespace serialization
+
+// forward declarations
+namespace archive {
+namespace detail {
+
+class basic_oarchive;
+class basic_pointer_oserializer;
+
+class BOOST_SYMBOL_VISIBLE basic_oserializer :
+ public basic_serializer
+{
+private:
+ basic_pointer_oserializer *m_bpos;
+protected:
+ explicit BOOST_ARCHIVE_DECL basic_oserializer(
+ const boost::serialization::extended_type_info & type_
+ );
+ virtual BOOST_ARCHIVE_DECL ~basic_oserializer();
+public:
+ bool serialized_as_pointer() const {
+ return m_bpos != NULL;
+ }
+ void set_bpos(basic_pointer_oserializer *bpos){
+ m_bpos = bpos;
+ }
+ const basic_pointer_oserializer * get_bpos() const {
+ return m_bpos;
+ }
+ virtual void save_object_data(
+ basic_oarchive & ar, const void * x
+ ) const = 0;
+ // returns true if class_info should be saved
+ virtual bool class_info() const = 0;
+ // returns true if objects should be tracked
+ virtual bool tracking(const unsigned int flags) const = 0;
+ // returns class version
+ virtual version_type version() const = 0;
+ // returns true if this class is polymorphic
+ virtual bool is_polymorphic() const = 0;
+};
+
+} // namespace detail
+} // namespace serialization
+} // namespace boost
+
+#ifdef BOOST_MSVC
+#pragma warning(pop)
+#endif
+
+#include <boost/archive/detail/abi_suffix.hpp> // pops abi_suffix.hpp pragmas
+
+#endif // BOOST_SERIALIZATION_BASIC_OSERIALIZER_HPP
diff --git a/include/boost/archive/detail/basic_pointer_iserializer.hpp b/include/boost/archive/detail/basic_pointer_iserializer.hpp
new file mode 100644
index 0000000..1fc4b14
--- /dev/null
+++ b/include/boost/archive/detail/basic_pointer_iserializer.hpp
@@ -0,0 +1,70 @@
+#ifndef BOOST_ARCHIVE_BASIC_POINTER_ISERIALIZER_HPP
+#define BOOST_ARCHIVE_BASIC_POINTER_ISERIALIZER_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER)
+# pragma once
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// basic_pointer_oserializer.hpp: extenstion of type_info required for
+// serialization.
+
+// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
+// Use, modification and distribution is subject to the Boost Software
+// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+
+// See http://www.boost.org for updates, documentation, and revision history.
+#include <boost/config.hpp>
+#include <boost/noncopyable.hpp>
+#include <boost/archive/detail/auto_link_archive.hpp>
+#include <boost/archive/detail/basic_serializer.hpp>
+
+#include <boost/archive/detail/abi_prefix.hpp> // must be the last header
+
+#ifdef BOOST_MSVC
+# pragma warning(push)
+# pragma warning(disable : 4511 4512)
+#endif
+
+namespace boost {
+namespace serialization {
+ class extended_type_info;
+} // namespace serialization
+
+// forward declarations
+namespace archive {
+namespace detail {
+
+class basic_iarchive;
+class basic_iserializer;
+
+class BOOST_SYMBOL_VISIBLE basic_pointer_iserializer
+ : public basic_serializer {
+protected:
+ explicit BOOST_ARCHIVE_DECL basic_pointer_iserializer(
+ const boost::serialization::extended_type_info & type_
+ );
+ virtual BOOST_ARCHIVE_DECL ~basic_pointer_iserializer();
+public:
+ virtual void * heap_allocation() const = 0;
+ virtual const basic_iserializer & get_basic_serializer() const = 0;
+ virtual void load_object_ptr(
+ basic_iarchive & ar,
+ void * x,
+ const unsigned int file_version
+ ) const = 0;
+};
+
+} // namespace detail
+} // namespace archive
+} // namespace boost
+
+#ifdef BOOST_MSVC
+#pragma warning(pop)
+#endif
+
+#include <boost/archive/detail/abi_suffix.hpp> // pops abi_suffix.hpp pragmas
+
+#endif // BOOST_ARCHIVE_BASIC_POINTER_ISERIALIZER_HPP
diff --git a/include/boost/archive/detail/basic_pointer_oserializer.hpp b/include/boost/archive/detail/basic_pointer_oserializer.hpp
new file mode 100644
index 0000000..1a5d954
--- /dev/null
+++ b/include/boost/archive/detail/basic_pointer_oserializer.hpp
@@ -0,0 +1,68 @@
+#ifndef BOOST_ARCHIVE_BASIC_POINTER_OSERIALIZER_HPP
+#define BOOST_ARCHIVE_BASIC_POINTER_OSERIALIZER_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER)
+# pragma once
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// basic_pointer_oserializer.hpp: extenstion of type_info required for
+// serialization.
+
+// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
+// Use, modification and distribution is subject to the Boost Software
+// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+
+// See http://www.boost.org for updates, documentation, and revision history.
+#include <boost/config.hpp>
+#include <boost/noncopyable.hpp>
+#include <boost/archive/detail/auto_link_archive.hpp>
+#include <boost/archive/detail/basic_serializer.hpp>
+
+#include <boost/archive/detail/abi_prefix.hpp> // must be the last header
+
+#ifdef BOOST_MSVC
+# pragma warning(push)
+# pragma warning(disable : 4511 4512)
+#endif
+
+namespace boost {
+namespace serialization {
+ class extended_type_info;
+} // namespace serialization
+
+namespace archive {
+namespace detail {
+
+class basic_oarchive;
+class basic_oserializer;
+
+class BOOST_SYMBOL_VISIBLE basic_pointer_oserializer :
+ public basic_serializer
+{
+protected:
+ explicit BOOST_ARCHIVE_DECL basic_pointer_oserializer(
+ const boost::serialization::extended_type_info & type_
+ );
+public:
+ virtual BOOST_ARCHIVE_DECL ~basic_pointer_oserializer();
+ virtual const basic_oserializer & get_basic_serializer() const = 0;
+ virtual void save_object_ptr(
+ basic_oarchive & ar,
+ const void * x
+ ) const = 0;
+};
+
+} // namespace detail
+} // namespace archive
+} // namespace boost
+
+#ifdef BOOST_MSVC
+#pragma warning(pop)
+#endif
+
+#include <boost/archive/detail/abi_suffix.hpp> // pops abi_suffix.hpp pragmas
+
+#endif // BOOST_ARCHIVE_BASIC_POINTER_OSERIALIZER_HPP
diff --git a/include/boost/archive/detail/basic_serializer.hpp b/include/boost/archive/detail/basic_serializer.hpp
new file mode 100644
index 0000000..f9c4203
--- /dev/null
+++ b/include/boost/archive/detail/basic_serializer.hpp
@@ -0,0 +1,77 @@
+#ifndef BOOST_ARCHIVE_BASIC_SERIALIZER_HPP
+#define BOOST_ARCHIVE_BASIC_SERIALIZER_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER)
+# pragma once
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// basic_serializer.hpp: extenstion of type_info required for serialization.
+
+// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
+// Use, modification and distribution is subject to the Boost Software
+// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+
+// See http://www.boost.org for updates, documentation, and revision history.
+
+#include <boost/assert.hpp>
+#include <cstddef> // NULL
+
+#include <boost/noncopyable.hpp>
+#include <boost/config.hpp>
+#include <boost/serialization/extended_type_info.hpp>
+
+#ifdef BOOST_MSVC
+# pragma warning(push)
+# pragma warning(disable : 4511 4512)
+#endif
+
+namespace boost {
+namespace archive {
+namespace detail {
+
+class basic_serializer :
+ private boost::noncopyable
+{
+ const boost::serialization::extended_type_info * m_eti;
+protected:
+ explicit basic_serializer(
+ const boost::serialization::extended_type_info & eti
+ ) :
+ m_eti(& eti)
+ {}
+public:
+ inline bool
+ operator<(const basic_serializer & rhs) const {
+ // can't compare address since there can be multiple eti records
+ // for the same type in different execution modules (that is, DLLS)
+ // leave this here as a reminder not to do this!
+ // return & lhs.get_eti() < & rhs.get_eti();
+ return get_eti() < rhs.get_eti();
+ }
+ const char * get_debug_info() const {
+ return m_eti->get_debug_info();
+ }
+ const boost::serialization::extended_type_info & get_eti() const {
+ return * m_eti;
+ }
+};
+
+class basic_serializer_arg : public basic_serializer {
+public:
+ basic_serializer_arg(const serialization::extended_type_info & eti) :
+ basic_serializer(eti)
+ {}
+};
+
+} // namespace detail
+} // namespace archive
+} // namespace boost
+
+#ifdef BOOST_MSVC
+#pragma warning(pop)
+#endif
+
+#endif // BOOST_ARCHIVE_BASIC_SERIALIZER_HPP
diff --git a/include/boost/archive/detail/basic_serializer_map.hpp b/include/boost/archive/detail/basic_serializer_map.hpp
new file mode 100644
index 0000000..7934180
--- /dev/null
+++ b/include/boost/archive/detail/basic_serializer_map.hpp
@@ -0,0 +1,69 @@
+#ifndef BOOST_SERIALIZER_MAP_HPP
+#define BOOST_SERIALIZER_MAP_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER)
+# pragma once
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// basic_serializer_map.hpp: extenstion of type_info required for serialization.
+
+// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
+// Use, modification and distribution is subject to the Boost Software
+// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+
+// See http://www.boost.org for updates, documentation, and revision history.
+
+#include <set>
+
+#include <boost/config.hpp>
+#include <boost/noncopyable.hpp>
+#include <boost/archive/detail/auto_link_archive.hpp>
+
+#include <boost/archive/detail/abi_prefix.hpp> // must be the last header
+
+namespace boost {
+namespace serialization {
+ class extended_type_info;
+}
+
+namespace archive {
+namespace detail {
+
+class basic_serializer;
+
+class BOOST_SYMBOL_VISIBLE
+basic_serializer_map : public
+ boost::noncopyable
+{
+ struct type_info_pointer_compare
+ {
+ bool operator()(
+ const basic_serializer * lhs, const basic_serializer * rhs
+ ) const ;
+ };
+ typedef std::set<
+ const basic_serializer *,
+ type_info_pointer_compare
+ > map_type;
+ map_type m_map;
+public:
+ BOOST_ARCHIVE_DECL bool insert(const basic_serializer * bs);
+ BOOST_ARCHIVE_DECL void erase(const basic_serializer * bs);
+ BOOST_ARCHIVE_DECL const basic_serializer * find(
+ const boost::serialization::extended_type_info & type_
+ ) const;
+private:
+ // cw 8.3 requires this
+ basic_serializer_map& operator=(basic_serializer_map const&);
+};
+
+} // namespace detail
+} // namespace archive
+} // namespace boost
+
+#include <boost/archive/detail/abi_suffix.hpp> // must be the last header
+
+#endif // BOOST_SERIALIZER_MAP_HPP
diff --git a/include/boost/archive/detail/check.hpp b/include/boost/archive/detail/check.hpp
new file mode 100644
index 0000000..10034e7
--- /dev/null
+++ b/include/boost/archive/detail/check.hpp
@@ -0,0 +1,169 @@
+#ifndef BOOST_ARCHIVE_DETAIL_CHECK_HPP
+#define BOOST_ARCHIVE_DETAIL_CHECK_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER)
+# pragma once
+#pragma inline_depth(511)
+#pragma inline_recursion(on)
+#endif
+
+#if defined(__MWERKS__)
+#pragma inline_depth(511)
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// check.hpp: interface for serialization system.
+
+// (C) Copyright 2009 Robert Ramey - http://www.rrsd.com .
+// Use, modification and distribution is subject to the Boost Software
+// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+
+// See http://www.boost.org for updates, documentation, and revision history.
+
+#include <boost/config.hpp>
+
+#include <boost/static_assert.hpp>
+#include <boost/type_traits/is_const.hpp>
+
+#include <boost/mpl/eval_if.hpp>
+#include <boost/mpl/or.hpp>
+#include <boost/mpl/equal_to.hpp>
+#include <boost/mpl/int.hpp>
+#include <boost/mpl/not.hpp>
+#include <boost/mpl/greater.hpp>
+#include <boost/mpl/assert.hpp>
+
+#include <boost/serialization/static_warning.hpp>
+#include <boost/serialization/version.hpp>
+#include <boost/serialization/level.hpp>
+#include <boost/serialization/tracking.hpp>
+#include <boost/serialization/wrapper.hpp>
+
+namespace boost {
+namespace archive {
+namespace detail {
+
+// checks for objects
+
+template<class T>
+inline void check_object_level(){
+ typedef
+ typename mpl::greater_equal<
+ serialization::implementation_level< T >,
+ mpl::int_<serialization::primitive_type>
+ >::type typex;
+
+ // trap attempts to serialize objects marked
+ // not_serializable
+ BOOST_STATIC_ASSERT(typex::value);
+}
+
+template<class T>
+inline void check_object_versioning(){
+ typedef
+ typename mpl::or_<
+ typename mpl::greater<
+ serialization::implementation_level< T >,
+ mpl::int_<serialization::object_serializable>
+ >,
+ typename mpl::equal_to<
+ serialization::version< T >,
+ mpl::int_<0>
+ >
+ > typex;
+ // trap attempts to serialize with objects that don't
+ // save class information in the archive with versioning.
+ BOOST_STATIC_ASSERT(typex::value);
+}
+
+template<class T>
+inline void check_object_tracking(){
+ // presume it has already been determined that
+ // T is not a const
+ BOOST_STATIC_ASSERT(! boost::is_const< T >::value);
+ typedef typename mpl::equal_to<
+ serialization::tracking_level< T >,
+ mpl::int_<serialization::track_never>
+ >::type typex;
+ // saving an non-const object of a type not marked "track_never)
+
+ // may be an indicator of an error usage of the
+ // serialization library and should be double checked.
+ // See documentation on object tracking. Also, see the
+ // "rationale" section of the documenation
+ // for motivation for this checking.
+
+ BOOST_STATIC_WARNING(typex::value);
+}
+
+// checks for pointers
+
+template<class T>
+inline void check_pointer_level(){
+ // we should only invoke this once we KNOW that T
+ // has been used as a pointer!!
+ typedef
+ typename mpl::or_<
+ typename mpl::greater<
+ serialization::implementation_level< T >,
+ mpl::int_<serialization::object_serializable>
+ >,
+ typename mpl::not_<
+ typename mpl::equal_to<
+ serialization::tracking_level< T >,
+ mpl::int_<serialization::track_selectively>
+ >
+ >
+ > typex;
+ // Address the following when serializing to a pointer:
+
+ // a) This type doesn't save class information in the
+ // archive. That is, the serialization trait implementation
+ // level <= object_serializable.
+ // b) Tracking for this type is set to "track selectively"
+
+ // in this case, indication that an object is tracked is
+ // not stored in the archive itself - see level == object_serializable
+ // but rather the existence of the operation ar >> T * is used to
+ // infer that an object of this type should be tracked. So, if
+ // you save via a pointer but don't load via a pointer the operation
+ // will fail on load without given any valid reason for the failure.
+
+ // So if your program traps here, consider changing the
+ // tracking or implementation level traits - or not
+ // serializing via a pointer.
+ BOOST_STATIC_WARNING(typex::value);
+}
+
+template<class T>
+void inline check_pointer_tracking(){
+ typedef typename mpl::greater<
+ serialization::tracking_level< T >,
+ mpl::int_<serialization::track_never>
+ >::type typex;
+ // serializing an object of a type marked "track_never" through a pointer
+ // could result in creating more objects than were saved!
+ BOOST_STATIC_WARNING(typex::value);
+}
+
+template<class T>
+inline void check_const_loading(){
+ typedef
+ typename mpl::or_<
+ typename boost::serialization::is_wrapper< T >,
+ typename mpl::not_<
+ typename boost::is_const< T >
+ >
+ >::type typex;
+ // cannot load data into a "const" object unless it's a
+ // wrapper around some other non-const object.
+ BOOST_STATIC_ASSERT(typex::value);
+}
+
+} // detail
+} // archive
+} // boost
+
+#endif // BOOST_ARCHIVE_DETAIL_CHECK_HPP
diff --git a/include/boost/archive/detail/common_iarchive.hpp b/include/boost/archive/detail/common_iarchive.hpp
new file mode 100644
index 0000000..4176a8a
--- /dev/null
+++ b/include/boost/archive/detail/common_iarchive.hpp
@@ -0,0 +1,89 @@
+#ifndef BOOST_ARCHIVE_DETAIL_COMMON_IARCHIVE_HPP
+#define BOOST_ARCHIVE_DETAIL_COMMON_IARCHIVE_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER)
+# pragma once
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// common_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 <boost/config.hpp>
+
+#include <boost/archive/detail/basic_iarchive.hpp>
+#include <boost/archive/detail/basic_pointer_iserializer.hpp>
+#include <boost/archive/detail/interface_iarchive.hpp>
+
+#ifdef BOOST_MSVC
+# pragma warning(push)
+# pragma warning(disable : 4511 4512)
+#endif
+
+namespace boost {
+namespace archive {
+namespace detail {
+
+class extended_type_info;
+
+// note: referred to as Curiously Recurring Template Patter (CRTP)
+template<class Archive>
+class BOOST_SYMBOL_VISIBLE common_iarchive :
+ public basic_iarchive,
+ public interface_iarchive<Archive>
+{
+ friend class interface_iarchive<Archive>;
+ friend class basic_iarchive;
+private:
+ virtual void vload(version_type & t){
+ * this->This() >> t;
+ }
+ virtual void vload(object_id_type & t){
+ * this->This() >> t;
+ }
+ virtual void vload(class_id_type & t){
+ * this->This() >> t;
+ }
+ virtual void vload(class_id_optional_type & t){
+ * this->This() >> t;
+ }
+ virtual void vload(tracking_type & t){
+ * this->This() >> t;
+ }
+ virtual void vload(class_name_type &s){
+ * this->This() >> s;
+ }
+protected:
+ // default processing - invoke serialization library
+ template<class T>
+ void load_override(T & t){
+ archive::load(* this->This(), t);
+ }
+ // default implementations of functions which emit start/end tags for
+ // archive types that require them.
+ void load_start(const char * /*name*/){}
+ void load_end(const char * /*name*/){}
+ // default archive initialization
+ common_iarchive(unsigned int flags = 0) :
+ basic_iarchive(flags),
+ interface_iarchive<Archive>()
+ {}
+};
+
+} // namespace detail
+} // namespace archive
+} // namespace boost
+
+#ifdef BOOST_MSVC
+#pragma warning(pop)
+#endif
+
+#endif // BOOST_ARCHIVE_DETAIL_COMMON_IARCHIVE_HPP
+
diff --git a/include/boost/archive/detail/common_oarchive.hpp b/include/boost/archive/detail/common_oarchive.hpp
new file mode 100644
index 0000000..f742863
--- /dev/null
+++ b/include/boost/archive/detail/common_oarchive.hpp
@@ -0,0 +1,89 @@
+#ifndef BOOST_ARCHIVE_DETAIL_COMMON_OARCHIVE_HPP
+#define BOOST_ARCHIVE_DETAIL_COMMON_OARCHIVE_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER)
+# pragma once
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// common_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 <boost/config.hpp>
+
+#include <boost/archive/detail/basic_oarchive.hpp>
+#include <boost/archive/detail/interface_oarchive.hpp>
+
+#ifdef BOOST_MSVC
+# pragma warning(push)
+# pragma warning(disable : 4511 4512)
+#endif
+
+namespace boost {
+namespace archive {
+namespace detail {
+
+// note: referred to as Curiously Recurring Template Patter (CRTP)
+template<class Archive>
+
+class BOOST_SYMBOL_VISIBLE common_oarchive :
+ public basic_oarchive,
+ public interface_oarchive<Archive>
+{
+ friend class interface_oarchive<Archive>;
+ friend class basic_oarchive;
+private:
+ virtual void vsave(const version_type t){
+ * this->This() << t;
+ }
+ virtual void vsave(const object_id_type t){
+ * this->This() << t;
+ }
+ virtual void vsave(const object_reference_type t){
+ * this->This() << t;
+ }
+ virtual void vsave(const class_id_type t){
+ * this->This() << t;
+ }
+ virtual void vsave(const class_id_reference_type t){
+ * this->This() << t;
+ }
+ virtual void vsave(const class_id_optional_type t){
+ * this->This() << t;
+ }
+ virtual void vsave(const class_name_type & t){
+ * this->This() << t;
+ }
+ virtual void vsave(const tracking_type t){
+ * this->This() << t;
+ }
+protected:
+ // default processing - invoke serialization library
+ template<class T>
+ void save_override(T & t){
+ archive::save(* this->This(), t);
+ }
+ void save_start(const char * /*name*/){}
+ void save_end(const char * /*name*/){}
+ common_oarchive(unsigned int flags = 0) :
+ basic_oarchive(flags),
+ interface_oarchive<Archive>()
+ {}
+};
+
+} // namespace detail
+} // namespace archive
+} // namespace boost
+
+#ifdef BOOST_MSVC
+#pragma warning(pop)
+#endif
+
+#endif // BOOST_ARCHIVE_DETAIL_COMMON_OARCHIVE_HPP
diff --git a/include/boost/archive/detail/decl.hpp b/include/boost/archive/detail/decl.hpp
new file mode 100644
index 0000000..4f731cd
--- /dev/null
+++ b/include/boost/archive/detail/decl.hpp
@@ -0,0 +1,57 @@
+#ifndef BOOST_ARCHIVE_DETAIL_DECL_HPP
+#define BOOST_ARCHIVE_DETAIL_DECL_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER)
+# pragma once
+#endif
+
+/////////1/////////2///////// 3/////////4/////////5/////////6/////////7/////////8
+// decl.hpp
+//
+// (c) Copyright Robert Ramey 2004
+// Use, modification, and distribution is subject to the Boost Software
+// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+
+// See library home page at http://www.boost.org/libs/serialization
+
+//----------------------------------------------------------------------------//
+
+// This header implements separate compilation features as described in
+// http://www.boost.org/more/separate_compilation.html
+
+#include <boost/config.hpp>
+
+#if (defined(BOOST_ALL_DYN_LINK) || defined(BOOST_SERIALIZATION_DYN_LINK))
+ #if defined(BOOST_ARCHIVE_SOURCE)
+ #define BOOST_ARCHIVE_DECL BOOST_SYMBOL_EXPORT
+ #else
+ #define BOOST_ARCHIVE_DECL BOOST_SYMBOL_IMPORT
+ #endif
+
+ #if defined(BOOST_WARCHIVE_SOURCE)
+ #define BOOST_WARCHIVE_DECL BOOST_SYMBOL_EXPORT
+ #else
+ #define BOOST_WARCHIVE_DECL BOOST_SYMBOL_IMPORT
+ #endif
+
+ #if defined(BOOST_WARCHIVE_SOURCE) || defined(BOOST_ARCHIVE_SOURCE)
+ #define BOOST_ARCHIVE_OR_WARCHIVE_DECL BOOST_SYMBOL_EXPORT
+ #else
+ #define BOOST_ARCHIVE_OR_WARCHIVE_DECL BOOST_SYMBOL_IMPORT
+ #endif
+
+#endif
+
+#if ! defined(BOOST_ARCHIVE_DECL)
+ #define BOOST_ARCHIVE_DECL
+#endif
+#if ! defined(BOOST_WARCHIVE_DECL)
+ #define BOOST_WARCHIVE_DECL
+#endif
+#if ! defined(BOOST_ARCHIVE_OR_WARCHIVE_DECL)
+ #define BOOST_ARCHIVE_OR_WARCHIVE_DECL
+#endif
+
+#endif // BOOST_ARCHIVE_DETAIL_DECL_HPP
diff --git a/include/boost/archive/detail/helper_collection.hpp b/include/boost/archive/detail/helper_collection.hpp
new file mode 100644
index 0000000..edb4125
--- /dev/null
+++ b/include/boost/archive/detail/helper_collection.hpp
@@ -0,0 +1,99 @@
+#ifndef BOOST_ARCHIVE_DETAIL_HELPER_COLLECTION_HPP
+#define BOOST_ARCHIVE_DETAIL_HELPER_COLLECTION_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
+// helper_collection.hpp: archive support for run-time helpers
+
+// (C) Copyright 2002-2008 Robert Ramey and Joaquin M Lopez Munoz
+// 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 <cstddef> // NULL
+#include <vector>
+#include <utility>
+#include <memory>
+#include <algorithm>
+
+#include <boost/config.hpp>
+
+#include <boost/smart_ptr/shared_ptr.hpp>
+#include <boost/smart_ptr/make_shared.hpp>
+
+namespace boost {
+
+namespace archive {
+namespace detail {
+
+class helper_collection
+{
+ helper_collection(const helper_collection&); // non-copyable
+ helper_collection& operator = (const helper_collection&); // non-copyable
+
+ // note: we dont' actually "share" the function object pointer
+ // we only use shared_ptr to make sure that it get's deleted
+
+ typedef std::pair<
+ const void *,
+ boost::shared_ptr<void>
+ > helper_value_type;
+ template<class T>
+ boost::shared_ptr<void> make_helper_ptr(){
+ // use boost::shared_ptr rather than std::shared_ptr to maintain
+ // c++03 compatibility
+ return boost::make_shared<T>();
+ }
+
+ typedef std::vector<helper_value_type> collection;
+ collection m_collection;
+
+ struct predicate {
+ BOOST_DELETED_FUNCTION(predicate & operator=(const predicate & rhs))
+ public:
+ const void * const m_ti;
+ bool operator()(helper_value_type const &rhs) const {
+ return m_ti == rhs.first;
+ }
+ predicate(const void * ti) :
+ m_ti(ti)
+ {}
+ };
+protected:
+ helper_collection(){}
+ ~helper_collection(){}
+public:
+ template<typename Helper>
+ Helper& find_helper(void * const id = 0) {
+ collection::const_iterator it =
+ std::find_if(
+ m_collection.begin(),
+ m_collection.end(),
+ predicate(id)
+ );
+
+ void * rval = 0;
+ if(it == m_collection.end()){
+ m_collection.push_back(
+ std::make_pair(id, make_helper_ptr<Helper>())
+ );
+ rval = m_collection.back().second.get();
+ }
+ else{
+ rval = it->second.get();
+ }
+ return *static_cast<Helper *>(rval);
+ }
+};
+
+} // namespace detail
+} // namespace serialization
+} // namespace boost
+
+#endif // BOOST_ARCHIVE_DETAIL_HELPER_COLLECTION_HPP
diff --git a/include/boost/archive/detail/interface_iarchive.hpp b/include/boost/archive/detail/interface_iarchive.hpp
new file mode 100644
index 0000000..4a99e28
--- /dev/null
+++ b/include/boost/archive/detail/interface_iarchive.hpp
@@ -0,0 +1,85 @@
+#ifndef BOOST_ARCHIVE_DETAIL_INTERFACE_IARCHIVE_HPP
+#define BOOST_ARCHIVE_DETAIL_INTERFACE_IARCHIVE_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER)
+# pragma once
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// interface_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 <cstddef> // NULL
+#include <boost/cstdint.hpp>
+#include <boost/mpl/bool.hpp>
+#include <boost/archive/detail/auto_link_archive.hpp>
+#include <boost/archive/detail/iserializer.hpp>
+#include <boost/archive/detail/helper_collection.hpp>
+#include <boost/serialization/singleton.hpp>
+#include <boost/archive/detail/abi_prefix.hpp> // must be the last header
+
+namespace boost {
+namespace archive {
+namespace detail {
+
+class basic_pointer_iserializer;
+
+template<class Archive>
+class interface_iarchive
+{
+protected:
+ interface_iarchive(){};
+public:
+ /////////////////////////////////////////////////////////
+ // archive public interface
+ typedef mpl::bool_<true> is_loading;
+ typedef mpl::bool_<false> is_saving;
+
+ // return a pointer to the most derived class
+ Archive * This(){
+ return static_cast<Archive *>(this);
+ }
+
+ template<class T>
+ const basic_pointer_iserializer *
+ register_type(T * = NULL){
+ const basic_pointer_iserializer & bpis =
+ boost::serialization::singleton<
+ pointer_iserializer<Archive, T>
+ >::get_const_instance();
+ this->This()->register_basic_serializer(bpis.get_basic_serializer());
+ return & bpis;
+ }
+ template<class Helper>
+ Helper &
+ get_helper(void * const id = 0){
+ helper_collection & hc = this->This()->get_helper_collection();
+ return hc.template find_helper<Helper>(id);
+ }
+
+ template<class T>
+ Archive & operator>>(T & t){
+ this->This()->load_override(t);
+ return * this->This();
+ }
+
+ // the & operator
+ template<class T>
+ Archive & operator&(T & t){
+ return *(this->This()) >> t;
+ }
+};
+
+} // namespace detail
+} // namespace archive
+} // namespace boost
+
+#include <boost/archive/detail/abi_suffix.hpp> // pops abi_suffix.hpp pragmas
+
+#endif // BOOST_ARCHIVE_DETAIL_INTERFACE_IARCHIVE_HPP
diff --git a/include/boost/archive/detail/interface_oarchive.hpp b/include/boost/archive/detail/interface_oarchive.hpp
new file mode 100644
index 0000000..359463e
--- /dev/null
+++ b/include/boost/archive/detail/interface_oarchive.hpp
@@ -0,0 +1,87 @@
+#ifndef BOOST_ARCHIVE_DETAIL_INTERFACE_OARCHIVE_HPP
+#define BOOST_ARCHIVE_DETAIL_INTERFACE_OARCHIVE_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER)
+# pragma once
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// interface_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 <cstddef> // NULL
+#include <boost/cstdint.hpp>
+#include <boost/mpl/bool.hpp>
+
+#include <boost/archive/detail/auto_link_archive.hpp>
+#include <boost/archive/detail/oserializer.hpp>
+#include <boost/archive/detail/abi_prefix.hpp> // must be the last header
+
+#include <boost/serialization/singleton.hpp>
+
+namespace boost {
+namespace archive {
+namespace detail {
+
+class basic_pointer_oserializer;
+
+template<class Archive>
+class interface_oarchive
+{
+protected:
+ interface_oarchive(){};
+public:
+ /////////////////////////////////////////////////////////
+ // archive public interface
+ typedef mpl::bool_<false> is_loading;
+ typedef mpl::bool_<true> is_saving;
+
+ // return a pointer to the most derived class
+ Archive * This(){
+ return static_cast<Archive *>(this);
+ }
+
+ template<class T>
+ const basic_pointer_oserializer *
+ register_type(const T * = NULL){
+ const basic_pointer_oserializer & bpos =
+ boost::serialization::singleton<
+ pointer_oserializer<Archive, T>
+ >::get_const_instance();
+ this->This()->register_basic_serializer(bpos.get_basic_serializer());
+ return & bpos;
+ }
+
+ template<class Helper>
+ Helper &
+ get_helper(void * const id = 0){
+ helper_collection & hc = this->This()->get_helper_collection();
+ return hc.template find_helper<Helper>(id);
+ }
+
+ template<class T>
+ Archive & operator<<(const T & t){
+ this->This()->save_override(t);
+ return * this->This();
+ }
+
+ // the & operator
+ template<class T>
+ Archive & operator&(const T & t){
+ return * this ->This() << t;
+ }
+};
+
+} // namespace detail
+} // namespace archive
+} // namespace boost
+
+#include <boost/archive/detail/abi_suffix.hpp> // pops abi_suffix.hpp pragmas
+
+#endif // BOOST_ARCHIVE_DETAIL_INTERFACE_IARCHIVE_HPP
diff --git a/include/boost/archive/detail/iserializer.hpp b/include/boost/archive/detail/iserializer.hpp
new file mode 100644
index 0000000..6c2fd67
--- /dev/null
+++ b/include/boost/archive/detail/iserializer.hpp
@@ -0,0 +1,632 @@
+#ifndef BOOST_ARCHIVE_DETAIL_ISERIALIZER_HPP
+#define BOOST_ARCHIVE_DETAIL_ISERIALIZER_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER)
+# pragma once
+#pragma inline_depth(511)
+#pragma inline_recursion(on)
+#endif
+
+#if defined(__MWERKS__)
+#pragma inline_depth(511)
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// iserializer.hpp: interface for serialization system.
+
+// (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 <new> // for placement new
+#include <cstddef> // size_t, NULL
+
+#include <boost/config.hpp>
+#include <boost/detail/workaround.hpp>
+#if defined(BOOST_NO_STDC_NAMESPACE)
+namespace std{
+ using ::size_t;
+} // namespace std
+#endif
+
+#include <boost/static_assert.hpp>
+
+#include <boost/mpl/eval_if.hpp>
+#include <boost/mpl/identity.hpp>
+#include <boost/mpl/greater_equal.hpp>
+#include <boost/mpl/equal_to.hpp>
+#include <boost/core/no_exceptions_support.hpp>
+
+#ifndef BOOST_SERIALIZATION_DEFAULT_TYPE_INFO
+ #include <boost/serialization/extended_type_info_typeid.hpp>
+#endif
+#include <boost/serialization/throw_exception.hpp>
+#include <boost/serialization/smart_cast.hpp>
+#include <boost/serialization/static_warning.hpp>
+
+#include <boost/type_traits/is_pointer.hpp>
+#include <boost/type_traits/is_enum.hpp>
+#include <boost/type_traits/is_const.hpp>
+#include <boost/type_traits/remove_const.hpp>
+#include <boost/type_traits/remove_extent.hpp>
+#include <boost/type_traits/is_polymorphic.hpp>
+
+#include <boost/serialization/assume_abstract.hpp>
+
+#if !defined(BOOST_MSVC) && \
+ (BOOST_WORKAROUND(__IBMCPP__, < 1210) || \
+ defined(__SUNPRO_CC) && (__SUNPRO_CC < 0x590))
+ #define DONT_USE_HAS_NEW_OPERATOR 1
+#else
+ #define DONT_USE_HAS_NEW_OPERATOR 0
+#endif
+
+#if ! DONT_USE_HAS_NEW_OPERATOR
+#include <boost/type_traits/has_new_operator.hpp>
+#endif
+
+#include <boost/serialization/serialization.hpp>
+#include <boost/serialization/version.hpp>
+#include <boost/serialization/level.hpp>
+#include <boost/serialization/tracking.hpp>
+#include <boost/serialization/type_info_implementation.hpp>
+#include <boost/serialization/nvp.hpp>
+#include <boost/serialization/void_cast.hpp>
+#include <boost/serialization/collection_size_type.hpp>
+#include <boost/serialization/singleton.hpp>
+#include <boost/serialization/wrapper.hpp>
+#include <boost/serialization/array_wrapper.hpp>
+
+// the following is need only for dynamic cast of polymorphic pointers
+#include <boost/archive/archive_exception.hpp>
+#include <boost/archive/detail/basic_iarchive.hpp>
+#include <boost/archive/detail/basic_iserializer.hpp>
+#include <boost/archive/detail/basic_pointer_iserializer.hpp>
+#include <boost/archive/detail/archive_serializer_map.hpp>
+#include <boost/archive/detail/check.hpp>
+
+#include <boost/core/addressof.hpp>
+
+namespace boost {
+
+namespace serialization {
+ class extended_type_info;
+} // namespace serialization
+
+namespace archive {
+
+// an accessor to permit friend access to archives. Needed because
+// some compilers don't handle friend templates completely
+class load_access {
+public:
+ template<class Archive, class T>
+ static void load_primitive(Archive &ar, T &t){
+ ar.load(t);
+ }
+};
+
+namespace detail {
+
+#ifdef BOOST_MSVC
+# pragma warning(push)
+# pragma warning(disable : 4511 4512)
+#endif
+
+template<class Archive, class T>
+class iserializer : public basic_iserializer
+{
+private:
+ virtual void destroy(/*const*/ void *address) const {
+ boost::serialization::access::destroy(static_cast<T *>(address));
+ }
+protected:
+ // protected constructor since it's always created by singleton
+ explicit iserializer() :
+ basic_iserializer(
+ boost::serialization::singleton<
+ typename
+ boost::serialization::type_info_implementation< T >::type
+ >::get_const_instance()
+ )
+ {}
+public:
+ virtual BOOST_DLLEXPORT void load_object_data(
+ basic_iarchive & ar,
+ void *x,
+ const unsigned int file_version
+ ) const BOOST_USED;
+ virtual bool class_info() const {
+ return boost::serialization::implementation_level< T >::value
+ >= boost::serialization::object_class_info;
+ }
+ virtual bool tracking(const unsigned int /* flags */) const {
+ return boost::serialization::tracking_level< T >::value
+ == boost::serialization::track_always
+ || ( boost::serialization::tracking_level< T >::value
+ == boost::serialization::track_selectively
+ && serialized_as_pointer());
+ }
+ virtual version_type version() const {
+ return version_type(::boost::serialization::version< T >::value);
+ }
+ virtual bool is_polymorphic() const {
+ return boost::is_polymorphic< T >::value;
+ }
+ virtual ~iserializer(){};
+};
+
+#ifdef BOOST_MSVC
+# pragma warning(pop)
+#endif
+
+template<class Archive, class T>
+BOOST_DLLEXPORT void iserializer<Archive, T>::load_object_data(
+ basic_iarchive & ar,
+ void *x,
+ const unsigned int file_version
+) const {
+ // note: we now comment this out. Before we permited archive
+ // version # to be very large. Now we don't. To permit
+ // readers of these old archives, we have to suppress this
+ // code. Perhaps in the future we might re-enable it but
+ // permit its suppression with a runtime switch.
+ #if 0
+ // trap case where the program cannot handle the current version
+ if(file_version > static_cast<const unsigned int>(version()))
+ boost::serialization::throw_exception(
+ archive::archive_exception(
+ boost::archive::archive_exception::unsupported_class_version,
+ get_debug_info()
+ )
+ );
+ #endif
+ // make sure call is routed through the higest interface that might
+ // be specialized by the user.
+ boost::serialization::serialize_adl(
+ boost::serialization::smart_cast_reference<Archive &>(ar),
+ * static_cast<T *>(x),
+ file_version
+ );
+}
+
+#ifdef BOOST_MSVC
+# pragma warning(push)
+# pragma warning(disable : 4511 4512)
+#endif
+
+// the purpose of this code is to allocate memory for an object
+// without requiring the constructor to be called. Presumably
+// the allocated object will be subsequently initialized with
+// "placement new".
+// note: we have the boost type trait has_new_operator but we
+// have no corresponding has_delete_operator. So we presume
+// that the former being true would imply that the a delete
+// operator is also defined for the class T.
+
+template<class T>
+struct heap_allocation {
+ // boost::has_new_operator< T > doesn't work on these compilers
+ #if DONT_USE_HAS_NEW_OPERATOR
+ // This doesn't handle operator new overload for class T
+ static T * invoke_new(){
+ return static_cast<T *>(operator new(sizeof(T)));
+ }
+ static void invoke_delete(T *t){
+ (operator delete(t));
+ }
+ #else
+ // note: we presume that a true value for has_new_operator
+ // implies the existence of a class specific delete operator as well
+ // as a class specific new operator.
+ struct has_new_operator {
+ static T * invoke_new() {
+ return static_cast<T *>((T::operator new)(sizeof(T)));
+ }
+ static void invoke_delete(T * t) {
+ // if compilation fails here, the likely cause that the class
+ // T has a class specific new operator but no class specific
+ // delete operator which matches the following signature.
+ // note that this solution addresses the issue that two
+ // possible signatures. But it doesn't address the possibility
+ // that the class might have class specific new with NO
+ // class specific delete at all. Patches (compatible with
+ // C++03) welcome!
+ (operator delete)(t);
+ }
+ };
+ struct doesnt_have_new_operator {
+ static T* invoke_new() {
+ return static_cast<T *>(operator new(sizeof(T)));
+ }
+ static void invoke_delete(T * t) {
+ // Note: I'm reliance upon automatic conversion from T * to void * here
+ (operator delete)(t);
+ }
+ };
+ static T * invoke_new() {
+ typedef typename
+ mpl::eval_if<
+ boost::has_new_operator< T >,
+ mpl::identity<has_new_operator >,
+ mpl::identity<doesnt_have_new_operator >
+ >::type typex;
+ return typex::invoke_new();
+ }
+ static void invoke_delete(T *t) {
+ typedef typename
+ mpl::eval_if<
+ boost::has_new_operator< T >,
+ mpl::identity<has_new_operator >,
+ mpl::identity<doesnt_have_new_operator >
+ >::type typex;
+ typex::invoke_delete(t);
+ }
+ #endif
+ explicit heap_allocation(){
+ m_p = invoke_new();
+ }
+ ~heap_allocation(){
+ if (0 != m_p)
+ invoke_delete(m_p);
+ }
+ T* get() const {
+ return m_p;
+ }
+
+ T* release() {
+ T* p = m_p;
+ m_p = 0;
+ return p;
+ }
+private:
+ T* m_p;
+};
+
+template<class Archive, class T>
+class pointer_iserializer :
+ public basic_pointer_iserializer
+{
+private:
+ virtual void * heap_allocation() const {
+ detail::heap_allocation<T> h;
+ T * t = h.get();
+ h.release();
+ return t;
+ }
+ virtual const basic_iserializer & get_basic_serializer() const {
+ return boost::serialization::singleton<
+ iserializer<Archive, T>
+ >::get_const_instance();
+ }
+ BOOST_DLLEXPORT virtual void load_object_ptr(
+ basic_iarchive & ar,
+ void * x,
+ const unsigned int file_version
+ ) const BOOST_USED;
+protected:
+ // this should alway be a singleton so make the constructor protected
+ pointer_iserializer();
+ ~pointer_iserializer();
+};
+
+#ifdef BOOST_MSVC
+# pragma warning(pop)
+#endif
+
+// note: BOOST_DLLEXPORT is so that code for polymorphic class
+// serialized only through base class won't get optimized out
+template<class Archive, class T>
+BOOST_DLLEXPORT void pointer_iserializer<Archive, T>::load_object_ptr(
+ basic_iarchive & ar,
+ void * t,
+ const unsigned int file_version
+) const
+{
+ Archive & ar_impl =
+ boost::serialization::smart_cast_reference<Archive &>(ar);
+
+ // note that the above will throw std::bad_alloc if the allocation
+ // fails so we don't have to address this contingency here.
+
+ // catch exception during load_construct_data so that we don't
+ // automatically delete the t which is most likely not fully
+ // constructed
+ BOOST_TRY {
+ // this addresses an obscure situation that occurs when
+ // load_constructor de-serializes something through a pointer.
+ ar.next_object_pointer(t);
+ boost::serialization::load_construct_data_adl<Archive, T>(
+ ar_impl,
+ static_cast<T *>(t),
+ file_version
+ );
+ }
+ BOOST_CATCH(...){
+ // if we get here the load_construct failed. The heap_allocation
+ // will be automatically deleted so we don't have to do anything
+ // special here.
+ BOOST_RETHROW;
+ }
+ BOOST_CATCH_END
+
+ ar_impl >> boost::serialization::make_nvp(NULL, * static_cast<T *>(t));
+}
+
+template<class Archive, class T>
+pointer_iserializer<Archive, T>::pointer_iserializer() :
+ basic_pointer_iserializer(
+ boost::serialization::singleton<
+ typename
+ boost::serialization::type_info_implementation< T >::type
+ >::get_const_instance()
+ )
+{
+ boost::serialization::singleton<
+ iserializer<Archive, T>
+ >::get_mutable_instance().set_bpis(this);
+ archive_serializer_map<Archive>::insert(this);
+}
+
+template<class Archive, class T>
+pointer_iserializer<Archive, T>::~pointer_iserializer(){
+ archive_serializer_map<Archive>::erase(this);
+}
+
+template<class Archive>
+struct load_non_pointer_type {
+ // note this bounces the call right back to the archive
+ // with no runtime overhead
+ struct load_primitive {
+ template<class T>
+ static void invoke(Archive & ar, T & t){
+ load_access::load_primitive(ar, t);
+ }
+ };
+ // note this bounces the call right back to the archive
+ // with no runtime overhead
+ struct load_only {
+ template<class T>
+ static void invoke(Archive & ar, const T & t){
+ // short cut to user's serializer
+ // make sure call is routed through the higest interface that might
+ // be specialized by the user.
+ boost::serialization::serialize_adl(
+ ar,
+ const_cast<T &>(t),
+ boost::serialization::version< T >::value
+ );
+ }
+ };
+
+ // note this save class information including version
+ // and serialization level to the archive
+ struct load_standard {
+ template<class T>
+ static void invoke(Archive &ar, const T & t){
+ void * x = boost::addressof(const_cast<T &>(t));
+ ar.load_object(
+ x,
+ boost::serialization::singleton<
+ iserializer<Archive, T>
+ >::get_const_instance()
+ );
+ }
+ };
+
+ struct load_conditional {
+ template<class T>
+ static void invoke(Archive &ar, T &t){
+ //if(0 == (ar.get_flags() & no_tracking))
+ load_standard::invoke(ar, t);
+ //else
+ // load_only::invoke(ar, t);
+ }
+ };
+
+ template<class T>
+ static void invoke(Archive & ar, T &t){
+ typedef typename mpl::eval_if<
+ // if its primitive
+ mpl::equal_to<
+ boost::serialization::implementation_level< T >,
+ mpl::int_<boost::serialization::primitive_type>
+ >,
+ mpl::identity<load_primitive>,
+ // else
+ typename mpl::eval_if<
+ // class info / version
+ mpl::greater_equal<
+ boost::serialization::implementation_level< T >,
+ mpl::int_<boost::serialization::object_class_info>
+ >,
+ // do standard load
+ mpl::identity<load_standard>,
+ // else
+ typename mpl::eval_if<
+ // no tracking
+ mpl::equal_to<
+ boost::serialization::tracking_level< T >,
+ mpl::int_<boost::serialization::track_never>
+ >,
+ // do a fast load
+ mpl::identity<load_only>,
+ // else
+ // do a fast load only tracking is turned off
+ mpl::identity<load_conditional>
+ > > >::type typex;
+ check_object_versioning< T >();
+ check_object_level< T >();
+ typex::invoke(ar, t);
+ }
+};
+
+template<class Archive>
+struct load_pointer_type {
+ struct abstract
+ {
+ template<class T>
+ static const basic_pointer_iserializer * register_type(Archive & /* ar */){
+ // it has? to be polymorphic
+ BOOST_STATIC_ASSERT(boost::is_polymorphic< T >::value);
+ return static_cast<basic_pointer_iserializer *>(NULL);
+ }
+ };
+
+ struct non_abstract
+ {
+ template<class T>
+ static const basic_pointer_iserializer * register_type(Archive & ar){
+ return ar.register_type(static_cast<T *>(NULL));
+ }
+ };
+
+ template<class T>
+ static const basic_pointer_iserializer * register_type(Archive &ar, const T* const /*t*/){
+ // there should never be any need to load an abstract polymorphic
+ // class pointer. Inhibiting code generation for this
+ // permits abstract base classes to be used - note: exception
+ // virtual serialize functions used for plug-ins
+ typedef typename
+ mpl::eval_if<
+ boost::serialization::is_abstract<const T>,
+ boost::mpl::identity<abstract>,
+ boost::mpl::identity<non_abstract>
+ >::type typex;
+ return typex::template register_type< T >(ar);
+ }
+
+ template<class T>
+ static T * pointer_tweak(
+ const boost::serialization::extended_type_info & eti,
+ void const * const t,
+ const T &
+ ) {
+ // tweak the pointer back to the base class
+ void * upcast = const_cast<void *>(
+ boost::serialization::void_upcast(
+ eti,
+ boost::serialization::singleton<
+ typename
+ boost::serialization::type_info_implementation< T >::type
+ >::get_const_instance(),
+ t
+ )
+ );
+ if(NULL == upcast)
+ boost::serialization::throw_exception(
+ archive_exception(archive_exception::unregistered_class)
+ );
+ return static_cast<T *>(upcast);
+ }
+
+ template<class T>
+ static void check_load(T * const /* t */){
+ check_pointer_level< T >();
+ check_pointer_tracking< T >();
+ }
+
+ static const basic_pointer_iserializer *
+ find(const boost::serialization::extended_type_info & type){
+ return static_cast<const basic_pointer_iserializer *>(
+ archive_serializer_map<Archive>::find(type)
+ );
+ }
+
+ template<class Tptr>
+ static void invoke(Archive & ar, Tptr & t){
+ check_load(t);
+ const basic_pointer_iserializer * bpis_ptr = register_type(ar, t);
+ const basic_pointer_iserializer * newbpis_ptr = ar.load_pointer(
+ // note major hack here !!!
+ // I tried every way to convert Tptr &t (where Tptr might
+ // include const) to void * &. This is the only way
+ // I could make it work. RR
+ (void * & )t,
+ bpis_ptr,
+ find
+ );
+ // if the pointer isn't that of the base class
+ if(newbpis_ptr != bpis_ptr){
+ t = pointer_tweak(newbpis_ptr->get_eti(), t, *t);
+ }
+ }
+};
+
+template<class Archive>
+struct load_enum_type {
+ template<class T>
+ static void invoke(Archive &ar, T &t){
+ // convert integers to correct enum to load
+ int i;
+ ar >> boost::serialization::make_nvp(NULL, i);
+ t = static_cast< T >(i);
+ }
+};
+
+template<class Archive>
+struct load_array_type {
+ template<class T>
+ static void invoke(Archive &ar, T &t){
+ typedef typename remove_extent< T >::type value_type;
+
+ // convert integers to correct enum to load
+ // determine number of elements in the array. Consider the
+ // fact that some machines will align elements on boundries
+ // other than characters.
+ std::size_t current_count = sizeof(t) / (
+ static_cast<char *>(static_cast<void *>(&t[1]))
+ - static_cast<char *>(static_cast<void *>(&t[0]))
+ );
+ boost::serialization::collection_size_type count;
+ ar >> BOOST_SERIALIZATION_NVP(count);
+ if(static_cast<std::size_t>(count) > current_count)
+ boost::serialization::throw_exception(
+ archive::archive_exception(
+ boost::archive::archive_exception::array_size_too_short
+ )
+ );
+ // explict template arguments to pass intel C++ compiler
+ ar >> serialization::make_array<
+ value_type,
+ boost::serialization::collection_size_type
+ >(
+ static_cast<value_type *>(&t[0]),
+ count
+ );
+ }
+};
+
+} // detail
+
+template<class Archive, class T>
+inline void load(Archive & ar, T &t){
+ // if this assertion trips. It means we're trying to load a
+ // const object with a compiler that doesn't have correct
+ // function template ordering. On other compilers, this is
+ // handled below.
+ detail::check_const_loading< T >();
+ typedef
+ typename mpl::eval_if<is_pointer< T >,
+ mpl::identity<detail::load_pointer_type<Archive> >
+ ,//else
+ typename mpl::eval_if<is_array< T >,
+ mpl::identity<detail::load_array_type<Archive> >
+ ,//else
+ typename mpl::eval_if<is_enum< T >,
+ mpl::identity<detail::load_enum_type<Archive> >
+ ,//else
+ mpl::identity<detail::load_non_pointer_type<Archive> >
+ >
+ >
+ >::type typex;
+ typex::invoke(ar, t);
+}
+
+} // namespace archive
+} // namespace boost
+
+#endif // BOOST_ARCHIVE_DETAIL_ISERIALIZER_HPP
diff --git a/include/boost/archive/detail/oserializer.hpp b/include/boost/archive/detail/oserializer.hpp
new file mode 100644
index 0000000..612e1f2
--- /dev/null
+++ b/include/boost/archive/detail/oserializer.hpp
@@ -0,0 +1,545 @@
+#ifndef BOOST_ARCHIVE_OSERIALIZER_HPP
+#define BOOST_ARCHIVE_OSERIALIZER_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER)
+# pragma once
+#pragma inline_depth(511)
+#pragma inline_recursion(on)
+#endif
+
+#if defined(__MWERKS__)
+#pragma inline_depth(511)
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// oserializer.hpp: interface for serialization system.
+
+// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
+// Use, modification and distribution is subject to the Boost Software
+// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+
+// See http://www.boost.org for updates, documentation, and revision history.
+
+#include <boost/assert.hpp>
+#include <cstddef> // NULL
+
+#include <boost/config.hpp>
+
+#include <boost/static_assert.hpp>
+#include <boost/detail/workaround.hpp>
+
+#include <boost/mpl/eval_if.hpp>
+#include <boost/mpl/equal_to.hpp>
+#include <boost/mpl/greater_equal.hpp>
+#include <boost/mpl/identity.hpp>
+#include <boost/mpl/bool_fwd.hpp>
+
+#ifndef BOOST_SERIALIZATION_DEFAULT_TYPE_INFO
+ #include <boost/serialization/extended_type_info_typeid.hpp>
+#endif
+#include <boost/serialization/throw_exception.hpp>
+#include <boost/serialization/smart_cast.hpp>
+#include <boost/serialization/assume_abstract.hpp>
+#include <boost/serialization/static_warning.hpp>
+
+#include <boost/type_traits/is_pointer.hpp>
+#include <boost/type_traits/is_enum.hpp>
+#include <boost/type_traits/is_const.hpp>
+#include <boost/type_traits/is_polymorphic.hpp>
+#include <boost/type_traits/remove_extent.hpp>
+
+#include <boost/serialization/serialization.hpp>
+#include <boost/serialization/version.hpp>
+#include <boost/serialization/level.hpp>
+#include <boost/serialization/tracking.hpp>
+#include <boost/serialization/type_info_implementation.hpp>
+#include <boost/serialization/nvp.hpp>
+#include <boost/serialization/void_cast.hpp>
+#include <boost/serialization/collection_size_type.hpp>
+#include <boost/serialization/array_wrapper.hpp>
+
+#include <boost/serialization/singleton.hpp>
+
+#include <boost/archive/archive_exception.hpp>
+#include <boost/archive/detail/basic_oarchive.hpp>
+#include <boost/archive/detail/basic_oserializer.hpp>
+#include <boost/archive/detail/basic_pointer_oserializer.hpp>
+#include <boost/archive/detail/archive_serializer_map.hpp>
+#include <boost/archive/detail/check.hpp>
+
+#include <boost/core/addressof.hpp>
+
+namespace boost {
+
+namespace serialization {
+ class extended_type_info;
+} // namespace serialization
+
+namespace archive {
+
+// an accessor to permit friend access to archives. Needed because
+// some compilers don't handle friend templates completely
+class save_access {
+public:
+ template<class Archive>
+ static void end_preamble(Archive & ar){
+ ar.end_preamble();
+ }
+ template<class Archive, class T>
+ static void save_primitive(Archive & ar, const T & t){
+ ar.end_preamble();
+ ar.save(t);
+ }
+};
+
+namespace detail {
+
+#ifdef BOOST_MSVC
+# pragma warning(push)
+# pragma warning(disable : 4511 4512)
+#endif
+
+template<class Archive, class T>
+class oserializer : public basic_oserializer
+{
+private:
+ // private constructor to inhibit any existence other than the
+ // static one
+public:
+ explicit BOOST_DLLEXPORT oserializer() :
+ basic_oserializer(
+ boost::serialization::singleton<
+ typename
+ boost::serialization::type_info_implementation< T >::type
+ >::get_const_instance()
+ )
+ {}
+ virtual BOOST_DLLEXPORT void save_object_data(
+ basic_oarchive & ar,
+ const void *x
+ ) const BOOST_USED;
+ virtual bool class_info() const {
+ return boost::serialization::implementation_level< T >::value
+ >= boost::serialization::object_class_info;
+ }
+ virtual bool tracking(const unsigned int /* flags */) const {
+ return boost::serialization::tracking_level< T >::value == boost::serialization::track_always
+ || (boost::serialization::tracking_level< T >::value == boost::serialization::track_selectively
+ && serialized_as_pointer());
+ }
+ virtual version_type version() const {
+ return version_type(::boost::serialization::version< T >::value);
+ }
+ virtual bool is_polymorphic() const {
+ return boost::is_polymorphic< T >::value;
+ }
+ virtual ~oserializer(){}
+};
+
+#ifdef BOOST_MSVC
+# pragma warning(pop)
+#endif
+
+template<class Archive, class T>
+BOOST_DLLEXPORT void oserializer<Archive, T>::save_object_data(
+ basic_oarchive & ar,
+ const void *x
+) const {
+ // make sure call is routed through the highest interface that might
+ // be specialized by the user.
+ BOOST_STATIC_ASSERT(boost::is_const< T >::value == false);
+ boost::serialization::serialize_adl(
+ boost::serialization::smart_cast_reference<Archive &>(ar),
+ * static_cast<T *>(const_cast<void *>(x)),
+ version()
+ );
+}
+
+#ifdef BOOST_MSVC
+# pragma warning(push)
+# pragma warning(disable : 4511 4512)
+#endif
+
+template<class Archive, class T>
+class pointer_oserializer :
+ public basic_pointer_oserializer
+{
+private:
+ const basic_oserializer &
+ get_basic_serializer() const {
+ return boost::serialization::singleton<
+ oserializer<Archive, T>
+ >::get_const_instance();
+ }
+ virtual BOOST_DLLEXPORT void save_object_ptr(
+ basic_oarchive & ar,
+ const void * x
+ ) const BOOST_USED;
+public:
+ pointer_oserializer();
+ ~pointer_oserializer();
+};
+
+#ifdef BOOST_MSVC
+# pragma warning(pop)
+#endif
+
+template<class Archive, class T>
+BOOST_DLLEXPORT void pointer_oserializer<Archive, T>::save_object_ptr(
+ basic_oarchive & ar,
+ const void * x
+) const {
+ BOOST_ASSERT(NULL != x);
+ // make sure call is routed through the highest interface that might
+ // be specialized by the user.
+ T * t = static_cast<T *>(const_cast<void *>(x));
+ const unsigned int file_version = boost::serialization::version< T >::value;
+ Archive & ar_impl
+ = boost::serialization::smart_cast_reference<Archive &>(ar);
+ boost::serialization::save_construct_data_adl<Archive, T>(
+ ar_impl,
+ t,
+ file_version
+ );
+ ar_impl << boost::serialization::make_nvp(NULL, * t);
+}
+
+template<class Archive, class T>
+pointer_oserializer<Archive, T>::pointer_oserializer() :
+ basic_pointer_oserializer(
+ boost::serialization::singleton<
+ typename
+ boost::serialization::type_info_implementation< T >::type
+ >::get_const_instance()
+ )
+{
+ // make sure appropriate member function is instantiated
+ boost::serialization::singleton<
+ oserializer<Archive, T>
+ >::get_mutable_instance().set_bpos(this);
+ archive_serializer_map<Archive>::insert(this);
+}
+
+template<class Archive, class T>
+pointer_oserializer<Archive, T>::~pointer_oserializer(){
+ archive_serializer_map<Archive>::erase(this);
+}
+
+template<class Archive>
+struct save_non_pointer_type {
+ // note this bounces the call right back to the archive
+ // with no runtime overhead
+ struct save_primitive {
+ template<class T>
+ static void invoke(Archive & ar, const T & t){
+ save_access::save_primitive(ar, t);
+ }
+ };
+ // same as above but passes through serialization
+ struct save_only {
+ template<class T>
+ static void invoke(Archive & ar, const T & t){
+ // make sure call is routed through the highest interface that might
+ // be specialized by the user.
+ boost::serialization::serialize_adl(
+ ar,
+ const_cast<T &>(t),
+ ::boost::serialization::version< T >::value
+ );
+ }
+ };
+ // adds class information to the archive. This includes
+ // serialization level and class version
+ struct save_standard {
+ template<class T>
+ static void invoke(Archive &ar, const T & t){
+ ar.save_object(
+ boost::addressof(t),
+ boost::serialization::singleton<
+ oserializer<Archive, T>
+ >::get_const_instance()
+ );
+ }
+ };
+
+
+
+ // adds class information to the archive. This includes
+ // serialization level and class version
+ struct save_conditional {
+ template<class T>
+ static void invoke(Archive &ar, const T &t){
+ //if(0 == (ar.get_flags() & no_tracking))
+ save_standard::invoke(ar, t);
+ //else
+ // save_only::invoke(ar, t);
+ }
+ };
+
+
+ template<class T>
+ static void invoke(Archive & ar, const T & t){
+ typedef
+ typename mpl::eval_if<
+ // if its primitive
+ mpl::equal_to<
+ boost::serialization::implementation_level< T >,
+ mpl::int_<boost::serialization::primitive_type>
+ >,
+ mpl::identity<save_primitive>,
+ // else
+ typename mpl::eval_if<
+ // class info / version
+ mpl::greater_equal<
+ boost::serialization::implementation_level< T >,
+ mpl::int_<boost::serialization::object_class_info>
+ >,
+ // do standard save
+ mpl::identity<save_standard>,
+ // else
+ typename mpl::eval_if<
+ // no tracking
+ mpl::equal_to<
+ boost::serialization::tracking_level< T >,
+ mpl::int_<boost::serialization::track_never>
+ >,
+ // do a fast save
+ mpl::identity<save_only>,
+ // else
+ // do a fast save only tracking is turned off
+ mpl::identity<save_conditional>
+ > > >::type typex;
+ check_object_versioning< T >();
+ typex::invoke(ar, t);
+ }
+ template<class T>
+ static void invoke(Archive & ar, T & t){
+ check_object_level< T >();
+ check_object_tracking< T >();
+ invoke(ar, const_cast<const T &>(t));
+ }
+};
+
+template<class Archive>
+struct save_pointer_type {
+ struct abstract
+ {
+ template<class T>
+ static const basic_pointer_oserializer * register_type(Archive & /* ar */){
+ // it has? to be polymorphic
+ BOOST_STATIC_ASSERT(boost::is_polymorphic< T >::value);
+ return NULL;
+ }
+ };
+
+ struct non_abstract
+ {
+ template<class T>
+ static const basic_pointer_oserializer * register_type(Archive & ar){
+ return ar.register_type(static_cast<T *>(NULL));
+ }
+ };
+
+ template<class T>
+ static const basic_pointer_oserializer * register_type(Archive &ar, T* const /*t*/){
+ // there should never be any need to save an abstract polymorphic
+ // class pointer. Inhibiting code generation for this
+ // permits abstract base classes to be used - note: exception
+ // virtual serialize functions used for plug-ins
+ typedef
+ typename mpl::eval_if<
+ boost::serialization::is_abstract< T >,
+ mpl::identity<abstract>,
+ mpl::identity<non_abstract>
+ >::type typex;
+ return typex::template register_type< T >(ar);
+ }
+
+ struct non_polymorphic
+ {
+ template<class T>
+ static void save(
+ Archive &ar,
+ T & t
+ ){
+ const basic_pointer_oserializer & bpos =
+ boost::serialization::singleton<
+ pointer_oserializer<Archive, T>
+ >::get_const_instance();
+ // save the requested pointer type
+ ar.save_pointer(& t, & bpos);
+ }
+ };
+
+ struct polymorphic
+ {
+ template<class T>
+ static void save(
+ Archive &ar,
+ T & t
+ ){
+ typename
+ boost::serialization::type_info_implementation< T >::type const
+ & i = boost::serialization::singleton<
+ typename
+ boost::serialization::type_info_implementation< T >::type
+ >::get_const_instance();
+
+ boost::serialization::extended_type_info const * const this_type = & i;
+
+ // retrieve the true type of the object pointed to
+ // if this assertion fails its an error in this library
+ BOOST_ASSERT(NULL != this_type);
+
+ const boost::serialization::extended_type_info * true_type =
+ i.get_derived_extended_type_info(t);
+
+ // note:if this exception is thrown, be sure that derived pointer
+ // is either registered or exported.
+ if(NULL == true_type){
+ boost::serialization::throw_exception(
+ archive_exception(
+ archive_exception::unregistered_class,
+ "derived class not registered or exported"
+ )
+ );
+ }
+
+ // if its not a pointer to a more derived type
+ const void *vp = static_cast<const void *>(&t);
+ if(*this_type == *true_type){
+ const basic_pointer_oserializer * bpos = register_type(ar, &t);
+ ar.save_pointer(vp, bpos);
+ return;
+ }
+ // convert pointer to more derived type. if this is thrown
+ // it means that the base/derived relationship hasn't be registered
+ vp = serialization::void_downcast(
+ *true_type,
+ *this_type,
+ static_cast<const void *>(&t)
+ );
+ if(NULL == vp){
+ boost::serialization::throw_exception(
+ archive_exception(
+ archive_exception::unregistered_cast,
+ true_type->get_debug_info(),
+ this_type->get_debug_info()
+ )
+ );
+ }
+
+ // since true_type is valid, and this only gets made if the
+ // pointer oserializer object has been created, this should never
+ // fail
+ const basic_pointer_oserializer * bpos
+ = static_cast<const basic_pointer_oserializer *>(
+ boost::serialization::singleton<
+ archive_serializer_map<Archive>
+ >::get_const_instance().find(*true_type)
+ );
+ BOOST_ASSERT(NULL != bpos);
+ if(NULL == bpos)
+ boost::serialization::throw_exception(
+ archive_exception(
+ archive_exception::unregistered_class,
+ "derived class not registered or exported"
+ )
+ );
+ ar.save_pointer(vp, bpos);
+ }
+ };
+
+ template<class T>
+ static void save(
+ Archive & ar,
+ const T & t
+ ){
+ check_pointer_level< T >();
+ check_pointer_tracking< T >();
+ typedef typename mpl::eval_if<
+ is_polymorphic< T >,
+ mpl::identity<polymorphic>,
+ mpl::identity<non_polymorphic>
+ >::type type;
+ type::save(ar, const_cast<T &>(t));
+ }
+
+ template<class TPtr>
+ static void invoke(Archive &ar, const TPtr t){
+ register_type(ar, t);
+ if(NULL == t){
+ basic_oarchive & boa
+ = boost::serialization::smart_cast_reference<basic_oarchive &>(ar);
+ boa.save_null_pointer();
+ save_access::end_preamble(ar);
+ return;
+ }
+ save(ar, * t);
+ }
+};
+
+template<class Archive>
+struct save_enum_type
+{
+ template<class T>
+ static void invoke(Archive &ar, const T &t){
+ // convert enum to integers on save
+ const int i = static_cast<int>(t);
+ ar << boost::serialization::make_nvp(NULL, i);
+ }
+};
+
+template<class Archive>
+struct save_array_type
+{
+ template<class T>
+ static void invoke(Archive &ar, const T &t){
+ typedef typename boost::remove_extent< T >::type value_type;
+
+ save_access::end_preamble(ar);
+ // consider alignment
+ std::size_t c = sizeof(t) / (
+ static_cast<const char *>(static_cast<const void *>(&t[1]))
+ - static_cast<const char *>(static_cast<const void *>(&t[0]))
+ );
+ boost::serialization::collection_size_type count(c);
+ ar << BOOST_SERIALIZATION_NVP(count);
+ // explict template arguments to pass intel C++ compiler
+ ar << serialization::make_array<
+ const value_type,
+ boost::serialization::collection_size_type
+ >(
+ static_cast<const value_type *>(&t[0]),
+ count
+ );
+ }
+};
+
+} // detail
+
+template<class Archive, class T>
+inline void save(Archive & ar, /*const*/ T &t){
+ typedef
+ typename mpl::eval_if<is_pointer< T >,
+ mpl::identity<detail::save_pointer_type<Archive> >,
+ //else
+ typename mpl::eval_if<is_enum< T >,
+ mpl::identity<detail::save_enum_type<Archive> >,
+ //else
+ typename mpl::eval_if<is_array< T >,
+ mpl::identity<detail::save_array_type<Archive> >,
+ //else
+ mpl::identity<detail::save_non_pointer_type<Archive> >
+ >
+ >
+ >::type typex;
+ typex::invoke(ar, t);
+}
+
+} // namespace archive
+} // namespace boost
+
+#endif // BOOST_ARCHIVE_OSERIALIZER_HPP
diff --git a/include/boost/archive/detail/polymorphic_iarchive_route.hpp b/include/boost/archive/detail/polymorphic_iarchive_route.hpp
new file mode 100644
index 0000000..105685e
--- /dev/null
+++ b/include/boost/archive/detail/polymorphic_iarchive_route.hpp
@@ -0,0 +1,218 @@
+#ifndef BOOST_ARCHIVE_DETAIL_POLYMORPHIC_IARCHIVE_ROUTE_HPP
+#define BOOST_ARCHIVE_DETAIL_POLYMORPHIC_IARCHIVE_ROUTE_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER)
+# pragma once
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// polymorphic_iarchive_route.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 <string>
+#include <ostream>
+#include <cstddef>
+
+#include <boost/config.hpp>
+#if defined(BOOST_NO_STDC_NAMESPACE)
+namespace std{
+ using ::size_t;
+} // namespace std
+#endif
+
+#include <boost/cstdint.hpp>
+#include <boost/integer_traits.hpp>
+#include <boost/archive/polymorphic_iarchive.hpp>
+#include <boost/archive/detail/abi_prefix.hpp> // must be the last header
+
+namespace boost {
+namespace serialization {
+ class extended_type_info;
+} // namespace serialization
+namespace archive {
+namespace detail{
+
+class basic_iserializer;
+class basic_pointer_iserializer;
+
+#ifdef BOOST_MSVC
+# pragma warning(push)
+# pragma warning(disable : 4511 4512)
+#endif
+
+template<class ArchiveImplementation>
+class polymorphic_iarchive_route :
+ public polymorphic_iarchive,
+ // note: gcc dynamic cross cast fails if the the derivation below is
+ // not public. I think this is a mistake.
+ public /*protected*/ ArchiveImplementation
+{
+private:
+ // these are used by the serialization library.
+ virtual void load_object(
+ void *t,
+ const basic_iserializer & bis
+ ){
+ ArchiveImplementation::load_object(t, bis);
+ }
+ virtual const basic_pointer_iserializer * load_pointer(
+ void * & t,
+ const basic_pointer_iserializer * bpis_ptr,
+ const basic_pointer_iserializer * (*finder)(
+ const boost::serialization::extended_type_info & type
+ )
+ ){
+ return ArchiveImplementation::load_pointer(t, bpis_ptr, finder);
+ }
+ virtual void set_library_version(library_version_type archive_library_version){
+ ArchiveImplementation::set_library_version(archive_library_version);
+ }
+ virtual library_version_type get_library_version() const{
+ return ArchiveImplementation::get_library_version();
+ }
+ virtual unsigned int get_flags() const {
+ return ArchiveImplementation::get_flags();
+ }
+ virtual void delete_created_pointers(){
+ ArchiveImplementation::delete_created_pointers();
+ }
+ virtual void reset_object_address(
+ const void * new_address,
+ const void * old_address
+ ){
+ ArchiveImplementation::reset_object_address(new_address, old_address);
+ }
+ virtual void load_binary(void * t, std::size_t size){
+ ArchiveImplementation::load_binary(t, size);
+ }
+ // primitive types the only ones permitted by polymorphic archives
+ virtual void load(bool & t){
+ ArchiveImplementation::load(t);
+ }
+ virtual void load(char & t){
+ ArchiveImplementation::load(t);
+ }
+ virtual void load(signed char & t){
+ ArchiveImplementation::load(t);
+ }
+ virtual void load(unsigned char & t){
+ ArchiveImplementation::load(t);
+ }
+ #ifndef BOOST_NO_CWCHAR
+ #ifndef BOOST_NO_INTRINSIC_WCHAR_T
+ virtual void load(wchar_t & t){
+ ArchiveImplementation::load(t);
+ }
+ #endif
+ #endif
+ virtual void load(short & t){
+ ArchiveImplementation::load(t);
+ }
+ virtual void load(unsigned short & t){
+ ArchiveImplementation::load(t);
+ }
+ virtual void load(int & t){
+ ArchiveImplementation::load(t);
+ }
+ virtual void load(unsigned int & t){
+ ArchiveImplementation::load(t);
+ }
+ virtual void load(long & t){
+ ArchiveImplementation::load(t);
+ }
+ virtual void load(unsigned long & t){
+ ArchiveImplementation::load(t);
+ }
+ #if defined(BOOST_HAS_LONG_LONG)
+ virtual void load(boost::long_long_type & t){
+ ArchiveImplementation::load(t);
+ }
+ virtual void load(boost::ulong_long_type & t){
+ ArchiveImplementation::load(t);
+ }
+ #elif defined(BOOST_HAS_MS_INT64)
+ virtual void load(__int64 & t){
+ ArchiveImplementation::load(t);
+ }
+ virtual void load(unsigned __int64 & t){
+ ArchiveImplementation::load(t);
+ }
+ #endif
+ virtual void load(float & t){
+ ArchiveImplementation::load(t);
+ }
+ virtual void load(double & t){
+ ArchiveImplementation::load(t);
+ }
+ virtual void load(std::string & t){
+ ArchiveImplementation::load(t);
+ }
+ #ifndef BOOST_NO_STD_WSTRING
+ virtual void load(std::wstring & t){
+ ArchiveImplementation::load(t);
+ }
+ #endif
+ // used for xml and other tagged formats default does nothing
+ virtual void load_start(const char * name){
+ ArchiveImplementation::load_start(name);
+ }
+ virtual void load_end(const char * name){
+ ArchiveImplementation::load_end(name);
+ }
+ virtual void register_basic_serializer(const basic_iserializer & bis){
+ ArchiveImplementation::register_basic_serializer(bis);
+ }
+ virtual helper_collection &
+ get_helper_collection(){
+ return ArchiveImplementation::get_helper_collection();
+ }
+public:
+ // this can't be inheriteded because they appear in mulitple
+ // parents
+ typedef mpl::bool_<true> is_loading;
+ typedef mpl::bool_<false> is_saving;
+ // the >> operator
+ template<class T>
+ polymorphic_iarchive & operator>>(T & t){
+ return polymorphic_iarchive::operator>>(t);
+ }
+ // the & operator
+ template<class T>
+ polymorphic_iarchive & operator&(T & t){
+ return polymorphic_iarchive::operator&(t);
+ }
+ // register type function
+ template<class T>
+ const basic_pointer_iserializer *
+ register_type(T * t = NULL){
+ return ArchiveImplementation::register_type(t);
+ }
+ // all current archives take a stream as constructor argument
+ template <class _Elem, class _Tr>
+ polymorphic_iarchive_route(
+ std::basic_istream<_Elem, _Tr> & is,
+ unsigned int flags = 0
+ ) :
+ ArchiveImplementation(is, flags)
+ {}
+ virtual ~polymorphic_iarchive_route(){};
+};
+
+} // namespace detail
+} // namespace archive
+} // namespace boost
+
+#ifdef BOOST_MSVC
+#pragma warning(pop)
+#endif
+
+#include <boost/archive/detail/abi_suffix.hpp> // pops abi_suffix.hpp pragmas
+
+#endif // BOOST_ARCHIVE_DETAIL_POLYMORPHIC_IARCHIVE_DISPATCH_HPP
diff --git a/include/boost/archive/detail/polymorphic_oarchive_route.hpp b/include/boost/archive/detail/polymorphic_oarchive_route.hpp
new file mode 100644
index 0000000..b23fd6b
--- /dev/null
+++ b/include/boost/archive/detail/polymorphic_oarchive_route.hpp
@@ -0,0 +1,209 @@
+#ifndef BOOST_ARCHIVE_DETAIL_POLYMORPHIC_OARCHIVE_ROUTE_HPP
+#define BOOST_ARCHIVE_DETAIL_POLYMORPHIC_OARCHIVE_ROUTE_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER)
+# pragma once
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// polymorphic_oarchive_route.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 <string>
+#include <ostream>
+#include <cstddef> // size_t
+
+#include <boost/config.hpp>
+#if defined(BOOST_NO_STDC_NAMESPACE)
+namespace std{
+ using ::size_t;
+} // namespace std
+#endif
+
+#include <boost/cstdint.hpp>
+#include <boost/integer_traits.hpp>
+#include <boost/archive/polymorphic_oarchive.hpp>
+#include <boost/archive/detail/abi_prefix.hpp> // must be the last header
+
+namespace boost {
+namespace serialization {
+ class extended_type_info;
+} // namespace serialization
+namespace archive {
+namespace detail{
+
+class basic_oserializer;
+class basic_pointer_oserializer;
+
+#ifdef BOOST_MSVC
+# pragma warning(push)
+# pragma warning(disable : 4511 4512)
+#endif
+
+template<class ArchiveImplementation>
+class polymorphic_oarchive_route :
+ public polymorphic_oarchive,
+ // note: gcc dynamic cross cast fails if the the derivation below is
+ // not public. I think this is a mistake.
+ public /*protected*/ ArchiveImplementation
+{
+private:
+ // these are used by the serialization library.
+ virtual void save_object(
+ const void *x,
+ const detail::basic_oserializer & bos
+ ){
+ ArchiveImplementation::save_object(x, bos);
+ }
+ virtual void save_pointer(
+ const void * t,
+ const detail::basic_pointer_oserializer * bpos_ptr
+ ){
+ ArchiveImplementation::save_pointer(t, bpos_ptr);
+ }
+ virtual void save_null_pointer(){
+ ArchiveImplementation::save_null_pointer();
+ }
+ // primitive types the only ones permitted by polymorphic archives
+ virtual void save(const bool t){
+ ArchiveImplementation::save(t);
+ }
+ virtual void save(const char t){
+ ArchiveImplementation::save(t);
+ }
+ virtual void save(const signed char t){
+ ArchiveImplementation::save(t);
+ }
+ virtual void save(const unsigned char t){
+ ArchiveImplementation::save(t);
+ }
+ #ifndef BOOST_NO_CWCHAR
+ #ifndef BOOST_NO_INTRINSIC_WCHAR_T
+ virtual void save(const wchar_t t){
+ ArchiveImplementation::save(t);
+ }
+ #endif
+ #endif
+ virtual void save(const short t){
+ ArchiveImplementation::save(t);
+ }
+ virtual void save(const unsigned short t){
+ ArchiveImplementation::save(t);
+ }
+ virtual void save(const int t){
+ ArchiveImplementation::save(t);
+ }
+ virtual void save(const unsigned int t){
+ ArchiveImplementation::save(t);
+ }
+ virtual void save(const long t){
+ ArchiveImplementation::save(t);
+ }
+ virtual void save(const unsigned long t){
+ ArchiveImplementation::save(t);
+ }
+ #if defined(BOOST_HAS_LONG_LONG)
+ virtual void save(const boost::long_long_type t){
+ ArchiveImplementation::save(t);
+ }
+ virtual void save(const boost::ulong_long_type t){
+ ArchiveImplementation::save(t);
+ }
+ #elif defined(BOOST_HAS_MS_INT64)
+ virtual void save(const boost::int64_t t){
+ ArchiveImplementation::save(t);
+ }
+ virtual void save(const boost::uint64_t t){
+ ArchiveImplementation::save(t);
+ }
+ #endif
+ virtual void save(const float t){
+ ArchiveImplementation::save(t);
+ }
+ virtual void save(const double t){
+ ArchiveImplementation::save(t);
+ }
+ virtual void save(const std::string & t){
+ ArchiveImplementation::save(t);
+ }
+ #ifndef BOOST_NO_STD_WSTRING
+ virtual void save(const std::wstring & t){
+ ArchiveImplementation::save(t);
+ }
+ #endif
+ virtual library_version_type get_library_version() const{
+ return ArchiveImplementation::get_library_version();
+ }
+ virtual unsigned int get_flags() const {
+ return ArchiveImplementation::get_flags();
+ }
+ virtual void save_binary(const void * t, std::size_t size){
+ ArchiveImplementation::save_binary(t, size);
+ }
+ // used for xml and other tagged formats default does nothing
+ virtual void save_start(const char * name){
+ ArchiveImplementation::save_start(name);
+ }
+ virtual void save_end(const char * name){
+ ArchiveImplementation::save_end(name);
+ }
+ virtual void end_preamble(){
+ ArchiveImplementation::end_preamble();
+ }
+ virtual void register_basic_serializer(const detail::basic_oserializer & bos){
+ ArchiveImplementation::register_basic_serializer(bos);
+ }
+ virtual helper_collection &
+ get_helper_collection(){
+ return ArchiveImplementation::get_helper_collection();
+ }
+public:
+ // this can't be inheriteded because they appear in mulitple
+ // parents
+ typedef mpl::bool_<false> is_loading;
+ typedef mpl::bool_<true> is_saving;
+ // the << operator
+ template<class T>
+ polymorphic_oarchive & operator<<(T & t){
+ return polymorphic_oarchive::operator<<(t);
+ }
+ // the & operator
+ template<class T>
+ polymorphic_oarchive & operator&(T & t){
+ return polymorphic_oarchive::operator&(t);
+ }
+ // register type function
+ template<class T>
+ const basic_pointer_oserializer *
+ register_type(T * t = NULL){
+ return ArchiveImplementation::register_type(t);
+ }
+ // all current archives take a stream as constructor argument
+ template <class _Elem, class _Tr>
+ polymorphic_oarchive_route(
+ std::basic_ostream<_Elem, _Tr> & os,
+ unsigned int flags = 0
+ ) :
+ ArchiveImplementation(os, flags)
+ {}
+ virtual ~polymorphic_oarchive_route(){};
+};
+
+} // namespace detail
+} // namespace archive
+} // namespace boost
+
+#ifdef BOOST_MSVC
+#pragma warning(pop)
+#endif
+
+#include <boost/archive/detail/abi_suffix.hpp> // pops abi_suffix.hpp pragmas
+
+#endif // BOOST_ARCHIVE_DETAIL_POLYMORPHIC_OARCHIVE_DISPATCH_HPP
diff --git a/include/boost/archive/detail/register_archive.hpp b/include/boost/archive/detail/register_archive.hpp
new file mode 100644
index 0000000..5ffecc7
--- /dev/null
+++ b/include/boost/archive/detail/register_archive.hpp
@@ -0,0 +1,91 @@
+// Copyright David Abrahams 2006. 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)
+#ifndef BOOST_ARCHIVE_DETAIL_REGISTER_ARCHIVE_DWA2006521_HPP
+# define BOOST_ARCHIVE_DETAIL_REGISTER_ARCHIVE_DWA2006521_HPP
+
+namespace boost { namespace archive { namespace detail {
+
+// No instantiate_ptr_serialization overloads generated by
+// BOOST_SERIALIZATION_REGISTER_ARCHIVE that lexically follow the call
+// will be seen *unless* they are in an associated namespace of one of
+// the arguments, so we pass one of these along to make sure this
+// namespace is considered. See temp.dep.candidate (14.6.4.2) in the
+// standard.
+struct adl_tag {};
+
+template <class Archive, class Serializable>
+struct ptr_serialization_support;
+
+// We could've just used ptr_serialization_support, above, but using
+// it with only a forward declaration causes vc6/7 to complain about a
+// missing instantiate member, even if it has one. This is just a
+// friendly layer of indirection.
+template <class Archive, class Serializable>
+struct _ptr_serialization_support
+ : ptr_serialization_support<Archive,Serializable>
+{
+ typedef int type;
+};
+
+#if defined(__SUNPRO_CC) && (__SUNPRO_CC < 0x5130)
+
+template<int N>
+struct counter : counter<N-1> {};
+template<>
+struct counter<0> {};
+
+template<class Serializable>
+void instantiate_ptr_serialization(Serializable* s, int, adl_tag) {
+ instantiate_ptr_serialization(s, counter<20>());
+}
+
+template<class Archive>
+struct get_counter {
+ static const int value = sizeof(adjust_counter(counter<20>()));
+ typedef counter<value> type;
+ typedef counter<value - 1> prior;
+ typedef char (&next)[value+1];
+};
+
+char adjust_counter(counter<0>);
+template<class Serializable>
+void instantiate_ptr_serialization(Serializable*, counter<0>) {}
+
+#define BOOST_SERIALIZATION_REGISTER_ARCHIVE(Archive) \
+namespace boost { namespace archive { namespace detail { \
+ get_counter<Archive >::next adjust_counter(get_counter<Archive >::type);\
+ template<class Serializable> \
+ void instantiate_ptr_serialization(Serializable* s, \
+ get_counter<Archive >::type) { \
+ ptr_serialization_support<Archive, Serializable> x; \
+ instantiate_ptr_serialization(s, get_counter<Archive >::prior()); \
+ }\
+}}}
+
+
+#else
+
+// This function gets called, but its only purpose is to participate
+// in overload resolution with the functions declared by
+// BOOST_SERIALIZATION_REGISTER_ARCHIVE, below.
+template <class Serializable>
+void instantiate_ptr_serialization(Serializable*, int, adl_tag ) {}
+
+// The function declaration generated by this macro never actually
+// gets called, but its return type gets instantiated, and that's
+// enough to cause registration of serialization functions between
+// Archive and any exported Serializable type. See also:
+// boost/serialization/export.hpp
+# define BOOST_SERIALIZATION_REGISTER_ARCHIVE(Archive) \
+namespace boost { namespace archive { namespace detail { \
+ \
+template <class Serializable> \
+typename _ptr_serialization_support<Archive, Serializable>::type \
+instantiate_ptr_serialization( Serializable*, Archive*, adl_tag ); \
+ \
+}}}
+#endif
+}}} // namespace boost::archive::detail
+
+#endif // BOOST_ARCHIVE_DETAIL_INSTANTIATE_SERIALIZE_DWA2006521_HPP
diff --git a/include/boost/archive/detail/utf8_codecvt_facet.hpp b/include/boost/archive/detail/utf8_codecvt_facet.hpp
new file mode 100644
index 0000000..00b2b41
--- /dev/null
+++ b/include/boost/archive/detail/utf8_codecvt_facet.hpp
@@ -0,0 +1,29 @@
+// Copyright (c) 2001 Ronald Garcia, Indiana University (garcia@osl.iu.edu)
+// Andrew Lumsdaine, Indiana University (lums@osl.iu.edu).
+// 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)
+
+#ifndef BOOST_ARCHIVE_DETAIL_UTF8_CODECVT_FACET_HPP
+#define BOOST_ARCHIVE_DETAIL_UTF8_CODECVT_FACET_HPP
+
+#include <boost/config.hpp>
+
+#ifdef BOOST_NO_STD_WSTREAMBUF
+#error "wide char i/o not supported on this platform"
+#endif
+
+// use boost's utf8 codecvt facet
+#include <boost/archive/detail/decl.hpp>
+#define BOOST_UTF8_BEGIN_NAMESPACE \
+ namespace boost { namespace archive { namespace detail {
+#define BOOST_UTF8_DECL BOOST_ARCHIVE_DECL
+#define BOOST_UTF8_END_NAMESPACE }}}
+
+#include <boost/detail/utf8_codecvt_facet.hpp>
+
+#undef BOOST_UTF8_END_NAMESPACE
+#undef BOOST_UTF8_DECL
+#undef BOOST_UTF8_BEGIN_NAMESPACE
+
+#endif // BOOST_ARCHIVE_DETAIL_UTF8_CODECVT_FACET_HPP
diff --git a/include/boost/archive/dinkumware.hpp b/include/boost/archive/dinkumware.hpp
new file mode 100644
index 0000000..90ba627
--- /dev/null
+++ b/include/boost/archive/dinkumware.hpp
@@ -0,0 +1,224 @@
+#ifndef BOOST_ARCHIVE_DINKUMWARE_HPP
+#define BOOST_ARCHIVE_DINKUMWARE_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER)
+# pragma once
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// dinkumware.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.
+
+// this file adds a couple of things that are missing from the dinkumware
+// implementation of the standard library.
+
+#include <iterator>
+#include <string>
+
+#include <boost/config.hpp>
+#include <boost/cstdint.hpp>
+
+namespace std {
+
+// define i/o operators for 64 bit integers
+template<class CharType>
+basic_ostream<CharType> &
+operator<<(basic_ostream<CharType> & os, boost::uint64_t t){
+ // octal rendering of 64 bit number would be 22 octets + eos
+ CharType d[23];
+ unsigned int radix;
+
+ if(os.flags() & (int)std::ios_base::hex)
+ radix = 16;
+ else
+ if(os.flags() & (int)std::ios_base::oct)
+ radix = 8;
+ else
+ //if(s.flags() & (int)std::ios_base::dec)
+ radix = 10;
+ unsigned int i = 0;
+ do{
+ unsigned int j = t % radix;
+ d[i++] = j + ((j < 10) ? '0' : ('a' - 10));
+ t /= radix;
+ }
+ while(t > 0);
+ d[i--] = '\0';
+
+ // reverse digits
+ unsigned int j = 0;
+ while(j < i){
+ CharType k = d[i];
+ d[i] = d[j];
+ d[j] = k;
+ --i;++j;
+ }
+ os << d;
+ return os;
+
+}
+
+template<class CharType>
+basic_ostream<CharType> &
+operator<<(basic_ostream<CharType> &os, boost::int64_t t){
+ if(0 <= t){
+ os << static_cast<boost::uint64_t>(t);
+ }
+ else{
+ os.put('-');
+ os << -t;
+ }
+ return os;
+}
+
+template<class CharType>
+basic_istream<CharType> &
+operator>>(basic_istream<CharType> &is, boost::int64_t & t){
+ CharType d;
+ do{
+ d = is.get();
+ }
+ while(::isspace(d));
+ bool negative = (d == '-');
+ if(negative)
+ d = is.get();
+ unsigned int radix;
+ if(is.flags() & (int)std::ios_base::hex)
+ radix = 16;
+ else
+ if(is.flags() & (int)std::ios_base::oct)
+ radix = 8;
+ else
+ //if(s.flags() & (int)std::ios_base::dec)
+ radix = 10;
+ t = 0;
+ do{
+ if('0' <= d && d <= '9')
+ t = t * radix + (d - '0');
+ else
+ if('a' <= d && d <= 'f')
+ t = t * radix + (d - 'a' + 10);
+ else
+ break;
+ d = is.get();
+ }
+ while(!is.fail());
+ // restore the delimiter
+ is.putback(d);
+ is.clear();
+ if(negative)
+ t = -t;
+ return is;
+}
+
+template<class CharType>
+basic_istream<CharType> &
+operator>>(basic_istream<CharType> &is, boost::uint64_t & t){
+ boost::int64_t it;
+ is >> it;
+ t = it;
+ return is;
+}
+
+//#endif
+
+template<>
+class back_insert_iterator<basic_string<char> > : public
+ iterator<output_iterator_tag, char>
+{
+public:
+ typedef basic_string<char> container_type;
+ typedef container_type::reference reference;
+
+ explicit back_insert_iterator(container_type & s)
+ : container(& s)
+ {} // construct with container
+
+ back_insert_iterator<container_type> & operator=(
+ container_type::const_reference Val_
+ ){ // push value into container
+ //container->push_back(Val_);
+ *container += Val_;
+ return (*this);
+ }
+
+ back_insert_iterator<container_type> & operator*(){
+ return (*this);
+ }
+
+ back_insert_iterator<container_type> & operator++(){
+ // pretend to preincrement
+ return (*this);
+ }
+
+ back_insert_iterator<container_type> operator++(int){
+ // pretend to postincrement
+ return (*this);
+ }
+
+protected:
+ container_type *container; // pointer to container
+};
+
+template<char>
+inline back_insert_iterator<basic_string<char> > back_inserter(
+ basic_string<char> & s
+){
+ return (std::back_insert_iterator<basic_string<char> >(s));
+}
+
+template<>
+class back_insert_iterator<basic_string<wchar_t> > : public
+ iterator<output_iterator_tag, wchar_t>
+{
+public:
+ typedef basic_string<wchar_t> container_type;
+ typedef container_type::reference reference;
+
+ explicit back_insert_iterator(container_type & s)
+ : container(& s)
+ {} // construct with container
+
+ back_insert_iterator<container_type> & operator=(
+ container_type::const_reference Val_
+ ){ // push value into container
+ //container->push_back(Val_);
+ *container += Val_;
+ return (*this);
+ }
+
+ back_insert_iterator<container_type> & operator*(){
+ return (*this);
+ }
+
+ back_insert_iterator<container_type> & operator++(){
+ // pretend to preincrement
+ return (*this);
+ }
+
+ back_insert_iterator<container_type> operator++(int){
+ // pretend to postincrement
+ return (*this);
+ }
+
+protected:
+ container_type *container; // pointer to container
+};
+
+template<wchar_t>
+inline back_insert_iterator<basic_string<wchar_t> > back_inserter(
+ basic_string<wchar_t> & s
+){
+ return (std::back_insert_iterator<basic_string<wchar_t> >(s));
+}
+
+} // namespace std
+
+#endif //BOOST_ARCHIVE_DINKUMWARE_HPP
diff --git a/include/boost/archive/impl/archive_serializer_map.ipp b/include/boost/archive/impl/archive_serializer_map.ipp
new file mode 100644
index 0000000..7f163ec
--- /dev/null
+++ b/include/boost/archive/impl/archive_serializer_map.ipp
@@ -0,0 +1,75 @@
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// archive_serializer_map.ipp:
+
+// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
+// Distributed under the Boost Software License, Version 1.0. (See
+// accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+
+// See http://www.boost.org for updates, documentation, and revision history.
+
+//////////////////////////////////////////////////////////////////////
+// implementation of basic_text_iprimitive overrides for the combination
+// of template parameters used to implement a text_iprimitive
+
+#include <boost/config.hpp>
+#include <boost/archive/detail/archive_serializer_map.hpp>
+#include <boost/archive/detail/basic_serializer_map.hpp>
+#include <boost/serialization/singleton.hpp>
+
+namespace boost {
+namespace archive {
+namespace detail {
+
+#ifdef BOOST_MSVC
+# pragma warning(push)
+# pragma warning(disable : 4511 4512)
+#endif
+
+namespace extra_detail { // anon
+ template<class Archive>
+ class map : public basic_serializer_map
+ {};
+}
+
+#ifdef BOOST_MSVC
+# pragma warning(pop)
+#endif
+
+template<class Archive>
+BOOST_ARCHIVE_OR_WARCHIVE_DECL bool
+archive_serializer_map<Archive>::insert(const basic_serializer * bs){
+ return boost::serialization::singleton<
+ extra_detail::map<Archive>
+ >::get_mutable_instance().insert(bs);
+}
+
+template<class Archive>
+BOOST_ARCHIVE_OR_WARCHIVE_DECL void
+archive_serializer_map<Archive>::erase(const basic_serializer * bs){
+ BOOST_ASSERT(! boost::serialization::singleton<
+ extra_detail::map<Archive>
+ >::is_destroyed()
+ );
+ if(boost::serialization::singleton<
+ extra_detail::map<Archive>
+ >::is_destroyed())
+ return;
+ boost::serialization::singleton<
+ extra_detail::map<Archive>
+ >::get_mutable_instance().erase(bs);
+}
+
+template<class Archive>
+BOOST_ARCHIVE_OR_WARCHIVE_DECL const basic_serializer *
+archive_serializer_map<Archive>::find(
+ const boost::serialization::extended_type_info & eti
+) {
+ return boost::serialization::singleton<
+ extra_detail::map<Archive>
+ >::get_const_instance().find(eti);
+}
+
+} // namespace detail
+} // namespace archive
+} // namespace boost
diff --git a/include/boost/archive/impl/basic_binary_iarchive.ipp b/include/boost/archive/impl/basic_binary_iarchive.ipp
new file mode 100644
index 0000000..d5619ab
--- /dev/null
+++ b/include/boost/archive/impl/basic_binary_iarchive.ipp
@@ -0,0 +1,134 @@
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// basic_binary_iarchive.ipp:
+
+// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
+// Use, modification and distribution is subject to the Boost Software
+// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+
+// See http://www.boost.org for updates, documentation, and revision history.
+#include <string>
+#include <boost/assert.hpp>
+#include <algorithm>
+#include <cstring>
+
+#include <boost/config.hpp>
+#if defined(BOOST_NO_STDC_NAMESPACE)
+namespace std{
+ using ::memcpy;
+ using ::strlen;
+ using ::size_t;
+}
+#endif
+
+#include <boost/detail/workaround.hpp>
+#include <boost/detail/endian.hpp>
+
+#include <boost/archive/basic_binary_iarchive.hpp>
+
+namespace boost {
+namespace archive {
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// implementation of binary_binary_archive
+template<class Archive>
+BOOST_ARCHIVE_OR_WARCHIVE_DECL void
+basic_binary_iarchive<Archive>::load_override(class_name_type & t){
+ std::string cn;
+ cn.reserve(BOOST_SERIALIZATION_MAX_KEY_SIZE);
+ load_override(cn);
+ if(cn.size() > (BOOST_SERIALIZATION_MAX_KEY_SIZE - 1))
+ boost::serialization::throw_exception(
+ archive_exception(archive_exception::invalid_class_name)
+ );
+ std::memcpy(t, cn.data(), cn.size());
+ // borland tweak
+ t.t[cn.size()] = '\0';
+}
+
+template<class Archive>
+BOOST_ARCHIVE_OR_WARCHIVE_DECL void
+basic_binary_iarchive<Archive>::init(void){
+ // read signature in an archive version independent manner
+ std::string file_signature;
+
+ #if 0 // commented out since it interfers with derivation
+ BOOST_TRY {
+ std::size_t l;
+ this->This()->load(l);
+ if(l == std::strlen(BOOST_ARCHIVE_SIGNATURE())) {
+ // borland de-allocator fixup
+ #if BOOST_WORKAROUND(_RWSTD_VER, BOOST_TESTED_AT(20101))
+ if(NULL != file_signature.data())
+ #endif
+ file_signature.resize(l);
+ // note breaking a rule here - could be a problem on some platform
+ if(0 < l)
+ this->This()->load_binary(&(*file_signature.begin()), l);
+ }
+ }
+ BOOST_CATCH(archive_exception const &) { // catch stream_error archive exceptions
+ // will cause invalid_signature archive exception to be thrown below
+ file_signature = "";
+ }
+ BOOST_CATCH_END
+ #else
+ // https://svn.boost.org/trac/boost/ticket/7301
+ * this->This() >> file_signature;
+ #endif
+
+ if(file_signature != BOOST_ARCHIVE_SIGNATURE())
+ boost::serialization::throw_exception(
+ archive_exception(archive_exception::invalid_signature)
+ );
+
+ // make sure the version of the reading archive library can
+ // support the format of the archive being read
+ library_version_type input_library_version;
+ //* this->This() >> input_library_version;
+ {
+ int v = 0;
+ v = this->This()->m_sb.sbumpc();
+ #if defined(BOOST_LITTLE_ENDIAN)
+ if(v < 6){
+ ;
+ }
+ else
+ if(v < 7){
+ // version 6 - next byte should be zero
+ this->This()->m_sb.sbumpc();
+ }
+ else
+ if(v < 8){
+ int x1;
+ // version 7 = might be followed by zero or some other byte
+ x1 = this->This()->m_sb.sgetc();
+ // it's =a zero, push it back
+ if(0 == x1)
+ this->This()->m_sb.sbumpc();
+ }
+ else{
+ // version 8+ followed by a zero
+ this->This()->m_sb.sbumpc();
+ }
+ #elif defined(BOOST_BIG_ENDIAN)
+ if(v == 0)
+ v = this->This()->m_sb.sbumpc();
+ #endif
+ input_library_version = static_cast<library_version_type>(v);
+ }
+
+ #if BOOST_WORKAROUND(__MWERKS__, BOOST_TESTED_AT(0x3205))
+ this->set_library_version(input_library_version);
+ #else
+ detail::basic_iarchive::set_library_version(input_library_version);
+ #endif
+
+ if(BOOST_ARCHIVE_VERSION() < input_library_version)
+ boost::serialization::throw_exception(
+ archive_exception(archive_exception::unsupported_version)
+ );
+}
+
+} // namespace archive
+} // namespace boost
diff --git a/include/boost/archive/impl/basic_binary_iprimitive.ipp b/include/boost/archive/impl/basic_binary_iprimitive.ipp
new file mode 100644
index 0000000..e2d0510
--- /dev/null
+++ b/include/boost/archive/impl/basic_binary_iprimitive.ipp
@@ -0,0 +1,173 @@
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// basic_binary_iprimitive.ipp:
+
+// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
+// Use, modification and distribution is subject to the Boost Software
+// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+
+// See http://www.boost.org for updates, documentation, and revision history.
+
+#include <boost/assert.hpp>
+#include <cstddef> // size_t, NULL
+#include <cstring> // memcpy
+
+#include <boost/config.hpp>
+#if defined(BOOST_NO_STDC_NAMESPACE)
+namespace std{
+ using ::size_t;
+ using ::memcpy;
+} // namespace std
+#endif
+
+#include <boost/serialization/throw_exception.hpp>
+#include <boost/core/no_exceptions_support.hpp>
+#include <boost/archive/archive_exception.hpp>
+#include <boost/archive/basic_binary_iprimitive.hpp>
+
+namespace boost {
+namespace archive {
+
+//////////////////////////////////////////////////////////////////////
+// implementation of basic_binary_iprimitive
+
+template<class Archive, class Elem, class Tr>
+BOOST_ARCHIVE_OR_WARCHIVE_DECL void
+basic_binary_iprimitive<Archive, Elem, Tr>::init()
+{
+ // Detect attempts to pass native binary archives across
+ // incompatible platforms. This is not fool proof but its
+ // better than nothing.
+ unsigned char size;
+ this->This()->load(size);
+ if(sizeof(int) != size)
+ boost::serialization::throw_exception(
+ archive_exception(
+ archive_exception::incompatible_native_format,
+ "size of int"
+ )
+ );
+ this->This()->load(size);
+ if(sizeof(long) != size)
+ boost::serialization::throw_exception(
+ archive_exception(
+ archive_exception::incompatible_native_format,
+ "size of long"
+ )
+ );
+ this->This()->load(size);
+ if(sizeof(float) != size)
+ boost::serialization::throw_exception(
+ archive_exception(
+ archive_exception::incompatible_native_format,
+ "size of float"
+ )
+ );
+ this->This()->load(size);
+ if(sizeof(double) != size)
+ boost::serialization::throw_exception(
+ archive_exception(
+ archive_exception::incompatible_native_format,
+ "size of double"
+ )
+ );
+
+ // for checking endian
+ int i;
+ this->This()->load(i);
+ if(1 != i)
+ boost::serialization::throw_exception(
+ archive_exception(
+ archive_exception::incompatible_native_format,
+ "endian setting"
+ )
+ );
+}
+
+#ifndef BOOST_NO_CWCHAR
+#ifndef BOOST_NO_INTRINSIC_WCHAR_T
+template<class Archive, class Elem, class Tr>
+BOOST_ARCHIVE_OR_WARCHIVE_DECL void
+basic_binary_iprimitive<Archive, Elem, Tr>::load(wchar_t * ws)
+{
+ std::size_t l; // number of wchar_t !!!
+ this->This()->load(l);
+ load_binary(ws, l * sizeof(wchar_t) / sizeof(char));
+ ws[l] = L'\0';
+}
+#endif
+#endif
+
+template<class Archive, class Elem, class Tr>
+BOOST_ARCHIVE_OR_WARCHIVE_DECL void
+basic_binary_iprimitive<Archive, Elem, Tr>::load(std::string & s)
+{
+ std::size_t l;
+ this->This()->load(l);
+ // borland de-allocator fixup
+ #if BOOST_WORKAROUND(_RWSTD_VER, BOOST_TESTED_AT(20101))
+ if(NULL != s.data())
+ #endif
+ s.resize(l);
+ // note breaking a rule here - could be a problem on some platform
+ if(0 < l)
+ load_binary(&(*s.begin()), l);
+}
+
+template<class Archive, class Elem, class Tr>
+BOOST_ARCHIVE_OR_WARCHIVE_DECL void
+basic_binary_iprimitive<Archive, Elem, Tr>::load(char * s)
+{
+ std::size_t l;
+ this->This()->load(l);
+ load_binary(s, l);
+ s[l] = '\0';
+}
+
+#ifndef BOOST_NO_STD_WSTRING
+template<class Archive, class Elem, class Tr>
+BOOST_ARCHIVE_OR_WARCHIVE_DECL void
+basic_binary_iprimitive<Archive, Elem, Tr>::load(std::wstring & ws)
+{
+ std::size_t l;
+ this->This()->load(l);
+ // borland de-allocator fixup
+ #if BOOST_WORKAROUND(_RWSTD_VER, BOOST_TESTED_AT(20101))
+ if(NULL != ws.data())
+ #endif
+ ws.resize(l);
+ // note breaking a rule here - is could be a problem on some platform
+ load_binary(const_cast<wchar_t *>(ws.data()), l * sizeof(wchar_t) / sizeof(char));
+}
+#endif
+
+template<class Archive, class Elem, class Tr>
+BOOST_ARCHIVE_OR_WARCHIVE_DECL
+basic_binary_iprimitive<Archive, Elem, Tr>::basic_binary_iprimitive(
+ std::basic_streambuf<Elem, Tr> & sb,
+ bool no_codecvt
+) :
+#ifndef BOOST_NO_STD_LOCALE
+ m_sb(sb),
+ codecvt_null_facet(1),
+ locale_saver(m_sb),
+ archive_locale(sb.getloc(), & codecvt_null_facet)
+{
+ if(! no_codecvt){
+ m_sb.pubsync();
+ m_sb.pubimbue(archive_locale);
+ }
+}
+#else
+ m_sb(sb)
+{}
+#endif
+
+// scoped_ptr requires that g be a complete type at time of
+// destruction so define destructor here rather than in the header
+template<class Archive, class Elem, class Tr>
+BOOST_ARCHIVE_OR_WARCHIVE_DECL
+basic_binary_iprimitive<Archive, Elem, Tr>::~basic_binary_iprimitive(){}
+
+} // namespace archive
+} // namespace boost
diff --git a/include/boost/archive/impl/basic_binary_oarchive.ipp b/include/boost/archive/impl/basic_binary_oarchive.ipp
new file mode 100644
index 0000000..d5a019d
--- /dev/null
+++ b/include/boost/archive/impl/basic_binary_oarchive.ipp
@@ -0,0 +1,42 @@
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// basic_binary_oarchive.ipp:
+
+// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
+// Use, modification and distribution is subject to the Boost Software
+// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+
+// See http://www.boost.org for updates, documentation, and revision history.
+#include <string>
+#include <boost/assert.hpp>
+#include <algorithm>
+#include <cstring>
+
+#include <boost/config.hpp>
+#if defined(BOOST_NO_STDC_NAMESPACE)
+namespace std{
+ using ::memcpy;
+}
+#endif
+
+#include <boost/archive/basic_binary_oarchive.hpp>
+
+namespace boost {
+namespace archive {
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// implementation of binary_binary_oarchive
+
+template<class Archive>
+BOOST_ARCHIVE_OR_WARCHIVE_DECL void
+basic_binary_oarchive<Archive>::init(){
+ // write signature in an archive version independent manner
+ const std::string file_signature(BOOST_ARCHIVE_SIGNATURE());
+ * this->This() << file_signature;
+ // write library version
+ const library_version_type v(BOOST_ARCHIVE_VERSION());
+ * this->This() << v;
+}
+
+} // namespace archive
+} // namespace boost
diff --git a/include/boost/archive/impl/basic_binary_oprimitive.ipp b/include/boost/archive/impl/basic_binary_oprimitive.ipp
new file mode 100644
index 0000000..7b04217
--- /dev/null
+++ b/include/boost/archive/impl/basic_binary_oprimitive.ipp
@@ -0,0 +1,126 @@
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// basic_binary_oprimitive.ipp:
+
+// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
+// Use, modification and distribution is subject to the Boost Software
+// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+
+// See http://www.boost.org for updates, documentation, and revision history.
+
+#include <ostream>
+#include <cstddef> // NULL
+#include <cstring>
+
+#include <boost/config.hpp>
+
+#if defined(BOOST_NO_STDC_NAMESPACE) && ! defined(__LIBCOMO__)
+namespace std{
+ using ::strlen;
+} // namespace std
+#endif
+
+#ifndef BOOST_NO_CWCHAR
+#include <cwchar>
+#ifdef BOOST_NO_STDC_NAMESPACE
+namespace std{ using ::wcslen; }
+#endif
+#endif
+
+#include <boost/archive/basic_binary_oprimitive.hpp>
+#include <boost/core/no_exceptions_support.hpp>
+
+namespace boost {
+namespace archive {
+
+//////////////////////////////////////////////////////////////////////
+// implementation of basic_binary_oprimitive
+
+template<class Archive, class Elem, class Tr>
+BOOST_ARCHIVE_OR_WARCHIVE_DECL void
+basic_binary_oprimitive<Archive, Elem, Tr>::init()
+{
+ // record native sizes of fundamental types
+ // this is to permit detection of attempts to pass
+ // native binary archives accross incompatible machines.
+ // This is not foolproof but its better than nothing.
+ this->This()->save(static_cast<unsigned char>(sizeof(int)));
+ this->This()->save(static_cast<unsigned char>(sizeof(long)));
+ this->This()->save(static_cast<unsigned char>(sizeof(float)));
+ this->This()->save(static_cast<unsigned char>(sizeof(double)));
+ // for checking endianness
+ this->This()->save(int(1));
+}
+
+template<class Archive, class Elem, class Tr>
+BOOST_ARCHIVE_OR_WARCHIVE_DECL void
+basic_binary_oprimitive<Archive, Elem, Tr>::save(const char * s)
+{
+ std::size_t l = std::strlen(s);
+ this->This()->save(l);
+ save_binary(s, l);
+}
+
+template<class Archive, class Elem, class Tr>
+BOOST_ARCHIVE_OR_WARCHIVE_DECL void
+basic_binary_oprimitive<Archive, Elem, Tr>::save(const std::string &s)
+{
+ std::size_t l = static_cast<std::size_t>(s.size());
+ this->This()->save(l);
+ save_binary(s.data(), l);
+}
+
+#ifndef BOOST_NO_CWCHAR
+#ifndef BOOST_NO_INTRINSIC_WCHAR_T
+template<class Archive, class Elem, class Tr>
+BOOST_ARCHIVE_OR_WARCHIVE_DECL void
+basic_binary_oprimitive<Archive, Elem, Tr>::save(const wchar_t * ws)
+{
+ std::size_t l = std::wcslen(ws);
+ this->This()->save(l);
+ save_binary(ws, l * sizeof(wchar_t) / sizeof(char));
+}
+#endif
+
+#ifndef BOOST_NO_STD_WSTRING
+template<class Archive, class Elem, class Tr>
+BOOST_ARCHIVE_OR_WARCHIVE_DECL void
+basic_binary_oprimitive<Archive, Elem, Tr>::save(const std::wstring &ws)
+{
+ std::size_t l = ws.size();
+ this->This()->save(l);
+ save_binary(ws.data(), l * sizeof(wchar_t) / sizeof(char));
+}
+#endif
+#endif // BOOST_NO_CWCHAR
+
+template<class Archive, class Elem, class Tr>
+BOOST_ARCHIVE_OR_WARCHIVE_DECL
+basic_binary_oprimitive<Archive, Elem, Tr>::basic_binary_oprimitive(
+ std::basic_streambuf<Elem, Tr> & sb,
+ bool no_codecvt
+) :
+#ifndef BOOST_NO_STD_LOCALE
+ m_sb(sb),
+ codecvt_null_facet(1),
+ locale_saver(m_sb),
+ archive_locale(sb.getloc(), & codecvt_null_facet)
+{
+ if(! no_codecvt){
+ m_sb.pubsync();
+ m_sb.pubimbue(archive_locale);
+ }
+}
+#else
+ m_sb(sb)
+{}
+#endif
+
+// scoped_ptr requires that g be a complete type at time of
+// destruction so define destructor here rather than in the header
+template<class Archive, class Elem, class Tr>
+BOOST_ARCHIVE_OR_WARCHIVE_DECL
+basic_binary_oprimitive<Archive, Elem, Tr>::~basic_binary_oprimitive(){}
+
+} // namespace archive
+} // namespace boost
diff --git a/include/boost/archive/impl/basic_text_iarchive.ipp b/include/boost/archive/impl/basic_text_iarchive.ipp
new file mode 100644
index 0000000..9ec8c65
--- /dev/null
+++ b/include/boost/archive/impl/basic_text_iarchive.ipp
@@ -0,0 +1,76 @@
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// basic_text_iarchive.ipp:
+
+// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
+// Use, modification and distribution is subject to the Boost Software
+// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+
+// See http://www.boost.org for updates, documentation, and revision history.
+#include <string>
+#include <algorithm>
+#include <cstring>
+
+#include <boost/config.hpp>
+#if defined(BOOST_NO_STDC_NAMESPACE)
+namespace std{
+ using ::memcpy;
+}
+#endif
+
+#include <boost/detail/workaround.hpp>
+#include <boost/serialization/string.hpp>
+#include <boost/archive/basic_text_iarchive.hpp>
+
+namespace boost {
+namespace archive {
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// implementation of text_text_archive
+
+template<class Archive>
+BOOST_ARCHIVE_OR_WARCHIVE_DECL void
+basic_text_iarchive<Archive>::load_override(class_name_type & t){
+ std::string cn;
+ cn.reserve(BOOST_SERIALIZATION_MAX_KEY_SIZE);
+ load_override(cn);
+ if(cn.size() > (BOOST_SERIALIZATION_MAX_KEY_SIZE - 1))
+ boost::serialization::throw_exception(
+ archive_exception(archive_exception::invalid_class_name)
+ );
+ std::memcpy(t, cn.data(), cn.size());
+ // borland tweak
+ t.t[cn.size()] = '\0';
+}
+
+template<class Archive>
+BOOST_ARCHIVE_OR_WARCHIVE_DECL void
+basic_text_iarchive<Archive>::init(void){
+ // read signature in an archive version independent manner
+ std::string file_signature;
+ * this->This() >> file_signature;
+ if(file_signature != BOOST_ARCHIVE_SIGNATURE())
+ boost::serialization::throw_exception(
+ archive_exception(archive_exception::invalid_signature)
+ );
+
+ // make sure the version of the reading archive library can
+ // support the format of the archive being read
+ library_version_type input_library_version;
+ * this->This() >> input_library_version;
+
+ #if BOOST_WORKAROUND(__MWERKS__, BOOST_TESTED_AT(0x3205))
+ this->set_library_version(input_library_version);
+ #else
+ detail::basic_iarchive::set_library_version(input_library_version);
+ #endif
+
+ // extra little .t is to get around borland quirk
+ if(BOOST_ARCHIVE_VERSION() < input_library_version)
+ boost::serialization::throw_exception(
+ archive_exception(archive_exception::unsupported_version)
+ );
+}
+
+} // namespace archive
+} // namespace boost
diff --git a/include/boost/archive/impl/basic_text_iprimitive.ipp b/include/boost/archive/impl/basic_text_iprimitive.ipp
new file mode 100644
index 0000000..4e44728
--- /dev/null
+++ b/include/boost/archive/impl/basic_text_iprimitive.ipp
@@ -0,0 +1,137 @@
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// basic_text_iprimitive.ipp:
+
+// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
+// Distributed under the Boost Software License, Version 1.0. (See
+// accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+
+// See http://www.boost.org for updates, documentation, and revision history.
+
+#include <cstddef> // size_t, NULL
+#include <limits> // NULL
+
+#include <boost/config.hpp>
+#if defined(BOOST_NO_STDC_NAMESPACE)
+namespace std{
+ using ::size_t;
+} // namespace std
+#endif
+
+#include <boost/serialization/throw_exception.hpp>
+
+#include <boost/archive/basic_text_iprimitive.hpp>
+
+#include <boost/archive/iterators/remove_whitespace.hpp>
+#include <boost/archive/iterators/istream_iterator.hpp>
+#include <boost/archive/iterators/binary_from_base64.hpp>
+#include <boost/archive/iterators/transform_width.hpp>
+
+namespace boost {
+namespace archive {
+
+namespace detail {
+ template<class CharType>
+ static inline bool is_whitespace(CharType c);
+
+ template<>
+ inline bool is_whitespace(char t){
+ return 0 != std::isspace(t);
+ }
+
+ #ifndef BOOST_NO_CWCHAR
+ template<>
+ inline bool is_whitespace(wchar_t t){
+ return 0 != std::iswspace(t);
+ }
+ #endif
+} // detail
+
+// translate base64 text into binary and copy into buffer
+// until buffer is full.
+template<class IStream>
+BOOST_ARCHIVE_OR_WARCHIVE_DECL void
+basic_text_iprimitive<IStream>::load_binary(
+ void *address,
+ std::size_t count
+){
+ typedef typename IStream::char_type CharType;
+
+ if(0 == count)
+ return;
+
+ BOOST_ASSERT(
+ static_cast<std::size_t>((std::numeric_limits<std::streamsize>::max)())
+ > (count + sizeof(CharType) - 1)/sizeof(CharType)
+ );
+
+ if(is.fail())
+ boost::serialization::throw_exception(
+ archive_exception(archive_exception::input_stream_error)
+ );
+ // convert from base64 to binary
+ typedef typename
+ iterators::transform_width<
+ iterators::binary_from_base64<
+ iterators::remove_whitespace<
+ iterators::istream_iterator<CharType>
+ >
+ ,typename IStream::int_type
+ >
+ ,8
+ ,6
+ ,CharType
+ >
+ binary;
+
+ binary i = binary(iterators::istream_iterator<CharType>(is));
+
+ char * caddr = static_cast<char *>(address);
+
+ // take care that we don't increment anymore than necessary
+ while(count-- > 0){
+ *caddr++ = static_cast<char>(*i++);
+ }
+
+ // skip over any excess input
+ for(;;){
+ typename IStream::int_type r;
+ r = is.get();
+ if(is.eof())
+ break;
+ if(detail::is_whitespace(static_cast<CharType>(r)))
+ break;
+ }
+}
+
+template<class IStream>
+BOOST_ARCHIVE_OR_WARCHIVE_DECL
+basic_text_iprimitive<IStream>::basic_text_iprimitive(
+ IStream &is_,
+ bool no_codecvt
+) :
+ is(is_),
+ flags_saver(is_),
+ precision_saver(is_),
+#ifndef BOOST_NO_STD_LOCALE
+ codecvt_null_facet(1),
+ archive_locale(is.getloc(), & codecvt_null_facet),
+ locale_saver(is)
+{
+ if(! no_codecvt){
+ is_.sync();
+ is_.imbue(archive_locale);
+ }
+ is_ >> std::noboolalpha;
+}
+#else
+{}
+#endif
+
+template<class IStream>
+BOOST_ARCHIVE_OR_WARCHIVE_DECL
+basic_text_iprimitive<IStream>::~basic_text_iprimitive(){
+}
+
+} // namespace archive
+} // namespace boost
diff --git a/include/boost/archive/impl/basic_text_oarchive.ipp b/include/boost/archive/impl/basic_text_oarchive.ipp
new file mode 100644
index 0000000..44bc140
--- /dev/null
+++ b/include/boost/archive/impl/basic_text_oarchive.ipp
@@ -0,0 +1,62 @@
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// basic_text_oarchive.ipp:
+
+// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
+// Use, modification and distribution is subject to the Boost Software
+// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+
+// See http://www.boost.org for updates, documentation, and revision history.
+#include <string>
+#include <boost/assert.hpp>
+#include <cstring>
+
+#include <boost/config.hpp>
+#if defined(BOOST_NO_STDC_NAMESPACE)
+namespace std{
+ using ::memcpy;
+}
+#endif
+
+#include <boost/archive/basic_text_oarchive.hpp>
+
+namespace boost {
+namespace archive {
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// implementation of basic_text_oarchive
+
+template<class Archive>
+BOOST_ARCHIVE_OR_WARCHIVE_DECL void
+basic_text_oarchive<Archive>::newtoken()
+{
+ switch(delimiter){
+ default:
+ BOOST_ASSERT(false);
+ break;
+ case eol:
+ this->This()->put('\n');
+ delimiter = space;
+ break;
+ case space:
+ this->This()->put(' ');
+ break;
+ case none:
+ delimiter = space;
+ break;
+ }
+}
+
+template<class Archive>
+BOOST_ARCHIVE_OR_WARCHIVE_DECL void
+basic_text_oarchive<Archive>::init(){
+ // write signature in an archive version independent manner
+ const std::string file_signature(BOOST_ARCHIVE_SIGNATURE());
+ * this->This() << file_signature;
+ // write library version
+ const library_version_type v(BOOST_ARCHIVE_VERSION());
+ * this->This() << v;
+}
+
+} // namespace archive
+} // namespace boost
diff --git a/include/boost/archive/impl/basic_text_oprimitive.ipp b/include/boost/archive/impl/basic_text_oprimitive.ipp
new file mode 100644
index 0000000..6030fd4
--- /dev/null
+++ b/include/boost/archive/impl/basic_text_oprimitive.ipp
@@ -0,0 +1,115 @@
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// basic_text_oprimitive.ipp:
+
+// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
+// Use, modification and distribution is subject to the Boost Software
+// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+
+// See http://www.boost.org for updates, documentation, and revision history.
+
+#include <cstddef> // NULL
+#include <algorithm> // std::copy
+#include <exception> // std::uncaught_exception
+#include <boost/config.hpp>
+#if defined(BOOST_NO_STDC_NAMESPACE)
+namespace std{
+ using ::size_t;
+} // namespace std
+#endif
+
+#include <boost/archive/basic_text_oprimitive.hpp>
+
+#include <boost/archive/iterators/base64_from_binary.hpp>
+#include <boost/archive/iterators/insert_linebreaks.hpp>
+#include <boost/archive/iterators/transform_width.hpp>
+#include <boost/archive/iterators/ostream_iterator.hpp>
+
+namespace boost {
+namespace archive {
+
+// translate to base64 and copy in to buffer.
+template<class OStream>
+BOOST_ARCHIVE_OR_WARCHIVE_DECL void
+basic_text_oprimitive<OStream>::save_binary(
+ const void *address,
+ std::size_t count
+){
+ typedef typename OStream::char_type CharType;
+
+ if(0 == count)
+ return;
+
+ if(os.fail())
+ boost::serialization::throw_exception(
+ archive_exception(archive_exception::output_stream_error)
+ );
+
+ os.put('\n');
+
+ typedef
+ boost::archive::iterators::insert_linebreaks<
+ boost::archive::iterators::base64_from_binary<
+ boost::archive::iterators::transform_width<
+ const char *,
+ 6,
+ 8
+ >
+ >
+ ,76
+ ,const char // cwpro8 needs this
+ >
+ base64_text;
+
+ boost::archive::iterators::ostream_iterator<CharType> oi(os);
+ std::copy(
+ base64_text(static_cast<const char *>(address)),
+ base64_text(
+ static_cast<const char *>(address) + count
+ ),
+ oi
+ );
+
+ std::size_t tail = count % 3;
+ if(tail > 0){
+ *oi++ = '=';
+ if(tail < 2)
+ *oi = '=';
+ }
+}
+
+template<class OStream>
+BOOST_ARCHIVE_OR_WARCHIVE_DECL
+basic_text_oprimitive<OStream>::basic_text_oprimitive(
+ OStream & os_,
+ bool no_codecvt
+) :
+ os(os_),
+ flags_saver(os_),
+ precision_saver(os_),
+#ifndef BOOST_NO_STD_LOCALE
+ codecvt_null_facet(1),
+ archive_locale(os.getloc(), & codecvt_null_facet),
+ locale_saver(os)
+{
+ if(! no_codecvt){
+ os_.flush();
+ os_.imbue(archive_locale);
+ }
+ os_ << std::noboolalpha;
+}
+#else
+{}
+#endif
+
+
+template<class OStream>
+BOOST_ARCHIVE_OR_WARCHIVE_DECL
+basic_text_oprimitive<OStream>::~basic_text_oprimitive(){
+ if(std::uncaught_exception())
+ return;
+ os << std::endl;
+}
+
+} //namespace boost
+} //namespace archive
diff --git a/include/boost/archive/impl/basic_xml_grammar.hpp b/include/boost/archive/impl/basic_xml_grammar.hpp
new file mode 100644
index 0000000..6d4e468
--- /dev/null
+++ b/include/boost/archive/impl/basic_xml_grammar.hpp
@@ -0,0 +1,173 @@
+#ifndef BOOST_ARCHIVE_BASIC_XML_GRAMMAR_HPP
+#define BOOST_ARCHIVE_BASIC_XML_GRAMMAR_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER)
+# pragma once
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// basic_xml_grammar.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.
+
+// this module is derived from simplexml.cpp - an example shipped as part of
+// the spirit parser. This example contains the following notice:
+/*=============================================================================
+ simplexml.cpp
+
+ Spirit V1.3
+ URL: http://spirit.sourceforge.net/
+
+ Copyright (c) 2001, Daniel C. Nuffer
+
+ This software is provided 'as-is', without any express or implied
+ warranty. In no event will the copyright holder be held liable for
+ any damages arising from the use of this software.
+
+ Permission is granted to anyone to use this software for any purpose,
+ including commercial applications, and to alter it and redistribute
+ it freely, subject to the following restrictions:
+
+ 1. The origin of this software must not be misrepresented; you must
+ not claim that you wrote the original software. If you use this
+ software in a product, an acknowledgment in the product documentation
+ would be appreciated but is not required.
+
+ 2. Altered source versions must be plainly marked as such, and must
+ not be misrepresented as being the original software.
+
+ 3. This notice may not be removed or altered from any source
+ distribution.
+=============================================================================*/
+#include <string>
+
+#include <boost/config.hpp>
+#include <boost/detail/workaround.hpp>
+
+#include <boost/spirit/include/classic_rule.hpp>
+#include <boost/spirit/include/classic_chset.hpp>
+
+#include <boost/archive/basic_archive.hpp>
+#include <boost/serialization/tracking.hpp>
+#include <boost/serialization/version.hpp>
+
+namespace boost {
+namespace archive {
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// XML grammar parsing
+
+template<class CharType>
+class basic_xml_grammar {
+public:
+ // The following is not necessary according to DR45, but at least
+ // one compiler (Compaq C++ 6.5 in strict_ansi mode) chokes otherwise.
+ struct return_values;
+ friend struct return_values;
+
+private:
+ typedef typename std::basic_istream<CharType> IStream;
+ typedef typename std::basic_string<CharType> StringType;
+ typedef typename boost::spirit::classic::chset<CharType> chset_t;
+ typedef typename boost::spirit::classic::chlit<CharType> chlit_t;
+ typedef typename boost::spirit::classic::scanner<
+ typename std::basic_string<CharType>::iterator
+ > scanner_t;
+ typedef typename boost::spirit::classic::rule<scanner_t> rule_t;
+ // Start grammar definition
+ rule_t
+ Reference,
+ Eq,
+ STag,
+ ETag,
+ LetterOrUnderscoreOrColon,
+ AttValue,
+ CharRef1,
+ CharRef2,
+ CharRef,
+ AmpRef,
+ LTRef,
+ GTRef,
+ AposRef,
+ QuoteRef,
+ CharData,
+ CharDataChars,
+ content,
+ AmpName,
+ LTName,
+ GTName,
+ ClassNameChar,
+ ClassName,
+ Name,
+ XMLDecl,
+ XMLDeclChars,
+ DocTypeDecl,
+ DocTypeDeclChars,
+ ClassIDAttribute,
+ ObjectIDAttribute,
+ ClassNameAttribute,
+ TrackingAttribute,
+ VersionAttribute,
+ UnusedAttribute,
+ Attribute,
+ SignatureAttribute,
+ SerializationWrapper,
+ NameHead,
+ NameTail,
+ AttributeList,
+ S;
+
+ // XML Character classes
+ chset_t
+ BaseChar,
+ Ideographic,
+ Char,
+ Letter,
+ Digit,
+ CombiningChar,
+ Extender,
+ Sch,
+ NameChar;
+
+ void init_chset();
+
+ bool my_parse(
+ IStream & is,
+ const rule_t &rule_,
+ const CharType delimiter = L'>'
+ ) const ;
+public:
+ struct return_values {
+ StringType object_name;
+ StringType contents;
+ //class_id_type class_id;
+ int_least16_t class_id;
+ //object_id_type object_id;
+ uint_least32_t object_id;
+ //version_type version;
+ unsigned int version;
+ tracking_type tracking_level;
+ StringType class_name;
+ return_values() :
+ version(0),
+ tracking_level(false)
+ {}
+ } rv;
+ bool parse_start_tag(IStream & is) /*const*/;
+ bool parse_end_tag(IStream & is) const;
+ bool parse_string(IStream & is, StringType & s) /*const*/;
+ void init(IStream & is);
+ bool windup(IStream & is);
+ basic_xml_grammar();
+};
+
+} // namespace archive
+} // namespace boost
+
+#endif // BOOST_ARCHIVE_BASIC_XML_GRAMMAR_HPP
diff --git a/include/boost/archive/impl/basic_xml_iarchive.ipp b/include/boost/archive/impl/basic_xml_iarchive.ipp
new file mode 100644
index 0000000..625458b
--- /dev/null
+++ b/include/boost/archive/impl/basic_xml_iarchive.ipp
@@ -0,0 +1,115 @@
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// basic_xml_iarchive.ipp:
+
+// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
+// Use, modification and distribution is subject to the Boost Software
+// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+
+// See http://www.boost.org for updates, documentation, and revision history.
+
+#include <boost/assert.hpp>
+#include <cstddef> // NULL
+#include <algorithm>
+
+#include <boost/serialization/throw_exception.hpp>
+#include <boost/archive/xml_archive_exception.hpp>
+#include <boost/archive/basic_xml_iarchive.hpp>
+#include <boost/serialization/tracking.hpp>
+
+namespace boost {
+namespace archive {
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// implementation of xml_text_archive
+
+template<class Archive>
+BOOST_ARCHIVE_OR_WARCHIVE_DECL void
+basic_xml_iarchive<Archive>::load_start(const char *name){
+ // if there's no name
+ if(NULL == name)
+ return;
+ bool result = this->This()->gimpl->parse_start_tag(this->This()->get_is());
+ if(true != result){
+ boost::serialization::throw_exception(
+ archive_exception(archive_exception::input_stream_error)
+ );
+ }
+ // don't check start tag at highest level
+ ++depth;
+ return;
+}
+
+template<class Archive>
+BOOST_ARCHIVE_OR_WARCHIVE_DECL void
+basic_xml_iarchive<Archive>::load_end(const char *name){
+ // if there's no name
+ if(NULL == name)
+ return;
+ bool result = this->This()->gimpl->parse_end_tag(this->This()->get_is());
+ if(true != result){
+ boost::serialization::throw_exception(
+ archive_exception(archive_exception::input_stream_error)
+ );
+ }
+
+ // don't check start tag at highest level
+ if(0 == --depth)
+ return;
+
+ if(0 == (this->get_flags() & no_xml_tag_checking)){
+ // double check that the tag matches what is expected - useful for debug
+ if(0 != name[this->This()->gimpl->rv.object_name.size()]
+ || ! std::equal(
+ this->This()->gimpl->rv.object_name.begin(),
+ this->This()->gimpl->rv.object_name.end(),
+ name
+ )
+ ){
+ boost::serialization::throw_exception(
+ xml_archive_exception(
+ xml_archive_exception::xml_archive_tag_mismatch,
+ name
+ )
+ );
+ }
+ }
+}
+
+template<class Archive>
+BOOST_ARCHIVE_OR_WARCHIVE_DECL void
+basic_xml_iarchive<Archive>::load_override(object_id_type & t){
+ t = object_id_type(this->This()->gimpl->rv.object_id);
+}
+
+template<class Archive>
+BOOST_ARCHIVE_OR_WARCHIVE_DECL void
+basic_xml_iarchive<Archive>::load_override(version_type & t){
+ t = version_type(this->This()->gimpl->rv.version);
+}
+
+template<class Archive>
+BOOST_ARCHIVE_OR_WARCHIVE_DECL void
+basic_xml_iarchive<Archive>::load_override(class_id_type & t){
+ t = class_id_type(this->This()->gimpl->rv.class_id);
+}
+
+template<class Archive>
+BOOST_ARCHIVE_OR_WARCHIVE_DECL void
+basic_xml_iarchive<Archive>::load_override(tracking_type & t){
+ t = this->This()->gimpl->rv.tracking_level;
+}
+
+template<class Archive>
+BOOST_ARCHIVE_OR_WARCHIVE_DECL
+basic_xml_iarchive<Archive>::basic_xml_iarchive(unsigned int flags) :
+ detail::common_iarchive<Archive>(flags),
+ depth(0)
+{}
+template<class Archive>
+BOOST_ARCHIVE_OR_WARCHIVE_DECL
+basic_xml_iarchive<Archive>::~basic_xml_iarchive(){
+}
+
+} // namespace archive
+} // namespace boost
diff --git a/include/boost/archive/impl/basic_xml_oarchive.ipp b/include/boost/archive/impl/basic_xml_oarchive.ipp
new file mode 100644
index 0000000..3184413
--- /dev/null
+++ b/include/boost/archive/impl/basic_xml_oarchive.ipp
@@ -0,0 +1,272 @@
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// basic_xml_oarchive.ipp:
+
+// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
+// Distributed under the Boost Software License, Version 1.0. (See
+// accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+
+// See http://www.boost.org for updates, documentation, and revision history.
+
+#include <algorithm>
+#include <cstddef> // NULL
+#include <cstring>
+#if defined(BOOST_NO_STDC_NAMESPACE) && ! defined(__LIBCOMO__)
+namespace std{
+ using ::strlen;
+} // namespace std
+#endif
+
+#include <boost/archive/basic_xml_archive.hpp>
+#include <boost/archive/basic_xml_oarchive.hpp>
+#include <boost/archive/xml_archive_exception.hpp>
+#include <boost/core/no_exceptions_support.hpp>
+
+namespace boost {
+namespace archive {
+
+namespace detail {
+template<class CharType>
+struct XML_name {
+ void operator()(CharType t) const{
+ const unsigned char lookup_table[] = {
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,0, // -.
+ 1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0, // 0-9
+ 0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, // A-
+ 1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,1, // -Z _
+ 0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, // a-
+ 1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0, // -z
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
+ };
+ if((unsigned)t > 127)
+ return;
+ if(0 == lookup_table[(unsigned)t])
+ boost::serialization::throw_exception(
+ xml_archive_exception(
+ xml_archive_exception::xml_archive_tag_name_error
+ )
+ );
+ }
+};
+
+} // namespace detail
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// implemenations of functions common to both types of xml output
+
+template<class Archive>
+BOOST_ARCHIVE_OR_WARCHIVE_DECL void
+basic_xml_oarchive<Archive>::write_attribute(
+ const char *attribute_name,
+ int t,
+ const char *conjunction
+){
+ this->This()->put(' ');
+ this->This()->put(attribute_name);
+ this->This()->put(conjunction);
+ this->This()->save(t);
+ this->This()->put('"');
+}
+
+template<class Archive>
+BOOST_ARCHIVE_OR_WARCHIVE_DECL void
+basic_xml_oarchive<Archive>::write_attribute(
+ const char *attribute_name,
+ const char *key
+){
+ this->This()->put(' ');
+ this->This()->put(attribute_name);
+ this->This()->put("=\"");
+ this->This()->save(key);
+ this->This()->put('"');
+}
+
+template<class Archive>
+BOOST_ARCHIVE_OR_WARCHIVE_DECL void
+basic_xml_oarchive<Archive>::indent(){
+ int i;
+ for(i = depth; i-- > 0;)
+ this->This()->put('\t');
+}
+
+template<class Archive>
+BOOST_ARCHIVE_OR_WARCHIVE_DECL void
+basic_xml_oarchive<Archive>::save_start(const char *name)
+{
+ if(NULL == name)
+ return;
+
+ // be sure name has no invalid characters
+ std::for_each(name, name + std::strlen(name), detail::XML_name<const char>());
+
+ end_preamble();
+ if(depth > 0){
+ this->This()->put('\n');
+ indent();
+ }
+ ++depth;
+ this->This()->put('<');
+ this->This()->save(name);
+ pending_preamble = true;
+ indent_next = false;
+}
+
+template<class Archive>
+BOOST_ARCHIVE_OR_WARCHIVE_DECL void
+basic_xml_oarchive<Archive>::save_end(const char *name)
+{
+ if(NULL == name)
+ return;
+
+ // be sure name has no invalid characters
+ std::for_each(name, name + std::strlen(name), detail::XML_name<const char>());
+
+ end_preamble();
+ --depth;
+ if(indent_next){
+ this->This()->put('\n');
+ indent();
+ }
+ indent_next = true;
+ this->This()->put("</");
+ this->This()->save(name);
+ this->This()->put('>');
+ if(0 == depth)
+ this->This()->put('\n');
+}
+
+template<class Archive>
+BOOST_ARCHIVE_OR_WARCHIVE_DECL void
+basic_xml_oarchive<Archive>::end_preamble(){
+ if(pending_preamble){
+ this->This()->put('>');
+ pending_preamble = false;
+ }
+}
+#if 0
+template<class Archive>
+BOOST_ARCHIVE_OR_WARCHIVE_DECL void
+basic_xml_oarchive<Archive>::save_override(const object_id_type & t)
+{
+ int i = t.t; // extra .t is for borland
+ write_attribute(BOOST_ARCHIVE_XML_OBJECT_ID(), i, "=\"_");
+}
+template<class Archive>
+BOOST_ARCHIVE_OR_WARCHIVE_DECL void
+basic_xml_oarchive<Archive>::save_override(
+ const object_reference_type & t,
+ int
+){
+ int i = t.t; // extra .t is for borland
+ write_attribute(BOOST_ARCHIVE_XML_OBJECT_REFERENCE(), i, "=\"_");
+}
+template<class Archive>
+BOOST_ARCHIVE_OR_WARCHIVE_DECL void
+basic_xml_oarchive<Archive>::save_override(const version_type & t)
+{
+ int i = t.t; // extra .t is for borland
+ write_attribute(BOOST_ARCHIVE_XML_VERSION(), i);
+}
+#endif
+
+template<class Archive>
+BOOST_ARCHIVE_OR_WARCHIVE_DECL void
+basic_xml_oarchive<Archive>::save_override(const object_id_type & t)
+{
+ // borland doesn't do conversion of STRONG_TYPEDEFs very well
+ const unsigned int i = t;
+ write_attribute(BOOST_ARCHIVE_XML_OBJECT_ID(), i, "=\"_");
+}
+template<class Archive>
+BOOST_ARCHIVE_OR_WARCHIVE_DECL void
+basic_xml_oarchive<Archive>::save_override(
+ const object_reference_type & t
+){
+ const unsigned int i = t;
+ write_attribute(BOOST_ARCHIVE_XML_OBJECT_REFERENCE(), i, "=\"_");
+}
+template<class Archive>
+BOOST_ARCHIVE_OR_WARCHIVE_DECL void
+basic_xml_oarchive<Archive>::save_override(const version_type & t)
+{
+ const unsigned int i = t;
+ write_attribute(BOOST_ARCHIVE_XML_VERSION(), i);
+}
+
+template<class Archive>
+BOOST_ARCHIVE_OR_WARCHIVE_DECL void
+basic_xml_oarchive<Archive>::save_override(const class_id_type & t)
+{
+ write_attribute(BOOST_ARCHIVE_XML_CLASS_ID(), t);
+}
+template<class Archive>
+BOOST_ARCHIVE_OR_WARCHIVE_DECL void
+basic_xml_oarchive<Archive>::save_override(
+ const class_id_reference_type & t
+){
+ write_attribute(BOOST_ARCHIVE_XML_CLASS_ID_REFERENCE(), t);
+}
+template<class Archive>
+BOOST_ARCHIVE_OR_WARCHIVE_DECL void
+basic_xml_oarchive<Archive>::save_override(
+ const class_id_optional_type & t
+){
+ write_attribute(BOOST_ARCHIVE_XML_CLASS_ID(), t);
+}
+template<class Archive>
+BOOST_ARCHIVE_OR_WARCHIVE_DECL void
+basic_xml_oarchive<Archive>::save_override(const class_name_type & t)
+{
+ const char * key = t;
+ if(NULL == key)
+ return;
+ write_attribute(BOOST_ARCHIVE_XML_CLASS_NAME(), key);
+}
+
+template<class Archive>
+BOOST_ARCHIVE_OR_WARCHIVE_DECL void
+basic_xml_oarchive<Archive>::save_override(const tracking_type & t)
+{
+ write_attribute(BOOST_ARCHIVE_XML_TRACKING(), t.t);
+}
+
+template<class Archive>
+BOOST_ARCHIVE_OR_WARCHIVE_DECL void
+basic_xml_oarchive<Archive>::init(){
+ // xml header
+ this->This()->put("<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\" ?>\n");
+ this->This()->put("<!DOCTYPE boost_serialization>\n");
+ // xml document wrapper - outer root
+ this->This()->put("<boost_serialization");
+ write_attribute("signature", BOOST_ARCHIVE_SIGNATURE());
+ write_attribute("version", BOOST_ARCHIVE_VERSION());
+ this->This()->put(">\n");
+}
+
+template<class Archive>
+BOOST_ARCHIVE_OR_WARCHIVE_DECL void
+basic_xml_oarchive<Archive>::windup(){
+ // xml_trailer
+ this->This()->put("</boost_serialization>\n");
+}
+
+template<class Archive>
+BOOST_ARCHIVE_OR_WARCHIVE_DECL
+basic_xml_oarchive<Archive>::basic_xml_oarchive(unsigned int flags) :
+ detail::common_oarchive<Archive>(flags),
+ depth(0),
+ pending_preamble(false),
+ indent_next(false)
+{
+}
+
+template<class Archive>
+BOOST_ARCHIVE_OR_WARCHIVE_DECL
+basic_xml_oarchive<Archive>::~basic_xml_oarchive(){
+}
+
+} // namespace archive
+} // namespace boost
diff --git a/include/boost/archive/impl/text_iarchive_impl.ipp b/include/boost/archive/impl/text_iarchive_impl.ipp
new file mode 100644
index 0000000..ae4e275
--- /dev/null
+++ b/include/boost/archive/impl/text_iarchive_impl.ipp
@@ -0,0 +1,128 @@
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// text_iarchive_impl.ipp:
+
+// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
+// Distributed under the Boost Software License, Version 1.0. (See
+// accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+
+// See http://www.boost.org for updates, documentation, and revision history.
+
+//////////////////////////////////////////////////////////////////////
+// implementation of basic_text_iprimitive overrides for the combination
+// of template parameters used to implement a text_iprimitive
+
+#include <cstddef> // size_t, NULL
+#include <boost/config.hpp>
+#if defined(BOOST_NO_STDC_NAMESPACE)
+namespace std{
+ using ::size_t;
+} // namespace std
+#endif
+
+#include <boost/detail/workaround.hpp> // RogueWave
+
+#include <boost/archive/text_iarchive.hpp>
+
+namespace boost {
+namespace archive {
+
+template<class Archive>
+BOOST_ARCHIVE_DECL void
+text_iarchive_impl<Archive>::load(char *s)
+{
+ std::size_t size;
+ * this->This() >> size;
+ // skip separating space
+ is.get();
+ // Works on all tested platforms
+ is.read(s, size);
+ s[size] = '\0';
+}
+
+template<class Archive>
+BOOST_ARCHIVE_DECL void
+text_iarchive_impl<Archive>::load(std::string &s)
+{
+ std::size_t size;
+ * this->This() >> size;
+ // skip separating space
+ is.get();
+ // borland de-allocator fixup
+ #if BOOST_WORKAROUND(_RWSTD_VER, BOOST_TESTED_AT(20101))
+ if(NULL != s.data())
+ #endif
+ s.resize(size);
+ if(0 < size)
+ is.read(&(*s.begin()), size);
+}
+
+#ifndef BOOST_NO_CWCHAR
+#ifndef BOOST_NO_INTRINSIC_WCHAR_T
+template<class Archive>
+BOOST_ARCHIVE_DECL void
+text_iarchive_impl<Archive>::load(wchar_t *ws)
+{
+ std::size_t size;
+ * this->This() >> size;
+ // skip separating space
+ is.get();
+ is.read((char *)ws, size * sizeof(wchar_t)/sizeof(char));
+ ws[size] = L'\0';
+}
+#endif // BOOST_NO_INTRINSIC_WCHAR_T
+
+#ifndef BOOST_NO_STD_WSTRING
+template<class Archive>
+BOOST_ARCHIVE_DECL void
+text_iarchive_impl<Archive>::load(std::wstring &ws)
+{
+ std::size_t size;
+ * this->This() >> size;
+ // borland de-allocator fixup
+ #if BOOST_WORKAROUND(_RWSTD_VER, BOOST_TESTED_AT(20101))
+ if(NULL != ws.data())
+ #endif
+ ws.resize(size);
+ // skip separating space
+ is.get();
+ is.read((char *)ws.data(), size * sizeof(wchar_t)/sizeof(char));
+}
+
+#endif // BOOST_NO_STD_WSTRING
+#endif // BOOST_NO_CWCHAR
+
+template<class Archive>
+BOOST_ARCHIVE_DECL void
+text_iarchive_impl<Archive>::load_override(class_name_type & t){
+ basic_text_iarchive<Archive>::load_override(t);
+}
+
+template<class Archive>
+BOOST_ARCHIVE_DECL void
+text_iarchive_impl<Archive>::init(){
+ basic_text_iarchive<Archive>::init();
+}
+
+template<class Archive>
+BOOST_ARCHIVE_DECL
+text_iarchive_impl<Archive>::text_iarchive_impl(
+ std::istream & is,
+ unsigned int flags
+) :
+ basic_text_iprimitive<std::istream>(
+ is,
+ 0 != (flags & no_codecvt)
+ ),
+ basic_text_iarchive<Archive>(flags)
+{
+ if(0 == (flags & no_header))
+ #if BOOST_WORKAROUND(__MWERKS__, BOOST_TESTED_AT(0x3205))
+ this->init();
+ #else
+ this->basic_text_iarchive<Archive>::init();
+ #endif
+}
+
+} // namespace archive
+} // namespace boost
diff --git a/include/boost/archive/impl/text_oarchive_impl.ipp b/include/boost/archive/impl/text_oarchive_impl.ipp
new file mode 100644
index 0000000..37d8664
--- /dev/null
+++ b/include/boost/archive/impl/text_oarchive_impl.ipp
@@ -0,0 +1,122 @@
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// text_oarchive_impl.ipp:
+
+// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
+// Distributed under the Boost Software License, Version 1.0. (See
+// accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+
+// See http://www.boost.org for updates, documentation, and revision history.
+
+#include <string>
+#include <boost/config.hpp>
+#include <cstddef> // size_t
+
+#include <boost/config.hpp>
+#if defined(BOOST_NO_STDC_NAMESPACE)
+namespace std{
+ using ::size_t;
+} // namespace std
+#endif
+
+#ifndef BOOST_NO_CWCHAR
+#include <cwchar>
+#ifdef BOOST_NO_STDC_NAMESPACE
+namespace std{ using ::wcslen; }
+#endif
+#endif
+
+#include <boost/archive/text_oarchive.hpp>
+
+namespace boost {
+namespace archive {
+
+//////////////////////////////////////////////////////////////////////
+// implementation of basic_text_oprimitive overrides for the combination
+// of template parameters used to create a text_oprimitive
+
+template<class Archive>
+BOOST_ARCHIVE_DECL void
+text_oarchive_impl<Archive>::save(const char * s)
+{
+ const std::size_t len = std::ostream::traits_type::length(s);
+ *this->This() << len;
+ this->This()->newtoken();
+ os << s;
+}
+
+template<class Archive>
+BOOST_ARCHIVE_DECL void
+text_oarchive_impl<Archive>::save(const std::string &s)
+{
+ const std::size_t size = s.size();
+ *this->This() << size;
+ this->This()->newtoken();
+ os << s;
+}
+
+#ifndef BOOST_NO_CWCHAR
+#ifndef BOOST_NO_INTRINSIC_WCHAR_T
+template<class Archive>
+BOOST_ARCHIVE_DECL void
+text_oarchive_impl<Archive>::save(const wchar_t * ws)
+{
+ const std::size_t l = std::wcslen(ws);
+ * this->This() << l;
+ this->This()->newtoken();
+ os.write((const char *)ws, l * sizeof(wchar_t)/sizeof(char));
+}
+#endif
+
+#ifndef BOOST_NO_STD_WSTRING
+template<class Archive>
+BOOST_ARCHIVE_DECL void
+text_oarchive_impl<Archive>::save(const std::wstring &ws)
+{
+ const std::size_t l = ws.size();
+ * this->This() << l;
+ this->This()->newtoken();
+ os.write((const char *)(ws.data()), l * sizeof(wchar_t)/sizeof(char));
+}
+#endif
+#endif // BOOST_NO_CWCHAR
+
+template<class Archive>
+BOOST_ARCHIVE_DECL
+text_oarchive_impl<Archive>::text_oarchive_impl(
+ std::ostream & os,
+ unsigned int flags
+) :
+ basic_text_oprimitive<std::ostream>(
+ os,
+ 0 != (flags & no_codecvt)
+ ),
+ basic_text_oarchive<Archive>(flags)
+{
+ if(0 == (flags & no_header))
+ #if BOOST_WORKAROUND(__MWERKS__, BOOST_TESTED_AT(0x3205))
+ this->init();
+ #else
+ this->basic_text_oarchive<Archive>::init();
+ #endif
+}
+
+template<class Archive>
+BOOST_ARCHIVE_DECL void
+text_oarchive_impl<Archive>::save_binary(const void *address, std::size_t count){
+ put('\n');
+ this->end_preamble();
+ #if ! defined(__MWERKS__)
+ this->basic_text_oprimitive<std::ostream>::save_binary(
+ #else
+ this->basic_text_oprimitive::save_binary(
+ #endif
+ address,
+ count
+ );
+ this->delimiter = this->eol;
+}
+
+} // namespace archive
+} // namespace boost
+
diff --git a/include/boost/archive/impl/text_wiarchive_impl.ipp b/include/boost/archive/impl/text_wiarchive_impl.ipp
new file mode 100644
index 0000000..e85625a
--- /dev/null
+++ b/include/boost/archive/impl/text_wiarchive_impl.ipp
@@ -0,0 +1,118 @@
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// text_text_wiarchive_impl.ipp:
+
+// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
+// Distributed under the Boost Software License, Version 1.0. (See
+// accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+
+// See http://www.boost.org for updates, documentation, and revision history.
+
+#include <cstddef> // size_t, NULL
+
+#include <boost/config.hpp>
+#if defined(BOOST_NO_STDC_NAMESPACE)
+namespace std{
+ using ::size_t;
+} // namespace std
+#endif
+
+#include <boost/detail/workaround.hpp> // fixup for RogueWave
+
+#ifndef BOOST_NO_STD_WSTREAMBUF
+#include <boost/archive/basic_text_iprimitive.hpp>
+
+namespace boost {
+namespace archive {
+
+//////////////////////////////////////////////////////////////////////
+// implementation of wiprimtives functions
+//
+template<class Archive>
+BOOST_WARCHIVE_DECL void
+text_wiarchive_impl<Archive>::load(char *s)
+{
+ std::size_t size;
+ * this->This() >> size;
+ // skip separating space
+ is.get();
+ while(size-- > 0){
+ *s++ = is.narrow(is.get(), '\0');
+ }
+ *s = '\0';
+}
+
+template<class Archive>
+BOOST_WARCHIVE_DECL void
+text_wiarchive_impl<Archive>::load(std::string &s)
+{
+ std::size_t size;
+ * this->This() >> size;
+ // skip separating space
+ is.get();
+ #if BOOST_WORKAROUND(_RWSTD_VER, BOOST_TESTED_AT(20101))
+ if(NULL != s.data())
+ #endif
+ s.resize(0);
+ s.reserve(size);
+ while(size-- > 0){
+ char x = is.narrow(is.get(), '\0');
+ s += x;
+ }
+}
+
+#ifndef BOOST_NO_INTRINSIC_WCHAR_T
+template<class Archive>
+BOOST_WARCHIVE_DECL void
+text_wiarchive_impl<Archive>::load(wchar_t *s)
+{
+ std::size_t size;
+ * this->This() >> size;
+ // skip separating space
+ is.get();
+ // Works on all tested platforms
+ is.read(s, size);
+ s[size] = L'\0';
+}
+#endif
+
+#ifndef BOOST_NO_STD_WSTRING
+template<class Archive>
+BOOST_WARCHIVE_DECL void
+text_wiarchive_impl<Archive>::load(std::wstring &ws)
+{
+ std::size_t size;
+ * this->This() >> size;
+ // skip separating space
+ is.get();
+ // borland complains about resize
+ // borland de-allocator fixup
+ #if BOOST_WORKAROUND(_RWSTD_VER, BOOST_TESTED_AT(20101))
+ if(NULL != ws.data())
+ #endif
+ ws.resize(size);
+ // note breaking a rule here - is this a problem on some platform
+ is.read(const_cast<wchar_t *>(ws.data()), size);
+}
+#endif
+
+template<class Archive>
+BOOST_WARCHIVE_DECL
+text_wiarchive_impl<Archive>::text_wiarchive_impl(
+ std::wistream & is,
+ unsigned int flags
+) :
+ basic_text_iprimitive<std::wistream>(
+ is,
+ 0 != (flags & no_codecvt)
+ ),
+ basic_text_iarchive<Archive>(flags)
+{
+ if(0 == (flags & no_header))
+ basic_text_iarchive<Archive>::init();
+}
+
+} // archive
+} // boost
+
+#endif // BOOST_NO_STD_WSTREAMBUF
diff --git a/include/boost/archive/impl/text_woarchive_impl.ipp b/include/boost/archive/impl/text_woarchive_impl.ipp
new file mode 100644
index 0000000..2b6d427
--- /dev/null
+++ b/include/boost/archive/impl/text_woarchive_impl.ipp
@@ -0,0 +1,85 @@
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// text_woarchive_impl.ipp:
+
+// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
+// Distributed under the Boost Software License, Version 1.0. (See
+// accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+
+// See http://www.boost.org for updates, documentation, and revision history.
+
+#include <boost/config.hpp>
+#ifndef BOOST_NO_STD_WSTREAMBUF
+
+#include <cstring>
+#include <cstddef> // size_t
+#if defined(BOOST_NO_STDC_NAMESPACE) && ! defined(__LIBCOMO__)
+namespace std{
+ using ::strlen;
+ using ::size_t;
+} // namespace std
+#endif
+
+#include <ostream>
+
+#include <boost/archive/text_woarchive.hpp>
+
+namespace boost {
+namespace archive {
+
+//////////////////////////////////////////////////////////////////////
+// implementation of woarchive functions
+//
+template<class Archive>
+BOOST_WARCHIVE_DECL void
+text_woarchive_impl<Archive>::save(const char *s)
+{
+ // note: superfluous local variable fixes borland warning
+ const std::size_t size = std::strlen(s);
+ * this->This() << size;
+ this->This()->newtoken();
+ while(*s != '\0')
+ os.put(os.widen(*s++));
+}
+
+template<class Archive>
+BOOST_WARCHIVE_DECL void
+text_woarchive_impl<Archive>::save(const std::string &s)
+{
+ const std::size_t size = s.size();
+ * this->This() << size;
+ this->This()->newtoken();
+ const char * cptr = s.data();
+ for(std::size_t i = size; i-- > 0;)
+ os.put(os.widen(*cptr++));
+}
+
+#ifndef BOOST_NO_INTRINSIC_WCHAR_T
+template<class Archive>
+BOOST_WARCHIVE_DECL void
+text_woarchive_impl<Archive>::save(const wchar_t *ws)
+{
+ const std::size_t size = std::wostream::traits_type::length(ws);
+ * this->This() << size;
+ this->This()->newtoken();
+ os.write(ws, size);
+}
+#endif
+
+#ifndef BOOST_NO_STD_WSTRING
+template<class Archive>
+BOOST_WARCHIVE_DECL void
+text_woarchive_impl<Archive>::save(const std::wstring &ws)
+{
+ const std::size_t size = ws.length();
+ * this->This() << size;
+ this->This()->newtoken();
+ os.write(ws.data(), size);
+}
+#endif
+
+} // namespace archive
+} // namespace boost
+
+#endif
+
diff --git a/include/boost/archive/impl/xml_iarchive_impl.ipp b/include/boost/archive/impl/xml_iarchive_impl.ipp
new file mode 100644
index 0000000..efc32e0
--- /dev/null
+++ b/include/boost/archive/impl/xml_iarchive_impl.ipp
@@ -0,0 +1,199 @@
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// xml_iarchive_impl.cpp:
+
+// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
+// Distributed under the Boost Software License, Version 1.0. (See
+// accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+
+// See http://www.boost.org for updates, documentation, and revision history.
+
+#include <boost/config.hpp>
+#include <cstring> // memcpy
+#include <cstddef> // NULL
+#include <exception>
+
+#if defined(BOOST_NO_STDC_NAMESPACE)
+namespace std{
+ using ::memcpy;
+} // namespace std
+#endif
+
+#ifndef BOOST_NO_CWCHAR
+#include <cwchar> // mbstate_t and mbrtowc
+#if defined(BOOST_NO_STDC_NAMESPACE)
+namespace std{
+ using ::mbstate_t;
+ using ::mbrtowc;
+ } // namespace std
+#endif
+#endif // BOOST_NO_CWCHAR
+
+#include <boost/detail/workaround.hpp> // RogueWave and Dinkumware
+#if BOOST_WORKAROUND(BOOST_DINKUMWARE_STDLIB, == 1)
+#include <boost/archive/dinkumware.hpp>
+#endif
+
+#include <boost/core/no_exceptions_support.hpp>
+
+#include <boost/archive/xml_archive_exception.hpp>
+#include <boost/archive/iterators/dataflow_exception.hpp>
+#include <boost/archive/basic_xml_archive.hpp>
+#include <boost/archive/xml_iarchive.hpp>
+
+#include "basic_xml_grammar.hpp"
+
+namespace boost {
+namespace archive {
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// implemenations of functions specific to char archives
+
+// wide char stuff used by char archives
+
+#ifndef BOOST_NO_CWCHAR
+#ifndef BOOST_NO_STD_WSTRING
+template<class Archive>
+BOOST_ARCHIVE_DECL void
+xml_iarchive_impl<Archive>::load(std::wstring &ws){
+ std::string s;
+ bool result = gimpl->parse_string(is, s);
+ if(! result)
+ boost::serialization::throw_exception(
+ xml_archive_exception(xml_archive_exception::xml_archive_parsing_error)
+ );
+
+ #if BOOST_WORKAROUND(_RWSTD_VER, BOOST_TESTED_AT(20101))
+ if(NULL != ws.data())
+ #endif
+ ws.resize(0);
+ std::mbstate_t mbs = std::mbstate_t();
+ const char * start = s.data();
+ const char * end = start + s.size();
+ while(start < end){
+ wchar_t wc;
+ std::size_t count = std::mbrtowc(&wc, start, end - start, &mbs);
+ if(count == static_cast<std::size_t>(-1))
+ boost::serialization::throw_exception(
+ iterators::dataflow_exception(
+ iterators::dataflow_exception::invalid_conversion
+ )
+ );
+ if(count == static_cast<std::size_t>(-2))
+ continue;
+ start += count;
+ ws += wc;
+ }
+}
+#endif // BOOST_NO_STD_WSTRING
+
+#ifndef BOOST_NO_INTRINSIC_WCHAR_T
+template<class Archive>
+BOOST_ARCHIVE_DECL void
+xml_iarchive_impl<Archive>::load(wchar_t * ws){
+ std::string s;
+ bool result = gimpl->parse_string(is, s);
+ if(! result)
+ boost::serialization::throw_exception(
+ xml_archive_exception(
+ xml_archive_exception::xml_archive_parsing_error
+ )
+ );
+
+ std::mbstate_t mbs = std::mbstate_t();
+ const char * start = s.data();
+ const char * end = start + s.size();
+ while(start < end){
+ wchar_t wc;
+ std::size_t length = std::mbrtowc(&wc, start, end - start, &mbs);
+ if(static_cast<std::size_t>(-1) == length)
+ boost::serialization::throw_exception(
+ iterators::dataflow_exception(
+ iterators::dataflow_exception::invalid_conversion
+ )
+ );
+ if(static_cast<std::size_t>(-2) == length)
+ continue;
+
+ start += length;
+ *ws++ = wc;
+ }
+ *ws = L'\0';
+}
+#endif // BOOST_NO_INTRINSIC_WCHAR_T
+
+#endif // BOOST_NO_CWCHAR
+
+template<class Archive>
+BOOST_ARCHIVE_DECL void
+xml_iarchive_impl<Archive>::load(std::string &s){
+ bool result = gimpl->parse_string(is, s);
+ if(! result)
+ boost::serialization::throw_exception(
+ xml_archive_exception(xml_archive_exception::xml_archive_parsing_error)
+ );
+}
+
+template<class Archive>
+BOOST_ARCHIVE_DECL void
+xml_iarchive_impl<Archive>::load(char * s){
+ std::string tstring;
+ bool result = gimpl->parse_string(is, tstring);
+ if(! result)
+ boost::serialization::throw_exception(
+ xml_archive_exception(xml_archive_exception::xml_archive_parsing_error)
+ );
+ std::memcpy(s, tstring.data(), tstring.size());
+ s[tstring.size()] = 0;
+}
+
+template<class Archive>
+BOOST_ARCHIVE_DECL void
+xml_iarchive_impl<Archive>::load_override(class_name_type & t){
+ const std::string & s = gimpl->rv.class_name;
+ if(s.size() > BOOST_SERIALIZATION_MAX_KEY_SIZE - 1)
+ boost::serialization::throw_exception(
+ archive_exception(archive_exception::invalid_class_name)
+ );
+ char * tptr = t;
+ std::memcpy(tptr, s.data(), s.size());
+ tptr[s.size()] = '\0';
+}
+
+template<class Archive>
+BOOST_ARCHIVE_DECL void
+xml_iarchive_impl<Archive>::init(){
+ gimpl->init(is);
+ this->set_library_version(
+ library_version_type(gimpl->rv.version)
+ );
+}
+
+template<class Archive>
+BOOST_ARCHIVE_DECL
+xml_iarchive_impl<Archive>::xml_iarchive_impl(
+ std::istream &is_,
+ unsigned int flags
+) :
+ basic_text_iprimitive<std::istream>(
+ is_,
+ 0 != (flags & no_codecvt)
+ ),
+ basic_xml_iarchive<Archive>(flags),
+ gimpl(new xml_grammar())
+{
+ if(0 == (flags & no_header))
+ init();
+}
+
+template<class Archive>
+BOOST_ARCHIVE_DECL
+xml_iarchive_impl<Archive>::~xml_iarchive_impl(){
+ if(std::uncaught_exception())
+ return;
+ if(0 == (this->get_flags() & no_header)){
+ gimpl->windup(is);
+ }
+}
+} // namespace archive
+} // namespace boost
diff --git a/include/boost/archive/impl/xml_oarchive_impl.ipp b/include/boost/archive/impl/xml_oarchive_impl.ipp
new file mode 100644
index 0000000..5ebd454
--- /dev/null
+++ b/include/boost/archive/impl/xml_oarchive_impl.ipp
@@ -0,0 +1,142 @@
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// xml_oarchive_impl.ipp:
+
+// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
+// Distributed under the Boost Software License, Version 1.0. (See
+// accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+
+#include <ostream>
+#include <iomanip>
+#include <algorithm> // std::copy
+#include <string>
+#include <exception>
+
+#include <cstring> // strlen
+#include <boost/config.hpp> // msvc 6.0 needs this to suppress warnings
+#if defined(BOOST_NO_STDC_NAMESPACE)
+namespace std{
+ using ::strlen;
+} // namespace std
+#endif
+
+#include <boost/archive/iterators/xml_escape.hpp>
+#include <boost/archive/iterators/ostream_iterator.hpp>
+
+#ifndef BOOST_NO_CWCHAR
+#include <boost/archive/wcslen.hpp>
+#include <boost/archive/iterators/mb_from_wchar.hpp>
+#endif
+
+namespace boost {
+namespace archive {
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// implemenations of functions specific to char archives
+
+// wide char stuff used by char archives
+#ifndef BOOST_NO_CWCHAR
+// copy chars to output escaping to xml and translating wide chars to mb chars
+template<class InputIterator>
+void save_iterator(std::ostream &os, InputIterator begin, InputIterator end){
+ typedef boost::archive::iterators::mb_from_wchar<
+ boost::archive::iterators::xml_escape<InputIterator>
+ > translator;
+ std::copy(
+ translator(begin),
+ translator(end),
+ boost::archive::iterators::ostream_iterator<char>(os)
+ );
+}
+
+#ifndef BOOST_NO_STD_WSTRING
+template<class Archive>
+BOOST_ARCHIVE_DECL void
+xml_oarchive_impl<Archive>::save(const std::wstring & ws){
+// at least one library doesn't typedef value_type for strings
+// so rather than using string directly make a pointer iterator out of it
+// save_iterator(os, ws.data(), ws.data() + std::wcslen(ws.data()));
+ save_iterator(os, ws.data(), ws.data() + ws.size());
+}
+#endif
+
+#ifndef BOOST_NO_INTRINSIC_WCHAR_T
+template<class Archive>
+BOOST_ARCHIVE_DECL void
+xml_oarchive_impl<Archive>::save(const wchar_t * ws){
+ save_iterator(os, ws, ws + std::wcslen(ws));
+}
+#endif
+
+#endif // BOOST_NO_CWCHAR
+
+template<class Archive>
+BOOST_ARCHIVE_DECL void
+xml_oarchive_impl<Archive>::save(const std::string & s){
+// at least one library doesn't typedef value_type for strings
+// so rather than using string directly make a pointer iterator out of it
+ typedef boost::archive::iterators::xml_escape<
+ const char *
+ > xml_escape_translator;
+ std::copy(
+ xml_escape_translator(s.data()),
+ xml_escape_translator(s.data()+ s.size()),
+ boost::archive::iterators::ostream_iterator<char>(os)
+ );
+}
+
+template<class Archive>
+BOOST_ARCHIVE_DECL void
+xml_oarchive_impl<Archive>::save(const char * s){
+ typedef boost::archive::iterators::xml_escape<
+ const char *
+ > xml_escape_translator;
+ std::copy(
+ xml_escape_translator(s),
+ xml_escape_translator(s + std::strlen(s)),
+ boost::archive::iterators::ostream_iterator<char>(os)
+ );
+}
+
+template<class Archive>
+BOOST_ARCHIVE_DECL
+xml_oarchive_impl<Archive>::xml_oarchive_impl(
+ std::ostream & os_,
+ unsigned int flags
+) :
+ basic_text_oprimitive<std::ostream>(
+ os_,
+ 0 != (flags & no_codecvt)
+ ),
+ basic_xml_oarchive<Archive>(flags)
+{
+ if(0 == (flags & no_header))
+ this->init();
+}
+
+template<class Archive>
+BOOST_ARCHIVE_DECL void
+xml_oarchive_impl<Archive>::save_binary(const void *address, std::size_t count){
+ this->end_preamble();
+ #if ! defined(__MWERKS__)
+ this->basic_text_oprimitive<std::ostream>::save_binary(
+ #else
+ this->basic_text_oprimitive::save_binary(
+ #endif
+ address,
+ count
+ );
+ this->indent_next = true;
+}
+
+template<class Archive>
+BOOST_ARCHIVE_DECL
+xml_oarchive_impl<Archive>::~xml_oarchive_impl(){
+ if(std::uncaught_exception())
+ return;
+ if(0 == (this->get_flags() & no_header))
+ this->windup();
+}
+
+} // namespace archive
+} // namespace boost
diff --git a/include/boost/archive/impl/xml_wiarchive_impl.ipp b/include/boost/archive/impl/xml_wiarchive_impl.ipp
new file mode 100644
index 0000000..f572b76
--- /dev/null
+++ b/include/boost/archive/impl/xml_wiarchive_impl.ipp
@@ -0,0 +1,189 @@
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// xml_wiarchive_impl.ipp:
+
+// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
+// Distributed under the Boost Software License, Version 1.0. (See
+// accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+
+// See http://www.boost.org for updates, documentation, and revision history.
+
+#include <cstring>
+#if defined(BOOST_NO_STDC_NAMESPACE)
+namespace std{
+ using ::memcpy;
+} //std
+#endif
+
+#include <boost/config.hpp> // msvc 6.0 needs this to suppress warnings
+#ifndef BOOST_NO_STD_WSTREAMBUF
+
+#include <boost/assert.hpp>
+#include <algorithm> // std::copy
+#include <exception> // uncaught exception
+#include <boost/detail/workaround.hpp> // Dinkumware and RogueWave
+#if BOOST_WORKAROUND(BOOST_DINKUMWARE_STDLIB, == 1)
+#include <boost/archive/dinkumware.hpp>
+#endif
+
+#include <boost/io/ios_state.hpp>
+#include <boost/core/no_exceptions_support.hpp>
+#include <boost/serialization/string.hpp>
+
+#include <boost/archive/basic_xml_archive.hpp>
+#include <boost/archive/xml_wiarchive.hpp>
+
+#include <boost/archive/xml_archive_exception.hpp>
+#include <boost/archive/iterators/mb_from_wchar.hpp>
+
+#include <boost/archive/detail/utf8_codecvt_facet.hpp>
+
+#include "basic_xml_grammar.hpp"
+
+namespace boost {
+namespace archive {
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// implemenations of functions specific to wide char archives
+
+namespace { // anonymous
+
+void copy_to_ptr(char * s, const std::wstring & ws){
+ std::copy(
+ iterators::mb_from_wchar<std::wstring::const_iterator>(
+ ws.begin()
+ ),
+ iterators::mb_from_wchar<std::wstring::const_iterator>(
+ ws.end()
+ ),
+ s
+ );
+ s[ws.size()] = 0;
+}
+
+} // anonymous
+
+template<class Archive>
+BOOST_WARCHIVE_DECL void
+xml_wiarchive_impl<Archive>::load(std::string & s){
+ std::wstring ws;
+ bool result = gimpl->parse_string(is, ws);
+ if(! result)
+ boost::serialization::throw_exception(
+ xml_archive_exception(xml_archive_exception::xml_archive_parsing_error)
+ );
+ #if BOOST_WORKAROUND(_RWSTD_VER, BOOST_TESTED_AT(20101))
+ if(NULL != s.data())
+ #endif
+ s.resize(0);
+ s.reserve(ws.size());
+ std::copy(
+ iterators::mb_from_wchar<std::wstring::iterator>(
+ ws.begin()
+ ),
+ iterators::mb_from_wchar<std::wstring::iterator>(
+ ws.end()
+ ),
+ std::back_inserter(s)
+ );
+}
+
+#ifndef BOOST_NO_STD_WSTRING
+template<class Archive>
+BOOST_WARCHIVE_DECL void
+xml_wiarchive_impl<Archive>::load(std::wstring & ws){
+ bool result = gimpl->parse_string(is, ws);
+ if(! result)
+ boost::serialization::throw_exception(
+ xml_archive_exception(xml_archive_exception::xml_archive_parsing_error)
+ );
+}
+#endif
+
+template<class Archive>
+BOOST_WARCHIVE_DECL void
+xml_wiarchive_impl<Archive>::load(char * s){
+ std::wstring ws;
+ bool result = gimpl->parse_string(is, ws);
+ if(! result)
+ boost::serialization::throw_exception(
+ xml_archive_exception(xml_archive_exception::xml_archive_parsing_error)
+ );
+ copy_to_ptr(s, ws);
+}
+
+#ifndef BOOST_NO_INTRINSIC_WCHAR_T
+template<class Archive>
+BOOST_WARCHIVE_DECL void
+xml_wiarchive_impl<Archive>::load(wchar_t * ws){
+ std::wstring twstring;
+ bool result = gimpl->parse_string(is, twstring);
+ if(! result)
+ boost::serialization::throw_exception(
+ xml_archive_exception(xml_archive_exception::xml_archive_parsing_error)
+ );
+ std::memcpy(ws, twstring.c_str(), twstring.size());
+ ws[twstring.size()] = L'\0';
+}
+#endif
+
+template<class Archive>
+BOOST_WARCHIVE_DECL void
+xml_wiarchive_impl<Archive>::load_override(class_name_type & t){
+ const std::wstring & ws = gimpl->rv.class_name;
+ if(ws.size() > BOOST_SERIALIZATION_MAX_KEY_SIZE - 1)
+ boost::serialization::throw_exception(
+ archive_exception(archive_exception::invalid_class_name)
+ );
+ copy_to_ptr(t, ws);
+}
+
+template<class Archive>
+BOOST_WARCHIVE_DECL void
+xml_wiarchive_impl<Archive>::init(){
+ gimpl->init(is);
+ this->set_library_version(
+ library_version_type(gimpl->rv.version)
+ );
+}
+
+template<class Archive>
+BOOST_WARCHIVE_DECL
+xml_wiarchive_impl<Archive>::xml_wiarchive_impl(
+ std::wistream &is_,
+ unsigned int flags
+) :
+ basic_text_iprimitive<std::wistream>(
+ is_,
+ true // don't change the codecvt - use the one below
+ ),
+ basic_xml_iarchive<Archive>(flags),
+ gimpl(new xml_wgrammar())
+{
+ if(0 == (flags & no_codecvt)){
+ archive_locale = std::locale(
+ is_.getloc(),
+ new boost::archive::detail::utf8_codecvt_facet
+ );
+ // libstdc++ crashes without this
+ is_.sync();
+ is_.imbue(archive_locale);
+ }
+ if(0 == (flags & no_header))
+ init();
+}
+
+template<class Archive>
+BOOST_WARCHIVE_DECL
+xml_wiarchive_impl<Archive>::~xml_wiarchive_impl(){
+ if(std::uncaught_exception())
+ return;
+ if(0 == (this->get_flags() & no_header)){
+ gimpl->windup(is);
+ }
+}
+
+} // namespace archive
+} // namespace boost
+
+#endif // BOOST_NO_STD_WSTREAMBUF
diff --git a/include/boost/archive/impl/xml_woarchive_impl.ipp b/include/boost/archive/impl/xml_woarchive_impl.ipp
new file mode 100644
index 0000000..630898b
--- /dev/null
+++ b/include/boost/archive/impl/xml_woarchive_impl.ipp
@@ -0,0 +1,170 @@
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// xml_woarchive_impl.ipp:
+
+// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
+// Distributed under the Boost Software License, Version 1.0. (See
+// accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+
+#include <boost/config.hpp>
+#ifndef BOOST_NO_STD_WSTREAMBUF
+
+#include <ostream>
+#include <string>
+#include <algorithm> // std::copy
+#include <locale>
+#include <exception>
+
+#include <cstring> // strlen
+#include <cstdlib> // mbtowc
+#ifndef BOOST_NO_CWCHAR
+#include <cwchar> // wcslen
+#endif
+
+#include <boost/config.hpp>
+#if defined(BOOST_NO_STDC_NAMESPACE)
+namespace std{
+ using ::strlen;
+ #if ! defined(BOOST_NO_INTRINSIC_WCHAR_T)
+ using ::mbtowc;
+ using ::wcslen;
+ #endif
+} // namespace std
+#endif
+
+#include <boost/archive/xml_woarchive.hpp>
+#include <boost/archive/detail/utf8_codecvt_facet.hpp>
+
+#include <boost/serialization/throw_exception.hpp>
+
+#include <boost/archive/iterators/xml_escape.hpp>
+#include <boost/archive/iterators/wchar_from_mb.hpp>
+#include <boost/archive/iterators/ostream_iterator.hpp>
+#include <boost/archive/iterators/dataflow_exception.hpp>
+
+namespace boost {
+namespace archive {
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// implemenations of functions specific to wide char archives
+
+// copy chars to output escaping to xml and widening characters as we go
+template<class InputIterator>
+void save_iterator(std::wostream &os, InputIterator begin, InputIterator end){
+ typedef iterators::wchar_from_mb<
+ iterators::xml_escape<InputIterator>
+ > xmbtows;
+ std::copy(
+ xmbtows(begin),
+ xmbtows(end),
+ boost::archive::iterators::ostream_iterator<wchar_t>(os)
+ );
+}
+
+template<class Archive>
+BOOST_WARCHIVE_DECL void
+xml_woarchive_impl<Archive>::save(const std::string & s){
+ // note: we don't use s.begin() and s.end() because dinkumware
+ // doesn't have string::value_type defined. So use a wrapper
+ // around these values to implement the definitions.
+ const char * begin = s.data();
+ const char * end = begin + s.size();
+ save_iterator(os, begin, end);
+}
+
+#ifndef BOOST_NO_STD_WSTRING
+template<class Archive>
+BOOST_WARCHIVE_DECL void
+xml_woarchive_impl<Archive>::save(const std::wstring & ws){
+#if 0
+ typedef iterators::xml_escape<std::wstring::const_iterator> xmbtows;
+ std::copy(
+ xmbtows(ws.begin()),
+ xmbtows(ws.end()),
+ boost::archive::iterators::ostream_iterator<wchar_t>(os)
+ );
+#endif
+ typedef iterators::xml_escape<const wchar_t *> xmbtows;
+ std::copy(
+ xmbtows(ws.data()),
+ xmbtows(ws.data() + ws.size()),
+ boost::archive::iterators::ostream_iterator<wchar_t>(os)
+ );
+}
+#endif //BOOST_NO_STD_WSTRING
+
+template<class Archive>
+BOOST_WARCHIVE_DECL void
+xml_woarchive_impl<Archive>::save(const char * s){
+ save_iterator(os, s, s + std::strlen(s));
+}
+
+#ifndef BOOST_NO_INTRINSIC_WCHAR_T
+template<class Archive>
+BOOST_WARCHIVE_DECL void
+xml_woarchive_impl<Archive>::save(const wchar_t * ws){
+ typedef iterators::xml_escape<const wchar_t *> xmbtows;
+ std::copy(
+ xmbtows(ws),
+ xmbtows(ws + std::wcslen(ws)),
+ boost::archive::iterators::ostream_iterator<wchar_t>(os)
+ );
+}
+#endif
+
+template<class Archive>
+BOOST_WARCHIVE_DECL
+xml_woarchive_impl<Archive>::xml_woarchive_impl(
+ std::wostream & os_,
+ unsigned int flags
+) :
+ basic_text_oprimitive<std::wostream>(
+ os_,
+ true // don't change the codecvt - use the one below
+ ),
+ basic_xml_oarchive<Archive>(flags)
+{
+ if(0 == (flags & no_codecvt)){
+ archive_locale = std::locale(
+ os_.getloc(),
+ new boost::archive::detail::utf8_codecvt_facet
+ );
+ os_.flush();
+ os_.imbue(archive_locale);
+ }
+ if(0 == (flags & no_header))
+ this->init();
+}
+
+template<class Archive>
+BOOST_WARCHIVE_DECL
+xml_woarchive_impl<Archive>::~xml_woarchive_impl(){
+ if(std::uncaught_exception())
+ return;
+ if(0 == (this->get_flags() & no_header)){
+ os << L"</boost_serialization>";
+ }
+}
+
+template<class Archive>
+BOOST_WARCHIVE_DECL void
+xml_woarchive_impl<Archive>::save_binary(
+ const void *address,
+ std::size_t count
+){
+ this->end_preamble();
+ #if ! defined(__MWERKS__)
+ this->basic_text_oprimitive<std::wostream>::save_binary(
+ #else
+ this->basic_text_oprimitive::save_binary(
+ #endif
+ address,
+ count
+ );
+ this->indent_next = true;
+}
+
+} // namespace archive
+} // namespace boost
+
+#endif //BOOST_NO_STD_WSTREAMBUF
diff --git a/include/boost/archive/iterators/base64_exception.hpp b/include/boost/archive/iterators/base64_exception.hpp
new file mode 100644
index 0000000..8f9208b
--- /dev/null
+++ b/include/boost/archive/iterators/base64_exception.hpp
@@ -0,0 +1,68 @@
+#ifndef BOOST_ARCHIVE_ITERATORS_BASE64_EXCEPTION_HPP
+#define BOOST_ARCHIVE_ITERATORS_BASE64_EXCEPTION_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER)
+# pragma once
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// base64_exception.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 <boost/config.hpp>
+#ifndef BOOST_NO_EXCEPTIONS
+#include <exception>
+
+#include <boost/assert.hpp>
+
+namespace boost {
+namespace archive {
+namespace iterators {
+
+//////////////////////////////////////////////////////////////////////
+// exceptions thrown by base64s
+//
+class base64_exception : public std::exception
+{
+public:
+ typedef enum {
+ invalid_code, // attempt to encode a value > 6 bits
+ invalid_character, // decode a value not in base64 char set
+ other_exception
+ } exception_code;
+ exception_code code;
+
+ base64_exception(exception_code c = other_exception) : code(c)
+ {}
+
+ virtual const char *what( ) const throw( )
+ {
+ const char *msg = "unknown exception code";
+ switch(code){
+ case invalid_code:
+ msg = "attempt to encode a value > 6 bits";
+ break;
+ case invalid_character:
+ msg = "attempt to decode a value not in base64 char set";
+ break;
+ default:
+ BOOST_ASSERT(false);
+ break;
+ }
+ return msg;
+ }
+};
+
+} // namespace iterators
+} // namespace archive
+} // namespace boost
+
+#endif //BOOST_NO_EXCEPTIONS
+#endif //BOOST_ARCHIVE_ITERATORS_ARCHIVE_EXCEPTION_HPP
diff --git a/include/boost/archive/iterators/base64_from_binary.hpp b/include/boost/archive/iterators/base64_from_binary.hpp
new file mode 100644
index 0000000..ee84994
--- /dev/null
+++ b/include/boost/archive/iterators/base64_from_binary.hpp
@@ -0,0 +1,109 @@
+#ifndef BOOST_ARCHIVE_ITERATORS_BASE64_FROM_BINARY_HPP
+#define BOOST_ARCHIVE_ITERATORS_BASE64_FROM_BINARY_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER)
+# pragma once
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// base64_from_binary.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 <boost/assert.hpp>
+
+#include <cstddef> // size_t
+#if defined(BOOST_NO_STDC_NAMESPACE)
+namespace std{
+ using ::size_t;
+} // namespace std
+#endif
+
+#include <boost/iterator/transform_iterator.hpp>
+#include <boost/archive/iterators/dataflow_exception.hpp>
+
+namespace boost {
+namespace archive {
+namespace iterators {
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// convert binary integers to base64 characters
+
+namespace detail {
+
+template<class CharType>
+struct from_6_bit {
+ typedef CharType result_type;
+ CharType operator()(CharType t) const{
+ static const char * lookup_table =
+ "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
+ "abcdefghijklmnopqrstuvwxyz"
+ "0123456789"
+ "+/";
+ BOOST_ASSERT(t < 64);
+ return lookup_table[static_cast<size_t>(t)];
+ }
+};
+
+} // namespace detail
+
+// note: what we would like to do is
+// template<class Base, class CharType = typename Base::value_type>
+// typedef transform_iterator<
+// from_6_bit<CharType>,
+// transform_width<Base, 6, sizeof(Base::value_type) * 8, CharType>
+// > base64_from_binary;
+// but C++ won't accept this. Rather than using a "type generator" and
+// using a different syntax, make a derivation which should be equivalent.
+//
+// Another issue addressed here is that the transform_iterator doesn't have
+// a templated constructor. This makes it incompatible with the dataflow
+// ideal. This is also addressed here.
+
+//template<class Base, class CharType = typename Base::value_type>
+template<
+ class Base,
+ class CharType = typename boost::iterator_value<Base>::type
+>
+class base64_from_binary :
+ public transform_iterator<
+ detail::from_6_bit<CharType>,
+ Base
+ >
+{
+ friend class boost::iterator_core_access;
+ typedef transform_iterator<
+ typename detail::from_6_bit<CharType>,
+ Base
+ > super_t;
+
+public:
+ // make composible buy using templated constructor
+ template<class T>
+ base64_from_binary(T start) :
+ super_t(
+ Base(static_cast< T >(start)),
+ detail::from_6_bit<CharType>()
+ )
+ {}
+ // intel 7.1 doesn't like default copy constructor
+ base64_from_binary(const base64_from_binary & rhs) :
+ super_t(
+ Base(rhs.base_reference()),
+ detail::from_6_bit<CharType>()
+ )
+ {}
+// base64_from_binary(){};
+};
+
+} // namespace iterators
+} // namespace archive
+} // namespace boost
+
+#endif // BOOST_ARCHIVE_ITERATORS_BASE64_FROM_BINARY_HPP
diff --git a/include/boost/archive/iterators/binary_from_base64.hpp b/include/boost/archive/iterators/binary_from_base64.hpp
new file mode 100644
index 0000000..89b8f88
--- /dev/null
+++ b/include/boost/archive/iterators/binary_from_base64.hpp
@@ -0,0 +1,118 @@
+#ifndef BOOST_ARCHIVE_ITERATORS_BINARY_FROM_BASE64_HPP
+#define BOOST_ARCHIVE_ITERATORS_BINARY_FROM_BASE64_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER)
+# pragma once
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// binary_from_base64.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 <boost/assert.hpp>
+
+#include <boost/serialization/throw_exception.hpp>
+#include <boost/static_assert.hpp>
+
+#include <boost/iterator/transform_iterator.hpp>
+#include <boost/archive/iterators/dataflow_exception.hpp>
+
+namespace boost {
+namespace archive {
+namespace iterators {
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// convert base64 characters to binary data
+
+namespace detail {
+
+template<class CharType>
+struct to_6_bit {
+ typedef CharType result_type;
+ CharType operator()(CharType t) const{
+ static const signed char lookup_table[] = {
+ -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
+ -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
+ -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,62,-1,-1,-1,63,
+ 52,53,54,55,56,57,58,59,60,61,-1,-1,-1, 0,-1,-1, // render '=' as 0
+ -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9,10,11,12,13,14,
+ 15,16,17,18,19,20,21,22,23,24,25,-1,-1,-1,-1,-1,
+ -1,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,
+ 41,42,43,44,45,46,47,48,49,50,51,-1,-1,-1,-1,-1
+ };
+ // metrowerks trips this assertion - how come?
+ #if ! defined(__MWERKS__)
+ BOOST_STATIC_ASSERT(128 == sizeof(lookup_table));
+ #endif
+ signed char value = -1;
+ if((unsigned)t <= 127)
+ value = lookup_table[(unsigned)t];
+ if(-1 == value)
+ boost::serialization::throw_exception(
+ dataflow_exception(dataflow_exception::invalid_base64_character)
+ );
+ return value;
+ }
+};
+
+} // namespace detail
+
+// note: what we would like to do is
+// template<class Base, class CharType = typename Base::value_type>
+// typedef transform_iterator<
+// from_6_bit<CharType>,
+// transform_width<Base, 6, sizeof(Base::value_type) * 8, CharType>
+// > base64_from_binary;
+// but C++ won't accept this. Rather than using a "type generator" and
+// using a different syntax, make a derivation which should be equivalent.
+//
+// Another issue addressed here is that the transform_iterator doesn't have
+// a templated constructor. This makes it incompatible with the dataflow
+// ideal. This is also addressed here.
+
+template<
+ class Base,
+ class CharType = typename boost::iterator_value<Base>::type
+>
+class binary_from_base64 : public
+ transform_iterator<
+ detail::to_6_bit<CharType>,
+ Base
+ >
+{
+ friend class boost::iterator_core_access;
+ typedef transform_iterator<
+ detail::to_6_bit<CharType>,
+ Base
+ > super_t;
+public:
+ // make composible buy using templated constructor
+ template<class T>
+ binary_from_base64(T start) :
+ super_t(
+ Base(static_cast< T >(start)),
+ detail::to_6_bit<CharType>()
+ )
+ {}
+ // intel 7.1 doesn't like default copy constructor
+ binary_from_base64(const binary_from_base64 & rhs) :
+ super_t(
+ Base(rhs.base_reference()),
+ detail::to_6_bit<CharType>()
+ )
+ {}
+// binary_from_base64(){};
+};
+
+} // namespace iterators
+} // namespace archive
+} // namespace boost
+
+#endif // BOOST_ARCHIVE_ITERATORS_BINARY_FROM_BASE64_HPP
diff --git a/include/boost/archive/iterators/dataflow.hpp b/include/boost/archive/iterators/dataflow.hpp
new file mode 100644
index 0000000..07733d5
--- /dev/null
+++ b/include/boost/archive/iterators/dataflow.hpp
@@ -0,0 +1,102 @@
+#ifndef BOOST_ARCHIVE_ITERATORS_DATAFLOW_HPP
+#define BOOST_ARCHIVE_ITERATORS_DATAFLOW_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER)
+# pragma once
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// dataflow.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 <boost/assert.hpp>
+
+#include <boost/mpl/eval_if.hpp>
+#include <boost/mpl/if.hpp>
+#include <boost/mpl/apply.hpp>
+#include <boost/mpl/plus.hpp>
+#include <boost/mpl/int.hpp>
+
+#include <boost/type_traits/is_convertible.hpp>
+#include <boost/type_traits/is_base_and_derived.hpp>
+#include <boost/type_traits/is_pointer.hpp>
+#include <boost/iterator/iterator_adaptor.hpp>
+#include <boost/iterator/iterator_traits.hpp>
+#include <boost/static_assert.hpp>
+
+namespace boost {
+namespace archive {
+namespace iterators {
+
+// poor man's tri-state
+struct tri_state {
+ enum state_enum {
+ is_false = false,
+ is_true = true,
+ is_indeterminant
+ } m_state;
+ // convert to bool
+ operator bool (){
+ BOOST_ASSERT(is_indeterminant != m_state);
+ return is_true == m_state ? true : false;
+ }
+ // assign from bool
+ tri_state & operator=(bool rhs) {
+ m_state = rhs ? is_true : is_false;
+ return *this;
+ }
+ tri_state(bool rhs) :
+ m_state(rhs ? is_true : is_false)
+ {}
+ tri_state(state_enum state) :
+ m_state(state)
+ {}
+ bool operator==(const tri_state & rhs) const {
+ return m_state == rhs.m_state;
+ }
+ bool operator!=(const tri_state & rhs) const {
+ return m_state != rhs.m_state;
+ }
+};
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// implement functions common to dataflow iterators
+template<class Derived>
+class dataflow {
+ bool m_eoi;
+protected:
+ // test for iterator equality
+ tri_state equal(const Derived & rhs) const {
+ if(m_eoi && rhs.m_eoi)
+ return true;
+ if(m_eoi || rhs.m_eoi)
+ return false;
+ return tri_state(tri_state::is_indeterminant);
+ }
+ void eoi(bool tf){
+ m_eoi = tf;
+ }
+ bool eoi() const {
+ return m_eoi;
+ }
+public:
+ dataflow(bool tf) :
+ m_eoi(tf)
+ {}
+ dataflow() : // used for iterator end
+ m_eoi(true)
+ {}
+};
+
+} // namespace iterators
+} // namespace archive
+} // namespace boost
+
+#endif // BOOST_ARCHIVE_ITERATORS_DATAFLOW_HPP
diff --git a/include/boost/archive/iterators/dataflow_exception.hpp b/include/boost/archive/iterators/dataflow_exception.hpp
new file mode 100644
index 0000000..e3e1860
--- /dev/null
+++ b/include/boost/archive/iterators/dataflow_exception.hpp
@@ -0,0 +1,80 @@
+#ifndef BOOST_ARCHIVE_ITERATORS_DATAFLOW_EXCEPTION_HPP
+#define BOOST_ARCHIVE_ITERATORS_DATAFLOW_EXCEPTION_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER)
+# pragma once
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// dataflow_exception.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 <boost/config.hpp>
+#ifndef BOOST_NO_EXCEPTIONS
+#include <exception>
+#endif //BOOST_NO_EXCEPTIONS
+
+#include <boost/assert.hpp>
+
+namespace boost {
+namespace archive {
+namespace iterators {
+
+//////////////////////////////////////////////////////////////////////
+// exceptions thrown by dataflows
+//
+class dataflow_exception : public std::exception
+{
+public:
+ typedef enum {
+ invalid_6_bitcode,
+ invalid_base64_character,
+ invalid_xml_escape_sequence,
+ comparison_not_permitted,
+ invalid_conversion,
+ other_exception
+ } exception_code;
+ exception_code code;
+
+ dataflow_exception(exception_code c = other_exception) : code(c)
+ {}
+
+ virtual const char *what( ) const throw( )
+ {
+ const char *msg = "unknown exception code";
+ switch(code){
+ case invalid_6_bitcode:
+ msg = "attempt to encode a value > 6 bits";
+ break;
+ case invalid_base64_character:
+ msg = "attempt to decode a value not in base64 char set";
+ break;
+ case invalid_xml_escape_sequence:
+ msg = "invalid xml escape_sequence";
+ break;
+ case comparison_not_permitted:
+ msg = "cannot invoke iterator comparison now";
+ break;
+ case invalid_conversion:
+ msg = "invalid multbyte/wide char conversion";
+ break;
+ default:
+ BOOST_ASSERT(false);
+ break;
+ }
+ return msg;
+ }
+};
+
+} // namespace iterators
+} // namespace archive
+} // namespace boost
+
+#endif //BOOST_ARCHIVE_ITERATORS_DATAFLOW_EXCEPTION_HPP
diff --git a/include/boost/archive/iterators/escape.hpp b/include/boost/archive/iterators/escape.hpp
new file mode 100644
index 0000000..103b31e
--- /dev/null
+++ b/include/boost/archive/iterators/escape.hpp
@@ -0,0 +1,115 @@
+#ifndef BOOST_ARCHIVE_ITERATORS_ESCAPE_HPP
+#define BOOST_ARCHIVE_ITERATORS_ESCAPE_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER)
+# pragma once
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// escape.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 <boost/assert.hpp>
+#include <cstddef> // NULL
+
+#include <boost/iterator/iterator_adaptor.hpp>
+#include <boost/iterator/iterator_traits.hpp>
+
+namespace boost {
+namespace archive {
+namespace iterators {
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// insert escapes into text
+
+template<class Derived, class Base>
+class escape :
+ public boost::iterator_adaptor<
+ Derived,
+ Base,
+ typename boost::iterator_value<Base>::type,
+ single_pass_traversal_tag,
+ typename boost::iterator_value<Base>::type
+ >
+{
+ typedef typename boost::iterator_value<Base>::type base_value_type;
+ typedef typename boost::iterator_reference<Base>::type reference_type;
+ friend class boost::iterator_core_access;
+
+ typedef typename boost::iterator_adaptor<
+ Derived,
+ Base,
+ base_value_type,
+ single_pass_traversal_tag,
+ base_value_type
+ > super_t;
+
+ typedef escape<Derived, Base> this_t;
+
+ void dereference_impl() {
+ m_current_value = static_cast<Derived *>(this)->fill(m_bnext, m_bend);
+ m_full = true;
+ }
+
+ //Access the value referred to
+ reference_type dereference() const {
+ if(!m_full)
+ const_cast<this_t *>(this)->dereference_impl();
+ return m_current_value;
+ }
+
+ bool equal(const this_t & rhs) const {
+ if(m_full){
+ if(! rhs.m_full)
+ const_cast<this_t *>(& rhs)->dereference_impl();
+ }
+ else{
+ if(rhs.m_full)
+ const_cast<this_t *>(this)->dereference_impl();
+ }
+ if(m_bnext != rhs.m_bnext)
+ return false;
+ if(this->base_reference() != rhs.base_reference())
+ return false;
+ return true;
+ }
+
+ void increment(){
+ if(++m_bnext < m_bend){
+ m_current_value = *m_bnext;
+ return;
+ }
+ ++(this->base_reference());
+ m_bnext = NULL;
+ m_bend = NULL;
+ m_full = false;
+ }
+
+ // buffer to handle pending characters
+ const base_value_type *m_bnext;
+ const base_value_type *m_bend;
+ bool m_full;
+ base_value_type m_current_value;
+public:
+ escape(Base base) :
+ super_t(base),
+ m_bnext(NULL),
+ m_bend(NULL),
+ m_full(false),
+ m_current_value(0)
+ {
+ }
+};
+
+} // namespace iterators
+} // namespace archive
+} // namespace boost
+
+#endif // BOOST_ARCHIVE_ITERATORS_ESCAPE_HPP
diff --git a/include/boost/archive/iterators/insert_linebreaks.hpp b/include/boost/archive/iterators/insert_linebreaks.hpp
new file mode 100644
index 0000000..2504b03
--- /dev/null
+++ b/include/boost/archive/iterators/insert_linebreaks.hpp
@@ -0,0 +1,99 @@
+#ifndef BOOST_ARCHIVE_ITERATORS_INSERT_LINEBREAKS_HPP
+#define BOOST_ARCHIVE_ITERATORS_INSERT_LINEBREAKS_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER)
+# pragma once
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// insert_linebreaks.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 <boost/assert.hpp>
+
+#include <boost/config.hpp>
+#if defined(BOOST_NO_STDC_NAMESPACE)
+namespace std{ using ::memcpy; }
+#endif
+
+#include <boost/iterator/iterator_adaptor.hpp>
+#include <boost/iterator/iterator_traits.hpp>
+
+namespace boost {
+namespace archive {
+namespace iterators {
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// insert line break every N characters
+template<
+ class Base,
+ int N,
+ class CharType = typename boost::iterator_value<Base>::type
+>
+class insert_linebreaks :
+ public iterator_adaptor<
+ insert_linebreaks<Base, N, CharType>,
+ Base,
+ CharType,
+ single_pass_traversal_tag,
+ CharType
+ >
+{
+private:
+ friend class boost::iterator_core_access;
+ typedef iterator_adaptor<
+ insert_linebreaks<Base, N, CharType>,
+ Base,
+ CharType,
+ single_pass_traversal_tag,
+ CharType
+ > super_t;
+
+ bool equal(const insert_linebreaks<Base, N, CharType> & rhs) const {
+ return
+// m_count == rhs.m_count
+// && base_reference() == rhs.base_reference()
+ this->base_reference() == rhs.base_reference()
+ ;
+ }
+
+ void increment() {
+ if(m_count == N){
+ m_count = 0;
+ return;
+ }
+ ++m_count;
+ ++(this->base_reference());
+ }
+ CharType dereference() const {
+ if(m_count == N)
+ return '\n';
+ return * (this->base_reference());
+ }
+ unsigned int m_count;
+public:
+ // make composible buy using templated constructor
+ template<class T>
+ insert_linebreaks(T start) :
+ super_t(Base(static_cast< T >(start))),
+ m_count(0)
+ {}
+ // intel 7.1 doesn't like default copy constructor
+ insert_linebreaks(const insert_linebreaks & rhs) :
+ super_t(rhs.base_reference()),
+ m_count(rhs.m_count)
+ {}
+};
+
+} // namespace iterators
+} // namespace archive
+} // namespace boost
+
+#endif // BOOST_ARCHIVE_ITERATORS_INSERT_LINEBREAKS_HPP
diff --git a/include/boost/archive/iterators/istream_iterator.hpp b/include/boost/archive/iterators/istream_iterator.hpp
new file mode 100644
index 0000000..a187f60
--- /dev/null
+++ b/include/boost/archive/iterators/istream_iterator.hpp
@@ -0,0 +1,92 @@
+#ifndef BOOST_ARCHIVE_ITERATORS_ISTREAM_ITERATOR_HPP
+#define BOOST_ARCHIVE_ITERATORS_ISTREAM_ITERATOR_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER)
+# pragma once
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// istream_iterator.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.
+
+// note: this is a custom version of the standard istream_iterator.
+// This is necessary as the standard version doesn't work as expected
+// for wchar_t based streams on systems for which wchar_t not a true
+// type but rather a synonym for some integer type.
+
+#include <cstddef> // NULL
+#include <istream>
+#include <boost/iterator/iterator_facade.hpp>
+
+namespace boost {
+namespace archive {
+namespace iterators {
+
+// given a type, make an input iterator based on a pointer to that type
+template<class Elem = char>
+class istream_iterator :
+ public boost::iterator_facade<
+ istream_iterator<Elem>,
+ Elem,
+ std::input_iterator_tag,
+ Elem
+ >
+{
+ friend class boost::iterator_core_access;
+ typedef istream_iterator this_t ;
+ typedef typename boost::iterator_facade<
+ istream_iterator<Elem>,
+ Elem,
+ std::input_iterator_tag,
+ Elem
+ > super_t;
+ typedef typename std::basic_istream<Elem> istream_type;
+
+ bool equal(const this_t & rhs) const {
+ // note: only works for comparison against end of stream
+ return m_istream == rhs.m_istream;
+ }
+
+ //Access the value referred to
+ Elem dereference() const {
+ return static_cast<Elem>(m_istream->peek());
+ }
+
+ void increment(){
+ if(NULL != m_istream){
+ m_istream->ignore(1);
+ }
+ }
+
+ istream_type *m_istream;
+ Elem m_current_value;
+public:
+ istream_iterator(istream_type & is) :
+ m_istream(& is)
+ {
+ //increment();
+ }
+
+ istream_iterator() :
+ m_istream(NULL),
+ m_current_value(NULL)
+ {}
+
+ istream_iterator(const istream_iterator<Elem> & rhs) :
+ m_istream(rhs.m_istream),
+ m_current_value(rhs.m_current_value)
+ {}
+};
+
+} // namespace iterators
+} // namespace archive
+} // namespace boost
+
+#endif // BOOST_ARCHIVE_ITERATORS_ISTREAM_ITERATOR_HPP
diff --git a/include/boost/archive/iterators/mb_from_wchar.hpp b/include/boost/archive/iterators/mb_from_wchar.hpp
new file mode 100644
index 0000000..eb30480
--- /dev/null
+++ b/include/boost/archive/iterators/mb_from_wchar.hpp
@@ -0,0 +1,142 @@
+#ifndef BOOST_ARCHIVE_ITERATORS_MB_FROM_WCHAR_HPP
+#define BOOST_ARCHIVE_ITERATORS_MB_FROM_WCHAR_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER)
+# pragma once
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// mb_from_wchar.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 <boost/assert.hpp>
+#include <cstddef> // size_t
+#ifndef BOOST_NO_CWCHAR
+#include <cwchar> // mbstate_t
+#endif
+#include <boost/config.hpp>
+#if defined(BOOST_NO_STDC_NAMESPACE)
+namespace std{
+ using ::mbstate_t;
+} // namespace std
+#endif
+
+#include <boost/archive/detail/utf8_codecvt_facet.hpp>
+#include <boost/iterator/iterator_adaptor.hpp>
+
+namespace boost {
+namespace archive {
+namespace iterators {
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// class used by text archives to translate wide strings and to char
+// strings of the currently selected locale
+template<class Base> // the input iterator
+class mb_from_wchar
+ : public boost::iterator_adaptor<
+ mb_from_wchar<Base>,
+ Base,
+ wchar_t,
+ single_pass_traversal_tag,
+ char
+ >
+{
+ friend class boost::iterator_core_access;
+
+ typedef typename boost::iterator_adaptor<
+ mb_from_wchar<Base>,
+ Base,
+ wchar_t,
+ single_pass_traversal_tag,
+ char
+ > super_t;
+
+ typedef mb_from_wchar<Base> this_t;
+
+ char dereference_impl() {
+ if(! m_full){
+ fill();
+ m_full = true;
+ }
+ return m_buffer[m_bnext];
+ }
+
+ char dereference() const {
+ return (const_cast<this_t *>(this))->dereference_impl();
+ }
+ // test for iterator equality
+ bool equal(const mb_from_wchar<Base> & rhs) const {
+ // once the value is filled, the base_reference has been incremented
+ // so don't permit comparison anymore.
+ return
+ 0 == m_bend
+ && 0 == m_bnext
+ && this->base_reference() == rhs.base_reference()
+ ;
+ }
+
+ void fill(){
+ wchar_t value = * this->base_reference();
+ const wchar_t *wend;
+ char *bend;
+ BOOST_VERIFY(
+ m_codecvt_facet.out(
+ m_mbs,
+ & value, & value + 1, wend,
+ m_buffer, m_buffer + sizeof(m_buffer), bend
+ )
+ ==
+ std::codecvt_base::ok
+ );
+ m_bnext = 0;
+ m_bend = bend - m_buffer;
+ }
+
+ void increment(){
+ if(++m_bnext < m_bend)
+ return;
+ m_bend =
+ m_bnext = 0;
+ ++(this->base_reference());
+ m_full = false;
+ }
+
+ boost::archive::detail::utf8_codecvt_facet m_codecvt_facet;
+ std::mbstate_t m_mbs;
+ // buffer to handle pending characters
+ char m_buffer[9 /* MB_CUR_MAX */];
+ std::size_t m_bend;
+ std::size_t m_bnext;
+ bool m_full;
+
+public:
+ // make composible buy using templated constructor
+ template<class T>
+ mb_from_wchar(T start) :
+ super_t(Base(static_cast< T >(start))),
+ m_mbs(std::mbstate_t()),
+ m_bend(0),
+ m_bnext(0),
+ m_full(false)
+ {}
+ // intel 7.1 doesn't like default copy constructor
+ mb_from_wchar(const mb_from_wchar & rhs) :
+ super_t(rhs.base_reference()),
+ m_bend(rhs.m_bend),
+ m_bnext(rhs.m_bnext),
+ m_full(rhs.m_full)
+ {}
+};
+
+} // namespace iterators
+} // namespace archive
+} // namespace boost
+
+#endif // BOOST_ARCHIVE_ITERATORS_MB_FROM_WCHAR_HPP
diff --git a/include/boost/archive/iterators/ostream_iterator.hpp b/include/boost/archive/iterators/ostream_iterator.hpp
new file mode 100644
index 0000000..49a9b99
--- /dev/null
+++ b/include/boost/archive/iterators/ostream_iterator.hpp
@@ -0,0 +1,83 @@
+#ifndef BOOST_ARCHIVE_ITERATORS_OSTREAM_ITERATOR_HPP
+#define BOOST_ARCHIVE_ITERATORS_OSTREAM_ITERATOR_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER)
+# pragma once
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// ostream_iterator.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.
+
+// note: this is a custom version of the standard ostream_iterator.
+// This is necessary as the standard version doesn't work as expected
+// for wchar_t based streams on systems for which wchar_t not a true
+// type but rather a synonym for some integer type.
+
+#include <ostream>
+#include <boost/iterator/iterator_facade.hpp>
+
+namespace boost {
+namespace archive {
+namespace iterators {
+
+// given a type, make an input iterator based on a pointer to that type
+template<class Elem>
+class ostream_iterator :
+ public boost::iterator_facade<
+ ostream_iterator<Elem>,
+ Elem,
+ std::output_iterator_tag,
+ ostream_iterator<Elem> &
+ >
+{
+ friend class boost::iterator_core_access;
+ typedef ostream_iterator this_t ;
+ typedef Elem char_type;
+ typedef std::basic_ostream<char_type> ostream_type;
+
+ //emulate the behavior of std::ostream
+ ostream_iterator & dereference() const {
+ return const_cast<ostream_iterator &>(*this);
+ }
+ bool equal(const this_t & rhs) const {
+ return m_ostream == rhs.m_ostream;
+ }
+ void increment(){}
+protected:
+ ostream_type *m_ostream;
+ void put_val(char_type e){
+ if(NULL != m_ostream){
+ m_ostream->put(e);
+ if(! m_ostream->good())
+ m_ostream = NULL;
+ }
+ }
+public:
+ this_t & operator=(char_type c){
+ put_val(c);
+ return *this;
+ }
+ ostream_iterator(ostream_type & os) :
+ m_ostream (& os)
+ {}
+ ostream_iterator() :
+ m_ostream (NULL)
+ {}
+ ostream_iterator(const ostream_iterator & rhs) :
+ m_ostream (rhs.m_ostream)
+ {}
+};
+
+} // namespace iterators
+} // namespace archive
+} // namespace boost
+
+#endif // BOOST_ARCHIVE_ITERATORS_OSTREAM_ITERATOR_HPP
diff --git a/include/boost/archive/iterators/remove_whitespace.hpp b/include/boost/archive/iterators/remove_whitespace.hpp
new file mode 100644
index 0000000..c3580ab
--- /dev/null
+++ b/include/boost/archive/iterators/remove_whitespace.hpp
@@ -0,0 +1,167 @@
+#ifndef BOOST_ARCHIVE_ITERATORS_REMOVE_WHITESPACE_HPP
+#define BOOST_ARCHIVE_ITERATORS_REMOVE_WHITESPACE_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER)
+# pragma once
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// remove_whitespace.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 <boost/assert.hpp>
+
+#include <boost/iterator/iterator_adaptor.hpp>
+#include <boost/iterator/filter_iterator.hpp>
+#include <boost/iterator/iterator_traits.hpp>
+
+// here is the default standard implementation of the functor used
+// by the filter iterator to remove spaces. Unfortunately usage
+// of this implementation in combination with spirit trips a bug
+// VC 6.5. The only way I can find to work around it is to
+// implement a special non-standard version for this platform
+
+#ifndef BOOST_NO_CWCTYPE
+#include <cwctype> // iswspace
+#if defined(BOOST_NO_STDC_NAMESPACE)
+namespace std{ using ::iswspace; }
+#endif
+#endif
+
+#include <cctype> // isspace
+#if defined(BOOST_NO_STDC_NAMESPACE)
+namespace std{ using ::isspace; }
+#endif
+
+#if defined(__STD_RWCOMPILER_H__) || defined(_RWSTD_VER)
+// this is required for the RW STL on Linux and Tru64.
+#undef isspace
+#undef iswspace
+#endif
+
+namespace { // anonymous
+
+template<class CharType>
+struct remove_whitespace_predicate;
+
+template<>
+struct remove_whitespace_predicate<char>
+{
+ bool operator()(unsigned char t){
+ return ! std::isspace(t);
+ }
+};
+
+#ifndef BOOST_NO_CWCHAR
+template<>
+struct remove_whitespace_predicate<wchar_t>
+{
+ bool operator()(wchar_t t){
+ return ! std::iswspace(t);
+ }
+};
+#endif
+
+} // namespace anonymous
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// convert base64 file data (including whitespace and padding) to binary
+
+namespace boost {
+namespace archive {
+namespace iterators {
+
+// custom version of filter iterator which doesn't look ahead further than
+// necessary
+
+template<class Predicate, class Base>
+class filter_iterator
+ : public boost::iterator_adaptor<
+ filter_iterator<Predicate, Base>,
+ Base,
+ use_default,
+ single_pass_traversal_tag
+ >
+{
+ friend class boost::iterator_core_access;
+ typedef typename boost::iterator_adaptor<
+ filter_iterator<Predicate, Base>,
+ Base,
+ use_default,
+ single_pass_traversal_tag
+ > super_t;
+ typedef filter_iterator<Predicate, Base> this_t;
+ typedef typename super_t::reference reference_type;
+
+ reference_type dereference_impl(){
+ if(! m_full){
+ while(! m_predicate(* this->base_reference()))
+ ++(this->base_reference());
+ m_full = true;
+ }
+ return * this->base_reference();
+ }
+
+ reference_type dereference() const {
+ return const_cast<this_t *>(this)->dereference_impl();
+ }
+
+ Predicate m_predicate;
+ bool m_full;
+public:
+ // note: this function is public only because comeau compiler complained
+ // I don't know if this is because the compiler is wrong or what
+ void increment(){
+ m_full = false;
+ ++(this->base_reference());
+ }
+ filter_iterator(Base start) :
+ super_t(start),
+ m_full(false)
+ {}
+ filter_iterator(){}
+};
+
+template<class Base>
+class remove_whitespace :
+ public filter_iterator<
+ remove_whitespace_predicate<
+ typename boost::iterator_value<Base>::type
+ //typename Base::value_type
+ >,
+ Base
+ >
+{
+ friend class boost::iterator_core_access;
+ typedef filter_iterator<
+ remove_whitespace_predicate<
+ typename boost::iterator_value<Base>::type
+ //typename Base::value_type
+ >,
+ Base
+ > super_t;
+public:
+// remove_whitespace(){} // why is this needed?
+ // make composible buy using templated constructor
+ template<class T>
+ remove_whitespace(T start) :
+ super_t(Base(static_cast< T >(start)))
+ {}
+ // intel 7.1 doesn't like default copy constructor
+ remove_whitespace(const remove_whitespace & rhs) :
+ super_t(rhs.base_reference())
+ {}
+};
+
+} // namespace iterators
+} // namespace archive
+} // namespace boost
+
+#endif // BOOST_ARCHIVE_ITERATORS_REMOVE_WHITESPACE_HPP
diff --git a/include/boost/archive/iterators/transform_width.hpp b/include/boost/archive/iterators/transform_width.hpp
new file mode 100644
index 0000000..09c050a
--- /dev/null
+++ b/include/boost/archive/iterators/transform_width.hpp
@@ -0,0 +1,177 @@
+#ifndef BOOST_ARCHIVE_ITERATORS_TRANSFORM_WIDTH_HPP
+#define BOOST_ARCHIVE_ITERATORS_TRANSFORM_WIDTH_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER)
+# pragma once
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// transform_width.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.
+
+// iterator which takes elements of x bits and returns elements of y bits.
+// used to change streams of 8 bit characters into streams of 6 bit characters.
+// and vice-versa for implementing base64 encodeing/decoding. Be very careful
+// when using and end iterator. end is only reliable detected when the input
+// stream length is some common multiple of x and y. E.G. Base64 6 bit
+// character and 8 bit bytes. Lowest common multiple is 24 => 4 6 bit characters
+// or 3 8 bit characters
+
+#include <boost/iterator/iterator_adaptor.hpp>
+#include <boost/iterator/iterator_traits.hpp>
+
+#include <algorithm> // std::min
+
+namespace boost {
+namespace archive {
+namespace iterators {
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// class used by text archives to translate char strings to wchar_t
+// strings of the currently selected locale
+template<
+ class Base,
+ int BitsOut,
+ int BitsIn,
+ class CharType = typename boost::iterator_value<Base>::type // output character
+>
+class transform_width :
+ public boost::iterator_adaptor<
+ transform_width<Base, BitsOut, BitsIn, CharType>,
+ Base,
+ CharType,
+ single_pass_traversal_tag,
+ CharType
+ >
+{
+ friend class boost::iterator_core_access;
+ typedef typename boost::iterator_adaptor<
+ transform_width<Base, BitsOut, BitsIn, CharType>,
+ Base,
+ CharType,
+ single_pass_traversal_tag,
+ CharType
+ > super_t;
+
+ typedef transform_width<Base, BitsOut, BitsIn, CharType> this_t;
+ typedef typename iterator_value<Base>::type base_value_type;
+
+ void fill();
+
+ CharType dereference() const {
+ if(!m_buffer_out_full)
+ const_cast<this_t *>(this)->fill();
+ return m_buffer_out;
+ }
+
+ bool equal_impl(const this_t & rhs){
+ if(BitsIn < BitsOut) // discard any left over bits
+ return this->base_reference() == rhs.base_reference();
+ else{
+ // BitsIn > BitsOut // zero fill
+ if(this->base_reference() == rhs.base_reference()){
+ m_end_of_sequence = true;
+ return 0 == m_remaining_bits;
+ }
+ return false;
+ }
+ }
+
+ // standard iterator interface
+ bool equal(const this_t & rhs) const {
+ return const_cast<this_t *>(this)->equal_impl(rhs);
+ }
+
+ void increment(){
+ m_buffer_out_full = false;
+ }
+
+ bool m_buffer_out_full;
+ CharType m_buffer_out;
+
+ // last read element from input
+ base_value_type m_buffer_in;
+
+ // number of bits to left in the input buffer.
+ unsigned int m_remaining_bits;
+
+ // flag to indicate we've reached end of data.
+ bool m_end_of_sequence;
+
+public:
+ // make composible buy using templated constructor
+ template<class T>
+ transform_width(T start) :
+ super_t(Base(static_cast< T >(start))),
+ m_buffer_out_full(false),
+ m_buffer_out(0),
+ // To disable GCC warning, but not truly necessary
+ //(m_buffer_in will be initialized later before being
+ //used because m_remaining_bits == 0)
+ m_buffer_in(0),
+ m_remaining_bits(0),
+ m_end_of_sequence(false)
+ {}
+ // intel 7.1 doesn't like default copy constructor
+ transform_width(const transform_width & rhs) :
+ super_t(rhs.base_reference()),
+ m_buffer_out_full(rhs.m_buffer_out_full),
+ m_buffer_out(rhs.m_buffer_out),
+ m_buffer_in(rhs.m_buffer_in),
+ m_remaining_bits(rhs.m_remaining_bits),
+ m_end_of_sequence(false)
+ {}
+};
+
+template<
+ class Base,
+ int BitsOut,
+ int BitsIn,
+ class CharType
+>
+void transform_width<Base, BitsOut, BitsIn, CharType>::fill() {
+ unsigned int missing_bits = BitsOut;
+ m_buffer_out = 0;
+ do{
+ if(0 == m_remaining_bits){
+ if(m_end_of_sequence){
+ m_buffer_in = 0;
+ m_remaining_bits = missing_bits;
+ }
+ else{
+ m_buffer_in = * this->base_reference()++;
+ m_remaining_bits = BitsIn;
+ }
+ }
+
+ // append these bits to the next output
+ // up to the size of the output
+ unsigned int i = (std::min)(missing_bits, m_remaining_bits);
+ // shift interesting bits to least significant position
+ base_value_type j = m_buffer_in >> (m_remaining_bits - i);
+ // and mask off the un interesting higher bits
+ // note presumption of twos complement notation
+ j &= (1 << i) - 1;
+ // append then interesting bits to the output value
+ m_buffer_out <<= i;
+ m_buffer_out |= j;
+
+ // and update counters
+ missing_bits -= i;
+ m_remaining_bits -= i;
+ }while(0 < missing_bits);
+ m_buffer_out_full = true;
+}
+
+} // namespace iterators
+} // namespace archive
+} // namespace boost
+
+#endif // BOOST_ARCHIVE_ITERATORS_TRANSFORM_WIDTH_HPP
diff --git a/include/boost/archive/iterators/unescape.hpp b/include/boost/archive/iterators/unescape.hpp
new file mode 100644
index 0000000..abf6240
--- /dev/null
+++ b/include/boost/archive/iterators/unescape.hpp
@@ -0,0 +1,89 @@
+#ifndef BOOST_ARCHIVE_ITERATORS_UNESCAPE_HPP
+#define BOOST_ARCHIVE_ITERATORS_UNESCAPE_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER)
+# pragma once
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// unescape.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 <boost/assert.hpp>
+
+#include <boost/iterator/iterator_adaptor.hpp>
+#include <boost/pointee.hpp>
+
+namespace boost {
+namespace archive {
+namespace iterators {
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// class used by text archives to translate char strings to wchar_t
+// strings of the currently selected locale
+template<class Derived, class Base>
+class unescape
+ : public boost::iterator_adaptor<
+ unescape<Derived, Base>,
+ Base,
+ typename pointee<Base>::type,
+ single_pass_traversal_tag,
+ typename pointee<Base>::type
+ >
+{
+ friend class boost::iterator_core_access;
+ typedef typename boost::iterator_adaptor<
+ unescape<Derived, Base>,
+ Base,
+ typename pointee<Base>::type,
+ single_pass_traversal_tag,
+ typename pointee<Base>::type
+ > super_t;
+
+ typedef unescape<Derived, Base> this_t;
+public:
+ typedef typename this_t::value_type value_type;
+ typedef typename this_t::reference reference;
+private:
+ value_type dereference_impl() {
+ if(! m_full){
+ m_current_value = static_cast<Derived *>(this)->drain();
+ m_full = true;
+ }
+ return m_current_value;
+ }
+
+ reference dereference() const {
+ return const_cast<this_t *>(this)->dereference_impl();
+ }
+
+ value_type m_current_value;
+ bool m_full;
+
+ void increment(){
+ ++(this->base_reference());
+ dereference_impl();
+ m_full = false;
+ };
+
+public:
+
+ unescape(Base base) :
+ super_t(base),
+ m_full(false)
+ {}
+
+};
+
+} // namespace iterators
+} // namespace archive
+} // namespace boost
+
+#endif // BOOST_ARCHIVE_ITERATORS_UNESCAPE_HPP
diff --git a/include/boost/archive/iterators/wchar_from_mb.hpp b/include/boost/archive/iterators/wchar_from_mb.hpp
new file mode 100644
index 0000000..2af8f64
--- /dev/null
+++ b/include/boost/archive/iterators/wchar_from_mb.hpp
@@ -0,0 +1,194 @@
+#ifndef BOOST_ARCHIVE_ITERATORS_WCHAR_FROM_MB_HPP
+#define BOOST_ARCHIVE_ITERATORS_WCHAR_FROM_MB_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER)
+# pragma once
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// wchar_from_mb.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 <boost/assert.hpp>
+#include <cctype>
+#include <cstddef> // size_t
+#ifndef BOOST_NO_CWCHAR
+#include <cwchar> // mbstate_t
+#endif
+#include <algorithm> // copy
+
+#include <boost/config.hpp>
+#if defined(BOOST_NO_STDC_NAMESPACE)
+namespace std{
+ using ::mbstate_t;
+} // namespace std
+#endif
+#include <boost/array.hpp>
+#include <boost/iterator/iterator_adaptor.hpp>
+#include <boost/archive/detail/utf8_codecvt_facet.hpp>
+#include <boost/archive/iterators/dataflow_exception.hpp>
+#include <boost/serialization/throw_exception.hpp>
+
+#include <iostream>
+
+namespace boost {
+namespace archive {
+namespace iterators {
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// class used by text archives to translate char strings to wchar_t
+// strings of the currently selected locale
+template<class Base>
+class wchar_from_mb
+ : public boost::iterator_adaptor<
+ wchar_from_mb<Base>,
+ Base,
+ wchar_t,
+ single_pass_traversal_tag,
+ wchar_t
+ >
+{
+ friend class boost::iterator_core_access;
+ typedef typename boost::iterator_adaptor<
+ wchar_from_mb<Base>,
+ Base,
+ wchar_t,
+ single_pass_traversal_tag,
+ wchar_t
+ > super_t;
+
+ typedef wchar_from_mb<Base> this_t;
+
+ void drain();
+
+ wchar_t dereference() const {
+ if(m_output.m_next == m_output.m_next_available)
+ return static_cast<wchar_t>(0);
+ return * m_output.m_next;
+ }
+
+ void increment(){
+ if(m_output.m_next == m_output.m_next_available)
+ return;
+ if(++m_output.m_next == m_output.m_next_available){
+ if(m_input.m_done)
+ return;
+ drain();
+ }
+ }
+
+ bool equal(this_t const & rhs) const {
+ return dereference() == rhs.dereference();
+ }
+
+ boost::archive::detail::utf8_codecvt_facet m_codecvt_facet;
+ std::mbstate_t m_mbs;
+
+ template<typename T>
+ struct sliding_buffer {
+ boost::array<T, 32> m_buffer;
+ typename boost::array<T, 32>::const_iterator m_next_available;
+ typename boost::array<T, 32>::iterator m_next;
+ bool m_done;
+ // default ctor
+ sliding_buffer() :
+ m_next_available(m_buffer.begin()),
+ m_next(m_buffer.begin()),
+ m_done(false)
+ {}
+ // copy ctor
+ sliding_buffer(const sliding_buffer & rhs) :
+ m_next_available(
+ std::copy(
+ rhs.m_buffer.begin(),
+ rhs.m_next_available,
+ m_buffer.begin()
+ )
+ ),
+ m_next(
+ m_buffer.begin() + (rhs.m_next - rhs.m_buffer.begin())
+ ),
+ m_done(rhs.m_done)
+ {}
+ };
+
+ sliding_buffer<typename iterator_value<Base>::type> m_input;
+ sliding_buffer<typename iterator_value<this_t>::type> m_output;
+
+public:
+ // make composible buy using templated constructor
+ template<class T>
+ wchar_from_mb(T start) :
+ super_t(Base(static_cast< T >(start))),
+ m_mbs(std::mbstate_t())
+ {
+ BOOST_ASSERT(std::mbsinit(&m_mbs));
+ drain();
+ }
+ // default constructor used as an end iterator
+ wchar_from_mb(){}
+
+ // copy ctor
+ wchar_from_mb(const wchar_from_mb & rhs) :
+ super_t(rhs.base_reference()),
+ m_mbs(rhs.m_mbs),
+ m_input(rhs.m_input),
+ m_output(rhs.m_output)
+ {}
+};
+
+template<class Base>
+void wchar_from_mb<Base>::drain(){
+ BOOST_ASSERT(! m_input.m_done);
+ for(;;){
+ typename boost::iterators::iterator_reference<Base>::type c = *(this->base_reference());
+ // a null character in a multibyte stream is takes as end of string
+ if(0 == c){
+ m_input.m_done = true;
+ break;
+ }
+ ++(this->base_reference());
+ * const_cast<typename iterator_value<Base>::type *>(
+ (m_input.m_next_available++)
+ ) = c;
+ // if input buffer is full - we're done for now
+ if(m_input.m_buffer.end() == m_input.m_next_available)
+ break;
+ }
+ const typename boost::iterators::iterator_value<Base>::type * input_new_start;
+ typename iterator_value<this_t>::type * next_available;
+
+ std::codecvt_base::result r = m_codecvt_facet.in(
+ m_mbs,
+ m_input.m_buffer.begin(),
+ m_input.m_next_available,
+ input_new_start,
+ m_output.m_buffer.begin(),
+ m_output.m_buffer.end(),
+ next_available
+ );
+ BOOST_ASSERT(std::codecvt_base::ok == r);
+ m_output.m_next_available = next_available;
+ m_output.m_next = m_output.m_buffer.begin();
+
+ // we're done with some of the input so shift left.
+ m_input.m_next_available = std::copy(
+ input_new_start,
+ m_input.m_next_available,
+ m_input.m_buffer.begin()
+ );
+ m_input.m_next = m_input.m_buffer.begin();
+}
+
+} // namespace iterators
+} // namespace archive
+} // namespace boost
+
+#endif // BOOST_ARCHIVE_ITERATORS_WCHAR_FROM_MB_HPP
diff --git a/include/boost/archive/iterators/xml_escape.hpp b/include/boost/archive/iterators/xml_escape.hpp
new file mode 100644
index 0000000..c838a73
--- /dev/null
+++ b/include/boost/archive/iterators/xml_escape.hpp
@@ -0,0 +1,121 @@
+#ifndef BOOST_ARCHIVE_ITERATORS_XML_ESCAPE_HPP
+#define BOOST_ARCHIVE_ITERATORS_XML_ESCAPE_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER)
+# pragma once
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// xml_escape.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 <boost/assert.hpp>
+#include <boost/archive/iterators/escape.hpp>
+
+namespace boost {
+namespace archive {
+namespace iterators {
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// insert escapes into xml text
+
+template<class Base>
+class xml_escape
+ : public escape<xml_escape<Base>, Base>
+{
+ friend class boost::iterator_core_access;
+
+ typedef escape<xml_escape<Base>, Base> super_t;
+
+public:
+ char fill(const char * & bstart, const char * & bend);
+ wchar_t fill(const wchar_t * & bstart, const wchar_t * & bend);
+
+ template<class T>
+ xml_escape(T start) :
+ super_t(Base(static_cast< T >(start)))
+ {}
+ // intel 7.1 doesn't like default copy constructor
+ xml_escape(const xml_escape & rhs) :
+ super_t(rhs.base_reference())
+ {}
+};
+
+template<class Base>
+char xml_escape<Base>::fill(
+ const char * & bstart,
+ const char * & bend
+){
+ char current_value = * this->base_reference();
+ switch(current_value){
+ case '<':
+ bstart = "<";
+ bend = bstart + 4;
+ break;
+ case '>':
+ bstart = ">";
+ bend = bstart + 4;
+ break;
+ case '&':
+ bstart = "&";
+ bend = bstart + 5;
+ break;
+ case '"':
+ bstart = """;
+ bend = bstart + 6;
+ break;
+ case '\'':
+ bstart = "'";
+ bend = bstart + 6;
+ break;
+ default:
+ return current_value;
+ }
+ return *bstart;
+}
+
+template<class Base>
+wchar_t xml_escape<Base>::fill(
+ const wchar_t * & bstart,
+ const wchar_t * & bend
+){
+ wchar_t current_value = * this->base_reference();
+ switch(current_value){
+ case '<':
+ bstart = L"<";
+ bend = bstart + 4;
+ break;
+ case '>':
+ bstart = L">";
+ bend = bstart + 4;
+ break;
+ case '&':
+ bstart = L"&";
+ bend = bstart + 5;
+ break;
+ case '"':
+ bstart = L""";
+ bend = bstart + 6;
+ break;
+ case '\'':
+ bstart = L"'";
+ bend = bstart + 6;
+ break;
+ default:
+ return current_value;
+ }
+ return *bstart;
+}
+
+} // namespace iterators
+} // namespace archive
+} // namespace boost
+
+#endif // BOOST_ARCHIVE_ITERATORS_XML_ESCAPE_HPP
diff --git a/include/boost/archive/iterators/xml_unescape.hpp b/include/boost/archive/iterators/xml_unescape.hpp
new file mode 100644
index 0000000..9d3c3af
--- /dev/null
+++ b/include/boost/archive/iterators/xml_unescape.hpp
@@ -0,0 +1,127 @@
+#ifndef BOOST_ARCHIVE_ITERATORS_XML_UNESCAPE_HPP
+#define BOOST_ARCHIVE_ITERATORS_XML_UNESCAPE_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER)
+# pragma once
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// xml_unescape.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 <boost/config.hpp>
+#include <boost/detail/workaround.hpp>
+#include <boost/assert.hpp>
+
+#include <boost/serialization/throw_exception.hpp>
+
+#include <boost/archive/iterators/unescape.hpp>
+#include <boost/archive/iterators/dataflow_exception.hpp>
+
+namespace boost {
+namespace archive {
+namespace iterators {
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// replace &??? xml escape sequences with the corresponding characters
+template<class Base>
+class xml_unescape
+ : public unescape<xml_unescape<Base>, Base>
+{
+ friend class boost::iterator_core_access;
+ typedef xml_unescape<Base> this_t;
+ typedef unescape<this_t, Base> super_t;
+ typedef typename boost::iterator_reference<this_t> reference_type;
+
+ reference_type dereference() const {
+ return unescape<xml_unescape<Base>, Base>::dereference();
+ }
+public:
+ // msvc versions prior to 14.0 crash with and ICE
+ #if BOOST_WORKAROUND(BOOST_MSVC, < 1900)
+ typedef int value_type;
+ #else
+ typedef typename super_t::value_type value_type;
+ #endif
+
+ void drain_residue(const char *literal);
+ value_type drain();
+
+ template<class T>
+ xml_unescape(T start) :
+ super_t(Base(static_cast< T >(start)))
+ {}
+ // intel 7.1 doesn't like default copy constructor
+ xml_unescape(const xml_unescape & rhs) :
+ super_t(rhs.base_reference())
+ {}
+};
+
+template<class Base>
+void xml_unescape<Base>::drain_residue(const char * literal){
+ do{
+ if(* literal != * ++(this->base_reference()))
+ boost::serialization::throw_exception(
+ dataflow_exception(
+ dataflow_exception::invalid_xml_escape_sequence
+ )
+ );
+ }
+ while('\0' != * ++literal);
+}
+
+// note key constraint on this function is that can't "look ahead" any
+// more than necessary into base iterator. Doing so would alter the base
+// iterator refenence which would make subsequent iterator comparisons
+// incorrect and thereby break the composiblity of iterators.
+template<class Base>
+typename xml_unescape<Base>::value_type
+//int
+xml_unescape<Base>::drain(){
+ value_type retval = * this->base_reference();
+ if('&' != retval){
+ return retval;
+ }
+ retval = * ++(this->base_reference());
+ switch(retval){
+ case 'l': // <
+ drain_residue("t;");
+ retval = '<';
+ break;
+ case 'g': // >
+ drain_residue("t;");
+ retval = '>';
+ break;
+ case 'a':
+ retval = * ++(this->base_reference());
+ switch(retval){
+ case 'p': // '
+ drain_residue("os;");
+ retval = '\'';
+ break;
+ case 'm': // &
+ drain_residue("p;");
+ retval = '&';
+ break;
+ }
+ break;
+ case 'q':
+ drain_residue("uot;");
+ retval = '"';
+ break;
+ }
+ return retval;
+}
+
+} // namespace iterators
+} // namespace archive
+} // namespace boost
+
+#endif // BOOST_ARCHIVE_ITERATORS_XML_UNESCAPE_HPP
diff --git a/include/boost/archive/iterators/xml_unescape_exception.hpp b/include/boost/archive/iterators/xml_unescape_exception.hpp
new file mode 100644
index 0000000..71a6437
--- /dev/null
+++ b/include/boost/archive/iterators/xml_unescape_exception.hpp
@@ -0,0 +1,49 @@
+#ifndef BOOST_ARCHIVE_ITERATORS_XML_UNESCAPE_EXCEPTION_HPP
+#define BOOST_ARCHIVE_ITERATORS_XML_UNESCAPE_EXCEPTION_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER)
+# pragma once
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// xml_unescape_exception.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 <boost/config.hpp>
+#ifndef BOOST_NO_EXCEPTIONS
+#include <exception>
+
+#include <boost/assert.hpp>
+
+namespace boost {
+namespace archive {
+namespace iterators {
+
+//////////////////////////////////////////////////////////////////////
+// exceptions thrown by xml_unescapes
+//
+class xml_unescape_exception : public std::exception
+{
+public:
+ xml_unescape_exception()
+ {}
+
+ virtual const char *what( ) const throw( )
+ {
+ return "xml contained un-recognized escape code";
+ }
+};
+
+} // namespace iterators
+} // namespace archive
+} // namespace boost
+
+#endif //BOOST_NO_EXCEPTIONS
+#endif //BOOST_ARCHIVE_ITERATORS_XML_UNESCAPE_EXCEPTION_HPP
diff --git a/include/boost/archive/polymorphic_binary_iarchive.hpp b/include/boost/archive/polymorphic_binary_iarchive.hpp
new file mode 100644
index 0000000..4a898a8
--- /dev/null
+++ b/include/boost/archive/polymorphic_binary_iarchive.hpp
@@ -0,0 +1,54 @@
+#ifndef BOOST_ARCHIVE_POLYMORPHIC_BINARY_IARCHIVE_HPP
+#define BOOST_ARCHIVE_POLYMORPHIC_BINARY_IARCHIVE_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER)
+# pragma once
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// polymorphic_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 <boost/config.hpp>
+#include <boost/archive/binary_iarchive.hpp>
+#include <boost/archive/detail/polymorphic_iarchive_route.hpp>
+
+#ifdef BOOST_MSVC
+# pragma warning(push)
+# pragma warning(disable : 4511 4512)
+#endif
+
+namespace boost {
+namespace archive {
+
+class polymorphic_binary_iarchive :
+ public detail::polymorphic_iarchive_route<binary_iarchive>
+{
+public:
+ polymorphic_binary_iarchive(std::istream & is, unsigned int flags = 0) :
+ detail::polymorphic_iarchive_route<binary_iarchive>(is, flags)
+ {}
+ ~polymorphic_binary_iarchive(){}
+};
+
+} // namespace archive
+} // namespace boost
+
+#ifdef BOOST_MSVC
+#pragma warning(pop)
+#endif
+
+// required by export
+BOOST_SERIALIZATION_REGISTER_ARCHIVE(
+ boost::archive::polymorphic_binary_iarchive
+)
+
+#endif // BOOST_ARCHIVE_POLYMORPHIC_BINARY_IARCHIVE_HPP
+
diff --git a/include/boost/archive/polymorphic_binary_oarchive.hpp b/include/boost/archive/polymorphic_binary_oarchive.hpp
new file mode 100644
index 0000000..931b243
--- /dev/null
+++ b/include/boost/archive/polymorphic_binary_oarchive.hpp
@@ -0,0 +1,43 @@
+#ifndef BOOST_ARCHIVE_POLYMORPHIC_BINARY_OARCHIVE_HPP
+#define BOOST_ARCHIVE_POLYMORPHIC_BINARY_OARCHIVE_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER)
+# pragma once
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// polymorphic_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 <boost/config.hpp>
+#include <boost/archive/binary_oarchive.hpp>
+#include <boost/archive/detail/polymorphic_oarchive_route.hpp>
+
+namespace boost {
+namespace archive {
+
+typedef detail::polymorphic_oarchive_route<
+ binary_oarchive_impl<
+ binary_oarchive,
+ std::ostream::char_type,
+ std::ostream::traits_type
+ >
+ > polymorphic_binary_oarchive;
+
+} // namespace archive
+} // namespace boost
+
+// required by export
+BOOST_SERIALIZATION_REGISTER_ARCHIVE(
+ boost::archive::polymorphic_binary_oarchive
+)
+
+#endif // BOOST_ARCHIVE_POLYMORPHIC_BINARY_OARCHIVE_HPP
+
diff --git a/include/boost/archive/polymorphic_iarchive.hpp b/include/boost/archive/polymorphic_iarchive.hpp
new file mode 100644
index 0000000..d3c59a9
--- /dev/null
+++ b/include/boost/archive/polymorphic_iarchive.hpp
@@ -0,0 +1,168 @@
+#ifndef BOOST_ARCHIVE_POLYMORPHIC_IARCHIVE_HPP
+#define BOOST_ARCHIVE_POLYMORPHIC_IARCHIVE_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER)
+# pragma once
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// polymorphic_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 <cstddef> // std::size_t
+#include <climits> // ULONG_MAX
+#include <string>
+
+#include <boost/config.hpp>
+#if defined(BOOST_NO_STDC_NAMESPACE)
+namespace std{
+ using ::size_t;
+} // namespace std
+#endif
+
+#include <boost/cstdint.hpp>
+
+#include <boost/archive/detail/iserializer.hpp>
+#include <boost/archive/detail/interface_iarchive.hpp>
+#include <boost/serialization/nvp.hpp>
+#include <boost/archive/detail/register_archive.hpp>
+
+#include <boost/archive/detail/decl.hpp>
+#include <boost/archive/detail/abi_prefix.hpp> // must be the last header
+
+namespace boost {
+namespace serialization {
+ class extended_type_info;
+} // namespace serialization
+namespace archive {
+namespace detail {
+ class basic_iarchive;
+ class basic_iserializer;
+}
+
+class polymorphic_iarchive;
+
+class BOOST_SYMBOL_VISIBLE polymorphic_iarchive_impl :
+ public detail::interface_iarchive<polymorphic_iarchive>
+{
+#ifdef BOOST_NO_MEMBER_TEMPLATE_FRIENDS
+public:
+#else
+ friend class detail::interface_iarchive<polymorphic_iarchive>;
+ friend class load_access;
+#endif
+ // primitive types the only ones permitted by polymorphic archives
+ virtual void load(bool & t) = 0;
+
+ virtual void load(char & t) = 0;
+ virtual void load(signed char & t) = 0;
+ virtual void load(unsigned char & t) = 0;
+ #ifndef BOOST_NO_CWCHAR
+ #ifndef BOOST_NO_INTRINSIC_WCHAR_T
+ virtual void load(wchar_t & t) = 0;
+ #endif
+ #endif
+ virtual void load(short & t) = 0;
+ virtual void load(unsigned short & t) = 0;
+ virtual void load(int & t) = 0;
+ virtual void load(unsigned int & t) = 0;
+ virtual void load(long & t) = 0;
+ virtual void load(unsigned long & t) = 0;
+
+ #if defined(BOOST_HAS_LONG_LONG)
+ virtual void load(boost::long_long_type & t) = 0;
+ virtual void load(boost::ulong_long_type & t) = 0;
+ #elif defined(BOOST_HAS_MS_INT64)
+ virtual void load(__int64 & t) = 0;
+ virtual void load(unsigned __int64 & t) = 0;
+ #endif
+
+ virtual void load(float & t) = 0;
+ virtual void load(double & t) = 0;
+
+ // string types are treated as primitives
+ virtual void load(std::string & t) = 0;
+ #ifndef BOOST_NO_STD_WSTRING
+ virtual void load(std::wstring & t) = 0;
+ #endif
+
+ // used for xml and other tagged formats
+ virtual void load_start(const char * name) = 0;
+ virtual void load_end(const char * name) = 0;
+ virtual void register_basic_serializer(const detail::basic_iserializer & bis) = 0;
+ virtual detail::helper_collection & get_helper_collection() = 0;
+
+ // msvc and borland won't automatically pass these to the base class so
+ // make it explicit here
+ template<class T>
+ void load_override(T & t)
+ {
+ archive::load(* this->This(), t);
+ }
+ // special treatment for name-value pairs.
+ template<class T>
+ void load_override(
+ const boost::serialization::nvp< T > & t
+ ){
+ load_start(t.name());
+ archive::load(* this->This(), t.value());
+ load_end(t.name());
+ }
+protected:
+ virtual ~polymorphic_iarchive_impl(){};
+public:
+ // utility function implemented by all legal archives
+ virtual void set_library_version(library_version_type archive_library_version) = 0;
+ virtual library_version_type get_library_version() const = 0;
+ virtual unsigned int get_flags() const = 0;
+ virtual void delete_created_pointers() = 0;
+ virtual void reset_object_address(
+ const void * new_address,
+ const void * old_address
+ ) = 0;
+
+ virtual void load_binary(void * t, std::size_t size) = 0;
+
+ // these are used by the serialization library implementation.
+ virtual void load_object(
+ void *t,
+ const detail::basic_iserializer & bis
+ ) = 0;
+ virtual const detail::basic_pointer_iserializer * load_pointer(
+ void * & t,
+ const detail::basic_pointer_iserializer * bpis_ptr,
+ const detail::basic_pointer_iserializer * (*finder)(
+ const boost::serialization::extended_type_info & type
+ )
+ ) = 0;
+};
+
+} // namespace archive
+} // namespace boost
+
+#include <boost/archive/detail/abi_suffix.hpp> // pops abi_suffix.hpp pragmas
+
+namespace boost {
+namespace archive {
+
+class BOOST_SYMBOL_VISIBLE polymorphic_iarchive :
+ public polymorphic_iarchive_impl
+{
+public:
+ virtual ~polymorphic_iarchive(){};
+};
+
+} // namespace archive
+} // namespace boost
+
+// required by export
+BOOST_SERIALIZATION_REGISTER_ARCHIVE(boost::archive::polymorphic_iarchive)
+
+#endif // BOOST_ARCHIVE_POLYMORPHIC_IARCHIVE_HPP
diff --git a/include/boost/archive/polymorphic_oarchive.hpp b/include/boost/archive/polymorphic_oarchive.hpp
new file mode 100644
index 0000000..edac4ed
--- /dev/null
+++ b/include/boost/archive/polymorphic_oarchive.hpp
@@ -0,0 +1,154 @@
+#ifndef BOOST_ARCHIVE_POLYMORPHIC_OARCHIVE_HPP
+#define BOOST_ARCHIVE_POLYMORPHIC_OARCHIVE_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER)
+# pragma once
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// polymorphic_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 <cstddef> // size_t
+#include <climits> // ULONG_MAX
+#include <string>
+
+#include <boost/config.hpp>
+#if defined(BOOST_NO_STDC_NAMESPACE)
+namespace std{
+ using ::size_t;
+} // namespace std
+#endif
+
+#include <boost/cstdint.hpp>
+#include <boost/archive/detail/oserializer.hpp>
+#include <boost/archive/detail/interface_oarchive.hpp>
+#include <boost/serialization/nvp.hpp>
+#include <boost/archive/detail/register_archive.hpp>
+
+#include <boost/archive/detail/decl.hpp>
+#include <boost/archive/detail/abi_prefix.hpp> // must be the last header
+
+namespace boost {
+namespace serialization {
+ class extended_type_info;
+} // namespace serialization
+namespace archive {
+namespace detail {
+ class basic_oarchive;
+ class basic_oserializer;
+}
+
+class polymorphic_oarchive;
+
+class BOOST_SYMBOL_VISIBLE polymorphic_oarchive_impl :
+ public detail::interface_oarchive<polymorphic_oarchive>
+{
+#ifdef BOOST_NO_MEMBER_TEMPLATE_FRIENDS
+public:
+#else
+ friend class detail::interface_oarchive<polymorphic_oarchive>;
+ friend class save_access;
+#endif
+ // primitive types the only ones permitted by polymorphic archives
+ virtual void save(const bool t) = 0;
+
+ virtual void save(const char t) = 0;
+ virtual void save(const signed char t) = 0;
+ virtual void save(const unsigned char t) = 0;
+ #ifndef BOOST_NO_CWCHAR
+ #ifndef BOOST_NO_INTRINSIC_WCHAR_T
+ virtual void save(const wchar_t t) = 0;
+ #endif
+ #endif
+ virtual void save(const short t) = 0;
+ virtual void save(const unsigned short t) = 0;
+ virtual void save(const int t) = 0;
+ virtual void save(const unsigned int t) = 0;
+ virtual void save(const long t) = 0;
+ virtual void save(const unsigned long t) = 0;
+
+ #if defined(BOOST_HAS_LONG_LONG)
+ virtual void save(const boost::long_long_type t) = 0;
+ virtual void save(const boost::ulong_long_type t) = 0;
+ #elif defined(BOOST_HAS_MS_INT64)
+ virtual void save(const __int64 t) = 0;
+ virtual void save(const unsigned __int64 t) = 0;
+ #endif
+
+ virtual void save(const float t) = 0;
+ virtual void save(const double t) = 0;
+
+ // string types are treated as primitives
+ virtual void save(const std::string & t) = 0;
+ #ifndef BOOST_NO_STD_WSTRING
+ virtual void save(const std::wstring & t) = 0;
+ #endif
+
+ virtual void save_null_pointer() = 0;
+ // used for xml and other tagged formats
+ virtual void save_start(const char * name) = 0;
+ virtual void save_end(const char * name) = 0;
+ virtual void register_basic_serializer(const detail::basic_oserializer & bos) = 0;
+ virtual detail::helper_collection & get_helper_collection() = 0;
+
+ virtual void end_preamble() = 0;
+
+ // msvc and borland won't automatically pass these to the base class so
+ // make it explicit here
+ template<class T>
+ void save_override(T & t)
+ {
+ archive::save(* this->This(), t);
+ }
+ // special treatment for name-value pairs.
+ template<class T>
+ void save_override(
+ const ::boost::serialization::nvp< T > & t
+ ){
+ save_start(t.name());
+ archive::save(* this->This(), t.const_value());
+ save_end(t.name());
+ }
+protected:
+ virtual ~polymorphic_oarchive_impl(){};
+public:
+ // utility functions implemented by all legal archives
+ virtual unsigned int get_flags() const = 0;
+ virtual library_version_type get_library_version() const = 0;
+ virtual void save_binary(const void * t, std::size_t size) = 0;
+
+ virtual void save_object(
+ const void *x,
+ const detail::basic_oserializer & bos
+ ) = 0;
+ virtual void save_pointer(
+ const void * t,
+ const detail::basic_pointer_oserializer * bpos_ptr
+ ) = 0;
+};
+
+// note: preserve naming symmetry
+class BOOST_SYMBOL_VISIBLE polymorphic_oarchive :
+ public polymorphic_oarchive_impl
+{
+public:
+ virtual ~polymorphic_oarchive(){};
+};
+
+} // namespace archive
+} // namespace boost
+
+// required by export
+BOOST_SERIALIZATION_REGISTER_ARCHIVE(boost::archive::polymorphic_oarchive)
+
+#include <boost/archive/detail/abi_suffix.hpp> // pops abi_suffix.hpp pragmas
+
+#endif // BOOST_ARCHIVE_POLYMORPHIC_OARCHIVE_HPP
diff --git a/include/boost/archive/polymorphic_text_iarchive.hpp b/include/boost/archive/polymorphic_text_iarchive.hpp
new file mode 100644
index 0000000..7bef292
--- /dev/null
+++ b/include/boost/archive/polymorphic_text_iarchive.hpp
@@ -0,0 +1,54 @@
+#ifndef BOOST_ARCHIVE_POLYMORPHIC_TEXT_IARCHIVE_HPP
+#define BOOST_ARCHIVE_POLYMORPHIC_TEXT_IARCHIVE_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER)
+# pragma once
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// polymorphic_text_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 <boost/config.hpp>
+#include <boost/archive/text_iarchive.hpp>
+#include <boost/archive/detail/polymorphic_iarchive_route.hpp>
+
+#ifdef BOOST_MSVC
+# pragma warning(push)
+# pragma warning(disable : 4511 4512)
+#endif
+
+namespace boost {
+namespace archive {
+
+class polymorphic_text_iarchive :
+ public detail::polymorphic_iarchive_route<text_iarchive>
+{
+public:
+ polymorphic_text_iarchive(std::istream & is, unsigned int flags = 0) :
+ detail::polymorphic_iarchive_route<text_iarchive>(is, flags)
+ {}
+ ~polymorphic_text_iarchive(){}
+};
+
+} // namespace archive
+} // namespace boost
+
+#ifdef BOOST_MSVC
+#pragma warning(pop)
+#endif
+
+// required by export
+BOOST_SERIALIZATION_REGISTER_ARCHIVE(
+ boost::archive::polymorphic_text_iarchive
+)
+
+#endif // BOOST_ARCHIVE_POLYMORPHIC_TEXT_IARCHIVE_HPP
+
diff --git a/include/boost/archive/polymorphic_text_oarchive.hpp b/include/boost/archive/polymorphic_text_oarchive.hpp
new file mode 100644
index 0000000..457aad9
--- /dev/null
+++ b/include/boost/archive/polymorphic_text_oarchive.hpp
@@ -0,0 +1,39 @@
+#ifndef BOOST_ARCHIVE_POLYMORPHIC_TEXT_OARCHIVE_HPP
+#define BOOST_ARCHIVE_POLYMORPHIC_TEXT_OARCHIVE_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER)
+# pragma once
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// polymorphic_text_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 <boost/config.hpp>
+#include <boost/archive/text_oarchive.hpp>
+#include <boost/archive/detail/polymorphic_oarchive_route.hpp>
+
+namespace boost {
+namespace archive {
+
+typedef detail::polymorphic_oarchive_route<
+ text_oarchive_impl<text_oarchive>
+> polymorphic_text_oarchive;
+
+} // namespace archive
+} // namespace boost
+
+// required by export
+BOOST_SERIALIZATION_REGISTER_ARCHIVE(
+ boost::archive::polymorphic_text_oarchive
+)
+
+#endif // BOOST_ARCHIVE_POLYMORPHIC_TEXT_OARCHIVE_HPP
+
diff --git a/include/boost/archive/polymorphic_text_wiarchive.hpp b/include/boost/archive/polymorphic_text_wiarchive.hpp
new file mode 100644
index 0000000..8466f05
--- /dev/null
+++ b/include/boost/archive/polymorphic_text_wiarchive.hpp
@@ -0,0 +1,59 @@
+#ifndef BOOST_ARCHIVE_POLYMORPHIC_TEXT_WIARCHIVE_HPP
+#define BOOST_ARCHIVE_POLYMORPHIC_TEXT_WIARCHIVE_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER)
+# pragma once
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// polymorphic_text_wiarchive.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 <boost/config.hpp>
+#ifdef BOOST_NO_STD_WSTREAMBUF
+#error "wide char i/o not supported on this platform"
+#else
+
+#include <boost/archive/text_wiarchive.hpp>
+#include <boost/archive/detail/polymorphic_iarchive_route.hpp>
+
+#ifdef BOOST_MSVC
+# pragma warning(push)
+# pragma warning(disable : 4511 4512)
+#endif
+
+namespace boost {
+namespace archive {
+
+class polymorphic_text_wiarchive :
+ public detail::polymorphic_iarchive_route<text_wiarchive>
+{
+public:
+ polymorphic_text_wiarchive(std::wistream & is, unsigned int flags = 0) :
+ detail::polymorphic_iarchive_route<text_wiarchive>(is, flags)
+ {}
+ ~polymorphic_text_wiarchive(){}
+};
+
+} // namespace archive
+} // namespace boost
+
+#ifdef BOOST_MSVC
+#pragma warning(pop)
+#endif
+
+// required by export
+BOOST_SERIALIZATION_REGISTER_ARCHIVE(
+ boost::archive::polymorphic_text_wiarchive
+)
+
+#endif // BOOST_NO_STD_WSTREAMBUF
+#endif // BOOST_ARCHIVE_POLYMORPHIC_TEXT_WIARCHIVE_HPP
+
diff --git a/include/boost/archive/polymorphic_text_woarchive.hpp b/include/boost/archive/polymorphic_text_woarchive.hpp
new file mode 100644
index 0000000..295625d
--- /dev/null
+++ b/include/boost/archive/polymorphic_text_woarchive.hpp
@@ -0,0 +1,44 @@
+#ifndef BOOST_ARCHIVE_POLYMORPHIC_TEXT_WOARCHIVE_HPP
+#define BOOST_ARCHIVE_POLYMORPHIC_TEXT_WOARCHIVE_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER)
+# pragma once
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// polymorphic_text_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 <boost/config.hpp>
+#ifdef BOOST_NO_STD_WSTREAMBUF
+#error "wide char i/o not supported on this platform"
+#else
+
+#include <boost/archive/text_woarchive.hpp>
+#include <boost/archive/detail/polymorphic_oarchive_route.hpp>
+
+namespace boost {
+namespace archive {
+
+typedef detail::polymorphic_oarchive_route<
+ text_woarchive_impl<text_woarchive>
+> polymorphic_text_woarchive;
+
+} // namespace archive
+} // namespace boost
+
+// required by export
+BOOST_SERIALIZATION_REGISTER_ARCHIVE(
+ boost::archive::polymorphic_text_woarchive
+)
+
+#endif // BOOST_NO_STD_WSTREAMBUF
+#endif // BOOST_ARCHIVE_POLYMORPHIC_TEXT_WOARCHIVE_HPP
+
diff --git a/include/boost/archive/polymorphic_xml_iarchive.hpp b/include/boost/archive/polymorphic_xml_iarchive.hpp
new file mode 100644
index 0000000..4dc3f89
--- /dev/null
+++ b/include/boost/archive/polymorphic_xml_iarchive.hpp
@@ -0,0 +1,54 @@
+#ifndef BOOST_ARCHIVE_POLYMORPHIC_XML_IARCHIVE_HPP
+#define BOOST_ARCHIVE_POLYMORPHIC_XML_IARCHIVE_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER)
+# pragma once
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// polymorphic_xml_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 <boost/config.hpp>
+#include <boost/archive/xml_iarchive.hpp>
+#include <boost/archive/detail/polymorphic_iarchive_route.hpp>
+
+#ifdef BOOST_MSVC
+# pragma warning(push)
+# pragma warning(disable : 4511 4512)
+#endif
+
+namespace boost {
+namespace archive {
+
+class polymorphic_xml_iarchive :
+ public detail::polymorphic_iarchive_route<xml_iarchive>
+{
+public:
+ polymorphic_xml_iarchive(std::istream & is, unsigned int flags = 0) :
+ detail::polymorphic_iarchive_route<xml_iarchive>(is, flags)
+ {}
+ ~polymorphic_xml_iarchive(){}
+};
+
+} // namespace archive
+} // namespace boost
+
+#ifdef BOOST_MSVC
+#pragma warning(pop)
+#endif
+
+// required by export
+BOOST_SERIALIZATION_REGISTER_ARCHIVE(
+ boost::archive::polymorphic_xml_iarchive
+)
+
+#endif // BOOST_ARCHIVE_POLYMORPHIC_XML_IARCHIVE_HPP
+
diff --git a/include/boost/archive/polymorphic_xml_oarchive.hpp b/include/boost/archive/polymorphic_xml_oarchive.hpp
new file mode 100644
index 0000000..514f9e5
--- /dev/null
+++ b/include/boost/archive/polymorphic_xml_oarchive.hpp
@@ -0,0 +1,39 @@
+#ifndef BOOST_ARCHIVE_POLYMORPHIC_XML_OARCHIVE_HPP
+#define BOOST_ARCHIVE_POLYMORPHIC_XML_OARCHIVE_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER)
+# pragma once
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// polymorphic_xml_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 <boost/config.hpp>
+#include <boost/archive/xml_oarchive.hpp>
+#include <boost/archive/detail/polymorphic_oarchive_route.hpp>
+
+namespace boost {
+namespace archive {
+
+typedef detail::polymorphic_oarchive_route<
+ xml_oarchive_impl<xml_oarchive>
+> polymorphic_xml_oarchive;
+
+} // namespace archive
+} // namespace boost
+
+// required by export
+BOOST_SERIALIZATION_REGISTER_ARCHIVE(
+ boost::archive::polymorphic_xml_oarchive
+)
+
+#endif // BOOST_ARCHIVE_POLYMORPHIC_XML_OARCHIVE_HPP
+
diff --git a/include/boost/archive/polymorphic_xml_wiarchive.hpp b/include/boost/archive/polymorphic_xml_wiarchive.hpp
new file mode 100644
index 0000000..d4ab731
--- /dev/null
+++ b/include/boost/archive/polymorphic_xml_wiarchive.hpp
@@ -0,0 +1,50 @@
+#ifndef BOOST_ARCHIVE_POLYMORPHIC_XML_WIARCHIVE_HPP
+#define BOOST_ARCHIVE_POLYMORPHIC_XML_WIARCHIVE_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER)
+# pragma once
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// polymorphic_xml_wiarchive.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 <boost/config.hpp>
+#ifdef BOOST_NO_STD_WSTREAMBUF
+#error "wide char i/o not supported on this platform"
+#else
+
+#include <boost/archive/xml_wiarchive.hpp>
+#include <boost/archive/detail/polymorphic_iarchive_route.hpp>
+
+namespace boost {
+namespace archive {
+
+class polymorphic_xml_wiarchive :
+ public detail::polymorphic_iarchive_route<xml_wiarchive>
+{
+public:
+ polymorphic_xml_wiarchive(std::wistream & is, unsigned int flags = 0) :
+ detail::polymorphic_iarchive_route<xml_wiarchive>(is, flags)
+ {}
+ ~polymorphic_xml_wiarchive(){}
+};
+
+} // namespace archive
+} // namespace boost
+
+// required by export
+BOOST_SERIALIZATION_REGISTER_ARCHIVE(
+ boost::archive::polymorphic_xml_wiarchive
+)
+
+#endif // BOOST_NO_STD_WSTREAMBUF
+#endif // BOOST_ARCHIVE_POLYMORPHIC_XML_WIARCHIVE_HPP
+
diff --git a/include/boost/archive/polymorphic_xml_woarchive.hpp b/include/boost/archive/polymorphic_xml_woarchive.hpp
new file mode 100644
index 0000000..dd8963f
--- /dev/null
+++ b/include/boost/archive/polymorphic_xml_woarchive.hpp
@@ -0,0 +1,44 @@
+#ifndef BOOST_ARCHIVE_POLYMORPHIC_XML_WOARCHIVE_HPP
+#define BOOST_ARCHIVE_POLYMORPHIC_XML_WOARCHIVE_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER)
+# pragma once
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// polymorphic_xml_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 <boost/config.hpp>
+#ifdef BOOST_NO_STD_WSTREAMBUF
+#error "wide char i/o not supported on this platform"
+#else
+
+#include <boost/archive/xml_woarchive.hpp>
+#include <boost/archive/detail/polymorphic_oarchive_route.hpp>
+
+namespace boost {
+namespace archive {
+
+typedef detail::polymorphic_oarchive_route<
+ xml_woarchive_impl<xml_woarchive>
+> polymorphic_xml_woarchive;
+
+} // namespace archive
+} // namespace boost
+
+// required by export
+BOOST_SERIALIZATION_REGISTER_ARCHIVE(
+ boost::archive::polymorphic_xml_woarchive
+)
+
+#endif // BOOST_NO_STD_WSTREAMBUF
+#endif // BOOST_ARCHIVE_POLYMORPHIC_XML_WOARCHIVE_HPP
+
diff --git a/include/boost/archive/text_iarchive.hpp b/include/boost/archive/text_iarchive.hpp
new file mode 100644
index 0000000..d9d60ad
--- /dev/null
+++ b/include/boost/archive/text_iarchive.hpp
@@ -0,0 +1,132 @@
+#ifndef BOOST_ARCHIVE_TEXT_IARCHIVE_HPP
+#define BOOST_ARCHIVE_TEXT_IARCHIVE_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER)
+# pragma once
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// text_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 <istream>
+
+#include <boost/config.hpp>
+#include <boost/archive/detail/auto_link_archive.hpp>
+#include <boost/archive/basic_text_iprimitive.hpp>
+#include <boost/archive/basic_text_iarchive.hpp>
+#include <boost/archive/detail/register_archive.hpp>
+#include <boost/serialization/item_version_type.hpp>
+
+#include <boost/archive/detail/abi_prefix.hpp> // must be the last header
+
+#ifdef BOOST_MSVC
+# pragma warning(push)
+# pragma warning(disable : 4511 4512)
+#endif
+
+namespace boost {
+namespace archive {
+
+namespace detail {
+ template<class Archive> class interface_iarchive;
+} // namespace detail
+
+template<class Archive>
+class BOOST_SYMBOL_VISIBLE text_iarchive_impl :
+ public basic_text_iprimitive<std::istream>,
+ public basic_text_iarchive<Archive>
+{
+#ifdef BOOST_NO_MEMBER_TEMPLATE_FRIENDS
+public:
+#else
+protected:
+ friend class detail::interface_iarchive<Archive>;
+ friend class load_access;
+#endif
+ template<class T>
+ void load(T & t){
+ basic_text_iprimitive<std::istream>::load(t);
+ }
+ void load(version_type & t){
+ unsigned int v;
+ load(v);
+ t = version_type(v);
+ }
+ void load(boost::serialization::item_version_type & t){
+ unsigned int v;
+ load(v);
+ t = boost::serialization::item_version_type(v);
+ }
+ BOOST_ARCHIVE_DECL void
+ load(char * t);
+ #ifndef BOOST_NO_INTRINSIC_WCHAR_T
+ BOOST_ARCHIVE_DECL void
+ load(wchar_t * t);
+ #endif
+ BOOST_ARCHIVE_DECL void
+ load(std::string &s);
+ #ifndef BOOST_NO_STD_WSTRING
+ BOOST_ARCHIVE_DECL void
+ load(std::wstring &ws);
+ #endif
+ template<class T>
+ void load_override(T & t){
+ basic_text_iarchive<Archive>::load_override(t);
+ }
+ BOOST_ARCHIVE_DECL void
+ load_override(class_name_type & t);
+ BOOST_ARCHIVE_DECL void
+ init();
+ BOOST_ARCHIVE_DECL
+ text_iarchive_impl(std::istream & is, unsigned int flags);
+ // don't import inline definitions! leave this as a reminder.
+ //BOOST_ARCHIVE_DECL
+ ~text_iarchive_impl(){};
+};
+
+} // namespace archive
+} // namespace boost
+
+#ifdef BOOST_MSVC
+#pragma warning(pop)
+#endif
+
+#include <boost/archive/detail/abi_suffix.hpp> // pops abi_suffix.hpp pragmas
+
+#ifdef BOOST_MSVC
+# pragma warning(push)
+# pragma warning(disable : 4511 4512)
+#endif
+
+namespace boost {
+namespace archive {
+
+class BOOST_SYMBOL_VISIBLE text_iarchive :
+ public text_iarchive_impl<text_iarchive>{
+public:
+ text_iarchive(std::istream & is_, unsigned int flags = 0) :
+ // note: added _ to suppress useless gcc warning
+ text_iarchive_impl<text_iarchive>(is_, flags)
+ {}
+ ~text_iarchive(){}
+};
+
+} // namespace archive
+} // namespace boost
+
+// required by export
+BOOST_SERIALIZATION_REGISTER_ARCHIVE(boost::archive::text_iarchive)
+
+#ifdef BOOST_MSVC
+#pragma warning(pop)
+#endif
+
+#endif // BOOST_ARCHIVE_TEXT_IARCHIVE_HPP
diff --git a/include/boost/archive/text_oarchive.hpp b/include/boost/archive/text_oarchive.hpp
new file mode 100644
index 0000000..e4c6d46
--- /dev/null
+++ b/include/boost/archive/text_oarchive.hpp
@@ -0,0 +1,121 @@
+#ifndef BOOST_ARCHIVE_TEXT_OARCHIVE_HPP
+#define BOOST_ARCHIVE_TEXT_OARCHIVE_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER)
+# pragma once
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// text_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 <ostream>
+#include <cstddef> // std::size_t
+
+#include <boost/config.hpp>
+#if defined(BOOST_NO_STDC_NAMESPACE)
+namespace std{
+ using ::size_t;
+} // namespace std
+#endif
+
+#include <boost/archive/detail/auto_link_archive.hpp>
+#include <boost/archive/basic_text_oprimitive.hpp>
+#include <boost/archive/basic_text_oarchive.hpp>
+#include <boost/archive/detail/register_archive.hpp>
+#include <boost/serialization/item_version_type.hpp>
+
+#include <boost/archive/detail/abi_prefix.hpp> // must be the last header
+
+#ifdef BOOST_MSVC
+# pragma warning(push)
+# pragma warning(disable : 4511 4512)
+#endif
+
+namespace boost {
+namespace archive {
+
+namespace detail {
+ template<class Archive> class interface_oarchive;
+} // namespace detail
+
+template<class Archive>
+class BOOST_SYMBOL_VISIBLE text_oarchive_impl :
+ /* protected ? */ public basic_text_oprimitive<std::ostream>,
+ public basic_text_oarchive<Archive>
+{
+#ifdef BOOST_NO_MEMBER_TEMPLATE_FRIENDS
+public:
+#else
+protected:
+ friend class detail::interface_oarchive<Archive>;
+ friend class basic_text_oarchive<Archive>;
+ friend class save_access;
+#endif
+ template<class T>
+ void save(const T & t){
+ this->newtoken();
+ basic_text_oprimitive<std::ostream>::save(t);
+ }
+ void save(const version_type & t){
+ save(static_cast<unsigned int>(t));
+ }
+ void save(const boost::serialization::item_version_type & t){
+ save(static_cast<unsigned int>(t));
+ }
+ BOOST_ARCHIVE_DECL void
+ save(const char * t);
+ #ifndef BOOST_NO_INTRINSIC_WCHAR_T
+ BOOST_ARCHIVE_DECL void
+ save(const wchar_t * t);
+ #endif
+ BOOST_ARCHIVE_DECL void
+ save(const std::string &s);
+ #ifndef BOOST_NO_STD_WSTRING
+ BOOST_ARCHIVE_DECL void
+ save(const std::wstring &ws);
+ #endif
+ BOOST_ARCHIVE_DECL
+ text_oarchive_impl(std::ostream & os, unsigned int flags);
+ // don't import inline definitions! leave this as a reminder.
+ //BOOST_ARCHIVE_DECL
+ ~text_oarchive_impl(){};
+public:
+ BOOST_ARCHIVE_DECL void
+ save_binary(const void *address, std::size_t count);
+};
+
+// do not derive from this class. If you want to extend this functionality
+// via inhertance, derived from text_oarchive_impl instead. This will
+// preserve correct static polymorphism.
+class BOOST_SYMBOL_VISIBLE text_oarchive :
+ public text_oarchive_impl<text_oarchive>
+{
+public:
+ text_oarchive(std::ostream & os_, unsigned int flags = 0) :
+ // note: added _ to suppress useless gcc warning
+ text_oarchive_impl<text_oarchive>(os_, flags)
+ {}
+ ~text_oarchive(){}
+};
+
+} // namespace archive
+} // namespace boost
+
+// required by export
+BOOST_SERIALIZATION_REGISTER_ARCHIVE(boost::archive::text_oarchive)
+
+#ifdef BOOST_MSVC
+#pragma warning(pop)
+#endif
+
+#include <boost/archive/detail/abi_suffix.hpp> // pops abi_suffix.hpp pragmas
+
+#endif // BOOST_ARCHIVE_TEXT_OARCHIVE_HPP
diff --git a/include/boost/archive/text_wiarchive.hpp b/include/boost/archive/text_wiarchive.hpp
new file mode 100644
index 0000000..3adf068
--- /dev/null
+++ b/include/boost/archive/text_wiarchive.hpp
@@ -0,0 +1,137 @@
+#ifndef BOOST_ARCHIVE_TEXT_WIARCHIVE_HPP
+#define BOOST_ARCHIVE_TEXT_WIARCHIVE_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER)
+# pragma once
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// text_wiarchive.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 <boost/config.hpp>
+#ifdef BOOST_NO_STD_WSTREAMBUF
+#error "wide char i/o not supported on this platform"
+#else
+
+#include <istream>
+
+#include <boost/archive/detail/auto_link_warchive.hpp>
+#include <boost/archive/basic_text_iprimitive.hpp>
+#include <boost/archive/basic_text_iarchive.hpp>
+#include <boost/archive/detail/register_archive.hpp>
+#include <boost/serialization/item_version_type.hpp>
+
+#include <boost/archive/detail/abi_prefix.hpp> // must be the last header
+
+#ifdef BOOST_MSVC
+# pragma warning(push)
+# pragma warning(disable : 4511 4512)
+#endif
+
+namespace boost {
+namespace archive {
+
+namespace detail {
+ template<class Archive> class interface_iarchive;
+} // namespace detail
+
+template<class Archive>
+class BOOST_SYMBOL_VISIBLE text_wiarchive_impl :
+ public basic_text_iprimitive<std::wistream>,
+ public basic_text_iarchive<Archive>
+{
+#ifdef BOOST_NO_MEMBER_TEMPLATE_FRIENDS
+public:
+#else
+protected:
+ #if BOOST_WORKAROUND(BOOST_MSVC, < 1500)
+ // for some inexplicable reason insertion of "class" generates compile erro
+ // on msvc 7.1
+ friend detail::interface_iarchive<Archive>;
+ friend load_access;
+ #else
+ friend class detail::interface_iarchive<Archive>;
+ friend class load_access;
+ #endif
+#endif
+ template<class T>
+ void load(T & t){
+ basic_text_iprimitive<std::wistream>::load(t);
+ }
+ void load(version_type & t){
+ unsigned int v;
+ load(v);
+ t = version_type(v);
+ }
+ void load(boost::serialization::item_version_type & t){
+ unsigned int v;
+ load(v);
+ t = boost::serialization::item_version_type(v);
+ }
+ BOOST_WARCHIVE_DECL void
+ load(char * t);
+ #ifndef BOOST_NO_INTRINSIC_WCHAR_T
+ BOOST_WARCHIVE_DECL void
+ load(wchar_t * t);
+ #endif
+ BOOST_WARCHIVE_DECL void
+ load(std::string &s);
+ #ifndef BOOST_NO_STD_WSTRING
+ BOOST_WARCHIVE_DECL void
+ load(std::wstring &ws);
+ #endif
+ template<class T>
+ void load_override(T & t){
+ basic_text_iarchive<Archive>::load_override(t);
+ }
+ BOOST_WARCHIVE_DECL
+ text_wiarchive_impl(std::wistream & is, unsigned int flags);
+ ~text_wiarchive_impl(){};
+};
+
+} // namespace archive
+} // namespace boost
+
+#ifdef BOOST_MSVC
+#pragma warning(pop)
+#endif
+
+#include <boost/archive/detail/abi_suffix.hpp> // pops abi_suffix.hpp pragmas
+
+#ifdef BOOST_MSVC
+# pragma warning(push)
+# pragma warning(disable : 4511 4512)
+#endif
+
+namespace boost {
+namespace archive {
+
+class BOOST_SYMBOL_VISIBLE text_wiarchive :
+ public text_wiarchive_impl<text_wiarchive>{
+public:
+ text_wiarchive(std::wistream & is, unsigned int flags = 0) :
+ text_wiarchive_impl<text_wiarchive>(is, flags)
+ {}
+ ~text_wiarchive(){}
+};
+
+} // namespace archive
+} // namespace boost
+
+// required by export
+BOOST_SERIALIZATION_REGISTER_ARCHIVE(boost::archive::text_wiarchive)
+
+#ifdef BOOST_MSVC
+#pragma warning(pop)
+#endif
+
+#endif // BOOST_NO_STD_WSTREAMBUF
+#endif // BOOST_ARCHIVE_TEXT_WIARCHIVE_HPP
diff --git a/include/boost/archive/text_woarchive.hpp b/include/boost/archive/text_woarchive.hpp
new file mode 100644
index 0000000..beba62f
--- /dev/null
+++ b/include/boost/archive/text_woarchive.hpp
@@ -0,0 +1,155 @@
+#ifndef BOOST_ARCHIVE_TEXT_WOARCHIVE_HPP
+#define BOOST_ARCHIVE_TEXT_WOARCHIVE_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER)
+# pragma once
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// text_woarchive.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 <boost/config.hpp>
+
+#ifdef BOOST_NO_STD_WSTREAMBUF
+#error "wide char i/o not supported on this platform"
+#else
+
+#include <ostream>
+#include <cstddef> // size_t
+
+#if defined(BOOST_NO_STDC_NAMESPACE)
+namespace std{
+ using ::size_t;
+} // namespace std
+#endif
+
+#include <boost/archive/detail/auto_link_warchive.hpp>
+#include <boost/archive/basic_text_oprimitive.hpp>
+#include <boost/archive/basic_text_oarchive.hpp>
+#include <boost/archive/detail/register_archive.hpp>
+#include <boost/serialization/item_version_type.hpp>
+
+#include <boost/archive/detail/abi_prefix.hpp> // must be the last header
+
+#ifdef BOOST_MSVC
+# pragma warning(push)
+# pragma warning(disable : 4511 4512)
+#endif
+
+namespace boost {
+namespace archive {
+
+namespace detail {
+ template<class Archive> class interface_oarchive;
+} // namespace detail
+
+template<class Archive>
+class BOOST_SYMBOL_VISIBLE text_woarchive_impl :
+ public basic_text_oprimitive<std::wostream>,
+ public basic_text_oarchive<Archive>
+{
+#ifdef BOOST_NO_MEMBER_TEMPLATE_FRIENDS
+public:
+#else
+protected:
+ #if BOOST_WORKAROUND(BOOST_MSVC, < 1500)
+ // for some inexplicable reason insertion of "class" generates compile erro
+ // on msvc 7.1
+ friend detail::interface_oarchive<Archive>;
+ friend basic_text_oarchive<Archive>;
+ friend save_access;
+ #else
+ friend class detail::interface_oarchive<Archive>;
+ friend class basic_text_oarchive<Archive>;
+ friend class save_access;
+ #endif
+#endif
+ template<class T>
+ void save(const T & t){
+ this->newtoken();
+ basic_text_oprimitive<std::wostream>::save(t);
+ }
+ void save(const version_type & t){
+ save(static_cast<unsigned int>(t));
+ }
+ void save(const boost::serialization::item_version_type & t){
+ save(static_cast<unsigned int>(t));
+ }
+ BOOST_WARCHIVE_DECL void
+ save(const char * t);
+ #ifndef BOOST_NO_INTRINSIC_WCHAR_T
+ BOOST_WARCHIVE_DECL void
+ save(const wchar_t * t);
+ #endif
+ BOOST_WARCHIVE_DECL void
+ save(const std::string &s);
+ #ifndef BOOST_NO_STD_WSTRING
+ BOOST_WARCHIVE_DECL void
+ save(const std::wstring &ws);
+ #endif
+ text_woarchive_impl(std::wostream & os, unsigned int flags) :
+ basic_text_oprimitive<std::wostream>(
+ os,
+ 0 != (flags & no_codecvt)
+ ),
+ basic_text_oarchive<Archive>(flags)
+ {
+ if(0 == (flags & no_header))
+ basic_text_oarchive<Archive>::init();
+ }
+public:
+ void save_binary(const void *address, std::size_t count){
+ put(static_cast<wchar_t>('\n'));
+ this->end_preamble();
+ #if ! defined(__MWERKS__)
+ this->basic_text_oprimitive<std::wostream>::save_binary(
+ #else
+ this->basic_text_oprimitive::save_binary(
+ #endif
+ address,
+ count
+ );
+ put(static_cast<wchar_t>('\n'));
+ this->delimiter = this->none;
+ }
+
+};
+
+// we use the following because we can't use
+// typedef text_oarchive_impl<text_oarchive_impl<...> > text_oarchive;
+
+// do not derive from this class. If you want to extend this functionality
+// via inhertance, derived from text_oarchive_impl instead. This will
+// preserve correct static polymorphism.
+class BOOST_SYMBOL_VISIBLE text_woarchive :
+ public text_woarchive_impl<text_woarchive>
+{
+public:
+ text_woarchive(std::wostream & os, unsigned int flags = 0) :
+ text_woarchive_impl<text_woarchive>(os, flags)
+ {}
+ ~text_woarchive(){}
+};
+
+} // namespace archive
+} // namespace boost
+
+// required by export
+BOOST_SERIALIZATION_REGISTER_ARCHIVE(boost::archive::text_woarchive)
+
+#ifdef BOOST_MSVC
+#pragma warning(pop)
+#endif
+
+#include <boost/archive/detail/abi_suffix.hpp> // pops abi_suffix.hpp pragmas
+
+#endif // BOOST_NO_STD_WSTREAMBUF
+#endif // BOOST_ARCHIVE_TEXT_WOARCHIVE_HPP
diff --git a/include/boost/archive/tmpdir.hpp b/include/boost/archive/tmpdir.hpp
new file mode 100644
index 0000000..400d23b
--- /dev/null
+++ b/include/boost/archive/tmpdir.hpp
@@ -0,0 +1,50 @@
+#ifndef BOOST_ARCHIVE_TMPDIR_HPP
+#define BOOST_ARCHIVE_TMPDIR_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER)
+# pragma once
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// tmpdir.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 <cstdlib> // getenv
+#include <cstddef> // NULL
+//#include <boost/assert.hpp>
+
+#include <boost/config.hpp>
+#ifdef BOOST_NO_STDC_NAMESPACE
+namespace std {
+ using ::getenv;
+}
+#endif
+
+namespace boost {
+namespace archive {
+
+inline const char * tmpdir(){
+ const char *dirname;
+ dirname = std::getenv("TMP");
+ if(NULL == dirname)
+ dirname = std::getenv("TMPDIR");
+ if(NULL == dirname)
+ dirname = std::getenv("TEMP");
+ if(NULL == dirname){
+ //BOOST_ASSERT(false); // no temp directory found
+ dirname = ".";
+ }
+ return dirname;
+}
+
+} // archive
+} // boost
+
+#endif // BOOST_ARCHIVE_TMPDIR_HPP
diff --git a/include/boost/archive/wcslen.hpp b/include/boost/archive/wcslen.hpp
new file mode 100644
index 0000000..0b60004
--- /dev/null
+++ b/include/boost/archive/wcslen.hpp
@@ -0,0 +1,58 @@
+#ifndef BOOST_ARCHIVE_WCSLEN_HPP
+#define BOOST_ARCHIVE_WCSLEN_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER)
+# pragma once
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// wcslen.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 <cstddef> // size_t
+#include <boost/config.hpp>
+#if defined(BOOST_NO_STDC_NAMESPACE)
+namespace std{
+ using ::size_t;
+} // namespace std
+#endif
+
+#ifndef BOOST_NO_CWCHAR
+
+// a couple of libraries which include wchar_t don't include
+// wcslen
+
+#if defined(BOOST_DINKUMWARE_STDLIB) && BOOST_DINKUMWARE_STDLIB < 306 \
+|| defined(__LIBCOMO__)
+
+namespace std {
+inline std::size_t wcslen(const wchar_t * ws)
+{
+ const wchar_t * eows = ws;
+ while(* eows != 0)
+ ++eows;
+ return eows - ws;
+}
+} // namespace std
+
+#else
+
+#ifndef BOOST_NO_CWCHAR
+#include <cwchar>
+#endif
+#ifdef BOOST_NO_STDC_NAMESPACE
+namespace std{ using ::wcslen; }
+#endif
+
+#endif // wcslen
+
+#endif //BOOST_NO_CWCHAR
+
+#endif //BOOST_ARCHIVE_WCSLEN_HPP
diff --git a/include/boost/archive/xml_archive_exception.hpp b/include/boost/archive/xml_archive_exception.hpp
new file mode 100644
index 0000000..82c53ef
--- /dev/null
+++ b/include/boost/archive/xml_archive_exception.hpp
@@ -0,0 +1,57 @@
+#ifndef BOOST_ARCHIVE_XML_ARCHIVE_EXCEPTION_HPP
+#define BOOST_ARCHIVE_XML_ARCHIVE_EXCEPTION_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER)
+# pragma once
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// xml_archive_exception.hpp:
+
+// (C) Copyright 2007 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 <exception>
+#include <boost/assert.hpp>
+
+#include <boost/config.hpp>
+#include <boost/archive/detail/decl.hpp>
+#include <boost/archive/archive_exception.hpp>
+
+#include <boost/archive/detail/abi_prefix.hpp> // must be the last header
+
+namespace boost {
+namespace archive {
+
+//////////////////////////////////////////////////////////////////////
+// exceptions thrown by xml archives
+//
+class BOOST_SYMBOL_VISIBLE xml_archive_exception :
+ public virtual boost::archive::archive_exception
+{
+public:
+ typedef enum {
+ xml_archive_parsing_error, // see save_register
+ xml_archive_tag_mismatch,
+ xml_archive_tag_name_error
+ } exception_code;
+ BOOST_ARCHIVE_DECL xml_archive_exception(
+ exception_code c,
+ const char * e1 = NULL,
+ const char * e2 = NULL
+ );
+ BOOST_ARCHIVE_DECL xml_archive_exception(xml_archive_exception const &) ;
+ virtual BOOST_ARCHIVE_DECL ~xml_archive_exception() BOOST_NOEXCEPT_OR_NOTHROW ;
+};
+
+}// namespace archive
+}// namespace boost
+
+#include <boost/archive/detail/abi_suffix.hpp> // pops abi_suffix.hpp pragmas
+
+#endif //BOOST_XML_ARCHIVE_ARCHIVE_EXCEPTION_HPP
diff --git a/include/boost/archive/xml_iarchive.hpp b/include/boost/archive/xml_iarchive.hpp
new file mode 100644
index 0000000..abd2f9f
--- /dev/null
+++ b/include/boost/archive/xml_iarchive.hpp
@@ -0,0 +1,142 @@
+#ifndef BOOST_ARCHIVE_XML_IARCHIVE_HPP
+#define BOOST_ARCHIVE_XML_IARCHIVE_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER)
+# pragma once
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// xml_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 <istream>
+
+#include <boost/scoped_ptr.hpp>
+#include <boost/archive/detail/auto_link_archive.hpp>
+#include <boost/archive/basic_text_iprimitive.hpp>
+#include <boost/archive/basic_xml_iarchive.hpp>
+#include <boost/archive/detail/register_archive.hpp>
+#include <boost/serialization/item_version_type.hpp>
+
+#include <boost/archive/detail/abi_prefix.hpp> // must be the last header
+
+#ifdef BOOST_MSVC
+# pragma warning(push)
+# pragma warning(disable : 4511 4512)
+#endif
+
+namespace boost {
+namespace archive {
+
+namespace detail {
+ template<class Archive> class interface_iarchive;
+} // namespace detail
+
+template<class CharType>
+class basic_xml_grammar;
+typedef basic_xml_grammar<char> xml_grammar;
+
+template<class Archive>
+class BOOST_SYMBOL_VISIBLE xml_iarchive_impl :
+ public basic_text_iprimitive<std::istream>,
+ public basic_xml_iarchive<Archive>
+{
+#ifdef BOOST_NO_MEMBER_TEMPLATE_FRIENDS
+public:
+#else
+protected:
+ friend class detail::interface_iarchive<Archive>;
+ friend class basic_xml_iarchive<Archive>;
+ friend class load_access;
+#endif
+ // use boost:scoped_ptr to implement automatic deletion;
+ boost::scoped_ptr<xml_grammar> gimpl;
+
+ std::istream & get_is(){
+ return is;
+ }
+ template<class T>
+ void load(T & t){
+ basic_text_iprimitive<std::istream>::load(t);
+ }
+ void
+ load(version_type & t){
+ unsigned int v;
+ load(v);
+ t = version_type(v);
+ }
+ void
+ load(boost::serialization::item_version_type & t){
+ unsigned int v;
+ load(v);
+ t = boost::serialization::item_version_type(v);
+ }
+ BOOST_ARCHIVE_DECL void
+ load(char * t);
+ #ifndef BOOST_NO_INTRINSIC_WCHAR_T
+ BOOST_ARCHIVE_DECL void
+ load(wchar_t * t);
+ #endif
+ BOOST_ARCHIVE_DECL void
+ load(std::string &s);
+ #ifndef BOOST_NO_STD_WSTRING
+ BOOST_ARCHIVE_DECL void
+ load(std::wstring &ws);
+ #endif
+ template<class T>
+ void load_override(T & t){
+ basic_xml_iarchive<Archive>::load_override(t);
+ }
+ BOOST_ARCHIVE_DECL void
+ load_override(class_name_type & t);
+ BOOST_ARCHIVE_DECL void
+ init();
+ BOOST_ARCHIVE_DECL
+ xml_iarchive_impl(std::istream & is, unsigned int flags);
+ BOOST_ARCHIVE_DECL
+ ~xml_iarchive_impl();
+};
+
+} // namespace archive
+} // namespace boost
+
+#ifdef BOOST_MSVC
+#pragma warning(pop)
+#endif
+
+#include <boost/archive/detail/abi_suffix.hpp> // pops abi_suffix.hpp pragmas
+#ifdef BOOST_MSVC
+# pragma warning(push)
+# pragma warning(disable : 4511 4512)
+#endif
+
+namespace boost {
+namespace archive {
+
+class BOOST_SYMBOL_VISIBLE xml_iarchive :
+ public xml_iarchive_impl<xml_iarchive>{
+public:
+ xml_iarchive(std::istream & is, unsigned int flags = 0) :
+ xml_iarchive_impl<xml_iarchive>(is, flags)
+ {}
+ ~xml_iarchive(){};
+};
+
+} // namespace archive
+} // namespace boost
+
+// required by export
+BOOST_SERIALIZATION_REGISTER_ARCHIVE(boost::archive::xml_iarchive)
+
+#ifdef BOOST_MSVC
+#pragma warning(pop)
+#endif
+
+#endif // BOOST_ARCHIVE_XML_IARCHIVE_HPP
diff --git a/include/boost/archive/xml_oarchive.hpp b/include/boost/archive/xml_oarchive.hpp
new file mode 100644
index 0000000..d0fa8b2
--- /dev/null
+++ b/include/boost/archive/xml_oarchive.hpp
@@ -0,0 +1,137 @@
+#ifndef BOOST_ARCHIVE_XML_OARCHIVE_HPP
+#define BOOST_ARCHIVE_XML_OARCHIVE_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER)
+# pragma once
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// xml_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 <ostream>
+
+#include <cstddef> // size_t
+#include <boost/config.hpp>
+#if defined(BOOST_NO_STDC_NAMESPACE)
+namespace std{
+ using ::size_t;
+} // namespace std
+#endif
+
+#include <boost/archive/detail/auto_link_archive.hpp>
+#include <boost/archive/basic_text_oprimitive.hpp>
+#include <boost/archive/basic_xml_oarchive.hpp>
+#include <boost/archive/detail/register_archive.hpp>
+#include <boost/serialization/item_version_type.hpp>
+
+#include <boost/archive/detail/abi_prefix.hpp> // must be the last header
+
+#ifdef BOOST_MSVC
+# pragma warning(push)
+# pragma warning(disable : 4511 4512)
+#endif
+
+namespace boost {
+namespace archive {
+
+namespace detail {
+ template<class Archive> class interface_oarchive;
+} // namespace detail
+
+template<class Archive>
+class BOOST_SYMBOL_VISIBLE xml_oarchive_impl :
+ public basic_text_oprimitive<std::ostream>,
+ public basic_xml_oarchive<Archive>
+{
+#ifdef BOOST_NO_MEMBER_TEMPLATE_FRIENDS
+public:
+#else
+protected:
+ friend class detail::interface_oarchive<Archive>;
+ friend class basic_xml_oarchive<Archive>;
+ friend class save_access;
+#endif
+ template<class T>
+ void save(const T & t){
+ basic_text_oprimitive<std::ostream>::save(t);
+ }
+ void
+ save(const version_type & t){
+ save(static_cast<unsigned int>(t));
+ }
+ void
+ save(const boost::serialization::item_version_type & t){
+ save(static_cast<unsigned int>(t));
+ }
+ BOOST_ARCHIVE_DECL void
+ save(const char * t);
+ #ifndef BOOST_NO_INTRINSIC_WCHAR_T
+ BOOST_ARCHIVE_DECL void
+ save(const wchar_t * t);
+ #endif
+ BOOST_ARCHIVE_DECL void
+ save(const std::string &s);
+ #ifndef BOOST_NO_STD_WSTRING
+ BOOST_ARCHIVE_DECL void
+ save(const std::wstring &ws);
+ #endif
+ BOOST_ARCHIVE_DECL
+ xml_oarchive_impl(std::ostream & os, unsigned int flags);
+ BOOST_ARCHIVE_DECL
+ ~xml_oarchive_impl();
+public:
+ BOOST_ARCHIVE_DECL
+ void save_binary(const void *address, std::size_t count);
+};
+
+} // namespace archive
+} // namespace boost
+
+#ifdef BOOST_MSVC
+#pragma warning(pop)
+#endif
+
+#include <boost/archive/detail/abi_suffix.hpp> // pops abi_suffix.hpp pragmas
+#ifdef BOOST_MSVC
+# pragma warning(push)
+# pragma warning(disable : 4511 4512)
+#endif
+
+namespace boost {
+namespace archive {
+
+// we use the following because we can't use
+// typedef xml_oarchive_impl<xml_oarchive_impl<...> > xml_oarchive;
+
+// do not derive from this class. If you want to extend this functionality
+// via inhertance, derived from xml_oarchive_impl instead. This will
+// preserve correct static polymorphism.
+class BOOST_SYMBOL_VISIBLE xml_oarchive :
+ public xml_oarchive_impl<xml_oarchive>
+{
+public:
+ xml_oarchive(std::ostream & os, unsigned int flags = 0) :
+ xml_oarchive_impl<xml_oarchive>(os, flags)
+ {}
+ ~xml_oarchive(){}
+};
+
+} // namespace archive
+} // namespace boost
+
+// required by export
+BOOST_SERIALIZATION_REGISTER_ARCHIVE(boost::archive::xml_oarchive)
+
+#ifdef BOOST_MSVC
+#pragma warning(pop)
+#endif
+
+#endif // BOOST_ARCHIVE_XML_OARCHIVE_HPP
diff --git a/include/boost/archive/xml_wiarchive.hpp b/include/boost/archive/xml_wiarchive.hpp
new file mode 100644
index 0000000..2ca3e55
--- /dev/null
+++ b/include/boost/archive/xml_wiarchive.hpp
@@ -0,0 +1,150 @@
+#ifndef BOOST_ARCHIVE_XML_WIARCHIVE_HPP
+#define BOOST_ARCHIVE_XML_WIARCHIVE_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER)
+# pragma once
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// xml_wiarchive.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 <boost/config.hpp>
+#ifdef BOOST_NO_STD_WSTREAMBUF
+#error "wide char i/o not supported on this platform"
+#else
+
+#include <istream>
+
+#include <boost/smart_ptr/scoped_ptr.hpp>
+#include <boost/archive/detail/auto_link_warchive.hpp>
+#include <boost/archive/basic_text_iprimitive.hpp>
+#include <boost/archive/basic_xml_iarchive.hpp>
+#include <boost/archive/detail/register_archive.hpp>
+#include <boost/serialization/item_version_type.hpp>
+// #include <boost/archive/detail/utf8_codecvt_facet.hpp>
+
+#include <boost/archive/detail/abi_prefix.hpp> // must be the last header
+
+#ifdef BOOST_MSVC
+# pragma warning(push)
+# pragma warning(disable : 4511 4512)
+#endif
+
+namespace boost {
+namespace archive {
+
+namespace detail {
+ template<class Archive> class interface_iarchive;
+} // namespace detail
+
+template<class CharType>
+class basic_xml_grammar;
+typedef basic_xml_grammar<wchar_t> xml_wgrammar;
+
+template<class Archive>
+class BOOST_SYMBOL_VISIBLE xml_wiarchive_impl :
+ public basic_text_iprimitive<std::wistream>,
+ public basic_xml_iarchive<Archive>
+{
+#ifdef BOOST_NO_MEMBER_TEMPLATE_FRIENDS
+public:
+#else
+protected:
+ friend class detail::interface_iarchive<Archive>;
+ friend class basic_xml_iarchive<Archive>;
+ friend class load_access;
+#endif
+ std::locale archive_locale;
+ boost::scoped_ptr<xml_wgrammar> gimpl;
+ std::wistream & get_is(){
+ return is;
+ }
+ template<class T>
+ void
+ load(T & t){
+ basic_text_iprimitive<std::wistream>::load(t);
+ }
+ void
+ load(version_type & t){
+ unsigned int v;
+ load(v);
+ t = version_type(v);
+ }
+ void
+ load(boost::serialization::item_version_type & t){
+ unsigned int v;
+ load(v);
+ t = boost::serialization::item_version_type(v);
+ }
+ BOOST_WARCHIVE_DECL void
+ load(char * t);
+ #ifndef BOOST_NO_INTRINSIC_WCHAR_T
+ BOOST_WARCHIVE_DECL void
+ load(wchar_t * t);
+ #endif
+ BOOST_WARCHIVE_DECL void
+ load(std::string &s);
+ #ifndef BOOST_NO_STD_WSTRING
+ BOOST_WARCHIVE_DECL void
+ load(std::wstring &ws);
+ #endif
+ template<class T>
+ void load_override(T & t){
+ basic_xml_iarchive<Archive>::load_override(t);
+ }
+ BOOST_WARCHIVE_DECL void
+ load_override(class_name_type & t);
+ BOOST_WARCHIVE_DECL void
+ init();
+ BOOST_WARCHIVE_DECL
+ xml_wiarchive_impl(std::wistream & is, unsigned int flags) ;
+ BOOST_WARCHIVE_DECL
+ ~xml_wiarchive_impl();
+};
+
+} // namespace archive
+} // namespace boost
+
+#ifdef BOOST_MSVC
+# pragma warning(pop)
+#endif
+
+#include <boost/archive/detail/abi_suffix.hpp> // pops abi_suffix.hpp pragmas
+
+#ifdef BOOST_MSVC
+# pragma warning(push)
+# pragma warning(disable : 4511 4512)
+#endif
+
+namespace boost {
+namespace archive {
+
+class BOOST_SYMBOL_VISIBLE xml_wiarchive :
+ public xml_wiarchive_impl<xml_wiarchive>{
+public:
+ xml_wiarchive(std::wistream & is, unsigned int flags = 0) :
+ xml_wiarchive_impl<xml_wiarchive>(is, flags)
+ {}
+ ~xml_wiarchive(){}
+};
+
+} // namespace archive
+} // namespace boost
+
+// required by export
+BOOST_SERIALIZATION_REGISTER_ARCHIVE(boost::archive::xml_wiarchive)
+
+#ifdef BOOST_MSVC
+#pragma warning(pop)
+#endif
+
+#endif // BOOST_NO_STD_WSTREAMBUF
+#endif // BOOST_ARCHIVE_XML_WIARCHIVE_HPP
diff --git a/include/boost/archive/xml_woarchive.hpp b/include/boost/archive/xml_woarchive.hpp
new file mode 100644
index 0000000..e6ac50d
--- /dev/null
+++ b/include/boost/archive/xml_woarchive.hpp
@@ -0,0 +1,134 @@
+#ifndef BOOST_ARCHIVE_XML_WOARCHIVE_HPP
+#define BOOST_ARCHIVE_XML_WOARCHIVE_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER)
+# pragma once
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// xml_woarchive.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 <boost/config.hpp>
+#ifdef BOOST_NO_STD_WSTREAMBUF
+#error "wide char i/o not supported on this platform"
+#else
+#include <cstddef> // size_t
+#if defined(BOOST_NO_STDC_NAMESPACE)
+namespace std{
+ using ::size_t;
+} // namespace std
+#endif
+
+#include <ostream>
+
+//#include <boost/smart_ptr/scoped_ptr.hpp>
+#include <boost/archive/detail/auto_link_warchive.hpp>
+#include <boost/archive/basic_text_oprimitive.hpp>
+#include <boost/archive/basic_xml_oarchive.hpp>
+#include <boost/archive/detail/register_archive.hpp>
+#include <boost/serialization/item_version_type.hpp>
+//#include <boost/archive/detail/utf8_codecvt_facet.hpp>
+
+#include <boost/archive/detail/abi_prefix.hpp> // must be the last header
+
+#ifdef BOOST_MSVC
+# pragma warning(push)
+# pragma warning(disable : 4511 4512)
+#endif
+
+namespace boost {
+namespace archive {
+
+namespace detail {
+ template<class Archive> class interface_oarchive;
+} // namespace detail
+
+template<class Archive>
+class BOOST_SYMBOL_VISIBLE xml_woarchive_impl :
+ public basic_text_oprimitive<std::wostream>,
+ public basic_xml_oarchive<Archive>
+{
+#ifdef BOOST_NO_MEMBER_TEMPLATE_FRIENDS
+public:
+#else
+protected:
+ friend class detail::interface_oarchive<Archive>;
+ friend class basic_xml_oarchive<Archive>;
+ friend class save_access;
+#endif
+ //void end_preamble(){
+ // basic_xml_oarchive<Archive>::end_preamble();
+ //}
+ template<class T>
+ void
+ save(const T & t){
+ basic_text_oprimitive<std::wostream>::save(t);
+ }
+ void
+ save(const version_type & t){
+ save(static_cast<unsigned int>(t));
+ }
+ void
+ save(const boost::serialization::item_version_type & t){
+ save(static_cast<unsigned int>(t));
+ }
+ BOOST_WARCHIVE_DECL void
+ save(const char * t);
+ #ifndef BOOST_NO_INTRINSIC_WCHAR_T
+ BOOST_WARCHIVE_DECL void
+ save(const wchar_t * t);
+ #endif
+ BOOST_WARCHIVE_DECL void
+ save(const std::string &s);
+ #ifndef BOOST_NO_STD_WSTRING
+ BOOST_WARCHIVE_DECL void
+ save(const std::wstring &ws);
+ #endif
+ BOOST_WARCHIVE_DECL
+ xml_woarchive_impl(std::wostream & os, unsigned int flags);
+ BOOST_WARCHIVE_DECL
+ ~xml_woarchive_impl();
+public:
+ BOOST_WARCHIVE_DECL void
+ save_binary(const void *address, std::size_t count);
+
+};
+
+// we use the following because we can't use
+// typedef xml_woarchive_impl<xml_woarchive_impl<...> > xml_woarchive;
+
+// do not derive from this class. If you want to extend this functionality
+// via inhertance, derived from xml_woarchive_impl instead. This will
+// preserve correct static polymorphism.
+class BOOST_SYMBOL_VISIBLE xml_woarchive :
+ public xml_woarchive_impl<xml_woarchive>
+{
+public:
+ xml_woarchive(std::wostream & os, unsigned int flags = 0) :
+ xml_woarchive_impl<xml_woarchive>(os, flags)
+ {}
+ ~xml_woarchive(){}
+};
+
+} // namespace archive
+} // namespace boost
+
+// required by export
+BOOST_SERIALIZATION_REGISTER_ARCHIVE(boost::archive::xml_woarchive)
+
+#ifdef BOOST_MSVC
+#pragma warning(pop)
+#endif
+
+#include <boost/archive/detail/abi_suffix.hpp> // pops abi_suffix.hpp pragmas
+
+#endif // BOOST_NO_STD_WSTREAMBUF
+#endif // BOOST_ARCHIVE_XML_OARCHIVE_HPP