/Src/Dependencies/Boost/boost/archive/shared_ptr_helper.hpp

  1#ifndef BOOST_ARCHIVE_SHARED_PTR_HELPER_HPP
  2#define BOOST_ARCHIVE_SHARED_PTR_HELPER_HPP
  3
  4// MS compatible compilers support #pragma once
  5#if defined(_MSC_VER) && (_MSC_VER >= 1020)
  6# pragma once
  7#endif
  8
  9/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
 10// shared_ptr_helper.hpp: serialization for boost shared pointern
 11
 12// (C) Copyright 2004-2009 Robert Ramey, Martin Ecker and Takatoshi Kondo
 13// Use, modification and distribution is subject to the Boost Software
 14// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
 15// http://www.boost.org/LICENSE_1_0.txt)
 16
 17//  See http://www.boost.org for updates, documentation, and revision history.
 18
 19#include <set>
 20#include <list>
 21#include <utility>
 22#include <cstddef> // NULL
 23
 24#include <boost/config.hpp>
 25#include <boost/shared_ptr.hpp>
 26
 27#include <boost/type_traits/is_polymorphic.hpp>
 28#include <boost/serialization/type_info_implementation.hpp>
 29#include <boost/serialization/shared_ptr_132.hpp>
 30#include <boost/serialization/throw_exception.hpp>
 31
 32#include <boost/archive/archive_exception.hpp>
 33#include <boost/archive/detail/decl.hpp>
 34
 35#include <boost/archive/detail/abi_prefix.hpp> // must be the last headern
 36
 37namespace boost_132 {
 38    template<class T> class shared_ptr;
 39}
 40namespace boost {
 41    template<class T> class shared_ptr;
 42    namespace serialization {
 43        class extended_type_info;
 44        template<class Archive, class T>
 45        inline void load(
 46            Archive & ar,
 47            boost::shared_ptr< T > &t,
 48            const unsigned int file_version
 49        );
 50    }
 51namespace archive{
 52namespace detail {
 53
 54/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
 55// a common class for holding various types of shared pointers
 56
 57class shared_ptr_helper {
 58    struct collection_type_compare {
 59        bool operator()(
 60            const shared_ptr<const void> &lhs,
 61            const shared_ptr<const void> &rhs
 62        )const{
 63            return lhs.get() < rhs.get();
 64        }
 65    };
 66    typedef std::set<
 67        boost::shared_ptr<const void>,
 68        collection_type_compare
 69    > collection_type;
 70    typedef collection_type::const_iterator iterator_type;
 71    // list of shared_pointers create accessable by raw pointer. This
 72    // is used to "match up" shared pointers loaded at different
 73    // points in the archive. Note, we delay construction until
 74    // it is actually used since this is by default included as
 75    // a "mix-in" even if shared_ptr isn't used.
 76    collection_type * m_pointers;
 77
 78    struct null_deleter {
 79        void operator()(void const *) const {}
 80    };
 81
 82    struct void_deleter {
 83        const boost::serialization::extended_type_info * m_eti;
 84        void_deleter(const boost::serialization::extended_type_info *eti) :
 85            m_eti(eti)
 86        {}
 87        void operator()(void *vp) const {
 88            m_eti->destroy(vp);
 89        }
 90    };
 91
 92#ifdef BOOST_NO_MEMBER_TEMPLATE_FRIENDS
 93public:
 94#else
 95    template<class Archive, class T>
 96    friend inline void boost::serialization::load(
 97        Archive & ar,
 98        boost::shared_ptr< T > &t,
 99        const unsigned int file_version
100    );
101#endif
102
103//  #ifdef BOOST_SERIALIZATION_SHARED_PTR_132_HPP
104    // list of loaded pointers.  This is used to be sure that the pointers
105    // stay around long enough to be "matched" with other pointers loaded
106    // by the same archive.  These are created with a "null_deleter" so that
107    // when this list is destroyed - the underlaying raw pointers are not
108    // destroyed.  This has to be done because the pointers are also held by
109    // new system which is disjoint from this set.  This is implemented
110    // by a change in load_construct_data below.  It makes this file suitable
111    // only for loading pointers into a 1.33 or later boost system.
112    std::list<boost_132::shared_ptr<const void> > * m_pointers_132;
113//  #endif
114
115    // returns pointer to object and an indicator whether this is a
116    // new entry (true) or a previous one (false)
117    BOOST_ARCHIVE_DECL(shared_ptr<void>) 
118    get_od(
119        const void * od,
120        const boost::serialization::extended_type_info * true_type, 
121        const boost::serialization::extended_type_info * this_type
122    );
123
124    BOOST_ARCHIVE_DECL(void)
125    append(const boost::shared_ptr<const void> &);
126
127    template<class T>
128    struct non_polymorphic {
129        static const boost::serialization::extended_type_info * 
130        get_object_identifier(T & t){
131            return & boost::serialization::singleton<
132                BOOST_DEDUCED_TYPENAME 
133                boost::serialization::type_info_implementation< T >::type
134            >::get_const_instance();
135        }
136    };
137    template<class T>
138    struct polymorphic {
139        static const boost::serialization::extended_type_info * 
140        get_object_identifier(T & t){
141            return boost::serialization::singleton<
142                BOOST_DEDUCED_TYPENAME 
143                boost::serialization::type_info_implementation< T >::type
144            >::get_const_instance().get_derived_extended_type_info(t);
145        }
146    };
147public:
148    template<class T>
149    void reset(shared_ptr< T > & s, T * t){
150        if(NULL == t){
151            s.reset();
152            return;
153        }
154        const boost::serialization::extended_type_info * this_type
155            = & boost::serialization::type_info_implementation< T >::type
156                    ::get_const_instance();
157
158        // get pointer to the most derived object.  This is effectively
159        // the object identifern
160        typedef BOOST_DEDUCED_TYPENAME mpl::eval_if<
161            is_polymorphic< T >,
162            mpl::identity<polymorphic< T > >,
163            mpl::identity<non_polymorphic< T > >
164        >::type type;
165
166        const boost::serialization::extended_type_info * true_type
167            = type::get_object_identifier(*t);
168
169        // note:if this exception is thrown, be sure that derived pointern
170        // is either registered or exported.
171        if(NULL == true_type)
172            boost::serialization::throw_exception(
173                archive_exception(
174                    archive_exception::unregistered_class,
175                    this_type->get_debug_info()
176                )
177            );
178        shared_ptr<void> r =
179            get_od(
180                static_cast<const void *>(t), 
181                true_type,
182                this_type
183            );
184        if(!r){
185            s.reset(t);
186            const void * od = void_downcast(
187                *true_type,
188                *this_type,
189                static_cast<const void *>(t)
190            );
191            shared_ptr<const void> sp(s, od);
192            append(sp);
193        }
194        else{
195            s = shared_ptr< T >(
196                r,
197                static_cast<T *>(r.get())
198            );
199        }
200    }
201
202//  #ifdef BOOST_SERIALIZATION_SHARED_PTR_132_HPP
203    BOOST_ARCHIVE_DECL(void)
204    append(const boost_132::shared_ptr<const void> & t);
205//  #endif
206public:
207    BOOST_ARCHIVE_DECL(BOOST_PP_EMPTY())
208    shared_ptr_helper();
209    BOOST_ARCHIVE_DECL(BOOST_PP_EMPTY())
210    ~shared_ptr_helper();
211};
212
213} // namespace detail
214} // namespace archive
215} // namespace boost
216
217#include <boost/archive/detail/abi_suffix.hpp> // pops abi_suffix.hpp pragmas
218
219#endif // BOOST_ARCHIVE_SHARED_PTR_HELPER_HPP