Added boost header

test/external/boost/archive/detail/abi_prefix.hpp

@@ -0,0 +1,20 @@
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// abi_prefix.hpp
+
+// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
+// Use, modification and distribution is subject to the Boost Software
+// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+
+//  See http://www.boost.org for updates, documentation, and revision history.
+
+#include <boost/config/abi_prefix.hpp> // must be the last header
+#ifdef BOOST_MSVC
+#  pragma warning(push)
+#  pragma warning(disable : 4251 4231 4660 4275)
+#endif
+
+#if defined( __BORLANDC__ )
+#pragma nopushoptwarn
+#endif
+

test/external/boost/archive/detail/abi_suffix.hpp

@@ -0,0 +1,19 @@
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// abi_suffix.hpp
+
+// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
+// Use, modification and distribution is subject to the Boost Software
+// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+
+//  See http://www.boost.org for updates, documentation, and revision history.
+
+#ifdef BOOST_MSVC
+#pragma warning(pop)
+#endif
+#include <boost/config/abi_suffix.hpp> // pops abi_suffix.hpp pragmas
+
+#if defined( __BORLANDC__ )
+#pragma nopushoptwarn
+#endif
+

test/external/boost/archive/detail/archive_serializer_map.hpp

@@ -0,0 +1,55 @@
+#ifndef BOOST_ARCHIVE_SERIALIZER_MAP_HPP
+#define BOOST_ARCHIVE_SERIALIZER_MAP_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+# pragma once
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// archive_serializer_map.hpp: extenstion of type_info required for 
+// serialization.
+
+// (C) Copyright 2009 Robert Ramey - http://www.rrsd.com . 
+// Use, modification and distribution is subject to the Boost Software
+// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+
+//  See http://www.boost.org for updates, documentation, and revision history.
+
+// note: this is nothing more than the thinest of wrappers around
+// basic_serializer_map so we can have a one map / archive type. 
+
+#include <boost/config.hpp>
+#include <boost/archive/detail/auto_link_archive.hpp>
+#include <boost/archive/detail/abi_prefix.hpp> // must be the last header
+
+namespace boost {
+
+namespace serialization {
+    class extended_type_info;
+} // namespace serialization
+
+namespace archive {
+namespace detail {
+
+class basic_serializer;
+
+template<class Archive>
+class BOOST_ARCHIVE_OR_WARCHIVE_DECL(BOOST_PP_EMPTY()) 
+archive_serializer_map {
+public:
+    static bool insert(const basic_serializer * bs);
+    static void erase(const basic_serializer * bs);
+    static const basic_serializer * find(
+        const boost::serialization::extended_type_info & type_
+    );
+};
+
+} // namespace detail
+} // namespace archive
+} // namespace boost
+
+#include <boost/archive/detail/abi_suffix.hpp> // must be the last header
+
+#endif //BOOST_ARCHIVE_SERIALIZER_MAP_HPP

test/external/boost/archive/detail/auto_link_archive.hpp

@@ -0,0 +1,48 @@
+#ifndef BOOST_ARCHIVE_DETAIL_AUTO_LINK_ARCHIVE_HPP
+#define BOOST_ARCHIVE_DETAIL_AUTO_LINK_ARCHIVE_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+# pragma once
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+//  auto_link_archive.hpp
+//
+//  (c) Copyright Robert Ramey 2004
+//  Use, modification, and distribution is subject to the Boost Software
+//  License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+
+//  See library home page at http://www.boost.org/libs/serialization
+
+//----------------------------------------------------------------------------// 
+
+// This header implements separate compilation features as described in
+// http://www.boost.org/more/separate_compilation.html
+
+//  enable automatic library variant selection  ------------------------------// 
+
+#include <boost/archive/detail/decl.hpp>
+
+#if !defined(BOOST_ALL_NO_LIB) && !defined(BOOST_SERIALIZATION_NO_LIB) \
+&&  !defined(BOOST_ARCHIVE_SOURCE) && !defined(BOOST_WARCHIVE_SOURCE)  \
+&&  !defined(BOOST_SERIALIZATION_SOURCE)
+
+    // Set the name of our library, this will get undef'ed by auto_link.hpp
+    // once it's done with it:
+    //
+    #define BOOST_LIB_NAME boost_serialization
+    //
+    // If we're importing code from a dll, then tell auto_link.hpp about it:
+    //
+    #if defined(BOOST_ALL_DYN_LINK) || defined(BOOST_SERIALIZATION_DYN_LINK)
+    #  define BOOST_DYN_LINK
+    #endif
+    //
+    // And include the header that does the work:
+    //
+    #include <boost/config/auto_link.hpp>
+#endif  // auto-linking disabled
+
+#endif // BOOST_ARCHIVE_DETAIL_AUTO_LINK_ARCHIVE_HPP

test/external/boost/archive/detail/auto_link_warchive.hpp

@@ -0,0 +1,47 @@
+#ifndef BOOST_ARCHIVE_DETAIL_AUTO_LINK_WARCHIVE_HPP
+#define BOOST_ARCHIVE_DETAIL_AUTO_LINK_WARCHIVE_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+# pragma once
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+//  auto_link_warchive.hpp
+//
+//  (c) Copyright Robert Ramey 2004
+//  Use, modification, and distribution is subject to the Boost Software
+//  License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+
+//  See library home page at http://www.boost.org/libs/serialization
+
+//----------------------------------------------------------------------------// 
+
+// This header implements separate compilation features as described in
+// http://www.boost.org/more/separate_compilation.html
+
+//  enable automatic library variant selection  ------------------------------// 
+
+#include <boost/archive/detail/decl.hpp>
+
+#if !defined(BOOST_WARCHIVE_SOURCE) \
+&& !defined(BOOST_ALL_NO_LIB) && !defined(BOOST_SERIALIZATION_NO_LIB)
+
+// Set the name of our library, this will get undef'ed by auto_link.hpp
+// once it's done with it:
+//
+#define BOOST_LIB_NAME boost_wserialization
+//
+// If we're importing code from a dll, then tell auto_link.hpp about it:
+//
+#if defined(BOOST_ALL_DYN_LINK) || defined(BOOST_SERIALIZATION_DYN_LINK)
+#  define BOOST_DYN_LINK
+#endif
+//
+// And include the header that does the work:
+//
+#include <boost/config/auto_link.hpp>
+#endif  // auto-linking disabled
+
+#endif // ARCHIVE_DETAIL_AUTO_LINK_ARCHIVE_HPP

test/external/boost/archive/detail/basic_archive_impl.hpp

@@ -0,0 +1,48 @@
+#ifndef BOOST_ARCHIVE_DETAIL_BASIC_ARCHIVE_IMPL_HPP
+#define BOOST_ARCHIVE_DETAIL_BASIC_ARCHIVE_IMPL_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+# pragma once
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// basic_archive_impl.hpp:
+
+// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
+// Use, modification and distribution is subject to the Boost Software
+// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+
+//  See http://www.boost.org for updates, documentation, and revision history.
+
+// can't use this - much as I'd like to as borland doesn't support it
+// #include <boost/scoped_ptr.hpp>
+
+#include <set>
+
+#include <boost/archive/detail/abi_prefix.hpp> // must be the last header
+
+namespace boost {
+namespace serialization {
+    class extended_type_info;
+} // namespace serialization
+
+namespace archive {
+namespace detail {
+
+//////////////////////////////////////////////////////////////////////
+class BOOST_ARCHIVE_DECL(BOOST_PP_EMPTY()) basic_archive_impl
+{
+};
+
+} // namespace detail
+} // namespace serialization
+} // namespace boost
+
+#include <boost/archive/detail/abi_suffix.hpp> // pops abi_suffix.hpp pragmas
+
+#endif //BOOST_ARCHIVE_DETAIL_BASIC_ARCHIVE_IMPL_HPP
+
+
+

test/external/boost/archive/detail/basic_config.hpp

@@ -0,0 +1,45 @@
+#ifndef BOOST_ARCHIVE_DETAIL_BASIC_CONFIG_HPP
+#define BOOST_ARCHIVE_DETAIL_BASIC_CONFIG_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+# pragma once
+#endif
+
+//  basic_config.hpp  ---------------------------------------------//
+
+//  (c) Copyright Robert Ramey 2004
+//  Use, modification, and distribution is subject to the Boost Software
+//  License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+
+//  See library home page at http://www.boost.org/libs/serialization
+
+//----------------------------------------------------------------------------// 
+
+// This header implements separate compilation features as described in
+// http://www.boost.org/more/separate_compilation.html
+
+#include <boost/config.hpp>
+
+#ifdef BOOST_HAS_DECLSPEC // defined in config system
+// we need to import/export our code only if the user has specifically
+// asked for it by defining either BOOST_ALL_DYN_LINK if they want all boost
+// libraries to be dynamically linked, or BOOST_ARCHIVE_DYN_LINK
+// if they want just this one to be dynamically linked:
+#if defined(BOOST_ALL_DYN_LINK) || defined(BOOST_ARCHIVE_DYN_LINK)
+// export if this is our own source, otherwise import:
+#ifdef BOOST_ARCHIVE_SOURCE
+# define BOOST_ARCHIVE_DECL __declspec(dllexport)
+#else
+# define BOOST_ARCHIVE_DECL __declspec(dllimport)
+#endif  // BOOST_ARCHIVE_SOURCE
+#endif  // DYN_LINK
+#endif  // BOOST_HAS_DECLSPEC
+//
+// if BOOST_ARCHIVE_DECL isn't defined yet define it now:
+#ifndef BOOST_ARCHIVE_DECL
+#define BOOST_ARCHIVE_DECL
+#endif
+
+#endif // BOOST_ARCHIVE_DETAIL_BASIC_CONFIG_HPP

test/external/boost/archive/detail/basic_iarchive.hpp

@@ -0,0 +1,110 @@
+#ifndef BOOST_ARCHIVE_DETAIL_BASIC_IARCHIVE_HPP
+#define BOOST_ARCHIVE_DETAIL_BASIC_IARCHIVE_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+# pragma once
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// basic_iarchive.hpp:
+
+// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
+// Use, modification and distribution is subject to the Boost Software
+// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+
+//  See http://www.boost.org for updates, documentation, and revision history.
+
+// can't use this - much as I'd like to as borland doesn't support it
+// #include <boost/scoped_ptr.hpp>
+
+#include <boost/config.hpp>
+#include <boost/noncopyable.hpp>
+
+#include <boost/type_traits/broken_compiler_spec.hpp>
+#include <boost/serialization/tracking_enum.hpp>
+#include <boost/archive/basic_archive.hpp>
+#include <boost/archive/detail/decl.hpp>
+#include <boost/archive/detail/abi_prefix.hpp> // must be the last header
+
+namespace boost {
+namespace serialization {
+    class extended_type_info;
+} // namespace serialization
+
+namespace archive {
+namespace detail {
+
+class basic_iarchive_impl;
+class BOOST_ARCHIVE_DECL(BOOST_PP_EMPTY()) basic_iserializer;
+class BOOST_ARCHIVE_DECL(BOOST_PP_EMPTY()) basic_pointer_iserializer;
+//////////////////////////////////////////////////////////////////////
+// class basic_iarchive - read serialized objects from a input stream
+class BOOST_ARCHIVE_DECL(BOOST_PP_EMPTY()) basic_iarchive :
+    private boost::noncopyable
+{
+    friend class basic_iarchive_impl;
+    // hide implementation of this class to minimize header conclusion
+    // in client code. I couldn't used scoped pointer with borland
+    // boost::scoped_ptr<basic_iarchive_impl> pimpl;
+    basic_iarchive_impl * pimpl;
+
+    virtual void vload(version_type &t) =  0;
+    virtual void vload(object_id_type &t) =  0;
+    virtual void vload(class_id_type &t) =  0;
+    virtual void vload(class_id_optional_type &t) = 0;
+    virtual void vload(class_name_type &t) = 0;
+    virtual void vload(tracking_type &t) = 0;
+protected:
+    basic_iarchive(unsigned int flags);
+    // account for bogus gcc warning
+    #if defined(__GNUC__)
+    virtual
+    #endif
+    ~basic_iarchive();
+public:
+    // note: NOT part of the public API.
+    void next_object_pointer(void *t);
+    void register_basic_serializer(
+        const basic_iserializer & bis
+    );
+    void load_object(
+        void *t, 
+        const basic_iserializer & bis
+    );
+    const basic_pointer_iserializer * 
+    load_pointer(
+        void * & t, 
+        const basic_pointer_iserializer * bpis_ptr,
+        const basic_pointer_iserializer * (*finder)(
+            const boost::serialization::extended_type_info & eti
+        )
+
+    );
+    // real public API starts here
+    void 
+    set_library_version(library_version_type archive_library_version);
+    library_version_type 
+    get_library_version() const;
+    unsigned int
+    get_flags() const;
+    void 
+    reset_object_address(const void * new_address, const void * old_address);
+    void 
+    delete_created_pointers();
+};
+
+} // namespace detail
+} // namespace archive
+} // namespace boost
+
+// required by smart_cast for compilers not implementing 
+// partial template specialization
+BOOST_TT_BROKEN_COMPILER_SPEC(
+    boost::archive::detail::basic_iarchive  
+) 
+
+#include <boost/archive/detail/abi_suffix.hpp> // pops abi_suffix.hpp pragmas
+
+#endif //BOOST_ARCHIVE_DETAIL_BASIC_IARCHIVE_HPP

