[ceph.git] / ceph / src / boost / libs / serialization / src / basic_oarchive.cpp

/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
// basic_oarchive.cpp:

// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
// Use, modification and distribution is subject to the Boost Software
// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)

//  See http://www.boost.org for updates, documentation, and revision history.

#include <boost/config.hpp> // msvc 6.0 needs this for warning suppression

#include <boost/assert.hpp>
#include <set>
#include <cstddef> // NULL

#include <boost/limits.hpp>

// including this here to work around an ICC in intel 7.0
// normally this would be part of basic_oarchive.hpp below.
#define BOOST_ARCHIVE_SOURCE
// include this to prevent linker errors when the
// same modules are marked export and import.
#define BOOST_SERIALIZATION_SOURCE
#include <boost/serialization/config.hpp>
#include <boost/serialization/state_saver.hpp>
#include <boost/serialization/throw_exception.hpp>
#include <boost/serialization/extended_type_info.hpp>

#include <boost/archive/detail/decl.hpp>
#include <boost/archive/basic_archive.hpp>
#include <boost/archive/detail/basic_oserializer.hpp>
#include <boost/archive/detail/basic_pointer_oserializer.hpp>
#include <boost/archive/detail/basic_oarchive.hpp>
#include <boost/archive/archive_exception.hpp>

#ifdef BOOST_MSVC
#  pragma warning(push)
#  pragma warning(disable : 4251 4231 4660 4275)
#endif

using namespace boost::serialization;

namespace boost {
namespace archive {
namespace detail {

class basic_oarchive_impl {
    friend class basic_oarchive;
    unsigned int m_flags;

    //////////////////////////////////////////////////////////////////////
    // information about each serialized object saved
    // keyed on address, class_id
    struct aobject
    {
        const void * address;
        class_id_type class_id;
        object_id_type object_id;

        bool operator<(const aobject &rhs) const
        {
            BOOST_ASSERT(NULL != address);
            BOOST_ASSERT(NULL != rhs.address);
            if( address < rhs.address )
                return true;
            if( address > rhs.address )
                return false;
            return class_id < rhs.class_id;
        }
        aobject & operator=(const aobject & rhs)
        {
            address = rhs.address;
            class_id = rhs.class_id;
            object_id = rhs.object_id;
            return *this;
        }
        aobject(
            const void *a,
            class_id_type class_id_,
            object_id_type object_id_
        ) :
            address(a),
            class_id(class_id_),
            object_id(object_id_)
        {}
        aobject() : address(NULL){}
    };
    // keyed on class_id, address
    typedef std::set<aobject> object_set_type;
    object_set_type object_set;

    //////////////////////////////////////////////////////////////////////
    // information about each serialized class saved
    // keyed on type_info
    struct cobject_type
    {
        const basic_oserializer * m_bos_ptr;
        const class_id_type m_class_id;
        bool m_initialized;
        cobject_type(
            std::size_t class_id,
            const basic_oserializer & bos
        ) :
            m_bos_ptr(& bos),
            m_class_id(class_id),
            m_initialized(false)
        {}
        cobject_type(const basic_oserializer & bos) :
            m_bos_ptr(& bos),
            m_initialized(false)
        {}
        cobject_type(
            const cobject_type & rhs
        ) :
            m_bos_ptr(rhs.m_bos_ptr),
            m_class_id(rhs.m_class_id),
            m_initialized(rhs.m_initialized)
        {}
        // the following cannot be defined because of the const
        // member.  This will generate a link error if an attempt
        // is made to assign.  This should never be necessary
        // use this only for lookup argument 
        cobject_type & operator=(const cobject_type &rhs);
        bool operator<(const cobject_type &rhs) const {
            return *m_bos_ptr < *(rhs.m_bos_ptr);
        }
    };
    // keyed on type_info
    typedef std::set<cobject_type> cobject_info_set_type;
    cobject_info_set_type cobject_info_set;

    // list of objects initially stored as pointers - used to detect errors
    // keyed on object id
    std::set<object_id_type> stored_pointers;

    // address of the most recent object serialized as a poiner
    // whose data itself is now pending serialization
    const void * pending_object;
    const basic_oserializer * pending_bos;

    basic_oarchive_impl(unsigned int flags) :
        m_flags(flags),
        pending_object(NULL),
        pending_bos(NULL)
    {}

