comparison DEPENDENCIES/generic/include/boost/serialization/shared_ptr_helper.hpp @ 102:f46d142149f5

Whoops, finish that update

+#ifndef BOOST_SERIALIZATION_SHARED_PTR_HELPER_HPP
+#define BOOST_SERIALIZATION_SHARED_PTR_HELPER_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER)
+# pragma once
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// shared_ptr_helper.hpp: serialization for boost shared pointern
+
+// (C) Copyright 2004-2009 Robert Ramey, Martin Ecker and Takatoshi Kondo
+// Use, modification and distribution is subject to the Boost Software
+// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+
+//  See http://www.boost.org for updates, documentation, and revision history.
+
+#include <map>
+#include <list>
+#include <utility>
+#include <cstddef> // NULL
+
+#include <boost/config.hpp>
+#include <boost/shared_ptr.hpp>
+#include <boost/type_traits/is_polymorphic.hpp>
+#include <boost/mpl/if.hpp>
+
+#include <boost/serialization/singleton.hpp>
+#include <boost/serialization/extended_type_info.hpp>
+#include <boost/serialization/throw_exception.hpp>
+#include <boost/serialization/type_info_implementation.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 {
+namespace serialization {
+
+#ifndef BOOST_NO_MEMBER_TEMPLATE_FRIENDS
+template<class Archive, template<class U> class SPT >
+void load(
+    Archive & ar,
+    SPT< class U > &t,
+    const unsigned int file_version
+);
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// a common class for holding various types of shared pointers
+
+template<template<class T> class SPT>
+class shared_ptr_helper {
+    typedef std::map<
+        const void *, // address of object
+        SPT<void> // address shared ptr to single instance
+    > object_shared_pointer_map;
+
+    // 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.
+    object_shared_pointer_map * m_o_sp;
+
+    struct null_deleter {
+        void operator()(void const *) const {}
+    };
+
+#if defined(BOOST_NO_MEMBER_TEMPLATE_FRIENDS) || defined(BOOST_MSVC)
+public:
+#else
+    template<class Archive, class U>
+    friend void boost::serialization::load(
+        Archive & ar,
+        SPT< U > &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;
+    BOOST_ARCHIVE_DECL(void)
+    append(const boost_132::shared_ptr<const void> & t){
+        if(NULL == m_pointers_132)
+            m_pointers_132 = new std::list<boost_132::shared_ptr<const void> >;
+        m_pointers_132->push_back(t);
+    }
+    #endif
+
+    struct non_polymorphic {
+        template<class U>
+        static const boost::serialization::extended_type_info * 
+        get_object_type(U & ){
+            return & boost::serialization::singleton<
+                typename 
+                boost::serialization::type_info_implementation< U >::type
+            >::get_const_instance();
+        }
+    };
+    struct polymorphic {
+        template<class U>
+        static const boost::serialization::extended_type_info * 
+        get_object_type(U & u){
+            return boost::serialization::singleton<
+                typename 
+                boost::serialization::type_info_implementation< U >::type
+            >::get_const_instance().get_derived_extended_type_info(u);
+        }
+    };
+
+public:
+    template<class T>
+    void reset(SPT< 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's eti.  This is effectively
+        // the object type identifer
+        typedef typename mpl::if_<
+            is_polymorphic< T >,
+            polymorphic,
+            non_polymorphic
+        >::type type;
+
+        const boost::serialization::extended_type_info * true_type
+            = type::get_object_type(*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(
+                boost::archive::archive_exception(
+                    boost::archive::archive_exception::unregistered_class,
+                    this_type->get_debug_info()
+                )
+            );
+        // get void pointer to the most derived type
+        // this uniquely identifies the object referred to
+        // oid = "object identifier"
+        const void * oid = void_downcast(
+            *true_type,
+            *this_type,
+            t
+        );
+        if(NULL == oid)
+            boost::serialization::throw_exception(
+                boost::archive::archive_exception(
+                    boost::archive::archive_exception::unregistered_cast,
+                    true_type->get_debug_info(),
+                    this_type->get_debug_info()
+                )
+            );
+
+        // make tracking array if necessary
+        if(NULL == m_o_sp)
+            m_o_sp = new object_shared_pointer_map;
+
+        typename object_shared_pointer_map::iterator i = m_o_sp->find(oid);
+
+        // if it's a new object
+        if(i == m_o_sp->end()){
+            s.reset(t);
+            std::pair<typename object_shared_pointer_map::iterator, bool> result;
+            result = m_o_sp->insert(std::make_pair(oid, s));
+            BOOST_ASSERT(result.second);
+        }
+        // if the object has already been seen
+        else{
+            s = SPT<T>(i->second, t);
+        }
+    }
+
+    shared_ptr_helper() :
+        m_o_sp(NULL)
+        #ifdef BOOST_SERIALIZATION_SHARED_PTR_132_HPP
+            , m_pointers_132(NULL)
+        #endif
+    {}
+    virtual ~shared_ptr_helper(){
+        if(NULL != m_o_sp)
+            delete m_o_sp;
+        #ifdef BOOST_SERIALIZATION_SHARED_PTR_132_HPP
+        if(NULL != m_pointers_132)
+            delete m_pointers_132;
+        #endif
+    }
+};
+
+} // namespace serialization
+} // namespace boost
+
+#include <boost/archive/detail/abi_suffix.hpp> // pops abi_suffix.hpp pragmas
+
+#endif // BOOST_SERIALIZATION_SHARED_PTR_HELPER_HPP