test/external/boost/archive/detail/basic_iserializer.hpp

@@ -0,0 +1,95 @@
+#ifndef BOOST_ARCHIVE_DETAIL_BASIC_ISERIALIZER_HPP
+#define BOOST_ARCHIVE_DETAIL_BASIC_ISERIALIZER_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+# pragma once
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// basic_iserializer.hpp: extenstion of type_info required for serialization.
+
+// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
+// Use, modification and distribution is subject to the Boost Software
+// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+
+//  See http://www.boost.org for updates, documentation, and revision history.
+
+#include <cstdlib> // NULL
+#include <boost/config.hpp>
+
+#include <boost/archive/basic_archive.hpp>
+#include <boost/archive/detail/decl.hpp>
+#include <boost/archive/detail/basic_serializer.hpp>
+#include <boost/archive/detail/auto_link_archive.hpp>
+#include <boost/archive/detail/abi_prefix.hpp> // must be the last header
+
+#ifdef BOOST_MSVC
+#  pragma warning(push)
+#  pragma warning(disable : 4511 4512)
+#endif
+
+namespace boost {
+namespace serialization {
+    class extended_type_info;
+} // namespace serialization
+
+// forward declarations
+namespace archive {
+namespace detail {
+
+class BOOST_ARCHIVE_DECL(BOOST_PP_EMPTY()) basic_iarchive;
+class BOOST_ARCHIVE_DECL(BOOST_PP_EMPTY()) basic_pointer_iserializer;
+
+class BOOST_ARCHIVE_DECL(BOOST_PP_EMPTY()) basic_iserializer : 
+    public basic_serializer
+{
+private:
+    basic_pointer_iserializer *m_bpis;
+protected:
+    explicit basic_iserializer(
+        const boost::serialization::extended_type_info & type
+    );
+    // account for bogus gcc warning
+    #if defined(__GNUC__)
+    virtual
+    #endif
+    ~basic_iserializer();
+public:
+    bool serialized_as_pointer() const {
+        return m_bpis != NULL;
+    }
+    void set_bpis(basic_pointer_iserializer *bpis){
+        m_bpis = bpis;
+    }
+    const basic_pointer_iserializer * get_bpis_ptr() const {
+        return m_bpis;
+    }
+    virtual void load_object_data(
+        basic_iarchive & ar, 
+        void *x,
+        const unsigned int file_version
+    ) const = 0;
+    // returns true if class_info should be saved
+    virtual bool class_info() const = 0 ;
+    // returns true if objects should be tracked
+    virtual bool tracking(const unsigned int) const = 0 ;
+    // returns class version
+    virtual version_type version() const = 0 ;
+    // returns true if this class is polymorphic
+    virtual bool is_polymorphic() const = 0;
+    virtual void destroy(/*const*/ void *address) const = 0 ;
+};
+
+} // namespae detail
+} // namespace archive
+} // namespace boost
+
+#ifdef BOOST_MSVC
+#pragma warning(pop)
+#endif
+
+#include <boost/archive/detail/abi_suffix.hpp> // pops abi_suffix.hpp pragmas
+
+#endif // BOOST_ARCHIVE_DETAIL_BASIC_ISERIALIZER_HPP

test/external/boost/archive/detail/basic_oarchive.hpp

@@ -0,0 +1,106 @@
+#ifndef BOOST_ARCHIVE_BASIC_OARCHIVE_HPP
+#define BOOST_ARCHIVE_BASIC_OARCHIVE_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+# pragma once
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// basic_oarchive.hpp:
+
+// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
+// Use, modification and distribution is subject to the Boost Software
+// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+
+//  See http://www.boost.org for updates, documentation, and revision history.
+
+#include <cstddef> // NULL
+#include <boost/config.hpp>
+#include <boost/noncopyable.hpp>
+
+#include <boost/type_traits/broken_compiler_spec.hpp>
+
+// can't use this - much as I'd like to as borland doesn't support it
+// #include <boost/scoped_ptr.hpp>
+
+#include <boost/archive/basic_archive.hpp>
+#include <boost/serialization/tracking_enum.hpp>
+
+#include <boost/archive/detail/abi_prefix.hpp> // must be the last header
+
+namespace boost {
+namespace serialization {
+    class extended_type_info;
+} // namespace serialization
+
+namespace archive {
+namespace detail {
+
+class basic_oarchive_impl;
+class BOOST_ARCHIVE_DECL(BOOST_PP_EMPTY()) basic_oserializer;
+class BOOST_ARCHIVE_DECL(BOOST_PP_EMPTY()) basic_pointer_oserializer;
+//////////////////////////////////////////////////////////////////////
+// class basic_oarchive - write serialized objects to an output stream
+class BOOST_ARCHIVE_OR_WARCHIVE_DECL(BOOST_PP_EMPTY()) basic_oarchive :
+    private boost::noncopyable
+{
+    friend class basic_oarchive_impl;
+    // hide implementation of this class to minimize header conclusion
+    // in client code. note: borland can't use scoped_ptr
+    //boost::scoped_ptr<basic_oarchive_impl> pimpl;
+    basic_oarchive_impl * pimpl;
+
+    // overload these to bracket object attributes. Used to implement
+    // xml archives
+    virtual void vsave(const version_type t) =  0;
+    virtual void vsave(const object_id_type t) =  0;
+    virtual void vsave(const object_reference_type t) =  0;
+    virtual void vsave(const class_id_type t) =  0;
+    virtual void vsave(const class_id_optional_type t) = 0;
+    virtual void vsave(const class_id_reference_type t) =  0;
+    virtual void vsave(const class_name_type & t) = 0;
+    virtual void vsave(const tracking_type t) = 0;
+protected:
+    basic_oarchive(unsigned int flags = 0);
+    // account for bogus gcc warning
+    #if defined(__GNUC__)
+    virtual
+    #endif
+    ~basic_oarchive();
+public:
+    // note: NOT part of the public interface
+    void register_basic_serializer(
+        const basic_oserializer & bos
+    );
+    void save_object(
+        const void *x, 
+        const basic_oserializer & bos
+    );
+    void save_pointer(
+        const void * t, 
+        const basic_pointer_oserializer * bpos_ptr
+    );
+    void save_null_pointer(){
+        vsave(NULL_POINTER_TAG);
+    }
+    // real public interface starts here
+    void end_preamble(); // default implementation does nothing
+    library_version_type get_library_version() const;
+    unsigned int get_flags() const;
+};
+
+} // namespace detail
+} // namespace archive
+} // namespace boost
+
+// required by smart_cast for compilers not implementing 
+// partial template specialization
+BOOST_TT_BROKEN_COMPILER_SPEC(
+    boost::archive::detail::basic_oarchive
+)
+
+#include <boost/archive/detail/abi_suffix.hpp> // pops abi_suffix.hpp pragmas
+
+#endif //BOOST_ARCHIVE_BASIC_OARCHIVE_HPP

test/external/boost/archive/detail/basic_oserializer.hpp

@@ -0,0 +1,93 @@
+#ifndef BOOST_SERIALIZATION_BASIC_OSERIALIZER_HPP
+#define BOOST_SERIALIZATION_BASIC_OSERIALIZER_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+# pragma once
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// basic_oserializer.hpp: extenstion of type_info required for serialization.
+
+// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
+// Use, modification and distribution is subject to the Boost Software
+// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+
+//  See http://www.boost.org for updates, documentation, and revision history.
+
+#include <cstddef> // NULL
+#include <boost/config.hpp>
+#include <boost/noncopyable.hpp>
+
+#include <boost/archive/basic_archive.hpp>
+#include <boost/archive/detail/auto_link_archive.hpp>
+#include <boost/archive/detail/basic_serializer.hpp>
+
+#include <boost/archive/detail/abi_prefix.hpp> // must be the last header
+
+#ifdef BOOST_MSVC
+#  pragma warning(push)
+#  pragma warning(disable : 4511 4512)
+#endif
+
+namespace boost {
+namespace serialization {
+    class extended_type_info;
+} // namespace serialization
+
+// forward declarations
+namespace archive {
+namespace detail {
+
+class BOOST_ARCHIVE_DECL(BOOST_PP_EMPTY()) basic_oarchive;
+class BOOST_ARCHIVE_DECL(BOOST_PP_EMPTY()) basic_pointer_oserializer;
+
+class BOOST_ARCHIVE_DECL(BOOST_PP_EMPTY()) basic_oserializer : 
+    public basic_serializer
+{
+private:
+    basic_pointer_oserializer *m_bpos;
+protected:
+    explicit basic_oserializer(
+        const boost::serialization::extended_type_info & type_
+    );
+    // account for bogus gcc warning
+    #if defined(__GNUC__)
+    virtual
+    #endif
+    ~basic_oserializer();
+public:
+    bool serialized_as_pointer() const {
+        return m_bpos != NULL;
+    }
+    void set_bpos(basic_pointer_oserializer *bpos){
+        m_bpos = bpos;
+    }
+    const basic_pointer_oserializer * get_bpos() const {
+        return m_bpos;
+    }
+    virtual void save_object_data(
+        basic_oarchive & ar, const void * x
+    ) const = 0;
+    // returns true if class_info should be saved
+    virtual bool class_info() const = 0;
+    // returns true if objects should be tracked
+    virtual bool tracking(const unsigned int flags) const = 0;
+    // returns class version
+    virtual version_type version() const = 0;
+    // returns true if this class is polymorphic
+    virtual bool is_polymorphic() const = 0;
+};
+
+} // namespace detail
+} // namespace serialization
+} // namespace boost
+
+#ifdef BOOST_MSVC
+#pragma warning(pop)
+#endif
+
+#include <boost/archive/detail/abi_suffix.hpp> // pops abi_suffix.hpp pragmas
+
+#endif // BOOST_SERIALIZATION_BASIC_OSERIALIZER_HPP

test/external/boost/archive/detail/basic_pointer_iserializer.hpp

@@ -0,0 +1,73 @@
+#ifndef BOOST_ARCHIVE_BASIC_POINTER_ISERIALIZER_HPP
+#define BOOST_ARCHIVE_BASIC_POINTER_ISERIALIZER_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+# pragma once
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// basic_pointer_oserializer.hpp: extenstion of type_info required for 
+// serialization.
+
+// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
+// Use, modification and distribution is subject to the Boost Software
+// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+
+//  See http://www.boost.org for updates, documentation, and revision history.
+#include <boost/config.hpp>
+#include <boost/noncopyable.hpp>
+#include <boost/archive/detail/auto_link_archive.hpp>
+#include <boost/archive/detail/basic_serializer.hpp>
+
+#include <boost/archive/detail/abi_prefix.hpp> // must be the last header
+
+#ifdef BOOST_MSVC
+#  pragma warning(push)
+#  pragma warning(disable : 4511 4512)
+#endif
+
+namespace boost {
+namespace serialization {
+    class extended_type_info;
+} // namespace serialization
+
+// forward declarations
+namespace archive {
+namespace detail {
+
+class BOOST_ARCHIVE_DECL(BOOST_PP_EMPTY()) basic_iarchive;
+class BOOST_ARCHIVE_DECL(BOOST_PP_EMPTY()) basic_iserializer;
+
+class BOOST_ARCHIVE_DECL(BOOST_PP_EMPTY()) basic_pointer_iserializer 
+    : public basic_serializer {
+protected:
+    explicit basic_pointer_iserializer(
+        const boost::serialization::extended_type_info & type_
+    );
+    // account for bogus gcc warning
+    #if defined(__GNUC__)
+    virtual
+    #endif
+    ~basic_pointer_iserializer();
+public:
+    virtual const basic_iserializer & get_basic_serializer() const = 0;
+    virtual void load_object_ptr(
+        basic_iarchive & ar, 
+        void * & x,
+        const unsigned int file_version
+    ) const = 0;
+};
+
+} // namespace detail
+} // namespace archive
+} // namespace boost
+
+#ifdef BOOST_MSVC
+#pragma warning(pop)
+#endif
+
+#include <boost/archive/detail/abi_suffix.hpp> // pops abi_suffix.hpp pragmas
+
+#endif // BOOST_ARCHIVE_BASIC_POINTER_ISERIALIZER_HPP

test/external/boost/archive/detail/basic_pointer_oserializer.hpp

@@ -0,0 +1,72 @@
+#ifndef BOOST_ARCHIVE_BASIC_POINTER_OSERIALIZER_HPP
+#define BOOST_ARCHIVE_BASIC_POINTER_OSERIALIZER_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+# pragma once
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// basic_pointer_oserializer.hpp: extenstion of type_info required for 
+// serialization.
+
+// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
+// Use, modification and distribution is subject to the Boost Software
+// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+
+//  See http://www.boost.org for updates, documentation, and revision history.
+#include <boost/config.hpp>
+#include <boost/noncopyable.hpp>
+#include <boost/archive/detail/auto_link_archive.hpp>
+#include <boost/archive/detail/basic_serializer.hpp>
+
+#include <boost/archive/detail/abi_prefix.hpp> // must be the last header
+
+#ifdef BOOST_MSVC
+#  pragma warning(push)
+#  pragma warning(disable : 4511 4512)
+#endif
+
+namespace boost {
+namespace serialization {
+    class extended_type_info;
+} // namespace serialization
+
+namespace archive {
+namespace detail {
+
+class BOOST_ARCHIVE_DECL(BOOST_PP_EMPTY()) basic_oarchive;
+class BOOST_ARCHIVE_DECL(BOOST_PP_EMPTY()) basic_oserializer;
+
+class BOOST_ARCHIVE_DECL(BOOST_PP_EMPTY()) basic_pointer_oserializer : 
+    public basic_serializer
+{
+protected:
+    explicit basic_pointer_oserializer(
+        const boost::serialization::extended_type_info & type_
+    );
+public:
+    // account for bogus gcc warning
+    #if defined(__GNUC__)
+    virtual
+    #endif
+    ~basic_pointer_oserializer();
+    virtual const basic_oserializer & get_basic_serializer() const = 0;
+    virtual void save_object_ptr(
+        basic_oarchive & ar,
+        const void * x
+    ) const = 0;
+};
+
+} // namespace detail
+} // namespace archive
+} // namespace boost
+
+#ifdef BOOST_MSVC
+#pragma warning(pop)
+#endif
+
+#include <boost/archive/detail/abi_suffix.hpp> // pops abi_suffix.hpp pragmas
+
+#endif // BOOST_ARCHIVE_BASIC_POINTER_OSERIALIZER_HPP