    const cobject_type &
    find(const basic_oserializer & bos);
    const basic_oserializer *  
    find(const serialization::extended_type_info &ti) const;

//public:
    const cobject_type &
    register_type(const basic_oserializer & bos);
    void save_object(
        basic_oarchive & ar,
        const void *t,
        const basic_oserializer & bos
    );
    void save_pointer(
        basic_oarchive & ar,
        const void * t, 
        const basic_pointer_oserializer * bpos
    );
};

//////////////////////////////////////////////////////////////////////
// basic_oarchive implementation functions

// given a type_info - find its bos
// return NULL if not found
inline const basic_oserializer *
basic_oarchive_impl::find(const serialization::extended_type_info & ti) const {
    #ifdef BOOST_MSVC
    #  pragma warning(push)
    #  pragma warning(disable : 4511 4512)
    #endif
    class bosarg : 
        public basic_oserializer
    {
        bool class_info() const {
            BOOST_ASSERT(false); 
            return false;
        }
        // returns true if objects should be tracked
        bool tracking(const unsigned int) const {
            BOOST_ASSERT(false);
            return false;
        }
        // returns class version
        version_type version() const {
            BOOST_ASSERT(false);
            return version_type(0);
        }
        // returns true if this class is polymorphic
        bool is_polymorphic() const{
            BOOST_ASSERT(false);
            return false;
        }
        void save_object_data(      
            basic_oarchive & /*ar*/, const void * /*x*/
        ) const {
            BOOST_ASSERT(false);
        }
    public:
        bosarg(const serialization::extended_type_info & eti) :
          boost::archive::detail::basic_oserializer(eti)
        {}
    };
    #ifdef BOOST_MSVC
    #pragma warning(pop)
    #endif
    bosarg bos(ti);
    cobject_info_set_type::const_iterator cit 
        = cobject_info_set.find(cobject_type(bos));
    // it should already have been "registered" - see below
    if(cit == cobject_info_set.end()){
        // if an entry is not found in the table it is because a pointer
        // of a derived class has been serialized through its base class
        // but the derived class hasn't been "registered" 
        return NULL;
    }
    // return pointer to the real class
    return cit->m_bos_ptr;
}

inline const basic_oarchive_impl::cobject_type &
basic_oarchive_impl::find(const basic_oserializer & bos)
{
    std::pair<cobject_info_set_type::iterator, bool> cresult = 
        cobject_info_set.insert(cobject_type(cobject_info_set.size(), bos));
    return *(cresult.first);
}

inline const basic_oarchive_impl::cobject_type &
basic_oarchive_impl::register_type(
    const basic_oserializer & bos
){
    cobject_type co(cobject_info_set.size(), bos);
    std::pair<cobject_info_set_type::const_iterator, bool>
        result = cobject_info_set.insert(co);
    return *(result.first);
}

inline void
basic_oarchive_impl::save_object(
    basic_oarchive & ar,
    const void *t,
    const basic_oserializer & bos
){
    // if its been serialized through a pointer and the preamble's been done
    if(t == pending_object && pending_bos == & bos){
        // just save the object data
        ar.end_preamble();
        (bos.save_object_data)(ar, t);
        return;
    }

    // get class information for this object
    const cobject_type & co = register_type(bos);
    if(bos.class_info()){
        if( ! co.m_initialized){
            ar.vsave(class_id_optional_type(co.m_class_id));
            ar.vsave(tracking_type(bos.tracking(m_flags)));
            ar.vsave(version_type(bos.version()));
            (const_cast<cobject_type &>(co)).m_initialized = true;
        }
    }

    // we're not tracking this type of object
    if(! bos.tracking(m_flags)){
        // just windup the preamble - no object id to write
        ar.end_preamble();
        // and save the data
        (bos.save_object_data)(ar, t);
        return;
    }

    // look for an existing object id
    object_id_type oid(object_set.size());
    // lookup to see if this object has already been written to the archive
    basic_oarchive_impl::aobject ao(t, co.m_class_id, oid);
    std::pair<basic_oarchive_impl::object_set_type::const_iterator, bool>
        aresult = object_set.insert(ao);
    oid = aresult.first->object_id;

    // if its a new object
    if(aresult.second){
        // write out the object id
        ar.vsave(oid);
        ar.end_preamble();
        // and data
        (bos.save_object_data)(ar, t);
        return;
    }

    // check that it wasn't originally stored through a pointer
    if(stored_pointers.end() != stored_pointers.find(oid)){
        // this has to be a user error.  loading such an archive
        // would create duplicate objects
        boost::serialization::throw_exception(
            archive_exception(archive_exception::pointer_conflict)
        );
    }
    // just save the object id
    ar.vsave(object_reference_type(oid));
    ar.end_preamble();
    return;
}

// save a pointer to an object instance
inline void
basic_oarchive_impl::save_pointer(
    basic_oarchive & ar,
    const void * t, 
    const basic_pointer_oserializer * bpos_ptr
){
    const basic_oserializer & bos = bpos_ptr->get_basic_serializer();
    std::size_t original_count = cobject_info_set.size();
    const cobject_type & co = register_type(bos);
    if(! co.m_initialized){
        ar.vsave(co.m_class_id);
        // if its a previously unregistered class 
        if((cobject_info_set.size() > original_count)){
            if(bos.is_polymorphic()){
                const serialization::extended_type_info *eti = & bos.get_eti();
                const char * key = NULL;
                if(NULL != eti)
                    key = eti->get_key();
                if(NULL != key){
                    // the following is required by IBM C++ compiler which
                    // makes a copy when passing a non-const to a const.  This
                    // is permitted by the standard but rarely seen in practice
                    const class_name_type cn(key);
                    if(cn.size() > (BOOST_SERIALIZATION_MAX_KEY_SIZE - 1))
                        boost::serialization::throw_exception(
                            boost::archive::archive_exception(
                                boost::archive::archive_exception::
                                    invalid_class_name)
                            );
                    // write out the external class identifier
                    ar.vsave(cn);
                }
                else
                    // without an external class name
                    // we won't be able to de-serialize it so bail now
                    boost::serialization::throw_exception(
                        archive_exception(archive_exception::unregistered_class)
                    );
            }
        }
        if(bos.class_info()){
            ar.vsave(tracking_type(bos.tracking(m_flags)));
            ar.vsave(version_type(bos.version()));
        }
        (const_cast<cobject_type &>(co)).m_initialized = true;
    }
    else{
        ar.vsave(class_id_reference_type(co.m_class_id));
    }

    // if we're not tracking
    if(! bos.tracking(m_flags)){
        // just save the data itself
        ar.end_preamble();
        serialization::state_saver<const void *> x(pending_object);
        serialization::state_saver<const basic_oserializer *> y(pending_bos);
        pending_object = t;
        pending_bos = & bpos_ptr->get_basic_serializer();
        bpos_ptr->save_object_ptr(ar, t);
        return;
    }

    object_id_type oid(object_set.size());
    // lookup to see if this object has already been written to the archive
    basic_oarchive_impl::aobject ao(t, co.m_class_id, oid);
    std::pair<basic_oarchive_impl::object_set_type::const_iterator, bool>
        aresult = object_set.insert(ao);
    oid = aresult.first->object_id;
    // if the saved object already exists
    if(! aresult.second){
        // append the object id to he preamble
        ar.vsave(object_reference_type(oid));
        // and windup.
        ar.end_preamble();
        return;
    }

    // append id of this object to preamble
    ar.vsave(oid);
    ar.end_preamble();

    // and save the object itself
    serialization::state_saver<const void *> x(pending_object);
    serialization::state_saver<const basic_oserializer *> y(pending_bos);
    pending_object = t;
    pending_bos = & bpos_ptr->get_basic_serializer();
    bpos_ptr->save_object_ptr(ar, t);
    // add to the set of object initially stored through pointers
    stored_pointers.insert(oid);
}

} // namespace detail
} // namespace archive
} // namespace boost

