Added boost header

test/external/boost/archive/shared_ptr_helper.hpp

@@ -0,0 +1,219 @@
+#ifndef BOOST_ARCHIVE_SHARED_PTR_HELPER_HPP
+#define BOOST_ARCHIVE_SHARED_PTR_HELPER_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
+// shared_ptr_helper.hpp: serialization for boost shared pointern
+
+// (C) Copyright 2004-2009 Robert Ramey, Martin Ecker and Takatoshi Kondo
+// Use, modification and distribution is subject to the Boost Software
+// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+
+//  See http://www.boost.org for updates, documentation, and revision history.
+
+#include <set>
+#include <list>
+#include <utility>
+#include <cstddef> // NULL
+
+#include <boost/config.hpp>
+#include <boost/shared_ptr.hpp>
+
+#include <boost/type_traits/is_polymorphic.hpp>
+#include <boost/serialization/type_info_implementation.hpp>
+#include <boost/serialization/shared_ptr_132.hpp>
+#include <boost/serialization/throw_exception.hpp>
+
+#include <boost/archive/archive_exception.hpp>
+#include <boost/archive/detail/decl.hpp>
+
+#include <boost/archive/detail/abi_prefix.hpp> // must be the last headern
+
+namespace boost_132 {
+    template<class T> class shared_ptr;
+}
+namespace boost {
+    template<class T> class shared_ptr;
+    namespace serialization {
+        class extended_type_info;
+        template<class Archive, class T>
+        inline void load(
+            Archive & ar,
+            boost::shared_ptr< T > &t,
+            const unsigned int file_version
+        );
+    }
+namespace archive{
+namespace detail {
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// a common class for holding various types of shared pointers
+
+class shared_ptr_helper {
+    struct collection_type_compare {
+        bool operator()(
+            const shared_ptr<const void> &lhs,
+            const shared_ptr<const void> &rhs
+        )const{
+            return lhs.get() < rhs.get();
+        }
+    };
+    typedef std::set<
+        boost::shared_ptr<const void>,
+        collection_type_compare
+    > collection_type;
+    typedef collection_type::const_iterator iterator_type;
+    // list of shared_pointers create accessable by raw pointer. This
+    // is used to "match up" shared pointers loaded at different
+    // points in the archive. Note, we delay construction until
+    // it is actually used since this is by default included as
+    // a "mix-in" even if shared_ptr isn't used.
+    collection_type * m_pointers;
+
+    struct null_deleter {
+        void operator()(void const *) const {}
+    };
+
+    struct void_deleter {
+        const boost::serialization::extended_type_info * m_eti;
+        void_deleter(const boost::serialization::extended_type_info *eti) :
+            m_eti(eti)
+        {}
+        void operator()(void *vp) const {
+            m_eti->destroy(vp);
+        }
+    };
+
+#ifdef BOOST_NO_MEMBER_TEMPLATE_FRIENDS
+public:
+#else
+    template<class Archive, class T>
+    friend inline void boost::serialization::load(
+        Archive & ar,
+        boost::shared_ptr< T > &t,
+        const unsigned int file_version
+    );
+#endif
+
+//  #ifdef BOOST_SERIALIZATION_SHARED_PTR_132_HPP
+    // list of loaded pointers.  This is used to be sure that the pointers
+    // stay around long enough to be "matched" with other pointers loaded
+    // by the same archive.  These are created with a "null_deleter" so that
+    // when this list is destroyed - the underlaying raw pointers are not
+    // destroyed.  This has to be done because the pointers are also held by
+    // new system which is disjoint from this set.  This is implemented
+    // by a change in load_construct_data below.  It makes this file suitable
+    // only for loading pointers into a 1.33 or later boost system.
+    std::list<boost_132::shared_ptr<const void> > * m_pointers_132;
+//  #endif
+
+    // returns pointer to object and an indicator whether this is a
+    // new entry (true) or a previous one (false)
+    BOOST_ARCHIVE_DECL(shared_ptr<void>) 
+    get_od(
+        const void * od,
+        const boost::serialization::extended_type_info * true_type, 
+        const boost::serialization::extended_type_info * this_type
+    );
+
+    BOOST_ARCHIVE_DECL(void)
+    append(const boost::shared_ptr<const void> &);
+
+    template<class T>
+    struct non_polymorphic {
+        static const boost::serialization::extended_type_info * 
+        get_object_identifier(T & t){
+            return & boost::serialization::singleton<
+                BOOST_DEDUCED_TYPENAME 
+                boost::serialization::type_info_implementation< T >::type
+            >::get_const_instance();
+        }
+    };
+    template<class T>
+    struct polymorphic {
+        static const boost::serialization::extended_type_info * 
+        get_object_identifier(T & t){
+            return boost::serialization::singleton<
+                BOOST_DEDUCED_TYPENAME 
+                boost::serialization::type_info_implementation< T >::type
+            >::get_const_instance().get_derived_extended_type_info(t);
+        }
+    };
+public:
+    template<class T>
+    void reset(shared_ptr< T > & s, T * t){
+        if(NULL == t){
+            s.reset();
+            return;
+        }
+        const boost::serialization::extended_type_info * this_type
+            = & boost::serialization::type_info_implementation< T >::type
+                    ::get_const_instance();
+
+        // get pointer to the most derived object.  This is effectively
+        // the object identifern
+        typedef BOOST_DEDUCED_TYPENAME mpl::eval_if<
+            is_polymorphic< T >,
+            mpl::identity<polymorphic< T > >,
+            mpl::identity<non_polymorphic< T > >
+        >::type type;
+
+        const boost::serialization::extended_type_info * true_type
+            = type::get_object_identifier(*t);
+
+        // note:if this exception is thrown, be sure that derived pointern
+        // is either registered or exported.
+        if(NULL == true_type)
+            boost::serialization::throw_exception(
+                archive_exception(
+                    archive_exception::unregistered_class,
+                    this_type->get_debug_info()
+                )
+            );
+        shared_ptr<void> r =
+            get_od(
+                static_cast<const void *>(t), 
+                true_type,
+                this_type
+            );
+        if(!r){
+            s.reset(t);
+            const void * od = void_downcast(
+                *true_type,
+                *this_type,
+                static_cast<const void *>(t)
+            );
+            shared_ptr<const void> sp(s, od);
+            append(sp);
+        }
+        else{
+            s = shared_ptr< T >(
+                r,
+                static_cast<T *>(r.get())
+            );
+        }
+    }
+
+//  #ifdef BOOST_SERIALIZATION_SHARED_PTR_132_HPP
+    BOOST_ARCHIVE_DECL(void)
+    append(const boost_132::shared_ptr<const void> & t);
+//  #endif
+public:
+    BOOST_ARCHIVE_DECL(BOOST_PP_EMPTY())
+    shared_ptr_helper();
+    BOOST_ARCHIVE_DECL(BOOST_PP_EMPTY())
+    ~shared_ptr_helper();
+};
+
+} // namespace detail
+} // namespace archive
+} // namespace boost
+
+#include <boost/archive/detail/abi_suffix.hpp> // pops abi_suffix.hpp pragmas
+
+#endif // BOOST_ARCHIVE_SHARED_PTR_HELPER_HPP