test/external/boost/archive/detail/basic_serializer.hpp

@@ -0,0 +1,79 @@
+#ifndef  BOOST_ARCHIVE_BASIC_SERIALIZER_HPP
+#define BOOST_ARCHIVE_BASIC_SERIALIZER_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+# pragma once
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// basic_serializer.hpp: extenstion of type_info required for serialization.
+
+// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
+// Use, modification and distribution is subject to the Boost Software
+// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+
+//  See http://www.boost.org for updates, documentation, and revision history.
+
+#include <boost/assert.hpp>
+#include <cstddef> // NULL
+
+#include <boost/noncopyable.hpp>
+#include <boost/config.hpp>
+#include <boost/serialization/extended_type_info.hpp>
+
+#ifdef BOOST_MSVC
+#  pragma warning(push)
+#  pragma warning(disable : 4511 4512)
+#endif
+
+namespace boost {
+namespace archive {
+namespace detail {
+
+class basic_serializer : 
+    private boost::noncopyable
+{
+    const boost::serialization::extended_type_info * m_eti;
+protected:
+    explicit basic_serializer(
+        const boost::serialization::extended_type_info & eti
+    ) : 
+        m_eti(& eti)
+    {
+        BOOST_ASSERT(NULL != & eti);
+    }
+public:
+    inline bool 
+    operator<(const basic_serializer & rhs) const {
+        // can't compare address since there can be multiple eti records
+        // for the same type in different execution modules (that is, DLLS)
+        // leave this here as a reminder not to do this!
+        // return & lhs.get_eti() < & rhs.get_eti();
+        return get_eti() < rhs.get_eti();
+    }
+    const char * get_debug_info() const {
+        return m_eti->get_debug_info();
+    }
+    const boost::serialization::extended_type_info & get_eti() const {
+        return * m_eti;
+    }
+};
+
+class basic_serializer_arg : public basic_serializer {
+public:
+    basic_serializer_arg(const serialization::extended_type_info & eti) :
+        basic_serializer(eti)
+    {}
+};
+
+} // namespace detail
+} // namespace archive
+} // namespace boost
+
+#ifdef BOOST_MSVC
+#pragma warning(pop)
+#endif
+
+#endif // BOOST_ARCHIVE_BASIC_SERIALIZER_HPP

test/external/boost/archive/detail/basic_serializer_map.hpp

@@ -0,0 +1,69 @@
+#ifndef  BOOST_SERIALIZER_MAP_HPP
+#define BOOST_SERIALIZER_MAP_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+# pragma once
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// basic_serializer_map.hpp: extenstion of type_info required for serialization.
+
+// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
+// Use, modification and distribution is subject to the Boost Software
+// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+
+//  See http://www.boost.org for updates, documentation, and revision history.
+
+#include <set>
+
+#include <boost/config.hpp>
+#include <boost/utility.hpp>
+#include <boost/archive/detail/auto_link_archive.hpp>
+
+#include <boost/archive/detail/abi_prefix.hpp> // must be the last header
+
+namespace boost { 
+namespace serialization {
+    class extended_type_info;
+}
+
+namespace archive {
+namespace detail {
+
+class basic_serializer;
+
+class BOOST_ARCHIVE_OR_WARCHIVE_DECL(BOOST_PP_EMPTY())
+basic_serializer_map : public
+    boost::noncopyable
+{
+    struct type_info_pointer_compare
+    {
+        bool operator()(
+            const basic_serializer * lhs, const basic_serializer * rhs
+        ) const ;
+    };
+    typedef std::set<
+        const basic_serializer *, 
+        type_info_pointer_compare
+    > map_type;
+    map_type m_map;
+public:
+    bool insert(const basic_serializer * bs);
+    void erase(const basic_serializer * bs);
+    const basic_serializer * find(
+        const boost::serialization::extended_type_info & type_
+    ) const;
+private:
+    // cw 8.3 requires this
+    basic_serializer_map& operator=(basic_serializer_map const&);
+};
+
+} // namespace detail
+} // namespace archive
+} // namespace boost
+
+#include <boost/archive/detail/abi_suffix.hpp> // must be the last header
+
+#endif // BOOST_SERIALIZER_MAP_HPP

test/external/boost/archive/detail/check.hpp

@@ -0,0 +1,169 @@
+#ifndef BOOST_ARCHIVE_DETAIL_CHECK_HPP
+#define BOOST_ARCHIVE_DETAIL_CHECK_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+# pragma once
+#pragma inline_depth(511)
+#pragma inline_recursion(on)
+#endif
+
+#if defined(__MWERKS__)
+#pragma inline_depth(511)
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// check.hpp: interface for serialization system.
+
+// (C) Copyright 2009 Robert Ramey - http://www.rrsd.com . 
+// Use, modification and distribution is subject to the Boost Software
+// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+
+//  See http://www.boost.org for updates, documentation, and revision history.
+
+#include <boost/config.hpp>
+
+#include <boost/static_assert.hpp>
+#include <boost/type_traits/is_const.hpp>
+
+#include <boost/mpl/eval_if.hpp>
+#include <boost/mpl/or.hpp>
+#include <boost/mpl/equal_to.hpp>
+#include <boost/mpl/int.hpp>
+#include <boost/mpl/not.hpp>
+#include <boost/mpl/greater.hpp>
+#include <boost/mpl/assert.hpp>
+
+#include <boost/serialization/static_warning.hpp>
+#include <boost/serialization/version.hpp>
+#include <boost/serialization/level.hpp>
+#include <boost/serialization/tracking.hpp>
+#include <boost/serialization/wrapper.hpp>
+
+namespace boost {
+namespace archive {
+namespace detail {
+
+// checks for objects
+
+template<class T>
+inline void check_object_level(){
+    typedef 
+        BOOST_DEDUCED_TYPENAME mpl::greater_equal<
+            serialization::implementation_level< T >,
+            mpl::int_<serialization::primitive_type>
+        >::type typex;
+
+    // trap attempts to serialize objects marked
+    // not_serializable
+    BOOST_STATIC_ASSERT(typex::value);
+}
+
+template<class T>
+inline void check_object_versioning(){
+    typedef 
+        BOOST_DEDUCED_TYPENAME mpl::or_<
+            BOOST_DEDUCED_TYPENAME mpl::greater<
+                serialization::implementation_level< T >,
+                mpl::int_<serialization::object_serializable>
+            >,
+            BOOST_DEDUCED_TYPENAME mpl::equal_to<
+                serialization::version< T >,
+                mpl::int_<0>
+            >
+        > typex;
+    // trap attempts to serialize with objects that don't
+    // save class information in the archive with versioning.
+    BOOST_STATIC_ASSERT(typex::value);
+}
+
+template<class T>
+inline void check_object_tracking(){
+    // presume it has already been determined that
+    // T is not a const
+    BOOST_STATIC_ASSERT(! boost::is_const< T >::value);
+    typedef BOOST_DEDUCED_TYPENAME mpl::equal_to<
+        serialization::tracking_level< T >,
+        mpl::int_<serialization::track_never>
+    >::type typex;
+    // saving an non-const object of a type not marked "track_never)
+
+    // may be an indicator of an error usage of the
+    // serialization library and should be double checked.  
+    // See documentation on object tracking.  Also, see the 
+    // "rationale" section of the documenation
+    // for motivation for this checking.
+
+    BOOST_STATIC_WARNING(typex::value);
+}
+
+// checks for pointers
+
+template<class T>
+inline void check_pointer_level(){
+    // we should only invoke this once we KNOW that T
+    // has been used as a pointer!!
+    typedef 
+        BOOST_DEDUCED_TYPENAME mpl::or_<
+            BOOST_DEDUCED_TYPENAME mpl::greater<
+                serialization::implementation_level< T >,
+                mpl::int_<serialization::object_serializable>
+            >,
+            BOOST_DEDUCED_TYPENAME mpl::not_<
+                BOOST_DEDUCED_TYPENAME mpl::equal_to<
+                    serialization::tracking_level< T >,
+                    mpl::int_<serialization::track_selectively>
+                >
+            >
+        > typex;
+    // Address the following when serializing to a pointer:
+
+    // a) This type doesn't save class information in the
+    // archive. That is, the serialization trait implementation
+    // level <= object_serializable.
+    // b) Tracking for this type is set to "track selectively"
+
+    // in this case, indication that an object is tracked is
+    // not stored in the archive itself - see level == object_serializable
+    // but rather the existence of the operation ar >> T * is used to 
+    // infer that an object of this type should be tracked.  So, if
+    // you save via a pointer but don't load via a pointer the operation
+    // will fail on load without given any valid reason for the failure.
+
+    // So if your program traps here, consider changing the 
+    // tracking or implementation level traits - or not
+    // serializing via a pointer.
+    BOOST_STATIC_WARNING(typex::value);
+}
+
+template<class T>
+void inline check_pointer_tracking(){
+    typedef BOOST_DEDUCED_TYPENAME mpl::greater<
+        serialization::tracking_level< T >,
+        mpl::int_<serialization::track_never>
+    >::type typex;
+    // serializing an object of a type marked "track_never" through a pointer
+    // could result in creating more objects than were saved!
+    BOOST_STATIC_WARNING(typex::value);
+}
+
+template<class T>
+inline void check_const_loading(){
+    typedef
+        BOOST_DEDUCED_TYPENAME mpl::or_<
+            BOOST_DEDUCED_TYPENAME boost::serialization::is_wrapper< T >,
+            BOOST_DEDUCED_TYPENAME mpl::not_<
+                BOOST_DEDUCED_TYPENAME boost::is_const< T >
+            >
+        >::type typex;
+    // cannot load data into a "const" object unless it's a
+    // wrapper around some other non-const object.
+    BOOST_STATIC_ASSERT(typex::value);
+}
+
+} // detail
+} // archive
+} // boost
+
+#endif // BOOST_ARCHIVE_DETAIL_CHECK_HPP

test/external/boost/archive/detail/common_iarchive.hpp

@@ -0,0 +1,88 @@
+#ifndef BOOST_ARCHIVE_DETAIL_COMMON_IARCHIVE_HPP
+#define BOOST_ARCHIVE_DETAIL_COMMON_IARCHIVE_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+# pragma once
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// common_iarchive.hpp
+
+// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
+// Use, modification and distribution is subject to the Boost Software
+// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+
+//  See http://www.boost.org for updates, documentation, and revision history.
+
+#include <boost/config.hpp>
+
+#include <boost/archive/detail/basic_iarchive.hpp>
+#include <boost/archive/detail/basic_pointer_iserializer.hpp>
+#include <boost/archive/detail/interface_iarchive.hpp>
+
+#ifdef BOOST_MSVC
+#  pragma warning(push)
+#  pragma warning(disable : 4511 4512)
+#endif
+
+namespace boost {
+namespace archive {
+namespace detail {
+
+class extended_type_info;
+
+// note: referred to as Curiously Recurring Template Patter (CRTP)
+template<class Archive>
+class common_iarchive : 
+    public basic_iarchive,
+    public interface_iarchive<Archive>
+{
+    friend class interface_iarchive<Archive>;
+private:
+    virtual void vload(version_type & t){
+        * this->This() >> t; 
+    }
+    virtual void vload(object_id_type & t){
+        * this->This() >> t;
+    }
+    virtual void vload(class_id_type & t){
+        * this->This() >> t;
+    }
+    virtual void vload(class_id_optional_type & t){
+        * this->This() >> t;
+    }
+    virtual void vload(tracking_type & t){
+        * this->This() >> t;
+    }
+    virtual void vload(class_name_type &s){
+        * this->This() >> s;
+    }
+protected:
+    // default processing - invoke serialization library
+    template<class T>
+    void load_override(T & t, BOOST_PFTO int){
+        archive::load(* this->This(), t);
+    }
+    // default implementations of functions which emit start/end tags for
+    // archive types that require them.
+    void load_start(const char * /*name*/){}
+    void load_end(const char * /*name*/){}
+    // default archive initialization
+    common_iarchive(unsigned int flags = 0) : 
+        basic_iarchive(flags),
+        interface_iarchive<Archive>()
+    {}
+};
+
+} // namespace detail
+} // namespace archive
+} // namespace boost
+
+#ifdef BOOST_MSVC
+#pragma warning(pop)
+#endif
+
+#endif // BOOST_ARCHIVE_DETAIL_COMMON_IARCHIVE_HPP
+