//////////////////////////////////////////////////////////////////////
// implementation of basic_oarchive functions

namespace boost {
namespace archive {
namespace detail {

BOOST_ARCHIVE_DECL 
basic_oarchive::basic_oarchive(unsigned int flags)
    : pimpl(new basic_oarchive_impl(flags))
{}

BOOST_ARCHIVE_DECL 
basic_oarchive::~basic_oarchive()
{}

BOOST_ARCHIVE_DECL void 
basic_oarchive::save_object(
    const void *x, 
    const basic_oserializer & bos
){
    pimpl->save_object(*this, x, bos);
}

BOOST_ARCHIVE_DECL void 
basic_oarchive::save_pointer(
    const void * t, 
    const basic_pointer_oserializer * bpos_ptr
){
    pimpl->save_pointer(*this, t, bpos_ptr);
}

BOOST_ARCHIVE_DECL void 
basic_oarchive::register_basic_serializer(const basic_oserializer & bos){
    pimpl->register_type(bos);
}

BOOST_ARCHIVE_DECL library_version_type
basic_oarchive::get_library_version() const{
    return BOOST_ARCHIVE_VERSION();
}

BOOST_ARCHIVE_DECL unsigned int
basic_oarchive::get_flags() const{
    return pimpl->m_flags;
}

BOOST_ARCHIVE_DECL void 
basic_oarchive::end_preamble(){
}

BOOST_ARCHIVE_DECL helper_collection &
basic_oarchive::get_helper_collection(){
	return *this;
}

} // namespace detail
} // namespace archive
} // namespace boost

