Swiftdiff options
Diffstat (limited to '3rdParty/Boost/src/boost/archive')
85 files changed, 869 insertions, 959 deletions
diff --git a/3rdParty/Boost/src/boost/archive/add_facet.hpp b/3rdParty/Boost/src/boost/archive/add_facet.hpp index 6bafe9b..242bdd9 100644 --- a/3rdParty/Boost/src/boost/archive/add_facet.hpp +++ b/3rdParty/Boost/src/boost/archive/add_facet.hpp @@ -1,40 +1,40 @@ #ifndef BOOST_ARCHIVE_ADD_FACET_HPP #define BOOST_ARCHIVE_ADD_FACET_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 // add_facet.hpp // (C) Copyright 2003 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 <locale> #include <boost/config.hpp> #include <boost/detail/workaround.hpp> // does STLport uses native STL for locales? #if (defined(__SGI_STL_PORT)&& defined(_STLP_NO_OWN_IOSTREAMS)) // and this native STL lib is old Dinkumware (has not defined _CPPLIB_VER) # if (defined(_YVALS) && !defined(__IBMCPP__)) || !defined(_CPPLIB_VER) # define BOOST_ARCHIVE_OLD_DINKUMWARE_BENEATH_STLPORT # endif #endif namespace boost { namespace archive { template<class Facet> inline std::locale * add_facet(const std::locale &l, Facet * f){ return #if defined BOOST_ARCHIVE_OLD_DINKUMWARE_BENEATH_STLPORT // std namespace used for native locale new std::locale(std::_Addfac(l, f)); diff --git a/3rdParty/Boost/src/boost/archive/archive_exception.hpp b/3rdParty/Boost/src/boost/archive/archive_exception.hpp index b5f33f6..ffb430c 100644 --- a/3rdParty/Boost/src/boost/archive/archive_exception.hpp +++ b/3rdParty/Boost/src/boost/archive/archive_exception.hpp @@ -1,97 +1,99 @@ #ifndef BOOST_ARCHIVE_ARCHIVE_EXCEPTION_HPP #define BOOST_ARCHIVE_ARCHIVE_EXCEPTION_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 // archive/archive_exception.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 <exception> #include <boost/assert.hpp> #include <string> #include <boost/config.hpp> #include <boost/preprocessor/empty.hpp> #include <boost/archive/detail/decl.hpp> // note: the only reason this is in here is that windows header // includes #define exception_code _exception_code (arrrgghhhh!). // the most expedient way to address this is be sure that this // header is always included whenever this header file is included. #if defined(BOOST_WINDOWS) #include <excpt.h> #endif #include <boost/archive/detail/abi_prefix.hpp> // must be the last header namespace boost { namespace archive { ////////////////////////////////////////////////////////////////////// // exceptions thrown by archives // class BOOST_ARCHIVE_DECL(BOOST_PP_EMPTY()) archive_exception : public virtual std::exception { +protected: + char m_buffer[128]; public: typedef enum { no_exception, // initialized without code other_exception, // any excepton not listed below - unregistered_class, // attempt to serialize a pointer of an + unregistered_class, // attempt to serialize a pointer of // an unregistered class invalid_signature, // first line of archive does not contain // expected string unsupported_version,// archive created with library version // subsequent to this one pointer_conflict, // an attempt has been made to directly // serialize an object which has - // already been serialzed through a pointer. - // Were this permited, the archive load would result + // already been serialized through a pointer. + // Were this permitted, the archive load would result // in the creation of an extra copy of the obect. incompatible_native_format, // attempt to read native binary format // on incompatible platform array_size_too_short,// array being loaded doesn't fit in array allocated input_stream_error, // error on input stream invalid_class_name, // class name greater than the maximum permitted. // most likely a corrupted archive or an attempt // to insert virus via buffer overrun method. unregistered_cast, // base - derived relationship not registered with // void_cast_register unsupported_class_version, // type saved with a version # greater than the - // one used by the program. This indicates that the proggram + // one used by the program. This indicates that the program // needs to be rebuilt. multiple_code_instantiation, // code for implementing serialization for some // type has been instantiated in more than one module. output_stream_error // error on input stream } exception_code; -protected: - std::string m_msg; public: exception_code code; archive_exception( exception_code c, const char * e1 = NULL, const char * e2 = NULL ); - ~archive_exception() throw (); - virtual const char *what( ) const throw(); + virtual ~archive_exception() throw(); + virtual const char *what() const throw(); protected: + unsigned int + append(unsigned int l, const char * a); archive_exception(); }; }// namespace archive }// namespace boost #include <boost/archive/detail/abi_suffix.hpp> // pops abi_suffix.hpp pragmas #endif //BOOST_ARCHIVE_ARCHIVE_EXCEPTION_HPP diff --git a/3rdParty/Boost/src/boost/archive/basic_archive.hpp b/3rdParty/Boost/src/boost/archive/basic_archive.hpp index c5ac880..0412112 100644 --- a/3rdParty/Boost/src/boost/archive/basic_archive.hpp +++ b/3rdParty/Boost/src/boost/archive/basic_archive.hpp @@ -1,53 +1,53 @@ #ifndef BOOST_ARCHIVE_BASIC_ARCHIVE_HPP #define BOOST_ARCHIVE_BASIC_ARCHIVE_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 // basic_archive.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 <cstring> // count #include <boost/assert.hpp> #include <boost/config.hpp> #include <boost/cstdint.hpp> // size_t #include <boost/noncopyable.hpp> #include <boost/integer_traits.hpp> #include <boost/archive/detail/auto_link_archive.hpp> #include <boost/archive/detail/abi_prefix.hpp> // must be the last header namespace boost { namespace archive { #if defined(_MSC_VER) #pragma warning( push ) #pragma warning( disable : 4244 4267 ) #endif /* NOTE : Warning : Warning : Warning : Warning : Warning * Don't ever changes this. If you do, they previously created * binary archives won't be readable !!! */ class library_version_type { private: typedef uint_least16_t base_type; base_type t; public: library_version_type(): t(0) {}; explicit library_version_type(const unsigned int & t_) : t(t_){ BOOST_ASSERT(t_ <= boost::integer_traits<base_type>::const_max); } library_version_type(const library_version_type & t_) : t(t_.t) {} library_version_type & operator=(const library_version_type & rhs){ t = rhs.t; @@ -189,70 +189,73 @@ struct tracking_type { tracking_type(const tracking_type & t_) : t(t_.t) {} operator bool () const { return t; }; operator bool & () { return t; }; tracking_type & operator=(const bool t_){ t = t_; return *this; } bool operator==(const tracking_type & rhs) const { return t == rhs.t; } bool operator==(const bool & rhs) const { return t == rhs; } tracking_type & operator=(const tracking_type & rhs){ t = rhs.t; return *this; } }; struct class_name_type : private boost::noncopyable { char *t; operator const char * & () const { return const_cast<const char * &>(t); } operator char * () { return t; } + std::size_t size() const { + return std::strlen(t); + } explicit class_name_type(const char *key_) : t(const_cast<char *>(key_)){} explicit class_name_type(char *key_) : t(key_){} class_name_type & operator=(const class_name_type & rhs){ t = rhs.t; return *this; } }; enum archive_flags { no_header = 1, // suppress archive header info no_codecvt = 2, // suppress alteration of codecvt facet no_xml_tag_checking = 4, // suppress checking of xml tags no_tracking = 8, // suppress ALL tracking flags_last = 8 }; BOOST_ARCHIVE_DECL(const char *) BOOST_ARCHIVE_SIGNATURE(); /* NOTE : Warning : Warning : Warning : Warning : Warning * If any of these are changed to different sized types, * binary_iarchive won't be able to read older archives * unless you rev the library version and include conditional * code based on the library version. There is nothing * inherently wrong in doing this - but you have to be super * careful because it's easy to get wrong and start breaking * old archives !!! */ #define BOOST_ARCHIVE_STRONG_TYPEDEF(T, D) \ class D : public T { \ public: \ explicit D(const T tt) : T(tt){} \ diff --git a/3rdParty/Boost/src/boost/archive/basic_binary_iarchive.hpp b/3rdParty/Boost/src/boost/archive/basic_binary_iarchive.hpp index d851dab..a649d5e 100644 --- a/3rdParty/Boost/src/boost/archive/basic_binary_iarchive.hpp +++ b/3rdParty/Boost/src/boost/archive/basic_binary_iarchive.hpp @@ -1,96 +1,102 @@ #ifndef BOOST_ARCHIVE_BASIC_BINARY_IARCHIVE_HPP #define BOOST_ARCHIVE_BASIC_BINARY_IARCHIVE_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 // basic_binary_iarchive.hpp // // archives stored as native binary - this should be the fastest way // to archive the state of a group of obects. It makes no attempt to // convert to any canonical form. // IN GENERAL, ARCHIVES CREATED WITH THIS CLASS WILL NOT BE READABLE // ON PLATFORM APART FROM THE ONE THEY ARE CREATED ON // (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/serialization/pfto.hpp> #include <boost/archive/basic_archive.hpp> #include <boost/archive/detail/common_iarchive.hpp> #include <boost/serialization/collection_size_type.hpp> #include <boost/serialization/string.hpp> #include <boost/serialization/item_version_type.hpp> #include <boost/integer_traits.hpp> #ifdef BOOST_MSVC # pragma warning(push) # pragma warning(disable : 4511 4512) #endif #include <boost/archive/detail/abi_prefix.hpp> // must be the last header namespace boost { namespace archive { +namespace detail { + template<class Archive> class interface_iarchive; +} // namespace detail + ///////////////////////////////////////////////////////////////////////// // class basic_binary_iarchive - read serialized objects from a input binary stream template<class Archive> class basic_binary_iarchive : public detail::common_iarchive<Archive> { -protected: -#if BOOST_WORKAROUND(BOOST_MSVC, <= 1300) +#ifdef BOOST_NO_MEMBER_TEMPLATE_FRIENDS public: -#elif defined(BOOST_MSVC) - // for some inexplicable reason insertion of "class" generates compile erro - // on msvc 7.1 - friend detail::interface_iarchive<Archive>; #else - friend class detail::interface_iarchive<Archive>; +protected: + #if BOOST_WORKAROUND(BOOST_MSVC, < 1500) + // for some inexplicable reason insertion of "class" generates compile erro + // on msvc 7.1 + friend detail::interface_iarchive<Archive>; + #else + friend class detail::interface_iarchive<Archive>; + #endif #endif // intermediate level to support override of operators // fot templates in the absence of partial function // template ordering. If we get here pass to base class // note extra nonsense to sneak it pass the borland compiers typedef detail::common_iarchive<Archive> detail_common_iarchive; template<class T> void load_override(T & t, BOOST_PFTO int version){ this->detail_common_iarchive::load_override(t, static_cast<int>(version)); } // include these to trap a change in binary format which // isn't specifically handled // upto 32K classes BOOST_STATIC_ASSERT(sizeof(class_id_type) == sizeof(int_least16_t)); BOOST_STATIC_ASSERT(sizeof(class_id_reference_type) == sizeof(int_least16_t)); // upto 2G objects BOOST_STATIC_ASSERT(sizeof(object_id_type) == sizeof(uint_least32_t)); BOOST_STATIC_ASSERT(sizeof(object_reference_type) == sizeof(uint_least32_t)); // binary files don't include the optional information void load_override(class_id_optional_type & /* t */, int){} void load_override(tracking_type & t, int /*version*/){ library_version_type lvt = this->get_library_version(); if(boost::archive::library_version_type(6) < lvt){ int_least8_t x=0; * this->This() >> x; t = boost::archive::tracking_type(x); } else{ bool x=0; * this->This() >> x; t = boost::archive::tracking_type(x); } diff --git a/3rdParty/Boost/src/boost/archive/basic_binary_iprimitive.hpp b/3rdParty/Boost/src/boost/archive/basic_binary_iprimitive.hpp index fc27123..2e72a1c 100644 --- a/3rdParty/Boost/src/boost/archive/basic_binary_iprimitive.hpp +++ b/3rdParty/Boost/src/boost/archive/basic_binary_iprimitive.hpp @@ -1,40 +1,40 @@ #ifndef BOOST_ARCHIVE_BINARY_IPRIMITIVE_HPP #define BOOST_ARCHIVE_BINARY_IPRIMITIVE_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) #pragma warning( disable : 4800 ) #endif /////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8 // basic_binary_iprimitive.hpp // // archives stored as native binary - this should be the fastest way // to archive the state of a group of obects. It makes no attempt to // convert to any canonical form. // IN GENERAL, ARCHIVES CREATED WITH THIS CLASS WILL NOT BE READABLE // ON PLATFORM APART FROM THE ONE THEY ARE CREATED ON // (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 <iosfwd> #include <boost/assert.hpp> #include <locale> #include <cstring> // std::memcpy #include <cstddef> // std::size_t #include <streambuf> // basic_streambuf #include <string> #include <boost/config.hpp> #if defined(BOOST_NO_STDC_NAMESPACE) namespace std{ @@ -94,97 +94,97 @@ public: // trap usage of invalid uninitialized boolean void load(bool & t){ load_binary(& t, sizeof(t)); int i = t; BOOST_ASSERT(0 == i || 1 == i); (void)i; // warning suppression for release builds. } BOOST_ARCHIVE_OR_WARCHIVE_DECL(void) load(std::string &s); #ifndef BOOST_NO_STD_WSTRING BOOST_ARCHIVE_OR_WARCHIVE_DECL(void) load(std::wstring &ws); #endif BOOST_ARCHIVE_OR_WARCHIVE_DECL(void) load(char * t); BOOST_ARCHIVE_OR_WARCHIVE_DECL(void) load(wchar_t * t); BOOST_ARCHIVE_OR_WARCHIVE_DECL(void) init(); BOOST_ARCHIVE_OR_WARCHIVE_DECL(BOOST_PP_EMPTY()) basic_binary_iprimitive( std::basic_streambuf<Elem, Tr> & sb, bool no_codecvt ); BOOST_ARCHIVE_OR_WARCHIVE_DECL(BOOST_PP_EMPTY()) ~basic_binary_iprimitive(); public: // we provide an optimized load for all fundamental types // typedef serialization::is_bitwise_serializable<mpl::_1> // use_array_optimization; struct use_array_optimization { template <class T> #if defined(BOOST_NO_DEPENDENT_NESTED_DERIVATIONS) struct apply { - typedef BOOST_DEDUCED_TYPENAME boost::serialization::is_bitwise_serializable< T >::type type; + typedef typename boost::serialization::is_bitwise_serializable< T >::type type; }; #else struct apply : public boost::serialization::is_bitwise_serializable< T > {}; #endif }; // the optimized load_array dispatches to load_binary template <class ValueType> void load_array(serialization::array<ValueType>& a, unsigned int) { load_binary(a.address(),a.count()*sizeof(ValueType)); } void load_binary(void *address, std::size_t count); }; template<class Archive, class Elem, class Tr> inline void basic_binary_iprimitive<Archive, Elem, Tr>::load_binary( void *address, std::size_t count ){ // note: an optimizer should eliminate the following for char files BOOST_ASSERT( static_cast<std::streamsize>(count / sizeof(Elem)) <= boost::integer_traits<std::streamsize>::const_max ); std::streamsize s = static_cast<std::streamsize>(count / sizeof(Elem)); std::streamsize scount = m_sb.sgetn( static_cast<Elem *>(address), s ); if(scount != s) boost::serialization::throw_exception( archive_exception(archive_exception::input_stream_error) ); // note: an optimizer should eliminate the following for char files BOOST_ASSERT(count % sizeof(Elem) <= boost::integer_traits<std::streamsize>::const_max); s = static_cast<std::streamsize>(count % sizeof(Elem)); if(0 < s){ // if(is.fail()) // boost::serialization::throw_exception( // archive_exception(archive_exception::stream_error) // ); Elem t; scount = m_sb.sgetn(& t, 1); if(scount != 1) boost::serialization::throw_exception( archive_exception(archive_exception::input_stream_error) ); - std::memcpy(static_cast<char*>(address) + (count - s), &t, s); + std::memcpy(static_cast<char*>(address) + (count - s), &t, static_cast<std::size_t>(s)); } } } // namespace archive } // namespace boost #include <boost/archive/detail/abi_suffix.hpp> // pop pragmas #endif // BOOST_ARCHIVE_BINARY_IPRIMITIVE_HPP diff --git a/3rdParty/Boost/src/boost/archive/basic_binary_oarchive.hpp b/3rdParty/Boost/src/boost/archive/basic_binary_oarchive.hpp index 01622b9..f8b53e9 100644 --- a/3rdParty/Boost/src/boost/archive/basic_binary_oarchive.hpp +++ b/3rdParty/Boost/src/boost/archive/basic_binary_oarchive.hpp @@ -1,104 +1,110 @@ #ifndef BOOST_ARCHIVE_BASIC_BINARY_OARCHIVE_HPP #define BOOST_ARCHIVE_BASIC_BINARY_OARCHIVE_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 // basic_binary_oarchive.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. // archives stored as native binary - this should be the fastest way // to archive the state of a group of obects. It makes no attempt to // convert to any canonical form. // IN GENERAL, ARCHIVES CREATED WITH THIS CLASS WILL NOT BE READABLE // ON PLATFORM APART FROM THE ONE THEY ARE CREATE ON #include <boost/assert.hpp> #include <boost/config.hpp> #include <boost/detail/workaround.hpp> #include <boost/serialization/pfto.hpp> #include <boost/integer.hpp> #include <boost/integer_traits.hpp> #include <boost/archive/detail/common_oarchive.hpp> #include <boost/serialization/string.hpp> #include <boost/serialization/collection_size_type.hpp> #include <boost/serialization/item_version_type.hpp> #include <boost/archive/detail/abi_prefix.hpp> // must be the last header #ifdef BOOST_MSVC # pragma warning(push) # pragma warning(disable : 4511 4512) #endif namespace boost { namespace archive { +namespace detail { + template<class Archive> class interface_oarchive; +} // namespace detail + ////////////////////////////////////////////////////////////////////// // class basic_binary_oarchive - write serialized objects to a binary output stream // note: this archive has no pretensions to portability. Archive format // may vary across machine architectures and compilers. About the only // guarentee is that an archive created with this code will be readable // by a program built with the same tools for the same machne. This class // does have the virtue of buiding the smalles archive in the minimum amount // of time. So under some circumstances it may be he right choice. template<class Archive> class basic_binary_oarchive : public archive::detail::common_oarchive<Archive> { -protected: -#if BOOST_WORKAROUND(BOOST_MSVC, <= 1300) +#ifdef BOOST_NO_MEMBER_TEMPLATE_FRIENDS public: -#elif defined(BOOST_MSVC) - // for some inexplicable reason insertion of "class" generates compile erro - // on msvc 7.1 - friend detail::interface_oarchive<Archive>; #else - friend class detail::interface_oarchive<Archive>; +protected: + #if BOOST_WORKAROUND(BOOST_MSVC, < 1500) + // for some inexplicable reason insertion of "class" generates compile erro + // on msvc 7.1 + friend detail::interface_oarchive<Archive>; + #else + friend class detail::interface_oarchive<Archive>; + #endif #endif // any datatype not specifed below will be handled by base class typedef detail::common_oarchive<Archive> detail_common_oarchive; template<class T> void save_override(const T & t, BOOST_PFTO int version){ this->detail_common_oarchive::save_override(t, static_cast<int>(version)); } // include these to trap a change in binary format which // isn't specifically handled BOOST_STATIC_ASSERT(sizeof(tracking_type) == sizeof(bool)); // upto 32K classes BOOST_STATIC_ASSERT(sizeof(class_id_type) == sizeof(int_least16_t)); BOOST_STATIC_ASSERT(sizeof(class_id_reference_type) == sizeof(int_least16_t)); // upto 2G objects BOOST_STATIC_ASSERT(sizeof(object_id_type) == sizeof(uint_least32_t)); BOOST_STATIC_ASSERT(sizeof(object_reference_type) == sizeof(uint_least32_t)); // binary files don't include the optional information void save_override(const class_id_optional_type & /* t */, int){} // enable this if we decide to support generation of previous versions #if 0 void save_override(const boost::archive::version_type & t, int version){ library_version_type lvt = this->get_library_version(); if(boost::archive::library_version_type(7) < lvt){ this->detail_common_oarchive::save_override(t, version); } else if(boost::archive::library_version_type(6) < lvt){ const boost::uint_least16_t x = t; * this->This() << x; } else{ const unsigned int x = t; diff --git a/3rdParty/Boost/src/boost/archive/basic_binary_oprimitive.hpp b/3rdParty/Boost/src/boost/archive/basic_binary_oprimitive.hpp index 53e44e4..ba070cd 100644 --- a/3rdParty/Boost/src/boost/archive/basic_binary_oprimitive.hpp +++ b/3rdParty/Boost/src/boost/archive/basic_binary_oprimitive.hpp @@ -1,184 +1,183 @@ #ifndef BOOST_ARCHIVE_BASIC_BINARY_OPRIMITIVE_HPP #define BOOST_ARCHIVE_BASIC_BINARY_OPRIMITIVE_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 // basic_binary_oprimitive.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. // archives stored as native binary - this should be the fastest way // to archive the state of a group of obects. It makes no attempt to // convert to any canonical form. // IN GENERAL, ARCHIVES CREATED WITH THIS CLASS WILL NOT BE READABLE // ON PLATFORM APART FROM THE ONE THEY ARE CREATE ON #include <iosfwd> #include <boost/assert.hpp> #include <locale> #include <streambuf> // basic_streambuf #include <string> #include <cstddef> // size_t #include <boost/config.hpp> #if defined(BOOST_NO_STDC_NAMESPACE) namespace std{ using ::size_t; } // namespace std #endif #include <boost/cstdint.hpp> #include <boost/integer.hpp> #include <boost/integer_traits.hpp> #include <boost/scoped_ptr.hpp> #include <boost/serialization/throw_exception.hpp> #include <boost/archive/basic_streambuf_locale_saver.hpp> #include <boost/archive/archive_exception.hpp> #include <boost/serialization/is_bitwise_serializable.hpp> #include <boost/mpl/placeholders.hpp> #include <boost/serialization/array.hpp> #include <boost/archive/detail/auto_link_archive.hpp> #include <boost/archive/detail/abi_prefix.hpp> // must be the last header namespace boost { namespace archive { ///////////////////////////////////////////////////////////////////////// // class basic_binary_oprimitive - binary output of prmitives template<class Archive, class Elem, class Tr> -class basic_binary_oprimitive -{ +class basic_binary_oprimitive { #ifndef BOOST_NO_MEMBER_TEMPLATE_FRIENDS friend class save_access; protected: #else public: #endif std::basic_streambuf<Elem, Tr> & m_sb; // return a pointer to the most derived class Archive * This(){ return static_cast<Archive *>(this); } #ifndef BOOST_NO_STD_LOCALE boost::scoped_ptr<std::locale> archive_locale; basic_streambuf_locale_saver<Elem, Tr> locale_saver; #endif // default saving of primitives. template<class T> void save(const T & t) { save_binary(& t, sizeof(T)); } ///////////////////////////////////////////////////////// // fundamental types that need special treatment // trap usage of invalid uninitialized boolean which would // otherwise crash on load. void save(const bool t){ BOOST_ASSERT(0 == static_cast<int>(t) || 1 == static_cast<int>(t)); save_binary(& t, sizeof(t)); } BOOST_ARCHIVE_OR_WARCHIVE_DECL(void) save(const std::string &s); #ifndef BOOST_NO_STD_WSTRING BOOST_ARCHIVE_OR_WARCHIVE_DECL(void) save(const std::wstring &ws); #endif BOOST_ARCHIVE_OR_WARCHIVE_DECL(void) save(const char * t); BOOST_ARCHIVE_OR_WARCHIVE_DECL(void) save(const wchar_t * t); BOOST_ARCHIVE_OR_WARCHIVE_DECL(void) init(); BOOST_ARCHIVE_OR_WARCHIVE_DECL(BOOST_PP_EMPTY()) basic_binary_oprimitive( std::basic_streambuf<Elem, Tr> & sb, bool no_codecvt ); BOOST_ARCHIVE_OR_WARCHIVE_DECL(BOOST_PP_EMPTY()) ~basic_binary_oprimitive(); public: // we provide an optimized save for all fundamental types // typedef serialization::is_bitwise_serializable<mpl::_1> // use_array_optimization; // workaround without using mpl lambdas struct use_array_optimization { template <class T> #if defined(BOOST_NO_DEPENDENT_NESTED_DERIVATIONS) struct apply { - typedef BOOST_DEDUCED_TYPENAME boost::serialization::is_bitwise_serializable< T >::type type; + typedef typename boost::serialization::is_bitwise_serializable< T >::type type; }; #else struct apply : public boost::serialization::is_bitwise_serializable< T > {}; #endif }; // the optimized save_array dispatches to save_binary template <class ValueType> void save_array(boost::serialization::array<ValueType> const& a, unsigned int) { save_binary(a.address(),a.count()*sizeof(ValueType)); } void save_binary(const void *address, std::size_t count); }; template<class Archive, class Elem, class Tr> inline void basic_binary_oprimitive<Archive, Elem, Tr>::save_binary( const void *address, std::size_t count ){ //BOOST_ASSERT( // static_cast<std::size_t>((std::numeric_limits<std::streamsize>::max)()) >= count //); // note: if the following assertions fail // a likely cause is that the output stream is set to "text" // mode where by cr characters recieve special treatment. // be sure that the output stream is opened with ios::binary //if(os.fail()) // boost::serialization::throw_exception( // archive_exception(archive_exception::output_stream_error) // ); // figure number of elements to output - round up count = ( count + sizeof(Elem) - 1) / sizeof(Elem); BOOST_ASSERT(count <= std::size_t(boost::integer_traits<std::streamsize>::const_max)); std::streamsize scount = m_sb.sputn( static_cast<const Elem *>(address), static_cast<std::streamsize>(count) ); if(count != static_cast<std::size_t>(scount)) boost::serialization::throw_exception( archive_exception(archive_exception::output_stream_error) ); //os.write( - // static_cast<const BOOST_DEDUCED_TYPENAME OStream::char_type *>(address), + // static_cast<const typename OStream::char_type *>(address), // count //); //BOOST_ASSERT(os.good()); } } //namespace boost } //namespace archive #include <boost/archive/detail/abi_suffix.hpp> // pop pragmas #endif // BOOST_ARCHIVE_BASIC_BINARY_OPRIMITIVE_HPP diff --git a/3rdParty/Boost/src/boost/archive/basic_streambuf_locale_saver.hpp b/3rdParty/Boost/src/boost/archive/basic_streambuf_locale_saver.hpp index ca764e1..6bf8f71 100644 --- a/3rdParty/Boost/src/boost/archive/basic_streambuf_locale_saver.hpp +++ b/3rdParty/Boost/src/boost/archive/basic_streambuf_locale_saver.hpp @@ -1,73 +1,73 @@ #ifndef BOOST_ARCHIVE_BASIC_STREAMBUF_LOCALE_SAVER_HPP #define BOOST_ARCHIVE_BASIC_STREAMBUF_LOCALE_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 // basic_streambuf_local_saver.hpp // (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) // See http://www.boost.org for updates, documentation, and revision history. // note derived from boost/io/ios_state.hpp // Copyright 2002, 2005 Daryle Walker. Use, modification, and distribution // are subject to the Boost Software License, Version 1.0. (See accompanying // file LICENSE_1_0.txt or a copy at <http://www.boost.org/LICENSE_1_0.txt>.) // See <http://www.boost.org/libs/io/> for the library's home page. #ifndef BOOST_NO_STD_LOCALE #include <locale> // for std::locale #include <streambuf> // for std::basic_streambuf #include <boost/config.hpp> #include <boost/noncopyable.hpp> #ifdef BOOST_MSVC # pragma warning(push) # pragma warning(disable : 4511 4512) #endif namespace boost{ namespace archive{ template < typename Ch, class Tr > class basic_streambuf_locale_saver : private boost::noncopyable { public: typedef ::std::basic_streambuf<Ch, Tr> state_type; typedef ::std::locale aspect_type; explicit basic_streambuf_locale_saver( state_type &s ) : s_save_( s ), a_save_( s.getloc() ) {} - basic_streambuf_locale_saver( state_type &s, aspect_type const &a ) + explicit basic_streambuf_locale_saver( state_type &s, aspect_type const &a ) : s_save_( s ), a_save_( s.pubimbue(a) ) {} ~basic_streambuf_locale_saver() { this->restore(); } void restore() { s_save_.pubimbue( a_save_ ); } private: state_type & s_save_; aspect_type const a_save_; }; } // archive } // boost #ifdef BOOST_MSVC #pragma warning(pop) #endif #endif // BOOST_NO_STD_LOCALE #endif // BOOST_ARCHIVE_BASIC_STREAMBUF_LOCALE_SAVER_HPP diff --git a/3rdParty/Boost/src/boost/archive/basic_text_iarchive.hpp b/3rdParty/Boost/src/boost/archive/basic_text_iarchive.hpp index 729d51a..0e78ff6 100644 --- a/3rdParty/Boost/src/boost/archive/basic_text_iarchive.hpp +++ b/3rdParty/Boost/src/boost/archive/basic_text_iarchive.hpp @@ -1,91 +1,97 @@ #ifndef BOOST_ARCHIVE_BASIC_TEXT_IARCHIVE_HPP #define BOOST_ARCHIVE_BASIC_TEXT_IARCHIVE_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 // basic_text_iarchive.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. // archives stored as text - note these ar templated on the basic // stream templates to accommodate wide (and other?) kind of characters // // note the fact that on libraries without wide characters, ostream is // is not a specialization of basic_ostream which in fact is not defined // in such cases. So we can't use basic_ostream<IStream::char_type> but rather // use two template parameters #include <boost/config.hpp> #include <boost/serialization/pfto.hpp> #include <boost/detail/workaround.hpp> #include <boost/archive/detail/common_iarchive.hpp> #include <boost/archive/detail/abi_prefix.hpp> // must be the last header #ifdef BOOST_MSVC # pragma warning(push) # pragma warning(disable : 4511 4512) #endif namespace boost { namespace archive { +namespace detail { + template<class Archive> class interface_iarchive; +} // namespace detail + ///////////////////////////////////////////////////////////////////////// // class basic_text_iarchive - read serialized objects from a input text stream template<class Archive> class basic_text_iarchive : public detail::common_iarchive<Archive> { -protected: -#if BOOST_WORKAROUND(BOOST_MSVC, <= 1300) +#ifdef BOOST_NO_MEMBER_TEMPLATE_FRIENDS public: -#elif defined(BOOST_MSVC) - // for some inexplicable reason insertion of "class" generates compile erro - // on msvc 7.1 - friend detail::interface_iarchive<Archive>; #else - friend class detail::interface_iarchive<Archive>; +protected: + #if BOOST_WORKAROUND(BOOST_MSVC, < 1500) + // for some inexplicable reason insertion of "class" generates compile erro + // on msvc 7.1 + friend detail::interface_iarchive<Archive>; + #else + friend class detail::interface_iarchive<Archive>; + #endif #endif // intermediate level to support override of operators // fot templates in the absence of partial function // template ordering typedef detail::common_iarchive<Archive> detail_common_iarchive; template<class T> void load_override(T & t, BOOST_PFTO int){ this->detail_common_iarchive::load_override(t, 0); } // text file don't include the optional information void load_override(class_id_optional_type & /*t*/, int){} BOOST_ARCHIVE_OR_WARCHIVE_DECL(void) load_override(class_name_type & t, int); BOOST_ARCHIVE_OR_WARCHIVE_DECL(void) init(void); basic_text_iarchive(unsigned int flags) : detail::common_iarchive<Archive>(flags) {} ~basic_text_iarchive(){} }; } // namespace archive } // namespace boost #ifdef BOOST_MSVC #pragma warning(pop) #endif #include <boost/archive/detail/abi_suffix.hpp> // pops abi_suffix.hpp pragmas #endif // BOOST_ARCHIVE_BASIC_TEXT_IARCHIVE_HPP diff --git a/3rdParty/Boost/src/boost/archive/basic_text_iprimitive.hpp b/3rdParty/Boost/src/boost/archive/basic_text_iprimitive.hpp index b927ec9..dabc3c8 100644 --- a/3rdParty/Boost/src/boost/archive/basic_text_iprimitive.hpp +++ b/3rdParty/Boost/src/boost/archive/basic_text_iprimitive.hpp @@ -1,127 +1,120 @@ #ifndef BOOST_ARCHIVE_BASIC_TEXT_IPRIMITIVE_HPP #define BOOST_ARCHIVE_BASIC_TEXT_IPRIMITIVE_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 // basic_text_iprimitive.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. // archives stored as text - note these are templated on the basic // stream templates to accommodate wide (and other?) kind of characters // // Note the fact that on libraries without wide characters, ostream is // not a specialization of basic_ostream which in fact is not defined // in such cases. So we can't use basic_ostream<IStream::char_type> but rather // use two template parameters #include <boost/assert.hpp> #include <locale> #include <cstddef> // size_t #include <boost/config.hpp> #if defined(BOOST_NO_STDC_NAMESPACE) namespace std{ using ::size_t; #if ! defined(BOOST_DINKUMWARE_STDLIB) && ! defined(__SGI_STL_PORT) using ::locale; #endif } // namespace std #endif #include <boost/detail/workaround.hpp> #if BOOST_WORKAROUND(BOOST_DINKUMWARE_STDLIB, == 1) #include <boost/archive/dinkumware.hpp> #endif #include <boost/limits.hpp> #include <boost/io/ios_state.hpp> #include <boost/scoped_ptr.hpp> #include <boost/static_assert.hpp> #include <boost/serialization/throw_exception.hpp> #include <boost/archive/archive_exception.hpp> #include <boost/archive/basic_streambuf_locale_saver.hpp> #include <boost/archive/detail/abi_prefix.hpp> // must be the last header namespace boost { namespace archive { ///////////////////////////////////////////////////////////////////////// // class basic_text_iarchive - load serialized objects from a input text stream #if defined(_MSC_VER) #pragma warning( push ) #pragma warning( disable : 4244 4267 ) #endif template<class IStream> -class basic_text_iprimitive -{ -#ifndef BOOST_NO_MEMBER_TEMPLATE_FRIENDS +class basic_text_iprimitive { protected: -#else -public: -#endif IStream &is; io::ios_flags_saver flags_saver; io::ios_precision_saver precision_saver; #ifndef BOOST_NO_STD_LOCALE boost::scoped_ptr<std::locale> archive_locale; basic_streambuf_locale_saver< - BOOST_DEDUCED_TYPENAME IStream::char_type, - BOOST_DEDUCED_TYPENAME IStream::traits_type + typename IStream::char_type, + typename IStream::traits_type > locale_saver; #endif template<class T> void load(T & t) { - if(! is.fail()){ - is >> t; + if(is >> t) return; - } boost::serialization::throw_exception( archive_exception(archive_exception::input_stream_error) ); } void load(char & t) { short int i; load(i); t = i; } void load(signed char & t) { short int i; load(i); t = i; } void load(unsigned char & t) { unsigned short int i; load(i); t = i; } #ifndef BOOST_NO_INTRINSIC_WCHAR_T void load(wchar_t & t) { BOOST_STATIC_ASSERT(sizeof(wchar_t) <= sizeof(int)); int i; load(i); t = i; } #endif BOOST_ARCHIVE_OR_WARCHIVE_DECL(BOOST_PP_EMPTY()) basic_text_iprimitive(IStream &is, bool no_codecvt); diff --git a/3rdParty/Boost/src/boost/archive/basic_text_oarchive.hpp b/3rdParty/Boost/src/boost/archive/basic_text_oarchive.hpp index dd10f65..bed9cd3 100644 --- a/3rdParty/Boost/src/boost/archive/basic_text_oarchive.hpp +++ b/3rdParty/Boost/src/boost/archive/basic_text_oarchive.hpp @@ -1,96 +1,102 @@ #ifndef BOOST_ARCHIVE_BASIC_TEXT_OARCHIVE_HPP #define BOOST_ARCHIVE_BASIC_TEXT_OARCHIVE_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 // basic_text_oarchive.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. // archives stored as text - note these ar templated on the basic // stream templates to accommodate wide (and other?) kind of characters // // note the fact that on libraries without wide characters, ostream is // is not a specialization of basic_ostream which in fact is not defined // in such cases. So we can't use basic_ostream<OStream::char_type> but rather // use two template parameters #include <boost/assert.hpp> #include <boost/config.hpp> #include <boost/serialization/pfto.hpp> #include <boost/detail/workaround.hpp> #include <boost/archive/detail/common_oarchive.hpp> #include <boost/serialization/string.hpp> #include <boost/archive/detail/abi_prefix.hpp> // must be the last header #ifdef BOOST_MSVC # pragma warning(push) # pragma warning(disable : 4511 4512) #endif namespace boost { namespace archive { +namespace detail { + template<class Archive> class interface_oarchive; +} // namespace detail + ///////////////////////////////////////////////////////////////////////// // class basic_text_oarchive template<class Archive> class basic_text_oarchive : public detail::common_oarchive<Archive> { -protected: -#if BOOST_WORKAROUND(BOOST_MSVC, <= 1300) \ -|| BOOST_WORKAROUND(__BORLANDC__,BOOST_TESTED_AT(0x560)) +#ifdef BOOST_NO_MEMBER_TEMPLATE_FRIENDS public: -#elif defined(BOOST_MSVC) - // for some inexplicable reason insertion of "class" generates compile erro - // on msvc 7.1 - friend detail::interface_oarchive<Archive>; #else - friend class detail::interface_oarchive<Archive>; +protected: + #if BOOST_WORKAROUND(BOOST_MSVC, < 1500) + // for some inexplicable reason insertion of "class" generates compile erro + // on msvc 7.1 + friend detail::interface_oarchive<Archive>; + #else + friend class detail::interface_oarchive<Archive>; + #endif #endif + enum { none, eol, space } delimiter; BOOST_ARCHIVE_OR_WARCHIVE_DECL(void) newtoken(); void newline(){ delimiter = eol; } // default processing - kick back to base class. Note the // extra stuff to get it passed borland compilers typedef detail::common_oarchive<Archive> detail_common_oarchive; template<class T> void save_override(T & t, BOOST_PFTO int){ this->detail_common_oarchive::save_override(t, 0); } // start new objects on a new line void save_override(const object_id_type & t, int){ this->This()->newline(); this->detail_common_oarchive::save_override(t, 0); } // text file don't include the optional information void save_override(const class_id_optional_type & /* t */, int){} void save_override(const class_name_type & t, int){ const std::string s(t); * this->This() << s; } diff --git a/3rdParty/Boost/src/boost/archive/basic_text_oprimitive.hpp b/3rdParty/Boost/src/boost/archive/basic_text_oprimitive.hpp index 06885ad..73a0a62 100644 --- a/3rdParty/Boost/src/boost/archive/basic_text_oprimitive.hpp +++ b/3rdParty/Boost/src/boost/archive/basic_text_oprimitive.hpp @@ -1,173 +1,206 @@ #ifndef BOOST_ARCHIVE_BASIC_TEXT_OPRIMITIVE_HPP #define BOOST_ARCHIVE_BASIC_TEXT_OPRIMITIVE_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 // basic_text_oprimitive.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. // archives stored as text - note these ar templated on the basic // stream templates to accommodate wide (and other?) kind of characters // // note the fact that on libraries without wide characters, ostream is // is not a specialization of basic_ostream which in fact is not defined // in such cases. So we can't use basic_ostream<OStream::char_type> but rather // use two template parameters #include <iomanip> #include <locale> -#include <boost/config/no_tr1/cmath.hpp> // isnan #include <boost/assert.hpp> #include <cstddef> // size_t #include <boost/config.hpp> #include <boost/static_assert.hpp> #include <boost/detail/workaround.hpp> +#include <boost/io/ios_state.hpp> + #if BOOST_WORKAROUND(BOOST_DINKUMWARE_STDLIB, == 1) #include <boost/archive/dinkumware.hpp> #endif #if defined(BOOST_NO_STDC_NAMESPACE) namespace std{ using ::size_t; #if ! defined(BOOST_DINKUMWARE_STDLIB) && ! defined(__SGI_STL_PORT) using ::locale; #endif } // namespace std #endif +#include <boost/type_traits/is_floating_point.hpp> +#include <boost/mpl/bool.hpp> #include <boost/limits.hpp> #include <boost/integer.hpp> #include <boost/io/ios_state.hpp> #include <boost/scoped_ptr.hpp> #include <boost/serialization/throw_exception.hpp> #include <boost/archive/archive_exception.hpp> #include <boost/archive/basic_streambuf_locale_saver.hpp> #include <boost/archive/detail/abi_prefix.hpp> // must be the last header namespace boost { namespace archive { class save_access; ///////////////////////////////////////////////////////////////////////// // class basic_text_oprimitive - output of prmitives to stream template<class OStream> class basic_text_oprimitive { -#ifndef BOOST_NO_MEMBER_TEMPLATE_FRIENDS protected: -#else -public: -#endif OStream &os; io::ios_flags_saver flags_saver; io::ios_precision_saver precision_saver; #ifndef BOOST_NO_STD_LOCALE boost::scoped_ptr<std::locale> archive_locale; basic_streambuf_locale_saver< - BOOST_DEDUCED_TYPENAME OStream::char_type, - BOOST_DEDUCED_TYPENAME OStream::traits_type + typename OStream::char_type, + typename OStream::traits_type > locale_saver; #endif - // default saving of primitives. - template<class T> - void save(const T &t){ - if(os.fail()) - boost::serialization::throw_exception( - archive_exception(archive_exception::output_stream_error) - ); - os << t; - } - ///////////////////////////////////////////////////////// // fundamental types that need special treatment void save(const bool t){ // trap usage of invalid uninitialized boolean which would // otherwise crash on load. BOOST_ASSERT(0 == static_cast<int>(t) || 1 == static_cast<int>(t)); if(os.fail()) boost::serialization::throw_exception( archive_exception(archive_exception::output_stream_error) ); os << t; } void save(const signed char t) { save(static_cast<short int>(t)); } void save(const unsigned char t) { save(static_cast<short unsigned int>(t)); } void save(const char t) { save(static_cast<short int>(t)); } #ifndef BOOST_NO_INTRINSIC_WCHAR_T void save(const wchar_t t) { BOOST_STATIC_ASSERT(sizeof(wchar_t) <= sizeof(int)); save(static_cast<int>(t)); } #endif - void save(const float t) - { - // must be a user mistake - can't serialize un-initialized data + + ///////////////////////////////////////////////////////// + // saving of any types not listed above + + template<class T> + void save_impl(const T &t, boost::mpl::bool_<false> &){ if(os.fail()) boost::serialization::throw_exception( archive_exception(archive_exception::output_stream_error) ); - os << std::setprecision(std::numeric_limits<float>::digits10 + 2); os << t; } - void save(const double t) - { + + ///////////////////////////////////////////////////////// + // floating point types need even more special treatment + // the following determines whether the type T is some sort + // of floating point type. Note that we then assume that + // the stream << operator is defined on that type - if not + // we'll get a compile time error. This is meant to automatically + // support synthesized types which support floating point + // operations. Also it should handle compiler dependent types + // such long double. Due to John Maddock. + + template<class T> + struct is_float { + typedef typename mpl::bool_< + boost::is_floating_point<T>::value + || (std::numeric_limits<T>::is_specialized + && !std::numeric_limits<T>::is_integer + && !std::numeric_limits<T>::is_exact + && std::numeric_limits<T>::max_exponent) + >::type type; + }; + + template<class T> + void save_impl(const T &t, boost::mpl::bool_<true> &){ // must be a user mistake - can't serialize un-initialized data if(os.fail()) boost::serialization::throw_exception( archive_exception(archive_exception::output_stream_error) ); - os << std::setprecision(std::numeric_limits<double>::digits10 + 2); - os << t; + // The formulae for the number of decimla digits required is given in + // http://www2.open-std.org/JTC1/SC22/WG21/docs/papers/2005/n1822.pdf + // which is derived from Kahan's paper: + // www.eecs.berkeley.edu/~wkahan/ieee754status/ieee754.ps + // const unsigned int digits = (std::numeric_limits<T>::digits * 3010) / 10000; + // note: I've commented out the above because I didn't get good results. e.g. + // in one case I got a difference of 19 units. + #ifndef BOOST_NO_CXX11_NUMERIC_LIMITS + const unsigned int digits = std::numeric_limits<T>::max_digits10; + #else + const unsigned int digits = std::numeric_limits<T>::digits10 + 2; + #endif + os << std::setprecision(digits) << std::scientific << t; } + + template<class T> + void save(const T & t){ + boost::io::ios_flags_saver fs(os); + boost::io::ios_precision_saver ps(os); + typename is_float<T>::type tf; + save_impl(t, tf); + } + BOOST_ARCHIVE_OR_WARCHIVE_DECL(BOOST_PP_EMPTY()) basic_text_oprimitive(OStream & os, bool no_codecvt); BOOST_ARCHIVE_OR_WARCHIVE_DECL(BOOST_PP_EMPTY()) ~basic_text_oprimitive(); public: // unformatted append of one character - void put(BOOST_DEDUCED_TYPENAME OStream::char_type c){ + void put(typename OStream::char_type c){ if(os.fail()) boost::serialization::throw_exception( archive_exception(archive_exception::output_stream_error) ); os.put(c); } // unformatted append of null terminated string void put(const char * s){ while('\0' != *s) os.put(*s++); } BOOST_ARCHIVE_OR_WARCHIVE_DECL(void) save_binary(const void *address, std::size_t count); }; } //namespace boost } //namespace archive #include <boost/archive/detail/abi_suffix.hpp> // pops abi_suffix.hpp pragmas #endif // BOOST_ARCHIVE_BASIC_TEXT_OPRIMITIVE_HPP diff --git a/3rdParty/Boost/src/boost/archive/basic_xml_archive.hpp b/3rdParty/Boost/src/boost/archive/basic_xml_archive.hpp index c99d94f..a4ad3a2 100644 --- a/3rdParty/Boost/src/boost/archive/basic_xml_archive.hpp +++ b/3rdParty/Boost/src/boost/archive/basic_xml_archive.hpp @@ -1,40 +1,40 @@ #ifndef BOOST_ARCHIVE_BASIC_XML_TEXT_ARCHIVE_HPP #define BOOST_ARCHIVE_BASIC_XML_TEXT_ARCHIVE_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 // basic_xml_archive.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/archive/archive_exception.hpp> #include <boost/archive/detail/auto_link_archive.hpp> #include <boost/archive/detail/abi_prefix.hpp> // must be the last header namespace boost { namespace archive { // constant strings used in xml i/o extern BOOST_ARCHIVE_DECL(const char *) BOOST_ARCHIVE_XML_OBJECT_ID(); extern BOOST_ARCHIVE_DECL(const char *) BOOST_ARCHIVE_XML_OBJECT_REFERENCE(); extern BOOST_ARCHIVE_DECL(const char *) BOOST_ARCHIVE_XML_CLASS_ID(); diff --git a/3rdParty/Boost/src/boost/archive/basic_xml_iarchive.hpp b/3rdParty/Boost/src/boost/archive/basic_xml_iarchive.hpp index d7b8bfd..5047fef 100644 --- a/3rdParty/Boost/src/boost/archive/basic_xml_iarchive.hpp +++ b/3rdParty/Boost/src/boost/archive/basic_xml_iarchive.hpp @@ -1,89 +1,95 @@ #ifndef BOOST_ARCHIVE_BASIC_XML_IARCHIVE_HPP #define BOOST_ARCHIVE_BASIC_XML_IARCHIVE_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 // basic_xml_iarchive.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/serialization/pfto.hpp> #include <boost/detail/workaround.hpp> #include <boost/archive/detail/common_iarchive.hpp> #include <boost/serialization/nvp.hpp> #include <boost/serialization/string.hpp> #include <boost/mpl/assert.hpp> #include <boost/archive/detail/abi_prefix.hpp> // must be the last header #ifdef BOOST_MSVC # pragma warning(push) # pragma warning(disable : 4511 4512) #endif namespace boost { namespace archive { +namespace detail { + template<class Archive> class interface_iarchive; +} // namespace detail + ///////////////////////////////////////////////////////////////////////// // class xml_iarchive - read serialized objects from a input text stream template<class Archive> class basic_xml_iarchive : public detail::common_iarchive<Archive> { -protected: -#if BOOST_WORKAROUND(BOOST_MSVC, <= 1300) +#ifdef BOOST_NO_MEMBER_TEMPLATE_FRIENDS public: -#elif defined(BOOST_MSVC) - // for some inexplicable reason insertion of "class" generates compile erro - // on msvc 7.1 - friend detail::interface_oarchive<Archive>; #else - friend class detail::interface_oarchive<Archive>; +protected: + #if BOOST_WORKAROUND(BOOST_MSVC, < 1500) + // for some inexplicable reason insertion of "class" generates compile erro + // on msvc 7.1 + friend detail::interface_iarchive<Archive>; + #else + friend class detail::interface_iarchive<Archive>; + #endif #endif unsigned int depth; BOOST_ARCHIVE_OR_WARCHIVE_DECL(void) load_start(const char *name); BOOST_ARCHIVE_OR_WARCHIVE_DECL(void) load_end(const char *name); // Anything not an attribute and not a name-value pair is an // should be trapped here. template<class T> void load_override(T & t, BOOST_PFTO int) { // If your program fails to compile here, its most likely due to // not specifying an nvp wrapper around the variable to // be serialized. BOOST_MPL_ASSERT((serialization::is_wrapper< T >)); this->detail_common_iarchive::load_override(t, 0); } // Anything not an attribute - see below - should be a name value // pair and be processed here typedef detail::common_iarchive<Archive> detail_common_iarchive; template<class T> void load_override( #ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING const #endif boost::serialization::nvp< T > & t, int ){ this->This()->load_start(t.name()); this->detail_common_iarchive::load_override(t.value(), 0); this->This()->load_end(t.name()); } diff --git a/3rdParty/Boost/src/boost/archive/basic_xml_oarchive.hpp b/3rdParty/Boost/src/boost/archive/basic_xml_oarchive.hpp index b571372..c986833 100644 --- a/3rdParty/Boost/src/boost/archive/basic_xml_oarchive.hpp +++ b/3rdParty/Boost/src/boost/archive/basic_xml_oarchive.hpp @@ -1,91 +1,96 @@ #ifndef BOOST_ARCHIVE_BASIC_XML_OARCHIVE_HPP #define BOOST_ARCHIVE_BASIC_XML_OARCHIVE_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 // basic_xml_oarchive.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/archive/detail/common_oarchive.hpp> #include <boost/serialization/nvp.hpp> #include <boost/serialization/tracking.hpp> #include <boost/serialization/string.hpp> #include <boost/mpl/assert.hpp> #include <boost/archive/detail/abi_prefix.hpp> // must be the last header #ifdef BOOST_MSVC # pragma warning(push) # pragma warning(disable : 4511 4512) #endif namespace boost { namespace archive { +namespace detail { + template<class Archive> class interface_oarchive; +} // namespace detail + ////////////////////////////////////////////////////////////////////// // class basic_xml_oarchive - write serialized objects to a xml output stream template<class Archive> class basic_xml_oarchive : public detail::common_oarchive<Archive> { -protected: -#if BOOST_WORKAROUND(BOOST_MSVC, <= 1300) +#ifdef BOOST_NO_MEMBER_TEMPLATE_FRIENDS public: -#elif defined(BOOST_MSVC) +#else +protected: +#endif +#if BOOST_WORKAROUND(BOOST_MSVC, < 1500) // for some inexplicable reason insertion of "class" generates compile erro // on msvc 7.1 friend detail::interface_oarchive<Archive>; - friend class save_access; #else friend class detail::interface_oarchive<Archive>; - friend class save_access; #endif + friend class save_access; // special stuff for xml output unsigned int depth; bool indent_next; bool pending_preamble; BOOST_ARCHIVE_OR_WARCHIVE_DECL(void) indent(); BOOST_ARCHIVE_OR_WARCHIVE_DECL(void) init(); BOOST_ARCHIVE_OR_WARCHIVE_DECL(void) write_attribute( const char *attribute_name, int t, const char *conjunction = "=\"" ); BOOST_ARCHIVE_OR_WARCHIVE_DECL(void) write_attribute( const char *attribute_name, const char *key ); // helpers used below BOOST_ARCHIVE_OR_WARCHIVE_DECL(void) save_start(const char *name); BOOST_ARCHIVE_OR_WARCHIVE_DECL(void) save_end(const char *name); BOOST_ARCHIVE_OR_WARCHIVE_DECL(void) end_preamble(); // Anything not an attribute and not a name-value pair is an // error and should be trapped here. template<class T> void save_override(T & t, BOOST_PFTO int) { // If your program fails to compile here, its most likely due to // not specifying an nvp wrapper around the variable to // be serialized. diff --git a/3rdParty/Boost/src/boost/archive/binary_iarchive.hpp b/3rdParty/Boost/src/boost/archive/binary_iarchive.hpp index 638d996..ce67cca 100644 --- a/3rdParty/Boost/src/boost/archive/binary_iarchive.hpp +++ b/3rdParty/Boost/src/boost/archive/binary_iarchive.hpp @@ -1,103 +1,64 @@ #ifndef BOOST_ARCHIVE_BINARY_IARCHIVE_HPP #define BOOST_ARCHIVE_BINARY_IARCHIVE_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 // binary_iarchive.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 <istream> #include <boost/archive/binary_iarchive_impl.hpp> #include <boost/archive/detail/register_archive.hpp> #ifdef BOOST_MSVC # pragma warning(push) # pragma warning(disable : 4511 4512) #endif -namespace boost { -namespace archive { - -// do not derive from the classes below. If you want to extend this functionality -// via inhertance, derived from text_iarchive_impl instead. This will -// preserve correct static polymorphism. - -// same as binary_iarchive below - without the shared_ptr_helper -class naked_binary_iarchive : - public binary_iarchive_impl< - boost::archive::naked_binary_iarchive, - std::istream::char_type, - std::istream::traits_type - > -{ -public: - naked_binary_iarchive(std::istream & is, unsigned int flags = 0) : - binary_iarchive_impl< - naked_binary_iarchive, std::istream::char_type, std::istream::traits_type - >(is, flags) - {} - naked_binary_iarchive(std::streambuf & bsb, unsigned int flags = 0) : - binary_iarchive_impl< - naked_binary_iarchive, std::istream::char_type, std::istream::traits_type - >(bsb, flags) - {} -}; - -} // namespace archive -} // namespace boost - -// note special treatment of shared_ptr. This type needs a special -// structure associated with every archive. We created a "mix-in" -// class to provide this functionality. Since shared_ptr holds a -// special esteem in the boost library - we included it here by default. -#include <boost/archive/shared_ptr_helper.hpp> - -namespace boost { +namespace boost { namespace archive { // do not derive from this class. If you want to extend this functionality // via inhertance, derived from binary_iarchive_impl instead. This will // preserve correct static polymorphism. class binary_iarchive : public binary_iarchive_impl< boost::archive::binary_iarchive, std::istream::char_type, std::istream::traits_type - >, - public detail::shared_ptr_helper -{ + >{ public: binary_iarchive(std::istream & is, unsigned int flags = 0) : binary_iarchive_impl< binary_iarchive, std::istream::char_type, std::istream::traits_type >(is, flags) {} binary_iarchive(std::streambuf & bsb, unsigned int flags = 0) : binary_iarchive_impl< binary_iarchive, std::istream::char_type, std::istream::traits_type >(bsb, flags) {} }; } // namespace archive } // namespace boost // required by export BOOST_SERIALIZATION_REGISTER_ARCHIVE(boost::archive::binary_iarchive) BOOST_SERIALIZATION_USE_ARRAY_OPTIMIZATION(boost::archive::binary_iarchive) #ifdef BOOST_MSVC #pragma warning(pop) #endif #endif // BOOST_ARCHIVE_BINARY_IARCHIVE_HPP diff --git a/3rdParty/Boost/src/boost/archive/binary_iarchive_impl.hpp b/3rdParty/Boost/src/boost/archive/binary_iarchive_impl.hpp index 32c476d..a9afe61 100644 --- a/3rdParty/Boost/src/boost/archive/binary_iarchive_impl.hpp +++ b/3rdParty/Boost/src/boost/archive/binary_iarchive_impl.hpp @@ -1,78 +1,90 @@ #ifndef BOOST_ARCHIVE_BINARY_IARCHIVE_IMPL_HPP #define BOOST_ARCHIVE_BINARY_IARCHIVE_IMPL_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 // binary_iarchive_impl.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 <istream> #include <boost/serialization/pfto.hpp> #include <boost/archive/basic_binary_iprimitive.hpp> #include <boost/archive/basic_binary_iarchive.hpp> #ifdef BOOST_MSVC # pragma warning(push) # pragma warning(disable : 4511 4512) #endif namespace boost { namespace archive { +namespace detail { + template<class Archive> class interface_iarchive; +} // namespace detail + template<class Archive, class Elem, class Tr> class binary_iarchive_impl : public basic_binary_iprimitive<Archive, Elem, Tr>, public basic_binary_iarchive<Archive> { #ifdef BOOST_NO_MEMBER_TEMPLATE_FRIENDS public: #else - friend class detail::interface_iarchive<Archive>; - friend class basic_binary_iarchive<Archive>; - friend class load_access; protected: + #if BOOST_WORKAROUND(BOOST_MSVC, < 1500) + // for some inexplicable reason insertion of "class" generates compile erro + // on msvc 7.1 + friend detail::interface_iarchive<Archive>; + friend basic_binary_iarchive<Archive>; + friend load_access; + #else + friend class detail::interface_iarchive<Archive>; + friend class basic_binary_iarchive<Archive>; + friend class load_access; + #endif #endif // note: the following should not needed - but one compiler (vc 7.1) // fails to compile one test (test_shared_ptr) without it !!! // make this protected so it can be called from a derived archive template<class T> void load_override(T & t, BOOST_PFTO int){ this->basic_binary_iarchive<Archive>::load_override(t, 0L); } void init(unsigned int flags){ if(0 != (flags & no_header)) return; #if ! defined(__MWERKS__) this->basic_binary_iarchive<Archive>::init(); this->basic_binary_iprimitive<Archive, Elem, Tr>::init(); #else basic_binary_iarchive<Archive>::init(); basic_binary_iprimitive<Archive, Elem, Tr>::init(); #endif } binary_iarchive_impl( std::basic_streambuf<Elem, Tr> & bsb, unsigned int flags ) : basic_binary_iprimitive<Archive, Elem, Tr>( bsb, 0 != (flags & no_codecvt) ), basic_binary_iarchive<Archive>(flags) { init(flags); } binary_iarchive_impl( std::basic_istream<Elem, Tr> & is, unsigned int flags ) : diff --git a/3rdParty/Boost/src/boost/archive/binary_oarchive.hpp b/3rdParty/Boost/src/boost/archive/binary_oarchive.hpp index 2aac14f..89a86da 100644 --- a/3rdParty/Boost/src/boost/archive/binary_oarchive.hpp +++ b/3rdParty/Boost/src/boost/archive/binary_oarchive.hpp @@ -1,66 +1,64 @@ #ifndef BOOST_ARCHIVE_BINARY_OARCHIVE_HPP #define BOOST_ARCHIVE_BINARY_OARCHIVE_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 // binary_oarchive.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 <ostream> #include <boost/config.hpp> #include <boost/archive/binary_oarchive_impl.hpp> #include <boost/archive/detail/register_archive.hpp> #ifdef BOOST_MSVC # pragma warning(push) # pragma warning(disable : 4511 4512) #endif namespace boost { namespace archive { // do not derive from this class. If you want to extend this functionality // via inhertance, derived from binary_oarchive_impl instead. This will // preserve correct static polymorphism. class binary_oarchive : public binary_oarchive_impl< binary_oarchive, std::ostream::char_type, std::ostream::traits_type > { public: binary_oarchive(std::ostream & os, unsigned int flags = 0) : binary_oarchive_impl< binary_oarchive, std::ostream::char_type, std::ostream::traits_type >(os, flags) {} binary_oarchive(std::streambuf & bsb, unsigned int flags = 0) : binary_oarchive_impl< binary_oarchive, std::ostream::char_type, std::ostream::traits_type >(bsb, flags) {} }; -typedef binary_oarchive naked_binary_oarchive; - } // namespace archive } // namespace boost // required by export BOOST_SERIALIZATION_REGISTER_ARCHIVE(boost::archive::binary_oarchive) BOOST_SERIALIZATION_USE_ARRAY_OPTIMIZATION(boost::archive::binary_oarchive) #ifdef BOOST_MSVC #pragma warning(pop) #endif #endif // BOOST_ARCHIVE_BINARY_OARCHIVE_HPP diff --git a/3rdParty/Boost/src/boost/archive/binary_oarchive_impl.hpp b/3rdParty/Boost/src/boost/archive/binary_oarchive_impl.hpp index 7ca773b..a8c9733 100644 --- a/3rdParty/Boost/src/boost/archive/binary_oarchive_impl.hpp +++ b/3rdParty/Boost/src/boost/archive/binary_oarchive_impl.hpp @@ -1,79 +1,91 @@ #ifndef BOOST_ARCHIVE_BINARY_OARCHIVE_IMPL_HPP #define BOOST_ARCHIVE_BINARY_OARCHIVE_IMPL_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 // binary_oarchive_impl.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 <ostream> #include <boost/config.hpp> #include <boost/serialization/pfto.hpp> #include <boost/archive/basic_binary_oprimitive.hpp> #include <boost/archive/basic_binary_oarchive.hpp> #ifdef BOOST_MSVC # pragma warning(push) # pragma warning(disable : 4511 4512) #endif namespace boost { namespace archive { +namespace detail { + template<class Archive> class interface_oarchive; +} // namespace detail + template<class Archive, class Elem, class Tr> class binary_oarchive_impl : public basic_binary_oprimitive<Archive, Elem, Tr>, public basic_binary_oarchive<Archive> { #ifdef BOOST_NO_MEMBER_TEMPLATE_FRIENDS public: #else - friend class detail::interface_oarchive<Archive>; - friend class basic_binary_oarchive<Archive>; - friend class save_access; protected: + #if BOOST_WORKAROUND(BOOST_MSVC, < 1500) + // for some inexplicable reason insertion of "class" generates compile erro + // on msvc 7.1 + friend detail::interface_oarchive<Archive>; + friend basic_binary_oarchive<Archive>; + friend save_access; + #else + friend class detail::interface_oarchive<Archive>; + friend class basic_binary_oarchive<Archive>; + friend class save_access; + #endif #endif // note: the following should not needed - but one compiler (vc 7.1) // fails to compile one test (test_shared_ptr) without it !!! // make this protected so it can be called from a derived archive template<class T> void save_override(T & t, BOOST_PFTO int){ this->basic_binary_oarchive<Archive>::save_override(t, 0L); } void init(unsigned int flags) { if(0 != (flags & no_header)) return; #if ! defined(__MWERKS__) this->basic_binary_oarchive<Archive>::init(); this->basic_binary_oprimitive<Archive, Elem, Tr>::init(); #else basic_binary_oarchive<Archive>::init(); basic_binary_oprimitive<Archive, Elem, Tr>::init(); #endif } binary_oarchive_impl( std::basic_streambuf<Elem, Tr> & bsb, unsigned int flags ) : basic_binary_oprimitive<Archive, Elem, Tr>( bsb, 0 != (flags & no_codecvt) ), basic_binary_oarchive<Archive>(flags) { init(flags); } binary_oarchive_impl( std::basic_ostream<Elem, Tr> & os, unsigned int flags ) : diff --git a/3rdParty/Boost/src/boost/archive/binary_wiarchive.hpp b/3rdParty/Boost/src/boost/archive/binary_wiarchive.hpp index b5f6a71..775d8f8 100644 --- a/3rdParty/Boost/src/boost/archive/binary_wiarchive.hpp +++ b/3rdParty/Boost/src/boost/archive/binary_wiarchive.hpp @@ -1,93 +1,56 @@ #ifndef BOOST_ARCHIVE_BINARY_WIARCHIVE_HPP #define BOOST_ARCHIVE_BINARY_WIARCHIVE_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 // binary_wiarchive.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> #ifdef BOOST_NO_STD_WSTREAMBUF #error "wide char i/o not supported on this platform" #else #include <istream> // wistream #include <boost/archive/binary_iarchive_impl.hpp> #include <boost/archive/detail/register_archive.hpp> namespace boost { namespace archive { -// same as binary_wiarchive below - without the shared_ptr_helper -class naked_binary_wiarchive : - public binary_iarchive_impl< - boost::archive::naked_binary_wiarchive, - std::wistream::char_type, - std::wistream::traits_type - > -{ -public: - naked_binary_wiarchive(std::wistream & is, unsigned int flags = 0) : - binary_iarchive_impl< - naked_binary_wiarchive, - std::wistream::char_type, - std::wistream::traits_type - >(is, flags) - {} - naked_binary_wiarchive(std::wstreambuf & bsb, unsigned int flags = 0) : - binary_iarchive_impl< - naked_binary_wiarchive, - std::wistream::char_type, - std::wistream::traits_type - >(bsb, flags) - {} -}; - -} // namespace archive -} // namespace boost - -// note special treatment of shared_ptr. This type needs a special -// structure associated with every archive. We created a "mix-in" -// class to provide this functionality. Since shared_ptr holds a -// special esteem in the boost library - we included it here by default. -#include <boost/archive/shared_ptr_helper.hpp> - -namespace boost { -namespace archive { - class binary_wiarchive : public binary_iarchive_impl< binary_wiarchive, std::wistream::char_type, std::wistream::traits_type > { public: binary_wiarchive(std::wistream & is, unsigned int flags = 0) : binary_iarchive_impl< binary_wiarchive, std::wistream::char_type, std::wistream::traits_type >(is, flags) {} binary_wiarchive(std::wstreambuf & bsb, unsigned int flags = 0) : binary_iarchive_impl< binary_wiarchive, std::wistream::char_type, std::wistream::traits_type >(bsb, flags) {} }; } // namespace archive } // namespace boost // required by export BOOST_SERIALIZATION_REGISTER_ARCHIVE(boost::archive::binary_wiarchive) #endif // BOOST_NO_STD_WSTREAMBUF #endif // BOOST_ARCHIVE_BINARY_WIARCHIVE_HPP diff --git a/3rdParty/Boost/src/boost/archive/binary_woarchive.hpp b/3rdParty/Boost/src/boost/archive/binary_woarchive.hpp index 2075dac..a8817d6 100644 --- a/3rdParty/Boost/src/boost/archive/binary_woarchive.hpp +++ b/3rdParty/Boost/src/boost/archive/binary_woarchive.hpp @@ -1,61 +1,59 @@ #ifndef BOOST_ARCHIVE_BINARY_WOARCHIVE_HPP #define BOOST_ARCHIVE_BINARY_WOARCHIVE_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 // binary_woarchive.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> #ifdef BOOST_NO_STD_WSTREAMBUF #error "wide char i/o not supported on this platform" #else #include <ostream> #include <boost/archive/binary_oarchive_impl.hpp> #include <boost/archive/detail/register_archive.hpp> namespace boost { namespace archive { // do not derive from this class. If you want to extend this functionality // via inhertance, derived from binary_oarchive_impl instead. This will // preserve correct static polymorphism. class binary_woarchive : public binary_oarchive_impl< binary_woarchive, std::wostream::char_type, std::wostream::traits_type > { public: binary_woarchive(std::wostream & os, unsigned int flags = 0) : binary_oarchive_impl< binary_woarchive, std::wostream::char_type, std::wostream::traits_type >(os, flags) {} binary_woarchive(std::wstreambuf & bsb, unsigned int flags = 0) : binary_oarchive_impl< binary_woarchive, std::wostream::char_type, std::wostream::traits_type >(bsb, flags) {} }; -typedef binary_woarchive naked_binary_woarchive; - } // namespace archive } // namespace boost // required by export BOOST_SERIALIZATION_REGISTER_ARCHIVE(boost::archive::binary_woarchive) #endif // BOOST_NO_STD_WSTREAMBUF #endif // BOOST_ARCHIVE_BINARY_WOARCHIVE_HPP diff --git a/3rdParty/Boost/src/boost/archive/codecvt_null.hpp b/3rdParty/Boost/src/boost/archive/codecvt_null.hpp index 910b261..caeefee 100644 --- a/3rdParty/Boost/src/boost/archive/codecvt_null.hpp +++ b/3rdParty/Boost/src/boost/archive/codecvt_null.hpp @@ -1,40 +1,40 @@ #ifndef BOOST_ARCHIVE_CODECVT_NULL_HPP #define BOOST_ARCHIVE_CODECVT_NULL_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 // codecvt_null.hpp: // (C) Copyright 2004 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 <locale> #include <cstddef> // NULL, size_t #include <cwchar> // for mbstate_t #include <boost/config.hpp> #include <boost/archive/detail/auto_link_archive.hpp> #include <boost/archive/detail/abi_prefix.hpp> // must be the last header #if defined(BOOST_NO_STDC_NAMESPACE) namespace std { // For STLport on WinCE, BOOST_NO_STDC_NAMESPACE can get defined if STLport is putting symbols in its own namespace. // In the case of codecvt, however, this does not mean that codecvt is in the global namespace (it will be in STLport's namespace) # if !defined(__SGI_STL_PORT) && !defined(_STLPORT_VERSION) using ::codecvt; # endif using ::mbstate_t; using ::size_t; } // namespace #endif #ifdef BOOST_MSVC # pragma warning(push) # pragma warning(disable : 4511 4512) diff --git a/3rdParty/Boost/src/boost/archive/detail/archive_serializer_map.hpp b/3rdParty/Boost/src/boost/archive/detail/archive_serializer_map.hpp index 6d2eec4..53fcae4 100644 --- a/3rdParty/Boost/src/boost/archive/detail/archive_serializer_map.hpp +++ b/3rdParty/Boost/src/boost/archive/detail/archive_serializer_map.hpp @@ -1,40 +1,40 @@ #ifndef BOOST_ARCHIVE_SERIALIZER_MAP_HPP #define BOOST_ARCHIVE_SERIALIZER_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 // archive_serializer_map.hpp: extenstion of type_info required for // serialization. // (C) Copyright 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) // See http://www.boost.org for updates, documentation, and revision history. // note: this is nothing more than the thinest of wrappers around // basic_serializer_map so we can have a one map / archive type. #include <boost/config.hpp> #include <boost/archive/detail/auto_link_archive.hpp> #include <boost/archive/detail/abi_prefix.hpp> // must be the last header namespace boost { namespace serialization { class extended_type_info; } // namespace serialization namespace archive { namespace detail { class basic_serializer; template<class Archive> class BOOST_ARCHIVE_OR_WARCHIVE_DECL(BOOST_PP_EMPTY()) archive_serializer_map { diff --git a/3rdParty/Boost/src/boost/archive/detail/auto_link_archive.hpp b/3rdParty/Boost/src/boost/archive/detail/auto_link_archive.hpp index 05956f0..79b0e49 100644 --- a/3rdParty/Boost/src/boost/archive/detail/auto_link_archive.hpp +++ b/3rdParty/Boost/src/boost/archive/detail/auto_link_archive.hpp @@ -1,40 +1,40 @@ #ifndef BOOST_ARCHIVE_DETAIL_AUTO_LINK_ARCHIVE_HPP #define BOOST_ARCHIVE_DETAIL_AUTO_LINK_ARCHIVE_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 // auto_link_archive.hpp // // (c) Copyright Robert Ramey 2004 // Use, modification, and distribution is subject to the Boost Software // License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // See library home page at http://www.boost.org/libs/serialization //----------------------------------------------------------------------------// // This header implements separate compilation features as described in // http://www.boost.org/more/separate_compilation.html // enable automatic library variant selection ------------------------------// #include <boost/archive/detail/decl.hpp> #if !defined(BOOST_ALL_NO_LIB) && !defined(BOOST_SERIALIZATION_NO_LIB) \ && !defined(BOOST_ARCHIVE_SOURCE) && !defined(BOOST_WARCHIVE_SOURCE) \ && !defined(BOOST_SERIALIZATION_SOURCE) // Set the name of our library, this will get undef'ed by auto_link.hpp // once it's done with it: // #define BOOST_LIB_NAME boost_serialization // // If we're importing code from a dll, then tell auto_link.hpp about it: // #if defined(BOOST_ALL_DYN_LINK) || defined(BOOST_SERIALIZATION_DYN_LINK) # define BOOST_DYN_LINK diff --git a/3rdParty/Boost/src/boost/archive/detail/auto_link_warchive.hpp b/3rdParty/Boost/src/boost/archive/detail/auto_link_warchive.hpp index 4d4efcd..683d191 100644 --- a/3rdParty/Boost/src/boost/archive/detail/auto_link_warchive.hpp +++ b/3rdParty/Boost/src/boost/archive/detail/auto_link_warchive.hpp @@ -1,40 +1,40 @@ #ifndef BOOST_ARCHIVE_DETAIL_AUTO_LINK_WARCHIVE_HPP #define BOOST_ARCHIVE_DETAIL_AUTO_LINK_WARCHIVE_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 // auto_link_warchive.hpp // // (c) Copyright Robert Ramey 2004 // Use, modification, and distribution is subject to the Boost Software // License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // See library home page at http://www.boost.org/libs/serialization //----------------------------------------------------------------------------// // This header implements separate compilation features as described in // http://www.boost.org/more/separate_compilation.html // enable automatic library variant selection ------------------------------// #include <boost/archive/detail/decl.hpp> #if !defined(BOOST_WARCHIVE_SOURCE) \ && !defined(BOOST_ALL_NO_LIB) && !defined(BOOST_SERIALIZATION_NO_LIB) // Set the name of our library, this will get undef'ed by auto_link.hpp // once it's done with it: // #define BOOST_LIB_NAME boost_wserialization // // If we're importing code from a dll, then tell auto_link.hpp about it: // #if defined(BOOST_ALL_DYN_LINK) || defined(BOOST_SERIALIZATION_DYN_LINK) # define BOOST_DYN_LINK #endif diff --git a/3rdParty/Boost/src/boost/archive/detail/basic_iarchive.hpp b/3rdParty/Boost/src/boost/archive/detail/basic_iarchive.hpp index f62987e..fdafbbf 100644 --- a/3rdParty/Boost/src/boost/archive/detail/basic_iarchive.hpp +++ b/3rdParty/Boost/src/boost/archive/detail/basic_iarchive.hpp @@ -1,110 +1,105 @@ #ifndef BOOST_ARCHIVE_DETAIL_BASIC_IARCHIVE_HPP #define BOOST_ARCHIVE_DETAIL_BASIC_IARCHIVE_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 // basic_iarchive.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. // can't use this - much as I'd like to as borland doesn't support it // #include <boost/scoped_ptr.hpp> #include <boost/config.hpp> #include <boost/noncopyable.hpp> -#include <boost/type_traits/broken_compiler_spec.hpp> #include <boost/serialization/tracking_enum.hpp> #include <boost/archive/basic_archive.hpp> #include <boost/archive/detail/decl.hpp> +#include <boost/archive/detail/helper_collection.hpp> #include <boost/archive/detail/abi_prefix.hpp> // must be the last header namespace boost { namespace serialization { class extended_type_info; } // namespace serialization namespace archive { namespace detail { class basic_iarchive_impl; class BOOST_ARCHIVE_DECL(BOOST_PP_EMPTY()) basic_iserializer; class BOOST_ARCHIVE_DECL(BOOST_PP_EMPTY()) basic_pointer_iserializer; ////////////////////////////////////////////////////////////////////// // class basic_iarchive - read serialized objects from a input stream class BOOST_ARCHIVE_DECL(BOOST_PP_EMPTY()) basic_iarchive : - private boost::noncopyable + private boost::noncopyable, + public boost::archive::detail::helper_collection { friend class basic_iarchive_impl; // hide implementation of this class to minimize header conclusion // in client code. I couldn't used scoped pointer with borland // boost::scoped_ptr<basic_iarchive_impl> pimpl; basic_iarchive_impl * pimpl; virtual void vload(version_type &t) = 0; virtual void vload(object_id_type &t) = 0; virtual void vload(class_id_type &t) = 0; virtual void vload(class_id_optional_type &t) = 0; virtual void vload(class_name_type &t) = 0; virtual void vload(tracking_type &t) = 0; protected: basic_iarchive(unsigned int flags); // account for bogus gcc warning #if defined(__GNUC__) virtual #endif ~basic_iarchive(); public: // note: NOT part of the public API. void next_object_pointer(void *t); void register_basic_serializer( const basic_iserializer & bis ); void load_object( void *t, const basic_iserializer & bis ); const basic_pointer_iserializer * load_pointer( void * & t, const basic_pointer_iserializer * bpis_ptr, const basic_pointer_iserializer * (*finder)( const boost::serialization::extended_type_info & eti ) ); // real public API starts here void set_library_version(library_version_type archive_library_version); library_version_type get_library_version() const; unsigned int get_flags() const; void reset_object_address(const void * new_address, const void * old_address); void delete_created_pointers(); }; } // namespace detail } // namespace archive } // namespace boost -// required by smart_cast for compilers not implementing -// partial template specialization -BOOST_TT_BROKEN_COMPILER_SPEC( - boost::archive::detail::basic_iarchive -) - #include <boost/archive/detail/abi_suffix.hpp> // pops abi_suffix.hpp pragmas #endif //BOOST_ARCHIVE_DETAIL_BASIC_IARCHIVE_HPP diff --git a/3rdParty/Boost/src/boost/archive/detail/basic_iserializer.hpp b/3rdParty/Boost/src/boost/archive/detail/basic_iserializer.hpp index 2f4f6d8..3bff3e1 100644 --- a/3rdParty/Boost/src/boost/archive/detail/basic_iserializer.hpp +++ b/3rdParty/Boost/src/boost/archive/detail/basic_iserializer.hpp @@ -1,40 +1,40 @@ #ifndef BOOST_ARCHIVE_DETAIL_BASIC_ISERIALIZER_HPP #define BOOST_ARCHIVE_DETAIL_BASIC_ISERIALIZER_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 // basic_iserializer.hpp: extenstion of type_info required for serialization. // (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 <cstdlib> // NULL #include <boost/config.hpp> #include <boost/archive/basic_archive.hpp> #include <boost/archive/detail/decl.hpp> #include <boost/archive/detail/basic_serializer.hpp> #include <boost/archive/detail/auto_link_archive.hpp> #include <boost/archive/detail/abi_prefix.hpp> // must be the last header #ifdef BOOST_MSVC # pragma warning(push) # pragma warning(disable : 4511 4512) #endif namespace boost { namespace serialization { class extended_type_info; } // namespace serialization // forward declarations namespace archive { namespace detail { diff --git a/3rdParty/Boost/src/boost/archive/detail/basic_oarchive.hpp b/3rdParty/Boost/src/boost/archive/detail/basic_oarchive.hpp index 402e569..f65d110 100644 --- a/3rdParty/Boost/src/boost/archive/detail/basic_oarchive.hpp +++ b/3rdParty/Boost/src/boost/archive/detail/basic_oarchive.hpp @@ -1,106 +1,100 @@ #ifndef BOOST_ARCHIVE_BASIC_OARCHIVE_HPP #define BOOST_ARCHIVE_BASIC_OARCHIVE_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 // basic_oarchive.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 <cstddef> // NULL #include <boost/config.hpp> #include <boost/noncopyable.hpp> -#include <boost/type_traits/broken_compiler_spec.hpp> - // can't use this - much as I'd like to as borland doesn't support it // #include <boost/scoped_ptr.hpp> #include <boost/archive/basic_archive.hpp> #include <boost/serialization/tracking_enum.hpp> - +#include <boost/archive/detail/helper_collection.hpp> #include <boost/archive/detail/abi_prefix.hpp> // must be the last header namespace boost { namespace serialization { class extended_type_info; } // namespace serialization namespace archive { namespace detail { class basic_oarchive_impl; class BOOST_ARCHIVE_DECL(BOOST_PP_EMPTY()) basic_oserializer; class BOOST_ARCHIVE_DECL(BOOST_PP_EMPTY()) basic_pointer_oserializer; + ////////////////////////////////////////////////////////////////////// // class basic_oarchive - write serialized objects to an output stream class BOOST_ARCHIVE_OR_WARCHIVE_DECL(BOOST_PP_EMPTY()) basic_oarchive : - private boost::noncopyable + private boost::noncopyable, + public boost::archive::detail::helper_collection { friend class basic_oarchive_impl; // hide implementation of this class to minimize header conclusion // in client code. note: borland can't use scoped_ptr //boost::scoped_ptr<basic_oarchive_impl> pimpl; basic_oarchive_impl * pimpl; // overload these to bracket object attributes. Used to implement // xml archives virtual void vsave(const version_type t) = 0; virtual void vsave(const object_id_type t) = 0; virtual void vsave(const object_reference_type t) = 0; virtual void vsave(const class_id_type t) = 0; virtual void vsave(const class_id_optional_type t) = 0; virtual void vsave(const class_id_reference_type t) = 0; virtual void vsave(const class_name_type & t) = 0; virtual void vsave(const tracking_type t) = 0; protected: basic_oarchive(unsigned int flags = 0); // account for bogus gcc warning #if defined(__GNUC__) virtual #endif ~basic_oarchive(); public: // note: NOT part of the public interface void register_basic_serializer( const basic_oserializer & bos ); void save_object( const void *x, const basic_oserializer & bos ); void save_pointer( const void * t, const basic_pointer_oserializer * bpos_ptr ); void save_null_pointer(){ vsave(NULL_POINTER_TAG); } // real public interface starts here void end_preamble(); // default implementation does nothing library_version_type get_library_version() const; unsigned int get_flags() const; }; } // namespace detail } // namespace archive } // namespace boost -// required by smart_cast for compilers not implementing -// partial template specialization -BOOST_TT_BROKEN_COMPILER_SPEC( - boost::archive::detail::basic_oarchive -) - #include <boost/archive/detail/abi_suffix.hpp> // pops abi_suffix.hpp pragmas #endif //BOOST_ARCHIVE_BASIC_OARCHIVE_HPP diff --git a/3rdParty/Boost/src/boost/archive/detail/basic_oserializer.hpp b/3rdParty/Boost/src/boost/archive/detail/basic_oserializer.hpp index 74af7e6..6ae063f 100644 --- a/3rdParty/Boost/src/boost/archive/detail/basic_oserializer.hpp +++ b/3rdParty/Boost/src/boost/archive/detail/basic_oserializer.hpp @@ -1,40 +1,40 @@ #ifndef BOOST_SERIALIZATION_BASIC_OSERIALIZER_HPP #define BOOST_SERIALIZATION_BASIC_OSERIALIZER_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 // basic_oserializer.hpp: extenstion of type_info required for serialization. // (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 <cstddef> // NULL #include <boost/config.hpp> #include <boost/noncopyable.hpp> #include <boost/archive/basic_archive.hpp> #include <boost/archive/detail/auto_link_archive.hpp> #include <boost/archive/detail/basic_serializer.hpp> #include <boost/archive/detail/abi_prefix.hpp> // must be the last header #ifdef BOOST_MSVC # pragma warning(push) # pragma warning(disable : 4511 4512) #endif namespace boost { namespace serialization { class extended_type_info; } // namespace serialization // forward declarations namespace archive { diff --git a/3rdParty/Boost/src/boost/archive/detail/basic_pointer_iserializer.hpp b/3rdParty/Boost/src/boost/archive/detail/basic_pointer_iserializer.hpp index d957b83..86badc1 100644 --- a/3rdParty/Boost/src/boost/archive/detail/basic_pointer_iserializer.hpp +++ b/3rdParty/Boost/src/boost/archive/detail/basic_pointer_iserializer.hpp @@ -1,73 +1,74 @@ #ifndef BOOST_ARCHIVE_BASIC_POINTER_ISERIALIZER_HPP #define BOOST_ARCHIVE_BASIC_POINTER_ISERIALIZER_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 // basic_pointer_oserializer.hpp: extenstion of type_info required for // serialization. // (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/noncopyable.hpp> #include <boost/archive/detail/auto_link_archive.hpp> #include <boost/archive/detail/basic_serializer.hpp> #include <boost/archive/detail/abi_prefix.hpp> // must be the last header #ifdef BOOST_MSVC # pragma warning(push) # pragma warning(disable : 4511 4512) #endif namespace boost { namespace serialization { class extended_type_info; } // namespace serialization // forward declarations namespace archive { namespace detail { class BOOST_ARCHIVE_DECL(BOOST_PP_EMPTY()) basic_iarchive; class BOOST_ARCHIVE_DECL(BOOST_PP_EMPTY()) basic_iserializer; class BOOST_ARCHIVE_DECL(BOOST_PP_EMPTY()) basic_pointer_iserializer : public basic_serializer { protected: explicit basic_pointer_iserializer( const boost::serialization::extended_type_info & type_ ); // account for bogus gcc warning #if defined(__GNUC__) virtual #endif ~basic_pointer_iserializer(); public: + virtual void * heap_allocation() const = 0; virtual const basic_iserializer & get_basic_serializer() const = 0; virtual void load_object_ptr( basic_iarchive & ar, - void * & x, + void * x, const unsigned int file_version ) const = 0; }; } // namespace detail } // namespace archive } // namespace boost #ifdef BOOST_MSVC #pragma warning(pop) #endif #include <boost/archive/detail/abi_suffix.hpp> // pops abi_suffix.hpp pragmas #endif // BOOST_ARCHIVE_BASIC_POINTER_ISERIALIZER_HPP diff --git a/3rdParty/Boost/src/boost/archive/detail/basic_pointer_oserializer.hpp b/3rdParty/Boost/src/boost/archive/detail/basic_pointer_oserializer.hpp index b0d3fb9..bafc46a 100644 --- a/3rdParty/Boost/src/boost/archive/detail/basic_pointer_oserializer.hpp +++ b/3rdParty/Boost/src/boost/archive/detail/basic_pointer_oserializer.hpp @@ -1,40 +1,40 @@ #ifndef BOOST_ARCHIVE_BASIC_POINTER_OSERIALIZER_HPP #define BOOST_ARCHIVE_BASIC_POINTER_OSERIALIZER_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 // basic_pointer_oserializer.hpp: extenstion of type_info required for // serialization. // (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/noncopyable.hpp> #include <boost/archive/detail/auto_link_archive.hpp> #include <boost/archive/detail/basic_serializer.hpp> #include <boost/archive/detail/abi_prefix.hpp> // must be the last header #ifdef BOOST_MSVC # pragma warning(push) # pragma warning(disable : 4511 4512) #endif namespace boost { namespace serialization { class extended_type_info; } // namespace serialization namespace archive { namespace detail { class BOOST_ARCHIVE_DECL(BOOST_PP_EMPTY()) basic_oarchive; class BOOST_ARCHIVE_DECL(BOOST_PP_EMPTY()) basic_oserializer; diff --git a/3rdParty/Boost/src/boost/archive/detail/basic_serializer.hpp b/3rdParty/Boost/src/boost/archive/detail/basic_serializer.hpp index 5dbd886..c7d3b4b 100644 --- a/3rdParty/Boost/src/boost/archive/detail/basic_serializer.hpp +++ b/3rdParty/Boost/src/boost/archive/detail/basic_serializer.hpp @@ -1,40 +1,40 @@ #ifndef BOOST_ARCHIVE_BASIC_SERIALIZER_HPP #define BOOST_ARCHIVE_BASIC_SERIALIZER_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 // basic_serializer.hpp: extenstion of type_info required for serialization. // (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 <cstddef> // NULL #include <boost/noncopyable.hpp> #include <boost/config.hpp> #include <boost/serialization/extended_type_info.hpp> #ifdef BOOST_MSVC # pragma warning(push) # pragma warning(disable : 4511 4512) #endif namespace boost { namespace archive { namespace detail { class basic_serializer : private boost::noncopyable { const boost::serialization::extended_type_info * m_eti; protected: explicit basic_serializer( diff --git a/3rdParty/Boost/src/boost/archive/detail/basic_serializer_map.hpp b/3rdParty/Boost/src/boost/archive/detail/basic_serializer_map.hpp index a991ea1..202c20e 100644 --- a/3rdParty/Boost/src/boost/archive/detail/basic_serializer_map.hpp +++ b/3rdParty/Boost/src/boost/archive/detail/basic_serializer_map.hpp @@ -1,40 +1,40 @@ #ifndef BOOST_SERIALIZER_MAP_HPP #define BOOST_SERIALIZER_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 // basic_serializer_map.hpp: extenstion of type_info required for serialization. // (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/noncopyable.hpp> #include <boost/archive/detail/auto_link_archive.hpp> #include <boost/archive/detail/abi_prefix.hpp> // must be the last header namespace boost { namespace serialization { class extended_type_info; } namespace archive { namespace detail { class basic_serializer; class BOOST_ARCHIVE_OR_WARCHIVE_DECL(BOOST_PP_EMPTY()) basic_serializer_map : public boost::noncopyable { diff --git a/3rdParty/Boost/src/boost/archive/detail/check.hpp b/3rdParty/Boost/src/boost/archive/detail/check.hpp index c9cba51..10034e7 100644 --- a/3rdParty/Boost/src/boost/archive/detail/check.hpp +++ b/3rdParty/Boost/src/boost/archive/detail/check.hpp @@ -1,169 +1,169 @@ #ifndef BOOST_ARCHIVE_DETAIL_CHECK_HPP #define BOOST_ARCHIVE_DETAIL_CHECK_HPP // MS compatible compilers support #pragma once -#if defined(_MSC_VER) && (_MSC_VER >= 1020) +#if defined(_MSC_VER) # pragma once #pragma inline_depth(511) #pragma inline_recursion(on) #endif #if defined(__MWERKS__) #pragma inline_depth(511) #endif /////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8 // check.hpp: interface for serialization system. // (C) Copyright 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) // See http://www.boost.org for updates, documentation, and revision history. #include <boost/config.hpp> #include <boost/static_assert.hpp> #include <boost/type_traits/is_const.hpp> #include <boost/mpl/eval_if.hpp> #include <boost/mpl/or.hpp> #include <boost/mpl/equal_to.hpp> #include <boost/mpl/int.hpp> #include <boost/mpl/not.hpp> #include <boost/mpl/greater.hpp> #include <boost/mpl/assert.hpp> #include <boost/serialization/static_warning.hpp> #include <boost/serialization/version.hpp> #include <boost/serialization/level.hpp> #include <boost/serialization/tracking.hpp> #include <boost/serialization/wrapper.hpp> namespace boost { namespace archive { namespace detail { // checks for objects template<class T> inline void check_object_level(){ typedef - BOOST_DEDUCED_TYPENAME mpl::greater_equal< + typename mpl::greater_equal< serialization::implementation_level< T >, mpl::int_<serialization::primitive_type> >::type typex; // trap attempts to serialize objects marked // not_serializable BOOST_STATIC_ASSERT(typex::value); } template<class T> inline void check_object_versioning(){ typedef - BOOST_DEDUCED_TYPENAME mpl::or_< - BOOST_DEDUCED_TYPENAME mpl::greater< + typename mpl::or_< + typename mpl::greater< serialization::implementation_level< T >, mpl::int_<serialization::object_serializable> >, - BOOST_DEDUCED_TYPENAME mpl::equal_to< + typename mpl::equal_to< serialization::version< T >, mpl::int_<0> > > typex; // trap attempts to serialize with objects that don't // save class information in the archive with versioning. BOOST_STATIC_ASSERT(typex::value); } template<class T> inline void check_object_tracking(){ // presume it has already been determined that // T is not a const BOOST_STATIC_ASSERT(! boost::is_const< T >::value); - typedef BOOST_DEDUCED_TYPENAME mpl::equal_to< + typedef typename mpl::equal_to< serialization::tracking_level< T >, mpl::int_<serialization::track_never> >::type typex; // saving an non-const object of a type not marked "track_never) // may be an indicator of an error usage of the // serialization library and should be double checked. // See documentation on object tracking. Also, see the // "rationale" section of the documenation // for motivation for this checking. BOOST_STATIC_WARNING(typex::value); } // checks for pointers template<class T> inline void check_pointer_level(){ // we should only invoke this once we KNOW that T // has been used as a pointer!! typedef - BOOST_DEDUCED_TYPENAME mpl::or_< - BOOST_DEDUCED_TYPENAME mpl::greater< + typename mpl::or_< + typename mpl::greater< serialization::implementation_level< T >, mpl::int_<serialization::object_serializable> >, - BOOST_DEDUCED_TYPENAME mpl::not_< - BOOST_DEDUCED_TYPENAME mpl::equal_to< + typename mpl::not_< + typename mpl::equal_to< serialization::tracking_level< T >, mpl::int_<serialization::track_selectively> > > > typex; // Address the following when serializing to a pointer: // a) This type doesn't save class information in the // archive. That is, the serialization trait implementation // level <= object_serializable. // b) Tracking for this type is set to "track selectively" // in this case, indication that an object is tracked is // not stored in the archive itself - see level == object_serializable // but rather the existence of the operation ar >> T * is used to // infer that an object of this type should be tracked. So, if // you save via a pointer but don't load via a pointer the operation // will fail on load without given any valid reason for the failure. // So if your program traps here, consider changing the // tracking or implementation level traits - or not // serializing via a pointer. BOOST_STATIC_WARNING(typex::value); } template<class T> void inline check_pointer_tracking(){ - typedef BOOST_DEDUCED_TYPENAME mpl::greater< + typedef typename mpl::greater< serialization::tracking_level< T >, mpl::int_<serialization::track_never> >::type typex; // serializing an object of a type marked "track_never" through a pointer // could result in creating more objects than were saved! BOOST_STATIC_WARNING(typex::value); } template<class T> inline void check_const_loading(){ typedef - BOOST_DEDUCED_TYPENAME mpl::or_< - BOOST_DEDUCED_TYPENAME boost::serialization::is_wrapper< T >, - BOOST_DEDUCED_TYPENAME mpl::not_< - BOOST_DEDUCED_TYPENAME boost::is_const< T > + typename mpl::or_< + typename boost::serialization::is_wrapper< T >, + typename mpl::not_< + typename boost::is_const< T > > >::type typex; // cannot load data into a "const" object unless it's a // wrapper around some other non-const object. BOOST_STATIC_ASSERT(typex::value); } } // detail } // archive } // boost #endif // BOOST_ARCHIVE_DETAIL_CHECK_HPP diff --git a/3rdParty/Boost/src/boost/archive/detail/common_iarchive.hpp b/3rdParty/Boost/src/boost/archive/detail/common_iarchive.hpp index 54c07c3..45e6d34 100644 --- a/3rdParty/Boost/src/boost/archive/detail/common_iarchive.hpp +++ b/3rdParty/Boost/src/boost/archive/detail/common_iarchive.hpp @@ -1,40 +1,40 @@ #ifndef BOOST_ARCHIVE_DETAIL_COMMON_IARCHIVE_HPP #define BOOST_ARCHIVE_DETAIL_COMMON_IARCHIVE_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 // common_iarchive.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/archive/detail/basic_iarchive.hpp> #include <boost/archive/detail/basic_pointer_iserializer.hpp> #include <boost/archive/detail/interface_iarchive.hpp> #ifdef BOOST_MSVC # pragma warning(push) # pragma warning(disable : 4511 4512) #endif namespace boost { namespace archive { namespace detail { class extended_type_info; // note: referred to as Curiously Recurring Template Patter (CRTP) template<class Archive> class common_iarchive : public basic_iarchive, public interface_iarchive<Archive> diff --git a/3rdParty/Boost/src/boost/archive/detail/common_oarchive.hpp b/3rdParty/Boost/src/boost/archive/detail/common_oarchive.hpp index 7962063..0d7474b 100644 --- a/3rdParty/Boost/src/boost/archive/detail/common_oarchive.hpp +++ b/3rdParty/Boost/src/boost/archive/detail/common_oarchive.hpp @@ -1,40 +1,40 @@ #ifndef BOOST_ARCHIVE_DETAIL_COMMON_OARCHIVE_HPP #define BOOST_ARCHIVE_DETAIL_COMMON_OARCHIVE_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 // common_oarchive.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/archive/detail/basic_oarchive.hpp> #include <boost/archive/detail/interface_oarchive.hpp> #ifdef BOOST_MSVC # pragma warning(push) # pragma warning(disable : 4511 4512) #endif namespace boost { namespace archive { namespace detail { // note: referred to as Curiously Recurring Template Patter (CRTP) template<class Archive> class common_oarchive : public basic_oarchive, public interface_oarchive<Archive> { friend class interface_oarchive<Archive>; private: diff --git a/3rdParty/Boost/src/boost/archive/detail/decl.hpp b/3rdParty/Boost/src/boost/archive/detail/decl.hpp index 9695001..44e22be 100644 --- a/3rdParty/Boost/src/boost/archive/detail/decl.hpp +++ b/3rdParty/Boost/src/boost/archive/detail/decl.hpp @@ -1,40 +1,40 @@ #ifndef BOOST_ARCHIVE_DETAIL_DECL_HPP #define BOOST_ARCHIVE_DETAIL_DECL_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 // decl.hpp // // (c) Copyright Robert Ramey 2004 // Use, modification, and distribution is subject to the Boost Software // License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // See library home page at http://www.boost.org/libs/serialization //----------------------------------------------------------------------------// // This header implements separate compilation features as described in // http://www.boost.org/more/separate_compilation.html #include <boost/config.hpp> #include <boost/preprocessor/facilities/empty.hpp> #if defined(BOOST_HAS_DECLSPEC) #if (defined(BOOST_ALL_DYN_LINK) || defined(BOOST_SERIALIZATION_DYN_LINK)) #if defined(BOOST_ARCHIVE_SOURCE) #if defined(__BORLANDC__) #define BOOST_ARCHIVE_DECL(T) T __export #define BOOST_ARCHIVE_OR_WARCHIVE_DECL(T) T __export #else #define BOOST_ARCHIVE_DECL(T) __declspec(dllexport) T #define BOOST_ARCHIVE_OR_WARCHIVE_DECL(T) __declspec(dllexport) T #endif #else #if defined(__BORLANDC__) #define BOOST_ARCHIVE_DECL(T) T __import #else diff --git a/3rdParty/Boost/src/boost/archive/detail/helper_collection.hpp b/3rdParty/Boost/src/boost/archive/detail/helper_collection.hpp new file mode 100644 index 0000000..ba3c60c --- /dev/null +++ b/3rdParty/Boost/src/boost/archive/detail/helper_collection.hpp @@ -0,0 +1,111 @@ +#ifndef BOOST_ARCHIVE_DETAIL_HELPER_COLLECTION_HPP +#define BOOST_ARCHIVE_DETAIL_HELPER_COLLECTION_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 +// helper_collection.hpp: archive support for run-time helpers + +// (C) Copyright 2002-2008 Robert Ramey and Joaquin M Lopez Munoz +// 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 <typeinfo> +#include <vector> +#include <utility> +#include <memory> +#include <algorithm> + +#include <boost/config.hpp> + +#ifdef BOOST_NO_CXX11_SMART_PTR + #include <boost/smart_ptr/shared_ptr.hpp> + #include <boost/smart_ptr/make_shared.hpp> +#endif + +namespace boost { + +namespace archive { +namespace detail { + +class helper_collection +{ + helper_collection(const helper_collection&); // non-copyable + helper_collection& operator = (const helper_collection&); // non-copyable + + // note: we dont' actually "share" the function object pointer + // we only use shared_ptr to make sure that it get's deleted + + #ifndef BOOST_NO_CXX11_SMART_PTR + typedef std::pair< + const std::type_info *, + std::shared_ptr<void> + > helper_value_type; + template<class T> + std::shared_ptr<void> make_helper_ptr(){ + return std::make_shared<T>(); + } + #else + typedef std::pair< + const std::type_info *, + boost::shared_ptr<void> + > helper_value_type; + template<class T> + boost::shared_ptr<void> make_helper_ptr(){ + return boost::make_shared<T>(); + } + #endif + typedef std::vector<helper_value_type> collection; + collection m_collection; + + struct predicate { + const std::type_info * m_ti; + bool operator()(helper_value_type const &rhs) const { + return *m_ti == *rhs.first; + } + predicate(const std::type_info * ti) : + m_ti(ti) + {} + }; +protected: + helper_collection(){} + ~helper_collection(){} +public: + template<typename Helper> + Helper& get_helper(Helper * = NULL) { + + const std::type_info * eti = & typeid(Helper); + + collection::const_iterator it = + std::find_if( + m_collection.begin(), + m_collection.end(), + predicate(eti) + ); + + void * rval; + if(it == m_collection.end()){ + m_collection.push_back( + std::make_pair(eti, make_helper_ptr<Helper>()) + ); + rval = m_collection.back().second.get(); + } + else{ + rval = it->second.get(); + } + return *static_cast<Helper *>(rval); + } +}; + +} // namespace detail +} // namespace serialization +} // namespace boost + +#endif // BOOST_ARCHIVE_DETAIL_HELPER_COLLECTION_HPP diff --git a/3rdParty/Boost/src/boost/archive/detail/interface_iarchive.hpp b/3rdParty/Boost/src/boost/archive/detail/interface_iarchive.hpp index 0648752..b7bd165 100644 --- a/3rdParty/Boost/src/boost/archive/detail/interface_iarchive.hpp +++ b/3rdParty/Boost/src/boost/archive/detail/interface_iarchive.hpp @@ -1,40 +1,40 @@ #ifndef BOOST_ARCHIVE_DETAIL_INTERFACE_IARCHIVE_HPP #define BOOST_ARCHIVE_DETAIL_INTERFACE_IARCHIVE_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 // interface_iarchive.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 <cstddef> // NULL #include <boost/cstdint.hpp> #include <boost/mpl/bool.hpp> #include <boost/archive/detail/auto_link_archive.hpp> #include <boost/archive/detail/iserializer.hpp> #include <boost/serialization/singleton.hpp> #include <boost/archive/detail/abi_prefix.hpp> // must be the last header namespace boost { namespace archive { namespace detail { class BOOST_ARCHIVE_OR_WARCHIVE_DECL(BOOST_PP_EMPTY()) basic_pointer_iserializer; template<class Archive> class interface_iarchive { protected: interface_iarchive(){}; public: ///////////////////////////////////////////////////////// // archive public interface typedef mpl::bool_<true> is_loading; diff --git a/3rdParty/Boost/src/boost/archive/detail/interface_oarchive.hpp b/3rdParty/Boost/src/boost/archive/detail/interface_oarchive.hpp index e8db7a2..7ae7176 100644 --- a/3rdParty/Boost/src/boost/archive/detail/interface_oarchive.hpp +++ b/3rdParty/Boost/src/boost/archive/detail/interface_oarchive.hpp @@ -1,40 +1,40 @@ #ifndef BOOST_ARCHIVE_DETAIL_INTERFACE_OARCHIVE_HPP #define BOOST_ARCHIVE_DETAIL_INTERFACE_OARCHIVE_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 // interface_oarchive.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 <cstddef> // NULL #include <boost/cstdint.hpp> #include <boost/mpl/bool.hpp> #include <boost/archive/detail/auto_link_archive.hpp> #include <boost/archive/detail/oserializer.hpp> #include <boost/archive/detail/abi_prefix.hpp> // must be the last header #include <boost/serialization/singleton.hpp> namespace boost { namespace archive { namespace detail { class BOOST_ARCHIVE_OR_WARCHIVE_DECL(BOOST_PP_EMPTY()) basic_pointer_oserializer; template<class Archive> class interface_oarchive { protected: interface_oarchive(){}; public: ///////////////////////////////////////////////////////// diff --git a/3rdParty/Boost/src/boost/archive/detail/iserializer.hpp b/3rdParty/Boost/src/boost/archive/detail/iserializer.hpp index 53765af..cf547de 100644 --- a/3rdParty/Boost/src/boost/archive/detail/iserializer.hpp +++ b/3rdParty/Boost/src/boost/archive/detail/iserializer.hpp @@ -1,620 +1,646 @@ #ifndef BOOST_ARCHIVE_DETAIL_ISERIALIZER_HPP #define BOOST_ARCHIVE_DETAIL_ISERIALIZER_HPP // MS compatible compilers support #pragma once -#if defined(_MSC_VER) && (_MSC_VER >= 1020) +#if defined(_MSC_VER) # pragma once #pragma inline_depth(511) #pragma inline_recursion(on) #endif #if defined(__MWERKS__) #pragma inline_depth(511) #endif /////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8 // iserializer.hpp: interface for serialization system. // (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . // Use, modification and distribution is subject to the Boost Software // License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // See http://www.boost.org for updates, documentation, and revision history. #include <new> // for placement new -#include <memory> // for auto_ptr #include <cstddef> // size_t, NULL #include <boost/config.hpp> #include <boost/detail/workaround.hpp> #if defined(BOOST_NO_STDC_NAMESPACE) namespace std{ using ::size_t; } // namespace std #endif #include <boost/static_assert.hpp> #include <boost/mpl/eval_if.hpp> #include <boost/mpl/identity.hpp> #include <boost/mpl/greater_equal.hpp> #include <boost/mpl/equal_to.hpp> #include <boost/mpl/bool.hpp> #include <boost/detail/no_exceptions_support.hpp> #ifndef BOOST_SERIALIZATION_DEFAULT_TYPE_INFO #include <boost/serialization/extended_type_info_typeid.hpp> #endif #include <boost/serialization/throw_exception.hpp> #include <boost/serialization/smart_cast.hpp> #include <boost/serialization/static_warning.hpp> #include <boost/type_traits/is_pointer.hpp> #include <boost/type_traits/is_enum.hpp> #include <boost/type_traits/is_const.hpp> #include <boost/type_traits/remove_const.hpp> #include <boost/type_traits/remove_extent.hpp> #include <boost/type_traits/is_polymorphic.hpp> #include <boost/serialization/assume_abstract.hpp> -#define DONT_USE_HAS_NEW_OPERATOR ( \ +#if ! ( \ defined(__BORLANDC__) \ || BOOST_WORKAROUND(__IBMCPP__, < 1210) \ - || defined(BOOST_MSVC) && (BOOST_MSVC <= 1300) \ || defined(__SUNPRO_CC) && (__SUNPRO_CC < 0x590) \ ) - -#if ! DONT_USE_HAS_NEW_OPERATOR #include <boost/type_traits/has_new_operator.hpp> #endif #include <boost/serialization/serialization.hpp> #include <boost/serialization/version.hpp> #include <boost/serialization/level.hpp> #include <boost/serialization/tracking.hpp> #include <boost/serialization/type_info_implementation.hpp> #include <boost/serialization/nvp.hpp> #include <boost/serialization/void_cast.hpp> #include <boost/serialization/array.hpp> #include <boost/serialization/collection_size_type.hpp> #include <boost/serialization/singleton.hpp> #include <boost/serialization/wrapper.hpp> // the following is need only for dynamic cast of polymorphic pointers #include <boost/archive/archive_exception.hpp> #include <boost/archive/detail/basic_iarchive.hpp> #include <boost/archive/detail/basic_iserializer.hpp> #include <boost/archive/detail/basic_pointer_iserializer.hpp> #include <boost/archive/detail/archive_serializer_map.hpp> #include <boost/archive/detail/check.hpp> namespace boost { namespace serialization { class extended_type_info; } // namespace serialization namespace archive { // an accessor to permit friend access to archives. Needed because // some compilers don't handle friend templates completely class load_access { public: template<class Archive, class T> static void load_primitive(Archive &ar, T &t){ ar.load(t); } }; namespace detail { #ifdef BOOST_MSVC # pragma warning(push) # pragma warning(disable : 4511 4512) #endif template<class Archive, class T> class iserializer : public basic_iserializer { private: virtual void destroy(/*const*/ void *address) const { boost::serialization::access::destroy(static_cast<T *>(address)); } protected: // protected constructor since it's always created by singleton explicit iserializer() : basic_iserializer( boost::serialization::singleton< - BOOST_DEDUCED_TYPENAME + typename boost::serialization::type_info_implementation< T >::type >::get_const_instance() ) {} public: virtual BOOST_DLLEXPORT void load_object_data( basic_iarchive & ar, void *x, const unsigned int file_version ) const BOOST_USED; virtual bool class_info() const { return boost::serialization::implementation_level< T >::value >= boost::serialization::object_class_info; } virtual bool tracking(const unsigned int /* flags */) const { return boost::serialization::tracking_level< T >::value == boost::serialization::track_always || ( boost::serialization::tracking_level< T >::value == boost::serialization::track_selectively && serialized_as_pointer()); } virtual version_type version() const { return version_type(::boost::serialization::version< T >::value); } virtual bool is_polymorphic() const { return boost::is_polymorphic< T >::value; } virtual ~iserializer(){}; }; #ifdef BOOST_MSVC # pragma warning(pop) #endif template<class Archive, class T> BOOST_DLLEXPORT void iserializer<Archive, T>::load_object_data( basic_iarchive & ar, void *x, const unsigned int file_version ) const { // note: we now comment this out. Before we permited archive // version # to be very large. Now we don't. To permit // readers of these old archives, we have to suppress this // code. Perhaps in the future we might re-enable it but // permit its suppression with a runtime switch. #if 0 // trap case where the program cannot handle the current version if(file_version > static_cast<const unsigned int>(version())) boost::serialization::throw_exception( archive::archive_exception( boost::archive::archive_exception::unsupported_class_version, get_debug_info() ) ); #endif // make sure call is routed through the higest interface that might // be specialized by the user. boost::serialization::serialize_adl( boost::serialization::smart_cast_reference<Archive &>(ar), * static_cast<T *>(x), file_version ); } #ifdef BOOST_MSVC # pragma warning(push) # pragma warning(disable : 4511 4512) #endif -template<class Archive, class T> -class pointer_iserializer : - public basic_pointer_iserializer -{ -private: - virtual const basic_iserializer & get_basic_serializer() const { - return boost::serialization::singleton< - iserializer<Archive, T> - >::get_const_instance(); - } - BOOST_DLLEXPORT virtual void load_object_ptr( - basic_iarchive & ar, - void * & x, - const unsigned int file_version - ) const BOOST_USED; -protected: - // this should alway be a singleton so make the constructor protected - pointer_iserializer(); - ~pointer_iserializer(); -}; - -#ifdef BOOST_MSVC -# pragma warning(pop) -#endif - -// note trick to be sure that operator new is using class specific -// version if such exists. Due to Peter Dimov. -// note: the following fails if T has no default constructor. -// otherwise it would have been ideal -//struct heap_allocator : public T -//{ -// T * invoke(){ -// return ::new(sizeof(T)); -// } -//} +// the purpose of this code is to allocate memory for an object +// without requiring the constructor to be called. Presumably +// the allocated object will be subsequently initialized with +// "placement new". +// note: we have the boost type trait has_new_operator but we +// have no corresponding has_delete_operator. So we presume +// that the former being true would imply that the a delete +// operator is also defined for the class T. template<class T> -struct heap_allocator -{ +struct heap_allocation { // boost::has_new_operator< T > doesn't work on these compilers #if DONT_USE_HAS_NEW_OPERATOR // This doesn't handle operator new overload for class T - static T * invoke(){ + static T * invoke_new(){ return static_cast<T *>(operator new(sizeof(T))); } + static viod invoke_delete(){ + (operator delete(sizeof(T))); + } #else + // note: we presume that a true value for has_new_operator + // implies the existence of a class specific delete operator as well + // as a class specific new operator. struct has_new_operator { - static T* invoke() { + static T * invoke_new() { return static_cast<T *>((T::operator new)(sizeof(T))); } + static void invoke_delete(T * t) { + // if compilation fails here, the likely cause that the class + // T has a class specific new operator but no class specific + // delete operator which matches the following signature. Fix + // your program to have this. Note that adding operator delete + // with only one parameter doesn't seem correct to me since + // the standard(3.7.4.2) says " + // "If a class T has a member deallocation function named + // 'operator delete' with exactly one parameter, then that function + // is a usual (non-placement) deallocation function" which I take + // to mean that it will call the destructor of type T which we don't + // want to do here. + // Note: reliance upon automatic conversion from T * to void * here + (T::operator delete)(t, sizeof(T)); + } }; struct doesnt_have_new_operator { - static T* invoke() { + static T* invoke_new() { return static_cast<T *>(operator new(sizeof(T))); } + static void invoke_delete(T * t) { + // Note: I'm reliance upon automatic conversion from T * to void * here + (operator delete)(t); + } }; - static T * invoke() { - typedef BOOST_DEDUCED_TYPENAME + static T * invoke_new() { + typedef typename mpl::eval_if< boost::has_new_operator< T >, mpl::identity<has_new_operator >, mpl::identity<doesnt_have_new_operator > >::type typex; - return typex::invoke(); + return typex::invoke_new(); + } + static void invoke_delete(T *t) { + typedef typename + mpl::eval_if< + boost::has_new_operator< T >, + mpl::identity<has_new_operator >, + mpl::identity<doesnt_have_new_operator > + >::type typex; + typex::invoke_delete(t); } #endif -}; - -// due to Martin Ecker -template <typename T> -class auto_ptr_with_deleter -{ -public: - explicit auto_ptr_with_deleter(T* p) : - m_p(p) - {} - ~auto_ptr_with_deleter(){ - if (m_p) - boost::serialization::access::destroy(m_p); + explicit heap_allocation(){ + m_p = invoke_new(); + } + ~heap_allocation(){ + if (0 != m_p) + invoke_delete(m_p); } T* get() const { return m_p; } T* release() { T* p = m_p; - m_p = NULL; + m_p = 0; return p; } private: T* m_p; }; +template<class Archive, class T> +class pointer_iserializer : + public basic_pointer_iserializer +{ +private: + virtual void * heap_allocation() const { + detail::heap_allocation<T> h; + T * t = h.get(); + h.release(); + return t; + } + virtual const basic_iserializer & get_basic_serializer() const { + return boost::serialization::singleton< + iserializer<Archive, T> + >::get_const_instance(); + } + BOOST_DLLEXPORT virtual void load_object_ptr( + basic_iarchive & ar, + void * x, + const unsigned int file_version + ) const BOOST_USED; +protected: + // this should alway be a singleton so make the constructor protected + pointer_iserializer(); + ~pointer_iserializer(); +}; + +#ifdef BOOST_MSVC +# pragma warning(pop) +#endif + // note: BOOST_DLLEXPORT is so that code for polymorphic class // serialized only through base class won't get optimized out template<class Archive, class T> BOOST_DLLEXPORT void pointer_iserializer<Archive, T>::load_object_ptr( basic_iarchive & ar, - void * & x, + void * t, const unsigned int file_version ) const { Archive & ar_impl = boost::serialization::smart_cast_reference<Archive &>(ar); - auto_ptr_with_deleter< T > ap(heap_allocator< T >::invoke()); - if(NULL == ap.get()) - boost::serialization::throw_exception(std::bad_alloc()) ; - - T * t = ap.get(); - x = t; + // note that the above will throw std::bad_alloc if the allocation + // fails so we don't have to address this contingency here. // catch exception during load_construct_data so that we don't // automatically delete the t which is most likely not fully // constructed BOOST_TRY { - // this addresses an obscure situtation that occurs when + // this addresses an obscure situation that occurs when // load_constructor de-serializes something through a pointer. ar.next_object_pointer(t); boost::serialization::load_construct_data_adl<Archive, T>( ar_impl, - t, + static_cast<T *>(t), file_version ); } BOOST_CATCH(...){ - ap.release(); + // if we get here the load_construct failed. The heap_allocation + // will be automatically deleted so we don't have to do anything + // special here. BOOST_RETHROW; } BOOST_CATCH_END - ar_impl >> boost::serialization::make_nvp(NULL, * t); - ap.release(); + ar_impl >> boost::serialization::make_nvp(NULL, * static_cast<T *>(t)); } template<class Archive, class T> pointer_iserializer<Archive, T>::pointer_iserializer() : basic_pointer_iserializer( boost::serialization::singleton< - BOOST_DEDUCED_TYPENAME + typename boost::serialization::type_info_implementation< T >::type >::get_const_instance() ) { boost::serialization::singleton< iserializer<Archive, T> >::get_mutable_instance().set_bpis(this); archive_serializer_map<Archive>::insert(this); } template<class Archive, class T> pointer_iserializer<Archive, T>::~pointer_iserializer(){ archive_serializer_map<Archive>::erase(this); } template<class Archive> struct load_non_pointer_type { // note this bounces the call right back to the archive // with no runtime overhead struct load_primitive { template<class T> static void invoke(Archive & ar, T & t){ load_access::load_primitive(ar, t); } }; // note this bounces the call right back to the archive // with no runtime overhead struct load_only { template<class T> static void invoke(Archive & ar, const T & t){ // short cut to user's serializer // make sure call is routed through the higest interface that might // be specialized by the user. boost::serialization::serialize_adl( ar, const_cast<T &>(t), boost::serialization::version< T >::value ); } }; // note this save class information including version // and serialization level to the archive struct load_standard { template<class T> static void invoke(Archive &ar, const T & t){ void * x = & const_cast<T &>(t); ar.load_object( x, boost::serialization::singleton< iserializer<Archive, T> >::get_const_instance() ); } }; struct load_conditional { template<class T> static void invoke(Archive &ar, T &t){ //if(0 == (ar.get_flags() & no_tracking)) load_standard::invoke(ar, t); //else // load_only::invoke(ar, t); } }; template<class T> static void invoke(Archive & ar, T &t){ - typedef BOOST_DEDUCED_TYPENAME mpl::eval_if< + typedef typename mpl::eval_if< // if its primitive mpl::equal_to< boost::serialization::implementation_level< T >, mpl::int_<boost::serialization::primitive_type> >, mpl::identity<load_primitive>, // else - BOOST_DEDUCED_TYPENAME mpl::eval_if< + typename mpl::eval_if< // class info / version mpl::greater_equal< boost::serialization::implementation_level< T >, mpl::int_<boost::serialization::object_class_info> >, // do standard load mpl::identity<load_standard>, // else - BOOST_DEDUCED_TYPENAME mpl::eval_if< + typename mpl::eval_if< // no tracking mpl::equal_to< boost::serialization::tracking_level< T >, mpl::int_<boost::serialization::track_never> >, // do a fast load mpl::identity<load_only>, // else // do a fast load only tracking is turned off mpl::identity<load_conditional> > > >::type typex; check_object_versioning< T >(); check_object_level< T >(); typex::invoke(ar, t); } }; template<class Archive> struct load_pointer_type { struct abstract { template<class T> static const basic_pointer_iserializer * register_type(Archive & /* ar */){ // it has? to be polymorphic BOOST_STATIC_ASSERT(boost::is_polymorphic< T >::value); return static_cast<basic_pointer_iserializer *>(NULL); } }; struct non_abstract { template<class T> static const basic_pointer_iserializer * register_type(Archive & ar){ return ar.register_type(static_cast<T *>(NULL)); } }; template<class T> static const basic_pointer_iserializer * register_type(Archive &ar, const T & /*t*/){ // there should never be any need to load an abstract polymorphic // class pointer. Inhibiting code generation for this // permits abstract base classes to be used - note: exception // virtual serialize functions used for plug-ins - typedef BOOST_DEDUCED_TYPENAME + typedef typename mpl::eval_if< boost::serialization::is_abstract<const T>, boost::mpl::identity<abstract>, boost::mpl::identity<non_abstract> >::type typex; return typex::template register_type< T >(ar); } template<class T> static T * pointer_tweak( const boost::serialization::extended_type_info & eti, void const * const t, const T & ) { // tweak the pointer back to the base class - return static_cast<T *>( - const_cast<void *>( - boost::serialization::void_upcast( - eti, - boost::serialization::singleton< - BOOST_DEDUCED_TYPENAME - boost::serialization::type_info_implementation< T >::type - >::get_const_instance(), - t - ) + void * upcast = const_cast<void *>( + boost::serialization::void_upcast( + eti, + boost::serialization::singleton< + typename + boost::serialization::type_info_implementation< T >::type + >::get_const_instance(), + t ) ); + if(NULL == upcast) + boost::serialization::throw_exception( + archive_exception(archive_exception::unregistered_class) + ); + return static_cast<T *>(upcast); } template<class T> static void check_load(T & /* t */){ check_pointer_level< T >(); check_pointer_tracking< T >(); } static const basic_pointer_iserializer * find(const boost::serialization::extended_type_info & type){ return static_cast<const basic_pointer_iserializer *>( archive_serializer_map<Archive>::find(type) ); } template<class Tptr> static void invoke(Archive & ar, Tptr & t){ check_load(*t); const basic_pointer_iserializer * bpis_ptr = register_type(ar, *t); const basic_pointer_iserializer * newbpis_ptr = ar.load_pointer( // note major hack here !!! // I tried every way to convert Tptr &t (where Tptr might // include const) to void * &. This is the only way // I could make it work. RR (void * & )t, bpis_ptr, find ); // if the pointer isn't that of the base class if(newbpis_ptr != bpis_ptr){ t = pointer_tweak(newbpis_ptr->get_eti(), t, *t); } } }; template<class Archive> struct load_enum_type { template<class T> static void invoke(Archive &ar, T &t){ // convert integers to correct enum to load int i; ar >> boost::serialization::make_nvp(NULL, i); t = static_cast< T >(i); } }; template<class Archive> struct load_array_type { template<class T> static void invoke(Archive &ar, T &t){ - typedef BOOST_DEDUCED_TYPENAME remove_extent< T >::type value_type; + typedef typename remove_extent< T >::type value_type; // convert integers to correct enum to load // determine number of elements in the array. Consider the // fact that some machines will align elements on boundries // other than characters. std::size_t current_count = sizeof(t) / ( static_cast<char *>(static_cast<void *>(&t[1])) - static_cast<char *>(static_cast<void *>(&t[0])) ); boost::serialization::collection_size_type count; ar >> BOOST_SERIALIZATION_NVP(count); if(static_cast<std::size_t>(count) > current_count) boost::serialization::throw_exception( archive::archive_exception( boost::archive::archive_exception::array_size_too_short ) ); ar >> serialization::make_array(static_cast<value_type*>(&t[0]),count); } }; } // detail template<class Archive, class T> inline void load(Archive & ar, T &t){ // if this assertion trips. It means we're trying to load a // const object with a compiler that doesn't have correct // funtion template ordering. On other compilers, this is // handled below. detail::check_const_loading< T >(); typedef - BOOST_DEDUCED_TYPENAME mpl::eval_if<is_pointer< T >, + typename mpl::eval_if<is_pointer< T >, mpl::identity<detail::load_pointer_type<Archive> > ,//else - BOOST_DEDUCED_TYPENAME mpl::eval_if<is_array< T >, + typename mpl::eval_if<is_array< T >, mpl::identity<detail::load_array_type<Archive> > ,//else - BOOST_DEDUCED_TYPENAME mpl::eval_if<is_enum< T >, + typename mpl::eval_if<is_enum< T >, mpl::identity<detail::load_enum_type<Archive> > ,//else mpl::identity<detail::load_non_pointer_type<Archive> > > > >::type typex; typex::invoke(ar, t); } #if 0 // BORLAND #if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x560)) // borland has a couple of problems // a) if function is partially specialized - see below // const paramters are transformed to non-const ones // b) implementation of base_object can't be made to work // correctly which results in all base_object s being const. // So, strip off the const for borland. This breaks the trap // for loading const objects - but I see no alternative template<class Archive, class T> inline void load(Archive &ar, const T & t){ load(ar, const_cast<T &>(t)); } #endif // let wrappers through. #ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING template<class Archive, class T> inline void load_wrapper(Archive &ar, const T&t, mpl::true_){ boost::archive::load(ar, const_cast<T&>(t)); } #if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x560)) template<class Archive, class T> diff --git a/3rdParty/Boost/src/boost/archive/detail/oserializer.hpp b/3rdParty/Boost/src/boost/archive/detail/oserializer.hpp index 7d2694d..7a7e239 100644 --- a/3rdParty/Boost/src/boost/archive/detail/oserializer.hpp +++ b/3rdParty/Boost/src/boost/archive/detail/oserializer.hpp @@ -1,40 +1,40 @@ #ifndef BOOST_ARCHIVE_OSERIALIZER_HPP #define BOOST_ARCHIVE_OSERIALIZER_HPP // MS compatible compilers support #pragma once -#if defined(_MSC_VER) && (_MSC_VER >= 1020) +#if defined(_MSC_VER) # pragma once #pragma inline_depth(511) #pragma inline_recursion(on) #endif #if defined(__MWERKS__) #pragma inline_depth(511) #endif /////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8 // oserializer.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/assert.hpp> #include <cstddef> // NULL #include <boost/config.hpp> #include <boost/static_assert.hpp> #include <boost/detail/workaround.hpp> #include <boost/mpl/eval_if.hpp> #include <boost/mpl/equal_to.hpp> #include <boost/mpl/greater_equal.hpp> #include <boost/mpl/identity.hpp> #ifndef BOOST_SERIALIZATION_DEFAULT_TYPE_INFO #include <boost/serialization/extended_type_info_typeid.hpp> #endif #include <boost/serialization/throw_exception.hpp> @@ -74,71 +74,71 @@ namespace serialization { namespace archive { // an accessor to permit friend access to archives. Needed because // some compilers don't handle friend templates completely class save_access { public: template<class Archive> static void end_preamble(Archive & ar){ ar.end_preamble(); } template<class Archive, class T> static void save_primitive(Archive & ar, const T & t){ ar.end_preamble(); ar.save(t); } }; namespace detail { #ifdef BOOST_MSVC # pragma warning(push) # pragma warning(disable : 4511 4512) #endif template<class Archive, class T> class oserializer : public basic_oserializer { private: // private constructor to inhibit any existence other than the // static one public: explicit BOOST_DLLEXPORT oserializer() : basic_oserializer( boost::serialization::singleton< - BOOST_DEDUCED_TYPENAME + typename boost::serialization::type_info_implementation< T >::type >::get_const_instance() ) {} virtual BOOST_DLLEXPORT void save_object_data( basic_oarchive & ar, const void *x ) const BOOST_USED; virtual bool class_info() const { return boost::serialization::implementation_level< T >::value >= boost::serialization::object_class_info; } virtual bool tracking(const unsigned int /* flags */) const { return boost::serialization::tracking_level< T >::value == boost::serialization::track_always || (boost::serialization::tracking_level< T >::value == boost::serialization::track_selectively && serialized_as_pointer()); } virtual version_type version() const { return version_type(::boost::serialization::version< T >::value); } virtual bool is_polymorphic() const { return boost::is_polymorphic< T >::value; } virtual ~oserializer(){} }; #ifdef BOOST_MSVC # pragma warning(pop) #endif template<class Archive, class T> BOOST_DLLEXPORT void oserializer<Archive, T>::save_object_data( basic_oarchive & ar, const void *x ) const { @@ -173,242 +173,242 @@ private: const void * x ) const BOOST_USED; public: pointer_oserializer(); ~pointer_oserializer(); }; #ifdef BOOST_MSVC # pragma warning(pop) #endif template<class Archive, class T> BOOST_DLLEXPORT void pointer_oserializer<Archive, T>::save_object_ptr( basic_oarchive & ar, const void * x ) const { BOOST_ASSERT(NULL != x); // make sure call is routed through the highest interface that might // be specialized by the user. T * t = static_cast<T *>(const_cast<void *>(x)); const unsigned int file_version = boost::serialization::version< T >::value; Archive & ar_impl = boost::serialization::smart_cast_reference<Archive &>(ar); boost::serialization::save_construct_data_adl<Archive, T>( ar_impl, t, file_version ); ar_impl << boost::serialization::make_nvp(NULL, * t); } template<class Archive, class T> pointer_oserializer<Archive, T>::pointer_oserializer() : basic_pointer_oserializer( boost::serialization::singleton< - BOOST_DEDUCED_TYPENAME + typename boost::serialization::type_info_implementation< T >::type >::get_const_instance() ) { // make sure appropriate member function is instantiated boost::serialization::singleton< oserializer<Archive, T> >::get_mutable_instance().set_bpos(this); archive_serializer_map<Archive>::insert(this); } template<class Archive, class T> pointer_oserializer<Archive, T>::~pointer_oserializer(){ archive_serializer_map<Archive>::erase(this); } template<class Archive> struct save_non_pointer_type { // note this bounces the call right back to the archive // with no runtime overhead struct save_primitive { template<class T> static void invoke(Archive & ar, const T & t){ save_access::save_primitive(ar, t); } }; // same as above but passes through serialization struct save_only { template<class T> static void invoke(Archive & ar, const T & t){ // make sure call is routed through the highest interface that might // be specialized by the user. boost::serialization::serialize_adl( ar, const_cast<T &>(t), ::boost::serialization::version< T >::value ); } }; // adds class information to the archive. This includes // serialization level and class version struct save_standard { template<class T> static void invoke(Archive &ar, const T & t){ ar.save_object( & t, boost::serialization::singleton< oserializer<Archive, T> >::get_const_instance() ); } }; // adds class information to the archive. This includes // serialization level and class version struct save_conditional { template<class T> static void invoke(Archive &ar, const T &t){ //if(0 == (ar.get_flags() & no_tracking)) save_standard::invoke(ar, t); //else // save_only::invoke(ar, t); } }; template<class T> static void invoke(Archive & ar, const T & t){ typedef - BOOST_DEDUCED_TYPENAME mpl::eval_if< + typename mpl::eval_if< // if its primitive mpl::equal_to< boost::serialization::implementation_level< T >, mpl::int_<boost::serialization::primitive_type> >, mpl::identity<save_primitive>, // else - BOOST_DEDUCED_TYPENAME mpl::eval_if< + typename mpl::eval_if< // class info / version mpl::greater_equal< boost::serialization::implementation_level< T >, mpl::int_<boost::serialization::object_class_info> >, // do standard save mpl::identity<save_standard>, // else - BOOST_DEDUCED_TYPENAME mpl::eval_if< + typename mpl::eval_if< // no tracking mpl::equal_to< boost::serialization::tracking_level< T >, mpl::int_<boost::serialization::track_never> >, // do a fast save mpl::identity<save_only>, // else // do a fast save only tracking is turned off mpl::identity<save_conditional> > > >::type typex; check_object_versioning< T >(); typex::invoke(ar, t); } template<class T> static void invoke(Archive & ar, T & t){ check_object_level< T >(); check_object_tracking< T >(); invoke(ar, const_cast<const T &>(t)); } }; template<class Archive> struct save_pointer_type { struct abstract { template<class T> static const basic_pointer_oserializer * register_type(Archive & /* ar */){ // it has? to be polymorphic BOOST_STATIC_ASSERT(boost::is_polymorphic< T >::value); return NULL; } }; struct non_abstract { template<class T> static const basic_pointer_oserializer * register_type(Archive & ar){ return ar.register_type(static_cast<T *>(NULL)); } }; template<class T> static const basic_pointer_oserializer * register_type(Archive &ar, T & /*t*/){ // there should never be any need to save an abstract polymorphic // class pointer. Inhibiting code generation for this // permits abstract base classes to be used - note: exception // virtual serialize functions used for plug-ins typedef - BOOST_DEDUCED_TYPENAME mpl::eval_if< + typename mpl::eval_if< boost::serialization::is_abstract< T >, mpl::identity<abstract>, mpl::identity<non_abstract> >::type typex; return typex::template register_type< T >(ar); } struct non_polymorphic { template<class T> static void save( Archive &ar, T & t ){ const basic_pointer_oserializer & bpos = boost::serialization::singleton< pointer_oserializer<Archive, T> >::get_const_instance(); // save the requested pointer type ar.save_pointer(& t, & bpos); } }; struct polymorphic { template<class T> static void save( Archive &ar, T & t ){ - BOOST_DEDUCED_TYPENAME + typename boost::serialization::type_info_implementation< T >::type const & i = boost::serialization::singleton< - BOOST_DEDUCED_TYPENAME + typename boost::serialization::type_info_implementation< T >::type >::get_const_instance(); boost::serialization::extended_type_info const * const this_type = & i; // retrieve the true type of the object pointed to // if this assertion fails its an error in this library BOOST_ASSERT(NULL != this_type); const boost::serialization::extended_type_info * true_type = i.get_derived_extended_type_info(t); // note:if this exception is thrown, be sure that derived pointer // is either registered or exported. if(NULL == true_type){ boost::serialization::throw_exception( archive_exception( archive_exception::unregistered_class, "derived class not registered or exported" ) ); } // if its not a pointer to a more derived type const void *vp = static_cast<const void *>(&t); if(*this_type == *true_type){ const basic_pointer_oserializer * bpos = register_type(ar, t); ar.save_pointer(vp, bpos); return; } // convert pointer to more derived type. if this is thrown // it means that the base/derived relationship hasn't be registered vp = serialization::void_downcast( *true_type, *this_type, @@ -420,112 +420,112 @@ struct save_pointer_type { archive_exception::unregistered_cast, true_type->get_debug_info(), this_type->get_debug_info() ) ); } // since true_type is valid, and this only gets made if the // pointer oserializer object has been created, this should never // fail const basic_pointer_oserializer * bpos = static_cast<const basic_pointer_oserializer *>( boost::serialization::singleton< archive_serializer_map<Archive> >::get_const_instance().find(*true_type) ); BOOST_ASSERT(NULL != bpos); if(NULL == bpos) boost::serialization::throw_exception( archive_exception( archive_exception::unregistered_class, "derived class not registered or exported" ) ); ar.save_pointer(vp, bpos); } }; template<class T> static void save( Archive & ar, const T & t ){ check_pointer_level< T >(); check_pointer_tracking< T >(); - typedef BOOST_DEDUCED_TYPENAME mpl::eval_if< + typedef typename mpl::eval_if< is_polymorphic< T >, mpl::identity<polymorphic>, mpl::identity<non_polymorphic> >::type type; type::save(ar, const_cast<T &>(t)); } template<class TPtr> static void invoke(Archive &ar, const TPtr t){ register_type(ar, * t); if(NULL == t){ basic_oarchive & boa = boost::serialization::smart_cast_reference<basic_oarchive &>(ar); boa.save_null_pointer(); save_access::end_preamble(ar); return; } save(ar, * t); } }; template<class Archive> struct save_enum_type { template<class T> static void invoke(Archive &ar, const T &t){ // convert enum to integers on save const int i = static_cast<int>(t); ar << boost::serialization::make_nvp(NULL, i); } }; template<class Archive> struct save_array_type { template<class T> static void invoke(Archive &ar, const T &t){ - typedef BOOST_DEDUCED_TYPENAME boost::remove_extent< T >::type value_type; + typedef typename boost::remove_extent< T >::type value_type; save_access::end_preamble(ar); // consider alignment std::size_t c = sizeof(t) / ( static_cast<const char *>(static_cast<const void *>(&t[1])) - static_cast<const char *>(static_cast<const void *>(&t[0])) ); boost::serialization::collection_size_type count(c); ar << BOOST_SERIALIZATION_NVP(count); ar << serialization::make_array(static_cast<value_type const*>(&t[0]),count); } }; } // detail template<class Archive, class T> inline void save(Archive & ar, /*const*/ T &t){ typedef - BOOST_DEDUCED_TYPENAME mpl::eval_if<is_pointer< T >, + typename mpl::eval_if<is_pointer< T >, mpl::identity<detail::save_pointer_type<Archive> >, //else - BOOST_DEDUCED_TYPENAME mpl::eval_if<is_enum< T >, + typename mpl::eval_if<is_enum< T >, mpl::identity<detail::save_enum_type<Archive> >, //else - BOOST_DEDUCED_TYPENAME mpl::eval_if<is_array< T >, + typename mpl::eval_if<is_array< T >, mpl::identity<detail::save_array_type<Archive> >, //else mpl::identity<detail::save_non_pointer_type<Archive> > > > >::type typex; typex::invoke(ar, t); } } // namespace archive } // namespace boost #endif // BOOST_ARCHIVE_OSERIALIZER_HPP diff --git a/3rdParty/Boost/src/boost/archive/detail/register_archive.hpp b/3rdParty/Boost/src/boost/archive/detail/register_archive.hpp index e31ae46..81a19b9 100644 --- a/3rdParty/Boost/src/boost/archive/detail/register_archive.hpp +++ b/3rdParty/Boost/src/boost/archive/detail/register_archive.hpp @@ -49,43 +49,43 @@ struct get_counter { }; char adjust_counter(counter<0>); template<class Serializable> void instantiate_ptr_serialization(Serializable*, counter<0>) {} #define BOOST_SERIALIZATION_REGISTER_ARCHIVE(Archive) \ namespace boost { namespace archive { namespace detail { \ get_counter<Archive >::next adjust_counter(get_counter<Archive >::type);\ template<class Serializable> \ void instantiate_ptr_serialization(Serializable* s, \ get_counter<Archive >::type) { \ ptr_serialization_support<Archive, Serializable> x; \ instantiate_ptr_serialization(s, get_counter<Archive >::prior()); \ }\ }}} #else // This function gets called, but its only purpose is to participate // in overload resolution with the functions declared by // BOOST_SERIALIZATION_REGISTER_ARCHIVE, below. template <class Serializable> void instantiate_ptr_serialization(Serializable*, int, adl_tag ) {} // The function declaration generated by this macro never actually // gets called, but its return type gets instantiated, and that's // enough to cause registration of serialization functions between // Archive and any exported Serializable type. See also: // boost/serialization/export.hpp # define BOOST_SERIALIZATION_REGISTER_ARCHIVE(Archive) \ namespace boost { namespace archive { namespace detail { \ \ template <class Serializable> \ -BOOST_DEDUCED_TYPENAME _ptr_serialization_support<Archive, Serializable>::type \ +typename _ptr_serialization_support<Archive, Serializable>::type \ instantiate_ptr_serialization( Serializable*, Archive*, adl_tag ); \ \ }}} #endif }}} // namespace boost::archive::detail #endif // BOOST_ARCHIVE_DETAIL_INSTANTIATE_SERIALIZE_DWA2006521_HPP diff --git a/3rdParty/Boost/src/boost/archive/detail/utf8_codecvt_facet.hpp b/3rdParty/Boost/src/boost/archive/detail/utf8_codecvt_facet.hpp index bd859ff..b2430d5 100644 --- a/3rdParty/Boost/src/boost/archive/detail/utf8_codecvt_facet.hpp +++ b/3rdParty/Boost/src/boost/archive/detail/utf8_codecvt_facet.hpp @@ -1,21 +1,23 @@ // Copyright (c) 2001 Ronald Garcia, Indiana University (garcia@osl.iu.edu) // Andrew Lumsdaine, Indiana University (lums@osl.iu.edu). // 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) #ifndef BOOST_ARCHIVE_DETAIL_UTF8_CODECVT_FACET_HPP #define BOOST_ARCHIVE_DETAIL_UTF8_CODECVT_FACET_HPP -#define BOOST_UTF8_BEGIN_NAMESPACE \ - namespace boost { namespace archive { namespace detail { -#define BOOST_UTF8_DECL -#define BOOST_UTF8_END_NAMESPACE }}} +#ifdef BOOST_NO_CXX11_HDR_CODECVT + #define BOOST_UTF8_BEGIN_NAMESPACE \ + namespace boost { namespace archive { namespace detail { + #define BOOST_UTF8_DECL + #define BOOST_UTF8_END_NAMESPACE }}} -#include <boost/detail/utf8_codecvt_facet.hpp> - -#undef BOOST_UTF8_END_NAMESPACE -#undef BOOST_UTF8_DECL -#undef BOOST_UTF8_BEGIN_NAMESPACE + #include <boost/detail/utf8_codecvt_facet.hpp> + #undef BOOST_UTF8_END_NAMESPACE + #undef BOOST_UTF8_DECL + #undef BOOST_UTF8_BEGIN_NAMESPACE +#endif // BOOST_NO_CXX11_HDR_CODECVT #endif // BOOST_ARCHIVE_DETAIL_UTF8_CODECVT_FACET_HPP + diff --git a/3rdParty/Boost/src/boost/archive/dinkumware.hpp b/3rdParty/Boost/src/boost/archive/dinkumware.hpp index bfa828d..90ba627 100644 --- a/3rdParty/Boost/src/boost/archive/dinkumware.hpp +++ b/3rdParty/Boost/src/boost/archive/dinkumware.hpp @@ -1,40 +1,40 @@ #ifndef BOOST_ARCHIVE_DINKUMWARE_HPP #define BOOST_ARCHIVE_DINKUMWARE_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 // dinkumware.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 file adds a couple of things that are missing from the dinkumware // implementation of the standard library. #include <iterator> #include <string> #include <boost/config.hpp> #include <boost/cstdint.hpp> namespace std { // define i/o operators for 64 bit integers template<class CharType> basic_ostream<CharType> & operator<<(basic_ostream<CharType> & os, boost::uint64_t t){ // octal rendering of 64 bit number would be 22 octets + eos CharType d[23]; unsigned int radix; if(os.flags() & (int)std::ios_base::hex) radix = 16; else diff --git a/3rdParty/Boost/src/boost/archive/impl/basic_binary_iarchive.ipp b/3rdParty/Boost/src/boost/archive/impl/basic_binary_iarchive.ipp index 8ea39f7..b8e7f45 100644 --- a/3rdParty/Boost/src/boost/archive/impl/basic_binary_iarchive.ipp +++ b/3rdParty/Boost/src/boost/archive/impl/basic_binary_iarchive.ipp @@ -1,129 +1,133 @@ /////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8 // basic_binary_iarchive.ipp: // (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/assert.hpp> #include <algorithm> #include <cstring> -#include <boost/config.hpp> // for BOOST_DEDUCED_TYPENAME +#include <boost/config.hpp> #if defined(BOOST_NO_STDC_NAMESPACE) namespace std{ using ::memcpy; using ::strlen; using ::size_t; } #endif #include <boost/detail/workaround.hpp> #include <boost/detail/endian.hpp> #include <boost/archive/basic_binary_iarchive.hpp> namespace boost { namespace archive { /////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8 // implementation of binary_binary_archive template<class Archive> BOOST_ARCHIVE_OR_WARCHIVE_DECL(void) basic_binary_iarchive<Archive>::load_override(class_name_type & t, int){ std::string cn; cn.reserve(BOOST_SERIALIZATION_MAX_KEY_SIZE); load_override(cn, 0); if(cn.size() > (BOOST_SERIALIZATION_MAX_KEY_SIZE - 1)) boost::serialization::throw_exception( archive_exception(archive_exception::invalid_class_name) ); std::memcpy(t, cn.data(), cn.size()); // borland tweak t.t[cn.size()] = '\0'; } template<class Archive> BOOST_ARCHIVE_OR_WARCHIVE_DECL(void) basic_binary_iarchive<Archive>::init(){ // read signature in an archive version independent manner std::string file_signature; + + #if 0 // commented out since it interfers with derivation try { std::size_t l; this->This()->load(l); if(l == std::strlen(BOOST_ARCHIVE_SIGNATURE())) { // borland de-allocator fixup #if BOOST_WORKAROUND(_RWSTD_VER, BOOST_TESTED_AT(20101)) if(NULL != file_signature.data()) #endif file_signature.resize(l); // note breaking a rule here - could be a problem on some platform if(0 < l) this->This()->load_binary(&(*file_signature.begin()), l); } } catch(archive_exception const &) { // catch stream_error archive exceptions // will cause invalid_signature archive exception to be thrown below file_signature = ""; } + #else + // https://svn.boost.org/trac/boost/ticket/7301 + * this->This() >> file_signature; + #endif + if(file_signature != BOOST_ARCHIVE_SIGNATURE()) boost::serialization::throw_exception( archive_exception(archive_exception::invalid_signature) ); // make sure the version of the reading archive library can // support the format of the archive being read library_version_type input_library_version; //* this->This() >> input_library_version; { int v = 0; v = this->This()->m_sb.sbumpc(); #if defined(BOOST_LITTLE_ENDIAN) if(v < 6){ ; } else if(v < 7){ // version 6 - next byte should be zero this->This()->m_sb.sbumpc(); } else if(v < 8){ int x1; // version 7 = might be followed by zero or some other byte x1 = this->This()->m_sb.sgetc(); // it's =a zero, push it back if(0 == x1) this->This()->m_sb.sbumpc(); } else{ // version 8+ followed by a zero this->This()->m_sb.sbumpc(); } #elif defined(BOOST_BIG_ENDIAN) if(v == 0) v = this->This()->m_sb.sbumpc(); #endif input_library_version = static_cast<library_version_type>(v); } #if BOOST_WORKAROUND(__MWERKS__, BOOST_TESTED_AT(0x3205)) this->set_library_version(input_library_version); #else - #if ! BOOST_WORKAROUND(BOOST_MSVC, <= 1200) - detail:: - #endif - basic_iarchive::set_library_version(input_library_version); + detail::basic_iarchive::set_library_version(input_library_version); #endif if(BOOST_ARCHIVE_VERSION() < input_library_version) boost::serialization::throw_exception( archive_exception(archive_exception::unsupported_version) ); } } // namespace archive } // namespace boost diff --git a/3rdParty/Boost/src/boost/archive/impl/basic_binary_iprimitive.ipp b/3rdParty/Boost/src/boost/archive/impl/basic_binary_iprimitive.ipp index e0f5c2e..9e2340e 100644 --- a/3rdParty/Boost/src/boost/archive/impl/basic_binary_iprimitive.ipp +++ b/3rdParty/Boost/src/boost/archive/impl/basic_binary_iprimitive.ipp @@ -1,65 +1,66 @@ /////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8 // basic_binary_iprimitive.ipp: // (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 <cstddef> // size_t, NULL #include <cstring> // memcpy #include <boost/config.hpp> #if defined(BOOST_NO_STDC_NAMESPACE) namespace std{ using ::size_t; using ::memcpy; } // namespace std #endif #include <boost/detail/workaround.hpp> // fixup for RogueWave #include <boost/serialization/throw_exception.hpp> #include <boost/scoped_ptr.hpp> #include <boost/archive/archive_exception.hpp> #include <boost/archive/codecvt_null.hpp> #include <boost/archive/add_facet.hpp> +#include <boost/archive/basic_binary_iprimitive.hpp> namespace boost { namespace archive { ////////////////////////////////////////////////////////////////////// // implementation of basic_binary_iprimitive template<class Archive, class Elem, class Tr> BOOST_ARCHIVE_OR_WARCHIVE_DECL(void) basic_binary_iprimitive<Archive, Elem, Tr>::init() { // Detect attempts to pass native binary archives across // incompatible platforms. This is not fool proof but its // better than nothing. unsigned char size; this->This()->load(size); if(sizeof(int) != size) boost::serialization::throw_exception( archive_exception( archive_exception::incompatible_native_format, "size of int" ) ); this->This()->load(size); if(sizeof(long) != size) boost::serialization::throw_exception( archive_exception( archive_exception::incompatible_native_format, "size of long" ) ); this->This()->load(size); if(sizeof(float) != size) boost::serialization::throw_exception( archive_exception( diff --git a/3rdParty/Boost/src/boost/archive/impl/basic_binary_oarchive.ipp b/3rdParty/Boost/src/boost/archive/impl/basic_binary_oarchive.ipp index dec2cd7..467fd6f 100644 --- a/3rdParty/Boost/src/boost/archive/impl/basic_binary_oarchive.ipp +++ b/3rdParty/Boost/src/boost/archive/impl/basic_binary_oarchive.ipp @@ -1,46 +1,46 @@ /////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8 // basic_binary_oarchive.ipp: // (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/assert.hpp> #include <algorithm> #include <cstring> -#include <boost/config.hpp> // for BOOST_DEDUCED_TYPENAME +#include <boost/config.hpp> #if defined(BOOST_NO_STDC_NAMESPACE) namespace std{ using ::memcpy; } #endif #include <boost/archive/basic_binary_oarchive.hpp> namespace boost { namespace archive { /////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8 // implementation of binary_binary_oarchive template<class Archive> #if !defined(__BORLANDC__) BOOST_ARCHIVE_OR_WARCHIVE_DECL(void) #else void #endif basic_binary_oarchive<Archive>::init(){ // write signature in an archive version independent manner const std::string file_signature(BOOST_ARCHIVE_SIGNATURE()); * this->This() << file_signature; // write library version const library_version_type v(BOOST_ARCHIVE_VERSION()); * this->This() << v; } } // namespace archive } // namespace boost diff --git a/3rdParty/Boost/src/boost/archive/impl/basic_binary_oprimitive.ipp b/3rdParty/Boost/src/boost/archive/impl/basic_binary_oprimitive.ipp index 02b5ffa..509decb 100644 --- a/3rdParty/Boost/src/boost/archive/impl/basic_binary_oprimitive.ipp +++ b/3rdParty/Boost/src/boost/archive/impl/basic_binary_oprimitive.ipp @@ -1,68 +1,69 @@ /////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8 // basic_binary_oprimitive.ipp: // (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 <ostream> #include <cstddef> // NULL #include <cstring> #include <boost/config.hpp> #if defined(BOOST_NO_STDC_NAMESPACE) && ! defined(__LIBCOMO__) namespace std{ using ::strlen; } // namespace std #endif #ifndef BOOST_NO_CWCHAR #include <cwchar> #ifdef BOOST_NO_STDC_NAMESPACE namespace std{ using ::wcslen; } #endif #endif #include <boost/detail/workaround.hpp> #include <boost/archive/add_facet.hpp> #include <boost/archive/codecvt_null.hpp> +#include <boost/archive/basic_binary_oprimitive.hpp> namespace boost { namespace archive { ////////////////////////////////////////////////////////////////////// // implementation of basic_binary_oprimitive template<class Archive, class Elem, class Tr> BOOST_ARCHIVE_OR_WARCHIVE_DECL(void) basic_binary_oprimitive<Archive, Elem, Tr>::init() { // record native sizes of fundamental types // this is to permit detection of attempts to pass // native binary archives accross incompatible machines. // This is not foolproof but its better than nothing. this->This()->save(static_cast<unsigned char>(sizeof(int))); this->This()->save(static_cast<unsigned char>(sizeof(long))); this->This()->save(static_cast<unsigned char>(sizeof(float))); this->This()->save(static_cast<unsigned char>(sizeof(double))); // for checking endianness this->This()->save(int(1)); } template<class Archive, class Elem, class Tr> BOOST_ARCHIVE_OR_WARCHIVE_DECL(void) basic_binary_oprimitive<Archive, Elem, Tr>::save(const char * s) { std::size_t l = std::strlen(s); this->This()->save(l); save_binary(s, l); } template<class Archive, class Elem, class Tr> BOOST_ARCHIVE_OR_WARCHIVE_DECL(void) basic_binary_oprimitive<Archive, Elem, Tr>::save(const std::string &s) diff --git a/3rdParty/Boost/src/boost/archive/impl/basic_text_iarchive.ipp b/3rdParty/Boost/src/boost/archive/impl/basic_text_iarchive.ipp index 0a246b7..8d364f9 100644 --- a/3rdParty/Boost/src/boost/archive/impl/basic_text_iarchive.ipp +++ b/3rdParty/Boost/src/boost/archive/impl/basic_text_iarchive.ipp @@ -1,79 +1,76 @@ /////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8 // basic_text_iarchive.ipp: // (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 <algorithm> #include <cstring> -#include <boost/config.hpp> // for BOOST_DEDUCED_TYPENAME +#include <boost/config.hpp> #if defined(BOOST_NO_STDC_NAMESPACE) namespace std{ using ::memcpy; } #endif #include <boost/detail/workaround.hpp> #include <boost/serialization/string.hpp> #include <boost/archive/basic_text_iarchive.hpp> namespace boost { namespace archive { /////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8 // implementation of text_text_archive template<class Archive> BOOST_ARCHIVE_OR_WARCHIVE_DECL(void) basic_text_iarchive<Archive>::load_override(class_name_type & t, int){ std::string cn; cn.reserve(BOOST_SERIALIZATION_MAX_KEY_SIZE); load_override(cn, 0); if(cn.size() > (BOOST_SERIALIZATION_MAX_KEY_SIZE - 1)) boost::serialization::throw_exception( archive_exception(archive_exception::invalid_class_name) ); std::memcpy(t, cn.data(), cn.size()); // borland tweak t.t[cn.size()] = '\0'; } template<class Archive> BOOST_ARCHIVE_OR_WARCHIVE_DECL(void) basic_text_iarchive<Archive>::init(void){ // read signature in an archive version independent manner std::string file_signature; * this->This() >> file_signature; if(file_signature != BOOST_ARCHIVE_SIGNATURE()) boost::serialization::throw_exception( archive_exception(archive_exception::invalid_signature) ); // make sure the version of the reading archive library can // support the format of the archive being read library_version_type input_library_version; * this->This() >> input_library_version; #if BOOST_WORKAROUND(__MWERKS__, BOOST_TESTED_AT(0x3205)) this->set_library_version(input_library_version); #else - #if ! BOOST_WORKAROUND(BOOST_MSVC, <= 1200) - detail:: - #endif - basic_iarchive::set_library_version(input_library_version); + detail::basic_iarchive::set_library_version(input_library_version); #endif // extra little .t is to get around borland quirk if(BOOST_ARCHIVE_VERSION() < input_library_version) boost::serialization::throw_exception( archive_exception(archive_exception::unsupported_version) ); } } // namespace archive } // namespace boost diff --git a/3rdParty/Boost/src/boost/archive/impl/basic_text_iprimitive.ipp b/3rdParty/Boost/src/boost/archive/impl/basic_text_iprimitive.ipp index ad6a6d5..d0da284 100644 --- a/3rdParty/Boost/src/boost/archive/impl/basic_text_iprimitive.ipp +++ b/3rdParty/Boost/src/boost/archive/impl/basic_text_iprimitive.ipp @@ -1,154 +1,152 @@ /////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8 // basic_text_iprimitive.ipp: // (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . // 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 for updates, documentation, and revision history. #include <cstddef> // size_t #include <cstddef> // NULL #include <boost/config.hpp> #if defined(BOOST_NO_STDC_NAMESPACE) namespace std{ using ::size_t; } // namespace std #endif #include <boost/serialization/throw_exception.hpp> #include <boost/serialization/pfto.hpp> #include <boost/archive/basic_text_iprimitive.hpp> #include <boost/archive/codecvt_null.hpp> #include <boost/archive/add_facet.hpp> #include <boost/archive/iterators/remove_whitespace.hpp> #include <boost/archive/iterators/istream_iterator.hpp> #include <boost/archive/iterators/binary_from_base64.hpp> #include <boost/archive/iterators/transform_width.hpp> -namespace boost { +namespace boost { namespace archive { -namespace { +namespace detail { template<class CharType> bool is_whitespace(CharType c); template<> bool is_whitespace(char t){ return 0 != std::isspace(t); } #ifndef BOOST_NO_CWCHAR template<> bool is_whitespace(wchar_t t){ return 0 != std::iswspace(t); } #endif -} +} // detail // translate base64 text into binary and copy into buffer // until buffer is full. template<class IStream> BOOST_ARCHIVE_OR_WARCHIVE_DECL(void) basic_text_iprimitive<IStream>::load_binary( void *address, std::size_t count ){ - typedef BOOST_DEDUCED_TYPENAME IStream::char_type CharType; + typedef typename IStream::char_type CharType; if(0 == count) return; BOOST_ASSERT( static_cast<std::size_t>((std::numeric_limits<std::streamsize>::max)()) > (count + sizeof(CharType) - 1)/sizeof(CharType) ); if(is.fail()) boost::serialization::throw_exception( archive_exception(archive_exception::input_stream_error) ); // convert from base64 to binary - typedef BOOST_DEDUCED_TYPENAME + typedef typename iterators::transform_width< iterators::binary_from_base64< iterators::remove_whitespace< iterators::istream_iterator<CharType> > ,CharType > ,8 ,6 ,CharType > binary; - - binary ti_begin = binary( + + binary i = binary( BOOST_MAKE_PFTO_WRAPPER( iterators::istream_iterator<CharType>(is) ) ); - + char * caddr = static_cast<char *>(address); // take care that we don't increment anymore than necessary - while(--count > 0){ - *caddr++ = static_cast<char>(*ti_begin); - ++ti_begin; + while(count-- > 0){ + *caddr++ = static_cast<char>(*i++); } - *caddr++ = static_cast<char>(*ti_begin); - - iterators::istream_iterator<CharType> i; + + // skip over any excess input for(;;){ - BOOST_DEDUCED_TYPENAME IStream::int_type r; + typename IStream::int_type r; r = is.get(); if(is.eof()) break; - if(is_whitespace(static_cast<CharType>(r))) + if(detail::is_whitespace(static_cast<CharType>(r))) break; } } - + template<class IStream> BOOST_ARCHIVE_OR_WARCHIVE_DECL(BOOST_PP_EMPTY()) basic_text_iprimitive<IStream>::basic_text_iprimitive( IStream &is_, bool no_codecvt ) : #ifndef BOOST_NO_STD_LOCALE is(is_), flags_saver(is_), precision_saver(is_), archive_locale(NULL), locale_saver(* is_.rdbuf()) { if(! no_codecvt){ archive_locale.reset( add_facet( std::locale::classic(), - new codecvt_null<BOOST_DEDUCED_TYPENAME IStream::char_type> + new codecvt_null<typename IStream::char_type> ) ); is.imbue(* archive_locale); } is >> std::noboolalpha; } #else is(is_), flags_saver(is_), precision_saver(is_) {} #endif template<class IStream> BOOST_ARCHIVE_OR_WARCHIVE_DECL(BOOST_PP_EMPTY()) basic_text_iprimitive<IStream>::~basic_text_iprimitive(){ is.sync(); } } // namespace archive } // namespace boost diff --git a/3rdParty/Boost/src/boost/archive/impl/basic_text_oarchive.ipp b/3rdParty/Boost/src/boost/archive/impl/basic_text_oarchive.ipp index 34e6995..4170c97 100644 --- a/3rdParty/Boost/src/boost/archive/impl/basic_text_oarchive.ipp +++ b/3rdParty/Boost/src/boost/archive/impl/basic_text_oarchive.ipp @@ -1,49 +1,49 @@ /////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8 // basic_text_oarchive.ipp: // (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/assert.hpp> #include <cstring> -#include <boost/config.hpp> // for BOOST_DEDUCED_TYPENAME +#include <boost/config.hpp> #if defined(BOOST_NO_STDC_NAMESPACE) namespace std{ using ::memcpy; } #endif #include <boost/archive/basic_text_oarchive.hpp> namespace boost { namespace archive { /////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8 // implementation of basic_text_oarchive template<class Archive> BOOST_ARCHIVE_OR_WARCHIVE_DECL(void) basic_text_oarchive<Archive>::newtoken() { switch(delimiter){ default: BOOST_ASSERT(false); break; case eol: this->This()->put('\n'); delimiter = space; break; case space: this->This()->put(' '); break; case none: delimiter = space; break; } } diff --git a/3rdParty/Boost/src/boost/archive/impl/basic_text_oprimitive.ipp b/3rdParty/Boost/src/boost/archive/impl/basic_text_oprimitive.ipp index cacab61..33ab4a8 100644 --- a/3rdParty/Boost/src/boost/archive/impl/basic_text_oprimitive.ipp +++ b/3rdParty/Boost/src/boost/archive/impl/basic_text_oprimitive.ipp @@ -1,114 +1,115 @@ /////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8 // basic_text_oprimitive.ipp: // (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 <cstddef> // NULL +#include <algorithm> // std::copy #include <boost/serialization/pfto.hpp> #include <boost/archive/basic_text_oprimitive.hpp> #include <boost/archive/codecvt_null.hpp> #include <boost/archive/add_facet.hpp> #include <boost/archive/iterators/base64_from_binary.hpp> #include <boost/archive/iterators/insert_linebreaks.hpp> #include <boost/archive/iterators/transform_width.hpp> #include <boost/archive/iterators/ostream_iterator.hpp> namespace boost { namespace archive { // translate to base64 and copy in to buffer. template<class OStream> BOOST_ARCHIVE_OR_WARCHIVE_DECL(void) basic_text_oprimitive<OStream>::save_binary( const void *address, std::size_t count ){ - typedef BOOST_DEDUCED_TYPENAME OStream::char_type CharType; + typedef typename OStream::char_type CharType; if(0 == count) return; if(os.fail()) boost::serialization::throw_exception( archive_exception(archive_exception::output_stream_error) ); os.put('\n'); typedef boost::archive::iterators::insert_linebreaks< boost::archive::iterators::base64_from_binary< boost::archive::iterators::transform_width< const char *, 6, 8 > > - ,72 + ,76 ,const char // cwpro8 needs this > base64_text; boost::archive::iterators::ostream_iterator<CharType> oi(os); std::copy( base64_text(BOOST_MAKE_PFTO_WRAPPER(static_cast<const char *>(address))), base64_text( BOOST_MAKE_PFTO_WRAPPER(static_cast<const char *>(address) + count) ), oi ); std::size_t tail = count % 3; if(tail > 0){ *oi++ = '='; if(tail < 2) *oi = '='; } } template<class OStream> BOOST_ARCHIVE_OR_WARCHIVE_DECL(BOOST_PP_EMPTY()) basic_text_oprimitive<OStream>::basic_text_oprimitive( OStream & os_, bool no_codecvt ) : #ifndef BOOST_NO_STD_LOCALE os(os_), flags_saver(os_), precision_saver(os_), archive_locale(NULL), locale_saver(* os_.rdbuf()) { if(! no_codecvt){ archive_locale.reset( add_facet( std::locale::classic(), - new codecvt_null<BOOST_DEDUCED_TYPENAME OStream::char_type> + new codecvt_null<typename OStream::char_type> ) ); os.imbue(* archive_locale); } os << std::noboolalpha; } #else os(os_), flags_saver(os_), precision_saver(os_) {} #endif template<class OStream> BOOST_ARCHIVE_OR_WARCHIVE_DECL(BOOST_PP_EMPTY()) basic_text_oprimitive<OStream>::~basic_text_oprimitive(){ os << std::endl; } } //namespace boost } //namespace archive diff --git a/3rdParty/Boost/src/boost/archive/impl/basic_xml_grammar.hpp b/3rdParty/Boost/src/boost/archive/impl/basic_xml_grammar.hpp index 807ed07..66ca1f0 100644 --- a/3rdParty/Boost/src/boost/archive/impl/basic_xml_grammar.hpp +++ b/3rdParty/Boost/src/boost/archive/impl/basic_xml_grammar.hpp @@ -1,92 +1,87 @@ #ifndef BOOST_ARCHIVE_BASIC_XML_GRAMMAR_HPP #define BOOST_ARCHIVE_BASIC_XML_GRAMMAR_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 // basic_xml_grammar.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 module is derived from simplexml.cpp - an example shipped as part of // the spirit parser. This example contains the following notice: /*============================================================================= simplexml.cpp Spirit V1.3 URL: http://spirit.sourceforge.net/ Copyright (c) 2001, Daniel C. Nuffer This software is provided 'as-is', without any express or implied warranty. In no event will the copyright holder be held liable for any damages arising from the use of this software. Permission is granted to anyone to use this software for any purpose, including commercial applications, and to alter it and redistribute it freely, subject to the following restrictions: 1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. 2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. 3. This notice may not be removed or altered from any source distribution. =============================================================================*/ #include <string> #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/spirit/include/classic_rule.hpp> #include <boost/spirit/include/classic_chset.hpp> #include <boost/archive/basic_archive.hpp> #include <boost/serialization/tracking.hpp> #include <boost/serialization/version.hpp> namespace boost { namespace archive { /////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8 // XML grammar parsing template<class CharType> class basic_xml_grammar { public: // The following is not necessary according to DR45, but at least // one compiler (Compaq C++ 6.5 in strict_ansi mode) chokes otherwise. struct return_values; friend struct return_values; private: typedef BOOST_DEDUCED_TYPENAME std::basic_istream<CharType> IStream; typedef BOOST_DEDUCED_TYPENAME std::basic_string<CharType> StringType; typedef BOOST_DEDUCED_TYPENAME boost::spirit::classic::chset<CharType> chset_t; typedef BOOST_DEDUCED_TYPENAME boost::spirit::classic::chlit<CharType> chlit_t; typedef BOOST_DEDUCED_TYPENAME boost::spirit::classic::scanner< BOOST_DEDUCED_TYPENAME std::basic_string<CharType>::iterator > scanner_t; typedef BOOST_DEDUCED_TYPENAME boost::spirit::classic::rule<scanner_t> rule_t; // Start grammar definition rule_t Reference, Eq, STag, diff --git a/3rdParty/Boost/src/boost/archive/impl/xml_iarchive_impl.ipp b/3rdParty/Boost/src/boost/archive/impl/xml_iarchive_impl.ipp index c7cbc7f..dc62eed 100644 --- a/3rdParty/Boost/src/boost/archive/impl/xml_iarchive_impl.ipp +++ b/3rdParty/Boost/src/boost/archive/impl/xml_iarchive_impl.ipp @@ -66,73 +66,73 @@ xml_iarchive_impl<Archive>::load(std::wstring &ws){ ws.resize(0); const char * start = s.data(); const char * end = start + s.size(); while(start < end){ wchar_t wc; int resultx = std::mbtowc(&wc, start, end - start); if(0 < resultx){ start += resultx; ws += wc; continue; } boost::serialization::throw_exception( iterators::dataflow_exception( iterators::dataflow_exception::invalid_conversion ) ); } } #endif // BOOST_NO_STD_WSTRING #ifndef BOOST_NO_INTRINSIC_WCHAR_T template<class Archive> BOOST_ARCHIVE_DECL(void) xml_iarchive_impl<Archive>::load(wchar_t * ws){ std::string s; bool result = gimpl->parse_string(is, s); if(! result) boost::serialization::throw_exception( xml_archive_exception(xml_archive_exception::xml_archive_parsing_error) ); const char * start = s.data(); const char * end = start + s.size(); while(start < end){ wchar_t wc; - int result = std::mbtowc(&wc, start, end - start); - if(0 < result){ - start += result; + int length = std::mbtowc(&wc, start, end - start); + if(0 < length){ + start += length; *ws++ = wc; continue; } boost::serialization::throw_exception( iterators::dataflow_exception( iterators::dataflow_exception::invalid_conversion ) ); } *ws = L'\0'; } #endif // BOOST_NO_INTRINSIC_WCHAR_T #endif // BOOST_NO_CWCHAR template<class Archive> BOOST_ARCHIVE_DECL(void) xml_iarchive_impl<Archive>::load(std::string &s){ bool result = gimpl->parse_string(is, s); if(! result) boost::serialization::throw_exception( xml_archive_exception(xml_archive_exception::xml_archive_parsing_error) ); } template<class Archive> BOOST_ARCHIVE_DECL(void) xml_iarchive_impl<Archive>::load(char * s){ std::string tstring; bool result = gimpl->parse_string(is, tstring); if(! result) boost::serialization::throw_exception( xml_archive_exception(xml_archive_exception::xml_archive_parsing_error) ); std::memcpy(s, tstring.data(), tstring.size()); diff --git a/3rdParty/Boost/src/boost/archive/impl/xml_oarchive_impl.ipp b/3rdParty/Boost/src/boost/archive/impl/xml_oarchive_impl.ipp index 8ab954f..ab1a217 100644 --- a/3rdParty/Boost/src/boost/archive/impl/xml_oarchive_impl.ipp +++ b/3rdParty/Boost/src/boost/archive/impl/xml_oarchive_impl.ipp @@ -1,46 +1,46 @@ /////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8 // xml_oarchive_impl.ipp: // (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . // 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 <ostream> #include <iomanip> -#include <algorithm> +#include <algorithm> // std::copy #include <string> #include <cstring> // strlen #include <boost/config.hpp> // msvc 6.0 needs this to suppress warnings #if defined(BOOST_NO_STDC_NAMESPACE) namespace std{ using ::strlen; } // namespace std #endif #include <boost/archive/iterators/xml_escape.hpp> #include <boost/archive/iterators/ostream_iterator.hpp> #ifndef BOOST_NO_CWCHAR #include <boost/archive/wcslen.hpp> #include <boost/archive/iterators/mb_from_wchar.hpp> #endif namespace boost { namespace archive { /////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8 // implemenations of functions specific to char archives // wide char stuff used by char archives #ifndef BOOST_NO_CWCHAR // copy chars to output escaping to xml and translating wide chars to mb chars template<class InputIterator> void save_iterator(std::ostream &os, InputIterator begin, InputIterator end){ typedef boost::archive::iterators::mb_from_wchar< boost::archive::iterators::xml_escape<InputIterator> > translator; std::copy( translator(BOOST_MAKE_PFTO_WRAPPER(begin)), translator(BOOST_MAKE_PFTO_WRAPPER(end)), diff --git a/3rdParty/Boost/src/boost/archive/impl/xml_wiarchive_impl.ipp b/3rdParty/Boost/src/boost/archive/impl/xml_wiarchive_impl.ipp index 9dde66c..a4665ad 100644 --- a/3rdParty/Boost/src/boost/archive/impl/xml_wiarchive_impl.ipp +++ b/3rdParty/Boost/src/boost/archive/impl/xml_wiarchive_impl.ipp @@ -1,74 +1,79 @@ /////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8 -// xml_wiprimitive.cpp: +// xml_wiarchive_impl.ipp: // (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . // 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 for updates, documentation, and revision history. -#include <boost/config.hpp> // for BOOST_DEDUCED_TYPENAME - #include <cstring> #if defined(BOOST_NO_STDC_NAMESPACE) namespace std{ using ::memcpy; } //std #endif #include <boost/config.hpp> // msvc 6.0 needs this to suppress warnings #ifndef BOOST_NO_STD_WSTREAMBUF #include <boost/assert.hpp> -#include <algorithm> +#include <algorithm> // std::copy #include <boost/detail/workaround.hpp> // Dinkumware and RogueWave #if BOOST_WORKAROUND(BOOST_DINKUMWARE_STDLIB, == 1) #include <boost/archive/dinkumware.hpp> #endif #include <boost/io/ios_state.hpp> #include <boost/detail/no_exceptions_support.hpp> #include <boost/serialization/pfto.hpp> #include <boost/serialization/string.hpp> #include <boost/archive/add_facet.hpp> -#include <boost/archive/xml_archive_exception.hpp> -#include <boost/archive/detail/utf8_codecvt_facet.hpp> +#ifndef BOOST_NO_CXX11_HDR_CODECVT + #include <codecvt> + namespace boost { namespace archive { namespace detail { + typedef std::codecvt_utf8<wchar_t> utf8_codecvt_facet; + } } } +#else + #include <boost/archive/detail/utf8_codecvt_facet.hpp> +#endif +#include <boost/archive/xml_archive_exception.hpp> #include <boost/archive/iterators/mb_from_wchar.hpp> #include <boost/archive/basic_xml_archive.hpp> #include <boost/archive/xml_wiarchive.hpp> #include "basic_xml_grammar.hpp" namespace boost { namespace archive { /////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8 // implemenations of functions specific to wide char archives namespace { // anonymous void copy_to_ptr(char * s, const std::wstring & ws){ std::copy( iterators::mb_from_wchar<std::wstring::const_iterator>( BOOST_MAKE_PFTO_WRAPPER(ws.begin()) ), iterators::mb_from_wchar<std::wstring::const_iterator>( BOOST_MAKE_PFTO_WRAPPER(ws.end()) ), s ); s[ws.size()] = 0; } } // anonymous template<class Archive> BOOST_WARCHIVE_DECL(void) xml_wiarchive_impl<Archive>::load(std::string & s){ std::wstring ws; bool result = gimpl->parse_string(is, ws); @@ -135,71 +140,71 @@ template<class Archive> BOOST_WARCHIVE_DECL(void) xml_wiarchive_impl<Archive>::load_override(class_name_type & t, int){ const std::wstring & ws = gimpl->rv.class_name; if(ws.size() > BOOST_SERIALIZATION_MAX_KEY_SIZE - 1) boost::serialization::throw_exception( archive_exception(archive_exception::invalid_class_name) ); copy_to_ptr(t, ws); } template<class Archive> BOOST_WARCHIVE_DECL(void) xml_wiarchive_impl<Archive>::init(){ gimpl->init(is); this->set_library_version( library_version_type(gimpl->rv.version) ); } template<class Archive> BOOST_WARCHIVE_DECL(BOOST_PP_EMPTY()) xml_wiarchive_impl<Archive>::xml_wiarchive_impl( std::wistream &is_, unsigned int flags ) : basic_text_iprimitive<std::wistream>( is_, true // don't change the codecvt - use the one below ), basic_xml_iarchive<Archive>(flags), gimpl(new xml_wgrammar()) { if(0 == (flags & no_codecvt)){ archive_locale.reset( add_facet( - std::locale::classic(), + is_.getloc(), new boost::archive::detail::utf8_codecvt_facet ) ); is.imbue(* archive_locale); } if(0 == (flags & no_header)){ BOOST_TRY{ this->init(); } BOOST_CATCH(...){ delete gimpl; #ifndef BOOST_NO_EXCEPTIONS throw; // re-throw #endif } BOOST_CATCH_END } } template<class Archive> BOOST_WARCHIVE_DECL(BOOST_PP_EMPTY()) xml_wiarchive_impl<Archive>::~xml_wiarchive_impl(){ if(0 == (this->get_flags() & no_header)){ BOOST_TRY{ gimpl->windup(is); } BOOST_CATCH(...){} BOOST_CATCH_END } delete gimpl; } } // namespace archive } // namespace boost diff --git a/3rdParty/Boost/src/boost/archive/impl/xml_woarchive_impl.ipp b/3rdParty/Boost/src/boost/archive/impl/xml_woarchive_impl.ipp index 3bf42bd..6092a91 100644 --- a/3rdParty/Boost/src/boost/archive/impl/xml_woarchive_impl.ipp +++ b/3rdParty/Boost/src/boost/archive/impl/xml_woarchive_impl.ipp @@ -1,77 +1,83 @@ /////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8 // xml_woarchive_impl.ipp: // (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . // 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_STD_WSTREAMBUF #include <ostream> #include <string> -#include <algorithm> +#include <algorithm> // std::copy #include <locale> -#include <boost/config.hpp> // msvc 6.0 needs this to suppress warnings - // for BOOST_DEDUCED_TYPENAME #include <cstring> // strlen #include <cstdlib> // mbtowc #include <cwchar> // wcslen +#include <boost/config.hpp> #if defined(BOOST_NO_STDC_NAMESPACE) namespace std{ using ::strlen; #if ! defined(BOOST_NO_INTRINSIC_WCHAR_T) using ::mbtowc; using ::wcslen; #endif } // namespace std #endif #include <boost/serialization/throw_exception.hpp> #include <boost/serialization/pfto.hpp> #include <boost/archive/iterators/xml_escape.hpp> #include <boost/archive/iterators/wchar_from_mb.hpp> #include <boost/archive/iterators/ostream_iterator.hpp> #include <boost/archive/iterators/dataflow_exception.hpp> #include <boost/archive/add_facet.hpp> -#include <boost/archive/detail/utf8_codecvt_facet.hpp> +#ifndef BOOST_NO_CXX11_HDR_CODECVT + #include <codecvt> + namespace boost { namespace archive { namespace detail { + typedef std::codecvt_utf8<wchar_t> utf8_codecvt_facet; + } } } +#else + #include <boost/archive/detail/utf8_codecvt_facet.hpp> +#endif namespace boost { namespace archive { /////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8 // implemenations of functions specific to wide char archives // copy chars to output escaping to xml and widening characters as we go template<class InputIterator> void save_iterator(std::wostream &os, InputIterator begin, InputIterator end){ typedef iterators::wchar_from_mb< iterators::xml_escape<InputIterator> > xmbtows; std::copy( xmbtows(BOOST_MAKE_PFTO_WRAPPER(begin)), xmbtows(BOOST_MAKE_PFTO_WRAPPER(end)), boost::archive::iterators::ostream_iterator<wchar_t>(os) ); } template<class Archive> BOOST_WARCHIVE_DECL(void) xml_woarchive_impl<Archive>::save(const std::string & s){ // note: we don't use s.begin() and s.end() because dinkumware // doesn't have string::value_type defined. So use a wrapper // around these values to implement the definitions. const char * begin = s.data(); const char * end = begin + s.size(); save_iterator(os, begin, end); } #ifndef BOOST_NO_STD_WSTRING template<class Archive> BOOST_WARCHIVE_DECL(void) xml_woarchive_impl<Archive>::save(const std::wstring & ws){ @@ -96,65 +102,66 @@ template<class Archive> BOOST_WARCHIVE_DECL(void) xml_woarchive_impl<Archive>::save(const char * s){ save_iterator(os, s, s + std::strlen(s)); } #ifndef BOOST_NO_INTRINSIC_WCHAR_T template<class Archive> BOOST_WARCHIVE_DECL(void) xml_woarchive_impl<Archive>::save(const wchar_t * ws){ os << ws; typedef iterators::xml_escape<const wchar_t *> xmbtows; std::copy( xmbtows(BOOST_MAKE_PFTO_WRAPPER(ws)), xmbtows(BOOST_MAKE_PFTO_WRAPPER(ws + std::wcslen(ws))), boost::archive::iterators::ostream_iterator<wchar_t>(os) ); } #endif template<class Archive> BOOST_WARCHIVE_DECL(BOOST_PP_EMPTY()) xml_woarchive_impl<Archive>::xml_woarchive_impl( std::wostream & os_, unsigned int flags ) : basic_text_oprimitive<std::wostream>( os_, true // don't change the codecvt - use the one below ), basic_xml_oarchive<Archive>(flags) { // Standard behavior is that imbue can be called // a) before output is invoked or // b) after flush has been called. This prevents one-to-many // transforms (such as one to many transforms from getting - // mixed up. Unfortunately, STLPort doesn't respect b) above - // so the restoration of the original archive locale done by - // the locale_saver doesn't get processed, - // before the current one is destroyed. - // so the codecvt doesn't get replaced with the orginal - // so closing the stream invokes codecvt::do_unshift - // so it crashes because the corresponding locale that contained - // the codecvt isn't around any more. - // we can hack around this by using a static codecvt that never - // gets destroyed. + // mixed up. if(0 == (flags & no_codecvt)){ boost::archive::detail::utf8_codecvt_facet *pfacet; #if defined(__SGI_STL_PORT) - static boost::archive::detail::utf8_codecvt_facet + // Unfortunately, STLPort doesn't respect b) above + // so the restoration of the original archive locale done by + // the locale_saver doesn't get processed, + // before the current one is destroyed. + // so the codecvt doesn't get replaced with the orginal + // so closing the stream invokes codecvt::do_unshift + // so it crashes because the corresponding locale that contained + // the codecvt isn't around any more. + // we can hack around this by using a static codecvt that never + // gets destroyed. + static boost::archive::detail::utf8_codecvt_facet facet(static_cast<size_t>(1)); pfacet = & facet; #else pfacet = new boost::archive::detail::utf8_codecvt_facet; #endif - archive_locale.reset(add_facet(std::locale::classic(), pfacet)); + archive_locale.reset(add_facet(os_.getloc(), pfacet)); os.imbue(* archive_locale); } if(0 == (flags & no_header)) this->init(); } } // namespace archive } // namespace boost #endif //BOOST_NO_STD_WSTREAMBUF diff --git a/3rdParty/Boost/src/boost/archive/iterators/base64_from_binary.hpp b/3rdParty/Boost/src/boost/archive/iterators/base64_from_binary.hpp index ecb916a..836d93d 100644 --- a/3rdParty/Boost/src/boost/archive/iterators/base64_from_binary.hpp +++ b/3rdParty/Boost/src/boost/archive/iterators/base64_from_binary.hpp @@ -1,112 +1,111 @@ #ifndef BOOST_ARCHIVE_ITERATORS_BASE64_FROM_BINARY_HPP #define BOOST_ARCHIVE_ITERATORS_BASE64_FROM_BINARY_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 // base64_from_binary.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/assert.hpp> #include <cstddef> // size_t -#include <boost/config.hpp> // for BOOST_DEDUCED_TYPENAME #if defined(BOOST_NO_STDC_NAMESPACE) namespace std{ using ::size_t; } // namespace std #endif #include <boost/serialization/pfto.hpp> #include <boost/iterator/transform_iterator.hpp> #include <boost/archive/iterators/dataflow_exception.hpp> namespace boost { namespace archive { namespace iterators { /////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8 // convert binary integers to base64 characters namespace detail { template<class CharType> struct from_6_bit { typedef CharType result_type; CharType operator()(CharType t) const{ const char * lookup_table = "ABCDEFGHIJKLMNOPQRSTUVWXYZ" "abcdefghijklmnopqrstuvwxyz" "0123456789" "+/"; BOOST_ASSERT(t < 64); return lookup_table[static_cast<size_t>(t)]; } }; } // namespace detail // note: what we would like to do is -// template<class Base, class CharType = BOOST_DEDUCED_TYPENAME Base::value_type> +// template<class Base, class CharType = typename Base::value_type> // typedef transform_iterator< // from_6_bit<CharType>, // transform_width<Base, 6, sizeof(Base::value_type) * 8, CharType> // > base64_from_binary; // but C++ won't accept this. Rather than using a "type generator" and // using a different syntax, make a derivation which should be equivalent. // // Another issue addressed here is that the transform_iterator doesn't have // a templated constructor. This makes it incompatible with the dataflow // ideal. This is also addressed here. -//template<class Base, class CharType = BOOST_DEDUCED_TYPENAME Base::value_type> +//template<class Base, class CharType = typename Base::value_type> template< class Base, - class CharType = BOOST_DEDUCED_TYPENAME boost::iterator_value<Base>::type + class CharType = typename boost::iterator_value<Base>::type > class base64_from_binary : public transform_iterator< detail::from_6_bit<CharType>, Base > { friend class boost::iterator_core_access; typedef transform_iterator< - BOOST_DEDUCED_TYPENAME detail::from_6_bit<CharType>, + typename detail::from_6_bit<CharType>, Base > super_t; public: // make composible buy using templated constructor template<class T> base64_from_binary(BOOST_PFTO_WRAPPER(T) start) : super_t( Base(BOOST_MAKE_PFTO_WRAPPER(static_cast< T >(start))), detail::from_6_bit<CharType>() ) {} // intel 7.1 doesn't like default copy constructor base64_from_binary(const base64_from_binary & rhs) : super_t( Base(rhs.base_reference()), detail::from_6_bit<CharType>() ) {} // base64_from_binary(){}; }; } // namespace iterators } // namespace archive } // namespace boost #endif // BOOST_ARCHIVE_ITERATORS_BASE64_FROM_BINARY_HPP diff --git a/3rdParty/Boost/src/boost/archive/iterators/binary_from_base64.hpp b/3rdParty/Boost/src/boost/archive/iterators/binary_from_base64.hpp index 60f23f3..9d2c87e 100644 --- a/3rdParty/Boost/src/boost/archive/iterators/binary_from_base64.hpp +++ b/3rdParty/Boost/src/boost/archive/iterators/binary_from_base64.hpp @@ -1,119 +1,118 @@ #ifndef BOOST_ARCHIVE_ITERATORS_BINARY_FROM_BASE64_HPP #define BOOST_ARCHIVE_ITERATORS_BINARY_FROM_BASE64_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 // binary_from_base64.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/assert.hpp> -#include <boost/config.hpp> // for BOOST_DEDUCED_TYPENAME #include <boost/serialization/throw_exception.hpp> #include <boost/serialization/pfto.hpp> #include <boost/static_assert.hpp> #include <boost/iterator/transform_iterator.hpp> #include <boost/archive/iterators/dataflow_exception.hpp> namespace boost { namespace archive { namespace iterators { /////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8 // convert base64 characters to binary data namespace detail { template<class CharType> struct to_6_bit { typedef CharType result_type; CharType operator()(CharType t) const{ const signed char lookup_table[] = { -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1, -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1, -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,62,-1,-1,-1,63, - 52,53,54,55,56,57,58,59,60,61,-1,-1,-1,-1,-1,-1, + 52,53,54,55,56,57,58,59,60,61,-1,-1,-1, 0,-1,-1, // render '=' as 0 -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9,10,11,12,13,14, 15,16,17,18,19,20,21,22,23,24,25,-1,-1,-1,-1,-1, -1,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40, 41,42,43,44,45,46,47,48,49,50,51,-1,-1,-1,-1,-1 }; // metrowerks trips this assertion - how come? #if ! defined(__MWERKS__) BOOST_STATIC_ASSERT(128 == sizeof(lookup_table)); #endif signed char value = -1; if((unsigned)t <= 127) value = lookup_table[(unsigned)t]; if(-1 == value) boost::serialization::throw_exception( dataflow_exception(dataflow_exception::invalid_base64_character) ); return value; } }; } // namespace detail // note: what we would like to do is -// template<class Base, class CharType = BOOST_DEDUCED_TYPENAME Base::value_type> +// template<class Base, class CharType = typename Base::value_type> // typedef transform_iterator< // from_6_bit<CharType>, // transform_width<Base, 6, sizeof(Base::value_type) * 8, CharType> // > base64_from_binary; // but C++ won't accept this. Rather than using a "type generator" and // using a different syntax, make a derivation which should be equivalent. // // Another issue addressed here is that the transform_iterator doesn't have // a templated constructor. This makes it incompatible with the dataflow // ideal. This is also addressed here. template< class Base, - class CharType = BOOST_DEDUCED_TYPENAME boost::iterator_value<Base>::type + class CharType = typename boost::iterator_value<Base>::type > class binary_from_base64 : public transform_iterator< detail::to_6_bit<CharType>, Base > { friend class boost::iterator_core_access; typedef transform_iterator< detail::to_6_bit<CharType>, Base > super_t; public: // make composible buy using templated constructor template<class T> binary_from_base64(BOOST_PFTO_WRAPPER(T) start) : super_t( Base(BOOST_MAKE_PFTO_WRAPPER(static_cast< T >(start))), detail::to_6_bit<CharType>() ) {} // intel 7.1 doesn't like default copy constructor binary_from_base64(const binary_from_base64 & rhs) : super_t( Base(rhs.base_reference()), detail::to_6_bit<CharType>() ) {} // binary_from_base64(){}; }; } // namespace iterators } // namespace archive } // namespace boost diff --git a/3rdParty/Boost/src/boost/archive/iterators/dataflow_exception.hpp b/3rdParty/Boost/src/boost/archive/iterators/dataflow_exception.hpp index 1d655a1..e3e1860 100644 --- a/3rdParty/Boost/src/boost/archive/iterators/dataflow_exception.hpp +++ b/3rdParty/Boost/src/boost/archive/iterators/dataflow_exception.hpp @@ -1,40 +1,40 @@ #ifndef BOOST_ARCHIVE_ITERATORS_DATAFLOW_EXCEPTION_HPP #define BOOST_ARCHIVE_ITERATORS_DATAFLOW_EXCEPTION_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 // dataflow_exception.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> #ifndef BOOST_NO_EXCEPTIONS #include <exception> #endif //BOOST_NO_EXCEPTIONS #include <boost/assert.hpp> namespace boost { namespace archive { namespace iterators { ////////////////////////////////////////////////////////////////////// // exceptions thrown by dataflows // class dataflow_exception : public std::exception { public: typedef enum { invalid_6_bitcode, invalid_base64_character, invalid_xml_escape_sequence, comparison_not_permitted, diff --git a/3rdParty/Boost/src/boost/archive/iterators/escape.hpp b/3rdParty/Boost/src/boost/archive/iterators/escape.hpp index bb527d4..a1fee91 100644 --- a/3rdParty/Boost/src/boost/archive/iterators/escape.hpp +++ b/3rdParty/Boost/src/boost/archive/iterators/escape.hpp @@ -1,82 +1,81 @@ #ifndef BOOST_ARCHIVE_ITERATORS_ESCAPE_HPP #define BOOST_ARCHIVE_ITERATORS_ESCAPE_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 // escape.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/assert.hpp> #include <cstddef> // NULL -#include <boost/config.hpp> // for BOOST_DEDUCED_TYPENAME #include <boost/iterator/iterator_adaptor.hpp> #include <boost/iterator/iterator_traits.hpp> namespace boost { namespace archive { namespace iterators { /////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8 // insert escapes into text template<class Derived, class Base> class escape : public boost::iterator_adaptor< Derived, Base, - BOOST_DEDUCED_TYPENAME boost::iterator_value<Base>::type, + typename boost::iterator_value<Base>::type, single_pass_traversal_tag, - BOOST_DEDUCED_TYPENAME boost::iterator_value<Base>::type + typename boost::iterator_value<Base>::type > { - typedef BOOST_DEDUCED_TYPENAME boost::iterator_value<Base>::type base_value_type; - typedef BOOST_DEDUCED_TYPENAME boost::iterator_reference<Base>::type reference_type; + typedef typename boost::iterator_value<Base>::type base_value_type; + typedef typename boost::iterator_reference<Base>::type reference_type; friend class boost::iterator_core_access; - typedef BOOST_DEDUCED_TYPENAME boost::iterator_adaptor< + typedef typename boost::iterator_adaptor< Derived, Base, base_value_type, single_pass_traversal_tag, base_value_type > super_t; typedef escape<Derived, Base> this_t; void dereference_impl() { m_current_value = static_cast<Derived *>(this)->fill(m_bnext, m_bend); m_full = true; } //Access the value referred to reference_type dereference() const { if(!m_full) const_cast<this_t *>(this)->dereference_impl(); return m_current_value; } bool equal(const this_t & rhs) const { if(m_full){ if(! rhs.m_full) const_cast<this_t *>(& rhs)->dereference_impl(); } else{ if(rhs.m_full) const_cast<this_t *>(this)->dereference_impl(); } if(m_bnext != rhs.m_bnext) return false; if(this->base_reference() != rhs.base_reference()) return false; return true; diff --git a/3rdParty/Boost/src/boost/archive/iterators/insert_linebreaks.hpp b/3rdParty/Boost/src/boost/archive/iterators/insert_linebreaks.hpp index 5f826ca..7fbc79f 100644 --- a/3rdParty/Boost/src/boost/archive/iterators/insert_linebreaks.hpp +++ b/3rdParty/Boost/src/boost/archive/iterators/insert_linebreaks.hpp @@ -1,75 +1,75 @@ #ifndef BOOST_ARCHIVE_ITERATORS_INSERT_LINEBREAKS_HPP #define BOOST_ARCHIVE_ITERATORS_INSERT_LINEBREAKS_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 // insert_linebreaks.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/assert.hpp> -#include <boost/config.hpp> // for BOOST_DEDUCED_TYPENAME +#include <boost/config.hpp> #if defined(BOOST_NO_STDC_NAMESPACE) namespace std{ using ::memcpy; } #endif #include <boost/serialization/pfto.hpp> #include <boost/iterator/iterator_adaptor.hpp> #include <boost/iterator/iterator_traits.hpp> namespace boost { namespace archive { namespace iterators { /////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8 // insert line break every N characters template< class Base, int N, - class CharType = BOOST_DEDUCED_TYPENAME boost::iterator_value<Base>::type + class CharType = typename boost::iterator_value<Base>::type > class insert_linebreaks : public iterator_adaptor< insert_linebreaks<Base, N, CharType>, Base, CharType, single_pass_traversal_tag, CharType > { private: friend class boost::iterator_core_access; typedef iterator_adaptor< insert_linebreaks<Base, N, CharType>, Base, CharType, single_pass_traversal_tag, CharType > super_t; bool equal(const insert_linebreaks<Base, N, CharType> & rhs) const { return // m_count == rhs.m_count // && base_reference() == rhs.base_reference() this->base_reference() == rhs.base_reference() ; } void increment() { if(m_count == N){ m_count = 0; return; } ++m_count; ++(this->base_reference()); diff --git a/3rdParty/Boost/src/boost/archive/iterators/istream_iterator.hpp b/3rdParty/Boost/src/boost/archive/iterators/istream_iterator.hpp index 1df612d..41aa0be 100644 --- a/3rdParty/Boost/src/boost/archive/iterators/istream_iterator.hpp +++ b/3rdParty/Boost/src/boost/archive/iterators/istream_iterator.hpp @@ -1,95 +1,107 @@ #ifndef BOOST_ARCHIVE_ITERATORS_ISTREAM_ITERATOR_HPP #define BOOST_ARCHIVE_ITERATORS_ISTREAM_ITERATOR_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 // istream_iterator.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. // note: this is a custom version of the standard istream_iterator. // This is necessary as the standard version doesn't work as expected // for wchar_t based streams on systems for which wchar_t not a true // type but rather a synonym for some integer type. #include <cstddef> // NULL #include <istream> #include <boost/iterator/iterator_facade.hpp> namespace boost { namespace archive { namespace iterators { // given a type, make an input iterator based on a pointer to that type template<class Elem = char> class istream_iterator : public boost::iterator_facade< istream_iterator<Elem>, Elem, std::input_iterator_tag, Elem > { friend class boost::iterator_core_access; typedef istream_iterator this_t ; - typedef BOOST_DEDUCED_TYPENAME boost::iterator_facade< + typedef typename boost::iterator_facade< istream_iterator<Elem>, Elem, std::input_iterator_tag, Elem > super_t; - typedef BOOST_DEDUCED_TYPENAME std::basic_istream<Elem> istream_type; + typedef typename std::basic_istream<Elem> istream_type; - //Access the value referred to - Elem dereference() const { - return m_current_value; - } - bool equal(const this_t & rhs) const { // note: only works for comparison against end of stream return m_istream == rhs.m_istream; } +/* + //Access the value referred to + Elem dereference() const { + return m_current_value; + } + void increment(){ if(NULL != m_istream){ m_current_value = static_cast<Elem>(m_istream->get()); if(! m_istream->good()){ const_cast<this_t *>(this)->m_istream = NULL; } } } +*/ + //Access the value referred to + Elem dereference() const { + return m_istream->peek(); + } + + void increment(){ + if(NULL != m_istream){ + m_istream->ignore(1); + } + } istream_type *m_istream; Elem m_current_value; public: istream_iterator(istream_type & is) : m_istream(& is) { - increment(); + //increment(); } istream_iterator() : m_istream(NULL) {} istream_iterator(const istream_iterator<Elem> & rhs) : m_istream(rhs.m_istream), m_current_value(rhs.m_current_value) {} }; } // namespace iterators } // namespace archive } // namespace boost #endif // BOOST_ARCHIVE_ITERATORS_ISTREAM_ITERATOR_HPP diff --git a/3rdParty/Boost/src/boost/archive/iterators/mb_from_wchar.hpp b/3rdParty/Boost/src/boost/archive/iterators/mb_from_wchar.hpp index d8f8a12..04e7c7e 100644 --- a/3rdParty/Boost/src/boost/archive/iterators/mb_from_wchar.hpp +++ b/3rdParty/Boost/src/boost/archive/iterators/mb_from_wchar.hpp @@ -1,88 +1,88 @@ #ifndef BOOST_ARCHIVE_ITERATORS_MB_FROM_WCHAR_HPP #define BOOST_ARCHIVE_ITERATORS_MB_FROM_WCHAR_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 // mb_from_wchar.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/assert.hpp> #include <cstddef> // size_t #include <cstdlib> // for wctomb() -#include <boost/config.hpp> // for BOOST_DEDUCED_TYPENAME +#include <boost/config.hpp> #if defined(BOOST_NO_STDC_NAMESPACE) namespace std{ using ::size_t; using ::wctomb; } // namespace std #endif #include <boost/serialization/pfto.hpp> #include <boost/iterator/iterator_adaptor.hpp> namespace boost { namespace archive { namespace iterators { /////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8 // class used by text archives to translate wide strings and to char // strings of the currently selected locale template<class Base> // the input iterator class mb_from_wchar : public boost::iterator_adaptor< mb_from_wchar<Base>, Base, wchar_t, single_pass_traversal_tag, char > { friend class boost::iterator_core_access; - typedef BOOST_DEDUCED_TYPENAME boost::iterator_adaptor< + typedef typename boost::iterator_adaptor< mb_from_wchar<Base>, Base, wchar_t, single_pass_traversal_tag, char > super_t; typedef mb_from_wchar<Base> this_t; char dereference_impl() { if(! m_full){ fill(); m_full = true; } return m_buffer[m_bnext]; } char dereference() const { return (const_cast<this_t *>(this))->dereference_impl(); } // test for iterator equality bool equal(const mb_from_wchar<Base> & rhs) const { // once the value is filled, the base_reference has been incremented // so don't permit comparison anymore. return 0 == m_bend && 0 == m_bnext && this->base_reference() == rhs.base_reference() ; } void fill(){ wchar_t value = * this->base_reference(); #if (defined(__MINGW32__) && ((__MINGW32_MAJOR_VERSION > 3) \ || ((__MINGW32_MAJOR_VERSION == 3) && (__MINGW32_MINOR_VERSION >= 8)))) diff --git a/3rdParty/Boost/src/boost/archive/iterators/ostream_iterator.hpp b/3rdParty/Boost/src/boost/archive/iterators/ostream_iterator.hpp index 7c3203f..49a9b99 100644 --- a/3rdParty/Boost/src/boost/archive/iterators/ostream_iterator.hpp +++ b/3rdParty/Boost/src/boost/archive/iterators/ostream_iterator.hpp @@ -1,40 +1,40 @@ #ifndef BOOST_ARCHIVE_ITERATORS_OSTREAM_ITERATOR_HPP #define BOOST_ARCHIVE_ITERATORS_OSTREAM_ITERATOR_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 // ostream_iterator.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. // note: this is a custom version of the standard ostream_iterator. // This is necessary as the standard version doesn't work as expected // for wchar_t based streams on systems for which wchar_t not a true // type but rather a synonym for some integer type. #include <ostream> #include <boost/iterator/iterator_facade.hpp> namespace boost { namespace archive { namespace iterators { // given a type, make an input iterator based on a pointer to that type template<class Elem> class ostream_iterator : public boost::iterator_facade< ostream_iterator<Elem>, Elem, std::output_iterator_tag, ostream_iterator<Elem> & > { diff --git a/3rdParty/Boost/src/boost/archive/iterators/remove_whitespace.hpp b/3rdParty/Boost/src/boost/archive/iterators/remove_whitespace.hpp index a01049f..4383987 100644 --- a/3rdParty/Boost/src/boost/archive/iterators/remove_whitespace.hpp +++ b/3rdParty/Boost/src/boost/archive/iterators/remove_whitespace.hpp @@ -1,176 +1,169 @@ #ifndef BOOST_ARCHIVE_ITERATORS_REMOVE_WHITESPACE_HPP #define BOOST_ARCHIVE_ITERATORS_REMOVE_WHITESPACE_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 // remove_whitespace.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/assert.hpp> -#include <boost/config.hpp> // for BOOST_DEDUCED_TYPENAME - #include <boost/serialization/pfto.hpp> #include <boost/iterator/iterator_adaptor.hpp> #include <boost/iterator/filter_iterator.hpp> #include <boost/iterator/iterator_traits.hpp> -//#include <boost/detail/workaround.hpp> -//#if ! BOOST_WORKAROUND(BOOST_MSVC, <=1300) - // here is the default standard implementation of the functor used // by the filter iterator to remove spaces. Unfortunately usage // of this implementation in combination with spirit trips a bug // VC 6.5. The only way I can find to work around it is to // implement a special non-standard version for this platform #ifndef BOOST_NO_CWCTYPE #include <cwctype> // iswspace #if defined(BOOST_NO_STDC_NAMESPACE) namespace std{ using ::iswspace; } #endif #endif #include <cctype> // isspace #if defined(BOOST_NO_STDC_NAMESPACE) namespace std{ using ::isspace; } #endif #if defined(__STD_RWCOMPILER_H__) || defined(_RWSTD_VER) // this is required for the RW STL on Linux and Tru64. #undef isspace #undef iswspace #endif -//#endif // BOOST_WORKAROUND - namespace { // anonymous template<class CharType> struct remove_whitespace_predicate; template<> struct remove_whitespace_predicate<char> { bool operator()(unsigned char t){ return ! std::isspace(t); } }; #ifndef BOOST_NO_CWCHAR template<> struct remove_whitespace_predicate<wchar_t> { bool operator()(wchar_t t){ return ! std::iswspace(t); } }; #endif } // namespace anonymous /////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8 // convert base64 file data (including whitespace and padding) to binary namespace boost { namespace archive { namespace iterators { // custom version of filter iterator which doesn't look ahead further than // necessary template<class Predicate, class Base> class filter_iterator : public boost::iterator_adaptor< filter_iterator<Predicate, Base>, Base, use_default, single_pass_traversal_tag > { friend class boost::iterator_core_access; - typedef BOOST_DEDUCED_TYPENAME boost::iterator_adaptor< + typedef typename boost::iterator_adaptor< filter_iterator<Predicate, Base>, Base, use_default, single_pass_traversal_tag > super_t; typedef filter_iterator<Predicate, Base> this_t; - typedef BOOST_DEDUCED_TYPENAME super_t::reference reference_type; + typedef typename super_t::reference reference_type; reference_type dereference_impl(){ if(! m_full){ while(! m_predicate(* this->base_reference())) ++(this->base_reference()); m_full = true; } return * this->base_reference(); } reference_type dereference() const { return const_cast<this_t *>(this)->dereference_impl(); } Predicate m_predicate; bool m_full; public: // note: this function is public only because comeau compiler complained // I don't know if this is because the compiler is wrong or what void increment(){ m_full = false; ++(this->base_reference()); } filter_iterator(Base start) : super_t(start), m_full(false) {} filter_iterator(){} }; template<class Base> class remove_whitespace : public filter_iterator< remove_whitespace_predicate< - BOOST_DEDUCED_TYPENAME boost::iterator_value<Base>::type - //BOOST_DEDUCED_TYPENAME Base::value_type + typename boost::iterator_value<Base>::type + //typename Base::value_type >, Base > { friend class boost::iterator_core_access; typedef filter_iterator< remove_whitespace_predicate< - BOOST_DEDUCED_TYPENAME boost::iterator_value<Base>::type - //BOOST_DEDUCED_TYPENAME Base::value_type + typename boost::iterator_value<Base>::type + //typename Base::value_type >, Base > super_t; public: // remove_whitespace(){} // why is this needed? // make composible buy using templated constructor template<class T> remove_whitespace(BOOST_PFTO_WRAPPER(T) start) : super_t(Base(BOOST_MAKE_PFTO_WRAPPER(static_cast< T >(start)))) {} // intel 7.1 doesn't like default copy constructor remove_whitespace(const remove_whitespace & rhs) : super_t(rhs.base_reference()) {} }; } // namespace iterators } // namespace archive } // namespace boost #endif // BOOST_ARCHIVE_ITERATORS_REMOVE_WHITESPACE_HPP diff --git a/3rdParty/Boost/src/boost/archive/iterators/transform_width.hpp b/3rdParty/Boost/src/boost/archive/iterators/transform_width.hpp index 6e2c526..4e11953 100644 --- a/3rdParty/Boost/src/boost/archive/iterators/transform_width.hpp +++ b/3rdParty/Boost/src/boost/archive/iterators/transform_width.hpp @@ -1,170 +1,177 @@ #ifndef BOOST_ARCHIVE_ITERATORS_TRANSFORM_WIDTH_HPP #define BOOST_ARCHIVE_ITERATORS_TRANSFORM_WIDTH_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 // transform_width.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. // iterator which takes elements of x bits and returns elements of y bits. // used to change streams of 8 bit characters into streams of 6 bit characters. // and vice-versa for implementing base64 encodeing/decoding. Be very careful // when using and end iterator. end is only reliable detected when the input // stream length is some common multiple of x and y. E.G. Base64 6 bit // character and 8 bit bytes. Lowest common multiple is 24 => 4 6 bit characters // or 3 8 bit characters -#include <algorithm> - -#include <boost/config.hpp> // for BOOST_DEDUCED_TYPENAME & PTFO #include <boost/serialization/pfto.hpp> #include <boost/iterator/iterator_adaptor.hpp> #include <boost/iterator/iterator_traits.hpp> +#include <algorithm> // std::min + namespace boost { namespace archive { namespace iterators { /////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8 // class used by text archives to translate char strings to wchar_t // strings of the currently selected locale template< class Base, int BitsOut, int BitsIn, - class CharType = BOOST_DEDUCED_TYPENAME boost::iterator_value<Base>::type // output character + class CharType = typename boost::iterator_value<Base>::type // output character > class transform_width : public boost::iterator_adaptor< transform_width<Base, BitsOut, BitsIn, CharType>, Base, CharType, single_pass_traversal_tag, CharType > { friend class boost::iterator_core_access; - typedef BOOST_DEDUCED_TYPENAME boost::iterator_adaptor< + typedef typename boost::iterator_adaptor< transform_width<Base, BitsOut, BitsIn, CharType>, Base, CharType, single_pass_traversal_tag, CharType > super_t; typedef transform_width<Base, BitsOut, BitsIn, CharType> this_t; - typedef BOOST_DEDUCED_TYPENAME iterator_value<Base>::type base_value_type; + typedef typename iterator_value<Base>::type base_value_type; - CharType fill(); + void fill(); - CharType dereference_impl(){ - if(! m_full){ - m_current_value = fill(); - m_full = true; - } - return m_current_value; + CharType dereference() const { + if(!m_buffer_out_full) + const_cast<this_t *>(this)->fill(); + return m_buffer_out; } - CharType dereference() const { - return const_cast<this_t *>(this)->dereference_impl(); + bool equal_impl(const this_t & rhs){ + if(BitsIn < BitsOut) // discard any left over bits + return this->base_reference() == rhs.base_reference(); + else{ + // BitsIn > BitsOut // zero fill + if(this->base_reference() == rhs.base_reference()){ + m_end_of_sequence = true; + return 0 == m_remaining_bits; + } + return false; + } } - // test for iterator equality + // standard iterator interface bool equal(const this_t & rhs) const { - return - this->base_reference() == rhs.base_reference(); - ; + return const_cast<this_t *>(this)->equal_impl(rhs); } void increment(){ - m_displacement += BitsOut; - - while(m_displacement >= BitsIn){ - m_displacement -= BitsIn; - if(0 == m_displacement) - m_bufferfull = false; - if(! m_bufferfull){ - // note: suspect that this is not invoked for borland - ++(this->base_reference()); - } - } - m_full = false; + m_buffer_out_full = false; } - CharType m_current_value; - // number of bits left in current input character buffer - unsigned int m_displacement; - base_value_type m_buffer; - // flag to current output character is ready - just used to save time - bool m_full; - // flag to indicate that m_buffer has data - bool m_bufferfull; + bool m_buffer_out_full; + CharType m_buffer_out; + + // last read element from input + base_value_type m_buffer_in; + + // number of bits to left in the input buffer. + unsigned int m_remaining_bits; + + // flag to indicate we've reached end of data. + bool m_end_of_sequence; public: // make composible buy using templated constructor template<class T> transform_width(BOOST_PFTO_WRAPPER(T) start) : super_t(Base(BOOST_MAKE_PFTO_WRAPPER(static_cast< T >(start)))), - m_displacement(0), - m_full(false), - m_bufferfull(false) + m_buffer_out_full(false), + // To disable GCC warning, but not truly necessary + //(m_buffer_in will be initialized later before being + //used because m_remaining_bits == 0) + m_buffer_in(0), + m_remaining_bits(0), + m_end_of_sequence(false) {} // intel 7.1 doesn't like default copy constructor transform_width(const transform_width & rhs) : super_t(rhs.base_reference()), - m_current_value(rhs.m_current_value), - m_displacement(rhs.m_displacement), - m_buffer(rhs.m_buffer), - m_full(rhs.m_full), - m_bufferfull(rhs.m_bufferfull) + m_buffer_out_full(rhs.m_buffer_out_full), + m_buffer_in(rhs.m_buffer_in), + m_remaining_bits(rhs.m_remaining_bits), + m_end_of_sequence(false) {} }; -template<class Base, int BitsOut, int BitsIn, class CharType> -CharType transform_width<Base, BitsOut, BitsIn, CharType>::fill(){ - CharType retval = 0; +template< + class Base, + int BitsOut, + int BitsIn, + class CharType +> +void transform_width<Base, BitsOut, BitsIn, CharType>::fill() { unsigned int missing_bits = BitsOut; - for(;;){ - unsigned int bcount; - if(! m_bufferfull){ - m_buffer = * this->base_reference(); - m_bufferfull = true; - bcount = BitsIn; + m_buffer_out = 0; + do{ + if(0 == m_remaining_bits){ + if(m_end_of_sequence){ + m_buffer_in = 0; + m_remaining_bits = missing_bits; + } + else{ + m_buffer_in = * this->base_reference()++; + m_remaining_bits = BitsIn; + } } - else - bcount = BitsIn - m_displacement; - unsigned int i = (std::min)(bcount, missing_bits); + + // append these bits to the next output + // up to the size of the output + unsigned int i = std::min(missing_bits, m_remaining_bits); // shift interesting bits to least significant position - unsigned int j = m_buffer >> (bcount - i); - // strip off uninteresting bits - // (note presumption of two's complement arithmetic) - j &= ~(-(1 << i)); + base_value_type j = m_buffer_in >> (m_remaining_bits - i); + // and mask off the un interesting higher bits + // note presumption of twos complement notation + j &= (1 << i) - 1; // append then interesting bits to the output value - retval <<= i; - retval |= j; + m_buffer_out <<= i; + m_buffer_out |= j; + + // and update counters missing_bits -= i; - if(0 == missing_bits) - break; - // note: suspect that this is not invoked for borland 5.51 - ++(this->base_reference()); - m_bufferfull = false; - } - return retval; + m_remaining_bits -= i; + }while(0 < missing_bits); + m_buffer_out_full = true; } } // namespace iterators } // namespace archive } // namespace boost #endif // BOOST_ARCHIVE_ITERATORS_TRANSFORM_WIDTH_HPP diff --git a/3rdParty/Boost/src/boost/archive/iterators/unescape.hpp b/3rdParty/Boost/src/boost/archive/iterators/unescape.hpp index 9cbd316..abf6240 100644 --- a/3rdParty/Boost/src/boost/archive/iterators/unescape.hpp +++ b/3rdParty/Boost/src/boost/archive/iterators/unescape.hpp @@ -1,90 +1,88 @@ #ifndef BOOST_ARCHIVE_ITERATORS_UNESCAPE_HPP #define BOOST_ARCHIVE_ITERATORS_UNESCAPE_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 // unescape.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/assert.hpp> -#include <boost/config.hpp> // for BOOST_DEDUCED_TYPENAME #include <boost/iterator/iterator_adaptor.hpp> -//#include <boost/iterator/iterator_traits.hpp> #include <boost/pointee.hpp> namespace boost { namespace archive { namespace iterators { /////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8 // class used by text archives to translate char strings to wchar_t // strings of the currently selected locale template<class Derived, class Base> class unescape : public boost::iterator_adaptor< unescape<Derived, Base>, Base, - BOOST_DEDUCED_TYPENAME pointee<Base>::type, + typename pointee<Base>::type, single_pass_traversal_tag, - BOOST_DEDUCED_TYPENAME pointee<Base>::type + typename pointee<Base>::type > { friend class boost::iterator_core_access; - typedef BOOST_DEDUCED_TYPENAME boost::iterator_adaptor< + typedef typename boost::iterator_adaptor< unescape<Derived, Base>, Base, - BOOST_DEDUCED_TYPENAME pointee<Base>::type, + typename pointee<Base>::type, single_pass_traversal_tag, - BOOST_DEDUCED_TYPENAME pointee<Base>::type + typename pointee<Base>::type > super_t; typedef unescape<Derived, Base> this_t; public: - typedef BOOST_DEDUCED_TYPENAME this_t::value_type value_type; - typedef BOOST_DEDUCED_TYPENAME this_t::reference reference; + typedef typename this_t::value_type value_type; + typedef typename this_t::reference reference; private: value_type dereference_impl() { if(! m_full){ m_current_value = static_cast<Derived *>(this)->drain(); m_full = true; } return m_current_value; } reference dereference() const { return const_cast<this_t *>(this)->dereference_impl(); } value_type m_current_value; bool m_full; void increment(){ ++(this->base_reference()); dereference_impl(); m_full = false; }; public: unescape(Base base) : super_t(base), m_full(false) {} }; } // namespace iterators } // namespace archive } // namespace boost diff --git a/3rdParty/Boost/src/boost/archive/iterators/wchar_from_mb.hpp b/3rdParty/Boost/src/boost/archive/iterators/wchar_from_mb.hpp index 4da8121..ab81f17 100644 --- a/3rdParty/Boost/src/boost/archive/iterators/wchar_from_mb.hpp +++ b/3rdParty/Boost/src/boost/archive/iterators/wchar_from_mb.hpp @@ -1,91 +1,91 @@ #ifndef BOOST_ARCHIVE_ITERATORS_WCHAR_FROM_MB_HPP #define BOOST_ARCHIVE_ITERATORS_WCHAR_FROM_MB_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 // wchar_from_mb.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/assert.hpp> #include <cctype> #include <cstddef> // size_t #include <cstdlib> // mblen -#include <boost/config.hpp> // for BOOST_DEDUCED_TYPENAME +#include <boost/config.hpp> #if defined(BOOST_NO_STDC_NAMESPACE) namespace std{ using ::mblen; using ::mbtowc; } // namespace std #endif #include <boost/serialization/throw_exception.hpp> #include <boost/serialization/pfto.hpp> #include <boost/iterator/iterator_adaptor.hpp> #include <boost/archive/iterators/dataflow_exception.hpp> namespace boost { namespace archive { namespace iterators { /////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8 // class used by text archives to translate char strings to wchar_t // strings of the currently selected locale template<class Base> class wchar_from_mb : public boost::iterator_adaptor< wchar_from_mb<Base>, Base, wchar_t, single_pass_traversal_tag, wchar_t > { friend class boost::iterator_core_access; - typedef BOOST_DEDUCED_TYPENAME boost::iterator_adaptor< + typedef typename boost::iterator_adaptor< wchar_from_mb<Base>, Base, wchar_t, single_pass_traversal_tag, wchar_t > super_t; typedef wchar_from_mb<Base> this_t; wchar_t drain(); wchar_t dereference_impl() { if(! m_full){ m_current_value = drain(); m_full = true; } return m_current_value; } wchar_t dereference() const { return const_cast<this_t *>(this)->dereference_impl(); } void increment(){ dereference_impl(); m_full = false; ++(this->base_reference()); }; wchar_t m_current_value; bool m_full; public: // make composible buy using templated constructor template<class T> diff --git a/3rdParty/Boost/src/boost/archive/iterators/xml_escape.hpp b/3rdParty/Boost/src/boost/archive/iterators/xml_escape.hpp index eadb96e..a5d2c51 100644 --- a/3rdParty/Boost/src/boost/archive/iterators/xml_escape.hpp +++ b/3rdParty/Boost/src/boost/archive/iterators/xml_escape.hpp @@ -1,58 +1,55 @@ #ifndef BOOST_ARCHIVE_ITERATORS_XML_ESCAPE_HPP #define BOOST_ARCHIVE_ITERATORS_XML_ESCAPE_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 // xml_escape.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/assert.hpp> - -#include <boost/config.hpp> // for BOOST_DEDUCED_TYPENAME #include <boost/serialization/pfto.hpp> - #include <boost/archive/iterators/escape.hpp> namespace boost { namespace archive { namespace iterators { /////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8 // insert escapes into xml text template<class Base> class xml_escape : public escape<xml_escape<Base>, Base> { friend class boost::iterator_core_access; typedef escape<xml_escape<Base>, Base> super_t; public: char fill(const char * & bstart, const char * & bend); wchar_t fill(const wchar_t * & bstart, const wchar_t * & bend); template<class T> xml_escape(BOOST_PFTO_WRAPPER(T) start) : super_t(Base(BOOST_MAKE_PFTO_WRAPPER(static_cast< T >(start)))) {} // intel 7.1 doesn't like default copy constructor xml_escape(const xml_escape & rhs) : super_t(rhs.base_reference()) {} }; template<class Base> char xml_escape<Base>::fill( const char * & bstart, const char * & bend diff --git a/3rdParty/Boost/src/boost/archive/iterators/xml_unescape.hpp b/3rdParty/Boost/src/boost/archive/iterators/xml_unescape.hpp index 3295adb..69438ed 100644 --- a/3rdParty/Boost/src/boost/archive/iterators/xml_unescape.hpp +++ b/3rdParty/Boost/src/boost/archive/iterators/xml_unescape.hpp @@ -1,121 +1,119 @@ #ifndef BOOST_ARCHIVE_ITERATORS_XML_UNESCAPE_HPP #define BOOST_ARCHIVE_ITERATORS_XML_UNESCAPE_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 // xml_unescape.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/assert.hpp> -#include <boost/config.hpp> // for BOOST_DEDUCED_TYPENAME - #include <boost/serialization/throw_exception.hpp> #include <boost/serialization/pfto.hpp> #include <boost/archive/iterators/unescape.hpp> #include <boost/archive/iterators/dataflow_exception.hpp> namespace boost { namespace archive { namespace iterators { /////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8 // replace &??? xml escape sequences with the corresponding characters template<class Base> class xml_unescape : public unescape<xml_unescape<Base>, Base> { friend class boost::iterator_core_access; typedef xml_unescape<Base> this_t; typedef unescape<this_t, Base> super_t; - typedef BOOST_DEDUCED_TYPENAME boost::iterator_reference<this_t> reference_type; + typedef typename boost::iterator_reference<this_t> reference_type; reference_type dereference() const { return unescape<xml_unescape<Base>, Base>::dereference(); } public: // workaround msvc 7.1 ICU crash #if defined(BOOST_MSVC) typedef int value_type; #else - typedef BOOST_DEDUCED_TYPENAME this_t::value_type value_type; + typedef typename this_t::value_type value_type; #endif void drain_residue(const char *literal); value_type drain(); template<class T> xml_unescape(BOOST_PFTO_WRAPPER(T) start) : super_t(Base(BOOST_MAKE_PFTO_WRAPPER(static_cast< T >(start)))) {} // intel 7.1 doesn't like default copy constructor xml_unescape(const xml_unescape & rhs) : super_t(rhs.base_reference()) {} }; template<class Base> void xml_unescape<Base>::drain_residue(const char * literal){ do{ if(* literal != * ++(this->base_reference())) boost::serialization::throw_exception( dataflow_exception( dataflow_exception::invalid_xml_escape_sequence ) ); } while('\0' != * ++literal); } // note key constraint on this function is that can't "look ahead" any // more than necessary into base iterator. Doing so would alter the base // iterator refenence which would make subsequent iterator comparisons // incorrect and thereby break the composiblity of iterators. template<class Base> -BOOST_DEDUCED_TYPENAME xml_unescape<Base>::value_type +typename xml_unescape<Base>::value_type //int xml_unescape<Base>::drain(){ value_type retval = * this->base_reference(); if('&' != retval){ return retval; } retval = * ++(this->base_reference()); switch(retval){ case 'l': // < drain_residue("t;"); retval = '<'; break; case 'g': // > drain_residue("t;"); retval = '>'; break; case 'a': retval = * ++(this->base_reference()); switch(retval){ case 'p': // ' drain_residue("os;"); retval = '\''; break; case 'm': // & drain_residue("p;"); retval = '&'; break; } break; case 'q': drain_residue("uot;"); retval = '"'; break; } return retval; diff --git a/3rdParty/Boost/src/boost/archive/polymorphic_iarchive.hpp b/3rdParty/Boost/src/boost/archive/polymorphic_iarchive.hpp index 2f76cf2..50488a3 100644 --- a/3rdParty/Boost/src/boost/archive/polymorphic_iarchive.hpp +++ b/3rdParty/Boost/src/boost/archive/polymorphic_iarchive.hpp @@ -1,78 +1,76 @@ #ifndef BOOST_ARCHIVE_POLYMORPHIC_IARCHIVE_HPP #define BOOST_ARCHIVE_POLYMORPHIC_IARCHIVE_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 // polymorphic_iarchive.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 <cstddef> // std::size_t #include <climits> // ULONG_MAX #include <string> #include <boost/config.hpp> #if defined(BOOST_NO_STDC_NAMESPACE) namespace std{ using ::size_t; } // namespace std #endif #include <boost/cstdint.hpp> #include <boost/serialization/pfto.hpp> #include <boost/archive/detail/iserializer.hpp> #include <boost/archive/detail/interface_iarchive.hpp> #include <boost/serialization/nvp.hpp> #include <boost/archive/detail/register_archive.hpp> #include <boost/archive/detail/decl.hpp> #include <boost/archive/detail/abi_prefix.hpp> // must be the last header namespace boost { -template<class T> -class shared_ptr; namespace serialization { class extended_type_info; } // namespace serialization namespace archive { namespace detail { class BOOST_ARCHIVE_DECL(BOOST_PP_EMPTY()) basic_iarchive; class BOOST_ARCHIVE_DECL(BOOST_PP_EMPTY()) basic_iarchive; } class polymorphic_iarchive; class polymorphic_iarchive_impl : public detail::interface_iarchive<polymorphic_iarchive> { #ifdef BOOST_NO_MEMBER_TEMPLATE_FRIENDS public: #else friend class detail::interface_iarchive<polymorphic_iarchive>; friend class load_access; #endif // primitive types the only ones permitted by polymorphic archives virtual void load(bool & t) = 0; virtual void load(char & t) = 0; virtual void load(signed char & t) = 0; virtual void load(unsigned char & t) = 0; #ifndef BOOST_NO_CWCHAR #ifndef BOOST_NO_INTRINSIC_WCHAR_T virtual void load(wchar_t & t) = 0; #endif #endif virtual void load(short & t) = 0; virtual void load(unsigned short & t) = 0; virtual void load(int & t) = 0; virtual void load(unsigned int & t) = 0; @@ -123,59 +121,52 @@ public: } protected: virtual ~polymorphic_iarchive_impl(){}; public: // utility function implemented by all legal archives virtual void set_library_version(library_version_type archive_library_version) = 0; virtual library_version_type get_library_version() const = 0; virtual unsigned int get_flags() const = 0; virtual void delete_created_pointers() = 0; virtual void reset_object_address( const void * new_address, const void * old_address ) = 0; virtual void load_binary(void * t, std::size_t size) = 0; // these are used by the serialization library implementation. virtual void load_object( void *t, const detail::basic_iserializer & bis ) = 0; virtual const detail::basic_pointer_iserializer * load_pointer( void * & t, const detail::basic_pointer_iserializer * bpis_ptr, const detail::basic_pointer_iserializer * (*finder)( const boost::serialization::extended_type_info & type ) ) = 0; }; } // namespace archive } // namespace boost #include <boost/archive/detail/abi_suffix.hpp> // pops abi_suffix.hpp pragmas -// note special treatment of shared_ptr. This type needs a special -// structure associated with every archive. We created a "mix-in" -// class to provide this functionality. Since shared_ptr holds a -// special esteem in the boost library - we included it here by default. -#include <boost/archive/shared_ptr_helper.hpp> - -namespace boost { +namespace boost { namespace archive { class polymorphic_iarchive : - public polymorphic_iarchive_impl, - public detail::shared_ptr_helper + public polymorphic_iarchive_impl { public: virtual ~polymorphic_iarchive(){}; }; } // namespace archive } // namespace boost // required by export BOOST_SERIALIZATION_REGISTER_ARCHIVE(boost::archive::polymorphic_iarchive) #endif // BOOST_ARCHIVE_POLYMORPHIC_IARCHIVE_HPP diff --git a/3rdParty/Boost/src/boost/archive/polymorphic_oarchive.hpp b/3rdParty/Boost/src/boost/archive/polymorphic_oarchive.hpp index 420029b..1eb9e0b 100644 --- a/3rdParty/Boost/src/boost/archive/polymorphic_oarchive.hpp +++ b/3rdParty/Boost/src/boost/archive/polymorphic_oarchive.hpp @@ -1,77 +1,75 @@ #ifndef BOOST_ARCHIVE_POLYMORPHIC_OARCHIVE_HPP #define BOOST_ARCHIVE_POLYMORPHIC_OARCHIVE_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 // polymorphic_oarchive.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 <cstddef> // size_t #include <climits> // ULONG_MAX #include <string> #include <boost/config.hpp> #if defined(BOOST_NO_STDC_NAMESPACE) namespace std{ using ::size_t; } // namespace std #endif #include <boost/cstdint.hpp> #include <boost/serialization/pfto.hpp> #include <boost/archive/detail/oserializer.hpp> #include <boost/archive/detail/interface_oarchive.hpp> #include <boost/serialization/nvp.hpp> #include <boost/archive/detail/register_archive.hpp> #include <boost/archive/detail/decl.hpp> #include <boost/archive/detail/abi_prefix.hpp> // must be the last header namespace boost { -template<class T> -class shared_ptr; namespace serialization { class extended_type_info; } // namespace serialization namespace archive { namespace detail { class BOOST_ARCHIVE_DECL(BOOST_PP_EMPTY()) basic_oarchive; class BOOST_ARCHIVE_DECL(BOOST_PP_EMPTY()) basic_oserializer; } class polymorphic_oarchive; class polymorphic_oarchive_impl : public detail::interface_oarchive<polymorphic_oarchive> { #ifdef BOOST_NO_MEMBER_TEMPLATE_FRIENDS public: #else friend class detail::interface_oarchive<polymorphic_oarchive>; friend class save_access; #endif // primitive types the only ones permitted by polymorphic archives virtual void save(const bool t) = 0; virtual void save(const char t) = 0; virtual void save(const signed char t) = 0; virtual void save(const unsigned char t) = 0; #ifndef BOOST_NO_CWCHAR #ifndef BOOST_NO_INTRINSIC_WCHAR_T virtual void save(const wchar_t t) = 0; #endif #endif virtual void save(const short t) = 0; virtual void save(const unsigned short t) = 0; virtual void save(const int t) = 0; virtual void save(const unsigned int t) = 0; diff --git a/3rdParty/Boost/src/boost/archive/shared_ptr_helper.hpp b/3rdParty/Boost/src/boost/archive/shared_ptr_helper.hpp deleted file mode 100644 index 39e6eb8..0000000 --- a/3rdParty/Boost/src/boost/archive/shared_ptr_helper.hpp +++ /dev/null @@ -1,219 +0,0 @@ -#ifndef BOOST_ARCHIVE_SHARED_PTR_HELPER_HPP -#define BOOST_ARCHIVE_SHARED_PTR_HELPER_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_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 <set> -#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/serialization/type_info_implementation.hpp> -#include <boost/serialization/shared_ptr_132.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 { - template<class T> class shared_ptr; - namespace serialization { - class extended_type_info; - template<class Archive, class T> - inline void load( - Archive & ar, - boost::shared_ptr< T > &t, - const unsigned int file_version - ); - } -namespace archive{ -namespace detail { - -/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8 -// a common class for holding various types of shared pointers - -class shared_ptr_helper { - struct collection_type_compare { - bool operator()( - const shared_ptr<const void> &lhs, - const shared_ptr<const void> &rhs - )const{ - return lhs.get() < rhs.get(); - } - }; - typedef std::set< - boost::shared_ptr<const void>, - collection_type_compare - > collection_type; - typedef collection_type::const_iterator iterator_type; - // 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. - collection_type * m_pointers; - - struct null_deleter { - void operator()(void const *) const {} - }; - - struct void_deleter { - const boost::serialization::extended_type_info * m_eti; - void_deleter(const boost::serialization::extended_type_info *eti) : - m_eti(eti) - {} - void operator()(void *vp) const { - m_eti->destroy(vp); - } - }; - -#ifdef BOOST_NO_MEMBER_TEMPLATE_FRIENDS -public: -#else - template<class Archive, class T> - friend inline void boost::serialization::load( - Archive & ar, - boost::shared_ptr< T > &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; -// #endif - - // returns pointer to object and an indicator whether this is a - // new entry (true) or a previous one (false) - BOOST_ARCHIVE_DECL(shared_ptr<void>) - get_od( - const void * od, - const boost::serialization::extended_type_info * true_type, - const boost::serialization::extended_type_info * this_type - ); - - BOOST_ARCHIVE_DECL(void) - append(const boost::shared_ptr<const void> &); - - template<class T> - struct non_polymorphic { - static const boost::serialization::extended_type_info * - get_object_identifier(T &){ - return & boost::serialization::singleton< - BOOST_DEDUCED_TYPENAME - boost::serialization::type_info_implementation< T >::type - >::get_const_instance(); - } - }; - template<class T> - struct polymorphic { - static const boost::serialization::extended_type_info * - get_object_identifier(T & t){ - return boost::serialization::singleton< - BOOST_DEDUCED_TYPENAME - boost::serialization::type_info_implementation< T >::type - >::get_const_instance().get_derived_extended_type_info(t); - } - }; -public: - template<class T> - void reset(shared_ptr< 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. This is effectively - // the object identifern - typedef BOOST_DEDUCED_TYPENAME mpl::eval_if< - is_polymorphic< T >, - mpl::identity<polymorphic< T > >, - mpl::identity<non_polymorphic< T > > - >::type type; - - const boost::serialization::extended_type_info * true_type - = type::get_object_identifier(*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( - archive_exception( - archive_exception::unregistered_class, - this_type->get_debug_info() - ) - ); - shared_ptr<void> r = - get_od( - static_cast<const void *>(t), - true_type, - this_type - ); - if(!r){ - s.reset(t); - const void * od = void_downcast( - *true_type, - *this_type, - static_cast<const void *>(t) - ); - shared_ptr<const void> sp(s, od); - append(sp); - } - else{ - s = shared_ptr< T >( - r, - static_cast<T *>(r.get()) - ); - } - } - -// #ifdef BOOST_SERIALIZATION_SHARED_PTR_132_HPP - BOOST_ARCHIVE_DECL(void) - append(const boost_132::shared_ptr<const void> & t); -// #endif -public: - BOOST_ARCHIVE_DECL(BOOST_PP_EMPTY()) - shared_ptr_helper(); - BOOST_ARCHIVE_DECL(BOOST_PP_EMPTY()) - ~shared_ptr_helper(); -}; - -} // namespace detail -} // namespace archive -} // namespace boost - -#include <boost/archive/detail/abi_suffix.hpp> // pops abi_suffix.hpp pragmas - -#endif // BOOST_ARCHIVE_SHARED_PTR_HELPER_HPP diff --git a/3rdParty/Boost/src/boost/archive/text_iarchive.hpp b/3rdParty/Boost/src/boost/archive/text_iarchive.hpp index 298928b..1fd0f60 100644 --- a/3rdParty/Boost/src/boost/archive/text_iarchive.hpp +++ b/3rdParty/Boost/src/boost/archive/text_iarchive.hpp @@ -1,156 +1,142 @@ #ifndef BOOST_ARCHIVE_TEXT_IARCHIVE_HPP #define BOOST_ARCHIVE_TEXT_IARCHIVE_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 // text_iarchive.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 <istream> #include <boost/config.hpp> #include <boost/archive/detail/auto_link_archive.hpp> #include <boost/archive/basic_text_iprimitive.hpp> #include <boost/archive/basic_text_iarchive.hpp> #include <boost/archive/detail/register_archive.hpp> #include <boost/serialization/item_version_type.hpp> #include <boost/archive/detail/abi_prefix.hpp> // must be the last header #ifdef BOOST_MSVC # pragma warning(push) # pragma warning(disable : 4511 4512) #endif namespace boost { namespace archive { +namespace detail { + template<class Archive> class interface_iarchive; +} // namespace detail + template<class Archive> class text_iarchive_impl : public basic_text_iprimitive<std::istream>, public basic_text_iarchive<Archive> { #ifdef BOOST_NO_MEMBER_TEMPLATE_FRIENDS public: #else - friend class detail::interface_iarchive<Archive>; - friend class basic_text_iarchive<Archive>; - friend class load_access; protected: + #if BOOST_WORKAROUND(BOOST_MSVC, < 1500) + // for some inexplicable reason insertion of "class" generates compile erro + // on msvc 7.1 + friend detail::interface_iarchive<Archive>; + friend load_access; + #else + friend class detail::interface_iarchive<Archive>; + friend class load_access; + #endif #endif template<class T> void load(T & t){ basic_text_iprimitive<std::istream>::load(t); } void load(version_type & t){ unsigned int v; load(v); t = version_type(v); } void load(boost::serialization::item_version_type & t){ unsigned int v; load(v); t = boost::serialization::item_version_type(v); } BOOST_ARCHIVE_DECL(void) load(char * t); #ifndef BOOST_NO_INTRINSIC_WCHAR_T BOOST_ARCHIVE_DECL(void) load(wchar_t * t); #endif BOOST_ARCHIVE_DECL(void) load(std::string &s); #ifndef BOOST_NO_STD_WSTRING BOOST_ARCHIVE_DECL(void) load(std::wstring &ws); #endif // note: the following should not needed - but one compiler (vc 7.1) // fails to compile one test (test_shared_ptr) without it !!! // make this protected so it can be called from a derived archive template<class T> void load_override(T & t, BOOST_PFTO int){ basic_text_iarchive<Archive>::load_override(t, 0); } BOOST_ARCHIVE_DECL(void) load_override(class_name_type & t, int); BOOST_ARCHIVE_DECL(void) init(); BOOST_ARCHIVE_DECL(BOOST_PP_EMPTY()) text_iarchive_impl(std::istream & is, unsigned int flags); // don't import inline definitions! leave this as a reminder. //BOOST_ARCHIVE_DECL(BOOST_PP_EMPTY()) ~text_iarchive_impl(){}; }; -// do not derive from the classes below. If you want to extend this functionality -// via inhertance, derived from text_iarchive_impl instead. This will -// preserve correct static polymorphism. - -// same as text_iarchive below - without the shared_ptr_helper -class naked_text_iarchive : - public text_iarchive_impl<naked_text_iarchive> -{ -public: - naked_text_iarchive(std::istream & is_, unsigned int flags = 0) : - // note: added _ to suppress useless gcc warning - text_iarchive_impl<naked_text_iarchive>(is_, flags) - {} - ~naked_text_iarchive(){} -}; - } // namespace archive } // namespace boost #ifdef BOOST_MSVC #pragma warning(pop) #endif #include <boost/archive/detail/abi_suffix.hpp> // pops abi_suffix.hpp pragmas -// note special treatment of shared_ptr. This type needs a special -// structure associated with every archive. We created a "mix-in" -// class to provide this functionality. Since shared_ptr holds a -// special esteem in the boost library - we included it here by default. -#include <boost/archive/shared_ptr_helper.hpp> - #ifdef BOOST_MSVC # pragma warning(push) # pragma warning(disable : 4511 4512) #endif namespace boost { namespace archive { class text_iarchive : - public text_iarchive_impl<text_iarchive>, - public detail::shared_ptr_helper -{ + public text_iarchive_impl<text_iarchive>{ public: text_iarchive(std::istream & is_, unsigned int flags = 0) : // note: added _ to suppress useless gcc warning text_iarchive_impl<text_iarchive>(is_, flags) {} ~text_iarchive(){} }; } // namespace archive } // namespace boost // required by export BOOST_SERIALIZATION_REGISTER_ARCHIVE(boost::archive::text_iarchive) #ifdef BOOST_MSVC #pragma warning(pop) #endif #endif // BOOST_ARCHIVE_TEXT_IARCHIVE_HPP diff --git a/3rdParty/Boost/src/boost/archive/text_oarchive.hpp b/3rdParty/Boost/src/boost/archive/text_oarchive.hpp index 2100d53..9fd63a9 100644 --- a/3rdParty/Boost/src/boost/archive/text_oarchive.hpp +++ b/3rdParty/Boost/src/boost/archive/text_oarchive.hpp @@ -1,119 +1,129 @@ #ifndef BOOST_ARCHIVE_TEXT_OARCHIVE_HPP #define BOOST_ARCHIVE_TEXT_OARCHIVE_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 // text_oarchive.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 <ostream> #include <cstddef> // std::size_t #include <boost/config.hpp> #if defined(BOOST_NO_STDC_NAMESPACE) namespace std{ using ::size_t; } // namespace std #endif #include <boost/archive/detail/auto_link_archive.hpp> #include <boost/archive/basic_text_oprimitive.hpp> #include <boost/archive/basic_text_oarchive.hpp> #include <boost/archive/detail/register_archive.hpp> #include <boost/serialization/item_version_type.hpp> #include <boost/archive/detail/abi_prefix.hpp> // must be the last header #ifdef BOOST_MSVC # pragma warning(push) # pragma warning(disable : 4511 4512) #endif namespace boost { namespace archive { +namespace detail { + template<class Archive> class interface_oarchive; +} // namespace detail + template<class Archive> class text_oarchive_impl : /* protected ? */ public basic_text_oprimitive<std::ostream>, public basic_text_oarchive<Archive> { #ifdef BOOST_NO_MEMBER_TEMPLATE_FRIENDS public: #else - friend class detail::interface_oarchive<Archive>; - friend class basic_text_oarchive<Archive>; - friend class save_access; protected: + #if BOOST_WORKAROUND(BOOST_MSVC, < 1500) + // for some inexplicable reason insertion of "class" generates compile erro + // on msvc 7.1 + friend detail::interface_oarchive<Archive>; + friend basic_text_oarchive<Archive>; + friend save_access; + #else + friend class detail::interface_oarchive<Archive>; + friend class basic_text_oarchive<Archive>; + friend class save_access; + #endif #endif template<class T> void save(const T & t){ this->newtoken(); basic_text_oprimitive<std::ostream>::save(t); } void save(const version_type & t){ save(static_cast<const unsigned int>(t)); } void save(const boost::serialization::item_version_type & t){ save(static_cast<const unsigned int>(t)); } BOOST_ARCHIVE_DECL(void) save(const char * t); #ifndef BOOST_NO_INTRINSIC_WCHAR_T BOOST_ARCHIVE_DECL(void) save(const wchar_t * t); #endif BOOST_ARCHIVE_DECL(void) save(const std::string &s); #ifndef BOOST_NO_STD_WSTRING BOOST_ARCHIVE_DECL(void) save(const std::wstring &ws); #endif BOOST_ARCHIVE_DECL(BOOST_PP_EMPTY()) text_oarchive_impl(std::ostream & os, unsigned int flags); // don't import inline definitions! leave this as a reminder. //BOOST_ARCHIVE_DECL(BOOST_PP_EMPTY()) ~text_oarchive_impl(){}; public: BOOST_ARCHIVE_DECL(void) save_binary(const void *address, std::size_t count); }; // do not derive from this class. If you want to extend this functionality // via inhertance, derived from text_oarchive_impl instead. This will // preserve correct static polymorphism. class text_oarchive : public text_oarchive_impl<text_oarchive> { public: text_oarchive(std::ostream & os_, unsigned int flags = 0) : // note: added _ to suppress useless gcc warning text_oarchive_impl<text_oarchive>(os_, flags) {} ~text_oarchive(){} }; -typedef text_oarchive naked_text_oarchive; - } // namespace archive } // namespace boost // required by export BOOST_SERIALIZATION_REGISTER_ARCHIVE(boost::archive::text_oarchive) #ifdef BOOST_MSVC #pragma warning(pop) #endif #include <boost/archive/detail/abi_suffix.hpp> // pops abi_suffix.hpp pragmas #endif // BOOST_ARCHIVE_TEXT_OARCHIVE_HPP diff --git a/3rdParty/Boost/src/boost/archive/text_wiarchive.hpp b/3rdParty/Boost/src/boost/archive/text_wiarchive.hpp index 7451f3a..5105d35 100644 --- a/3rdParty/Boost/src/boost/archive/text_wiarchive.hpp +++ b/3rdParty/Boost/src/boost/archive/text_wiarchive.hpp @@ -1,152 +1,139 @@ #ifndef BOOST_ARCHIVE_TEXT_WIARCHIVE_HPP #define BOOST_ARCHIVE_TEXT_WIARCHIVE_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 // text_wiarchive.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> #ifdef BOOST_NO_STD_WSTREAMBUF #error "wide char i/o not supported on this platform" #else #include <istream> #include <boost/archive/detail/auto_link_warchive.hpp> #include <boost/archive/basic_text_iprimitive.hpp> #include <boost/archive/basic_text_iarchive.hpp> #include <boost/archive/detail/register_archive.hpp> #include <boost/serialization/item_version_type.hpp> #include <boost/archive/detail/abi_prefix.hpp> // must be the last header #ifdef BOOST_MSVC # pragma warning(push) # pragma warning(disable : 4511 4512) #endif namespace boost { namespace archive { +namespace detail { + template<class Archive> class interface_iarchive; +} // namespace detail + template<class Archive> class text_wiarchive_impl : public basic_text_iprimitive<std::wistream>, public basic_text_iarchive<Archive> { #ifdef BOOST_NO_MEMBER_TEMPLATE_FRIENDS public: #else - friend class detail::interface_iarchive<Archive>; - friend class basic_text_iarchive<Archive>; - friend class load_access; protected: + #if BOOST_WORKAROUND(BOOST_MSVC, < 1500) + // for some inexplicable reason insertion of "class" generates compile erro + // on msvc 7.1 + friend detail::interface_iarchive<Archive>; + friend load_access; + #else + friend class detail::interface_iarchive<Archive>; + friend class load_access; + #endif #endif template<class T> void load(T & t){ basic_text_iprimitive<std::wistream>::load(t); } void load(version_type & t){ unsigned int v; load(v); t = version_type(v); } void load(boost::serialization::item_version_type & t){ unsigned int v; load(v); t = boost::serialization::item_version_type(v); } BOOST_WARCHIVE_DECL(void) load(char * t); #ifndef BOOST_NO_INTRINSIC_WCHAR_T BOOST_WARCHIVE_DECL(void) load(wchar_t * t); #endif BOOST_WARCHIVE_DECL(void) load(std::string &s); #ifndef BOOST_NO_STD_WSTRING BOOST_WARCHIVE_DECL(void) load(std::wstring &ws); #endif // note: the following should not needed - but one compiler (vc 7.1) // fails to compile one test (test_shared_ptr) without it !!! template<class T> void load_override(T & t, BOOST_PFTO int){ basic_text_iarchive<Archive>::load_override(t, 0); } BOOST_WARCHIVE_DECL(BOOST_PP_EMPTY()) text_wiarchive_impl(std::wistream & is, unsigned int flags); ~text_wiarchive_impl(){}; }; -// do not derive from the classes below. If you want to extend this functionality -// via inhertance, derived from text_iarchive_impl instead. This will -// preserve correct static polymorphism. - -// same as text_wiarchive below - without the shared_ptr_helper -class naked_text_wiarchive : - public text_wiarchive_impl<naked_text_wiarchive> -{ -public: - naked_text_wiarchive(std::wistream & is, unsigned int flags = 0) : - text_wiarchive_impl<naked_text_wiarchive>(is, flags) - {} - ~naked_text_wiarchive(){} -}; - } // namespace archive } // namespace boost #ifdef BOOST_MSVC #pragma warning(pop) #endif #include <boost/archive/detail/abi_suffix.hpp> // pops abi_suffix.hpp pragmas -// note special treatment of shared_ptr. This type needs a special -// structure associated with every archive. We created a "mix-in" -// class to provide this functionality. Since shared_ptr holds a -// special esteem in the boost library - we included it here by default. -#include <boost/archive/shared_ptr_helper.hpp> - #ifdef BOOST_MSVC # pragma warning(push) # pragma warning(disable : 4511 4512) #endif namespace boost { namespace archive { class text_wiarchive : - public text_wiarchive_impl<text_wiarchive>, - public detail::shared_ptr_helper -{ + public text_wiarchive_impl<text_wiarchive>{ public: text_wiarchive(std::wistream & is, unsigned int flags = 0) : text_wiarchive_impl<text_wiarchive>(is, flags) {} ~text_wiarchive(){} }; } // namespace archive } // namespace boost // required by export BOOST_SERIALIZATION_REGISTER_ARCHIVE(boost::archive::text_wiarchive) #ifdef BOOST_MSVC #pragma warning(pop) #endif #endif // BOOST_NO_STD_WSTREAMBUF #endif // BOOST_ARCHIVE_TEXT_WIARCHIVE_HPP diff --git a/3rdParty/Boost/src/boost/archive/text_woarchive.hpp b/3rdParty/Boost/src/boost/archive/text_woarchive.hpp index 7ed0c82..2f75204 100644 --- a/3rdParty/Boost/src/boost/archive/text_woarchive.hpp +++ b/3rdParty/Boost/src/boost/archive/text_woarchive.hpp @@ -1,145 +1,155 @@ #ifndef BOOST_ARCHIVE_TEXT_WOARCHIVE_HPP #define BOOST_ARCHIVE_TEXT_WOARCHIVE_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 // text_woarchive.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> #ifdef BOOST_NO_STD_WSTREAMBUF #error "wide char i/o not supported on this platform" #else #include <ostream> #include <cstddef> // size_t #if defined(BOOST_NO_STDC_NAMESPACE) namespace std{ using ::size_t; } // namespace std #endif #include <boost/archive/detail/auto_link_warchive.hpp> #include <boost/archive/basic_text_oprimitive.hpp> #include <boost/archive/basic_text_oarchive.hpp> #include <boost/archive/detail/register_archive.hpp> #include <boost/serialization/item_version_type.hpp> #include <boost/archive/detail/abi_prefix.hpp> // must be the last header #ifdef BOOST_MSVC # pragma warning(push) # pragma warning(disable : 4511 4512) #endif namespace boost { namespace archive { +namespace detail { + template<class Archive> class interface_oarchive; +} // namespace detail + template<class Archive> class text_woarchive_impl : public basic_text_oprimitive<std::wostream>, public basic_text_oarchive<Archive> { #ifdef BOOST_NO_MEMBER_TEMPLATE_FRIENDS public: #else - friend class detail::interface_oarchive<Archive>; - friend class basic_text_oarchive<Archive>; - friend class save_access; protected: + #if BOOST_WORKAROUND(BOOST_MSVC, < 1500) + // for some inexplicable reason insertion of "class" generates compile erro + // on msvc 7.1 + friend detail::interface_oarchive<Archive>; + friend basic_text_oarchive<Archive>; + friend save_access; + #else + friend class detail::interface_oarchive<Archive>; + friend class basic_text_oarchive<Archive>; + friend class save_access; + #endif #endif template<class T> void save(const T & t){ this->newtoken(); basic_text_oprimitive<std::wostream>::save(t); } void save(const version_type & t){ save(static_cast<const unsigned int>(t)); } void save(const boost::serialization::item_version_type & t){ save(static_cast<const unsigned int>(t)); } BOOST_WARCHIVE_DECL(void) save(const char * t); #ifndef BOOST_NO_INTRINSIC_WCHAR_T BOOST_WARCHIVE_DECL(void) save(const wchar_t * t); #endif BOOST_WARCHIVE_DECL(void) save(const std::string &s); #ifndef BOOST_NO_STD_WSTRING BOOST_WARCHIVE_DECL(void) save(const std::wstring &ws); #endif text_woarchive_impl(std::wostream & os, unsigned int flags) : basic_text_oprimitive<std::wostream>( os, 0 != (flags & no_codecvt) ), basic_text_oarchive<Archive>(flags) { if(0 == (flags & no_header)) basic_text_oarchive<Archive>::init(); } public: void save_binary(const void *address, std::size_t count){ put(static_cast<wchar_t>('\n')); this->end_preamble(); #if ! defined(__MWERKS__) this->basic_text_oprimitive<std::wostream>::save_binary( #else this->basic_text_oprimitive::save_binary( #endif address, count ); put(static_cast<wchar_t>('\n')); this->delimiter = this->none; } }; // we use the following because we can't use // typedef text_oarchive_impl<text_oarchive_impl<...> > text_oarchive; // do not derive from this class. If you want to extend this functionality // via inhertance, derived from text_oarchive_impl instead. This will // preserve correct static polymorphism. class text_woarchive : public text_woarchive_impl<text_woarchive> { public: text_woarchive(std::wostream & os, unsigned int flags = 0) : text_woarchive_impl<text_woarchive>(os, flags) {} ~text_woarchive(){} }; -typedef text_woarchive naked_text_woarchive; - } // namespace archive } // namespace boost // required by export BOOST_SERIALIZATION_REGISTER_ARCHIVE(boost::archive::text_woarchive) #ifdef BOOST_MSVC #pragma warning(pop) #endif #include <boost/archive/detail/abi_suffix.hpp> // pops abi_suffix.hpp pragmas #endif // BOOST_NO_STD_WSTREAMBUF #endif // BOOST_ARCHIVE_TEXT_WOARCHIVE_HPP diff --git a/3rdParty/Boost/src/boost/archive/wcslen.hpp b/3rdParty/Boost/src/boost/archive/wcslen.hpp index 5c14acf..2a3d635 100644 --- a/3rdParty/Boost/src/boost/archive/wcslen.hpp +++ b/3rdParty/Boost/src/boost/archive/wcslen.hpp @@ -1,40 +1,40 @@ #ifndef BOOST_ARCHIVE_WCSLEN_HPP #define BOOST_ARCHIVE_WCSLEN_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 // wcslen.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 <cstddef> // size_t #include <boost/config.hpp> #if defined(BOOST_NO_STDC_NAMESPACE) namespace std{ using ::size_t; } // namespace std #endif #ifndef BOOST_NO_CWCHAR // a couple of libraries which include wchar_t don't include // wcslen #if defined(BOOST_DINKUMWARE_STDLIB) && BOOST_DINKUMWARE_STDLIB < 306 \ || defined(__LIBCOMO__) namespace std { inline std::size_t wcslen(const wchar_t * ws) { const wchar_t * eows = ws; while(* eows != 0) ++eows; diff --git a/3rdParty/Boost/src/boost/archive/xml_archive_exception.hpp b/3rdParty/Boost/src/boost/archive/xml_archive_exception.hpp index 48e6cb3..622cafe 100644 --- a/3rdParty/Boost/src/boost/archive/xml_archive_exception.hpp +++ b/3rdParty/Boost/src/boost/archive/xml_archive_exception.hpp @@ -1,40 +1,40 @@ #ifndef BOOST_ARCHIVE_XML_ARCHIVE_EXCEPTION_HPP #define BOOST_ARCHIVE_XML_ARCHIVE_EXCEPTION_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 // xml_archive_exception.hpp: // (C) Copyright 2007 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 <exception> #include <boost/assert.hpp> #include <boost/config.hpp> #include <boost/preprocessor/empty.hpp> #include <boost/archive/detail/decl.hpp> #include <boost/archive/archive_exception.hpp> #include <boost/archive/detail/abi_prefix.hpp> // must be the last header namespace boost { namespace archive { ////////////////////////////////////////////////////////////////////// // exceptions thrown by xml archives // class BOOST_ARCHIVE_DECL(BOOST_PP_EMPTY()) xml_archive_exception : public virtual boost::archive::archive_exception { public: typedef enum { xml_archive_parsing_error, // see save_register diff --git a/3rdParty/Boost/src/boost/archive/xml_iarchive.hpp b/3rdParty/Boost/src/boost/archive/xml_iarchive.hpp index be6cfe4..ba50d7c 100644 --- a/3rdParty/Boost/src/boost/archive/xml_iarchive.hpp +++ b/3rdParty/Boost/src/boost/archive/xml_iarchive.hpp @@ -1,164 +1,152 @@ #ifndef BOOST_ARCHIVE_XML_IARCHIVE_HPP #define BOOST_ARCHIVE_XML_IARCHIVE_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 // xml_iarchive.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 <istream> //#include <boost/scoped_ptr.hpp> #include <boost/archive/detail/auto_link_archive.hpp> #include <boost/archive/basic_text_iprimitive.hpp> #include <boost/archive/basic_xml_iarchive.hpp> #include <boost/archive/detail/register_archive.hpp> #include <boost/serialization/item_version_type.hpp> #include <boost/archive/detail/abi_prefix.hpp> // must be the last header #ifdef BOOST_MSVC # pragma warning(push) # pragma warning(disable : 4511 4512) #endif namespace boost { namespace archive { +namespace detail { + template<class Archive> class interface_iarchive; +} // namespace detail + template<class CharType> class basic_xml_grammar; typedef basic_xml_grammar<char> xml_grammar; template<class Archive> class xml_iarchive_impl : public basic_text_iprimitive<std::istream>, public basic_xml_iarchive<Archive> { #ifdef BOOST_NO_MEMBER_TEMPLATE_FRIENDS public: #else - friend class detail::interface_iarchive<Archive>; - friend class basic_xml_iarchive<Archive>; - friend class load_access; protected: + #if BOOST_WORKAROUND(BOOST_MSVC, < 1500) + // for some inexplicable reason insertion of "class" generates compile erro + // on msvc 7.1 + friend detail::interface_iarchive<Archive>; + friend basic_xml_iarchive<Archive>; + friend load_access; + #else + friend class detail::interface_iarchive<Archive>; + friend class basic_xml_iarchive<Archive>; + friend class load_access; + #endif #endif // instances of micro xml parser to parse start preambles // scoped_ptr doesn't play nice with borland - so use a naked pointer // scoped_ptr<xml_grammar> gimpl; xml_grammar *gimpl; std::istream & get_is(){ return is; } template<class T> void load(T & t){ basic_text_iprimitive<std::istream>::load(t); } void load(version_type & t){ unsigned int v; load(v); t = version_type(v); } void load(boost::serialization::item_version_type & t){ unsigned int v; load(v); t = boost::serialization::item_version_type(v); } BOOST_ARCHIVE_DECL(void) load(char * t); #ifndef BOOST_NO_INTRINSIC_WCHAR_T BOOST_ARCHIVE_DECL(void) load(wchar_t * t); #endif BOOST_ARCHIVE_DECL(void) load(std::string &s); #ifndef BOOST_NO_STD_WSTRING BOOST_ARCHIVE_DECL(void) load(std::wstring &ws); #endif template<class T> void load_override(T & t, BOOST_PFTO int){ basic_xml_iarchive<Archive>::load_override(t, 0); } BOOST_ARCHIVE_DECL(void) load_override(class_name_type & t, int); BOOST_ARCHIVE_DECL(void) init(); BOOST_ARCHIVE_DECL(BOOST_PP_EMPTY()) xml_iarchive_impl(std::istream & is, unsigned int flags); BOOST_ARCHIVE_DECL(BOOST_PP_EMPTY()) ~xml_iarchive_impl(); }; -// do not derive from the classes below. If you want to extend this functionality -// via inhertance, derived from text_iarchive_impl instead. This will -// preserve correct static polymorphism. - -// same as xml_iarchive below - without the shared_ptr_helper -class naked_xml_iarchive : - public xml_iarchive_impl<naked_xml_iarchive> -{ -public: - naked_xml_iarchive(std::istream & is, unsigned int flags = 0) : - xml_iarchive_impl<naked_xml_iarchive>(is, flags) - {} - ~naked_xml_iarchive(){} -}; - } // namespace archive } // namespace boost #ifdef BOOST_MSVC #pragma warning(pop) #endif #include <boost/archive/detail/abi_suffix.hpp> // pops abi_suffix.hpp pragmas - -// note special treatment of shared_ptr. This type needs a special -// structure associated with every archive. We created a "mix-in" -// class to provide this functionality. Since shared_ptr holds a -// special esteem in the boost library - we included it here by default. -#include <boost/archive/shared_ptr_helper.hpp> - #ifdef BOOST_MSVC # pragma warning(push) # pragma warning(disable : 4511 4512) #endif namespace boost { namespace archive { class xml_iarchive : - public xml_iarchive_impl<xml_iarchive>, - public detail::shared_ptr_helper -{ + public xml_iarchive_impl<xml_iarchive>{ public: xml_iarchive(std::istream & is, unsigned int flags = 0) : xml_iarchive_impl<xml_iarchive>(is, flags) {} ~xml_iarchive(){}; }; } // namespace archive } // namespace boost // required by export BOOST_SERIALIZATION_REGISTER_ARCHIVE(boost::archive::xml_iarchive) #ifdef BOOST_MSVC #pragma warning(pop) #endif #endif // BOOST_ARCHIVE_XML_IARCHIVE_HPP diff --git a/3rdParty/Boost/src/boost/archive/xml_oarchive.hpp b/3rdParty/Boost/src/boost/archive/xml_oarchive.hpp index 167ba09..2ac4ae1 100644 --- a/3rdParty/Boost/src/boost/archive/xml_oarchive.hpp +++ b/3rdParty/Boost/src/boost/archive/xml_oarchive.hpp @@ -1,133 +1,143 @@ #ifndef BOOST_ARCHIVE_XML_OARCHIVE_HPP #define BOOST_ARCHIVE_XML_OARCHIVE_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 // xml_oarchive.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 <ostream> #include <cstddef> // size_t #include <boost/config.hpp> #if defined(BOOST_NO_STDC_NAMESPACE) namespace std{ using ::size_t; } // namespace std #endif #include <boost/archive/detail/auto_link_archive.hpp> #include <boost/archive/basic_text_oprimitive.hpp> #include <boost/archive/basic_xml_oarchive.hpp> #include <boost/archive/detail/register_archive.hpp> #include <boost/serialization/item_version_type.hpp> #include <boost/archive/detail/abi_prefix.hpp> // must be the last header #ifdef BOOST_MSVC # pragma warning(push) # pragma warning(disable : 4511 4512) #endif namespace boost { namespace archive { +namespace detail { + template<class Archive> class interface_oarchive; +} // namespace detail + template<class Archive> class xml_oarchive_impl : public basic_text_oprimitive<std::ostream>, public basic_xml_oarchive<Archive> { #ifdef BOOST_NO_MEMBER_TEMPLATE_FRIENDS public: #else - friend class detail::interface_oarchive<Archive>; - friend class basic_xml_oarchive<Archive>; - friend class save_access; protected: + #if BOOST_WORKAROUND(BOOST_MSVC, < 1500) + // for some inexplicable reason insertion of "class" generates compile erro + // on msvc 7.1 + friend detail::interface_oarchive<Archive>; + friend basic_xml_oarchive<Archive>; + friend save_access; + #else + friend class detail::interface_oarchive<Archive>; + friend class basic_xml_oarchive<Archive>; + friend class save_access; + #endif #endif //void end_preamble(){ // basic_xml_oarchive<Archive>::end_preamble(); //} template<class T> void save(const T & t){ basic_text_oprimitive<std::ostream>::save(t); } void save(const version_type & t){ save(static_cast<const unsigned int>(t)); } void save(const boost::serialization::item_version_type & t){ save(static_cast<const unsigned int>(t)); } BOOST_ARCHIVE_DECL(void) save(const char * t); #ifndef BOOST_NO_INTRINSIC_WCHAR_T BOOST_ARCHIVE_DECL(void) save(const wchar_t * t); #endif BOOST_ARCHIVE_DECL(void) save(const std::string &s); #ifndef BOOST_NO_STD_WSTRING BOOST_ARCHIVE_DECL(void) save(const std::wstring &ws); #endif BOOST_ARCHIVE_DECL(BOOST_PP_EMPTY()) xml_oarchive_impl(std::ostream & os, unsigned int flags); ~xml_oarchive_impl(){} public: void save_binary(const void *address, std::size_t count){ this->end_preamble(); #if ! defined(__MWERKS__) this->basic_text_oprimitive<std::ostream>::save_binary( #else this->basic_text_oprimitive::save_binary( #endif address, count ); this->indent_next = true; } }; // we use the following because we can't use // typedef xml_oarchive_impl<xml_oarchive_impl<...> > xml_oarchive; // do not derive from this class. If you want to extend this functionality // via inhertance, derived from xml_oarchive_impl instead. This will // preserve correct static polymorphism. class xml_oarchive : public xml_oarchive_impl<xml_oarchive> { public: xml_oarchive(std::ostream & os, unsigned int flags = 0) : xml_oarchive_impl<xml_oarchive>(os, flags) {} ~xml_oarchive(){} }; -typedef xml_oarchive naked_xml_oarchive; - } // namespace archive } // namespace boost // required by export BOOST_SERIALIZATION_REGISTER_ARCHIVE(boost::archive::xml_oarchive) #ifdef BOOST_MSVC #pragma warning(pop) #endif #include <boost/archive/detail/abi_suffix.hpp> // pops abi_suffix.hpp pragmas #endif // BOOST_ARCHIVE_XML_OARCHIVE_HPP diff --git a/3rdParty/Boost/src/boost/archive/xml_wiarchive.hpp b/3rdParty/Boost/src/boost/archive/xml_wiarchive.hpp index 59ebbb5..31aff88 100644 --- a/3rdParty/Boost/src/boost/archive/xml_wiarchive.hpp +++ b/3rdParty/Boost/src/boost/archive/xml_wiarchive.hpp @@ -1,170 +1,159 @@ #ifndef BOOST_ARCHIVE_XML_WIARCHIVE_HPP #define BOOST_ARCHIVE_XML_WIARCHIVE_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 // xml_wiarchive.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> #ifdef BOOST_NO_STD_WSTREAMBUF #error "wide char i/o not supported on this platform" #else #include <istream> //#include <boost/scoped_ptr.hpp> #include <boost/archive/detail/auto_link_warchive.hpp> #include <boost/archive/basic_text_iprimitive.hpp> #include <boost/archive/basic_xml_iarchive.hpp> #include <boost/archive/detail/register_archive.hpp> #include <boost/serialization/item_version_type.hpp> #include <boost/archive/detail/abi_prefix.hpp> // must be the last header #ifdef BOOST_MSVC # pragma warning(push) # pragma warning(disable : 4511 4512) #endif namespace boost { namespace archive { +namespace detail { + template<class Archive> class interface_iarchive; +} // namespace detail + template<class CharType> class basic_xml_grammar; typedef basic_xml_grammar<wchar_t> xml_wgrammar; template<class Archive> class xml_wiarchive_impl : public basic_text_iprimitive<std::wistream>, public basic_xml_iarchive<Archive> { #ifdef BOOST_NO_MEMBER_TEMPLATE_FRIENDS public: #else - friend class detail::interface_iarchive<Archive>; - friend class basic_xml_iarchive<Archive>; - friend class load_access; protected: + #if BOOST_WORKAROUND(BOOST_MSVC, < 1500) + // for some inexplicable reason insertion of "class" generates compile erro + // on msvc 7.1 + friend detail::interface_iarchive<Archive>; + friend basic_xml_iarchive<Archive>; + friend load_access; + #else + friend class detail::interface_iarchive<Archive>; + friend class basic_xml_iarchive<Archive>; + friend class load_access; + #endif #endif // instances of micro xml parser to parse start preambles // scoped_ptr doesn't play nice with borland - so use a naked pointer // scoped_ptr<xml_wgrammar> gimpl; xml_wgrammar *gimpl; std::wistream & get_is(){ return is; } template<class T> void load(T & t){ basic_text_iprimitive<std::wistream>::load(t); } void load(version_type & t){ unsigned int v; load(v); t = version_type(v); } void load(boost::serialization::item_version_type & t){ unsigned int v; load(v); t = boost::serialization::item_version_type(v); } BOOST_WARCHIVE_DECL(void) load(char * t); #ifndef BOOST_NO_INTRINSIC_WCHAR_T BOOST_WARCHIVE_DECL(void) load(wchar_t * t); #endif BOOST_WARCHIVE_DECL(void) load(std::string &s); #ifndef BOOST_NO_STD_WSTRING BOOST_WARCHIVE_DECL(void) load(std::wstring &ws); #endif template<class T> void load_override(T & t, BOOST_PFTO int){ basic_xml_iarchive<Archive>::load_override(t, 0); } BOOST_WARCHIVE_DECL(void) load_override(class_name_type & t, int); BOOST_WARCHIVE_DECL(void) init(); BOOST_WARCHIVE_DECL(BOOST_PP_EMPTY()) xml_wiarchive_impl(std::wistream & is, unsigned int flags) ; BOOST_WARCHIVE_DECL(BOOST_PP_EMPTY()) ~xml_wiarchive_impl(); }; -// do not derive from the classes below. If you want to extend this functionality -// via inhertance, derived from xml_wiarchive_impl instead. This will -// preserve correct static polymorphism. - -// same as xml_wiarchive below - without the shared_ptr_helper -class naked_xml_wiarchive : - public xml_wiarchive_impl<naked_xml_wiarchive> -{ -public: - naked_xml_wiarchive(std::wistream & is, unsigned int flags = 0) : - xml_wiarchive_impl<naked_xml_wiarchive>(is, flags) - {} - ~naked_xml_wiarchive(){} -}; - } // namespace archive } // namespace boost #ifdef BOOST_MSVC # pragma warning(pop) #endif #include <boost/archive/detail/abi_suffix.hpp> // pops abi_suffix.hpp pragmas -// note special treatment of shared_ptr. This type needs a special -// structure associated with every archive. We created a "mix-in" -// class to provide this functionality. Since shared_ptr holds a -// special esteem in the boost library - we included it here by default. -#include <boost/archive/shared_ptr_helper.hpp> - #ifdef BOOST_MSVC # pragma warning(push) # pragma warning(disable : 4511 4512) #endif namespace boost { namespace archive { class xml_wiarchive : - public xml_wiarchive_impl<xml_wiarchive>, - public detail::shared_ptr_helper -{ + public xml_wiarchive_impl<xml_wiarchive>{ public: xml_wiarchive(std::wistream & is, unsigned int flags = 0) : xml_wiarchive_impl<xml_wiarchive>(is, flags) {} ~xml_wiarchive(){} }; } // namespace archive } // namespace boost // required by export BOOST_SERIALIZATION_REGISTER_ARCHIVE(boost::archive::xml_wiarchive) #ifdef BOOST_MSVC #pragma warning(pop) #endif #endif // BOOST_NO_STD_WSTREAMBUF #endif // BOOST_ARCHIVE_XML_WIARCHIVE_HPP diff --git a/3rdParty/Boost/src/boost/archive/xml_woarchive.hpp b/3rdParty/Boost/src/boost/archive/xml_woarchive.hpp index 08c0fdc..7fcaeb9 100644 --- a/3rdParty/Boost/src/boost/archive/xml_woarchive.hpp +++ b/3rdParty/Boost/src/boost/archive/xml_woarchive.hpp @@ -1,140 +1,151 @@ #ifndef BOOST_ARCHIVE_XML_WOARCHIVE_HPP #define BOOST_ARCHIVE_XML_WOARCHIVE_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 // xml_woarchive.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> #ifdef BOOST_NO_STD_WSTREAMBUF #error "wide char i/o not supported on this platform" #else #include <cstddef> // size_t #if defined(BOOST_NO_STDC_NAMESPACE) namespace std{ using ::size_t; } // namespace std #endif #include <ostream> #include <boost/archive/detail/auto_link_warchive.hpp> #include <boost/archive/basic_text_oprimitive.hpp> #include <boost/archive/basic_xml_oarchive.hpp> #include <boost/archive/detail/register_archive.hpp> #include <boost/serialization/item_version_type.hpp> #include <boost/archive/detail/abi_prefix.hpp> // must be the last header #ifdef BOOST_MSVC # pragma warning(push) # pragma warning(disable : 4511 4512) #endif namespace boost { namespace archive { +namespace detail { + template<class Archive> class interface_oarchive; +} // namespace detail + template<class Archive> class xml_woarchive_impl : public basic_text_oprimitive<std::wostream>, public basic_xml_oarchive<Archive> { #ifdef BOOST_NO_MEMBER_TEMPLATE_FRIENDS public: #else - friend class detail::interface_oarchive<Archive>; - friend class basic_xml_oarchive<Archive>; - friend class save_access; protected: + #if BOOST_WORKAROUND(BOOST_MSVC, < 1500) + // for some inexplicable reason insertion of "class" generates compile erro + // on msvc 7.1 + friend detail::interface_oarchive<Archive>; + friend basic_xml_oarchive<Archive>; + friend save_access; + #else + friend class detail::interface_oarchive<Archive>; + friend class basic_xml_oarchive<Archive>; + friend class save_access; + #endif #endif + //void end_preamble(){ // basic_xml_oarchive<Archive>::end_preamble(); //} template<class T> void save(const T & t){ basic_text_oprimitive<std::wostream>::save(t); } void save(const version_type & t){ save(static_cast<const unsigned int>(t)); } void save(const boost::serialization::item_version_type & t){ save(static_cast<const unsigned int>(t)); } BOOST_WARCHIVE_DECL(void) save(const char * t); #ifndef BOOST_NO_INTRINSIC_WCHAR_T BOOST_WARCHIVE_DECL(void) save(const wchar_t * t); #endif BOOST_WARCHIVE_DECL(void) save(const std::string &s); #ifndef BOOST_NO_STD_WSTRING BOOST_WARCHIVE_DECL(void) save(const std::wstring &ws); #endif BOOST_WARCHIVE_DECL(BOOST_PP_EMPTY()) xml_woarchive_impl(std::wostream & os, unsigned int flags); ~xml_woarchive_impl(){} public: void save_binary(const void *address, std::size_t count){ this->end_preamble(); #if ! defined(__MWERKS__) this->basic_text_oprimitive<std::wostream>::save_binary( #else this->basic_text_oprimitive::save_binary( #endif address, count ); this->indent_next = true; } }; // we use the following because we can't use // typedef xml_woarchive_impl<xml_woarchive_impl<...> > xml_woarchive; // do not derive from this class. If you want to extend this functionality // via inhertance, derived from xml_woarchive_impl instead. This will // preserve correct static polymorphism. class xml_woarchive : public xml_woarchive_impl<xml_woarchive> { public: xml_woarchive(std::wostream & os, unsigned int flags = 0) : xml_woarchive_impl<xml_woarchive>(os, flags) {} ~xml_woarchive(){} }; -typedef xml_woarchive naked_xml_woarchive; - } // namespace archive } // namespace boost // required by export BOOST_SERIALIZATION_REGISTER_ARCHIVE(boost::archive::xml_woarchive) #ifdef BOOST_MSVC #pragma warning(pop) #endif #include <boost/archive/detail/abi_suffix.hpp> // pops abi_suffix.hpp pragmas #endif // BOOST_NO_STD_WSTREAMBUF #endif // BOOST_ARCHIVE_XML_OARCHIVE_HPP |