test/external/boost/archive/detail/common_oarchive.hpp

@@ -0,0 +1,87 @@
+#ifndef BOOST_ARCHIVE_DETAIL_COMMON_OARCHIVE_HPP
+#define BOOST_ARCHIVE_DETAIL_COMMON_OARCHIVE_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+# pragma once
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// common_oarchive.hpp
+
+// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
+// Use, modification and distribution is subject to the Boost Software
+// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+
+//  See http://www.boost.org for updates, documentation, and revision history.
+
+#include <boost/config.hpp>
+
+#include <boost/archive/detail/basic_oarchive.hpp>
+#include <boost/archive/detail/interface_oarchive.hpp>
+
+#ifdef BOOST_MSVC
+#  pragma warning(push)
+#  pragma warning(disable : 4511 4512)
+#endif
+
+namespace boost {
+namespace archive {
+namespace detail {
+
+// note: referred to as Curiously Recurring Template Patter (CRTP)
+template<class Archive>
+class common_oarchive : 
+    public basic_oarchive,
+    public interface_oarchive<Archive>
+{
+    friend class interface_oarchive<Archive>;
+private:
+    virtual void vsave(const version_type t){
+        * this->This() << t;
+    }
+    virtual void vsave(const object_id_type t){
+        * this->This() << t;
+    }
+    virtual void vsave(const object_reference_type t){
+        * this->This() << t;
+    }
+    virtual void vsave(const class_id_type t){
+        * this->This() << t;
+    }
+    virtual void vsave(const class_id_reference_type t){
+        * this->This() << t;
+    }
+    virtual void vsave(const class_id_optional_type t){
+        * this->This() << t;
+    }
+    virtual void vsave(const class_name_type & t){
+        * this->This() << t;
+    }
+    virtual void vsave(const tracking_type t){
+        * this->This() << t;
+    }
+protected:
+    // default processing - invoke serialization library
+    template<class T>
+    void save_override(T & t, BOOST_PFTO int){
+        archive::save(* this->This(), t);
+    }
+    void save_start(const char * /*name*/){}
+    void save_end(const char * /*name*/){}
+    common_oarchive(unsigned int flags = 0) : 
+        basic_oarchive(flags),
+        interface_oarchive<Archive>()
+    {}
+};
+
+} // namespace detail
+} // namespace archive
+} // namespace boost
+
+#ifdef BOOST_MSVC
+#pragma warning(pop)
+#endif
+
+#endif // BOOST_ARCHIVE_DETAIL_COMMON_OARCHIVE_HPP

test/external/boost/archive/detail/decl.hpp

@@ -0,0 +1,79 @@
+#ifndef BOOST_ARCHIVE_DETAIL_DECL_HPP
+#define BOOST_ARCHIVE_DETAIL_DECL_HPP 
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+# pragma once
+#endif 
+
+/////////1/////////2///////// 3/////////4/////////5/////////6/////////7/////////8
+//  decl.hpp
+//
+//  (c) Copyright Robert Ramey 2004
+//  Use, modification, and distribution is subject to the Boost Software
+//  License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+
+//  See library home page at http://www.boost.org/libs/serialization
+
+//----------------------------------------------------------------------------// 
+
+// This header implements separate compilation features as described in
+// http://www.boost.org/more/separate_compilation.html
+
+#include <boost/config.hpp>
+#include <boost/preprocessor/facilities/empty.hpp>
+
+#if defined(BOOST_HAS_DECLSPEC)
+    #if (defined(BOOST_ALL_DYN_LINK) || defined(BOOST_SERIALIZATION_DYN_LINK))
+        #if defined(BOOST_ARCHIVE_SOURCE)
+            #if defined(__BORLANDC__)
+            #define BOOST_ARCHIVE_DECL(T) T __export
+            #define BOOST_ARCHIVE_OR_WARCHIVE_DECL(T)  T __export
+            #else
+            #define BOOST_ARCHIVE_DECL(T) __declspec(dllexport) T
+            #define BOOST_ARCHIVE_OR_WARCHIVE_DECL(T)  __declspec(dllexport) T
+            #endif
+        #else
+            #if defined(__BORLANDC__)
+            #define BOOST_ARCHIVE_DECL(T) T __import
+            #else
+            #define BOOST_ARCHIVE_DECL(T) __declspec(dllimport) T
+            #endif
+        #endif
+        #if defined(BOOST_WARCHIVE_SOURCE)
+            #if defined(__BORLANDC__)
+            #define BOOST_WARCHIVE_DECL(T) T __export
+            #define BOOST_ARCHIVE_OR_WARCHIVE_DECL(T) T __export
+            #else
+            #define BOOST_WARCHIVE_DECL(T) __declspec(dllexport) T
+            #define BOOST_ARCHIVE_OR_WARCHIVE_DECL(T) __declspec(dllexport) T
+            #endif
+        #else
+            #if defined(__BORLANDC__)
+            #define BOOST_WARCHIVE_DECL(T) T __import
+            #else
+            #define BOOST_WARCHIVE_DECL(T) __declspec(dllimport) T
+            #endif
+        #endif
+        #if !defined(BOOST_WARCHIVE_SOURCE) && !defined(BOOST_ARCHIVE_SOURCE)
+            #if defined(__BORLANDC__)
+            #define BOOST_ARCHIVE_OR_WARCHIVE_DECL(T) T __import
+            #else
+            #define BOOST_ARCHIVE_OR_WARCHIVE_DECL(T) __declspec(dllimport) T
+            #endif
+        #endif
+    #endif
+#endif // BOOST_HAS_DECLSPEC
+
+#if ! defined(BOOST_ARCHIVE_DECL)
+    #define BOOST_ARCHIVE_DECL(T) T
+#endif
+#if ! defined(BOOST_WARCHIVE_DECL)
+    #define BOOST_WARCHIVE_DECL(T) T
+#endif
+#if ! defined(BOOST_ARCHIVE_OR_WARCHIVE_DECL)
+    #define BOOST_ARCHIVE_OR_WARCHIVE_DECL(T) T
+#endif
+
+#endif // BOOST_ARCHIVE_DETAIL_DECL_HPP

test/external/boost/archive/detail/interface_iarchive.hpp

@@ -0,0 +1,77 @@
+#ifndef BOOST_ARCHIVE_DETAIL_INTERFACE_IARCHIVE_HPP
+#define BOOST_ARCHIVE_DETAIL_INTERFACE_IARCHIVE_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+# pragma once
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// interface_iarchive.hpp
+
+// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
+// Use, modification and distribution is subject to the Boost Software
+// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+
+//  See http://www.boost.org for updates, documentation, and revision history.
+#include <cstddef> // NULL
+#include <boost/cstdint.hpp>
+#include <boost/mpl/bool.hpp>
+#include <boost/archive/detail/auto_link_archive.hpp>
+#include <boost/archive/detail/iserializer.hpp>
+#include <boost/serialization/singleton.hpp>
+#include <boost/archive/detail/abi_prefix.hpp> // must be the last header
+
+namespace boost {
+namespace archive {
+namespace detail {
+
+class BOOST_ARCHIVE_OR_WARCHIVE_DECL(BOOST_PP_EMPTY()) basic_pointer_iserializer;
+
+template<class Archive>
+class interface_iarchive 
+{
+protected:
+    interface_iarchive(){};
+public:
+    /////////////////////////////////////////////////////////
+    // archive public interface
+    typedef mpl::bool_<true> is_loading;
+    typedef mpl::bool_<false> is_saving;
+
+    // return a pointer to the most derived class
+    Archive * This(){
+        return static_cast<Archive *>(this);
+    }
+
+    template<class T>
+    const basic_pointer_iserializer * 
+    register_type(T * = NULL){
+        const basic_pointer_iserializer & bpis =
+            boost::serialization::singleton<
+                pointer_iserializer<Archive, T> 
+            >::get_const_instance();
+        this->This()->register_basic_serializer(bpis.get_basic_serializer());
+        return & bpis;
+    }
+    template<class T>
+    Archive & operator>>(T & t){
+        this->This()->load_override(t, 0);
+        return * this->This();
+    }
+
+    // the & operator 
+    template<class T>
+    Archive & operator&(T & t){
+        return *(this->This()) >> t;
+    }
+};
+
+} // namespace detail
+} // namespace archive
+} // namespace boost
+
+#include <boost/archive/detail/abi_suffix.hpp> // pops abi_suffix.hpp pragmas
+
+#endif // BOOST_ARCHIVE_DETAIL_INTERFACE_IARCHIVE_HPP

test/external/boost/archive/detail/interface_oarchive.hpp

@@ -0,0 +1,84 @@
+#ifndef BOOST_ARCHIVE_DETAIL_INTERFACE_OARCHIVE_HPP
+#define BOOST_ARCHIVE_DETAIL_INTERFACE_OARCHIVE_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+# pragma once
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// interface_oarchive.hpp
+
+// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
+// Use, modification and distribution is subject to the Boost Software
+// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+
+//  See http://www.boost.org for updates, documentation, and revision history.
+#include <cstddef> // NULL
+#include <boost/cstdint.hpp>
+#include <boost/mpl/bool.hpp>
+
+#include <boost/archive/detail/auto_link_archive.hpp>
+#include <boost/archive/detail/oserializer.hpp>
+#include <boost/archive/detail/abi_prefix.hpp> // must be the last header
+
+#include <boost/serialization/singleton.hpp>
+
+namespace boost {
+namespace archive {
+namespace detail {
+
+class BOOST_ARCHIVE_OR_WARCHIVE_DECL(BOOST_PP_EMPTY()) basic_pointer_oserializer;
+
+template<class Archive>
+class interface_oarchive 
+{
+protected:
+    interface_oarchive(){};
+public:
+    /////////////////////////////////////////////////////////
+    // archive public interface
+    typedef mpl::bool_<false> is_loading;
+    typedef mpl::bool_<true> is_saving;
+
+    // return a pointer to the most derived class
+    Archive * This(){
+        return static_cast<Archive *>(this);
+    }
+
+    template<class T>
+    const basic_pointer_oserializer * 
+    register_type(const T * = NULL){
+        const basic_pointer_oserializer & bpos =
+            boost::serialization::singleton<
+                pointer_oserializer<Archive, T>
+            >::get_const_instance();
+        this->This()->register_basic_serializer(bpos.get_basic_serializer());
+        return & bpos;
+    }
+
+    template<class T>
+    Archive & operator<<(T & t){
+        this->This()->save_override(t, 0);
+        return * this->This();
+    }
+    
+    // the & operator 
+    template<class T>
+    Archive & operator&(T & t){
+        #ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING
+            return * this->This() << const_cast<const T &>(t);
+        #else
+            return * this->This() << t;
+        #endif
+    }
+};
+
+} // namespace detail
+} // namespace archive
+} // namespace boost
+
+#include <boost/archive/detail/abi_suffix.hpp> // pops abi_suffix.hpp pragmas
+
+#endif // BOOST_ARCHIVE_DETAIL_INTERFACE_IARCHIVE_HPP

test/external/boost/archive/detail/iserializer.hpp