#ifdef BOOST_MSVC
#pragma warning(pop)
#endif
Commit	Line	Data
7c673cae FG	1	/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
	2	// basic_oarchive.cpp:
	3
	4	// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
	5	// Use, modification and distribution is subject to the Boost Software
	6	// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
	7	// http://www.boost.org/LICENSE_1_0.txt)
	8
	9	// See http://www.boost.org for updates, documentation, and revision history.
	10
	11	#include <boost/config.hpp> // msvc 6.0 needs this for warning suppression
	12
	13	#include <boost/assert.hpp>
	14	#include <set>
	15	#include <cstddef> // NULL
	16
	17	#include <boost/limits.hpp>
	18
	19	// including this here to work around an ICC in intel 7.0
	20	// normally this would be part of basic_oarchive.hpp below.
	21	#define BOOST_ARCHIVE_SOURCE
	22	// include this to prevent linker errors when the
	23	// same modules are marked export and import.
	24	#define BOOST_SERIALIZATION_SOURCE
	25	#include <boost/serialization/config.hpp>
	26	#include <boost/serialization/state_saver.hpp>
	27	#include <boost/serialization/throw_exception.hpp>
	28	#include <boost/serialization/extended_type_info.hpp>
	29
	30	#include <boost/archive/detail/decl.hpp>
	31	#include <boost/archive/basic_archive.hpp>
	32	#include <boost/archive/detail/basic_oserializer.hpp>
	33	#include <boost/archive/detail/basic_pointer_oserializer.hpp>
	34	#include <boost/archive/detail/basic_oarchive.hpp>
	35	#include <boost/archive/archive_exception.hpp>
	36
	37	#ifdef BOOST_MSVC
	38	# pragma warning(push)
	39	# pragma warning(disable : 4251 4231 4660 4275)
	40	#endif
	41
	42	using namespace boost::serialization;
	43
	44	namespace boost {
	45	namespace archive {
	46	namespace detail {
	47
	48	class basic_oarchive_impl {
	49	friend class basic_oarchive;
	50	unsigned int m_flags;
	51
	52	//////////////////////////////////////////////////////////////////////
	53	// information about each serialized object saved
	54	// keyed on address, class_id
	55	struct aobject
	56	{
	57	const void * address;
	58	class_id_type class_id;
	59	object_id_type object_id;
	60
	61	bool operator<(const aobject &rhs) const
	62	{
	63	BOOST_ASSERT(NULL != address);
	64	BOOST_ASSERT(NULL != rhs.address);
65	if( address < rhs.address )
66	return true;
67	if( address > rhs.address )
68	return false;
69	return class_id < rhs.class_id;
70	}
71	aobject & operator=(const aobject & rhs)
72	{
73	address = rhs.address;
74	class_id = rhs.class_id;
75	object_id = rhs.object_id;
76	return *this;
77	}
78	aobject(
79	const void *a,
80	class_id_type class_id_,
81	object_id_type object_id_
82	) :
83	address(a),
84	class_id(class_id_),
85	object_id(object_id_)
86	{}
87	aobject() : address(NULL){}
88	};
89	// keyed on class_id, address
90	typedef std::set<aobject> object_set_type;
91	object_set_type object_set;
92
93	//////////////////////////////////////////////////////////////////////
94	// information about each serialized class saved
95	// keyed on type_info
96	struct cobject_type
97	{
98	const basic_oserializer * m_bos_ptr;
99	const class_id_type m_class_id;
100	bool m_initialized;
101	cobject_type(
102	std::size_t class_id,
103	const basic_oserializer & bos
104	) :
105	m_bos_ptr(& bos),
106	m_class_id(class_id),
107	m_initialized(false)
108	{}
b32b8144 FG	109	cobject_type(const basic_oserializer & bos) :
	110	m_bos_ptr(& bos),
	111	m_initialized(false)
7c673cae FG	112	{}
	113	cobject_type(
	114	const cobject_type & rhs
	115	) :
	116	m_bos_ptr(rhs.m_bos_ptr),
	117	m_class_id(rhs.m_class_id),
	118	m_initialized(rhs.m_initialized)
	119	{}
	120	// the following cannot be defined because of the const
	121	// member. This will generate a link error if an attempt
	122	// is made to assign. This should never be necessary
	123	// use this only for lookup argument
	124	cobject_type & operator=(const cobject_type &rhs);
	125	bool operator<(const cobject_type &rhs) const {
	126	return m_bos_ptr < (rhs.m_bos_ptr);
	127	}
	128	};
	129	// keyed on type_info
	130	typedef std::set<cobject_type> cobject_info_set_type;
	131	cobject_info_set_type cobject_info_set;
	132
	133	// list of objects initially stored as pointers - used to detect errors
	134	// keyed on object id
	135	std::set<object_id_type> stored_pointers;
	136
	137	// address of the most recent object serialized as a poiner
	138	// whose data itself is now pending serialization
	139	const void * pending_object;
	140	const basic_oserializer * pending_bos;
	141
	142	basic_oarchive_impl(unsigned int flags) :
	143	m_flags(flags),
	144	pending_object(NULL),
	145	pending_bos(NULL)
	146	{}
	147
	148	const cobject_type &
	149	find(const basic_oserializer & bos);
	150	const basic_oserializer *
	151	find(const serialization::extended_type_info &ti) const;
	152
	153	//public:
	154	const cobject_type &
	155	register_type(const basic_oserializer & bos);
	156	void save_object(
	157	basic_oarchive & ar,
	158	const void *t,
	159	const basic_oserializer & bos
	160	);
	161	void save_pointer(
	162	basic_oarchive & ar,
	163	const void * t,
	164	const basic_pointer_oserializer * bpos
	165	);
	166	};
	167
	168	//////////////////////////////////////////////////////////////////////
	169	// basic_oarchive implementation functions
	170
	171	// given a type_info - find its bos
	172	// return NULL if not found
	173	inline const basic_oserializer *
	174	basic_oarchive_impl::find(const serialization::extended_type_info & ti) const {
	175	#ifdef BOOST_MSVC
176	# pragma warning(push)
177	# pragma warning(disable : 4511 4512)
178	#endif
179	class bosarg :
180	public basic_oserializer
181	{
182	bool class_info() const {
183	BOOST_ASSERT(false);
184	return false;
185	}
186	// returns true if objects should be tracked
187	bool tracking(const unsigned int) const {
188	BOOST_ASSERT(false);
189	return false;
190	}
191	// returns class version
192	version_type version() const {
193	BOOST_ASSERT(false);
194	return version_type(0);
195	}
196	// returns true if this class is polymorphic
197	bool is_polymorphic() const{
198	BOOST_ASSERT(false);
199	return false;
200	}
201	void save_object_data(
202	basic_oarchive & /ar/, const void * /x/
203	) const {
204	BOOST_ASSERT(false);
205	}
206	public:
207	bosarg(const serialization::extended_type_info & eti) :
208	boost::archive::detail::basic_oserializer(eti)
209	{}
210	};
211	#ifdef BOOST_MSVC
212	#pragma warning(pop)
213	#endif
214	bosarg bos(ti);
215	cobject_info_set_type::const_iterator cit
216	= cobject_info_set.find(cobject_type(bos));
217	// it should already have been "registered" - see below
218	if(cit == cobject_info_set.end()){
219	// if an entry is not found in the table it is because a pointer
220	// of a derived class has been serialized through its base class
221	// but the derived class hasn't been "registered"
222	return NULL;
223	}
224	// return pointer to the real class
225	return cit->m_bos_ptr;
226	}
227
228	inline const basic_oarchive_impl::cobject_type &
229	basic_oarchive_impl::find(const basic_oserializer & bos)
230	{
231	std::pair<cobject_info_set_type::iterator, bool> cresult =
232	cobject_info_set.insert(cobject_type(cobject_info_set.size(), bos));
233	return *(cresult.first);
234	}
235
236	inline const basic_oarchive_impl::cobject_type &
237	basic_oarchive_impl::register_type(
238	const basic_oserializer & bos
239	){
240	cobject_type co(cobject_info_set.size(), bos);
241	std::pair<cobject_info_set_type::const_iterator, bool>
242	result = cobject_info_set.insert(co);
243	return *(result.first);
244	}
245
246	inline void
247	basic_oarchive_impl::save_object(
248	basic_oarchive & ar,
249	const void *t,
250	const basic_oserializer & bos
251	){
252	// if its been serialized through a pointer and the preamble's been done
253	if(t == pending_object && pending_bos == & bos){
254	// just save the object data
255	ar.end_preamble();
256	(bos.save_object_data)(ar, t);
257	return;
258	}
259
260	// get class information for this object
261	const cobject_type & co = register_type(bos);
262	if(bos.class_info()){
263	if( ! co.m_initialized){
264	ar.vsave(class_id_optional_type(co.m_class_id));
265	ar.vsave(tracking_type(bos.tracking(m_flags)));
266	ar.vsave(version_type(bos.version()));
267	(const_cast<cobject_type &>(co)).m_initialized = true;
268	}
269	}
270
271	// we're not tracking this type of object
272	if(! bos.tracking(m_flags)){
273	// just windup the preamble - no object id to write
274	ar.end_preamble();
275	// and save the data
276	(bos.save_object_data)(ar, t);
277	return;
278	}
279
280	// look for an existing object id
281	object_id_type oid(object_set.size());
282	// lookup to see if this object has already been written to the archive
283	basic_oarchive_impl::aobject ao(t, co.m_class_id, oid);
284	std::pair<basic_oarchive_impl::object_set_type::const_iterator, bool>
285	aresult = object_set.insert(ao);
286	oid = aresult.first->object_id;
287
288	// if its a new object
289	if(aresult.second){
290	// write out the object id
291	ar.vsave(oid);
292	ar.end_preamble();
293	// and data
294	(bos.save_object_data)(ar, t);
295	return;
296	}
297
298	// check that it wasn't originally stored through a pointer
299	if(stored_pointers.end() != stored_pointers.find(oid)){
300	// this has to be a user error. loading such an archive
301	// would create duplicate objects
302	boost::serialization::throw_exception(
303	archive_exception(archive_exception::pointer_conflict)
304	);
305	}
306	// just save the object id
307	ar.vsave(object_reference_type(oid));
308	ar.end_preamble();
309	return;
310	}
311
312	// save a pointer to an object instance
313	inline void
314	basic_oarchive_impl::save_pointer(
315	basic_oarchive & ar,
316	const void * t,
317	const basic_pointer_oserializer * bpos_ptr
318	){
319	const basic_oserializer & bos = bpos_ptr->get_basic_serializer();
320	std::size_t original_count = cobject_info_set.size();
321	const cobject_type & co = register_type(bos);
322	if(! co.m_initialized){
323	ar.vsave(co.m_class_id);
324	// if its a previously unregistered class
325	if((cobject_info_set.size() > original_count)){
326	if(bos.is_polymorphic()){
327	const serialization::extended_type_info *eti = & bos.get_eti();
328	const char * key = NULL;
329	if(NULL != eti)
330	key = eti->get_key();
331	if(NULL != key){
332	// the following is required by IBM C++ compiler which
333	// makes a copy when passing a non-const to a const. This
334	// is permitted by the standard but rarely seen in practice
335	const class_name_type cn(key);
336	if(cn.size() > (BOOST_SERIALIZATION_MAX_KEY_SIZE - 1))
337	boost::serialization::throw_exception(
338	boost::archive::archive_exception(
339	boost::archive::archive_exception::
340	invalid_class_name)
341	);
342	// write out the external class identifier
343	ar.vsave(cn);
344	}
345	else
346	// without an external class name
347	// we won't be able to de-serialize it so bail now
348	boost::serialization::throw_exception(
349	archive_exception(archive_exception::unregistered_class)
350	);
351	}
352	}
353	if(bos.class_info()){
354	ar.vsave(tracking_type(bos.tracking(m_flags)));
355	ar.vsave(version_type(bos.version()));
356	}
357	(const_cast<cobject_type &>(co)).m_initialized = true;
358	}
359	else{
360	ar.vsave(class_id_reference_type(co.m_class_id));
361	}
362
363	// if we're not tracking
364	if(! bos.tracking(m_flags)){
365	// just save the data itself
366	ar.end_preamble();
367	serialization::state_saver<const void *> x(pending_object);
368	serialization::state_saver<const basic_oserializer *> y(pending_bos);
369	pending_object = t;
370	pending_bos = & bpos_ptr->get_basic_serializer();
371	bpos_ptr->save_object_ptr(ar, t);
372	return;
373	}
374
375	object_id_type oid(object_set.size());
376	// lookup to see if this object has already been written to the archive
377	basic_oarchive_impl::aobject ao(t, co.m_class_id, oid);
378	std::pair<basic_oarchive_impl::object_set_type::const_iterator, bool>
379	aresult = object_set.insert(ao);
380	oid = aresult.first->object_id;
381	// if the saved object already exists
382	if(! aresult.second){
383	// append the object id to he preamble
384	ar.vsave(object_reference_type(oid));
385	// and windup.
386	ar.end_preamble();
387	return;
388	}
389
390	// append id of this object to preamble
391	ar.vsave(oid);
392	ar.end_preamble();
393
394	// and save the object itself
395	serialization::state_saver<const void *> x(pending_object);
396	serialization::state_saver<const basic_oserializer *> y(pending_bos);
397	pending_object = t;
398	pending_bos = & bpos_ptr->get_basic_serializer();
399	bpos_ptr->save_object_ptr(ar, t);
400	// add to the set of object initially stored through pointers
401	stored_pointers.insert(oid);
402	}
403
404	} // namespace detail
405	} // namespace archive
406	} // namespace boost
407
408	//////////////////////////////////////////////////////////////////////
409	// implementation of basic_oarchive functions
410
411	namespace boost {
412	namespace archive {
413	namespace detail {
414
415	BOOST_ARCHIVE_DECL
416	basic_oarchive::basic_oarchive(unsigned int flags)
417	: pimpl(new basic_oarchive_impl(flags))
418	{}
419
420	BOOST_ARCHIVE_DECL
421	basic_oarchive::~basic_oarchive()
422	{}
423
424	BOOST_ARCHIVE_DECL void
425	basic_oarchive::save_object(
426	const void *x,
427	const basic_oserializer & bos
428	){
429	pimpl->save_object(*this, x, bos);
430	}
431
432	BOOST_ARCHIVE_DECL void
433	basic_oarchive::save_pointer(
434	const void * t,
435	const basic_pointer_oserializer * bpos_ptr
436	){
437	pimpl->save_pointer(*this, t, bpos_ptr);
438	}
439
440	BOOST_ARCHIVE_DECL void
441	basic_oarchive::register_basic_serializer(const basic_oserializer & bos){
442	pimpl->register_type(bos);
443	}
444
445	BOOST_ARCHIVE_DECL library_version_type
446	basic_oarchive::get_library_version() const{
447	return BOOST_ARCHIVE_VERSION();
448	}
449
450	BOOST_ARCHIVE_DECL unsigned int
451	basic_oarchive::get_flags() const{
452	return pimpl->m_flags;
453	}
454
455	BOOST_ARCHIVE_DECL void
456	basic_oarchive::end_preamble(){
457	}
458
459	BOOST_ARCHIVE_DECL helper_collection &
460	basic_oarchive::get_helper_collection(){
461	return *this;
462	}
463
464	} // namespace detail
465	} // namespace archive
466	} // namespace boost
467
468	#ifdef BOOST_MSVC
469	#pragma warning(pop)
470	#endif