summaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
authorKevin Smith <git@kismith.co.uk>2013-01-04 19:42:37 (GMT)
committerKevin Smith <git@kismith.co.uk>2013-04-06 13:36:54 (GMT)
commit3333ab69d62d1be7ae7dd7a4e56cc4bb608d3add (patch)
tree5ee630b666ae21dd4c4202703c158383de1faf91 /3rdParty/Boost/src/libs
parentb9ef4566d31219d66a615b1eae042a01828c8b7d (diff)
downloadswift-3333ab69d62d1be7ae7dd7a4e56cc4bb608d3add.zip
swift-3333ab69d62d1be7ae7dd7a4e56cc4bb608d3add.tar.bz2
Add boost serialization library
We'll need it before too long Change-Id: Ia34c7f26e1aedbc13a2fc10c980994cbcb7cb348
Diffstat (limited to '3rdParty/Boost/src/libs')
-rw-r--r--3rdParty/Boost/src/libs/serialization/src/archive_exception.cpp114
-rw-r--r--3rdParty/Boost/src/libs/serialization/src/basic_archive.cpp80
-rw-r--r--3rdParty/Boost/src/libs/serialization/src/basic_iarchive.cpp576
-rw-r--r--3rdParty/Boost/src/libs/serialization/src/basic_iserializer.cpp33
-rw-r--r--3rdParty/Boost/src/libs/serialization/src/basic_oarchive.cpp459
-rw-r--r--3rdParty/Boost/src/libs/serialization/src/basic_oserializer.cpp33
-rw-r--r--3rdParty/Boost/src/libs/serialization/src/basic_pointer_iserializer.cpp30
-rw-r--r--3rdParty/Boost/src/libs/serialization/src/basic_pointer_oserializer.cpp30
-rw-r--r--3rdParty/Boost/src/libs/serialization/src/basic_serializer_map.cpp111
-rw-r--r--3rdParty/Boost/src/libs/serialization/src/basic_text_iprimitive.cpp28
-rw-r--r--3rdParty/Boost/src/libs/serialization/src/basic_text_oprimitive.cpp28
-rw-r--r--3rdParty/Boost/src/libs/serialization/src/basic_text_wiprimitive.cpp35
-rw-r--r--3rdParty/Boost/src/libs/serialization/src/basic_text_woprimitive.cpp35
-rw-r--r--3rdParty/Boost/src/libs/serialization/src/basic_xml_archive.cpp51
-rw-r--r--3rdParty/Boost/src/libs/serialization/src/basic_xml_grammar.ipp468
-rw-r--r--3rdParty/Boost/src/libs/serialization/src/binary_iarchive.cpp53
-rw-r--r--3rdParty/Boost/src/libs/serialization/src/binary_oarchive.cpp39
-rw-r--r--3rdParty/Boost/src/libs/serialization/src/binary_wiarchive.cpp60
-rw-r--r--3rdParty/Boost/src/libs/serialization/src/binary_woarchive.cpp44
-rw-r--r--3rdParty/Boost/src/libs/serialization/src/codecvt_null.cpp83
-rw-r--r--3rdParty/Boost/src/libs/serialization/src/extended_type_info.cpp188
-rw-r--r--3rdParty/Boost/src/libs/serialization/src/extended_type_info_no_rtti.cpp85
-rw-r--r--3rdParty/Boost/src/libs/serialization/src/extended_type_info_typeid.cpp161
-rw-r--r--3rdParty/Boost/src/libs/serialization/src/polymorphic_iarchive.cpp29
-rw-r--r--3rdParty/Boost/src/libs/serialization/src/polymorphic_oarchive.cpp29
-rw-r--r--3rdParty/Boost/src/libs/serialization/src/shared_ptr_helper.cpp138
-rw-r--r--3rdParty/Boost/src/libs/serialization/src/stl_port.cpp43
-rw-r--r--3rdParty/Boost/src/libs/serialization/src/text_iarchive.cpp36
-rw-r--r--3rdParty/Boost/src/libs/serialization/src/text_oarchive.cpp33
-rw-r--r--3rdParty/Boost/src/libs/serialization/src/text_wiarchive.cpp41
-rw-r--r--3rdParty/Boost/src/libs/serialization/src/text_woarchive.cpp35
-rw-r--r--3rdParty/Boost/src/libs/serialization/src/utf8_codecvt_facet.cpp21
-rw-r--r--3rdParty/Boost/src/libs/serialization/src/void_cast.cpp360
-rw-r--r--3rdParty/Boost/src/libs/serialization/src/xml_archive_exception.cpp56
-rw-r--r--3rdParty/Boost/src/libs/serialization/src/xml_grammar.cpp73
-rw-r--r--3rdParty/Boost/src/libs/serialization/src/xml_iarchive.cpp46
-rw-r--r--3rdParty/Boost/src/libs/serialization/src/xml_oarchive.cpp32
-rw-r--r--3rdParty/Boost/src/libs/serialization/src/xml_wgrammar.cpp157
-rw-r--r--3rdParty/Boost/src/libs/serialization/src/xml_wiarchive.cpp53
-rw-r--r--3rdParty/Boost/src/libs/serialization/src/xml_woarchive.cpp35
40 files changed, 4041 insertions, 0 deletions
diff --git a/3rdParty/Boost/src/libs/serialization/src/archive_exception.cpp b/3rdParty/Boost/src/libs/serialization/src/archive_exception.cpp
new file mode 100644
index 0000000..50d326a
--- /dev/null
+++ b/3rdParty/Boost/src/libs/serialization/src/archive_exception.cpp
@@ -0,0 +1,114 @@
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// archive_exception.cpp:
+
+// (C) Copyright 2009 Robert Ramey - http://www.rrsd.com .
+// Use, modification and distribution is subject to the Boost Software
+// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+
+// See http://www.boost.org for updates, documentation, and revision history.
+
+#if (defined _MSC_VER) && (_MSC_VER == 1200)
+# pragma warning (disable : 4786) // too long name, harmless warning
+#endif
+
+#include <exception>
+#include <boost/assert.hpp>
+#include <string>
+
+#define BOOST_ARCHIVE_SOURCE
+#include <boost/archive/archive_exception.hpp>
+
+namespace boost {
+namespace archive {
+
+BOOST_ARCHIVE_DECL(BOOST_PP_EMPTY())
+archive_exception::archive_exception(
+ exception_code c,
+ const char * e1,
+ const char * e2
+) :
+ code(c)
+{
+ m_msg = "programming error";
+ switch(code){
+ case no_exception:
+ m_msg = "uninitialized exception";
+ break;
+ case unregistered_class:
+ m_msg = "unregistered class";
+ if(NULL != e1){
+ m_msg += " - ";
+ m_msg += e1;
+ }
+ break;
+ case invalid_signature:
+ m_msg = "invalid signature";
+ break;
+ case unsupported_version:
+ m_msg = "unsupported version";
+ break;
+ case pointer_conflict:
+ m_msg = "pointer conflict";
+ break;
+ case incompatible_native_format:
+ m_msg = "incompatible native format";
+ if(NULL != e1){
+ m_msg += " - ";
+ m_msg += e1;
+ }
+ break;
+ case array_size_too_short:
+ m_msg = "array size too short";
+ break;
+ case input_stream_error:
+ m_msg = "input stream error";
+ break;
+ case invalid_class_name:
+ m_msg = "class name too long";
+ break;
+ case unregistered_cast:
+ m_msg = "unregistered void cast ";
+ m_msg += (NULL != e1) ? e1 : "?";
+ m_msg += "<-";
+ m_msg += (NULL != e2) ? e2 : "?";
+ break;
+ case unsupported_class_version:
+ m_msg = "class version ";
+ m_msg += (NULL != e1) ? e1 : "<unknown class>";
+ break;
+ case other_exception:
+ // if get here - it indicates a derived exception
+ // was sliced by passing by value in catch
+ m_msg = "unknown derived exception";
+ break;
+ case multiple_code_instantiation:
+ m_msg = "code instantiated in more than one module";
+ if(NULL != e1){
+ m_msg += " - ";
+ m_msg += e1;
+ }
+ break;
+ case output_stream_error:
+ m_msg = "output stream error";
+ break;
+ default:
+ BOOST_ASSERT(false);
+ break;
+ }
+}
+BOOST_ARCHIVE_DECL(BOOST_PP_EMPTY())
+archive_exception::~archive_exception() throw () {}
+
+BOOST_ARCHIVE_DECL(const char *)
+archive_exception::what( ) const throw()
+{
+ return m_msg.c_str();
+}
+BOOST_ARCHIVE_DECL(BOOST_PP_EMPTY())
+archive_exception::archive_exception() :
+ code(no_exception)
+{}
+
+} // archive
+} // boost
diff --git a/3rdParty/Boost/src/libs/serialization/src/basic_archive.cpp b/3rdParty/Boost/src/libs/serialization/src/basic_archive.cpp
new file mode 100644
index 0000000..23e5702
--- /dev/null
+++ b/3rdParty/Boost/src/libs/serialization/src/basic_archive.cpp
@@ -0,0 +1,80 @@
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// basic_archive.cpp:
+
+// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
+// Use, modification and distribution is subject to the Boost Software
+// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+
+// See http://www.boost.org for updates, documentation, and revision history.
+
+//////////////////////////////////////////////////////////////////////
+//
+// objects are stored as
+//
+// class_id* // -1 for a null pointer
+// if a new class id
+// [
+// exported key - class name*
+// tracking level - always/never
+// class version
+// ]
+//
+// if tracking
+// [
+// object_id
+// ]
+//
+// [ // if a new object id
+// data...
+// ]
+//
+// * required only for pointers - optional for objects
+
+#define BOOST_ARCHIVE_SOURCE
+#include <boost/archive/basic_archive.hpp>
+
+namespace boost {
+namespace archive {
+
+///////////////////////////////////////////////////////////////////////
+// constants used in archive signature
+//This should never ever change. note that is not an std::string
+// string.
+BOOST_ARCHIVE_DECL(const char *)
+BOOST_ARCHIVE_SIGNATURE(){
+ return "serialization::archive";
+}
+
+// this should change if the capabilities are added to the library
+// such that archives can be created which can't be read by previous
+// versions of this library
+// 1 - initial version
+// 2 - made address tracking optional
+// 3 - numerous changes - can't guarentee compatibility with previous versions
+// 4 - Boost 1.34
+// added item_version to properly support versioning for collections
+// 5 - Boost 1.36
+// changed serialization of collections: adding version even for primitive
+// types caused backwards compatibility breaking change in 1.35
+// 6 - Boost 1.41 17 Nov 2009
+// serializing collection sizes as std::size_t
+// 7 Boost 1.42 2 Feb 2010
+// error - changed binary version to 16 bits w/o changing library version #
+// That is - binary archives are recorded with #6 even though they are
+// different from the previous versions. This means that binary archives
+// created with versions 1.42 and 1.43 will have to be fixed with a special
+// program which fixes the library version # in the header
+// Boost 1.43 6 May 2010
+// no change
+// 8 - Boost 1.44
+// separated version_type into library_version_type and class_version_type
+// changed version_type to be stored as 8 bits.
+
+BOOST_ARCHIVE_DECL(library_version_type)
+BOOST_ARCHIVE_VERSION(){
+ return library_version_type(9);
+}
+
+} // namespace archive
+} // namespace boost
diff --git a/3rdParty/Boost/src/libs/serialization/src/basic_iarchive.cpp b/3rdParty/Boost/src/libs/serialization/src/basic_iarchive.cpp
new file mode 100644
index 0000000..e9baddd
--- /dev/null
+++ b/3rdParty/Boost/src/libs/serialization/src/basic_iarchive.cpp
@@ -0,0 +1,576 @@
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// basic_archive.cpp:
+
+// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
+// Use, modification and distribution is subject to the Boost Software
+// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+
+// See http://www.boost.org for updates, documentation, and revision history.
+
+#include <boost/config.hpp> // msvc 6.0 needs this to suppress warnings
+
+#include <boost/assert.hpp>
+#include <set>
+#include <list>
+#include <vector>
+#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/integer_traits.hpp>
+#include <boost/serialization/state_saver.hpp>
+#include <boost/serialization/throw_exception.hpp>
+#include <boost/serialization/tracking.hpp>
+
+#define BOOST_ARCHIVE_SOURCE
+// include this to prevent linker errors when the
+// same modules are marked export and import.
+#define BOOST_SERIALIZATION_SOURCE
+
+#include <boost/archive/archive_exception.hpp>
+
+#include <boost/archive/detail/decl.hpp>
+#include <boost/archive/basic_archive.hpp>
+#include <boost/archive/detail/basic_iserializer.hpp>
+#include <boost/archive/detail/basic_pointer_iserializer.hpp>
+#include <boost/archive/detail/basic_iarchive.hpp>
+
+#include <boost/archive/detail/auto_link_archive.hpp>
+
+using namespace boost::serialization;
+
+namespace boost {
+namespace archive {
+namespace detail {
+
+class basic_iarchive_impl {
+ friend class basic_iarchive;
+ library_version_type m_archive_library_version;
+ unsigned int m_flags;
+
+ //////////////////////////////////////////////////////////////////////
+ // information about each serialized object loaded
+ // indexed on object_id
+ struct aobject
+ {
+ void * address;
+ bool loaded_as_pointer;
+ class_id_type class_id;
+ aobject(
+ void *a,
+ class_id_type class_id_
+ ) :
+ address(a),
+ loaded_as_pointer(false),
+ class_id(class_id_)
+ {}
+ aobject() :
+ address(NULL),
+ loaded_as_pointer(false),
+ class_id(-2)
+ {}
+ };
+ typedef std::vector<aobject> object_id_vector_type;
+ object_id_vector_type object_id_vector;
+
+ //////////////////////////////////////////////////////////////////////
+ // used to implement the reset_object_address operation.
+ object_id_type moveable_objects_start;
+ object_id_type moveable_objects_end;
+ object_id_type moveable_objects_recent;
+
+ void reset_object_address(
+ const void * new_address,
+ const void *old_address
+ );
+
+ //////////////////////////////////////////////////////////////////////
+ // used by load object to look up class id given basic_serializer
+ struct cobject_type
+ {
+ const basic_iserializer * m_bis;
+ const class_id_type m_class_id;
+ cobject_type(
+ std::size_t class_id,
+ const basic_iserializer & bis
+ ) :
+ m_bis(& bis),
+ m_class_id(class_id)
+ {}
+ cobject_type(const cobject_type & rhs) :
+ m_bis(rhs.m_bis),
+ m_class_id(rhs.m_class_id)
+ {}
+ // the following cannot be defined because of the const
+ // member. This will generate a link error if an attempt
+ // is made to assign. This should never be necessary
+ cobject_type & operator=(const cobject_type & rhs);
+ bool operator<(const cobject_type &rhs) const
+ {
+ return *m_bis < *(rhs.m_bis);
+ }
+ };
+ typedef std::set<cobject_type> cobject_info_set_type;
+ cobject_info_set_type cobject_info_set;
+
+ //////////////////////////////////////////////////////////////////////
+ // information about each serialized class indexed on class_id
+ class cobject_id
+ {
+ public:
+ cobject_id & operator=(const cobject_id & rhs){
+ bis_ptr = rhs.bis_ptr;
+ bpis_ptr = rhs.bpis_ptr;
+ file_version = rhs.file_version;
+ tracking_level = rhs.tracking_level;
+ initialized = rhs.initialized;
+ return *this;
+ }
+ const basic_iserializer * bis_ptr;
+ const basic_pointer_iserializer * bpis_ptr;
+ version_type file_version;
+ tracking_type tracking_level;
+ bool initialized;
+
+ cobject_id(const basic_iserializer & bis_) :
+ bis_ptr(& bis_),
+ bpis_ptr(NULL),
+ file_version(0),
+ tracking_level(track_never),
+ initialized(false)
+ {}
+ cobject_id(const cobject_id &rhs):
+ bis_ptr(rhs.bis_ptr),
+ bpis_ptr(rhs.bpis_ptr),
+ file_version(rhs.file_version),
+ tracking_level(rhs.tracking_level),
+ initialized(rhs.initialized)
+ {}
+ };
+ typedef std::vector<cobject_id> cobject_id_vector_type;
+ cobject_id_vector_type cobject_id_vector;
+
+ //////////////////////////////////////////////////////////////////////
+ // address of the most recent object serialized as a poiner
+ // whose data itself is now pending serialization
+ void * pending_object;
+ const basic_iserializer * pending_bis;
+ version_type pending_version;
+
+ basic_iarchive_impl(unsigned int flags) :
+ m_archive_library_version(BOOST_ARCHIVE_VERSION()),
+ m_flags(flags),
+ moveable_objects_start(0),
+ moveable_objects_end(0),
+ moveable_objects_recent(0),
+ pending_object(NULL),
+ pending_bis(NULL),
+ pending_version(0)
+ {}
+ ~basic_iarchive_impl(){}
+ void set_library_version(library_version_type archive_library_version){
+ m_archive_library_version = archive_library_version;
+ }
+ bool
+ track(
+ basic_iarchive & ar,
+ void * & t
+ );
+ void
+ load_preamble(
+ basic_iarchive & ar,
+ cobject_id & co
+ );
+ class_id_type register_type(
+ const basic_iserializer & bis
+ );
+
+ // redirect through virtual functions to load functions for this archive
+ template<class T>
+ void load(basic_iarchive & ar, T & t){
+ ar.vload(t);
+ }
+
+//public:
+ void
+ next_object_pointer(void * t){
+ pending_object = t;
+ }
+ void delete_created_pointers();
+ class_id_type register_type(
+ const basic_pointer_iserializer & bpis
+ );
+ void load_object(
+ basic_iarchive & ar,
+ void * t,
+ const basic_iserializer & bis
+ );
+ const basic_pointer_iserializer * load_pointer(
+ basic_iarchive & ar,
+ void * & t,
+ const basic_pointer_iserializer * bpis,
+ const basic_pointer_iserializer * (*finder)(
+ const boost::serialization::extended_type_info & type
+ )
+
+ );
+};
+
+inline void
+basic_iarchive_impl::reset_object_address(
+ const void * new_address,
+ const void *old_address
+){
+ // this code handles a couple of situations.
+ // a) where reset_object_address is applied to an untracked object.
+ // In such a case the call is really superfluous and its really an
+ // an error. But we don't have access to the types here so we can't
+ // know that. However, this code will effectively turn this situation
+ // into a no-op and every thing will work fine - albeat with a small
+ // execution time penalty.
+ // b) where the call to reset_object_address doesn't immediatly follow
+ // the << operator to which it corresponds. This would be a bad idea
+ // but the code may work anyway. Naturally, a bad practice on the part
+ // of the programmer but we can't detect it - as above. So maybe we
+ // can save a few more people from themselves as above.
+ object_id_type i;
+ for(i = moveable_objects_recent; i < moveable_objects_end; ++i){
+ if(old_address == object_id_vector[i].address)
+ break;
+ }
+ for(; i < moveable_objects_end; ++i){
+
+ // calculate displacement from this level
+ // warning - pointer arithmetic on void * is in herently non-portable
+ // but expected to work on all platforms in current usage
+ if(object_id_vector[i].address > old_address){
+ std::size_t member_displacement
+ = reinterpret_cast<std::size_t>(object_id_vector[i].address)
+ - reinterpret_cast<std::size_t>(old_address);
+ object_id_vector[i].address = reinterpret_cast<void *>(
+ reinterpret_cast<std::size_t>(new_address) + member_displacement
+ );
+ }
+ else{
+ std::size_t member_displacement
+ = reinterpret_cast<std::size_t>(old_address)
+ - reinterpret_cast<std::size_t>(object_id_vector[i].address);
+ object_id_vector[i].address = reinterpret_cast<void *>(
+ reinterpret_cast<std::size_t>(new_address) - member_displacement
+ );
+ }
+ }
+}
+
+inline void
+basic_iarchive_impl::delete_created_pointers()
+{
+ object_id_vector_type::iterator i;
+ for(
+ i = object_id_vector.begin();
+ i != object_id_vector.end();
+ ++i
+ ){
+ if(i->loaded_as_pointer){
+ // borland complains without this minor hack
+ const int j = i->class_id;
+ const cobject_id & co = cobject_id_vector[j];
+ //const cobject_id & co = cobject_id_vector[i->class_id];
+ // with the appropriate input serializer,
+ // delete the indicated object
+ co.bis_ptr->destroy(i->address);
+ }
+ }
+}
+
+inline class_id_type
+basic_iarchive_impl::register_type(
+ const basic_iserializer & bis
+){
+ class_id_type cid(cobject_info_set.size());
+ cobject_type co(cid, bis);
+ std::pair<cobject_info_set_type::const_iterator, bool>
+ result = cobject_info_set.insert(co);
+
+ if(result.second){
+ cobject_id_vector.push_back(cobject_id(bis));
+ BOOST_ASSERT(cobject_info_set.size() == cobject_id_vector.size());
+ }
+ cid = result.first->m_class_id;
+ // borland complains without this minor hack
+ const int tid = cid;
+ cobject_id & coid = cobject_id_vector[tid];
+ coid.bpis_ptr = bis.get_bpis_ptr();
+ return cid;
+}
+
+void
+basic_iarchive_impl::load_preamble(
+ basic_iarchive & ar,
+ cobject_id & co
+){
+ if(! co.initialized){
+ if(co.bis_ptr->class_info()){
+ class_id_optional_type cid(class_id_type(0));
+ load(ar, cid); // to be thrown away
+ load(ar, co.tracking_level);
+ load(ar, co.file_version);
+ }
+ else{
+ // override tracking with indicator from class information
+ co.tracking_level = co.bis_ptr->tracking(m_flags);
+ co.file_version = version_type(
+ co.bis_ptr->version()
+ );
+ }
+ co.initialized = true;
+ }
+}
+
+bool
+basic_iarchive_impl::track(
+ basic_iarchive & ar,
+ void * & t
+){
+ object_id_type oid;
+ load(ar, oid);
+
+ // if its a reference to a old object
+ if(object_id_type(object_id_vector.size()) > oid){
+ // we're done
+ t = object_id_vector[oid].address;
+ return false;
+ }
+ return true;
+}
+
+inline void
+basic_iarchive_impl::load_object(
+ basic_iarchive & ar,
+ void * t,
+ const basic_iserializer & bis
+){
+ // if its been serialized through a pointer and the preamble's been done
+ if(t == pending_object && & bis == pending_bis){
+ // read data
+ (bis.load_object_data)(ar, t, pending_version);
+ return;
+ }
+
+ const class_id_type cid = register_type(bis);
+ const int i = cid;
+ cobject_id & co = cobject_id_vector[i];
+
+ load_preamble(ar, co);
+
+ // save the current move stack position in case we want to truncate it
+ boost::serialization::state_saver<object_id_type> w(moveable_objects_start);
+
+ // note: extra line used to evade borland issue
+ const bool tracking = co.tracking_level;
+
+ object_id_type this_id;
+ moveable_objects_start =
+ this_id = object_id_type(object_id_vector.size());
+
+ // if we tracked this object when the archive was saved
+ if(tracking){
+ // if it was already read
+ if(!track(ar, t))
+ // we're done
+ return;
+ // add a new enty into the tracking list
+ object_id_vector.push_back(aobject(t, cid));
+ // and add an entry for this object
+ moveable_objects_end = object_id_type(object_id_vector.size());
+ }
+ // read data
+ (bis.load_object_data)(ar, t, co.file_version);
+ moveable_objects_recent = this_id;
+}
+
+inline const basic_pointer_iserializer *
+basic_iarchive_impl::load_pointer(
+ basic_iarchive &ar,
+ void * & t,
+ const basic_pointer_iserializer * bpis_ptr,
+ const basic_pointer_iserializer * (*finder)(
+ const boost::serialization::extended_type_info & type_
+ )
+
+){
+ class_id_type cid;
+ load(ar, cid);
+
+ if(NULL_POINTER_TAG == cid){
+ t = NULL;
+ return bpis_ptr;
+ }
+
+ // if its a new class type - i.e. never been registered
+ if(class_id_type(cobject_info_set.size()) <= cid){
+ // if its either abstract
+ if(NULL == bpis_ptr
+ // or polymorphic
+ || bpis_ptr->get_basic_serializer().is_polymorphic()){
+ // is must have been exported
+ char key[BOOST_SERIALIZATION_MAX_KEY_SIZE];
+ class_name_type class_name(key);
+ load(ar, class_name);
+ // if it has a class name
+ const serialization::extended_type_info *eti = NULL;
+ if(0 != key[0])
+ eti = serialization::extended_type_info::find(key);
+ if(NULL == eti)
+ boost::serialization::throw_exception(
+ archive_exception(archive_exception::unregistered_class)
+ );
+ bpis_ptr = (*finder)(*eti);
+ }
+ BOOST_ASSERT(NULL != bpis_ptr);
+ class_id_type new_cid = register_type(bpis_ptr->get_basic_serializer());
+ int i = cid;
+ cobject_id_vector[i].bpis_ptr = bpis_ptr;
+ BOOST_ASSERT(new_cid == cid);
+ }
+ int i = cid;
+ cobject_id & co = cobject_id_vector[i];
+ bpis_ptr = co.bpis_ptr;
+
+ load_preamble(ar, co);
+
+ // extra line to evade borland issue
+ const bool tracking = co.tracking_level;
+ // if we're tracking and the pointer has already been read
+ if(tracking && ! track(ar, t))
+ // we're done
+ return bpis_ptr;
+
+ // save state
+ serialization::state_saver<object_id_type> w_start(moveable_objects_start);
+
+ if(! tracking){
+ bpis_ptr->load_object_ptr(ar, t, co.file_version);
+ }
+ else{
+ serialization::state_saver<void *> x(pending_object);
+ serialization::state_saver<const basic_iserializer *> y(pending_bis);
+ serialization::state_saver<version_type> z(pending_version);
+
+ pending_bis = & bpis_ptr->get_basic_serializer();
+ pending_version = co.file_version;
+
+ // predict next object id to be created
+ const unsigned int ui = object_id_vector.size();
+
+ serialization::state_saver<object_id_type> w_end(moveable_objects_end);
+
+ // because the following operation could move the items
+ // don't use co after this
+ // add to list of serialized objects so that we can properly handle
+ // cyclic strucures
+ object_id_vector.push_back(aobject(t, cid));
+
+ bpis_ptr->load_object_ptr(
+ ar,
+ object_id_vector[ui].address,
+ co.file_version
+ );
+ t = object_id_vector[ui].address;
+ object_id_vector[ui].loaded_as_pointer = true;
+ BOOST_ASSERT(NULL != t);
+ }
+
+ return bpis_ptr;
+}
+
+} // namespace detail
+} // namespace archive
+} // namespace boost
+
+//////////////////////////////////////////////////////////////////////
+// implementation of basic_iarchive functions
+namespace boost {
+namespace archive {
+namespace detail {
+
+BOOST_ARCHIVE_DECL(void)
+basic_iarchive::next_object_pointer(void *t){
+ pimpl->next_object_pointer(t);
+}
+
+BOOST_ARCHIVE_DECL(BOOST_PP_EMPTY())
+basic_iarchive::basic_iarchive(unsigned int flags) :
+ pimpl(new basic_iarchive_impl(flags))
+{}
+
+BOOST_ARCHIVE_DECL(BOOST_PP_EMPTY())
+basic_iarchive::~basic_iarchive()
+{
+ delete pimpl;
+}
+
+BOOST_ARCHIVE_DECL(void)
+basic_iarchive::set_library_version(library_version_type archive_library_version){
+ pimpl->set_library_version(archive_library_version);
+}
+
+BOOST_ARCHIVE_DECL(void)
+basic_iarchive::reset_object_address(
+ const void * new_address,
+ const void * old_address
+){
+ pimpl->reset_object_address(new_address, old_address);
+}
+
+BOOST_ARCHIVE_DECL(void)
+basic_iarchive::load_object(
+ void *t,
+ const basic_iserializer & bis
+){
+ pimpl->load_object(*this, t, bis);
+}
+
+// load a pointer object
+BOOST_ARCHIVE_DECL(const basic_pointer_iserializer *)
+basic_iarchive::load_pointer(
+ void * &t,
+ const basic_pointer_iserializer * bpis_ptr,
+ const basic_pointer_iserializer * (*finder)(
+ const boost::serialization::extended_type_info & type_
+ )
+
+){
+ return pimpl->load_pointer(*this, t, bpis_ptr, finder);
+}
+
+BOOST_ARCHIVE_DECL(void)
+basic_iarchive::register_basic_serializer(const basic_iserializer & bis){
+ pimpl->register_type(bis);
+}
+
+BOOST_ARCHIVE_DECL(void)
+basic_iarchive::delete_created_pointers()
+{
+ pimpl->delete_created_pointers();
+}
+
+BOOST_ARCHIVE_DECL(boost::archive::library_version_type)
+basic_iarchive::get_library_version() const{
+ return pimpl->m_archive_library_version;
+}
+
+BOOST_ARCHIVE_DECL(unsigned int)
+basic_iarchive::get_flags() const{
+ return pimpl->m_flags;
+}
+
+} // namespace detail
+} // namespace archive
+} // namespace boost
diff --git a/3rdParty/Boost/src/libs/serialization/src/basic_iserializer.cpp b/3rdParty/Boost/src/libs/serialization/src/basic_iserializer.cpp
new file mode 100644
index 0000000..e18e16f
--- /dev/null
+++ b/3rdParty/Boost/src/libs/serialization/src/basic_iserializer.cpp
@@ -0,0 +1,33 @@
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// basic_iserializer.cpp:
+
+// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
+// Use, modification and distribution is subject to the Boost Software
+// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+
+// See http://www.boost.org for updates, documentation, and revision history.
+
+#include <cstddef> // NULL
+
+#define BOOST_ARCHIVE_SOURCE
+#include <boost/archive/detail/basic_iserializer.hpp>
+
+namespace boost {
+namespace archive {
+namespace detail {
+
+BOOST_ARCHIVE_DECL(BOOST_PP_EMPTY())
+basic_iserializer::basic_iserializer(
+ const boost::serialization::extended_type_info & eti
+) :
+ basic_serializer(eti),
+ m_bpis(NULL)
+{}
+
+BOOST_ARCHIVE_DECL(BOOST_PP_EMPTY())
+basic_iserializer::~basic_iserializer(){}
+
+} // namespace detail
+} // namespace archive
+} // namespace boost
diff --git a/3rdParty/Boost/src/libs/serialization/src/basic_oarchive.cpp b/3rdParty/Boost/src/libs/serialization/src/basic_oarchive.cpp
new file mode 100644
index 0000000..33f33f8
--- /dev/null
+++ b/3rdParty/Boost/src/libs/serialization/src/basic_oarchive.cpp
@@ -0,0 +1,459 @@
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// basic_oarchive.cpp:
+
+// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
+// Use, modification and distribution is subject to the Boost Software
+// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+
+// See http://www.boost.org for updates, documentation, and revision history.
+
+#include <boost/config.hpp> // msvc 6.0 needs this for warning suppression
+
+#include <boost/assert.hpp>
+#include <set>
+#include <cstddef> // NULL
+
+#include <boost/limits.hpp>
+#include <boost/serialization/state_saver.hpp>
+#include <boost/serialization/throw_exception.hpp>
+
+// including this here to work around an ICC in intel 7.0
+// normally this would be part of basic_oarchive.hpp below.
+#define BOOST_ARCHIVE_SOURCE
+// include this to prevent linker errors when the
+// same modules are marked export and import.
+#define BOOST_SERIALIZATION_SOURCE
+
+#include <boost/archive/detail/decl.hpp>
+#include <boost/archive/basic_archive.hpp>
+#include <boost/archive/detail/basic_oserializer.hpp>
+#include <boost/archive/detail/basic_pointer_oserializer.hpp>
+#include <boost/archive/detail/basic_oarchive.hpp>
+#include <boost/archive/archive_exception.hpp>
+#include <boost/serialization/extended_type_info.hpp>
+
+#ifdef BOOST_MSVC
+# pragma warning(push)
+# pragma warning(disable : 4251 4231 4660 4275)
+#endif
+
+using namespace boost::serialization;
+
+namespace boost {
+namespace archive {
+namespace detail {
+
+class basic_oarchive_impl {
+ friend class basic_oarchive;
+ unsigned int m_flags;
+
+ //////////////////////////////////////////////////////////////////////
+ // information about each serialized object saved
+ // keyed on address, class_id
+ struct aobject
+ {
+ const void * address;
+ class_id_type class_id;
+ object_id_type object_id;
+
+ bool operator<(const aobject &rhs) const
+ {
+ BOOST_ASSERT(NULL != address);
+ BOOST_ASSERT(NULL != rhs.address);
+ if( address < rhs.address )
+ return true;
+ if( address > rhs.address )
+ return false;
+ return class_id < rhs.class_id;
+ }
+ aobject & operator=(const aobject & rhs)
+ {
+ address = rhs.address;
+ class_id = rhs.class_id;
+ object_id = rhs.object_id;
+ return *this;
+ }
+ aobject(
+ const void *a,
+ class_id_type class_id_,
+ object_id_type object_id_
+ ) :
+ address(a),
+ class_id(class_id_),
+ object_id(object_id_)
+ {}
+ aobject() : address(NULL){}
+ };
+ // keyed on class_id, address
+ typedef std::set<aobject> object_set_type;
+ object_set_type object_set;
+
+ //////////////////////////////////////////////////////////////////////
+ // information about each serialized class saved
+ // keyed on type_info
+ struct cobject_type
+ {
+ const basic_oserializer * m_bos_ptr;
+ const class_id_type m_class_id;
+ bool m_initialized;
+ cobject_type(
+ std::size_t class_id,
+ const basic_oserializer & bos
+ ) :
+ m_bos_ptr(& bos),
+ m_class_id(class_id),
+ m_initialized(false)
+ {}
+ cobject_type(const basic_oserializer & bos)
+ : m_bos_ptr(& bos)
+ {}
+ cobject_type(
+ const cobject_type & rhs
+ ) :
+ m_bos_ptr(rhs.m_bos_ptr),
+ m_class_id(rhs.m_class_id),
+ m_initialized(rhs.m_initialized)
+ {}
+ // the following cannot be defined because of the const
+ // member. This will generate a link error if an attempt
+ // is made to assign. This should never be necessary
+ // use this only for lookup argument
+ cobject_type & operator=(const cobject_type &rhs);
+ bool operator<(const cobject_type &rhs) const {
+ return *m_bos_ptr < *(rhs.m_bos_ptr);
+ }
+ };
+ // keyed on type_info
+ typedef std::set<cobject_type> cobject_info_set_type;
+ cobject_info_set_type cobject_info_set;
+
+ // list of objects initially stored as pointers - used to detect errors
+ // keyed on object id
+ std::set<object_id_type> stored_pointers;
+
+ // address of the most recent object serialized as a poiner
+ // whose data itself is now pending serialization
+ const void * pending_object;
+ const basic_oserializer * pending_bos;
+
+ basic_oarchive_impl(unsigned int flags) :
+ m_flags(flags),
+ pending_object(NULL),
+ pending_bos(NULL)
+ {}
+
+ const cobject_type &
+ find(const basic_oserializer & bos);
+ const basic_oserializer *
+ find(const serialization::extended_type_info &ti) const;
+
+//public:
+ const cobject_type &
+ register_type(const basic_oserializer & bos);
+ void save_object(
+ basic_oarchive & ar,
+ const void *t,
+ const basic_oserializer & bos
+ );
+ void save_pointer(
+ basic_oarchive & ar,
+ const void * t,
+ const basic_pointer_oserializer * bpos
+ );
+};
+
+//////////////////////////////////////////////////////////////////////
+// basic_oarchive implementation functions
+
+// given a type_info - find its bos
+// return NULL if not found
+inline const basic_oserializer *
+basic_oarchive_impl::find(const serialization::extended_type_info & ti) const {
+ #ifdef BOOST_MSVC
+ # pragma warning(push)
+ # pragma warning(disable : 4511 4512)
+ #endif
+ class bosarg :
+ public basic_oserializer
+ {
+ bool class_info() const {
+ BOOST_ASSERT(false);
+ return false;
+ }
+ // returns true if objects should be tracked
+ bool tracking(const unsigned int) const {
+ BOOST_ASSERT(false);
+ return false;
+ }
+ // returns class version
+ version_type version() const {
+ BOOST_ASSERT(false);
+ return version_type(0);
+ }
+ // returns true if this class is polymorphic
+ bool is_polymorphic() const{
+ BOOST_ASSERT(false);
+ return false;
+ }
+ void save_object_data(
+ basic_oarchive & /*ar*/, const void * /*x*/
+ ) const {
+ BOOST_ASSERT(false);
+ }
+ public:
+ bosarg(const serialization::extended_type_info & eti) :
+ boost::archive::detail::basic_oserializer(eti)
+ {}
+ };
+ #ifdef BOOST_MSVC
+ #pragma warning(pop)
+ #endif
+ bosarg bos(ti);
+ cobject_info_set_type::const_iterator cit
+ = cobject_info_set.find(cobject_type(bos));
+ // it should already have been "registered" - see below
+ if(cit == cobject_info_set.end()){
+ // if an entry is not found in the table it is because a pointer
+ // of a derived class has been serialized through its base class
+ // but the derived class hasn't been "registered"
+ return NULL;
+ }
+ // return pointer to the real class
+ return cit->m_bos_ptr;
+}
+
+inline const basic_oarchive_impl::cobject_type &
+basic_oarchive_impl::find(const basic_oserializer & bos)
+{
+ std::pair<cobject_info_set_type::iterator, bool> cresult =
+ cobject_info_set.insert(cobject_type(cobject_info_set.size(), bos));
+ return *(cresult.first);
+}
+
+inline const basic_oarchive_impl::cobject_type &
+basic_oarchive_impl::register_type(
+ const basic_oserializer & bos
+){
+ cobject_type co(cobject_info_set.size(), bos);
+ std::pair<cobject_info_set_type::const_iterator, bool>
+ result = cobject_info_set.insert(co);
+ return *(result.first);
+}
+
+inline void
+basic_oarchive_impl::save_object(
+ basic_oarchive & ar,
+ const void *t,
+ const basic_oserializer & bos
+){
+ // if its been serialized through a pointer and the preamble's been done
+ if(t == pending_object && pending_bos == & bos){
+ // just save the object data
+ ar.end_preamble();
+ (bos.save_object_data)(ar, t);
+ return;
+ }
+
+ // get class information for this object
+ const cobject_type & co = register_type(bos);
+ if(bos.class_info()){
+ if( ! co.m_initialized){
+ ar.vsave(class_id_optional_type(co.m_class_id));
+ ar.vsave(tracking_type(bos.tracking(m_flags)));
+ ar.vsave(version_type(bos.version()));
+ (const_cast<cobject_type &>(co)).m_initialized = true;
+ }
+ }
+
+ // we're not tracking this type of object
+ if(! bos.tracking(m_flags)){
+ // just windup the preamble - no object id to write
+ ar.end_preamble();
+ // and save the data
+ (bos.save_object_data)(ar, t);
+ return;
+ }
+
+ // look for an existing object id
+ object_id_type oid(object_set.size());
+ // lookup to see if this object has already been written to the archive
+ basic_oarchive_impl::aobject ao(t, co.m_class_id, oid);
+ std::pair<basic_oarchive_impl::object_set_type::const_iterator, bool>
+ aresult = object_set.insert(ao);
+ oid = aresult.first->object_id;
+
+ // if its a new object
+ if(aresult.second){
+ // write out the object id
+ ar.vsave(oid);
+ ar.end_preamble();
+ // and data
+ (bos.save_object_data)(ar, t);
+ return;
+ }
+
+ // check that it wasn't originally stored through a pointer
+ if(stored_pointers.end() != stored_pointers.find(oid)){
+ // this has to be a user error. loading such an archive
+ // would create duplicate objects
+ boost::serialization::throw_exception(
+ archive_exception(archive_exception::pointer_conflict)
+ );
+ }
+ // just save the object id
+ ar.vsave(object_reference_type(oid));
+ ar.end_preamble();
+ return;
+}
+
+// save a pointer to an object instance
+inline void
+basic_oarchive_impl::save_pointer(
+ basic_oarchive & ar,
+ const void * t,
+ const basic_pointer_oserializer * bpos_ptr
+){
+ const basic_oserializer & bos = bpos_ptr->get_basic_serializer();
+ std::size_t original_count = cobject_info_set.size();
+ const cobject_type & co = register_type(bos);
+ if(! co.m_initialized){
+ ar.vsave(co.m_class_id);
+ // if its a previously unregistered class
+ if((cobject_info_set.size() > original_count)){
+ if(bos.is_polymorphic()){
+ const serialization::extended_type_info *eti = & bos.get_eti();
+ const char * key = NULL;
+ if(NULL != eti)
+ key = eti->get_key();
+ if(NULL != key){
+ // the following is required by IBM C++ compiler which
+ // makes a copy when passing a non-const to a const. This
+ // is permitted by the standard but rarely seen in practice
+ const class_name_type cn(key);
+ // write out the external class identifier
+ ar.vsave(cn);
+ }
+ else
+ // without an external class name
+ // we won't be able to de-serialize it so bail now
+ boost::serialization::throw_exception(
+ archive_exception(archive_exception::unregistered_class)
+ );
+ }
+ }
+ if(bos.class_info()){
+ ar.vsave(tracking_type(bos.tracking(m_flags)));
+ ar.vsave(version_type(bos.version()));
+ }
+ (const_cast<cobject_type &>(co)).m_initialized = true;
+ }
+ else{
+ ar.vsave(class_id_reference_type(co.m_class_id));
+ }
+
+ // if we're not tracking
+ if(! bos.tracking(m_flags)){
+ // just save the data itself
+ ar.end_preamble();
+ serialization::state_saver<const void *> x(pending_object);
+ serialization::state_saver<const basic_oserializer *> y(pending_bos);
+ pending_object = t;
+ pending_bos = & bpos_ptr->get_basic_serializer();
+ bpos_ptr->save_object_ptr(ar, t);
+ return;
+ }
+
+ object_id_type oid(object_set.size());
+ // lookup to see if this object has already been written to the archive
+ basic_oarchive_impl::aobject ao(t, co.m_class_id, oid);
+ std::pair<basic_oarchive_impl::object_set_type::const_iterator, bool>
+ aresult = object_set.insert(ao);
+ oid = aresult.first->object_id;
+ // if the saved object already exists
+ if(! aresult.second){
+ // append the object id to he preamble
+ ar.vsave(object_reference_type(oid));
+ // and windup.
+ ar.end_preamble();
+ return;
+ }
+
+ // append id of this object to preamble
+ ar.vsave(oid);
+ ar.end_preamble();
+
+ // and save the object itself
+ serialization::state_saver<const void *> x(pending_object);
+ serialization::state_saver<const basic_oserializer *> y(pending_bos);
+ pending_object = t;
+ pending_bos = & bpos_ptr->get_basic_serializer();
+ bpos_ptr->save_object_ptr(ar, t);
+ // add to the set of object initially stored through pointers
+ stored_pointers.insert(oid);
+}
+
+} // namespace detail
+} // namespace archive
+} // namespace boost
+
+//////////////////////////////////////////////////////////////////////
+// implementation of basic_oarchive functions
+
+namespace boost {
+namespace archive {
+namespace detail {
+
+BOOST_ARCHIVE_DECL(BOOST_PP_EMPTY())
+basic_oarchive::basic_oarchive(unsigned int flags)
+ : pimpl(new basic_oarchive_impl(flags))
+{}
+
+BOOST_ARCHIVE_DECL(BOOST_PP_EMPTY())
+basic_oarchive::~basic_oarchive()
+{
+ delete pimpl;
+}
+
+BOOST_ARCHIVE_DECL(void)
+basic_oarchive::save_object(
+ const void *x,
+ const basic_oserializer & bos
+){
+ pimpl->save_object(*this, x, bos);
+}
+
+BOOST_ARCHIVE_DECL(void)
+basic_oarchive::save_pointer(
+ const void * t,
+ const basic_pointer_oserializer * bpos_ptr
+){
+ pimpl->save_pointer(*this, t, bpos_ptr);
+}
+
+BOOST_ARCHIVE_DECL(void)
+basic_oarchive::register_basic_serializer(const basic_oserializer & bos){
+ pimpl->register_type(bos);
+}
+
+BOOST_ARCHIVE_DECL(library_version_type)
+basic_oarchive::get_library_version() const{
+ return BOOST_ARCHIVE_VERSION();
+}
+
+BOOST_ARCHIVE_DECL(unsigned int)
+basic_oarchive::get_flags() const{
+ return pimpl->m_flags;
+}
+
+BOOST_ARCHIVE_DECL(void)
+basic_oarchive::end_preamble(){
+}
+
+} // namespace detail
+} // namespace archive
+} // namespace boost
+
+#ifdef BOOST_MSVC
+#pragma warning(pop)
+#endif
diff --git a/3rdParty/Boost/src/libs/serialization/src/basic_oserializer.cpp b/3rdParty/Boost/src/libs/serialization/src/basic_oserializer.cpp
new file mode 100644
index 0000000..0e21806
--- /dev/null
+++ b/3rdParty/Boost/src/libs/serialization/src/basic_oserializer.cpp
@@ -0,0 +1,33 @@
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// basic_oserializer.cpp:
+
+// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
+// Use, modification and distribution is subject to the Boost Software
+// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+
+// See http://www.boost.org for updates, documentation, and revision history.
+
+#include <cstddef> // NULL
+
+#define BOOST_ARCHIVE_SOURCE
+#include <boost/archive/detail/basic_oserializer.hpp>
+
+namespace boost {
+namespace archive {
+namespace detail {
+
+BOOST_ARCHIVE_DECL(BOOST_PP_EMPTY())
+basic_oserializer::basic_oserializer(
+ const boost::serialization::extended_type_info & eti
+) :
+ basic_serializer(eti),
+ m_bpos(NULL)
+{}
+
+BOOST_ARCHIVE_DECL(BOOST_PP_EMPTY())
+basic_oserializer::~basic_oserializer(){}
+
+} // namespace detail
+} // namespace archive
+} // namespace boost
diff --git a/3rdParty/Boost/src/libs/serialization/src/basic_pointer_iserializer.cpp b/3rdParty/Boost/src/libs/serialization/src/basic_pointer_iserializer.cpp
new file mode 100644
index 0000000..fac766f
--- /dev/null
+++ b/3rdParty/Boost/src/libs/serialization/src/basic_pointer_iserializer.cpp
@@ -0,0 +1,30 @@
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// basic_pointer_iserializer.cpp:
+
+// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
+// Use, modification and distribution is subject to the Boost Software
+// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+
+// See http://www.boost.org for updates, documentation, and revision history.
+
+#define BOOST_ARCHIVE_SOURCE
+#include <boost/archive/detail/basic_pointer_iserializer.hpp>
+
+namespace boost {
+namespace archive {
+namespace detail {
+
+BOOST_ARCHIVE_DECL(BOOST_PP_EMPTY())
+basic_pointer_iserializer::basic_pointer_iserializer(
+ const boost::serialization::extended_type_info & eti
+) :
+ basic_serializer(eti)
+{}
+
+BOOST_ARCHIVE_DECL(BOOST_PP_EMPTY())
+basic_pointer_iserializer::~basic_pointer_iserializer() {}
+
+} // namespace detail
+} // namespace archive
+} // namespace boost
diff --git a/3rdParty/Boost/src/libs/serialization/src/basic_pointer_oserializer.cpp b/3rdParty/Boost/src/libs/serialization/src/basic_pointer_oserializer.cpp
new file mode 100644
index 0000000..9e9f1dd
--- /dev/null
+++ b/3rdParty/Boost/src/libs/serialization/src/basic_pointer_oserializer.cpp
@@ -0,0 +1,30 @@
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// basic_pointer_oserializer.cpp:
+
+// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
+// Use, modification and distribution is subject to the Boost Software
+// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+
+// See http://www.boost.org for updates, documentation, and revision history.
+
+#define BOOST_ARCHIVE_SOURCE
+#include <boost/archive/detail/basic_pointer_oserializer.hpp>
+
+namespace boost {
+namespace archive {
+namespace detail {
+
+BOOST_ARCHIVE_DECL(BOOST_PP_EMPTY())
+basic_pointer_oserializer::basic_pointer_oserializer(
+ const boost::serialization::extended_type_info & eti
+) :
+ basic_serializer(eti)
+{}
+
+BOOST_ARCHIVE_DECL(BOOST_PP_EMPTY())
+basic_pointer_oserializer::~basic_pointer_oserializer() {}
+
+} // namespace detail
+} // namespace archive
+} // namespace boost
diff --git a/3rdParty/Boost/src/libs/serialization/src/basic_serializer_map.cpp b/3rdParty/Boost/src/libs/serialization/src/basic_serializer_map.cpp
new file mode 100644
index 0000000..80e805f
--- /dev/null
+++ b/3rdParty/Boost/src/libs/serialization/src/basic_serializer_map.cpp
@@ -0,0 +1,111 @@
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// serializer_map.cpp:
+
+// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
+// Use, modification and distribution is subject to the Boost Software
+// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+
+// See http://www.boost.org for updates, documentation, and revision history.
+
+#if (defined _MSC_VER) && (_MSC_VER == 1200)
+# pragma warning (disable : 4786) // too long name, harmless warning
+#endif
+
+#include <set>
+#include <utility>
+
+#define BOOST_ARCHIVE_SOURCE
+// include this to prevent linker errors when the
+// same modules are marked export and import.
+#define BOOST_SERIALIZATION_SOURCE
+
+#include <boost/archive/archive_exception.hpp>
+#include <boost/serialization/throw_exception.hpp>
+
+#include <boost/archive/detail/basic_serializer.hpp>
+#include <boost/archive/detail/basic_serializer_map.hpp>
+
+namespace boost {
+ namespace serialization {
+ class extended_type_info;
+ }
+namespace archive {
+namespace detail {
+
+bool
+basic_serializer_map::type_info_pointer_compare::operator()(
+ const basic_serializer * lhs, const basic_serializer * rhs
+) const {
+ return *lhs < *rhs;
+}
+
+BOOST_ARCHIVE_DECL(bool)
+basic_serializer_map::insert(const basic_serializer * bs){
+ // attempt to insert serializer into it's map
+ const std::pair<map_type::iterator, bool> result =
+ m_map.insert(bs);
+ // the following is commented out - rather than being just
+ // deleted as a reminder not to try this.
+
+ // At first it seemed like a good idea. It enforced the
+ // idea that a type be exported from at most one code module
+ // (DLL or mainline). This would enforce a "one definition rule"
+ // across code modules. This seems a good idea to me.
+ // But it seems that it's just too hard for many users to implement.
+
+ // Ideally, I would like to make this exception a warning -
+ // but there isn't anyway to do that.
+
+ // if this fails, it's because it's been instantiated
+ // in multiple modules - DLLS - a recipe for problems.
+ // So trap this here
+ // if(!result.second){
+ // boost::serialization::throw_exception(
+ // archive_exception(
+ // archive_exception::multiple_code_instantiation,
+ // bs->get_debug_info()
+ // )
+ // );
+ // }
+ return true;
+}
+
+BOOST_ARCHIVE_DECL(void)
+basic_serializer_map::erase(const basic_serializer * bs){
+ map_type::iterator it = m_map.begin();
+ map_type::iterator it_end = m_map.end();
+
+ while(it != it_end){
+ // note item 9 from Effective STL !!! it++
+ if(*it == bs)
+ m_map.erase(it++);
+ else
+ it++;
+ }
+ // note: we can't do this since some of the eti records
+ // we're pointing to might be expired and the comparison
+ // won't work. Leave this as a reminder not to "optimize" this.
+ //it = m_map.find(bs);
+ //assert(it != m_map.end());
+ //if(*it == bs)
+ // m_map.erase(it);
+}
+BOOST_ARCHIVE_DECL(const basic_serializer *)
+basic_serializer_map::find(
+ const boost::serialization::extended_type_info & eti
+) const {
+ const basic_serializer_arg bs(eti);
+ map_type::const_iterator it;
+ it = m_map.find(& bs);
+ if(it == m_map.end()){
+ BOOST_ASSERT(false);
+ return 0;
+ }
+ return *it;
+}
+
+} // namespace detail
+} // namespace archive
+} // namespace boost
+
diff --git a/3rdParty/Boost/src/libs/serialization/src/basic_text_iprimitive.cpp b/3rdParty/Boost/src/libs/serialization/src/basic_text_iprimitive.cpp
new file mode 100644
index 0000000..c67a942
--- /dev/null
+++ b/3rdParty/Boost/src/libs/serialization/src/basic_text_iprimitive.cpp
@@ -0,0 +1,28 @@
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// basic_text_iprimitive.cpp:
+
+// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
+// Use, modification and distribution is subject to the Boost Software
+// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+
+// See http://www.boost.org for updates, documentation, and revision history.
+
+#if (defined _MSC_VER) && (_MSC_VER == 1200)
+# pragma warning (disable : 4786) // too long name, harmless warning
+#endif
+
+#include <istream>
+
+#define BOOST_ARCHIVE_SOURCE
+#include <boost/archive/detail/auto_link_archive.hpp>
+#include <boost/archive/impl/basic_text_iprimitive.ipp>
+
+namespace boost {
+namespace archive {
+
+// explicitly instantiate for this type of text stream
+template class basic_text_iprimitive<std::istream> ;
+
+} // namespace archive
+} // namespace boost
diff --git a/3rdParty/Boost/src/libs/serialization/src/basic_text_oprimitive.cpp b/3rdParty/Boost/src/libs/serialization/src/basic_text_oprimitive.cpp
new file mode 100644
index 0000000..d8d98d6
--- /dev/null
+++ b/3rdParty/Boost/src/libs/serialization/src/basic_text_oprimitive.cpp
@@ -0,0 +1,28 @@
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// basic_text_oprimitive.cpp:
+
+// (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.
+
+#if (defined _MSC_VER) && (_MSC_VER == 1200)
+# pragma warning (disable : 4786) // too long name, harmless warning
+#endif
+
+#include <ostream>
+
+#define BOOST_ARCHIVE_SOURCE
+#include <boost/archive/detail/auto_link_archive.hpp>
+#include <boost/archive/impl/basic_text_oprimitive.ipp>
+
+namespace boost {
+namespace archive {
+
+// explicitly instantiate for this type of text stream
+template class basic_text_oprimitive<std::ostream> ;
+
+} // namespace archive
+} // namespace boost
diff --git a/3rdParty/Boost/src/libs/serialization/src/basic_text_wiprimitive.cpp b/3rdParty/Boost/src/libs/serialization/src/basic_text_wiprimitive.cpp
new file mode 100644
index 0000000..4797485
--- /dev/null
+++ b/3rdParty/Boost/src/libs/serialization/src/basic_text_wiprimitive.cpp
@@ -0,0 +1,35 @@
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// basic_text_wiprimitive.cpp:
+
+// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
+// Use, modification and distribution is subject to the Boost Software
+// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+
+// See http://www.boost.org for updates, documentation, and revision history.
+
+#include <boost/config.hpp>
+
+#ifdef BOOST_NO_STD_WSTREAMBUF
+#error "wide char i/o not supported on this platform"
+#else
+
+#if (defined _MSC_VER) && (_MSC_VER == 1200)
+# pragma warning (disable : 4786) // too long name, harmless warning
+#endif
+
+#include <istream>
+
+#define BOOST_WARCHIVE_SOURCE
+#include <boost/archive/detail/auto_link_warchive.hpp>
+#include <boost/archive/impl/basic_text_iprimitive.ipp>
+
+namespace boost {
+namespace archive {
+
+template class basic_text_iprimitive<std::wistream> ;
+
+} // namespace archive
+} // namespace boost
+
+#endif // BOOST_NO_STD_WSTREAMBUF
diff --git a/3rdParty/Boost/src/libs/serialization/src/basic_text_woprimitive.cpp b/3rdParty/Boost/src/libs/serialization/src/basic_text_woprimitive.cpp
new file mode 100644
index 0000000..e13294e
--- /dev/null
+++ b/3rdParty/Boost/src/libs/serialization/src/basic_text_woprimitive.cpp
@@ -0,0 +1,35 @@
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// basic_text_woprimitive.cpp:
+
+// (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 <boost/config.hpp>
+
+#ifdef BOOST_NO_STD_WSTREAMBUF
+#error "wide char i/o not supported on this platform"
+#else
+
+#if (defined _MSC_VER) && (_MSC_VER == 1200)
+# pragma warning (disable : 4786) // too long name, harmless warning
+#endif
+
+#include <ostream>
+
+#define BOOST_WARCHIVE_SOURCE
+#include <boost/archive/detail/auto_link_warchive.hpp>
+#include <boost/archive/impl/basic_text_oprimitive.ipp>
+
+namespace boost {
+namespace archive {
+
+template class basic_text_oprimitive<std::wostream> ;
+
+} // namespace archive
+} // namespace boost
+
+#endif // BOOST_NO_STD_WSTREAMBUF
diff --git a/3rdParty/Boost/src/libs/serialization/src/basic_xml_archive.cpp b/3rdParty/Boost/src/libs/serialization/src/basic_xml_archive.cpp
new file mode 100644
index 0000000..e71aaef
--- /dev/null
+++ b/3rdParty/Boost/src/libs/serialization/src/basic_xml_archive.cpp
@@ -0,0 +1,51 @@
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// basic_xml_archive.cpp:
+
+// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
+// Use, modification and distribution is subject to the Boost Software
+// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+
+// See http://www.boost.org for updates, documentation, and revision history.
+
+#define BOOST_ARCHIVE_SOURCE
+#include <boost/archive/basic_xml_archive.hpp>
+
+namespace boost {
+namespace archive {
+
+BOOST_ARCHIVE_DECL(const char *)
+BOOST_ARCHIVE_XML_OBJECT_ID(){
+ return "object_id";
+}
+BOOST_ARCHIVE_DECL(const char *)
+BOOST_ARCHIVE_XML_OBJECT_REFERENCE(){
+ return "object_id_reference";
+}
+BOOST_ARCHIVE_DECL(const char *)
+BOOST_ARCHIVE_XML_CLASS_ID(){
+ return "class_id";
+}
+BOOST_ARCHIVE_DECL(const char *)
+BOOST_ARCHIVE_XML_CLASS_ID_REFERENCE(){
+ return "class_id_reference";
+}
+BOOST_ARCHIVE_DECL(const char *)
+BOOST_ARCHIVE_XML_CLASS_NAME(){
+ return "class_name";
+}
+BOOST_ARCHIVE_DECL(const char *)
+BOOST_ARCHIVE_XML_TRACKING(){
+ return "tracking_level";
+}
+BOOST_ARCHIVE_DECL(const char *)
+BOOST_ARCHIVE_XML_VERSION(){
+ return "version";
+}
+BOOST_ARCHIVE_DECL(const char *)
+BOOST_ARCHIVE_XML_SIGNATURE(){
+ return "signature";
+}
+
+}// namespace archive
+}// namespace boost
diff --git a/3rdParty/Boost/src/libs/serialization/src/basic_xml_grammar.ipp b/3rdParty/Boost/src/libs/serialization/src/basic_xml_grammar.ipp
new file mode 100644
index 0000000..011bba7
--- /dev/null
+++ b/3rdParty/Boost/src/libs/serialization/src/basic_xml_grammar.ipp
@@ -0,0 +1,468 @@
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// basic_xml_grammar.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.
+
+#if (defined _MSC_VER) && (_MSC_VER == 1200)
+# pragma warning (disable : 4786) // too long name, harmless warning
+#endif
+
+#include <istream>
+#include <algorithm>
+#include <boost/config.hpp> // BOOST_DEDUCED_TYPENAME
+
+#ifdef BOOST_MSVC
+# pragma warning(push)
+# pragma warning(disable : 4511 4512)
+#endif
+
+// spirit stuff
+#include <boost/spirit/include/classic_operators.hpp>
+#include <boost/spirit/include/classic_actions.hpp>
+#include <boost/spirit/include/classic_numerics.hpp>
+
+#ifdef BOOST_MSVC
+#pragma warning(pop)
+#endif
+
+// for head_iterator test
+//#include <boost/bind.hpp>
+#include <boost/function.hpp>
+#include <boost/serialization/pfto.hpp>
+
+#include <boost/io/ios_state.hpp>
+#include <boost/serialization/throw_exception.hpp>
+#include <boost/archive/impl/basic_xml_grammar.hpp>
+#include <boost/archive/xml_archive_exception.hpp>
+#include <boost/archive/basic_xml_archive.hpp>
+#include <boost/archive/iterators/xml_unescape.hpp>
+
+using namespace boost::spirit::classic;
+
+namespace boost {
+namespace archive {
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// template code for basic_xml_grammar of both wchar_t and char types
+
+namespace xml { // anonymous
+
+#ifdef BOOST_MSVC
+# pragma warning(push)
+# pragma warning(disable : 4511 4512)
+#endif
+
+template<class T>
+struct assign_impl {
+ T & t;
+ void operator()(const T t_) const {
+ t = t_;
+ }
+ assign_impl(T & t_)
+ : t(t_)
+ {}
+};
+
+template<>
+struct assign_impl<std::string> {
+ std::string & t;
+ void operator()(
+ std::string::const_iterator b,
+ std::string::const_iterator e
+ ) const {
+ t.resize(0);
+ while(b != e){
+ t += * b;
+ ++b;
+ }
+ }
+ assign_impl<std::string> & operator=(
+ assign_impl<std::string> & rhs
+ );
+ assign_impl(std::string & t_)
+ : t(t_)
+ {}
+};
+
+#ifndef BOOST_NO_STD_WSTRING
+template<>
+struct assign_impl<std::wstring> {
+ std::wstring & t;
+ void operator()(
+ std::wstring::const_iterator b,
+ std::wstring::const_iterator e
+ ) const {
+ t.resize(0);
+ while(b != e){
+ t += * b;
+ ++b;
+ }
+ }
+ assign_impl(std::wstring & t_)
+ : t(t_)
+ {}
+};
+#endif
+
+template<class T>
+assign_impl<T> assign_object(T &t){
+ return assign_impl<T>(t);
+}
+
+struct assign_level {
+ tracking_type & tracking_level;
+ void operator()(const unsigned int tracking_level_) const {
+ tracking_level = (0 == tracking_level_) ? false : true;
+ }
+ assign_level(tracking_type & tracking_level_)
+ : tracking_level(tracking_level_)
+ {}
+};
+
+template<class String, class Iterator>
+struct append_string {
+ String & contents;
+ void operator()(Iterator start, Iterator end) const {
+ #if 0
+ typedef boost::archive::iterators::xml_unescape<Iterator> translator;
+ contents.append(
+ translator(BOOST_MAKE_PFTO_WRAPPER(start)),
+ translator(BOOST_MAKE_PFTO_WRAPPER(end))
+ );
+ #endif
+ contents.append(start, end);
+ }
+ append_string(String & contents_)
+ : contents(contents_)
+ {}
+};
+
+template<class String>
+struct append_char {
+ String & contents;
+ void operator()(const unsigned int char_value) const {
+ const BOOST_DEDUCED_TYPENAME String::value_type z = char_value;
+ contents += z;
+ }
+ append_char(String & contents_)
+ : contents(contents_)
+ {}
+};
+
+template<class String, unsigned int c>
+struct append_lit {
+ String & contents;
+ template<class X, class Y>
+ void operator()(const X & /*x*/, const Y & /*y*/) const {
+ const BOOST_DEDUCED_TYPENAME String::value_type z = c;
+ contents += z;
+ }
+ append_lit(String & contents_)
+ : contents(contents_)
+ {}
+};
+
+#ifdef BOOST_MSVC
+#pragma warning(pop)
+#endif
+
+} // namespace anonymous
+
+template<class CharType>
+bool basic_xml_grammar<CharType>::my_parse(
+ BOOST_DEDUCED_TYPENAME basic_xml_grammar<CharType>::IStream & is,
+ const rule_t & rule_,
+ CharType delimiter
+) const {
+ if(is.fail()){
+ boost::serialization::throw_exception(
+ archive_exception(archive_exception::input_stream_error)
+ );
+ }
+
+ boost::io::ios_flags_saver ifs(is);
+ is >> std::noskipws;
+
+ std::basic_string<CharType> arg;
+
+ CharType val;
+ do{
+ BOOST_DEDUCED_TYPENAME basic_xml_grammar<CharType>::IStream::int_type
+ result = is.get();
+ if(is.fail())
+ return false;
+ val = static_cast<CharType>(result);
+ arg += val;
+ }
+ while(val != delimiter);
+
+ // read just one more character. This will be the newline after the tag
+ // this is so that the next operation will return fail if the archive
+ // is terminated. This will permit the archive to be used for debug
+ // and transaction data logging in the standard way.
+
+ parse_info<BOOST_DEDUCED_TYPENAME std::basic_string<CharType>::iterator>
+ result = boost::spirit::classic::parse(arg.begin(), arg.end(), rule_);
+ return result.hit;
+}
+
+template<class CharType>
+bool basic_xml_grammar<CharType>::parse_start_tag(
+ BOOST_DEDUCED_TYPENAME basic_xml_grammar<CharType>::IStream & is
+){
+ rv.class_name.resize(0);
+ return my_parse(is, STag);
+}
+
+template<class CharType>
+bool basic_xml_grammar<CharType>::parse_end_tag(IStream & is) const {
+ return my_parse(is, ETag);
+}
+
+template<class CharType>
+bool basic_xml_grammar<CharType>::parse_string(IStream & is, StringType & s){
+ rv.contents.resize(0);
+ bool result = my_parse(is, content, '<');
+ // note: unget caused a problem with dinkumware. replace with
+ // is.unget();
+ // putback another dilimiter instead
+ is.putback('<');
+ if(result)
+ s = rv.contents;
+ return result;
+}
+
+template<class CharType>
+basic_xml_grammar<CharType>::basic_xml_grammar(){
+ init_chset();
+
+ S =
+ +(Sch)
+ ;
+
+ // refactoring to workaround template depth on darwin
+ NameHead = (Letter | '_' | ':');
+ NameTail = *NameChar ;
+ Name =
+ NameHead >> NameTail
+ ;
+
+ Eq =
+ !S >> '=' >> !S
+ ;
+
+ AttributeList =
+ *(S >> Attribute)
+ ;
+
+ STag =
+ !S
+ >> '<'
+ >> Name [xml::assign_object(rv.object_name)]
+ >> AttributeList
+ >> !S
+ >> '>'
+ ;
+
+ ETag =
+ !S
+ >> "</"
+ >> Name [xml::assign_object(rv.object_name)]
+ >> !S
+ >> '>'
+ ;
+
+ // refactoring to workaround template depth on darwin
+ CharDataChars = +(anychar_p - chset_p(L"&<"));
+ CharData =
+ CharDataChars [
+ xml::append_string<
+ StringType,
+ BOOST_DEDUCED_TYPENAME std::basic_string<CharType>::const_iterator
+ >(rv.contents)
+ ]
+ ;
+
+ // slight factoring works around ICE in msvc 6.0
+ CharRef1 =
+ str_p(L"&#") >> uint_p [xml::append_char<StringType>(rv.contents)] >> L';'
+ ;
+ CharRef2 =
+ str_p(L"&#x") >> hex_p [xml::append_char<StringType>(rv.contents)] >> L';'
+ ;
+ CharRef = CharRef1 | CharRef2 ;
+
+ AmpRef = str_p(L"&amp;")[xml::append_lit<StringType, L'&'>(rv.contents)];
+ LTRef = str_p(L"&lt;")[xml::append_lit<StringType, L'<'>(rv.contents)];
+ GTRef = str_p(L"&gt;")[xml::append_lit<StringType, L'>'>(rv.contents)];
+ AposRef = str_p(L"&apos;")[xml::append_lit<StringType, L'\''>(rv.contents)];
+ QuoteRef = str_p(L"&quot;")[xml::append_lit<StringType, L'"'>(rv.contents)];
+
+ Reference =
+ AmpRef
+ | LTRef
+ | GTRef
+ | AposRef
+ | QuoteRef
+ | CharRef
+ ;
+
+ content =
+ L"<" // should be end_p
+ | +(Reference | CharData) >> L"<"
+ ;
+
+ ClassIDAttribute =
+ str_p(BOOST_ARCHIVE_XML_CLASS_ID()) >> NameTail
+ >> Eq
+ >> L'"'
+ >> int_p [xml::assign_object(rv.class_id)]
+ >> L'"'
+ ;
+
+ ObjectIDAttribute = (
+ str_p(BOOST_ARCHIVE_XML_OBJECT_ID())
+ |
+ str_p(BOOST_ARCHIVE_XML_OBJECT_REFERENCE())
+ )
+ >> NameTail
+ >> Eq
+ >> L'"'
+ >> L'_'
+ >> uint_p [xml::assign_object(rv.object_id)]
+ >> L'"'
+ ;
+
+ AmpName = str_p(L"&amp;")[xml::append_lit<StringType, L'&'>(rv.class_name)];
+ LTName = str_p(L"&lt;")[xml::append_lit<StringType, L'<'>(rv.class_name)];
+ GTName = str_p(L"&gt;")[xml::append_lit<StringType, L'>'>(rv.class_name)];
+ ClassNameChar =
+ AmpName
+ | LTName
+ | GTName
+ | (anychar_p - chset_p(L"\"")) [xml::append_char<StringType>(rv.class_name)]
+ ;
+
+ ClassName =
+ * ClassNameChar
+ ;
+
+ ClassNameAttribute =
+ str_p(BOOST_ARCHIVE_XML_CLASS_NAME())
+ >> Eq
+ >> L'"'
+ >> ClassName
+ >> L'"'
+ ;
+
+ TrackingAttribute =
+ str_p(BOOST_ARCHIVE_XML_TRACKING())
+ >> Eq
+ >> L'"'
+ >> uint_p [xml::assign_level(rv.tracking_level)]
+ >> L'"'
+ ;
+
+ VersionAttribute =
+ str_p(BOOST_ARCHIVE_XML_VERSION())
+ >> Eq
+ >> L'"'
+ >> uint_p [xml::assign_object(rv.version)]
+ >> L'"'
+ ;
+
+ UnusedAttribute =
+ Name
+ >> Eq
+ >> L'"'
+ >> !CharData
+ >> L'"'
+ ;
+
+ Attribute =
+ ClassIDAttribute
+ | ObjectIDAttribute
+ | ClassNameAttribute
+ | TrackingAttribute
+ | VersionAttribute
+ | UnusedAttribute
+ ;
+
+ XMLDeclChars = *(anychar_p - chset_p(L"?>"));
+ XMLDecl =
+ !S
+ >> str_p(L"<?xml")
+ >> S
+ >> str_p(L"version")
+ >> Eq
+ >> str_p(L"\"1.0\"")
+ >> XMLDeclChars
+ >> !S
+ >> str_p(L"?>")
+ ;
+
+ DocTypeDeclChars = *(anychar_p - chset_p(L">"));
+ DocTypeDecl =
+ !S
+ >> str_p(L"<!DOCTYPE")
+ >> DocTypeDeclChars
+ >> L'>'
+ ;
+
+ SignatureAttribute =
+ str_p(L"signature")
+ >> Eq
+ >> L'"'
+ >> Name [xml::assign_object(rv.class_name)]
+ >> L'"'
+ ;
+
+ SerializationWrapper =
+ !S
+ >> str_p(L"<boost_serialization")
+ >> S
+ >> ( (SignatureAttribute >> S >> VersionAttribute)
+ | (VersionAttribute >> S >> SignatureAttribute)
+ )
+ >> !S
+ >> L'>'
+ ;
+}
+
+template<class CharType>
+void basic_xml_grammar<CharType>::init(IStream & is){
+ init_chset();
+ if(! my_parse(is, XMLDecl))
+ boost::serialization::throw_exception(
+ xml_archive_exception(xml_archive_exception::xml_archive_parsing_error)
+ );
+ if(! my_parse(is, DocTypeDecl))
+ boost::serialization::throw_exception(
+ xml_archive_exception(xml_archive_exception::xml_archive_parsing_error)
+ );
+ if(! my_parse(is, SerializationWrapper))
+ boost::serialization::throw_exception(
+ xml_archive_exception(xml_archive_exception::xml_archive_parsing_error)
+ );
+ if(! std::equal(rv.class_name.begin(), rv.class_name.end(), BOOST_ARCHIVE_SIGNATURE()))
+ boost::serialization::throw_exception(
+ archive_exception(archive_exception::invalid_signature)
+ );
+}
+
+template<class CharType>
+void basic_xml_grammar<CharType>::windup(IStream & is){
+ if(is.fail())
+ return;
+ // uh-oh - don't throw exception from code called by a destructor !
+ // so just ignore any failure.
+ my_parse(is, ETag);
+}
+
+} // namespace archive
+} // namespace boost
diff --git a/3rdParty/Boost/src/libs/serialization/src/binary_iarchive.cpp b/3rdParty/Boost/src/libs/serialization/src/binary_iarchive.cpp
new file mode 100644
index 0000000..7bb0435
--- /dev/null
+++ b/3rdParty/Boost/src/libs/serialization/src/binary_iarchive.cpp
@@ -0,0 +1,53 @@
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// binary_iarchive.cpp:
+
+// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
+// Use, modification and distribution is subject to the Boost Software
+// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+
+// See http://www.boost.org for updates, documentation, and revision history.
+
+#include <istream>
+
+#define BOOST_ARCHIVE_SOURCE
+#include <boost/archive/binary_iarchive.hpp>
+#include <boost/archive/detail/archive_serializer_map.hpp>
+
+#include <boost/archive/impl/archive_serializer_map.ipp>
+#include <boost/archive/impl/basic_binary_iprimitive.ipp>
+#include <boost/archive/impl/basic_binary_iarchive.ipp>
+
+namespace boost {
+namespace archive {
+
+// explicitly instantiate for this type of stream
+template class detail::archive_serializer_map<naked_binary_iarchive>;
+template class basic_binary_iprimitive<
+ naked_binary_iarchive,
+ std::istream::char_type,
+ std::istream::traits_type
+>;
+template class basic_binary_iarchive<naked_binary_iarchive> ;
+template class binary_iarchive_impl<
+ naked_binary_iarchive,
+ std::istream::char_type,
+ std::istream::traits_type
+>;
+
+// explicitly instantiate for this type of stream
+template class detail::archive_serializer_map<binary_iarchive>;
+template class basic_binary_iprimitive<
+ binary_iarchive,
+ std::istream::char_type,
+ std::istream::traits_type
+>;
+template class basic_binary_iarchive<binary_iarchive> ;
+template class binary_iarchive_impl<
+ binary_iarchive,
+ std::istream::char_type,
+ std::istream::traits_type
+>;
+
+} // namespace archive
+} // namespace boost
diff --git a/3rdParty/Boost/src/libs/serialization/src/binary_oarchive.cpp b/3rdParty/Boost/src/libs/serialization/src/binary_oarchive.cpp
new file mode 100644
index 0000000..e7ab904
--- /dev/null
+++ b/3rdParty/Boost/src/libs/serialization/src/binary_oarchive.cpp
@@ -0,0 +1,39 @@
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// binary_oarchive.cpp:
+
+// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
+// Use, modification and distribution is subject to the Boost Software
+// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+
+// See http://www.boost.org for updates, documentation, and revision history.
+
+#include <ostream>
+
+#define BOOST_ARCHIVE_SOURCE
+#include <boost/archive/binary_oarchive.hpp>
+#include <boost/archive/detail/archive_serializer_map.hpp>
+
+// explicitly instantiate for this type of binary stream
+#include <boost/archive/impl/archive_serializer_map.ipp>
+#include <boost/archive/impl/basic_binary_oprimitive.ipp>
+#include <boost/archive/impl/basic_binary_oarchive.ipp>
+
+namespace boost {
+namespace archive {
+
+template class detail::archive_serializer_map<binary_oarchive>;
+template class basic_binary_oprimitive<
+ binary_oarchive,
+ std::ostream::char_type,
+ std::ostream::traits_type
+>;
+template class basic_binary_oarchive<binary_oarchive> ;
+template class binary_oarchive_impl<
+ binary_oarchive,
+ std::ostream::char_type,
+ std::ostream::traits_type
+>;
+
+} // namespace archive
+} // namespace boost
diff --git a/3rdParty/Boost/src/libs/serialization/src/binary_wiarchive.cpp b/3rdParty/Boost/src/libs/serialization/src/binary_wiarchive.cpp
new file mode 100644
index 0000000..a6135c8
--- /dev/null
+++ b/3rdParty/Boost/src/libs/serialization/src/binary_wiarchive.cpp
@@ -0,0 +1,60 @@
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// binary_wiarchive.cpp:
+
+// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
+// Use, modification and distribution is subject to the Boost Software
+// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+
+// See http://www.boost.org for updates, documentation, and revision history.
+
+#include <boost/config.hpp>
+
+#ifdef BOOST_NO_STD_WSTREAMBUF
+#error "wide char i/o not supported on this platform"
+#else
+
+#define BOOST_WARCHIVE_SOURCE
+#include <boost/archive/binary_wiarchive.hpp>
+#include <boost/archive/detail/archive_serializer_map.hpp>
+
+// explicitly instantiate for this type of text stream
+#include <boost/archive/impl/archive_serializer_map.ipp>
+#include <boost/archive/impl/basic_binary_iprimitive.ipp>
+#include <boost/archive/impl/basic_binary_iarchive.ipp>
+
+namespace boost {
+namespace archive {
+
+template class detail::archive_serializer_map<naked_binary_wiarchive>;
+template class basic_binary_iprimitive<
+ naked_binary_wiarchive,
+ wchar_t,
+ std::char_traits<wchar_t>
+>;
+template class basic_binary_iarchive<naked_binary_wiarchive> ;
+template class binary_iarchive_impl<
+ naked_binary_wiarchive,
+ wchar_t,
+ std::char_traits<wchar_t>
+>;
+
+// explicitly instantiate for this type of text stream
+template class detail::archive_serializer_map<binary_wiarchive>;
+template class basic_binary_iprimitive<
+ binary_wiarchive,
+ wchar_t,
+ std::char_traits<wchar_t>
+>;
+template class basic_binary_iarchive<binary_wiarchive> ;
+template class binary_iarchive_impl<
+ binary_wiarchive,
+ wchar_t,
+ std::char_traits<wchar_t>
+>;
+
+} // namespace archive
+} // namespace boost
+
+#endif // BOOST_NO_STD_WSTREAMBUF
+
diff --git a/3rdParty/Boost/src/libs/serialization/src/binary_woarchive.cpp b/3rdParty/Boost/src/libs/serialization/src/binary_woarchive.cpp
new file mode 100644
index 0000000..905a319
--- /dev/null
+++ b/3rdParty/Boost/src/libs/serialization/src/binary_woarchive.cpp
@@ -0,0 +1,44 @@
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// binary_woarchive.cpp:
+
+// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
+// Use, modification and distribution is subject to the Boost Software
+// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+
+// See http://www.boost.org for updates, documentation, and revision history.
+
+#include <boost/config.hpp>
+
+#ifdef BOOST_NO_STD_WSTREAMBUF
+#error "wide char i/o not supported on this platform"
+#else
+
+#define BOOST_WARCHIVE_SOURCE
+#include <boost/archive/binary_woarchive.hpp>
+
+// explicitly instantiate for this type of text stream
+#include <boost/archive/impl/archive_serializer_map.ipp>
+#include <boost/archive/impl/basic_binary_oprimitive.ipp>
+#include <boost/archive/impl/basic_binary_oarchive.ipp>
+
+namespace boost {
+namespace archive {
+
+template class detail::archive_serializer_map<binary_woarchive>;
+template class basic_binary_oprimitive<
+ binary_woarchive,
+ wchar_t,
+ std::char_traits<wchar_t>
+>;
+template class basic_binary_oarchive<binary_woarchive> ;
+template class binary_oarchive_impl<
+ binary_woarchive,
+ wchar_t,
+ std::char_traits<wchar_t>
+>;
+
+} // namespace archive
+} // namespace boost
+
+#endif // BOOST_NO_STD_WSTREAMBUF
diff --git a/3rdParty/Boost/src/libs/serialization/src/codecvt_null.cpp b/3rdParty/Boost/src/libs/serialization/src/codecvt_null.cpp
new file mode 100644
index 0000000..80ba2a3
--- /dev/null
+++ b/3rdParty/Boost/src/libs/serialization/src/codecvt_null.cpp
@@ -0,0 +1,83 @@
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// codecvt_null.cpp
+
+// Copyright (c) 2004 Robert Ramey, Indiana University (garcia@osl.iu.edu)
+// Andrew Lumsdaine, Indiana University (lums@osl.iu.edu).
+// 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)
+
+#define BOOST_WARCHIVE_SOURCE
+#include <boost/archive/codecvt_null.hpp>
+
+// codecvt implementation for passing wchar_t objects to char output
+// without any translation whatever. Used to implement binary output
+// of wchar_t objects.
+
+namespace boost {
+namespace archive {
+
+BOOST_WARCHIVE_DECL(std::codecvt_base::result)
+codecvt_null<wchar_t>::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 {
+ while(first1 != last1){
+ // Per std::22.2.1.5.2/2, we can store no more that
+ // last2-first2 characters. If we need to more encode
+ // next internal char type, return 'partial'.
+ if(static_cast<int>(sizeof(wchar_t)) > (last2 - first2)){
+ next1 = first1;
+ next2 = first2;
+ return std::codecvt_base::partial;
+ }
+ * reinterpret_cast<wchar_t *>(first2) = * first1++;
+ first2 += sizeof(wchar_t);
+
+ }
+ next1 = first1;
+ next2 = first2;
+ return std::codecvt_base::ok;
+}
+
+BOOST_WARCHIVE_DECL(std::codecvt_base::result)
+codecvt_null<wchar_t>::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 {
+ // Process input characters until we've run of them,
+ // or the number of remaining characters is not
+ // enough to construct another output character,
+ // or we've run out of place for output characters.
+ while(first2 != last2){
+ // Have we converted all input characters?
+ // Return with 'ok', if so.
+ if (first1 == last1)
+ break;
+ // Do we have less input characters than needed
+ // for a single output character?
+ if(static_cast<int>(sizeof(wchar_t)) > (last1 - first1)){
+ next1 = first1;
+ next2 = first2;
+ return std::codecvt_base::partial;
+ }
+ *first2++ = * reinterpret_cast<const wchar_t *>(first1);
+ first1 += sizeof(wchar_t);
+ }
+ next1 = first1;
+ next2 = first2;
+ return std::codecvt_base::ok;
+}
+
+} // namespace archive
+} // namespace boost
diff --git a/3rdParty/Boost/src/libs/serialization/src/extended_type_info.cpp b/3rdParty/Boost/src/libs/serialization/src/extended_type_info.cpp
new file mode 100644
index 0000000..2efbefc
--- /dev/null
+++ b/3rdParty/Boost/src/libs/serialization/src/extended_type_info.cpp
@@ -0,0 +1,188 @@
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// extended_type_info.cpp: implementation for portable version of type_info
+
+// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
+// Use, modification and distribution is subject to the Boost Software
+// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+
+// See http://www.boost.org for updates, documentation, and revision history.
+
+#if (defined _MSC_VER) && (_MSC_VER == 1200)
+# pragma warning (disable : 4786) // too long name, harmless warning
+#endif
+
+#include <algorithm>
+#include <set>
+#include <utility>
+#include <boost/assert.hpp>
+#include <cstddef> // NULL
+
+#include <boost/config.hpp> // msvc needs this to suppress warning
+
+#include <cstring>
+#if defined(BOOST_NO_STDC_NAMESPACE)
+namespace std{ using ::strcmp; }
+#endif
+
+#include <boost/detail/no_exceptions_support.hpp>
+#include <boost/serialization/singleton.hpp>
+#include <boost/serialization/force_include.hpp>
+
+#define BOOST_SERIALIZATION_SOURCE
+#include <boost/serialization/extended_type_info.hpp>
+
+#ifdef BOOST_MSVC
+# pragma warning(push)
+# pragma warning(disable : 4511 4512)
+#endif
+
+namespace boost {
+namespace serialization {
+namespace detail {
+
+struct key_compare
+{
+ bool
+ operator()(
+ const extended_type_info * lhs,
+ const extended_type_info * rhs
+ ) const {
+ // performance shortcut
+ if(lhs == rhs)
+ return false;
+ const char * l = lhs->get_key();
+ BOOST_ASSERT(NULL != l);
+ const char * r = rhs->get_key();
+ BOOST_ASSERT(NULL != r);
+ // performance shortcut
+ // shortcut to exploit string pooling
+ if(l == r)
+ return false;
+ // for exported types, use the string key so that
+ // multiple instances in different translation units
+ // can be matched up
+ return std::strcmp(l, r) < 0;
+ }
+};
+
+typedef std::multiset<const extended_type_info *, key_compare> ktmap;
+
+#ifdef BOOST_MSVC
+# pragma warning(push)
+# pragma warning(disable : 4511 4512)
+#endif
+
+class extended_type_info_arg : public extended_type_info
+{
+ virtual bool
+ is_less_than(const extended_type_info & /*rhs*/) const {
+ BOOST_ASSERT(false);
+ return false;
+ };
+ virtual bool
+ is_equal(const extended_type_info & /*rhs*/) const {
+ BOOST_ASSERT(false);
+ return false;
+ };
+ virtual const char * get_debug_info() const {
+ return get_key();
+ }
+ virtual void * construct(unsigned int /*count*/, ...) const{
+ BOOST_ASSERT(false);
+ return NULL;
+ }
+ virtual void destroy(void const * const /*p*/) const {
+ BOOST_ASSERT(false);
+ }
+public:
+ extended_type_info_arg(const char * key) :
+ extended_type_info(0, key)
+ {}
+
+ ~extended_type_info_arg(){
+ }
+};
+
+#ifdef BOOST_MSVC
+# pragma warning(pop)
+#endif
+
+} // namespace detail
+
+BOOST_SERIALIZATION_DECL(void)
+extended_type_info::key_register() const{
+ if(NULL == get_key())
+ return;
+ singleton<detail::ktmap>::get_mutable_instance().insert(this);
+}
+
+BOOST_SERIALIZATION_DECL(void)
+extended_type_info::key_unregister() const{
+ if(NULL == get_key())
+ return;
+ if(! singleton<detail::ktmap>::is_destroyed()){
+ detail::ktmap & x = singleton<detail::ktmap>::get_mutable_instance();
+ detail::ktmap::iterator start = x.lower_bound(this);
+ detail::ktmap::iterator end = x.upper_bound(this);
+ // remove entry in map which corresponds to this type
+ for(;start != end; ++start){
+ if(this == *start){
+ x.erase(start);
+ break;
+ }
+ }
+ }
+}
+
+BOOST_SERIALIZATION_DECL(const extended_type_info *)
+extended_type_info::find(const char *key) {
+ BOOST_ASSERT(NULL != key);
+ const detail::ktmap & k = singleton<detail::ktmap>::get_const_instance();
+ const detail::extended_type_info_arg eti_key(key);
+ const detail::ktmap::const_iterator it = k.find(& eti_key);
+ if(k.end() == it)
+ return NULL;
+ return *(it);
+}
+
+BOOST_SERIALIZATION_DECL(BOOST_PP_EMPTY())
+extended_type_info::extended_type_info(
+ const unsigned int type_info_key,
+ const char * key
+) :
+ m_type_info_key(type_info_key),
+ m_key(key)
+{
+}
+
+BOOST_SERIALIZATION_DECL(BOOST_PP_EMPTY())
+extended_type_info::~extended_type_info(){
+}
+
+BOOST_SERIALIZATION_DECL(bool)
+extended_type_info::operator<(const extended_type_info &rhs) const {
+ // short cut for a common cases
+ if(this == & rhs)
+ return false;
+ if(m_type_info_key == rhs.m_type_info_key){
+ return is_less_than(rhs);
+ }
+ if(m_type_info_key < rhs.m_type_info_key)
+ return true;
+ return false;
+}
+
+BOOST_SERIALIZATION_DECL(bool)
+extended_type_info::operator==(const extended_type_info &rhs) const {
+ // short cut for a common cases
+ if(this == & rhs)
+ return true;
+ if(m_type_info_key != rhs.m_type_info_key){
+ return false;
+ }
+ return is_equal(rhs);
+}
+
+} // namespace serialization
+} // namespace boost
diff --git a/3rdParty/Boost/src/libs/serialization/src/extended_type_info_no_rtti.cpp b/3rdParty/Boost/src/libs/serialization/src/extended_type_info_no_rtti.cpp
new file mode 100644
index 0000000..3b2a888
--- /dev/null
+++ b/3rdParty/Boost/src/libs/serialization/src/extended_type_info_no_rtti.cpp
@@ -0,0 +1,85 @@
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// extended_type_info_no_rtti.cpp: specific implementation of type info
+// that is NOT based on typeid
+
+// (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>
+#include <cstddef> // NULL
+#include <boost/assert.hpp>
+
+#include <boost/config.hpp>
+#if defined(BOOST_NO_STDC_NAMESPACE)
+namespace std{ using ::strcmp; }
+#endif
+
+#define BOOST_SERIALIZATION_SOURCE
+#include <boost/serialization/extended_type_info_no_rtti.hpp>
+
+#define EXTENDED_TYPE_INFO_NO_RTTI_KEY 2
+
+namespace boost {
+namespace serialization {
+namespace no_rtti_system {
+
+BOOST_SERIALIZATION_DECL(BOOST_PP_EMPTY())
+extended_type_info_no_rtti_0::extended_type_info_no_rtti_0(
+ const char * key
+) :
+ extended_type_info(EXTENDED_TYPE_INFO_NO_RTTI_KEY, key)
+{}
+
+BOOST_SERIALIZATION_DECL(bool)
+extended_type_info_no_rtti_0::is_less_than(
+ const boost::serialization::extended_type_info &rhs) const
+{
+ // shortcut for common case
+ if(this == & rhs)
+ return false;
+ const char * l = get_key();
+ const char * r = rhs.get_key();
+ // if this assertion is triggered, it could mean one of the following
+ // a) This class was never exported - make sure all calls which use
+ // this method of type id are in fact exported.
+ // b) This class was used (e.g. serialized through a pointer) before
+ // it was exported. Make sure that classes which use this method
+ // of type id are NOT "automatically" registered by serializating
+ // through a pointer to the to most derived class. OR make sure
+ // that the BOOST_CLASS_EXPORT is included in every file
+ // which does this.
+ BOOST_ASSERT(NULL != l);
+ BOOST_ASSERT(NULL != r);
+ return std::strcmp(l, r) < 0;
+}
+
+BOOST_SERIALIZATION_DECL(bool)
+extended_type_info_no_rtti_0::is_equal(
+ const boost::serialization::extended_type_info &rhs) const
+{
+ // shortcut for common case
+ if(this == & rhs)
+ return true;
+ // null keys don't match with anything
+ const char * l = get_key();
+ BOOST_ASSERT(NULL != l);
+ if(NULL == l)
+ return false;
+ const char * r = rhs.get_key();
+ BOOST_ASSERT(NULL != r);
+ if(NULL == r)
+ return false;
+ return 0 == std::strcmp(l, r);
+}
+
+BOOST_SERIALIZATION_DECL(BOOST_PP_EMPTY())
+extended_type_info_no_rtti_0::~extended_type_info_no_rtti_0()
+{}
+
+} // namespece detail
+} // namespace serialization
+} // namespace boost
diff --git a/3rdParty/Boost/src/libs/serialization/src/extended_type_info_typeid.cpp b/3rdParty/Boost/src/libs/serialization/src/extended_type_info_typeid.cpp
new file mode 100644
index 0000000..463287a
--- /dev/null
+++ b/3rdParty/Boost/src/libs/serialization/src/extended_type_info_typeid.cpp
@@ -0,0 +1,161 @@
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// extended_type_info_typeid.cpp: specific implementation of type info
+// that is based on typeid
+
+// (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 <algorithm>
+#include <set>
+#include <boost/assert.hpp>
+#include <typeinfo>
+#include <cstddef> // NULL
+
+#include <boost/detail/no_exceptions_support.hpp>
+
+#include <boost/serialization/singleton.hpp>
+
+#define BOOST_SERIALIZATION_SOURCE
+#include <boost/serialization/extended_type_info_typeid.hpp>
+
+namespace boost {
+namespace serialization {
+namespace typeid_system {
+
+#define EXTENDED_TYPE_INFO_TYPE_KEY 1
+
+struct type_compare
+{
+ bool
+ operator()(
+ const extended_type_info_typeid_0 * lhs,
+ const extended_type_info_typeid_0 * rhs
+ ) const {
+ return lhs->is_less_than(*rhs);
+ }
+};
+
+typedef std::multiset<
+ const extended_type_info_typeid_0 *,
+ type_compare
+> tkmap;
+
+BOOST_SERIALIZATION_DECL(bool)
+extended_type_info_typeid_0::is_less_than(
+ const boost::serialization::extended_type_info & rhs
+) const {
+ // shortcut for common case
+ if(this == & rhs)
+ return false;
+ return 0 != m_ti->before(
+ *(static_cast<const extended_type_info_typeid_0 &>(rhs).m_ti)
+ );
+}
+
+BOOST_SERIALIZATION_DECL(bool)
+extended_type_info_typeid_0::is_equal(
+ const boost::serialization::extended_type_info & rhs
+) const {
+ return
+ // note: std::type_info == operator returns an int !!!
+ // the following permits conversion to bool without a warning.
+ ! (
+ * m_ti
+ != *(static_cast<const extended_type_info_typeid_0 &>(rhs).m_ti)
+ )
+ ;
+}
+
+BOOST_SERIALIZATION_DECL(BOOST_PP_EMPTY())
+extended_type_info_typeid_0::extended_type_info_typeid_0(
+ const char * key
+) :
+ extended_type_info(EXTENDED_TYPE_INFO_TYPE_KEY, key),
+ m_ti(NULL)
+{}
+
+BOOST_SERIALIZATION_DECL(BOOST_PP_EMPTY())
+extended_type_info_typeid_0::~extended_type_info_typeid_0()
+{}
+
+BOOST_SERIALIZATION_DECL(void)
+extended_type_info_typeid_0::type_register(const std::type_info & ti){
+ m_ti = & ti;
+ singleton<tkmap>::get_mutable_instance().insert(this);
+}
+
+BOOST_SERIALIZATION_DECL(void)
+extended_type_info_typeid_0::type_unregister()
+{
+ if(NULL != m_ti){
+ if(! singleton<tkmap>::is_destroyed()){
+ tkmap & x = singleton<tkmap>::get_mutable_instance();
+ tkmap::iterator start = x.lower_bound(this);
+ tkmap::iterator end = x.upper_bound(this);
+ BOOST_ASSERT(start != end);
+
+ // remove entry in map which corresponds to this type
+ do{
+ if(this == *start)
+ x.erase(start++);
+ else
+ ++start;
+ }while(start != end);
+ }
+ }
+ m_ti = NULL;
+}
+
+#ifdef BOOST_MSVC
+# pragma warning(push)
+# pragma warning(disable : 4511 4512)
+#endif
+
+// this derivation is used for creating search arguments
+class extended_type_info_typeid_arg :
+ public extended_type_info_typeid_0
+{
+ virtual void * construct(unsigned int /*count*/, ...) const{
+ BOOST_ASSERT(false);
+ return NULL;
+ }
+ virtual void destroy(void const * const /*p*/) const {
+ BOOST_ASSERT(false);
+ }
+public:
+ extended_type_info_typeid_arg(const std::type_info & ti) :
+ extended_type_info_typeid_0(NULL)
+ {
+ // note absense of self register and key as this is used only as
+ // search argument given a type_info reference and is not to
+ // be added to the map.
+ m_ti = & ti;
+ }
+ ~extended_type_info_typeid_arg(){
+ m_ti = NULL;
+ }
+};
+
+#ifdef BOOST_MSVC
+# pragma warning(pop)
+#endif
+
+BOOST_SERIALIZATION_DECL(const extended_type_info *)
+extended_type_info_typeid_0::get_extended_type_info(
+ const std::type_info & ti
+) const {
+ typeid_system::extended_type_info_typeid_arg etia(ti);
+ const tkmap & t = singleton<tkmap>::get_const_instance();
+ const tkmap::const_iterator it = t.find(& etia);
+ if(t.end() == it)
+ return NULL;
+ return *(it);
+}
+
+} // namespace detail
+} // namespace serialization
+} // namespace boost
diff --git a/3rdParty/Boost/src/libs/serialization/src/polymorphic_iarchive.cpp b/3rdParty/Boost/src/libs/serialization/src/polymorphic_iarchive.cpp
new file mode 100644
index 0000000..5e8c986
--- /dev/null
+++ b/3rdParty/Boost/src/libs/serialization/src/polymorphic_iarchive.cpp
@@ -0,0 +1,29 @@
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// polymorphic_iarchive.cpp:
+
+// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
+// Use, modification and distribution is subject to the Boost Software
+// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+
+// See http://www.boost.org for updates, documentation, and revision history.
+
+#if (defined _MSC_VER) && (_MSC_VER == 1200)
+# pragma warning (disable : 4786) // too long name, harmless warning
+#endif
+
+#define BOOST_ARCHIVE_SOURCE
+#include <boost/archive/detail/archive_serializer_map.hpp>
+
+#include <boost/archive/impl/archive_serializer_map.ipp>
+#include <boost/archive/polymorphic_iarchive.hpp>
+
+namespace boost {
+namespace archive {
+namespace detail {
+
+template class archive_serializer_map<polymorphic_iarchive>;
+
+} // detail
+} // archive
+} // boost
diff --git a/3rdParty/Boost/src/libs/serialization/src/polymorphic_oarchive.cpp b/3rdParty/Boost/src/libs/serialization/src/polymorphic_oarchive.cpp
new file mode 100644
index 0000000..b85895e
--- /dev/null
+++ b/3rdParty/Boost/src/libs/serialization/src/polymorphic_oarchive.cpp
@@ -0,0 +1,29 @@
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// polymorphic_oarchive.cpp:
+
+// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
+// Use, modification and distribution is subject to the Boost Software
+// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+
+// See http://www.boost.org for updates, documentation, and revision history.
+
+#if (defined _MSC_VER) && (_MSC_VER == 1200)
+# pragma warning (disable : 4786) // too long name, harmless warning
+#endif
+
+#define BOOST_ARCHIVE_SOURCE
+#include <boost/archive/detail/archive_serializer_map.hpp>
+
+#include <boost/archive/impl/archive_serializer_map.ipp>
+#include <boost/archive/polymorphic_oarchive.hpp>
+
+namespace boost {
+namespace archive {
+namespace detail {
+
+template class archive_serializer_map<polymorphic_oarchive>;
+
+} // detail
+} // archive
+} // boost
diff --git a/3rdParty/Boost/src/libs/serialization/src/shared_ptr_helper.cpp b/3rdParty/Boost/src/libs/serialization/src/shared_ptr_helper.cpp
new file mode 100644
index 0000000..b155cd9
--- /dev/null
+++ b/3rdParty/Boost/src/libs/serialization/src/shared_ptr_helper.cpp
@@ -0,0 +1,138 @@
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+# pragma once
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// shared_ptr_helper.hpp: serialization for boost shared pointern
+
+// (C) Copyright 2004-2009 Robert Ramey, Martin Ecker and Takatoshi Kondo
+// 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 <map>
+#include <list>
+#include <utility>
+#include <cstddef> // NULL
+
+#define BOOST_ARCHIVE_SOURCE
+// include this to prevent linker errors when the
+// same modules are marked export and import.
+#define BOOST_SERIALIZATION_SOURCE
+
+#include <boost/serialization/throw_exception.hpp>
+#include <boost/serialization/void_cast.hpp>
+#include <boost/serialization/extended_type_info.hpp>
+#include <boost/archive/shared_ptr_helper.hpp>
+#include <boost/archive/archive_exception.hpp>
+
+namespace boost {
+namespace archive{
+namespace detail {
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// a common class for holding various types of shared pointers
+
+// returns pointer to object and an indicator whether this is a
+// new entry (true) or a previous one (false)
+BOOST_ARCHIVE_DECL(shared_ptr<void>)
+shared_ptr_helper::get_od(
+ const void * t,
+ const boost::serialization::extended_type_info * true_type,
+ const boost::serialization::extended_type_info * this_type
+){
+ // get void pointer to the most derived type
+ // this uniquely identifies the object referred to
+ const void * od = void_downcast(
+ *true_type,
+ *this_type,
+ t
+ );
+ if(NULL == od)
+ boost::serialization::throw_exception(
+ archive_exception(
+ archive_exception::unregistered_cast,
+ true_type->get_debug_info(),
+ this_type->get_debug_info()
+ )
+ );
+
+ // make tracking array if necessary
+ if(NULL == m_pointers)
+ m_pointers = new collection_type;
+
+ //shared_ptr<const void> sp(od, null_deleter());
+ shared_ptr<const void> sp(od, null_deleter());
+ collection_type::iterator i = m_pointers->find(sp);
+
+ if(i == m_pointers->end()){
+ shared_ptr<void> np;
+ return np;
+ }
+ od = void_upcast(
+ *true_type,
+ *this_type,
+ i->get()
+ );
+ if(NULL == od)
+ boost::serialization::throw_exception(
+ archive_exception(
+ archive_exception::unregistered_cast,
+ true_type->get_debug_info(),
+ this_type->get_debug_info()
+ )
+ );
+
+ return shared_ptr<void>(
+ const_pointer_cast<void>(*i),
+ const_cast<void *>(od)
+ );
+}
+
+BOOST_ARCHIVE_DECL(void)
+shared_ptr_helper::append(const boost::shared_ptr<const void> &sp){
+ // make tracking array if necessary
+ if(NULL == m_pointers)
+ m_pointers = new collection_type;
+
+ collection_type::iterator i = m_pointers->find(sp);
+
+ if(i == m_pointers->end()){
+ std::pair<collection_type::iterator, bool> result;
+ result = m_pointers->insert(sp);
+ BOOST_ASSERT(result.second);
+ }
+}
+
+// #ifdef BOOST_SERIALIZATION_SHARED_PTR_132_HPP
+BOOST_ARCHIVE_DECL(void)
+shared_ptr_helper::append(const boost_132::shared_ptr<const void> & t){
+ if(NULL == m_pointers_132)
+ m_pointers_132 = new std::list<boost_132::shared_ptr<const void> >;
+ m_pointers_132->push_back(t);
+}
+// #endif
+BOOST_ARCHIVE_DECL(BOOST_PP_EMPTY())
+shared_ptr_helper::shared_ptr_helper() :
+ m_pointers(NULL)
+ #ifdef BOOST_SERIALIZATION_SHARED_PTR_132_HPP
+ , m_pointers_132(NULL)
+ #endif
+{}
+BOOST_ARCHIVE_DECL(BOOST_PP_EMPTY())
+shared_ptr_helper::~shared_ptr_helper(){
+ if(NULL != m_pointers)
+ delete m_pointers;
+ #ifdef BOOST_SERIALIZATION_SHARED_PTR_132_HPP
+ if(NULL != m_pointers_132)
+ delete m_pointers_132;
+ #endif
+}
+
+} // namespace detail
+} // namespace serialization
+} // namespace boost
+
diff --git a/3rdParty/Boost/src/libs/serialization/src/stl_port.cpp b/3rdParty/Boost/src/libs/serialization/src/stl_port.cpp
new file mode 100644
index 0000000..e5378bc
--- /dev/null
+++ b/3rdParty/Boost/src/libs/serialization/src/stl_port.cpp
@@ -0,0 +1,43 @@
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// stl_port.cpp: implementation of run-time casting of void pointers
+
+// (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.
+
+#if (defined _MSC_VER) && (_MSC_VER == 1200)
+# pragma warning (disable : 4786) // too long name, harmless warning
+#endif
+
+// this befuddles the msvc 6 compiler so we can't use it
+#if ! ((defined _MSC_VER) && (_MSC_VER <= 1300)) \
+&& ! defined(__BORLANDC__)
+
+#include <boost/config.hpp>
+
+#if defined(__SGI_STL_PORT) && (__SGI_STL_PORT < 0x500)
+
+#include <boost/archive/codecvt_null.hpp>
+
+// explicit instantiation
+
+namespace std {
+
+template
+locale::locale(
+ const locale& __loc, boost::archive::codecvt_null<char> * __f
+);
+
+template
+locale::locale(
+ const locale& __loc, boost::archive::codecvt_null<wchar_t> * __f
+);
+
+} // namespace std
+
+#endif
+
+#endif
diff --git a/3rdParty/Boost/src/libs/serialization/src/text_iarchive.cpp b/3rdParty/Boost/src/libs/serialization/src/text_iarchive.cpp
new file mode 100644
index 0000000..cb9017f
--- /dev/null
+++ b/3rdParty/Boost/src/libs/serialization/src/text_iarchive.cpp
@@ -0,0 +1,36 @@
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// text_iarchive.cpp:
+
+// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
+// Use, modification and distribution is subject to the Boost Software
+// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+
+// See http://www.boost.org for updates, documentation, and revision history.
+
+#if (defined _MSC_VER) && (_MSC_VER == 1200)
+# pragma warning (disable : 4786) // too long name, harmless warning
+#endif
+
+#define BOOST_ARCHIVE_SOURCE
+#include <boost/archive/text_iarchive.hpp>
+#include <boost/archive/detail/archive_serializer_map.hpp>
+
+// explicitly instantiate for this type of text stream
+#include <boost/archive/impl/archive_serializer_map.ipp>
+#include <boost/archive/impl/basic_text_iarchive.ipp>
+#include <boost/archive/impl/text_iarchive_impl.ipp>
+
+namespace boost {
+namespace archive {
+
+template class detail::archive_serializer_map<naked_text_iarchive>;
+template class basic_text_iarchive<naked_text_iarchive> ;
+template class text_iarchive_impl<naked_text_iarchive> ;
+
+template class detail::archive_serializer_map<text_iarchive>;
+template class basic_text_iarchive<text_iarchive> ;
+template class text_iarchive_impl<text_iarchive> ;
+
+} // namespace archive
+} // namespace boost
diff --git a/3rdParty/Boost/src/libs/serialization/src/text_oarchive.cpp b/3rdParty/Boost/src/libs/serialization/src/text_oarchive.cpp
new file mode 100644
index 0000000..19165d6
--- /dev/null
+++ b/3rdParty/Boost/src/libs/serialization/src/text_oarchive.cpp
@@ -0,0 +1,33 @@
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// text_oarchive.cpp:
+
+// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
+// Use, modification and distribution is subject to the Boost Software
+// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+
+// See http://www.boost.org for updates, documentation, and revision history.
+
+#if (defined _MSC_VER) && (_MSC_VER == 1200)
+# pragma warning (disable : 4786) // too long name, harmless warning
+#endif
+
+#define BOOST_ARCHIVE_SOURCE
+#include <boost/archive/text_oarchive.hpp>
+#include <boost/archive/detail/archive_serializer_map.hpp>
+
+// explicitly instantiate for this type of text stream
+#include <boost/archive/impl/archive_serializer_map.ipp>
+#include <boost/archive/impl/basic_text_oarchive.ipp>
+#include <boost/archive/impl/text_oarchive_impl.ipp>
+
+namespace boost {
+namespace archive {
+
+//template class basic_text_oprimitive<std::ostream> ;
+template class detail::archive_serializer_map<text_oarchive>;
+template class basic_text_oarchive<text_oarchive> ;
+template class text_oarchive_impl<text_oarchive> ;
+
+} // namespace serialization
+} // namespace boost
diff --git a/3rdParty/Boost/src/libs/serialization/src/text_wiarchive.cpp b/3rdParty/Boost/src/libs/serialization/src/text_wiarchive.cpp
new file mode 100644
index 0000000..a6630c0
--- /dev/null
+++ b/3rdParty/Boost/src/libs/serialization/src/text_wiarchive.cpp
@@ -0,0 +1,41 @@
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// text_wiarchive.cpp:
+
+// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
+// Use, modification and distribution is subject to the Boost Software
+// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+
+// See http://www.boost.org for updates, documentation, and revision history.
+
+#include <boost/config.hpp>
+
+#ifdef BOOST_NO_STD_WSTREAMBUF
+#error "wide char i/o not supported on this platform"
+#else
+
+#define BOOST_WARCHIVE_SOURCE
+#include <boost/archive/text_wiarchive.hpp>
+#include <boost/archive/detail/archive_serializer_map.hpp>
+
+// explicitly instantiate for this type of text stream
+#include <boost/archive/impl/archive_serializer_map.ipp>
+#include <boost/archive/impl/basic_text_iarchive.ipp>
+#include <boost/archive/impl/text_wiarchive_impl.ipp>
+
+namespace boost {
+namespace archive {
+
+template class detail::archive_serializer_map<naked_text_wiarchive>;
+template class basic_text_iarchive<naked_text_wiarchive> ;
+template class text_wiarchive_impl<naked_text_wiarchive> ;
+
+template class detail::archive_serializer_map<text_wiarchive>;
+template class basic_text_iarchive<text_wiarchive> ;
+template class text_wiarchive_impl<text_wiarchive> ;
+
+} // namespace archive
+} // namespace boost
+
+#endif // BOOST_NO_STD_WSTREAMBUF
+
diff --git a/3rdParty/Boost/src/libs/serialization/src/text_woarchive.cpp b/3rdParty/Boost/src/libs/serialization/src/text_woarchive.cpp
new file mode 100644
index 0000000..54b4a0d
--- /dev/null
+++ b/3rdParty/Boost/src/libs/serialization/src/text_woarchive.cpp
@@ -0,0 +1,35 @@
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// text_woarchive.cpp:
+
+// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
+// Use, modification and distribution is subject to the Boost Software
+// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+
+// See http://www.boost.org for updates, documentation, and revision history.
+
+#include <boost/config.hpp>
+#ifdef BOOST_NO_STD_WSTREAMBUF
+#error "wide char i/o not supported on this platform"
+#else
+
+#define BOOST_WARCHIVE_SOURCE
+#include <boost/archive/text_woarchive.hpp>
+#include <boost/archive/detail/archive_serializer_map.hpp>
+
+// explicitly instantiate for this type of text stream
+#include <boost/archive/impl/archive_serializer_map.ipp>
+#include <boost/archive/impl/basic_text_oarchive.ipp>
+#include <boost/archive/impl/text_woarchive_impl.ipp>
+
+namespace boost {
+namespace archive {
+
+template class detail::archive_serializer_map<text_woarchive>;
+template class basic_text_oarchive<text_woarchive> ;
+template class text_woarchive_impl<text_woarchive> ;
+
+} // namespace archive
+} // namespace boost
+
+#endif // BOOST_NO_STD_WSTREAMBUF
diff --git a/3rdParty/Boost/src/libs/serialization/src/utf8_codecvt_facet.cpp b/3rdParty/Boost/src/libs/serialization/src/utf8_codecvt_facet.cpp
new file mode 100644
index 0000000..d064c63
--- /dev/null
+++ b/3rdParty/Boost/src/libs/serialization/src/utf8_codecvt_facet.cpp
@@ -0,0 +1,21 @@
+// Copyright Vladimir Prus 2004.
+// 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>
+#ifdef BOOST_NO_STD_WSTREAMBUF
+#error "wide char i/o not supported on this platform"
+#else
+
+#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.ipp>
+#undef BOOST_UTF8_END_NAMESPACE
+#undef BOOST_UTF8_DECL
+#undef BOOST_UTF8_BEGIN_NAMESPACE
+
+#endif // BOOST_NO_STD_WSTREAMBUF
+
diff --git a/3rdParty/Boost/src/libs/serialization/src/void_cast.cpp b/3rdParty/Boost/src/libs/serialization/src/void_cast.cpp
new file mode 100644
index 0000000..df31235
--- /dev/null
+++ b/3rdParty/Boost/src/libs/serialization/src/void_cast.cpp
@@ -0,0 +1,360 @@
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// void_cast.cpp: implementation of run-time casting of void pointers
+
+// (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)
+// <gennadiy.rozental@tfn.com>
+
+// See http://www.boost.org for updates, documentation, and revision history.
+
+#if (defined _MSC_VER) && (_MSC_VER == 1200)
+# pragma warning (disable : 4786) // too long name, harmless warning
+#endif
+
+#include <boost/assert.hpp>
+#include <cstddef> // NULL
+#ifdef BOOST_SERIALIZATION_LOG
+#include <iostream>
+#endif
+
+// STL
+#include <set>
+#include <functional>
+#include <algorithm>
+#include <boost/assert.hpp>
+
+// BOOST
+#define BOOST_SERIALIZATION_SOURCE
+#include <boost/serialization/singleton.hpp>
+#include <boost/serialization/extended_type_info.hpp>
+#include <boost/serialization/void_cast.hpp>
+
+namespace boost {
+namespace serialization {
+namespace void_cast_detail {
+
+// note that void_casters are keyed on value of
+// member extended type info records - NOT their
+// addresses. This is necessary in order for the
+// void cast operations to work across dll and exe
+// module boundries.
+bool void_caster::operator<(const void_caster & rhs) const {
+ // include short cut to save time and eliminate
+ // problems when when base class aren't virtual
+ if(m_derived != rhs.m_derived){
+ if(*m_derived < *rhs.m_derived)
+ return true;
+ if(*rhs.m_derived < *m_derived)
+ return false;
+ }
+ // m_derived == rhs.m_derived
+ if(m_base != rhs.m_base)
+ return *m_base < *rhs.m_base;
+ else
+ return false;
+}
+
+struct void_caster_compare {
+ bool operator()(const void_caster * lhs, const void_caster * rhs) const {
+ return *lhs < *rhs;
+ }
+};
+
+typedef std::set<const void_caster *, void_caster_compare> set_type;
+typedef boost::serialization::singleton<set_type> void_caster_registry;
+
+#ifdef BOOST_MSVC
+# pragma warning(push)
+# pragma warning(disable : 4511 4512)
+#endif
+
+// implementation of shortcut void caster
+class void_caster_shortcut : public void_caster
+{
+ bool m_includes_virtual_base;
+
+ void const *
+ vbc_upcast(
+ void const * const t
+ ) const;
+ void const *
+ vbc_downcast(
+ void const * const t
+ ) const;
+ virtual void const *
+ upcast(void const * const t) const{
+ if(m_includes_virtual_base)
+ return vbc_upcast(t);
+ return static_cast<const char *> ( t ) - m_difference;
+ }
+ virtual void const *
+ downcast(void const * const t) const{
+ if(m_includes_virtual_base)
+ return vbc_downcast(t);
+ return static_cast<const char *> ( t ) + m_difference;
+ }
+ virtual bool is_shortcut() const {
+ return true;
+ }
+ virtual bool has_virtual_base() const {
+ return m_includes_virtual_base;
+ }
+public:
+ void_caster_shortcut(
+ extended_type_info const * derived,
+ extended_type_info const * base,
+ std::ptrdiff_t difference,
+ bool includes_virtual_base,
+ void_caster const * const parent
+ ) :
+ void_caster(derived, base, difference, parent),
+ m_includes_virtual_base(includes_virtual_base)
+ {
+ recursive_register(includes_virtual_base);
+ }
+ virtual ~void_caster_shortcut(){
+ recursive_unregister();
+ }
+};
+
+#ifdef BOOST_MSVC
+# pragma warning(pop)
+#endif
+
+void const *
+void_caster_shortcut::vbc_downcast(
+ void const * const t
+) const {
+ // try to find a chain that gives us what we want
+ const void_cast_detail::set_type & s
+ = void_cast_detail::void_caster_registry::get_const_instance();
+ void_cast_detail::set_type::const_iterator it;
+ for(it = s.begin(); it != s.end(); ++it){
+ // if the current candidate casts to the desired target type
+ if ((*it)->m_derived == m_derived){
+ // and if it's not us
+ if ((*it)->m_base != m_base){
+ // try to cast from the candidate base to our base
+ const void * t_new;
+ t_new = void_downcast(*(*it)->m_base, *m_base, t);
+ // if we were successful
+ if(NULL != t_new){
+ // recast to our derived
+ const void_caster * vc = *it;
+ return vc->downcast(t_new);
+ }
+ }
+ }
+ }
+ return NULL;
+}
+
+void const *
+void_caster_shortcut::vbc_upcast(
+ void const * const t
+) const {
+ // try to find a chain that gives us what we want
+ const void_cast_detail::set_type & s
+ = void_cast_detail::void_caster_registry::get_const_instance();
+ void_cast_detail::set_type::const_iterator it;
+ for(it = s.begin(); it != s.end(); ++it){
+ // if the current candidate casts from the desired base type
+ if((*it)->m_base == m_base){
+ // and if it's not us
+ if ((*it)->m_derived != m_derived){
+ // try to cast from the candidate derived to our our derived
+ const void * t_new;
+ t_new = void_upcast(*m_derived, *(*it)->m_derived, t);
+ if(NULL != t_new)
+ return (*it)->upcast(t_new);
+ }
+ }
+ }
+ return NULL;
+}
+
+#ifdef BOOST_MSVC
+# pragma warning(push)
+# pragma warning(disable : 4511 4512)
+#endif
+
+// just used as a search key
+class void_caster_argument : public void_caster
+{
+ virtual void const *
+ upcast(void const * const /*t*/) const {
+ BOOST_ASSERT(false);
+ return NULL;
+ }
+ virtual void const *
+ downcast( void const * const /*t*/) const {
+ BOOST_ASSERT(false);
+ return NULL;
+ }
+ virtual bool has_virtual_base() const {
+ BOOST_ASSERT(false);
+ return false;
+ }
+public:
+ void_caster_argument(
+ extended_type_info const * derived,
+ extended_type_info const * base
+ ) :
+ void_caster(derived, base)
+ {}
+ virtual ~void_caster_argument(){};
+};
+
+#ifdef BOOST_MSVC
+# pragma warning(pop)
+#endif
+
+// implementation of void caster base class
+BOOST_SERIALIZATION_DECL(void)
+void_caster::recursive_register(bool includes_virtual_base) const {
+ void_cast_detail::set_type & s
+ = void_cast_detail::void_caster_registry::get_mutable_instance();
+
+ #ifdef BOOST_SERIALIZATION_LOG
+ std::clog << "recursive_register\n";
+ std::clog << m_derived->get_debug_info();
+ std::clog << "<-";
+ std::clog << m_base->get_debug_info();
+ std::clog << "\n";
+ #endif
+
+ std::pair<void_cast_detail::set_type::const_iterator, bool> result;
+ // comment this out for now.
+ result = s.insert(this);
+ //assert(result.second);
+
+ // generate all implied void_casts.
+ void_cast_detail::set_type::const_iterator it;
+ for(it = s.begin(); it != s.end(); ++it){
+ if(* m_derived == * (*it)->m_base){
+ const void_caster_argument vca(
+ (*it)->m_derived,
+ m_base
+ );
+ void_cast_detail::set_type::const_iterator i;
+ i = s.find(& vca);
+ if(i == s.end()){
+ new void_caster_shortcut(
+ (*it)->m_derived,
+ m_base,
+ m_difference + (*it)->m_difference,
+ (*it)->has_virtual_base() || includes_virtual_base,
+ this
+ );
+ }
+ }
+ if(* (*it)->m_derived == * m_base){
+ const void_caster_argument vca(
+ m_derived,
+ (*it)->m_base
+ );
+ void_cast_detail::set_type::const_iterator i;
+ i = s.find(& vca);
+ if(i == s.end()){
+ new void_caster_shortcut(
+ m_derived,
+ (*it)->m_base,
+ m_difference + (*it)->m_difference,
+ (*it)->has_virtual_base() || includes_virtual_base,
+ this
+ );
+ }
+ }
+ }
+}
+
+BOOST_SERIALIZATION_DECL(void)
+void_caster::recursive_unregister() const {
+ if(void_caster_registry::is_destroyed())
+ return;
+
+ #ifdef BOOST_SERIALIZATION_LOG
+ std::clog << "recursive_unregister\n";
+ std::clog << m_derived->get_debug_info();
+ std::clog << "<-";
+ std::clog << m_base->get_debug_info();
+ std::clog << "\n";
+ #endif
+
+ void_cast_detail::set_type & s
+ = void_caster_registry::get_mutable_instance();
+
+ // delete all shortcuts which use this primitive
+ void_cast_detail::set_type::iterator it;
+ for(it = s.begin(); it != s.end();){
+ const void_caster * vc = *it;
+ if(vc == this){
+ s.erase(it++);
+ }
+ else
+ if(vc->m_parent == this){
+ s.erase(it);
+ delete vc;
+ it = s.begin();
+ }
+ else
+ it++;
+ }
+}
+
+} // namespace void_cast_detail
+
+// Given a void *, assume that it really points to an instance of one type
+// and alter it so that it would point to an instance of a related type.
+// Return the altered pointer. If there exists no sequence of casts that
+// can transform from_type to to_type, return a NULL.
+BOOST_SERIALIZATION_DECL(void const *)
+void_upcast(
+ extended_type_info const & derived,
+ extended_type_info const & base,
+ void const * const t
+){
+ // same types - trivial case
+ if (derived == base)
+ return t;
+
+ // check to see if base/derived pair is found in the registry
+ const void_cast_detail::set_type & s
+ = void_cast_detail::void_caster_registry::get_const_instance();
+ const void_cast_detail::void_caster_argument ca(& derived, & base);
+
+ void_cast_detail::set_type::const_iterator it;
+ it = s.find(& ca);
+ if (s.end() != it)
+ return (*it)->upcast(t);
+
+ return NULL;
+}
+
+BOOST_SERIALIZATION_DECL(void const *)
+void_downcast(
+ extended_type_info const & derived,
+ extended_type_info const & base,
+ void const * const t
+){
+ // same types - trivial case
+ if (derived == base)
+ return t;
+
+ // check to see if base/derived pair is found in the registry
+ const void_cast_detail::set_type & s
+ = void_cast_detail::void_caster_registry::get_const_instance();
+ const void_cast_detail::void_caster_argument ca(& derived, & base);
+
+ void_cast_detail::set_type::const_iterator it;
+ it = s.find(&ca);
+ if (s.end() != it)
+ return(*it)->downcast(t);
+
+ return NULL;
+}
+
+} // namespace serialization
+} // namespace boost
diff --git a/3rdParty/Boost/src/libs/serialization/src/xml_archive_exception.cpp b/3rdParty/Boost/src/libs/serialization/src/xml_archive_exception.cpp
new file mode 100644
index 0000000..ea78916
--- /dev/null
+++ b/3rdParty/Boost/src/libs/serialization/src/xml_archive_exception.cpp
@@ -0,0 +1,56 @@
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// xml_archive_exception.cpp:
+
+// (C) Copyright 2009 Robert Ramey - http://www.rrsd.com .
+// Use, modification and distribution is subject to the Boost Software
+// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+
+// See http://www.boost.org for updates, documentation, and revision history.
+
+#if (defined _MSC_VER) && (_MSC_VER == 1200)
+# pragma warning (disable : 4786) // too long name, harmless warning
+#endif
+
+
+#include <exception>
+#include <boost/assert.hpp>
+#include <string>
+
+#define BOOST_ARCHIVE_SOURCE
+#include <boost/archive/xml_archive_exception.hpp>
+
+namespace boost {
+namespace archive {
+
+BOOST_ARCHIVE_DECL(BOOST_PP_EMPTY())
+xml_archive_exception::xml_archive_exception(
+ exception_code c,
+ const char * e1,
+ const char * e2
+ ) :
+ archive_exception(other_exception, e1, e2)
+ {
+ m_msg = "programming error";
+ switch(c){
+ case xml_archive_parsing_error:
+ m_msg = "unrecognized XML syntax";
+ break;
+ case xml_archive_tag_mismatch:
+ m_msg = "XML start/end tag mismatch";
+ if(NULL != e1){
+ m_msg += " - ";
+ m_msg += e1;
+ }
+ break;
+ case xml_archive_tag_name_error:
+ m_msg = "Invalid XML tag name";
+ break;
+ default:
+ BOOST_ASSERT(false);
+ break;
+ }
+ }
+
+} // archive
+} // boost
diff --git a/3rdParty/Boost/src/libs/serialization/src/xml_grammar.cpp b/3rdParty/Boost/src/libs/serialization/src/xml_grammar.cpp
new file mode 100644
index 0000000..05904f4
--- /dev/null
+++ b/3rdParty/Boost/src/libs/serialization/src/xml_grammar.cpp
@@ -0,0 +1,73 @@
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// xml_grammar.cpp:
+
+// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
+// Use, modification and distribution is subject to the Boost Software
+// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+
+// See http://www.boost.org for updates, documentation, and revision history.
+
+#if (defined _MSC_VER) && (_MSC_VER == 1200)
+# pragma warning (disable : 4786) // too long name, harmless warning
+#endif
+
+#define BOOST_ARCHIVE_SOURCE
+#include <boost/archive/impl/basic_xml_grammar.hpp>
+
+using namespace boost::spirit::classic;
+
+#include <boost/config.hpp>
+
+// fixup for borland
+// The following code will be put into Boost.Config in a later revision
+#if ! defined(__SGI_STL_PORT) \
+&& defined(BOOST_RWSTD_VER) && BOOST_RWSTD_VER<=0x020101
+#include <string>
+namespace std {
+ template<>
+ inline string &
+ string::replace (
+ char * first1,
+ char * last1,
+ const char * first2,
+ const char * last2
+ ){
+ replace(first1-begin(),last1-first1,first2,last2-first2,0,last2-first2);
+ return *this;
+ }
+} // namespace std
+#endif
+
+namespace boost {
+namespace archive {
+
+typedef basic_xml_grammar<char> xml_grammar;
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// specific definitions for char based XML
+
+template<>
+void xml_grammar::init_chset(){
+ Char = chset_t("\x9\xA\xD\x20-\x7f\x80\x81-\xFF");
+ Letter = chset_t("\x41-\x5A\x61-\x7A\xC0-\xD6\xD8-\xF6\xF8-\xFF");
+ Digit = chset_t("0-9");
+ Extender = chset_t('\xB7');
+ Sch = chset_t("\x20\x9\xD\xA");
+ NameChar = Letter | Digit | chset_p("._:-") | Extender ;
+}
+
+} // namespace archive
+} // namespace boost
+
+#include "basic_xml_grammar.ipp"
+
+namespace boost {
+namespace archive {
+
+// explicit instantiation of xml for 8 bit characters
+template class basic_xml_grammar<char>;
+
+} // namespace archive
+} // namespace boost
+
diff --git a/3rdParty/Boost/src/libs/serialization/src/xml_iarchive.cpp b/3rdParty/Boost/src/libs/serialization/src/xml_iarchive.cpp
new file mode 100644
index 0000000..6d0de77
--- /dev/null
+++ b/3rdParty/Boost/src/libs/serialization/src/xml_iarchive.cpp
@@ -0,0 +1,46 @@
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// xml_iarchive.cpp:
+
+// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
+// Use, modification and distribution is subject to the Boost Software
+// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+
+// See http://www.boost.org for updates, documentation, and revision history.
+
+#if (defined _MSC_VER) && (_MSC_VER == 1200)
+# pragma warning (disable : 4786) // too long name, harmless warning
+#endif
+
+#define BOOST_ARCHIVE_SOURCE
+
+// the following works around an issue between spirit 1.61 and borland.
+// it turns out the the certain spirit stuff must be defined before
+// certain parts of mpl. including this here makes sure that happens
+#include <boost/config.hpp>
+#include <boost/detail/workaround.hpp>
+#if BOOST_WORKAROUND(__BORLANDC__, <= 0x560 )
+#include <boost/archive/impl/basic_xml_grammar.hpp>
+#endif
+
+#include <boost/archive/xml_iarchive.hpp>
+#include <boost/archive/detail/archive_serializer_map.hpp>
+
+// explicitly instantiate for this type of xml stream
+#include <boost/archive/impl/archive_serializer_map.ipp>
+#include <boost/archive/impl/basic_xml_iarchive.ipp>
+#include <boost/archive/impl/xml_iarchive_impl.ipp>
+
+namespace boost {
+namespace archive {
+
+template class detail::archive_serializer_map<naked_xml_iarchive>;
+template class basic_xml_iarchive<naked_xml_iarchive> ;
+template class xml_iarchive_impl<naked_xml_iarchive> ;
+
+template class detail::archive_serializer_map<xml_iarchive>;
+template class basic_xml_iarchive<xml_iarchive> ;
+template class xml_iarchive_impl<xml_iarchive> ;
+
+} // namespace archive
+} // namespace boost
diff --git a/3rdParty/Boost/src/libs/serialization/src/xml_oarchive.cpp b/3rdParty/Boost/src/libs/serialization/src/xml_oarchive.cpp
new file mode 100644
index 0000000..88bcdd6
--- /dev/null
+++ b/3rdParty/Boost/src/libs/serialization/src/xml_oarchive.cpp
@@ -0,0 +1,32 @@
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// xml_oarchive.cpp:
+
+// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
+// Use, modification and distribution is subject to the Boost Software
+// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+
+// See http://www.boost.org for updates, documentation, and revision history.
+
+#if (defined _MSC_VER) && (_MSC_VER == 1200)
+# pragma warning (disable : 4786) // too long name, harmless warning
+#endif
+
+#define BOOST_ARCHIVE_SOURCE
+#include <boost/archive/xml_oarchive.hpp>
+#include <boost/archive/detail/archive_serializer_map.hpp>
+
+// explicitly instantiate for this type of xml stream
+#include <boost/archive/impl/archive_serializer_map.ipp>
+#include <boost/archive/impl/basic_xml_oarchive.ipp>
+#include <boost/archive/impl/xml_oarchive_impl.ipp>
+
+namespace boost {
+namespace archive {
+
+template class detail::archive_serializer_map<xml_oarchive>;
+template class basic_xml_oarchive<xml_oarchive> ;
+template class xml_oarchive_impl<xml_oarchive> ;
+
+} // namespace archive
+} // namespace boost
diff --git a/3rdParty/Boost/src/libs/serialization/src/xml_wgrammar.cpp b/3rdParty/Boost/src/libs/serialization/src/xml_wgrammar.cpp
new file mode 100644
index 0000000..d3dd844
--- /dev/null
+++ b/3rdParty/Boost/src/libs/serialization/src/xml_wgrammar.cpp
@@ -0,0 +1,157 @@
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// xml_wgrammar.cpp:
+
+// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
+// Use, modification and distribution is subject to the Boost Software
+// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+
+// See http://www.boost.org for updates, documentation, and revision history.
+
+#include <boost/config.hpp>
+
+#ifdef BOOST_NO_STD_WSTREAMBUF
+#error "wide char i/o not supported on this platform"
+#else
+
+#define BOOST_WARCHIVE_SOURCE
+#include <boost/archive/impl/basic_xml_grammar.hpp>
+
+using namespace boost::spirit::classic;
+
+// fixup for RogueWave
+#include <boost/config.hpp>
+#if ! defined(__SGI_STL_PORT) \
+&& defined(BOOST_RWSTD_VER) && BOOST_RWSTD_VER<=0x020101
+#include <string>
+namespace std {
+ template<>
+ inline wstring &
+ wstring::replace (
+ wchar_t * first1,
+ wchar_t * last1,
+ const wchar_t * first2,
+ const wchar_t * last2
+ ){
+ replace(first1-begin(),last1-first1,first2,last2-first2,0,last2-first2);
+ return *this;
+ }
+} // namespace std
+#endif
+
+namespace boost {
+namespace archive {
+
+typedef basic_xml_grammar<wchar_t> xml_wgrammar;
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// specific definitions for wchar_t based XML
+
+template<>
+void xml_wgrammar::init_chset(){
+ Char = chset_t(
+ #if defined(__GNUC__) && defined(linux)
+ L"\x9\xA\xD\x20-\xD7FF\xE000-\xFFFD\x10000-\x10FFFF"
+ #else
+ L"\x9\xA\xD\x20-\xD7FF\xE000-\xFFFD"
+ #endif
+ );
+
+ Sch = chset_t(L"\x20\x9\xD\xA");
+
+ BaseChar = chset_t(
+ L"\x41-\x5A\x61-\x7A\xC0-\xD6\xD8-\xF6\xF8-\xFF\x100-\x131\x134-\x13E"
+ L"\x141-\x148\x14A-\x17E\x180-\x1C3\x1CD-\x1F0\x1F4-\x1F5\x1FA-\x217"
+ L"\x250-\x2A8\x2BB-\x2C1\x386\x388-\x38A\x38C\x38E-\x3A1\x3A3-\x3CE"
+ L"\x3D0-\x3D6\x3DA\x3DC\x3DE\x3E0\x3E2-\x3F3\x401-\x40C\x40E-\x44F"
+ L"\x451-\x45C\x45E-\x481\x490-\x4C4\x4C7-\x4C8\x4CB-\x4CC\x4D0-\x4EB"
+ L"\x4EE-\x4F5\x4F8-\x4F9\x531-\x556\x559\x561-\x586\x5D0-\x5EA"
+ L"\x5F0-\x5F2\x621-\x63A\x641-\x64A\x671-\x6B7\x6BA-\x6BE\x6C0-\x6CE"
+ L"\x6D0-\x6D3\x6D5\x6E5-\x6E6\x905-\x939\x93D\x958-\x961\x985-\x98C"
+ L"\x98F-\x990\x993-\x9A8\x9AA-\x9B0\x9B2\x9B6-\x9B9\x9DC-\x9DD"
+ L"\x9DF-\x9E1\x9F0-\x9F1\xA05-\xA0A\xA0F-\xA10\xA13-\xA28\xA2A-\xA30"
+ L"\xA32-\xA33\xA35-\xA36\xA38-\xA39\xA59-\xA5C\xA5E\xA72-\xA74"
+ L"\xA85-\xA8B\xA8D\xA8F-\xA91\xA93-\xAA8\xAAA-\xAB0\xAB2-\xAB3"
+ L"\xAB5-\xAB9\xABD\xAE0\xB05-\xB0C\xB0F-\xB10\xB13-\xB28\xB2A-\xB30"
+ L"\xB32-\xB33\xB36-\xB39\xB3D\xB5C-\xB5D\xB5F-\xB61\xB85-\xB8A"
+ L"\xB8E-\xB90\xB92-\xB95\xB99-\xB9A\xB9C\xB9E-\xB9F\xBA3-\xBA4"
+ L"\xBA8-\xBAA\xBAE-\xBB5\xBB7-\xBB9\xC05-\xC0C\xC0E-\xC10\xC12-\xC28"
+ L"\xC2A-\xC33\xC35-\xC39\xC60-\xC61\xC85-\xC8C\xC8E-\xC90\xC92-\xCA8"
+ L"\xCAA-\xCB3\xCB5-\xCB9\xCDE\xCE0-\xCE1\xD05-\xD0C\xD0E-\xD10"
+ L"\xD12-\xD28\xD2A-\xD39\xD60-\xD61\xE01-\xE2E\xE30\xE32-\xE33"
+ L"\xE40-\xE45\xE81-\xE82\xE84\xE87-\xE88\xE8A\xE8D\xE94-\xE97"
+ L"\xE99-\xE9F\xEA1-\xEA3\xEA5\xEA7\xEAA-\xEAB\xEAD-\xEAE\xEB0"
+ L"\xEB2-\xEB3\xEBD\xEC0-\xEC4\xF40-\xF47\xF49-\xF69\x10A0-\x10C5"
+ L"\x10D0-\x10F6\x1100\x1102-\x1103\x1105-\x1107\x1109\x110B-\x110C"
+ L"\x110E-\x1112\x113C\x113E\x1140\x114C\x114E\x1150\x1154-\x1155"
+ L"\x1159\x115F-\x1161\x1163\x1165\x1167\x1169\x116D-\x116E"
+ L"\x1172-\x1173\x1175\x119E\x11A8\x11AB\x11AE-\x11AF\x11B7-\x11B8"
+ L"\x11BA\x11BC-\x11C2\x11EB\x11F0\x11F9\x1E00-\x1E9B\x1EA0-\x1EF9"
+ L"\x1F00-\x1F15\x1F18-\x1F1D\x1F20-\x1F45\x1F48-\x1F4D\x1F50-\x1F57"
+ L"\x1F59\x1F5B\x1F5D\x1F5F-\x1F7D\x1F80-\x1FB4\x1FB6-\x1FBC\x1FBE"
+ L"\x1FC2-\x1FC4\x1FC6-\x1FCC\x1FD0-\x1FD3\x1FD6-\x1FDB\x1FE0-\x1FEC"
+ L"\x1FF2-\x1FF4\x1FF6-\x1FFC\x2126\x212A-\x212B\x212E\x2180-\x2182"
+ L"\x3041-\x3094\x30A1-\x30FA\x3105-\x312C\xAC00-\xD7A3"
+ );
+
+ Ideographic = chset_t(L"\x4E00-\x9FA5\x3007\x3021-\x3029");
+
+ Letter = BaseChar | Ideographic;
+
+ CombiningChar = chset_t(
+ L"\x0300-\x0345\x0360-\x0361\x0483-\x0486\x0591-\x05A1\x05A3-\x05B9"
+ L"\x05BB-\x05BD\x05BF\x05C1-\x05C2\x05C4\x064B-\x0652\x0670"
+ L"\x06D6-\x06DC\x06DD-\x06DF\x06E0-\x06E4\x06E7-\x06E8\x06EA-\x06ED"
+ L"\x0901-\x0903\x093C\x093E-\x094C\x094D\x0951-\x0954\x0962-\x0963"
+ L"\x0981-\x0983\x09BC\x09BE\x09BF\x09C0-\x09C4\x09C7-\x09C8"
+ L"\x09CB-\x09CD\x09D7\x09E2-\x09E3\x0A02\x0A3C\x0A3E\x0A3F"
+ L"\x0A40-\x0A42\x0A47-\x0A48\x0A4B-\x0A4D\x0A70-\x0A71\x0A81-\x0A83"
+ L"\x0ABC\x0ABE-\x0AC5\x0AC7-\x0AC9\x0ACB-\x0ACD\x0B01-\x0B03\x0B3C"
+ L"\x0B3E-\x0B43\x0B47-\x0B48\x0B4B-\x0B4D\x0B56-\x0B57\x0B82-\x0B83"
+ L"\x0BBE-\x0BC2\x0BC6-\x0BC8\x0BCA-\x0BCD\x0BD7\x0C01-\x0C03"
+ L"\x0C3E-\x0C44\x0C46-\x0C48\x0C4A-\x0C4D\x0C55-\x0C56\x0C82-\x0C83"
+ L"\x0CBE-\x0CC4\x0CC6-\x0CC8\x0CCA-\x0CCD\x0CD5-\x0CD6\x0D02-\x0D03"
+ L"\x0D3E-\x0D43\x0D46-\x0D48\x0D4A-\x0D4D\x0D57\x0E31\x0E34-\x0E3A"
+ L"\x0E47-\x0E4E\x0EB1\x0EB4-\x0EB9\x0EBB-\x0EBC\x0EC8-\x0ECD"
+ L"\x0F18-\x0F19\x0F35\x0F37\x0F39\x0F3E\x0F3F\x0F71-\x0F84"
+ L"\x0F86-\x0F8B\x0F90-\x0F95\x0F97\x0F99-\x0FAD\x0FB1-\x0FB7\x0FB9"
+ L"\x20D0-\x20DC\x20E1\x302A-\x302F\x3099\x309A"
+ );
+
+ Digit = chset_t(
+ L"\x0030-\x0039\x0660-\x0669\x06F0-\x06F9\x0966-\x096F\x09E6-\x09EF"
+ L"\x0A66-\x0A6F\x0AE6-\x0AEF\x0B66-\x0B6F\x0BE7-\x0BEF\x0C66-\x0C6F"
+ L"\x0CE6-\x0CEF\x0D66-\x0D6F\x0E50-\x0E59\x0ED0-\x0ED9\x0F20-\x0F29"
+ );
+
+ Extender = chset_t(
+ L"\x00B7\x02D0\x02D1\x0387\x0640\x0E46\x0EC6\x3005\x3031-\x3035"
+ L"\x309D-\x309E\x30FC-\x30FE"
+ );
+
+ NameChar =
+ Letter
+ | Digit
+ | L'.'
+ | L'-'
+ | L'_'
+ | L':'
+ | CombiningChar
+ | Extender
+ ;
+}
+} // namespace archive
+} // namespace boost
+
+#include "basic_xml_grammar.ipp"
+
+namespace boost {
+namespace archive {
+
+// explicit instantiation of xml for wide characters
+template class basic_xml_grammar<wchar_t>;
+
+} // namespace archive
+} // namespace boost
+
+#endif
diff --git a/3rdParty/Boost/src/libs/serialization/src/xml_wiarchive.cpp b/3rdParty/Boost/src/libs/serialization/src/xml_wiarchive.cpp
new file mode 100644
index 0000000..2e10947
--- /dev/null
+++ b/3rdParty/Boost/src/libs/serialization/src/xml_wiarchive.cpp
@@ -0,0 +1,53 @@
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// xml_wiarchive.cpp:
+
+// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
+// Use, modification and distribution is subject to the Boost Software
+// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+
+// See http://www.boost.org for updates, documentation, and revision history.
+
+#include <boost/config.hpp>
+#ifdef BOOST_NO_STD_WSTREAMBUF
+#error "wide char i/o not supported on this platform"
+#else
+
+#include <boost/detail/workaround.hpp>
+
+#if (defined _MSC_VER) && (_MSC_VER == 1200)
+# pragma warning (disable : 4786) // too long name, harmless warning
+#endif
+
+#define BOOST_WARCHIVE_SOURCE
+
+// the following works around an issue between spirit 1.61 and borland.
+// it turns out the the certain spirit stuff must be defined before
+// certain parts of mpl. including this here makes sure that happens
+#if BOOST_WORKAROUND(__BORLANDC__, <= 0x560 )
+#include <boost/archive/impl/basic_xml_grammar.hpp>
+#endif
+
+#include <boost/archive/xml_wiarchive.hpp>
+#include <boost/archive/detail/archive_serializer_map.hpp>
+
+// explicitly instantiate for this type of xml stream
+#include <boost/archive/impl/archive_serializer_map.ipp>
+#include <boost/archive/impl/basic_xml_iarchive.ipp>
+#include <boost/archive/impl/xml_wiarchive_impl.ipp>
+
+namespace boost {
+namespace archive {
+
+template class detail::archive_serializer_map<naked_xml_wiarchive>;
+template class basic_xml_iarchive<naked_xml_wiarchive> ;
+template class xml_wiarchive_impl<naked_xml_wiarchive> ;
+
+template class detail::archive_serializer_map<xml_wiarchive>;
+template class basic_xml_iarchive<xml_wiarchive> ;
+template class xml_wiarchive_impl<xml_wiarchive> ;
+
+} // namespace archive
+} // namespace boost
+
+#endif // BOOST_NO_STD_WSTREAMBUF
diff --git a/3rdParty/Boost/src/libs/serialization/src/xml_woarchive.cpp b/3rdParty/Boost/src/libs/serialization/src/xml_woarchive.cpp
new file mode 100644
index 0000000..e71daaf
--- /dev/null
+++ b/3rdParty/Boost/src/libs/serialization/src/xml_woarchive.cpp
@@ -0,0 +1,35 @@
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// xml_woarchive.cpp:
+
+// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
+// Use, modification and distribution is subject to the Boost Software
+// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+
+// See http://www.boost.org for updates, documentation, and revision history.
+
+#include <boost/config.hpp>
+#ifdef BOOST_NO_STD_WSTREAMBUF
+#error "wide char i/o not supported on this platform"
+#else
+
+#define BOOST_WARCHIVE_SOURCE
+#include <boost/archive/xml_woarchive.hpp>
+#include <boost/archive/detail/archive_serializer_map.hpp>
+
+// explicitly instantiate for this type of text stream
+#include <boost/archive/impl/archive_serializer_map.ipp>
+#include <boost/archive/impl/basic_xml_oarchive.ipp>
+#include <boost/archive/impl/xml_woarchive_impl.ipp>
+
+namespace boost {
+namespace archive {
+
+template class detail::archive_serializer_map<xml_woarchive>;
+template class basic_xml_oarchive<xml_woarchive> ;
+template class xml_woarchive_impl<xml_woarchive> ;
+
+} // namespace archive
+} // namespace boost
+
+#endif // BOOST_NO_STD_WSTREAMBUF