@@ -0,0 +1,632 @@
+#ifndef BOOST_ARCHIVE_DETAIL_ISERIALIZER_HPP
+#define BOOST_ARCHIVE_DETAIL_ISERIALIZER_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+# pragma once
+#pragma inline_depth(511)
+#pragma inline_recursion(on)
+#endif
+
+#if defined(__MWERKS__)
+#pragma inline_depth(511)
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// iserializer.hpp: interface for serialization system.
+
+// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
+// Use, modification and distribution is subject to the Boost Software
+// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+
+//  See http://www.boost.org for updates, documentation, and revision history.
+
+#include <new>     // for placement new
+#include <memory>  // for auto_ptr
+#include <cstddef> // size_t, NULL
+
+#include <boost/config.hpp>
+#include <boost/detail/workaround.hpp>
+#if defined(BOOST_NO_STDC_NAMESPACE)
+namespace std{ 
+    using ::size_t; 
+} // namespace std
+#endif
+
+#include <boost/static_assert.hpp>
+
+#include <boost/mpl/eval_if.hpp>
+#include <boost/mpl/identity.hpp>
+#include <boost/mpl/greater_equal.hpp>
+#include <boost/mpl/equal_to.hpp>
+#include <boost/mpl/bool.hpp>
+#include <boost/detail/no_exceptions_support.hpp>
+
+#ifndef BOOST_SERIALIZATION_DEFAULT_TYPE_INFO   
+    #include <boost/serialization/extended_type_info_typeid.hpp>   
+#endif
+#include <boost/serialization/throw_exception.hpp>
+#include <boost/serialization/smart_cast.hpp>
+#include <boost/serialization/static_warning.hpp>
+
+#include <boost/type_traits/is_pointer.hpp>
+#include <boost/type_traits/is_enum.hpp>
+#include <boost/type_traits/is_const.hpp>
+#include <boost/type_traits/remove_const.hpp>
+#include <boost/type_traits/remove_extent.hpp>
+#include <boost/type_traits/is_polymorphic.hpp>
+
+#include <boost/serialization/assume_abstract.hpp>
+
+#define DONT_USE_HAS_NEW_OPERATOR (                    \
+    defined(__BORLANDC__)                              \
+    || defined(__IBMCPP__)                             \
+    || defined(BOOST_MSVC) && (BOOST_MSVC <= 1300)     \
+    || defined(__SUNPRO_CC) && (__SUNPRO_CC < 0x590)   \
+)
+
+#if ! DONT_USE_HAS_NEW_OPERATOR
+#include <boost/type_traits/has_new_operator.hpp>
+#endif
+
+#include <boost/serialization/serialization.hpp>
+#include <boost/serialization/version.hpp>
+#include <boost/serialization/level.hpp>
+#include <boost/serialization/tracking.hpp>
+#include <boost/serialization/type_info_implementation.hpp>
+#include <boost/serialization/nvp.hpp>
+#include <boost/serialization/void_cast.hpp>
+#include <boost/serialization/array.hpp>
+#include <boost/serialization/collection_size_type.hpp>
+#include <boost/serialization/singleton.hpp>
+#include <boost/serialization/wrapper.hpp>
+
+// the following is need only for dynamic cast of polymorphic pointers
+#include <boost/archive/archive_exception.hpp>
+#include <boost/archive/detail/basic_iarchive.hpp>
+#include <boost/archive/detail/basic_iserializer.hpp>
+#include <boost/archive/detail/basic_pointer_iserializer.hpp>
+#include <boost/archive/detail/archive_serializer_map.hpp>
+#include <boost/archive/detail/check.hpp>
+
+namespace boost {
+
+namespace serialization {
+    class extended_type_info;
+} // namespace serialization
+
+namespace archive {
+
+// an accessor to permit friend access to archives.  Needed because
+// some compilers don't handle friend templates completely
+class load_access {
+public:
+    template<class Archive, class T>
+    static void load_primitive(Archive &ar, T &t){
+        ar.load(t);
+    }
+};
+
+namespace detail {
+
+#ifdef BOOST_MSVC
+#  pragma warning(push)
+#  pragma warning(disable : 4511 4512)
+#endif
+
+template<class Archive, class T>
+class iserializer : public basic_iserializer
+{
+private:
+    virtual void destroy(/*const*/ void *address) const {
+        boost::serialization::access::destroy(static_cast<T *>(address));
+    }
+protected:
+    // protected constructor since it's always created by singleton
+    explicit iserializer() :
+        basic_iserializer(
+            boost::serialization::singleton<
+                BOOST_DEDUCED_TYPENAME 
+                boost::serialization::type_info_implementation< T >::type
+            >::get_const_instance()
+        )
+    {}
+public:
+    virtual BOOST_DLLEXPORT void load_object_data(
+        basic_iarchive & ar,
+        void *x, 
+        const unsigned int file_version
+    ) const BOOST_USED;
+    virtual bool class_info() const {
+        return boost::serialization::implementation_level< T >::value 
+            >= boost::serialization::object_class_info;
+    }
+    virtual bool tracking(const unsigned int /* flags */) const {
+        return boost::serialization::tracking_level< T >::value 
+                == boost::serialization::track_always
+            || ( boost::serialization::tracking_level< T >::value 
+                == boost::serialization::track_selectively
+                && serialized_as_pointer());
+    }
+    virtual version_type version() const {
+        return version_type(::boost::serialization::version< T >::value);
+    }
+    virtual bool is_polymorphic() const {
+        return boost::is_polymorphic< T >::value;
+    }
+    virtual ~iserializer(){};
+};
+
+#ifdef BOOST_MSVC
+#  pragma warning(pop)
+#endif
+
+template<class Archive, class T>
+BOOST_DLLEXPORT void iserializer<Archive, T>::load_object_data(
+    basic_iarchive & ar,
+    void *x, 
+    const unsigned int file_version
+) const {
+    // note: we now comment this out. Before we permited archive
+    // version # to be very large.  Now we don't.  To permit
+    // readers of these old archives, we have to suppress this 
+    // code.  Perhaps in the future we might re-enable it but
+    // permit its suppression with a runtime switch.
+    #if 0
+    // trap case where the program cannot handle the current version
+    if(file_version > static_cast<const unsigned int>(version()))
+        boost::serialization::throw_exception(
+            archive::archive_exception(
+                boost::archive::archive_exception::unsupported_class_version,
+                get_debug_info()
+            )
+        );
+    #endif
+    // make sure call is routed through the higest interface that might
+    // be specialized by the user.
+    boost::serialization::serialize_adl(
+        boost::serialization::smart_cast_reference<Archive &>(ar),
+        * static_cast<T *>(x), 
+        file_version
+    );
+}
+
+#ifdef BOOST_MSVC
+#  pragma warning(push)
+#  pragma warning(disable : 4511 4512)
+#endif
+
+template<class Archive, class T>
+class pointer_iserializer :
+    public basic_pointer_iserializer
+{
+private:
+    virtual const basic_iserializer & get_basic_serializer() const {
+        return boost::serialization::singleton<
+            iserializer<Archive, T>
+        >::get_const_instance();
+    }
+    BOOST_DLLEXPORT virtual void load_object_ptr(
+        basic_iarchive & ar, 
+        void * & x,
+        const unsigned int file_version
+    ) const BOOST_USED;
+protected:
+    // this should alway be a singleton so make the constructor protected
+    pointer_iserializer();
+    ~pointer_iserializer();
+};
+
+#ifdef BOOST_MSVC
+#  pragma warning(pop)
+#endif
+
+// note trick to be sure that operator new is using class specific
+// version if such exists. Due to Peter Dimov.
+// note: the following fails if T has no default constructor.
+// otherwise it would have been ideal
+//struct heap_allocator : public T 
+//{
+//    T * invoke(){
+//        return ::new(sizeof(T));
+//    }
+//}
+
+template<class T>
+struct heap_allocator
+{
+    // boost::has_new_operator< T > doesn't work on these compilers
+    #if DONT_USE_HAS_NEW_OPERATOR
+        // This doesn't handle operator new overload for class T
+        static T * invoke(){
+            return static_cast<T *>(operator new(sizeof(T)));
+        }
+    #else
+        struct has_new_operator {
+            static T* invoke() {
+                return static_cast<T *>((T::operator new)(sizeof(T)));
+            }
+        };
+        struct doesnt_have_new_operator {
+            static T* invoke() {
+                return static_cast<T *>(operator new(sizeof(T)));
+            }
+        };
+        static T * invoke() {
+            typedef BOOST_DEDUCED_TYPENAME
+                mpl::eval_if<
+                    boost::has_new_operator< T >,
+                    mpl::identity<has_new_operator >,
+                    mpl::identity<doesnt_have_new_operator >    
+                >::type typex;
+            return typex::invoke();
+        }
+    #endif
+};
+
+// due to Martin Ecker
+template <typename T>
+class auto_ptr_with_deleter
+{
+public:
+    explicit auto_ptr_with_deleter(T* p) :
+        m_p(p)
+    {}
+    ~auto_ptr_with_deleter(){
+        if (m_p)
+            boost::serialization::access::destroy(m_p);
+    }
+    T* get() const {
+        return m_p;
+    }
+
+    T* release() {
+        T* p = m_p;
+        m_p = NULL;
+        return p;
+    }
+private:
+    T* m_p;
+};
+
+// note: BOOST_DLLEXPORT is so that code for polymorphic class
+// serialized only through base class won't get optimized out
+template<class Archive, class T>
+BOOST_DLLEXPORT void pointer_iserializer<Archive, T>::load_object_ptr(
+    basic_iarchive & ar, 
+    void * & x,
+    const unsigned int file_version
+) const
+{
+    Archive & ar_impl = 
+        boost::serialization::smart_cast_reference<Archive &>(ar);
+
+    auto_ptr_with_deleter< T > ap(heap_allocator< T >::invoke());
+    if(NULL == ap.get())
+        boost::serialization::throw_exception(std::bad_alloc()) ;
+
+    T * t = ap.get();
+    x = t;
+
+    // catch exception during load_construct_data so that we don't
+    // automatically delete the t which is most likely not fully
+    // constructed
+    BOOST_TRY {
+        // this addresses an obscure situtation that occurs when 
+        // load_constructor de-serializes something through a pointer.
+        ar.next_object_pointer(t);
+        boost::serialization::load_construct_data_adl<Archive, T>(
+            ar_impl,
+            t, 
+            file_version
+        );
+    }
+    BOOST_CATCH(...){
+        ap.release();
+        BOOST_RETHROW;
+    }
+    BOOST_CATCH_END
+
+    ar_impl >> boost::serialization::make_nvp(NULL, * t);
+    ap.release();
+}
+
+template<class Archive, class T>
+pointer_iserializer<Archive, T>::pointer_iserializer() :
+    basic_pointer_iserializer(
+        boost::serialization::singleton<
+            BOOST_DEDUCED_TYPENAME 
+            boost::serialization::type_info_implementation< T >::type
+        >::get_const_instance()
+    )
+{
+    boost::serialization::singleton<
+        iserializer<Archive, T>
+    >::get_mutable_instance().set_bpis(this);
+    archive_serializer_map<Archive>::insert(this);
+}
+
+template<class Archive, class T>
+pointer_iserializer<Archive, T>::~pointer_iserializer(){
+    archive_serializer_map<Archive>::erase(this);
+}
+
+template<class Archive>
+struct load_non_pointer_type {
+    // note this bounces the call right back to the archive
+    // with no runtime overhead
+    struct load_primitive {
+        template<class T>
+        static void invoke(Archive & ar, T & t){
+            load_access::load_primitive(ar, t);
+        }
+    };
+    // note this bounces the call right back to the archive
+    // with no runtime overhead
+    struct load_only {
+        template<class T>
+        static void invoke(Archive & ar, const T & t){
+            // short cut to user's serializer
+            // make sure call is routed through the higest interface that might
+            // be specialized by the user.
+            boost::serialization::serialize_adl(
+                ar, 
+                const_cast<T &>(t), 
+                boost::serialization::version< T >::value
+            );
+        }
+    };
+
+    // note this save class information including version
+    // and serialization level to the archive
+    struct load_standard {
+        template<class T>
+        static void invoke(Archive &ar, const T & t){
+            void * x = & const_cast<T &>(t);
+            ar.load_object(
+                x, 
+                boost::serialization::singleton<
+                    iserializer<Archive, T>
+                >::get_const_instance()
+            );
+        }
+    };
+
+    struct load_conditional {
+        template<class T>
+        static void invoke(Archive &ar, T &t){
+            //if(0 == (ar.get_flags() & no_tracking))
+                load_standard::invoke(ar, t);
+            //else
+            //    load_only::invoke(ar, t);
+        }
+    };
+
+    template<class T>
+    static void invoke(Archive & ar, T &t){
+        typedef BOOST_DEDUCED_TYPENAME mpl::eval_if<
+                // if its primitive
+                mpl::equal_to<
+                    boost::serialization::implementation_level< T >,
+                    mpl::int_<boost::serialization::primitive_type>
+                >,
+                mpl::identity<load_primitive>,
+            // else
+            BOOST_DEDUCED_TYPENAME mpl::eval_if<
+            // class info / version
+            mpl::greater_equal<
+                        boost::serialization::implementation_level< T >,
+                        mpl::int_<boost::serialization::object_class_info>
+                    >,
+            // do standard load
+            mpl::identity<load_standard>,
+        // else
+        BOOST_DEDUCED_TYPENAME mpl::eval_if<
+            // no tracking
+                    mpl::equal_to<
+                        boost::serialization::tracking_level< T >,
+                        mpl::int_<boost::serialization::track_never>
+                >,
+                // do a fast load
+                mpl::identity<load_only>,
+            // else
+            // do a fast load only tracking is turned off
+            mpl::identity<load_conditional>
+        > > >::type typex;
+        check_object_versioning< T >();
+        check_object_level< T >();
+        typex::invoke(ar, t);
+    }
+};
+
+template<class Archive>
+struct load_pointer_type {
+    struct abstract
+    {
+        template<class T>
+        static const basic_pointer_iserializer * register_type(Archive & /* ar */){
+            // it has? to be polymorphic
+            BOOST_STATIC_ASSERT(boost::is_polymorphic< T >::value);
+            return static_cast<basic_pointer_iserializer *>(NULL);
+         }
+    };
+
+    struct non_abstract
+    {
+        template<class T>
+        static const basic_pointer_iserializer * register_type(Archive & ar){
+            return ar.register_type(static_cast<T *>(NULL));
+        }
+    };
+
+    template<class T>
+    static const basic_pointer_iserializer * register_type(Archive &ar, const T & /*t*/){
+        // there should never be any need to load an abstract polymorphic 
+        // class pointer.  Inhibiting code generation for this
+        // permits abstract base classes to be used - note: exception
+        // virtual serialize functions used for plug-ins
+        typedef BOOST_DEDUCED_TYPENAME
+            mpl::eval_if<
+                boost::serialization::is_abstract<const T>,
+                boost::mpl::identity<abstract>,
+                boost::mpl::identity<non_abstract>  
+            >::type typex;
+        return typex::template register_type< T >(ar);
+    }
+
+    template<class T>
+    static T * pointer_tweak(
+        const boost::serialization::extended_type_info & eti,
+        void const * const t,
+        const T &
+    ) {
+        // tweak the pointer back to the base class
+        return static_cast<T *>(
+            const_cast<void *>(
+                boost::serialization::void_upcast(
+                    eti,
+                    boost::serialization::singleton<
+                        BOOST_DEDUCED_TYPENAME 
+                        boost::serialization::type_info_implementation< T >::type
+                    >::get_const_instance(),
+                    t
+                )
+            )
+        );
+    }
+
+    template<class T>
+    static void check_load(T & /* t */){
+        check_pointer_level< T >();
+        check_pointer_tracking< T >();
+    }
+
+    static const basic_pointer_iserializer *
+    find(const boost::serialization::extended_type_info & type){
+        return static_cast<const basic_pointer_iserializer *>(
+            archive_serializer_map<Archive>::find(type)
+        );
+    }
+
+    template<class Tptr>
+    static void invoke(Archive & ar, Tptr & t){
+        check_load(*t);
+        const basic_pointer_iserializer * bpis_ptr = register_type(ar, *t);
+        const basic_pointer_iserializer * newbpis_ptr = ar.load_pointer(
+            // note major hack here !!!
+            // I tried every way to convert Tptr &t (where Tptr might
+            // include const) to void * &.  This is the only way
+            // I could make it work. RR
+            (void * & )t,
+            bpis_ptr,
+            find
+        );
+        // if the pointer isn't that of the base class
+        if(newbpis_ptr != bpis_ptr){
+            t = pointer_tweak(newbpis_ptr->get_eti(), t, *t);
+        }
+    }
+};
+
+template<class Archive>
+struct load_enum_type {
+    template<class T>
+    static void invoke(Archive &ar, T &t){
+        // convert integers to correct enum to load
+        int i;
+        ar >> boost::serialization::make_nvp(NULL, i);
+        t = static_cast< T >(i);
+    }
+};
+
+template<class Archive>
+struct load_array_type {
+    template<class T>
+    static void invoke(Archive &ar, T &t){
+        typedef BOOST_DEDUCED_TYPENAME remove_extent< T >::type value_type;
+        
+        // convert integers to correct enum to load
+        // determine number of elements in the array. Consider the
+        // fact that some machines will align elements on boundries
+        // other than characters.
+        std::size_t current_count = sizeof(t) / (
+            static_cast<char *>(static_cast<void *>(&t[1])) 
+            - static_cast<char *>(static_cast<void *>(&t[0]))
+        );
+        boost::serialization::collection_size_type count;
+        ar >> BOOST_SERIALIZATION_NVP(count);
+        if(static_cast<std::size_t>(count) > current_count)
+            boost::serialization::throw_exception(
+                archive::archive_exception(
+                    boost::archive::archive_exception::array_size_too_short
+                )
+            );
+        ar >> serialization::make_array(static_cast<value_type*>(&t[0]),count);
+    }
+};
+
+} // detail
+
+template<class Archive, class T>
+inline void load(Archive & ar, T &t){
+    // if this assertion trips. It means we're trying to load a
+    // const object with a compiler that doesn't have correct
+    // funtion template ordering.  On other compilers, this is
+    // handled below.
+    detail::check_const_loading< T >();
+    typedef
+        BOOST_DEDUCED_TYPENAME mpl::eval_if<is_pointer< T >,
+            mpl::identity<detail::load_pointer_type<Archive> >
+        ,//else
+        BOOST_DEDUCED_TYPENAME mpl::eval_if<is_array< T >,
+            mpl::identity<detail::load_array_type<Archive> >
+        ,//else
+        BOOST_DEDUCED_TYPENAME mpl::eval_if<is_enum< T >,
+            mpl::identity<detail::load_enum_type<Archive> >
+        ,//else
+            mpl::identity<detail::load_non_pointer_type<Archive> >
+        >
+        >
+        >::type typex;
+    typex::invoke(ar, t);
+}
+
+#if 0
+
+// BORLAND
+#if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x560))
+// borland has a couple of problems
+// a) if function is partially specialized - see below
+// const paramters are transformed to non-const ones
+// b) implementation of base_object can't be made to work
+// correctly which results in all base_object s being const.
+// So, strip off the const for borland.  This breaks the trap
+// for loading const objects - but I see no alternative
+template<class Archive, class T>
+inline void load(Archive &ar, const T & t){
+    load(ar, const_cast<T &>(t));
+}
+#endif
+
+// let wrappers through.
+#ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING
+template<class Archive, class T>
+inline void load_wrapper(Archive &ar, const T&t, mpl::true_){
+    boost::archive::load(ar, const_cast<T&>(t));
+}
+
+#if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x560))
+template<class Archive, class T>
+inline void load(Archive &ar, const T&t){
+  load_wrapper(ar,t,serialization::is_wrapper< T >());
+}
+#endif 
+#endif
+
+#endif
+
+} // namespace archive
+} // namespace boost
+
+#endif // BOOST_ARCHIVE_DETAIL_ISERIALIZER_HPP

