Swiftdiff options
| author | Tobias Markmann <tm@ayena.de> | 2014-10-19 20:22:58 (GMT) |
|---|---|---|
| committer | Tobias Markmann <tm@ayena.de> | 2014-10-20 13:49:33 (GMT) |
| commit | 6b22dfcf59474dd016a0355a3102a1dd3692d92c (patch) | |
| tree | 2b1fd33be433a91e81fee84fdc2bf1b52575d934 /3rdParty/Boost/src/boost/serialization | |
| parent | 38b0cb785fea8eae5e48fae56440695fdfd10ee1 (diff) | |
| download | swift-contrib-6b22dfcf59474dd016a0355a3102a1dd3692d92c.zip swift-contrib-6b22dfcf59474dd016a0355a3102a1dd3692d92c.tar.bz2 | |
Update Boost in 3rdParty to version 1.56.0.
This updates Boost in our 3rdParty directory to version 1.56.0.
Updated our update.sh script to stop on error.
Changed error reporting in SwiftTools/CrashReporter.cpp to SWIFT_LOG due to
missing include of <iostream> with newer Boost.
Change-Id: I4b35c77de951333979a524097f35f5f83d325edc
Diffstat (limited to '3rdParty/Boost/src/boost/serialization')
49 files changed, 495 insertions, 1648 deletions
diff --git a/3rdParty/Boost/src/boost/serialization/access.hpp b/3rdParty/Boost/src/boost/serialization/access.hpp index 40256d6..ec88ff5 100644 --- a/3rdParty/Boost/src/boost/serialization/access.hpp +++ b/3rdParty/Boost/src/boost/serialization/access.hpp @@ -1,40 +1,40 @@ #ifndef BOOST_SERIALIZATION_ACCESS_HPP #define BOOST_SERIALIZATION_ACCESS_HPP // MS compatible compilers support #pragma once -#if defined(_MSC_VER) && (_MSC_VER >= 1020) +#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> #include <boost/serialization/pfto.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> diff --git a/3rdParty/Boost/src/boost/serialization/array.hpp b/3rdParty/Boost/src/boost/serialization/array.hpp index 3391a96..35c640c 100644 --- a/3rdParty/Boost/src/boost/serialization/array.hpp +++ b/3rdParty/Boost/src/boost/serialization/array.hpp @@ -1,47 +1,51 @@ #ifndef BOOST_SERIALIZATION_ARRAY_HPP #define BOOST_SERIALIZATION_ARRAY_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 + #include <iostream> #include <cstddef> // std::size_t -#include <cstddef> -#include <boost/config.hpp> // msvc 6.0 needs this for warning suppression +#ifndef BOOST_NO_CXX11_HDR_ARRAY +#include <array> +#endif + #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/mpl/always.hpp> #include <boost/mpl/apply.hpp> #include <boost/mpl/bool.hpp> #include <boost/type_traits/remove_const.hpp> #include <boost/array.hpp> namespace boost { namespace serialization { // traits to specify whether to use an optimized array serialization #ifdef __BORLANDC__ // workaround for Borland compiler template <class Archive> struct use_array_optimization { template <class T> struct apply : boost::mpl::false_ {}; }; #else template <class Archive> struct use_array_optimization : boost::mpl::always<boost::mpl::false_> {}; #endif template<class T> class array : public wrapper_traits<const array< T > > { @@ -65,89 +69,103 @@ public: template<class Archive> void serialize_optimized(Archive &ar, const unsigned int, mpl::false_ ) const { // default implemention does the loop std::size_t c = count(); value_type * 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 BOOST_DEDUCED_TYPENAME + typedef typename boost::serialization::use_array_optimization<Archive>::template apply< - BOOST_DEDUCED_TYPENAME remove_const< T >::type + typename remove_const< T >::type >::type use_optimized; serialize_optimized(ar,version,use_optimized()); } value_type* address() const { return m_t; } std::size_t count() const { return m_element_count; } private: value_type* m_t; std::size_t m_element_count; }; template<class T> inline #ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING const #endif array< T > make_array( T* t, std::size_t s){ return array< T >(t, s); } +// implement serialization for boost::array template <class Archive, class T, std::size_t N> void serialize(Archive& ar, boost::array<T,N>& a, const unsigned int /* version */) { - ar & boost::serialization::make_nvp("elems",a.elems); + ar & boost::serialization::make_nvp("elems", a.elems); } +#ifndef BOOST_NO_CXX11_HDR_ARRAY +// implement serialization for std::array +template <class Archive, class T, std::size_t N> +void serialize(Archive& ar, std::array<T,N>& a, const unsigned int /* version */) +{ + ar & boost::serialization::make_nvp( + "elems", + *static_cast<T (*)[N]>(static_cast<void *>(a.data())) + ); + +} +#endif + } } // end namespace boost::serialization #ifdef __BORLANDC__ // ignore optimizations for Borland #define BOOST_SERIALIZATION_USE_ARRAY_OPTIMIZATION(Archive) #else #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 \ - , BOOST_DEDUCED_TYPENAME boost::remove_const<ValueType>::type \ + , typename boost::remove_const<ValueType>::type \ >::type {}; \ }; }} #endif // __BORLANDC__ #endif //BOOST_SERIALIZATION_ARRAY_HPP diff --git a/3rdParty/Boost/src/boost/serialization/assume_abstract.hpp b/3rdParty/Boost/src/boost/serialization/assume_abstract.hpp index 4a8123a..a5cb2f5 100644 --- a/3rdParty/Boost/src/boost/serialization/assume_abstract.hpp +++ b/3rdParty/Boost/src/boost/serialization/assume_abstract.hpp @@ -1,40 +1,40 @@ #ifndef BOOST_SERIALIZATION_ASSUME_ABSTRACT_HPP #define BOOST_SERIALIZATION_ASSUME_ABSTRACT_HPP // MS compatible compilers support #pragma once -#if defined(_MSC_VER) && (_MSC_VER >= 1020) +#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> #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 { diff --git a/3rdParty/Boost/src/boost/serialization/base_object.hpp b/3rdParty/Boost/src/boost/serialization/base_object.hpp index b840d25..562dbd5 100644 --- a/3rdParty/Boost/src/boost/serialization/base_object.hpp +++ b/3rdParty/Boost/src/boost/serialization/base_object.hpp @@ -1,112 +1,112 @@ #ifndef BOOST_SERIALIZATION_BASE_OBJECT_HPP #define BOOST_SERIALIZATION_BASE_OBJECT_HPP // MS compatible compilers support #pragma once -#if defined(_MSC_VER) && (_MSC_VER >= 1020) +#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/bool.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 BOOST_DEDUCED_TYPENAME + 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 BOOST_DEDUCED_TYPENAME mpl::eval_if< + typedef typename mpl::eval_if< is_polymorphic<Base>, mpl::identity<polymorphic>, mpl::identity<non_polymorphic> >::type type; return type::invoke(); } }; } // namespace detail #if defined(__BORLANDC__) && __BORLANDC__ < 0x610 template<class Base, class Derived> const Base & base_object(const Derived & d) { BOOST_STATIC_ASSERT(! is_pointer<Derived>::value); detail::base_register<Base, Derived>::invoke(); return access::cast_reference<const Base, Derived>(d); } #else template<class Base, class Derived> -BOOST_DEDUCED_TYPENAME detail::base_cast<Base, Derived>::type & +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 BOOST_DEDUCED_TYPENAME detail::base_cast<Base, Derived>::type type; + typedef typename detail::base_cast<Base, Derived>::type type; detail::base_register<type, Derived>::invoke(); return access::cast_reference<type, Derived>(d); } #endif } // namespace serialization } // namespace boost #endif // BOOST_SERIALIZATION_BASE_OBJECT_HPP diff --git a/3rdParty/Boost/src/boost/serialization/collection_traits.hpp b/3rdParty/Boost/src/boost/serialization/collection_traits.hpp index 60453c7..b3fe843 100644 --- a/3rdParty/Boost/src/boost/serialization/collection_traits.hpp +++ b/3rdParty/Boost/src/boost/serialization/collection_traits.hpp @@ -1,40 +1,40 @@ #ifndef BOOST_SERIALIZATION_COLLECTION_TRAITS_HPP #define BOOST_SERIALIZATION_COLLECTION_TRAITS_HPP // MS compatible compilers support #pragma once -#if defined(_MSC_VER) && (_MSC_VER >= 1020) +#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); \ }; \ diff --git a/3rdParty/Boost/src/boost/serialization/collections_load_imp.hpp b/3rdParty/Boost/src/boost/serialization/collections_load_imp.hpp index 11b00cd..2291e74 100644 --- a/3rdParty/Boost/src/boost/serialization/collections_load_imp.hpp +++ b/3rdParty/Boost/src/boost/serialization/collections_load_imp.hpp @@ -1,166 +1,166 @@ #ifndef BOOST_SERIALIZATION_COLLECTIONS_LOAD_IMP_HPP #define BOOST_SERIALIZATION_COLLECTIONS_LOAD_IMP_HPP // MS compatible compilers support #pragma once -#if defined(_MSC_VER) && (_MSC_VER >= 1020) +#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> namespace boost{ namespace serialization { namespace stl { ////////////////////////////////////////////////////////////////////// // implementation of serialization for STL containers // // sequential container input template<class Archive, class Container> struct archive_input_seq { - inline BOOST_DEDUCED_TYPENAME Container::iterator + inline typename Container::iterator operator()( Archive &ar, Container &s, const unsigned int v, - BOOST_DEDUCED_TYPENAME Container::iterator hint + typename Container::iterator hint ){ - typedef BOOST_DEDUCED_TYPENAME Container::value_type type; + typedef typename Container::value_type type; detail::stack_construct<Archive, type> t(ar, v); // borland fails silently w/o full namespace ar >> boost::serialization::make_nvp("item", t.reference()); s.push_back(t.reference()); ar.reset_object_address(& s.back() , & t.reference()); return hint; } }; // map input template<class Archive, class Container> struct archive_input_map { - inline BOOST_DEDUCED_TYPENAME Container::iterator + inline typename Container::iterator operator()( Archive &ar, Container &s, const unsigned int v, - BOOST_DEDUCED_TYPENAME Container::iterator hint + typename Container::iterator hint ){ - typedef BOOST_DEDUCED_TYPENAME Container::value_type type; + typedef typename Container::value_type type; detail::stack_construct<Archive, type> t(ar, v); // borland fails silently w/o full namespace ar >> boost::serialization::make_nvp("item", t.reference()); - BOOST_DEDUCED_TYPENAME Container::iterator result = + typename Container::iterator result = s.insert(hint, t.reference()); // note: the following presumes that the map::value_type was NOT tracked // in the archive. This is the usual case, but here there is no way // to determine that. ar.reset_object_address( & (result->second), & t.reference().second ); return result; } }; // set input template<class Archive, class Container> struct archive_input_set { - inline BOOST_DEDUCED_TYPENAME Container::iterator + inline typename Container::iterator operator()( Archive &ar, Container &s, const unsigned int v, - BOOST_DEDUCED_TYPENAME Container::iterator hint + typename Container::iterator hint ){ - typedef BOOST_DEDUCED_TYPENAME Container::value_type type; + typedef typename Container::value_type type; detail::stack_construct<Archive, type> t(ar, v); // borland fails silently w/o full namespace ar >> boost::serialization::make_nvp("item", t.reference()); - BOOST_DEDUCED_TYPENAME Container::iterator result = + typename Container::iterator result = s.insert(hint, t.reference()); ar.reset_object_address(& (* result), & t.reference()); return result; } }; template<class Container> class reserve_imp { public: void operator()(Container &s, std::size_t count) const { s.reserve(count); } }; template<class Container> class no_reserve_imp { public: void operator()(Container & /* s */, std::size_t /* count */) const{} }; template<class Archive, class Container, class InputFunction, class R> inline void load_collection(Archive & ar, Container &s) { s.clear(); - collection_size_type count; 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); } R rx; rx(s, count); InputFunction ifunc; - BOOST_DEDUCED_TYPENAME Container::iterator hint; + typename Container::iterator hint; hint = s.begin(); while(count-- > 0){ hint = ifunc(ar, s, item_version, hint); } } } // namespace stl } // namespace serialization } // namespace boost #endif //BOOST_SERIALIZATION_COLLECTIONS_LOAD_IMP_HPP diff --git a/3rdParty/Boost/src/boost/serialization/collections_save_imp.hpp b/3rdParty/Boost/src/boost/serialization/collections_save_imp.hpp index 5151c4b..f3cabfc 100644 --- a/3rdParty/Boost/src/boost/serialization/collections_save_imp.hpp +++ b/3rdParty/Boost/src/boost/serialization/collections_save_imp.hpp @@ -1,72 +1,82 @@ #ifndef BOOST_SERIALIZATION_COLLECTIONS_SAVE_IMP_HPP #define BOOST_SERIALIZATION_COLLECTIONS_SAVE_IMP_HPP // MS compatible compilers support #pragma once -#if defined(_MSC_VER) && (_MSC_VER >= 1020) +#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/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) +inline void save_collection( + Archive & ar, + const Container &s, + collection_size_type count) { + ar << BOOST_SERIALIZATION_NVP(count); // record number of elements - collection_size_type count(s.size()); const item_version_type item_version( - version<BOOST_DEDUCED_TYPENAME Container::value_type>::value + version<typename Container::value_type>::value ); - ar << BOOST_SERIALIZATION_NVP(count); #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 - BOOST_DEDUCED_TYPENAME Container::const_iterator it = s.begin(); + 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, &(*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/3rdParty/Boost/src/boost/serialization/detail/get_data.hpp b/3rdParty/Boost/src/boost/serialization/detail/get_data.hpp index 3cbcb4a..da89213 100644 --- a/3rdParty/Boost/src/boost/serialization/detail/get_data.hpp +++ b/3rdParty/Boost/src/boost/serialization/detail/get_data.hpp @@ -1,47 +1,47 @@ // (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. #ifndef BOOST_SERIALIZATION_DETAIL_GET_DATA_HPP #define BOOST_SERIALIZATION_DETAIL_GET_DATA_HPP // MS compatible compilers support #pragma once -#if defined(_MSC_VER) && (_MSC_VER >= 1020) +#if defined(_MSC_VER) # pragma once #endif #if defined(__SGI_STL_PORT) || defined(_STLPORT_VERSION) #define STD _STLP_STD #else #define STD std #endif #include <vector> #include <valarray> namespace boost { namespace serialization { namespace detail { template <class T, class Allocator> T* get_data(STD::vector<T,Allocator>& v) { return v.empty() ? 0 : &(v[0]); } template <class T, class Allocator> T* get_data(STD::vector<T,Allocator> const & v) { return get_data(const_cast<STD::vector<T,Allocator>&>(v)); } template <class T> T* get_data(STD::valarray<T>& v) { return v.size()==0 ? 0 : &(v[0]); } template <class T> diff --git a/3rdParty/Boost/src/boost/serialization/detail/shared_count_132.hpp b/3rdParty/Boost/src/boost/serialization/detail/shared_count_132.hpp deleted file mode 100644 index c42355b..0000000 --- a/3rdParty/Boost/src/boost/serialization/detail/shared_count_132.hpp +++ /dev/null @@ -1,569 +0,0 @@ -#ifndef BOOST_DETAIL_SHARED_COUNT_132_HPP_INCLUDED -#define BOOST_DETAIL_SHARED_COUNT_132_HPP_INCLUDED - -// MS compatible compilers support #pragma once - -#if defined(_MSC_VER) && (_MSC_VER >= 1020) -# pragma once -#endif - -// -// detail/shared_count.hpp -// -// Copyright (c) 2001, 2002, 2003 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> - -#if defined(BOOST_SP_USE_STD_ALLOCATOR) && defined(BOOST_SP_USE_QUICK_ALLOCATOR) -# error BOOST_SP_USE_STD_ALLOCATOR and BOOST_SP_USE_QUICK_ALLOCATOR are incompatible. -#endif - -#include <boost/checked_delete.hpp> -#include <boost/serialization/throw_exception.hpp> -#include <boost/detail/lightweight_mutex.hpp> - -#if defined(BOOST_SP_USE_QUICK_ALLOCATOR) -#include <boost/detail/quick_allocator.hpp> -#endif - -#include <memory> // std::auto_ptr, std::allocator -#include <functional> // std::less -#include <exception> // std::exception -#include <new> // std::bad_alloc -#include <typeinfo> // std::type_info in get_deleter -#include <cstddef> // std::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 - -#ifdef __BORLANDC__ -# pragma warn -8026 // Functions with excep. spec. are not expanded inline -# pragma warn -8027 // Functions containing try are not expanded inline -#endif - -namespace boost_132 { - -// Debug hooks - -#if defined(BOOST_SP_ENABLE_DEBUG_HOOKS) - -void sp_scalar_constructor_hook(void * px, std::size_t size, void * pn); -void sp_array_constructor_hook(void * px); -void sp_scalar_destructor_hook(void * px, std::size_t size, void * pn); -void sp_array_destructor_hook(void * px); - -#endif - - -// The standard library that comes with Borland C++ 5.5.1 -// defines std::exception and its members as having C calling -// convention (-pc). When the definition of bad_weak_ptr -// is compiled with -ps, the compiler issues an error. -// Hence, the temporary #pragma option -pc below. The version -// check is deliberately conservative. - -#if defined(__BORLANDC__) && __BORLANDC__ == 0x551 -# pragma option push -pc -#endif - -class bad_weak_ptr: public std::exception -{ -public: - - virtual char const * what() const throw() - { - return "boost::bad_weak_ptr"; - } -}; - -#if defined(__BORLANDC__) && __BORLANDC__ == 0x551 -# pragma option pop -#endif - -namespace detail{ - -class sp_counted_base -{ -//private: - - typedef boost::detail::lightweight_mutex mutex_type; - -public: - - sp_counted_base(): use_count_(1), weak_count_(1) - { - } - - virtual ~sp_counted_base() // nothrow - { - } - - // dispose() is called when use_count_ drops to zero, to release - // the resources managed by *this. - - virtual void dispose() = 0; // nothrow - - // destruct() is called when weak_count_ drops to zero. - - virtual void destruct() // nothrow - { - delete this; - } - - virtual void * get_deleter(std::type_info const & ti) = 0; - - void add_ref_copy() - { -#if defined(BOOST_HAS_THREADS) - mutex_type::scoped_lock lock(mtx_); -#endif - ++use_count_; - } - - void add_ref_lock() - { -#if defined(BOOST_HAS_THREADS) - mutex_type::scoped_lock lock(mtx_); -#endif - if(use_count_ == 0) boost::serialization::throw_exception(bad_weak_ptr()); - ++use_count_; - } - - void release() // nothrow - { - { -#if defined(BOOST_HAS_THREADS) - mutex_type::scoped_lock lock(mtx_); -#endif - long new_use_count = --use_count_; - - if(new_use_count != 0) return; - } - - dispose(); - weak_release(); - } - - void weak_add_ref() // nothrow - { -#if defined(BOOST_HAS_THREADS) - mutex_type::scoped_lock lock(mtx_); -#endif - ++weak_count_; - } - - void weak_release() // nothrow - { - long new_weak_count; - - { -#if defined(BOOST_HAS_THREADS) - mutex_type::scoped_lock lock(mtx_); -#endif - new_weak_count = --weak_count_; - } - - if(new_weak_count == 0) - { - destruct(); - } - } - - long use_count() const // nothrow - { -#if defined(BOOST_HAS_THREADS) - mutex_type::scoped_lock lock(mtx_); -#endif - return use_count_; - } - -//private: -public: - sp_counted_base(sp_counted_base const &); - sp_counted_base & operator= (sp_counted_base const &); - - long use_count_; // #shared - long weak_count_; // #weak + (#shared != 0) - -#if defined(BOOST_HAS_THREADS) || defined(BOOST_LWM_WIN32) - mutable mutex_type mtx_; -#endif -}; - -#if defined(BOOST_SP_ENABLE_DEBUG_HOOKS) - -template<class T> void cbi_call_constructor_hook(sp_counted_base * pn, T * px, checked_deleter< T > const &, int) -{ - boost::sp_scalar_constructor_hook(px, sizeof(T), pn); -} - -template<class T> void cbi_call_constructor_hook(sp_counted_base *, T * px, checked_array_deleter< T > const &, int) -{ - boost::sp_array_constructor_hook(px); -} - -template<class P, class D> void cbi_call_constructor_hook(sp_counted_base *, P const &, D const &, long) -{ -} - -template<class T> void cbi_call_destructor_hook(sp_counted_base * pn, T * px, checked_deleter< T > const &, int) -{ - boost::sp_scalar_destructor_hook(px, sizeof(T), pn); -} - -template<class T> void cbi_call_destructor_hook(sp_counted_base *, T * px, checked_array_deleter< T > const &, int) -{ - boost::sp_array_destructor_hook(px); -} - -template<class P, class D> void cbi_call_destructor_hook(sp_counted_base *, P const &, D const &, long) -{ -} - -#endif - -// -// Borland's Codeguard trips up over the -Vx- option here: -// -#ifdef __CODEGUARD__ -# pragma option push -Vx- -#endif - -template<class P, class D> class sp_counted_base_impl: public sp_counted_base -{ -//private: -public: - P ptr; // copy constructor must not throw - D del; // copy constructor must not throw - - sp_counted_base_impl(sp_counted_base_impl const &); - sp_counted_base_impl & operator= (sp_counted_base_impl const &); - - typedef sp_counted_base_impl<P, D> this_type; - -public: - - // pre: initial_use_count <= initial_weak_count, d(p) must not throw - - sp_counted_base_impl(P p, D d): ptr(p), del(d) - { -#if defined(BOOST_SP_ENABLE_DEBUG_HOOKS) - detail::cbi_call_constructor_hook(this, p, d, 0); -#endif - } - - virtual void dispose() // nothrow - { -#if defined(BOOST_SP_ENABLE_DEBUG_HOOKS) - detail::cbi_call_destructor_hook(this, ptr, del, 0); -#endif - del(ptr); - } - - virtual void * get_deleter(std::type_info const & ti) - { - return ti == typeid(D)? &del: 0; - } - -#if defined(BOOST_SP_USE_STD_ALLOCATOR) - - void * operator new(std::size_t) - { - return std::allocator<this_type>().allocate(1, static_cast<this_type *>(0)); - } - - void operator delete(void * p) - { - std::allocator<this_type>().deallocate(static_cast<this_type *>(p), 1); - } - -#endif - -#if defined(BOOST_SP_USE_QUICK_ALLOCATOR) - - void * operator new(std::size_t) - { - return boost::detail::quick_allocator<this_type>::alloc(); - } - - void operator delete(void * p) - { - boost::detail::quick_allocator<this_type>::dealloc(p); - } - -#endif -}; - -#if defined(BOOST_SP_ENABLE_DEBUG_HOOKS) - -int const shared_count_id = 0x2C35F101; -int const weak_count_id = 0x298C38A4; - -#endif - -class weak_count; - -class shared_count -{ -//private: -public: - sp_counted_base * pi_; - -#if defined(BOOST_SP_ENABLE_DEBUG_HOOKS) - int id_; -#endif - - friend class weak_count; - -public: - - shared_count(): pi_(0) // nothrow -#if defined(BOOST_SP_ENABLE_DEBUG_HOOKS) - , id_(shared_count_id) -#endif - { - } - - template<class P, class D> shared_count(P p, D d): pi_(0) -#if defined(BOOST_SP_ENABLE_DEBUG_HOOKS) - , id_(shared_count_id) -#endif - { -#ifndef BOOST_NO_EXCEPTIONS - - try - { - pi_ = new sp_counted_base_impl<P, D>(p, d); - } - catch(...) - { - d(p); // delete p - throw; - } - -#else - - pi_ = new sp_counted_base_impl<P, D>(p, d); - - if(pi_ == 0) - { - d(p); // delete p - boost::serialization::throw_exception(std::bad_alloc()); - } - -#endif - } - -#ifndef BOOST_NO_AUTO_PTR - - // auto_ptr<Y> is special cased to provide the strong guarantee - - template<class Y> - explicit shared_count(std::auto_ptr<Y> & r): pi_( - new sp_counted_base_impl< - Y *, - boost::checked_deleter<Y> - >(r.get(), boost::checked_deleter<Y>())) -#if defined(BOOST_SP_ENABLE_DEBUG_HOOKS) - , id_(shared_count_id) -#endif - { - r.release(); - } - -#endif - - ~shared_count() // nothrow - { - if(pi_ != 0) pi_->release(); -#if defined(BOOST_SP_ENABLE_DEBUG_HOOKS) - id_ = 0; -#endif - } - - shared_count(shared_count const & r): pi_(r.pi_) // nothrow -#if defined(BOOST_SP_ENABLE_DEBUG_HOOKS) - , id_(shared_count_id) -#endif - { - if(pi_ != 0) pi_->add_ref_copy(); - } - - explicit shared_count(weak_count const & r); // throws bad_weak_ptr when r.use_count() == 0 - - shared_count & operator= (shared_count const & r) // nothrow - { - sp_counted_base * tmp = r.pi_; - - if(tmp != pi_) - { - if(tmp != 0) tmp->add_ref_copy(); - if(pi_ != 0) pi_->release(); - pi_ = tmp; - } - - return *this; - } - - void swap(shared_count & r) // nothrow - { - sp_counted_base * tmp = r.pi_; - r.pi_ = pi_; - pi_ = tmp; - } - - long use_count() const // nothrow - { - return pi_ != 0? pi_->use_count(): 0; - } - - bool unique() const // nothrow - { - return use_count() == 1; - } - - friend inline bool operator==(shared_count const & a, shared_count const & b) - { - return a.pi_ == b.pi_; - } - - friend inline bool operator<(shared_count const & a, shared_count const & b) - { - return std::less<sp_counted_base *>()(a.pi_, b.pi_); - } - - void * get_deleter(std::type_info const & ti) const - { - return pi_? pi_->get_deleter(ti): 0; - } -}; - -#ifdef __CODEGUARD__ -# pragma option pop -#endif - - -class weak_count -{ -private: - - sp_counted_base * pi_; - -#if defined(BOOST_SP_ENABLE_DEBUG_HOOKS) - int id_; -#endif - - friend class shared_count; - -public: - - weak_count(): pi_(0) // nothrow -#if defined(BOOST_SP_ENABLE_DEBUG_HOOKS) - , id_(weak_count_id) -#endif - { - } - - weak_count(shared_count const & r): pi_(r.pi_) // nothrow -#if defined(BOOST_SP_ENABLE_DEBUG_HOOKS) - , id_(shared_count_id) -#endif - { - if(pi_ != 0) pi_->weak_add_ref(); - } - - weak_count(weak_count const & r): pi_(r.pi_) // nothrow -#if defined(BOOST_SP_ENABLE_DEBUG_HOOKS) - , id_(shared_count_id) -#endif - { - if(pi_ != 0) pi_->weak_add_ref(); - } - - ~weak_count() // nothrow - { - if(pi_ != 0) pi_->weak_release(); -#if defined(BOOST_SP_ENABLE_DEBUG_HOOKS) - id_ = 0; -#endif - } - - weak_count & operator= (shared_count const & r) // nothrow - { - sp_counted_base * tmp = r.pi_; - if(tmp != 0) tmp->weak_add_ref(); - if(pi_ != 0) pi_->weak_release(); - pi_ = tmp; - - return *this; - } - - weak_count & operator= (weak_count const & r) // nothrow - { - sp_counted_base * tmp = r.pi_; - if(tmp != 0) tmp->weak_add_ref(); - if(pi_ != 0) pi_->weak_release(); - pi_ = tmp; - - return *this; - } - - void swap(weak_count & r) // nothrow - { - sp_counted_base * tmp = r.pi_; - r.pi_ = pi_; - pi_ = tmp; - } - - long use_count() const // nothrow - { - return pi_ != 0? pi_->use_count(): 0; - } - - friend inline bool operator==(weak_count const & a, weak_count const & b) - { - return a.pi_ == b.pi_; - } - - friend inline bool operator<(weak_count const & a, weak_count const & b) - { - return std::less<sp_counted_base *>()(a.pi_, b.pi_); - } -}; - -inline shared_count::shared_count(weak_count const & r): pi_(r.pi_) -#if defined(BOOST_SP_ENABLE_DEBUG_HOOKS) - , id_(shared_count_id) -#endif -{ - if(pi_ != 0) - { - pi_->add_ref_lock(); - } - else - { - boost::serialization::throw_exception(bad_weak_ptr()); - } -} - -} // namespace detail - -} // namespace boost - -BOOST_SERIALIZATION_ASSUME_ABSTRACT(boost_132::detail::sp_counted_base) - -#ifdef __BORLANDC__ -# pragma warn .8027 // Functions containing try are not expanded inline -# pragma warn .8026 // Functions with excep. spec. are not expanded inline -#endif - -#endif // #ifndef BOOST_DETAIL_SHARED_COUNT_HPP_INCLUDED diff --git a/3rdParty/Boost/src/boost/serialization/detail/shared_ptr_132.hpp b/3rdParty/Boost/src/boost/serialization/detail/shared_ptr_132.hpp deleted file mode 100644 index b5f2b21..0000000 --- a/3rdParty/Boost/src/boost/serialization/detail/shared_ptr_132.hpp +++ /dev/null @@ -1,478 +0,0 @@ -#ifndef BOOST_SHARED_PTR_132_HPP_INCLUDED -#define BOOST_SHARED_PTR_132_HPP_INCLUDED - -// -// shared_ptr.hpp -// -// (C) Copyright Greg Colvin and Beman Dawes 1998, 1999. -// Copyright (c) 2001, 2002, 2003 Peter Dimov -// -// 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) -// -// See http://www.boost.org/libs/smart_ptr/shared_ptr.htm for documentation. -// - -#include <boost/config.hpp> // for broken compiler workarounds - -#if defined(BOOST_NO_MEMBER_TEMPLATES) && !defined(BOOST_MSVC6_MEMBER_TEMPLATES) -#include <boost/serialization/detail/shared_ptr_nmt_132.hpp> -#else - -#include <boost/assert.hpp> -#include <boost/checked_delete.hpp> -#include <boost/serialization/throw_exception.hpp> -#include <boost/detail/workaround.hpp> - -#include <boost/serialization/access.hpp> -#include <boost/serialization/detail/shared_count_132.hpp> - -#include <memory> // for std::auto_ptr -#include <algorithm> // for std::swap -#include <functional> // for std::less -#include <typeinfo> // for std::bad_cast -#include <iosfwd> // for std::basic_ostream - -#ifdef BOOST_MSVC // moved here to work around VC++ compiler crash -# pragma warning(push) -# pragma warning(disable:4284) // odd return type for operator-> -#endif - -namespace boost_132 { - -template<class T> class weak_ptr; -template<class T> class enable_shared_from_this; - -namespace detail -{ - -struct static_cast_tag {}; -struct const_cast_tag {}; -struct dynamic_cast_tag {}; -struct polymorphic_cast_tag {}; - -template<class T> struct shared_ptr_traits -{ - typedef T & reference; -}; - -template<> struct shared_ptr_traits<void> -{ - typedef void reference; -}; - -#if !defined(BOOST_NO_CV_VOID_SPECIALIZATIONS) - -template<> struct shared_ptr_traits<void const> -{ - typedef void reference; -}; - -template<> struct shared_ptr_traits<void volatile> -{ - typedef void reference; -}; - -template<> struct shared_ptr_traits<void const volatile> -{ - typedef void reference; -}; - -#endif - -// enable_shared_from_this support - -template<class T, class Y> void sp_enable_shared_from_this( shared_count const & pn, enable_shared_from_this< T > const * pe, Y const * px ) -{ - if(pe != 0) pe->_internal_weak_this._internal_assign(const_cast<Y*>(px), pn); -} - -inline void sp_enable_shared_from_this( shared_count const & /*pn*/, ... ) -{ -} - -} // namespace detail - - -// -// shared_ptr -// -// An enhanced relative of scoped_ptr with reference counted copy semantics. -// The object pointed to is deleted when the last shared_ptr pointing to it -// is destroyed or reset. -// - -template<class T> class shared_ptr -{ -private: - // Borland 5.5.1 specific workaround - typedef shared_ptr< T > this_type; - -public: - - typedef T element_type; - typedef T value_type; - typedef T * pointer; - typedef BOOST_DEDUCED_TYPENAME detail::shared_ptr_traits< T >::reference reference; - - shared_ptr(): px(0), pn() // never throws in 1.30+ - { - } - -#if BOOST_WORKAROUND( __BORLANDC__, BOOST_TESTED_AT( 0x564) ) - template<class Y> - explicit shared_ptr(Y * p): px(p), pn(p, boost::checked_deleter<Y>()) // Y must be complete -#else - template<class Y> - explicit shared_ptr(Y * p): px(p), pn(p, boost::checked_deleter<Y>()) // Y must be complete -#endif - { - detail::sp_enable_shared_from_this( pn, p, p ); - } - - // - // Requirements: D's copy constructor must not throw - // - // shared_ptr will release p by calling d(p) - // - - template<class Y, class D> shared_ptr(Y * p, D d): px(p), pn(p, d) - { - detail::sp_enable_shared_from_this( pn, p, p ); - } - -// generated copy constructor, assignment, destructor are fine... - -// except that Borland C++ has a bug, and g++ with -Wsynth warns -#if defined(__BORLANDC__) || defined(__GNUC__) - - shared_ptr & operator=(shared_ptr const & r) // never throws - { - px = r.px; - pn = r.pn; // shared_count::op= doesn't throw - return *this; - } - -#endif - - template<class Y> - explicit shared_ptr(weak_ptr<Y> const & r): pn(r.pn) // may throw - { - // it is now safe to copy r.px, as pn(r.pn) did not throw - px = r.px; - } - - template<class Y> - shared_ptr(shared_ptr<Y> const & r): px(r.px), pn(r.pn) // never throws - { - } - - template<class Y> - shared_ptr(shared_ptr<Y> const & r, detail::static_cast_tag): px(static_cast<element_type *>(r.px)), pn(r.pn) - { - } - - template<class Y> - shared_ptr(shared_ptr<Y> const & r, detail::const_cast_tag): px(const_cast<element_type *>(r.px)), pn(r.pn) - { - } - - template<class Y> - shared_ptr(shared_ptr<Y> const & r, detail::dynamic_cast_tag): px(dynamic_cast<element_type *>(r.px)), pn(r.pn) - { - if(px == 0) // need to allocate new counter -- the cast failed - { - pn = detail::shared_count(); - } - } - - template<class Y> - shared_ptr(shared_ptr<Y> const & r, detail::polymorphic_cast_tag): px(dynamic_cast<element_type *>(r.px)), pn(r.pn) - { - if(px == 0) - { - boost::serialization::throw_exception(std::bad_cast()); - } - } - -#ifndef BOOST_NO_AUTO_PTR - - template<class Y> - explicit shared_ptr(std::auto_ptr<Y> & r): px(r.get()), pn() - { - Y * tmp = r.get(); - pn = detail::shared_count(r); - detail::sp_enable_shared_from_this( pn, tmp, tmp ); - } - -#endif - -#if !defined(BOOST_MSVC) || (BOOST_MSVC > 1200) - - template<class Y> - shared_ptr & operator=(shared_ptr<Y> const & r) // never throws - { - px = r.px; - pn = r.pn; // shared_count::op= doesn't throw - return *this; - } - -#endif - -#ifndef BOOST_NO_AUTO_PTR - - template<class Y> - shared_ptr & operator=(std::auto_ptr<Y> & r) - { - this_type(r).swap(*this); - return *this; - } - -#endif - - void reset() // never throws in 1.30+ - { - this_type().swap(*this); - } - - template<class Y> void reset(Y * p) // Y must be complete - { - BOOST_ASSERT(p == 0 || p != px); // catch self-reset errors - this_type(p).swap(*this); - } - - template<class Y, class D> void reset(Y * p, D d) - { - this_type(p, d).swap(*this); - } - - reference operator* () const // never throws - { - BOOST_ASSERT(px != 0); - return *px; - } - - T * operator-> () const // never throws - { - BOOST_ASSERT(px != 0); - return px; - } - - T * get() const // never throws - { - return px; - } - - // implicit conversion to "bool" - -#if defined(__SUNPRO_CC) && BOOST_WORKAROUND(__SUNPRO_CC, <= 0x530) - - operator bool () const - { - return px != 0; - } - -#elif defined(__MWERKS__) && BOOST_WORKAROUND(__MWERKS__, BOOST_TESTED_AT(0x3003)) - typedef T * (this_type::*unspecified_bool_type)() const; - - operator unspecified_bool_type() const // never throws - { - return px == 0? 0: &this_type::get; - } - -#else - - typedef T * this_type::*unspecified_bool_type; - - operator unspecified_bool_type() const // never throws - { - return px == 0? 0: &this_type::px; - } - -#endif - - // operator! is redundant, but some compilers need it - - bool operator! () const // never throws - { - return px == 0; - } - - bool unique() const // never throws - { - return pn.unique(); - } - - long use_count() const // never throws - { - return pn.use_count(); - } - - void swap(shared_ptr< T > & other) // never throws - { - std::swap(px, other.px); - pn.swap(other.pn); - } - - template<class Y> bool _internal_less(shared_ptr<Y> const & rhs) const - { - return pn < rhs.pn; - } - - void * _internal_get_deleter(std::type_info const & ti) const - { - return pn.get_deleter(ti); - } - -// Tasteless as this may seem, making all members public allows member templates -// to work in the absence of member template friends. (Matthew Langston) - -#ifndef BOOST_NO_MEMBER_TEMPLATE_FRIENDS - -private: - - template<class Y> friend class shared_ptr; - template<class Y> friend class weak_ptr; - - -#endif -public: // for serialization - T * px; // contained pointer - detail::shared_count pn; // reference counter - -}; // shared_ptr - -template<class T, class U> inline bool operator==(shared_ptr< T > const & a, shared_ptr<U> const & b) -{ - return a.get() == b.get(); -} - -template<class T, class U> inline bool operator!=(shared_ptr< T > const & a, shared_ptr<U> const & b) -{ - return a.get() != b.get(); -} - -#if __GNUC__ == 2 && __GNUC_MINOR__ <= 96 - -// Resolve the ambiguity between our op!= and the one in rel_ops - -template<class T> inline bool operator!=(shared_ptr< T > const & a, shared_ptr< T > const & b) -{ - return a.get() != b.get(); -} - -#endif - -template<class T, class U> inline bool operator<(shared_ptr< T > const & a, shared_ptr<U> const & b) -{ - return a._internal_less(b); -} - -template<class T> inline void swap(shared_ptr< T > & a, shared_ptr< T > & b) -{ - a.swap(b); -} - -template<class T, class U> shared_ptr< T > static_pointer_cast(shared_ptr<U> const & r) -{ - return shared_ptr< T >(r, detail::static_cast_tag()); -} - -template<class T, class U> shared_ptr< T > const_pointer_cast(shared_ptr<U> const & r) -{ - return shared_ptr< T >(r, detail::const_cast_tag()); -} - -template<class T, class U> shared_ptr< T > dynamic_pointer_cast(shared_ptr<U> const & r) -{ - return shared_ptr< T >(r, detail::dynamic_cast_tag()); -} - -// shared_*_cast names are deprecated. Use *_pointer_cast instead. - -template<class T, class U> shared_ptr< T > shared_static_cast(shared_ptr<U> const & r) -{ - return shared_ptr< T >(r, detail::static_cast_tag()); -} - -template<class T, class U> shared_ptr< T > shared_dynamic_cast(shared_ptr<U> const & r) -{ - return shared_ptr< T >(r, detail::dynamic_cast_tag()); -} - -template<class T, class U> shared_ptr< T > shared_polymorphic_cast(shared_ptr<U> const & r) -{ - return shared_ptr< T >(r, detail::polymorphic_cast_tag()); -} - -template<class T, class U> shared_ptr< T > shared_polymorphic_downcast(shared_ptr<U> const & r) -{ - BOOST_ASSERT(dynamic_cast<T *>(r.get()) == r.get()); - return shared_static_cast< T >(r); -} - -// get_pointer() enables boost::mem_fn to recognize shared_ptr - -template<class T> inline T * get_pointer(shared_ptr< T > const & p) -{ - return p.get(); -} - -// operator<< - -#if defined(__GNUC__) && (__GNUC__ < 3) - -template<class Y> std::ostream & operator<< (std::ostream & os, shared_ptr<Y> const & p) -{ - os << p.get(); - return os; -} - -#else - -# if defined(BOOST_MSVC) && BOOST_WORKAROUND(BOOST_MSVC, <= 1200 && __SGI_STL_PORT) -// MSVC6 has problems finding std::basic_ostream through the using declaration in namespace _STL -using std::basic_ostream; -template<class E, class T, class Y> basic_ostream<E, T> & operator<< (basic_ostream<E, T> & os, shared_ptr<Y> const & p) -# else -template<class E, class T, class Y> std::basic_ostream<E, T> & operator<< (std::basic_ostream<E, T> & os, shared_ptr<Y> const & p) -# endif -{ - os << p.get(); - return os; -} - -#endif - -// get_deleter (experimental) - -#if (defined(__GNUC__) && (__GNUC__ < 3)) || (defined(__EDG_VERSION__) && (__EDG_VERSION__ <= 238)) - -// g++ 2.9x doesn't allow static_cast<X const *>(void *) -// apparently EDG 2.38 also doesn't accept it - -template<class D, class T> D * get_deleter(shared_ptr< T > const & p) -{ - void const * q = p._internal_get_deleter(typeid(D)); - return const_cast<D *>(static_cast<D const *>(q)); -} - -#else - -template<class D, class T> D * get_deleter(shared_ptr< T > const & p) -{ - return static_cast<D *>(p._internal_get_deleter(typeid(D))); -} - -#endif - -} // namespace boost - -#ifdef BOOST_MSVC -# pragma warning(pop) -#endif - -#endif // #if defined(BOOST_NO_MEMBER_TEMPLATES) && !defined(BOOST_MSVC6_MEMBER_TEMPLATES) - -#endif // #ifndef BOOST_SHARED_PTR_132_HPP_INCLUDED diff --git a/3rdParty/Boost/src/boost/serialization/detail/shared_ptr_nmt_132.hpp b/3rdParty/Boost/src/boost/serialization/detail/shared_ptr_nmt_132.hpp deleted file mode 100644 index 490e7dd..0000000 --- a/3rdParty/Boost/src/boost/serialization/detail/shared_ptr_nmt_132.hpp +++ /dev/null @@ -1,182 +0,0 @@ -#ifndef BOOST_DETAIL_SHARED_PTR_NMT_132_HPP_INCLUDED -#define BOOST_DETAIL_SHARED_PTR_NMT_132_HPP_INCLUDED - -// -// detail/shared_ptr_nmt.hpp - shared_ptr.hpp without member templates -// -// (C) Copyright Greg Colvin and Beman Dawes 1998, 1999. -// Copyright (c) 2001, 2002 Peter Dimov -// -// 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) -// -// See http://www.boost.org/libs/smart_ptr/shared_ptr.htm for documentation. -// - -#include <boost/assert.hpp> -#include <boost/checked_delete.hpp> -#include <boost/serialization/throw_exception.hpp> -#include <boost/detail/atomic_count.hpp> - -#ifndef BOOST_NO_AUTO_PTR -# include <memory> // for std::auto_ptr -#endif - -#include <algorithm> // for std::swap -#include <functional> // for std::less -#include <new> // for std::bad_alloc - -namespace boost -{ - -template<class T> class shared_ptr -{ -private: - - typedef detail::atomic_count count_type; - -public: - - typedef T element_type; - typedef T value_type; - - explicit shared_ptr(T * p = 0): px(p) - { -#ifndef BOOST_NO_EXCEPTIONS - - try // prevent leak if new throws - { - pn = new count_type(1); - } - catch(...) - { - boost::checked_delete(p); - throw; - } - -#else - - pn = new count_type(1); - - if(pn == 0) - { - boost::checked_delete(p); - boost::serialization::throw_exception(std::bad_alloc()); - } - -#endif - } - - ~shared_ptr() - { - if(--*pn == 0) - { - boost::checked_delete(px); - delete pn; - } - } - - shared_ptr(shared_ptr const & r): px(r.px) // never throws - { - pn = r.pn; - ++*pn; - } - - shared_ptr & operator=(shared_ptr const & r) - { - shared_ptr(r).swap(*this); - return *this; - } - -#ifndef BOOST_NO_AUTO_PTR - - explicit shared_ptr(std::auto_ptr< T > & r) - { - pn = new count_type(1); // may throw - px = r.release(); // fix: moved here to stop leak if new throws - } - - shared_ptr & operator=(std::auto_ptr< T > & r) - { - shared_ptr(r).swap(*this); - return *this; - } - -#endif - - void reset(T * p = 0) - { - BOOST_ASSERT(p == 0 || p != px); - shared_ptr(p).swap(*this); - } - - T & operator*() const // never throws - { - BOOST_ASSERT(px != 0); - return *px; - } - - T * operator->() const // never throws - { - BOOST_ASSERT(px != 0); - return px; - } - - T * get() const // never throws - { - return px; - } - - long use_count() const // never throws - { - return *pn; - } - - bool unique() const // never throws - { - return *pn == 1; - } - - void swap(shared_ptr< T > & other) // never throws - { - std::swap(px, other.px); - std::swap(pn, other.pn); - } - -private: - - T * px; // contained pointer - count_type * pn; // ptr to reference counter -}; - -template<class T, class U> inline bool operator==(shared_ptr< T > const & a, shared_ptr<U> const & b) -{ - return a.get() == b.get(); -} - -template<class T, class U> inline bool operator!=(shared_ptr< T > const & a, shared_ptr<U> const & b) -{ - return a.get() != b.get(); -} - -template<class T> inline bool operator<(shared_ptr< T > const & a, shared_ptr< T > const & b) -{ - return std::less<T*>()(a.get(), b.get()); -} - -template<class T> void swap(shared_ptr< T > & a, shared_ptr< T > & b) -{ - a.swap(b); -} - -// get_pointer() enables boost::mem_fn to recognize shared_ptr - -template<class T> inline T * get_pointer(shared_ptr< T > const & p) -{ - return p.get(); -} - -} // namespace boost - -#endif // #ifndef BOOST_DETAIL_SHARED_PTR_NMT_132_HPP_INCLUDED diff --git a/3rdParty/Boost/src/boost/serialization/detail/stack_constructor.hpp b/3rdParty/Boost/src/boost/serialization/detail/stack_constructor.hpp index de623b0..7c74c18 100644 --- a/3rdParty/Boost/src/boost/serialization/detail/stack_constructor.hpp +++ b/3rdParty/Boost/src/boost/serialization/detail/stack_constructor.hpp @@ -1,73 +1,69 @@ #ifndef BOOST_SERIALIZATION_DETAIL_STACH_CONSTRUCTOR_HPP #define BOOST_SERIALIZATION_DETAIL_STACH_CONSTRUCTOR_HPP // MS compatible compilers support #pragma once -#if defined(_MSC_VER) && (_MSC_VER >= 1020) +#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. #include <boost/aligned_storage.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 BOOST_DEDUCED_TYPENAME boost::aligned_storage< + typedef typename boost::aligned_storage< sizeof(T), #if BOOST_WORKAROUND(__BORLANDC__,BOOST_TESTED_AT(0x560)) 8 #else boost::alignment_of<T>::value #endif > 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/3rdParty/Boost/src/boost/serialization/extended_type_info.hpp b/3rdParty/Boost/src/boost/serialization/extended_type_info.hpp index a4b4b69..d4b57af 100644 --- a/3rdParty/Boost/src/boost/serialization/extended_type_info.hpp +++ b/3rdParty/Boost/src/boost/serialization/extended_type_info.hpp @@ -1,40 +1,40 @@ #ifndef BOOST_SERIALIZATION_EXTENDED_TYPE_INFO_HPP #define BOOST_SERIALIZATION_EXTENDED_TYPE_INFO_HPP // MS compatible compilers support #pragma once -#if defined(_MSC_VER) && (_MSC_VER >= 1020) +#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{ diff --git a/3rdParty/Boost/src/boost/serialization/extended_type_info_no_rtti.hpp b/3rdParty/Boost/src/boost/serialization/extended_type_info_no_rtti.hpp index 025b3f6..62b2473 100644 --- a/3rdParty/Boost/src/boost/serialization/extended_type_info_no_rtti.hpp +++ b/3rdParty/Boost/src/boost/serialization/extended_type_info_no_rtti.hpp @@ -1,41 +1,41 @@ #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) && (_MSC_VER >= 1020) +#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) @@ -57,126 +57,126 @@ class BOOST_SERIALIZATION_DECL(BOOST_PP_EMPTY()) extended_type_info_no_rtti_0 : { protected: extended_type_info_no_rtti_0(const char * key); ~extended_type_info_no_rtti_0(); public: virtual bool is_less_than(const boost::serialization::extended_type_info &rhs) const ; virtual 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 - BOOST_DEDUCED_TYPENAME boost::mpl::if_c< + 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<BOOST_DEDUCED_TYPENAME boost::remove_const< T >::type, 0>(ap); + return factory<typename boost::remove_const< T >::type, 0>(ap); case 1: - return factory<BOOST_DEDUCED_TYPENAME boost::remove_const< T >::type, 1>(ap); + return factory<typename boost::remove_const< T >::type, 1>(ap); case 2: - return factory<BOOST_DEDUCED_TYPENAME boost::remove_const< T >::type, 2>(ap); + return factory<typename boost::remove_const< T >::type, 2>(ap); case 3: - return factory<BOOST_DEDUCED_TYPENAME boost::remove_const< T >::type, 3>(ap); + return factory<typename boost::remove_const< T >::type, 3>(ap); case 4: - return factory<BOOST_DEDUCED_TYPENAME boost::remove_const< T >::type, 4>(ap); + 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 BOOST_DEDUCED_TYPENAME + 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/3rdParty/Boost/src/boost/serialization/extended_type_info_typeid.hpp b/3rdParty/Boost/src/boost/serialization/extended_type_info_typeid.hpp index 9f09587..6a003be 100644 --- a/3rdParty/Boost/src/boost/serialization/extended_type_info_typeid.hpp +++ b/3rdParty/Boost/src/boost/serialization/extended_type_info_typeid.hpp @@ -1,41 +1,41 @@ #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) && (_MSC_VER >= 1020) +#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 @@ -82,84 +82,84 @@ 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(get_key()) { 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<BOOST_DEDUCED_TYPENAME boost::remove_const< T >::type, 0>(ap); + return factory<typename boost::remove_const< T >::type, 0>(ap); case 1: - return factory<BOOST_DEDUCED_TYPENAME boost::remove_const< T >::type, 1>(ap); + return factory<typename boost::remove_const< T >::type, 1>(ap); case 2: - return factory<BOOST_DEDUCED_TYPENAME boost::remove_const< T >::type, 2>(ap); + return factory<typename boost::remove_const< T >::type, 2>(ap); case 3: - return factory<BOOST_DEDUCED_TYPENAME boost::remove_const< T >::type, 3>(ap); + return factory<typename boost::remove_const< T >::type, 3>(ap); case 4: - return factory<BOOST_DEDUCED_TYPENAME boost::remove_const< T >::type, 4>(ap); + 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 BOOST_DEDUCED_TYPENAME + 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/3rdParty/Boost/src/boost/serialization/factory.hpp b/3rdParty/Boost/src/boost/serialization/factory.hpp index a25bf20..b601af6 100644 --- a/3rdParty/Boost/src/boost/serialization/factory.hpp +++ b/3rdParty/Boost/src/boost/serialization/factory.hpp @@ -1,41 +1,41 @@ #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) && (_MSC_VER >= 1020) +#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/preprocessor/facilities/empty.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; } diff --git a/3rdParty/Boost/src/boost/serialization/force_include.hpp b/3rdParty/Boost/src/boost/serialization/force_include.hpp index 5578ee8..468be37 100644 --- a/3rdParty/Boost/src/boost/serialization/force_include.hpp +++ b/3rdParty/Boost/src/boost/serialization/force_include.hpp @@ -1,40 +1,40 @@ #ifndef BOOST_SERIALIZATION_FORCE_INCLUDE_HPP #define BOOST_SERIALIZATION_FORCE_INCLUDE_HPP // MS compatible compilers support #pragma once -#if defined(_MSC_VER) && (_MSC_VER >= 1020) +#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__) # if defined(__BORLANDC__) # define BOOST_DLLEXPORT __export # else # define BOOST_DLLEXPORT __declspec(dllexport) # endif #elif ! defined(_WIN32) && ! defined(_WIN64) # if defined(__MWERKS__) diff --git a/3rdParty/Boost/src/boost/serialization/is_bitwise_serializable.hpp b/3rdParty/Boost/src/boost/serialization/is_bitwise_serializable.hpp index 34eec40..dac597e 100644 --- a/3rdParty/Boost/src/boost/serialization/is_bitwise_serializable.hpp +++ b/3rdParty/Boost/src/boost/serialization/is_bitwise_serializable.hpp @@ -1,46 +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) && (_MSC_VER >= 1020) +#if defined(_MSC_VER) # pragma once #endif #include <boost/mpl/bool.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/3rdParty/Boost/src/boost/serialization/level.hpp b/3rdParty/Boost/src/boost/serialization/level.hpp index ce507b2..b037f7e 100644 --- a/3rdParty/Boost/src/boost/serialization/level.hpp +++ b/3rdParty/Boost/src/boost/serialization/level.hpp @@ -1,125 +1,124 @@ #ifndef BOOST_SERIALIZATION_LEVEL_HPP #define BOOST_SERIALIZATION_LEVEL_HPP // MS compatible compilers support #pragma once -#if defined(_MSC_VER) && (_MSC_VER >= 1020) +#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/mpl/aux_/nttp_decl.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 BOOST_DEDUCED_TYPENAME U::level type; + 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 - BOOST_DEDUCED_TYPENAME mpl::eval_if< + typename mpl::eval_if< is_base_and_derived<boost::serialization::basic_traits, T>, traits_class_level< T >, //else - BOOST_DEDUCED_TYPENAME mpl::eval_if< + typename mpl::eval_if< is_fundamental< T >, mpl::int_<primitive_type>, //else - BOOST_DEDUCED_TYPENAME mpl::eval_if< + typename mpl::eval_if< is_class< T >, mpl::int_<object_class_info>, //else - BOOST_DEDUCED_TYPENAME mpl::eval_if< + typename mpl::eval_if< is_array< T >, #if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x560)) mpl::int_<not_serializable>, #else mpl::int_<object_serializable>, #endif //else - BOOST_DEDUCED_TYPENAME mpl::eval_if< + typename mpl::eval_if< is_enum< T >, //#if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x560)) // mpl::int_<not_serializable>, //#else mpl::int_<primitive_type>, //#endif //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, BOOST_MPL_AUX_NTTP_DECL(int, L) > +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/3rdParty/Boost/src/boost/serialization/level_enum.hpp b/3rdParty/Boost/src/boost/serialization/level_enum.hpp index 11bd17f..baf64e0 100644 --- a/3rdParty/Boost/src/boost/serialization/level_enum.hpp +++ b/3rdParty/Boost/src/boost/serialization/level_enum.hpp @@ -1,40 +1,40 @@ #ifndef BOOST_SERIALIZATION_LEVEL_ENUM_HPP #define BOOST_SERIALIZATION_LEVEL_ENUM_HPP // MS compatible compilers support #pragma once -#if defined(_MSC_VER) && (_MSC_VER >= 1020) +#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. diff --git a/3rdParty/Boost/src/boost/serialization/list.hpp b/3rdParty/Boost/src/boost/serialization/list.hpp index 469bb23..63d3b47 100644 --- a/3rdParty/Boost/src/boost/serialization/list.hpp +++ b/3rdParty/Boost/src/boost/serialization/list.hpp @@ -1,40 +1,40 @@ #ifndef BOOST_SERIALIZATION_LIST_HPP #define BOOST_SERIALIZATION_LIST_HPP // MS compatible compilers support #pragma once -#if defined(_MSC_VER) && (_MSC_VER >= 1020) +#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/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); } diff --git a/3rdParty/Boost/src/boost/serialization/map.hpp b/3rdParty/Boost/src/boost/serialization/map.hpp index 624290d..11a3d6b 100644 --- a/3rdParty/Boost/src/boost/serialization/map.hpp +++ b/3rdParty/Boost/src/boost/serialization/map.hpp @@ -1,40 +1,40 @@ #ifndef BOOST_SERIALIZATION_MAP_HPP #define BOOST_SERIALIZATION_MAP_HPP // MS compatible compilers support #pragma once -#if defined(_MSC_VER) && (_MSC_VER >= 1020) +#if defined(_MSC_VER) # pragma once #endif /////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8 // serialization/map.hpp: // serialization for stl map 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 <map> #include <boost/config.hpp> #include <boost/serialization/utility.hpp> #include <boost/serialization/collections_save_imp.hpp> #include <boost/serialization/collections_load_imp.hpp> #include <boost/serialization/split_free.hpp> namespace boost { namespace serialization { template<class Archive, class Type, class Key, class Compare, class Allocator > inline void save( Archive & ar, const std::map<Key, Type, Compare, Allocator> &t, const unsigned int /* file_version */ ){ boost::serialization::stl::save_collection< Archive, std::map<Key, Type, Compare, Allocator> diff --git a/3rdParty/Boost/src/boost/serialization/nvp.hpp b/3rdParty/Boost/src/boost/serialization/nvp.hpp index 2d7f4ed..f33707c 100644 --- a/3rdParty/Boost/src/boost/serialization/nvp.hpp +++ b/3rdParty/Boost/src/boost/serialization/nvp.hpp @@ -1,61 +1,57 @@ #ifndef BOOST_SERIALIZATION_NVP_HPP #define BOOST_SERIALIZATION_NVP_HPP // MS compatible compilers support #pragma once -#if defined(_MSC_VER) && (_MSC_VER >= 1020) +#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> -// supress noise -#if BOOST_WORKAROUND(BOOST_MSVC, <= 1200) -# pragma warning (disable : 4786) // too long name, harmless warning -#endif #include <boost/mpl/integral_c.hpp> #include <boost/mpl/integral_c_tag.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> namespace boost { namespace serialization { template<class T> struct nvp : public std::pair<const char *, T *>, public wrapper_traits<const nvp< T > > { explicit nvp(const char * name_, T & t) : // note: redundant cast works around borland issue // note: added _ to suppress useless gcc warning std::pair<const char *, T *>(name_, (T*)(& t)) {} nvp(const nvp & rhs) : // note: redundant cast works around borland issue std::pair<const char *, T *>(rhs.first, (T*)rhs.second) {} const char * name() const { return this->first; } T & value() const { return *(this->second); } @@ -72,73 +68,71 @@ struct nvp : // just discarded and only the value is serialized. template<class Archivex> void save( Archivex & ar, const unsigned int /* file_version */ ) const { // CodeWarrior 8.x can't seem to resolve the << op for a rhs of "const T *" ar.operator<<(const_value()); } template<class Archivex> void load( Archivex & ar, const unsigned int /* file_version */ ){ // CodeWarrior 8.x can't seem to resolve the >> op for a rhs of "const T *" ar.operator>>(value()); } BOOST_SERIALIZATION_SPLIT_MEMBER() }; template<class T> inline #ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING const #endif 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 !!! -#if 0 // #ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION 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); }; -#endif } // 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/3rdParty/Boost/src/boost/serialization/optional.hpp b/3rdParty/Boost/src/boost/serialization/optional.hpp index 929fa07..4024cf5 100644 --- a/3rdParty/Boost/src/boost/serialization/optional.hpp +++ b/3rdParty/Boost/src/boost/serialization/optional.hpp @@ -1,48 +1,48 @@ /////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8 // (C) Copyright 2002-4 Pavel Vozenilek . // 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) // Provides non-intrusive serialization for boost::optional. #ifndef BOOST_SERIALIZATION_OPTIONAL_HPP_ #define BOOST_SERIALIZATION_OPTIONAL_HPP_ -#if defined(_MSC_VER) && (_MSC_VER >= 1020) +#if defined(_MSC_VER) # pragma once #endif #include <boost/config.hpp> #include <boost/archive/detail/basic_iarchive.hpp> #include <boost/optional.hpp> #include <boost/serialization/item_version_type.hpp> #include <boost/serialization/split_free.hpp> #include <boost/serialization/level.hpp> #include <boost/serialization/nvp.hpp> #include <boost/serialization/version.hpp> #include <boost/serialization/detail/stack_constructor.hpp> // function specializations must be defined in the appropriate // namespace - boost::serialization namespace boost { namespace serialization { template<class Archive, class T> void save( Archive & ar, const boost::optional< T > & t, const unsigned int /*version*/ ){ const bool tflag = t.is_initialized(); ar << boost::serialization::make_nvp("initialized", tflag); if (tflag){ const boost::serialization::item_version_type item_version(version< T >::value); #if 0 const boost::archive::library_version_type library_version( ar.get_library_version() }; if(boost::archive::library_version_type(3) < library_version){ @@ -58,70 +58,39 @@ void save( template<class Archive, class T> void load( Archive & ar, boost::optional< T > & t, const unsigned int /*version*/ ){ bool tflag; ar >> boost::serialization::make_nvp("initialized", tflag); if (tflag){ boost::serialization::item_version_type item_version(0); boost::archive::library_version_type library_version( ar.get_library_version() ); if(boost::archive::library_version_type(3) < library_version){ // item_version is handled as an attribute so it doesnt need an NVP ar >> BOOST_SERIALIZATION_NVP(item_version); } detail::stack_construct<Archive, T> aux(ar, item_version); ar >> boost::serialization::make_nvp("value", aux.reference()); t.reset(aux.reference()); } else { t.reset(); } } template<class Archive, class T> void serialize( Archive & ar, boost::optional< T > & t, const unsigned int version ){ boost::serialization::split_free(ar, t, version); } -// the following would be slightly more efficient. But it -// would mean that archives created with programs that support -// TPS wouldn't be readable by programs that don't support TPS. -// Hence we decline to support this otherwise convenient optimization. -//#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION -#if 0 - -template <class T> -struct implementation_level<optional< T > > -{ - typedef mpl::integral_c_tag tag; - typedef mpl::int_<boost::serialization::object_serializable> type; - BOOST_STATIC_CONSTANT( - int , - value = boost::serialization::implementation_level::type::value - ); -}; - -template<class T> -struct tracking_level<optional< T > > -{ - typedef mpl::integral_c_tag tag; - typedef mpl::int_<boost::serialization::track_never> type; - BOOST_STATIC_CONSTANT( - int , - value = boost::serialization::tracking_level::type::value - ); -}; - -#endif - } // serialization } // namespace boost #endif // BOOST_SERIALIZATION_OPTIONAL_HPP_ diff --git a/3rdParty/Boost/src/boost/serialization/pfto.hpp b/3rdParty/Boost/src/boost/serialization/pfto.hpp index 8d98463..0370d28 100644 --- a/3rdParty/Boost/src/boost/serialization/pfto.hpp +++ b/3rdParty/Boost/src/boost/serialization/pfto.hpp @@ -1,40 +1,40 @@ #ifndef BOOST_SERIALIZATION_PFTO_HPP #define BOOST_SERIALIZATION_PFTO_HPP // MS compatible compilers support #pragma once -#if defined(_MSC_VER) && (_MSC_VER >= 1020) +#if defined(_MSC_VER) # pragma once #endif /////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8 // pfto.hpp: workarounds for compilers which have problems supporting // Partial Function Template Ordering (PFTO). // (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. // PFTO version is used to specify the last argument of certain functions // Function it is used to support compilers that fail to support correct Partial // Template Ordering #include <boost/config.hpp> // some compilers can use an exta argument and use function overloading // to choose desired function. This extra argument is long in the default // function implementation and int for the rest. The function is called // with an int argument. This first attempts to match functions with an // int argument before the default one (with a long argument). This is // known to function with VC 6.0. On other compilers this fails (Borland) // or causes other problems (GCC). note: this #if defined(BOOST_NO_FUNCTION_TEMPLATE_ORDERING) #define BOOST_PFTO long #else #define BOOST_PFTO #endif // here's another approach. Rather than use a default function - make sure // there is no default at all by requiring that all function invocations // have a "wrapped" argument type. This solves a problem with VC 6.0 diff --git a/3rdParty/Boost/src/boost/serialization/serialization.hpp b/3rdParty/Boost/src/boost/serialization/serialization.hpp index f17e8dd..8462b59 100644 --- a/3rdParty/Boost/src/boost/serialization/serialization.hpp +++ b/3rdParty/Boost/src/boost/serialization/serialization.hpp @@ -1,44 +1,44 @@ #ifndef BOOST_SERIALIZATION_SERIALIZATION_HPP #define BOOST_SERIALIZATION_SERIALIZATION_HPP // MS compatible compilers support #pragma once -#if defined(_MSC_VER) && (_MSC_VER >= 1020) +#if defined(_MSC_VER) # pragma once #endif -#if defined(_MSC_VER) && (_MSC_VER >= 1310) +#if defined(_MSC_VER) # pragma warning (disable : 4675) // suppress ADL warning #endif #include <boost/config.hpp> #include <boost/serialization/strong_typedef.hpp> #include <boost/serialization/pfto.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> diff --git a/3rdParty/Boost/src/boost/serialization/set.hpp b/3rdParty/Boost/src/boost/serialization/set.hpp index 4bb69ab..6882fb0 100644 --- a/3rdParty/Boost/src/boost/serialization/set.hpp +++ b/3rdParty/Boost/src/boost/serialization/set.hpp @@ -1,40 +1,40 @@ #ifndef BOOST_SERIALIZATION_SET_HPP #define BOOST_SERIALIZATION_SET_HPP // MS compatible compilers support #pragma once -#if defined(_MSC_VER) && (_MSC_VER >= 1020) +#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 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/serialization/collections_save_imp.hpp> #include <boost/serialization/collections_load_imp.hpp> #include <boost/serialization/split_free.hpp> namespace boost { namespace serialization { 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); } diff --git a/3rdParty/Boost/src/boost/serialization/shared_ptr.hpp b/3rdParty/Boost/src/boost/serialization/shared_ptr.hpp index 37f95e3..f595678 100644 --- a/3rdParty/Boost/src/boost/serialization/shared_ptr.hpp +++ b/3rdParty/Boost/src/boost/serialization/shared_ptr.hpp @@ -1,177 +1,279 @@ #ifndef BOOST_SERIALIZATION_SHARED_PTR_HPP #define BOOST_SERIALIZATION_SHARED_PTR_HPP // MS compatible compilers support #pragma once -#if defined(_MSC_VER) && (_MSC_VER >= 1020) +#if defined(_MSC_VER) # pragma once #endif /////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8 // shared_ptr.hpp: serialization for boost shared pointer // (C) Copyright 2004 Robert Ramey and Martin Ecker // 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 <cstddef> // NULL #include <boost/config.hpp> #include <boost/mpl/integral_c.hpp> #include <boost/mpl/integral_c_tag.hpp> #include <boost/detail/workaround.hpp> #include <boost/shared_ptr.hpp> +#include <boost/serialization/shared_ptr_helper.hpp> #include <boost/serialization/split_free.hpp> #include <boost/serialization/nvp.hpp> #include <boost/serialization/version.hpp> #include <boost/serialization/tracking.hpp> /////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8 -// shared_ptr serialization traits +// boost:: shared_ptr serialization traits // version 1 to distinguish from boost 1.32 version. Note: we can only do this // for a template when the compiler supports partial template specialization #ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION namespace boost { namespace serialization{ template<class T> struct version< ::boost::shared_ptr< T > > { typedef mpl::integral_c_tag tag; #if BOOST_WORKAROUND(__MWERKS__, BOOST_TESTED_AT(0x3206)) - typedef BOOST_DEDUCED_TYPENAME mpl::int_<1> type; + typedef typename mpl::int_<1> type; #else typedef mpl::int_<1> type; #endif #if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x570)) BOOST_STATIC_CONSTANT(int, value = 1); #else BOOST_STATIC_CONSTANT(int, value = type::value); #endif }; // don't track shared pointers template<class T> struct tracking_level< ::boost::shared_ptr< T > > { typedef mpl::integral_c_tag tag; #if BOOST_WORKAROUND(__MWERKS__, BOOST_TESTED_AT(0x3206)) - typedef BOOST_DEDUCED_TYPENAME mpl::int_< ::boost::serialization::track_never> type; + typedef typename mpl::int_< ::boost::serialization::track_never> type; #else typedef mpl::int_< ::boost::serialization::track_never> type; #endif #if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x570)) BOOST_STATIC_CONSTANT(int, value = ::boost::serialization::track_never); #else BOOST_STATIC_CONSTANT(int, value = type::value); #endif }; }} #define BOOST_SERIALIZATION_SHARED_PTR(T) #else // define macro to let users of these compilers do this #define BOOST_SERIALIZATION_SHARED_PTR(T) \ BOOST_CLASS_VERSION( \ ::boost::shared_ptr< T >, \ 1 \ ) \ BOOST_CLASS_TRACKING( \ ::boost::shared_ptr< T >, \ ::boost::serialization::track_never \ ) \ /**/ #endif namespace boost { namespace serialization{ struct null_deleter { void operator()(void const *) const {} }; /////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8 -// serialization for shared_ptr +// serialization for boost::shared_ptr template<class Archive, class T> inline void save( Archive & ar, const boost::shared_ptr< T > &t, const unsigned int /* file_version */ ){ // The most common cause of trapping here would be serializing // something like shared_ptr<int>. This occurs because int // is never tracked by default. Wrap int in a trackable type BOOST_STATIC_ASSERT((tracking_level< T >::value != track_never)); const T * t_ptr = t.get(); ar << boost::serialization::make_nvp("px", t_ptr); } #ifdef BOOST_SERIALIZATION_SHARED_PTR_132_HPP template<class Archive, class T> inline void load( Archive & ar, boost::shared_ptr< T > &t, const unsigned int file_version ){ // The most common cause of trapping here would be serializing // something like shared_ptr<int>. This occurs because int // is never tracked by default. Wrap int in a trackable type BOOST_STATIC_ASSERT((tracking_level< T >::value != track_never)); T* r; if(file_version < 1){ - //ar.register_type(static_cast< - // boost_132::detail::sp_counted_base_impl<T *, boost::checked_deleter< T > > * - //>(NULL)); ar.register_type(static_cast< boost_132::detail::sp_counted_base_impl<T *, null_deleter > * >(NULL)); boost_132::shared_ptr< T > sp; ar >> boost::serialization::make_nvp("px", sp.px); ar >> boost::serialization::make_nvp("pn", sp.pn); // got to keep the sps around so the sp.pns don't disappear - ar.append(sp); + boost::serialization::shared_ptr_helper<boost::shared_ptr> & h = + ar.template get_helper< + shared_ptr_helper<boost::shared_ptr> + >(); + h.append(sp); r = sp.get(); } else{ ar >> boost::serialization::make_nvp("px", r); } - ar.reset(t,r); + shared_ptr_helper<boost::shared_ptr> & h = + ar.template get_helper< + boost::serialization::shared_ptr_helper<boost::shared_ptr> + >(); + h.reset(t,r); } - #else template<class Archive, class T> inline void load( Archive & ar, boost::shared_ptr< T > &t, const unsigned int /*file_version*/ ){ // The most common cause of trapping here would be serializing // something like shared_ptr<int>. This occurs because int // is never tracked by default. Wrap int in a trackable type BOOST_STATIC_ASSERT((tracking_level< T >::value != track_never)); T* r; ar >> boost::serialization::make_nvp("px", r); - ar.reset(t,r); + boost::serialization::shared_ptr_helper<boost::shared_ptr> & h = + ar.template get_helper< + shared_ptr_helper<boost::shared_ptr> + >(); + h.reset(t,r); } #endif template<class Archive, class T> inline void serialize( Archive & ar, boost::shared_ptr< T > &t, const unsigned int file_version ){ // correct shared_ptr serialization depends upon object tracking // being used. BOOST_STATIC_ASSERT( boost::serialization::tracking_level< T >::value != boost::serialization::track_never ); boost::serialization::split_free(ar, t, file_version); } } // namespace serialization } // namespace boost +/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8 +// std::shared_ptr serialization traits +// version 1 to distinguish from boost 1.32 version. Note: we can only do this +// for a template when the compiler supports partial template specialization + +#ifndef BOOST_NO_CXX11_SMART_PTR +#include <boost/static_assert.hpp> + +// note: we presume that any compiler/library which supports C++11 +// std::pointers also supports template partial specialization +// trap here if such presumption were to turn out to wrong!!! +#ifdef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION + BOOST_STATIC_ASSERT(false); +#endif + +namespace boost { +namespace serialization{ + template<class T> + struct version< ::std::shared_ptr< T > > { + typedef mpl::integral_c_tag tag; + typedef mpl::int_<1> type; + BOOST_STATIC_CONSTANT(int, value = type::value); + }; + // don't track shared pointers + template<class T> + struct tracking_level< ::std::shared_ptr< T > > { + typedef mpl::integral_c_tag tag; + typedef mpl::int_< ::boost::serialization::track_never> type; + BOOST_STATIC_CONSTANT(int, value = type::value); + }; +}} +// the following just keeps older programs from breaking +#define BOOST_SERIALIZATION_SHARED_PTR(T) + +namespace boost { +namespace serialization{ + +/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8 +// serialization for std::shared_ptr + +template<class Archive, class T> +inline void save( + Archive & ar, + const std::shared_ptr< T > &t, + const unsigned int /* file_version */ +){ + // The most common cause of trapping here would be serializing + // something like shared_ptr<int>. This occurs because int + // is never tracked by default. Wrap int in a trackable type + BOOST_STATIC_ASSERT((tracking_level< T >::value != track_never)); + const T * t_ptr = t.get(); + ar << boost::serialization::make_nvp("px", t_ptr); +} + +template<class Archive, class T> +inline void load( + Archive & ar, + std::shared_ptr< T > &t, + const unsigned int /*file_version*/ +){ + // The most common cause of trapping here would be serializing + // something like shared_ptr<int>. This occurs because int + // is never tracked by default. Wrap int in a trackable type + BOOST_STATIC_ASSERT((tracking_level< T >::value != track_never)); + T* r; + ar >> boost::serialization::make_nvp("px", r); + boost::serialization::shared_ptr_helper<std::shared_ptr> & h = + ar.template get_helper< + shared_ptr_helper<std::shared_ptr> + >(); + h.reset(t,r); +} + +template<class Archive, class T> +inline void serialize( + Archive & ar, + std::shared_ptr< T > &t, + const unsigned int file_version +){ + // correct shared_ptr serialization depends upon object tracking + // being used. + BOOST_STATIC_ASSERT( + boost::serialization::tracking_level< T >::value + != boost::serialization::track_never + ); + boost::serialization::split_free(ar, t, file_version); +} + +} // namespace serialization +} // namespace boost + +#endif // BOOST_NO_CXX11_SMART_PTR + #endif // BOOST_SERIALIZATION_SHARED_PTR_HPP diff --git a/3rdParty/Boost/src/boost/serialization/shared_ptr_132.hpp b/3rdParty/Boost/src/boost/serialization/shared_ptr_132.hpp deleted file mode 100644 index 9bcefe0..0000000 --- a/3rdParty/Boost/src/boost/serialization/shared_ptr_132.hpp +++ /dev/null @@ -1,222 +0,0 @@ -#ifndef BOOST_SERIALIZATION_SHARED_PTR_132_HPP -#define BOOST_SERIALIZATION_SHARED_PTR_132_HPP - -// MS compatible compilers support #pragma once -#if defined(_MSC_VER) && (_MSC_VER >= 1020) -# pragma once -#endif - -/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8 -// shared_ptr.hpp: serialization for boost shared pointer - -// (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. - -// note: totally unadvised hack to gain access to private variables -// in shared_ptr and shared_count. Unfortunately its the only way to -// do this without changing shared_ptr and shared_count -// the best we can do is to detect a conflict here -#include <boost/config.hpp> - -#include <list> -#include <cstddef> // NULL - -#include <boost/serialization/assume_abstract.hpp> -#include <boost/serialization/split_free.hpp> -#include <boost/serialization/nvp.hpp> -#include <boost/serialization/tracking.hpp> -#include <boost/serialization/void_cast.hpp> - -// mark base class as an (uncreatable) base class -#include <boost/serialization/detail/shared_ptr_132.hpp> - -///////////////////////////////////////////////////////////// -// Maintain a couple of lists of loaded shared pointers of the old previous -// version (1.32) - -namespace boost_132 { -namespace serialization { -namespace detail { - -struct null_deleter { - void operator()(void const *) const {} -}; - -} // namespace detail -} // namespace serialization -} // namespace boost_132 - -///////////////////////////////////////////////////////////// -// sp_counted_base_impl serialization - -namespace boost { -namespace serialization { - -template<class Archive, class P, class D> -inline void serialize( - Archive & /* ar */, - boost_132::detail::sp_counted_base_impl<P, D> & /* t */, - const unsigned int /*file_version*/ -){ - // register the relationship between each derived class - // its polymorphic base - boost::serialization::void_cast_register< - boost_132::detail::sp_counted_base_impl<P, D>, - boost_132::detail::sp_counted_base - >( - static_cast<boost_132::detail::sp_counted_base_impl<P, D> *>(NULL), - static_cast<boost_132::detail::sp_counted_base *>(NULL) - ); -} - -template<class Archive, class P, class D> -inline void save_construct_data( - Archive & ar, - const - boost_132::detail::sp_counted_base_impl<P, D> *t, - const BOOST_PFTO unsigned int /* file_version */ -){ - // variables used for construction - ar << boost::serialization::make_nvp("ptr", t->ptr); -} - -template<class Archive, class P, class D> -inline void load_construct_data( - Archive & ar, - boost_132::detail::sp_counted_base_impl<P, D> * t, - const unsigned int /* file_version */ -){ - P ptr_; - ar >> boost::serialization::make_nvp("ptr", ptr_); - // ::new(t)boost_132::detail::sp_counted_base_impl<P, D>(ptr_, D()); - // placement - // note: the original ::new... above is replaced by the one here. This one - // creates all new objects with a null_deleter so that after the archive - // is finished loading and the shared_ptrs are destroyed - the underlying - // raw pointers are NOT deleted. This is necessary as they are used by the - // new system as well. - ::new(t)boost_132::detail::sp_counted_base_impl< - P, - boost_132::serialization::detail::null_deleter - >( - ptr_, boost_132::serialization::detail::null_deleter() - ); // placement new - // compensate for that fact that a new shared count always is - // initialized with one. the add_ref_copy below will increment it - // every time its serialized so without this adjustment - // the use and weak counts will be off by one. - t->use_count_ = 0; -} - -} // serialization -} // namespace boost - -///////////////////////////////////////////////////////////// -// shared_count serialization - -namespace boost { -namespace serialization { - -template<class Archive> -inline void save( - Archive & ar, - const boost_132::detail::shared_count &t, - const unsigned int /* file_version */ -){ - ar << boost::serialization::make_nvp("pi", t.pi_); -} - -template<class Archive> -inline void load( - Archive & ar, - boost_132::detail::shared_count &t, - const unsigned int /* file_version */ -){ - ar >> boost::serialization::make_nvp("pi", t.pi_); - if(NULL != t.pi_) - t.pi_->add_ref_copy(); -} - -} // serialization -} // namespace boost - -BOOST_SERIALIZATION_SPLIT_FREE(boost_132::detail::shared_count) - -///////////////////////////////////////////////////////////// -// implement serialization for shared_ptr< T > - -namespace boost { -namespace serialization { - -template<class Archive, class T> -inline void save( - Archive & ar, - const boost_132::shared_ptr< T > &t, - const unsigned int /* file_version */ -){ - // only the raw pointer has to be saved - // the ref count is maintained automatically as shared pointers are loaded - ar.register_type(static_cast< - boost_132::detail::sp_counted_base_impl<T *, boost::checked_deleter< T > > * - >(NULL)); - ar << boost::serialization::make_nvp("px", t.px); - ar << boost::serialization::make_nvp("pn", t.pn); -} - -template<class Archive, class T> -inline void load( - Archive & ar, - boost_132::shared_ptr< T > &t, - const unsigned int /* file_version */ -){ - // only the raw pointer has to be saved - // the ref count is maintained automatically as shared pointers are loaded - ar.register_type(static_cast< - boost_132::detail::sp_counted_base_impl<T *, boost::checked_deleter< T > > * - >(NULL)); - ar >> boost::serialization::make_nvp("px", t.px); - ar >> boost::serialization::make_nvp("pn", t.pn); -} - -template<class Archive, class T> -inline void serialize( - Archive & ar, - boost_132::shared_ptr< T > &t, - const unsigned int file_version -){ - // correct shared_ptr serialization depends upon object tracking - // being used. - BOOST_STATIC_ASSERT( - boost::serialization::tracking_level< T >::value - != boost::serialization::track_never - ); - boost::serialization::split_free(ar, t, file_version); -} - -} // serialization -} // namespace boost - -// note: change below uses null_deleter -// This macro is used to export GUIDS for shared pointers to allow -// the serialization system to export them properly. David Tonge -#define BOOST_SHARED_POINTER_EXPORT_GUID(T, K) \ - typedef boost_132::detail::sp_counted_base_impl< \ - T *, \ - boost::checked_deleter< T > \ - > __shared_ptr_ ## T; \ - BOOST_CLASS_EXPORT_GUID(__shared_ptr_ ## T, "__shared_ptr_" K) \ - BOOST_CLASS_EXPORT_GUID(T, K) \ - /**/ - -#define BOOST_SHARED_POINTER_EXPORT(T) \ - BOOST_SHARED_POINTER_EXPORT_GUID( \ - T, \ - BOOST_PP_STRINGIZE(T) \ - ) \ - /**/ - -#endif // BOOST_SERIALIZATION_SHARED_PTR_132_HPP diff --git a/3rdParty/Boost/src/boost/serialization/shared_ptr_helper.hpp b/3rdParty/Boost/src/boost/serialization/shared_ptr_helper.hpp new file mode 100644 index 0000000..9dace87 --- /dev/null +++ b/3rdParty/Boost/src/boost/serialization/shared_ptr_helper.hpp @@ -0,0 +1,212 @@ +#ifndef BOOST_SERIALIZATION_SHARED_PTR_HELPER_HPP +#define BOOST_SERIALIZATION_SHARED_PTR_HELPER_HPP + +// MS compatible compilers support #pragma once +#if defined(_MSC_VER) +# pragma once +#endif + +/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8 +// shared_ptr_helper.hpp: serialization for boost shared pointern + +// (C) Copyright 2004-2009 Robert Ramey, Martin Ecker and Takatoshi Kondo +// Use, modification and distribution is subject to the Boost Software +// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) + +// See http://www.boost.org for updates, documentation, and revision history. + +#include <map> +#include <list> +#include <utility> +#include <cstddef> // NULL + +#include <boost/config.hpp> +#include <boost/shared_ptr.hpp> +#include <boost/type_traits/is_polymorphic.hpp> +#include <boost/mpl/if.hpp> + +#include <boost/serialization/type_info_implementation.hpp> +#include <boost/serialization/throw_exception.hpp> +#include <boost/archive/archive_exception.hpp> +#include <boost/archive/detail/decl.hpp> + +#include <boost/archive/detail/abi_prefix.hpp> // must be the last headern + +namespace boost_132 { + template<class T> class shared_ptr; +} +namespace boost { +namespace serialization { + +class extended_type_info; + +#ifndef BOOST_NO_MEMBER_TEMPLATE_FRIENDS +template<class Archive, template<class U> class SPT > +void load( + Archive & ar, + SPT< class U > &t, + const unsigned int file_version +); +#endif + +/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8 +// a common class for holding various types of shared pointers + +template<template<class T> class SPT> +class shared_ptr_helper { + typedef std::map< + const void *, // address of object + SPT<void> // address shared ptr to single instance + > object_shared_pointer_map; + + // list of shared_pointers create accessable by raw pointer. This + // is used to "match up" shared pointers loaded at different + // points in the archive. Note, we delay construction until + // it is actually used since this is by default included as + // a "mix-in" even if shared_ptr isn't used. + object_shared_pointer_map * m_o_sp; + + struct null_deleter { + void operator()(void const *) const {} + }; + +#if defined(BOOST_NO_MEMBER_TEMPLATE_FRIENDS) || defined(BOOST_MSVC) +public: +#else + template<class Archive, class U> + friend void boost::serialization::load( + Archive & ar, + SPT< U > &t, + const unsigned int file_version + ); +#endif + + #ifdef BOOST_SERIALIZATION_SHARED_PTR_132_HPP + // list of loaded pointers. This is used to be sure that the pointers + // stay around long enough to be "matched" with other pointers loaded + // by the same archive. These are created with a "null_deleter" so that + // when this list is destroyed - the underlaying raw pointers are not + // destroyed. This has to be done because the pointers are also held by + // new system which is disjoint from this set. This is implemented + // by a change in load_construct_data below. It makes this file suitable + // only for loading pointers into a 1.33 or later boost system. + std::list<boost_132::shared_ptr<const void> > * m_pointers_132; + BOOST_ARCHIVE_DECL(void) + append(const boost_132::shared_ptr<const void> & t){ + if(NULL == m_pointers_132) + m_pointers_132 = new std::list<boost_132::shared_ptr<const void> >; + m_pointers_132->push_back(t); + } + #endif + + struct non_polymorphic { + template<class U> + static const boost::serialization::extended_type_info * + get_object_type(U & ){ + return & boost::serialization::singleton< + typename + boost::serialization::type_info_implementation< U >::type + >::get_const_instance(); + } + }; + struct polymorphic { + template<class U> + static const boost::serialization::extended_type_info * + get_object_type(U & u){ + return boost::serialization::singleton< + typename + boost::serialization::type_info_implementation< U >::type + >::get_const_instance().get_derived_extended_type_info(u); + } + }; + +public: + template<class T> + void reset(SPT< T > & s, T * t){ + if(NULL == t){ + s.reset(); + return; + } + const boost::serialization::extended_type_info * this_type + = & boost::serialization::type_info_implementation< T >::type + ::get_const_instance(); + + // get pointer to the most derived object's eti. This is effectively + // the object type identifer + typedef typename mpl::if_< + is_polymorphic< T >, + polymorphic, + non_polymorphic + >::type type; + + const boost::serialization::extended_type_info * true_type + = type::get_object_type(*t); + + // note:if this exception is thrown, be sure that derived pointern + // is either registered or exported. + if(NULL == true_type) + boost::serialization::throw_exception( + boost::archive::archive_exception( + boost::archive::archive_exception::unregistered_class, + this_type->get_debug_info() + ) + ); + // get void pointer to the most derived type + // this uniquely identifies the object referred to + // oid = "object identifier" + const void * oid = void_downcast( + *true_type, + *this_type, + t + ); + if(NULL == oid) + boost::serialization::throw_exception( + boost::archive::archive_exception( + boost::archive::archive_exception::unregistered_cast, + true_type->get_debug_info(), + this_type->get_debug_info() + ) + ); + + // make tracking array if necessary + if(NULL == m_o_sp) + m_o_sp = new object_shared_pointer_map; + + typename object_shared_pointer_map::iterator i = m_o_sp->find(oid); + + // if it's a new object + if(i == m_o_sp->end()){ + s.reset(t); + std::pair<typename object_shared_pointer_map::iterator, bool> result; + result = m_o_sp->insert(std::make_pair(oid, s)); + BOOST_ASSERT(result.second); + } + // if the object has already been seen + else{ + s = SPT<T>(i->second, t); + } + } + + shared_ptr_helper() : + m_o_sp(NULL) + #ifdef BOOST_SERIALIZATION_SHARED_PTR_132_HPP + , m_pointers_132(NULL) + #endif + {} + virtual ~shared_ptr_helper(){ + if(NULL != m_o_sp) + delete m_o_sp; + #ifdef BOOST_SERIALIZATION_SHARED_PTR_132_HPP + if(NULL != m_pointers_132) + delete m_pointers_132; + #endif + } +}; + +} // namespace serialization +} // namespace boost + +#include <boost/archive/detail/abi_suffix.hpp> // pops abi_suffix.hpp pragmas + +#endif // BOOST_SERIALIZATION_SHARED_PTR_HELPER_HPP diff --git a/3rdParty/Boost/src/boost/serialization/singleton.hpp b/3rdParty/Boost/src/boost/serialization/singleton.hpp index f521590..546118c 100644 --- a/3rdParty/Boost/src/boost/serialization/singleton.hpp +++ b/3rdParty/Boost/src/boost/serialization/singleton.hpp @@ -1,68 +1,68 @@ #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. // // 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) && (_MSC_VER >= 1020) +#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> #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 guarenteed 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. diff --git a/3rdParty/Boost/src/boost/serialization/smart_cast.hpp b/3rdParty/Boost/src/boost/serialization/smart_cast.hpp index c240a55..02edb4b 100644 --- a/3rdParty/Boost/src/boost/serialization/smart_cast.hpp +++ b/3rdParty/Boost/src/boost/serialization/smart_cast.hpp @@ -1,301 +1,303 @@ #ifndef BOOST_SERIALIZATION_SMART_CAST_HPP #define BOOST_SERIALIZATION_SMART_CAST_HPP // MS compatible compilers support #pragma once -#if defined(_MSC_VER) && (_MSC_VER >= 1020) +#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(__BORLANDC__) && (__BORLANDC__ <= 0x560) \ || 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 BOOST_DEDUCED_TYPENAME mpl::eval_if< - BOOST_DEDUCED_TYPENAME mpl::and_< + typedef typename mpl::eval_if< + typename mpl::and_< mpl::not_<is_base_and_derived< - BOOST_DEDUCED_TYPENAME remove_reference< T >::type, + typename remove_reference< T >::type, U > >, mpl::not_<is_base_and_derived< U, - BOOST_DEDUCED_TYPENAME remove_reference< T >::type + 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){ #if defined(__BORLANDC__) return mpl::eval_if< boost::is_polymorphic<U>, mpl::identity<polymorphic>, mpl::identity<non_polymorphic> >::type::cast(u); #else - typedef BOOST_DEDUCED_TYPENAME mpl::eval_if< + typedef typename mpl::eval_if< boost::is_polymorphic<U>, mpl::identity<polymorphic>, mpl::identity<non_polymorphic> >::type typex; return typex::cast(u); #endif } }; 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 std::bad_cast(); + if ( tmp == 0 ) throw_exception(std::bad_cast()); #endif return tmp; } }; template<class U> static T cast(U * u){ // if we're in debug mode - #if ! defined(NDEBUG) || defined(__BORLANDC__) && (__BORLANDC__ <= 0x560) + #if 0 //! defined(NDEBUG) || defined(__BORLANDC__) && (__BORLANDC__ <= 0x560) // do a checked dynamic cast return cross::cast(u); #else // borland 5.51 chokes here so we can't use it // note: if remove_pointer 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 - BOOST_DEDUCED_TYPENAME mpl::eval_if< - BOOST_DEDUCED_TYPENAME mpl::and_< + typename mpl::eval_if< + typename mpl::and_< mpl::not_<is_base_and_derived< - BOOST_DEDUCED_TYPENAME remove_pointer< T >::type, + typename remove_pointer< T >::type, U > >, mpl::not_<is_base_and_derived< U, - BOOST_DEDUCED_TYPENAME remove_pointer< T >::type + typename remove_pointer< T >::type > > >, // borland chokes w/o full qualification here mpl::identity<cross>, mpl::identity<linear> >::type typex; return typex::cast(u); #endif } #else template<class U> static T cast(U * u){ T tmp = dynamic_cast< T >(u); #ifndef NDEBUG - if ( tmp == 0 ) throw std::bad_cast(); + 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){ #if defined(__BORLANDC__) return mpl::eval_if< boost::is_polymorphic<U>, mpl::identity<polymorphic>, mpl::identity<non_polymorphic> >::type::cast(u); #else - typedef BOOST_DEDUCED_TYPENAME mpl::eval_if< + typedef typename mpl::eval_if< boost::is_polymorphic<U>, mpl::identity<polymorphic>, mpl::identity<non_polymorphic> >::type typex; return typex::cast(u); #endif } }; 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 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 - BOOST_DEDUCED_TYPENAME mpl::eval_if< - BOOST_DEDUCED_TYPENAME mpl::or_< + 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 - BOOST_DEDUCED_TYPENAME mpl::eval_if<boost::is_pointer<U>, + typename mpl::eval_if<boost::is_pointer<U>, mpl::identity<smart_cast_impl::pointer< T > >, // else - BOOST_DEDUCED_TYPENAME mpl::eval_if<boost::is_reference<U>, + 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/3rdParty/Boost/src/boost/serialization/split_free.hpp b/3rdParty/Boost/src/boost/serialization/split_free.hpp index 9dbcd2f..85e2f59 100644 --- a/3rdParty/Boost/src/boost/serialization/split_free.hpp +++ b/3rdParty/Boost/src/boost/serialization/split_free.hpp @@ -1,93 +1,93 @@ #ifndef BOOST_SERIALIZATION_SPLIT_FREE_HPP #define BOOST_SERIALIZATION_SPLIT_FREE_HPP // MS compatible compilers support #pragma once -#if defined(_MSC_VER) && (_MSC_VER >= 1020) +#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 BOOST_DEDUCED_TYPENAME mpl::eval_if< - BOOST_DEDUCED_TYPENAME Archive::is_saving, + 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/3rdParty/Boost/src/boost/serialization/split_member.hpp b/3rdParty/Boost/src/boost/serialization/split_member.hpp index 6987945..5f32520 100644 --- a/3rdParty/Boost/src/boost/serialization/split_member.hpp +++ b/3rdParty/Boost/src/boost/serialization/split_member.hpp @@ -1,86 +1,86 @@ #ifndef BOOST_SERIALIZATION_SPLIT_MEMBER_HPP #define BOOST_SERIALIZATION_SPLIT_MEMBER_HPP // MS compatible compilers support #pragma once -#if defined(_MSC_VER) && (_MSC_VER >= 1020) +#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 BOOST_DEDUCED_TYPENAME mpl::eval_if< - BOOST_DEDUCED_TYPENAME Archive::is_saving, + 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/3rdParty/Boost/src/boost/serialization/state_saver.hpp b/3rdParty/Boost/src/boost/serialization/state_saver.hpp index 69cbe3e..6e6f985 100644 --- a/3rdParty/Boost/src/boost/serialization/state_saver.hpp +++ b/3rdParty/Boost/src/boost/serialization/state_saver.hpp @@ -1,40 +1,40 @@ #ifndef BOOST_SERIALIZATION_STATE_SAVER_HPP #define BOOST_SERIALIZATION_STATE_SAVER_HPP // MS compatible compilers support #pragma once -#if defined(_MSC_VER) && (_MSC_VER >= 1020) +#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/detail/no_exceptions_support.hpp> #include <boost/mpl/eval_if.hpp> #include <boost/mpl/identity.hpp> namespace boost { namespace serialization { @@ -45,52 +45,52 @@ template<class T> // - 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 BOOST_DEDUCED_TYPENAME mpl::eval_if< + 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/3rdParty/Boost/src/boost/serialization/static_warning.hpp b/3rdParty/Boost/src/boost/serialization/static_warning.hpp index b41791a..d2f23d3 100644 --- a/3rdParty/Boost/src/boost/serialization/static_warning.hpp +++ b/3rdParty/Boost/src/boost/serialization/static_warning.hpp @@ -1,108 +1,108 @@ #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) && (_MSC_VER >= 1020) +#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. The // only pragma which is absolutely necessary here is for Borland 5.x, since // W8073 is disabled by default. If enabling selected warnings is considered // unacceptable, this section can be replaced with: // #if defined(__BORLANDC__) && (__BORLANDC__ <= 0x600) // pragma warn +st // #endif // 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/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_JOIN(STATIC_WARNING_LINE, L) BOOST_STATIC_ASSERT_UNUSED_ATTRIBUTE; #define BOOST_STATIC_WARNING(B) BOOST_SERIALIZATION_BSW(B, __LINE__) #endif // BOOST_SERIALIZATION_STATIC_WARNING_HPP diff --git a/3rdParty/Boost/src/boost/serialization/string.hpp b/3rdParty/Boost/src/boost/serialization/string.hpp index 36d1594..d63df76 100644 --- a/3rdParty/Boost/src/boost/serialization/string.hpp +++ b/3rdParty/Boost/src/boost/serialization/string.hpp @@ -1,40 +1,40 @@ #ifndef BOOST_SERIALIZATION_STRING_HPP #define BOOST_SERIALIZATION_STRING_HPP // MS compatible compilers support #pragma once -#if defined(_MSC_VER) && (_MSC_VER >= 1020) +#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 // left over from a previous incarnation - strings are now always primitive types #if 0 #include <string> #include <boost/serialization/collections_save_imp.hpp> #include <boost/serialization/collections_load_imp.hpp> #include <boost/serialization/split_free.hpp> namespace boost { namespace serialization { // basic_string - general case diff --git a/3rdParty/Boost/src/boost/serialization/strong_typedef.hpp b/3rdParty/Boost/src/boost/serialization/strong_typedef.hpp index c6308c2..54a5162 100644 --- a/3rdParty/Boost/src/boost/serialization/strong_typedef.hpp +++ b/3rdParty/Boost/src/boost/serialization/strong_typedef.hpp @@ -1,40 +1,40 @@ #ifndef BOOST_SERIALIZATION_STRONG_TYPEDEF_HPP #define BOOST_SERIALIZATION_STRONG_TYPEDEF_HPP // MS compatible compilers support #pragma once -#if defined(_MSC_VER) && (_MSC_VER >= 1020) +#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 . // 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> #if !defined(__BORLANDC__) || __BORLANDC__ >= 0x590 #define BOOST_STRONG_TYPEDEF(T, D) \ struct D \ : boost::totally_ordered1< D \ , boost::totally_ordered2< D, T \ > > \ { \ T t; \ explicit D(const T t_) : t(t_) {}; \ D(): t() {}; \ D(const D & t_) : t(t_.t){} \ D & operator=(const D & rhs) { t = rhs.t; return *this;} \ D & operator=(const T & rhs) { t = rhs; return *this;} \ diff --git a/3rdParty/Boost/src/boost/serialization/throw_exception.hpp b/3rdParty/Boost/src/boost/serialization/throw_exception.hpp index ed7d810..b67618a 100644 --- a/3rdParty/Boost/src/boost/serialization/throw_exception.hpp +++ b/3rdParty/Boost/src/boost/serialization/throw_exception.hpp @@ -1,41 +1,41 @@ #ifndef BOOST_SERIALIZATION_THROW_EXCEPTION_HPP_INCLUDED #define BOOST_SERIALIZATION_THROW_EXCEPTION_HPP_INCLUDED // MS compatible compilers support #pragma once -#if defined(_MSC_VER) && (_MSC_VER >= 1020) +#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 diff --git a/3rdParty/Boost/src/boost/serialization/tracking.hpp b/3rdParty/Boost/src/boost/serialization/tracking.hpp index fadcbd0..d5c79b8 100644 --- a/3rdParty/Boost/src/boost/serialization/tracking.hpp +++ b/3rdParty/Boost/src/boost/serialization/tracking.hpp @@ -1,96 +1,96 @@ #ifndef BOOST_SERIALIZATION_TRACKING_HPP #define BOOST_SERIALIZATION_TRACKING_HPP // MS compatible compilers support #pragma once -#if defined(_MSC_VER) && (_MSC_VER >= 1020) +#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 BOOST_DEDUCED_TYPENAME U::tracking type; + 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 - BOOST_DEDUCED_TYPENAME mpl::eval_if< + typename mpl::eval_if< is_base_and_derived<boost::serialization::basic_traits, T>, traits_class_tracking< T >, //else - BOOST_DEDUCED_TYPENAME mpl::eval_if< + typename mpl::eval_if< is_pointer< T >, // pointers are not tracked by default mpl::int_<track_never>, //else - BOOST_DEDUCED_TYPENAME mpl::eval_if< + typename mpl::eval_if< // for primitives - BOOST_DEDUCED_TYPENAME mpl::equal_to< + 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 { \ diff --git a/3rdParty/Boost/src/boost/serialization/tracking_enum.hpp b/3rdParty/Boost/src/boost/serialization/tracking_enum.hpp index e4e4e21..278051e 100644 --- a/3rdParty/Boost/src/boost/serialization/tracking_enum.hpp +++ b/3rdParty/Boost/src/boost/serialization/tracking_enum.hpp @@ -1,40 +1,40 @@ #ifndef BOOST_SERIALIZATION_TRACKING_ENUM_HPP #define BOOST_SERIALIZATION_TRACKING_ENUM_HPP // MS compatible compilers support #pragma once -#if defined(_MSC_VER) && (_MSC_VER >= 1020) +#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 diff --git a/3rdParty/Boost/src/boost/serialization/traits.hpp b/3rdParty/Boost/src/boost/serialization/traits.hpp index da80009..d338b1b 100644 --- a/3rdParty/Boost/src/boost/serialization/traits.hpp +++ b/3rdParty/Boost/src/boost/serialization/traits.hpp @@ -1,65 +1,65 @@ #ifndef BOOST_SERIALIZATION_TRAITS_HPP #define BOOST_SERIALIZATION_TRAITS_HPP // MS compatible compilers support #pragma once -#if defined(_MSC_VER) && (_MSC_VER >= 1020) +#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.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 BOOST_DEDUCED_TYPENAME mpl::int_<Level> level; - typedef BOOST_DEDUCED_TYPENAME mpl::int_<Tracking> tracking; - typedef BOOST_DEDUCED_TYPENAME mpl::int_<Version> version; + 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/3rdParty/Boost/src/boost/serialization/type_info_implementation.hpp b/3rdParty/Boost/src/boost/serialization/type_info_implementation.hpp index 00eb152..2c033fc 100644 --- a/3rdParty/Boost/src/boost/serialization/type_info_implementation.hpp +++ b/3rdParty/Boost/src/boost/serialization/type_info_implementation.hpp @@ -1,83 +1,83 @@ #ifndef BOOST_SERIALIZATION_TYPE_INFO_IMPLEMENTATION_HPP #define BOOST_SERIALIZATION_TYPE_INFO_IMPLEMENTATION_HPP // MS compatible compilers support #pragma once -#if defined(_MSC_VER) && (_MSC_VER >= 1020) +#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 BOOST_DEDUCED_TYPENAME U::type_info_implementation::type type; + typedef typename U::type_info_implementation::type type; }; // note: at least one compiler complained w/o the full qualification // on basic traits below typedef - BOOST_DEDUCED_TYPENAME mpl::eval_if< + typename mpl::eval_if< is_base_and_derived<boost::serialization::basic_traits, T>, traits_class_typeinfo_implementation< T >, //else mpl::identity< - BOOST_DEDUCED_TYPENAME extended_type_info_impl< T >::type + 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. #if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x560)) #define BOOST_CLASS_TYPE_INFO(T, ETI) \ namespace boost { \ namespace serialization { \ template<> \ struct type_info_implementation< T > { \ typedef const ETI type; \ }; \ } \ } \ /**/ #else #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; \ }; \ } \ } \ /**/ diff --git a/3rdParty/Boost/src/boost/serialization/utility.hpp b/3rdParty/Boost/src/boost/serialization/utility.hpp index 3d69abc..4867a4a 100644 --- a/3rdParty/Boost/src/boost/serialization/utility.hpp +++ b/3rdParty/Boost/src/boost/serialization/utility.hpp @@ -1,56 +1,56 @@ #ifndef BOOST_SERIALIZATION_UTILITY_HPP #define BOOST_SERIALIZATION_UTILITY_HPP // MS compatible compilers support #pragma once -#if defined(_MSC_VER) && (_MSC_VER >= 1020) +#if defined(_MSC_VER) # pragma once #endif /////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8 // serialization/utility.hpp: // serialization for stl utility 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 <utility> #include <boost/config.hpp> #include <boost/type_traits/remove_const.hpp> #include <boost/serialization/nvp.hpp> #include <boost/serialization/is_bitwise_serializable.hpp> #include <boost/mpl/and.hpp> namespace boost { namespace serialization { // pair template<class Archive, class F, class S> inline void serialize( Archive & ar, std::pair<F, S> & p, const unsigned int /* file_version */ ){ // note: we remove any const-ness on the first argument. The reason is that // for stl maps, the type saved is pair<const key, T). We remove // the const-ness in order to be able to load it. - typedef BOOST_DEDUCED_TYPENAME boost::remove_const<F>::type typef; + typedef typename boost::remove_const<F>::type typef; ar & boost::serialization::make_nvp("first", const_cast<typef &>(p.first)); ar & boost::serialization::make_nvp("second", p.second); } /// specialization of is_bitwise_serializable for pairs template <class T, class U> struct is_bitwise_serializable<std::pair<T,U> > : public mpl::and_<is_bitwise_serializable< T >,is_bitwise_serializable<U> > { }; } // serialization } // namespace boost #endif // BOOST_SERIALIZATION_UTILITY_HPP diff --git a/3rdParty/Boost/src/boost/serialization/vector.hpp b/3rdParty/Boost/src/boost/serialization/vector.hpp index 7520c09..3af1d67 100644 --- a/3rdParty/Boost/src/boost/serialization/vector.hpp +++ b/3rdParty/Boost/src/boost/serialization/vector.hpp @@ -1,40 +1,40 @@ #ifndef BOOST_SERIALIZATION_VECTOR_HPP #define BOOST_SERIALIZATION_VECTOR_HPP // MS compatible compilers support #pragma once -#if defined(_MSC_VER) && (_MSC_VER >= 1020) +#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/type_traits/is_arithmetic.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.hpp> #include <boost/serialization/detail/get_data.hpp> #include <boost/mpl/bool.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) @@ -89,132 +89,128 @@ inline void save( const unsigned int /* file_version */, mpl::true_ ){ const collection_size_type count(t.size()); ar << BOOST_SERIALIZATION_NVP(count); if (!t.empty()) ar << make_array(detail::get_data(t),t.size()); } 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()) ar >> make_array(detail::get_data(t),t.size()); } // 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 BOOST_DEDUCED_TYPENAME + typedef typename boost::serialization::use_array_optimization<Archive>::template apply< - BOOST_DEDUCED_TYPENAME remove_const<U>::type + 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 BOOST_DEDUCED_TYPENAME + typedef typename boost::serialization::use_array_optimization<Archive>::template apply< - BOOST_DEDUCED_TYPENAME remove_const<U>::type + 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); } -#if ! BOOST_WORKAROUND(BOOST_MSVC, <= 1300) - /////////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.clear(); while(count-- > 0){ bool i; ar >> boost::serialization::make_nvp("item", i); t.push_back(i); } } // 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); } -#endif // BOOST_WORKAROUND - } // 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/3rdParty/Boost/src/boost/serialization/version.hpp b/3rdParty/Boost/src/boost/serialization/version.hpp index ef3dff2..21a74d7 100644 --- a/3rdParty/Boost/src/boost/serialization/version.hpp +++ b/3rdParty/Boost/src/boost/serialization/version.hpp @@ -1,82 +1,82 @@ #ifndef BOOST_SERIALIZATION_VERSION_HPP #define BOOST_SERIALIZATION_VERSION_HPP // MS compatible compilers support #pragma once -#if defined(_MSC_VER) && (_MSC_VER >= 1020) +#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 BOOST_DEDUCED_TYPENAME U::version type; + 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 - BOOST_DEDUCED_TYPENAME mpl::eval_if< + 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 { \ diff --git a/3rdParty/Boost/src/boost/serialization/void_cast.hpp b/3rdParty/Boost/src/boost/serialization/void_cast.hpp index b5b1e85..61b6449 100644 --- a/3rdParty/Boost/src/boost/serialization/void_cast.hpp +++ b/3rdParty/Boost/src/boost/serialization/void_cast.hpp @@ -1,40 +1,40 @@ #ifndef BOOST_SERIALIZATION_VOID_CAST_HPP #define BOOST_SERIALIZATION_VOID_CAST_HPP // MS compatible compilers support #pragma once -#if defined(_MSC_VER) && (_MSC_VER >= 1020) +#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 { @@ -149,150 +149,150 @@ public: # pragma warning(push) # pragma warning(disable : 4251 4231 4660 4275 4511 4512) #endif template <class Derived, class Base> class 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:I wanted to display from 0 here, but at least one compiler + // note:I wanted to displace from 0 here, but at least one compiler // treated 0 by not shifting it at all. reinterpret_cast<std::ptrdiff_t>( static_cast<Derived *>( - reinterpret_cast<Base *>(1) + reinterpret_cast<Base *>(8) ) - ) - 1 + ) - 8 ) { recursive_register(); } template <class Derived, class Base> void_caster_primitive<Derived, Base>::~void_caster_primitive(){ recursive_unregister(); } template <class Derived, class Base> class 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 void_caster_base : public void_caster { typedef - BOOST_DEDUCED_TYPENAME mpl::eval_if<boost::is_virtual_base_of<Base,Derived>, + 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 - BOOST_DEDUCED_TYPENAME mpl::eval_if<boost::is_virtual_base_of<Base,Derived>, + 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 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/3rdParty/Boost/src/boost/serialization/void_cast_fwd.hpp b/3rdParty/Boost/src/boost/serialization/void_cast_fwd.hpp index c94adb2..def61d5 100644 --- a/3rdParty/Boost/src/boost/serialization/void_cast_fwd.hpp +++ b/3rdParty/Boost/src/boost/serialization/void_cast_fwd.hpp @@ -1,37 +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) && (_MSC_VER >= 1020) +#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/3rdParty/Boost/src/boost/serialization/wrapper.hpp b/3rdParty/Boost/src/boost/serialization/wrapper.hpp index eeb4333..6a2a730 100644 --- a/3rdParty/Boost/src/boost/serialization/wrapper.hpp +++ b/3rdParty/Boost/src/boost/serialization/wrapper.hpp @@ -9,52 +9,52 @@ #include <boost/serialization/traits.hpp> #include <boost/type_traits/is_base_and_derived.hpp> #include <boost/mpl/eval_if.hpp> #include <boost/mpl/bool.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 BOOST_DEDUCED_TYPENAME is_wrapper_impl<const T>::type type; + 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 |