bgirgis/cpp-thirdparty
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

update boost

Browse Source
This commit is contained in:
Bassem Girgis
2023-11-24 12:56:13 -06:00
parent cfc99971af
commit 19d727037a
9260 changed files with 849256 additions and 299957 deletions
Download Patch File Download Diff File Expand all files Collapse all files

32
linx64/include/boost/archive/archive_exception.hpp
View File

@@ -9,7 +9,7 @@
/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
// archive/archive_exception.hpp:
// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
// (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)
@@ -20,16 +20,16 @@
#include <boost/assert.hpp>
#include <string>
#include <boost/config.hpp>
#include <boost/config.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
#if defined(BOOST_WINDOWS)
#include <excpt.h>
#endif
#include <boost/archive/detail/abi_prefix.hpp> // must be the last header
@@ -39,7 +39,7 @@ namespace archive {
//////////////////////////////////////////////////////////////////////
// exceptions thrown by archives
//
class BOOST_SYMBOL_VISIBLE archive_exception :
class BOOST_SYMBOL_VISIBLE archive_exception :
public virtual std::exception
{
private:
@@ -52,7 +52,7 @@ protected:
public:
typedef enum {
no_exception, // initialized without code
other_exception, // any excepton not listed below
other_exception, // any exception not listed below
unregistered_class, // attempt to serialize a pointer of
// an unregistered class
invalid_signature, // first line of archive does not contain
@@ -61,9 +61,9 @@ public:
// subsequent to this one
pointer_conflict, // an attempt has been made to directly
// serialize an object which has
// already been serialized through a pointer.
// Were this permitted, the archive load would result
// in the creation of an extra copy of the obect.
// already been serialized through a pointer.
// Were this permitted, the archive load would result
// in the creation of an extra copy of the object.
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
@@ -71,9 +71,9 @@ public:
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
unregistered_cast, // base - derived relationship not registered with
// void_cast_register
unsupported_class_version, // type saved with a version # greater than the
unsupported_class_version, // type saved with a version # greater than the
// one used by the program. This indicates that the program
// needs to be rebuilt.
multiple_code_instantiation, // code for implementing serialization for some
@@ -83,13 +83,13 @@ public:
exception_code code;
BOOST_ARCHIVE_DECL archive_exception(
exception_code c,
exception_code c,
const char * e1 = NULL,
const char * e2 = NULL
) BOOST_NOEXCEPT;
BOOST_ARCHIVE_DECL archive_exception(archive_exception const &) BOOST_NOEXCEPT ;
virtual BOOST_ARCHIVE_DECL ~archive_exception() BOOST_NOEXCEPT_OR_NOTHROW ;
virtual BOOST_ARCHIVE_DECL const char * what() const BOOST_NOEXCEPT_OR_NOTHROW ;
BOOST_ARCHIVE_DECL archive_exception(archive_exception const &) BOOST_NOEXCEPT;
BOOST_ARCHIVE_DECL ~archive_exception() BOOST_NOEXCEPT_OR_NOTHROW BOOST_OVERRIDE;
BOOST_ARCHIVE_DECL const char * what() const BOOST_NOEXCEPT_OR_NOTHROW BOOST_OVERRIDE;
};
}// namespace archive

115
linx64/include/boost/archive/basic_archive.hpp
View File

@@ -9,7 +9,7 @@
/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
// basic_archive.hpp:
// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
// (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)
@@ -18,9 +18,9 @@
#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/noncopyable.hpp>
#include <boost/serialization/library_version_type.hpp>
#include <boost/archive/detail/auto_link_archive.hpp>
#include <boost/archive/detail/abi_prefix.hpp> // must be the last header
@@ -33,76 +33,43 @@ namespace archive {
#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;
return *this;
}
// used for text output
operator base_type () const {
return t;
}
// used for text input
operator base_type & (){
return t;
}
bool operator==(const library_version_type & rhs) const {
return t == rhs.t;
}
bool operator<(const library_version_type & rhs) const {
return t < rhs.t;
}
};
BOOST_ARCHIVE_DECL library_version_type
BOOST_ARCHIVE_DECL boost::serialization::library_version_type
BOOST_ARCHIVE_VERSION();
// create alias in boost::archive for older user code.
typedef boost::serialization::library_version_type library_version_type;
class version_type {
private:
typedef uint_least32_t base_type;
base_type t;
public:
// should be private - but MPI fails if it's not!!!
version_type(): t(0) {};
version_type(): t(0) {}
explicit version_type(const unsigned int & t_) : t(t_){
BOOST_ASSERT(t_ <= boost::integer_traits<base_type>::const_max);
}
version_type(const version_type & t_) :
version_type(const version_type & t_) :
t(t_.t)
{}
version_type & operator=(const version_type & rhs){
t = rhs.t;
t = rhs.t;
return *this;
}
// used for text output
operator base_type () const {
return t;
}
}
// used for text intput
operator base_type & (){
return t;
}
}
bool operator==(const version_type & rhs) const {
return t == rhs.t;
}
}
bool operator<(const version_type & rhs) const {
return t < rhs.t;
}
}
};
class class_id_type {
@@ -111,73 +78,73 @@ private:
base_type t;
public:
// should be private - but then can't use BOOST_STRONG_TYPE below
class_id_type() : t(0) {};
class_id_type() : t(0) {}
explicit class_id_type(const int t_) : t(t_){
BOOST_ASSERT(t_ <= boost::integer_traits<base_type>::const_max);
}
explicit class_id_type(const std::size_t t_) : t(t_){
// BOOST_ASSERT(t_ <= boost::integer_traits<base_type>::const_max);
}
class_id_type(const class_id_type & t_) :
class_id_type(const class_id_type & t_) :
t(t_.t)
{}
class_id_type & operator=(const class_id_type & rhs){
t = rhs.t;
t = rhs.t;
return *this;
}
// used for text output
operator base_type () const {
return t;
}
}
// used for text input
operator base_type &() {
return t;
}
}
bool operator==(const class_id_type & rhs) const {
return t == rhs.t;
}
}
bool operator<(const class_id_type & rhs) const {
return t < rhs.t;
}
}
};
#define NULL_POINTER_TAG boost::archive::class_id_type(-1)
#define BOOST_SERIALIZATION_NULL_POINTER_TAG boost::archive::class_id_type(-1)
class object_id_type {
private:
typedef uint_least32_t base_type;
base_type t;
public:
object_id_type(): t(0) {};
object_id_type(): t(0) {}
// note: presumes that size_t >= unsigned int.
// use explicit cast to silence useless warning
explicit object_id_type(const std::size_t & t_) : t(static_cast<base_type>(t_)){
// make quadriple sure that we haven't lost any real integer
// make quadruple sure that we haven't lost any real integer
// precision
BOOST_ASSERT(t_ <= boost::integer_traits<base_type>::const_max);
}
object_id_type(const object_id_type & t_) :
object_id_type(const object_id_type & t_) :
t(t_.t)
{}
object_id_type & operator=(const object_id_type & rhs){
t = rhs.t;
t = rhs.t;
return *this;
}
// used for text output
operator base_type () const {
return t;
}
}
// used for text input
operator base_type & () {
return t;
}
}
bool operator==(const object_id_type & rhs) const {
return t == rhs.t;
}
}
bool operator<(const object_id_type & rhs) const {
return t < rhs.t;
}
}
};
#if defined(_MSC_VER)
@@ -188,16 +155,16 @@ struct tracking_type {
bool t;
explicit tracking_type(const bool t_ = false)
: t(t_)
{};
{}
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;
@@ -214,8 +181,8 @@ struct tracking_type {
}
};
struct class_name_type :
private boost::noncopyable
struct class_name_type :
private boost::noncopyable
{
char *t;
operator const char * & () const {
@@ -227,9 +194,9 @@ struct class_name_type :
std::size_t size() const {
return std::strlen(t);
}
explicit class_name_type(const char *key_)
explicit class_name_type(const char *key_)
: t(const_cast<char *>(key_)){}
explicit class_name_type(char *key_)
explicit class_name_type(char *key_)
: t(key_){}
class_name_type & operator=(const class_name_type & rhs){
t = rhs.t;
@@ -249,7 +216,7 @@ BOOST_ARCHIVE_DECL const char *
BOOST_ARCHIVE_SIGNATURE();
/* NOTE : Warning : Warning : Warning : Warning : Warning
* If any of these are changed to different sized types,
* 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
@@ -279,7 +246,7 @@ BOOST_ARCHIVE_STRONG_TYPEDEF(object_id_type, object_reference_type)
// set implementation level to primitive for all types
// used internally by the serialization library
BOOST_CLASS_IMPLEMENTATION(boost::archive::library_version_type, primitive_type)
BOOST_CLASS_IMPLEMENTATION(boost::serialization::library_version_type, primitive_type)
BOOST_CLASS_IMPLEMENTATION(boost::archive::version_type, primitive_type)
BOOST_CLASS_IMPLEMENTATION(boost::archive::class_id_type, primitive_type)
BOOST_CLASS_IMPLEMENTATION(boost::archive::class_id_reference_type, primitive_type)
@@ -291,10 +258,10 @@ BOOST_CLASS_IMPLEMENTATION(boost::archive::tracking_type, primitive_type)
#include <boost/serialization/is_bitwise_serializable.hpp>
// set types used internally by the serialization library
// set types used internally by the serialization library
// to be bitwise serializable
BOOST_IS_BITWISE_SERIALIZABLE(boost::archive::library_version_type)
BOOST_IS_BITWISE_SERIALIZABLE(boost::serialization::library_version_type)
BOOST_IS_BITWISE_SERIALIZABLE(boost::archive::version_type)
BOOST_IS_BITWISE_SERIALIZABLE(boost::archive::class_id_type)
BOOST_IS_BITWISE_SERIALIZABLE(boost::archive::class_id_reference_type)

45
linx64/include/boost/archive/basic_binary_iarchive.hpp
View File

@@ -16,7 +16,7 @@
// 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 .
// (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)
@@ -30,6 +30,7 @@
#include <boost/archive/detail/common_iarchive.hpp>
#include <boost/serialization/collection_size_type.hpp>
#include <boost/serialization/string.hpp>
#include <boost/serialization/library_version_type.hpp>
#include <boost/serialization/item_version_type.hpp>
#include <boost/integer_traits.hpp>
@@ -40,7 +41,7 @@
#include <boost/archive/detail/abi_prefix.hpp> // must be the last header
namespace boost {
namespace boost {
namespace archive {
namespace detail {
@@ -50,7 +51,7 @@ namespace detail {
/////////////////////////////////////////////////////////////////////////
// class basic_binary_iarchive - read serialized objects from a input binary stream
template<class Archive>
class BOOST_SYMBOL_VISIBLE basic_binary_iarchive :
class BOOST_SYMBOL_VISIBLE basic_binary_iarchive :
public detail::common_iarchive<Archive>
{
#ifdef BOOST_NO_MEMBER_TEMPLATE_FRIENDS
@@ -66,7 +67,7 @@ protected:
#endif
#endif
// intermediate level to support override of operators
// fot templates in the absence of partial function
// 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;
@@ -84,12 +85,12 @@ protected:
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
// binary files don't include the optional information
void load_override(class_id_optional_type & /* t */){}
void load_override(tracking_type & t, int /*version*/){
library_version_type lvt = this->get_library_version();
if(boost::archive::library_version_type(6) < lvt){
boost::serialization::library_version_type lv = this->get_library_version();
if(boost::serialization::library_version_type(6) < lv){
int_least8_t x=0;
* this->This() >> x;
t = boost::archive::tracking_type(x);
@@ -101,7 +102,7 @@ protected:
}
}
void load_override(class_id_type & t){
library_version_type lvt = this->get_library_version();
boost::serialization::library_version_type lv = this->get_library_version();
/*
* library versions:
* boost 1.39 -> 5
@@ -117,10 +118,10 @@ protected:
* - v > 6 : 16bit
* - other : 32bit
* --> which is obviously incorrect, see point 1
*
*
* the fix here decodes class_id_type on 16bit for all v <= 7, which seems to be the correct behaviour ...
*/
if(boost::archive::library_version_type(7) < lvt){
if(boost::serialization::library_version_type (7) < lv){
this->detail_common_iarchive::load_override(t);
}
else{
@@ -134,24 +135,24 @@ protected:
}
void load_override(version_type & t){
library_version_type lvt = this->get_library_version();
if(boost::archive::library_version_type(7) < lvt){
boost::serialization::library_version_type lv = this->get_library_version();
if(boost::serialization::library_version_type(7) < lv){
this->detail_common_iarchive::load_override(t);
}
else
if(boost::archive::library_version_type(6) < lvt){
if(boost::serialization::library_version_type(6) < lv){
uint_least8_t x=0;
* this->This() >> x;
t = boost::archive::version_type(x);
}
else
if(boost::archive::library_version_type(5) < lvt){
if(boost::serialization::library_version_type(5) < lv){
uint_least16_t x=0;
* this->This() >> x;
t = boost::archive::version_type(x);
}
else
if(boost::archive::library_version_type(2) < lvt){
if(boost::serialization::library_version_type(2) < lv){
// upto 255 versions
unsigned char x=0;
* this->This() >> x;
@@ -165,13 +166,13 @@ protected:
}
void load_override(boost::serialization::item_version_type & t){
library_version_type lvt = this->get_library_version();
// if(boost::archive::library_version_type(7) < lvt){
if(boost::archive::library_version_type(6) < lvt){
boost::serialization::library_version_type lv = this->get_library_version();
// if(boost::serialization::library_version_type(7) < lvt){
if(boost::serialization::library_version_type(6) < lv){
this->detail_common_iarchive::load_override(t);
}
else
if(boost::archive::library_version_type(6) < lvt){
if(boost::serialization::library_version_type(6) < lv){
uint_least16_t x=0;
* this->This() >> x;
t = boost::serialization::item_version_type(x);
@@ -184,21 +185,21 @@ protected:
}
void load_override(serialization::collection_size_type & t){
if(boost::archive::library_version_type(5) < this->get_library_version()){
if(boost::serialization::library_version_type(5) < this->get_library_version()){
this->detail_common_iarchive::load_override(t);
}
else{
unsigned int x=0;
* this->This() >> x;
t = serialization::collection_size_type(x);
}
}
}
BOOST_ARCHIVE_OR_WARCHIVE_DECL void
load_override(class_name_type & t);
BOOST_ARCHIVE_OR_WARCHIVE_DECL void
init();
basic_binary_iarchive(unsigned int flags) :
detail::common_iarchive<Archive>(flags)
{}

41
linx64/include/boost/archive/basic_binary_iprimitive.hpp
View File

@@ -20,7 +20,7 @@
// 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 .
// (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)
@@ -37,8 +37,8 @@
#include <boost/config.hpp>
#if defined(BOOST_NO_STDC_NAMESPACE)
namespace std{
using ::memcpy;
namespace std{
using ::memcpy;
using ::size_t;
} // namespace std
#endif
@@ -48,7 +48,6 @@ namespace std{
#include <boost/integer.hpp>
#include <boost/integer_traits.hpp>
//#include <boost/mpl/placeholders.hpp>
#include <boost/serialization/is_bitwise_serializable.hpp>
#include <boost/serialization/array_wrapper.hpp>
@@ -58,7 +57,7 @@ namespace std{
#include <boost/archive/detail/auto_link_archive.hpp>
#include <boost/archive/detail/abi_prefix.hpp> // must be the last header
namespace boost {
namespace boost {
namespace archive {
/////////////////////////////////////////////////////////////////////////////
@@ -98,8 +97,8 @@ public:
/////////////////////////////////////////////////////////
// fundamental types that need special treatment
// trap usage of invalid uninitialized boolean
// trap usage of invalid uninitialized boolean
void load(bool & t){
load_binary(& t, sizeof(t));
int i = t;
@@ -119,29 +118,29 @@ public:
BOOST_ARCHIVE_OR_WARCHIVE_DECL void
init();
BOOST_ARCHIVE_OR_WARCHIVE_DECL
BOOST_ARCHIVE_OR_WARCHIVE_DECL
basic_binary_iprimitive(
std::basic_streambuf<Elem, Tr> & sb,
std::basic_streambuf<Elem, Tr> & sb,
bool no_codecvt
);
BOOST_ARCHIVE_OR_WARCHIVE_DECL
BOOST_ARCHIVE_OR_WARCHIVE_DECL
~basic_binary_iprimitive();
public:
// we provide an optimized load for all fundamental types
// typedef serialization::is_bitwise_serializable<mpl::_1>
// 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 typename boost::serialization::is_bitwise_serializable< T >::type type;
struct use_array_optimization {
template <class T>
#if defined(BOOST_NO_DEPENDENT_NESTED_DERIVATIONS)
struct apply {
typedef typename boost::serialization::is_bitwise_serializable< T >::type type;
};
#else
struct apply : public boost::serialization::is_bitwise_serializable< T > {};
struct apply : public boost::serialization::is_bitwise_serializable< T > {};
#endif
};
// the optimized load_array dispatches to load_binary
// the optimized load_array dispatches to load_binary
template <class ValueType>
void load_array(serialization::array_wrapper<ValueType>& a, unsigned int)
{
@@ -155,17 +154,17 @@ public:
template<class Archive, class Elem, class Tr>
inline void
basic_binary_iprimitive<Archive, Elem, Tr>::load_binary(
void *address,
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))
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),
static_cast<Elem *>(address),
s
);
if(scount != s)

22
linx64/include/boost/archive/basic_binary_oarchive.hpp
View File

@@ -9,7 +9,7 @@
/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
// basic_binary_oarchive.hpp
// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
// (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)
@@ -58,7 +58,7 @@ namespace detail {
// 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 BOOST_SYMBOL_VISIBLE basic_binary_oarchive :
class BOOST_SYMBOL_VISIBLE basic_binary_oarchive :
public detail::common_oarchive<Archive>
{
#ifdef BOOST_NO_MEMBER_TEMPLATE_FRIENDS
@@ -90,18 +90,18 @@ protected:
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
// binary files don't include the optional information
void save_override(const class_id_optional_type & /* t */){}
// enable this if we decide to support generation of previous versions
#if 0
void save_override(const boost::archive::version_type & t){
library_version_type lvt = this->get_library_version();
if(boost::archive::library_version_type(7) < lvt){
if(boost::serialization::library_version_type(7) < lvt){
this->detail_common_oarchive::save_override(t);
}
else
if(boost::archive::library_version_type(6) < lvt){
if(boost::serialization::library_version_type(6) < lvt){
const boost::uint_least16_t x = t;
* this->This() << x;
}
@@ -112,11 +112,11 @@ protected:
}
void save_override(const boost::serialization::item_version_type & t){
library_version_type lvt = this->get_library_version();
if(boost::archive::library_version_type(7) < lvt){
if(boost::serialization::library_version_type(7) < lvt){
this->detail_common_oarchive::save_override(t);
}
else
if(boost::archive::library_version_type(6) < lvt){
if(boost::serialization::library_version_type(6) < lvt){
const boost::uint_least16_t x = t;
* this->This() << x;
}
@@ -128,11 +128,11 @@ protected:
void save_override(class_id_type & t){
library_version_type lvt = this->get_library_version();
if(boost::archive::library_version_type(7) < lvt){
if(boost::serialization::library_version_type(7) < lvt){
this->detail_common_oarchive::save_override(t);
}
else
if(boost::archive::library_version_type(6) < lvt){
if(boost::serialization::library_version_type(6) < lvt){
const boost::int_least16_t x = t;
* this->This() << x;
}
@@ -155,11 +155,11 @@ protected:
#if 0
void save_override(const serialization::collection_size_type & t){
if (get_library_version() < boost::archive::library_version_type(6)){
if (get_library_version() < boost::serialization::library_version_type(6)){
unsigned int x=0;
* this->This() >> x;
t = serialization::collection_size_type(x);
}
}
else{
* this->This() >> t;
}

43
linx64/include/boost/archive/basic_binary_oprimitive.hpp
View File

@@ -9,7 +9,7 @@
/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
// basic_binary_oprimitive.hpp
// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
// (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)
@@ -32,8 +32,8 @@
#include <boost/config.hpp>
#if defined(BOOST_NO_STDC_NAMESPACE)
namespace std{
using ::size_t;
namespace std{
using ::size_t;
} // namespace std
#endif
@@ -43,7 +43,6 @@ namespace std{
#include <boost/scoped_ptr.hpp>
#include <boost/serialization/throw_exception.hpp>
//#include <boost/mpl/placeholders.hpp>
#include <boost/serialization/is_bitwise_serializable.hpp>
#include <boost/serialization/array_wrapper.hpp>
@@ -93,7 +92,7 @@ public:
/////////////////////////////////////////////////////////
// fundamental types that need special treatment
// trap usage of invalid uninitialized boolean which would
// otherwise crash on load.
void save(const bool t){
@@ -113,32 +112,32 @@ public:
BOOST_ARCHIVE_OR_WARCHIVE_DECL void
init();
BOOST_ARCHIVE_OR_WARCHIVE_DECL
BOOST_ARCHIVE_OR_WARCHIVE_DECL
basic_binary_oprimitive(
std::basic_streambuf<Elem, Tr> & sb,
std::basic_streambuf<Elem, Tr> & sb,
bool no_codecvt
);
BOOST_ARCHIVE_OR_WARCHIVE_DECL
BOOST_ARCHIVE_OR_WARCHIVE_DECL
~basic_binary_oprimitive();
public:
// we provide an optimized save for all fundamental types
// typedef serialization::is_bitwise_serializable<mpl::_1>
// 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 typename boost::serialization::is_bitwise_serializable< T >::type type;
template <class T>
#if defined(BOOST_NO_DEPENDENT_NESTED_DERIVATIONS)
struct apply {
typedef typename boost::serialization::is_bitwise_serializable< T >::type type;
};
#else
struct apply : public boost::serialization::is_bitwise_serializable< T > {};
struct apply : public boost::serialization::is_bitwise_serializable< T > {};
#endif
};
// the optimized save_array dispatches to save_binary
// the optimized save_array dispatches to save_binary
template <class ValueType>
void save_array(boost::serialization::array_wrapper<ValueType> const& a, unsigned int)
{
@@ -149,9 +148,9 @@ public:
};
template<class Archive, class Elem, class Tr>
inline void
inline void
basic_binary_oprimitive<Archive, Elem, Tr>::save_binary(
const void *address,
const void *address,
std::size_t count
){
// BOOST_ASSERT(count <= std::size_t(boost::integer_traits<std::streamsize>::const_max));
@@ -166,7 +165,7 @@ basic_binary_oprimitive<Archive, Elem, Tr>::save_binary(
// figure number of elements to output - round up
count = ( count + sizeof(Elem) - 1) / sizeof(Elem);
std::streamsize scount = m_sb.sputn(
static_cast<const Elem *>(address),
static_cast<const Elem *>(address),
static_cast<std::streamsize>(count)
);
if(count != static_cast<std::size_t>(scount))
@@ -174,14 +173,14 @@ basic_binary_oprimitive<Archive, Elem, Tr>::save_binary(
archive_exception(archive_exception::output_stream_error)
);
//os.write(
// static_cast<const typename OStream::char_type *>(address),
// static_cast<const typename OStream::char_type *>(address),
// count
//);
//BOOST_ASSERT(os.good());
}
} //namespace boost
} //namespace archive
} //namespace boost
} //namespace archive
#include <boost/archive/detail/abi_suffix.hpp> // pop pragmas

16
linx64/include/boost/archive/basic_text_iarchive.hpp
View File

@@ -9,7 +9,7 @@
/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
// basic_text_iarchive.hpp
// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
// (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)
@@ -46,7 +46,7 @@ namespace detail {
/////////////////////////////////////////////////////////////////////////
// class basic_text_iarchive - read serialized objects from a input text stream
template<class Archive>
class BOOST_SYMBOL_VISIBLE basic_text_iarchive :
class BOOST_SYMBOL_VISIBLE basic_text_iarchive :
public detail::common_iarchive<Archive>
{
#ifdef BOOST_NO_MEMBER_TEMPLATE_FRIENDS
@@ -54,7 +54,7 @@ public:
#else
protected:
#if BOOST_WORKAROUND(BOOST_MSVC, < 1500)
// for some inexplicable reason insertion of "class" generates compile erro
// for some inexplicable reason insertion of "class" generates compile error
// on msvc 7.1
friend detail::interface_iarchive<Archive>;
#else
@@ -62,26 +62,26 @@ protected:
#endif
#endif
// intermediate level to support override of operators
// fot templates in the absence of partial function
// 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){
this->detail_common_iarchive::load_override(t);
}
// text file don't include the optional information
// text file don't include the optional information
void load_override(class_id_optional_type & /*t*/){}
BOOST_ARCHIVE_OR_WARCHIVE_DECL void
load_override(class_name_type & t);
BOOST_ARCHIVE_OR_WARCHIVE_DECL void
init(void);
init();
basic_text_iarchive(unsigned int flags) :
basic_text_iarchive(unsigned int flags) :
detail::common_iarchive<Archive>(flags)
{}
~basic_text_iarchive(){}
~basic_text_iarchive() BOOST_OVERRIDE {}
};
} // namespace archive

10
linx64/include/boost/archive/basic_text_iprimitive.hpp
View File

@@ -9,7 +9,7 @@
/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
// basic_text_iprimitive.hpp
// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
// (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)
@@ -29,8 +29,8 @@
#include <boost/config.hpp>
#if defined(BOOST_NO_STDC_NAMESPACE)
namespace std{
using ::size_t;
namespace std{
using ::size_t;
#if ! defined(BOOST_DINKUMWARE_STDLIB) && ! defined(__SGI_STL_PORT)
using ::locale;
#endif
@@ -121,9 +121,9 @@ protected:
t = i;
}
#endif
BOOST_ARCHIVE_OR_WARCHIVE_DECL
BOOST_ARCHIVE_OR_WARCHIVE_DECL
basic_text_iprimitive(IStream &is, bool no_codecvt);
BOOST_ARCHIVE_OR_WARCHIVE_DECL
BOOST_ARCHIVE_OR_WARCHIVE_DECL
~basic_text_iprimitive();
public:
BOOST_ARCHIVE_OR_WARCHIVE_DECL void

10
linx64/include/boost/archive/basic_text_oarchive.hpp
View File

@@ -9,7 +9,7 @@
/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
// basic_text_oarchive.hpp
// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
// (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)
@@ -44,9 +44,9 @@ namespace detail {
} // namespace detail
/////////////////////////////////////////////////////////////////////////
// class basic_text_oarchive
// class basic_text_oarchive
template<class Archive>
class BOOST_SYMBOL_VISIBLE basic_text_oarchive :
class BOOST_SYMBOL_VISIBLE basic_text_oarchive :
public detail::common_oarchive<Archive>
{
#ifdef BOOST_NO_MEMBER_TEMPLATE_FRIENDS
@@ -89,7 +89,7 @@ protected:
this->detail_common_oarchive::save_override(t);
}
// text file don't include the optional information
// text file don't include the optional information
void save_override(const class_id_optional_type & /* t */){}
void save_override(const class_name_type & t){
@@ -104,7 +104,7 @@ protected:
detail::common_oarchive<Archive>(flags),
delimiter(none)
{}
~basic_text_oarchive(){}
~basic_text_oarchive() BOOST_OVERRIDE {}
};
} // namespace archive

21
linx64/include/boost/archive/basic_text_oprimitive.hpp
View File

@@ -9,7 +9,7 @@
/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
// basic_text_oprimitive.hpp
// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
// (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)
@@ -38,7 +38,7 @@
#endif
#if defined(BOOST_NO_STDC_NAMESPACE)
namespace std{
namespace std{
using ::size_t;
#if ! defined(BOOST_DINKUMWARE_STDLIB) && ! defined(__SGI_STL_PORT)
using ::locale;
@@ -142,22 +142,23 @@ protected:
template<class T>
struct is_float {
typedef typename mpl::bool_<
boost::is_floating_point<T>::value
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)
&& 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())
if(os.fail()){
boost::serialization::throw_exception(
archive_exception(archive_exception::output_stream_error)
);
}
// 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:
@@ -181,7 +182,7 @@ protected:
BOOST_ARCHIVE_OR_WARCHIVE_DECL
basic_text_oprimitive(OStream & os, bool no_codecvt);
BOOST_ARCHIVE_OR_WARCHIVE_DECL
BOOST_ARCHIVE_OR_WARCHIVE_DECL
~basic_text_oprimitive();
public:
// unformatted append of one character
@@ -197,12 +198,12 @@ public:
while('\0' != *s)
os.put(*s++);
}
BOOST_ARCHIVE_OR_WARCHIVE_DECL void
BOOST_ARCHIVE_OR_WARCHIVE_DECL void
save_binary(const void *address, std::size_t count);
};
} //namespace boost
} //namespace archive
} //namespace boost
} //namespace archive
#include <boost/archive/detail/abi_suffix.hpp> // pops abi_suffix.hpp pragmas

20
linx64/include/boost/archive/basic_xml_archive.hpp
View File

@@ -9,7 +9,7 @@
/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
// basic_xml_archive.hpp:
// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
// (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)
@@ -21,40 +21,40 @@
#include <boost/archive/detail/auto_link_archive.hpp>
#include <boost/archive/detail/abi_prefix.hpp> // must be the last header
namespace boost {
namespace boost {
namespace archive {
// constant strings used in xml i/o
extern
extern
BOOST_ARCHIVE_DECL const char *
BOOST_ARCHIVE_XML_OBJECT_ID();
extern
extern
BOOST_ARCHIVE_DECL const char *
BOOST_ARCHIVE_XML_OBJECT_REFERENCE();
extern
extern
BOOST_ARCHIVE_DECL const char *
BOOST_ARCHIVE_XML_CLASS_ID();
extern
extern
BOOST_ARCHIVE_DECL const char *
BOOST_ARCHIVE_XML_CLASS_ID_REFERENCE();
extern
extern
BOOST_ARCHIVE_DECL const char *
BOOST_ARCHIVE_XML_CLASS_NAME();
extern
extern
BOOST_ARCHIVE_DECL const char *
BOOST_ARCHIVE_XML_TRACKING();
extern
extern
BOOST_ARCHIVE_DECL const char *
BOOST_ARCHIVE_XML_VERSION();
extern
extern
BOOST_ARCHIVE_DECL const char *
BOOST_ARCHIVE_XML_SIGNATURE();

2
linx64/include/boost/archive/basic_xml_iarchive.hpp
View File

@@ -104,7 +104,7 @@ protected:
BOOST_ARCHIVE_OR_WARCHIVE_DECL
basic_xml_iarchive(unsigned int flags);
BOOST_ARCHIVE_OR_WARCHIVE_DECL
~basic_xml_iarchive();
~basic_xml_iarchive() BOOST_OVERRIDE;
};
} // namespace archive

2
linx64/include/boost/archive/basic_xml_oarchive.hpp
View File

@@ -123,7 +123,7 @@ protected:
BOOST_ARCHIVE_OR_WARCHIVE_DECL
basic_xml_oarchive(unsigned int flags);
BOOST_ARCHIVE_OR_WARCHIVE_DECL
~basic_xml_oarchive();
~basic_xml_oarchive() BOOST_OVERRIDE;
};
} // namespace archive

14
linx64/include/boost/archive/binary_iarchive.hpp
View File

@@ -9,7 +9,7 @@
/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
// binary_iarchive.hpp
// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
// (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)
@@ -33,8 +33,8 @@ namespace archive {
// preserve correct static polymorphism.
class BOOST_SYMBOL_VISIBLE binary_iarchive :
public binary_iarchive_impl<
boost::archive::binary_iarchive,
std::istream::char_type,
boost::archive::binary_iarchive,
std::istream::char_type,
std::istream::traits_type
>{
public:
@@ -42,12 +42,16 @@ public:
binary_iarchive_impl<
binary_iarchive, std::istream::char_type, std::istream::traits_type
>(is, flags)
{}
{
init(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)
{}
{
init(flags);
}
};
} // namespace archive

22
linx64/include/boost/archive/binary_iarchive_impl.hpp
View File

@@ -9,7 +9,7 @@
/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
// binary_iarchive_impl.hpp
// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
// (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)
@@ -25,7 +25,7 @@
# pragma warning(disable : 4511 4512)
#endif
namespace boost {
namespace boost {
namespace archive {
namespace detail {
@@ -33,7 +33,7 @@ namespace detail {
} // namespace detail
template<class Archive, class Elem, class Tr>
class BOOST_SYMBOL_VISIBLE binary_iarchive_impl :
class BOOST_SYMBOL_VISIBLE binary_iarchive_impl :
public basic_binary_iprimitive<Archive, Elem, Tr>,
public basic_binary_iarchive<Archive>
{
@@ -70,29 +70,25 @@ protected:
#endif
}
binary_iarchive_impl(
std::basic_streambuf<Elem, Tr> & bsb,
std::basic_streambuf<Elem, Tr> & bsb,
unsigned int flags
) :
basic_binary_iprimitive<Archive, Elem, Tr>(
bsb,
bsb,
0 != (flags & no_codecvt)
),
basic_binary_iarchive<Archive>(flags)
{
init(flags);
}
{}
binary_iarchive_impl(
std::basic_istream<Elem, Tr> & is,
std::basic_istream<Elem, Tr> & is,
unsigned int flags
) :
basic_binary_iprimitive<Archive, Elem, Tr>(
* is.rdbuf(),
* is.rdbuf(),
0 != (flags & no_codecvt)
),
basic_binary_iarchive<Archive>(flags)
{
init(flags);
}
{}
};
} // namespace archive

14
linx64/include/boost/archive/binary_oarchive.hpp
View File

@@ -9,7 +9,7 @@
/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
// binary_oarchive.hpp
// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
// (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)
@@ -26,13 +26,13 @@
# pragma warning(disable : 4511 4512)
#endif
namespace boost {
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 BOOST_SYMBOL_VISIBLE binary_oarchive :
class BOOST_SYMBOL_VISIBLE binary_oarchive :
public binary_oarchive_impl<
binary_oarchive, std::ostream::char_type, std::ostream::traits_type
>
@@ -42,12 +42,16 @@ public:
binary_oarchive_impl<
binary_oarchive, std::ostream::char_type, std::ostream::traits_type
>(os, flags)
{}
{
init(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)
{}
{
init(flags);
}
};
} // namespace archive

22
linx64/include/boost/archive/binary_oarchive_impl.hpp
View File

@@ -9,7 +9,7 @@
/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
// binary_oarchive_impl.hpp
// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
// (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)
@@ -26,7 +26,7 @@
# pragma warning(disable : 4511 4512)
#endif
namespace boost {
namespace boost {
namespace archive {
namespace detail {
@@ -34,7 +34,7 @@ namespace detail {
} // namespace detail
template<class Archive, class Elem, class Tr>
class BOOST_SYMBOL_VISIBLE binary_oarchive_impl :
class BOOST_SYMBOL_VISIBLE binary_oarchive_impl :
public basic_binary_oprimitive<Archive, Elem, Tr>,
public basic_binary_oarchive<Archive>
{
@@ -71,29 +71,25 @@ protected:
#endif
}
binary_oarchive_impl(
std::basic_streambuf<Elem, Tr> & bsb,
std::basic_streambuf<Elem, Tr> & bsb,
unsigned int flags
) :
basic_binary_oprimitive<Archive, Elem, Tr>(
bsb,
bsb,
0 != (flags & no_codecvt)
),
basic_binary_oarchive<Archive>(flags)
{
init(flags);
}
{}
binary_oarchive_impl(
std::basic_ostream<Elem, Tr> & os,
std::basic_ostream<Elem, Tr> & os,
unsigned int flags
) :
basic_binary_oprimitive<Archive, Elem, Tr>(
* os.rdbuf(),
* os.rdbuf(),
0 != (flags & no_codecvt)
),
basic_binary_oarchive<Archive>(flags)
{
init(flags);
}
{}
};
} // namespace archive

6
linx64/include/boost/archive/binary_wiarchive.hpp
View File

@@ -9,7 +9,7 @@
/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
// binary_wiarchive.hpp
// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
// (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)
@@ -25,10 +25,10 @@
#include <boost/archive/binary_iarchive_impl.hpp>
#include <boost/archive/detail/register_archive.hpp>
namespace boost {
namespace boost {
namespace archive {
class binary_wiarchive :
class binary_wiarchive :
public binary_iarchive_impl<
binary_wiarchive, std::wistream::char_type, std::wistream::traits_type
>

6
linx64/include/boost/archive/binary_woarchive.hpp
View File

@@ -9,7 +9,7 @@
/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
// binary_woarchive.hpp
// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
// (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)
@@ -25,13 +25,13 @@
#include <boost/archive/binary_oarchive_impl.hpp>
#include <boost/archive/detail/register_archive.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_oarchive_impl instead. This will
// preserve correct static polymorphism.
class binary_woarchive :
class binary_woarchive :
public binary_oarchive_impl<
binary_woarchive, std::wostream::char_type, std::wostream::traits_type
>

36
linx64/include/boost/archive/codecvt_null.hpp
View File

@@ -24,7 +24,7 @@
#include <boost/config.hpp>
#include <boost/serialization/force_include.hpp>
#include <boost/archive/detail/auto_link_archive.hpp>
#include <boost/archive/detail/abi_prefix.hpp> // must be the last header
//#include <boost/archive/detail/abi_prefix.hpp> // must be the last header
#if defined(BOOST_NO_STDC_NAMESPACE)
namespace std {
@@ -52,21 +52,21 @@ class codecvt_null;
template<>
class codecvt_null<char> : public std::codecvt<char, char, std::mbstate_t>
{
virtual bool do_always_noconv() const throw() {
bool do_always_noconv() const throw() BOOST_OVERRIDE {
return true;
}
public:
explicit codecvt_null(std::size_t no_locale_manage = 0) :
std::codecvt<char, char, std::mbstate_t>(no_locale_manage)
{}
virtual ~codecvt_null(){};
~codecvt_null() BOOST_OVERRIDE {}
};
template<>
class BOOST_WARCHIVE_DECL codecvt_null<wchar_t> :
class BOOST_SYMBOL_VISIBLE codecvt_null<wchar_t> :
public std::codecvt<wchar_t, char, std::mbstate_t>
{
virtual std::codecvt_base::result
BOOST_SYMBOL_EXPORT std::codecvt_base::result
do_out(
std::mbstate_t & state,
const wchar_t * first1,
@@ -75,8 +75,9 @@ class BOOST_WARCHIVE_DECL codecvt_null<wchar_t> :
char * first2,
char * last2,
char * & next2
) const;
virtual std::codecvt_base::result
) const BOOST_OVERRIDE;
BOOST_SYMBOL_EXPORT std::codecvt_base::result
do_in(
std::mbstate_t & state,
const char * first1,
@@ -85,18 +86,23 @@ class BOOST_WARCHIVE_DECL codecvt_null<wchar_t> :
wchar_t * first2,
wchar_t * last2,
wchar_t * & next2
) const;
virtual int do_encoding( ) const throw( ){
) const BOOST_OVERRIDE;
BOOST_SYMBOL_EXPORT int do_encoding( ) const throw( ) BOOST_OVERRIDE {
return sizeof(wchar_t) / sizeof(char);
}
virtual int do_max_length( ) const throw( ){
BOOST_SYMBOL_EXPORT bool do_always_noconv() const throw() BOOST_OVERRIDE {
return false;
}
BOOST_SYMBOL_EXPORT int do_max_length( ) const throw( ) BOOST_OVERRIDE {
return do_encoding();
}
public:
explicit codecvt_null(std::size_t no_locale_manage = 0) :
std::codecvt<wchar_t, char, std::mbstate_t>(no_locale_manage)
{}
//virtual ~codecvt_null(){};
BOOST_SYMBOL_EXPORT explicit codecvt_null(std::size_t no_locale_manage = 0);
BOOST_SYMBOL_EXPORT ~codecvt_null() BOOST_OVERRIDE ;
};
} // namespace archive
@@ -105,6 +111,6 @@ public:
#ifdef BOOST_MSVC
# pragma warning(pop)
#endif
#include <boost/archive/detail/abi_suffix.hpp> // pop pragmas
//#include <boost/archive/detail/abi_suffix.hpp> // pop pragmas
#endif //BOOST_ARCHIVE_CODECVT_NULL_HPP

2
linx64/include/boost/archive/detail/abi_prefix.hpp
View File

@@ -1,7 +1,7 @@
/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
// abi_prefix.hpp
// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
// (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)

2
linx64/include/boost/archive/detail/abi_suffix.hpp
View File

@@ -1,7 +1,7 @@
/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
// abi_suffix.hpp
// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
// (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)

6
linx64/include/boost/archive/detail/archive_serializer_map.hpp
View File

@@ -7,10 +7,10 @@
#endif
/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
// archive_serializer_map.hpp: extenstion of type_info required for
// archive_serializer_map.hpp: extenstion of type_info required for
// serialization.
// (C) Copyright 2009 Robert Ramey - http://www.rrsd.com .
// (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)
@@ -18,7 +18,7 @@
// 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.
// basic_serializer_map so we can have a one map / archive type.
#include <boost/config.hpp>
#include <boost/archive/detail/auto_link_archive.hpp>

4
linx64/include/boost/archive/detail/auto_link_archive.hpp
View File

@@ -16,12 +16,12 @@
// 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 ------------------------------//
// enable automatic library variant selection ------------------------------//
#include <boost/archive/detail/decl.hpp>

4
linx64/include/boost/archive/detail/auto_link_warchive.hpp
View File

@@ -16,12 +16,12 @@
// 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 ------------------------------//
// enable automatic library variant selection ------------------------------//
#include <boost/archive/detail/decl.hpp>

18
linx64/include/boost/archive/detail/basic_iarchive.hpp
View File

@@ -9,7 +9,7 @@
/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
// basic_iarchive.hpp:
// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
// (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)
@@ -72,27 +72,27 @@ public:
const basic_iserializer & bis
);
BOOST_ARCHIVE_DECL void load_object(
void *t,
void *t,
const basic_iserializer & bis
);
BOOST_ARCHIVE_DECL const basic_pointer_iserializer *
BOOST_ARCHIVE_DECL const basic_pointer_iserializer *
load_pointer(
void * & t,
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
BOOST_ARCHIVE_DECL void
set_library_version(library_version_type archive_library_version);
BOOST_ARCHIVE_DECL library_version_type
BOOST_ARCHIVE_DECL void
set_library_version(boost::serialization::library_version_type archive_library_version);
BOOST_ARCHIVE_DECL boost::serialization::library_version_type
get_library_version() const;
BOOST_ARCHIVE_DECL unsigned int
get_flags() const;
BOOST_ARCHIVE_DECL void
BOOST_ARCHIVE_DECL void
reset_object_address(const void * new_address, const void * old_address);
BOOST_ARCHIVE_DECL void
BOOST_ARCHIVE_DECL void
delete_created_pointers();
};

6
linx64/include/boost/archive/detail/basic_iserializer.hpp
View File

@@ -9,7 +9,7 @@
/////////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 .
// (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)
@@ -42,7 +42,7 @@ namespace detail {
class basic_iarchive;
class basic_pointer_iserializer;
class BOOST_SYMBOL_VISIBLE basic_iserializer :
class BOOST_SYMBOL_VISIBLE basic_iserializer :
public basic_serializer
{
private:
@@ -63,7 +63,7 @@ public:
return m_bpis;
}
virtual void load_object_data(
basic_iarchive & ar,
basic_iarchive & ar,
void *x,
const unsigned int file_version
) const = 0;

10
linx64/include/boost/archive/detail/basic_oarchive.hpp
View File

@@ -9,7 +9,7 @@
/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
// basic_oarchive.hpp:
// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
// (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)
@@ -69,19 +69,19 @@ public:
const basic_oserializer & bos
);
BOOST_ARCHIVE_DECL void save_object(
const void *x,
const void *x,
const basic_oserializer & bos
);
BOOST_ARCHIVE_DECL void save_pointer(
const void * t,
const void * t,
const basic_pointer_oserializer * bpos_ptr
);
void save_null_pointer(){
vsave(NULL_POINTER_TAG);
vsave(BOOST_SERIALIZATION_NULL_POINTER_TAG);
}
// real public interface starts here
BOOST_ARCHIVE_DECL void end_preamble(); // default implementation does nothing
BOOST_ARCHIVE_DECL library_version_type get_library_version() const;
BOOST_ARCHIVE_DECL boost::serialization::library_version_type get_library_version() const;
BOOST_ARCHIVE_DECL unsigned int get_flags() const;
};

2
linx64/include/boost/archive/detail/basic_oserializer.hpp
View File

@@ -9,7 +9,7 @@
/////////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 .
// (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)

6
linx64/include/boost/archive/detail/basic_pointer_iserializer.hpp
View File

@@ -7,10 +7,10 @@
#endif
/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
// basic_pointer_oserializer.hpp: extenstion of type_info required for
// basic_pointer_oserializer.hpp: extenstion of type_info required for
// serialization.
// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
// (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)
@@ -51,7 +51,7 @@ public:
virtual void * heap_allocation() const = 0;
virtual const basic_iserializer & get_basic_serializer() const = 0;
virtual void load_object_ptr(
basic_iarchive & ar,
basic_iarchive & ar,
void * x,
const unsigned int file_version
) const = 0;

6
linx64/include/boost/archive/detail/basic_pointer_oserializer.hpp
View File

@@ -7,10 +7,10 @@
#endif
/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
// basic_pointer_oserializer.hpp: extenstion of type_info required for
// basic_pointer_oserializer.hpp: extenstion of type_info required for
// serialization.
// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
// (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)
@@ -39,7 +39,7 @@ namespace detail {
class basic_oarchive;
class basic_oserializer;
class BOOST_SYMBOL_VISIBLE basic_pointer_oserializer :
class BOOST_SYMBOL_VISIBLE basic_pointer_oserializer :
public basic_serializer
{
protected:

8
linx64/include/boost/archive/detail/basic_serializer.hpp
View File

@@ -9,7 +9,7 @@
/////////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 .
// (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)
@@ -32,18 +32,18 @@ namespace boost {
namespace archive {
namespace detail {
class basic_serializer :
class basic_serializer :
private boost::noncopyable
{
const boost::serialization::extended_type_info * m_eti;
protected:
explicit basic_serializer(
const boost::serialization::extended_type_info & eti
) :
) :
m_eti(& eti)
{}
public:
inline bool
inline bool
operator<(const basic_serializer & rhs) const {
// can't compare address since there can be multiple eti records
// for the same type in different execution modules (that is, DLLS)

6
linx64/include/boost/archive/detail/basic_serializer_map.hpp
View File

@@ -9,7 +9,7 @@
/////////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 .
// (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)
@@ -24,7 +24,7 @@
#include <boost/archive/detail/abi_prefix.hpp> // must be the last header
namespace boost {
namespace boost {
namespace serialization {
class extended_type_info;
}
@@ -45,7 +45,7 @@ basic_serializer_map : public
) const ;
};
typedef std::set<
const basic_serializer *,
const basic_serializer *,
type_info_pointer_compare
> map_type;
map_type m_map;

22
linx64/include/boost/archive/detail/check.hpp
View File

@@ -4,18 +4,20 @@
// MS compatible compilers support #pragma once
#if defined(_MSC_VER)
# pragma once
#pragma inline_depth(511)
#if !defined(__clang__)
#pragma inline_depth(255)
#pragma inline_recursion(on)
#endif
#endif
#if defined(__MWERKS__)
#pragma inline_depth(511)
#pragma inline_depth(255)
#endif
/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
// check.hpp: interface for serialization system.
// (C) Copyright 2009 Robert Ramey - http://www.rrsd.com .
// (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)
@@ -49,7 +51,7 @@ namespace detail {
template<class T>
inline void check_object_level(){
typedef
typedef
typename mpl::greater_equal<
serialization::implementation_level< T >,
mpl::int_<serialization::primitive_type>
@@ -62,7 +64,7 @@ inline void check_object_level(){
template<class T>
inline void check_object_versioning(){
typedef
typedef
typename mpl::or_<
typename mpl::greater<
serialization::implementation_level< T >,
@@ -90,8 +92,8 @@ inline void check_object_tracking(){
// 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
// 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.
@@ -104,7 +106,7 @@ 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
typedef
typename mpl::or_<
typename mpl::greater<
serialization::implementation_level< T >,
@@ -126,12 +128,12 @@ inline void check_pointer_level(){
// 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
// 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
// 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);

21
linx64/include/boost/archive/detail/common_iarchive.hpp
View File

@@ -9,7 +9,7 @@
/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
// common_iarchive.hpp
// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
// (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)
@@ -42,22 +42,22 @@ class BOOST_SYMBOL_VISIBLE common_iarchive :
friend class interface_iarchive<Archive>;
friend class basic_iarchive;
private:
virtual void vload(version_type & t){
* this->This() >> t;
}
virtual void vload(object_id_type & t){
void vload(version_type & t) BOOST_OVERRIDE {
* this->This() >> t;
}
virtual void vload(class_id_type & t){
void vload(object_id_type & t) BOOST_OVERRIDE {
* this->This() >> t;
}
virtual void vload(class_id_optional_type & t){
void vload(class_id_type & t) BOOST_OVERRIDE {
* this->This() >> t;
}
virtual void vload(tracking_type & t){
void vload(class_id_optional_type & t) BOOST_OVERRIDE {
* this->This() >> t;
}
virtual void vload(class_name_type &s){
void vload(tracking_type & t) BOOST_OVERRIDE {
* this->This() >> t;
}
void vload(class_name_type &s) BOOST_OVERRIDE {
* this->This() >> s;
}
protected:
@@ -71,7 +71,7 @@ protected:
void load_start(const char * /*name*/){}
void load_end(const char * /*name*/){}
// default archive initialization
common_iarchive(unsigned int flags = 0) :
common_iarchive(unsigned int flags = 0) :
basic_iarchive(flags),
interface_iarchive<Archive>()
{}
@@ -86,4 +86,3 @@ protected:
#endif
#endif // BOOST_ARCHIVE_DETAIL_COMMON_IARCHIVE_HPP

20
linx64/include/boost/archive/detail/common_oarchive.hpp
View File

@@ -9,7 +9,7 @@
/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
// common_oarchive.hpp
// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
// (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)
@@ -40,28 +40,28 @@ class BOOST_SYMBOL_VISIBLE common_oarchive :
friend class interface_oarchive<Archive>;
friend class basic_oarchive;
private:
virtual void vsave(const version_type t){
void vsave(const version_type t) BOOST_OVERRIDE {
* this->This() << t;
}
virtual void vsave(const object_id_type t){
void vsave(const object_id_type t) BOOST_OVERRIDE {
* this->This() << t;
}
virtual void vsave(const object_reference_type t){
void vsave(const object_reference_type t) BOOST_OVERRIDE {
* this->This() << t;
}
virtual void vsave(const class_id_type t){
void vsave(const class_id_type t) BOOST_OVERRIDE {
* this->This() << t;
}
virtual void vsave(const class_id_reference_type t){
void vsave(const class_id_reference_type t) BOOST_OVERRIDE {
* this->This() << t;
}
virtual void vsave(const class_id_optional_type t){
void vsave(const class_id_optional_type t) BOOST_OVERRIDE {
* this->This() << t;
}
virtual void vsave(const class_name_type & t){
void vsave(const class_name_type & t) BOOST_OVERRIDE {
* this->This() << t;
}
virtual void vsave(const tracking_type t){
void vsave(const tracking_type t) BOOST_OVERRIDE {
* this->This() << t;
}
protected:
@@ -72,7 +72,7 @@ protected:
}
void save_start(const char * /*name*/){}
void save_end(const char * /*name*/){}
common_oarchive(unsigned int flags = 0) :
common_oarchive(unsigned int flags = 0) :
basic_oarchive(flags),
interface_oarchive<Archive>()
{}

6
linx64/include/boost/archive/detail/decl.hpp
View File

@@ -1,10 +1,10 @@
#ifndef BOOST_ARCHIVE_DETAIL_DECL_HPP
#define BOOST_ARCHIVE_DETAIL_DECL_HPP
#define BOOST_ARCHIVE_DETAIL_DECL_HPP
// MS compatible compilers support #pragma once
#if defined(_MSC_VER)
# pragma once
#endif
#endif
/////////1/////////2///////// 3/////////4/////////5/////////6/////////7/////////8
// decl.hpp
@@ -16,7 +16,7 @@
// 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

14
linx64/include/boost/archive/detail/interface_iarchive.hpp
View File

@@ -9,7 +9,7 @@
/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
// interface_iarchive.hpp
// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
// (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)
@@ -31,10 +31,10 @@ namespace detail {
class basic_pointer_iserializer;
template<class Archive>
class interface_iarchive
class interface_iarchive
{
protected:
interface_iarchive(){};
interface_iarchive() {}
public:
/////////////////////////////////////////////////////////
// archive public interface
@@ -47,11 +47,11 @@ public:
}
template<class T>
const basic_pointer_iserializer *
const basic_pointer_iserializer *
register_type(T * = NULL){
const basic_pointer_iserializer & bpis =
boost::serialization::singleton<
pointer_iserializer<Archive, T>
pointer_iserializer<Archive, T>
>::get_const_instance();
this->This()->register_basic_serializer(bpis.get_basic_serializer());
return & bpis;
@@ -62,14 +62,14 @@ public:
helper_collection & hc = this->This()->get_helper_collection();
return hc.template find_helper<Helper>(id);
}
template<class T>
Archive & operator>>(T & t){
this->This()->load_override(t);
return * this->This();
}
// the & operator
// the & operator
template<class T>
Archive & operator&(T & t){
return *(this->This()) >> t;

14
linx64/include/boost/archive/detail/interface_oarchive.hpp
View File

@@ -9,7 +9,7 @@
/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
// interface_oarchive.hpp
// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
// (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)
@@ -32,10 +32,10 @@ namespace detail {
class basic_pointer_oserializer;
template<class Archive>
class interface_oarchive
class interface_oarchive
{
protected:
interface_oarchive(){};
interface_oarchive() {}
public:
/////////////////////////////////////////////////////////
// archive public interface
@@ -48,7 +48,7 @@ public:
}
template<class T>
const basic_pointer_oserializer *
const basic_pointer_oserializer *
register_type(const T * = NULL){
const basic_pointer_oserializer & bpos =
boost::serialization::singleton<
@@ -57,7 +57,7 @@ public:
this->This()->register_basic_serializer(bpos.get_basic_serializer());
return & bpos;
}
template<class Helper>
Helper &
get_helper(void * const id = 0){
@@ -70,8 +70,8 @@ public:
this->This()->save_override(t);
return * this->This();
}
// the & operator
// the & operator
template<class T>
Archive & operator&(const T & t){
return * this ->This() << t;

102
linx64/include/boost/archive/detail/iserializer.hpp
View File

@@ -2,20 +2,22 @@
#define BOOST_ARCHIVE_DETAIL_ISERIALIZER_HPP
// MS compatible compilers support #pragma once
#if defined(_MSC_VER)
#if defined(BOOST_MSVC)
# pragma once
#pragma inline_depth(511)
#if !defined(__clang__)
#pragma inline_depth(255)
#pragma inline_recursion(on)
#endif
#endif
#if defined(__MWERKS__)
#pragma inline_depth(511)
#pragma inline_depth(255)
#endif
/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
// iserializer.hpp: interface for serialization system.
// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
// (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)
@@ -28,8 +30,8 @@
#include <boost/config.hpp>
#include <boost/detail/workaround.hpp>
#if defined(BOOST_NO_STDC_NAMESPACE)
namespace std{
using ::size_t;
namespace std{
using ::size_t;
} // namespace std
#endif
@@ -41,8 +43,8 @@ namespace std{
#include <boost/mpl/equal_to.hpp>
#include <boost/core/no_exceptions_support.hpp>
#ifndef BOOST_SERIALIZATION_DEFAULT_TYPE_INFO
#include <boost/serialization/extended_type_info_typeid.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>
@@ -60,12 +62,12 @@ namespace std{
#if !defined(BOOST_MSVC) && \
(BOOST_WORKAROUND(__IBMCPP__, < 1210) || \
defined(__SUNPRO_CC) && (__SUNPRO_CC < 0x590))
#define DONT_USE_HAS_NEW_OPERATOR 1
#define BOOST_SERIALIZATION_DONT_USE_HAS_NEW_OPERATOR 1
#else
#define DONT_USE_HAS_NEW_OPERATOR 0
#define BOOST_SERIALIZATION_DONT_USE_HAS_NEW_OPERATOR 0
#endif
#if ! DONT_USE_HAS_NEW_OPERATOR
#if ! BOOST_SERIALIZATION_DONT_USE_HAS_NEW_OPERATOR
#include <boost/type_traits/has_new_operator.hpp>
#endif
@@ -120,41 +122,41 @@ template<class Archive, class T>
class iserializer : public basic_iserializer
{
private:
virtual void destroy(/*const*/ void *address) const {
void destroy(/*const*/ void *address) const BOOST_OVERRIDE {
boost::serialization::access::destroy(static_cast<T *>(address));
}
public:
explicit iserializer() :
basic_iserializer(
boost::serialization::singleton<
typename
typename
boost::serialization::type_info_implementation< T >::type
>::get_const_instance()
)
{}
virtual BOOST_DLLEXPORT void load_object_data(
BOOST_DLLEXPORT void load_object_data(
basic_iarchive & ar,
void *x,
void *x,
const unsigned int file_version
) const BOOST_USED;
virtual bool class_info() const {
return boost::serialization::implementation_level< T >::value
) const BOOST_OVERRIDE BOOST_USED;
bool class_info() const BOOST_OVERRIDE {
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
bool tracking(const unsigned int /* flags */) const BOOST_OVERRIDE {
return boost::serialization::tracking_level< T >::value
== boost::serialization::track_always
|| ( boost::serialization::tracking_level< T >::value
|| ( boost::serialization::tracking_level< T >::value
== boost::serialization::track_selectively
&& serialized_as_pointer());
}
virtual version_type version() const {
version_type version() const BOOST_OVERRIDE {
return version_type(::boost::serialization::version< T >::value);
}
virtual bool is_polymorphic() const {
bool is_polymorphic() const BOOST_OVERRIDE {
return boost::is_polymorphic< T >::value;
}
virtual ~iserializer(){};
~iserializer() BOOST_OVERRIDE {}
};
#ifdef BOOST_MSVC
@@ -164,12 +166,12 @@ public:
template<class Archive, class T>
BOOST_DLLEXPORT void iserializer<Archive, T>::load_object_data(
basic_iarchive & ar,
void *x,
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
// 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
@@ -186,7 +188,7 @@ BOOST_DLLEXPORT void iserializer<Archive, T>::load_object_data(
// be specialized by the user.
boost::serialization::serialize_adl(
boost::serialization::smart_cast_reference<Archive &>(ar),
* static_cast<T *>(x),
* static_cast<T *>(x),
file_version
);
}
@@ -199,7 +201,7 @@ BOOST_DLLEXPORT void iserializer<Archive, T>::load_object_data(
// 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".
// "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
@@ -208,7 +210,7 @@ BOOST_DLLEXPORT void iserializer<Archive, T>::load_object_data(
template<class T>
struct heap_allocation {
// boost::has_new_operator< T > doesn't work on these compilers
#if DONT_USE_HAS_NEW_OPERATOR
#if BOOST_SERIALIZATION_DONT_USE_HAS_NEW_OPERATOR
// This doesn't handle operator new overload for class T
static T * invoke_new(){
return static_cast<T *>(operator new(sizeof(T)));
@@ -250,7 +252,7 @@ struct heap_allocation {
mpl::eval_if<
boost::has_new_operator< T >,
mpl::identity<has_new_operator >,
mpl::identity<doesnt_have_new_operator >
mpl::identity<doesnt_have_new_operator >
>::type typex;
return typex::invoke_new();
}
@@ -259,7 +261,7 @@ struct heap_allocation {
mpl::eval_if<
boost::has_new_operator< T >,
mpl::identity<has_new_operator >,
mpl::identity<doesnt_have_new_operator >
mpl::identity<doesnt_have_new_operator >
>::type typex;
typex::invoke_delete(t);
}
@@ -289,26 +291,26 @@ class pointer_iserializer :
public basic_pointer_iserializer
{
private:
virtual void * heap_allocation() const {
void * heap_allocation() const BOOST_OVERRIDE {
detail::heap_allocation<T> h;
T * t = h.get();
h.release();
return t;
}
virtual const basic_iserializer & get_basic_serializer() const {
const basic_iserializer & get_basic_serializer() const BOOST_OVERRIDE {
return boost::serialization::singleton<
iserializer<Archive, T>
>::get_const_instance();
}
BOOST_DLLEXPORT virtual void load_object_ptr(
basic_iarchive & ar,
BOOST_DLLEXPORT void load_object_ptr(
basic_iarchive & ar,
void * x,
const unsigned int file_version
) const BOOST_USED;
) const BOOST_OVERRIDE BOOST_USED;
public:
// this should alway be a singleton so make the constructor protected
pointer_iserializer();
~pointer_iserializer();
~pointer_iserializer() BOOST_OVERRIDE;
};
#ifdef BOOST_MSVC
@@ -319,12 +321,12 @@ public:
// 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,
basic_iarchive & ar,
void * t,
const unsigned int file_version
) const
{
Archive & ar_impl =
Archive & ar_impl =
boost::serialization::smart_cast_reference<Archive &>(ar);
// note that the above will throw std::bad_alloc if the allocation
@@ -334,7 +336,7 @@ BOOST_DLLEXPORT void pointer_iserializer<Archive, T>::load_object_ptr(
// automatically delete the t which is most likely not fully
// constructed
BOOST_TRY {
// this addresses an obscure situation 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>(
@@ -358,7 +360,7 @@ template<class Archive, class T>
pointer_iserializer<Archive, T>::pointer_iserializer() :
basic_pointer_iserializer(
boost::serialization::singleton<
typename
typename
boost::serialization::type_info_implementation< T >::type
>::get_const_instance()
)
@@ -393,8 +395,8 @@ struct load_non_pointer_type {
// 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),
ar,
const_cast<T &>(t),
boost::serialization::version< T >::value
);
}
@@ -407,7 +409,7 @@ struct load_non_pointer_type {
static void invoke(Archive &ar, const T & t){
void * x = boost::addressof(const_cast<T &>(t));
ar.load_object(
x,
x,
boost::serialization::singleton<
iserializer<Archive, T>
>::get_const_instance()
@@ -484,7 +486,7 @@ struct load_pointer_type {
template<class T>
static const basic_pointer_iserializer * register_type(Archive &ar, const T* const /*t*/){
// there should never be any need to load an abstract polymorphic
// 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
@@ -492,7 +494,7 @@ struct load_pointer_type {
mpl::eval_if<
boost::serialization::is_abstract<const T>,
boost::mpl::identity<abstract>,
boost::mpl::identity<non_abstract>
boost::mpl::identity<non_abstract>
>::type typex;
return typex::template register_type< T >(ar);
}
@@ -508,7 +510,7 @@ struct load_pointer_type {
boost::serialization::void_upcast(
eti,
boost::serialization::singleton<
typename
typename
boost::serialization::type_info_implementation< T >::type
>::get_const_instance(),
t
@@ -570,13 +572,13 @@ struct load_array_type {
template<class T>
static void invoke(Archive &ar, T &t){
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
// fact that some machines will align elements on boundaries
// 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[1]))
- static_cast<char *>(static_cast<void *>(&t[0]))
);
boost::serialization::collection_size_type count;

96
linx64/include/boost/archive/detail/oserializer.hpp
View File

@@ -4,18 +4,20 @@
// MS compatible compilers support #pragma once
#if defined(_MSC_VER)
# pragma once
#pragma inline_depth(511)
#if !defined(__clang__)
#pragma inline_depth(255)
#pragma inline_recursion(on)
#endif
#endif
#if defined(__MWERKS__)
#pragma inline_depth(511)
#pragma inline_depth(255)
#endif
/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
// oserializer.hpp: interface for serialization system.
// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
// (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)
@@ -36,8 +38,8 @@
#include <boost/mpl/identity.hpp>
#include <boost/mpl/bool_fwd.hpp>
#ifndef BOOST_SERIALIZATION_DEFAULT_TYPE_INFO
#include <boost/serialization/extended_type_info_typeid.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>
@@ -105,37 +107,37 @@ template<class Archive, class T>
class oserializer : public basic_oserializer
{
private:
// private constructor to inhibit any existence other than the
// private constructor to inhibit any existence other than the
// static one
public:
explicit BOOST_DLLEXPORT oserializer() :
basic_oserializer(
boost::serialization::singleton<
typename
typename
boost::serialization::type_info_implementation< T >::type
>::get_const_instance()
)
{}
virtual BOOST_DLLEXPORT void save_object_data(
basic_oarchive & ar,
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
) const BOOST_OVERRIDE BOOST_USED;
bool class_info() const BOOST_OVERRIDE {
return boost::serialization::implementation_level< T >::value
>= boost::serialization::object_class_info;
}
virtual bool tracking(const unsigned int /* flags */) const {
bool tracking(const unsigned int /* flags */) const BOOST_OVERRIDE {
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 {
version_type version() const BOOST_OVERRIDE {
return version_type(::boost::serialization::version< T >::value);
}
virtual bool is_polymorphic() const {
bool is_polymorphic() const BOOST_OVERRIDE {
return boost::is_polymorphic< T >::value;
}
virtual ~oserializer(){}
~oserializer() BOOST_OVERRIDE {}
};
#ifdef BOOST_MSVC
@@ -144,7 +146,7 @@ public:
template<class Archive, class T>
BOOST_DLLEXPORT void oserializer<Archive, T>::save_object_data(
basic_oarchive & ar,
basic_oarchive & ar,
const void *x
) const {
// make sure call is routed through the highest interface that might
@@ -167,19 +169,19 @@ class pointer_oserializer :
public basic_pointer_oserializer
{
private:
const basic_oserializer &
get_basic_serializer() const {
const basic_oserializer &
get_basic_serializer() const BOOST_OVERRIDE {
return boost::serialization::singleton<
oserializer<Archive, T>
>::get_const_instance();
}
virtual BOOST_DLLEXPORT void save_object_ptr(
BOOST_DLLEXPORT void save_object_ptr(
basic_oarchive & ar,
const void * x
) const BOOST_USED;
) const BOOST_OVERRIDE BOOST_USED;
public:
pointer_oserializer();
~pointer_oserializer();
~pointer_oserializer() BOOST_OVERRIDE;
};
#ifdef BOOST_MSVC
@@ -196,11 +198,11 @@ BOOST_DLLEXPORT void pointer_oserializer<Archive, T>::save_object_ptr(
// 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
Archive & ar_impl
= boost::serialization::smart_cast_reference<Archive &>(ar);
boost::serialization::save_construct_data_adl<Archive, T>(
ar_impl,
t,
ar_impl,
t,
file_version
);
ar_impl << boost::serialization::make_nvp(NULL, * t);
@@ -210,14 +212,14 @@ template<class Archive, class T>
pointer_oserializer<Archive, T>::pointer_oserializer() :
basic_pointer_oserializer(
boost::serialization::singleton<
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>
oserializer<Archive, T>
>::get_mutable_instance().set_bpos(this);
archive_serializer_map<Archive>::insert(this);
}
@@ -244,8 +246,8 @@ struct save_non_pointer_type {
// 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),
ar,
const_cast<T &>(t),
::boost::serialization::version< T >::value
);
}
@@ -281,7 +283,7 @@ struct save_non_pointer_type {
template<class T>
static void invoke(Archive & ar, const T & t){
typedef
typedef
typename mpl::eval_if<
// if its primitive
mpl::equal_to<
@@ -310,7 +312,7 @@ struct save_non_pointer_type {
// else
// do a fast save only tracking is turned off
mpl::identity<save_conditional>
> > >::type typex;
> > >::type typex;
check_object_versioning< T >();
typex::invoke(ar, t);
}
@@ -344,15 +346,15 @@ struct save_pointer_type {
template<class T>
static const basic_pointer_oserializer * register_type(Archive &ar, T* const /*t*/){
// there should never be any need to save an abstract polymorphic
// 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
typedef
typename mpl::eval_if<
boost::serialization::is_abstract< T >,
mpl::identity<abstract>,
mpl::identity<non_abstract>
mpl::identity<non_abstract>
>::type typex;
return typex::template register_type< T >(ar);
}
@@ -361,10 +363,10 @@ struct save_pointer_type {
{
template<class T>
static void save(
Archive &ar,
Archive &ar,
T & t
){
const basic_pointer_oserializer & bpos =
const basic_pointer_oserializer & bpos =
boost::serialization::singleton<
pointer_oserializer<Archive, T>
>::get_const_instance();
@@ -377,13 +379,13 @@ struct save_pointer_type {
{
template<class T>
static void save(
Archive &ar,
Archive &ar,
T & t
){
typename
typename
boost::serialization::type_info_implementation< T >::type const
& i = boost::serialization::singleton<
typename
typename
boost::serialization::type_info_implementation< T >::type
>::get_const_instance();
@@ -417,8 +419,8 @@ struct save_pointer_type {
// 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,
*true_type,
*this_type,
static_cast<const void *>(&t)
);
if(NULL == vp){
@@ -431,7 +433,7 @@ struct save_pointer_type {
);
}
// since true_type is valid, and this only gets made if the
// 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
@@ -454,7 +456,7 @@ struct save_pointer_type {
template<class T>
static void save(
Archive & ar,
Archive & ar,
const T & t
){
check_pointer_level< T >();
@@ -471,7 +473,7 @@ struct save_pointer_type {
static void invoke(Archive &ar, const TPtr t){
register_type(ar, t);
if(NULL == t){
basic_oarchive & boa
basic_oarchive & boa
= boost::serialization::smart_cast_reference<basic_oarchive &>(ar);
boa.save_null_pointer();
save_access::end_preamble(ar);
@@ -498,11 +500,11 @@ struct save_array_type
template<class T>
static void invoke(Archive &ar, const T &t){
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[1]))
- static_cast<const char *>(static_cast<const void *>(&t[0]))
);
boost::serialization::collection_size_type count(c);
@@ -522,7 +524,7 @@ struct save_array_type
template<class Archive, class T>
inline void save(Archive & ar, /*const*/ T &t){
typedef
typedef
typename mpl::eval_if<is_pointer< T >,
mpl::identity<detail::save_pointer_type<Archive> >,
//else

76
linx64/include/boost/archive/detail/polymorphic_iarchive_route.hpp
View File

@@ -56,125 +56,125 @@ class polymorphic_iarchive_route :
{
private:
// these are used by the serialization library.
virtual void load_object(
void load_object(
void *t,
const basic_iserializer & bis
){
) BOOST_OVERRIDE {
ArchiveImplementation::load_object(t, bis);
}
virtual const basic_pointer_iserializer * load_pointer(
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 & type
)
){
) BOOST_OVERRIDE {
return ArchiveImplementation::load_pointer(t, bpis_ptr, finder);
}
virtual void set_library_version(library_version_type archive_library_version){
void set_library_version(boost::serialization::library_version_type archive_library_version) BOOST_OVERRIDE {
ArchiveImplementation::set_library_version(archive_library_version);
}
virtual library_version_type get_library_version() const{
boost::serialization::library_version_type get_library_version() const BOOST_OVERRIDE {
return ArchiveImplementation::get_library_version();
}
virtual unsigned int get_flags() const {
unsigned int get_flags() const BOOST_OVERRIDE {
return ArchiveImplementation::get_flags();
}
virtual void delete_created_pointers(){
void delete_created_pointers() BOOST_OVERRIDE {
ArchiveImplementation::delete_created_pointers();
}
virtual void reset_object_address(
void reset_object_address(
const void * new_address,
const void * old_address
){
) BOOST_OVERRIDE {
ArchiveImplementation::reset_object_address(new_address, old_address);
}
virtual void load_binary(void * t, std::size_t size){
void load_binary(void * t, std::size_t size) BOOST_OVERRIDE {
ArchiveImplementation::load_binary(t, size);
}
// primitive types the only ones permitted by polymorphic archives
virtual void load(bool & t){
void load(bool & t) BOOST_OVERRIDE {
ArchiveImplementation::load(t);
}
virtual void load(char & t){
void load(char & t) BOOST_OVERRIDE {
ArchiveImplementation::load(t);
}
virtual void load(signed char & t){
void load(signed char & t) BOOST_OVERRIDE {
ArchiveImplementation::load(t);
}
virtual void load(unsigned char & t){
void load(unsigned char & t) BOOST_OVERRIDE {
ArchiveImplementation::load(t);
}
#ifndef BOOST_NO_CWCHAR
#ifndef BOOST_NO_INTRINSIC_WCHAR_T
virtual void load(wchar_t & t){
void load(wchar_t & t) BOOST_OVERRIDE {
ArchiveImplementation::load(t);
}
#endif
#endif
virtual void load(short & t){
void load(short & t) BOOST_OVERRIDE {
ArchiveImplementation::load(t);
}
virtual void load(unsigned short & t){
void load(unsigned short & t) BOOST_OVERRIDE {
ArchiveImplementation::load(t);
}
virtual void load(int & t){
void load(int & t) BOOST_OVERRIDE {
ArchiveImplementation::load(t);
}
virtual void load(unsigned int & t){
void load(unsigned int & t) BOOST_OVERRIDE {
ArchiveImplementation::load(t);
}
virtual void load(long & t){
void load(long & t) BOOST_OVERRIDE {
ArchiveImplementation::load(t);
}
virtual void load(unsigned long & t){
void load(unsigned long & t) BOOST_OVERRIDE {
ArchiveImplementation::load(t);
}
#if defined(BOOST_HAS_LONG_LONG)
virtual void load(boost::long_long_type & t){
void load(boost::long_long_type & t) BOOST_OVERRIDE {
ArchiveImplementation::load(t);
}
virtual void load(boost::ulong_long_type & t){
void load(boost::ulong_long_type & t) BOOST_OVERRIDE {
ArchiveImplementation::load(t);
}
#elif defined(BOOST_HAS_MS_INT64)
virtual void load(__int64 & t){
void load(__int64 & t) BOOST_OVERRIDE {
ArchiveImplementation::load(t);
}
virtual void load(unsigned __int64 & t){
void load(unsigned __int64 & t) BOOST_OVERRIDE {
ArchiveImplementation::load(t);
}
#endif
virtual void load(float & t){
void load(float & t) BOOST_OVERRIDE {
ArchiveImplementation::load(t);
}
virtual void load(double & t){
void load(double & t) BOOST_OVERRIDE {
ArchiveImplementation::load(t);
}
virtual void load(std::string & t){
void load(std::string & t) BOOST_OVERRIDE {
ArchiveImplementation::load(t);
}
#ifndef BOOST_NO_STD_WSTRING
virtual void load(std::wstring & t){
void load(std::wstring & t) BOOST_OVERRIDE {
ArchiveImplementation::load(t);
}
#endif
// used for xml and other tagged formats default does nothing
virtual void load_start(const char * name){
void load_start(const char * name) BOOST_OVERRIDE {
ArchiveImplementation::load_start(name);
}
virtual void load_end(const char * name){
void load_end(const char * name) BOOST_OVERRIDE {
ArchiveImplementation::load_end(name);
}
virtual void register_basic_serializer(const basic_iserializer & bis){
void register_basic_serializer(const basic_iserializer & bis) BOOST_OVERRIDE {
ArchiveImplementation::register_basic_serializer(bis);
}
virtual helper_collection &
get_helper_collection(){
helper_collection &
get_helper_collection() BOOST_OVERRIDE {
return ArchiveImplementation::get_helper_collection();
}
public:
// this can't be inheriteded because they appear in mulitple
// this can't be inherited because they appear in multiple
// parents
typedef mpl::bool_<true> is_loading;
typedef mpl::bool_<false> is_saving;
@@ -190,7 +190,7 @@ public:
}
// register type function
template<class T>
const basic_pointer_iserializer *
const basic_pointer_iserializer *
register_type(T * t = NULL){
return ArchiveImplementation::register_type(t);
}
@@ -202,7 +202,7 @@ public:
) :
ArchiveImplementation(is, flags)
{}
virtual ~polymorphic_iarchive_route(){};
~polymorphic_iarchive_route() BOOST_OVERRIDE {}
};
} // namespace detail

72
linx64/include/boost/archive/detail/polymorphic_oarchive_route.hpp
View File

@@ -56,116 +56,116 @@ class polymorphic_oarchive_route :
{
private:
// these are used by the serialization library.
virtual void save_object(
void save_object(
const void *x,
const detail::basic_oserializer & bos
){
) BOOST_OVERRIDE {
ArchiveImplementation::save_object(x, bos);
}
virtual void save_pointer(
void save_pointer(
const void * t,
const detail::basic_pointer_oserializer * bpos_ptr
){
) BOOST_OVERRIDE {
ArchiveImplementation::save_pointer(t, bpos_ptr);
}
virtual void save_null_pointer(){
void save_null_pointer() BOOST_OVERRIDE {
ArchiveImplementation::save_null_pointer();
}
// primitive types the only ones permitted by polymorphic archives
virtual void save(const bool t){
void save(const bool t) BOOST_OVERRIDE {
ArchiveImplementation::save(t);
}
virtual void save(const char t){
void save(const char t) BOOST_OVERRIDE {
ArchiveImplementation::save(t);
}
virtual void save(const signed char t){
void save(const signed char t) BOOST_OVERRIDE {
ArchiveImplementation::save(t);
}
virtual void save(const unsigned char t){
void save(const unsigned char t) BOOST_OVERRIDE {
ArchiveImplementation::save(t);
}
#ifndef BOOST_NO_CWCHAR
#ifndef BOOST_NO_INTRINSIC_WCHAR_T
virtual void save(const wchar_t t){
void save(const wchar_t t) BOOST_OVERRIDE {
ArchiveImplementation::save(t);
}
#endif
#endif
virtual void save(const short t){
void save(const short t) BOOST_OVERRIDE {
ArchiveImplementation::save(t);
}
virtual void save(const unsigned short t){
void save(const unsigned short t) BOOST_OVERRIDE {
ArchiveImplementation::save(t);
}
virtual void save(const int t){
void save(const int t) BOOST_OVERRIDE {
ArchiveImplementation::save(t);
}
virtual void save(const unsigned int t){
void save(const unsigned int t) BOOST_OVERRIDE {
ArchiveImplementation::save(t);
}
virtual void save(const long t){
void save(const long t) BOOST_OVERRIDE {
ArchiveImplementation::save(t);
}
virtual void save(const unsigned long t){
void save(const unsigned long t) BOOST_OVERRIDE {
ArchiveImplementation::save(t);
}
#if defined(BOOST_HAS_LONG_LONG)
virtual void save(const boost::long_long_type t){
void save(const boost::long_long_type t) BOOST_OVERRIDE {
ArchiveImplementation::save(t);
}
virtual void save(const boost::ulong_long_type t){
void save(const boost::ulong_long_type t) BOOST_OVERRIDE {
ArchiveImplementation::save(t);
}
#elif defined(BOOST_HAS_MS_INT64)
virtual void save(const boost::int64_t t){
void save(const boost::int64_t t) BOOST_OVERRIDE {
ArchiveImplementation::save(t);
}
virtual void save(const boost::uint64_t t){
void save(const boost::uint64_t t) BOOST_OVERRIDE {
ArchiveImplementation::save(t);
}
#endif
virtual void save(const float t){
void save(const float t) BOOST_OVERRIDE {
ArchiveImplementation::save(t);
}
virtual void save(const double t){
void save(const double t) BOOST_OVERRIDE {
ArchiveImplementation::save(t);
}
virtual void save(const std::string & t){
void save(const std::string & t) BOOST_OVERRIDE {
ArchiveImplementation::save(t);
}
#ifndef BOOST_NO_STD_WSTRING
virtual void save(const std::wstring & t){
void save(const std::wstring & t) BOOST_OVERRIDE {
ArchiveImplementation::save(t);
}
#endif
virtual library_version_type get_library_version() const{
boost::serialization::library_version_type get_library_version() const BOOST_OVERRIDE {
return ArchiveImplementation::get_library_version();
}
virtual unsigned int get_flags() const {
unsigned int get_flags() const BOOST_OVERRIDE {
return ArchiveImplementation::get_flags();
}
virtual void save_binary(const void * t, std::size_t size){
void save_binary(const void * t, std::size_t size) BOOST_OVERRIDE {
ArchiveImplementation::save_binary(t, size);
}
// used for xml and other tagged formats default does nothing
virtual void save_start(const char * name){
void save_start(const char * name) BOOST_OVERRIDE {
ArchiveImplementation::save_start(name);
}
virtual void save_end(const char * name){
void save_end(const char * name) BOOST_OVERRIDE {
ArchiveImplementation::save_end(name);
}
virtual void end_preamble(){
void end_preamble() BOOST_OVERRIDE {
ArchiveImplementation::end_preamble();
}
virtual void register_basic_serializer(const detail::basic_oserializer & bos){
void register_basic_serializer(const detail::basic_oserializer & bos) BOOST_OVERRIDE {
ArchiveImplementation::register_basic_serializer(bos);
}
virtual helper_collection &
get_helper_collection(){
helper_collection &
get_helper_collection() BOOST_OVERRIDE {
return ArchiveImplementation::get_helper_collection();
}
public:
// this can't be inheriteded because they appear in mulitple
// this can't be inherited because they appear in multiple
// parents
typedef mpl::bool_<false> is_loading;
typedef mpl::bool_<true> is_saving;
@@ -181,7 +181,7 @@ public:
}
// register type function
template<class T>
const basic_pointer_oserializer *
const basic_pointer_oserializer *
register_type(T * t = NULL){
return ArchiveImplementation::register_type(t);
}
@@ -193,7 +193,7 @@ public:
) :
ArchiveImplementation(os, flags)
{}
virtual ~polymorphic_oarchive_route(){};
~polymorphic_oarchive_route() BOOST_OVERRIDE {}
};
} // namespace detail

2
linx64/include/boost/archive/detail/register_archive.hpp
View File

@@ -4,7 +4,7 @@
#ifndef BOOST_ARCHIVE_DETAIL_REGISTER_ARCHIVE_DWA2006521_HPP
# define BOOST_ARCHIVE_DETAIL_REGISTER_ARCHIVE_DWA2006521_HPP
namespace boost { namespace archive { namespace detail {
namespace boost { namespace archive { namespace detail {
// No instantiate_ptr_serialization overloads generated by
// BOOST_SERIALIZATION_REGISTER_ARCHIVE that lexically follow the call

1
linx64/include/boost/archive/detail/utf8_codecvt_facet.hpp
View File

@@ -17,7 +17,6 @@
#include <boost/archive/detail/decl.hpp>
#define BOOST_UTF8_BEGIN_NAMESPACE \
namespace boost { namespace archive { namespace detail {
#define BOOST_UTF8_DECL BOOST_ARCHIVE_DECL
#define BOOST_UTF8_END_NAMESPACE }}}
#include <boost/detail/utf8_codecvt_facet.hpp>

24
linx64/include/boost/archive/dinkumware.hpp
View File

@@ -9,7 +9,7 @@
/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
// dinkumware.hpp:
// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
// (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)
@@ -29,7 +29,7 @@ namespace std {
// define i/o operators for 64 bit integers
template<class CharType>
basic_ostream<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];
@@ -66,7 +66,7 @@ operator<<(basic_ostream<CharType> & os, boost::uint64_t t){
}
template<class CharType>
basic_ostream<CharType> &
basic_ostream<CharType> &
operator<<(basic_ostream<CharType> &os, boost::int64_t t){
if(0 <= t){
os << static_cast<boost::uint64_t>(t);
@@ -79,7 +79,7 @@ operator<<(basic_ostream<CharType> &os, boost::int64_t t){
}
template<class CharType>
basic_istream<CharType> &
basic_istream<CharType> &
operator>>(basic_istream<CharType> &is, boost::int64_t & t){
CharType d;
do{
@@ -119,7 +119,7 @@ operator>>(basic_istream<CharType> &is, boost::int64_t & t){
}
template<class CharType>
basic_istream<CharType> &
basic_istream<CharType> &
operator>>(basic_istream<CharType> &is, boost::uint64_t & t){
boost::int64_t it;
is >> it;
@@ -127,10 +127,8 @@ operator>>(basic_istream<CharType> &is, boost::uint64_t & t){
return is;
}
//#endif
template<>
class back_insert_iterator<basic_string<char> > : public
class back_insert_iterator<basic_string<char> > : public
iterator<output_iterator_tag, char>
{
public:
@@ -140,7 +138,7 @@ public:
explicit back_insert_iterator(container_type & s)
: container(& s)
{} // construct with container
back_insert_iterator<container_type> & operator=(
container_type::const_reference Val_
){ // push value into container
@@ -167,7 +165,7 @@ protected:
container_type *container; // pointer to container
};
template<char>
template<char>
inline back_insert_iterator<basic_string<char> > back_inserter(
basic_string<char> & s
){
@@ -175,7 +173,7 @@ inline back_insert_iterator<basic_string<char> > back_inserter(
}
template<>
class back_insert_iterator<basic_string<wchar_t> > : public
class back_insert_iterator<basic_string<wchar_t> > : public
iterator<output_iterator_tag, wchar_t>
{
public:
@@ -185,7 +183,7 @@ public:
explicit back_insert_iterator(container_type & s)
: container(& s)
{} // construct with container
back_insert_iterator<container_type> & operator=(
container_type::const_reference Val_
){ // push value into container
@@ -212,7 +210,7 @@ protected:
container_type *container; // pointer to container
};
template<wchar_t>
template<wchar_t>
inline back_insert_iterator<basic_string<wchar_t> > back_inserter(
basic_string<wchar_t> & s
){

12
linx64/include/boost/archive/impl/basic_binary_iarchive.ipp
View File

@@ -22,7 +22,7 @@ namespace std{
#endif
#include <boost/detail/workaround.hpp>
#include <boost/detail/endian.hpp>
#include <boost/predef/other/endian.h>
#include <boost/archive/basic_binary_iarchive.hpp>
@@ -48,7 +48,7 @@ basic_binary_iarchive<Archive>::load_override(class_name_type & t){
template<class Archive>
BOOST_ARCHIVE_OR_WARCHIVE_DECL void
basic_binary_iarchive<Archive>::init(void){
basic_binary_iarchive<Archive>::init() {
// read signature in an archive version independent manner
std::string file_signature;
@@ -84,12 +84,12 @@ basic_binary_iarchive<Archive>::init(void){
// make sure the version of the reading archive library can
// support the format of the archive being read
library_version_type input_library_version;
boost::serialization::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 BOOST_ENDIAN_LITTLE_BYTE
if(v < 6){
;
}
@@ -111,11 +111,11 @@ basic_binary_iarchive<Archive>::init(void){
// version 8+ followed by a zero
this->This()->m_sb.sbumpc();
}
#elif defined(BOOST_BIG_ENDIAN)
#elif BOOST_ENDIAN_BIG_BYTE
if(v == 0)
v = this->This()->m_sb.sbumpc();
#endif
input_library_version = static_cast<library_version_type>(v);
input_library_version = static_cast<boost::serialization::library_version_type>(v);
}
#if BOOST_WORKAROUND(__MWERKS__, BOOST_TESTED_AT(0x3205))

2
linx64/include/boost/archive/impl/basic_binary_oarchive.ipp
View File

@@ -34,7 +34,7 @@ basic_binary_oarchive<Archive>::init(){
const std::string file_signature(BOOST_ARCHIVE_SIGNATURE());
* this->This() << file_signature;
// write library version
const library_version_type v(BOOST_ARCHIVE_VERSION());
const boost::serialization::library_version_type v(BOOST_ARCHIVE_VERSION());
* this->This() << v;
}

4
linx64/include/boost/archive/impl/basic_text_iarchive.ipp
View File

@@ -45,7 +45,7 @@ basic_text_iarchive<Archive>::load_override(class_name_type & t){
template<class Archive>
BOOST_ARCHIVE_OR_WARCHIVE_DECL void
basic_text_iarchive<Archive>::init(void){
basic_text_iarchive<Archive>::init() {
// read signature in an archive version independent manner
std::string file_signature;
* this->This() >> file_signature;
@@ -56,7 +56,7 @@ basic_text_iarchive<Archive>::init(void){
// make sure the version of the reading archive library can
// support the format of the archive being read
library_version_type input_library_version;
boost::serialization::library_version_type input_library_version;
* this->This() >> input_library_version;
#if BOOST_WORKAROUND(__MWERKS__, BOOST_TESTED_AT(0x3205))

3
linx64/include/boost/archive/impl/basic_text_iprimitive.ipp
View File

@@ -112,8 +112,8 @@ basic_text_iprimitive<IStream>::basic_text_iprimitive(
) :
is(is_),
flags_saver(is_),
precision_saver(is_),
#ifndef BOOST_NO_STD_LOCALE
precision_saver(is_),
codecvt_null_facet(1),
archive_locale(is.getloc(), & codecvt_null_facet),
locale_saver(is)
@@ -125,6 +125,7 @@ basic_text_iprimitive<IStream>::basic_text_iprimitive(
is_ >> std::noboolalpha;
}
#else
precision_saver(is_)
{}
#endif

2
linx64/include/boost/archive/impl/basic_text_oarchive.ipp
View File

@@ -54,7 +54,7 @@ basic_text_oarchive<Archive>::init(){
const std::string file_signature(BOOST_ARCHIVE_SIGNATURE());
* this->This() << file_signature;
// write library version
const library_version_type v(BOOST_ARCHIVE_VERSION());
const boost::serialization::library_version_type v(BOOST_ARCHIVE_VERSION());
* this->This() << v;
}

8
linx64/include/boost/archive/impl/basic_text_oprimitive.ipp
View File

@@ -10,7 +10,6 @@
#include <cstddef> // NULL
#include <algorithm> // std::copy
#include <exception> // std::uncaught_exception
#include <boost/config.hpp>
#if defined(BOOST_NO_STDC_NAMESPACE)
namespace std{
@@ -18,6 +17,8 @@ namespace std{
} // namespace std
#endif
#include <boost/core/uncaught_exceptions.hpp>
#include <boost/archive/basic_text_oprimitive.hpp>
#include <boost/archive/iterators/base64_from_binary.hpp>
@@ -86,8 +87,8 @@ basic_text_oprimitive<OStream>::basic_text_oprimitive(
) :
os(os_),
flags_saver(os_),
precision_saver(os_),
#ifndef BOOST_NO_STD_LOCALE
precision_saver(os_),
codecvt_null_facet(1),
archive_locale(os.getloc(), & codecvt_null_facet),
locale_saver(os)
@@ -99,6 +100,7 @@ basic_text_oprimitive<OStream>::basic_text_oprimitive(
os_ << std::noboolalpha;
}
#else
precision_saver(os_)
{}
#endif
@@ -106,7 +108,7 @@ basic_text_oprimitive<OStream>::basic_text_oprimitive(
template<class OStream>
BOOST_ARCHIVE_OR_WARCHIVE_DECL
basic_text_oprimitive<OStream>::~basic_text_oprimitive(){
if(std::uncaught_exception())
if(boost::core::uncaught_exceptions() > 0)
return;
os << std::endl;
}

24
linx64/include/boost/archive/impl/basic_xml_grammar.hpp
View File

@@ -9,7 +9,7 @@
/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
// basic_xml_grammar.hpp
// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
// (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)
@@ -70,7 +70,7 @@ public:
// one compiler (Compaq C++ 6.5 in strict_ansi mode) chokes otherwise.
struct return_values;
friend struct return_values;
private:
typedef typename std::basic_istream<CharType> IStream;
typedef typename std::basic_string<CharType> StringType;
@@ -81,16 +81,16 @@ private:
> scanner_t;
typedef typename boost::spirit::classic::rule<scanner_t> rule_t;
// Start grammar definition
rule_t
rule_t
Reference,
Eq,
Eq,
STag,
ETag,
LetterOrUnderscoreOrColon,
AttValue,
CharRef1,
CharRef2,
CharRef,
AttValue,
CharRef1,
CharRef2,
CharRef,
AmpRef,
LTRef,
GTRef,
@@ -127,11 +127,11 @@ private:
chset_t
BaseChar,
Ideographic,
Char,
Letter,
Char,
Letter,
Digit,
CombiningChar,
Extender,
Extender,
Sch,
NameChar;
@@ -139,7 +139,7 @@ private:
bool my_parse(
IStream & is,
const rule_t &rule_,
const rule_t &rule_,
const CharType delimiter = L'>'
) const ;
public:

1
linx64/include/boost/archive/impl/basic_xml_iarchive.ipp
View File

@@ -37,7 +37,6 @@ basic_xml_iarchive<Archive>::load_start(const char *name){
}
// don't check start tag at highest level
++depth;
return;
}
template<class Archive>

9
linx64/include/boost/archive/impl/text_iarchive_impl.ipp
View File

@@ -115,14 +115,7 @@ text_iarchive_impl<Archive>::text_iarchive_impl(
0 != (flags & no_codecvt)
),
basic_text_iarchive<Archive>(flags)
{
if(0 == (flags & no_header))
#if BOOST_WORKAROUND(__MWERKS__, BOOST_TESTED_AT(0x3205))
this->init();
#else
this->basic_text_iarchive<Archive>::init();
#endif
}
{}
} // namespace archive
} // namespace boost

6
linx64/include/boost/archive/impl/text_oarchive_impl.ipp
View File

@@ -93,12 +93,6 @@ text_oarchive_impl<Archive>::text_oarchive_impl(
),
basic_text_oarchive<Archive>(flags)
{
if(0 == (flags & no_header))
#if BOOST_WORKAROUND(__MWERKS__, BOOST_TESTED_AT(0x3205))
this->init();
#else
this->basic_text_oarchive<Archive>::init();
#endif
}
template<class Archive>

2
linx64/include/boost/archive/impl/text_wiarchive_impl.ipp
View File

@@ -108,8 +108,6 @@ text_wiarchive_impl<Archive>::text_wiarchive_impl(
),
basic_text_iarchive<Archive>(flags)
{
if(0 == (flags & no_header))
basic_text_iarchive<Archive>::init();
}
} // archive

11
linx64/include/boost/archive/impl/xml_iarchive_impl.ipp
View File

@@ -11,7 +11,6 @@
#include <boost/config.hpp>
#include <cstring> // memcpy
#include <cstddef> // NULL
#include <exception>
#if defined(BOOST_NO_STDC_NAMESPACE)
namespace std{
@@ -34,6 +33,7 @@ namespace std{
#include <boost/archive/dinkumware.hpp>
#endif
#include <boost/core/uncaught_exceptions.hpp>
#include <boost/core/no_exceptions_support.hpp>
#include <boost/archive/xml_archive_exception.hpp>
@@ -165,7 +165,7 @@ BOOST_ARCHIVE_DECL void
xml_iarchive_impl<Archive>::init(){
gimpl->init(is);
this->set_library_version(
library_version_type(gimpl->rv.version)
boost::serialization::library_version_type(gimpl->rv.version)
);
}
@@ -181,15 +181,12 @@ xml_iarchive_impl<Archive>::xml_iarchive_impl(
),
basic_xml_iarchive<Archive>(flags),
gimpl(new xml_grammar())
{
if(0 == (flags & no_header))
init();
}
{}
template<class Archive>
BOOST_ARCHIVE_DECL
xml_iarchive_impl<Archive>::~xml_iarchive_impl(){
if(std::uncaught_exception())
if(boost::core::uncaught_exceptions() > 0)
return;
if(0 == (this->get_flags() & no_header)){
gimpl->windup(is);

9
linx64/include/boost/archive/impl/xml_oarchive_impl.ipp
View File

@@ -10,7 +10,6 @@
#include <iomanip>
#include <algorithm> // std::copy
#include <string>
#include <exception>
#include <cstring> // strlen
#include <boost/config.hpp> // msvc 6.0 needs this to suppress warnings
@@ -20,6 +19,7 @@ namespace std{
} // namespace std
#endif
#include <boost/core/uncaught_exceptions.hpp>
#include <boost/archive/iterators/xml_escape.hpp>
#include <boost/archive/iterators/ostream_iterator.hpp>
@@ -109,10 +109,7 @@ xml_oarchive_impl<Archive>::xml_oarchive_impl(
0 != (flags & no_codecvt)
),
basic_xml_oarchive<Archive>(flags)
{
if(0 == (flags & no_header))
this->init();
}
{}
template<class Archive>
BOOST_ARCHIVE_DECL void
@@ -132,7 +129,7 @@ xml_oarchive_impl<Archive>::save_binary(const void *address, std::size_t count){
template<class Archive>
BOOST_ARCHIVE_DECL
xml_oarchive_impl<Archive>::~xml_oarchive_impl(){
if(std::uncaught_exception())
if(boost::core::uncaught_exceptions() > 0)
return;
if(0 == (this->get_flags() & no_header))
this->windup();

8
linx64/include/boost/archive/impl/xml_wiarchive_impl.ipp
View File

@@ -20,13 +20,13 @@ namespace std{
#include <boost/assert.hpp>
#include <algorithm> // std::copy
#include <exception> // uncaught exception
#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/core/uncaught_exceptions.hpp>
#include <boost/core/no_exceptions_support.hpp>
#include <boost/serialization/string.hpp>
@@ -143,7 +143,7 @@ BOOST_WARCHIVE_DECL void
xml_wiarchive_impl<Archive>::init(){
gimpl->init(is);
this->set_library_version(
library_version_type(gimpl->rv.version)
boost::serialization::library_version_type(gimpl->rv.version)
);
}
@@ -169,14 +169,12 @@ xml_wiarchive_impl<Archive>::xml_wiarchive_impl(
is_.sync();
is_.imbue(archive_locale);
}
if(0 == (flags & no_header))
init();
}
template<class Archive>
BOOST_WARCHIVE_DECL
xml_wiarchive_impl<Archive>::~xml_wiarchive_impl(){
if(std::uncaught_exception())
if(boost::core::uncaught_exceptions() > 0)
return;
if(0 == (this->get_flags() & no_header)){
gimpl->windup(is);

7
linx64/include/boost/archive/impl/xml_woarchive_impl.ipp
View File

@@ -13,7 +13,6 @@
#include <string>
#include <algorithm> // std::copy
#include <locale>
#include <exception>
#include <cstring> // strlen
#include <cstdlib> // mbtowc
@@ -32,6 +31,8 @@ namespace std{
} // namespace std
#endif
#include <boost/core/uncaught_exceptions.hpp>
#include <boost/archive/xml_woarchive.hpp>
#include <boost/archive/detail/utf8_codecvt_facet.hpp>
@@ -132,14 +133,12 @@ xml_woarchive_impl<Archive>::xml_woarchive_impl(
os_.flush();
os_.imbue(archive_locale);
}
if(0 == (flags & no_header))
this->init();
}
template<class Archive>
BOOST_WARCHIVE_DECL
xml_woarchive_impl<Archive>::~xml_woarchive_impl(){
if(std::uncaught_exception())
if(boost::core::uncaught_exceptions() > 0)
return;
if(0 == (this->get_flags() & no_header)){
os << L"</boost_serialization>";

2
linx64/include/boost/archive/iterators/base64_exception.hpp
View File

@@ -9,7 +9,7 @@
/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
// base64_exception.hpp:
// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
// (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)

14
linx64/include/boost/archive/iterators/base64_from_binary.hpp
View File

@@ -9,7 +9,7 @@
/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
// base64_from_binary.hpp
// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
// (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)
@@ -20,15 +20,15 @@
#include <cstddef> // size_t
#if defined(BOOST_NO_STDC_NAMESPACE)
namespace std{
using ::size_t;
namespace std{
using ::size_t;
} // namespace std
#endif
#include <boost/iterator/transform_iterator.hpp>
#include <boost/archive/iterators/dataflow_exception.hpp>
namespace boost {
namespace boost {
namespace archive {
namespace iterators {
@@ -68,10 +68,10 @@ struct from_6_bit {
//template<class Base, class CharType = typename Base::value_type>
template<
class Base,
class Base,
class CharType = typename boost::iterator_value<Base>::type
>
class base64_from_binary :
class base64_from_binary :
public transform_iterator<
detail::from_6_bit<CharType>,
Base
@@ -93,7 +93,7 @@ public:
)
{}
// intel 7.1 doesn't like default copy constructor
base64_from_binary(const base64_from_binary & rhs) :
base64_from_binary(const base64_from_binary & rhs) :
super_t(
Base(rhs.base_reference()),
detail::from_6_bit<CharType>()

8
linx64/include/boost/archive/iterators/binary_from_base64.hpp
View File

@@ -9,7 +9,7 @@
/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
// binary_from_base64.hpp
// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
// (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)
@@ -24,7 +24,7 @@
#include <boost/iterator/transform_iterator.hpp>
#include <boost/archive/iterators/dataflow_exception.hpp>
namespace boost {
namespace boost {
namespace archive {
namespace iterators {
@@ -78,7 +78,7 @@ struct to_6_bit {
// ideal. This is also addressed here.
template<
class Base,
class Base,
class CharType = typename boost::iterator_value<Base>::type
>
class binary_from_base64 : public
@@ -102,7 +102,7 @@ public:
)
{}
// intel 7.1 doesn't like default copy constructor
binary_from_base64(const binary_from_base64 & rhs) :
binary_from_base64(const binary_from_base64 & rhs) :
super_t(
Base(rhs.base_reference()),
detail::to_6_bit<CharType>()

4
linx64/include/boost/archive/iterators/dataflow.hpp
View File

@@ -9,7 +9,7 @@
/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
// dataflow.hpp
// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
// (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)
@@ -31,7 +31,7 @@
#include <boost/iterator/iterator_traits.hpp>
#include <boost/static_assert.hpp>
namespace boost {
namespace boost {
namespace archive {
namespace iterators {

4
linx64/include/boost/archive/iterators/dataflow_exception.hpp
View File

@@ -9,7 +9,7 @@
/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
// dataflow_exception.hpp:
// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
// (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)
@@ -46,7 +46,7 @@ public:
dataflow_exception(exception_code c = other_exception) : code(c)
{}
virtual const char *what( ) const throw( )
const char *what( ) const throw( ) BOOST_OVERRIDE
{
const char *msg = "unknown exception code";
switch(code){

18
linx64/include/boost/archive/iterators/escape.hpp
View File

@@ -9,7 +9,7 @@
/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
// escape.hpp
// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
// (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)
@@ -22,7 +22,7 @@
#include <boost/iterator/iterator_adaptor.hpp>
#include <boost/iterator/iterator_traits.hpp>
namespace boost {
namespace boost {
namespace archive {
namespace iterators {
@@ -30,10 +30,10 @@ namespace iterators {
// insert escapes into text
template<class Derived, class Base>
class escape :
class escape :
public boost::iterator_adaptor<
Derived,
Base,
Derived,
Base,
typename boost::iterator_value<Base>::type,
single_pass_traversal_tag,
typename boost::iterator_value<Base>::type
@@ -44,8 +44,8 @@ class escape :
friend class boost::iterator_core_access;
typedef typename boost::iterator_adaptor<
Derived,
Base,
Derived,
Base,
base_value_type,
single_pass_traversal_tag,
base_value_type
@@ -58,7 +58,7 @@ class escape :
m_full = true;
}
//Access the value referred to
//Access the value referred to
reference_type dereference() const {
if(!m_full)
const_cast<this_t *>(this)->dereference_impl();
@@ -98,7 +98,7 @@ class escape :
bool m_full;
base_value_type m_current_value;
public:
escape(Base base) :
escape(Base base) :
super_t(base),
m_bnext(NULL),
m_bend(NULL),

12
linx64/include/boost/archive/iterators/insert_linebreaks.hpp
View File

@@ -9,7 +9,7 @@
/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
// insert_linebreaks.hpp
// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
// (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)
@@ -26,18 +26,18 @@ namespace std{ using ::memcpy; }
#include <boost/iterator/iterator_adaptor.hpp>
#include <boost/iterator/iterator_traits.hpp>
namespace boost {
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 Base,
int N,
class CharType = typename boost::iterator_value<Base>::type
>
class insert_linebreaks :
class insert_linebreaks :
public iterator_adaptor<
insert_linebreaks<Base, N, CharType>,
Base,
@@ -86,7 +86,7 @@ public:
m_count(0)
{}
// intel 7.1 doesn't like default copy constructor
insert_linebreaks(const insert_linebreaks & rhs) :
insert_linebreaks(const insert_linebreaks & rhs) :
super_t(rhs.base_reference()),
m_count(rhs.m_count)
{}

10
linx64/include/boost/archive/iterators/istream_iterator.hpp
View File

@@ -9,7 +9,7 @@
/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
// istream_iterator.hpp
// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
// (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)
@@ -25,13 +25,13 @@
#include <istream>
#include <boost/iterator/iterator_facade.hpp>
namespace boost {
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 :
class istream_iterator :
public boost::iterator_facade<
istream_iterator<Elem>,
Elem,
@@ -48,13 +48,13 @@ class istream_iterator :
Elem
> super_t;
typedef typename std::basic_istream<Elem> istream_type;
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
//Access the value referred to
Elem dereference() const {
return static_cast<Elem>(m_istream->peek());
}

20
linx64/include/boost/archive/iterators/mb_from_wchar.hpp
View File

@@ -9,7 +9,7 @@
/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
// mb_from_wchar.hpp
// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
// (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)
@@ -23,7 +23,7 @@
#endif
#include <boost/config.hpp>
#if defined(BOOST_NO_STDC_NAMESPACE)
namespace std{
namespace std{
using ::mbstate_t;
} // namespace std
#endif
@@ -31,7 +31,7 @@ namespace std{
#include <boost/archive/detail/utf8_codecvt_facet.hpp>
#include <boost/iterator/iterator_adaptor.hpp>
namespace boost {
namespace boost {
namespace archive {
namespace iterators {
@@ -41,8 +41,8 @@ namespace iterators {
template<class Base> // the input iterator
class mb_from_wchar
: public boost::iterator_adaptor<
mb_from_wchar<Base>,
Base,
mb_from_wchar<Base>,
Base,
wchar_t,
single_pass_traversal_tag,
char
@@ -51,8 +51,8 @@ class mb_from_wchar
friend class boost::iterator_core_access;
typedef typename boost::iterator_adaptor<
mb_from_wchar<Base>,
Base,
mb_from_wchar<Base>,
Base,
wchar_t,
single_pass_traversal_tag,
char
@@ -75,7 +75,7 @@ class mb_from_wchar
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
return
0 == m_bend
&& 0 == m_bnext
&& this->base_reference() == rhs.base_reference()
@@ -102,7 +102,7 @@ class mb_from_wchar
void increment(){
if(++m_bnext < m_bend)
return;
m_bend =
m_bend =
m_bnext = 0;
++(this->base_reference());
m_full = false;
@@ -127,7 +127,7 @@ public:
m_full(false)
{}
// intel 7.1 doesn't like default copy constructor
mb_from_wchar(const mb_from_wchar & rhs) :
mb_from_wchar(const mb_from_wchar & rhs) :
super_t(rhs.base_reference()),
m_bend(rhs.m_bend),
m_bnext(rhs.m_bnext),

8
linx64/include/boost/archive/iterators/ostream_iterator.hpp
View File

@@ -9,7 +9,7 @@
/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
// ostream_iterator.hpp
// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
// (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)
@@ -24,13 +24,13 @@
#include <ostream>
#include <boost/iterator/iterator_facade.hpp>
namespace boost {
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 :
class ostream_iterator :
public boost::iterator_facade<
ostream_iterator<Elem>,
Elem,
@@ -43,7 +43,7 @@ class ostream_iterator :
typedef Elem char_type;
typedef std::basic_ostream<char_type> ostream_type;
//emulate the behavior of std::ostream
//emulate the behavior of std::ostream
ostream_iterator & dereference() const {
return const_cast<ostream_iterator &>(*this);
}

14
linx64/include/boost/archive/iterators/remove_whitespace.hpp
View File

@@ -9,7 +9,7 @@
/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
// remove_whitespace.hpp
// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
// (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)
@@ -25,7 +25,7 @@
// 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
// 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
@@ -74,7 +74,7 @@ struct remove_whitespace_predicate<wchar_t>
/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
// convert base64 file data (including whitespace and padding) to binary
namespace boost {
namespace boost {
namespace archive {
namespace iterators {
@@ -122,15 +122,15 @@ public:
m_full = false;
++(this->base_reference());
}
filter_iterator(Base start) :
super_t(start),
filter_iterator(Base start) :
super_t(start),
m_full(false)
{}
filter_iterator(){}
};
template<class Base>
class remove_whitespace :
class remove_whitespace :
public filter_iterator<
remove_whitespace_predicate<
typename boost::iterator_value<Base>::type
@@ -155,7 +155,7 @@ public:
super_t(Base(static_cast< T >(start)))
{}
// intel 7.1 doesn't like default copy constructor
remove_whitespace(const remove_whitespace & rhs) :
remove_whitespace(const remove_whitespace & rhs) :
super_t(rhs.base_reference())
{}
};

28
linx64/include/boost/archive/iterators/transform_width.hpp
View File

@@ -9,7 +9,7 @@
/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
// transform_width.hpp
// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
// (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)
@@ -29,7 +29,7 @@
#include <algorithm> // std::min
namespace boost {
namespace boost {
namespace archive {
namespace iterators {
@@ -37,12 +37,12 @@ namespace iterators {
// 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 Base,
int BitsOut,
int BitsIn,
class CharType = typename boost::iterator_value<Base>::type // output character
>
class transform_width :
class transform_width :
public boost::iterator_adaptor<
transform_width<Base, BitsOut, BitsIn, CharType>,
Base,
@@ -108,19 +108,19 @@ class transform_width :
public:
// make composible buy using templated constructor
template<class T>
transform_width(T start) :
transform_width(T start) :
super_t(Base(static_cast< T >(start))),
m_buffer_out_full(false),
m_buffer_out(0),
// To disable GCC warning, but not truly necessary
//(m_buffer_in will be initialized later before being
// 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_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) :
transform_width(const transform_width & rhs) :
super_t(rhs.base_reference()),
m_buffer_out_full(rhs.m_buffer_out_full),
m_buffer_out(rhs.m_buffer_out),
@@ -131,9 +131,9 @@ public:
};
template<
class Base,
int BitsOut,
int BitsIn,
class Base,
int BitsOut,
int BitsIn,
class CharType
>
void transform_width<Base, BitsOut, BitsIn, CharType>::fill() {

16
linx64/include/boost/archive/iterators/unescape.hpp
View File

@@ -9,7 +9,7 @@
/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
// unescape.hpp
// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
// (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)
@@ -21,7 +21,7 @@
#include <boost/iterator/iterator_adaptor.hpp>
#include <boost/pointee.hpp>
namespace boost {
namespace boost {
namespace archive {
namespace iterators {
@@ -29,10 +29,10 @@ namespace iterators {
// 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
class unescape
: public boost::iterator_adaptor<
unescape<Derived, Base>,
Base,
Base,
typename pointee<Base>::type,
single_pass_traversal_tag,
typename pointee<Base>::type
@@ -40,8 +40,8 @@ class unescape
{
friend class boost::iterator_core_access;
typedef typename boost::iterator_adaptor<
unescape<Derived, Base>,
Base,
unescape<Derived, Base>,
Base,
typename pointee<Base>::type,
single_pass_traversal_tag,
typename pointee<Base>::type
@@ -71,11 +71,11 @@ private:
++(this->base_reference());
dereference_impl();
m_full = false;
};
}
public:
unescape(Base base) :
unescape(Base base) :
super_t(base),
m_full(false)
{}

22
linx64/include/boost/archive/iterators/wchar_from_mb.hpp
View File

@@ -9,14 +9,13 @@
/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
// wchar_from_mb.hpp
// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
// (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
#ifndef BOOST_NO_CWCHAR
@@ -26,10 +25,12 @@
#include <boost/config.hpp>
#if defined(BOOST_NO_STDC_NAMESPACE)
namespace std{
namespace std{
using ::mbstate_t;
} // namespace std
#endif
#include <boost/assert.hpp>
#include <boost/core/ignore_unused.hpp>
#include <boost/array.hpp>
#include <boost/iterator/iterator_adaptor.hpp>
#include <boost/archive/detail/utf8_codecvt_facet.hpp>
@@ -38,7 +39,7 @@ namespace std{
#include <iostream>
namespace boost {
namespace boost {
namespace archive {
namespace iterators {
@@ -46,10 +47,10 @@ namespace iterators {
// 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
class wchar_from_mb
: public boost::iterator_adaptor<
wchar_from_mb<Base>,
Base,
wchar_from_mb<Base>,
Base,
wchar_t,
single_pass_traversal_tag,
wchar_t
@@ -57,8 +58,8 @@ class wchar_from_mb
{
friend class boost::iterator_core_access;
typedef typename boost::iterator_adaptor<
wchar_from_mb<Base>,
Base,
wchar_from_mb<Base>,
Base,
wchar_t,
single_pass_traversal_tag,
wchar_t
@@ -125,7 +126,7 @@ class wchar_from_mb
public:
// make composible buy using templated constructor
template<class T>
wchar_from_mb(T start) :
wchar_from_mb(T start) :
super_t(Base(static_cast< T >(start))),
m_mbs(std::mbstate_t())
{
@@ -165,6 +166,7 @@ void wchar_from_mb<Base>::drain(){
const typename boost::iterators::iterator_value<Base>::type * input_new_start;
typename iterator_value<this_t>::type * next_available;
BOOST_ATTRIBUTE_UNUSED // redundant with ignore_unused below but clarifies intention
std::codecvt_base::result r = m_codecvt_facet.in(
m_mbs,
m_input.m_buffer.begin(),

12
linx64/include/boost/archive/iterators/xml_escape.hpp
View File

@@ -9,7 +9,7 @@
/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
// xml_escape.hpp
// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
// (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)
@@ -19,7 +19,7 @@
#include <boost/assert.hpp>
#include <boost/archive/iterators/escape.hpp>
namespace boost {
namespace boost {
namespace archive {
namespace iterators {
@@ -27,7 +27,7 @@ namespace iterators {
// insert escapes into xml text
template<class Base>
class xml_escape
class xml_escape
: public escape<xml_escape<Base>, Base>
{
friend class boost::iterator_core_access;
@@ -43,14 +43,14 @@ public:
super_t(Base(static_cast< T >(start)))
{}
// intel 7.1 doesn't like default copy constructor
xml_escape(const xml_escape & rhs) :
xml_escape(const xml_escape & rhs) :
super_t(rhs.base_reference())
{}
};
template<class Base>
char xml_escape<Base>::fill(
const char * & bstart,
const char * & bstart,
const char * & bend
){
char current_value = * this->base_reference();
@@ -83,7 +83,7 @@ char xml_escape<Base>::fill(
template<class Base>
wchar_t xml_escape<Base>::fill(
const wchar_t * & bstart,
const wchar_t * & bstart,
const wchar_t * & bend
){
wchar_t current_value = * this->base_reference();

16
linx64/include/boost/archive/iterators/xml_unescape.hpp
View File

@@ -9,7 +9,7 @@
/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
// xml_unescape.hpp
// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
// (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)
@@ -25,14 +25,14 @@
#include <boost/archive/iterators/unescape.hpp>
#include <boost/archive/iterators/dataflow_exception.hpp>
namespace boost {
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
class xml_unescape
: public unescape<xml_unescape<Base>, Base>
{
friend class boost::iterator_core_access;
@@ -44,7 +44,7 @@ class xml_unescape
return unescape<xml_unescape<Base>, Base>::dereference();
}
public:
// msvc versions prior to 14.0 crash with and ICE
// msvc versions prior to 14.0 crash with and ICE
#if BOOST_WORKAROUND(BOOST_MSVC, < 1900)
typedef int value_type;
#else
@@ -55,11 +55,11 @@ public:
value_type drain();
template<class T>
xml_unescape(T start) :
xml_unescape(T start) :
super_t(Base(static_cast< T >(start)))
{}
// intel 7.1 doesn't like default copy constructor
xml_unescape(const xml_unescape & rhs) :
xml_unescape(const xml_unescape & rhs) :
super_t(rhs.base_reference())
{}
};
@@ -82,8 +82,8 @@ void xml_unescape<Base>::drain_residue(const char * literal){
// iterator refenence which would make subsequent iterator comparisons
// incorrect and thereby break the composiblity of iterators.
template<class Base>
typename xml_unescape<Base>::value_type
//int
typename xml_unescape<Base>::value_type
//int
xml_unescape<Base>::drain(){
value_type retval = * this->base_reference();
if('&' != retval){

2
linx64/include/boost/archive/iterators/xml_unescape_exception.hpp
View File

@@ -9,7 +9,7 @@
/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
// xml_unescape_exception.hpp:
// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
// (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)

9
linx64/include/boost/archive/polymorphic_binary_iarchive.hpp
View File

@@ -9,7 +9,7 @@
/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
// polymorphic_binary_iarchive.hpp
// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
// (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)
@@ -25,17 +25,17 @@
# pragma warning(disable : 4511 4512)
#endif
namespace boost {
namespace boost {
namespace archive {
class BOOST_SYMBOL_VISIBLE polymorphic_binary_iarchive :
class BOOST_SYMBOL_VISIBLE polymorphic_binary_iarchive :
public detail::polymorphic_iarchive_route<binary_iarchive>
{
public:
polymorphic_binary_iarchive(std::istream & is, unsigned int flags = 0) :
detail::polymorphic_iarchive_route<binary_iarchive>(is, flags)
{}
~polymorphic_binary_iarchive(){}
~polymorphic_binary_iarchive() BOOST_OVERRIDE {}
};
} // namespace archive
@@ -51,4 +51,3 @@ BOOST_SERIALIZATION_REGISTER_ARCHIVE(
)
#endif // BOOST_ARCHIVE_POLYMORPHIC_BINARY_IARCHIVE_HPP

7
linx64/include/boost/archive/polymorphic_binary_oarchive.hpp
View File

@@ -9,7 +9,7 @@
/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
// polymorphic_binary_oarchive.hpp
// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
// (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)
@@ -20,7 +20,7 @@
#include <boost/archive/binary_oarchive.hpp>
#include <boost/archive/detail/polymorphic_oarchive_route.hpp>
namespace boost {
namespace boost {
namespace archive {
class BOOST_SYMBOL_VISIBLE polymorphic_binary_oarchive :
@@ -30,7 +30,7 @@ public:
polymorphic_binary_oarchive(std::ostream & os, unsigned int flags = 0) :
detail::polymorphic_oarchive_route<binary_oarchive>(os, flags)
{}
~polymorphic_binary_oarchive(){}
~polymorphic_binary_oarchive() BOOST_OVERRIDE {}
};
} // namespace archive
@@ -42,4 +42,3 @@ BOOST_SERIALIZATION_REGISTER_ARCHIVE(
)
#endif // BOOST_ARCHIVE_POLYMORPHIC_BINARY_OARCHIVE_HPP

13
linx64/include/boost/archive/polymorphic_iarchive.hpp
View File

@@ -17,7 +17,7 @@
// See http://www.boost.org for updates, documentation, and revision history.
#include <cstddef> // std::size_t
#include <climits> // ULONG_MAX
#include <climits> // ULONG_MAX
#include <string>
#include <boost/config.hpp>
@@ -31,6 +31,7 @@ namespace std{
#include <boost/archive/detail/iserializer.hpp>
#include <boost/archive/detail/interface_iarchive.hpp>
#include <boost/serialization/library_version_type.hpp>
#include <boost/serialization/nvp.hpp>
#include <boost/archive/detail/register_archive.hpp>
@@ -116,11 +117,13 @@ public:
load_end(t.name());
}
protected:
virtual ~polymorphic_iarchive_impl(){};
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 void set_library_version(
boost::serialization::library_version_type archive_library_version
) = 0;
virtual boost::serialization::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(
@@ -156,7 +159,7 @@ class BOOST_SYMBOL_VISIBLE polymorphic_iarchive :
public polymorphic_iarchive_impl
{
public:
virtual ~polymorphic_iarchive(){};
~polymorphic_iarchive() BOOST_OVERRIDE {}
};
} // namespace archive

10
linx64/include/boost/archive/polymorphic_oarchive.hpp
View File

@@ -17,7 +17,7 @@
// See http://www.boost.org for updates, documentation, and revision history.
#include <cstddef> // size_t
#include <climits> // ULONG_MAX
#include <climits> // ULONG_MAX
#include <string>
#include <boost/config.hpp>
@@ -118,11 +118,11 @@ public:
save_end(t.name());
}
protected:
virtual ~polymorphic_oarchive_impl(){};
virtual ~polymorphic_oarchive_impl() {}
public:
// utility functions implemented by all legal archives
virtual unsigned int get_flags() const = 0;
virtual library_version_type get_library_version() const = 0;
virtual boost::serialization::library_version_type get_library_version() const = 0;
virtual void save_binary(const void * t, std::size_t size) = 0;
virtual void save_object(
@@ -136,11 +136,11 @@ public:
};
// note: preserve naming symmetry
class BOOST_SYMBOL_VISIBLE polymorphic_oarchive :
class BOOST_SYMBOL_VISIBLE polymorphic_oarchive :
public polymorphic_oarchive_impl
{
public:
virtual ~polymorphic_oarchive(){};
~polymorphic_oarchive() BOOST_OVERRIDE {}
};
} // namespace archive

9
linx64/include/boost/archive/polymorphic_text_iarchive.hpp
View File

@@ -9,7 +9,7 @@
/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
// polymorphic_text_iarchive.hpp
// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
// (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)
@@ -25,17 +25,17 @@
# pragma warning(disable : 4511 4512)
#endif
namespace boost {
namespace boost {
namespace archive {
class BOOST_SYMBOL_VISIBLE polymorphic_text_iarchive :
class BOOST_SYMBOL_VISIBLE polymorphic_text_iarchive :
public detail::polymorphic_iarchive_route<text_iarchive>
{
public:
polymorphic_text_iarchive(std::istream & is, unsigned int flags = 0) :
detail::polymorphic_iarchive_route<text_iarchive>(is, flags)
{}
~polymorphic_text_iarchive(){}
~polymorphic_text_iarchive() BOOST_OVERRIDE {}
};
} // namespace archive
@@ -51,4 +51,3 @@ BOOST_SERIALIZATION_REGISTER_ARCHIVE(
)
#endif // BOOST_ARCHIVE_POLYMORPHIC_TEXT_IARCHIVE_HPP

7
linx64/include/boost/archive/polymorphic_text_oarchive.hpp
View File

@@ -9,7 +9,7 @@
/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
// polymorphic_text_oarchive.hpp
// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
// (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)
@@ -20,7 +20,7 @@
#include <boost/archive/text_oarchive.hpp>
#include <boost/archive/detail/polymorphic_oarchive_route.hpp>
namespace boost {
namespace boost {
namespace archive {
class BOOST_SYMBOL_VISIBLE polymorphic_text_oarchive :
@@ -30,7 +30,7 @@ public:
polymorphic_text_oarchive(std::ostream & os, unsigned int flags = 0) :
detail::polymorphic_oarchive_route<text_oarchive>(os, flags)
{}
~polymorphic_text_oarchive(){}
~polymorphic_text_oarchive() BOOST_OVERRIDE {}
};
} // namespace archive
@@ -42,4 +42,3 @@ BOOST_SERIALIZATION_REGISTER_ARCHIVE(
)
#endif // BOOST_ARCHIVE_POLYMORPHIC_TEXT_OARCHIVE_HPP

9
linx64/include/boost/archive/polymorphic_text_wiarchive.hpp
View File

@@ -9,7 +9,7 @@
/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
// polymorphic_text_wiarchive.hpp
// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
// (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)
@@ -29,17 +29,17 @@
# pragma warning(disable : 4511 4512)
#endif
namespace boost {
namespace boost {
namespace archive {
class BOOST_SYMBOL_VISIBLE polymorphic_text_wiarchive :
class BOOST_SYMBOL_VISIBLE polymorphic_text_wiarchive :
public detail::polymorphic_iarchive_route<text_wiarchive>
{
public:
polymorphic_text_wiarchive(std::wistream & is, unsigned int flags = 0) :
detail::polymorphic_iarchive_route<text_wiarchive>(is, flags)
{}
~polymorphic_text_wiarchive(){}
~polymorphic_text_wiarchive() BOOST_OVERRIDE {}
};
} // namespace archive
@@ -56,4 +56,3 @@ BOOST_SERIALIZATION_REGISTER_ARCHIVE(
#endif // BOOST_NO_STD_WSTREAMBUF
#endif // BOOST_ARCHIVE_POLYMORPHIC_TEXT_WIARCHIVE_HPP

9
linx64/include/boost/archive/polymorphic_text_woarchive.hpp
View File

@@ -9,7 +9,7 @@
/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
// polymorphic_text_oarchive.hpp
// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
// (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)
@@ -24,7 +24,7 @@
#include <boost/archive/text_woarchive.hpp>
#include <boost/archive/detail/polymorphic_oarchive_route.hpp>
namespace boost {
namespace boost {
namespace archive {
class BOOST_SYMBOL_VISIBLE polymorphic_text_woarchive :
@@ -34,7 +34,7 @@ public:
polymorphic_text_woarchive(std::wostream & os, unsigned int flags = 0) :
detail::polymorphic_oarchive_route<text_woarchive>(os, flags)
{}
~polymorphic_text_woarchive(){}
~polymorphic_text_woarchive() BOOST_OVERRIDE {}
};
} // namespace archive
@@ -45,6 +45,5 @@ BOOST_SERIALIZATION_REGISTER_ARCHIVE(
boost::archive::polymorphic_text_woarchive
)
#endif // BOOST_NO_STD_WSTREAMBUF
#endif // BOOST_NO_STD_WSTREAMBUF
#endif // BOOST_ARCHIVE_POLYMORPHIC_TEXT_WOARCHIVE_HPP

9
linx64/include/boost/archive/polymorphic_xml_iarchive.hpp
View File

@@ -9,7 +9,7 @@
/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
// polymorphic_xml_iarchive.hpp
// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
// (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)
@@ -25,17 +25,17 @@
# pragma warning(disable : 4511 4512)
#endif
namespace boost {
namespace boost {
namespace archive {
class BOOST_SYMBOL_VISIBLE polymorphic_xml_iarchive :
class BOOST_SYMBOL_VISIBLE polymorphic_xml_iarchive :
public detail::polymorphic_iarchive_route<xml_iarchive>
{
public:
polymorphic_xml_iarchive(std::istream & is, unsigned int flags = 0) :
detail::polymorphic_iarchive_route<xml_iarchive>(is, flags)
{}
~polymorphic_xml_iarchive(){}
~polymorphic_xml_iarchive() BOOST_OVERRIDE {}
};
} // namespace archive
@@ -51,4 +51,3 @@ BOOST_SERIALIZATION_REGISTER_ARCHIVE(
)
#endif // BOOST_ARCHIVE_POLYMORPHIC_XML_IARCHIVE_HPP

7
linx64/include/boost/archive/polymorphic_xml_oarchive.hpp
View File

@@ -9,7 +9,7 @@
/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
// polymorphic_xml_oarchive.hpp
// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
// (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)
@@ -20,7 +20,7 @@
#include <boost/archive/xml_oarchive.hpp>
#include <boost/archive/detail/polymorphic_oarchive_route.hpp>
namespace boost {
namespace boost {
namespace archive {
class BOOST_SYMBOL_VISIBLE polymorphic_xml_oarchive :
@@ -30,7 +30,7 @@ public:
polymorphic_xml_oarchive(std::ostream & os, unsigned int flags = 0) :
detail::polymorphic_oarchive_route<xml_oarchive>(os, flags)
{}
~polymorphic_xml_oarchive(){}
~polymorphic_xml_oarchive() BOOST_OVERRIDE {}
};
} // namespace archive
} // namespace boost
@@ -41,4 +41,3 @@ BOOST_SERIALIZATION_REGISTER_ARCHIVE(
)
#endif // BOOST_ARCHIVE_POLYMORPHIC_XML_OARCHIVE_HPP

11
linx64/include/boost/archive/polymorphic_xml_wiarchive.hpp
View File

@@ -9,7 +9,7 @@
/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
// polymorphic_xml_wiarchive.hpp
// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
// (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)
@@ -24,17 +24,17 @@
#include <boost/archive/xml_wiarchive.hpp>
#include <boost/archive/detail/polymorphic_iarchive_route.hpp>
namespace boost {
namespace boost {
namespace archive {
class BOOST_SYMBOL_VISIBLE polymorphic_xml_wiarchive :
class BOOST_SYMBOL_VISIBLE polymorphic_xml_wiarchive :
public detail::polymorphic_iarchive_route<xml_wiarchive>
{
public:
polymorphic_xml_wiarchive(std::wistream & is, unsigned int flags = 0) :
detail::polymorphic_iarchive_route<xml_wiarchive>(is, flags)
{}
~polymorphic_xml_wiarchive(){}
~polymorphic_xml_wiarchive() BOOST_OVERRIDE {}
};
} // namespace archive
@@ -45,6 +45,5 @@ BOOST_SERIALIZATION_REGISTER_ARCHIVE(
boost::archive::polymorphic_xml_wiarchive
)
#endif // BOOST_NO_STD_WSTREAMBUF
#endif // BOOST_NO_STD_WSTREAMBUF
#endif // BOOST_ARCHIVE_POLYMORPHIC_XML_WIARCHIVE_HPP

7
linx64/include/boost/archive/polymorphic_xml_woarchive.hpp
View File

@@ -9,7 +9,7 @@
/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
// polymorphic_xml_woarchive.hpp
// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
// (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)
@@ -24,7 +24,7 @@
#include <boost/archive/xml_woarchive.hpp>
#include <boost/archive/detail/polymorphic_oarchive_route.hpp>
namespace boost {
namespace boost {
namespace archive {
class BOOST_SYMBOL_VISIBLE polymorphic_xml_woarchive :
@@ -34,7 +34,7 @@ public:
polymorphic_xml_woarchive(std::wostream & os, unsigned int flags = 0) :
detail::polymorphic_oarchive_route<xml_woarchive>(os, flags)
{}
~polymorphic_xml_woarchive(){}
~polymorphic_xml_woarchive() BOOST_OVERRIDE {}
};
} // namespace archive
@@ -47,4 +47,3 @@ BOOST_SERIALIZATION_REGISTER_ARCHIVE(
#endif // BOOST_NO_STD_WSTREAMBUF
#endif // BOOST_ARCHIVE_POLYMORPHIC_XML_WOARCHIVE_HPP

29
linx64/include/boost/archive/text_iarchive.hpp
View File

@@ -9,7 +9,7 @@
/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
// text_iarchive.hpp
// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
// (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)
@@ -32,7 +32,7 @@
# pragma warning(disable : 4511 4512)
#endif
namespace boost {
namespace boost {
namespace archive {
namespace detail {
@@ -65,16 +65,16 @@ protected:
load(v);
t = boost::serialization::item_version_type(v);
}
BOOST_ARCHIVE_DECL void
BOOST_ARCHIVE_DECL void
load(char * t);
#ifndef BOOST_NO_INTRINSIC_WCHAR_T
BOOST_ARCHIVE_DECL void
BOOST_ARCHIVE_DECL void
load(wchar_t * t);
#endif
BOOST_ARCHIVE_DECL void
BOOST_ARCHIVE_DECL void
load(std::string &s);
#ifndef BOOST_NO_STD_WSTRING
BOOST_ARCHIVE_DECL void
BOOST_ARCHIVE_DECL void
load(std::wstring &ws);
#endif
template<class T>
@@ -85,11 +85,11 @@ protected:
load_override(class_name_type & t);
BOOST_ARCHIVE_DECL void
init();
BOOST_ARCHIVE_DECL
BOOST_ARCHIVE_DECL
text_iarchive_impl(std::istream & is, unsigned int flags);
// don't import inline definitions! leave this as a reminder.
//BOOST_ARCHIVE_DECL
~text_iarchive_impl(){};
//BOOST_ARCHIVE_DECL
~text_iarchive_impl() BOOST_OVERRIDE {}
};
} // namespace archive
@@ -106,17 +106,20 @@ protected:
# pragma warning(disable : 4511 4512)
#endif
namespace boost {
namespace boost {
namespace archive {
class BOOST_SYMBOL_VISIBLE text_iarchive :
class BOOST_SYMBOL_VISIBLE text_iarchive :
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(){}
{
if(0 == (flags & no_header))
init();
}
~text_iarchive() BOOST_OVERRIDE {}
};
} // namespace archive

35
linx64/include/boost/archive/text_oarchive.hpp
View File

@@ -9,7 +9,7 @@
/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
// text_oarchive.hpp
// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
// (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)
@@ -21,8 +21,8 @@
#include <boost/config.hpp>
#if defined(BOOST_NO_STDC_NAMESPACE)
namespace std{
using ::size_t;
namespace std{
using ::size_t;
} // namespace std
#endif
@@ -39,7 +39,7 @@ namespace std{
# pragma warning(disable : 4511 4512)
#endif
namespace boost {
namespace boost {
namespace archive {
namespace detail {
@@ -70,40 +70,43 @@ protected:
void save(const boost::serialization::item_version_type & t){
save(static_cast<unsigned int>(t));
}
BOOST_ARCHIVE_DECL void
BOOST_ARCHIVE_DECL void
save(const char * t);
#ifndef BOOST_NO_INTRINSIC_WCHAR_T
BOOST_ARCHIVE_DECL void
BOOST_ARCHIVE_DECL void
save(const wchar_t * t);
#endif
BOOST_ARCHIVE_DECL void
BOOST_ARCHIVE_DECL void
save(const std::string &s);
#ifndef BOOST_NO_STD_WSTRING
BOOST_ARCHIVE_DECL void
BOOST_ARCHIVE_DECL void
save(const std::wstring &ws);
#endif
BOOST_ARCHIVE_DECL
BOOST_ARCHIVE_DECL
text_oarchive_impl(std::ostream & os, unsigned int flags);
// don't import inline definitions! leave this as a reminder.
//BOOST_ARCHIVE_DECL
~text_oarchive_impl(){};
//BOOST_ARCHIVE_DECL
~text_oarchive_impl() BOOST_OVERRIDE {}
public:
BOOST_ARCHIVE_DECL void
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
// via inheritance, derived from text_oarchive_impl instead. This will
// preserve correct static polymorphism.
class BOOST_SYMBOL_VISIBLE text_oarchive :
class BOOST_SYMBOL_VISIBLE 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(){}
{
if(0 == (flags & no_header))
init();
}
~text_oarchive() BOOST_OVERRIDE {}
};
} // namespace archive

19
linx64/include/boost/archive/text_wiarchive.hpp
View File

@@ -9,7 +9,7 @@
/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
// text_wiarchive.hpp
// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
// (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)
@@ -36,7 +36,7 @@
# pragma warning(disable : 4511 4512)
#endif
namespace boost {
namespace boost {
namespace archive {
namespace detail {
@@ -92,9 +92,9 @@ protected:
void load_override(T & t){
basic_text_iarchive<Archive>::load_override(t);
}
BOOST_WARCHIVE_DECL
BOOST_WARCHIVE_DECL
text_wiarchive_impl(std::wistream & is, unsigned int flags);
~text_wiarchive_impl(){};
~text_wiarchive_impl() BOOST_OVERRIDE {}
};
} // namespace archive
@@ -111,16 +111,19 @@ protected:
# pragma warning(disable : 4511 4512)
#endif
namespace boost {
namespace boost {
namespace archive {
class BOOST_SYMBOL_VISIBLE text_wiarchive :
class BOOST_SYMBOL_VISIBLE text_wiarchive :
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(){}
{
if(0 == (flags & no_header))
init();
}
~text_wiarchive() BOOST_OVERRIDE {}
};
} // namespace archive

28
linx64/include/boost/archive/text_woarchive.hpp
View File

@@ -9,7 +9,7 @@
/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
// text_woarchive.hpp
// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
// (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)
@@ -26,8 +26,8 @@
#include <cstddef> // size_t
#if defined(BOOST_NO_STDC_NAMESPACE)
namespace std{
using ::size_t;
namespace std{
using ::size_t;
} // namespace std
#endif
@@ -44,7 +44,7 @@ namespace std{
# pragma warning(disable : 4511 4512)
#endif
namespace boost {
namespace boost {
namespace archive {
namespace detail {
@@ -97,14 +97,11 @@ protected:
#endif
text_woarchive_impl(std::wostream & os, unsigned int flags) :
basic_text_oprimitive<std::wostream>(
os,
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'));
@@ -114,7 +111,7 @@ public:
#else
this->basic_text_oprimitive::save_binary(
#endif
address,
address,
count
);
put(static_cast<wchar_t>('\n'));
@@ -127,16 +124,19 @@ public:
// 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
// via inheritance, derived from text_oarchive_impl instead. This will
// preserve correct static polymorphism.
class BOOST_SYMBOL_VISIBLE text_woarchive :
class BOOST_SYMBOL_VISIBLE 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(){}
{
if(0 == (flags & no_header))
init();
}
~text_woarchive() BOOST_OVERRIDE {}
};
} // namespace archive

3
linx64/include/boost/archive/tmpdir.hpp
View File

@@ -9,7 +9,7 @@
/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
// tmpdir.hpp:
// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
// (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)
@@ -18,7 +18,6 @@
#include <cstdlib> // getenv
#include <cstddef> // NULL
//#include <boost/assert.hpp>
#include <boost/config.hpp>
#ifdef BOOST_NO_STDC_NAMESPACE

8
linx64/include/boost/archive/wcslen.hpp
View File

@@ -9,7 +9,7 @@
/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
// wcslen.hpp:
// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
// (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)
@@ -19,8 +19,8 @@
#include <cstddef> // size_t
#include <boost/config.hpp>
#if defined(BOOST_NO_STDC_NAMESPACE)
namespace std{
using ::size_t;
namespace std{
using ::size_t;
} // namespace std
#endif
@@ -30,7 +30,7 @@ namespace std{
// wcslen
#if defined(BOOST_DINKUMWARE_STDLIB) && BOOST_DINKUMWARE_STDLIB < 306 \
|| defined(__LIBCOMO__)
|| defined(__LIBCOMO__)
namespace std {
inline std::size_t wcslen(const wchar_t * ws)

12
linx64/include/boost/archive/xml_archive_exception.hpp
View File

@@ -9,7 +9,7 @@
/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
// xml_archive_exception.hpp:
// (C) Copyright 2007 Robert Ramey - http://www.rrsd.com .
// (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)
@@ -19,7 +19,7 @@
#include <exception>
#include <boost/assert.hpp>
#include <boost/config.hpp>
#include <boost/config.hpp>
#include <boost/archive/detail/decl.hpp>
#include <boost/archive/archive_exception.hpp>
@@ -31,7 +31,7 @@ namespace archive {
//////////////////////////////////////////////////////////////////////
// exceptions thrown by xml archives
//
class BOOST_SYMBOL_VISIBLE xml_archive_exception :
class BOOST_SYMBOL_VISIBLE xml_archive_exception :
public virtual boost::archive::archive_exception
{
public:
@@ -41,12 +41,12 @@ public:
xml_archive_tag_name_error
} exception_code;
BOOST_ARCHIVE_DECL xml_archive_exception(
exception_code c,
exception_code c,
const char * e1 = NULL,
const char * e2 = NULL
);
BOOST_ARCHIVE_DECL xml_archive_exception(xml_archive_exception const &) ;
virtual BOOST_ARCHIVE_DECL ~xml_archive_exception() BOOST_NOEXCEPT_OR_NOTHROW ;
BOOST_ARCHIVE_DECL xml_archive_exception(xml_archive_exception const &);
BOOST_ARCHIVE_DECL ~xml_archive_exception() BOOST_NOEXCEPT_OR_NOTHROW BOOST_OVERRIDE;
};
}// namespace archive

25
linx64/include/boost/archive/xml_iarchive.hpp
View File

@@ -9,7 +9,7 @@
/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
// xml_iarchive.hpp
// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
// (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)
@@ -32,7 +32,7 @@
# pragma warning(disable : 4511 4512)
#endif
namespace boost {
namespace boost {
namespace archive {
namespace detail {
@@ -44,7 +44,7 @@ class basic_xml_grammar;
typedef basic_xml_grammar<char> xml_grammar;
template<class Archive>
class BOOST_SYMBOL_VISIBLE xml_iarchive_impl :
class BOOST_SYMBOL_VISIBLE xml_iarchive_impl :
public basic_text_iprimitive<std::istream>,
public basic_xml_iarchive<Archive>
{
@@ -66,13 +66,13 @@ protected:
void load(T & t){
basic_text_iprimitive<std::istream>::load(t);
}
void
void
load(version_type & t){
unsigned int v;
load(v);
t = version_type(v);
}
void
void
load(boost::serialization::item_version_type & t){
unsigned int v;
load(v);
@@ -98,10 +98,10 @@ protected:
load_override(class_name_type & t);
BOOST_ARCHIVE_DECL void
init();
BOOST_ARCHIVE_DECL
BOOST_ARCHIVE_DECL
xml_iarchive_impl(std::istream & is, unsigned int flags);
BOOST_ARCHIVE_DECL
~xml_iarchive_impl();
~xml_iarchive_impl() BOOST_OVERRIDE;
};
} // namespace archive
@@ -117,16 +117,19 @@ protected:
# pragma warning(disable : 4511 4512)
#endif
namespace boost {
namespace boost {
namespace archive {
class BOOST_SYMBOL_VISIBLE xml_iarchive :
class BOOST_SYMBOL_VISIBLE xml_iarchive :
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(){};
{
if(0 == (flags & no_header))
init();
}
~xml_iarchive() BOOST_OVERRIDE {}
};
} // namespace archive

33
linx64/include/boost/archive/xml_oarchive.hpp
View File

@@ -9,7 +9,7 @@
/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
// xml_oarchive.hpp
// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
// (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)
@@ -21,8 +21,8 @@
#include <cstddef> // size_t
#include <boost/config.hpp>
#if defined(BOOST_NO_STDC_NAMESPACE)
namespace std{
using ::size_t;
namespace std{
using ::size_t;
} // namespace std
#endif
@@ -47,7 +47,7 @@ namespace detail {
} // namespace detail
template<class Archive>
class BOOST_SYMBOL_VISIBLE xml_oarchive_impl :
class BOOST_SYMBOL_VISIBLE xml_oarchive_impl :
public basic_text_oprimitive<std::ostream>,
public basic_xml_oarchive<Archive>
{
@@ -63,15 +63,15 @@ protected:
void save(const T & t){
basic_text_oprimitive<std::ostream>::save(t);
}
void
void
save(const version_type & t){
save(static_cast<unsigned int>(t));
}
void
void
save(const boost::serialization::item_version_type & t){
save(static_cast<unsigned int>(t));
}
BOOST_ARCHIVE_DECL void
BOOST_ARCHIVE_DECL void
save(const char * t);
#ifndef BOOST_NO_INTRINSIC_WCHAR_T
BOOST_ARCHIVE_DECL void
@@ -83,10 +83,10 @@ protected:
BOOST_ARCHIVE_DECL void
save(const std::wstring &ws);
#endif
BOOST_ARCHIVE_DECL
BOOST_ARCHIVE_DECL
xml_oarchive_impl(std::ostream & os, unsigned int flags);
BOOST_ARCHIVE_DECL
~xml_oarchive_impl();
BOOST_ARCHIVE_DECL
~xml_oarchive_impl() BOOST_OVERRIDE;
public:
BOOST_ARCHIVE_DECL
void save_binary(const void *address, std::size_t count);
@@ -105,23 +105,26 @@ public:
# pragma warning(disable : 4511 4512)
#endif
namespace boost {
namespace boost {
namespace archive {
// 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
// via inheritance, derived from xml_oarchive_impl instead. This will
// preserve correct static polymorphism.
class BOOST_SYMBOL_VISIBLE xml_oarchive :
class BOOST_SYMBOL_VISIBLE 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(){}
{
if(0 == (flags & no_header))
init();
}
~xml_oarchive() BOOST_OVERRIDE {}
};
} // namespace archive

32
linx64/include/boost/archive/xml_wiarchive.hpp
View File

@@ -9,7 +9,7 @@
/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
// xml_wiarchive.hpp
// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
// (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)
@@ -29,7 +29,6 @@
#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/utf8_codecvt_facet.hpp>
#include <boost/archive/detail/abi_prefix.hpp> // must be the last header
@@ -50,7 +49,7 @@ class basic_xml_grammar;
typedef basic_xml_grammar<wchar_t> xml_wgrammar;
template<class Archive>
class BOOST_SYMBOL_VISIBLE xml_wiarchive_impl :
class BOOST_SYMBOL_VISIBLE xml_wiarchive_impl :
public basic_text_iprimitive<std::wistream>,
public basic_xml_iarchive<Archive>
{
@@ -68,17 +67,17 @@ protected:
return is;
}
template<class T>
void
void
load(T & t){
basic_text_iprimitive<std::wistream>::load(t);
}
void
void
load(version_type & t){
unsigned int v;
load(v);
t = version_type(v);
}
void
void
load(boost::serialization::item_version_type & t){
unsigned int v;
load(v);
@@ -102,19 +101,19 @@ protected:
}
BOOST_WARCHIVE_DECL void
load_override(class_name_type & t);
BOOST_WARCHIVE_DECL void
BOOST_WARCHIVE_DECL void
init();
BOOST_WARCHIVE_DECL
xml_wiarchive_impl(std::wistream & is, unsigned int flags) ;
BOOST_WARCHIVE_DECL
~xml_wiarchive_impl();
BOOST_WARCHIVE_DECL
xml_wiarchive_impl(std::wistream & is, unsigned int flags);
BOOST_WARCHIVE_DECL
~xml_wiarchive_impl() BOOST_OVERRIDE;
};
} // namespace archive
} // namespace boost
#ifdef BOOST_MSVC
# pragma warning(pop)
# pragma warning(pop)
#endif
#include <boost/archive/detail/abi_suffix.hpp> // pops abi_suffix.hpp pragmas
@@ -124,7 +123,7 @@ protected:
# pragma warning(disable : 4511 4512)
#endif
namespace boost {
namespace boost {
namespace archive {
class BOOST_SYMBOL_VISIBLE xml_wiarchive :
@@ -132,8 +131,11 @@ class BOOST_SYMBOL_VISIBLE xml_wiarchive :
public:
xml_wiarchive(std::wistream & is, unsigned int flags = 0) :
xml_wiarchive_impl<xml_wiarchive>(is, flags)
{}
~xml_wiarchive(){}
{
if(0 == (flags & no_header))
init();
}
~xml_wiarchive() BOOST_OVERRIDE {}
};
} // namespace archive

Some files were not shown because too many files have changed in this diff Show More