test/external/boost/archive/detail/oserializer.hpp

@@ -0,0 +1,531 @@
+#ifndef BOOST_ARCHIVE_OSERIALIZER_HPP
+#define BOOST_ARCHIVE_OSERIALIZER_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+# pragma once
+#pragma inline_depth(511)
+#pragma inline_recursion(on)
+#endif
+
+#if defined(__MWERKS__)
+#pragma inline_depth(511)
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// oserializer.hpp: interface for serialization system.
+
+// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
+// Use, modification and distribution is subject to the Boost Software
+// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+
+//  See http://www.boost.org for updates, documentation, and revision history.
+
+#include <boost/assert.hpp>
+#include <cstddef> // NULL
+
+#include <boost/config.hpp>
+#include <boost/static_assert.hpp>
+#include <boost/detail/workaround.hpp>
+
+#include <boost/mpl/eval_if.hpp>
+#include <boost/mpl/equal_to.hpp>
+#include <boost/mpl/greater_equal.hpp>
+#include <boost/mpl/identity.hpp>
+
+#ifndef BOOST_SERIALIZATION_DEFAULT_TYPE_INFO   
+    #include <boost/serialization/extended_type_info_typeid.hpp>   
+#endif
+#include <boost/serialization/throw_exception.hpp>
+#include <boost/serialization/smart_cast.hpp>
+#include <boost/serialization/assume_abstract.hpp>
+#include <boost/serialization/static_warning.hpp>
+
+#include <boost/type_traits/is_pointer.hpp>
+#include <boost/type_traits/is_enum.hpp>
+#include <boost/type_traits/is_const.hpp>
+#include <boost/type_traits/is_polymorphic.hpp>
+#include <boost/type_traits/remove_extent.hpp>
+
+#include <boost/serialization/serialization.hpp>
+#include <boost/serialization/version.hpp>
+#include <boost/serialization/level.hpp>
+#include <boost/serialization/tracking.hpp>
+#include <boost/serialization/type_info_implementation.hpp>
+#include <boost/serialization/nvp.hpp>
+#include <boost/serialization/void_cast.hpp>
+#include <boost/serialization/array.hpp>
+#include <boost/serialization/collection_size_type.hpp>
+#include <boost/serialization/singleton.hpp>
+
+#include <boost/archive/archive_exception.hpp>
+#include <boost/archive/detail/basic_oarchive.hpp>
+#include <boost/archive/detail/basic_oserializer.hpp>
+#include <boost/archive/detail/basic_pointer_oserializer.hpp>
+#include <boost/archive/detail/archive_serializer_map.hpp>
+#include <boost/archive/detail/check.hpp>
+
+namespace boost {
+
+namespace serialization {
+    class extended_type_info;
+} // namespace serialization
+
+namespace archive {
+
+// an accessor to permit friend access to archives.  Needed because
+// some compilers don't handle friend templates completely
+class save_access {
+public:
+    template<class Archive>
+    static void end_preamble(Archive & ar){
+        ar.end_preamble();
+    }
+    template<class Archive, class T>
+    static void save_primitive(Archive & ar, const  T & t){
+        ar.end_preamble();
+        ar.save(t);
+    }
+};
+
+namespace detail {
+
+#ifdef BOOST_MSVC
+#  pragma warning(push)
+#  pragma warning(disable : 4511 4512)
+#endif
+
+template<class Archive, class T>
+class oserializer : public basic_oserializer
+{
+private:
+    // private constructor to inhibit any existence other than the 
+    // static one
+public:
+    explicit BOOST_DLLEXPORT oserializer() :
+        basic_oserializer(
+            boost::serialization::singleton<
+                BOOST_DEDUCED_TYPENAME 
+                boost::serialization::type_info_implementation< T >::type
+            >::get_const_instance()
+        )
+    {}
+    virtual BOOST_DLLEXPORT void save_object_data(
+        basic_oarchive & ar,    
+        const void *x
+    ) const BOOST_USED;
+    virtual bool class_info() const {
+        return boost::serialization::implementation_level< T >::value 
+            >= boost::serialization::object_class_info;
+    }
+    virtual bool tracking(const unsigned int /* flags */) const {
+        return boost::serialization::tracking_level< T >::value == boost::serialization::track_always
+            || (boost::serialization::tracking_level< T >::value == boost::serialization::track_selectively
+                && serialized_as_pointer());
+    }
+    virtual version_type version() const {
+        return version_type(::boost::serialization::version< T >::value);
+    }
+    virtual bool is_polymorphic() const {
+        return boost::is_polymorphic< T >::value;
+    }
+    virtual ~oserializer(){}
+};
+
+#ifdef BOOST_MSVC
+#  pragma warning(pop)
+#endif
+
+template<class Archive, class T>
+BOOST_DLLEXPORT void oserializer<Archive, T>::save_object_data(
+    basic_oarchive & ar,    
+    const void *x
+) const {
+    // make sure call is routed through the highest interface that might
+    // be specialized by the user.
+    BOOST_STATIC_ASSERT(boost::is_const< T >::value == false);
+    boost::serialization::serialize_adl(
+        boost::serialization::smart_cast_reference<Archive &>(ar),
+        * static_cast<T *>(const_cast<void *>(x)),
+        version()
+    );
+}
+
+#ifdef BOOST_MSVC
+#  pragma warning(push)
+#  pragma warning(disable : 4511 4512)
+#endif
+
+template<class Archive, class T>
+class pointer_oserializer :
+    public basic_pointer_oserializer
+{
+private:
+    const basic_oserializer & 
+    get_basic_serializer() const {
+        return boost::serialization::singleton<
+            oserializer<Archive, T>
+        >::get_const_instance();
+    }
+    virtual BOOST_DLLEXPORT void save_object_ptr(
+        basic_oarchive & ar,
+        const void * x
+    ) const BOOST_USED;
+public:
+    pointer_oserializer();
+    ~pointer_oserializer();
+};
+
+#ifdef BOOST_MSVC
+#  pragma warning(pop)
+#endif
+
+template<class Archive, class T>
+BOOST_DLLEXPORT void pointer_oserializer<Archive, T>::save_object_ptr(
+    basic_oarchive & ar,
+    const void * x
+) const {
+    BOOST_ASSERT(NULL != x);
+    // make sure call is routed through the highest interface that might
+    // be specialized by the user.
+    T * t = static_cast<T *>(const_cast<void *>(x));
+    const unsigned int file_version = boost::serialization::version< T >::value;
+    Archive & ar_impl 
+        = boost::serialization::smart_cast_reference<Archive &>(ar);
+    boost::serialization::save_construct_data_adl<Archive, T>(
+        ar_impl, 
+        t, 
+        file_version
+    );
+    ar_impl << boost::serialization::make_nvp(NULL, * t);
+}
+
+template<class Archive, class T>
+pointer_oserializer<Archive, T>::pointer_oserializer() :
+    basic_pointer_oserializer(
+        boost::serialization::singleton<
+            BOOST_DEDUCED_TYPENAME 
+            boost::serialization::type_info_implementation< T >::type
+        >::get_const_instance()
+    )
+{
+    // make sure appropriate member function is instantiated
+    boost::serialization::singleton<
+        oserializer<Archive, T> 
+    >::get_mutable_instance().set_bpos(this);
+    archive_serializer_map<Archive>::insert(this);
+}
+
+template<class Archive, class T>
+pointer_oserializer<Archive, T>::~pointer_oserializer(){
+    archive_serializer_map<Archive>::erase(this);
+}
+
+template<class Archive>
+struct save_non_pointer_type {
+    // note this bounces the call right back to the archive
+    // with no runtime overhead
+    struct save_primitive {
+        template<class T>
+        static void invoke(Archive & ar, const T & t){
+            save_access::save_primitive(ar, t);
+        }
+    };
+    // same as above but passes through serialization
+    struct save_only {
+        template<class T>
+        static void invoke(Archive & ar, const T & t){
+            // make sure call is routed through the highest interface that might
+            // be specialized by the user.
+            boost::serialization::serialize_adl(
+                ar, 
+                const_cast<T &>(t), 
+                ::boost::serialization::version< T >::value
+            );
+        }
+    };
+    // adds class information to the archive. This includes
+    // serialization level and class version
+    struct save_standard {
+        template<class T>
+        static void invoke(Archive &ar, const T & t){
+            ar.save_object(
+                & t, 
+                boost::serialization::singleton<
+                    oserializer<Archive, T>
+                >::get_const_instance()
+            );
+        }
+    };
+
+    // adds class information to the archive. This includes
+    // serialization level and class version
+    struct save_conditional {
+        template<class T>
+        static void invoke(Archive &ar, const T &t){
+            //if(0 == (ar.get_flags() & no_tracking))
+                save_standard::invoke(ar, t);
+            //else
+            //   save_only::invoke(ar, t);
+        }
+    };
+
+
+    template<class T>
+    static void invoke(Archive & ar, const T & t){
+        typedef 
+            BOOST_DEDUCED_TYPENAME mpl::eval_if<
+            // if its primitive
+                mpl::equal_to<
+                    boost::serialization::implementation_level< T >,
+                    mpl::int_<boost::serialization::primitive_type>
+                >,
+                mpl::identity<save_primitive>,
+            // else
+            BOOST_DEDUCED_TYPENAME mpl::eval_if<
+                // class info / version
+                mpl::greater_equal<
+                    boost::serialization::implementation_level< T >,
+                    mpl::int_<boost::serialization::object_class_info>
+                >,
+                // do standard save
+                mpl::identity<save_standard>,
+            // else
+            BOOST_DEDUCED_TYPENAME mpl::eval_if<
+                    // no tracking
+                mpl::equal_to<
+                    boost::serialization::tracking_level< T >,
+                    mpl::int_<boost::serialization::track_never>
+                >,
+                // do a fast save
+                mpl::identity<save_only>,
+            // else
+                // do a fast save only tracking is turned off
+                mpl::identity<save_conditional>
+            > > >::type typex; 
+        check_object_versioning< T >();
+        typex::invoke(ar, t);
+    }
+    template<class T>
+    static void invoke(Archive & ar, T & t){
+        check_object_level< T >();
+        check_object_tracking< T >();
+        invoke(ar, const_cast<const T &>(t));
+    }
+};
+
+template<class Archive>
+struct save_pointer_type {
+    struct abstract
+    {
+        template<class T>
+        static const basic_pointer_oserializer * register_type(Archive & /* ar */){
+            // it has? to be polymorphic
+            BOOST_STATIC_ASSERT(boost::is_polymorphic< T >::value);
+            return NULL;
+        }
+    };
+
+    struct non_abstract
+    {
+        template<class T>
+        static const basic_pointer_oserializer * register_type(Archive & ar){
+            return ar.register_type(static_cast<T *>(NULL));
+        }
+    };
+
+    template<class T>
+    static const basic_pointer_oserializer * register_type(Archive &ar, T & /*t*/){
+        // there should never be any need to save an abstract polymorphic 
+        // class pointer.  Inhibiting code generation for this
+        // permits abstract base classes to be used - note: exception
+        // virtual serialize functions used for plug-ins
+        typedef 
+            BOOST_DEDUCED_TYPENAME mpl::eval_if<
+                boost::serialization::is_abstract< T >,
+                mpl::identity<abstract>,
+                mpl::identity<non_abstract>       
+            >::type typex;
+        return typex::template register_type< T >(ar);
+    }
+
+    struct non_polymorphic
+    {
+        template<class T>
+        static void save(
+            Archive &ar, 
+            T & t
+        ){
+            const basic_pointer_oserializer & bpos = 
+                boost::serialization::singleton<
+                    pointer_oserializer<Archive, T>
+                >::get_const_instance();
+            // save the requested pointer type
+            ar.save_pointer(& t, & bpos);
+        }
+    };
+
+    struct polymorphic
+    {
+        template<class T>
+        static void save(
+            Archive &ar, 
+            T & t
+        ){
+            BOOST_DEDUCED_TYPENAME 
+            boost::serialization::type_info_implementation< T >::type const
+            & i = boost::serialization::singleton<
+                BOOST_DEDUCED_TYPENAME 
+                boost::serialization::type_info_implementation< T >::type
+            >::get_const_instance();
+
+            boost::serialization::extended_type_info const * const this_type = & i;
+
+            // retrieve the true type of the object pointed to
+            // if this assertion fails its an error in this library
+            BOOST_ASSERT(NULL != this_type);
+
+            const boost::serialization::extended_type_info * true_type =
+                i.get_derived_extended_type_info(t);
+
+            // note:if this exception is thrown, be sure that derived pointer
+            // is either registered or exported.
+            if(NULL == true_type){
+                boost::serialization::throw_exception(
+                    archive_exception(
+                        archive_exception::unregistered_class,
+                        "derived class not registered or exported"
+                    )
+                );
+            }
+
+            // if its not a pointer to a more derived type
+            const void *vp = static_cast<const void *>(&t);
+            if(*this_type == *true_type){
+                const basic_pointer_oserializer * bpos = register_type(ar, t);
+                ar.save_pointer(vp, bpos);
+                return;
+            }
+            // convert pointer to more derived type. if this is thrown
+            // it means that the base/derived relationship hasn't be registered
+            vp = serialization::void_downcast(
+                *true_type, 
+                *this_type, 
+                static_cast<const void *>(&t)
+            );
+            if(NULL == vp){
+                boost::serialization::throw_exception(
+                    archive_exception(
+                        archive_exception::unregistered_cast,
+                        true_type->get_debug_info(),
+                        this_type->get_debug_info()
+                    )
+                );
+            }
+
+            // since true_type is valid, and this only gets made if the 
+            // pointer oserializer object has been created, this should never
+            // fail
+            const basic_pointer_oserializer * bpos
+                = static_cast<const basic_pointer_oserializer *>(
+                    boost::serialization::singleton<
+                        archive_serializer_map<Archive>
+                    >::get_const_instance().find(*true_type)
+                );
+            BOOST_ASSERT(NULL != bpos);
+            if(NULL == bpos)
+                boost::serialization::throw_exception(
+                    archive_exception(
+                        archive_exception::unregistered_class,
+                        "derived class not registered or exported"
+                    )
+                );
+            ar.save_pointer(vp, bpos);
+        }
+    };
+
+    template<class T>
+    static void save(
+        Archive & ar, 
+        const T & t
+    ){
+        check_pointer_level< T >();
+        check_pointer_tracking< T >();
+        typedef BOOST_DEDUCED_TYPENAME mpl::eval_if<
+            is_polymorphic< T >,
+            mpl::identity<polymorphic>,
+            mpl::identity<non_polymorphic>
+        >::type type;
+        type::save(ar, const_cast<T &>(t));
+    }
+
+    template<class TPtr>
+    static void invoke(Archive &ar, const TPtr t){
+        register_type(ar, * t);
+        if(NULL == t){
+            basic_oarchive & boa 
+                = boost::serialization::smart_cast_reference<basic_oarchive &>(ar);
+            boa.save_null_pointer();
+            save_access::end_preamble(ar);
+            return;
+        }
+        save(ar, * t);
+    }
+};
+
+template<class Archive>
+struct save_enum_type
+{
+    template<class T>
+    static void invoke(Archive &ar, const T &t){
+        // convert enum to integers on save
+        const int i = static_cast<int>(t);
+        ar << boost::serialization::make_nvp(NULL, i);
+    }
+};
+
+template<class Archive>
+struct save_array_type
+{
+    template<class T>
+    static void invoke(Archive &ar, const T &t){
+        typedef BOOST_DEDUCED_TYPENAME boost::remove_extent< T >::type value_type;
+        
+        save_access::end_preamble(ar);
+        // consider alignment
+        std::size_t c = sizeof(t) / (
+            static_cast<const char *>(static_cast<const void *>(&t[1])) 
+            - static_cast<const char *>(static_cast<const void *>(&t[0]))
+        );
+        boost::serialization::collection_size_type count(c);
+        ar << BOOST_SERIALIZATION_NVP(count);
+        ar << serialization::make_array(static_cast<value_type const*>(&t[0]),count);
+    }
+};
+
+} // detail
+
+template<class Archive, class T>
+inline void save(Archive & ar, /*const*/ T &t){
+    typedef 
+        BOOST_DEDUCED_TYPENAME mpl::eval_if<is_pointer< T >,
+            mpl::identity<detail::save_pointer_type<Archive> >,
+        //else
+        BOOST_DEDUCED_TYPENAME mpl::eval_if<is_enum< T >,
+            mpl::identity<detail::save_enum_type<Archive> >,
+        //else
+        BOOST_DEDUCED_TYPENAME mpl::eval_if<is_array< T >,
+            mpl::identity<detail::save_array_type<Archive> >,
+        //else
+            mpl::identity<detail::save_non_pointer_type<Archive> >
+        >
+        >
+        >::type typex;
+    typex::invoke(ar, t);
+}
+
+} // namespace archive
+} // namespace boost
+
+#endif // BOOST_ARCHIVE_OSERIALIZER_HPP

