summaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
Diffstat (limited to '3rdParty/Boost/src/boost/archive/detail')
-rw-r--r--3rdParty/Boost/src/boost/archive/detail/abi_prefix.hpp20
-rw-r--r--3rdParty/Boost/src/boost/archive/detail/abi_suffix.hpp19
-rw-r--r--3rdParty/Boost/src/boost/archive/detail/archive_serializer_map.hpp55
-rw-r--r--3rdParty/Boost/src/boost/archive/detail/auto_link_archive.hpp48
-rw-r--r--3rdParty/Boost/src/boost/archive/detail/auto_link_warchive.hpp47
-rw-r--r--3rdParty/Boost/src/boost/archive/detail/basic_iarchive.hpp110
-rw-r--r--3rdParty/Boost/src/boost/archive/detail/basic_iserializer.hpp95
-rw-r--r--3rdParty/Boost/src/boost/archive/detail/basic_oarchive.hpp106
-rw-r--r--3rdParty/Boost/src/boost/archive/detail/basic_oserializer.hpp93
-rw-r--r--3rdParty/Boost/src/boost/archive/detail/basic_pointer_iserializer.hpp73
-rw-r--r--3rdParty/Boost/src/boost/archive/detail/basic_pointer_oserializer.hpp72
-rw-r--r--3rdParty/Boost/src/boost/archive/detail/basic_serializer.hpp79
-rw-r--r--3rdParty/Boost/src/boost/archive/detail/basic_serializer_map.hpp69
-rw-r--r--3rdParty/Boost/src/boost/archive/detail/check.hpp169
-rw-r--r--3rdParty/Boost/src/boost/archive/detail/common_iarchive.hpp88
-rw-r--r--3rdParty/Boost/src/boost/archive/detail/common_oarchive.hpp87
-rw-r--r--3rdParty/Boost/src/boost/archive/detail/decl.hpp79
-rw-r--r--3rdParty/Boost/src/boost/archive/detail/interface_iarchive.hpp77
-rw-r--r--3rdParty/Boost/src/boost/archive/detail/interface_oarchive.hpp84
-rw-r--r--3rdParty/Boost/src/boost/archive/detail/iserializer.hpp632
-rw-r--r--3rdParty/Boost/src/boost/archive/detail/oserializer.hpp531
-rw-r--r--3rdParty/Boost/src/boost/archive/detail/register_archive.hpp91
-rw-r--r--3rdParty/Boost/src/boost/archive/detail/utf8_codecvt_facet.hpp21
23 files changed, 2745 insertions, 0 deletions
diff --git a/3rdParty/Boost/src/boost/archive/detail/abi_prefix.hpp b/3rdParty/Boost/src/boost/archive/detail/abi_prefix.hpp
new file mode 100644
index 0000000..e39ef11
--- /dev/null
+++ b/3rdParty/Boost/src/boost/archive/detail/abi_prefix.hpp
@@ -0,0 +1,20 @@
+/////////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
+
+#if defined( __BORLANDC__ )
+#pragma nopushoptwarn
+#endif
+
diff --git a/3rdParty/Boost/src/boost/archive/detail/abi_suffix.hpp b/3rdParty/Boost/src/boost/archive/detail/abi_suffix.hpp
new file mode 100644
index 0000000..a283b36
--- /dev/null
+++ b/3rdParty/Boost/src/boost/archive/detail/abi_suffix.hpp
@@ -0,0 +1,19 @@
+/////////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
+
+#if defined( __BORLANDC__ )
+#pragma nopushoptwarn
+#endif
+
diff --git a/3rdParty/Boost/src/boost/archive/detail/archive_serializer_map.hpp b/3rdParty/Boost/src/boost/archive/detail/archive_serializer_map.hpp
new file mode 100644
index 0000000..6d2eec4
--- /dev/null
+++ b/3rdParty/Boost/src/boost/archive/detail/archive_serializer_map.hpp
@@ -0,0 +1,55 @@
+#ifndef BOOST_ARCHIVE_SERIALIZER_MAP_HPP
+#define BOOST_ARCHIVE_SERIALIZER_MAP_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+# pragma once
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// archive_serializer_map.hpp: extenstion of type_info required for
+// serialization.
+
+// (C) Copyright 2009 Robert Ramey - http://www.rrsd.com .
+// Use, modification and distribution is subject to the Boost Software
+// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+
+// See http://www.boost.org for updates, documentation, and revision history.
+
+// note: this is nothing more than the thinest of wrappers around
+// basic_serializer_map so we can have a one map / archive type.
+
+#include <boost/config.hpp>
+#include <boost/archive/detail/auto_link_archive.hpp>
+#include <boost/archive/detail/abi_prefix.hpp> // must be the last header
+
+namespace boost {
+
+namespace serialization {
+ class extended_type_info;
+} // namespace serialization
+
+namespace archive {
+namespace detail {
+
+class basic_serializer;
+
+template<class Archive>
+class BOOST_ARCHIVE_OR_WARCHIVE_DECL(BOOST_PP_EMPTY())
+archive_serializer_map {
+public:
+ static bool insert(const basic_serializer * bs);
+ static void erase(const basic_serializer * bs);
+ static const basic_serializer * find(
+ const boost::serialization::extended_type_info & type_
+ );
+};
+
+} // namespace detail
+} // namespace archive
+} // namespace boost
+
+#include <boost/archive/detail/abi_suffix.hpp> // must be the last header
+
+#endif //BOOST_ARCHIVE_SERIALIZER_MAP_HPP
diff --git a/3rdParty/Boost/src/boost/archive/detail/auto_link_archive.hpp b/3rdParty/Boost/src/boost/archive/detail/auto_link_archive.hpp
new file mode 100644
index 0000000..05956f0
--- /dev/null
+++ b/3rdParty/Boost/src/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) && (_MSC_VER >= 1020)
+# 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/3rdParty/Boost/src/boost/archive/detail/auto_link_warchive.hpp b/3rdParty/Boost/src/boost/archive/detail/auto_link_warchive.hpp
new file mode 100644
index 0000000..4d4efcd
--- /dev/null
+++ b/3rdParty/Boost/src/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) && (_MSC_VER >= 1020)
+# 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/3rdParty/Boost/src/boost/archive/detail/basic_iarchive.hpp b/3rdParty/Boost/src/boost/archive/detail/basic_iarchive.hpp
new file mode 100644
index 0000000..f62987e
--- /dev/null
+++ b/3rdParty/Boost/src/boost/archive/detail/basic_iarchive.hpp
@@ -0,0 +1,110 @@
+#ifndef BOOST_ARCHIVE_DETAIL_BASIC_IARCHIVE_HPP
+#define BOOST_ARCHIVE_DETAIL_BASIC_IARCHIVE_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+# pragma once
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// 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/scoped_ptr.hpp>
+
+#include <boost/config.hpp>
+#include <boost/noncopyable.hpp>
+
+#include <boost/type_traits/broken_compiler_spec.hpp>
+#include <boost/serialization/tracking_enum.hpp>
+#include <boost/archive/basic_archive.hpp>
+#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_impl;
+class BOOST_ARCHIVE_DECL(BOOST_PP_EMPTY()) basic_iserializer;
+class BOOST_ARCHIVE_DECL(BOOST_PP_EMPTY()) basic_pointer_iserializer;
+//////////////////////////////////////////////////////////////////////
+// class basic_iarchive - read serialized objects from a input stream
+class BOOST_ARCHIVE_DECL(BOOST_PP_EMPTY()) basic_iarchive :
+ private boost::noncopyable
+{
+ friend class basic_iarchive_impl;
+ // hide implementation of this class to minimize header conclusion
+ // in client code. I couldn't used scoped pointer with borland
+ // boost::scoped_ptr<basic_iarchive_impl> pimpl;
+ 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:
+ basic_iarchive(unsigned int flags);
+ // account for bogus gcc warning
+ #if defined(__GNUC__)
+ virtual
+ #endif
+ ~basic_iarchive();
+public:
+ // note: NOT part of the public API.
+ void next_object_pointer(void *t);
+ void register_basic_serializer(
+ const basic_iserializer & bis
+ );
+ void load_object(
+ void *t,
+ const basic_iserializer & bis
+ );
+ const basic_pointer_iserializer *
+ load_pointer(
+ void * & t,
+ const basic_pointer_iserializer * bpis_ptr,
+ const basic_pointer_iserializer * (*finder)(
+ const boost::serialization::extended_type_info & eti
+ )
+
+ );
+ // real public API starts here
+ void
+ set_library_version(library_version_type archive_library_version);
+ library_version_type
+ get_library_version() const;
+ unsigned int
+ get_flags() const;
+ void
+ reset_object_address(const void * new_address, const void * old_address);
+ void
+ delete_created_pointers();
+};
+
+} // namespace detail
+} // namespace archive
+} // namespace boost
+
+// required by smart_cast for compilers not implementing
+// partial template specialization
+BOOST_TT_BROKEN_COMPILER_SPEC(
+ boost::archive::detail::basic_iarchive
+)
+
+#include <boost/archive/detail/abi_suffix.hpp> // pops abi_suffix.hpp pragmas
+
+#endif //BOOST_ARCHIVE_DETAIL_BASIC_IARCHIVE_HPP
diff --git a/3rdParty/Boost/src/boost/archive/detail/basic_iserializer.hpp b/3rdParty/Boost/src/boost/archive/detail/basic_iserializer.hpp
new file mode 100644
index 0000000..2f4f6d8
--- /dev/null
+++ b/3rdParty/Boost/src/boost/archive/detail/basic_iserializer.hpp
@@ -0,0 +1,95 @@
+#ifndef BOOST_ARCHIVE_DETAIL_BASIC_ISERIALIZER_HPP
+#define BOOST_ARCHIVE_DETAIL_BASIC_ISERIALIZER_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
+// 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 BOOST_ARCHIVE_DECL(BOOST_PP_EMPTY()) basic_iarchive;
+class BOOST_ARCHIVE_DECL(BOOST_PP_EMPTY()) basic_pointer_iserializer;
+
+class BOOST_ARCHIVE_DECL(BOOST_PP_EMPTY()) basic_iserializer :
+ public basic_serializer
+{
+private:
+ basic_pointer_iserializer *m_bpis;
+protected:
+ explicit basic_iserializer(
+ const boost::serialization::extended_type_info & type
+ );
+ // account for bogus gcc warning
+ #if defined(__GNUC__)
+ virtual
+ #endif
+ ~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/3rdParty/Boost/src/boost/archive/detail/basic_oarchive.hpp b/3rdParty/Boost/src/boost/archive/detail/basic_oarchive.hpp
new file mode 100644
index 0000000..402e569
--- /dev/null
+++ b/3rdParty/Boost/src/boost/archive/detail/basic_oarchive.hpp
@@ -0,0 +1,106 @@
+#ifndef BOOST_ARCHIVE_BASIC_OARCHIVE_HPP
+#define BOOST_ARCHIVE_BASIC_OARCHIVE_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+# pragma once
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// 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/type_traits/broken_compiler_spec.hpp>
+
+// can't use this - much as I'd like to as borland doesn't support it
+// #include <boost/scoped_ptr.hpp>
+
+#include <boost/archive/basic_archive.hpp>
+#include <boost/serialization/tracking_enum.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 BOOST_ARCHIVE_DECL(BOOST_PP_EMPTY()) basic_oserializer;
+class BOOST_ARCHIVE_DECL(BOOST_PP_EMPTY()) basic_pointer_oserializer;
+//////////////////////////////////////////////////////////////////////
+// class basic_oarchive - write serialized objects to an output stream
+class BOOST_ARCHIVE_OR_WARCHIVE_DECL(BOOST_PP_EMPTY()) basic_oarchive :
+ private boost::noncopyable
+{
+ friend class basic_oarchive_impl;
+ // hide implementation of this class to minimize header conclusion
+ // in client code. note: borland can't use scoped_ptr
+ //boost::scoped_ptr<basic_oarchive_impl> pimpl;
+ 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:
+ basic_oarchive(unsigned int flags = 0);
+ // account for bogus gcc warning
+ #if defined(__GNUC__)
+ virtual
+ #endif
+ ~basic_oarchive();
+public:
+ // note: NOT part of the public interface
+ void register_basic_serializer(
+ const basic_oserializer & bos
+ );
+ void save_object(
+ const void *x,
+ const basic_oserializer & bos
+ );
+ 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
+ void end_preamble(); // default implementation does nothing
+ library_version_type get_library_version() const;
+ unsigned int get_flags() const;
+};
+
+} // namespace detail
+} // namespace archive
+} // namespace boost
+
+// required by smart_cast for compilers not implementing
+// partial template specialization
+BOOST_TT_BROKEN_COMPILER_SPEC(
+ boost::archive::detail::basic_oarchive
+)
+
+#include <boost/archive/detail/abi_suffix.hpp> // pops abi_suffix.hpp pragmas
+
+#endif //BOOST_ARCHIVE_BASIC_OARCHIVE_HPP
diff --git a/3rdParty/Boost/src/boost/archive/detail/basic_oserializer.hpp b/3rdParty/Boost/src/boost/archive/detail/basic_oserializer.hpp
new file mode 100644
index 0000000..74af7e6
--- /dev/null
+++ b/3rdParty/Boost/src/boost/archive/detail/basic_oserializer.hpp
@@ -0,0 +1,93 @@
+#ifndef BOOST_SERIALIZATION_BASIC_OSERIALIZER_HPP
+#define BOOST_SERIALIZATION_BASIC_OSERIALIZER_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
+// 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 BOOST_ARCHIVE_DECL(BOOST_PP_EMPTY()) basic_oarchive;
+class BOOST_ARCHIVE_DECL(BOOST_PP_EMPTY()) basic_pointer_oserializer;
+
+class BOOST_ARCHIVE_DECL(BOOST_PP_EMPTY()) basic_oserializer :
+ public basic_serializer
+{
+private:
+ basic_pointer_oserializer *m_bpos;
+protected:
+ explicit basic_oserializer(
+ const boost::serialization::extended_type_info & type_
+ );
+ // account for bogus gcc warning
+ #if defined(__GNUC__)
+ virtual
+ #endif
+ ~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/3rdParty/Boost/src/boost/archive/detail/basic_pointer_iserializer.hpp b/3rdParty/Boost/src/boost/archive/detail/basic_pointer_iserializer.hpp
new file mode 100644
index 0000000..d957b83
--- /dev/null
+++ b/3rdParty/Boost/src/boost/archive/detail/basic_pointer_iserializer.hpp
@@ -0,0 +1,73 @@
+#ifndef BOOST_ARCHIVE_BASIC_POINTER_ISERIALIZER_HPP
+#define BOOST_ARCHIVE_BASIC_POINTER_ISERIALIZER_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
+// 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 BOOST_ARCHIVE_DECL(BOOST_PP_EMPTY()) basic_iarchive;
+class BOOST_ARCHIVE_DECL(BOOST_PP_EMPTY()) basic_iserializer;
+
+class BOOST_ARCHIVE_DECL(BOOST_PP_EMPTY()) basic_pointer_iserializer
+ : public basic_serializer {
+protected:
+ explicit basic_pointer_iserializer(
+ const boost::serialization::extended_type_info & type_
+ );
+ // account for bogus gcc warning
+ #if defined(__GNUC__)
+ virtual
+ #endif
+ ~basic_pointer_iserializer();
+public:
+ 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/3rdParty/Boost/src/boost/archive/detail/basic_pointer_oserializer.hpp b/3rdParty/Boost/src/boost/archive/detail/basic_pointer_oserializer.hpp
new file mode 100644
index 0000000..b0d3fb9
--- /dev/null
+++ b/3rdParty/Boost/src/boost/archive/detail/basic_pointer_oserializer.hpp
@@ -0,0 +1,72 @@
+#ifndef BOOST_ARCHIVE_BASIC_POINTER_OSERIALIZER_HPP
+#define BOOST_ARCHIVE_BASIC_POINTER_OSERIALIZER_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
+// 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 BOOST_ARCHIVE_DECL(BOOST_PP_EMPTY()) basic_oarchive;
+class BOOST_ARCHIVE_DECL(BOOST_PP_EMPTY()) basic_oserializer;
+
+class BOOST_ARCHIVE_DECL(BOOST_PP_EMPTY()) basic_pointer_oserializer :
+ public basic_serializer
+{
+protected:
+ explicit basic_pointer_oserializer(
+ const boost::serialization::extended_type_info & type_
+ );
+public:
+ // account for bogus gcc warning
+ #if defined(__GNUC__)
+ virtual
+ #endif
+ ~basic_pointer_oserializer();
+ virtual 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/3rdParty/Boost/src/boost/archive/detail/basic_serializer.hpp b/3rdParty/Boost/src/boost/archive/detail/basic_serializer.hpp
new file mode 100644
index 0000000..5dbd886
--- /dev/null
+++ b/3rdParty/Boost/src/boost/archive/detail/basic_serializer.hpp
@@ -0,0 +1,79 @@
+#ifndef BOOST_ARCHIVE_BASIC_SERIALIZER_HPP
+#define BOOST_ARCHIVE_BASIC_SERIALIZER_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
+// 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)
+ {
+ BOOST_ASSERT(NULL != & eti);
+ }
+public:
+ inline bool
+ operator<(const basic_serializer & rhs) const {
+ // can't compare address since there can be multiple eti records
+ // for the same type in different execution modules (that is, DLLS)
+ // leave this here as a reminder not to do this!
+ // return & lhs.get_eti() < & rhs.get_eti();
+ return get_eti() < rhs.get_eti();
+ }
+ const char * get_debug_info() const {
+ return m_eti->get_debug_info();
+ }
+ const boost::serialization::extended_type_info & get_eti() const {
+ return * m_eti;
+ }
+};
+
+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/3rdParty/Boost/src/boost/archive/detail/basic_serializer_map.hpp b/3rdParty/Boost/src/boost/archive/detail/basic_serializer_map.hpp
new file mode 100644
index 0000000..a991ea1
--- /dev/null
+++ b/3rdParty/Boost/src/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) && (_MSC_VER >= 1020)
+# 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_ARCHIVE_OR_WARCHIVE_DECL(BOOST_PP_EMPTY())
+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:
+ bool insert(const basic_serializer * bs);
+ void erase(const basic_serializer * bs);
+ const basic_serializer * find(
+ const boost::serialization::extended_type_info & type_
+ ) const;
+private:
+ // cw 8.3 requires this
+ basic_serializer_map& operator=(basic_serializer_map const&);
+};
+
+} // 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/3rdParty/Boost/src/boost/archive/detail/check.hpp b/3rdParty/Boost/src/boost/archive/detail/check.hpp
new file mode 100644
index 0000000..c9cba51
--- /dev/null
+++ b/3rdParty/Boost/src/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) && (_MSC_VER >= 1020)
+# pragma once
+#pragma inline_depth(511)
+#pragma inline_recursion(on)
+#endif
+
+#if defined(__MWERKS__)
+#pragma inline_depth(511)
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// check.hpp: interface for serialization system.
+
+// (C) Copyright 2009 Robert Ramey - http://www.rrsd.com .
+// Use, modification and distribution is subject to the Boost Software
+// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+
+// See http://www.boost.org for updates, documentation, and revision history.
+
+#include <boost/config.hpp>
+
+#include <boost/static_assert.hpp>
+#include <boost/type_traits/is_const.hpp>
+
+#include <boost/mpl/eval_if.hpp>
+#include <boost/mpl/or.hpp>
+#include <boost/mpl/equal_to.hpp>
+#include <boost/mpl/int.hpp>
+#include <boost/mpl/not.hpp>
+#include <boost/mpl/greater.hpp>
+#include <boost/mpl/assert.hpp>
+
+#include <boost/serialization/static_warning.hpp>
+#include <boost/serialization/version.hpp>
+#include <boost/serialization/level.hpp>
+#include <boost/serialization/tracking.hpp>
+#include <boost/serialization/wrapper.hpp>
+
+namespace boost {
+namespace archive {
+namespace detail {
+
+// checks for objects
+
+template<class T>
+inline void check_object_level(){
+ typedef
+ BOOST_DEDUCED_TYPENAME mpl::greater_equal<
+ serialization::implementation_level< T >,
+ mpl::int_<serialization::primitive_type>
+ >::type typex;
+
+ // trap attempts to serialize objects marked
+ // not_serializable
+ BOOST_STATIC_ASSERT(typex::value);
+}
+
+template<class T>
+inline void check_object_versioning(){
+ typedef
+ BOOST_DEDUCED_TYPENAME mpl::or_<
+ BOOST_DEDUCED_TYPENAME mpl::greater<
+ serialization::implementation_level< T >,
+ mpl::int_<serialization::object_serializable>
+ >,
+ BOOST_DEDUCED_TYPENAME mpl::equal_to<
+ serialization::version< T >,
+ mpl::int_<0>
+ >
+ > typex;
+ // trap attempts to serialize with objects that don't
+ // save class information in the archive with versioning.
+ BOOST_STATIC_ASSERT(typex::value);
+}
+
+template<class T>
+inline void check_object_tracking(){
+ // presume it has already been determined that
+ // T is not a const
+ BOOST_STATIC_ASSERT(! boost::is_const< T >::value);
+ typedef BOOST_DEDUCED_TYPENAME mpl::equal_to<
+ serialization::tracking_level< T >,
+ mpl::int_<serialization::track_never>
+ >::type typex;
+ // saving an non-const object of a type not marked "track_never)
+
+ // may be an indicator of an error usage of the
+ // serialization library and should be double checked.
+ // See documentation on object tracking. Also, see the
+ // "rationale" section of the documenation
+ // for motivation for this checking.
+
+ BOOST_STATIC_WARNING(typex::value);
+}
+
+// checks for pointers
+
+template<class T>
+inline void check_pointer_level(){
+ // we should only invoke this once we KNOW that T
+ // has been used as a pointer!!
+ typedef
+ BOOST_DEDUCED_TYPENAME mpl::or_<
+ BOOST_DEDUCED_TYPENAME mpl::greater<
+ serialization::implementation_level< T >,
+ mpl::int_<serialization::object_serializable>
+ >,
+ BOOST_DEDUCED_TYPENAME mpl::not_<
+ BOOST_DEDUCED_TYPENAME mpl::equal_to<
+ serialization::tracking_level< T >,
+ mpl::int_<serialization::track_selectively>
+ >
+ >
+ > typex;
+ // Address the following when serializing to a pointer:
+
+ // a) This type doesn't save class information in the
+ // archive. That is, the serialization trait implementation
+ // level <= object_serializable.
+ // b) Tracking for this type is set to "track selectively"
+
+ // in this case, indication that an object is tracked is
+ // not stored in the archive itself - see level == object_serializable
+ // but rather the existence of the operation ar >> T * is used to
+ // infer that an object of this type should be tracked. So, if
+ // you save via a pointer but don't load via a pointer the operation
+ // will fail on load without given any valid reason for the failure.
+
+ // So if your program traps here, consider changing the
+ // tracking or implementation level traits - or not
+ // serializing via a pointer.
+ BOOST_STATIC_WARNING(typex::value);
+}
+
+template<class T>
+void inline check_pointer_tracking(){
+ typedef BOOST_DEDUCED_TYPENAME mpl::greater<
+ serialization::tracking_level< T >,
+ mpl::int_<serialization::track_never>
+ >::type typex;
+ // serializing an object of a type marked "track_never" through a pointer
+ // could result in creating more objects than were saved!
+ BOOST_STATIC_WARNING(typex::value);
+}
+
+template<class T>
+inline void check_const_loading(){
+ typedef
+ BOOST_DEDUCED_TYPENAME mpl::or_<
+ BOOST_DEDUCED_TYPENAME boost::serialization::is_wrapper< T >,
+ BOOST_DEDUCED_TYPENAME mpl::not_<
+ BOOST_DEDUCED_TYPENAME boost::is_const< T >
+ >
+ >::type typex;
+ // cannot load data into a "const" object unless it's a
+ // wrapper around some other non-const object.
+ BOOST_STATIC_ASSERT(typex::value);
+}
+
+} // detail
+} // archive
+} // boost
+
+#endif // BOOST_ARCHIVE_DETAIL_CHECK_HPP
diff --git a/3rdParty/Boost/src/boost/archive/detail/common_iarchive.hpp b/3rdParty/Boost/src/boost/archive/detail/common_iarchive.hpp
new file mode 100644
index 0000000..54c07c3
--- /dev/null
+++ b/3rdParty/Boost/src/boost/archive/detail/common_iarchive.hpp
@@ -0,0 +1,88 @@
+#ifndef BOOST_ARCHIVE_DETAIL_COMMON_IARCHIVE_HPP
+#define BOOST_ARCHIVE_DETAIL_COMMON_IARCHIVE_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+# pragma once
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// 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 common_iarchive :
+ public basic_iarchive,
+ public interface_iarchive<Archive>
+{
+ friend class interface_iarchive<Archive>;
+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, BOOST_PFTO int){
+ 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/3rdParty/Boost/src/boost/archive/detail/common_oarchive.hpp b/3rdParty/Boost/src/boost/archive/detail/common_oarchive.hpp
new file mode 100644
index 0000000..7962063
--- /dev/null
+++ b/3rdParty/Boost/src/boost/archive/detail/common_oarchive.hpp
@@ -0,0 +1,87 @@
+#ifndef BOOST_ARCHIVE_DETAIL_COMMON_OARCHIVE_HPP
+#define BOOST_ARCHIVE_DETAIL_COMMON_OARCHIVE_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+# pragma once
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// 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 common_oarchive :
+ public basic_oarchive,
+ public interface_oarchive<Archive>
+{
+ friend class interface_oarchive<Archive>;
+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, BOOST_PFTO int){
+ 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/3rdParty/Boost/src/boost/archive/detail/decl.hpp b/3rdParty/Boost/src/boost/archive/detail/decl.hpp
new file mode 100644
index 0000000..9695001
--- /dev/null
+++ b/3rdParty/Boost/src/boost/archive/detail/decl.hpp
@@ -0,0 +1,79 @@
+#ifndef BOOST_ARCHIVE_DETAIL_DECL_HPP
+#define BOOST_ARCHIVE_DETAIL_DECL_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
+// 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>
+#include <boost/preprocessor/facilities/empty.hpp>
+
+#if defined(BOOST_HAS_DECLSPEC)
+ #if (defined(BOOST_ALL_DYN_LINK) || defined(BOOST_SERIALIZATION_DYN_LINK))
+ #if defined(BOOST_ARCHIVE_SOURCE)
+ #if defined(__BORLANDC__)
+ #define BOOST_ARCHIVE_DECL(T) T __export
+ #define BOOST_ARCHIVE_OR_WARCHIVE_DECL(T) T __export
+ #else
+ #define BOOST_ARCHIVE_DECL(T) __declspec(dllexport) T
+ #define BOOST_ARCHIVE_OR_WARCHIVE_DECL(T) __declspec(dllexport) T
+ #endif
+ #else
+ #if defined(__BORLANDC__)
+ #define BOOST_ARCHIVE_DECL(T) T __import
+ #else
+ #define BOOST_ARCHIVE_DECL(T) __declspec(dllimport) T
+ #endif
+ #endif
+ #if defined(BOOST_WARCHIVE_SOURCE)
+ #if defined(__BORLANDC__)
+ #define BOOST_WARCHIVE_DECL(T) T __export
+ #define BOOST_ARCHIVE_OR_WARCHIVE_DECL(T) T __export
+ #else
+ #define BOOST_WARCHIVE_DECL(T) __declspec(dllexport) T
+ #define BOOST_ARCHIVE_OR_WARCHIVE_DECL(T) __declspec(dllexport) T
+ #endif
+ #else
+ #if defined(__BORLANDC__)
+ #define BOOST_WARCHIVE_DECL(T) T __import
+ #else
+ #define BOOST_WARCHIVE_DECL(T) __declspec(dllimport) T
+ #endif
+ #endif
+ #if !defined(BOOST_WARCHIVE_SOURCE) && !defined(BOOST_ARCHIVE_SOURCE)
+ #if defined(__BORLANDC__)
+ #define BOOST_ARCHIVE_OR_WARCHIVE_DECL(T) T __import
+ #else
+ #define BOOST_ARCHIVE_OR_WARCHIVE_DECL(T) __declspec(dllimport) T
+ #endif
+ #endif
+ #endif
+#endif // BOOST_HAS_DECLSPEC
+
+#if ! defined(BOOST_ARCHIVE_DECL)
+ #define BOOST_ARCHIVE_DECL(T) T
+#endif
+#if ! defined(BOOST_WARCHIVE_DECL)
+ #define BOOST_WARCHIVE_DECL(T) T
+#endif
+#if ! defined(BOOST_ARCHIVE_OR_WARCHIVE_DECL)
+ #define BOOST_ARCHIVE_OR_WARCHIVE_DECL(T) T
+#endif
+
+#endif // BOOST_ARCHIVE_DETAIL_DECL_HPP
diff --git a/3rdParty/Boost/src/boost/archive/detail/interface_iarchive.hpp b/3rdParty/Boost/src/boost/archive/detail/interface_iarchive.hpp
new file mode 100644
index 0000000..0648752
--- /dev/null
+++ b/3rdParty/Boost/src/boost/archive/detail/interface_iarchive.hpp
@@ -0,0 +1,77 @@
+#ifndef BOOST_ARCHIVE_DETAIL_INTERFACE_IARCHIVE_HPP
+#define BOOST_ARCHIVE_DETAIL_INTERFACE_IARCHIVE_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+# pragma once
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// 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/serialization/singleton.hpp>
+#include <boost/archive/detail/abi_prefix.hpp> // must be the last header
+
+namespace boost {
+namespace archive {
+namespace detail {
+
+class BOOST_ARCHIVE_OR_WARCHIVE_DECL(BOOST_PP_EMPTY()) 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 T>
+ Archive & operator>>(T & t){
+ this->This()->load_override(t, 0);
+ 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/3rdParty/Boost/src/boost/archive/detail/interface_oarchive.hpp b/3rdParty/Boost/src/boost/archive/detail/interface_oarchive.hpp
new file mode 100644
index 0000000..e8db7a2
--- /dev/null
+++ b/3rdParty/Boost/src/boost/archive/detail/interface_oarchive.hpp
@@ -0,0 +1,84 @@
+#ifndef BOOST_ARCHIVE_DETAIL_INTERFACE_OARCHIVE_HPP
+#define BOOST_ARCHIVE_DETAIL_INTERFACE_OARCHIVE_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+# pragma once
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// 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 BOOST_ARCHIVE_OR_WARCHIVE_DECL(BOOST_PP_EMPTY()) 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 T>
+ Archive & operator<<(T & t){
+ this->This()->save_override(t, 0);
+ return * this->This();
+ }
+
+ // the & operator
+ template<class T>
+ Archive & operator&(T & t){
+ #ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING
+ return * this->This() << const_cast<const T &>(t);
+ #else
+ return * this->This() << t;
+ #endif
+ }
+};
+
+} // 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/3rdParty/Boost/src/boost/archive/detail/iserializer.hpp b/3rdParty/Boost/src/boost/archive/detail/iserializer.hpp
new file mode 100644
index 0000000..53765af
--- /dev/null
+++ b/3rdParty/Boost/src/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) && (_MSC_VER >= 1020)
+# pragma once
+#pragma inline_depth(511)
+#pragma inline_recursion(on)
+#endif
+
+#if defined(__MWERKS__)
+#pragma inline_depth(511)
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// 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 <memory> // for auto_ptr
+#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/mpl/bool.hpp>
+#include <boost/detail/no_exceptions_support.hpp>
+
+#ifndef BOOST_SERIALIZATION_DEFAULT_TYPE_INFO
+ #include <boost/serialization/extended_type_info_typeid.hpp>
+#endif
+#include <boost/serialization/throw_exception.hpp>
+#include <boost/serialization/smart_cast.hpp>
+#include <boost/serialization/static_warning.hpp>
+
+#include <boost/type_traits/is_pointer.hpp>
+#include <boost/type_traits/is_enum.hpp>
+#include <boost/type_traits/is_const.hpp>
+#include <boost/type_traits/remove_const.hpp>
+#include <boost/type_traits/remove_extent.hpp>
+#include <boost/type_traits/is_polymorphic.hpp>
+
+#include <boost/serialization/assume_abstract.hpp>
+
+#define DONT_USE_HAS_NEW_OPERATOR ( \
+ defined(__BORLANDC__) \
+ || BOOST_WORKAROUND(__IBMCPP__, < 1210) \
+ || defined(BOOST_MSVC) && (BOOST_MSVC <= 1300) \
+ || defined(__SUNPRO_CC) && (__SUNPRO_CC < 0x590) \
+)
+
+#if ! DONT_USE_HAS_NEW_OPERATOR
+#include <boost/type_traits/has_new_operator.hpp>
+#endif
+
+#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/array.hpp>
+#include <boost/serialization/collection_size_type.hpp>
+#include <boost/serialization/singleton.hpp>
+#include <boost/serialization/wrapper.hpp>
+
+// the following is need only for dynamic cast of polymorphic pointers
+#include <boost/archive/archive_exception.hpp>
+#include <boost/archive/detail/basic_iarchive.hpp>
+#include <boost/archive/detail/basic_iserializer.hpp>
+#include <boost/archive/detail/basic_pointer_iserializer.hpp>
+#include <boost/archive/detail/archive_serializer_map.hpp>
+#include <boost/archive/detail/check.hpp>
+
+namespace boost {
+
+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<
+ BOOST_DEDUCED_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
+
+template<class Archive, class T>
+class pointer_iserializer :
+ public basic_pointer_iserializer
+{
+private:
+ 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 trick to be sure that operator new is using class specific
+// version if such exists. Due to Peter Dimov.
+// note: the following fails if T has no default constructor.
+// otherwise it would have been ideal
+//struct heap_allocator : public T
+//{
+// T * invoke(){
+// return ::new(sizeof(T));
+// }
+//}
+
+template<class T>
+struct heap_allocator
+{
+ // boost::has_new_operator< T > doesn't work on these compilers
+ #if DONT_USE_HAS_NEW_OPERATOR
+ // This doesn't handle operator new overload for class T
+ static T * invoke(){
+ return static_cast<T *>(operator new(sizeof(T)));
+ }
+ #else
+ struct has_new_operator {
+ static T* invoke() {
+ return static_cast<T *>((T::operator new)(sizeof(T)));
+ }
+ };
+ struct doesnt_have_new_operator {
+ static T* invoke() {
+ return static_cast<T *>(operator new(sizeof(T)));
+ }
+ };
+ static T * invoke() {
+ typedef BOOST_DEDUCED_TYPENAME
+ mpl::eval_if<
+ boost::has_new_operator< T >,
+ mpl::identity<has_new_operator >,
+ mpl::identity<doesnt_have_new_operator >
+ >::type typex;
+ return typex::invoke();
+ }
+ #endif
+};
+
+// due to Martin Ecker
+template <typename T>
+class auto_ptr_with_deleter
+{
+public:
+ explicit auto_ptr_with_deleter(T* p) :
+ m_p(p)
+ {}
+ ~auto_ptr_with_deleter(){
+ if (m_p)
+ boost::serialization::access::destroy(m_p);
+ }
+ T* get() const {
+ return m_p;
+ }
+
+ T* release() {
+ T* p = m_p;
+ m_p = NULL;
+ return p;
+ }
+private:
+ T* m_p;
+};
+
+// note: BOOST_DLLEXPORT is so that code for polymorphic class
+// serialized only through base class won't get optimized out
+template<class Archive, class T>
+BOOST_DLLEXPORT void pointer_iserializer<Archive, T>::load_object_ptr(
+ basic_iarchive & ar,
+ void * & x,
+ const unsigned int file_version
+) const
+{
+ Archive & ar_impl =
+ boost::serialization::smart_cast_reference<Archive &>(ar);
+
+ auto_ptr_with_deleter< T > ap(heap_allocator< T >::invoke());
+ if(NULL == ap.get())
+ boost::serialization::throw_exception(std::bad_alloc()) ;
+
+ T * t = ap.get();
+ x = t;
+
+ // 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 situtation 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,
+ t,
+ file_version
+ );
+ }
+ BOOST_CATCH(...){
+ ap.release();
+ BOOST_RETHROW;
+ }
+ BOOST_CATCH_END
+
+ ar_impl >> boost::serialization::make_nvp(NULL, * t);
+ ap.release();
+}
+
+template<class Archive, class T>
+pointer_iserializer<Archive, T>::pointer_iserializer() :
+ basic_pointer_iserializer(
+ boost::serialization::singleton<
+ BOOST_DEDUCED_TYPENAME
+ boost::serialization::type_info_implementation< T >::type
+ >::get_const_instance()
+ )
+{
+ 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 = & 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 BOOST_DEDUCED_TYPENAME mpl::eval_if<
+ // if its primitive
+ mpl::equal_to<
+ boost::serialization::implementation_level< T >,
+ mpl::int_<boost::serialization::primitive_type>
+ >,
+ mpl::identity<load_primitive>,
+ // else
+ BOOST_DEDUCED_TYPENAME mpl::eval_if<
+ // class info / version
+ mpl::greater_equal<
+ boost::serialization::implementation_level< T >,
+ mpl::int_<boost::serialization::object_class_info>
+ >,
+ // do standard load
+ mpl::identity<load_standard>,
+ // else
+ BOOST_DEDUCED_TYPENAME mpl::eval_if<
+ // no tracking
+ mpl::equal_to<
+ boost::serialization::tracking_level< T >,
+ mpl::int_<boost::serialization::track_never>
+ >,
+ // do a fast load
+ mpl::identity<load_only>,
+ // else
+ // do a fast load only tracking is turned off
+ mpl::identity<load_conditional>
+ > > >::type typex;
+ 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 & /*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 BOOST_DEDUCED_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
+ return static_cast<T *>(
+ const_cast<void *>(
+ boost::serialization::void_upcast(
+ eti,
+ boost::serialization::singleton<
+ BOOST_DEDUCED_TYPENAME
+ boost::serialization::type_info_implementation< T >::type
+ >::get_const_instance(),
+ t
+ )
+ )
+ );
+ }
+
+ template<class T>
+ static void check_load(T & /* t */){
+ check_pointer_level< T >();
+ check_pointer_tracking< T >();
+ }
+
+ static const basic_pointer_iserializer *
+ find(const boost::serialization::extended_type_info & type){
+ return static_cast<const basic_pointer_iserializer *>(
+ archive_serializer_map<Archive>::find(type)
+ );
+ }
+
+ template<class Tptr>
+ static void invoke(Archive & ar, Tptr & t){
+ check_load(*t);
+ const basic_pointer_iserializer * bpis_ptr = register_type(ar, *t);
+ const basic_pointer_iserializer * newbpis_ptr = ar.load_pointer(
+ // note major hack here !!!
+ // I tried every way to convert Tptr &t (where Tptr might
+ // include const) to void * &. This is the only way
+ // I could make it work. RR
+ (void * & )t,
+ 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 BOOST_DEDUCED_TYPENAME remove_extent< T >::type value_type;
+
+ // convert integers to correct enum to load
+ // determine number of elements in the array. Consider the
+ // fact that some machines will align elements on boundries
+ // other than characters.
+ std::size_t current_count = sizeof(t) / (
+ 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
+ )
+ );
+ ar >> serialization::make_array(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
+ // funtion template ordering. On other compilers, this is
+ // handled below.
+ detail::check_const_loading< T >();
+ typedef
+ BOOST_DEDUCED_TYPENAME mpl::eval_if<is_pointer< T >,
+ mpl::identity<detail::load_pointer_type<Archive> >
+ ,//else
+ BOOST_DEDUCED_TYPENAME mpl::eval_if<is_array< T >,
+ mpl::identity<detail::load_array_type<Archive> >
+ ,//else
+ BOOST_DEDUCED_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);
+}
+
+#if 0
+
+// BORLAND
+#if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x560))
+// borland has a couple of problems
+// a) if function is partially specialized - see below
+// const paramters are transformed to non-const ones
+// b) implementation of base_object can't be made to work
+// correctly which results in all base_object s being const.
+// So, strip off the const for borland. This breaks the trap
+// for loading const objects - but I see no alternative
+template<class Archive, class T>
+inline void load(Archive &ar, const T & t){
+ load(ar, const_cast<T &>(t));
+}
+#endif
+
+// let wrappers through.
+#ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING
+template<class Archive, class T>
+inline void load_wrapper(Archive &ar, const T&t, mpl::true_){
+ boost::archive::load(ar, const_cast<T&>(t));
+}
+
+#if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x560))
+template<class Archive, class T>
+inline void load(Archive &ar, const T&t){
+ load_wrapper(ar,t,serialization::is_wrapper< T >());
+}
+#endif
+#endif
+
+#endif
+
+} // namespace archive
+} // namespace boost
+
+#endif // BOOST_ARCHIVE_DETAIL_ISERIALIZER_HPP
diff --git a/3rdParty/Boost/src/boost/archive/detail/oserializer.hpp b/3rdParty/Boost/src/boost/archive/detail/oserializer.hpp
new file mode 100644
index 0000000..7d2694d
--- /dev/null
+++ b/3rdParty/Boost/src/boost/archive/detail/oserializer.hpp
@@ -0,0 +1,531 @@
+#ifndef BOOST_ARCHIVE_OSERIALIZER_HPP
+#define BOOST_ARCHIVE_OSERIALIZER_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+# pragma once
+#pragma inline_depth(511)
+#pragma inline_recursion(on)
+#endif
+
+#if defined(__MWERKS__)
+#pragma inline_depth(511)
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// 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>
+
+#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/array.hpp>
+#include <boost/serialization/collection_size_type.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>
+
+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<
+ BOOST_DEDUCED_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<
+ BOOST_DEDUCED_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(
+ & 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
+ BOOST_DEDUCED_TYPENAME mpl::eval_if<
+ // if its primitive
+ mpl::equal_to<
+ boost::serialization::implementation_level< T >,
+ mpl::int_<boost::serialization::primitive_type>
+ >,
+ mpl::identity<save_primitive>,
+ // else
+ BOOST_DEDUCED_TYPENAME mpl::eval_if<
+ // class info / version
+ mpl::greater_equal<
+ boost::serialization::implementation_level< T >,
+ mpl::int_<boost::serialization::object_class_info>
+ >,
+ // do standard save
+ mpl::identity<save_standard>,
+ // else
+ BOOST_DEDUCED_TYPENAME mpl::eval_if<
+ // no tracking
+ mpl::equal_to<
+ boost::serialization::tracking_level< T >,
+ mpl::int_<boost::serialization::track_never>
+ >,
+ // do a fast save
+ mpl::identity<save_only>,
+ // else
+ // do a fast save only tracking is turned off
+ mpl::identity<save_conditional>
+ > > >::type typex;
+ check_object_versioning< T >();
+ 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 & /*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
+ BOOST_DEDUCED_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
+ ){
+ BOOST_DEDUCED_TYPENAME
+ boost::serialization::type_info_implementation< T >::type const
+ & i = boost::serialization::singleton<
+ BOOST_DEDUCED_TYPENAME
+ boost::serialization::type_info_implementation< T >::type
+ >::get_const_instance();
+
+ boost::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 BOOST_DEDUCED_TYPENAME mpl::eval_if<
+ is_polymorphic< T >,
+ mpl::identity<polymorphic>,
+ mpl::identity<non_polymorphic>
+ >::type type;
+ type::save(ar, const_cast<T &>(t));
+ }
+
+ 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 BOOST_DEDUCED_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);
+ ar << serialization::make_array(static_cast<value_type const*>(&t[0]),count);
+ }
+};
+
+} // detail
+
+template<class Archive, class T>
+inline void save(Archive & ar, /*const*/ T &t){
+ typedef
+ BOOST_DEDUCED_TYPENAME mpl::eval_if<is_pointer< T >,
+ mpl::identity<detail::save_pointer_type<Archive> >,
+ //else
+ BOOST_DEDUCED_TYPENAME mpl::eval_if<is_enum< T >,
+ mpl::identity<detail::save_enum_type<Archive> >,
+ //else
+ BOOST_DEDUCED_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/3rdParty/Boost/src/boost/archive/detail/register_archive.hpp b/3rdParty/Boost/src/boost/archive/detail/register_archive.hpp
new file mode 100644
index 0000000..e31ae46
--- /dev/null
+++ b/3rdParty/Boost/src/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;
+};
+
+#ifdef __SUNPRO_CC
+
+template<int N>
+struct counter : counter<N-1> {};
+template<>
+struct counter<0> {};
+
+template<class Serializable>
+void instantiate_ptr_serialization(Serializable* s, int, adl_tag) {
+ instantiate_ptr_serialization(s, counter<20>());
+}
+
+template<class Archive>
+struct get_counter {
+ static const int value = sizeof(adjust_counter(counter<20>()));
+ typedef counter<value> type;
+ typedef counter<value - 1> prior;
+ typedef char (&next)[value+1];
+};
+
+char adjust_counter(counter<0>);
+template<class Serializable>
+void instantiate_ptr_serialization(Serializable*, counter<0>) {}
+
+#define BOOST_SERIALIZATION_REGISTER_ARCHIVE(Archive) \
+namespace boost { namespace archive { namespace detail { \
+ get_counter<Archive >::next adjust_counter(get_counter<Archive >::type);\
+ template<class Serializable> \
+ void instantiate_ptr_serialization(Serializable* s, \
+ get_counter<Archive >::type) { \
+ ptr_serialization_support<Archive, Serializable> x; \
+ instantiate_ptr_serialization(s, get_counter<Archive >::prior()); \
+ }\
+}}}
+
+
+#else
+
+// This function gets called, but its only purpose is to participate
+// in overload resolution with the functions declared by
+// BOOST_SERIALIZATION_REGISTER_ARCHIVE, below.
+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> \
+BOOST_DEDUCED_TYPENAME _ptr_serialization_support<Archive, Serializable>::type \
+instantiate_ptr_serialization( Serializable*, Archive*, adl_tag ); \
+ \
+}}}
+#endif
+}}} // namespace boost::archive::detail
+
+#endif // BOOST_ARCHIVE_DETAIL_INSTANTIATE_SERIALIZE_DWA2006521_HPP
diff --git a/3rdParty/Boost/src/boost/archive/detail/utf8_codecvt_facet.hpp b/3rdParty/Boost/src/boost/archive/detail/utf8_codecvt_facet.hpp
new file mode 100644
index 0000000..bd859ff
--- /dev/null
+++ b/3rdParty/Boost/src/boost/archive/detail/utf8_codecvt_facet.hpp
@@ -0,0 +1,21 @@
+// 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
+
+#define BOOST_UTF8_BEGIN_NAMESPACE \
+ namespace boost { namespace archive { namespace detail {
+#define BOOST_UTF8_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