Swiftdiff options
| author | Tobias Markmann <tm@ayena.de> | 2014-10-19 20:22:58 (GMT) |
|---|---|---|
| committer | Tobias Markmann <tm@ayena.de> | 2014-10-20 13:49:33 (GMT) |
| commit | 6b22dfcf59474dd016a0355a3102a1dd3692d92c (patch) | |
| tree | 2b1fd33be433a91e81fee84fdc2bf1b52575d934 /3rdParty/Boost/src/boost/archive/detail/iserializer.hpp | |
| parent | 38b0cb785fea8eae5e48fae56440695fdfd10ee1 (diff) | |
| download | swift-contrib-6b22dfcf59474dd016a0355a3102a1dd3692d92c.zip swift-contrib-6b22dfcf59474dd016a0355a3102a1dd3692d92c.tar.bz2 | |
Update Boost in 3rdParty to version 1.56.0.
This updates Boost in our 3rdParty directory to version 1.56.0.
Updated our update.sh script to stop on error.
Changed error reporting in SwiftTools/CrashReporter.cpp to SWIFT_LOG due to
missing include of <iostream> with newer Boost.
Change-Id: I4b35c77de951333979a524097f35f5f83d325edc
Diffstat (limited to '3rdParty/Boost/src/boost/archive/detail/iserializer.hpp')
| -rw-r--r-- | 3rdParty/Boost/src/boost/archive/detail/iserializer.hpp | 216 |
1 files changed, 121 insertions, 95 deletions
diff --git a/3rdParty/Boost/src/boost/archive/detail/iserializer.hpp b/3rdParty/Boost/src/boost/archive/detail/iserializer.hpp index 53765af..cf547de 100644 --- a/3rdParty/Boost/src/boost/archive/detail/iserializer.hpp +++ b/3rdParty/Boost/src/boost/archive/detail/iserializer.hpp @@ -1,620 +1,646 @@ #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) +#if defined(_MSC_VER) # 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 ( \ +#if ! ( \ defined(__BORLANDC__) \ || BOOST_WORKAROUND(__IBMCPP__, < 1210) \ - || 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 + 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)); -// } -//} +// the purpose of this code is to allocate memory for an object +// without requiring the constructor to be called. Presumably +// the allocated object will be subsequently initialized with +// "placement new". +// note: we have the boost type trait has_new_operator but we +// have no corresponding has_delete_operator. So we presume +// that the former being true would imply that the a delete +// operator is also defined for the class T. template<class T> -struct heap_allocator -{ +struct heap_allocation { // 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(){ + static T * invoke_new(){ return static_cast<T *>(operator new(sizeof(T))); } + static viod invoke_delete(){ + (operator delete(sizeof(T))); + } #else + // note: we presume that a true value for has_new_operator + // implies the existence of a class specific delete operator as well + // as a class specific new operator. struct has_new_operator { - static T* invoke() { + static T * invoke_new() { return static_cast<T *>((T::operator new)(sizeof(T))); } + static void invoke_delete(T * t) { + // if compilation fails here, the likely cause that the class + // T has a class specific new operator but no class specific + // delete operator which matches the following signature. Fix + // your program to have this. Note that adding operator delete + // with only one parameter doesn't seem correct to me since + // the standard(3.7.4.2) says " + // "If a class T has a member deallocation function named + // 'operator delete' with exactly one parameter, then that function + // is a usual (non-placement) deallocation function" which I take + // to mean that it will call the destructor of type T which we don't + // want to do here. + // Note: reliance upon automatic conversion from T * to void * here + (T::operator delete)(t, sizeof(T)); + } }; struct doesnt_have_new_operator { - static T* invoke() { + static T* invoke_new() { return static_cast<T *>(operator new(sizeof(T))); } + static void invoke_delete(T * t) { + // Note: I'm reliance upon automatic conversion from T * to void * here + (operator delete)(t); + } }; - static T * invoke() { - typedef BOOST_DEDUCED_TYPENAME + static T * invoke_new() { + typedef 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(); + return typex::invoke_new(); + } + static void invoke_delete(T *t) { + typedef typename + mpl::eval_if< + boost::has_new_operator< T >, + mpl::identity<has_new_operator >, + mpl::identity<doesnt_have_new_operator > + >::type typex; + typex::invoke_delete(t); } #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); + explicit heap_allocation(){ + m_p = invoke_new(); + } + ~heap_allocation(){ + if (0 != m_p) + invoke_delete(m_p); } T* get() const { return m_p; } T* release() { T* p = m_p; - m_p = NULL; + m_p = 0; return p; } private: T* m_p; }; +template<class Archive, class T> +class pointer_iserializer : + public basic_pointer_iserializer +{ +private: + virtual void * heap_allocation() const { + detail::heap_allocation<T> h; + T * t = h.get(); + h.release(); + return t; + } + 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: 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, + void * t, 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; + // note that the above will throw std::bad_alloc if the allocation + // fails so we don't have to address this contingency here. // 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 + // this addresses an obscure situation 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, + static_cast<T *>(t), file_version ); } BOOST_CATCH(...){ - ap.release(); + // if we get here the load_construct failed. The heap_allocation + // will be automatically deleted so we don't have to do anything + // special here. BOOST_RETHROW; } BOOST_CATCH_END - ar_impl >> boost::serialization::make_nvp(NULL, * t); - ap.release(); + ar_impl >> boost::serialization::make_nvp(NULL, * static_cast<T *>(t)); } template<class Archive, class T> pointer_iserializer<Archive, T>::pointer_iserializer() : basic_pointer_iserializer( boost::serialization::singleton< - BOOST_DEDUCED_TYPENAME + 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< + typedef 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< + 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< + 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 + typedef 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 - ) + void * upcast = const_cast<void *>( + boost::serialization::void_upcast( + eti, + boost::serialization::singleton< + typename + boost::serialization::type_info_implementation< T >::type + >::get_const_instance(), + t ) ); + if(NULL == upcast) + boost::serialization::throw_exception( + archive_exception(archive_exception::unregistered_class) + ); + return static_cast<T *>(upcast); } 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; + typedef 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 >, + typename mpl::eval_if<is_pointer< T >, mpl::identity<detail::load_pointer_type<Archive> > ,//else - BOOST_DEDUCED_TYPENAME mpl::eval_if<is_array< T >, + typename mpl::eval_if<is_array< T >, mpl::identity<detail::load_array_type<Archive> > ,//else - BOOST_DEDUCED_TYPENAME mpl::eval_if<is_enum< T >, + 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> |