test/external/boost/archive/detail/polymorphic_iarchive_route.hpp

@@ -0,0 +1,215 @@
+#ifndef BOOST_ARCHIVE_DETAIL_POLYMORPHIC_IARCHIVE_ROUTE_HPP
+#define BOOST_ARCHIVE_DETAIL_POLYMORPHIC_IARCHIVE_ROUTE_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+# pragma once
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// polymorphic_iarchive_route.hpp
+
+// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
+// Use, modification and distribution is subject to the Boost Software
+// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+
+//  See http://www.boost.org for updates, documentation, and revision history.
+
+#include <string>
+#include <ostream>
+#include <cstddef>
+
+#include <boost/config.hpp>
+#if defined(BOOST_NO_STDC_NAMESPACE)
+namespace std{
+    using ::size_t;
+} // namespace std
+#endif
+
+#include <boost/cstdint.hpp>
+#include <boost/integer_traits.hpp>
+#include <boost/archive/polymorphic_iarchive.hpp>
+#include <boost/archive/detail/abi_prefix.hpp> // must be the last header
+
+namespace boost {
+namespace serialization {
+    class extended_type_info;
+} // namespace serialization
+namespace archive {
+namespace detail{
+
+class BOOST_ARCHIVE_DECL(BOOST_PP_EMPTY()) basic_iserializer;
+class BOOST_ARCHIVE_DECL(BOOST_PP_EMPTY()) basic_pointer_iserializer;
+
+#ifdef BOOST_MSVC
+#  pragma warning(push)
+#  pragma warning(disable : 4511 4512)
+#endif
+
+template<class ArchiveImplementation>
+class polymorphic_iarchive_route :
+    public polymorphic_iarchive,
+    // note: gcc dynamic cross cast fails if the the derivation below is
+    // not public.  I think this is a mistake.
+    public /*protected*/ ArchiveImplementation
+{
+private:
+    // these are used by the serialization library.
+    virtual void load_object(
+        void *t,
+        const basic_iserializer & bis
+    ){
+        ArchiveImplementation::load_object(t, bis);
+    }
+    virtual const basic_pointer_iserializer * load_pointer(
+        void * & t,
+        const basic_pointer_iserializer * bpis_ptr,
+        const basic_pointer_iserializer * (*finder)(
+            const boost::serialization::extended_type_info & type
+        )
+    ){
+        return ArchiveImplementation::load_pointer(t, bpis_ptr, finder);
+    }
+    virtual void set_library_version(library_version_type archive_library_version){
+        ArchiveImplementation::set_library_version(archive_library_version);
+    }
+    virtual library_version_type get_library_version() const{
+        return ArchiveImplementation::get_library_version();
+    }
+    virtual unsigned int get_flags() const {
+        return ArchiveImplementation::get_flags();
+    }
+    virtual void delete_created_pointers(){
+        ArchiveImplementation::delete_created_pointers();
+    }
+    virtual void reset_object_address(
+        const void * new_address,
+        const void * old_address
+    ){
+        ArchiveImplementation::reset_object_address(new_address, old_address);
+    }
+    virtual void load_binary(void * t, std::size_t size){
+        ArchiveImplementation::load_binary(t, size);
+    }
+    // primitive types the only ones permitted by polymorphic archives
+    virtual void load(bool & t){
+        ArchiveImplementation::load(t);
+    }
+    virtual void load(char & t){
+        ArchiveImplementation::load(t);
+    }
+    virtual void load(signed char & t){
+        ArchiveImplementation::load(t);
+    }
+    virtual void load(unsigned char & t){
+        ArchiveImplementation::load(t);
+    }
+    #ifndef BOOST_NO_CWCHAR
+    #ifndef BOOST_NO_INTRINSIC_WCHAR_T
+    virtual void load(wchar_t & t){
+        ArchiveImplementation::load(t);
+    }
+    #endif
+    #endif
+    virtual void load(short & t){
+        ArchiveImplementation::load(t);
+    }
+    virtual void load(unsigned short & t){
+        ArchiveImplementation::load(t);
+    }
+    virtual void load(int & t){
+        ArchiveImplementation::load(t);
+    }
+    virtual void load(unsigned int & t){
+        ArchiveImplementation::load(t);
+    }
+    virtual void load(long & t){
+        ArchiveImplementation::load(t);
+    }
+    virtual void load(unsigned long & t){
+        ArchiveImplementation::load(t);
+    }
+    #if defined(BOOST_HAS_LONG_LONG)
+    virtual void load(boost::long_long_type & t){
+        ArchiveImplementation::load(t);
+    }
+    virtual void load(boost::ulong_long_type & t){
+        ArchiveImplementation::load(t);
+    }
+    #elif defined(BOOST_HAS_MS_INT64)
+    virtual void load(__int64 & t){
+        ArchiveImplementation::load(t);
+    }
+    virtual void load(unsigned __int64 & t){
+        ArchiveImplementation::load(t);
+    }
+    #endif
+    virtual void load(float & t){
+        ArchiveImplementation::load(t);
+    }
+    virtual void load(double & t){
+        ArchiveImplementation::load(t);
+    }
+    virtual void load(std::string & t){
+        ArchiveImplementation::load(t);
+    }
+    #ifndef BOOST_NO_STD_WSTRING
+    virtual void load(std::wstring & t){
+        ArchiveImplementation::load(t);
+    }
+    #endif
+    // used for xml and other tagged formats default does nothing
+    virtual void load_start(const char * name){
+        ArchiveImplementation::load_start(name);
+    }
+    virtual void load_end(const char * name){
+        ArchiveImplementation::load_end(name);
+    }
+
+    virtual void register_basic_serializer(const basic_iserializer & bis){
+        ArchiveImplementation::register_basic_serializer(bis);
+    }
+public:
+    // this can't be inheriteded because they appear in mulitple
+    // parents
+    typedef mpl::bool_<true> is_loading;
+    typedef mpl::bool_<false> is_saving;
+    // the >> operator
+    template<class T>
+    polymorphic_iarchive & operator>>(T & t){
+        return polymorphic_iarchive::operator>>(t);
+    }
+    // the & operator
+    template<class T>
+    polymorphic_iarchive & operator&(T & t){
+        return polymorphic_iarchive::operator&(t);
+    }
+    // register type function
+    template<class T>
+    const basic_pointer_iserializer * 
+    register_type(T * t = NULL){
+        return ArchiveImplementation::register_type(t);
+    }
+    // all current archives take a stream as constructor argument
+    template <class _Elem, class _Tr>
+    polymorphic_iarchive_route(
+        std::basic_istream<_Elem, _Tr> & is,
+        unsigned int flags = 0
+    ) :
+        ArchiveImplementation(is, flags)
+    {}
+    virtual ~polymorphic_iarchive_route(){};
+};
+
+} // namespace detail
+} // namespace archive
+} // namespace boost
+
+#ifdef BOOST_MSVC
+#pragma warning(pop)
+#endif
+
+#include <boost/archive/detail/abi_suffix.hpp> // pops abi_suffix.hpp pragmas
+
+#endif // BOOST_ARCHIVE_DETAIL_POLYMORPHIC_IARCHIVE_DISPATCH_HPP

