diff options
Diffstat (limited to 'src/third_party/boost-1.69.0/boost/serialization')
43 files changed, 4424 insertions, 0 deletions
diff --git a/src/third_party/boost-1.69.0/boost/serialization/access.hpp b/src/third_party/boost-1.69.0/boost/serialization/access.hpp new file mode 100644 index 00000000000..f6581accc91 --- /dev/null +++ b/src/third_party/boost-1.69.0/boost/serialization/access.hpp @@ -0,0 +1,145 @@ +#ifndef BOOST_SERIALIZATION_ACCESS_HPP +#define BOOST_SERIALIZATION_ACCESS_HPP + +// MS compatible compilers support #pragma once +#if defined(_MSC_VER) +# pragma once +#endif + +/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8 +// access.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 <boost/config.hpp> + +namespace boost { + +namespace archive { +namespace detail { + template<class Archive, class T> + class iserializer; + template<class Archive, class T> + class oserializer; +} // namespace detail +} // namespace archive + +namespace serialization { + +// forward declarations +template<class Archive, class T> +inline void serialize_adl(Archive &, T &, const unsigned int); +namespace detail { + template<class Archive, class T> + struct member_saver; + template<class Archive, class T> + struct member_loader; +} // namespace detail + +// use an "accessor class so that we can use: +// "friend class boost::serialization::access;" +// in any serialized class to permit clean, safe access to private class members +// by the serialization system + +class access { +public: + // grant access to "real" serialization defaults +#ifdef BOOST_NO_MEMBER_TEMPLATE_FRIENDS +public: +#else + template<class Archive, class T> + friend struct detail::member_saver; + template<class Archive, class T> + friend struct detail::member_loader; + template<class Archive, class T> + friend class archive::detail::iserializer; + template<class Archive, class T> + friend class archive::detail::oserializer; + template<class Archive, class T> + friend inline void serialize( + Archive & ar, + T & t, + const unsigned int file_version + ); + template<class Archive, class T> + friend inline void save_construct_data( + Archive & ar, + const T * t, + const unsigned int file_version + ); + template<class Archive, class T> + friend inline void load_construct_data( + Archive & ar, + T * t, + const unsigned int file_version + ); +#endif + + // pass calls to users's class implementation + template<class Archive, class T> + static void member_save( + Archive & ar, + //const T & t, + T & t, + const unsigned int file_version + ){ + t.save(ar, file_version); + } + template<class Archive, class T> + static void member_load( + Archive & ar, + T & t, + const unsigned int file_version + ){ + t.load(ar, file_version); + } + template<class Archive, class T> + static void serialize( + Archive & ar, + T & t, + const unsigned int file_version + ){ + // note: if you get a compile time error here with a + // message something like: + // cannot convert parameter 1 from <file type 1> to <file type 2 &> + // a likely possible cause is that the class T contains a + // serialize function - but that serialize function isn't + // a template and corresponds to a file type different than + // the class Archive. To resolve this, don't include an + // archive type other than that for which the serialization + // function is defined!!! + t.serialize(ar, file_version); + } + template<class T> + static void destroy( const T * t) // const appropriate here? + { + // the const business is an MSVC 6.0 hack that should be + // benign on everything else + delete const_cast<T *>(t); + } + template<class T> + static void construct(T * t){ + // default is inplace invocation of default constructor + // Note the :: before the placement new. Required if the + // class doesn't have a class-specific placement new defined. + ::new(t)T; + } + template<class T, class U> + static T & cast_reference(U & u){ + return static_cast<T &>(u); + } + template<class T, class U> + static T * cast_pointer(U * u){ + return static_cast<T *>(u); + } +}; + +} // namespace serialization +} // namespace boost + +#endif // BOOST_SERIALIZATION_ACCESS_HPP diff --git a/src/third_party/boost-1.69.0/boost/serialization/array_optimization.hpp b/src/third_party/boost-1.69.0/boost/serialization/array_optimization.hpp new file mode 100644 index 00000000000..40dffba871a --- /dev/null +++ b/src/third_party/boost-1.69.0/boost/serialization/array_optimization.hpp @@ -0,0 +1,37 @@ +#ifndef BOOST_SERIALIZATION_ARRAY_OPTIMIZATON_HPP +#define BOOST_SERIALIZATION_ARRAY_OPTIMIZATON_HPP + +// (C) Copyright 2005 Matthias Troyer and Dave Abrahams +// 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) + +#include <boost/config.hpp> // msvc 6.0 needs this for warning suppression + +#if defined(BOOST_NO_STDC_NAMESPACE) +namespace std{ + using ::size_t; +} // namespace std +#endif + +#include <boost/mpl/always.hpp> +#include <boost/mpl/apply.hpp> +#include <boost/type_traits/remove_const.hpp> + +namespace boost { namespace serialization { + +template <class Archive> +struct use_array_optimization : boost::mpl::always<boost::mpl::false_> {}; + +} } // end namespace boost::serialization + +#define BOOST_SERIALIZATION_USE_ARRAY_OPTIMIZATION(Archive) \ +namespace boost { namespace serialization { \ +template <> struct use_array_optimization<Archive> { \ + template <class ValueType> \ + struct apply : boost::mpl::apply1<Archive::use_array_optimization \ + , typename boost::remove_const<ValueType>::type \ + >::type {}; \ +}; }} + +#endif //BOOST_SERIALIZATION_ARRAY_OPTIMIZATON_HPP diff --git a/src/third_party/boost-1.69.0/boost/serialization/array_wrapper.hpp b/src/third_party/boost-1.69.0/boost/serialization/array_wrapper.hpp new file mode 100644 index 00000000000..adf436e15b4 --- /dev/null +++ b/src/third_party/boost-1.69.0/boost/serialization/array_wrapper.hpp @@ -0,0 +1,121 @@ +#ifndef BOOST_SERIALIZATION_ARRAY_WRAPPER_HPP +#define BOOST_SERIALIZATION_ARRAY_WRAPPER_HPP + +// (C) Copyright 2005 Matthias Troyer and Dave Abrahams +// 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) + +//#include <iostream> + +#include <boost/config.hpp> // msvc 6.0 needs this for warning suppression + +#if defined(BOOST_NO_STDC_NAMESPACE) +namespace std{ + using ::size_t; +} // namespace std +#endif + +#include <boost/serialization/nvp.hpp> +#include <boost/serialization/split_member.hpp> +#include <boost/serialization/wrapper.hpp> +#include <boost/serialization/collection_size_type.hpp> +#include <boost/serialization/array_optimization.hpp> +#include <boost/mpl/always.hpp> +#include <boost/mpl/apply.hpp> +#include <boost/mpl/bool_fwd.hpp> +#include <boost/type_traits/remove_const.hpp> + +namespace boost { namespace serialization { + +template<class T> +class array_wrapper : + public wrapper_traits<const array_wrapper< T > > +{ +private: + array_wrapper & operator=(const array_wrapper & rhs); + // note: I would like to make the copy constructor private but this breaks + // make_array. So I make make_array a friend + template<class Tx, class S> + friend const boost::serialization::array_wrapper<Tx> make_array(Tx * t, S s); +public: + + array_wrapper(const array_wrapper & rhs) : + m_t(rhs.m_t), + m_element_count(rhs.m_element_count) + {} +public: + array_wrapper(T * t, std::size_t s) : + m_t(t), + m_element_count(s) + {} + + // default implementation + template<class Archive> + void serialize_optimized(Archive &ar, const unsigned int, mpl::false_ ) const + { + // default implemention does the loop + std::size_t c = count(); + T * t = address(); + while(0 < c--) + ar & boost::serialization::make_nvp("item", *t++); + } + + // optimized implementation + template<class Archive> + void serialize_optimized(Archive &ar, const unsigned int version, mpl::true_ ) + { + boost::serialization::split_member(ar, *this, version); + } + + // default implementation + template<class Archive> + void save(Archive &ar, const unsigned int version) const + { + ar.save_array(*this,version); + } + + // default implementation + template<class Archive> + void load(Archive &ar, const unsigned int version) + { + ar.load_array(*this,version); + } + + // default implementation + template<class Archive> + void serialize(Archive &ar, const unsigned int version) + { + typedef typename + boost::serialization::use_array_optimization<Archive>::template apply< + typename remove_const< T >::type + >::type use_optimized; + serialize_optimized(ar,version,use_optimized()); + } + + T * address() const + { + return m_t; + } + + std::size_t count() const + { + return m_element_count; + } + +private: + T * const m_t; + const std::size_t m_element_count; +}; + +template<class T, class S> +inline +const array_wrapper< T > make_array(T* t, S s){ + const array_wrapper< T > a(t, s); + return a; +} + +} } // end namespace boost::serialization + + +#endif //BOOST_SERIALIZATION_ARRAY_WRAPPER_HPP diff --git a/src/third_party/boost-1.69.0/boost/serialization/assume_abstract.hpp b/src/third_party/boost-1.69.0/boost/serialization/assume_abstract.hpp new file mode 100644 index 00000000000..632f9312f5f --- /dev/null +++ b/src/third_party/boost-1.69.0/boost/serialization/assume_abstract.hpp @@ -0,0 +1,60 @@ +#ifndef BOOST_SERIALIZATION_ASSUME_ABSTRACT_HPP +#define BOOST_SERIALIZATION_ASSUME_ABSTRACT_HPP + +// MS compatible compilers support #pragma once +#if defined(_MSC_VER) +# pragma once +#endif + +/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8 +// assume_abstract_class.hpp: + +// (C) Copyright 2008 Robert Ramey +// 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. + +// this is useful for compilers which don't support the boost::is_abstract + +#include <boost/type_traits/is_abstract.hpp> +#include <boost/mpl/bool_fwd.hpp> + +#ifndef BOOST_NO_IS_ABSTRACT + +// if there is an intrinsic is_abstract defined, we don't have to do anything +#define BOOST_SERIALIZATION_ASSUME_ABSTRACT(T) + +// but forward to the "official" is_abstract +namespace boost { +namespace serialization { + template<class T> + struct is_abstract : boost::is_abstract< T > {} ; +} // namespace serialization +} // namespace boost + +#else +// we have to "make" one + +namespace boost { +namespace serialization { + template<class T> + struct is_abstract : boost::false_type {}; +} // namespace serialization +} // namespace boost + +// define a macro to make explicit designation of this more transparent +#define BOOST_SERIALIZATION_ASSUME_ABSTRACT(T) \ +namespace boost { \ +namespace serialization { \ +template<> \ +struct is_abstract< T > : boost::true_type {}; \ +template<> \ +struct is_abstract< const T > : boost::true_type {}; \ +}} \ +/**/ + +#endif // BOOST_NO_IS_ABSTRACT + +#endif //BOOST_SERIALIZATION_ASSUME_ABSTRACT_HPP diff --git a/src/third_party/boost-1.69.0/boost/serialization/base_object.hpp b/src/third_party/boost-1.69.0/boost/serialization/base_object.hpp new file mode 100644 index 00000000000..1a82cecd4b5 --- /dev/null +++ b/src/third_party/boost-1.69.0/boost/serialization/base_object.hpp @@ -0,0 +1,100 @@ +#ifndef BOOST_SERIALIZATION_BASE_OBJECT_HPP +#define BOOST_SERIALIZATION_BASE_OBJECT_HPP + +// MS compatible compilers support #pragma once +#if defined(_MSC_VER) +# pragma once +#endif + +/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8 +// base_object.hpp: + +// (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. + +// if no archive headers have been included this is a no op +// this is to permit BOOST_EXPORT etc to be included in a +// file declaration header + +#include <boost/config.hpp> +#include <boost/detail/workaround.hpp> + +#include <boost/mpl/eval_if.hpp> +#include <boost/mpl/int.hpp> +#include <boost/mpl/identity.hpp> + +#include <boost/type_traits/is_base_and_derived.hpp> +#include <boost/type_traits/is_pointer.hpp> +#include <boost/type_traits/is_const.hpp> +#include <boost/type_traits/is_polymorphic.hpp> + +#include <boost/static_assert.hpp> +#include <boost/serialization/access.hpp> +#include <boost/serialization/force_include.hpp> +#include <boost/serialization/void_cast_fwd.hpp> + +namespace boost { +namespace serialization { + +namespace detail +{ + // get the base type for a given derived type + // preserving the const-ness + template<class B, class D> + struct base_cast + { + typedef typename + mpl::if_< + is_const<D>, + const B, + B + >::type type; + BOOST_STATIC_ASSERT(is_const<type>::value == is_const<D>::value); + }; + + // only register void casts if the types are polymorphic + template<class Base, class Derived> + struct base_register + { + struct polymorphic { + static void const * invoke(){ + Base const * const b = 0; + Derived const * const d = 0; + return & void_cast_register(d, b); + } + }; + struct non_polymorphic { + static void const * invoke(){ + return 0; + } + }; + static void const * invoke(){ + typedef typename mpl::eval_if< + is_polymorphic<Base>, + mpl::identity<polymorphic>, + mpl::identity<non_polymorphic> + >::type type; + return type::invoke(); + } + }; + +} // namespace detail +template<class Base, class Derived> +typename detail::base_cast<Base, Derived>::type & +base_object(Derived &d) +{ + BOOST_STATIC_ASSERT(( is_base_and_derived<Base,Derived>::value)); + BOOST_STATIC_ASSERT(! is_pointer<Derived>::value); + typedef typename detail::base_cast<Base, Derived>::type type; + detail::base_register<type, Derived>::invoke(); + return access::cast_reference<type, Derived>(d); +} + +} // namespace serialization +} // namespace boost + +#endif // BOOST_SERIALIZATION_BASE_OBJECT_HPP diff --git a/src/third_party/boost-1.69.0/boost/serialization/collection_size_type.hpp b/src/third_party/boost-1.69.0/boost/serialization/collection_size_type.hpp new file mode 100644 index 00000000000..2dd8fa72584 --- /dev/null +++ b/src/third_party/boost-1.69.0/boost/serialization/collection_size_type.hpp @@ -0,0 +1,62 @@ +#ifndef BOOST_SERIALIZATION_COLLECTION_SIZE_TYPE_HPP +#define BOOST_SERIALIZATION_COLLECTION_SIZE_TYPE_HPP + +// (C) Copyright 2005 Matthias Troyer +// 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) + +#include <cstddef> // size_t +#include <boost/serialization/strong_typedef.hpp> +#include <boost/serialization/level.hpp> +#include <boost/serialization/split_free.hpp> +#include <boost/serialization/is_bitwise_serializable.hpp> + +namespace boost { +namespace serialization { + +//BOOST_STRONG_TYPEDEF(std::size_t, collection_size_type) + +class collection_size_type { +private: + typedef std::size_t base_type; + base_type t; +public: + collection_size_type(): t(0) {}; + explicit collection_size_type(const std::size_t & t_) : + t(t_) + {} + collection_size_type(const collection_size_type & t_) : + t(t_.t) + {} + collection_size_type & operator=(const collection_size_type & rhs){ + t = rhs.t; + return *this; + } + collection_size_type & operator=(const unsigned int & rhs){ + t = rhs; + return *this; + } + // used for text output + operator base_type () const { + return t; + } + // used for text input + operator base_type & () { + return t; + } + bool operator==(const collection_size_type & rhs) const { + return t == rhs.t; + } + bool operator<(const collection_size_type & rhs) const { + return t < rhs.t; + } +}; + + +} } // end namespace boost::serialization + +BOOST_CLASS_IMPLEMENTATION(collection_size_type, primitive_type) +BOOST_IS_BITWISE_SERIALIZABLE(collection_size_type) + +#endif //BOOST_SERIALIZATION_COLLECTION_SIZE_TYPE_HPP diff --git a/src/third_party/boost-1.69.0/boost/serialization/collection_traits.hpp b/src/third_party/boost-1.69.0/boost/serialization/collection_traits.hpp new file mode 100644 index 00000000000..3ec9401eff0 --- /dev/null +++ b/src/third_party/boost-1.69.0/boost/serialization/collection_traits.hpp @@ -0,0 +1,79 @@ +#ifndef BOOST_SERIALIZATION_COLLECTION_TRAITS_HPP +#define BOOST_SERIALIZATION_COLLECTION_TRAITS_HPP + +// MS compatible compilers support #pragma once +#if defined(_MSC_VER) +# pragma once +#endif + +/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8 +// collection_traits.hpp: + +// (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. + +// This header assigns a level implemenation trait to a collection type +// for all primitives. It is needed so that archives which are meant to be +// portable don't write class information in the archive. Since, not all +// compiles recognize the same set of primitive types, the possibility +// exists for archives to be non-portable if class information for primitive +// types is included. This is addressed by the following macros. +#include <boost/config.hpp> +//#include <boost/mpl/integral_c.hpp> +#include <boost/mpl/integral_c_tag.hpp> + +#include <boost/cstdint.hpp> +#include <boost/integer_traits.hpp> +#include <climits> // ULONG_MAX +#include <boost/serialization/level.hpp> + +#define BOOST_SERIALIZATION_COLLECTION_TRAITS_HELPER(T, C) \ +template<> \ +struct implementation_level< C < T > > { \ + typedef mpl::integral_c_tag tag; \ + typedef mpl::int_<object_serializable> type; \ + BOOST_STATIC_CONSTANT(int, value = object_serializable); \ +}; \ +/**/ + +#if defined(BOOST_NO_CWCHAR) || defined(BOOST_NO_INTRINSIC_WCHAR_T) + #define BOOST_SERIALIZATION_COLLECTION_TRAITS_HELPER_WCHAR(C) +#else + #define BOOST_SERIALIZATION_COLLECTION_TRAITS_HELPER_WCHAR(C) \ + BOOST_SERIALIZATION_COLLECTION_TRAITS_HELPER(wchar_t, C) \ + /**/ +#endif + +#if defined(BOOST_HAS_LONG_LONG) + #define BOOST_SERIALIZATION_COLLECTION_TRAITS_HELPER_INT64(C) \ + BOOST_SERIALIZATION_COLLECTION_TRAITS_HELPER(boost::long_long_type, C) \ + BOOST_SERIALIZATION_COLLECTION_TRAITS_HELPER(boost::ulong_long_type, C) \ + /**/ +#else + #define BOOST_SERIALIZATION_COLLECTION_TRAITS_HELPER_INT64(C) +#endif + +#define BOOST_SERIALIZATION_COLLECTION_TRAITS(C) \ + namespace boost { namespace serialization { \ + BOOST_SERIALIZATION_COLLECTION_TRAITS_HELPER(bool, C) \ + BOOST_SERIALIZATION_COLLECTION_TRAITS_HELPER(char, C) \ + BOOST_SERIALIZATION_COLLECTION_TRAITS_HELPER(signed char, C) \ + BOOST_SERIALIZATION_COLLECTION_TRAITS_HELPER(unsigned char, C) \ + BOOST_SERIALIZATION_COLLECTION_TRAITS_HELPER(signed int, C) \ + BOOST_SERIALIZATION_COLLECTION_TRAITS_HELPER(unsigned int, C) \ + BOOST_SERIALIZATION_COLLECTION_TRAITS_HELPER(signed long, C) \ + BOOST_SERIALIZATION_COLLECTION_TRAITS_HELPER(unsigned long, C) \ + BOOST_SERIALIZATION_COLLECTION_TRAITS_HELPER(float, C) \ + BOOST_SERIALIZATION_COLLECTION_TRAITS_HELPER(double, C) \ + BOOST_SERIALIZATION_COLLECTION_TRAITS_HELPER(unsigned short, C) \ + BOOST_SERIALIZATION_COLLECTION_TRAITS_HELPER(signed short, C) \ + BOOST_SERIALIZATION_COLLECTION_TRAITS_HELPER_INT64(C) \ + BOOST_SERIALIZATION_COLLECTION_TRAITS_HELPER_WCHAR(C) \ + } } \ + /**/ + +#endif // BOOST_SERIALIZATION_COLLECTION_TRAITS diff --git a/src/third_party/boost-1.69.0/boost/serialization/collections_load_imp.hpp b/src/third_party/boost-1.69.0/boost/serialization/collections_load_imp.hpp new file mode 100644 index 00000000000..e042c0c130d --- /dev/null +++ b/src/third_party/boost-1.69.0/boost/serialization/collections_load_imp.hpp @@ -0,0 +1,106 @@ +#ifndef BOOST_SERIALIZATION_COLLECTIONS_LOAD_IMP_HPP +#define BOOST_SERIALIZATION_COLLECTIONS_LOAD_IMP_HPP + +// MS compatible compilers support #pragma once +#if defined(_MSC_VER) +# pragma once +#endif + +#if defined(_MSC_VER) && (_MSC_VER <= 1020) +# pragma warning (disable : 4786) // too long name, harmless warning +#endif + +/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8 +// collections_load_imp.hpp: serialization for loading stl collections + +// (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. + +// helper function templates for serialization of collections + +#include <boost/assert.hpp> +#include <cstddef> // size_t +#include <boost/config.hpp> // msvc 6.0 needs this for warning suppression +#if defined(BOOST_NO_STDC_NAMESPACE) +namespace std{ + using ::size_t; +} // namespace std +#endif +#include <boost/detail/workaround.hpp> + +#include <boost/archive/detail/basic_iarchive.hpp> +#include <boost/serialization/access.hpp> +#include <boost/serialization/nvp.hpp> +#include <boost/serialization/detail/stack_constructor.hpp> +#include <boost/serialization/collection_size_type.hpp> +#include <boost/serialization/item_version_type.hpp> +#include <boost/serialization/detail/is_default_constructible.hpp> +#include <boost/utility/enable_if.hpp> +#include <boost/move/utility_core.hpp> + +namespace boost{ +namespace serialization { +namespace stl { + +////////////////////////////////////////////////////////////////////// +// implementation of serialization for STL containers +// + +template< + class Archive, + class T +> +typename boost::enable_if< + typename detail::is_default_constructible< + typename T::value_type + >, + void +>::type +collection_load_impl( + Archive & ar, + T & t, + collection_size_type count, + item_version_type /*item_version*/ +){ + t.resize(count); + typename T::iterator hint; + hint = t.begin(); + while(count-- > 0){ + ar >> boost::serialization::make_nvp("item", *hint++); + } +} + +template< + class Archive, + class T +> +typename boost::disable_if< + typename detail::is_default_constructible< + typename T::value_type + >, + void +>::type +collection_load_impl( + Archive & ar, + T & t, + collection_size_type count, + item_version_type item_version +){ + t.clear(); + while(count-- > 0){ + detail::stack_construct<Archive, typename T::value_type> u(ar, item_version); + ar >> boost::serialization::make_nvp("item", u.reference()); + t.push_back(boost::move(u.reference())); + ar.reset_object_address(& t.back() , & u.reference()); + } +} + +} // namespace stl +} // namespace serialization +} // namespace boost + +#endif //BOOST_SERIALIZATION_COLLECTIONS_LOAD_IMP_HPP diff --git a/src/third_party/boost-1.69.0/boost/serialization/collections_save_imp.hpp b/src/third_party/boost-1.69.0/boost/serialization/collections_save_imp.hpp new file mode 100644 index 00000000000..5ada155e241 --- /dev/null +++ b/src/third_party/boost-1.69.0/boost/serialization/collections_save_imp.hpp @@ -0,0 +1,83 @@ +#ifndef BOOST_SERIALIZATION_COLLECTIONS_SAVE_IMP_HPP +#define BOOST_SERIALIZATION_COLLECTIONS_SAVE_IMP_HPP + +// MS compatible compilers support #pragma once +#if defined(_MSC_VER) +# pragma once +#endif + +/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8 +// collections_save_imp.hpp: serialization for stl collections + +// (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. + +// helper function templates for serialization of collections + +#include <boost/config.hpp> +#include <boost/core/addressof.hpp> +#include <boost/serialization/nvp.hpp> +#include <boost/serialization/serialization.hpp> +#include <boost/serialization/version.hpp> +#include <boost/serialization/collection_size_type.hpp> +#include <boost/serialization/item_version_type.hpp> + +namespace boost{ +namespace serialization { +namespace stl { + +////////////////////////////////////////////////////////////////////// +// implementation of serialization for STL containers +// + +template<class Archive, class Container> +inline void save_collection( + Archive & ar, + const Container &s, + collection_size_type count) +{ + ar << BOOST_SERIALIZATION_NVP(count); + // record number of elements + const item_version_type item_version( + version<typename Container::value_type>::value + ); + #if 0 + boost::archive::library_version_type library_version( + ar.get_library_version() + ); + if(boost::archive::library_version_type(3) < library_version){ + ar << BOOST_SERIALIZATION_NVP(item_version); + } + #else + ar << BOOST_SERIALIZATION_NVP(item_version); + #endif + + typename Container::const_iterator it = s.begin(); + while(count-- > 0){ + // note borland emits a no-op without the explicit namespace + boost::serialization::save_construct_data_adl( + ar, + boost::addressof(*it), + item_version + ); + ar << boost::serialization::make_nvp("item", *it++); + } +} + +template<class Archive, class Container> +inline void save_collection(Archive & ar, const Container &s) +{ + // record number of elements + collection_size_type count(s.size()); + save_collection(ar, s, count); +} + +} // namespace stl +} // namespace serialization +} // namespace boost + +#endif //BOOST_SERIALIZATION_COLLECTIONS_SAVE_IMP_HPP diff --git a/src/third_party/boost-1.69.0/boost/serialization/config.hpp b/src/third_party/boost-1.69.0/boost/serialization/config.hpp new file mode 100644 index 00000000000..ea8cb9239ed --- /dev/null +++ b/src/third_party/boost-1.69.0/boost/serialization/config.hpp @@ -0,0 +1,74 @@ +#ifndef BOOST_SERIALIZATION_CONFIG_HPP +#define BOOST_SERIALIZATION_CONFIG_HPP + +// config.hpp ---------------------------------------------// + +// (c) Copyright Robert Ramey 2004 +// 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 library home page at http://www.boost.org/libs/serialization + +//----------------------------------------------------------------------------// + +// This header implements separate compilation features as described in +// http://www.boost.org/more/separate_compilation.html + +#include <boost/config.hpp> +#include <boost/detail/workaround.hpp> + +// note: this version incorporates the related code into the the +// the same library as BOOST_ARCHIVE. This could change some day in the +// future + +// if BOOST_SERIALIZATION_DECL is defined undefine it now: +#ifdef BOOST_SERIALIZATION_DECL + #undef BOOST_SERIALIZATION_DECL +#endif + +// we need to import/export our code only if the user has specifically +// asked for it by defining either BOOST_ALL_DYN_LINK if they want all boost +// libraries to be dynamically linked, or BOOST_SERIALIZATION_DYN_LINK +// if they want just this one to be dynamically liked: +#if defined(BOOST_ALL_DYN_LINK) || defined(BOOST_SERIALIZATION_DYN_LINK) + #if !defined(BOOST_DYN_LINK) + #define BOOST_DYN_LINK + #endif + // export if this is our own source, otherwise import: + #if defined(BOOST_SERIALIZATION_SOURCE) + #define BOOST_SERIALIZATION_DECL BOOST_SYMBOL_EXPORT + #else + #define BOOST_SERIALIZATION_DECL BOOST_SYMBOL_IMPORT + #endif // defined(BOOST_SERIALIZATION_SOURCE) +#endif // defined(BOOST_ALL_DYN_LINK) || defined(BOOST_SERIALIZATION_DYN_LINK) + +// if BOOST_SERIALIZATION_DECL isn't defined yet define it now: +#ifndef BOOST_SERIALIZATION_DECL + #define BOOST_SERIALIZATION_DECL +#endif + +// enable automatic library variant selection ------------------------------// + +#if !defined(BOOST_ALL_NO_LIB) && !defined(BOOST_SERIALIZATION_NO_LIB) \ +&& !defined(BOOST_ARCHIVE_SOURCE) && !defined(BOOST_WARCHIVE_SOURCE) \ +&& !defined(BOOST_SERIALIZATION_SOURCE) + // + // Set the name of our library, this will get undef'ed by auto_link.hpp + // once it's done with it: + // + #define BOOST_LIB_NAME boost_serialization + // + // If we're importing code from a dll, then tell auto_link.hpp about it: + // + #if defined(BOOST_ALL_DYN_LINK) || defined(BOOST_SERIALIZATION_DYN_LINK) + # define BOOST_DYN_LINK + #endif + // + // And include the header that does the work: + // + #include <boost/config/auto_link.hpp> + +#endif + +#endif // BOOST_SERIALIZATION_CONFIG_HPP diff --git a/src/third_party/boost-1.69.0/boost/serialization/detail/is_default_constructible.hpp b/src/third_party/boost-1.69.0/boost/serialization/detail/is_default_constructible.hpp new file mode 100644 index 00000000000..4d20b13bf3e --- /dev/null +++ b/src/third_party/boost-1.69.0/boost/serialization/detail/is_default_constructible.hpp @@ -0,0 +1,54 @@ +#ifndef BOOST_SERIALIZATION_DETAIL_IS_DEFAULT_CONSTRUCTIBLE_HPP +#define BOOST_SERIALIZATION_DETAIL_IS_DEFAULT_CONSTRUCTIBLE_HPP + +// MS compatible compilers support #pragma once +#if defined(_MSC_VER) +# pragma once +#endif + +/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8 +// is_default_constructible.hpp: serialization for loading stl collections +// +// (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> + +#if ! defined(BOOST_NO_CXX11_HDR_TYPE_TRAITS) + #include <type_traits> + namespace boost{ + namespace serialization { + namespace detail { + + template<typename T> + struct is_default_constructible : public std::is_default_constructible<T> {}; + + } // detail + } // serializaition + } // boost +#else + // we don't have standard library support for is_default_constructible + // so we fake it by using boost::has_trivial_construtor. But this is not + // actually correct because it's possible that a default constructor + // to be non trivial. So when using this, make sure you're not using your + // own definition of of T() but are using the actual default one! + #include <boost/type_traits/has_trivial_constructor.hpp> + namespace boost{ + namespace serialization { + namespace detail { + + template<typename T> + struct is_default_constructible : public boost::has_trivial_constructor<T> {}; + + } // detail + } // serializaition + } // boost + +#endif + + +#endif // BOOST_SERIALIZATION_DETAIL_IS_DEFAULT_CONSTRUCTIBLE_HPP diff --git a/src/third_party/boost-1.69.0/boost/serialization/detail/stack_constructor.hpp b/src/third_party/boost-1.69.0/boost/serialization/detail/stack_constructor.hpp new file mode 100644 index 00000000000..ae14832c6db --- /dev/null +++ b/src/third_party/boost-1.69.0/boost/serialization/detail/stack_constructor.hpp @@ -0,0 +1,66 @@ +#ifndef BOOST_SERIALIZATION_DETAIL_STACK_CONSTRUCTOR_HPP +#define BOOST_SERIALIZATION_DETAIL_STACK_CONSTRUCTOR_HPP + +// MS compatible compilers support #pragma once +#if defined(_MSC_VER) +# pragma once +#endif + +/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8 +// stack_constructor.hpp: serialization for loading stl collections + +// (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/aligned_storage.hpp> +#include <boost/serialization/serialization.hpp> + +namespace boost{ +namespace serialization { +namespace detail { + +// reserve space on stack for an object of type T without actually +// construction such an object +template<typename T > +struct stack_allocate +{ + T * address() { + return static_cast<T*>(storage_.address()); + } + T & reference() { + return * address(); + } +private: + typedef typename boost::aligned_storage< + sizeof(T), + boost::alignment_of<T>::value + > type; + type storage_; +}; + +// construct element on the stack +template<class Archive, class T> +struct stack_construct : public stack_allocate<T> +{ + stack_construct(Archive & ar, const unsigned int version){ + // note borland emits a no-op without the explicit namespace + boost::serialization::load_construct_data_adl( + ar, + this->address(), + version + ); + } + ~stack_construct(){ + this->address()->~T(); // undo load_construct_data above + } +}; + +} // detail +} // serializaition +} // boost + +#endif // BOOST_SERIALIZATION_DETAIL_STACH_CONSTRUCTOR_HPP diff --git a/src/third_party/boost-1.69.0/boost/serialization/extended_type_info.hpp b/src/third_party/boost-1.69.0/boost/serialization/extended_type_info.hpp new file mode 100644 index 00000000000..bb2a190d465 --- /dev/null +++ b/src/third_party/boost-1.69.0/boost/serialization/extended_type_info.hpp @@ -0,0 +1,116 @@ +#ifndef BOOST_SERIALIZATION_EXTENDED_TYPE_INFO_HPP +#define BOOST_SERIALIZATION_EXTENDED_TYPE_INFO_HPP + +// MS compatible compilers support #pragma once +#if defined(_MSC_VER) +# pragma once +#endif + +/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8 +// extended_type_info.hpp: interface for portable version of type_info + +// (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. + +// for now, extended type info is part of the serialization libraries +// this could change in the future. +#include <cstdarg> +#include <boost/assert.hpp> +#include <cstddef> // NULL +#include <boost/config.hpp> +#include <boost/noncopyable.hpp> +#include <boost/mpl/bool.hpp> + +#include <boost/serialization/config.hpp> +#include <boost/config/abi_prefix.hpp> // must be the last header +#ifdef BOOST_MSVC +# pragma warning(push) +# pragma warning(disable : 4251 4231 4660 4275) +#endif + +#define BOOST_SERIALIZATION_MAX_KEY_SIZE 128 + +namespace boost { +namespace serialization { + +namespace void_cast_detail{ + class void_caster; +} + +class BOOST_SYMBOL_VISIBLE extended_type_info : + private boost::noncopyable +{ +private: + friend class boost::serialization::void_cast_detail::void_caster; + + // used to uniquely identify the type of class derived from this one + // so that different derivations of this class can be simultaneously + // included in implementation of sets and maps. + const unsigned int m_type_info_key; + virtual bool is_less_than(const extended_type_info & /*rhs*/) const = 0; + virtual bool is_equal(const extended_type_info & /*rhs*/) const = 0; + const char * m_key; + +protected: + BOOST_SERIALIZATION_DECL void key_unregister() const; + BOOST_SERIALIZATION_DECL void key_register() const; + // this class can't be used as is. It's just the + // common functionality for all type_info replacement + // systems. Hence, make these protected + BOOST_SERIALIZATION_DECL extended_type_info( + const unsigned int type_info_key, + const char * key + ); + virtual BOOST_SERIALIZATION_DECL ~extended_type_info(); +public: + const char * get_key() const { + return m_key; + } + virtual const char * get_debug_info() const = 0; + BOOST_SERIALIZATION_DECL bool operator<(const extended_type_info &rhs) const; + BOOST_SERIALIZATION_DECL bool operator==(const extended_type_info &rhs) const; + bool operator!=(const extended_type_info &rhs) const { + return !(operator==(rhs)); + } + // note explicit "export" of static function to work around + // gcc 4.5 mingw error + static BOOST_SERIALIZATION_DECL const extended_type_info * + find(const char *key); + // for plugins + virtual void * construct(unsigned int /*count*/ = 0, ...) const = 0; + virtual void destroy(void const * const /*p*/) const = 0; +}; + +template<class T> +struct guid_defined : boost::mpl::false_ {}; + +namespace ext { + template <typename T> + struct guid_impl + { + static inline const char * call() + { + return NULL; + } + }; +} + +template<class T> +inline const char * guid(){ + return ext::guid_impl<T>::call(); +} + +} // namespace serialization +} // namespace boost + +#ifdef BOOST_MSVC +#pragma warning(pop) +#endif + +#include <boost/config/abi_suffix.hpp> // pops abi_suffix.hpp pragmas + +#endif // BOOST_SERIALIZATION_EXTENDED_TYPE_INFO_HPP diff --git a/src/third_party/boost-1.69.0/boost/serialization/extended_type_info_no_rtti.hpp b/src/third_party/boost-1.69.0/boost/serialization/extended_type_info_no_rtti.hpp new file mode 100644 index 00000000000..aaa8b44459b --- /dev/null +++ b/src/third_party/boost-1.69.0/boost/serialization/extended_type_info_no_rtti.hpp @@ -0,0 +1,182 @@ +#ifndef BOOST_EXTENDED_TYPE_INFO_NO_RTTI_HPP +#define BOOST_EXTENDED_TYPE_INFO_NO_RTTI_HPP + +/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8 +// MS compatible compilers support #pragma once +#if defined(_MSC_VER) +# pragma once +#endif + +// extended_type_info_no_rtti.hpp: implementation for version that depends +// on runtime typing (rtti - typeid) but uses a user specified string +// as the portable class identifier. + +// (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/assert.hpp> + +#include <boost/config.hpp> +#include <boost/static_assert.hpp> + +#include <boost/mpl/if.hpp> +#include <boost/type_traits/is_polymorphic.hpp> +#include <boost/type_traits/remove_const.hpp> + +#include <boost/serialization/static_warning.hpp> +#include <boost/serialization/singleton.hpp> +#include <boost/serialization/extended_type_info.hpp> +#include <boost/serialization/factory.hpp> +#include <boost/serialization/throw_exception.hpp> + +#include <boost/serialization/config.hpp> +// hijack serialization access +#include <boost/serialization/access.hpp> + +#include <boost/config/abi_prefix.hpp> // must be the last header +#ifdef BOOST_MSVC +# pragma warning(push) +# pragma warning(disable : 4251 4231 4660 4275 4511 4512) +#endif + +namespace boost { +namespace serialization { +/////////////////////////////////////////////////////////////////////// +// define a special type_info that doesn't depend on rtti which is not +// available in all situations. + +namespace no_rtti_system { + +// common base class to share type_info_key. This is used to +// identify the method used to keep track of the extended type +class BOOST_SYMBOL_VISIBLE extended_type_info_no_rtti_0 : + public extended_type_info +{ +protected: + BOOST_SERIALIZATION_DECL extended_type_info_no_rtti_0(const char * key); + BOOST_SERIALIZATION_DECL ~extended_type_info_no_rtti_0(); +public: + virtual BOOST_SERIALIZATION_DECL bool + is_less_than(const boost::serialization::extended_type_info &rhs) const ; + virtual BOOST_SERIALIZATION_DECL bool + is_equal(const boost::serialization::extended_type_info &rhs) const ; +}; + +} // no_rtti_system + +template<class T> +class extended_type_info_no_rtti : + public no_rtti_system::extended_type_info_no_rtti_0, + public singleton<extended_type_info_no_rtti< T > > +{ + template<bool tf> + struct action { + struct defined { + static const char * invoke(){ + return guid< T >(); + } + }; + struct undefined { + // if your program traps here - you failed to + // export a guid for this type. the no_rtti + // system requires export for types serialized + // as pointers. + BOOST_STATIC_ASSERT(0 == sizeof(T)); + static const char * invoke(); + }; + static const char * invoke(){ + typedef + typename boost::mpl::if_c< + tf, + defined, + undefined + >::type type; + return type::invoke(); + } + }; +public: + extended_type_info_no_rtti() : + no_rtti_system::extended_type_info_no_rtti_0(get_key()) + { + key_register(); + } + ~extended_type_info_no_rtti(){ + key_unregister(); + } + const extended_type_info * + get_derived_extended_type_info(const T & t) const { + // find the type that corresponds to the most derived type. + // this implementation doesn't depend on typeid() but assumes + // that the specified type has a function of the following signature. + // A common implemention of such a function is to define as a virtual + // function. So if the is not a polymporphic type it's likely an error + BOOST_STATIC_WARNING(boost::is_polymorphic< T >::value); + const char * derived_key = t.get_key(); + BOOST_ASSERT(NULL != derived_key); + return boost::serialization::extended_type_info::find(derived_key); + } + const char * get_key() const{ + return action<guid_defined< T >::value >::invoke(); + } + virtual const char * get_debug_info() const{ + return action<guid_defined< T >::value >::invoke(); + } + virtual void * construct(unsigned int count, ...) const{ + // count up the arguments + std::va_list ap; + va_start(ap, count); + switch(count){ + case 0: + return factory<typename boost::remove_const< T >::type, 0>(ap); + case 1: + return factory<typename boost::remove_const< T >::type, 1>(ap); + case 2: + return factory<typename boost::remove_const< T >::type, 2>(ap); + case 3: + return factory<typename boost::remove_const< T >::type, 3>(ap); + case 4: + return factory<typename boost::remove_const< T >::type, 4>(ap); + default: + BOOST_ASSERT(false); // too many arguments + // throw exception here? + return NULL; + } + } + virtual void destroy(void const * const p) const{ + boost::serialization::access::destroy( + static_cast<T const *>(p) + ); + //delete static_cast<T const * const>(p) ; + } +}; + +} // namespace serialization +} // namespace boost + +/////////////////////////////////////////////////////////////////////////////// +// If no other implementation has been designated as default, +// use this one. To use this implementation as the default, specify it +// before any of the other headers. + +#ifndef BOOST_SERIALIZATION_DEFAULT_TYPE_INFO + #define BOOST_SERIALIZATION_DEFAULT_TYPE_INFO + namespace boost { + namespace serialization { + template<class T> + struct extended_type_info_impl { + typedef typename + boost::serialization::extended_type_info_no_rtti< T > type; + }; + } // namespace serialization + } // namespace boost +#endif + +#ifdef BOOST_MSVC +# pragma warning(pop) +#endif +#include <boost/config/abi_suffix.hpp> // pops abi_suffix.hpp pragmas + +#endif // BOOST_EXTENDED_TYPE_INFO_NO_RTTI_HPP diff --git a/src/third_party/boost-1.69.0/boost/serialization/extended_type_info_typeid.hpp b/src/third_party/boost-1.69.0/boost/serialization/extended_type_info_typeid.hpp new file mode 100644 index 00000000000..8ee591b3169 --- /dev/null +++ b/src/third_party/boost-1.69.0/boost/serialization/extended_type_info_typeid.hpp @@ -0,0 +1,167 @@ +#ifndef BOOST_SERIALIZATION_EXTENDED_TYPE_INFO_TYPEID_HPP +#define BOOST_SERIALIZATION_EXTENDED_TYPE_INFO_TYPEID_HPP + +/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8 +// MS compatible compilers support #pragma once +#if defined(_MSC_VER) +# pragma once +#endif + +// extended_type_info_typeid.hpp: implementation for version that depends +// on runtime typing (rtti - typeid) but uses a user specified string +// as the portable class identifier. + +// (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 <typeinfo> +#include <cstdarg> +#include <boost/assert.hpp> +#include <boost/config.hpp> + +#include <boost/static_assert.hpp> +#include <boost/serialization/static_warning.hpp> +#include <boost/type_traits/is_polymorphic.hpp> +#include <boost/type_traits/remove_const.hpp> + +#include <boost/serialization/config.hpp> +#include <boost/serialization/singleton.hpp> +#include <boost/serialization/extended_type_info.hpp> +#include <boost/serialization/factory.hpp> + +// hijack serialization access +#include <boost/serialization/access.hpp> + +#include <boost/mpl/if.hpp> + +#include <boost/config/abi_prefix.hpp> // must be the last header + +#ifdef BOOST_MSVC +# pragma warning(push) +# pragma warning(disable : 4251 4231 4660 4275 4511 4512) +#endif + +namespace boost { +namespace serialization { +namespace typeid_system { + +class BOOST_SYMBOL_VISIBLE extended_type_info_typeid_0 : + public extended_type_info +{ + virtual const char * get_debug_info() const { + if(static_cast<const std::type_info *>(0) == m_ti) + return static_cast<const char *>(0); + return m_ti->name(); + } +protected: + const std::type_info * m_ti; + BOOST_SERIALIZATION_DECL extended_type_info_typeid_0(const char * key); + BOOST_SERIALIZATION_DECL ~extended_type_info_typeid_0(); + BOOST_SERIALIZATION_DECL void type_register(const std::type_info & ti); + BOOST_SERIALIZATION_DECL void type_unregister(); + BOOST_SERIALIZATION_DECL const extended_type_info * + get_extended_type_info(const std::type_info & ti) const; +public: + virtual BOOST_SERIALIZATION_DECL bool + is_less_than(const extended_type_info &rhs) const; + virtual BOOST_SERIALIZATION_DECL bool + is_equal(const extended_type_info &rhs) const; + const std::type_info & get_typeid() const { + return *m_ti; + } +}; + +} // typeid_system + +template<class T> +class extended_type_info_typeid : + public typeid_system::extended_type_info_typeid_0, + public singleton<extended_type_info_typeid< T > > +{ +public: + extended_type_info_typeid() : + typeid_system::extended_type_info_typeid_0( + boost::serialization::guid< T >() + ) + { + type_register(typeid(T)); + key_register(); + } + ~extended_type_info_typeid(){ + key_unregister(); + type_unregister(); + } + // get the eti record for the true type of this record + // relying upon standard type info implemenation (rtti) + const extended_type_info * + get_derived_extended_type_info(const T & t) const { + // note: this implementation - based on usage of typeid (rtti) + // only does something if the class has at least one virtual function. + BOOST_STATIC_WARNING(boost::is_polymorphic< T >::value); + return + typeid_system::extended_type_info_typeid_0::get_extended_type_info( + typeid(t) + ); + } + const char * get_key() const { + return boost::serialization::guid< T >(); + } + virtual void * construct(unsigned int count, ...) const{ + // count up the arguments + std::va_list ap; + va_start(ap, count); + switch(count){ + case 0: + return factory<typename boost::remove_const< T >::type, 0>(ap); + case 1: + return factory<typename boost::remove_const< T >::type, 1>(ap); + case 2: + return factory<typename boost::remove_const< T >::type, 2>(ap); + case 3: + return factory<typename boost::remove_const< T >::type, 3>(ap); + case 4: + return factory<typename boost::remove_const< T >::type, 4>(ap); + default: + BOOST_ASSERT(false); // too many arguments + // throw exception here? + return NULL; + } + } + virtual void destroy(void const * const p) const { + boost::serialization::access::destroy( + static_cast<T const *>(p) + ); + //delete static_cast<T const * const>(p); + } +}; + +} // namespace serialization +} // namespace boost + +/////////////////////////////////////////////////////////////////////////////// +// If no other implementation has been designated as default, +// use this one. To use this implementation as the default, specify it +// before any of the other headers. +#ifndef BOOST_SERIALIZATION_DEFAULT_TYPE_INFO + #define BOOST_SERIALIZATION_DEFAULT_TYPE_INFO + namespace boost { + namespace serialization { + template<class T> + struct extended_type_info_impl { + typedef typename + boost::serialization::extended_type_info_typeid< T > type; + }; + } // namespace serialization + } // namespace boost +#endif + +#ifdef BOOST_MSVC +#pragma warning(pop) +#endif +#include <boost/config/abi_suffix.hpp> // pops abi_suffix.hpp pragmas + +#endif // BOOST_SERIALIZATION_EXTENDED_TYPE_INFO_TYPEID_HPP diff --git a/src/third_party/boost-1.69.0/boost/serialization/factory.hpp b/src/third_party/boost-1.69.0/boost/serialization/factory.hpp new file mode 100644 index 00000000000..2db7e7e36c3 --- /dev/null +++ b/src/third_party/boost-1.69.0/boost/serialization/factory.hpp @@ -0,0 +1,102 @@ +#ifndef BOOST_SERIALIZATION_FACTORY_HPP +#define BOOST_SERIALIZATION_FACTORY_HPP + +/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8 +// MS compatible compilers support #pragma once +#if defined(_MSC_VER) +# pragma once +#endif + +// factory.hpp: create an instance from an extended_type_info instance. + +// (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 <cstdarg> // valist +#include <cstddef> // NULL + +#include <boost/preprocessor/control/if.hpp> +#include <boost/preprocessor/comparison/greater.hpp> +#include <boost/assert.hpp> + +namespace std{ + #if defined(__LIBCOMO__) + using ::va_list; + #endif +} // namespace std + +namespace boost { +namespace serialization { + +// default implementation does nothing. +template<class T, int N> +T * factory(std::va_list){ + BOOST_ASSERT(false); + // throw exception here? + return NULL; +} + +} // namespace serialization +} // namespace boost + +#define BOOST_SERIALIZATION_FACTORY(N, T, A0, A1, A2, A3) \ +namespace boost { \ +namespace serialization { \ + template<> \ + T * factory<T, N>(std::va_list ap){ \ + BOOST_PP_IF(BOOST_PP_GREATER(N, 0) \ + , A0 a0 = va_arg(ap, A0);, BOOST_PP_EMPTY()) \ + BOOST_PP_IF(BOOST_PP_GREATER(N, 1) \ + , A1 a1 = va_arg(ap, A1);, BOOST_PP_EMPTY()) \ + BOOST_PP_IF(BOOST_PP_GREATER(N, 2) \ + , A2 a2 = va_arg(ap, A2);, BOOST_PP_EMPTY()) \ + BOOST_PP_IF(BOOST_PP_GREATER(N, 3) \ + , A3 a3 = va_arg(ap, A3);, BOOST_PP_EMPTY()) \ + return new T( \ + BOOST_PP_IF(BOOST_PP_GREATER(N, 0) \ + , a0, BOOST_PP_EMPTY()) \ + BOOST_PP_IF(BOOST_PP_GREATER(N, 1)) \ + , BOOST_PP_COMMA, BOOST_PP_EMPTY)() \ + BOOST_PP_IF(BOOST_PP_GREATER(N, 1) \ + , a1, BOOST_PP_EMPTY()) \ + BOOST_PP_IF(BOOST_PP_GREATER(N, 2)) \ + , BOOST_PP_COMMA, BOOST_PP_EMPTY)() \ + BOOST_PP_IF(BOOST_PP_GREATER(N, 2) \ + , a2, BOOST_PP_EMPTY()) \ + BOOST_PP_IF(BOOST_PP_GREATER(N, 3)) \ + , BOOST_PP_COMMA, BOOST_PP_EMPTY)() \ + BOOST_PP_IF(BOOST_PP_GREATER(N, 3) \ + , a3, BOOST_PP_EMPTY()) \ + ); \ + } \ +} \ +} /**/ + +#define BOOST_SERIALIZATION_FACTORY_4(T, A0, A1, A2, A3) \ + BOOST_SERIALIZATION_FACTORY(4, T, A0, A1, A2, A3) + +#define BOOST_SERIALIZATION_FACTORY_3(T, A0, A1, A2) \ + BOOST_SERIALIZATION_FACTORY(3, T, A0, A1, A2, 0) + +#define BOOST_SERIALIZATION_FACTORY_2(T, A0, A1) \ + BOOST_SERIALIZATION_FACTORY(2, T, A0, A1, 0, 0) + +#define BOOST_SERIALIZATION_FACTORY_1(T, A0) \ + BOOST_SERIALIZATION_FACTORY(1, T, A0, 0, 0, 0) + +#define BOOST_SERIALIZATION_FACTORY_0(T) \ +namespace boost { \ +namespace serialization { \ + template<> \ + T * factory<T, 0>(std::va_list){ \ + return new T(); \ + } \ +} \ +} \ +/**/ + +#endif // BOOST_SERIALIZATION_FACTORY_HPP diff --git a/src/third_party/boost-1.69.0/boost/serialization/force_include.hpp b/src/third_party/boost-1.69.0/boost/serialization/force_include.hpp new file mode 100644 index 00000000000..55ab79d0d58 --- /dev/null +++ b/src/third_party/boost-1.69.0/boost/serialization/force_include.hpp @@ -0,0 +1,55 @@ +#ifndef BOOST_SERIALIZATION_FORCE_INCLUDE_HPP +#define BOOST_SERIALIZATION_FORCE_INCLUDE_HPP + +// MS compatible compilers support #pragma once +#if defined(_MSC_VER) +# pragma once +#endif + +/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8 +// force_include.hpp: + +// (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> + +// the following help macro is to guarentee that certain coded +// is not removed by over-eager linker optimiser. In certain cases +// we create static objects must be created but are actually never +// referenced - creation has a side-effect such as global registration +// which is important to us. We make an effort to refer these objects +// so that a smart linker won't remove them as being unreferenced. +// In microsoft compilers, inlining the code that does the referring +// means the code gets lost and the static object is not included +// in the library and hence never registered. This manifests itself +// in an ungraceful crash at runtime when (and only when) built in +// release mode. + +#if defined(BOOST_HAS_DECLSPEC) && !defined(__COMO__) +# define BOOST_DLLEXPORT __declspec(dllexport) +#elif ! defined(_WIN32) && ! defined(_WIN64) +# if defined(__MWERKS__) +# define BOOST_DLLEXPORT __declspec(dllexport) +# elif defined(__GNUC__) && (__GNUC__ >= 3) +# define BOOST_USED __attribute__ ((__used__)) +# elif defined(__IBMCPP__) && (__IBMCPP__ >= 1110) +# define BOOST_USED __attribute__ ((__used__)) +# elif defined(__INTEL_COMPILER) && (BOOST_INTEL_CXX_VERSION >= 800) +# define BOOST_USED __attribute__ ((__used__)) +# endif +#endif + +#ifndef BOOST_USED +# define BOOST_USED +#endif + +#ifndef BOOST_DLLEXPORT +# define BOOST_DLLEXPORT +#endif + +#endif // BOOST_SERIALIZATION_FORCE_INCLUDE_HPP diff --git a/src/third_party/boost-1.69.0/boost/serialization/is_bitwise_serializable.hpp b/src/third_party/boost-1.69.0/boost/serialization/is_bitwise_serializable.hpp new file mode 100644 index 00000000000..7e24a2cb6d8 --- /dev/null +++ b/src/third_party/boost-1.69.0/boost/serialization/is_bitwise_serializable.hpp @@ -0,0 +1,46 @@ +// (C) Copyright 2007 Matthias Troyer + +// 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) + +// Authors: Matthias Troyer + +/** @file is_bitwise_serializable.hpp + * + * This header provides a traits class for determining whether a class + * can be serialized (in a non-portable way) just by copying the bits. + */ + + +#ifndef BOOST_SERIALIZATION_IS_BITWISE_SERIALIZABLE_HPP +#define BOOST_SERIALIZATION_IS_BITWISE_SERIALIZABLE_HPP + +// MS compatible compilers support #pragma once +#if defined(_MSC_VER) +# pragma once +#endif + +#include <boost/mpl/bool_fwd.hpp> +#include <boost/type_traits/is_arithmetic.hpp> + +namespace boost { +namespace serialization { + template<class T> + struct is_bitwise_serializable + : public is_arithmetic< T > + {}; +} // namespace serialization +} // namespace boost + + +// define a macro to make explicit designation of this more transparent +#define BOOST_IS_BITWISE_SERIALIZABLE(T) \ +namespace boost { \ +namespace serialization { \ +template<> \ +struct is_bitwise_serializable< T > : mpl::true_ {}; \ +}} \ +/**/ + +#endif //BOOST_SERIALIZATION_IS_BITWISE_SERIALIZABLE_HPP diff --git a/src/third_party/boost-1.69.0/boost/serialization/item_version_type.hpp b/src/third_party/boost-1.69.0/boost/serialization/item_version_type.hpp new file mode 100644 index 00000000000..f3e5adac6f8 --- /dev/null +++ b/src/third_party/boost-1.69.0/boost/serialization/item_version_type.hpp @@ -0,0 +1,68 @@ +#ifndef BOOST_SERIALIZATION_ITEM_VERSION_TYPE_HPP +#define BOOST_SERIALIZATION_ITEM_VERSION_TYPE_HPP + +// (C) Copyright 2010 Robert Ramey +// 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) + +#include <boost/cstdint.hpp> // uint_least8_t +#include <boost/integer_traits.hpp> +#include <boost/serialization/level.hpp> +#include <boost/serialization/is_bitwise_serializable.hpp> + +// fixes broken example build on x86_64-linux-gnu-gcc-4.6.0 +#include <boost/assert.hpp> + +namespace boost { +namespace serialization { + +#if defined(_MSC_VER) +#pragma warning( push ) +#pragma warning( disable : 4244 4267 ) +#endif + +class item_version_type { +private: + typedef unsigned int base_type; + base_type t; +public: + // should be private - but MPI fails if it's not!!! + item_version_type(): t(0) {}; + explicit item_version_type(const unsigned int t_) : t(t_){ + BOOST_ASSERT(t_ <= boost::integer_traits<base_type>::const_max); + } + item_version_type(const item_version_type & t_) : + t(t_.t) + {} + item_version_type & operator=(item_version_type rhs){ + t = rhs.t; + return *this; + } + // used for text output + operator base_type () const { + return t; + } + // used for text input + operator base_type & () { + return t; + } + bool operator==(const item_version_type & rhs) const { + return t == rhs.t; + } + bool operator<(const item_version_type & rhs) const { + return t < rhs.t; + } +}; + +#if defined(_MSC_VER) +#pragma warning( pop ) +#endif + +} } // end namespace boost::serialization + +BOOST_IS_BITWISE_SERIALIZABLE(item_version_type) + +BOOST_CLASS_IMPLEMENTATION(item_version_type, primitive_type) + +#endif //BOOST_SERIALIZATION_ITEM_VERSION_TYPE_HPP diff --git a/src/third_party/boost-1.69.0/boost/serialization/level.hpp b/src/third_party/boost-1.69.0/boost/serialization/level.hpp new file mode 100644 index 00000000000..f6a84d10422 --- /dev/null +++ b/src/third_party/boost-1.69.0/boost/serialization/level.hpp @@ -0,0 +1,116 @@ +#ifndef BOOST_SERIALIZATION_LEVEL_HPP +#define BOOST_SERIALIZATION_LEVEL_HPP + +// MS compatible compilers support #pragma once +#if defined(_MSC_VER) +# pragma once +#endif + +/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8 +// level.hpp: + +// (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> +#include <boost/detail/workaround.hpp> + +#include <boost/type_traits/is_fundamental.hpp> +#include <boost/type_traits/is_enum.hpp> +#include <boost/type_traits/is_array.hpp> +#include <boost/type_traits/is_class.hpp> +#include <boost/type_traits/is_base_and_derived.hpp> + +#include <boost/mpl/eval_if.hpp> +#include <boost/mpl/int.hpp> +#include <boost/mpl/integral_c.hpp> +#include <boost/mpl/integral_c_tag.hpp> + +#include <boost/serialization/level_enum.hpp> + +namespace boost { +namespace serialization { + +struct basic_traits; + +// default serialization implementation level +template<class T> +struct implementation_level_impl { + template<class U> + struct traits_class_level { + typedef typename U::level type; + }; + + typedef mpl::integral_c_tag tag; + // note: at least one compiler complained w/o the full qualification + // on basic traits below + typedef + typename mpl::eval_if< + is_base_and_derived<boost::serialization::basic_traits, T>, + traits_class_level< T >, + //else + typename mpl::eval_if< + is_fundamental< T >, + mpl::int_<primitive_type>, + //else + typename mpl::eval_if< + is_class< T >, + mpl::int_<object_class_info>, + //else + typename mpl::eval_if< + is_array< T >, + mpl::int_<object_serializable>, + //else + typename mpl::eval_if< + is_enum< T >, + mpl::int_<primitive_type>, + //else + mpl::int_<not_serializable> + > + > + > + > + >::type type; + // vc 7.1 doesn't like enums here + BOOST_STATIC_CONSTANT(int, value = type::value); +}; + +template<class T> +struct implementation_level : + public implementation_level_impl<const T> +{ +}; + +template<class T, int L> +inline bool operator>=(implementation_level< T > t, enum level_type l) +{ + return t.value >= (int)l; +} + +} // namespace serialization +} // namespace boost + +// specify the level of serialization implementation for the class +// require that class info saved when versioning is used +#define BOOST_CLASS_IMPLEMENTATION(T, E) \ + namespace boost { \ + namespace serialization { \ + template <> \ + struct implementation_level_impl< const T > \ + { \ + typedef mpl::integral_c_tag tag; \ + typedef mpl::int_< E > type; \ + BOOST_STATIC_CONSTANT( \ + int, \ + value = implementation_level_impl::type::value \ + ); \ + }; \ + } \ + } + /**/ + +#endif // BOOST_SERIALIZATION_LEVEL_HPP diff --git a/src/third_party/boost-1.69.0/boost/serialization/level_enum.hpp b/src/third_party/boost-1.69.0/boost/serialization/level_enum.hpp new file mode 100644 index 00000000000..baf64e04f31 --- /dev/null +++ b/src/third_party/boost-1.69.0/boost/serialization/level_enum.hpp @@ -0,0 +1,55 @@ +#ifndef BOOST_SERIALIZATION_LEVEL_ENUM_HPP +#define BOOST_SERIALIZATION_LEVEL_ENUM_HPP + +// MS compatible compilers support #pragma once +#if defined(_MSC_VER) +# pragma once +#endif + +/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8 +// level_enum.hpp: + +// (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. + +namespace boost { +namespace serialization { + +// for each class used in the program, specify which level +// of serialization should be implemented + +// names for each level +enum level_type +{ + // Don't serialize this type. An attempt to do so should + // invoke a compile time assertion. + not_serializable = 0, + // write/read this type directly to the archive. In this case + // serialization code won't be called. This is the default + // case for fundamental types. It presumes a member function or + // template in the archive class that can handle this type. + // there is no runtime overhead associated reading/writing + // instances of this level + primitive_type = 1, + // Serialize the objects of this type using the objects "serialize" + // function or template. This permits values to be written/read + // to/from archives but includes no class or version information. + object_serializable = 2, + /////////////////////////////////////////////////////////////////// + // once an object is serialized at one of the above levels, the + // corresponding archives cannot be read if the implementation level + // for the archive object is changed. + /////////////////////////////////////////////////////////////////// + // Add class information to the archive. Class information includes + // implementation level, class version and class name if available + object_class_info = 3 +}; + +} // namespace serialization +} // namespace boost + +#endif // BOOST_SERIALIZATION_LEVEL_ENUM_HPP diff --git a/src/third_party/boost-1.69.0/boost/serialization/list.hpp b/src/third_party/boost-1.69.0/boost/serialization/list.hpp new file mode 100644 index 00000000000..5fdc114d7ed --- /dev/null +++ b/src/third_party/boost-1.69.0/boost/serialization/list.hpp @@ -0,0 +1,85 @@ +#ifndef BOOST_SERIALIZATION_LIST_HPP +#define BOOST_SERIALIZATION_LIST_HPP + +// MS compatible compilers support #pragma once +#if defined(_MSC_VER) +# pragma once +#endif + +/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8 +// list.hpp: serialization for stl list templates + +// (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 <list> + +#include <boost/config.hpp> + +#include <boost/serialization/collections_save_imp.hpp> +#include <boost/serialization/collections_load_imp.hpp> + +#include <boost/archive/detail/basic_iarchive.hpp> +#include <boost/serialization/access.hpp> +#include <boost/serialization/nvp.hpp> +#include <boost/serialization/collection_size_type.hpp> +#include <boost/serialization/item_version_type.hpp> +#include <boost/serialization/split_free.hpp> + +namespace boost { +namespace serialization { + +template<class Archive, class U, class Allocator> +inline void save( + Archive & ar, + const std::list<U, Allocator> &t, + const unsigned int /* file_version */ +){ + boost::serialization::stl::save_collection< + Archive, + std::list<U, Allocator> + >(ar, t); +} + +template<class Archive, class U, class Allocator> +inline void load( + Archive & ar, + std::list<U, Allocator> &t, + const unsigned int /* file_version */ +){ + const boost::archive::library_version_type library_version( + ar.get_library_version() + ); + // retrieve number of elements + item_version_type item_version(0); + collection_size_type count; + ar >> BOOST_SERIALIZATION_NVP(count); + if(boost::archive::library_version_type(3) < library_version){ + ar >> BOOST_SERIALIZATION_NVP(item_version); + } + stl::collection_load_impl(ar, t, count, item_version); +} + +// split non-intrusive serialization function member into separate +// non intrusive save/load member functions +template<class Archive, class U, class Allocator> +inline void serialize( + Archive & ar, + std::list<U, Allocator> & t, + const unsigned int file_version +){ + boost::serialization::split_free(ar, t, file_version); +} + +} // serialization +} // namespace boost + +#include <boost/serialization/collection_traits.hpp> + +BOOST_SERIALIZATION_COLLECTION_TRAITS(std::list) + +#endif // BOOST_SERIALIZATION_LIST_HPP diff --git a/src/third_party/boost-1.69.0/boost/serialization/nvp.hpp b/src/third_party/boost-1.69.0/boost/serialization/nvp.hpp new file mode 100644 index 00000000000..066fe94d879 --- /dev/null +++ b/src/third_party/boost-1.69.0/boost/serialization/nvp.hpp @@ -0,0 +1,125 @@ +#ifndef BOOST_SERIALIZATION_NVP_HPP +#define BOOST_SERIALIZATION_NVP_HPP + +// MS compatible compilers support #pragma once +#if defined(_MSC_VER) +# pragma once +#endif + +/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8 +// nvp.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 <utility> + +#include <boost/config.hpp> +#include <boost/detail/workaround.hpp> + +#include <boost/serialization/level.hpp> +#include <boost/serialization/tracking.hpp> +#include <boost/serialization/split_member.hpp> +#include <boost/serialization/base_object.hpp> +#include <boost/serialization/traits.hpp> +#include <boost/serialization/wrapper.hpp> + +#include <boost/core/addressof.hpp> + +namespace boost { +namespace serialization { + +template<class T> +struct nvp : + public std::pair<const char *, T *>, + public wrapper_traits<const nvp< T > > +{ +//private: + nvp(const nvp & rhs) : + std::pair<const char *, T *>(rhs.first, rhs.second) + {} +public: + explicit nvp(const char * name_, T & t) : + // note: added _ to suppress useless gcc warning + std::pair<const char *, T *>(name_, boost::addressof(t)) + {} + + const char * name() const { + return this->first; + } + T & value() const { + return *(this->second); + } + + const T & const_value() const { + return *(this->second); + } + + template<class Archive> + void save( + Archive & ar, + const unsigned int /* file_version */ + ) const { + ar.operator<<(const_value()); + } + template<class Archive> + void load( + Archive & ar, + const unsigned int /* file_version */ + ){ + ar.operator>>(value()); + } + BOOST_SERIALIZATION_SPLIT_MEMBER() +}; + +template<class T> +inline +const nvp< T > make_nvp(const char * name, T & t){ + return nvp< T >(name, t); +} + +// to maintain efficiency and portability, we want to assign +// specific serialization traits to all instances of this wrappers. +// we can't strait forward method below as it depends upon +// Partial Template Specialization and doing so would mean that wrappers +// wouldn't be treated the same on different platforms. This would +// break archive portability. Leave this here as reminder not to use it !!! + +template <class T> +struct implementation_level<nvp< T > > +{ + typedef mpl::integral_c_tag tag; + typedef mpl::int_<object_serializable> type; + BOOST_STATIC_CONSTANT(int, value = implementation_level::type::value); +}; + +// nvp objects are generally created on the stack and are never tracked +template<class T> +struct tracking_level<nvp< T > > +{ + typedef mpl::integral_c_tag tag; + typedef mpl::int_<track_never> type; + BOOST_STATIC_CONSTANT(int, value = tracking_level::type::value); +}; + +} // seralization +} // boost + +#include <boost/preprocessor/stringize.hpp> + +#define BOOST_SERIALIZATION_NVP(name) \ + boost::serialization::make_nvp(BOOST_PP_STRINGIZE(name), name) +/**/ + +#define BOOST_SERIALIZATION_BASE_OBJECT_NVP(name) \ + boost::serialization::make_nvp( \ + BOOST_PP_STRINGIZE(name), \ + boost::serialization::base_object<name >(*this) \ + ) +/**/ + +#endif // BOOST_SERIALIZATION_NVP_HPP diff --git a/src/third_party/boost-1.69.0/boost/serialization/serialization.hpp b/src/third_party/boost-1.69.0/boost/serialization/serialization.hpp new file mode 100644 index 00000000000..a4d04723c75 --- /dev/null +++ b/src/third_party/boost-1.69.0/boost/serialization/serialization.hpp @@ -0,0 +1,154 @@ +#ifndef BOOST_SERIALIZATION_SERIALIZATION_HPP +#define BOOST_SERIALIZATION_SERIALIZATION_HPP + +// MS compatible compilers support #pragma once +#if defined(_MSC_VER) +# pragma once +#endif + +#if defined(_MSC_VER) +# pragma warning (disable : 4675) // suppress ADL warning +#endif + +#include <boost/config.hpp> +#include <boost/serialization/strong_typedef.hpp> + +/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8 +// serialization.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. + +////////////////////////////////////////////////////////////////////// +// public interface to serialization. + +///////////////////////////////////////////////////////////////////////////// +// layer 0 - intrusive verison +// declared and implemented for each user defined class to be serialized +// +// template<Archive> +// serialize(Archive &ar, const unsigned int file_version){ +// ar & base_object<base>(*this) & member1 & member2 ... ; +// } + +///////////////////////////////////////////////////////////////////////////// +// layer 1 - layer that routes member access through the access class. +// this is what permits us to grant access to private class member functions +// by specifying friend class boost::serialization::access + +#include <boost/serialization/access.hpp> + +///////////////////////////////////////////////////////////////////////////// +// layer 2 - default implementation of non-intrusive serialization. +// +// note the usage of function overloading to compensate that C++ does not +// currently support Partial Template Specialization for function templates +// We have declared the version number as "const unsigned long". +// Overriding templates for specific data types should declare the version +// number as "const unsigned int". Template matching will first be applied +// to functions with the same version types - that is the overloads. +// If there is no declared function prototype that matches, the second argument +// will be converted to "const unsigned long" and a match will be made with +// one of the default template functions below. + +namespace boost { +namespace serialization { + +BOOST_STRONG_TYPEDEF(unsigned int, version_type) + +// default implementation - call the member function "serialize" +template<class Archive, class T> +inline void serialize( + Archive & ar, T & t, const unsigned int file_version +){ + access::serialize(ar, t, static_cast<unsigned int>(file_version)); +} + +// save data required for construction +template<class Archive, class T> +inline void save_construct_data( + Archive & /*ar*/, + const T * /*t*/, + const unsigned int /*file_version */ +){ + // default is to save no data because default constructor + // requires no arguments. +} + +// load data required for construction and invoke constructor in place +template<class Archive, class T> +inline void load_construct_data( + Archive & /*ar*/, + T * t, + const unsigned int /*file_version*/ +){ + // default just uses the default constructor. going + // through access permits usage of otherwise private default + // constructor + access::construct(t); +} + +///////////////////////////////////////////////////////////////////////////// +// layer 3 - move call into serialization namespace so that ADL will function +// in the manner we desire. +// +// on compilers which don't implement ADL. only the current namespace +// i.e. boost::serialization will be searched. +// +// on compilers which DO implement ADL +// serialize overrides can be in any of the following +// +// 1) same namepace as Archive +// 2) same namespace as T +// 3) boost::serialization +// +// Due to Martin Ecker + +template<class Archive, class T> +inline void serialize_adl( + Archive & ar, + T & t, + const unsigned int file_version +){ + // note usage of function overloading to delay final resolution + // until the point of instantiation. This works around the two-phase + // lookup "feature" which inhibits redefintion of a default function + // template implementation. Due to Robert Ramey + // + // Note that this trick generates problems for compiles which don't support + // PFTO, suppress it here. As far as we know, there are no compilers + // which fail to support PFTO while supporting two-phase lookup. + const version_type v(file_version); + serialize(ar, t, v); +} + +template<class Archive, class T> +inline void save_construct_data_adl( + Archive & ar, + const T * t, + const unsigned int file_version +){ + // see above + const version_type v(file_version); + save_construct_data(ar, t, v); +} + +template<class Archive, class T> +inline void load_construct_data_adl( + Archive & ar, + T * t, + const unsigned int file_version +){ + // see above comment + const version_type v(file_version); + load_construct_data(ar, t, v); +} + +} // namespace serialization +} // namespace boost + +#endif //BOOST_SERIALIZATION_SERIALIZATION_HPP diff --git a/src/third_party/boost-1.69.0/boost/serialization/set.hpp b/src/third_party/boost-1.69.0/boost/serialization/set.hpp new file mode 100644 index 00000000000..dd201267fad --- /dev/null +++ b/src/third_party/boost-1.69.0/boost/serialization/set.hpp @@ -0,0 +1,138 @@ +#ifndef BOOST_SERIALIZATION_SET_HPP +#define BOOST_SERIALIZATION_SET_HPP + +// MS compatible compilers support #pragma once +#if defined(_MSC_VER) +# pragma once +#endif + +/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8 +// set.hpp: serialization for stl set templates + +// (C) Copyright 2002-2014 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 <set> + +#include <boost/config.hpp> + +#include <boost/archive/detail/basic_iarchive.hpp> +#include <boost/serialization/access.hpp> +#include <boost/serialization/nvp.hpp> +#include <boost/serialization/detail/stack_constructor.hpp> +#include <boost/serialization/collection_size_type.hpp> +#include <boost/serialization/item_version_type.hpp> + +#include <boost/serialization/collections_save_imp.hpp> +#include <boost/serialization/split_free.hpp> +#include <boost/move/utility_core.hpp> + +namespace boost { +namespace serialization { + +template<class Archive, class Container> +inline void load_set_collection(Archive & ar, Container &s) +{ + s.clear(); + const boost::archive::library_version_type library_version( + ar.get_library_version() + ); + // retrieve number of elements + item_version_type item_version(0); + collection_size_type count; + ar >> BOOST_SERIALIZATION_NVP(count); + if(boost::archive::library_version_type(3) < library_version){ + ar >> BOOST_SERIALIZATION_NVP(item_version); + } + typename Container::iterator hint; + hint = s.begin(); + while(count-- > 0){ + typedef typename Container::value_type type; + detail::stack_construct<Archive, type> t(ar, item_version); + // borland fails silently w/o full namespace + ar >> boost::serialization::make_nvp("item", t.reference()); + typename Container::iterator result = + s.insert(hint, boost::move(t.reference())); + const type * new_address = & (* result); + ar.reset_object_address(new_address, & t.reference()); + hint = result; + } +} + +template<class Archive, class Key, class Compare, class Allocator > +inline void save( + Archive & ar, + const std::set<Key, Compare, Allocator> &t, + const unsigned int /* file_version */ +){ + boost::serialization::stl::save_collection< + Archive, std::set<Key, Compare, Allocator> + >(ar, t); +} + +template<class Archive, class Key, class Compare, class Allocator > +inline void load( + Archive & ar, + std::set<Key, Compare, Allocator> &t, + const unsigned int /* file_version */ +){ + load_set_collection(ar, t); +} + +// split non-intrusive serialization function member into separate +// non intrusive save/load member functions +template<class Archive, class Key, class Compare, class Allocator > +inline void serialize( + Archive & ar, + std::set<Key, Compare, Allocator> & t, + const unsigned int file_version +){ + boost::serialization::split_free(ar, t, file_version); +} + +// multiset +template<class Archive, class Key, class Compare, class Allocator > +inline void save( + Archive & ar, + const std::multiset<Key, Compare, Allocator> &t, + const unsigned int /* file_version */ +){ + boost::serialization::stl::save_collection< + Archive, + std::multiset<Key, Compare, Allocator> + >(ar, t); +} + +template<class Archive, class Key, class Compare, class Allocator > +inline void load( + Archive & ar, + std::multiset<Key, Compare, Allocator> &t, + const unsigned int /* file_version */ +){ + load_set_collection(ar, t); +} + +// split non-intrusive serialization function member into separate +// non intrusive save/load member functions +template<class Archive, class Key, class Compare, class Allocator > +inline void serialize( + Archive & ar, + std::multiset<Key, Compare, Allocator> & t, + const unsigned int file_version +){ + boost::serialization::split_free(ar, t, file_version); +} + +} // namespace serialization +} // namespace boost + +#include <boost/serialization/collection_traits.hpp> + +BOOST_SERIALIZATION_COLLECTION_TRAITS(std::set) +BOOST_SERIALIZATION_COLLECTION_TRAITS(std::multiset) + +#endif // BOOST_SERIALIZATION_SET_HPP diff --git a/src/third_party/boost-1.69.0/boost/serialization/singleton.hpp b/src/third_party/boost-1.69.0/boost/serialization/singleton.hpp new file mode 100644 index 00000000000..a668100da20 --- /dev/null +++ b/src/third_party/boost-1.69.0/boost/serialization/singleton.hpp @@ -0,0 +1,218 @@ +#ifndef BOOST_SERIALIZATION_SINGLETON_HPP +#define BOOST_SERIALIZATION_SINGLETON_HPP + +/////////1/////////2///////// 3/////////4/////////5/////////6/////////7/////////8 +// singleton.hpp +// +// Copyright David Abrahams 2006. Original version +// +// Copyright Robert Ramey 2007. Changes made to permit +// application throughout the serialization library. +// +// Copyright Alexander Grund 2018. Corrections to singleton lifetime +// +// Distributed under 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) +// +// The intention here is to define a template which will convert +// any class into a singleton with the following features: +// +// a) initialized before first use. +// b) thread-safe for const access to the class +// c) non-locking +// +// In order to do this, +// a) Initialize dynamically when used. +// b) Require that all singletons be initialized before main +// is called or any entry point into the shared library is invoked. +// This guarentees no race condition for initialization. +// In debug mode, we assert that no non-const functions are called +// after main is invoked. +// + +// MS compatible compilers support #pragma once +#if defined(_MSC_VER) +# pragma once +#endif + +#include <boost/assert.hpp> +#include <boost/config.hpp> +#include <boost/noncopyable.hpp> +#include <boost/serialization/force_include.hpp> +#include <boost/serialization/config.hpp> + +#include <boost/archive/detail/auto_link_archive.hpp> +#include <boost/archive/detail/abi_prefix.hpp> // must be the last header + +#ifdef BOOST_MSVC +# pragma warning(push) +# pragma warning(disable : 4511 4512) +#endif + +namespace boost { +namespace serialization { + +////////////////////////////////////////////////////////////////////// +// Provides a dynamically-initialized (singleton) instance of T in a +// way that avoids LNK1179 on vc6. See http://tinyurl.com/ljdp8 or +// http://lists.boost.org/Archives/boost/2006/05/105286.php for +// details. +// + +// Singletons created by this code are guaranteed to be unique +// within the executable or shared library which creates them. +// This is sufficient and in fact ideal for the serialization library. +// The singleton is created when the module is loaded and destroyed +// when the module is unloaded. + +// This base class has two functions. + +// First it provides a module handle for each singleton indicating +// the executable or shared library in which it was created. This +// turns out to be necessary and sufficient to implement the tables +// used by serialization library. + +// Second, it provides a mechanism to detect when a non-const function +// is called after initialization. + +// Make a singleton to lock/unlock all singletons for alteration. +// The intent is that all singletons created/used by this code +// are to be initialized before main is called. A test program +// can lock all the singletons when main is entered. Thus any +// attempt to retrieve a mutable instance while locked will +// generate an assertion if compiled for debug. + +// The singleton template can be used in 2 ways: +// 1 (Recommended): Publicly inherit your type T from singleton<T>, +// make its ctor protected and access it via T::get_const_instance() +// 2: Simply access singleton<T> without changing T. Note that this only +// provides a global instance accesible by singleton<T>::get_const_instance() +// or singleton<T>::get_mutable_instance() to prevent using multiple instances +// of T make its ctor protected + +// Note on usage of BOOST_DLLEXPORT: These functions are in danger of +// being eliminated by the optimizer when building an application in +// release mode. Usage of the macro is meant to signal the compiler/linker +// to avoid dropping these functions which seem to be unreferenced. +// This usage is not related to autolinking. + +class BOOST_SYMBOL_VISIBLE singleton_module : + public boost::noncopyable +{ +private: + BOOST_DLLEXPORT bool & get_lock() BOOST_USED { + static bool lock = false; + return lock; + } + +public: + BOOST_DLLEXPORT void lock(){ + get_lock() = true; + } + BOOST_DLLEXPORT void unlock(){ + get_lock() = false; + } + BOOST_DLLEXPORT bool is_locked(){ + return get_lock(); + } +}; + +static inline singleton_module & get_singleton_module(){ + static singleton_module m; + return m; +} + +namespace detail { + +// This is the class actually instantiated and hence the real singleton. +// So there will only be one instance of this class. This does not hold +// for singleton<T> as a class derived from singleton<T> could be +// instantiated multiple times. +// It also provides a flag `is_destroyed` which returns true, when the +// class was destructed. It is static and hence accesible even after +// destruction. This can be used to check, if the singleton is still +// accesible e.g. in destructors of other singletons. +template<class T> +class singleton_wrapper : public T +{ + static bool & get_is_destroyed(){ + // Prefer a static function member to avoid LNK1179. + // Note: As this is for a singleton (1 instance only) it must be set + // never be reset (to false)! + static bool is_destroyed_flag = false; + return is_destroyed_flag; + } +public: + singleton_wrapper(){ + BOOST_ASSERT(! is_destroyed()); + } + ~singleton_wrapper(){ + get_is_destroyed() = true; + } + static bool is_destroyed(){ + return get_is_destroyed(); + } +}; + +} // detail + +template <class T> +class singleton { +private: + static T * m_instance; + // include this to provoke instantiation at pre-execution time + static void use(T const &) {} + static T & get_instance() { + BOOST_ASSERT(! is_destroyed()); + + // use a wrapper so that types T with protected constructors can be used + // Using a static function member avoids LNK1179 + static detail::singleton_wrapper< T > t; + + // note that the following is absolutely essential. + // commenting out this statement will cause compilers to fail to + // construct the instance at pre-execution time. This would prevent + // our usage/implementation of "locking" and introduce uncertainty into + // the sequence of object initialization. + // Unfortunately, this triggers detectors of undefine behavior + // and reports an error. But I've been unable to find a different + // of guarenteeing that the the singleton is created at pre-main time. + use(* m_instance); + + return static_cast<T &>(t); + } +protected: + // Do not allow instantiation of a singleton<T>. But we want to allow + // `class T: public singleton<T>` so we can't delete this ctor + BOOST_DLLEXPORT singleton(){} + +public: + BOOST_DLLEXPORT static T & get_mutable_instance(){ + BOOST_ASSERT(! get_singleton_module().is_locked()); + return get_instance(); + } + BOOST_DLLEXPORT static const T & get_const_instance(){ + return get_instance(); + } + BOOST_DLLEXPORT static bool is_destroyed(){ + return detail::singleton_wrapper< T >::is_destroyed(); + } +}; + +// Assigning the instance reference to a static member forces initialization +// at startup time as described in +// https://groups.google.com/forum/#!topic/microsoft.public.vc.language/kDVNLnIsfZk +template<class T> +T * singleton< T >::m_instance = & singleton< T >::get_instance(); + +} // namespace serialization +} // namespace boost + +#include <boost/archive/detail/abi_suffix.hpp> // pops abi_suffix.hpp pragmas + +#ifdef BOOST_MSVC +#pragma warning(pop) +#endif + +#endif // BOOST_SERIALIZATION_SINGLETON_HPP diff --git a/src/third_party/boost-1.69.0/boost/serialization/smart_cast.hpp b/src/third_party/boost-1.69.0/boost/serialization/smart_cast.hpp new file mode 100644 index 00000000000..563f36aa20b --- /dev/null +++ b/src/third_party/boost-1.69.0/boost/serialization/smart_cast.hpp @@ -0,0 +1,275 @@ +#ifndef BOOST_SERIALIZATION_SMART_CAST_HPP +#define BOOST_SERIALIZATION_SMART_CAST_HPP + +// MS compatible compilers support #pragma once +#if defined(_MSC_VER) +# pragma once +#endif + +/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8 +// smart_cast.hpp: + +// (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/libs/serialization for updates, documentation, and revision history. + +// casting of pointers and references. + +// In casting between different C++ classes, there are a number of +// rules that have to be kept in mind in deciding whether to use +// static_cast or dynamic_cast. + +// a) dynamic casting can only be applied when one of the types is polymorphic +// Otherwise static_cast must be used. +// b) only dynamic casting can do runtime error checking +// use of static_cast is generally un checked even when compiled for debug +// c) static_cast would be considered faster than dynamic_cast. + +// If casting is applied to a template parameter, there is no apriori way +// to know which of the two casting methods will be permitted or convenient. + +// smart_cast uses C++ type_traits, and program debug mode to select the +// most convenient cast to use. + +#include <exception> +#include <typeinfo> +#include <cstddef> // NULL + +#include <boost/config.hpp> +#include <boost/static_assert.hpp> + +#include <boost/type_traits/is_base_and_derived.hpp> +#include <boost/type_traits/is_polymorphic.hpp> +#include <boost/type_traits/is_pointer.hpp> +#include <boost/type_traits/is_reference.hpp> +#include <boost/type_traits/is_same.hpp> +#include <boost/type_traits/remove_pointer.hpp> +#include <boost/type_traits/remove_reference.hpp> + +#include <boost/mpl/eval_if.hpp> +#include <boost/mpl/if.hpp> +#include <boost/mpl/or.hpp> +#include <boost/mpl/and.hpp> +#include <boost/mpl/not.hpp> +#include <boost/mpl/identity.hpp> + +#include <boost/serialization/throw_exception.hpp> + +namespace boost { +namespace serialization { +namespace smart_cast_impl { + + template<class T> + struct reference { + + struct polymorphic { + + struct linear { + template<class U> + static T cast(U & u){ + return static_cast< T >(u); + } + }; + + struct cross { + template<class U> + static T cast(U & u){ + return dynamic_cast< T >(u); + } + }; + + template<class U> + static T cast(U & u){ + // if we're in debug mode + #if ! defined(NDEBUG) \ + || defined(__MWERKS__) + // do a checked dynamic cast + return cross::cast(u); + #else + // borland 5.51 chokes here so we can't use it + // note: if remove_reference isn't function for these types + // cross casting will be selected this will work but will + // not be the most efficient method. This will conflict with + // the original smart_cast motivation. + typedef typename mpl::eval_if< + typename mpl::and_< + mpl::not_<is_base_and_derived< + typename remove_reference< T >::type, + U + > >, + mpl::not_<is_base_and_derived< + U, + typename remove_reference< T >::type + > > + >, + // borland chokes w/o full qualification here + mpl::identity<cross>, + mpl::identity<linear> + >::type typex; + // typex works around gcc 2.95 issue + return typex::cast(u); + #endif + } + }; + + struct non_polymorphic { + template<class U> + static T cast(U & u){ + return static_cast< T >(u); + } + }; + template<class U> + static T cast(U & u){ + typedef typename mpl::eval_if< + boost::is_polymorphic<U>, + mpl::identity<polymorphic>, + mpl::identity<non_polymorphic> + >::type typex; + return typex::cast(u); + } + }; + + template<class T> + struct pointer { + + struct polymorphic { + // unfortunately, this below fails to work for virtual base + // classes. need has_virtual_base to do this. + // Subject for further study + #if 0 + struct linear { + template<class U> + static T cast(U * u){ + return static_cast< T >(u); + } + }; + + struct cross { + template<class U> + static T cast(U * u){ + T tmp = dynamic_cast< T >(u); + #ifndef NDEBUG + if ( tmp == 0 ) throw_exception(std::bad_cast()); + #endif + return tmp; + } + }; + + template<class U> + static T cast(U * u){ + typedef + typename mpl::eval_if< + typename mpl::and_< + mpl::not_<is_base_and_derived< + typename remove_pointer< T >::type, + U + > >, + mpl::not_<is_base_and_derived< + U, + typename remove_pointer< T >::type + > > + >, + // borland chokes w/o full qualification here + mpl::identity<cross>, + mpl::identity<linear> + >::type typex; + return typex::cast(u); + } + #else + template<class U> + static T cast(U * u){ + T tmp = dynamic_cast< T >(u); + #ifndef NDEBUG + if ( tmp == 0 ) throw_exception(std::bad_cast()); + #endif + return tmp; + } + #endif + }; + + struct non_polymorphic { + template<class U> + static T cast(U * u){ + return static_cast< T >(u); + } + }; + + template<class U> + static T cast(U * u){ + typedef typename mpl::eval_if< + boost::is_polymorphic<U>, + mpl::identity<polymorphic>, + mpl::identity<non_polymorphic> + >::type typex; + return typex::cast(u); + } + + }; + + template<class TPtr> + struct void_pointer { + template<class UPtr> + static TPtr cast(UPtr uptr){ + return static_cast<TPtr>(uptr); + } + }; + + template<class T> + struct error { + // if we get here, its because we are using one argument in the + // cast on a system which doesn't support partial template + // specialization + template<class U> + static T cast(U){ + BOOST_STATIC_ASSERT(sizeof(T)==0); + return * static_cast<T *>(NULL); + } + }; + +} // smart_cast_impl + +// this implements: +// smart_cast<Target *, Source *>(Source * s) +// smart_cast<Target &, Source &>(s) +// note that it will fail with +// smart_cast<Target &>(s) +template<class T, class U> +T smart_cast(U u) { + typedef + typename mpl::eval_if< + typename mpl::or_< + boost::is_same<void *, U>, + boost::is_same<void *, T>, + boost::is_same<const void *, U>, + boost::is_same<const void *, T> + >, + mpl::identity<smart_cast_impl::void_pointer< T > >, + // else + typename mpl::eval_if<boost::is_pointer<U>, + mpl::identity<smart_cast_impl::pointer< T > >, + // else + typename mpl::eval_if<boost::is_reference<U>, + mpl::identity<smart_cast_impl::reference< T > >, + // else + mpl::identity<smart_cast_impl::error< T > + > + > + > + >::type typex; + return typex::cast(u); +} + +// this implements: +// smart_cast_reference<Target &>(Source & s) +template<class T, class U> +T smart_cast_reference(U & u) { + return smart_cast_impl::reference< T >::cast(u); +} + +} // namespace serialization +} // namespace boost + +#endif // BOOST_SERIALIZATION_SMART_CAST_HPP diff --git a/src/third_party/boost-1.69.0/boost/serialization/split_free.hpp b/src/third_party/boost-1.69.0/boost/serialization/split_free.hpp new file mode 100644 index 00000000000..85e2f590fe4 --- /dev/null +++ b/src/third_party/boost-1.69.0/boost/serialization/split_free.hpp @@ -0,0 +1,93 @@ +#ifndef BOOST_SERIALIZATION_SPLIT_FREE_HPP +#define BOOST_SERIALIZATION_SPLIT_FREE_HPP + +// MS compatible compilers support #pragma once +#if defined(_MSC_VER) +# pragma once +#endif + +/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8 +// split_free.hpp: + +// (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> +#include <boost/mpl/eval_if.hpp> +#include <boost/mpl/identity.hpp> +#include <boost/serialization/serialization.hpp> + +namespace boost { +namespace archive { + namespace detail { + template<class Archive> class interface_oarchive; + template<class Archive> class interface_iarchive; + } // namespace detail +} // namespace archive + +namespace serialization { + +//namespace detail { +template<class Archive, class T> +struct free_saver { + static void invoke( + Archive & ar, + const T & t, + const unsigned int file_version + ){ + // use function overload (version_type) to workaround + // two-phase lookup issue + const version_type v(file_version); + save(ar, t, v); + } +}; +template<class Archive, class T> +struct free_loader { + static void invoke( + Archive & ar, + T & t, + const unsigned int file_version + ){ + // use function overload (version_type) to workaround + // two-phase lookup issue + const version_type v(file_version); + load(ar, t, v); + } +}; +//} // namespace detail + +template<class Archive, class T> +inline void split_free( + Archive & ar, + T & t, + const unsigned int file_version +){ + typedef typename mpl::eval_if< + typename Archive::is_saving, + mpl::identity</* detail:: */ free_saver<Archive, T> >, + mpl::identity</* detail:: */ free_loader<Archive, T> > + >::type typex; + typex::invoke(ar, t, file_version); +} + +} // namespace serialization +} // namespace boost + +#define BOOST_SERIALIZATION_SPLIT_FREE(T) \ +namespace boost { namespace serialization { \ +template<class Archive> \ +inline void serialize( \ + Archive & ar, \ + T & t, \ + const unsigned int file_version \ +){ \ + split_free(ar, t, file_version); \ +} \ +}} +/**/ + +#endif // BOOST_SERIALIZATION_SPLIT_FREE_HPP diff --git a/src/third_party/boost-1.69.0/boost/serialization/split_member.hpp b/src/third_party/boost-1.69.0/boost/serialization/split_member.hpp new file mode 100644 index 00000000000..5f32520559e --- /dev/null +++ b/src/third_party/boost-1.69.0/boost/serialization/split_member.hpp @@ -0,0 +1,86 @@ +#ifndef BOOST_SERIALIZATION_SPLIT_MEMBER_HPP +#define BOOST_SERIALIZATION_SPLIT_MEMBER_HPP + +// MS compatible compilers support #pragma once +#if defined(_MSC_VER) +# pragma once +#endif + +/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8 +// split_member.hpp: + +// (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> +#include <boost/mpl/eval_if.hpp> +#include <boost/mpl/identity.hpp> + +#include <boost/serialization/access.hpp> + +namespace boost { +namespace archive { + namespace detail { + template<class Archive> class interface_oarchive; + template<class Archive> class interface_iarchive; + } // namespace detail +} // namespace archive + +namespace serialization { +namespace detail { + + template<class Archive, class T> + struct member_saver { + static void invoke( + Archive & ar, + const T & t, + const unsigned int file_version + ){ + access::member_save(ar, t, file_version); + } + }; + + template<class Archive, class T> + struct member_loader { + static void invoke( + Archive & ar, + T & t, + const unsigned int file_version + ){ + access::member_load(ar, t, file_version); + } + }; + +} // detail + +template<class Archive, class T> +inline void split_member( + Archive & ar, T & t, const unsigned int file_version +){ + typedef typename mpl::eval_if< + typename Archive::is_saving, + mpl::identity<detail::member_saver<Archive, T> >, + mpl::identity<detail::member_loader<Archive, T> > + >::type typex; + typex::invoke(ar, t, file_version); +} + +} // namespace serialization +} // namespace boost + +// split member function serialize funcition into save/load +#define BOOST_SERIALIZATION_SPLIT_MEMBER() \ +template<class Archive> \ +void serialize( \ + Archive &ar, \ + const unsigned int file_version \ +){ \ + boost::serialization::split_member(ar, *this, file_version); \ +} \ +/**/ + +#endif // BOOST_SERIALIZATION_SPLIT_MEMBER_HPP diff --git a/src/third_party/boost-1.69.0/boost/serialization/state_saver.hpp b/src/third_party/boost-1.69.0/boost/serialization/state_saver.hpp new file mode 100644 index 00000000000..248b8d91556 --- /dev/null +++ b/src/third_party/boost-1.69.0/boost/serialization/state_saver.hpp @@ -0,0 +1,96 @@ +#ifndef BOOST_SERIALIZATION_STATE_SAVER_HPP +#define BOOST_SERIALIZATION_STATE_SAVER_HPP + +// MS compatible compilers support #pragma once +#if defined(_MSC_VER) +# pragma once +#endif + +/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8 +// state_saver.hpp: + +// (C) Copyright 2003-4 Pavel Vozenilek and 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/libs/serialization for updates, documentation, and revision history. + +// Inspired by Daryle Walker's iostate_saver concept. This saves the original +// value of a variable when a state_saver is constructed and restores +// upon destruction. Useful for being sure that state is restored to +// variables upon exit from scope. + + +#include <boost/config.hpp> +#ifndef BOOST_NO_EXCEPTIONS + #include <exception> +#endif + +#include <boost/call_traits.hpp> +#include <boost/noncopyable.hpp> +#include <boost/type_traits/has_nothrow_copy.hpp> +#include <boost/core/no_exceptions_support.hpp> + +#include <boost/mpl/eval_if.hpp> +#include <boost/mpl/identity.hpp> + +namespace boost { +namespace serialization { + +template<class T> +// T requirements: +// - POD or object semantic (cannot be reference, function, ...) +// - copy constructor +// - operator = (no-throw one preferred) +class state_saver : private boost::noncopyable +{ +private: + const T previous_value; + T & previous_ref; + + struct restore { + static void invoke(T & previous_ref, const T & previous_value){ + previous_ref = previous_value; // won't throw + } + }; + + struct restore_with_exception { + static void invoke(T & previous_ref, const T & previous_value){ + BOOST_TRY{ + previous_ref = previous_value; + } + BOOST_CATCH(::std::exception &) { + // we must ignore it - we are in destructor + } + BOOST_CATCH_END + } + }; + +public: + state_saver( + T & object + ) : + previous_value(object), + previous_ref(object) + {} + + ~state_saver() { + #ifndef BOOST_NO_EXCEPTIONS + typedef typename mpl::eval_if< + has_nothrow_copy< T >, + mpl::identity<restore>, + mpl::identity<restore_with_exception> + >::type typex; + typex::invoke(previous_ref, previous_value); + #else + previous_ref = previous_value; + #endif + } + +}; // state_saver<> + +} // serialization +} // boost + +#endif //BOOST_SERIALIZATION_STATE_SAVER_HPP diff --git a/src/third_party/boost-1.69.0/boost/serialization/static_warning.hpp b/src/third_party/boost-1.69.0/boost/serialization/static_warning.hpp new file mode 100644 index 00000000000..1d9238fc4d9 --- /dev/null +++ b/src/third_party/boost-1.69.0/boost/serialization/static_warning.hpp @@ -0,0 +1,103 @@ +#ifndef BOOST_SERIALIZATION_STATIC_WARNING_HPP +#define BOOST_SERIALIZATION_STATIC_WARNING_HPP + +// (C) Copyright Robert Ramey 2003. Jonathan Turkanis 2004. +// Use, modification and distribution is subject to the Boost Software +// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at +// MS compatible compilers support #pragma once +#if defined(_MSC_VER) +# pragma once +#endif + +// http://www.boost.org/LICENSE_1_0.txt) + +// See http://www.boost.org/libs/static_assert for documentation. + +/* + Revision history: + 15 June 2003 - Initial version. + 31 March 2004 - improved diagnostic messages and portability + (Jonathan Turkanis) + 03 April 2004 - works on VC6 at class and namespace scope + - ported to DigitalMars + - static warnings disabled by default; when enabled, + uses pragmas to enable required compiler warnings + on MSVC, Intel, Metrowerks and Borland 5.x. + (Jonathan Turkanis) + 30 May 2004 - tweaked for msvc 7.1 and gcc 3.3 + - static warnings ENabled by default; when enabled, + (Robert Ramey) +*/ + +#include <boost/config.hpp> + +// +// Implementation +// Makes use of the following warnings: +// 1. GCC prior to 3.3: division by zero. +// 2. BCC 6.0 preview: unreferenced local variable. +// 3. DigitalMars: returning address of local automatic variable. +// 4. VC6: class previously seen as struct (as in 'boost/mpl/print.hpp') +// 5. All others: deletion of pointer to incomplete type. +// +// The trick is to find code which produces warnings containing the name of +// a structure or variable. Details, with same numbering as above: +// 1. static_warning_impl<B>::value is zero iff B is false, so diving an int +// by this value generates a warning iff B is false. +// 2. static_warning_impl<B>::type has a constructor iff B is true, so an +// unreferenced variable of this type generates a warning iff B is false. +// 3. static_warning_impl<B>::type overloads operator& to return a dynamically +// allocated int pointer only is B is true, so returning the address of an +// automatic variable of this type generates a warning iff B is fasle. +// 4. static_warning_impl<B>::STATIC_WARNING is decalred as a struct iff B is +// false. +// 5. static_warning_impl<B>::type is incomplete iff B is false, so deleting a +// pointer to this type generates a warning iff B is false. +// + +//------------------Enable selected warnings----------------------------------// + +// Enable the warnings relied on by BOOST_STATIC_WARNING, where possible. + +// 6. replaced implementation with one which depends solely on +// mpl::print<>. The previous one was found to fail for functions +// under recent versions of gcc and intel compilers - Robert Ramey + +#include <boost/mpl/bool.hpp> +#include <boost/mpl/print.hpp> +#include <boost/mpl/eval_if.hpp> +#include <boost/mpl/bool_fwd.hpp> +#include <boost/static_assert.hpp> + +namespace boost { +namespace serialization { + +template<int L> +struct BOOST_SERIALIZATION_STATIC_WARNING_LINE{}; + +template<bool B, int L> +struct static_warning_test{ + typename boost::mpl::eval_if_c< + B, + boost::mpl::true_, + typename boost::mpl::identity< + boost::mpl::print< + BOOST_SERIALIZATION_STATIC_WARNING_LINE<L> + > + > + >::type type; +}; + +template<int i> +struct BOOST_SERIALIZATION_SS {}; + +} // serialization +} // boost + +#define BOOST_SERIALIZATION_BSW(B, L) \ + typedef boost::serialization::BOOST_SERIALIZATION_SS< \ + sizeof( boost::serialization::static_warning_test< B, L > ) \ + > BOOST_JOIN(STATIC_WARNING_LINE, L) BOOST_ATTRIBUTE_UNUSED; +#define BOOST_STATIC_WARNING(B) BOOST_SERIALIZATION_BSW(B, __LINE__) + +#endif // BOOST_SERIALIZATION_STATIC_WARNING_HPP diff --git a/src/third_party/boost-1.69.0/boost/serialization/string.hpp b/src/third_party/boost-1.69.0/boost/serialization/string.hpp new file mode 100644 index 00000000000..76e695d4f3c --- /dev/null +++ b/src/third_party/boost-1.69.0/boost/serialization/string.hpp @@ -0,0 +1,30 @@ +#ifndef BOOST_SERIALIZATION_STRING_HPP +#define BOOST_SERIALIZATION_STRING_HPP + +// MS compatible compilers support #pragma once +#if defined(_MSC_VER) +# pragma once +#endif + +/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8 +// serialization/string.hpp: +// serialization for stl string templates + +// (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 <string> + +#include <boost/config.hpp> +#include <boost/serialization/level.hpp> + +BOOST_CLASS_IMPLEMENTATION(std::string, boost::serialization::primitive_type) +#ifndef BOOST_NO_STD_WSTRING +BOOST_CLASS_IMPLEMENTATION(std::wstring, boost::serialization::primitive_type) +#endif + +#endif // BOOST_SERIALIZATION_STRING_HPP diff --git a/src/third_party/boost-1.69.0/boost/serialization/strong_typedef.hpp b/src/third_party/boost-1.69.0/boost/serialization/strong_typedef.hpp new file mode 100644 index 00000000000..fdd1b24c9cb --- /dev/null +++ b/src/third_party/boost-1.69.0/boost/serialization/strong_typedef.hpp @@ -0,0 +1,50 @@ +#ifndef BOOST_SERIALIZATION_STRONG_TYPEDEF_HPP +#define BOOST_SERIALIZATION_STRONG_TYPEDEF_HPP + +// MS compatible compilers support #pragma once +#if defined(_MSC_VER) +# pragma once +#endif + +/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8 +// strong_typedef.hpp: + +// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . +// (C) Copyright 2016 Ashish Sadanandan +// 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/libs/serialization for updates, documentation, and revision history. + +// macro used to implement a strong typedef. strong typedef +// guarentees that two types are distinguised even though the +// share the same underlying implementation. typedef does not create +// a new type. BOOST_STRONG_TYPEDEF(T, D) creates a new type named D +// that operates as a type T. + +#include <boost/config.hpp> +#include <boost/operators.hpp> +#include <boost/type_traits/has_nothrow_assign.hpp> +#include <boost/type_traits/has_nothrow_constructor.hpp> +#include <boost/type_traits/has_nothrow_copy.hpp> + +#define BOOST_STRONG_TYPEDEF(T, D) \ +struct D \ + : boost::totally_ordered1< D \ + , boost::totally_ordered2< D, T \ + > > \ +{ \ + T t; \ + explicit D(const T& t_) BOOST_NOEXCEPT_IF(boost::has_nothrow_copy_constructor<T>::value) : t(t_) {} \ + D() BOOST_NOEXCEPT_IF(boost::has_nothrow_default_constructor<T>::value) : t() {} \ + D(const D & t_) BOOST_NOEXCEPT_IF(boost::has_nothrow_copy_constructor<T>::value) : t(t_.t) {} \ + D& operator=(const D& rhs) BOOST_NOEXCEPT_IF(boost::has_nothrow_assign<T>::value) {t = rhs.t; return *this;} \ + D& operator=(const T& rhs) BOOST_NOEXCEPT_IF(boost::has_nothrow_assign<T>::value) {t = rhs; return *this;} \ + operator const T&() const {return t;} \ + operator T&() {return t;} \ + bool operator==(const D& rhs) const {return t == rhs.t;} \ + bool operator<(const D& rhs) const {return t < rhs.t;} \ +}; + +#endif // BOOST_SERIALIZATION_STRONG_TYPEDEF_HPP diff --git a/src/third_party/boost-1.69.0/boost/serialization/throw_exception.hpp b/src/third_party/boost-1.69.0/boost/serialization/throw_exception.hpp new file mode 100644 index 00000000000..b67618adc92 --- /dev/null +++ b/src/third_party/boost-1.69.0/boost/serialization/throw_exception.hpp @@ -0,0 +1,44 @@ +#ifndef BOOST_SERIALIZATION_THROW_EXCEPTION_HPP_INCLUDED +#define BOOST_SERIALIZATION_THROW_EXCEPTION_HPP_INCLUDED + +// MS compatible compilers support #pragma once + +#if defined(_MSC_VER) +# pragma once +#endif + +// boost/throw_exception.hpp +// +// Copyright (c) 2002 Peter Dimov and Multi Media Ltd. +// +// Distributed under 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) + +#include <boost/config.hpp> + +#ifndef BOOST_NO_EXCEPTIONS +#include <exception> +#endif + +namespace boost { +namespace serialization { + +#ifdef BOOST_NO_EXCEPTIONS + +inline void throw_exception(std::exception const & e) { + ::boost::throw_exception(e); +} + +#else + +template<class E> inline void throw_exception(E const & e){ + throw e; +} + +#endif + +} // namespace serialization +} // namespace boost + +#endif // #ifndef BOOST_SERIALIZATION_THROW_EXCEPTION_HPP_INCLUDED diff --git a/src/third_party/boost-1.69.0/boost/serialization/tracking.hpp b/src/third_party/boost-1.69.0/boost/serialization/tracking.hpp new file mode 100644 index 00000000000..d5c79b8409d --- /dev/null +++ b/src/third_party/boost-1.69.0/boost/serialization/tracking.hpp @@ -0,0 +1,118 @@ +#ifndef BOOST_SERIALIZATION_TRACKING_HPP +#define BOOST_SERIALIZATION_TRACKING_HPP + +// MS compatible compilers support #pragma once +#if defined(_MSC_VER) +# pragma once +#endif + +/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8 +// tracking.hpp: + +// (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> +#include <boost/static_assert.hpp> +#include <boost/mpl/eval_if.hpp> +#include <boost/mpl/identity.hpp> +#include <boost/mpl/int.hpp> +#include <boost/mpl/equal_to.hpp> +#include <boost/mpl/greater.hpp> +#include <boost/mpl/integral_c_tag.hpp> + +#include <boost/type_traits/is_base_and_derived.hpp> +#include <boost/type_traits/is_pointer.hpp> +#include <boost/serialization/level.hpp> +#include <boost/serialization/tracking_enum.hpp> +#include <boost/serialization/type_info_implementation.hpp> + +namespace boost { +namespace serialization { + +struct basic_traits; + +// default tracking level +template<class T> +struct tracking_level_impl { + template<class U> + struct traits_class_tracking { + typedef typename U::tracking type; + }; + typedef mpl::integral_c_tag tag; + // note: at least one compiler complained w/o the full qualification + // on basic traits below + typedef + typename mpl::eval_if< + is_base_and_derived<boost::serialization::basic_traits, T>, + traits_class_tracking< T >, + //else + typename mpl::eval_if< + is_pointer< T >, + // pointers are not tracked by default + mpl::int_<track_never>, + //else + typename mpl::eval_if< + // for primitives + typename mpl::equal_to< + implementation_level< T >, + mpl::int_<primitive_type> + >, + // is never + mpl::int_<track_never>, + // otherwise its selective + mpl::int_<track_selectively> + > > >::type type; + BOOST_STATIC_CONSTANT(int, value = type::value); +}; + +template<class T> +struct tracking_level : + public tracking_level_impl<const T> +{ +}; + +template<class T, enum tracking_type L> +inline bool operator>=(tracking_level< T > t, enum tracking_type l) +{ + return t.value >= (int)l; +} + +} // namespace serialization +} // namespace boost + + +// The STATIC_ASSERT is prevents one from setting tracking for a primitive type. +// This almost HAS to be an error. Doing this will effect serialization of all +// char's in your program which is almost certainly what you don't want to do. +// If you want to track all instances of a given primitive type, You'll have to +// wrap it in your own type so its not a primitive anymore. Then it will compile +// without problem. +#define BOOST_CLASS_TRACKING(T, E) \ +namespace boost { \ +namespace serialization { \ +template<> \ +struct tracking_level< T > \ +{ \ + typedef mpl::integral_c_tag tag; \ + typedef mpl::int_< E> type; \ + BOOST_STATIC_CONSTANT( \ + int, \ + value = tracking_level::type::value \ + ); \ + /* tracking for a class */ \ + BOOST_STATIC_ASSERT(( \ + mpl::greater< \ + /* that is a prmitive */ \ + implementation_level< T >, \ + mpl::int_<primitive_type> \ + >::value \ + )); \ +}; \ +}} + +#endif // BOOST_SERIALIZATION_TRACKING_HPP diff --git a/src/third_party/boost-1.69.0/boost/serialization/tracking_enum.hpp b/src/third_party/boost-1.69.0/boost/serialization/tracking_enum.hpp new file mode 100644 index 00000000000..278051e1baf --- /dev/null +++ b/src/third_party/boost-1.69.0/boost/serialization/tracking_enum.hpp @@ -0,0 +1,41 @@ +#ifndef BOOST_SERIALIZATION_TRACKING_ENUM_HPP +#define BOOST_SERIALIZATION_TRACKING_ENUM_HPP + +// MS compatible compilers support #pragma once +#if defined(_MSC_VER) +# pragma once +#endif + +/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8 +// tracking_enum.hpp: + +// (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. + +namespace boost { +namespace serialization { + +// addresses of serialized objects may be tracked to avoid saving/loading +// redundant copies. This header defines a class trait that can be used +// to specify when objects should be tracked + +// names for each tracking level +enum tracking_type +{ + // never track this type + track_never = 0, + // track objects of this type if the object is serialized through a + // pointer. + track_selectively = 1, + // always track this type + track_always = 2 +}; + +} // namespace serialization +} // namespace boost + +#endif // BOOST_SERIALIZATION_TRACKING_ENUM_HPP diff --git a/src/third_party/boost-1.69.0/boost/serialization/traits.hpp b/src/third_party/boost-1.69.0/boost/serialization/traits.hpp new file mode 100644 index 00000000000..9e114fdd3df --- /dev/null +++ b/src/third_party/boost-1.69.0/boost/serialization/traits.hpp @@ -0,0 +1,65 @@ +#ifndef BOOST_SERIALIZATION_TRAITS_HPP +#define BOOST_SERIALIZATION_TRAITS_HPP + +// MS compatible compilers support #pragma once +#if defined(_MSC_VER) +# pragma once +#endif + +/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8 +// traits.hpp: + +// (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. + +// This header is used to apply serialization traits to templates. The +// standard system can't be used for platforms which don't support +// Partial Templlate Specialization. + +// The motivation for this is the Name-Value Pair (NVP) template. +// it has to work the same on all platforms in order for archives +// to be portable accross platforms. + +#include <boost/config.hpp> +#include <boost/static_assert.hpp> + +#include <boost/mpl/int.hpp> +#include <boost/mpl/bool_fwd.hpp> +#include <boost/serialization/level_enum.hpp> +#include <boost/serialization/tracking_enum.hpp> + +namespace boost { +namespace serialization { + +// common base class used to detect appended traits class +struct basic_traits {}; + +template <class T> +struct extended_type_info_impl; + +template< + class T, + int Level, + int Tracking, + unsigned int Version = 0, + class ETII = extended_type_info_impl< T >, + class Wrapper = mpl::false_ +> +struct traits : public basic_traits { + BOOST_STATIC_ASSERT(Version == 0 || Level >= object_class_info); + BOOST_STATIC_ASSERT(Tracking == track_never || Level >= object_serializable); + typedef typename mpl::int_<Level> level; + typedef typename mpl::int_<Tracking> tracking; + typedef typename mpl::int_<Version> version; + typedef ETII type_info_implementation; + typedef Wrapper is_wrapper; +}; + +} // namespace serialization +} // namespace boost + +#endif // BOOST_SERIALIZATION_TRAITS_HPP diff --git a/src/third_party/boost-1.69.0/boost/serialization/type_info_implementation.hpp b/src/third_party/boost-1.69.0/boost/serialization/type_info_implementation.hpp new file mode 100644 index 00000000000..24637a8dbb3 --- /dev/null +++ b/src/third_party/boost-1.69.0/boost/serialization/type_info_implementation.hpp @@ -0,0 +1,73 @@ +#ifndef BOOST_SERIALIZATION_TYPE_INFO_IMPLEMENTATION_HPP +#define BOOST_SERIALIZATION_TYPE_INFO_IMPLEMENTATION_HPP + +// MS compatible compilers support #pragma once +#if defined(_MSC_VER) +# pragma once +#endif + +/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8 +// type_info_implementation.hpp: interface for portable version of type_info + +// (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> +#include <boost/detail/workaround.hpp> + +#include <boost/static_assert.hpp> +#include <boost/mpl/eval_if.hpp> +#include <boost/mpl/identity.hpp> +#include <boost/type_traits/is_base_and_derived.hpp> +#include <boost/serialization/traits.hpp> + +namespace boost { +namespace serialization { + +// note that T and const T are folded into const T so that +// there is only one table entry per type +template<class T> +struct type_info_implementation { + template<class U> + struct traits_class_typeinfo_implementation { + typedef typename U::type_info_implementation::type type; + }; + // note: at least one compiler complained w/o the full qualification + // on basic traits below + typedef + typename mpl::eval_if< + is_base_and_derived<boost::serialization::basic_traits, T>, + traits_class_typeinfo_implementation< T >, + //else + mpl::identity< + typename extended_type_info_impl< T >::type + > + >::type type; +}; + +} // namespace serialization +} // namespace boost + +// define a macro to assign a particular derivation of extended_type_info +// to a specified a class. +#define BOOST_CLASS_TYPE_INFO(T, ETI) \ +namespace boost { \ +namespace serialization { \ +template<> \ +struct type_info_implementation< T > { \ + typedef ETI type; \ +}; \ +template<> \ +struct type_info_implementation< const T > { \ + typedef ETI type; \ +}; \ +} \ +} \ +/**/ + +#endif /// BOOST_SERIALIZATION_TYPE_INFO_IMPLEMENTATION_HPP diff --git a/src/third_party/boost-1.69.0/boost/serialization/vector.hpp b/src/third_party/boost-1.69.0/boost/serialization/vector.hpp new file mode 100644 index 00000000000..9a114c00e20 --- /dev/null +++ b/src/third_party/boost-1.69.0/boost/serialization/vector.hpp @@ -0,0 +1,233 @@ +#ifndef BOOST_SERIALIZATION_VECTOR_HPP +#define BOOST_SERIALIZATION_VECTOR_HPP + +// MS compatible compilers support #pragma once +#if defined(_MSC_VER) +# pragma once +#endif + +/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8 +// vector.hpp: serialization for stl vector templates + +// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . +// fast array serialization (C) Copyright 2005 Matthias Troyer +// 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 <vector> + +#include <boost/config.hpp> +#include <boost/detail/workaround.hpp> + +#include <boost/archive/detail/basic_iarchive.hpp> +#include <boost/serialization/access.hpp> +#include <boost/serialization/nvp.hpp> +#include <boost/serialization/collection_size_type.hpp> +#include <boost/serialization/item_version_type.hpp> + +#include <boost/serialization/collections_save_imp.hpp> +#include <boost/serialization/collections_load_imp.hpp> +#include <boost/serialization/split_free.hpp> +#include <boost/serialization/array_wrapper.hpp> +#include <boost/mpl/bool_fwd.hpp> +#include <boost/mpl/if.hpp> + +// default is being compatible with version 1.34.1 files, not 1.35 files +#ifndef BOOST_SERIALIZATION_VECTOR_VERSIONED +#define BOOST_SERIALIZATION_VECTOR_VERSIONED(V) (V==4 || V==5) +#endif + +// function specializations must be defined in the appropriate +// namespace - boost::serialization +#if defined(__SGI_STL_PORT) || defined(_STLPORT_VERSION) +#define STD _STLP_STD +#else +#define STD std +#endif + +namespace boost { +namespace serialization { + +/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8 +// vector< T > + +// the default versions + +template<class Archive, class U, class Allocator> +inline void save( + Archive & ar, + const std::vector<U, Allocator> &t, + const unsigned int /* file_version */, + mpl::false_ +){ + boost::serialization::stl::save_collection<Archive, STD::vector<U, Allocator> >( + ar, t + ); +} + +template<class Archive, class U, class Allocator> +inline void load( + Archive & ar, + std::vector<U, Allocator> &t, + const unsigned int /* file_version */, + mpl::false_ +){ + const boost::archive::library_version_type library_version( + ar.get_library_version() + ); + // retrieve number of elements + item_version_type item_version(0); + collection_size_type count; + ar >> BOOST_SERIALIZATION_NVP(count); + if(boost::archive::library_version_type(3) < library_version){ + ar >> BOOST_SERIALIZATION_NVP(item_version); + } + t.reserve(count); + stl::collection_load_impl(ar, t, count, item_version); +} + +// the optimized versions + +template<class Archive, class U, class Allocator> +inline void save( + Archive & ar, + const std::vector<U, Allocator> &t, + const unsigned int /* file_version */, + mpl::true_ +){ + const collection_size_type count(t.size()); + ar << BOOST_SERIALIZATION_NVP(count); + if (!t.empty()) + // explict template arguments to pass intel C++ compiler + ar << serialization::make_array<const U, collection_size_type>( + static_cast<const U *>(&t[0]), + count + ); +} + +template<class Archive, class U, class Allocator> +inline void load( + Archive & ar, + std::vector<U, Allocator> &t, + const unsigned int /* file_version */, + mpl::true_ +){ + collection_size_type count(t.size()); + ar >> BOOST_SERIALIZATION_NVP(count); + t.resize(count); + unsigned int item_version=0; + if(BOOST_SERIALIZATION_VECTOR_VERSIONED(ar.get_library_version())) { + ar >> BOOST_SERIALIZATION_NVP(item_version); + } + if (!t.empty()) + // explict template arguments to pass intel C++ compiler + ar >> serialization::make_array<U, collection_size_type>( + static_cast<U *>(&t[0]), + count + ); + } + +// dispatch to either default or optimized versions + +template<class Archive, class U, class Allocator> +inline void save( + Archive & ar, + const std::vector<U, Allocator> &t, + const unsigned int file_version +){ + typedef typename + boost::serialization::use_array_optimization<Archive>::template apply< + typename remove_const<U>::type + >::type use_optimized; + save(ar,t,file_version, use_optimized()); +} + +template<class Archive, class U, class Allocator> +inline void load( + Archive & ar, + std::vector<U, Allocator> &t, + const unsigned int file_version +){ +#ifdef BOOST_SERIALIZATION_VECTOR_135_HPP + if (ar.get_library_version()==boost::archive::library_version_type(5)) + { + load(ar,t,file_version, boost::is_arithmetic<U>()); + return; + } +#endif + typedef typename + boost::serialization::use_array_optimization<Archive>::template apply< + typename remove_const<U>::type + >::type use_optimized; + load(ar,t,file_version, use_optimized()); +} + +// split non-intrusive serialization function member into separate +// non intrusive save/load member functions +template<class Archive, class U, class Allocator> +inline void serialize( + Archive & ar, + std::vector<U, Allocator> & t, + const unsigned int file_version +){ + boost::serialization::split_free(ar, t, file_version); +} + +/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8 +// vector<bool> +template<class Archive, class Allocator> +inline void save( + Archive & ar, + const std::vector<bool, Allocator> &t, + const unsigned int /* file_version */ +){ + // record number of elements + collection_size_type count (t.size()); + ar << BOOST_SERIALIZATION_NVP(count); + std::vector<bool>::const_iterator it = t.begin(); + while(count-- > 0){ + bool tb = *it++; + ar << boost::serialization::make_nvp("item", tb); + } +} + +template<class Archive, class Allocator> +inline void load( + Archive & ar, + std::vector<bool, Allocator> &t, + const unsigned int /* file_version */ +){ + // retrieve number of elements + collection_size_type count; + ar >> BOOST_SERIALIZATION_NVP(count); + t.resize(count); + for(collection_size_type i = collection_size_type(0); i < count; ++i){ + bool b; + ar >> boost::serialization::make_nvp("item", b); + t[i] = b; + } +} + +// split non-intrusive serialization function member into separate +// non intrusive save/load member functions +template<class Archive, class Allocator> +inline void serialize( + Archive & ar, + std::vector<bool, Allocator> & t, + const unsigned int file_version +){ + boost::serialization::split_free(ar, t, file_version); +} + +} // serialization +} // namespace boost + +#include <boost/serialization/collection_traits.hpp> + +BOOST_SERIALIZATION_COLLECTION_TRAITS(std::vector) +#undef STD + +#endif // BOOST_SERIALIZATION_VECTOR_HPP diff --git a/src/third_party/boost-1.69.0/boost/serialization/version.hpp b/src/third_party/boost-1.69.0/boost/serialization/version.hpp new file mode 100644 index 00000000000..21a74d73daa --- /dev/null +++ b/src/third_party/boost-1.69.0/boost/serialization/version.hpp @@ -0,0 +1,107 @@ +#ifndef BOOST_SERIALIZATION_VERSION_HPP +#define BOOST_SERIALIZATION_VERSION_HPP + +// MS compatible compilers support #pragma once +#if defined(_MSC_VER) +# pragma once +#endif + +/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8 +// version.hpp: + +// (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> +#include <boost/mpl/assert.hpp> +#include <boost/mpl/int.hpp> +#include <boost/mpl/eval_if.hpp> +#include <boost/mpl/identity.hpp> +#include <boost/mpl/integral_c_tag.hpp> + +#include <boost/type_traits/is_base_and_derived.hpp> + +namespace boost { +namespace serialization { + +struct basic_traits; + +// default version number is 0. Override with higher version +// when class definition changes. +template<class T> +struct version +{ + template<class U> + struct traits_class_version { + typedef typename U::version type; + }; + + typedef mpl::integral_c_tag tag; + // note: at least one compiler complained w/o the full qualification + // on basic traits below + typedef + typename mpl::eval_if< + is_base_and_derived<boost::serialization::basic_traits,T>, + traits_class_version< T >, + mpl::int_<0> + >::type type; + BOOST_STATIC_CONSTANT(int, value = version::type::value); +}; + +#ifndef BOOST_NO_INCLASS_MEMBER_INITIALIZATION +template<class T> +const int version<T>::value; +#endif + +} // namespace serialization +} // namespace boost + +/* note: at first it seemed that this would be a good place to trap + * as an error an attempt to set a version # for a class which doesn't + * save its class information (including version #) in the archive. + * However, this imposes a requirement that the version be set after + * the implemention level which would be pretty confusing. If this + * is to be done, do this check in the input or output operators when + * ALL the serialization traits are available. Included the implementation + * here with this comment as a reminder not to do this! + */ +//#include <boost/serialization/level.hpp> +//#include <boost/mpl/equal_to.hpp> + +#include <boost/mpl/less.hpp> +#include <boost/mpl/comparison.hpp> + +// specify the current version number for the class +// version numbers limited to 8 bits !!! +#define BOOST_CLASS_VERSION(T, N) \ +namespace boost { \ +namespace serialization { \ +template<> \ +struct version<T > \ +{ \ + typedef mpl::int_<N> type; \ + typedef mpl::integral_c_tag tag; \ + BOOST_STATIC_CONSTANT(int, value = version::type::value); \ + BOOST_MPL_ASSERT(( \ + boost::mpl::less< \ + boost::mpl::int_<N>, \ + boost::mpl::int_<256> \ + > \ + )); \ + /* \ + BOOST_MPL_ASSERT(( \ + mpl::equal_to< \ + :implementation_level<T >, \ + mpl::int_<object_class_info> \ + >::value \ + )); \ + */ \ +}; \ +} \ +} + +#endif // BOOST_SERIALIZATION_VERSION_HPP diff --git a/src/third_party/boost-1.69.0/boost/serialization/void_cast.hpp b/src/third_party/boost-1.69.0/boost/serialization/void_cast.hpp new file mode 100644 index 00000000000..97c5fe61ba7 --- /dev/null +++ b/src/third_party/boost-1.69.0/boost/serialization/void_cast.hpp @@ -0,0 +1,299 @@ +#ifndef BOOST_SERIALIZATION_VOID_CAST_HPP +#define BOOST_SERIALIZATION_VOID_CAST_HPP + +// MS compatible compilers support #pragma once +#if defined(_MSC_VER) +# pragma once +#endif + +/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8 +// void_cast.hpp: interface for run-time casting of void pointers. + +// (C) Copyright 2002-2009 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) +// gennadiy.rozental@tfn.com + +// See http://www.boost.org for updates, documentation, and revision history. + +#include <cstddef> // for ptrdiff_t +#include <boost/config.hpp> +#include <boost/noncopyable.hpp> + +#include <boost/serialization/smart_cast.hpp> +#include <boost/serialization/singleton.hpp> +#include <boost/serialization/force_include.hpp> +#include <boost/serialization/type_info_implementation.hpp> +#include <boost/serialization/extended_type_info.hpp> +#include <boost/type_traits/is_virtual_base_of.hpp> +#include <boost/serialization/void_cast_fwd.hpp> + +#include <boost/serialization/config.hpp> +#include <boost/config/abi_prefix.hpp> // must be the last header + +#ifdef BOOST_MSVC +# pragma warning(push) +# pragma warning(disable : 4251 4231 4660 4275) +#endif + +namespace boost { +namespace serialization { + +class extended_type_info; + +// Given a void *, assume that it really points to an instance of one type +// and alter it so that it would point to an instance of a related type. +// Return the altered pointer. If there exists no sequence of casts that +// can transform from_type to to_type, return a NULL. + +BOOST_SERIALIZATION_DECL void const * +void_upcast( + extended_type_info const & derived, + extended_type_info const & base, + void const * const t +); + +inline void * +void_upcast( + extended_type_info const & derived, + extended_type_info const & base, + void * const t +){ + return const_cast<void*>(void_upcast( + derived, + base, + const_cast<void const *>(t) + )); +} + +BOOST_SERIALIZATION_DECL void const * +void_downcast( + extended_type_info const & derived, + extended_type_info const & base, + void const * const t +); + +inline void * +void_downcast( + extended_type_info const & derived, + extended_type_info const & base, + void * const t +){ + return const_cast<void*>(void_downcast( + derived, + base, + const_cast<void const *>(t) + )); +} + +namespace void_cast_detail { + +class BOOST_SYMBOL_VISIBLE void_caster : + private boost::noncopyable +{ + friend + BOOST_SERIALIZATION_DECL void const * + boost::serialization::void_upcast( + extended_type_info const & derived, + extended_type_info const & base, + void const * const + ); + friend + BOOST_SERIALIZATION_DECL void const * + boost::serialization::void_downcast( + extended_type_info const & derived, + extended_type_info const & base, + void const * const + ); +protected: + BOOST_SERIALIZATION_DECL void recursive_register(bool includes_virtual_base = false) const; + BOOST_SERIALIZATION_DECL void recursive_unregister() const; + virtual bool has_virtual_base() const = 0; +public: + // Data members + const extended_type_info * m_derived; + const extended_type_info * m_base; + /*const*/ std::ptrdiff_t m_difference; + void_caster const * const m_parent; + + // note that void_casters are keyed on value of + // member extended type info records - NOT their + // addresses. This is necessary in order for the + // void cast operations to work across dll and exe + // module boundries. + bool operator<(const void_caster & rhs) const; + + const void_caster & operator*(){ + return *this; + } + // each derived class must re-implement these; + virtual void const * upcast(void const * const t) const = 0; + virtual void const * downcast(void const * const t) const = 0; + // Constructor + void_caster( + extended_type_info const * derived, + extended_type_info const * base, + std::ptrdiff_t difference = 0, + void_caster const * const parent = 0 + ) : + m_derived(derived), + m_base(base), + m_difference(difference), + m_parent(parent) + {} + virtual ~void_caster(){} +}; + +#ifdef BOOST_MSVC +# pragma warning(push) +# pragma warning(disable : 4251 4231 4660 4275 4511 4512) +#endif + +template <class Derived, class Base> +class BOOST_SYMBOL_VISIBLE void_caster_primitive : + public void_caster +{ + virtual void const * downcast(void const * const t) const { + const Derived * d = + boost::serialization::smart_cast<const Derived *, const Base *>( + static_cast<const Base *>(t) + ); + return d; + } + virtual void const * upcast(void const * const t) const { + const Base * b = + boost::serialization::smart_cast<const Base *, const Derived *>( + static_cast<const Derived *>(t) + ); + return b; + } + virtual bool has_virtual_base() const { + return false; + } +public: + void_caster_primitive(); + virtual ~void_caster_primitive(); +}; + +template <class Derived, class Base> +void_caster_primitive<Derived, Base>::void_caster_primitive() : + void_caster( + & type_info_implementation<Derived>::type::get_const_instance(), + & type_info_implementation<Base>::type::get_const_instance(), + /* note about displacement: + * displace 0: at least one compiler treated 0 by not shifting it at all + * displace by small value (8): caused ICE on certain mingw gcc versions */ + reinterpret_cast<std::ptrdiff_t>( + static_cast<Derived *>( + reinterpret_cast<Base *>(1 << 20) + ) + ) - (1 << 20) + ) +{ + recursive_register(); +} + +template <class Derived, class Base> +void_caster_primitive<Derived, Base>::~void_caster_primitive(){ + recursive_unregister(); +} + +template <class Derived, class Base> +class BOOST_SYMBOL_VISIBLE void_caster_virtual_base : + public void_caster +{ + virtual bool has_virtual_base() const { + return true; + } +public: + virtual void const * downcast(void const * const t) const { + const Derived * d = + dynamic_cast<const Derived *>( + static_cast<const Base *>(t) + ); + return d; + } + virtual void const * upcast(void const * const t) const { + const Base * b = + dynamic_cast<const Base *>( + static_cast<const Derived *>(t) + ); + return b; + } + void_caster_virtual_base(); + virtual ~void_caster_virtual_base(); +}; + +#ifdef BOOST_MSVC +#pragma warning(pop) +#endif + +template <class Derived, class Base> +void_caster_virtual_base<Derived,Base>::void_caster_virtual_base() : + void_caster( + & (type_info_implementation<Derived>::type::get_const_instance()), + & (type_info_implementation<Base>::type::get_const_instance()) + ) +{ + recursive_register(true); +} + +template <class Derived, class Base> +void_caster_virtual_base<Derived,Base>::~void_caster_virtual_base(){ + recursive_unregister(); +} + +template <class Derived, class Base> +struct BOOST_SYMBOL_VISIBLE void_caster_base : + public void_caster +{ + typedef + typename mpl::eval_if<boost::is_virtual_base_of<Base,Derived>, + mpl::identity< + void_cast_detail::void_caster_virtual_base<Derived, Base> + > + ,// else + mpl::identity< + void_cast_detail::void_caster_primitive<Derived, Base> + > + >::type type; +}; + +} // void_cast_detail + +template<class Derived, class Base> +BOOST_DLLEXPORT +inline const void_cast_detail::void_caster & void_cast_register( + Derived const * /* dnull = NULL */, + Base const * /* bnull = NULL */ +){ + typedef + typename mpl::eval_if<boost::is_virtual_base_of<Base,Derived>, + mpl::identity< + void_cast_detail::void_caster_virtual_base<Derived, Base> + > + ,// else + mpl::identity< + void_cast_detail::void_caster_primitive<Derived, Base> + > + >::type typex; + return singleton<typex>::get_const_instance(); +} + +template<class Derived, class Base> +class BOOST_SYMBOL_VISIBLE void_caster : + public void_cast_detail::void_caster_base<Derived, Base>::type +{ +}; + +} // namespace serialization +} // namespace boost + +#ifdef BOOST_MSVC +# pragma warning(pop) +#endif + +#include <boost/config/abi_suffix.hpp> // pops abi_suffix.hpp pragmas + +#endif // BOOST_SERIALIZATION_VOID_CAST_HPP diff --git a/src/third_party/boost-1.69.0/boost/serialization/void_cast_fwd.hpp b/src/third_party/boost-1.69.0/boost/serialization/void_cast_fwd.hpp new file mode 100644 index 00000000000..def61d52bb7 --- /dev/null +++ b/src/third_party/boost-1.69.0/boost/serialization/void_cast_fwd.hpp @@ -0,0 +1,37 @@ +#ifndef BOOST_SERIALIZATION_VOID_CAST_FWD_HPP +#define BOOST_SERIALIZATION_VOID_CAST_FWD_HPP + +// MS compatible compilers support #pragma once +#if defined(_MSC_VER) +# pragma once +#endif + +/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8 +// void_cast_fwd.hpp: interface for run-time casting of void pointers. + +// (C) Copyright 2005 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) +// gennadiy.rozental@tfn.com + +// See http://www.boost.org for updates, documentation, and revision history. + +#include <cstddef> // NULL +#include <boost/serialization/force_include.hpp> + +namespace boost { +namespace serialization { +namespace void_cast_detail{ +class void_caster; +} // namespace void_cast_detail +template<class Derived, class Base> +BOOST_DLLEXPORT +inline const void_cast_detail::void_caster & void_cast_register( + const Derived * dnull = NULL, + const Base * bnull = NULL +) BOOST_USED; +} // namespace serialization +} // namespace boost + +#endif // BOOST_SERIALIZATION_VOID_CAST_HPP diff --git a/src/third_party/boost-1.69.0/boost/serialization/wrapper.hpp b/src/third_party/boost-1.69.0/boost/serialization/wrapper.hpp new file mode 100644 index 00000000000..60d7910b17a --- /dev/null +++ b/src/third_party/boost-1.69.0/boost/serialization/wrapper.hpp @@ -0,0 +1,60 @@ +#ifndef BOOST_SERIALIZATION_WRAPPER_HPP +#define BOOST_SERIALIZATION_WRAPPER_HPP + +// (C) Copyright 2005-2006 Matthias Troyer +// 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) + +#include <boost/serialization/traits.hpp> +#include <boost/type_traits/is_base_and_derived.hpp> +#include <boost/mpl/eval_if.hpp> +#include <boost/mpl/bool_fwd.hpp> + +namespace boost { namespace serialization { + +/// the base class for serialization wrappers +/// +/// wrappers need to be treated differently at various places in the serialization library, +/// e.g. saving of non-const wrappers has to be possible. Since partial specialization +// is not supported by all compilers, we derive all wrappers from wrapper_traits. + +template< + class T, + int Level = object_serializable, + int Tracking = track_never, + unsigned int Version = 0, + class ETII = extended_type_info_impl< T > +> +struct wrapper_traits : + public traits<T,Level,Tracking,Version,ETII,mpl::true_> +{}; + +template<class T> +struct is_wrapper_impl : + boost::mpl::eval_if< + boost::is_base_and_derived<basic_traits,T>, + boost::mpl::true_, + boost::mpl::false_ + >::type +{}; + +template<class T> +struct is_wrapper { + typedef typename is_wrapper_impl<const T>::type type; +}; + +} // serialization +} // boost + +// A macro to define that a class is a wrapper +#define BOOST_CLASS_IS_WRAPPER(T) \ +namespace boost { \ +namespace serialization { \ +template<> \ +struct is_wrapper_impl<const T> : boost::mpl::true_ {}; \ +} \ +} \ +/**/ + +#endif //BOOST_SERIALIZATION_WRAPPER_HPP |