test/external/boost/archive/detail/polymorphic_oarchive_route.hpp

@@ -0,0 +1,205 @@
+#ifndef BOOST_ARCHIVE_DETAIL_POLYMORPHIC_OARCHIVE_ROUTE_HPP
+#define BOOST_ARCHIVE_DETAIL_POLYMORPHIC_OARCHIVE_ROUTE_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+# pragma once
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// polymorphic_oarchive_route.hpp
+
+// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
+// Use, modification and distribution is subject to the Boost Software
+// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+
+//  See http://www.boost.org for updates, documentation, and revision history.
+
+#include <string>
+#include <ostream>
+#include <cstddef> // size_t
+
+#include <boost/config.hpp>
+#if defined(BOOST_NO_STDC_NAMESPACE)
+namespace std{
+    using ::size_t;
+} // namespace std
+#endif
+
+#include <boost/cstdint.hpp>
+#include <boost/integer_traits.hpp>
+#include <boost/archive/polymorphic_oarchive.hpp>
+#include <boost/archive/detail/abi_prefix.hpp> // must be the last header
+
+namespace boost {
+namespace serialization {
+    class extended_type_info;
+} // namespace serialization
+namespace archive {
+namespace detail{
+
+class BOOST_ARCHIVE_DECL(BOOST_PP_EMPTY()) basic_oserializer;
+class BOOST_ARCHIVE_DECL(BOOST_PP_EMPTY()) basic_pointer_oserializer;
+
+#ifdef BOOST_MSVC
+#  pragma warning(push)
+#  pragma warning(disable : 4511 4512)
+#endif
+
+template<class ArchiveImplementation>
+class polymorphic_oarchive_route :
+    public polymorphic_oarchive,
+    // note: gcc dynamic cross cast fails if the the derivation below is
+    // not public.  I think this is a mistake.
+    public /*protected*/ ArchiveImplementation
+{
+private:
+    // these are used by the serialization library.
+    virtual void save_object(
+        const void *x,
+        const detail::basic_oserializer & bos
+    ){
+        ArchiveImplementation::save_object(x, bos);
+    }
+    virtual void save_pointer(
+        const void * t,
+        const detail::basic_pointer_oserializer * bpos_ptr
+    ){
+        ArchiveImplementation::save_pointer(t, bpos_ptr);
+    }
+    virtual void save_null_pointer(){
+        ArchiveImplementation::save_null_pointer();
+    }
+    // primitive types the only ones permitted by polymorphic archives
+    virtual void save(const bool t){
+        ArchiveImplementation::save(t);
+    }
+    virtual void save(const char t){
+        ArchiveImplementation::save(t);
+    }
+    virtual void save(const signed char t){
+        ArchiveImplementation::save(t);
+    }
+    virtual void save(const unsigned char t){
+        ArchiveImplementation::save(t);
+    }
+    #ifndef BOOST_NO_CWCHAR
+    #ifndef BOOST_NO_INTRINSIC_WCHAR_T
+    virtual void save(const wchar_t t){
+        ArchiveImplementation::save(t);
+    }
+    #endif
+    #endif
+    virtual void save(const short t){
+        ArchiveImplementation::save(t);
+    }
+    virtual void save(const unsigned short t){
+        ArchiveImplementation::save(t);
+    }
+    virtual void save(const int t){
+        ArchiveImplementation::save(t);
+    }
+    virtual void save(const unsigned int t){
+        ArchiveImplementation::save(t);
+    }
+    virtual void save(const long t){
+        ArchiveImplementation::save(t);
+    }
+    virtual void save(const unsigned long t){
+        ArchiveImplementation::save(t);
+    }
+    #if defined(BOOST_HAS_LONG_LONG)
+    virtual void save(const boost::long_long_type t){
+        ArchiveImplementation::save(t);
+    }
+    virtual void save(const boost::ulong_long_type t){
+        ArchiveImplementation::save(t);
+    }
+    #elif defined(BOOST_HAS_MS_INT64)
+    virtual void save(const boost::int64_t t){
+        ArchiveImplementation::save(t);
+    }
+    virtual void save(const boost::uint64_t t){
+        ArchiveImplementation::save(t);
+    }
+    #endif
+    virtual void save(const float t){
+        ArchiveImplementation::save(t);
+    }
+    virtual void save(const double t){
+        ArchiveImplementation::save(t);
+    }
+    virtual void save(const std::string & t){
+        ArchiveImplementation::save(t);
+    }
+    #ifndef BOOST_NO_STD_WSTRING
+    virtual void save(const std::wstring & t){
+        ArchiveImplementation::save(t);
+    }
+    #endif
+    virtual library_version_type get_library_version() const{
+        return ArchiveImplementation::get_library_version();
+    }
+    virtual unsigned int get_flags() const {
+        return ArchiveImplementation::get_flags();
+    }
+    virtual void save_binary(const void * t, std::size_t size){
+        ArchiveImplementation::save_binary(t, size);
+    }
+    // used for xml and other tagged formats default does nothing
+    virtual void save_start(const char * name){
+        ArchiveImplementation::save_start(name);
+    }
+    virtual void save_end(const char * name){
+        ArchiveImplementation::save_end(name);
+    }
+    virtual void end_preamble(){
+        ArchiveImplementation::end_preamble();
+    }
+    virtual void register_basic_serializer(const detail::basic_oserializer & bos){
+        ArchiveImplementation::register_basic_serializer(bos);
+    }
+public:
+    // this can't be inheriteded because they appear in mulitple
+    // parents
+    typedef mpl::bool_<false> is_loading;
+    typedef mpl::bool_<true> is_saving;
+    // the << operator
+    template<class T>
+    polymorphic_oarchive & operator<<(T & t){
+        return polymorphic_oarchive::operator<<(t);
+    }
+    // the & operator
+    template<class T>
+    polymorphic_oarchive & operator&(T & t){
+        return polymorphic_oarchive::operator&(t);
+    }
+    // register type function
+    template<class T>
+    const basic_pointer_oserializer * 
+    register_type(T * t = NULL){
+        return ArchiveImplementation::register_type(t);
+    }
+    // all current archives take a stream as constructor argument
+    template <class _Elem, class _Tr>
+    polymorphic_oarchive_route(
+        std::basic_ostream<_Elem, _Tr> & os,
+        unsigned int flags = 0
+    ) :
+        ArchiveImplementation(os, flags)
+    {}
+    virtual ~polymorphic_oarchive_route(){};
+};
+
+} // namespace detail
+} // namespace archive
+} // namespace boost
+
+#ifdef BOOST_MSVC
+#pragma warning(pop)
+#endif
+
+#include <boost/archive/detail/abi_suffix.hpp> // pops abi_suffix.hpp pragmas
+
+#endif // BOOST_ARCHIVE_DETAIL_POLYMORPHIC_OARCHIVE_DISPATCH_HPP

test/external/boost/archive/detail/register_archive.hpp

@@ -0,0 +1,91 @@
+// Copyright David Abrahams 2006. Distributed under the Boost
+// Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+#ifndef BOOST_ARCHIVE_DETAIL_REGISTER_ARCHIVE_DWA2006521_HPP
+# define BOOST_ARCHIVE_DETAIL_REGISTER_ARCHIVE_DWA2006521_HPP
+
+namespace boost { namespace archive { namespace detail { 
+
+// No instantiate_ptr_serialization overloads generated by
+// BOOST_SERIALIZATION_REGISTER_ARCHIVE that lexically follow the call
+// will be seen *unless* they are in an associated namespace of one of
+// the arguments, so we pass one of these along to make sure this
+// namespace is considered.  See temp.dep.candidate (14.6.4.2) in the
+// standard.
+struct adl_tag {};
+
+template <class Archive, class Serializable>
+struct ptr_serialization_support;
+
+// We could've just used ptr_serialization_support, above, but using
+// it with only a forward declaration causes vc6/7 to complain about a
+// missing instantiate member, even if it has one.  This is just a
+// friendly layer of indirection.
+template <class Archive, class Serializable>
+struct _ptr_serialization_support
+  : ptr_serialization_support<Archive,Serializable>
+{
+    typedef int type;
+};
+
+#ifdef __SUNPRO_CC
+
+template<int N>
+struct counter : counter<N-1> {};
+template<>
+struct counter<0> {};
+
+template<class Serializable>
+void instantiate_ptr_serialization(Serializable* s, int, adl_tag) {
+    instantiate_ptr_serialization(s, counter<20>());
+}
+
+template<class Archive>
+struct get_counter {
+    static const int value = sizeof(adjust_counter(counter<20>()));
+    typedef counter<value> type;
+    typedef counter<value - 1> prior;
+    typedef char (&next)[value+1];
+};
+
+char adjust_counter(counter<0>);
+template<class Serializable>
+void instantiate_ptr_serialization(Serializable*, counter<0>) {}
+
+#define BOOST_SERIALIZATION_REGISTER_ARCHIVE(Archive)                     \
+namespace boost { namespace archive { namespace detail {                  \
+    get_counter<Archive >::next adjust_counter(get_counter<Archive >::type);\
+    template<class Serializable>                                          \
+    void instantiate_ptr_serialization(Serializable* s,                   \
+        get_counter<Archive >::type) {                                    \
+        ptr_serialization_support<Archive, Serializable> x;               \
+        instantiate_ptr_serialization(s, get_counter<Archive >::prior()); \
+    }\
+}}}
+
+
+#else
+
+// This function gets called, but its only purpose is to participate
+// in overload resolution with the functions declared by
+// BOOST_SERIALIZATION_REGISTER_ARCHIVE, below.
+template <class Serializable>
+void instantiate_ptr_serialization(Serializable*, int, adl_tag ) {}
+
+// The function declaration generated by this macro never actually
+// gets called, but its return type gets instantiated, and that's
+// enough to cause registration of serialization functions between
+// Archive and any exported Serializable type.  See also:
+// boost/serialization/export.hpp
+# define BOOST_SERIALIZATION_REGISTER_ARCHIVE(Archive)                  \
+namespace boost { namespace archive { namespace detail {                \
+                                                                        \
+template <class Serializable>                                           \
+BOOST_DEDUCED_TYPENAME _ptr_serialization_support<Archive, Serializable>::type  \
+instantiate_ptr_serialization( Serializable*, Archive*, adl_tag );              \
+                                                                        \
+}}}
+#endif
+}}} // namespace boost::archive::detail
+
+#endif // BOOST_ARCHIVE_DETAIL_INSTANTIATE_SERIALIZE_DWA2006521_HPP

test/external/boost/archive/detail/utf8_codecvt_facet.hpp

@@ -0,0 +1,21 @@
+// Copyright (c) 2001 Ronald Garcia, Indiana University (garcia@osl.iu.edu)
+// Andrew Lumsdaine, Indiana University (lums@osl.iu.edu).
+// Distributed under the Boost Software License, Version 1.0. (See
+// accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+
+#ifndef BOOST_ARCHIVE_DETAIL_UTF8_CODECVT_FACET_HPP
+#define BOOST_ARCHIVE_DETAIL_UTF8_CODECVT_FACET_HPP
+
+#define BOOST_UTF8_BEGIN_NAMESPACE \
+     namespace boost { namespace archive { namespace detail {
+#define BOOST_UTF8_DECL
+#define BOOST_UTF8_END_NAMESPACE }}}
+
+#include <boost/detail/utf8_codecvt_facet.hpp>
+
+#undef BOOST_UTF8_END_NAMESPACE
+#undef BOOST_UTF8_DECL
+#undef BOOST_UTF8_BEGIN_NAMESPACE
+
+#endif // BOOST_ARCHIVE_DETAIL_UTF8_CODECVT_FACET_HPP