bring in skeleton for eagle_plugin and update boost for use of RapidXML within property_tree
This commit is contained in:
Dick Hollenbeck
parent
ffd57d88d7
commit
ab001b902a
|
|
@ -0,0 +1,55 @@
|
|||
#ifndef BOOST_ARCHIVE_ADD_FACET_HPP
|
||||
#define BOOST_ARCHIVE_ADD_FACET_HPP
|
||||
|
||||
// MS compatible compilers support #pragma once
|
||||
#if defined(_MSC_VER) && (_MSC_VER >= 1020)
|
||||
# pragma once
|
||||
#endif
|
||||
|
||||
/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
|
||||
// add_facet.hpp
|
||||
|
||||
// (C) Copyright 2003 Robert Ramey - http://www.rrsd.com .
|
||||
// Use, modification and distribution is subject to the Boost Software
|
||||
// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
// See http://www.boost.org for updates, documentation, and revision history.
|
||||
|
||||
#include <locale>
|
||||
#include <boost/config.hpp>
|
||||
#include <boost/detail/workaround.hpp>
|
||||
|
||||
// does STLport uses native STL for locales?
|
||||
#if (defined(__SGI_STL_PORT)&& defined(_STLP_NO_OWN_IOSTREAMS))
|
||||
// and this native STL lib is old Dinkumware (has not defined _CPPLIB_VER)
|
||||
# if (defined(_YVALS) && !defined(__IBMCPP__)) || !defined(_CPPLIB_VER)
|
||||
# define BOOST_ARCHIVE_OLD_DINKUMWARE_BENEATH_STLPORT
|
||||
# endif
|
||||
#endif
|
||||
|
||||
namespace boost {
|
||||
namespace archive {
|
||||
|
||||
template<class Facet>
|
||||
inline std::locale *
|
||||
add_facet(const std::locale &l, Facet * f){
|
||||
return
|
||||
#if defined BOOST_ARCHIVE_OLD_DINKUMWARE_BENEATH_STLPORT
|
||||
// std namespace used for native locale
|
||||
new std::locale(std::_Addfac(l, f));
|
||||
#elif BOOST_WORKAROUND(BOOST_DINKUMWARE_STDLIB, == 1) // old Dinkumwar
|
||||
// std namespace used for native locale
|
||||
new std::locale(std::_Addfac(l, f));
|
||||
#else
|
||||
// standard compatible
|
||||
new std::locale(l, f);
|
||||
#endif
|
||||
}
|
||||
|
||||
} // namespace archive
|
||||
} // namespace boost
|
||||
|
||||
#undef BOOST_ARCHIVE_OLD_DINKUMWARE_BENEATH_STLPORT
|
||||
|
||||
#endif // BOOST_ARCHIVE_ADD_FACET_HPP
|
||||
|
|
@ -0,0 +1,97 @@
|
|||
#ifndef BOOST_ARCHIVE_ARCHIVE_EXCEPTION_HPP
|
||||
#define BOOST_ARCHIVE_ARCHIVE_EXCEPTION_HPP
|
||||
|
||||
// MS compatible compilers support #pragma once
|
||||
#if defined(_MSC_VER) && (_MSC_VER >= 1020)
|
||||
# pragma once
|
||||
#endif
|
||||
|
||||
/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
|
||||
// archive/archive_exception.hpp:
|
||||
|
||||
// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
|
||||
// Use, modification and distribution is subject to the Boost Software
|
||||
// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
// See http://www.boost.org for updates, documentation, and revision history.
|
||||
|
||||
#include <exception>
|
||||
#include <boost/assert.hpp>
|
||||
#include <string>
|
||||
|
||||
#include <boost/config.hpp>
|
||||
#include <boost/preprocessor/empty.hpp>
|
||||
#include <boost/archive/detail/decl.hpp>
|
||||
|
||||
// note: the only reason this is in here is that windows header
|
||||
// includes #define exception_code _exception_code (arrrgghhhh!).
|
||||
// the most expedient way to address this is be sure that this
|
||||
// header is always included whenever this header file is included.
|
||||
#if defined(BOOST_WINDOWS)
|
||||
#include <excpt.h>
|
||||
#endif
|
||||
|
||||
#include <boost/archive/detail/abi_prefix.hpp> // must be the last header
|
||||
|
||||
namespace boost {
|
||||
namespace archive {
|
||||
|
||||
//////////////////////////////////////////////////////////////////////
|
||||
// exceptions thrown by archives
|
||||
//
|
||||
class BOOST_ARCHIVE_DECL(BOOST_PP_EMPTY()) archive_exception :
|
||||
public virtual std::exception
|
||||
{
|
||||
public:
|
||||
typedef enum {
|
||||
no_exception, // initialized without code
|
||||
other_exception, // any excepton not listed below
|
||||
unregistered_class, // attempt to serialize a pointer of an
|
||||
// an unregistered class
|
||||
invalid_signature, // first line of archive does not contain
|
||||
// expected string
|
||||
unsupported_version,// archive created with library version
|
||||
// subsequent to this one
|
||||
pointer_conflict, // an attempt has been made to directly
|
||||
// serialize an object which has
|
||||
// already been serialzed through a pointer.
|
||||
// Were this permited, the archive load would result
|
||||
// in the creation of an extra copy of the obect.
|
||||
incompatible_native_format, // attempt to read native binary format
|
||||
// on incompatible platform
|
||||
array_size_too_short,// array being loaded doesn't fit in array allocated
|
||||
input_stream_error, // error on input stream
|
||||
invalid_class_name, // class name greater than the maximum permitted.
|
||||
// most likely a corrupted archive or an attempt
|
||||
// to insert virus via buffer overrun method.
|
||||
unregistered_cast, // base - derived relationship not registered with
|
||||
// void_cast_register
|
||||
unsupported_class_version, // type saved with a version # greater than the
|
||||
// one used by the program. This indicates that the proggram
|
||||
// needs to be rebuilt.
|
||||
multiple_code_instantiation, // code for implementing serialization for some
|
||||
// type has been instantiated in more than one module.
|
||||
output_stream_error // error on input stream
|
||||
} exception_code;
|
||||
protected:
|
||||
std::string m_msg;
|
||||
public:
|
||||
exception_code code;
|
||||
archive_exception(
|
||||
exception_code c,
|
||||
const char * e1 = NULL,
|
||||
const char * e2 = NULL
|
||||
);
|
||||
~archive_exception() throw ();
|
||||
virtual const char *what( ) const throw();
|
||||
protected:
|
||||
archive_exception();
|
||||
};
|
||||
|
||||
}// namespace archive
|
||||
}// namespace boost
|
||||
|
||||
#include <boost/archive/detail/abi_suffix.hpp> // pops abi_suffix.hpp pragmas
|
||||
|
||||
#endif //BOOST_ARCHIVE_ARCHIVE_EXCEPTION_HPP
|
||||
|
|
@ -0,0 +1,300 @@
|
|||
#ifndef BOOST_ARCHIVE_BASIC_ARCHIVE_HPP
|
||||
#define BOOST_ARCHIVE_BASIC_ARCHIVE_HPP
|
||||
|
||||
// MS compatible compilers support #pragma once
|
||||
#if defined(_MSC_VER) && (_MSC_VER >= 1020)
|
||||
# pragma once
|
||||
#endif
|
||||
|
||||
/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
|
||||
// basic_archive.hpp:
|
||||
|
||||
// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
|
||||
// Use, modification and distribution is subject to the Boost Software
|
||||
// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
// See http://www.boost.org for updates, documentation, and revision history.
|
||||
|
||||
#include <boost/assert.hpp>
|
||||
#include <boost/config.hpp>
|
||||
#include <boost/cstdint.hpp> // size_t
|
||||
#include <boost/noncopyable.hpp>
|
||||
#include <boost/integer_traits.hpp>
|
||||
|
||||
#include <boost/archive/detail/auto_link_archive.hpp>
|
||||
#include <boost/archive/detail/abi_prefix.hpp> // must be the last header
|
||||
|
||||
namespace boost {
|
||||
namespace archive {
|
||||
|
||||
#if defined(_MSC_VER)
|
||||
#pragma warning( push )
|
||||
#pragma warning( disable : 4244 4267 )
|
||||
#endif
|
||||
|
||||
/* NOTE : Warning : Warning : Warning : Warning : Warning
|
||||
* Don't ever changes this. If you do, they previously created
|
||||
* binary archives won't be readable !!!
|
||||
*/
|
||||
class library_version_type {
|
||||
private:
|
||||
typedef uint_least16_t base_type;
|
||||
base_type t;
|
||||
public:
|
||||
library_version_type(): t(0) {};
|
||||
explicit library_version_type(const unsigned int & t_) : t(t_){
|
||||
BOOST_ASSERT(t_ <= boost::integer_traits<base_type>::const_max);
|
||||
}
|
||||
library_version_type(const library_version_type & t_) :
|
||||
t(t_.t)
|
||||
{}
|
||||
library_version_type & operator=(const library_version_type & rhs){
|
||||
t = rhs.t;
|
||||
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_VERSION();
|
||||
|
||||
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) {};
|
||||
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_) :
|
||||
t(t_.t)
|
||||
{}
|
||||
version_type & operator=(const version_type & rhs){
|
||||
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 {
|
||||
private:
|
||||
typedef int_least16_t base_type;
|
||||
base_type t;
|
||||
public:
|
||||
// should be private - but then can't use BOOST_STRONG_TYPE below
|
||||
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_) :
|
||||
t(t_.t)
|
||||
{}
|
||||
class_id_type & operator=(const class_id_type & rhs){
|
||||
t = rhs.t;
|
||||
return *this;
|
||||
}
|
||||
|
||||
// used for text output
|
||||
operator int () const {
|
||||
return t;
|
||||
}
|
||||
// used for text input
|
||||
operator int_least16_t &() {
|
||||
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)
|
||||
|
||||
class object_id_type {
|
||||
private:
|
||||
typedef uint_least32_t base_type;
|
||||
base_type t;
|
||||
public:
|
||||
object_id_type(): t(0) {};
|
||||
explicit object_id_type(const unsigned int & t_) : t(t_){
|
||||
BOOST_ASSERT(t_ <= boost::integer_traits<base_type>::const_max);
|
||||
}
|
||||
object_id_type(const object_id_type & t_) :
|
||||
t(t_.t)
|
||||
{}
|
||||
object_id_type & operator=(const object_id_type & rhs){
|
||||
t = rhs.t;
|
||||
return *this;
|
||||
}
|
||||
// used for text output
|
||||
operator uint_least32_t () const {
|
||||
return t;
|
||||
}
|
||||
// used for text input
|
||||
operator uint_least32_t & () {
|
||||
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)
|
||||
#pragma warning( pop )
|
||||
#endif
|
||||
|
||||
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;
|
||||
}
|
||||
bool operator==(const tracking_type & rhs) const {
|
||||
return t == rhs.t;
|
||||
}
|
||||
bool operator==(const bool & rhs) const {
|
||||
return t == rhs;
|
||||
}
|
||||
tracking_type & operator=(const tracking_type & rhs){
|
||||
t = rhs.t;
|
||||
return *this;
|
||||
}
|
||||
};
|
||||
|
||||
struct class_name_type :
|
||||
private boost::noncopyable
|
||||
{
|
||||
char *t;
|
||||
operator const char * & () const {
|
||||
return const_cast<const char * &>(t);
|
||||
}
|
||||
operator char * () {
|
||||
return t;
|
||||
}
|
||||
explicit class_name_type(const char *key_)
|
||||
: t(const_cast<char *>(key_)){}
|
||||
explicit class_name_type(char *key_)
|
||||
: t(key_){}
|
||||
class_name_type & operator=(const class_name_type & rhs){
|
||||
t = rhs.t;
|
||||
return *this;
|
||||
}
|
||||
};
|
||||
|
||||
enum archive_flags {
|
||||
no_header = 1, // suppress archive header info
|
||||
no_codecvt = 2, // suppress alteration of codecvt facet
|
||||
no_xml_tag_checking = 4, // suppress checking of xml tags
|
||||
no_tracking = 8, // suppress ALL tracking
|
||||
flags_last = 8
|
||||
};
|
||||
|
||||
BOOST_ARCHIVE_DECL(const char *)
|
||||
BOOST_ARCHIVE_SIGNATURE();
|
||||
|
||||
/* NOTE : Warning : Warning : Warning : Warning : Warning
|
||||
* If any of these are changed to different sized types,
|
||||
* binary_iarchive won't be able to read older archives
|
||||
* unless you rev the library version and include conditional
|
||||
* code based on the library version. There is nothing
|
||||
* inherently wrong in doing this - but you have to be super
|
||||
* careful because it's easy to get wrong and start breaking
|
||||
* old archives !!!
|
||||
*/
|
||||
|
||||
#define BOOST_ARCHIVE_STRONG_TYPEDEF(T, D) \
|
||||
class D : public T { \
|
||||
public: \
|
||||
explicit D(const T tt) : T(tt){} \
|
||||
}; \
|
||||
/**/
|
||||
|
||||
BOOST_ARCHIVE_STRONG_TYPEDEF(class_id_type, class_id_reference_type)
|
||||
BOOST_ARCHIVE_STRONG_TYPEDEF(class_id_type, class_id_optional_type)
|
||||
BOOST_ARCHIVE_STRONG_TYPEDEF(object_id_type, object_reference_type)
|
||||
|
||||
}// namespace archive
|
||||
}// namespace boost
|
||||
|
||||
#include <boost/archive/detail/abi_suffix.hpp> // pops abi_suffix.hpp pragmas
|
||||
|
||||
#include <boost/serialization/level.hpp>
|
||||
|
||||
// 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::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)
|
||||
BOOST_CLASS_IMPLEMENTATION(boost::archive::class_id_optional_type, primitive_type)
|
||||
BOOST_CLASS_IMPLEMENTATION(boost::archive::class_name_type, primitive_type)
|
||||
BOOST_CLASS_IMPLEMENTATION(boost::archive::object_id_type, primitive_type)
|
||||
BOOST_CLASS_IMPLEMENTATION(boost::archive::object_reference_type, primitive_type)
|
||||
BOOST_CLASS_IMPLEMENTATION(boost::archive::tracking_type, primitive_type)
|
||||
|
||||
#include <boost/serialization/is_bitwise_serializable.hpp>
|
||||
|
||||
// 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::archive::version_type)
|
||||
BOOST_IS_BITWISE_SERIALIZABLE(boost::archive::class_id_type)
|
||||
BOOST_IS_BITWISE_SERIALIZABLE(boost::archive::class_id_reference_type)
|
||||
BOOST_IS_BITWISE_SERIALIZABLE(boost::archive::class_id_optional_type)
|
||||
BOOST_IS_BITWISE_SERIALIZABLE(boost::archive::class_name_type)
|
||||
BOOST_IS_BITWISE_SERIALIZABLE(boost::archive::object_id_type)
|
||||
BOOST_IS_BITWISE_SERIALIZABLE(boost::archive::object_reference_type)
|
||||
BOOST_IS_BITWISE_SERIALIZABLE(boost::archive::tracking_type)
|
||||
|
||||
#endif //BOOST_ARCHIVE_BASIC_ARCHIVE_HPP
|
||||
|
|
@ -0,0 +1,222 @@
|
|||
#ifndef BOOST_ARCHIVE_BASIC_BINARY_IARCHIVE_HPP
|
||||
#define BOOST_ARCHIVE_BASIC_BINARY_IARCHIVE_HPP
|
||||
|
||||
// MS compatible compilers support #pragma once
|
||||
#if defined(_MSC_VER) && (_MSC_VER >= 1020)
|
||||
# pragma once
|
||||
#endif
|
||||
|
||||
/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
|
||||
// basic_binary_iarchive.hpp
|
||||
//
|
||||
// archives stored as native binary - this should be the fastest way
|
||||
// to archive the state of a group of obects. It makes no attempt to
|
||||
// convert to any canonical form.
|
||||
|
||||
// IN GENERAL, ARCHIVES CREATED WITH THIS CLASS WILL NOT BE READABLE
|
||||
// ON PLATFORM APART FROM THE ONE THEY ARE CREATED ON
|
||||
|
||||
// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
|
||||
// Use, modification and distribution is subject to the Boost Software
|
||||
// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
// See http://www.boost.org for updates, documentation, and revision history.
|
||||
|
||||
#include <boost/config.hpp>
|
||||
#include <boost/detail/workaround.hpp>
|
||||
#include <boost/serialization/pfto.hpp>
|
||||
|
||||
#include <boost/archive/basic_archive.hpp>
|
||||
#include <boost/archive/detail/common_iarchive.hpp>
|
||||
#include <boost/serialization/collection_size_type.hpp>
|
||||
#include <boost/serialization/string.hpp>
|
||||
#include <boost/serialization/item_version_type.hpp>
|
||||
#include <boost/integer_traits.hpp>
|
||||
|
||||
#ifdef BOOST_MSVC
|
||||
# pragma warning(push)
|
||||
# pragma warning(disable : 4511 4512)
|
||||
#endif
|
||||
|
||||
#include <boost/archive/detail/abi_prefix.hpp> // must be the last header
|
||||
|
||||
namespace boost {
|
||||
namespace archive {
|
||||
|
||||
/////////////////////////////////////////////////////////////////////////
|
||||
// class basic_binary_iarchive - read serialized objects from a input binary stream
|
||||
template<class Archive>
|
||||
class basic_binary_iarchive :
|
||||
public detail::common_iarchive<Archive>
|
||||
{
|
||||
protected:
|
||||
#if BOOST_WORKAROUND(BOOST_MSVC, <= 1300)
|
||||
public:
|
||||
#elif defined(BOOST_MSVC)
|
||||
// for some inexplicable reason insertion of "class" generates compile erro
|
||||
// on msvc 7.1
|
||||
friend detail::interface_iarchive<Archive>;
|
||||
#else
|
||||
friend class detail::interface_iarchive<Archive>;
|
||||
#endif
|
||||
// intermediate level to support override of operators
|
||||
// fot templates in the absence of partial function
|
||||
// template ordering. If we get here pass to base class
|
||||
// note extra nonsense to sneak it pass the borland compiers
|
||||
typedef detail::common_iarchive<Archive> detail_common_iarchive;
|
||||
template<class T>
|
||||
void load_override(T & t, BOOST_PFTO int version){
|
||||
this->detail_common_iarchive::load_override(t, static_cast<int>(version));
|
||||
}
|
||||
|
||||
// include these to trap a change in binary format which
|
||||
// isn't specifically handled
|
||||
// upto 32K classes
|
||||
BOOST_STATIC_ASSERT(sizeof(class_id_type) == sizeof(int_least16_t));
|
||||
BOOST_STATIC_ASSERT(sizeof(class_id_reference_type) == sizeof(int_least16_t));
|
||||
// upto 2G objects
|
||||
BOOST_STATIC_ASSERT(sizeof(object_id_type) == sizeof(uint_least32_t));
|
||||
BOOST_STATIC_ASSERT(sizeof(object_reference_type) == sizeof(uint_least32_t));
|
||||
|
||||
// binary files don't include the optional information
|
||||
void load_override(class_id_optional_type & /* t */, int){}
|
||||
|
||||
void load_override(tracking_type & t, int /*version*/){
|
||||
library_version_type lvt = this->get_library_version();
|
||||
if(boost::archive::library_version_type(6) < lvt){
|
||||
int_least8_t x=0;
|
||||
* this->This() >> x;
|
||||
t = boost::archive::tracking_type(x);
|
||||
}
|
||||
else{
|
||||
bool x=0;
|
||||
* this->This() >> x;
|
||||
t = boost::archive::tracking_type(x);
|
||||
}
|
||||
}
|
||||
void load_override(class_id_type & t, int version){
|
||||
library_version_type lvt = this->get_library_version();
|
||||
if(boost::archive::library_version_type(7) < lvt){
|
||||
this->detail_common_iarchive::load_override(t, version);
|
||||
}
|
||||
else
|
||||
if(boost::archive::library_version_type(6) < lvt){
|
||||
int_least16_t x=0;
|
||||
* this->This() >> x;
|
||||
t = boost::archive::class_id_type(x);
|
||||
}
|
||||
else{
|
||||
int x=0;
|
||||
* this->This() >> x;
|
||||
t = boost::archive::class_id_type(x);
|
||||
}
|
||||
}
|
||||
void load_override(class_id_reference_type & t, int version){
|
||||
load_override(static_cast<class_id_type &>(t), version);
|
||||
}
|
||||
#if 0
|
||||
void load_override(class_id_reference_type & t, int version){
|
||||
library_version_type lvt = this->get_library_version();
|
||||
if(boost::archive::library_version_type(7) < lvt){
|
||||
this->detail_common_iarchive::load_override(t, version);
|
||||
}
|
||||
else
|
||||
if(boost::archive::library_version_type(6) < lvt){
|
||||
int_least16_t x=0;
|
||||
* this->This() >> x;
|
||||
t = boost::archive::class_id_reference_type(
|
||||
boost::archive::class_id_type(x)
|
||||
);
|
||||
}
|
||||
else{
|
||||
int x=0;
|
||||
* this->This() >> x;
|
||||
t = boost::archive::class_id_reference_type(
|
||||
boost::archive::class_id_type(x)
|
||||
);
|
||||
}
|
||||
}
|
||||
#endif
|
||||
|
||||
void load_override(version_type & t, int version){
|
||||
library_version_type lvt = this->get_library_version();
|
||||
if(boost::archive::library_version_type(7) < lvt){
|
||||
this->detail_common_iarchive::load_override(t, version);
|
||||
}
|
||||
else
|
||||
if(boost::archive::library_version_type(6) < lvt){
|
||||
uint_least8_t x=0;
|
||||
* this->This() >> x;
|
||||
t = boost::archive::version_type(x);
|
||||
}
|
||||
else
|
||||
if(boost::archive::library_version_type(5) < lvt){
|
||||
uint_least16_t x=0;
|
||||
* this->This() >> x;
|
||||
t = boost::archive::version_type(x);
|
||||
}
|
||||
else
|
||||
if(boost::archive::library_version_type(2) < lvt){
|
||||
// upto 255 versions
|
||||
unsigned char x=0;
|
||||
* this->This() >> x;
|
||||
t = version_type(x);
|
||||
}
|
||||
else{
|
||||
unsigned int x=0;
|
||||
* this->This() >> x;
|
||||
t = boost::archive::version_type(x);
|
||||
}
|
||||
}
|
||||
|
||||
void load_override(boost::serialization::item_version_type & t, int version){
|
||||
library_version_type lvt = this->get_library_version();
|
||||
// if(boost::archive::library_version_type(7) < lvt){
|
||||
if(boost::archive::library_version_type(6) < lvt){
|
||||
this->detail_common_iarchive::load_override(t, version);
|
||||
}
|
||||
else
|
||||
if(boost::archive::library_version_type(6) < lvt){
|
||||
uint_least16_t x=0;
|
||||
* this->This() >> x;
|
||||
t = boost::serialization::item_version_type(x);
|
||||
}
|
||||
else{
|
||||
unsigned int x=0;
|
||||
* this->This() >> x;
|
||||
t = boost::serialization::item_version_type(x);
|
||||
}
|
||||
}
|
||||
|
||||
void load_override(serialization::collection_size_type & t, int version){
|
||||
if(boost::archive::library_version_type(5) < this->get_library_version()){
|
||||
this->detail_common_iarchive::load_override(t, version);
|
||||
}
|
||||
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, int);
|
||||
BOOST_ARCHIVE_OR_WARCHIVE_DECL(void)
|
||||
init();
|
||||
|
||||
basic_binary_iarchive(unsigned int flags) :
|
||||
detail::common_iarchive<Archive>(flags)
|
||||
{}
|
||||
};
|
||||
|
||||
} // namespace archive
|
||||
} // namespace boost
|
||||
|
||||
#ifdef BOOST_MSVC
|
||||
#pragma warning(pop)
|
||||
#endif
|
||||
|
||||
#include <boost/archive/detail/abi_suffix.hpp> // pops abi_suffix.hpp pragmas
|
||||
|
||||
#endif // BOOST_ARCHIVE_BASIC_BINARY_IARCHIVE_HPP
|
||||
|
|
@ -0,0 +1,190 @@
|
|||
#ifndef BOOST_ARCHIVE_BINARY_IPRIMITIVE_HPP
|
||||
#define BOOST_ARCHIVE_BINARY_IPRIMITIVE_HPP
|
||||
|
||||
// MS compatible compilers support #pragma once
|
||||
#if defined(_MSC_VER) && (_MSC_VER >= 1020)
|
||||
# pragma once
|
||||
#endif
|
||||
|
||||
#if defined(_MSC_VER)
|
||||
#pragma warning( disable : 4800 )
|
||||
#endif
|
||||
|
||||
/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
|
||||
// basic_binary_iprimitive.hpp
|
||||
//
|
||||
// archives stored as native binary - this should be the fastest way
|
||||
// to archive the state of a group of obects. It makes no attempt to
|
||||
// convert to any canonical form.
|
||||
|
||||
// IN GENERAL, ARCHIVES CREATED WITH THIS CLASS WILL NOT BE READABLE
|
||||
// ON PLATFORM APART FROM THE ONE THEY ARE CREATED ON
|
||||
|
||||
// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
|
||||
// Use, modification and distribution is subject to the Boost Software
|
||||
// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
// See http://www.boost.org for updates, documentation, and revision history.
|
||||
|
||||
#include <iosfwd>
|
||||
#include <boost/assert.hpp>
|
||||
#include <locale>
|
||||
#include <cstring> // std::memcpy
|
||||
#include <cstddef> // std::size_t
|
||||
#include <streambuf> // basic_streambuf
|
||||
#include <string>
|
||||
|
||||
#include <boost/config.hpp>
|
||||
#if defined(BOOST_NO_STDC_NAMESPACE)
|
||||
namespace std{
|
||||
using ::memcpy;
|
||||
using ::size_t;
|
||||
} // namespace std
|
||||
#endif
|
||||
|
||||
#include <boost/cstdint.hpp>
|
||||
#include <boost/scoped_ptr.hpp>
|
||||
#include <boost/serialization/throw_exception.hpp>
|
||||
#include <boost/integer.hpp>
|
||||
#include <boost/integer_traits.hpp>
|
||||
|
||||
#include <boost/archive/basic_streambuf_locale_saver.hpp>
|
||||
#include <boost/archive/archive_exception.hpp>
|
||||
#include <boost/mpl/placeholders.hpp>
|
||||
#include <boost/serialization/is_bitwise_serializable.hpp>
|
||||
#include <boost/serialization/array.hpp>
|
||||
#include <boost/archive/detail/auto_link_archive.hpp>
|
||||
#include <boost/archive/detail/abi_prefix.hpp> // must be the last header
|
||||
|
||||
namespace boost {
|
||||
namespace archive {
|
||||
|
||||
/////////////////////////////////////////////////////////////////////////////
|
||||
// class binary_iarchive - read serialized objects from a input binary stream
|
||||
template<class Archive, class Elem, class Tr>
|
||||
class basic_binary_iprimitive
|
||||
{
|
||||
#ifndef BOOST_NO_MEMBER_TEMPLATE_FRIENDS
|
||||
friend class load_access;
|
||||
protected:
|
||||
#else
|
||||
public:
|
||||
#endif
|
||||
std::basic_streambuf<Elem, Tr> & m_sb;
|
||||
// return a pointer to the most derived class
|
||||
Archive * This(){
|
||||
return static_cast<Archive *>(this);
|
||||
}
|
||||
|
||||
#ifndef BOOST_NO_STD_LOCALE
|
||||
boost::scoped_ptr<std::locale> archive_locale;
|
||||
basic_streambuf_locale_saver<Elem, Tr> locale_saver;
|
||||
#endif
|
||||
|
||||
// main template for serilization of primitive types
|
||||
template<class T>
|
||||
void load(T & t){
|
||||
load_binary(& t, sizeof(T));
|
||||
}
|
||||
|
||||
/////////////////////////////////////////////////////////
|
||||
// fundamental types that need special treatment
|
||||
|
||||
// trap usage of invalid uninitialized boolean
|
||||
void load(bool & t){
|
||||
load_binary(& t, sizeof(t));
|
||||
int i = t;
|
||||
BOOST_ASSERT(0 == i || 1 == i);
|
||||
(void)i; // warning suppression for release builds.
|
||||
}
|
||||
BOOST_ARCHIVE_OR_WARCHIVE_DECL(void)
|
||||
load(std::string &s);
|
||||
#ifndef BOOST_NO_STD_WSTRING
|
||||
BOOST_ARCHIVE_OR_WARCHIVE_DECL(void)
|
||||
load(std::wstring &ws);
|
||||
#endif
|
||||
BOOST_ARCHIVE_OR_WARCHIVE_DECL(void)
|
||||
load(char * t);
|
||||
BOOST_ARCHIVE_OR_WARCHIVE_DECL(void)
|
||||
load(wchar_t * t);
|
||||
|
||||
BOOST_ARCHIVE_OR_WARCHIVE_DECL(void)
|
||||
init();
|
||||
BOOST_ARCHIVE_OR_WARCHIVE_DECL(BOOST_PP_EMPTY())
|
||||
basic_binary_iprimitive(
|
||||
std::basic_streambuf<Elem, Tr> & sb,
|
||||
bool no_codecvt
|
||||
);
|
||||
BOOST_ARCHIVE_OR_WARCHIVE_DECL(BOOST_PP_EMPTY())
|
||||
~basic_binary_iprimitive();
|
||||
public:
|
||||
// we provide an optimized load for all fundamental types
|
||||
// typedef serialization::is_bitwise_serializable<mpl::_1>
|
||||
// use_array_optimization;
|
||||
struct use_array_optimization {
|
||||
template <class T>
|
||||
#if defined(BOOST_NO_DEPENDENT_NESTED_DERIVATIONS)
|
||||
struct apply {
|
||||
typedef BOOST_DEDUCED_TYPENAME boost::serialization::is_bitwise_serializable< T >::type type;
|
||||
};
|
||||
#else
|
||||
struct apply : public boost::serialization::is_bitwise_serializable< T > {};
|
||||
#endif
|
||||
};
|
||||
|
||||
// the optimized load_array dispatches to load_binary
|
||||
template <class ValueType>
|
||||
void load_array(serialization::array<ValueType>& a, unsigned int)
|
||||
{
|
||||
load_binary(a.address(),a.count()*sizeof(ValueType));
|
||||
}
|
||||
|
||||
void
|
||||
load_binary(void *address, std::size_t count);
|
||||
};
|
||||
|
||||
template<class Archive, class Elem, class Tr>
|
||||
inline void
|
||||
basic_binary_iprimitive<Archive, Elem, Tr>::load_binary(
|
||||
void *address,
|
||||
std::size_t count
|
||||
){
|
||||
// note: an optimizer should eliminate the following for char files
|
||||
BOOST_ASSERT(
|
||||
static_cast<std::streamsize>(count / sizeof(Elem))
|
||||
<= boost::integer_traits<std::streamsize>::const_max
|
||||
);
|
||||
std::streamsize s = static_cast<std::streamsize>(count / sizeof(Elem));
|
||||
std::streamsize scount = m_sb.sgetn(
|
||||
static_cast<Elem *>(address),
|
||||
s
|
||||
);
|
||||
if(scount != s)
|
||||
boost::serialization::throw_exception(
|
||||
archive_exception(archive_exception::input_stream_error)
|
||||
);
|
||||
// note: an optimizer should eliminate the following for char files
|
||||
BOOST_ASSERT(count % sizeof(Elem) <= boost::integer_traits<std::streamsize>::const_max);
|
||||
s = static_cast<std::streamsize>(count % sizeof(Elem));
|
||||
if(0 < s){
|
||||
// if(is.fail())
|
||||
// boost::serialization::throw_exception(
|
||||
// archive_exception(archive_exception::stream_error)
|
||||
// );
|
||||
Elem t;
|
||||
scount = m_sb.sgetn(& t, 1);
|
||||
if(scount != 1)
|
||||
boost::serialization::throw_exception(
|
||||
archive_exception(archive_exception::input_stream_error)
|
||||
);
|
||||
std::memcpy(static_cast<char*>(address) + (count - s), &t, s);
|
||||
}
|
||||
}
|
||||
|
||||
} // namespace archive
|
||||
} // namespace boost
|
||||
|
||||
#include <boost/archive/detail/abi_suffix.hpp> // pop pragmas
|
||||
|
||||
#endif // BOOST_ARCHIVE_BINARY_IPRIMITIVE_HPP
|
||||
|
|
@ -0,0 +1,180 @@
|
|||
#ifndef BOOST_ARCHIVE_BASIC_BINARY_OARCHIVE_HPP
|
||||
#define BOOST_ARCHIVE_BASIC_BINARY_OARCHIVE_HPP
|
||||
|
||||
// MS compatible compilers support #pragma once
|
||||
#if defined(_MSC_VER) && (_MSC_VER >= 1020)
|
||||
# pragma once
|
||||
#endif
|
||||
|
||||
/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
|
||||
// basic_binary_oarchive.hpp
|
||||
|
||||
// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
|
||||
// Use, modification and distribution is subject to the Boost Software
|
||||
// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
// See http://www.boost.org for updates, documentation, and revision history.
|
||||
|
||||
// archives stored as native binary - this should be the fastest way
|
||||
// to archive the state of a group of obects. It makes no attempt to
|
||||
// convert to any canonical form.
|
||||
|
||||
// IN GENERAL, ARCHIVES CREATED WITH THIS CLASS WILL NOT BE READABLE
|
||||
// ON PLATFORM APART FROM THE ONE THEY ARE CREATE ON
|
||||
|
||||
#include <boost/assert.hpp>
|
||||
#include <boost/config.hpp>
|
||||
#include <boost/detail/workaround.hpp>
|
||||
#include <boost/serialization/pfto.hpp>
|
||||
|
||||
#include <boost/integer.hpp>
|
||||
#include <boost/integer_traits.hpp>
|
||||
|
||||
#include <boost/archive/detail/common_oarchive.hpp>
|
||||
#include <boost/serialization/string.hpp>
|
||||
#include <boost/serialization/collection_size_type.hpp>
|
||||
#include <boost/serialization/item_version_type.hpp>
|
||||
|
||||
#include <boost/archive/detail/abi_prefix.hpp> // must be the last header
|
||||
|
||||
#ifdef BOOST_MSVC
|
||||
# pragma warning(push)
|
||||
# pragma warning(disable : 4511 4512)
|
||||
#endif
|
||||
|
||||
namespace boost {
|
||||
namespace archive {
|
||||
|
||||
//////////////////////////////////////////////////////////////////////
|
||||
// class basic_binary_oarchive - write serialized objects to a binary output stream
|
||||
// note: this archive has no pretensions to portability. Archive format
|
||||
// may vary across machine architectures and compilers. About the only
|
||||
// guarentee is that an archive created with this code will be readable
|
||||
// by a program built with the same tools for the same machne. This class
|
||||
// does have the virtue of buiding the smalles archive in the minimum amount
|
||||
// of time. So under some circumstances it may be he right choice.
|
||||
template<class Archive>
|
||||
class basic_binary_oarchive :
|
||||
public archive::detail::common_oarchive<Archive>
|
||||
{
|
||||
protected:
|
||||
#if BOOST_WORKAROUND(BOOST_MSVC, <= 1300)
|
||||
public:
|
||||
#elif defined(BOOST_MSVC)
|
||||
// for some inexplicable reason insertion of "class" generates compile erro
|
||||
// on msvc 7.1
|
||||
friend detail::interface_oarchive<Archive>;
|
||||
#else
|
||||
friend class detail::interface_oarchive<Archive>;
|
||||
#endif
|
||||
// any datatype not specifed below will be handled by base class
|
||||
typedef detail::common_oarchive<Archive> detail_common_oarchive;
|
||||
template<class T>
|
||||
void save_override(const T & t, BOOST_PFTO int version){
|
||||
this->detail_common_oarchive::save_override(t, static_cast<int>(version));
|
||||
}
|
||||
|
||||
// include these to trap a change in binary format which
|
||||
// isn't specifically handled
|
||||
BOOST_STATIC_ASSERT(sizeof(tracking_type) == sizeof(bool));
|
||||
// upto 32K classes
|
||||
BOOST_STATIC_ASSERT(sizeof(class_id_type) == sizeof(int_least16_t));
|
||||
BOOST_STATIC_ASSERT(sizeof(class_id_reference_type) == sizeof(int_least16_t));
|
||||
// upto 2G objects
|
||||
BOOST_STATIC_ASSERT(sizeof(object_id_type) == sizeof(uint_least32_t));
|
||||
BOOST_STATIC_ASSERT(sizeof(object_reference_type) == sizeof(uint_least32_t));
|
||||
|
||||
// binary files don't include the optional information
|
||||
void save_override(const class_id_optional_type & /* t */, int){}
|
||||
|
||||
// enable this if we decide to support generation of previous versions
|
||||
#if 0
|
||||
void save_override(const boost::archive::version_type & t, int version){
|
||||
library_version_type lvt = this->get_library_version();
|
||||
if(boost::archive::library_version_type(7) < lvt){
|
||||
this->detail_common_oarchive::save_override(t, version);
|
||||
}
|
||||
else
|
||||
if(boost::archive::library_version_type(6) < lvt){
|
||||
const boost::uint_least16_t x = t;
|
||||
* this->This() << x;
|
||||
}
|
||||
else{
|
||||
const unsigned int x = t;
|
||||
* this->This() << x;
|
||||
}
|
||||
}
|
||||
void save_override(const boost::serialization::item_version_type & t, int version){
|
||||
library_version_type lvt = this->get_library_version();
|
||||
if(boost::archive::library_version_type(7) < lvt){
|
||||
this->detail_common_oarchive::save_override(t, version);
|
||||
}
|
||||
else
|
||||
if(boost::archive::library_version_type(6) < lvt){
|
||||
const boost::uint_least16_t x = t;
|
||||
* this->This() << x;
|
||||
}
|
||||
else{
|
||||
const unsigned int x = t;
|
||||
* this->This() << x;
|
||||
}
|
||||
}
|
||||
|
||||
void save_override(class_id_type & t, int version){
|
||||
library_version_type lvt = this->get_library_version();
|
||||
if(boost::archive::library_version_type(7) < lvt){
|
||||
this->detail_common_oarchive::save_override(t, version);
|
||||
}
|
||||
else
|
||||
if(boost::archive::library_version_type(6) < lvt){
|
||||
const boost::int_least16_t x = t;
|
||||
* this->This() << x;
|
||||
}
|
||||
else{
|
||||
const int x = t;
|
||||
* this->This() << x;
|
||||
}
|
||||
}
|
||||
void save_override(class_id_reference_type & t, int version){
|
||||
save_override(static_cast<class_id_type &>(t), version);
|
||||
}
|
||||
|
||||
#endif
|
||||
|
||||
// explicitly convert to char * to avoid compile ambiguities
|
||||
void save_override(const class_name_type & t, int){
|
||||
const std::string s(t);
|
||||
* this->This() << s;
|
||||
}
|
||||
|
||||
#if 0
|
||||
void save_override(const serialization::collection_size_type & t, int){
|
||||
if (get_library_version() < boost::archive::library_version_type(6)){
|
||||
unsigned int x=0;
|
||||
* this->This() >> x;
|
||||
t = serialization::collection_size_type(x);
|
||||
}
|
||||
else{
|
||||
* this->This() >> t;
|
||||
}
|
||||
}
|
||||
#endif
|
||||
BOOST_ARCHIVE_OR_WARCHIVE_DECL(void)
|
||||
init();
|
||||
|
||||
basic_binary_oarchive(unsigned int flags) :
|
||||
detail::common_oarchive<Archive>(flags)
|
||||
{}
|
||||
};
|
||||
|
||||
} // namespace archive
|
||||
} // namespace boost
|
||||
|
||||
#ifdef BOOST_MSVC
|
||||
#pragma warning(pop)
|
||||
#endif
|
||||
|
||||
#include <boost/archive/detail/abi_suffix.hpp> // pops abi_suffix.hpp pragmas
|
||||
|
||||
#endif // BOOST_ARCHIVE_BASIC_BINARY_OARCHIVE_HPP
|
||||
|
|
@ -0,0 +1,184 @@
|
|||
#ifndef BOOST_ARCHIVE_BASIC_BINARY_OPRIMITIVE_HPP
|
||||
#define BOOST_ARCHIVE_BASIC_BINARY_OPRIMITIVE_HPP
|
||||
|
||||
// MS compatible compilers support #pragma once
|
||||
#if defined(_MSC_VER) && (_MSC_VER >= 1020)
|
||||
# pragma once
|
||||
#endif
|
||||
|
||||
/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
|
||||
// basic_binary_oprimitive.hpp
|
||||
|
||||
// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
|
||||
// Use, modification and distribution is subject to the Boost Software
|
||||
// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
// See http://www.boost.org for updates, documentation, and revision history.
|
||||
|
||||
// archives stored as native binary - this should be the fastest way
|
||||
// to archive the state of a group of obects. It makes no attempt to
|
||||
// convert to any canonical form.
|
||||
|
||||
// IN GENERAL, ARCHIVES CREATED WITH THIS CLASS WILL NOT BE READABLE
|
||||
// ON PLATFORM APART FROM THE ONE THEY ARE CREATE ON
|
||||
|
||||
#include <iosfwd>
|
||||
#include <boost/assert.hpp>
|
||||
#include <locale>
|
||||
#include <streambuf> // basic_streambuf
|
||||
#include <string>
|
||||
#include <cstddef> // size_t
|
||||
|
||||
#include <boost/config.hpp>
|
||||
#if defined(BOOST_NO_STDC_NAMESPACE)
|
||||
namespace std{
|
||||
using ::size_t;
|
||||
} // namespace std
|
||||
#endif
|
||||
|
||||
#include <boost/cstdint.hpp>
|
||||
#include <boost/integer.hpp>
|
||||
#include <boost/integer_traits.hpp>
|
||||
#include <boost/scoped_ptr.hpp>
|
||||
#include <boost/serialization/throw_exception.hpp>
|
||||
|
||||
#include <boost/archive/basic_streambuf_locale_saver.hpp>
|
||||
#include <boost/archive/archive_exception.hpp>
|
||||
#include <boost/serialization/is_bitwise_serializable.hpp>
|
||||
#include <boost/mpl/placeholders.hpp>
|
||||
#include <boost/serialization/array.hpp>
|
||||
#include <boost/archive/detail/auto_link_archive.hpp>
|
||||
#include <boost/archive/detail/abi_prefix.hpp> // must be the last header
|
||||
|
||||
namespace boost {
|
||||
namespace archive {
|
||||
|
||||
/////////////////////////////////////////////////////////////////////////
|
||||
// class basic_binary_oprimitive - binary output of prmitives
|
||||
|
||||
template<class Archive, class Elem, class Tr>
|
||||
class basic_binary_oprimitive
|
||||
{
|
||||
#ifndef BOOST_NO_MEMBER_TEMPLATE_FRIENDS
|
||||
friend class save_access;
|
||||
protected:
|
||||
#else
|
||||
public:
|
||||
#endif
|
||||
std::basic_streambuf<Elem, Tr> & m_sb;
|
||||
// return a pointer to the most derived class
|
||||
Archive * This(){
|
||||
return static_cast<Archive *>(this);
|
||||
}
|
||||
#ifndef BOOST_NO_STD_LOCALE
|
||||
boost::scoped_ptr<std::locale> archive_locale;
|
||||
basic_streambuf_locale_saver<Elem, Tr> locale_saver;
|
||||
#endif
|
||||
// default saving of primitives.
|
||||
template<class T>
|
||||
void save(const T & t)
|
||||
{
|
||||
save_binary(& t, sizeof(T));
|
||||
}
|
||||
|
||||
/////////////////////////////////////////////////////////
|
||||
// fundamental types that need special treatment
|
||||
|
||||
// trap usage of invalid uninitialized boolean which would
|
||||
// otherwise crash on load.
|
||||
void save(const bool t){
|
||||
BOOST_ASSERT(0 == static_cast<int>(t) || 1 == static_cast<int>(t));
|
||||
save_binary(& t, sizeof(t));
|
||||
}
|
||||
BOOST_ARCHIVE_OR_WARCHIVE_DECL(void)
|
||||
save(const std::string &s);
|
||||
#ifndef BOOST_NO_STD_WSTRING
|
||||
BOOST_ARCHIVE_OR_WARCHIVE_DECL(void)
|
||||
save(const std::wstring &ws);
|
||||
#endif
|
||||
BOOST_ARCHIVE_OR_WARCHIVE_DECL(void)
|
||||
save(const char * t);
|
||||
BOOST_ARCHIVE_OR_WARCHIVE_DECL(void)
|
||||
save(const wchar_t * t);
|
||||
|
||||
BOOST_ARCHIVE_OR_WARCHIVE_DECL(void)
|
||||
init();
|
||||
|
||||
BOOST_ARCHIVE_OR_WARCHIVE_DECL(BOOST_PP_EMPTY())
|
||||
basic_binary_oprimitive(
|
||||
std::basic_streambuf<Elem, Tr> & sb,
|
||||
bool no_codecvt
|
||||
);
|
||||
BOOST_ARCHIVE_OR_WARCHIVE_DECL(BOOST_PP_EMPTY())
|
||||
~basic_binary_oprimitive();
|
||||
public:
|
||||
|
||||
// we provide an optimized save for all fundamental types
|
||||
// typedef serialization::is_bitwise_serializable<mpl::_1>
|
||||
// use_array_optimization;
|
||||
// workaround without using mpl lambdas
|
||||
struct use_array_optimization {
|
||||
template <class T>
|
||||
#if defined(BOOST_NO_DEPENDENT_NESTED_DERIVATIONS)
|
||||
struct apply {
|
||||
typedef BOOST_DEDUCED_TYPENAME boost::serialization::is_bitwise_serializable< T >::type type;
|
||||
};
|
||||
#else
|
||||
struct apply : public boost::serialization::is_bitwise_serializable< T > {};
|
||||
#endif
|
||||
};
|
||||
|
||||
|
||||
// the optimized save_array dispatches to save_binary
|
||||
template <class ValueType>
|
||||
void save_array(boost::serialization::array<ValueType> const& a, unsigned int)
|
||||
{
|
||||
save_binary(a.address(),a.count()*sizeof(ValueType));
|
||||
}
|
||||
|
||||
void save_binary(const void *address, std::size_t count);
|
||||
};
|
||||
|
||||
template<class Archive, class Elem, class Tr>
|
||||
inline void
|
||||
basic_binary_oprimitive<Archive, Elem, Tr>::save_binary(
|
||||
const void *address,
|
||||
std::size_t count
|
||||
){
|
||||
//BOOST_ASSERT(
|
||||
// static_cast<std::size_t>((std::numeric_limits<std::streamsize>::max)()) >= count
|
||||
//);
|
||||
// note: if the following assertions fail
|
||||
// a likely cause is that the output stream is set to "text"
|
||||
// mode where by cr characters recieve special treatment.
|
||||
// be sure that the output stream is opened with ios::binary
|
||||
//if(os.fail())
|
||||
// boost::serialization::throw_exception(
|
||||
// archive_exception(archive_exception::output_stream_error)
|
||||
// );
|
||||
// figure number of elements to output - round up
|
||||
count = ( count + sizeof(Elem) - 1)
|
||||
/ sizeof(Elem);
|
||||
BOOST_ASSERT(count <= std::size_t(boost::integer_traits<std::streamsize>::const_max));
|
||||
std::streamsize scount = m_sb.sputn(
|
||||
static_cast<const Elem *>(address),
|
||||
static_cast<std::streamsize>(count)
|
||||
);
|
||||
if(count != static_cast<std::size_t>(scount))
|
||||
boost::serialization::throw_exception(
|
||||
archive_exception(archive_exception::output_stream_error)
|
||||
);
|
||||
//os.write(
|
||||
// static_cast<const BOOST_DEDUCED_TYPENAME OStream::char_type *>(address),
|
||||
// count
|
||||
//);
|
||||
//BOOST_ASSERT(os.good());
|
||||
}
|
||||
|
||||
} //namespace boost
|
||||
} //namespace archive
|
||||
|
||||
#include <boost/archive/detail/abi_suffix.hpp> // pop pragmas
|
||||
|
||||
#endif // BOOST_ARCHIVE_BASIC_BINARY_OPRIMITIVE_HPP
|
||||
|
|
@ -0,0 +1,73 @@
|
|||
#ifndef BOOST_ARCHIVE_BASIC_STREAMBUF_LOCALE_SAVER_HPP
|
||||
#define BOOST_ARCHIVE_BASIC_STREAMBUF_LOCALE_SAVER_HPP
|
||||
|
||||
// MS compatible compilers support #pragma once
|
||||
#if defined(_MSC_VER) && (_MSC_VER >= 1020)
|
||||
# pragma once
|
||||
#endif
|
||||
|
||||
/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
|
||||
// basic_streambuf_local_saver.hpp
|
||||
|
||||
// (C) Copyright 2005 Robert Ramey - http://www.rrsd.com
|
||||
|
||||
// Use, modification and distribution is subject to the Boost Software
|
||||
// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
// See http://www.boost.org for updates, documentation, and revision history.
|
||||
|
||||
// note derived from boost/io/ios_state.hpp
|
||||
// Copyright 2002, 2005 Daryle Walker. Use, modification, and distribution
|
||||
// are subject to the Boost Software License, Version 1.0. (See accompanying
|
||||
// file LICENSE_1_0.txt or a copy at <http://www.boost.org/LICENSE_1_0.txt>.)
|
||||
|
||||
// See <http://www.boost.org/libs/io/> for the library's home page.
|
||||
|
||||
#ifndef BOOST_NO_STD_LOCALE
|
||||
|
||||
#include <locale> // for std::locale
|
||||
#include <streambuf> // for std::basic_streambuf
|
||||
|
||||
#include <boost/config.hpp>
|
||||
#include <boost/noncopyable.hpp>
|
||||
|
||||
#ifdef BOOST_MSVC
|
||||
# pragma warning(push)
|
||||
# pragma warning(disable : 4511 4512)
|
||||
#endif
|
||||
|
||||
namespace boost{
|
||||
namespace archive{
|
||||
|
||||
template < typename Ch, class Tr >
|
||||
class basic_streambuf_locale_saver :
|
||||
private boost::noncopyable
|
||||
{
|
||||
public:
|
||||
typedef ::std::basic_streambuf<Ch, Tr> state_type;
|
||||
typedef ::std::locale aspect_type;
|
||||
explicit basic_streambuf_locale_saver( state_type &s )
|
||||
: s_save_( s ), a_save_( s.getloc() )
|
||||
{}
|
||||
basic_streambuf_locale_saver( state_type &s, aspect_type const &a )
|
||||
: s_save_( s ), a_save_( s.pubimbue(a) )
|
||||
{}
|
||||
~basic_streambuf_locale_saver()
|
||||
{ this->restore(); }
|
||||
void restore()
|
||||
{ s_save_.pubimbue( a_save_ ); }
|
||||
private:
|
||||
state_type & s_save_;
|
||||
aspect_type const a_save_;
|
||||
};
|
||||
|
||||
} // archive
|
||||
} // boost
|
||||
|
||||
#ifdef BOOST_MSVC
|
||||
#pragma warning(pop)
|
||||
#endif
|
||||
|
||||
#endif // BOOST_NO_STD_LOCALE
|
||||
#endif // BOOST_ARCHIVE_BASIC_STREAMBUF_LOCALE_SAVER_HPP
|
||||
|
|
@ -0,0 +1,91 @@
|
|||
#ifndef BOOST_ARCHIVE_BASIC_TEXT_IARCHIVE_HPP
|
||||
#define BOOST_ARCHIVE_BASIC_TEXT_IARCHIVE_HPP
|
||||
|
||||
// MS compatible compilers support #pragma once
|
||||
#if defined(_MSC_VER) && (_MSC_VER >= 1020)
|
||||
# pragma once
|
||||
#endif
|
||||
|
||||
/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
|
||||
// basic_text_iarchive.hpp
|
||||
|
||||
// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
|
||||
// Use, modification and distribution is subject to the Boost Software
|
||||
// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
// See http://www.boost.org for updates, documentation, and revision history.
|
||||
|
||||
// archives stored as text - note these ar templated on the basic
|
||||
// stream templates to accommodate wide (and other?) kind of characters
|
||||
//
|
||||
// note the fact that on libraries without wide characters, ostream is
|
||||
// is not a specialization of basic_ostream which in fact is not defined
|
||||
// in such cases. So we can't use basic_ostream<IStream::char_type> but rather
|
||||
// use two template parameters
|
||||
|
||||
#include <boost/config.hpp>
|
||||
#include <boost/serialization/pfto.hpp>
|
||||
#include <boost/detail/workaround.hpp>
|
||||
|
||||
#include <boost/archive/detail/common_iarchive.hpp>
|
||||
|
||||
#include <boost/archive/detail/abi_prefix.hpp> // must be the last header
|
||||
|
||||
#ifdef BOOST_MSVC
|
||||
# pragma warning(push)
|
||||
# pragma warning(disable : 4511 4512)
|
||||
#endif
|
||||
|
||||
namespace boost {
|
||||
namespace archive {
|
||||
|
||||
/////////////////////////////////////////////////////////////////////////
|
||||
// class basic_text_iarchive - read serialized objects from a input text stream
|
||||
template<class Archive>
|
||||
class basic_text_iarchive :
|
||||
public detail::common_iarchive<Archive>
|
||||
{
|
||||
protected:
|
||||
#if BOOST_WORKAROUND(BOOST_MSVC, <= 1300)
|
||||
public:
|
||||
#elif defined(BOOST_MSVC)
|
||||
// for some inexplicable reason insertion of "class" generates compile erro
|
||||
// on msvc 7.1
|
||||
friend detail::interface_iarchive<Archive>;
|
||||
#else
|
||||
friend class detail::interface_iarchive<Archive>;
|
||||
#endif
|
||||
// intermediate level to support override of operators
|
||||
// fot templates in the absence of partial function
|
||||
// template ordering
|
||||
typedef detail::common_iarchive<Archive> detail_common_iarchive;
|
||||
template<class T>
|
||||
void load_override(T & t, BOOST_PFTO int){
|
||||
this->detail_common_iarchive::load_override(t, 0);
|
||||
}
|
||||
// text file don't include the optional information
|
||||
void load_override(class_id_optional_type & /*t*/, int){}
|
||||
|
||||
BOOST_ARCHIVE_OR_WARCHIVE_DECL(void)
|
||||
load_override(class_name_type & t, int);
|
||||
|
||||
BOOST_ARCHIVE_OR_WARCHIVE_DECL(void)
|
||||
init(void);
|
||||
|
||||
basic_text_iarchive(unsigned int flags) :
|
||||
detail::common_iarchive<Archive>(flags)
|
||||
{}
|
||||
~basic_text_iarchive(){}
|
||||
};
|
||||
|
||||
} // namespace archive
|
||||
} // namespace boost
|
||||
|
||||
#ifdef BOOST_MSVC
|
||||
#pragma warning(pop)
|
||||
#endif
|
||||
|
||||
#include <boost/archive/detail/abi_suffix.hpp> // pops abi_suffix.hpp pragmas
|
||||
|
||||
#endif // BOOST_ARCHIVE_BASIC_TEXT_IARCHIVE_HPP
|
||||
|
|
@ -0,0 +1,144 @@
|
|||
#ifndef BOOST_ARCHIVE_BASIC_TEXT_IPRIMITIVE_HPP
|
||||
#define BOOST_ARCHIVE_BASIC_TEXT_IPRIMITIVE_HPP
|
||||
|
||||
// MS compatible compilers support #pragma once
|
||||
#if defined(_MSC_VER) && (_MSC_VER >= 1020)
|
||||
# pragma once
|
||||
#endif
|
||||
|
||||
/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
|
||||
// basic_text_iprimitive.hpp
|
||||
|
||||
// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
|
||||
// Use, modification and distribution is subject to the Boost Software
|
||||
// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
// See http://www.boost.org for updates, documentation, and revision history.
|
||||
|
||||
// archives stored as text - note these are templated on the basic
|
||||
// stream templates to accommodate wide (and other?) kind of characters
|
||||
//
|
||||
// Note the fact that on libraries without wide characters, ostream is
|
||||
// not a specialization of basic_ostream which in fact is not defined
|
||||
// in such cases. So we can't use basic_ostream<IStream::char_type> but rather
|
||||
// use two template parameters
|
||||
|
||||
#include <boost/assert.hpp>
|
||||
#include <locale>
|
||||
#include <cstddef> // size_t
|
||||
|
||||
#include <boost/config.hpp>
|
||||
#if defined(BOOST_NO_STDC_NAMESPACE)
|
||||
namespace std{
|
||||
using ::size_t;
|
||||
#if ! defined(BOOST_DINKUMWARE_STDLIB) && ! defined(__SGI_STL_PORT)
|
||||
using ::locale;
|
||||
#endif
|
||||
} // namespace std
|
||||
#endif
|
||||
|
||||
#include <boost/detail/workaround.hpp>
|
||||
#if BOOST_WORKAROUND(BOOST_DINKUMWARE_STDLIB, == 1)
|
||||
#include <boost/archive/dinkumware.hpp>
|
||||
#endif
|
||||
|
||||
#include <boost/limits.hpp>
|
||||
#include <boost/io/ios_state.hpp>
|
||||
#include <boost/scoped_ptr.hpp>
|
||||
#include <boost/static_assert.hpp>
|
||||
|
||||
#include <boost/serialization/throw_exception.hpp>
|
||||
#include <boost/archive/archive_exception.hpp>
|
||||
#include <boost/archive/basic_streambuf_locale_saver.hpp>
|
||||
#include <boost/archive/detail/abi_prefix.hpp> // must be the last header
|
||||
|
||||
namespace boost {
|
||||
namespace archive {
|
||||
|
||||
/////////////////////////////////////////////////////////////////////////
|
||||
// class basic_text_iarchive - load serialized objects from a input text stream
|
||||
#if defined(_MSC_VER)
|
||||
#pragma warning( push )
|
||||
#pragma warning( disable : 4244 4267 )
|
||||
#endif
|
||||
|
||||
template<class IStream>
|
||||
class basic_text_iprimitive
|
||||
{
|
||||
#ifndef BOOST_NO_MEMBER_TEMPLATE_FRIENDS
|
||||
protected:
|
||||
#else
|
||||
public:
|
||||
#endif
|
||||
IStream &is;
|
||||
io::ios_flags_saver flags_saver;
|
||||
io::ios_precision_saver precision_saver;
|
||||
|
||||
#ifndef BOOST_NO_STD_LOCALE
|
||||
boost::scoped_ptr<std::locale> archive_locale;
|
||||
basic_streambuf_locale_saver<
|
||||
BOOST_DEDUCED_TYPENAME IStream::char_type,
|
||||
BOOST_DEDUCED_TYPENAME IStream::traits_type
|
||||
> locale_saver;
|
||||
#endif
|
||||
|
||||
template<class T>
|
||||
void load(T & t)
|
||||
{
|
||||
if(! is.fail()){
|
||||
is >> t;
|
||||
return;
|
||||
}
|
||||
boost::serialization::throw_exception(
|
||||
archive_exception(archive_exception::input_stream_error)
|
||||
);
|
||||
}
|
||||
|
||||
void load(char & t)
|
||||
{
|
||||
short int i;
|
||||
load(i);
|
||||
t = i;
|
||||
}
|
||||
void load(signed char & t)
|
||||
{
|
||||
short int i;
|
||||
load(i);
|
||||
t = i;
|
||||
}
|
||||
void load(unsigned char & t)
|
||||
{
|
||||
unsigned short int i;
|
||||
load(i);
|
||||
t = i;
|
||||
}
|
||||
|
||||
#ifndef BOOST_NO_INTRINSIC_WCHAR_T
|
||||
void load(wchar_t & t)
|
||||
{
|
||||
BOOST_STATIC_ASSERT(sizeof(wchar_t) <= sizeof(int));
|
||||
int i;
|
||||
load(i);
|
||||
t = i;
|
||||
}
|
||||
#endif
|
||||
BOOST_ARCHIVE_OR_WARCHIVE_DECL(BOOST_PP_EMPTY())
|
||||
basic_text_iprimitive(IStream &is, bool no_codecvt);
|
||||
BOOST_ARCHIVE_OR_WARCHIVE_DECL(BOOST_PP_EMPTY())
|
||||
~basic_text_iprimitive();
|
||||
public:
|
||||
BOOST_ARCHIVE_OR_WARCHIVE_DECL(void)
|
||||
load_binary(void *address, std::size_t count);
|
||||
};
|
||||
|
||||
#if defined(_MSC_VER)
|
||||
#pragma warning( pop )
|
||||
#endif
|
||||
|
||||
} // namespace archive
|
||||
} // namespace boost
|
||||
|
||||
#include <boost/archive/detail/abi_suffix.hpp> // pop pragmas
|
||||
|
||||
#endif // BOOST_ARCHIVE_BASIC_TEXT_IPRIMITIVE_HPP
|
||||
|
|
@ -0,0 +1,116 @@
|
|||
#ifndef BOOST_ARCHIVE_BASIC_TEXT_OARCHIVE_HPP
|
||||
#define BOOST_ARCHIVE_BASIC_TEXT_OARCHIVE_HPP
|
||||
|
||||
// MS compatible compilers support #pragma once
|
||||
#if defined(_MSC_VER) && (_MSC_VER >= 1020)
|
||||
# pragma once
|
||||
#endif
|
||||
|
||||
/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
|
||||
// basic_text_oarchive.hpp
|
||||
|
||||
// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
|
||||
// Use, modification and distribution is subject to the Boost Software
|
||||
// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
// See http://www.boost.org for updates, documentation, and revision history.
|
||||
|
||||
// archives stored as text - note these ar templated on the basic
|
||||
// stream templates to accommodate wide (and other?) kind of characters
|
||||
//
|
||||
// note the fact that on libraries without wide characters, ostream is
|
||||
// is not a specialization of basic_ostream which in fact is not defined
|
||||
// in such cases. So we can't use basic_ostream<OStream::char_type> but rather
|
||||
// use two template parameters
|
||||
|
||||
#include <boost/assert.hpp>
|
||||
#include <boost/config.hpp>
|
||||
#include <boost/serialization/pfto.hpp>
|
||||
#include <boost/detail/workaround.hpp>
|
||||
|
||||
#include <boost/archive/detail/common_oarchive.hpp>
|
||||
#include <boost/serialization/string.hpp>
|
||||
|
||||
#include <boost/archive/detail/abi_prefix.hpp> // must be the last header
|
||||
|
||||
#ifdef BOOST_MSVC
|
||||
# pragma warning(push)
|
||||
# pragma warning(disable : 4511 4512)
|
||||
#endif
|
||||
|
||||
namespace boost {
|
||||
namespace archive {
|
||||
|
||||
/////////////////////////////////////////////////////////////////////////
|
||||
// class basic_text_oarchive
|
||||
template<class Archive>
|
||||
class basic_text_oarchive :
|
||||
public detail::common_oarchive<Archive>
|
||||
{
|
||||
protected:
|
||||
#if BOOST_WORKAROUND(BOOST_MSVC, <= 1300) \
|
||||
|| BOOST_WORKAROUND(__BORLANDC__,BOOST_TESTED_AT(0x560))
|
||||
public:
|
||||
#elif defined(BOOST_MSVC)
|
||||
// for some inexplicable reason insertion of "class" generates compile erro
|
||||
// on msvc 7.1
|
||||
friend detail::interface_oarchive<Archive>;
|
||||
#else
|
||||
friend class detail::interface_oarchive<Archive>;
|
||||
#endif
|
||||
enum {
|
||||
none,
|
||||
eol,
|
||||
space
|
||||
} delimiter;
|
||||
|
||||
BOOST_ARCHIVE_OR_WARCHIVE_DECL(void)
|
||||
newtoken();
|
||||
|
||||
void newline(){
|
||||
delimiter = eol;
|
||||
}
|
||||
|
||||
// default processing - kick back to base class. Note the
|
||||
// extra stuff to get it passed borland compilers
|
||||
typedef detail::common_oarchive<Archive> detail_common_oarchive;
|
||||
template<class T>
|
||||
void save_override(T & t, BOOST_PFTO int){
|
||||
this->detail_common_oarchive::save_override(t, 0);
|
||||
}
|
||||
|
||||
// start new objects on a new line
|
||||
void save_override(const object_id_type & t, int){
|
||||
this->This()->newline();
|
||||
this->detail_common_oarchive::save_override(t, 0);
|
||||
}
|
||||
|
||||
// text file don't include the optional information
|
||||
void save_override(const class_id_optional_type & /* t */, int){}
|
||||
|
||||
void save_override(const class_name_type & t, int){
|
||||
const std::string s(t);
|
||||
* this->This() << s;
|
||||
}
|
||||
|
||||
BOOST_ARCHIVE_OR_WARCHIVE_DECL(void)
|
||||
init();
|
||||
|
||||
basic_text_oarchive(unsigned int flags) :
|
||||
detail::common_oarchive<Archive>(flags),
|
||||
delimiter(none)
|
||||
{}
|
||||
~basic_text_oarchive(){}
|
||||
};
|
||||
|
||||
} // namespace archive
|
||||
} // namespace boost
|
||||
|
||||
#ifdef BOOST_MSVC
|
||||
#pragma warning(pop)
|
||||
#endif
|
||||
|
||||
#include <boost/archive/detail/abi_suffix.hpp> // pops abi_suffix.hpp pragmas
|
||||
|
||||
#endif // BOOST_ARCHIVE_BASIC_TEXT_OARCHIVE_HPP
|
||||
|
|
@ -0,0 +1,173 @@
|
|||
#ifndef BOOST_ARCHIVE_BASIC_TEXT_OPRIMITIVE_HPP
|
||||
#define BOOST_ARCHIVE_BASIC_TEXT_OPRIMITIVE_HPP
|
||||
|
||||
// MS compatible compilers support #pragma once
|
||||
#if defined(_MSC_VER) && (_MSC_VER >= 1020)
|
||||
# pragma once
|
||||
#endif
|
||||
|
||||
/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
|
||||
// basic_text_oprimitive.hpp
|
||||
|
||||
// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
|
||||
// Use, modification and distribution is subject to the Boost Software
|
||||
// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
// See http://www.boost.org for updates, documentation, and revision history.
|
||||
|
||||
// archives stored as text - note these ar templated on the basic
|
||||
// stream templates to accommodate wide (and other?) kind of characters
|
||||
//
|
||||
// note the fact that on libraries without wide characters, ostream is
|
||||
// is not a specialization of basic_ostream which in fact is not defined
|
||||
// in such cases. So we can't use basic_ostream<OStream::char_type> but rather
|
||||
// use two template parameters
|
||||
|
||||
#include <iomanip>
|
||||
#include <locale>
|
||||
#include <boost/config/no_tr1/cmath.hpp> // isnan
|
||||
#include <boost/assert.hpp>
|
||||
#include <cstddef> // size_t
|
||||
|
||||
#include <boost/config.hpp>
|
||||
#include <boost/static_assert.hpp>
|
||||
#include <boost/detail/workaround.hpp>
|
||||
#if BOOST_WORKAROUND(BOOST_DINKUMWARE_STDLIB, == 1)
|
||||
#include <boost/archive/dinkumware.hpp>
|
||||
#endif
|
||||
|
||||
#if defined(BOOST_NO_STDC_NAMESPACE)
|
||||
namespace std{
|
||||
using ::size_t;
|
||||
#if ! defined(BOOST_DINKUMWARE_STDLIB) && ! defined(__SGI_STL_PORT)
|
||||
using ::locale;
|
||||
#endif
|
||||
} // namespace std
|
||||
#endif
|
||||
|
||||
#include <boost/limits.hpp>
|
||||
#include <boost/integer.hpp>
|
||||
#include <boost/io/ios_state.hpp>
|
||||
#include <boost/scoped_ptr.hpp>
|
||||
#include <boost/serialization/throw_exception.hpp>
|
||||
#include <boost/archive/archive_exception.hpp>
|
||||
#include <boost/archive/basic_streambuf_locale_saver.hpp>
|
||||
#include <boost/archive/detail/abi_prefix.hpp> // must be the last header
|
||||
|
||||
namespace boost {
|
||||
namespace archive {
|
||||
|
||||
class save_access;
|
||||
|
||||
/////////////////////////////////////////////////////////////////////////
|
||||
// class basic_text_oprimitive - output of prmitives to stream
|
||||
template<class OStream>
|
||||
class basic_text_oprimitive
|
||||
{
|
||||
#ifndef BOOST_NO_MEMBER_TEMPLATE_FRIENDS
|
||||
protected:
|
||||
#else
|
||||
public:
|
||||
#endif
|
||||
OStream &os;
|
||||
io::ios_flags_saver flags_saver;
|
||||
io::ios_precision_saver precision_saver;
|
||||
|
||||
#ifndef BOOST_NO_STD_LOCALE
|
||||
boost::scoped_ptr<std::locale> archive_locale;
|
||||
basic_streambuf_locale_saver<
|
||||
BOOST_DEDUCED_TYPENAME OStream::char_type,
|
||||
BOOST_DEDUCED_TYPENAME OStream::traits_type
|
||||
> locale_saver;
|
||||
#endif
|
||||
|
||||
// default saving of primitives.
|
||||
template<class T>
|
||||
void save(const T &t){
|
||||
if(os.fail())
|
||||
boost::serialization::throw_exception(
|
||||
archive_exception(archive_exception::output_stream_error)
|
||||
);
|
||||
os << t;
|
||||
}
|
||||
|
||||
/////////////////////////////////////////////////////////
|
||||
// fundamental types that need special treatment
|
||||
void save(const bool t){
|
||||
// trap usage of invalid uninitialized boolean which would
|
||||
// otherwise crash on load.
|
||||
BOOST_ASSERT(0 == static_cast<int>(t) || 1 == static_cast<int>(t));
|
||||
if(os.fail())
|
||||
boost::serialization::throw_exception(
|
||||
archive_exception(archive_exception::output_stream_error)
|
||||
);
|
||||
os << t;
|
||||
}
|
||||
void save(const signed char t)
|
||||
{
|
||||
save(static_cast<short int>(t));
|
||||
}
|
||||
void save(const unsigned char t)
|
||||
{
|
||||
save(static_cast<short unsigned int>(t));
|
||||
}
|
||||
void save(const char t)
|
||||
{
|
||||
save(static_cast<short int>(t));
|
||||
}
|
||||
#ifndef BOOST_NO_INTRINSIC_WCHAR_T
|
||||
void save(const wchar_t t)
|
||||
{
|
||||
BOOST_STATIC_ASSERT(sizeof(wchar_t) <= sizeof(int));
|
||||
save(static_cast<int>(t));
|
||||
}
|
||||
#endif
|
||||
void save(const float t)
|
||||
{
|
||||
// must be a user mistake - can't serialize un-initialized data
|
||||
if(os.fail())
|
||||
boost::serialization::throw_exception(
|
||||
archive_exception(archive_exception::output_stream_error)
|
||||
);
|
||||
os << std::setprecision(std::numeric_limits<float>::digits10 + 2);
|
||||
os << t;
|
||||
}
|
||||
void save(const double t)
|
||||
{
|
||||
// must be a user mistake - can't serialize un-initialized data
|
||||
if(os.fail())
|
||||
boost::serialization::throw_exception(
|
||||
archive_exception(archive_exception::output_stream_error)
|
||||
);
|
||||
os << std::setprecision(std::numeric_limits<double>::digits10 + 2);
|
||||
os << t;
|
||||
}
|
||||
BOOST_ARCHIVE_OR_WARCHIVE_DECL(BOOST_PP_EMPTY())
|
||||
basic_text_oprimitive(OStream & os, bool no_codecvt);
|
||||
BOOST_ARCHIVE_OR_WARCHIVE_DECL(BOOST_PP_EMPTY())
|
||||
~basic_text_oprimitive();
|
||||
public:
|
||||
// unformatted append of one character
|
||||
void put(BOOST_DEDUCED_TYPENAME OStream::char_type c){
|
||||
if(os.fail())
|
||||
boost::serialization::throw_exception(
|
||||
archive_exception(archive_exception::output_stream_error)
|
||||
);
|
||||
os.put(c);
|
||||
}
|
||||
// unformatted append of null terminated string
|
||||
void put(const char * s){
|
||||
while('\0' != *s)
|
||||
os.put(*s++);
|
||||
}
|
||||
BOOST_ARCHIVE_OR_WARCHIVE_DECL(void)
|
||||
save_binary(const void *address, std::size_t count);
|
||||
};
|
||||
|
||||
} //namespace boost
|
||||
} //namespace archive
|
||||
|
||||
#include <boost/archive/detail/abi_suffix.hpp> // pops abi_suffix.hpp pragmas
|
||||
|
||||
#endif // BOOST_ARCHIVE_BASIC_TEXT_OPRIMITIVE_HPP
|
||||
|
|
@ -0,0 +1,67 @@
|
|||
#ifndef BOOST_ARCHIVE_BASIC_XML_TEXT_ARCHIVE_HPP
|
||||
#define BOOST_ARCHIVE_BASIC_XML_TEXT_ARCHIVE_HPP
|
||||
|
||||
// MS compatible compilers support #pragma once
|
||||
#if defined(_MSC_VER) && (_MSC_VER >= 1020)
|
||||
# pragma once
|
||||
#endif
|
||||
|
||||
/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
|
||||
// basic_xml_archive.hpp:
|
||||
|
||||
// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
|
||||
// Use, modification and distribution is subject to the Boost Software
|
||||
// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
// See http://www.boost.org for updates, documentation, and revision history.
|
||||
|
||||
#include <boost/archive/archive_exception.hpp>
|
||||
|
||||
#include <boost/archive/detail/auto_link_archive.hpp>
|
||||
#include <boost/archive/detail/abi_prefix.hpp> // must be the last header
|
||||
|
||||
namespace boost {
|
||||
namespace archive {
|
||||
|
||||
// constant strings used in xml i/o
|
||||
|
||||
extern
|
||||
BOOST_ARCHIVE_DECL(const char *)
|
||||
BOOST_ARCHIVE_XML_OBJECT_ID();
|
||||
|
||||
extern
|
||||
BOOST_ARCHIVE_DECL(const char *)
|
||||
BOOST_ARCHIVE_XML_OBJECT_REFERENCE();
|
||||
|
||||
extern
|
||||
BOOST_ARCHIVE_DECL(const char *)
|
||||
BOOST_ARCHIVE_XML_CLASS_ID();
|
||||
|
||||
extern
|
||||
BOOST_ARCHIVE_DECL(const char *)
|
||||
BOOST_ARCHIVE_XML_CLASS_ID_REFERENCE();
|
||||
|
||||
extern
|
||||
BOOST_ARCHIVE_DECL(const char *)
|
||||
BOOST_ARCHIVE_XML_CLASS_NAME();
|
||||
|
||||
extern
|
||||
BOOST_ARCHIVE_DECL(const char *)
|
||||
BOOST_ARCHIVE_XML_TRACKING();
|
||||
|
||||
extern
|
||||
BOOST_ARCHIVE_DECL(const char *)
|
||||
BOOST_ARCHIVE_XML_VERSION();
|
||||
|
||||
extern
|
||||
BOOST_ARCHIVE_DECL(const char *)
|
||||
BOOST_ARCHIVE_XML_SIGNATURE();
|
||||
|
||||
}// namespace archive
|
||||
}// namespace boost
|
||||
|
||||
#include <boost/archive/detail/abi_suffix.hpp> // pops abi_suffix.hpp pragmas
|
||||
|
||||
#endif // BOOST_ARCHIVE_BASIC_XML_TEXT_ARCHIVE_HPP
|
||||
|
||||
|
|
@ -0,0 +1,127 @@
|
|||
#ifndef BOOST_ARCHIVE_BASIC_XML_IARCHIVE_HPP
|
||||
#define BOOST_ARCHIVE_BASIC_XML_IARCHIVE_HPP
|
||||
|
||||
// MS compatible compilers support #pragma once
|
||||
#if defined(_MSC_VER) && (_MSC_VER >= 1020)
|
||||
# pragma once
|
||||
#endif
|
||||
|
||||
/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
|
||||
// basic_xml_iarchive.hpp
|
||||
|
||||
// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
|
||||
// Use, modification and distribution is subject to the Boost Software
|
||||
// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
// See http://www.boost.org for updates, documentation, and revision history.
|
||||
|
||||
#include <boost/config.hpp>
|
||||
#include <boost/serialization/pfto.hpp>
|
||||
#include <boost/detail/workaround.hpp>
|
||||
|
||||
#include <boost/archive/detail/common_iarchive.hpp>
|
||||
|
||||
#include <boost/serialization/nvp.hpp>
|
||||
#include <boost/serialization/string.hpp>
|
||||
|
||||
#include <boost/mpl/assert.hpp>
|
||||
|
||||
#include <boost/archive/detail/abi_prefix.hpp> // must be the last header
|
||||
|
||||
#ifdef BOOST_MSVC
|
||||
# pragma warning(push)
|
||||
# pragma warning(disable : 4511 4512)
|
||||
#endif
|
||||
|
||||
namespace boost {
|
||||
namespace archive {
|
||||
|
||||
/////////////////////////////////////////////////////////////////////////
|
||||
// class xml_iarchive - read serialized objects from a input text stream
|
||||
template<class Archive>
|
||||
class basic_xml_iarchive :
|
||||
public detail::common_iarchive<Archive>
|
||||
{
|
||||
protected:
|
||||
#if BOOST_WORKAROUND(BOOST_MSVC, <= 1300)
|
||||
public:
|
||||
#elif defined(BOOST_MSVC)
|
||||
// for some inexplicable reason insertion of "class" generates compile erro
|
||||
// on msvc 7.1
|
||||
friend detail::interface_oarchive<Archive>;
|
||||
#else
|
||||
friend class detail::interface_oarchive<Archive>;
|
||||
#endif
|
||||
unsigned int depth;
|
||||
BOOST_ARCHIVE_OR_WARCHIVE_DECL(void)
|
||||
load_start(const char *name);
|
||||
BOOST_ARCHIVE_OR_WARCHIVE_DECL(void)
|
||||
load_end(const char *name);
|
||||
|
||||
// Anything not an attribute and not a name-value pair is an
|
||||
// should be trapped here.
|
||||
template<class T>
|
||||
void load_override(T & t, BOOST_PFTO int)
|
||||
{
|
||||
// If your program fails to compile here, its most likely due to
|
||||
// not specifying an nvp wrapper around the variable to
|
||||
// be serialized.
|
||||
BOOST_MPL_ASSERT((serialization::is_wrapper< T >));
|
||||
this->detail_common_iarchive::load_override(t, 0);
|
||||
}
|
||||
|
||||
// Anything not an attribute - see below - should be a name value
|
||||
// pair and be processed here
|
||||
typedef detail::common_iarchive<Archive> detail_common_iarchive;
|
||||
template<class T>
|
||||
void load_override(
|
||||
#ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING
|
||||
const
|
||||
#endif
|
||||
boost::serialization::nvp< T > & t,
|
||||
int
|
||||
){
|
||||
this->This()->load_start(t.name());
|
||||
this->detail_common_iarchive::load_override(t.value(), 0);
|
||||
this->This()->load_end(t.name());
|
||||
}
|
||||
|
||||
// specific overrides for attributes - handle as
|
||||
// primitives. These are not name-value pairs
|
||||
// so they have to be intercepted here and passed on to load.
|
||||
// although the class_id is included in the xml text file in order
|
||||
// to make the file self describing, it isn't used when loading
|
||||
// an xml archive. So we can skip it here. Note: we MUST override
|
||||
// it otherwise it will be loaded as a normal primitive w/o tag and
|
||||
// leaving the archive in an undetermined state
|
||||
void load_override(class_id_optional_type & /* t */, int){}
|
||||
BOOST_ARCHIVE_OR_WARCHIVE_DECL(void)
|
||||
load_override(object_id_type & t, int);
|
||||
BOOST_ARCHIVE_OR_WARCHIVE_DECL(void)
|
||||
load_override(version_type & t, int);
|
||||
BOOST_ARCHIVE_OR_WARCHIVE_DECL(void)
|
||||
load_override(class_id_type & t, int);
|
||||
BOOST_ARCHIVE_OR_WARCHIVE_DECL(void)
|
||||
load_override(tracking_type & t, int);
|
||||
// class_name_type can't be handled here as it depends upon the
|
||||
// char type used by the stream. So require the derived implementation
|
||||
// handle this.
|
||||
// void load_override(class_name_type & t, int);
|
||||
|
||||
BOOST_ARCHIVE_OR_WARCHIVE_DECL(BOOST_PP_EMPTY())
|
||||
basic_xml_iarchive(unsigned int flags);
|
||||
BOOST_ARCHIVE_OR_WARCHIVE_DECL(BOOST_PP_EMPTY())
|
||||
~basic_xml_iarchive();
|
||||
};
|
||||
|
||||
} // namespace archive
|
||||
} // namespace boost
|
||||
|
||||
#ifdef BOOST_MSVC
|
||||
#pragma warning(pop)
|
||||
#endif
|
||||
|
||||
#include <boost/archive/detail/abi_suffix.hpp> // pops abi_suffix.hpp pragmas
|
||||
|
||||
#endif // BOOST_ARCHIVE_BASIC_XML_IARCHIVE_HPP
|
||||
|
|
@ -0,0 +1,145 @@
|
|||
#ifndef BOOST_ARCHIVE_BASIC_XML_OARCHIVE_HPP
|
||||
#define BOOST_ARCHIVE_BASIC_XML_OARCHIVE_HPP
|
||||
|
||||
// MS compatible compilers support #pragma once
|
||||
#if defined(_MSC_VER) && (_MSC_VER >= 1020)
|
||||
# pragma once
|
||||
#endif
|
||||
|
||||
/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
|
||||
// basic_xml_oarchive.hpp
|
||||
|
||||
// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
|
||||
// Use, modification and distribution is subject to the Boost Software
|
||||
// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
// See http://www.boost.org for updates, documentation, and revision history.
|
||||
|
||||
#include <boost/config.hpp>
|
||||
|
||||
#include <boost/archive/detail/common_oarchive.hpp>
|
||||
|
||||
#include <boost/serialization/nvp.hpp>
|
||||
#include <boost/serialization/tracking.hpp>
|
||||
#include <boost/serialization/string.hpp>
|
||||
|
||||
#include <boost/mpl/assert.hpp>
|
||||
|
||||
#include <boost/archive/detail/abi_prefix.hpp> // must be the last header
|
||||
|
||||
#ifdef BOOST_MSVC
|
||||
# pragma warning(push)
|
||||
# pragma warning(disable : 4511 4512)
|
||||
#endif
|
||||
|
||||
namespace boost {
|
||||
namespace archive {
|
||||
|
||||
//////////////////////////////////////////////////////////////////////
|
||||
// class basic_xml_oarchive - write serialized objects to a xml output stream
|
||||
template<class Archive>
|
||||
class basic_xml_oarchive :
|
||||
public detail::common_oarchive<Archive>
|
||||
{
|
||||
protected:
|
||||
#if BOOST_WORKAROUND(BOOST_MSVC, <= 1300)
|
||||
public:
|
||||
#elif defined(BOOST_MSVC)
|
||||
// for some inexplicable reason insertion of "class" generates compile erro
|
||||
// on msvc 7.1
|
||||
friend detail::interface_oarchive<Archive>;
|
||||
friend class save_access;
|
||||
#else
|
||||
friend class detail::interface_oarchive<Archive>;
|
||||
friend class save_access;
|
||||
#endif
|
||||
// special stuff for xml output
|
||||
unsigned int depth;
|
||||
bool indent_next;
|
||||
bool pending_preamble;
|
||||
BOOST_ARCHIVE_OR_WARCHIVE_DECL(void)
|
||||
indent();
|
||||
BOOST_ARCHIVE_OR_WARCHIVE_DECL(void)
|
||||
init();
|
||||
BOOST_ARCHIVE_OR_WARCHIVE_DECL(void)
|
||||
write_attribute(
|
||||
const char *attribute_name,
|
||||
int t,
|
||||
const char *conjunction = "=\""
|
||||
);
|
||||
BOOST_ARCHIVE_OR_WARCHIVE_DECL(void)
|
||||
write_attribute(
|
||||
const char *attribute_name,
|
||||
const char *key
|
||||
);
|
||||
// helpers used below
|
||||
BOOST_ARCHIVE_OR_WARCHIVE_DECL(void)
|
||||
save_start(const char *name);
|
||||
BOOST_ARCHIVE_OR_WARCHIVE_DECL(void)
|
||||
save_end(const char *name);
|
||||
BOOST_ARCHIVE_OR_WARCHIVE_DECL(void)
|
||||
end_preamble();
|
||||
|
||||
// Anything not an attribute and not a name-value pair is an
|
||||
// error and should be trapped here.
|
||||
template<class T>
|
||||
void save_override(T & t, BOOST_PFTO int)
|
||||
{
|
||||
// If your program fails to compile here, its most likely due to
|
||||
// not specifying an nvp wrapper around the variable to
|
||||
// be serialized.
|
||||
BOOST_MPL_ASSERT((serialization::is_wrapper< T >));
|
||||
this->detail_common_oarchive::save_override(t, 0);
|
||||
}
|
||||
|
||||
// special treatment for name-value pairs.
|
||||
typedef detail::common_oarchive<Archive> detail_common_oarchive;
|
||||
template<class T>
|
||||
void save_override(
|
||||
#ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING
|
||||
const
|
||||
#endif
|
||||
::boost::serialization::nvp< T > & t,
|
||||
int
|
||||
){
|
||||
this->This()->save_start(t.name());
|
||||
this->detail_common_oarchive::save_override(t.const_value(), 0);
|
||||
this->This()->save_end(t.name());
|
||||
}
|
||||
|
||||
// specific overrides for attributes - not name value pairs so we
|
||||
// want to trap them before the above "fall through"
|
||||
BOOST_ARCHIVE_OR_WARCHIVE_DECL(void)
|
||||
save_override(const object_id_type & t, int);
|
||||
BOOST_ARCHIVE_OR_WARCHIVE_DECL(void)
|
||||
save_override(const object_reference_type & t, int);
|
||||
BOOST_ARCHIVE_OR_WARCHIVE_DECL(void)
|
||||
save_override(const version_type & t, int);
|
||||
BOOST_ARCHIVE_OR_WARCHIVE_DECL(void)
|
||||
save_override(const class_id_type & t, int);
|
||||
BOOST_ARCHIVE_OR_WARCHIVE_DECL(void)
|
||||
save_override(const class_id_optional_type & t, int);
|
||||
BOOST_ARCHIVE_OR_WARCHIVE_DECL(void)
|
||||
save_override(const class_id_reference_type & t, int);
|
||||
BOOST_ARCHIVE_OR_WARCHIVE_DECL(void)
|
||||
save_override(const class_name_type & t, int);
|
||||
BOOST_ARCHIVE_OR_WARCHIVE_DECL(void)
|
||||
save_override(const tracking_type & t, int);
|
||||
|
||||
BOOST_ARCHIVE_OR_WARCHIVE_DECL(BOOST_PP_EMPTY())
|
||||
basic_xml_oarchive(unsigned int flags);
|
||||
BOOST_ARCHIVE_OR_WARCHIVE_DECL(BOOST_PP_EMPTY())
|
||||
~basic_xml_oarchive();
|
||||
};
|
||||
|
||||
} // namespace archive
|
||||
} // namespace boost
|
||||
|
||||
#ifdef BOOST_MSVC
|
||||
#pragma warning(pop)
|
||||
#endif
|
||||
|
||||
#include <boost/archive/detail/abi_suffix.hpp> // pops abi_suffix.hpp pragmas
|
||||
|
||||
#endif // BOOST_ARCHIVE_BASIC_XML_OARCHIVE_HPP
|
||||
|
|
@ -0,0 +1,103 @@
|
|||
#ifndef BOOST_ARCHIVE_BINARY_IARCHIVE_HPP
|
||||
#define BOOST_ARCHIVE_BINARY_IARCHIVE_HPP
|
||||
|
||||
// MS compatible compilers support #pragma once
|
||||
#if defined(_MSC_VER) && (_MSC_VER >= 1020)
|
||||
# pragma once
|
||||
#endif
|
||||
|
||||
/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
|
||||
// binary_iarchive.hpp
|
||||
|
||||
// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
|
||||
// Use, modification and distribution is subject to the Boost Software
|
||||
// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
// See http://www.boost.org for updates, documentation, and revision history.
|
||||
|
||||
#include <istream>
|
||||
#include <boost/archive/binary_iarchive_impl.hpp>
|
||||
#include <boost/archive/detail/register_archive.hpp>
|
||||
|
||||
#ifdef BOOST_MSVC
|
||||
# pragma warning(push)
|
||||
# pragma warning(disable : 4511 4512)
|
||||
#endif
|
||||
|
||||
namespace boost {
|
||||
namespace archive {
|
||||
|
||||
// do not derive from the classes below. If you want to extend this functionality
|
||||
// via inhertance, derived from text_iarchive_impl instead. This will
|
||||
// preserve correct static polymorphism.
|
||||
|
||||
// same as binary_iarchive below - without the shared_ptr_helper
|
||||
class naked_binary_iarchive :
|
||||
public binary_iarchive_impl<
|
||||
boost::archive::naked_binary_iarchive,
|
||||
std::istream::char_type,
|
||||
std::istream::traits_type
|
||||
>
|
||||
{
|
||||
public:
|
||||
naked_binary_iarchive(std::istream & is, unsigned int flags = 0) :
|
||||
binary_iarchive_impl<
|
||||
naked_binary_iarchive, std::istream::char_type, std::istream::traits_type
|
||||
>(is, flags)
|
||||
{}
|
||||
naked_binary_iarchive(std::streambuf & bsb, unsigned int flags = 0) :
|
||||
binary_iarchive_impl<
|
||||
naked_binary_iarchive, std::istream::char_type, std::istream::traits_type
|
||||
>(bsb, flags)
|
||||
{}
|
||||
};
|
||||
|
||||
} // namespace archive
|
||||
} // namespace boost
|
||||
|
||||
// note special treatment of shared_ptr. This type needs a special
|
||||
// structure associated with every archive. We created a "mix-in"
|
||||
// class to provide this functionality. Since shared_ptr holds a
|
||||
// special esteem in the boost library - we included it here by default.
|
||||
#include <boost/archive/shared_ptr_helper.hpp>
|
||||
|
||||
namespace boost {
|
||||
namespace archive {
|
||||
|
||||
// do not derive from this class. If you want to extend this functionality
|
||||
// via inhertance, derived from binary_iarchive_impl instead. This will
|
||||
// preserve correct static polymorphism.
|
||||
class binary_iarchive :
|
||||
public binary_iarchive_impl<
|
||||
boost::archive::binary_iarchive,
|
||||
std::istream::char_type,
|
||||
std::istream::traits_type
|
||||
>,
|
||||
public detail::shared_ptr_helper
|
||||
{
|
||||
public:
|
||||
binary_iarchive(std::istream & is, unsigned int flags = 0) :
|
||||
binary_iarchive_impl<
|
||||
binary_iarchive, std::istream::char_type, std::istream::traits_type
|
||||
>(is, flags)
|
||||
{}
|
||||
binary_iarchive(std::streambuf & bsb, unsigned int flags = 0) :
|
||||
binary_iarchive_impl<
|
||||
binary_iarchive, std::istream::char_type, std::istream::traits_type
|
||||
>(bsb, flags)
|
||||
{}
|
||||
};
|
||||
|
||||
} // namespace archive
|
||||
} // namespace boost
|
||||
|
||||
// required by export
|
||||
BOOST_SERIALIZATION_REGISTER_ARCHIVE(boost::archive::binary_iarchive)
|
||||
BOOST_SERIALIZATION_USE_ARRAY_OPTIMIZATION(boost::archive::binary_iarchive)
|
||||
|
||||
#ifdef BOOST_MSVC
|
||||
#pragma warning(pop)
|
||||
#endif
|
||||
|
||||
#endif // BOOST_ARCHIVE_BINARY_IARCHIVE_HPP
|
||||
|
|
@ -0,0 +1,96 @@
|
|||
#ifndef BOOST_ARCHIVE_BINARY_IARCHIVE_IMPL_HPP
|
||||
#define BOOST_ARCHIVE_BINARY_IARCHIVE_IMPL_HPP
|
||||
|
||||
// MS compatible compilers support #pragma once
|
||||
#if defined(_MSC_VER) && (_MSC_VER >= 1020)
|
||||
# pragma once
|
||||
#endif
|
||||
|
||||
/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
|
||||
// binary_iarchive_impl.hpp
|
||||
|
||||
// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
|
||||
// Use, modification and distribution is subject to the Boost Software
|
||||
// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
// See http://www.boost.org for updates, documentation, and revision history.
|
||||
|
||||
#include <istream>
|
||||
#include <boost/serialization/pfto.hpp>
|
||||
#include <boost/archive/basic_binary_iprimitive.hpp>
|
||||
#include <boost/archive/basic_binary_iarchive.hpp>
|
||||
|
||||
#ifdef BOOST_MSVC
|
||||
# pragma warning(push)
|
||||
# pragma warning(disable : 4511 4512)
|
||||
#endif
|
||||
|
||||
namespace boost {
|
||||
namespace archive {
|
||||
|
||||
template<class Archive, class Elem, class Tr>
|
||||
class binary_iarchive_impl :
|
||||
public basic_binary_iprimitive<Archive, Elem, Tr>,
|
||||
public basic_binary_iarchive<Archive>
|
||||
{
|
||||
#ifdef BOOST_NO_MEMBER_TEMPLATE_FRIENDS
|
||||
public:
|
||||
#else
|
||||
friend class detail::interface_iarchive<Archive>;
|
||||
friend class basic_binary_iarchive<Archive>;
|
||||
friend class load_access;
|
||||
protected:
|
||||
#endif
|
||||
// note: the following should not needed - but one compiler (vc 7.1)
|
||||
// fails to compile one test (test_shared_ptr) without it !!!
|
||||
// make this protected so it can be called from a derived archive
|
||||
template<class T>
|
||||
void load_override(T & t, BOOST_PFTO int){
|
||||
this->basic_binary_iarchive<Archive>::load_override(t, 0L);
|
||||
}
|
||||
void init(unsigned int flags){
|
||||
if(0 != (flags & no_header))
|
||||
return;
|
||||
#if ! defined(__MWERKS__)
|
||||
this->basic_binary_iarchive<Archive>::init();
|
||||
this->basic_binary_iprimitive<Archive, Elem, Tr>::init();
|
||||
#else
|
||||
basic_binary_iarchive<Archive>::init();
|
||||
basic_binary_iprimitive<Archive, Elem, Tr>::init();
|
||||
#endif
|
||||
}
|
||||
binary_iarchive_impl(
|
||||
std::basic_streambuf<Elem, Tr> & bsb,
|
||||
unsigned int flags
|
||||
) :
|
||||
basic_binary_iprimitive<Archive, Elem, Tr>(
|
||||
bsb,
|
||||
0 != (flags & no_codecvt)
|
||||
),
|
||||
basic_binary_iarchive<Archive>(flags)
|
||||
{
|
||||
init(flags);
|
||||
}
|
||||
binary_iarchive_impl(
|
||||
std::basic_istream<Elem, Tr> & is,
|
||||
unsigned int flags
|
||||
) :
|
||||
basic_binary_iprimitive<Archive, Elem, Tr>(
|
||||
* is.rdbuf(),
|
||||
0 != (flags & no_codecvt)
|
||||
),
|
||||
basic_binary_iarchive<Archive>(flags)
|
||||
{
|
||||
init(flags);
|
||||
}
|
||||
};
|
||||
|
||||
} // namespace archive
|
||||
} // namespace boost
|
||||
|
||||
#ifdef BOOST_MSVC
|
||||
#pragma warning(pop)
|
||||
#endif
|
||||
|
||||
#endif // BOOST_ARCHIVE_BINARY_IARCHIVE_IMPL_HPP
|
||||
|
|
@ -0,0 +1,66 @@
|
|||
#ifndef BOOST_ARCHIVE_BINARY_OARCHIVE_HPP
|
||||
#define BOOST_ARCHIVE_BINARY_OARCHIVE_HPP
|
||||
|
||||
// MS compatible compilers support #pragma once
|
||||
#if defined(_MSC_VER) && (_MSC_VER >= 1020)
|
||||
# pragma once
|
||||
#endif
|
||||
|
||||
/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
|
||||
// binary_oarchive.hpp
|
||||
|
||||
// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
|
||||
// Use, modification and distribution is subject to the Boost Software
|
||||
// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
// See http://www.boost.org for updates, documentation, and revision history.
|
||||
|
||||
#include <ostream>
|
||||
#include <boost/config.hpp>
|
||||
#include <boost/archive/binary_oarchive_impl.hpp>
|
||||
#include <boost/archive/detail/register_archive.hpp>
|
||||
|
||||
#ifdef BOOST_MSVC
|
||||
# pragma warning(push)
|
||||
# pragma warning(disable : 4511 4512)
|
||||
#endif
|
||||
|
||||
namespace boost {
|
||||
namespace archive {
|
||||
|
||||
// do not derive from this class. If you want to extend this functionality
|
||||
// via inhertance, derived from binary_oarchive_impl instead. This will
|
||||
// preserve correct static polymorphism.
|
||||
class binary_oarchive :
|
||||
public binary_oarchive_impl<
|
||||
binary_oarchive, std::ostream::char_type, std::ostream::traits_type
|
||||
>
|
||||
{
|
||||
public:
|
||||
binary_oarchive(std::ostream & os, unsigned int flags = 0) :
|
||||
binary_oarchive_impl<
|
||||
binary_oarchive, std::ostream::char_type, std::ostream::traits_type
|
||||
>(os, flags)
|
||||
{}
|
||||
binary_oarchive(std::streambuf & bsb, unsigned int flags = 0) :
|
||||
binary_oarchive_impl<
|
||||
binary_oarchive, std::ostream::char_type, std::ostream::traits_type
|
||||
>(bsb, flags)
|
||||
{}
|
||||
};
|
||||
|
||||
typedef binary_oarchive naked_binary_oarchive;
|
||||
|
||||
} // namespace archive
|
||||
} // namespace boost
|
||||
|
||||
// required by export
|
||||
BOOST_SERIALIZATION_REGISTER_ARCHIVE(boost::archive::binary_oarchive)
|
||||
BOOST_SERIALIZATION_USE_ARRAY_OPTIMIZATION(boost::archive::binary_oarchive)
|
||||
|
||||
#ifdef BOOST_MSVC
|
||||
#pragma warning(pop)
|
||||
#endif
|
||||
|
||||
#endif // BOOST_ARCHIVE_BINARY_OARCHIVE_HPP
|
||||
|
|
@ -0,0 +1,97 @@
|
|||
#ifndef BOOST_ARCHIVE_BINARY_OARCHIVE_IMPL_HPP
|
||||
#define BOOST_ARCHIVE_BINARY_OARCHIVE_IMPL_HPP
|
||||
|
||||
// MS compatible compilers support #pragma once
|
||||
#if defined(_MSC_VER) && (_MSC_VER >= 1020)
|
||||
# pragma once
|
||||
#endif
|
||||
|
||||
/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
|
||||
// binary_oarchive_impl.hpp
|
||||
|
||||
// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
|
||||
// Use, modification and distribution is subject to the Boost Software
|
||||
// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
// See http://www.boost.org for updates, documentation, and revision history.
|
||||
|
||||
#include <ostream>
|
||||
#include <boost/config.hpp>
|
||||
#include <boost/serialization/pfto.hpp>
|
||||
#include <boost/archive/basic_binary_oprimitive.hpp>
|
||||
#include <boost/archive/basic_binary_oarchive.hpp>
|
||||
|
||||
#ifdef BOOST_MSVC
|
||||
# pragma warning(push)
|
||||
# pragma warning(disable : 4511 4512)
|
||||
#endif
|
||||
|
||||
namespace boost {
|
||||
namespace archive {
|
||||
|
||||
template<class Archive, class Elem, class Tr>
|
||||
class binary_oarchive_impl :
|
||||
public basic_binary_oprimitive<Archive, Elem, Tr>,
|
||||
public basic_binary_oarchive<Archive>
|
||||
{
|
||||
#ifdef BOOST_NO_MEMBER_TEMPLATE_FRIENDS
|
||||
public:
|
||||
#else
|
||||
friend class detail::interface_oarchive<Archive>;
|
||||
friend class basic_binary_oarchive<Archive>;
|
||||
friend class save_access;
|
||||
protected:
|
||||
#endif
|
||||
// note: the following should not needed - but one compiler (vc 7.1)
|
||||
// fails to compile one test (test_shared_ptr) without it !!!
|
||||
// make this protected so it can be called from a derived archive
|
||||
template<class T>
|
||||
void save_override(T & t, BOOST_PFTO int){
|
||||
this->basic_binary_oarchive<Archive>::save_override(t, 0L);
|
||||
}
|
||||
void init(unsigned int flags) {
|
||||
if(0 != (flags & no_header))
|
||||
return;
|
||||
#if ! defined(__MWERKS__)
|
||||
this->basic_binary_oarchive<Archive>::init();
|
||||
this->basic_binary_oprimitive<Archive, Elem, Tr>::init();
|
||||
#else
|
||||
basic_binary_oarchive<Archive>::init();
|
||||
basic_binary_oprimitive<Archive, Elem, Tr>::init();
|
||||
#endif
|
||||
}
|
||||
binary_oarchive_impl(
|
||||
std::basic_streambuf<Elem, Tr> & bsb,
|
||||
unsigned int flags
|
||||
) :
|
||||
basic_binary_oprimitive<Archive, Elem, Tr>(
|
||||
bsb,
|
||||
0 != (flags & no_codecvt)
|
||||
),
|
||||
basic_binary_oarchive<Archive>(flags)
|
||||
{
|
||||
init(flags);
|
||||
}
|
||||
binary_oarchive_impl(
|
||||
std::basic_ostream<Elem, Tr> & os,
|
||||
unsigned int flags
|
||||
) :
|
||||
basic_binary_oprimitive<Archive, Elem, Tr>(
|
||||
* os.rdbuf(),
|
||||
0 != (flags & no_codecvt)
|
||||
),
|
||||
basic_binary_oarchive<Archive>(flags)
|
||||
{
|
||||
init(flags);
|
||||
}
|
||||
};
|
||||
|
||||
} // namespace archive
|
||||
} // namespace boost
|
||||
|
||||
#ifdef BOOST_MSVC
|
||||
#pragma warning(pop)
|
||||
#endif
|
||||
|
||||
#endif // BOOST_ARCHIVE_BINARY_OARCHIVE_IMPL_HPP
|
||||
|
|
@ -0,0 +1,93 @@
|
|||
#ifndef BOOST_ARCHIVE_BINARY_WIARCHIVE_HPP
|
||||
#define BOOST_ARCHIVE_BINARY_WIARCHIVE_HPP
|
||||
|
||||
// MS compatible compilers support #pragma once
|
||||
#if defined(_MSC_VER) && (_MSC_VER >= 1020)
|
||||
# pragma once
|
||||
#endif
|
||||
|
||||
/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
|
||||
// binary_wiarchive.hpp
|
||||
|
||||
// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
|
||||
// Use, modification and distribution is subject to the Boost Software
|
||||
// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
// See http://www.boost.org for updates, documentation, and revision history.
|
||||
|
||||
#include <boost/config.hpp>
|
||||
#ifdef BOOST_NO_STD_WSTREAMBUF
|
||||
#error "wide char i/o not supported on this platform"
|
||||
#else
|
||||
|
||||
#include <istream> // wistream
|
||||
#include <boost/archive/binary_iarchive_impl.hpp>
|
||||
#include <boost/archive/detail/register_archive.hpp>
|
||||
|
||||
namespace boost {
|
||||
namespace archive {
|
||||
|
||||
// same as binary_wiarchive below - without the shared_ptr_helper
|
||||
class naked_binary_wiarchive :
|
||||
public binary_iarchive_impl<
|
||||
boost::archive::naked_binary_wiarchive,
|
||||
std::wistream::char_type,
|
||||
std::wistream::traits_type
|
||||
>
|
||||
{
|
||||
public:
|
||||
naked_binary_wiarchive(std::wistream & is, unsigned int flags = 0) :
|
||||
binary_iarchive_impl<
|
||||
naked_binary_wiarchive,
|
||||
std::wistream::char_type,
|
||||
std::wistream::traits_type
|
||||
>(is, flags)
|
||||
{}
|
||||
naked_binary_wiarchive(std::wstreambuf & bsb, unsigned int flags = 0) :
|
||||
binary_iarchive_impl<
|
||||
naked_binary_wiarchive,
|
||||
std::wistream::char_type,
|
||||
std::wistream::traits_type
|
||||
>(bsb, flags)
|
||||
{}
|
||||
};
|
||||
|
||||
} // namespace archive
|
||||
} // namespace boost
|
||||
|
||||
// note special treatment of shared_ptr. This type needs a special
|
||||
// structure associated with every archive. We created a "mix-in"
|
||||
// class to provide this functionality. Since shared_ptr holds a
|
||||
// special esteem in the boost library - we included it here by default.
|
||||
#include <boost/archive/shared_ptr_helper.hpp>
|
||||
|
||||
namespace boost {
|
||||
namespace archive {
|
||||
|
||||
class binary_wiarchive :
|
||||
public binary_iarchive_impl<
|
||||
binary_wiarchive, std::wistream::char_type, std::wistream::traits_type
|
||||
>
|
||||
{
|
||||
public:
|
||||
binary_wiarchive(std::wistream & is, unsigned int flags = 0) :
|
||||
binary_iarchive_impl<
|
||||
binary_wiarchive, std::wistream::char_type, std::wistream::traits_type
|
||||
>(is, flags)
|
||||
{}
|
||||
binary_wiarchive(std::wstreambuf & bsb, unsigned int flags = 0) :
|
||||
binary_iarchive_impl<
|
||||
binary_wiarchive, std::wistream::char_type, std::wistream::traits_type
|
||||
>(bsb, flags)
|
||||
{}
|
||||
};
|
||||
|
||||
} // namespace archive
|
||||
} // namespace boost
|
||||
|
||||
// required by export
|
||||
BOOST_SERIALIZATION_REGISTER_ARCHIVE(boost::archive::binary_wiarchive)
|
||||
|
||||
#endif // BOOST_NO_STD_WSTREAMBUF
|
||||
#endif // BOOST_ARCHIVE_BINARY_WIARCHIVE_HPP
|
||||
|
|
@ -0,0 +1,61 @@
|
|||
#ifndef BOOST_ARCHIVE_BINARY_WOARCHIVE_HPP
|
||||
#define BOOST_ARCHIVE_BINARY_WOARCHIVE_HPP
|
||||
|
||||
// MS compatible compilers support #pragma once
|
||||
#if defined(_MSC_VER) && (_MSC_VER >= 1020)
|
||||
# pragma once
|
||||
#endif
|
||||
|
||||
/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
|
||||
// binary_woarchive.hpp
|
||||
|
||||
// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
|
||||
// Use, modification and distribution is subject to the Boost Software
|
||||
// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
// See http://www.boost.org for updates, documentation, and revision history.
|
||||
|
||||
#include <boost/config.hpp>
|
||||
#ifdef BOOST_NO_STD_WSTREAMBUF
|
||||
#error "wide char i/o not supported on this platform"
|
||||
#else
|
||||
|
||||
#include <ostream>
|
||||
#include <boost/archive/binary_oarchive_impl.hpp>
|
||||
#include <boost/archive/detail/register_archive.hpp>
|
||||
|
||||
namespace boost {
|
||||
namespace archive {
|
||||
|
||||
// do not derive from this class. If you want to extend this functionality
|
||||
// via inhertance, derived from binary_oarchive_impl instead. This will
|
||||
// preserve correct static polymorphism.
|
||||
class binary_woarchive :
|
||||
public binary_oarchive_impl<
|
||||
binary_woarchive, std::wostream::char_type, std::wostream::traits_type
|
||||
>
|
||||
{
|
||||
public:
|
||||
binary_woarchive(std::wostream & os, unsigned int flags = 0) :
|
||||
binary_oarchive_impl<
|
||||
binary_woarchive, std::wostream::char_type, std::wostream::traits_type
|
||||
>(os, flags)
|
||||
{}
|
||||
binary_woarchive(std::wstreambuf & bsb, unsigned int flags = 0) :
|
||||
binary_oarchive_impl<
|
||||
binary_woarchive, std::wostream::char_type, std::wostream::traits_type
|
||||
>(bsb, flags)
|
||||
{}
|
||||
};
|
||||
|
||||
typedef binary_woarchive naked_binary_woarchive;
|
||||
|
||||
} // namespace archive
|
||||
} // namespace boost
|
||||
|
||||
// required by export
|
||||
BOOST_SERIALIZATION_REGISTER_ARCHIVE(boost::archive::binary_woarchive)
|
||||
|
||||
#endif // BOOST_NO_STD_WSTREAMBUF
|
||||
#endif // BOOST_ARCHIVE_BINARY_WOARCHIVE_HPP
|
||||
|
|
@ -0,0 +1,100 @@
|
|||
#ifndef BOOST_ARCHIVE_CODECVT_NULL_HPP
|
||||
#define BOOST_ARCHIVE_CODECVT_NULL_HPP
|
||||
|
||||
// MS compatible compilers support #pragma once
|
||||
#if defined(_MSC_VER) && (_MSC_VER >= 1020)
|
||||
# pragma once
|
||||
#endif
|
||||
|
||||
/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
|
||||
// codecvt_null.hpp:
|
||||
|
||||
// (C) Copyright 2004 Robert Ramey - http://www.rrsd.com .
|
||||
// Use, modification and distribution is subject to the Boost Software
|
||||
// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
// See http://www.boost.org for updates, documentation, and revision history.
|
||||
|
||||
#include <locale>
|
||||
#include <cstddef> // NULL, size_t
|
||||
#include <cwchar> // for mbstate_t
|
||||
#include <boost/config.hpp>
|
||||
#include <boost/archive/detail/auto_link_archive.hpp>
|
||||
#include <boost/archive/detail/abi_prefix.hpp> // must be the last header
|
||||
|
||||
#if defined(BOOST_NO_STDC_NAMESPACE)
|
||||
namespace std {
|
||||
// For STLport on WinCE, BOOST_NO_STDC_NAMESPACE can get defined if STLport is putting symbols in its own namespace.
|
||||
// In the case of codecvt, however, this does not mean that codecvt is in the global namespace (it will be in STLport's namespace)
|
||||
# if !defined(__SGI_STL_PORT) && !defined(_STLPORT_VERSION)
|
||||
using ::codecvt;
|
||||
# endif
|
||||
using ::mbstate_t;
|
||||
using ::size_t;
|
||||
} // namespace
|
||||
#endif
|
||||
|
||||
#ifdef BOOST_MSVC
|
||||
# pragma warning(push)
|
||||
# pragma warning(disable : 4511 4512)
|
||||
#endif
|
||||
|
||||
namespace boost {
|
||||
namespace archive {
|
||||
|
||||
template<class Ch>
|
||||
class codecvt_null;
|
||||
|
||||
template<>
|
||||
class codecvt_null<char> : public std::codecvt<char, char, std::mbstate_t>
|
||||
{
|
||||
virtual bool do_always_noconv() const throw() {
|
||||
return true;
|
||||
}
|
||||
public:
|
||||
explicit codecvt_null(std::size_t no_locale_manage = 0) :
|
||||
std::codecvt<char, char, std::mbstate_t>(no_locale_manage)
|
||||
{}
|
||||
};
|
||||
|
||||
template<>
|
||||
class codecvt_null<wchar_t> : public std::codecvt<wchar_t, char, std::mbstate_t>
|
||||
{
|
||||
virtual BOOST_WARCHIVE_DECL(std::codecvt_base::result)
|
||||
do_out(
|
||||
std::mbstate_t & state,
|
||||
const wchar_t * first1,
|
||||
const wchar_t * last1,
|
||||
const wchar_t * & next1,
|
||||
char * first2,
|
||||
char * last2,
|
||||
char * & next2
|
||||
) const;
|
||||
virtual BOOST_WARCHIVE_DECL(std::codecvt_base::result)
|
||||
do_in(
|
||||
std::mbstate_t & state,
|
||||
const char * first1,
|
||||
const char * last1,
|
||||
const char * & next1,
|
||||
wchar_t * first2,
|
||||
wchar_t * last2,
|
||||
wchar_t * & next2
|
||||
) const;
|
||||
virtual int do_encoding( ) const throw( ){
|
||||
return sizeof(wchar_t) / sizeof(char);
|
||||
}
|
||||
virtual int do_max_length( ) const throw( ){
|
||||
return do_encoding();
|
||||
}
|
||||
};
|
||||
|
||||
} // namespace archive
|
||||
} // namespace boost
|
||||
|
||||
#ifdef BOOST_MSVC
|
||||
# pragma warning(pop)
|
||||
#endif
|
||||
#include <boost/archive/detail/abi_suffix.hpp> // pop pragmas
|
||||
|
||||
#endif //BOOST_ARCHIVE_CODECVT_NULL_HPP
|
||||
|
|
@ -0,0 +1,20 @@
|
|||
/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
|
||||
// abi_prefix.hpp
|
||||
|
||||
// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
|
||||
// Use, modification and distribution is subject to the Boost Software
|
||||
// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
// See http://www.boost.org for updates, documentation, and revision history.
|
||||
|
||||
#include <boost/config/abi_prefix.hpp> // must be the last header
|
||||
#ifdef BOOST_MSVC
|
||||
# pragma warning(push)
|
||||
# pragma warning(disable : 4251 4231 4660 4275)
|
||||
#endif
|
||||
|
||||
#if defined( __BORLANDC__ )
|
||||
#pragma nopushoptwarn
|
||||
#endif
|
||||
|
||||
|
|
@ -0,0 +1,19 @@
|
|||
/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
|
||||
// abi_suffix.hpp
|
||||
|
||||
// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
|
||||
// Use, modification and distribution is subject to the Boost Software
|
||||
// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
// See http://www.boost.org for updates, documentation, and revision history.
|
||||
|
||||
#ifdef BOOST_MSVC
|
||||
#pragma warning(pop)
|
||||
#endif
|
||||
#include <boost/config/abi_suffix.hpp> // pops abi_suffix.hpp pragmas
|
||||
|
||||
#if defined( __BORLANDC__ )
|
||||
#pragma nopushoptwarn
|
||||
#endif
|
||||
|
||||
|
|
@ -0,0 +1,55 @@
|
|||
#ifndef BOOST_ARCHIVE_SERIALIZER_MAP_HPP
|
||||
#define BOOST_ARCHIVE_SERIALIZER_MAP_HPP
|
||||
|
||||
// MS compatible compilers support #pragma once
|
||||
#if defined(_MSC_VER) && (_MSC_VER >= 1020)
|
||||
# pragma once
|
||||
#endif
|
||||
|
||||
/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
|
||||
// archive_serializer_map.hpp: extenstion of type_info required for
|
||||
// serialization.
|
||||
|
||||
// (C) Copyright 2009 Robert Ramey - http://www.rrsd.com .
|
||||
// Use, modification and distribution is subject to the Boost Software
|
||||
// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
// See http://www.boost.org for updates, documentation, and revision history.
|
||||
|
||||
// note: this is nothing more than the thinest of wrappers around
|
||||
// basic_serializer_map so we can have a one map / archive type.
|
||||
|
||||
#include <boost/config.hpp>
|
||||
#include <boost/archive/detail/auto_link_archive.hpp>
|
||||
#include <boost/archive/detail/abi_prefix.hpp> // must be the last header
|
||||
|
||||
namespace boost {
|
||||
|
||||
namespace serialization {
|
||||
class extended_type_info;
|
||||
} // namespace serialization
|
||||
|
||||
namespace archive {
|
||||
namespace detail {
|
||||
|
||||
class basic_serializer;
|
||||
|
||||
template<class Archive>
|
||||
class BOOST_ARCHIVE_OR_WARCHIVE_DECL(BOOST_PP_EMPTY())
|
||||
archive_serializer_map {
|
||||
public:
|
||||
static bool insert(const basic_serializer * bs);
|
||||
static void erase(const basic_serializer * bs);
|
||||
static const basic_serializer * find(
|
||||
const boost::serialization::extended_type_info & type_
|
||||
);
|
||||
};
|
||||
|
||||
} // namespace detail
|
||||
} // namespace archive
|
||||
} // namespace boost
|
||||
|
||||
#include <boost/archive/detail/abi_suffix.hpp> // must be the last header
|
||||
|
||||
#endif //BOOST_ARCHIVE_SERIALIZER_MAP_HPP
|
||||
|
|
@ -0,0 +1,48 @@
|
|||
#ifndef BOOST_ARCHIVE_DETAIL_AUTO_LINK_ARCHIVE_HPP
|
||||
#define BOOST_ARCHIVE_DETAIL_AUTO_LINK_ARCHIVE_HPP
|
||||
|
||||
// MS compatible compilers support #pragma once
|
||||
#if defined(_MSC_VER) && (_MSC_VER >= 1020)
|
||||
# pragma once
|
||||
#endif
|
||||
|
||||
/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
|
||||
// auto_link_archive.hpp
|
||||
//
|
||||
// (c) Copyright Robert Ramey 2004
|
||||
// Use, modification, and distribution is subject to the Boost Software
|
||||
// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
// See library home page at http://www.boost.org/libs/serialization
|
||||
|
||||
//----------------------------------------------------------------------------//
|
||||
|
||||
// This header implements separate compilation features as described in
|
||||
// http://www.boost.org/more/separate_compilation.html
|
||||
|
||||
// enable automatic library variant selection ------------------------------//
|
||||
|
||||
#include <boost/archive/detail/decl.hpp>
|
||||
|
||||
#if !defined(BOOST_ALL_NO_LIB) && !defined(BOOST_SERIALIZATION_NO_LIB) \
|
||||
&& !defined(BOOST_ARCHIVE_SOURCE) && !defined(BOOST_WARCHIVE_SOURCE) \
|
||||
&& !defined(BOOST_SERIALIZATION_SOURCE)
|
||||
|
||||
// Set the name of our library, this will get undef'ed by auto_link.hpp
|
||||
// once it's done with it:
|
||||
//
|
||||
#define BOOST_LIB_NAME boost_serialization
|
||||
//
|
||||
// If we're importing code from a dll, then tell auto_link.hpp about it:
|
||||
//
|
||||
#if defined(BOOST_ALL_DYN_LINK) || defined(BOOST_SERIALIZATION_DYN_LINK)
|
||||
# define BOOST_DYN_LINK
|
||||
#endif
|
||||
//
|
||||
// And include the header that does the work:
|
||||
//
|
||||
#include <boost/config/auto_link.hpp>
|
||||
#endif // auto-linking disabled
|
||||
|
||||
#endif // BOOST_ARCHIVE_DETAIL_AUTO_LINK_ARCHIVE_HPP
|
||||
|
|
@ -0,0 +1,47 @@
|
|||
#ifndef BOOST_ARCHIVE_DETAIL_AUTO_LINK_WARCHIVE_HPP
|
||||
#define BOOST_ARCHIVE_DETAIL_AUTO_LINK_WARCHIVE_HPP
|
||||
|
||||
// MS compatible compilers support #pragma once
|
||||
#if defined(_MSC_VER) && (_MSC_VER >= 1020)
|
||||
# pragma once
|
||||
#endif
|
||||
|
||||
/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
|
||||
// auto_link_warchive.hpp
|
||||
//
|
||||
// (c) Copyright Robert Ramey 2004
|
||||
// Use, modification, and distribution is subject to the Boost Software
|
||||
// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
// See library home page at http://www.boost.org/libs/serialization
|
||||
|
||||
//----------------------------------------------------------------------------//
|
||||
|
||||
// This header implements separate compilation features as described in
|
||||
// http://www.boost.org/more/separate_compilation.html
|
||||
|
||||
// enable automatic library variant selection ------------------------------//
|
||||
|
||||
#include <boost/archive/detail/decl.hpp>
|
||||
|
||||
#if !defined(BOOST_WARCHIVE_SOURCE) \
|
||||
&& !defined(BOOST_ALL_NO_LIB) && !defined(BOOST_SERIALIZATION_NO_LIB)
|
||||
|
||||
// Set the name of our library, this will get undef'ed by auto_link.hpp
|
||||
// once it's done with it:
|
||||
//
|
||||
#define BOOST_LIB_NAME boost_wserialization
|
||||
//
|
||||
// If we're importing code from a dll, then tell auto_link.hpp about it:
|
||||
//
|
||||
#if defined(BOOST_ALL_DYN_LINK) || defined(BOOST_SERIALIZATION_DYN_LINK)
|
||||
# define BOOST_DYN_LINK
|
||||
#endif
|
||||
//
|
||||
// And include the header that does the work:
|
||||
//
|
||||
#include <boost/config/auto_link.hpp>
|
||||
#endif // auto-linking disabled
|
||||
|
||||
#endif // ARCHIVE_DETAIL_AUTO_LINK_ARCHIVE_HPP
|
||||
|
|
@ -0,0 +1,48 @@
|
|||
#ifndef BOOST_ARCHIVE_DETAIL_BASIC_ARCHIVE_IMPL_HPP
|
||||
#define BOOST_ARCHIVE_DETAIL_BASIC_ARCHIVE_IMPL_HPP
|
||||
|
||||
// MS compatible compilers support #pragma once
|
||||
#if defined(_MSC_VER) && (_MSC_VER >= 1020)
|
||||
# pragma once
|
||||
#endif
|
||||
|
||||
/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
|
||||
// basic_archive_impl.hpp:
|
||||
|
||||
// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
|
||||
// Use, modification and distribution is subject to the Boost Software
|
||||
// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
// See http://www.boost.org for updates, documentation, and revision history.
|
||||
|
||||
// can't use this - much as I'd like to as borland doesn't support it
|
||||
// #include <boost/scoped_ptr.hpp>
|
||||
|
||||
#include <set>
|
||||
|
||||
#include <boost/archive/detail/abi_prefix.hpp> // must be the last header
|
||||
|
||||
namespace boost {
|
||||
namespace serialization {
|
||||
class extended_type_info;
|
||||
} // namespace serialization
|
||||
|
||||
namespace archive {
|
||||
namespace detail {
|
||||
|
||||
//////////////////////////////////////////////////////////////////////
|
||||
class BOOST_ARCHIVE_DECL(BOOST_PP_EMPTY()) basic_archive_impl
|
||||
{
|
||||
};
|
||||
|
||||
} // namespace detail
|
||||
} // namespace serialization
|
||||
} // namespace boost
|
||||
|
||||
#include <boost/archive/detail/abi_suffix.hpp> // pops abi_suffix.hpp pragmas
|
||||
|
||||
#endif //BOOST_ARCHIVE_DETAIL_BASIC_ARCHIVE_IMPL_HPP
|
||||
|
||||
|
||||
|
||||
|
|
@ -0,0 +1,45 @@
|
|||
#ifndef BOOST_ARCHIVE_DETAIL_BASIC_CONFIG_HPP
|
||||
#define BOOST_ARCHIVE_DETAIL_BASIC_CONFIG_HPP
|
||||
|
||||
// MS compatible compilers support #pragma once
|
||||
#if defined(_MSC_VER) && (_MSC_VER >= 1020)
|
||||
# pragma once
|
||||
#endif
|
||||
|
||||
// basic_config.hpp ---------------------------------------------//
|
||||
|
||||
// (c) Copyright Robert Ramey 2004
|
||||
// Use, modification, and distribution is subject to the Boost Software
|
||||
// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
// See library home page at http://www.boost.org/libs/serialization
|
||||
|
||||
//----------------------------------------------------------------------------//
|
||||
|
||||
// This header implements separate compilation features as described in
|
||||
// http://www.boost.org/more/separate_compilation.html
|
||||
|
||||
#include <boost/config.hpp>
|
||||
|
||||
#ifdef BOOST_HAS_DECLSPEC // defined in config system
|
||||
// we need to import/export our code only if the user has specifically
|
||||
// asked for it by defining either BOOST_ALL_DYN_LINK if they want all boost
|
||||
// libraries to be dynamically linked, or BOOST_ARCHIVE_DYN_LINK
|
||||
// if they want just this one to be dynamically linked:
|
||||
#if defined(BOOST_ALL_DYN_LINK) || defined(BOOST_ARCHIVE_DYN_LINK)
|
||||
// export if this is our own source, otherwise import:
|
||||
#ifdef BOOST_ARCHIVE_SOURCE
|
||||
# define BOOST_ARCHIVE_DECL __declspec(dllexport)
|
||||
#else
|
||||
# define BOOST_ARCHIVE_DECL __declspec(dllimport)
|
||||
#endif // BOOST_ARCHIVE_SOURCE
|
||||
#endif // DYN_LINK
|
||||
#endif // BOOST_HAS_DECLSPEC
|
||||
//
|
||||
// if BOOST_ARCHIVE_DECL isn't defined yet define it now:
|
||||
#ifndef BOOST_ARCHIVE_DECL
|
||||
#define BOOST_ARCHIVE_DECL
|
||||
#endif
|
||||
|
||||
#endif // BOOST_ARCHIVE_DETAIL_BASIC_CONFIG_HPP
|
||||
|
|
@ -0,0 +1,110 @@
|
|||
#ifndef BOOST_ARCHIVE_DETAIL_BASIC_IARCHIVE_HPP
|
||||
#define BOOST_ARCHIVE_DETAIL_BASIC_IARCHIVE_HPP
|
||||
|
||||
// MS compatible compilers support #pragma once
|
||||
#if defined(_MSC_VER) && (_MSC_VER >= 1020)
|
||||
# pragma once
|
||||
#endif
|
||||
|
||||
/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
|
||||
// basic_iarchive.hpp:
|
||||
|
||||
// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
|
||||
// Use, modification and distribution is subject to the Boost Software
|
||||
// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
// See http://www.boost.org for updates, documentation, and revision history.
|
||||
|
||||
// can't use this - much as I'd like to as borland doesn't support it
|
||||
// #include <boost/scoped_ptr.hpp>
|
||||
|
||||
#include <boost/config.hpp>
|
||||
#include <boost/noncopyable.hpp>
|
||||
|
||||
#include <boost/type_traits/broken_compiler_spec.hpp>
|
||||
#include <boost/serialization/tracking_enum.hpp>
|
||||
#include <boost/archive/basic_archive.hpp>
|
||||
#include <boost/archive/detail/decl.hpp>
|
||||
#include <boost/archive/detail/abi_prefix.hpp> // must be the last header
|
||||
|
||||
namespace boost {
|
||||
namespace serialization {
|
||||
class extended_type_info;
|
||||
} // namespace serialization
|
||||
|
||||
namespace archive {
|
||||
namespace detail {
|
||||
|
||||
class basic_iarchive_impl;
|
||||
class BOOST_ARCHIVE_DECL(BOOST_PP_EMPTY()) basic_iserializer;
|
||||
class BOOST_ARCHIVE_DECL(BOOST_PP_EMPTY()) basic_pointer_iserializer;
|
||||
//////////////////////////////////////////////////////////////////////
|
||||
// class basic_iarchive - read serialized objects from a input stream
|
||||
class BOOST_ARCHIVE_DECL(BOOST_PP_EMPTY()) basic_iarchive :
|
||||
private boost::noncopyable
|
||||
{
|
||||
friend class basic_iarchive_impl;
|
||||
// hide implementation of this class to minimize header conclusion
|
||||
// in client code. I couldn't used scoped pointer with borland
|
||||
// boost::scoped_ptr<basic_iarchive_impl> pimpl;
|
||||
basic_iarchive_impl * pimpl;
|
||||
|
||||
virtual void vload(version_type &t) = 0;
|
||||
virtual void vload(object_id_type &t) = 0;
|
||||
virtual void vload(class_id_type &t) = 0;
|
||||
virtual void vload(class_id_optional_type &t) = 0;
|
||||
virtual void vload(class_name_type &t) = 0;
|
||||
virtual void vload(tracking_type &t) = 0;
|
||||
protected:
|
||||
basic_iarchive(unsigned int flags);
|
||||
// account for bogus gcc warning
|
||||
#if defined(__GNUC__)
|
||||
virtual
|
||||
#endif
|
||||
~basic_iarchive();
|
||||
public:
|
||||
// note: NOT part of the public API.
|
||||
void next_object_pointer(void *t);
|
||||
void register_basic_serializer(
|
||||
const basic_iserializer & bis
|
||||
);
|
||||
void load_object(
|
||||
void *t,
|
||||
const basic_iserializer & bis
|
||||
);
|
||||
const basic_pointer_iserializer *
|
||||
load_pointer(
|
||||
void * & t,
|
||||
const basic_pointer_iserializer * bpis_ptr,
|
||||
const basic_pointer_iserializer * (*finder)(
|
||||
const boost::serialization::extended_type_info & eti
|
||||
)
|
||||
|
||||
);
|
||||
// real public API starts here
|
||||
void
|
||||
set_library_version(library_version_type archive_library_version);
|
||||
library_version_type
|
||||
get_library_version() const;
|
||||
unsigned int
|
||||
get_flags() const;
|
||||
void
|
||||
reset_object_address(const void * new_address, const void * old_address);
|
||||
void
|
||||
delete_created_pointers();
|
||||
};
|
||||
|
||||
} // namespace detail
|
||||
} // namespace archive
|
||||
} // namespace boost
|
||||
|
||||
// required by smart_cast for compilers not implementing
|
||||
// partial template specialization
|
||||
BOOST_TT_BROKEN_COMPILER_SPEC(
|
||||
boost::archive::detail::basic_iarchive
|
||||
)
|
||||
|
||||
#include <boost/archive/detail/abi_suffix.hpp> // pops abi_suffix.hpp pragmas
|
||||
|
||||
#endif //BOOST_ARCHIVE_DETAIL_BASIC_IARCHIVE_HPP
|
||||
|
|
@ -0,0 +1,95 @@
|
|||
#ifndef BOOST_ARCHIVE_DETAIL_BASIC_ISERIALIZER_HPP
|
||||
#define BOOST_ARCHIVE_DETAIL_BASIC_ISERIALIZER_HPP
|
||||
|
||||
// MS compatible compilers support #pragma once
|
||||
#if defined(_MSC_VER) && (_MSC_VER >= 1020)
|
||||
# pragma once
|
||||
#endif
|
||||
|
||||
/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
|
||||
// basic_iserializer.hpp: extenstion of type_info required for serialization.
|
||||
|
||||
// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
|
||||
// Use, modification and distribution is subject to the Boost Software
|
||||
// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
// See http://www.boost.org for updates, documentation, and revision history.
|
||||
|
||||
#include <cstdlib> // NULL
|
||||
#include <boost/config.hpp>
|
||||
|
||||
#include <boost/archive/basic_archive.hpp>
|
||||
#include <boost/archive/detail/decl.hpp>
|
||||
#include <boost/archive/detail/basic_serializer.hpp>
|
||||
#include <boost/archive/detail/auto_link_archive.hpp>
|
||||
#include <boost/archive/detail/abi_prefix.hpp> // must be the last header
|
||||
|
||||
#ifdef BOOST_MSVC
|
||||
# pragma warning(push)
|
||||
# pragma warning(disable : 4511 4512)
|
||||
#endif
|
||||
|
||||
namespace boost {
|
||||
namespace serialization {
|
||||
class extended_type_info;
|
||||
} // namespace serialization
|
||||
|
||||
// forward declarations
|
||||
namespace archive {
|
||||
namespace detail {
|
||||
|
||||
class BOOST_ARCHIVE_DECL(BOOST_PP_EMPTY()) basic_iarchive;
|
||||
class BOOST_ARCHIVE_DECL(BOOST_PP_EMPTY()) basic_pointer_iserializer;
|
||||
|
||||
class BOOST_ARCHIVE_DECL(BOOST_PP_EMPTY()) basic_iserializer :
|
||||
public basic_serializer
|
||||
{
|
||||
private:
|
||||
basic_pointer_iserializer *m_bpis;
|
||||
protected:
|
||||
explicit basic_iserializer(
|
||||
const boost::serialization::extended_type_info & type
|
||||
);
|
||||
// account for bogus gcc warning
|
||||
#if defined(__GNUC__)
|
||||
virtual
|
||||
#endif
|
||||
~basic_iserializer();
|
||||
public:
|
||||
bool serialized_as_pointer() const {
|
||||
return m_bpis != NULL;
|
||||
}
|
||||
void set_bpis(basic_pointer_iserializer *bpis){
|
||||
m_bpis = bpis;
|
||||
}
|
||||
const basic_pointer_iserializer * get_bpis_ptr() const {
|
||||
return m_bpis;
|
||||
}
|
||||
virtual void load_object_data(
|
||||
basic_iarchive & ar,
|
||||
void *x,
|
||||
const unsigned int file_version
|
||||
) const = 0;
|
||||
// returns true if class_info should be saved
|
||||
virtual bool class_info() const = 0 ;
|
||||
// returns true if objects should be tracked
|
||||
virtual bool tracking(const unsigned int) const = 0 ;
|
||||
// returns class version
|
||||
virtual version_type version() const = 0 ;
|
||||
// returns true if this class is polymorphic
|
||||
virtual bool is_polymorphic() const = 0;
|
||||
virtual void destroy(/*const*/ void *address) const = 0 ;
|
||||
};
|
||||
|
||||
} // namespae detail
|
||||
} // namespace archive
|
||||
} // namespace boost
|
||||
|
||||
#ifdef BOOST_MSVC
|
||||
#pragma warning(pop)
|
||||
#endif
|
||||
|
||||
#include <boost/archive/detail/abi_suffix.hpp> // pops abi_suffix.hpp pragmas
|
||||
|
||||
#endif // BOOST_ARCHIVE_DETAIL_BASIC_ISERIALIZER_HPP
|
||||
|
|
@ -0,0 +1,106 @@
|
|||
#ifndef BOOST_ARCHIVE_BASIC_OARCHIVE_HPP
|
||||
#define BOOST_ARCHIVE_BASIC_OARCHIVE_HPP
|
||||
|
||||
// MS compatible compilers support #pragma once
|
||||
#if defined(_MSC_VER) && (_MSC_VER >= 1020)
|
||||
# pragma once
|
||||
#endif
|
||||
|
||||
/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
|
||||
// basic_oarchive.hpp:
|
||||
|
||||
// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
|
||||
// Use, modification and distribution is subject to the Boost Software
|
||||
// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
// See http://www.boost.org for updates, documentation, and revision history.
|
||||
|
||||
#include <cstddef> // NULL
|
||||
#include <boost/config.hpp>
|
||||
#include <boost/noncopyable.hpp>
|
||||
|
||||
#include <boost/type_traits/broken_compiler_spec.hpp>
|
||||
|
||||
// can't use this - much as I'd like to as borland doesn't support it
|
||||
// #include <boost/scoped_ptr.hpp>
|
||||
|
||||
#include <boost/archive/basic_archive.hpp>
|
||||
#include <boost/serialization/tracking_enum.hpp>
|
||||
|
||||
#include <boost/archive/detail/abi_prefix.hpp> // must be the last header
|
||||
|
||||
namespace boost {
|
||||
namespace serialization {
|
||||
class extended_type_info;
|
||||
} // namespace serialization
|
||||
|
||||
namespace archive {
|
||||
namespace detail {
|
||||
|
||||
class basic_oarchive_impl;
|
||||
class BOOST_ARCHIVE_DECL(BOOST_PP_EMPTY()) basic_oserializer;
|
||||
class BOOST_ARCHIVE_DECL(BOOST_PP_EMPTY()) basic_pointer_oserializer;
|
||||
//////////////////////////////////////////////////////////////////////
|
||||
// class basic_oarchive - write serialized objects to an output stream
|
||||
class BOOST_ARCHIVE_OR_WARCHIVE_DECL(BOOST_PP_EMPTY()) basic_oarchive :
|
||||
private boost::noncopyable
|
||||
{
|
||||
friend class basic_oarchive_impl;
|
||||
// hide implementation of this class to minimize header conclusion
|
||||
// in client code. note: borland can't use scoped_ptr
|
||||
//boost::scoped_ptr<basic_oarchive_impl> pimpl;
|
||||
basic_oarchive_impl * pimpl;
|
||||
|
||||
// overload these to bracket object attributes. Used to implement
|
||||
// xml archives
|
||||
virtual void vsave(const version_type t) = 0;
|
||||
virtual void vsave(const object_id_type t) = 0;
|
||||
virtual void vsave(const object_reference_type t) = 0;
|
||||
virtual void vsave(const class_id_type t) = 0;
|
||||
virtual void vsave(const class_id_optional_type t) = 0;
|
||||
virtual void vsave(const class_id_reference_type t) = 0;
|
||||
virtual void vsave(const class_name_type & t) = 0;
|
||||
virtual void vsave(const tracking_type t) = 0;
|
||||
protected:
|
||||
basic_oarchive(unsigned int flags = 0);
|
||||
// account for bogus gcc warning
|
||||
#if defined(__GNUC__)
|
||||
virtual
|
||||
#endif
|
||||
~basic_oarchive();
|
||||
public:
|
||||
// note: NOT part of the public interface
|
||||
void register_basic_serializer(
|
||||
const basic_oserializer & bos
|
||||
);
|
||||
void save_object(
|
||||
const void *x,
|
||||
const basic_oserializer & bos
|
||||
);
|
||||
void save_pointer(
|
||||
const void * t,
|
||||
const basic_pointer_oserializer * bpos_ptr
|
||||
);
|
||||
void save_null_pointer(){
|
||||
vsave(NULL_POINTER_TAG);
|
||||
}
|
||||
// real public interface starts here
|
||||
void end_preamble(); // default implementation does nothing
|
||||
library_version_type get_library_version() const;
|
||||
unsigned int get_flags() const;
|
||||
};
|
||||
|
||||
} // namespace detail
|
||||
} // namespace archive
|
||||
} // namespace boost
|
||||
|
||||
// required by smart_cast for compilers not implementing
|
||||
// partial template specialization
|
||||
BOOST_TT_BROKEN_COMPILER_SPEC(
|
||||
boost::archive::detail::basic_oarchive
|
||||
)
|
||||
|
||||
#include <boost/archive/detail/abi_suffix.hpp> // pops abi_suffix.hpp pragmas
|
||||
|
||||
#endif //BOOST_ARCHIVE_BASIC_OARCHIVE_HPP
|
||||
|
|
@ -0,0 +1,93 @@
|
|||
#ifndef BOOST_SERIALIZATION_BASIC_OSERIALIZER_HPP
|
||||
#define BOOST_SERIALIZATION_BASIC_OSERIALIZER_HPP
|
||||
|
||||
// MS compatible compilers support #pragma once
|
||||
#if defined(_MSC_VER) && (_MSC_VER >= 1020)
|
||||
# pragma once
|
||||
#endif
|
||||
|
||||
/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
|
||||
// basic_oserializer.hpp: extenstion of type_info required for serialization.
|
||||
|
||||
// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
|
||||
// Use, modification and distribution is subject to the Boost Software
|
||||
// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
// See http://www.boost.org for updates, documentation, and revision history.
|
||||
|
||||
#include <cstddef> // NULL
|
||||
#include <boost/config.hpp>
|
||||
#include <boost/noncopyable.hpp>
|
||||
|
||||
#include <boost/archive/basic_archive.hpp>
|
||||
#include <boost/archive/detail/auto_link_archive.hpp>
|
||||
#include <boost/archive/detail/basic_serializer.hpp>
|
||||
|
||||
#include <boost/archive/detail/abi_prefix.hpp> // must be the last header
|
||||
|
||||
#ifdef BOOST_MSVC
|
||||
# pragma warning(push)
|
||||
# pragma warning(disable : 4511 4512)
|
||||
#endif
|
||||
|
||||
namespace boost {
|
||||
namespace serialization {
|
||||
class extended_type_info;
|
||||
} // namespace serialization
|
||||
|
||||
// forward declarations
|
||||
namespace archive {
|
||||
namespace detail {
|
||||
|
||||
class BOOST_ARCHIVE_DECL(BOOST_PP_EMPTY()) basic_oarchive;
|
||||
class BOOST_ARCHIVE_DECL(BOOST_PP_EMPTY()) basic_pointer_oserializer;
|
||||
|
||||
class BOOST_ARCHIVE_DECL(BOOST_PP_EMPTY()) basic_oserializer :
|
||||
public basic_serializer
|
||||
{
|
||||
private:
|
||||
basic_pointer_oserializer *m_bpos;
|
||||
protected:
|
||||
explicit basic_oserializer(
|
||||
const boost::serialization::extended_type_info & type_
|
||||
);
|
||||
// account for bogus gcc warning
|
||||
#if defined(__GNUC__)
|
||||
virtual
|
||||
#endif
|
||||
~basic_oserializer();
|
||||
public:
|
||||
bool serialized_as_pointer() const {
|
||||
return m_bpos != NULL;
|
||||
}
|
||||
void set_bpos(basic_pointer_oserializer *bpos){
|
||||
m_bpos = bpos;
|
||||
}
|
||||
const basic_pointer_oserializer * get_bpos() const {
|
||||
return m_bpos;
|
||||
}
|
||||
virtual void save_object_data(
|
||||
basic_oarchive & ar, const void * x
|
||||
) const = 0;
|
||||
// returns true if class_info should be saved
|
||||
virtual bool class_info() const = 0;
|
||||
// returns true if objects should be tracked
|
||||
virtual bool tracking(const unsigned int flags) const = 0;
|
||||
// returns class version
|
||||
virtual version_type version() const = 0;
|
||||
// returns true if this class is polymorphic
|
||||
virtual bool is_polymorphic() const = 0;
|
||||
};
|
||||
|
||||
} // namespace detail
|
||||
} // namespace serialization
|
||||
} // namespace boost
|
||||
|
||||
#ifdef BOOST_MSVC
|
||||
#pragma warning(pop)
|
||||
#endif
|
||||
|
||||
#include <boost/archive/detail/abi_suffix.hpp> // pops abi_suffix.hpp pragmas
|
||||
|
||||
#endif // BOOST_SERIALIZATION_BASIC_OSERIALIZER_HPP
|
||||
|
|
@ -0,0 +1,73 @@
|
|||
#ifndef BOOST_ARCHIVE_BASIC_POINTER_ISERIALIZER_HPP
|
||||
#define BOOST_ARCHIVE_BASIC_POINTER_ISERIALIZER_HPP
|
||||
|
||||
// MS compatible compilers support #pragma once
|
||||
#if defined(_MSC_VER) && (_MSC_VER >= 1020)
|
||||
# pragma once
|
||||
#endif
|
||||
|
||||
/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
|
||||
// basic_pointer_oserializer.hpp: extenstion of type_info required for
|
||||
// serialization.
|
||||
|
||||
// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
|
||||
// Use, modification and distribution is subject to the Boost Software
|
||||
// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
// See http://www.boost.org for updates, documentation, and revision history.
|
||||
#include <boost/config.hpp>
|
||||
#include <boost/noncopyable.hpp>
|
||||
#include <boost/archive/detail/auto_link_archive.hpp>
|
||||
#include <boost/archive/detail/basic_serializer.hpp>
|
||||
|
||||
#include <boost/archive/detail/abi_prefix.hpp> // must be the last header
|
||||
|
||||
#ifdef BOOST_MSVC
|
||||
# pragma warning(push)
|
||||
# pragma warning(disable : 4511 4512)
|
||||
#endif
|
||||
|
||||
namespace boost {
|
||||
namespace serialization {
|
||||
class extended_type_info;
|
||||
} // namespace serialization
|
||||
|
||||
// forward declarations
|
||||
namespace archive {
|
||||
namespace detail {
|
||||
|
||||
class BOOST_ARCHIVE_DECL(BOOST_PP_EMPTY()) basic_iarchive;
|
||||
class BOOST_ARCHIVE_DECL(BOOST_PP_EMPTY()) basic_iserializer;
|
||||
|
||||
class BOOST_ARCHIVE_DECL(BOOST_PP_EMPTY()) basic_pointer_iserializer
|
||||
: public basic_serializer {
|
||||
protected:
|
||||
explicit basic_pointer_iserializer(
|
||||
const boost::serialization::extended_type_info & type_
|
||||
);
|
||||
// account for bogus gcc warning
|
||||
#if defined(__GNUC__)
|
||||
virtual
|
||||
#endif
|
||||
~basic_pointer_iserializer();
|
||||
public:
|
||||
virtual const basic_iserializer & get_basic_serializer() const = 0;
|
||||
virtual void load_object_ptr(
|
||||
basic_iarchive & ar,
|
||||
void * & x,
|
||||
const unsigned int file_version
|
||||
) const = 0;
|
||||
};
|
||||
|
||||
} // namespace detail
|
||||
} // namespace archive
|
||||
} // namespace boost
|
||||
|
||||
#ifdef BOOST_MSVC
|
||||
#pragma warning(pop)
|
||||
#endif
|
||||
|
||||
#include <boost/archive/detail/abi_suffix.hpp> // pops abi_suffix.hpp pragmas
|
||||
|
||||
#endif // BOOST_ARCHIVE_BASIC_POINTER_ISERIALIZER_HPP
|
||||
|
|
@ -0,0 +1,72 @@
|
|||
#ifndef BOOST_ARCHIVE_BASIC_POINTER_OSERIALIZER_HPP
|
||||
#define BOOST_ARCHIVE_BASIC_POINTER_OSERIALIZER_HPP
|
||||
|
||||
// MS compatible compilers support #pragma once
|
||||
#if defined(_MSC_VER) && (_MSC_VER >= 1020)
|
||||
# pragma once
|
||||
#endif
|
||||
|
||||
/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
|
||||
// basic_pointer_oserializer.hpp: extenstion of type_info required for
|
||||
// serialization.
|
||||
|
||||
// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
|
||||
// Use, modification and distribution is subject to the Boost Software
|
||||
// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
// See http://www.boost.org for updates, documentation, and revision history.
|
||||
#include <boost/config.hpp>
|
||||
#include <boost/noncopyable.hpp>
|
||||
#include <boost/archive/detail/auto_link_archive.hpp>
|
||||
#include <boost/archive/detail/basic_serializer.hpp>
|
||||
|
||||
#include <boost/archive/detail/abi_prefix.hpp> // must be the last header
|
||||
|
||||
#ifdef BOOST_MSVC
|
||||
# pragma warning(push)
|
||||
# pragma warning(disable : 4511 4512)
|
||||
#endif
|
||||
|
||||
namespace boost {
|
||||
namespace serialization {
|
||||
class extended_type_info;
|
||||
} // namespace serialization
|
||||
|
||||
namespace archive {
|
||||
namespace detail {
|
||||
|
||||
class BOOST_ARCHIVE_DECL(BOOST_PP_EMPTY()) basic_oarchive;
|
||||
class BOOST_ARCHIVE_DECL(BOOST_PP_EMPTY()) basic_oserializer;
|
||||
|
||||
class BOOST_ARCHIVE_DECL(BOOST_PP_EMPTY()) basic_pointer_oserializer :
|
||||
public basic_serializer
|
||||
{
|
||||
protected:
|
||||
explicit basic_pointer_oserializer(
|
||||
const boost::serialization::extended_type_info & type_
|
||||
);
|
||||
public:
|
||||
// account for bogus gcc warning
|
||||
#if defined(__GNUC__)
|
||||
virtual
|
||||
#endif
|
||||
~basic_pointer_oserializer();
|
||||
virtual const basic_oserializer & get_basic_serializer() const = 0;
|
||||
virtual void save_object_ptr(
|
||||
basic_oarchive & ar,
|
||||
const void * x
|
||||
) const = 0;
|
||||
};
|
||||
|
||||
} // namespace detail
|
||||
} // namespace archive
|
||||
} // namespace boost
|
||||
|
||||
#ifdef BOOST_MSVC
|
||||
#pragma warning(pop)
|
||||
#endif
|
||||
|
||||
#include <boost/archive/detail/abi_suffix.hpp> // pops abi_suffix.hpp pragmas
|
||||
|
||||
#endif // BOOST_ARCHIVE_BASIC_POINTER_OSERIALIZER_HPP
|
||||
|
|
@ -0,0 +1,79 @@
|
|||
#ifndef BOOST_ARCHIVE_BASIC_SERIALIZER_HPP
|
||||
#define BOOST_ARCHIVE_BASIC_SERIALIZER_HPP
|
||||
|
||||
// MS compatible compilers support #pragma once
|
||||
#if defined(_MSC_VER) && (_MSC_VER >= 1020)
|
||||
# pragma once
|
||||
#endif
|
||||
|
||||
/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
|
||||
// basic_serializer.hpp: extenstion of type_info required for serialization.
|
||||
|
||||
// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
|
||||
// Use, modification and distribution is subject to the Boost Software
|
||||
// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
// See http://www.boost.org for updates, documentation, and revision history.
|
||||
|
||||
#include <boost/assert.hpp>
|
||||
#include <cstddef> // NULL
|
||||
|
||||
#include <boost/noncopyable.hpp>
|
||||
#include <boost/config.hpp>
|
||||
#include <boost/serialization/extended_type_info.hpp>
|
||||
|
||||
#ifdef BOOST_MSVC
|
||||
# pragma warning(push)
|
||||
# pragma warning(disable : 4511 4512)
|
||||
#endif
|
||||
|
||||
namespace boost {
|
||||
namespace archive {
|
||||
namespace detail {
|
||||
|
||||
class basic_serializer :
|
||||
private boost::noncopyable
|
||||
{
|
||||
const boost::serialization::extended_type_info * m_eti;
|
||||
protected:
|
||||
explicit basic_serializer(
|
||||
const boost::serialization::extended_type_info & eti
|
||||
) :
|
||||
m_eti(& eti)
|
||||
{
|
||||
BOOST_ASSERT(NULL != & eti);
|
||||
}
|
||||
public:
|
||||
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)
|
||||
// leave this here as a reminder not to do this!
|
||||
// return & lhs.get_eti() < & rhs.get_eti();
|
||||
return get_eti() < rhs.get_eti();
|
||||
}
|
||||
const char * get_debug_info() const {
|
||||
return m_eti->get_debug_info();
|
||||
}
|
||||
const boost::serialization::extended_type_info & get_eti() const {
|
||||
return * m_eti;
|
||||
}
|
||||
};
|
||||
|
||||
class basic_serializer_arg : public basic_serializer {
|
||||
public:
|
||||
basic_serializer_arg(const serialization::extended_type_info & eti) :
|
||||
basic_serializer(eti)
|
||||
{}
|
||||
};
|
||||
|
||||
} // namespace detail
|
||||
} // namespace archive
|
||||
} // namespace boost
|
||||
|
||||
#ifdef BOOST_MSVC
|
||||
#pragma warning(pop)
|
||||
#endif
|
||||
|
||||
#endif // BOOST_ARCHIVE_BASIC_SERIALIZER_HPP
|
||||
|
|
@ -0,0 +1,69 @@
|
|||
#ifndef BOOST_SERIALIZER_MAP_HPP
|
||||
#define BOOST_SERIALIZER_MAP_HPP
|
||||
|
||||
// MS compatible compilers support #pragma once
|
||||
#if defined(_MSC_VER) && (_MSC_VER >= 1020)
|
||||
# pragma once
|
||||
#endif
|
||||
|
||||
/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
|
||||
// basic_serializer_map.hpp: extenstion of type_info required for serialization.
|
||||
|
||||
// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
|
||||
// Use, modification and distribution is subject to the Boost Software
|
||||
// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
// See http://www.boost.org for updates, documentation, and revision history.
|
||||
|
||||
#include <set>
|
||||
|
||||
#include <boost/config.hpp>
|
||||
#include <boost/utility.hpp>
|
||||
#include <boost/archive/detail/auto_link_archive.hpp>
|
||||
|
||||
#include <boost/archive/detail/abi_prefix.hpp> // must be the last header
|
||||
|
||||
namespace boost {
|
||||
namespace serialization {
|
||||
class extended_type_info;
|
||||
}
|
||||
|
||||
namespace archive {
|
||||
namespace detail {
|
||||
|
||||
class basic_serializer;
|
||||
|
||||
class BOOST_ARCHIVE_OR_WARCHIVE_DECL(BOOST_PP_EMPTY())
|
||||
basic_serializer_map : public
|
||||
boost::noncopyable
|
||||
{
|
||||
struct type_info_pointer_compare
|
||||
{
|
||||
bool operator()(
|
||||
const basic_serializer * lhs, const basic_serializer * rhs
|
||||
) const ;
|
||||
};
|
||||
typedef std::set<
|
||||
const basic_serializer *,
|
||||
type_info_pointer_compare
|
||||
> map_type;
|
||||
map_type m_map;
|
||||
public:
|
||||
bool insert(const basic_serializer * bs);
|
||||
void erase(const basic_serializer * bs);
|
||||
const basic_serializer * find(
|
||||
const boost::serialization::extended_type_info & type_
|
||||
) const;
|
||||
private:
|
||||
// cw 8.3 requires this
|
||||
basic_serializer_map& operator=(basic_serializer_map const&);
|
||||
};
|
||||
|
||||
} // namespace detail
|
||||
} // namespace archive
|
||||
} // namespace boost
|
||||
|
||||
#include <boost/archive/detail/abi_suffix.hpp> // must be the last header
|
||||
|
||||
#endif // BOOST_SERIALIZER_MAP_HPP
|
||||
|
|
@ -0,0 +1,169 @@
|
|||
#ifndef BOOST_ARCHIVE_DETAIL_CHECK_HPP
|
||||
#define BOOST_ARCHIVE_DETAIL_CHECK_HPP
|
||||
|
||||
// MS compatible compilers support #pragma once
|
||||
#if defined(_MSC_VER) && (_MSC_VER >= 1020)
|
||||
# pragma once
|
||||
#pragma inline_depth(511)
|
||||
#pragma inline_recursion(on)
|
||||
#endif
|
||||
|
||||
#if defined(__MWERKS__)
|
||||
#pragma inline_depth(511)
|
||||
#endif
|
||||
|
||||
/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
|
||||
// check.hpp: interface for serialization system.
|
||||
|
||||
// (C) Copyright 2009 Robert Ramey - http://www.rrsd.com .
|
||||
// Use, modification and distribution is subject to the Boost Software
|
||||
// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
// See http://www.boost.org for updates, documentation, and revision history.
|
||||
|
||||
#include <boost/config.hpp>
|
||||
|
||||
#include <boost/static_assert.hpp>
|
||||
#include <boost/type_traits/is_const.hpp>
|
||||
|
||||
#include <boost/mpl/eval_if.hpp>
|
||||
#include <boost/mpl/or.hpp>
|
||||
#include <boost/mpl/equal_to.hpp>
|
||||
#include <boost/mpl/int.hpp>
|
||||
#include <boost/mpl/not.hpp>
|
||||
#include <boost/mpl/greater.hpp>
|
||||
#include <boost/mpl/assert.hpp>
|
||||
|
||||
#include <boost/serialization/static_warning.hpp>
|
||||
#include <boost/serialization/version.hpp>
|
||||
#include <boost/serialization/level.hpp>
|
||||
#include <boost/serialization/tracking.hpp>
|
||||
#include <boost/serialization/wrapper.hpp>
|
||||
|
||||
namespace boost {
|
||||
namespace archive {
|
||||
namespace detail {
|
||||
|
||||
// checks for objects
|
||||
|
||||
template<class T>
|
||||
inline void check_object_level(){
|
||||
typedef
|
||||
BOOST_DEDUCED_TYPENAME mpl::greater_equal<
|
||||
serialization::implementation_level< T >,
|
||||
mpl::int_<serialization::primitive_type>
|
||||
>::type typex;
|
||||
|
||||
// trap attempts to serialize objects marked
|
||||
// not_serializable
|
||||
BOOST_STATIC_ASSERT(typex::value);
|
||||
}
|
||||
|
||||
template<class T>
|
||||
inline void check_object_versioning(){
|
||||
typedef
|
||||
BOOST_DEDUCED_TYPENAME mpl::or_<
|
||||
BOOST_DEDUCED_TYPENAME mpl::greater<
|
||||
serialization::implementation_level< T >,
|
||||
mpl::int_<serialization::object_serializable>
|
||||
>,
|
||||
BOOST_DEDUCED_TYPENAME mpl::equal_to<
|
||||
serialization::version< T >,
|
||||
mpl::int_<0>
|
||||
>
|
||||
> typex;
|
||||
// trap attempts to serialize with objects that don't
|
||||
// save class information in the archive with versioning.
|
||||
BOOST_STATIC_ASSERT(typex::value);
|
||||
}
|
||||
|
||||
template<class T>
|
||||
inline void check_object_tracking(){
|
||||
// presume it has already been determined that
|
||||
// T is not a const
|
||||
BOOST_STATIC_ASSERT(! boost::is_const< T >::value);
|
||||
typedef BOOST_DEDUCED_TYPENAME mpl::equal_to<
|
||||
serialization::tracking_level< T >,
|
||||
mpl::int_<serialization::track_never>
|
||||
>::type typex;
|
||||
// saving an non-const object of a type not marked "track_never)
|
||||
|
||||
// may be an indicator of an error usage of the
|
||||
// serialization library and should be double checked.
|
||||
// See documentation on object tracking. Also, see the
|
||||
// "rationale" section of the documenation
|
||||
// for motivation for this checking.
|
||||
|
||||
BOOST_STATIC_WARNING(typex::value);
|
||||
}
|
||||
|
||||
// checks for pointers
|
||||
|
||||
template<class T>
|
||||
inline void check_pointer_level(){
|
||||
// we should only invoke this once we KNOW that T
|
||||
// has been used as a pointer!!
|
||||
typedef
|
||||
BOOST_DEDUCED_TYPENAME mpl::or_<
|
||||
BOOST_DEDUCED_TYPENAME mpl::greater<
|
||||
serialization::implementation_level< T >,
|
||||
mpl::int_<serialization::object_serializable>
|
||||
>,
|
||||
BOOST_DEDUCED_TYPENAME mpl::not_<
|
||||
BOOST_DEDUCED_TYPENAME mpl::equal_to<
|
||||
serialization::tracking_level< T >,
|
||||
mpl::int_<serialization::track_selectively>
|
||||
>
|
||||
>
|
||||
> typex;
|
||||
// Address the following when serializing to a pointer:
|
||||
|
||||
// a) This type doesn't save class information in the
|
||||
// archive. That is, the serialization trait implementation
|
||||
// level <= object_serializable.
|
||||
// b) Tracking for this type is set to "track selectively"
|
||||
|
||||
// in this case, indication that an object is tracked is
|
||||
// not stored in the archive itself - see level == object_serializable
|
||||
// but rather the existence of the operation ar >> T * is used to
|
||||
// infer that an object of this type should be tracked. So, if
|
||||
// you save via a pointer but don't load via a pointer the operation
|
||||
// will fail on load without given any valid reason for the failure.
|
||||
|
||||
// So if your program traps here, consider changing the
|
||||
// tracking or implementation level traits - or not
|
||||
// serializing via a pointer.
|
||||
BOOST_STATIC_WARNING(typex::value);
|
||||
}
|
||||
|
||||
template<class T>
|
||||
void inline check_pointer_tracking(){
|
||||
typedef BOOST_DEDUCED_TYPENAME mpl::greater<
|
||||
serialization::tracking_level< T >,
|
||||
mpl::int_<serialization::track_never>
|
||||
>::type typex;
|
||||
// serializing an object of a type marked "track_never" through a pointer
|
||||
// could result in creating more objects than were saved!
|
||||
BOOST_STATIC_WARNING(typex::value);
|
||||
}
|
||||
|
||||
template<class T>
|
||||
inline void check_const_loading(){
|
||||
typedef
|
||||
BOOST_DEDUCED_TYPENAME mpl::or_<
|
||||
BOOST_DEDUCED_TYPENAME boost::serialization::is_wrapper< T >,
|
||||
BOOST_DEDUCED_TYPENAME mpl::not_<
|
||||
BOOST_DEDUCED_TYPENAME boost::is_const< T >
|
||||
>
|
||||
>::type typex;
|
||||
// cannot load data into a "const" object unless it's a
|
||||
// wrapper around some other non-const object.
|
||||
BOOST_STATIC_ASSERT(typex::value);
|
||||
}
|
||||
|
||||
} // detail
|
||||
} // archive
|
||||
} // boost
|
||||
|
||||
#endif // BOOST_ARCHIVE_DETAIL_CHECK_HPP
|
||||
|
|
@ -0,0 +1,88 @@
|
|||
#ifndef BOOST_ARCHIVE_DETAIL_COMMON_IARCHIVE_HPP
|
||||
#define BOOST_ARCHIVE_DETAIL_COMMON_IARCHIVE_HPP
|
||||
|
||||
// MS compatible compilers support #pragma once
|
||||
#if defined(_MSC_VER) && (_MSC_VER >= 1020)
|
||||
# pragma once
|
||||
#endif
|
||||
|
||||
/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
|
||||
// common_iarchive.hpp
|
||||
|
||||
// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
|
||||
// Use, modification and distribution is subject to the Boost Software
|
||||
// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
// See http://www.boost.org for updates, documentation, and revision history.
|
||||
|
||||
#include <boost/config.hpp>
|
||||
|
||||
#include <boost/archive/detail/basic_iarchive.hpp>
|
||||
#include <boost/archive/detail/basic_pointer_iserializer.hpp>
|
||||
#include <boost/archive/detail/interface_iarchive.hpp>
|
||||
|
||||
#ifdef BOOST_MSVC
|
||||
# pragma warning(push)
|
||||
# pragma warning(disable : 4511 4512)
|
||||
#endif
|
||||
|
||||
namespace boost {
|
||||
namespace archive {
|
||||
namespace detail {
|
||||
|
||||
class extended_type_info;
|
||||
|
||||
// note: referred to as Curiously Recurring Template Patter (CRTP)
|
||||
template<class Archive>
|
||||
class common_iarchive :
|
||||
public basic_iarchive,
|
||||
public interface_iarchive<Archive>
|
||||
{
|
||||
friend class interface_iarchive<Archive>;
|
||||
private:
|
||||
virtual void vload(version_type & t){
|
||||
* this->This() >> t;
|
||||
}
|
||||
virtual void vload(object_id_type & t){
|
||||
* this->This() >> t;
|
||||
}
|
||||
virtual void vload(class_id_type & t){
|
||||
* this->This() >> t;
|
||||
}
|
||||
virtual void vload(class_id_optional_type & t){
|
||||
* this->This() >> t;
|
||||
}
|
||||
virtual void vload(tracking_type & t){
|
||||
* this->This() >> t;
|
||||
}
|
||||
virtual void vload(class_name_type &s){
|
||||
* this->This() >> s;
|
||||
}
|
||||
protected:
|
||||
// default processing - invoke serialization library
|
||||
template<class T>
|
||||
void load_override(T & t, BOOST_PFTO int){
|
||||
archive::load(* this->This(), t);
|
||||
}
|
||||
// default implementations of functions which emit start/end tags for
|
||||
// archive types that require them.
|
||||
void load_start(const char * /*name*/){}
|
||||
void load_end(const char * /*name*/){}
|
||||
// default archive initialization
|
||||
common_iarchive(unsigned int flags = 0) :
|
||||
basic_iarchive(flags),
|
||||
interface_iarchive<Archive>()
|
||||
{}
|
||||
};
|
||||
|
||||
} // namespace detail
|
||||
} // namespace archive
|
||||
} // namespace boost
|
||||
|
||||
#ifdef BOOST_MSVC
|
||||
#pragma warning(pop)
|
||||
#endif
|
||||
|
||||
#endif // BOOST_ARCHIVE_DETAIL_COMMON_IARCHIVE_HPP
|
||||
|
||||
|
|
@ -0,0 +1,87 @@
|
|||
#ifndef BOOST_ARCHIVE_DETAIL_COMMON_OARCHIVE_HPP
|
||||
#define BOOST_ARCHIVE_DETAIL_COMMON_OARCHIVE_HPP
|
||||
|
||||
// MS compatible compilers support #pragma once
|
||||
#if defined(_MSC_VER) && (_MSC_VER >= 1020)
|
||||
# pragma once
|
||||
#endif
|
||||
|
||||
/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
|
||||
// common_oarchive.hpp
|
||||
|
||||
// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
|
||||
// Use, modification and distribution is subject to the Boost Software
|
||||
// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
// See http://www.boost.org for updates, documentation, and revision history.
|
||||
|
||||
#include <boost/config.hpp>
|
||||
|
||||
#include <boost/archive/detail/basic_oarchive.hpp>
|
||||
#include <boost/archive/detail/interface_oarchive.hpp>
|
||||
|
||||
#ifdef BOOST_MSVC
|
||||
# pragma warning(push)
|
||||
# pragma warning(disable : 4511 4512)
|
||||
#endif
|
||||
|
||||
namespace boost {
|
||||
namespace archive {
|
||||
namespace detail {
|
||||
|
||||
// note: referred to as Curiously Recurring Template Patter (CRTP)
|
||||
template<class Archive>
|
||||
class common_oarchive :
|
||||
public basic_oarchive,
|
||||
public interface_oarchive<Archive>
|
||||
{
|
||||
friend class interface_oarchive<Archive>;
|
||||
private:
|
||||
virtual void vsave(const version_type t){
|
||||
* this->This() << t;
|
||||
}
|
||||
virtual void vsave(const object_id_type t){
|
||||
* this->This() << t;
|
||||
}
|
||||
virtual void vsave(const object_reference_type t){
|
||||
* this->This() << t;
|
||||
}
|
||||
virtual void vsave(const class_id_type t){
|
||||
* this->This() << t;
|
||||
}
|
||||
virtual void vsave(const class_id_reference_type t){
|
||||
* this->This() << t;
|
||||
}
|
||||
virtual void vsave(const class_id_optional_type t){
|
||||
* this->This() << t;
|
||||
}
|
||||
virtual void vsave(const class_name_type & t){
|
||||
* this->This() << t;
|
||||
}
|
||||
virtual void vsave(const tracking_type t){
|
||||
* this->This() << t;
|
||||
}
|
||||
protected:
|
||||
// default processing - invoke serialization library
|
||||
template<class T>
|
||||
void save_override(T & t, BOOST_PFTO int){
|
||||
archive::save(* this->This(), t);
|
||||
}
|
||||
void save_start(const char * /*name*/){}
|
||||
void save_end(const char * /*name*/){}
|
||||
common_oarchive(unsigned int flags = 0) :
|
||||
basic_oarchive(flags),
|
||||
interface_oarchive<Archive>()
|
||||
{}
|
||||
};
|
||||
|
||||
} // namespace detail
|
||||
} // namespace archive
|
||||
} // namespace boost
|
||||
|
||||
#ifdef BOOST_MSVC
|
||||
#pragma warning(pop)
|
||||
#endif
|
||||
|
||||
#endif // BOOST_ARCHIVE_DETAIL_COMMON_OARCHIVE_HPP
|
||||
|
|
@ -0,0 +1,79 @@
|
|||
#ifndef BOOST_ARCHIVE_DETAIL_DECL_HPP
|
||||
#define BOOST_ARCHIVE_DETAIL_DECL_HPP
|
||||
|
||||
// MS compatible compilers support #pragma once
|
||||
#if defined(_MSC_VER) && (_MSC_VER >= 1020)
|
||||
# pragma once
|
||||
#endif
|
||||
|
||||
/////////1/////////2///////// 3/////////4/////////5/////////6/////////7/////////8
|
||||
// decl.hpp
|
||||
//
|
||||
// (c) Copyright Robert Ramey 2004
|
||||
// Use, modification, and distribution is subject to the Boost Software
|
||||
// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
// See library home page at http://www.boost.org/libs/serialization
|
||||
|
||||
//----------------------------------------------------------------------------//
|
||||
|
||||
// This header implements separate compilation features as described in
|
||||
// http://www.boost.org/more/separate_compilation.html
|
||||
|
||||
#include <boost/config.hpp>
|
||||
#include <boost/preprocessor/facilities/empty.hpp>
|
||||
|
||||
#if defined(BOOST_HAS_DECLSPEC)
|
||||
#if (defined(BOOST_ALL_DYN_LINK) || defined(BOOST_SERIALIZATION_DYN_LINK))
|
||||
#if defined(BOOST_ARCHIVE_SOURCE)
|
||||
#if defined(__BORLANDC__)
|
||||
#define BOOST_ARCHIVE_DECL(T) T __export
|
||||
#define BOOST_ARCHIVE_OR_WARCHIVE_DECL(T) T __export
|
||||
#else
|
||||
#define BOOST_ARCHIVE_DECL(T) __declspec(dllexport) T
|
||||
#define BOOST_ARCHIVE_OR_WARCHIVE_DECL(T) __declspec(dllexport) T
|
||||
#endif
|
||||
#else
|
||||
#if defined(__BORLANDC__)
|
||||
#define BOOST_ARCHIVE_DECL(T) T __import
|
||||
#else
|
||||
#define BOOST_ARCHIVE_DECL(T) __declspec(dllimport) T
|
||||
#endif
|
||||
#endif
|
||||
#if defined(BOOST_WARCHIVE_SOURCE)
|
||||
#if defined(__BORLANDC__)
|
||||
#define BOOST_WARCHIVE_DECL(T) T __export
|
||||
#define BOOST_ARCHIVE_OR_WARCHIVE_DECL(T) T __export
|
||||
#else
|
||||
#define BOOST_WARCHIVE_DECL(T) __declspec(dllexport) T
|
||||
#define BOOST_ARCHIVE_OR_WARCHIVE_DECL(T) __declspec(dllexport) T
|
||||
#endif
|
||||
#else
|
||||
#if defined(__BORLANDC__)
|
||||
#define BOOST_WARCHIVE_DECL(T) T __import
|
||||
#else
|
||||
#define BOOST_WARCHIVE_DECL(T) __declspec(dllimport) T
|
||||
#endif
|
||||
#endif
|
||||
#if !defined(BOOST_WARCHIVE_SOURCE) && !defined(BOOST_ARCHIVE_SOURCE)
|
||||
#if defined(__BORLANDC__)
|
||||
#define BOOST_ARCHIVE_OR_WARCHIVE_DECL(T) T __import
|
||||
#else
|
||||
#define BOOST_ARCHIVE_OR_WARCHIVE_DECL(T) __declspec(dllimport) T
|
||||
#endif
|
||||
#endif
|
||||
#endif
|
||||
#endif // BOOST_HAS_DECLSPEC
|
||||
|
||||
#if ! defined(BOOST_ARCHIVE_DECL)
|
||||
#define BOOST_ARCHIVE_DECL(T) T
|
||||
#endif
|
||||
#if ! defined(BOOST_WARCHIVE_DECL)
|
||||
#define BOOST_WARCHIVE_DECL(T) T
|
||||
#endif
|
||||
#if ! defined(BOOST_ARCHIVE_OR_WARCHIVE_DECL)
|
||||
#define BOOST_ARCHIVE_OR_WARCHIVE_DECL(T) T
|
||||
#endif
|
||||
|
||||
#endif // BOOST_ARCHIVE_DETAIL_DECL_HPP
|
||||
|
|
@ -0,0 +1,77 @@
|
|||
#ifndef BOOST_ARCHIVE_DETAIL_INTERFACE_IARCHIVE_HPP
|
||||
#define BOOST_ARCHIVE_DETAIL_INTERFACE_IARCHIVE_HPP
|
||||
|
||||
// MS compatible compilers support #pragma once
|
||||
#if defined(_MSC_VER) && (_MSC_VER >= 1020)
|
||||
# pragma once
|
||||
#endif
|
||||
|
||||
/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
|
||||
// interface_iarchive.hpp
|
||||
|
||||
// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
|
||||
// Use, modification and distribution is subject to the Boost Software
|
||||
// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
// See http://www.boost.org for updates, documentation, and revision history.
|
||||
#include <cstddef> // NULL
|
||||
#include <boost/cstdint.hpp>
|
||||
#include <boost/mpl/bool.hpp>
|
||||
#include <boost/archive/detail/auto_link_archive.hpp>
|
||||
#include <boost/archive/detail/iserializer.hpp>
|
||||
#include <boost/serialization/singleton.hpp>
|
||||
#include <boost/archive/detail/abi_prefix.hpp> // must be the last header
|
||||
|
||||
namespace boost {
|
||||
namespace archive {
|
||||
namespace detail {
|
||||
|
||||
class BOOST_ARCHIVE_OR_WARCHIVE_DECL(BOOST_PP_EMPTY()) basic_pointer_iserializer;
|
||||
|
||||
template<class Archive>
|
||||
class interface_iarchive
|
||||
{
|
||||
protected:
|
||||
interface_iarchive(){};
|
||||
public:
|
||||
/////////////////////////////////////////////////////////
|
||||
// archive public interface
|
||||
typedef mpl::bool_<true> is_loading;
|
||||
typedef mpl::bool_<false> is_saving;
|
||||
|
||||
// return a pointer to the most derived class
|
||||
Archive * This(){
|
||||
return static_cast<Archive *>(this);
|
||||
}
|
||||
|
||||
template<class T>
|
||||
const basic_pointer_iserializer *
|
||||
register_type(T * = NULL){
|
||||
const basic_pointer_iserializer & bpis =
|
||||
boost::serialization::singleton<
|
||||
pointer_iserializer<Archive, T>
|
||||
>::get_const_instance();
|
||||
this->This()->register_basic_serializer(bpis.get_basic_serializer());
|
||||
return & bpis;
|
||||
}
|
||||
template<class T>
|
||||
Archive & operator>>(T & t){
|
||||
this->This()->load_override(t, 0);
|
||||
return * this->This();
|
||||
}
|
||||
|
||||
// the & operator
|
||||
template<class T>
|
||||
Archive & operator&(T & t){
|
||||
return *(this->This()) >> t;
|
||||
}
|
||||
};
|
||||
|
||||
} // namespace detail
|
||||
} // namespace archive
|
||||
} // namespace boost
|
||||
|
||||
#include <boost/archive/detail/abi_suffix.hpp> // pops abi_suffix.hpp pragmas
|
||||
|
||||
#endif // BOOST_ARCHIVE_DETAIL_INTERFACE_IARCHIVE_HPP
|
||||
|
|
@ -0,0 +1,84 @@
|
|||
#ifndef BOOST_ARCHIVE_DETAIL_INTERFACE_OARCHIVE_HPP
|
||||
#define BOOST_ARCHIVE_DETAIL_INTERFACE_OARCHIVE_HPP
|
||||
|
||||
// MS compatible compilers support #pragma once
|
||||
#if defined(_MSC_VER) && (_MSC_VER >= 1020)
|
||||
# pragma once
|
||||
#endif
|
||||
|
||||
/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
|
||||
// interface_oarchive.hpp
|
||||
|
||||
// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
|
||||
// Use, modification and distribution is subject to the Boost Software
|
||||
// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
// See http://www.boost.org for updates, documentation, and revision history.
|
||||
#include <cstddef> // NULL
|
||||
#include <boost/cstdint.hpp>
|
||||
#include <boost/mpl/bool.hpp>
|
||||
|
||||
#include <boost/archive/detail/auto_link_archive.hpp>
|
||||
#include <boost/archive/detail/oserializer.hpp>
|
||||
#include <boost/archive/detail/abi_prefix.hpp> // must be the last header
|
||||
|
||||
#include <boost/serialization/singleton.hpp>
|
||||
|
||||
namespace boost {
|
||||
namespace archive {
|
||||
namespace detail {
|
||||
|
||||
class BOOST_ARCHIVE_OR_WARCHIVE_DECL(BOOST_PP_EMPTY()) basic_pointer_oserializer;
|
||||
|
||||
template<class Archive>
|
||||
class interface_oarchive
|
||||
{
|
||||
protected:
|
||||
interface_oarchive(){};
|
||||
public:
|
||||
/////////////////////////////////////////////////////////
|
||||
// archive public interface
|
||||
typedef mpl::bool_<false> is_loading;
|
||||
typedef mpl::bool_<true> is_saving;
|
||||
|
||||
// return a pointer to the most derived class
|
||||
Archive * This(){
|
||||
return static_cast<Archive *>(this);
|
||||
}
|
||||
|
||||
template<class T>
|
||||
const basic_pointer_oserializer *
|
||||
register_type(const T * = NULL){
|
||||
const basic_pointer_oserializer & bpos =
|
||||
boost::serialization::singleton<
|
||||
pointer_oserializer<Archive, T>
|
||||
>::get_const_instance();
|
||||
this->This()->register_basic_serializer(bpos.get_basic_serializer());
|
||||
return & bpos;
|
||||
}
|
||||
|
||||
template<class T>
|
||||
Archive & operator<<(T & t){
|
||||
this->This()->save_override(t, 0);
|
||||
return * this->This();
|
||||
}
|
||||
|
||||
// the & operator
|
||||
template<class T>
|
||||
Archive & operator&(T & t){
|
||||
#ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING
|
||||
return * this->This() << const_cast<const T &>(t);
|
||||
#else
|
||||
return * this->This() << t;
|
||||
#endif
|
||||
}
|
||||
};
|
||||
|
||||
} // namespace detail
|
||||
} // namespace archive
|
||||
} // namespace boost
|
||||
|
||||
#include <boost/archive/detail/abi_suffix.hpp> // pops abi_suffix.hpp pragmas
|
||||
|
||||
#endif // BOOST_ARCHIVE_DETAIL_INTERFACE_IARCHIVE_HPP
|
||||
|
|
@ -0,0 +1,632 @@
|
|||
#ifndef BOOST_ARCHIVE_DETAIL_ISERIALIZER_HPP
|
||||
#define BOOST_ARCHIVE_DETAIL_ISERIALIZER_HPP
|
||||
|
||||
// MS compatible compilers support #pragma once
|
||||
#if defined(_MSC_VER) && (_MSC_VER >= 1020)
|
||||
# pragma once
|
||||
#pragma inline_depth(511)
|
||||
#pragma inline_recursion(on)
|
||||
#endif
|
||||
|
||||
#if defined(__MWERKS__)
|
||||
#pragma inline_depth(511)
|
||||
#endif
|
||||
|
||||
/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
|
||||
// iserializer.hpp: interface for serialization system.
|
||||
|
||||
// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
|
||||
// Use, modification and distribution is subject to the Boost Software
|
||||
// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
// See http://www.boost.org for updates, documentation, and revision history.
|
||||
|
||||
#include <new> // for placement new
|
||||
#include <memory> // for auto_ptr
|
||||
#include <cstddef> // size_t, NULL
|
||||
|
||||
#include <boost/config.hpp>
|
||||
#include <boost/detail/workaround.hpp>
|
||||
#if defined(BOOST_NO_STDC_NAMESPACE)
|
||||
namespace std{
|
||||
using ::size_t;
|
||||
} // namespace std
|
||||
#endif
|
||||
|
||||
#include <boost/static_assert.hpp>
|
||||
|
||||
#include <boost/mpl/eval_if.hpp>
|
||||
#include <boost/mpl/identity.hpp>
|
||||
#include <boost/mpl/greater_equal.hpp>
|
||||
#include <boost/mpl/equal_to.hpp>
|
||||
#include <boost/mpl/bool.hpp>
|
||||
#include <boost/detail/no_exceptions_support.hpp>
|
||||
|
||||
#ifndef BOOST_SERIALIZATION_DEFAULT_TYPE_INFO
|
||||
#include <boost/serialization/extended_type_info_typeid.hpp>
|
||||
#endif
|
||||
#include <boost/serialization/throw_exception.hpp>
|
||||
#include <boost/serialization/smart_cast.hpp>
|
||||
#include <boost/serialization/static_warning.hpp>
|
||||
|
||||
#include <boost/type_traits/is_pointer.hpp>
|
||||
#include <boost/type_traits/is_enum.hpp>
|
||||
#include <boost/type_traits/is_const.hpp>
|
||||
#include <boost/type_traits/remove_const.hpp>
|
||||
#include <boost/type_traits/remove_extent.hpp>
|
||||
#include <boost/type_traits/is_polymorphic.hpp>
|
||||
|
||||
#include <boost/serialization/assume_abstract.hpp>
|
||||
|
||||
#define DONT_USE_HAS_NEW_OPERATOR ( \
|
||||
defined(__BORLANDC__) \
|
||||
|| defined(__IBMCPP__) \
|
||||
|| defined(BOOST_MSVC) && (BOOST_MSVC <= 1300) \
|
||||
|| defined(__SUNPRO_CC) && (__SUNPRO_CC < 0x590) \
|
||||
)
|
||||
|
||||
#if ! DONT_USE_HAS_NEW_OPERATOR
|
||||
#include <boost/type_traits/has_new_operator.hpp>
|
||||
#endif
|
||||
|
||||
#include <boost/serialization/serialization.hpp>
|
||||
#include <boost/serialization/version.hpp>
|
||||
#include <boost/serialization/level.hpp>
|
||||
#include <boost/serialization/tracking.hpp>
|
||||
#include <boost/serialization/type_info_implementation.hpp>
|
||||
#include <boost/serialization/nvp.hpp>
|
||||
#include <boost/serialization/void_cast.hpp>
|
||||
#include <boost/serialization/array.hpp>
|
||||
#include <boost/serialization/collection_size_type.hpp>
|
||||
#include <boost/serialization/singleton.hpp>
|
||||
#include <boost/serialization/wrapper.hpp>
|
||||
|
||||
// the following is need only for dynamic cast of polymorphic pointers
|
||||
#include <boost/archive/archive_exception.hpp>
|
||||
#include <boost/archive/detail/basic_iarchive.hpp>
|
||||
#include <boost/archive/detail/basic_iserializer.hpp>
|
||||
#include <boost/archive/detail/basic_pointer_iserializer.hpp>
|
||||
#include <boost/archive/detail/archive_serializer_map.hpp>
|
||||
#include <boost/archive/detail/check.hpp>
|
||||
|
||||
namespace boost {
|
||||
|
||||
namespace serialization {
|
||||
class extended_type_info;
|
||||
} // namespace serialization
|
||||
|
||||
namespace archive {
|
||||
|
||||
// an accessor to permit friend access to archives. Needed because
|
||||
// some compilers don't handle friend templates completely
|
||||
class load_access {
|
||||
public:
|
||||
template<class Archive, class T>
|
||||
static void load_primitive(Archive &ar, T &t){
|
||||
ar.load(t);
|
||||
}
|
||||
};
|
||||
|
||||
namespace detail {
|
||||
|
||||
#ifdef BOOST_MSVC
|
||||
# pragma warning(push)
|
||||
# pragma warning(disable : 4511 4512)
|
||||
#endif
|
||||
|
||||
template<class Archive, class T>
|
||||
class iserializer : public basic_iserializer
|
||||
{
|
||||
private:
|
||||
virtual void destroy(/*const*/ void *address) const {
|
||||
boost::serialization::access::destroy(static_cast<T *>(address));
|
||||
}
|
||||
protected:
|
||||
// protected constructor since it's always created by singleton
|
||||
explicit iserializer() :
|
||||
basic_iserializer(
|
||||
boost::serialization::singleton<
|
||||
BOOST_DEDUCED_TYPENAME
|
||||
boost::serialization::type_info_implementation< T >::type
|
||||
>::get_const_instance()
|
||||
)
|
||||
{}
|
||||
public:
|
||||
virtual BOOST_DLLEXPORT void load_object_data(
|
||||
basic_iarchive & ar,
|
||||
void *x,
|
||||
const unsigned int file_version
|
||||
) const BOOST_USED;
|
||||
virtual bool class_info() const {
|
||||
return boost::serialization::implementation_level< T >::value
|
||||
>= boost::serialization::object_class_info;
|
||||
}
|
||||
virtual bool tracking(const unsigned int /* flags */) const {
|
||||
return boost::serialization::tracking_level< T >::value
|
||||
== boost::serialization::track_always
|
||||
|| ( boost::serialization::tracking_level< T >::value
|
||||
== boost::serialization::track_selectively
|
||||
&& serialized_as_pointer());
|
||||
}
|
||||
virtual version_type version() const {
|
||||
return version_type(::boost::serialization::version< T >::value);
|
||||
}
|
||||
virtual bool is_polymorphic() const {
|
||||
return boost::is_polymorphic< T >::value;
|
||||
}
|
||||
virtual ~iserializer(){};
|
||||
};
|
||||
|
||||
#ifdef BOOST_MSVC
|
||||
# pragma warning(pop)
|
||||
#endif
|
||||
|
||||
template<class Archive, class T>
|
||||
BOOST_DLLEXPORT void iserializer<Archive, T>::load_object_data(
|
||||
basic_iarchive & ar,
|
||||
void *x,
|
||||
const unsigned int file_version
|
||||
) const {
|
||||
// note: we now comment this out. Before we permited archive
|
||||
// version # to be very large. Now we don't. To permit
|
||||
// readers of these old archives, we have to suppress this
|
||||
// code. Perhaps in the future we might re-enable it but
|
||||
// permit its suppression with a runtime switch.
|
||||
#if 0
|
||||
// trap case where the program cannot handle the current version
|
||||
if(file_version > static_cast<const unsigned int>(version()))
|
||||
boost::serialization::throw_exception(
|
||||
archive::archive_exception(
|
||||
boost::archive::archive_exception::unsupported_class_version,
|
||||
get_debug_info()
|
||||
)
|
||||
);
|
||||
#endif
|
||||
// make sure call is routed through the higest interface that might
|
||||
// be specialized by the user.
|
||||
boost::serialization::serialize_adl(
|
||||
boost::serialization::smart_cast_reference<Archive &>(ar),
|
||||
* static_cast<T *>(x),
|
||||
file_version
|
||||
);
|
||||
}
|
||||
|
||||
#ifdef BOOST_MSVC
|
||||
# pragma warning(push)
|
||||
# pragma warning(disable : 4511 4512)
|
||||
#endif
|
||||
|
||||
template<class Archive, class T>
|
||||
class pointer_iserializer :
|
||||
public basic_pointer_iserializer
|
||||
{
|
||||
private:
|
||||
virtual const basic_iserializer & get_basic_serializer() const {
|
||||
return boost::serialization::singleton<
|
||||
iserializer<Archive, T>
|
||||
>::get_const_instance();
|
||||
}
|
||||
BOOST_DLLEXPORT virtual void load_object_ptr(
|
||||
basic_iarchive & ar,
|
||||
void * & x,
|
||||
const unsigned int file_version
|
||||
) const BOOST_USED;
|
||||
protected:
|
||||
// this should alway be a singleton so make the constructor protected
|
||||
pointer_iserializer();
|
||||
~pointer_iserializer();
|
||||
};
|
||||
|
||||
#ifdef BOOST_MSVC
|
||||
# pragma warning(pop)
|
||||
#endif
|
||||
|
||||
// note trick to be sure that operator new is using class specific
|
||||
// version if such exists. Due to Peter Dimov.
|
||||
// note: the following fails if T has no default constructor.
|
||||
// otherwise it would have been ideal
|
||||
//struct heap_allocator : public T
|
||||
//{
|
||||
// T * invoke(){
|
||||
// return ::new(sizeof(T));
|
||||
// }
|
||||
//}
|
||||
|
||||
template<class T>
|
||||
struct heap_allocator
|
||||
{
|
||||
// boost::has_new_operator< T > doesn't work on these compilers
|
||||
#if DONT_USE_HAS_NEW_OPERATOR
|
||||
// This doesn't handle operator new overload for class T
|
||||
static T * invoke(){
|
||||
return static_cast<T *>(operator new(sizeof(T)));
|
||||
}
|
||||
#else
|
||||
struct has_new_operator {
|
||||
static T* invoke() {
|
||||
return static_cast<T *>((T::operator new)(sizeof(T)));
|
||||
}
|
||||
};
|
||||
struct doesnt_have_new_operator {
|
||||
static T* invoke() {
|
||||
return static_cast<T *>(operator new(sizeof(T)));
|
||||
}
|
||||
};
|
||||
static T * invoke() {
|
||||
typedef BOOST_DEDUCED_TYPENAME
|
||||
mpl::eval_if<
|
||||
boost::has_new_operator< T >,
|
||||
mpl::identity<has_new_operator >,
|
||||
mpl::identity<doesnt_have_new_operator >
|
||||
>::type typex;
|
||||
return typex::invoke();
|
||||
}
|
||||
#endif
|
||||
};
|
||||
|
||||
// due to Martin Ecker
|
||||
template <typename T>
|
||||
class auto_ptr_with_deleter
|
||||
{
|
||||
public:
|
||||
explicit auto_ptr_with_deleter(T* p) :
|
||||
m_p(p)
|
||||
{}
|
||||
~auto_ptr_with_deleter(){
|
||||
if (m_p)
|
||||
boost::serialization::access::destroy(m_p);
|
||||
}
|
||||
T* get() const {
|
||||
return m_p;
|
||||
}
|
||||
|
||||
T* release() {
|
||||
T* p = m_p;
|
||||
m_p = NULL;
|
||||
return p;
|
||||
}
|
||||
private:
|
||||
T* m_p;
|
||||
};
|
||||
|
||||
// note: BOOST_DLLEXPORT is so that code for polymorphic class
|
||||
// serialized only through base class won't get optimized out
|
||||
template<class Archive, class T>
|
||||
BOOST_DLLEXPORT void pointer_iserializer<Archive, T>::load_object_ptr(
|
||||
basic_iarchive & ar,
|
||||
void * & x,
|
||||
const unsigned int file_version
|
||||
) const
|
||||
{
|
||||
Archive & ar_impl =
|
||||
boost::serialization::smart_cast_reference<Archive &>(ar);
|
||||
|
||||
auto_ptr_with_deleter< T > ap(heap_allocator< T >::invoke());
|
||||
if(NULL == ap.get())
|
||||
boost::serialization::throw_exception(std::bad_alloc()) ;
|
||||
|
||||
T * t = ap.get();
|
||||
x = t;
|
||||
|
||||
// catch exception during load_construct_data so that we don't
|
||||
// automatically delete the t which is most likely not fully
|
||||
// constructed
|
||||
BOOST_TRY {
|
||||
// this addresses an obscure situtation that occurs when
|
||||
// load_constructor de-serializes something through a pointer.
|
||||
ar.next_object_pointer(t);
|
||||
boost::serialization::load_construct_data_adl<Archive, T>(
|
||||
ar_impl,
|
||||
t,
|
||||
file_version
|
||||
);
|
||||
}
|
||||
BOOST_CATCH(...){
|
||||
ap.release();
|
||||
BOOST_RETHROW;
|
||||
}
|
||||
BOOST_CATCH_END
|
||||
|
||||
ar_impl >> boost::serialization::make_nvp(NULL, * t);
|
||||
ap.release();
|
||||
}
|
||||
|
||||
template<class Archive, class T>
|
||||
pointer_iserializer<Archive, T>::pointer_iserializer() :
|
||||
basic_pointer_iserializer(
|
||||
boost::serialization::singleton<
|
||||
BOOST_DEDUCED_TYPENAME
|
||||
boost::serialization::type_info_implementation< T >::type
|
||||
>::get_const_instance()
|
||||
)
|
||||
{
|
||||
boost::serialization::singleton<
|
||||
iserializer<Archive, T>
|
||||
>::get_mutable_instance().set_bpis(this);
|
||||
archive_serializer_map<Archive>::insert(this);
|
||||
}
|
||||
|
||||
template<class Archive, class T>
|
||||
pointer_iserializer<Archive, T>::~pointer_iserializer(){
|
||||
archive_serializer_map<Archive>::erase(this);
|
||||
}
|
||||
|
||||
template<class Archive>
|
||||
struct load_non_pointer_type {
|
||||
// note this bounces the call right back to the archive
|
||||
// with no runtime overhead
|
||||
struct load_primitive {
|
||||
template<class T>
|
||||
static void invoke(Archive & ar, T & t){
|
||||
load_access::load_primitive(ar, t);
|
||||
}
|
||||
};
|
||||
// note this bounces the call right back to the archive
|
||||
// with no runtime overhead
|
||||
struct load_only {
|
||||
template<class T>
|
||||
static void invoke(Archive & ar, const T & t){
|
||||
// short cut to user's serializer
|
||||
// make sure call is routed through the higest interface that might
|
||||
// be specialized by the user.
|
||||
boost::serialization::serialize_adl(
|
||||
ar,
|
||||
const_cast<T &>(t),
|
||||
boost::serialization::version< T >::value
|
||||
);
|
||||
}
|
||||
};
|
||||
|
||||
// note this save class information including version
|
||||
// and serialization level to the archive
|
||||
struct load_standard {
|
||||
template<class T>
|
||||
static void invoke(Archive &ar, const T & t){
|
||||
void * x = & const_cast<T &>(t);
|
||||
ar.load_object(
|
||||
x,
|
||||
boost::serialization::singleton<
|
||||
iserializer<Archive, T>
|
||||
>::get_const_instance()
|
||||
);
|
||||
}
|
||||
};
|
||||
|
||||
struct load_conditional {
|
||||
template<class T>
|
||||
static void invoke(Archive &ar, T &t){
|
||||
//if(0 == (ar.get_flags() & no_tracking))
|
||||
load_standard::invoke(ar, t);
|
||||
//else
|
||||
// load_only::invoke(ar, t);
|
||||
}
|
||||
};
|
||||
|
||||
template<class T>
|
||||
static void invoke(Archive & ar, T &t){
|
||||
typedef BOOST_DEDUCED_TYPENAME mpl::eval_if<
|
||||
// if its primitive
|
||||
mpl::equal_to<
|
||||
boost::serialization::implementation_level< T >,
|
||||
mpl::int_<boost::serialization::primitive_type>
|
||||
>,
|
||||
mpl::identity<load_primitive>,
|
||||
// else
|
||||
BOOST_DEDUCED_TYPENAME mpl::eval_if<
|
||||
// class info / version
|
||||
mpl::greater_equal<
|
||||
boost::serialization::implementation_level< T >,
|
||||
mpl::int_<boost::serialization::object_class_info>
|
||||
>,
|
||||
// do standard load
|
||||
mpl::identity<load_standard>,
|
||||
// else
|
||||
BOOST_DEDUCED_TYPENAME mpl::eval_if<
|
||||
// no tracking
|
||||
mpl::equal_to<
|
||||
boost::serialization::tracking_level< T >,
|
||||
mpl::int_<boost::serialization::track_never>
|
||||
>,
|
||||
// do a fast load
|
||||
mpl::identity<load_only>,
|
||||
// else
|
||||
// do a fast load only tracking is turned off
|
||||
mpl::identity<load_conditional>
|
||||
> > >::type typex;
|
||||
check_object_versioning< T >();
|
||||
check_object_level< T >();
|
||||
typex::invoke(ar, t);
|
||||
}
|
||||
};
|
||||
|
||||
template<class Archive>
|
||||
struct load_pointer_type {
|
||||
struct abstract
|
||||
{
|
||||
template<class T>
|
||||
static const basic_pointer_iserializer * register_type(Archive & /* ar */){
|
||||
// it has? to be polymorphic
|
||||
BOOST_STATIC_ASSERT(boost::is_polymorphic< T >::value);
|
||||
return static_cast<basic_pointer_iserializer *>(NULL);
|
||||
}
|
||||
};
|
||||
|
||||
struct non_abstract
|
||||
{
|
||||
template<class T>
|
||||
static const basic_pointer_iserializer * register_type(Archive & ar){
|
||||
return ar.register_type(static_cast<T *>(NULL));
|
||||
}
|
||||
};
|
||||
|
||||
template<class T>
|
||||
static const basic_pointer_iserializer * register_type(Archive &ar, const T & /*t*/){
|
||||
// there should never be any need to load an abstract polymorphic
|
||||
// class pointer. Inhibiting code generation for this
|
||||
// permits abstract base classes to be used - note: exception
|
||||
// virtual serialize functions used for plug-ins
|
||||
typedef BOOST_DEDUCED_TYPENAME
|
||||
mpl::eval_if<
|
||||
boost::serialization::is_abstract<const T>,
|
||||
boost::mpl::identity<abstract>,
|
||||
boost::mpl::identity<non_abstract>
|
||||
>::type typex;
|
||||
return typex::template register_type< T >(ar);
|
||||
}
|
||||
|
||||
template<class T>
|
||||
static T * pointer_tweak(
|
||||
const boost::serialization::extended_type_info & eti,
|
||||
void const * const t,
|
||||
const T &
|
||||
) {
|
||||
// tweak the pointer back to the base class
|
||||
return static_cast<T *>(
|
||||
const_cast<void *>(
|
||||
boost::serialization::void_upcast(
|
||||
eti,
|
||||
boost::serialization::singleton<
|
||||
BOOST_DEDUCED_TYPENAME
|
||||
boost::serialization::type_info_implementation< T >::type
|
||||
>::get_const_instance(),
|
||||
t
|
||||
)
|
||||
)
|
||||
);
|
||||
}
|
||||
|
||||
template<class T>
|
||||
static void check_load(T & /* t */){
|
||||
check_pointer_level< T >();
|
||||
check_pointer_tracking< T >();
|
||||
}
|
||||
|
||||
static const basic_pointer_iserializer *
|
||||
find(const boost::serialization::extended_type_info & type){
|
||||
return static_cast<const basic_pointer_iserializer *>(
|
||||
archive_serializer_map<Archive>::find(type)
|
||||
);
|
||||
}
|
||||
|
||||
template<class Tptr>
|
||||
static void invoke(Archive & ar, Tptr & t){
|
||||
check_load(*t);
|
||||
const basic_pointer_iserializer * bpis_ptr = register_type(ar, *t);
|
||||
const basic_pointer_iserializer * newbpis_ptr = ar.load_pointer(
|
||||
// note major hack here !!!
|
||||
// I tried every way to convert Tptr &t (where Tptr might
|
||||
// include const) to void * &. This is the only way
|
||||
// I could make it work. RR
|
||||
(void * & )t,
|
||||
bpis_ptr,
|
||||
find
|
||||
);
|
||||
// if the pointer isn't that of the base class
|
||||
if(newbpis_ptr != bpis_ptr){
|
||||
t = pointer_tweak(newbpis_ptr->get_eti(), t, *t);
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
template<class Archive>
|
||||
struct load_enum_type {
|
||||
template<class T>
|
||||
static void invoke(Archive &ar, T &t){
|
||||
// convert integers to correct enum to load
|
||||
int i;
|
||||
ar >> boost::serialization::make_nvp(NULL, i);
|
||||
t = static_cast< T >(i);
|
||||
}
|
||||
};
|
||||
|
||||
template<class Archive>
|
||||
struct load_array_type {
|
||||
template<class T>
|
||||
static void invoke(Archive &ar, T &t){
|
||||
typedef BOOST_DEDUCED_TYPENAME remove_extent< T >::type value_type;
|
||||
|
||||
// convert integers to correct enum to load
|
||||
// determine number of elements in the array. Consider the
|
||||
// fact that some machines will align elements on boundries
|
||||
// other than characters.
|
||||
std::size_t current_count = sizeof(t) / (
|
||||
static_cast<char *>(static_cast<void *>(&t[1]))
|
||||
- static_cast<char *>(static_cast<void *>(&t[0]))
|
||||
);
|
||||
boost::serialization::collection_size_type count;
|
||||
ar >> BOOST_SERIALIZATION_NVP(count);
|
||||
if(static_cast<std::size_t>(count) > current_count)
|
||||
boost::serialization::throw_exception(
|
||||
archive::archive_exception(
|
||||
boost::archive::archive_exception::array_size_too_short
|
||||
)
|
||||
);
|
||||
ar >> serialization::make_array(static_cast<value_type*>(&t[0]),count);
|
||||
}
|
||||
};
|
||||
|
||||
} // detail
|
||||
|
||||
template<class Archive, class T>
|
||||
inline void load(Archive & ar, T &t){
|
||||
// if this assertion trips. It means we're trying to load a
|
||||
// const object with a compiler that doesn't have correct
|
||||
// funtion template ordering. On other compilers, this is
|
||||
// handled below.
|
||||
detail::check_const_loading< T >();
|
||||
typedef
|
||||
BOOST_DEDUCED_TYPENAME mpl::eval_if<is_pointer< T >,
|
||||
mpl::identity<detail::load_pointer_type<Archive> >
|
||||
,//else
|
||||
BOOST_DEDUCED_TYPENAME mpl::eval_if<is_array< T >,
|
||||
mpl::identity<detail::load_array_type<Archive> >
|
||||
,//else
|
||||
BOOST_DEDUCED_TYPENAME mpl::eval_if<is_enum< T >,
|
||||
mpl::identity<detail::load_enum_type<Archive> >
|
||||
,//else
|
||||
mpl::identity<detail::load_non_pointer_type<Archive> >
|
||||
>
|
||||
>
|
||||
>::type typex;
|
||||
typex::invoke(ar, t);
|
||||
}
|
||||
|
||||
#if 0
|
||||
|
||||
// BORLAND
|
||||
#if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x560))
|
||||
// borland has a couple of problems
|
||||
// a) if function is partially specialized - see below
|
||||
// const paramters are transformed to non-const ones
|
||||
// b) implementation of base_object can't be made to work
|
||||
// correctly which results in all base_object s being const.
|
||||
// So, strip off the const for borland. This breaks the trap
|
||||
// for loading const objects - but I see no alternative
|
||||
template<class Archive, class T>
|
||||
inline void load(Archive &ar, const T & t){
|
||||
load(ar, const_cast<T &>(t));
|
||||
}
|
||||
#endif
|
||||
|
||||
// let wrappers through.
|
||||
#ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING
|
||||
template<class Archive, class T>
|
||||
inline void load_wrapper(Archive &ar, const T&t, mpl::true_){
|
||||
boost::archive::load(ar, const_cast<T&>(t));
|
||||
}
|
||||
|
||||
#if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x560))
|
||||
template<class Archive, class T>
|
||||
inline void load(Archive &ar, const T&t){
|
||||
load_wrapper(ar,t,serialization::is_wrapper< T >());
|
||||
}
|
||||
#endif
|
||||
#endif
|
||||
|
||||
#endif
|
||||
|
||||
} // namespace archive
|
||||
} // namespace boost
|
||||
|
||||
#endif // BOOST_ARCHIVE_DETAIL_ISERIALIZER_HPP
|
||||
|
|
@ -0,0 +1,531 @@
|
|||
#ifndef BOOST_ARCHIVE_OSERIALIZER_HPP
|
||||
#define BOOST_ARCHIVE_OSERIALIZER_HPP
|
||||
|
||||
// MS compatible compilers support #pragma once
|
||||
#if defined(_MSC_VER) && (_MSC_VER >= 1020)
|
||||
# pragma once
|
||||
#pragma inline_depth(511)
|
||||
#pragma inline_recursion(on)
|
||||
#endif
|
||||
|
||||
#if defined(__MWERKS__)
|
||||
#pragma inline_depth(511)
|
||||
#endif
|
||||
|
||||
/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
|
||||
// oserializer.hpp: interface for serialization system.
|
||||
|
||||
// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
|
||||
// Use, modification and distribution is subject to the Boost Software
|
||||
// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
// See http://www.boost.org for updates, documentation, and revision history.
|
||||
|
||||
#include <boost/assert.hpp>
|
||||
#include <cstddef> // NULL
|
||||
|
||||
#include <boost/config.hpp>
|
||||
#include <boost/static_assert.hpp>
|
||||
#include <boost/detail/workaround.hpp>
|
||||
|
||||
#include <boost/mpl/eval_if.hpp>
|
||||
#include <boost/mpl/equal_to.hpp>
|
||||
#include <boost/mpl/greater_equal.hpp>
|
||||
#include <boost/mpl/identity.hpp>
|
||||
|
||||
#ifndef BOOST_SERIALIZATION_DEFAULT_TYPE_INFO
|
||||
#include <boost/serialization/extended_type_info_typeid.hpp>
|
||||
#endif
|
||||
#include <boost/serialization/throw_exception.hpp>
|
||||
#include <boost/serialization/smart_cast.hpp>
|
||||
#include <boost/serialization/assume_abstract.hpp>
|
||||
#include <boost/serialization/static_warning.hpp>
|
||||
|
||||
#include <boost/type_traits/is_pointer.hpp>
|
||||
#include <boost/type_traits/is_enum.hpp>
|
||||
#include <boost/type_traits/is_const.hpp>
|
||||
#include <boost/type_traits/is_polymorphic.hpp>
|
||||
#include <boost/type_traits/remove_extent.hpp>
|
||||
|
||||
#include <boost/serialization/serialization.hpp>
|
||||
#include <boost/serialization/version.hpp>
|
||||
#include <boost/serialization/level.hpp>
|
||||
#include <boost/serialization/tracking.hpp>
|
||||
#include <boost/serialization/type_info_implementation.hpp>
|
||||
#include <boost/serialization/nvp.hpp>
|
||||
#include <boost/serialization/void_cast.hpp>
|
||||
#include <boost/serialization/array.hpp>
|
||||
#include <boost/serialization/collection_size_type.hpp>
|
||||
#include <boost/serialization/singleton.hpp>
|
||||
|
||||
#include <boost/archive/archive_exception.hpp>
|
||||
#include <boost/archive/detail/basic_oarchive.hpp>
|
||||
#include <boost/archive/detail/basic_oserializer.hpp>
|
||||
#include <boost/archive/detail/basic_pointer_oserializer.hpp>
|
||||
#include <boost/archive/detail/archive_serializer_map.hpp>
|
||||
#include <boost/archive/detail/check.hpp>
|
||||
|
||||
namespace boost {
|
||||
|
||||
namespace serialization {
|
||||
class extended_type_info;
|
||||
} // namespace serialization
|
||||
|
||||
namespace archive {
|
||||
|
||||
// an accessor to permit friend access to archives. Needed because
|
||||
// some compilers don't handle friend templates completely
|
||||
class save_access {
|
||||
public:
|
||||
template<class Archive>
|
||||
static void end_preamble(Archive & ar){
|
||||
ar.end_preamble();
|
||||
}
|
||||
template<class Archive, class T>
|
||||
static void save_primitive(Archive & ar, const T & t){
|
||||
ar.end_preamble();
|
||||
ar.save(t);
|
||||
}
|
||||
};
|
||||
|
||||
namespace detail {
|
||||
|
||||
#ifdef BOOST_MSVC
|
||||
# pragma warning(push)
|
||||
# pragma warning(disable : 4511 4512)
|
||||
#endif
|
||||
|
||||
template<class Archive, class T>
|
||||
class oserializer : public basic_oserializer
|
||||
{
|
||||
private:
|
||||
// private constructor to inhibit any existence other than the
|
||||
// static one
|
||||
public:
|
||||
explicit BOOST_DLLEXPORT oserializer() :
|
||||
basic_oserializer(
|
||||
boost::serialization::singleton<
|
||||
BOOST_DEDUCED_TYPENAME
|
||||
boost::serialization::type_info_implementation< T >::type
|
||||
>::get_const_instance()
|
||||
)
|
||||
{}
|
||||
virtual BOOST_DLLEXPORT void save_object_data(
|
||||
basic_oarchive & ar,
|
||||
const void *x
|
||||
) const BOOST_USED;
|
||||
virtual bool class_info() const {
|
||||
return boost::serialization::implementation_level< T >::value
|
||||
>= boost::serialization::object_class_info;
|
||||
}
|
||||
virtual bool tracking(const unsigned int /* flags */) const {
|
||||
return boost::serialization::tracking_level< T >::value == boost::serialization::track_always
|
||||
|| (boost::serialization::tracking_level< T >::value == boost::serialization::track_selectively
|
||||
&& serialized_as_pointer());
|
||||
}
|
||||
virtual version_type version() const {
|
||||
return version_type(::boost::serialization::version< T >::value);
|
||||
}
|
||||
virtual bool is_polymorphic() const {
|
||||
return boost::is_polymorphic< T >::value;
|
||||
}
|
||||
virtual ~oserializer(){}
|
||||
};
|
||||
|
||||
#ifdef BOOST_MSVC
|
||||
# pragma warning(pop)
|
||||
#endif
|
||||
|
||||
template<class Archive, class T>
|
||||
BOOST_DLLEXPORT void oserializer<Archive, T>::save_object_data(
|
||||
basic_oarchive & ar,
|
||||
const void *x
|
||||
) const {
|
||||
// make sure call is routed through the highest interface that might
|
||||
// be specialized by the user.
|
||||
BOOST_STATIC_ASSERT(boost::is_const< T >::value == false);
|
||||
boost::serialization::serialize_adl(
|
||||
boost::serialization::smart_cast_reference<Archive &>(ar),
|
||||
* static_cast<T *>(const_cast<void *>(x)),
|
||||
version()
|
||||
);
|
||||
}
|
||||
|
||||
#ifdef BOOST_MSVC
|
||||
# pragma warning(push)
|
||||
# pragma warning(disable : 4511 4512)
|
||||
#endif
|
||||
|
||||
template<class Archive, class T>
|
||||
class pointer_oserializer :
|
||||
public basic_pointer_oserializer
|
||||
{
|
||||
private:
|
||||
const basic_oserializer &
|
||||
get_basic_serializer() const {
|
||||
return boost::serialization::singleton<
|
||||
oserializer<Archive, T>
|
||||
>::get_const_instance();
|
||||
}
|
||||
virtual BOOST_DLLEXPORT void save_object_ptr(
|
||||
basic_oarchive & ar,
|
||||
const void * x
|
||||
) const BOOST_USED;
|
||||
public:
|
||||
pointer_oserializer();
|
||||
~pointer_oserializer();
|
||||
};
|
||||
|
||||
#ifdef BOOST_MSVC
|
||||
# pragma warning(pop)
|
||||
#endif
|
||||
|
||||
template<class Archive, class T>
|
||||
BOOST_DLLEXPORT void pointer_oserializer<Archive, T>::save_object_ptr(
|
||||
basic_oarchive & ar,
|
||||
const void * x
|
||||
) const {
|
||||
BOOST_ASSERT(NULL != x);
|
||||
// make sure call is routed through the highest interface that might
|
||||
// be specialized by the user.
|
||||
T * t = static_cast<T *>(const_cast<void *>(x));
|
||||
const unsigned int file_version = boost::serialization::version< T >::value;
|
||||
Archive & ar_impl
|
||||
= boost::serialization::smart_cast_reference<Archive &>(ar);
|
||||
boost::serialization::save_construct_data_adl<Archive, T>(
|
||||
ar_impl,
|
||||
t,
|
||||
file_version
|
||||
);
|
||||
ar_impl << boost::serialization::make_nvp(NULL, * t);
|
||||
}
|
||||
|
||||
template<class Archive, class T>
|
||||
pointer_oserializer<Archive, T>::pointer_oserializer() :
|
||||
basic_pointer_oserializer(
|
||||
boost::serialization::singleton<
|
||||
BOOST_DEDUCED_TYPENAME
|
||||
boost::serialization::type_info_implementation< T >::type
|
||||
>::get_const_instance()
|
||||
)
|
||||
{
|
||||
// make sure appropriate member function is instantiated
|
||||
boost::serialization::singleton<
|
||||
oserializer<Archive, T>
|
||||
>::get_mutable_instance().set_bpos(this);
|
||||
archive_serializer_map<Archive>::insert(this);
|
||||
}
|
||||
|
||||
template<class Archive, class T>
|
||||
pointer_oserializer<Archive, T>::~pointer_oserializer(){
|
||||
archive_serializer_map<Archive>::erase(this);
|
||||
}
|
||||
|
||||
template<class Archive>
|
||||
struct save_non_pointer_type {
|
||||
// note this bounces the call right back to the archive
|
||||
// with no runtime overhead
|
||||
struct save_primitive {
|
||||
template<class T>
|
||||
static void invoke(Archive & ar, const T & t){
|
||||
save_access::save_primitive(ar, t);
|
||||
}
|
||||
};
|
||||
// same as above but passes through serialization
|
||||
struct save_only {
|
||||
template<class T>
|
||||
static void invoke(Archive & ar, const T & t){
|
||||
// make sure call is routed through the highest interface that might
|
||||
// be specialized by the user.
|
||||
boost::serialization::serialize_adl(
|
||||
ar,
|
||||
const_cast<T &>(t),
|
||||
::boost::serialization::version< T >::value
|
||||
);
|
||||
}
|
||||
};
|
||||
// adds class information to the archive. This includes
|
||||
// serialization level and class version
|
||||
struct save_standard {
|
||||
template<class T>
|
||||
static void invoke(Archive &ar, const T & t){
|
||||
ar.save_object(
|
||||
& t,
|
||||
boost::serialization::singleton<
|
||||
oserializer<Archive, T>
|
||||
>::get_const_instance()
|
||||
);
|
||||
}
|
||||
};
|
||||
|
||||
// adds class information to the archive. This includes
|
||||
// serialization level and class version
|
||||
struct save_conditional {
|
||||
template<class T>
|
||||
static void invoke(Archive &ar, const T &t){
|
||||
//if(0 == (ar.get_flags() & no_tracking))
|
||||
save_standard::invoke(ar, t);
|
||||
//else
|
||||
// save_only::invoke(ar, t);
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
template<class T>
|
||||
static void invoke(Archive & ar, const T & t){
|
||||
typedef
|
||||
BOOST_DEDUCED_TYPENAME mpl::eval_if<
|
||||
// if its primitive
|
||||
mpl::equal_to<
|
||||
boost::serialization::implementation_level< T >,
|
||||
mpl::int_<boost::serialization::primitive_type>
|
||||
>,
|
||||
mpl::identity<save_primitive>,
|
||||
// else
|
||||
BOOST_DEDUCED_TYPENAME mpl::eval_if<
|
||||
// class info / version
|
||||
mpl::greater_equal<
|
||||
boost::serialization::implementation_level< T >,
|
||||
mpl::int_<boost::serialization::object_class_info>
|
||||
>,
|
||||
// do standard save
|
||||
mpl::identity<save_standard>,
|
||||
// else
|
||||
BOOST_DEDUCED_TYPENAME mpl::eval_if<
|
||||
// no tracking
|
||||
mpl::equal_to<
|
||||
boost::serialization::tracking_level< T >,
|
||||
mpl::int_<boost::serialization::track_never>
|
||||
>,
|
||||
// do a fast save
|
||||
mpl::identity<save_only>,
|
||||
// else
|
||||
// do a fast save only tracking is turned off
|
||||
mpl::identity<save_conditional>
|
||||
> > >::type typex;
|
||||
check_object_versioning< T >();
|
||||
typex::invoke(ar, t);
|
||||
}
|
||||
template<class T>
|
||||
static void invoke(Archive & ar, T & t){
|
||||
check_object_level< T >();
|
||||
check_object_tracking< T >();
|
||||
invoke(ar, const_cast<const T &>(t));
|
||||
}
|
||||
};
|
||||
|
||||
template<class Archive>
|
||||
struct save_pointer_type {
|
||||
struct abstract
|
||||
{
|
||||
template<class T>
|
||||
static const basic_pointer_oserializer * register_type(Archive & /* ar */){
|
||||
// it has? to be polymorphic
|
||||
BOOST_STATIC_ASSERT(boost::is_polymorphic< T >::value);
|
||||
return NULL;
|
||||
}
|
||||
};
|
||||
|
||||
struct non_abstract
|
||||
{
|
||||
template<class T>
|
||||
static const basic_pointer_oserializer * register_type(Archive & ar){
|
||||
return ar.register_type(static_cast<T *>(NULL));
|
||||
}
|
||||
};
|
||||
|
||||
template<class T>
|
||||
static const basic_pointer_oserializer * register_type(Archive &ar, T & /*t*/){
|
||||
// there should never be any need to save an abstract polymorphic
|
||||
// class pointer. Inhibiting code generation for this
|
||||
// permits abstract base classes to be used - note: exception
|
||||
// virtual serialize functions used for plug-ins
|
||||
typedef
|
||||
BOOST_DEDUCED_TYPENAME mpl::eval_if<
|
||||
boost::serialization::is_abstract< T >,
|
||||
mpl::identity<abstract>,
|
||||
mpl::identity<non_abstract>
|
||||
>::type typex;
|
||||
return typex::template register_type< T >(ar);
|
||||
}
|
||||
|
||||
struct non_polymorphic
|
||||
{
|
||||
template<class T>
|
||||
static void save(
|
||||
Archive &ar,
|
||||
T & t
|
||||
){
|
||||
const basic_pointer_oserializer & bpos =
|
||||
boost::serialization::singleton<
|
||||
pointer_oserializer<Archive, T>
|
||||
>::get_const_instance();
|
||||
// save the requested pointer type
|
||||
ar.save_pointer(& t, & bpos);
|
||||
}
|
||||
};
|
||||
|
||||
struct polymorphic
|
||||
{
|
||||
template<class T>
|
||||
static void save(
|
||||
Archive &ar,
|
||||
T & t
|
||||
){
|
||||
BOOST_DEDUCED_TYPENAME
|
||||
boost::serialization::type_info_implementation< T >::type const
|
||||
& i = boost::serialization::singleton<
|
||||
BOOST_DEDUCED_TYPENAME
|
||||
boost::serialization::type_info_implementation< T >::type
|
||||
>::get_const_instance();
|
||||
|
||||
boost::serialization::extended_type_info const * const this_type = & i;
|
||||
|
||||
// retrieve the true type of the object pointed to
|
||||
// if this assertion fails its an error in this library
|
||||
BOOST_ASSERT(NULL != this_type);
|
||||
|
||||
const boost::serialization::extended_type_info * true_type =
|
||||
i.get_derived_extended_type_info(t);
|
||||
|
||||
// note:if this exception is thrown, be sure that derived pointer
|
||||
// is either registered or exported.
|
||||
if(NULL == true_type){
|
||||
boost::serialization::throw_exception(
|
||||
archive_exception(
|
||||
archive_exception::unregistered_class,
|
||||
"derived class not registered or exported"
|
||||
)
|
||||
);
|
||||
}
|
||||
|
||||
// if its not a pointer to a more derived type
|
||||
const void *vp = static_cast<const void *>(&t);
|
||||
if(*this_type == *true_type){
|
||||
const basic_pointer_oserializer * bpos = register_type(ar, t);
|
||||
ar.save_pointer(vp, bpos);
|
||||
return;
|
||||
}
|
||||
// convert pointer to more derived type. if this is thrown
|
||||
// it means that the base/derived relationship hasn't be registered
|
||||
vp = serialization::void_downcast(
|
||||
*true_type,
|
||||
*this_type,
|
||||
static_cast<const void *>(&t)
|
||||
);
|
||||
if(NULL == vp){
|
||||
boost::serialization::throw_exception(
|
||||
archive_exception(
|
||||
archive_exception::unregistered_cast,
|
||||
true_type->get_debug_info(),
|
||||
this_type->get_debug_info()
|
||||
)
|
||||
);
|
||||
}
|
||||
|
||||
// since true_type is valid, and this only gets made if the
|
||||
// pointer oserializer object has been created, this should never
|
||||
// fail
|
||||
const basic_pointer_oserializer * bpos
|
||||
= static_cast<const basic_pointer_oserializer *>(
|
||||
boost::serialization::singleton<
|
||||
archive_serializer_map<Archive>
|
||||
>::get_const_instance().find(*true_type)
|
||||
);
|
||||
BOOST_ASSERT(NULL != bpos);
|
||||
if(NULL == bpos)
|
||||
boost::serialization::throw_exception(
|
||||
archive_exception(
|
||||
archive_exception::unregistered_class,
|
||||
"derived class not registered or exported"
|
||||
)
|
||||
);
|
||||
ar.save_pointer(vp, bpos);
|
||||
}
|
||||
};
|
||||
|
||||
template<class T>
|
||||
static void save(
|
||||
Archive & ar,
|
||||
const T & t
|
||||
){
|
||||
check_pointer_level< T >();
|
||||
check_pointer_tracking< T >();
|
||||
typedef BOOST_DEDUCED_TYPENAME mpl::eval_if<
|
||||
is_polymorphic< T >,
|
||||
mpl::identity<polymorphic>,
|
||||
mpl::identity<non_polymorphic>
|
||||
>::type type;
|
||||
type::save(ar, const_cast<T &>(t));
|
||||
}
|
||||
|
||||
template<class TPtr>
|
||||
static void invoke(Archive &ar, const TPtr t){
|
||||
register_type(ar, * t);
|
||||
if(NULL == t){
|
||||
basic_oarchive & boa
|
||||
= boost::serialization::smart_cast_reference<basic_oarchive &>(ar);
|
||||
boa.save_null_pointer();
|
||||
save_access::end_preamble(ar);
|
||||
return;
|
||||
}
|
||||
save(ar, * t);
|
||||
}
|
||||
};
|
||||
|
||||
template<class Archive>
|
||||
struct save_enum_type
|
||||
{
|
||||
template<class T>
|
||||
static void invoke(Archive &ar, const T &t){
|
||||
// convert enum to integers on save
|
||||
const int i = static_cast<int>(t);
|
||||
ar << boost::serialization::make_nvp(NULL, i);
|
||||
}
|
||||
};
|
||||
|
||||
template<class Archive>
|
||||
struct save_array_type
|
||||
{
|
||||
template<class T>
|
||||
static void invoke(Archive &ar, const T &t){
|
||||
typedef BOOST_DEDUCED_TYPENAME boost::remove_extent< T >::type value_type;
|
||||
|
||||
save_access::end_preamble(ar);
|
||||
// consider alignment
|
||||
std::size_t c = sizeof(t) / (
|
||||
static_cast<const char *>(static_cast<const void *>(&t[1]))
|
||||
- static_cast<const char *>(static_cast<const void *>(&t[0]))
|
||||
);
|
||||
boost::serialization::collection_size_type count(c);
|
||||
ar << BOOST_SERIALIZATION_NVP(count);
|
||||
ar << serialization::make_array(static_cast<value_type const*>(&t[0]),count);
|
||||
}
|
||||
};
|
||||
|
||||
} // detail
|
||||
|
||||
template<class Archive, class T>
|
||||
inline void save(Archive & ar, /*const*/ T &t){
|
||||
typedef
|
||||
BOOST_DEDUCED_TYPENAME mpl::eval_if<is_pointer< T >,
|
||||
mpl::identity<detail::save_pointer_type<Archive> >,
|
||||
//else
|
||||
BOOST_DEDUCED_TYPENAME mpl::eval_if<is_enum< T >,
|
||||
mpl::identity<detail::save_enum_type<Archive> >,
|
||||
//else
|
||||
BOOST_DEDUCED_TYPENAME mpl::eval_if<is_array< T >,
|
||||
mpl::identity<detail::save_array_type<Archive> >,
|
||||
//else
|
||||
mpl::identity<detail::save_non_pointer_type<Archive> >
|
||||
>
|
||||
>
|
||||
>::type typex;
|
||||
typex::invoke(ar, t);
|
||||
}
|
||||
|
||||
} // namespace archive
|
||||
} // namespace boost
|
||||
|
||||
#endif // BOOST_ARCHIVE_OSERIALIZER_HPP
|
||||
|
|
@ -0,0 +1,215 @@
|
|||
#ifndef BOOST_ARCHIVE_DETAIL_POLYMORPHIC_IARCHIVE_ROUTE_HPP
|
||||
#define BOOST_ARCHIVE_DETAIL_POLYMORPHIC_IARCHIVE_ROUTE_HPP
|
||||
|
||||
// MS compatible compilers support #pragma once
|
||||
#if defined(_MSC_VER) && (_MSC_VER >= 1020)
|
||||
# pragma once
|
||||
#endif
|
||||
|
||||
/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
|
||||
// polymorphic_iarchive_route.hpp
|
||||
|
||||
// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
|
||||
// Use, modification and distribution is subject to the Boost Software
|
||||
// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
// See http://www.boost.org for updates, documentation, and revision history.
|
||||
|
||||
#include <string>
|
||||
#include <ostream>
|
||||
#include <cstddef>
|
||||
|
||||
#include <boost/config.hpp>
|
||||
#if defined(BOOST_NO_STDC_NAMESPACE)
|
||||
namespace std{
|
||||
using ::size_t;
|
||||
} // namespace std
|
||||
#endif
|
||||
|
||||
#include <boost/cstdint.hpp>
|
||||
#include <boost/integer_traits.hpp>
|
||||
#include <boost/archive/polymorphic_iarchive.hpp>
|
||||
#include <boost/archive/detail/abi_prefix.hpp> // must be the last header
|
||||
|
||||
namespace boost {
|
||||
namespace serialization {
|
||||
class extended_type_info;
|
||||
} // namespace serialization
|
||||
namespace archive {
|
||||
namespace detail{
|
||||
|
||||
class BOOST_ARCHIVE_DECL(BOOST_PP_EMPTY()) basic_iserializer;
|
||||
class BOOST_ARCHIVE_DECL(BOOST_PP_EMPTY()) basic_pointer_iserializer;
|
||||
|
||||
#ifdef BOOST_MSVC
|
||||
# pragma warning(push)
|
||||
# pragma warning(disable : 4511 4512)
|
||||
#endif
|
||||
|
||||
template<class ArchiveImplementation>
|
||||
class polymorphic_iarchive_route :
|
||||
public polymorphic_iarchive,
|
||||
// note: gcc dynamic cross cast fails if the the derivation below is
|
||||
// not public. I think this is a mistake.
|
||||
public /*protected*/ ArchiveImplementation
|
||||
{
|
||||
private:
|
||||
// these are used by the serialization library.
|
||||
virtual void load_object(
|
||||
void *t,
|
||||
const basic_iserializer & bis
|
||||
){
|
||||
ArchiveImplementation::load_object(t, bis);
|
||||
}
|
||||
virtual 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
|
||||
)
|
||||
){
|
||||
return ArchiveImplementation::load_pointer(t, bpis_ptr, finder);
|
||||
}
|
||||
virtual void set_library_version(library_version_type archive_library_version){
|
||||
ArchiveImplementation::set_library_version(archive_library_version);
|
||||
}
|
||||
virtual library_version_type get_library_version() const{
|
||||
return ArchiveImplementation::get_library_version();
|
||||
}
|
||||
virtual unsigned int get_flags() const {
|
||||
return ArchiveImplementation::get_flags();
|
||||
}
|
||||
virtual void delete_created_pointers(){
|
||||
ArchiveImplementation::delete_created_pointers();
|
||||
}
|
||||
virtual void reset_object_address(
|
||||
const void * new_address,
|
||||
const void * old_address
|
||||
){
|
||||
ArchiveImplementation::reset_object_address(new_address, old_address);
|
||||
}
|
||||
virtual void load_binary(void * t, std::size_t size){
|
||||
ArchiveImplementation::load_binary(t, size);
|
||||
}
|
||||
// primitive types the only ones permitted by polymorphic archives
|
||||
virtual void load(bool & t){
|
||||
ArchiveImplementation::load(t);
|
||||
}
|
||||
virtual void load(char & t){
|
||||
ArchiveImplementation::load(t);
|
||||
}
|
||||
virtual void load(signed char & t){
|
||||
ArchiveImplementation::load(t);
|
||||
}
|
||||
virtual void load(unsigned char & t){
|
||||
ArchiveImplementation::load(t);
|
||||
}
|
||||
#ifndef BOOST_NO_CWCHAR
|
||||
#ifndef BOOST_NO_INTRINSIC_WCHAR_T
|
||||
virtual void load(wchar_t & t){
|
||||
ArchiveImplementation::load(t);
|
||||
}
|
||||
#endif
|
||||
#endif
|
||||
virtual void load(short & t){
|
||||
ArchiveImplementation::load(t);
|
||||
}
|
||||
virtual void load(unsigned short & t){
|
||||
ArchiveImplementation::load(t);
|
||||
}
|
||||
virtual void load(int & t){
|
||||
ArchiveImplementation::load(t);
|
||||
}
|
||||
virtual void load(unsigned int & t){
|
||||
ArchiveImplementation::load(t);
|
||||
}
|
||||
virtual void load(long & t){
|
||||
ArchiveImplementation::load(t);
|
||||
}
|
||||
virtual void load(unsigned long & t){
|
||||
ArchiveImplementation::load(t);
|
||||
}
|
||||
#if defined(BOOST_HAS_LONG_LONG)
|
||||
virtual void load(boost::long_long_type & t){
|
||||
ArchiveImplementation::load(t);
|
||||
}
|
||||
virtual void load(boost::ulong_long_type & t){
|
||||
ArchiveImplementation::load(t);
|
||||
}
|
||||
#elif defined(BOOST_HAS_MS_INT64)
|
||||
virtual void load(__int64 & t){
|
||||
ArchiveImplementation::load(t);
|
||||
}
|
||||
virtual void load(unsigned __int64 & t){
|
||||
ArchiveImplementation::load(t);
|
||||
}
|
||||
#endif
|
||||
virtual void load(float & t){
|
||||
ArchiveImplementation::load(t);
|
||||
}
|
||||
virtual void load(double & t){
|
||||
ArchiveImplementation::load(t);
|
||||
}
|
||||
virtual void load(std::string & t){
|
||||
ArchiveImplementation::load(t);
|
||||
}
|
||||
#ifndef BOOST_NO_STD_WSTRING
|
||||
virtual void load(std::wstring & t){
|
||||
ArchiveImplementation::load(t);
|
||||
}
|
||||
#endif
|
||||
// used for xml and other tagged formats default does nothing
|
||||
virtual void load_start(const char * name){
|
||||
ArchiveImplementation::load_start(name);
|
||||
}
|
||||
virtual void load_end(const char * name){
|
||||
ArchiveImplementation::load_end(name);
|
||||
}
|
||||
|
||||
virtual void register_basic_serializer(const basic_iserializer & bis){
|
||||
ArchiveImplementation::register_basic_serializer(bis);
|
||||
}
|
||||
public:
|
||||
// this can't be inheriteded because they appear in mulitple
|
||||
// parents
|
||||
typedef mpl::bool_<true> is_loading;
|
||||
typedef mpl::bool_<false> is_saving;
|
||||
// the >> operator
|
||||
template<class T>
|
||||
polymorphic_iarchive & operator>>(T & t){
|
||||
return polymorphic_iarchive::operator>>(t);
|
||||
}
|
||||
// the & operator
|
||||
template<class T>
|
||||
polymorphic_iarchive & operator&(T & t){
|
||||
return polymorphic_iarchive::operator&(t);
|
||||
}
|
||||
// register type function
|
||||
template<class T>
|
||||
const basic_pointer_iserializer *
|
||||
register_type(T * t = NULL){
|
||||
return ArchiveImplementation::register_type(t);
|
||||
}
|
||||
// all current archives take a stream as constructor argument
|
||||
template <class _Elem, class _Tr>
|
||||
polymorphic_iarchive_route(
|
||||
std::basic_istream<_Elem, _Tr> & is,
|
||||
unsigned int flags = 0
|
||||
) :
|
||||
ArchiveImplementation(is, flags)
|
||||
{}
|
||||
virtual ~polymorphic_iarchive_route(){};
|
||||
};
|
||||
|
||||
} // namespace detail
|
||||
} // namespace archive
|
||||
} // namespace boost
|
||||
|
||||
#ifdef BOOST_MSVC
|
||||
#pragma warning(pop)
|
||||
#endif
|
||||
|
||||
#include <boost/archive/detail/abi_suffix.hpp> // pops abi_suffix.hpp pragmas
|
||||
|
||||
#endif // BOOST_ARCHIVE_DETAIL_POLYMORPHIC_IARCHIVE_DISPATCH_HPP
|
||||
|
|
@ -0,0 +1,205 @@
|
|||
#ifndef BOOST_ARCHIVE_DETAIL_POLYMORPHIC_OARCHIVE_ROUTE_HPP
|
||||
#define BOOST_ARCHIVE_DETAIL_POLYMORPHIC_OARCHIVE_ROUTE_HPP
|
||||
|
||||
// MS compatible compilers support #pragma once
|
||||
#if defined(_MSC_VER) && (_MSC_VER >= 1020)
|
||||
# pragma once
|
||||
#endif
|
||||
|
||||
/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
|
||||
// polymorphic_oarchive_route.hpp
|
||||
|
||||
// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
|
||||
// Use, modification and distribution is subject to the Boost Software
|
||||
// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
// See http://www.boost.org for updates, documentation, and revision history.
|
||||
|
||||
#include <string>
|
||||
#include <ostream>
|
||||
#include <cstddef> // size_t
|
||||
|
||||
#include <boost/config.hpp>
|
||||
#if defined(BOOST_NO_STDC_NAMESPACE)
|
||||
namespace std{
|
||||
using ::size_t;
|
||||
} // namespace std
|
||||
#endif
|
||||
|
||||
#include <boost/cstdint.hpp>
|
||||
#include <boost/integer_traits.hpp>
|
||||
#include <boost/archive/polymorphic_oarchive.hpp>
|
||||
#include <boost/archive/detail/abi_prefix.hpp> // must be the last header
|
||||
|
||||
namespace boost {
|
||||
namespace serialization {
|
||||
class extended_type_info;
|
||||
} // namespace serialization
|
||||
namespace archive {
|
||||
namespace detail{
|
||||
|
||||
class BOOST_ARCHIVE_DECL(BOOST_PP_EMPTY()) basic_oserializer;
|
||||
class BOOST_ARCHIVE_DECL(BOOST_PP_EMPTY()) basic_pointer_oserializer;
|
||||
|
||||
#ifdef BOOST_MSVC
|
||||
# pragma warning(push)
|
||||
# pragma warning(disable : 4511 4512)
|
||||
#endif
|
||||
|
||||
template<class ArchiveImplementation>
|
||||
class polymorphic_oarchive_route :
|
||||
public polymorphic_oarchive,
|
||||
// note: gcc dynamic cross cast fails if the the derivation below is
|
||||
// not public. I think this is a mistake.
|
||||
public /*protected*/ ArchiveImplementation
|
||||
{
|
||||
private:
|
||||
// these are used by the serialization library.
|
||||
virtual void save_object(
|
||||
const void *x,
|
||||
const detail::basic_oserializer & bos
|
||||
){
|
||||
ArchiveImplementation::save_object(x, bos);
|
||||
}
|
||||
virtual void save_pointer(
|
||||
const void * t,
|
||||
const detail::basic_pointer_oserializer * bpos_ptr
|
||||
){
|
||||
ArchiveImplementation::save_pointer(t, bpos_ptr);
|
||||
}
|
||||
virtual void save_null_pointer(){
|
||||
ArchiveImplementation::save_null_pointer();
|
||||
}
|
||||
// primitive types the only ones permitted by polymorphic archives
|
||||
virtual void save(const bool t){
|
||||
ArchiveImplementation::save(t);
|
||||
}
|
||||
virtual void save(const char t){
|
||||
ArchiveImplementation::save(t);
|
||||
}
|
||||
virtual void save(const signed char t){
|
||||
ArchiveImplementation::save(t);
|
||||
}
|
||||
virtual void save(const unsigned char t){
|
||||
ArchiveImplementation::save(t);
|
||||
}
|
||||
#ifndef BOOST_NO_CWCHAR
|
||||
#ifndef BOOST_NO_INTRINSIC_WCHAR_T
|
||||
virtual void save(const wchar_t t){
|
||||
ArchiveImplementation::save(t);
|
||||
}
|
||||
#endif
|
||||
#endif
|
||||
virtual void save(const short t){
|
||||
ArchiveImplementation::save(t);
|
||||
}
|
||||
virtual void save(const unsigned short t){
|
||||
ArchiveImplementation::save(t);
|
||||
}
|
||||
virtual void save(const int t){
|
||||
ArchiveImplementation::save(t);
|
||||
}
|
||||
virtual void save(const unsigned int t){
|
||||
ArchiveImplementation::save(t);
|
||||
}
|
||||
virtual void save(const long t){
|
||||
ArchiveImplementation::save(t);
|
||||
}
|
||||
virtual void save(const unsigned long t){
|
||||
ArchiveImplementation::save(t);
|
||||
}
|
||||
#if defined(BOOST_HAS_LONG_LONG)
|
||||
virtual void save(const boost::long_long_type t){
|
||||
ArchiveImplementation::save(t);
|
||||
}
|
||||
virtual void save(const boost::ulong_long_type t){
|
||||
ArchiveImplementation::save(t);
|
||||
}
|
||||
#elif defined(BOOST_HAS_MS_INT64)
|
||||
virtual void save(const boost::int64_t t){
|
||||
ArchiveImplementation::save(t);
|
||||
}
|
||||
virtual void save(const boost::uint64_t t){
|
||||
ArchiveImplementation::save(t);
|
||||
}
|
||||
#endif
|
||||
virtual void save(const float t){
|
||||
ArchiveImplementation::save(t);
|
||||
}
|
||||
virtual void save(const double t){
|
||||
ArchiveImplementation::save(t);
|
||||
}
|
||||
virtual void save(const std::string & t){
|
||||
ArchiveImplementation::save(t);
|
||||
}
|
||||
#ifndef BOOST_NO_STD_WSTRING
|
||||
virtual void save(const std::wstring & t){
|
||||
ArchiveImplementation::save(t);
|
||||
}
|
||||
#endif
|
||||
virtual library_version_type get_library_version() const{
|
||||
return ArchiveImplementation::get_library_version();
|
||||
}
|
||||
virtual unsigned int get_flags() const {
|
||||
return ArchiveImplementation::get_flags();
|
||||
}
|
||||
virtual void save_binary(const void * t, std::size_t size){
|
||||
ArchiveImplementation::save_binary(t, size);
|
||||
}
|
||||
// used for xml and other tagged formats default does nothing
|
||||
virtual void save_start(const char * name){
|
||||
ArchiveImplementation::save_start(name);
|
||||
}
|
||||
virtual void save_end(const char * name){
|
||||
ArchiveImplementation::save_end(name);
|
||||
}
|
||||
virtual void end_preamble(){
|
||||
ArchiveImplementation::end_preamble();
|
||||
}
|
||||
virtual void register_basic_serializer(const detail::basic_oserializer & bos){
|
||||
ArchiveImplementation::register_basic_serializer(bos);
|
||||
}
|
||||
public:
|
||||
// this can't be inheriteded because they appear in mulitple
|
||||
// parents
|
||||
typedef mpl::bool_<false> is_loading;
|
||||
typedef mpl::bool_<true> is_saving;
|
||||
// the << operator
|
||||
template<class T>
|
||||
polymorphic_oarchive & operator<<(T & t){
|
||||
return polymorphic_oarchive::operator<<(t);
|
||||
}
|
||||
// the & operator
|
||||
template<class T>
|
||||
polymorphic_oarchive & operator&(T & t){
|
||||
return polymorphic_oarchive::operator&(t);
|
||||
}
|
||||
// register type function
|
||||
template<class T>
|
||||
const basic_pointer_oserializer *
|
||||
register_type(T * t = NULL){
|
||||
return ArchiveImplementation::register_type(t);
|
||||
}
|
||||
// all current archives take a stream as constructor argument
|
||||
template <class _Elem, class _Tr>
|
||||
polymorphic_oarchive_route(
|
||||
std::basic_ostream<_Elem, _Tr> & os,
|
||||
unsigned int flags = 0
|
||||
) :
|
||||
ArchiveImplementation(os, flags)
|
||||
{}
|
||||
virtual ~polymorphic_oarchive_route(){};
|
||||
};
|
||||
|
||||
} // namespace detail
|
||||
} // namespace archive
|
||||
} // namespace boost
|
||||
|
||||
#ifdef BOOST_MSVC
|
||||
#pragma warning(pop)
|
||||
#endif
|
||||
|
||||
#include <boost/archive/detail/abi_suffix.hpp> // pops abi_suffix.hpp pragmas
|
||||
|
||||
#endif // BOOST_ARCHIVE_DETAIL_POLYMORPHIC_OARCHIVE_DISPATCH_HPP
|
||||
|
|
@ -0,0 +1,91 @@
|
|||
// Copyright David Abrahams 2006. Distributed under the Boost
|
||||
// Software License, Version 1.0. (See accompanying
|
||||
// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
|
||||
#ifndef BOOST_ARCHIVE_DETAIL_REGISTER_ARCHIVE_DWA2006521_HPP
|
||||
# define BOOST_ARCHIVE_DETAIL_REGISTER_ARCHIVE_DWA2006521_HPP
|
||||
|
||||
namespace boost { namespace archive { namespace detail {
|
||||
|
||||
// No instantiate_ptr_serialization overloads generated by
|
||||
// BOOST_SERIALIZATION_REGISTER_ARCHIVE that lexically follow the call
|
||||
// will be seen *unless* they are in an associated namespace of one of
|
||||
// the arguments, so we pass one of these along to make sure this
|
||||
// namespace is considered. See temp.dep.candidate (14.6.4.2) in the
|
||||
// standard.
|
||||
struct adl_tag {};
|
||||
|
||||
template <class Archive, class Serializable>
|
||||
struct ptr_serialization_support;
|
||||
|
||||
// We could've just used ptr_serialization_support, above, but using
|
||||
// it with only a forward declaration causes vc6/7 to complain about a
|
||||
// missing instantiate member, even if it has one. This is just a
|
||||
// friendly layer of indirection.
|
||||
template <class Archive, class Serializable>
|
||||
struct _ptr_serialization_support
|
||||
: ptr_serialization_support<Archive,Serializable>
|
||||
{
|
||||
typedef int type;
|
||||
};
|
||||
|
||||
#ifdef __SUNPRO_CC
|
||||
|
||||
template<int N>
|
||||
struct counter : counter<N-1> {};
|
||||
template<>
|
||||
struct counter<0> {};
|
||||
|
||||
template<class Serializable>
|
||||
void instantiate_ptr_serialization(Serializable* s, int, adl_tag) {
|
||||
instantiate_ptr_serialization(s, counter<20>());
|
||||
}
|
||||
|
||||
template<class Archive>
|
||||
struct get_counter {
|
||||
static const int value = sizeof(adjust_counter(counter<20>()));
|
||||
typedef counter<value> type;
|
||||
typedef counter<value - 1> prior;
|
||||
typedef char (&next)[value+1];
|
||||
};
|
||||
|
||||
char adjust_counter(counter<0>);
|
||||
template<class Serializable>
|
||||
void instantiate_ptr_serialization(Serializable*, counter<0>) {}
|
||||
|
||||
#define BOOST_SERIALIZATION_REGISTER_ARCHIVE(Archive) \
|
||||
namespace boost { namespace archive { namespace detail { \
|
||||
get_counter<Archive >::next adjust_counter(get_counter<Archive >::type);\
|
||||
template<class Serializable> \
|
||||
void instantiate_ptr_serialization(Serializable* s, \
|
||||
get_counter<Archive >::type) { \
|
||||
ptr_serialization_support<Archive, Serializable> x; \
|
||||
instantiate_ptr_serialization(s, get_counter<Archive >::prior()); \
|
||||
}\
|
||||
}}}
|
||||
|
||||
|
||||
#else
|
||||
|
||||
// This function gets called, but its only purpose is to participate
|
||||
// in overload resolution with the functions declared by
|
||||
// BOOST_SERIALIZATION_REGISTER_ARCHIVE, below.
|
||||
template <class Serializable>
|
||||
void instantiate_ptr_serialization(Serializable*, int, adl_tag ) {}
|
||||
|
||||
// The function declaration generated by this macro never actually
|
||||
// gets called, but its return type gets instantiated, and that's
|
||||
// enough to cause registration of serialization functions between
|
||||
// Archive and any exported Serializable type. See also:
|
||||
// boost/serialization/export.hpp
|
||||
# define BOOST_SERIALIZATION_REGISTER_ARCHIVE(Archive) \
|
||||
namespace boost { namespace archive { namespace detail { \
|
||||
\
|
||||
template <class Serializable> \
|
||||
BOOST_DEDUCED_TYPENAME _ptr_serialization_support<Archive, Serializable>::type \
|
||||
instantiate_ptr_serialization( Serializable*, Archive*, adl_tag ); \
|
||||
\
|
||||
}}}
|
||||
#endif
|
||||
}}} // namespace boost::archive::detail
|
||||
|
||||
#endif // BOOST_ARCHIVE_DETAIL_INSTANTIATE_SERIALIZE_DWA2006521_HPP
|
||||
|
|
@ -0,0 +1,21 @@
|
|||
// Copyright (c) 2001 Ronald Garcia, Indiana University (garcia@osl.iu.edu)
|
||||
// Andrew Lumsdaine, Indiana University (lums@osl.iu.edu).
|
||||
// Distributed under the Boost Software License, Version 1.0. (See
|
||||
// accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
#ifndef BOOST_ARCHIVE_DETAIL_UTF8_CODECVT_FACET_HPP
|
||||
#define BOOST_ARCHIVE_DETAIL_UTF8_CODECVT_FACET_HPP
|
||||
|
||||
#define BOOST_UTF8_BEGIN_NAMESPACE \
|
||||
namespace boost { namespace archive { namespace detail {
|
||||
#define BOOST_UTF8_DECL
|
||||
#define BOOST_UTF8_END_NAMESPACE }}}
|
||||
|
||||
#include <boost/detail/utf8_codecvt_facet.hpp>
|
||||
|
||||
#undef BOOST_UTF8_END_NAMESPACE
|
||||
#undef BOOST_UTF8_DECL
|
||||
#undef BOOST_UTF8_BEGIN_NAMESPACE
|
||||
|
||||
#endif // BOOST_ARCHIVE_DETAIL_UTF8_CODECVT_FACET_HPP
|
||||
|
|
@ -0,0 +1,224 @@
|
|||
#ifndef BOOST_ARCHIVE_DINKUMWARE_HPP
|
||||
#define BOOST_ARCHIVE_DINKUMWARE_HPP
|
||||
|
||||
// MS compatible compilers support #pragma once
|
||||
#if defined(_MSC_VER) && (_MSC_VER >= 1020)
|
||||
# pragma once
|
||||
#endif
|
||||
|
||||
/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
|
||||
// dinkumware.hpp:
|
||||
|
||||
// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
|
||||
// Use, modification and distribution is subject to the Boost Software
|
||||
// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
// See http://www.boost.org for updates, documentation, and revision history.
|
||||
|
||||
// this file adds a couple of things that are missing from the dinkumware
|
||||
// implementation of the standard library.
|
||||
|
||||
#include <iterator>
|
||||
#include <string>
|
||||
|
||||
#include <boost/config.hpp>
|
||||
#include <boost/cstdint.hpp>
|
||||
|
||||
namespace std {
|
||||
|
||||
// define i/o operators for 64 bit integers
|
||||
template<class CharType>
|
||||
basic_ostream<CharType> &
|
||||
operator<<(basic_ostream<CharType> & os, boost::uint64_t t){
|
||||
// octal rendering of 64 bit number would be 22 octets + eos
|
||||
CharType d[23];
|
||||
unsigned int radix;
|
||||
|
||||
if(os.flags() & (int)std::ios_base::hex)
|
||||
radix = 16;
|
||||
else
|
||||
if(os.flags() & (int)std::ios_base::oct)
|
||||
radix = 8;
|
||||
else
|
||||
//if(s.flags() & (int)std::ios_base::dec)
|
||||
radix = 10;
|
||||
unsigned int i = 0;
|
||||
do{
|
||||
unsigned int j = t % radix;
|
||||
d[i++] = j + ((j < 10) ? '0' : ('a' - 10));
|
||||
t /= radix;
|
||||
}
|
||||
while(t > 0);
|
||||
d[i--] = '\0';
|
||||
|
||||
// reverse digits
|
||||
unsigned int j = 0;
|
||||
while(j < i){
|
||||
CharType k = d[i];
|
||||
d[i] = d[j];
|
||||
d[j] = k;
|
||||
--i;++j;
|
||||
}
|
||||
os << d;
|
||||
return os;
|
||||
|
||||
}
|
||||
|
||||
template<class CharType>
|
||||
basic_ostream<CharType> &
|
||||
operator<<(basic_ostream<CharType> &os, boost::int64_t t){
|
||||
if(0 <= t){
|
||||
os << static_cast<boost::uint64_t>(t);
|
||||
}
|
||||
else{
|
||||
os.put('-');
|
||||
os << -t;
|
||||
}
|
||||
return os;
|
||||
}
|
||||
|
||||
template<class CharType>
|
||||
basic_istream<CharType> &
|
||||
operator>>(basic_istream<CharType> &is, boost::int64_t & t){
|
||||
CharType d;
|
||||
do{
|
||||
d = is.get();
|
||||
}
|
||||
while(::isspace(d));
|
||||
bool negative = (d == '-');
|
||||
if(negative)
|
||||
d = is.get();
|
||||
unsigned int radix;
|
||||
if(is.flags() & (int)std::ios_base::hex)
|
||||
radix = 16;
|
||||
else
|
||||
if(is.flags() & (int)std::ios_base::oct)
|
||||
radix = 8;
|
||||
else
|
||||
//if(s.flags() & (int)std::ios_base::dec)
|
||||
radix = 10;
|
||||
t = 0;
|
||||
do{
|
||||
if('0' <= d && d <= '9')
|
||||
t = t * radix + (d - '0');
|
||||
else
|
||||
if('a' <= d && d <= 'f')
|
||||
t = t * radix + (d - 'a' + 10);
|
||||
else
|
||||
break;
|
||||
d = is.get();
|
||||
}
|
||||
while(!is.fail());
|
||||
// restore the delimiter
|
||||
is.putback(d);
|
||||
is.clear();
|
||||
if(negative)
|
||||
t = -t;
|
||||
return is;
|
||||
}
|
||||
|
||||
template<class CharType>
|
||||
basic_istream<CharType> &
|
||||
operator>>(basic_istream<CharType> &is, boost::uint64_t & t){
|
||||
boost::int64_t it;
|
||||
is >> it;
|
||||
t = it;
|
||||
return is;
|
||||
}
|
||||
|
||||
//#endif
|
||||
|
||||
template<>
|
||||
class back_insert_iterator<basic_string<char> > : public
|
||||
iterator<output_iterator_tag, char>
|
||||
{
|
||||
public:
|
||||
typedef basic_string<char> container_type;
|
||||
typedef container_type::reference reference;
|
||||
|
||||
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
|
||||
//container->push_back(Val_);
|
||||
*container += Val_;
|
||||
return (*this);
|
||||
}
|
||||
|
||||
back_insert_iterator<container_type> & operator*(){
|
||||
return (*this);
|
||||
}
|
||||
|
||||
back_insert_iterator<container_type> & operator++(){
|
||||
// pretend to preincrement
|
||||
return (*this);
|
||||
}
|
||||
|
||||
back_insert_iterator<container_type> operator++(int){
|
||||
// pretend to postincrement
|
||||
return (*this);
|
||||
}
|
||||
|
||||
protected:
|
||||
container_type *container; // pointer to container
|
||||
};
|
||||
|
||||
template<char>
|
||||
inline back_insert_iterator<basic_string<char> > back_inserter(
|
||||
basic_string<char> & s
|
||||
){
|
||||
return (std::back_insert_iterator<basic_string<char> >(s));
|
||||
}
|
||||
|
||||
template<>
|
||||
class back_insert_iterator<basic_string<wchar_t> > : public
|
||||
iterator<output_iterator_tag, wchar_t>
|
||||
{
|
||||
public:
|
||||
typedef basic_string<wchar_t> container_type;
|
||||
typedef container_type::reference reference;
|
||||
|
||||
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
|
||||
//container->push_back(Val_);
|
||||
*container += Val_;
|
||||
return (*this);
|
||||
}
|
||||
|
||||
back_insert_iterator<container_type> & operator*(){
|
||||
return (*this);
|
||||
}
|
||||
|
||||
back_insert_iterator<container_type> & operator++(){
|
||||
// pretend to preincrement
|
||||
return (*this);
|
||||
}
|
||||
|
||||
back_insert_iterator<container_type> operator++(int){
|
||||
// pretend to postincrement
|
||||
return (*this);
|
||||
}
|
||||
|
||||
protected:
|
||||
container_type *container; // pointer to container
|
||||
};
|
||||
|
||||
template<wchar_t>
|
||||
inline back_insert_iterator<basic_string<wchar_t> > back_inserter(
|
||||
basic_string<wchar_t> & s
|
||||
){
|
||||
return (std::back_insert_iterator<basic_string<wchar_t> >(s));
|
||||
}
|
||||
|
||||
} // namespace std
|
||||
|
||||
#endif //BOOST_ARCHIVE_DINKUMWARE_HPP
|
||||
|
|
@ -0,0 +1,71 @@
|
|||
/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
|
||||
// archive_serializer_map.ipp:
|
||||
|
||||
// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
|
||||
// Distributed under the Boost Software License, Version 1.0. (See
|
||||
// accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
// See http://www.boost.org for updates, documentation, and revision history.
|
||||
|
||||
//////////////////////////////////////////////////////////////////////
|
||||
// implementation of basic_text_iprimitive overrides for the combination
|
||||
// of template parameters used to implement a text_iprimitive
|
||||
|
||||
#include <boost/config.hpp>
|
||||
#include <boost/archive/detail/archive_serializer_map.hpp>
|
||||
#include <boost/archive/detail/basic_serializer_map.hpp>
|
||||
#include <boost/serialization/singleton.hpp>
|
||||
|
||||
namespace boost {
|
||||
namespace archive {
|
||||
namespace detail {
|
||||
|
||||
#ifdef BOOST_MSVC
|
||||
# pragma warning(push)
|
||||
# pragma warning(disable : 4511 4512)
|
||||
#endif
|
||||
|
||||
namespace extra_detail { // anon
|
||||
template<class Archive>
|
||||
class map : public basic_serializer_map
|
||||
{};
|
||||
}
|
||||
|
||||
#ifdef BOOST_MSVC
|
||||
# pragma warning(pop)
|
||||
#endif
|
||||
|
||||
template<class Archive>
|
||||
BOOST_ARCHIVE_OR_WARCHIVE_DECL(bool)
|
||||
archive_serializer_map<Archive>::insert(const basic_serializer * bs){
|
||||
return boost::serialization::singleton<
|
||||
extra_detail::map<Archive>
|
||||
>::get_mutable_instance().insert(bs);
|
||||
}
|
||||
|
||||
template<class Archive>
|
||||
BOOST_ARCHIVE_OR_WARCHIVE_DECL(void)
|
||||
archive_serializer_map<Archive>::erase(const basic_serializer * bs){
|
||||
if(boost::serialization::singleton<
|
||||
extra_detail::map<Archive>
|
||||
>::is_destroyed())
|
||||
return;
|
||||
boost::serialization::singleton<
|
||||
extra_detail::map<Archive>
|
||||
>::get_mutable_instance().erase(bs);
|
||||
}
|
||||
|
||||
template<class Archive>
|
||||
BOOST_ARCHIVE_OR_WARCHIVE_DECL(const basic_serializer *)
|
||||
archive_serializer_map<Archive>::find(
|
||||
const boost::serialization::extended_type_info & eti
|
||||
) {
|
||||
return boost::serialization::singleton<
|
||||
extra_detail::map<Archive>
|
||||
>::get_const_instance().find(eti);
|
||||
}
|
||||
|
||||
} // namespace detail
|
||||
} // namespace archive
|
||||
} // namespace boost
|
||||
|
|
@ -0,0 +1,129 @@
|
|||
/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
|
||||
// basic_binary_iarchive.ipp:
|
||||
|
||||
// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
|
||||
// Use, modification and distribution is subject to the Boost Software
|
||||
// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
// See http://www.boost.org for updates, documentation, and revision history.
|
||||
#include <string>
|
||||
#include <boost/assert.hpp>
|
||||
#include <algorithm>
|
||||
#include <cstring>
|
||||
|
||||
#include <boost/config.hpp> // for BOOST_DEDUCED_TYPENAME
|
||||
#if defined(BOOST_NO_STDC_NAMESPACE)
|
||||
namespace std{
|
||||
using ::memcpy;
|
||||
using ::strlen;
|
||||
using ::size_t;
|
||||
}
|
||||
#endif
|
||||
|
||||
#include <boost/detail/workaround.hpp>
|
||||
#include <boost/detail/endian.hpp>
|
||||
|
||||
#include <boost/archive/basic_binary_iarchive.hpp>
|
||||
|
||||
namespace boost {
|
||||
namespace archive {
|
||||
|
||||
/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
|
||||
// implementation of binary_binary_archive
|
||||
template<class Archive>
|
||||
BOOST_ARCHIVE_OR_WARCHIVE_DECL(void)
|
||||
basic_binary_iarchive<Archive>::load_override(class_name_type & t, int){
|
||||
std::string cn;
|
||||
cn.reserve(BOOST_SERIALIZATION_MAX_KEY_SIZE);
|
||||
load_override(cn, 0);
|
||||
if(cn.size() > (BOOST_SERIALIZATION_MAX_KEY_SIZE - 1))
|
||||
boost::serialization::throw_exception(
|
||||
archive_exception(archive_exception::invalid_class_name)
|
||||
);
|
||||
std::memcpy(t, cn.data(), cn.size());
|
||||
// borland tweak
|
||||
t.t[cn.size()] = '\0';
|
||||
}
|
||||
|
||||
template<class Archive>
|
||||
BOOST_ARCHIVE_OR_WARCHIVE_DECL(void)
|
||||
basic_binary_iarchive<Archive>::init(){
|
||||
// read signature in an archive version independent manner
|
||||
std::string file_signature;
|
||||
try {
|
||||
std::size_t l;
|
||||
this->This()->load(l);
|
||||
if(l == std::strlen(BOOST_ARCHIVE_SIGNATURE())) {
|
||||
// borland de-allocator fixup
|
||||
#if BOOST_WORKAROUND(_RWSTD_VER, BOOST_TESTED_AT(20101))
|
||||
if(NULL != file_signature.data())
|
||||
#endif
|
||||
file_signature.resize(l);
|
||||
// note breaking a rule here - could be a problem on some platform
|
||||
if(0 < l)
|
||||
this->This()->load_binary(&(*file_signature.begin()), l);
|
||||
}
|
||||
}
|
||||
catch(archive_exception const &) { // catch stream_error archive exceptions
|
||||
// will cause invalid_signature archive exception to be thrown below
|
||||
file_signature = "";
|
||||
}
|
||||
if(file_signature != BOOST_ARCHIVE_SIGNATURE())
|
||||
boost::serialization::throw_exception(
|
||||
archive_exception(archive_exception::invalid_signature)
|
||||
);
|
||||
|
||||
// make sure the version of the reading archive library can
|
||||
// support the format of the archive being read
|
||||
library_version_type input_library_version;
|
||||
//* this->This() >> input_library_version;
|
||||
{
|
||||
int v = 0;
|
||||
v = this->This()->m_sb.sbumpc();
|
||||
#if defined(BOOST_LITTLE_ENDIAN)
|
||||
if(v < 6){
|
||||
;
|
||||
}
|
||||
else
|
||||
if(v < 7){
|
||||
// version 6 - next byte should be zero
|
||||
this->This()->m_sb.sbumpc();
|
||||
}
|
||||
else
|
||||
if(v < 8){
|
||||
int x1;
|
||||
// version 7 = might be followed by zero or some other byte
|
||||
x1 = this->This()->m_sb.sgetc();
|
||||
// it's =a zero, push it back
|
||||
if(0 == x1)
|
||||
this->This()->m_sb.sbumpc();
|
||||
}
|
||||
else{
|
||||
// version 8+ followed by a zero
|
||||
this->This()->m_sb.sbumpc();
|
||||
}
|
||||
#elif defined(BOOST_BIG_ENDIAN)
|
||||
if(v == 0)
|
||||
v = this->This()->m_sb.sbumpc();
|
||||
#endif
|
||||
input_library_version = static_cast<library_version_type>(v);
|
||||
}
|
||||
|
||||
#if BOOST_WORKAROUND(__MWERKS__, BOOST_TESTED_AT(0x3205))
|
||||
this->set_library_version(input_library_version);
|
||||
#else
|
||||
#if ! BOOST_WORKAROUND(BOOST_MSVC, <= 1200)
|
||||
detail::
|
||||
#endif
|
||||
basic_iarchive::set_library_version(input_library_version);
|
||||
#endif
|
||||
|
||||
if(BOOST_ARCHIVE_VERSION() < input_library_version)
|
||||
boost::serialization::throw_exception(
|
||||
archive_exception(archive_exception::unsupported_version)
|
||||
);
|
||||
}
|
||||
|
||||
} // namespace archive
|
||||
} // namespace boost
|
||||
|
|
@ -0,0 +1,209 @@
|
|||
/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
|
||||
// basic_binary_iprimitive.ipp:
|
||||
|
||||
// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
|
||||
// Use, modification and distribution is subject to the Boost Software
|
||||
// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
// See http://www.boost.org for updates, documentation, and revision history.
|
||||
|
||||
#include <boost/assert.hpp>
|
||||
#include <cstddef> // size_t, NULL
|
||||
#include <cstring> // memcpy
|
||||
|
||||
#include <boost/config.hpp>
|
||||
#if defined(BOOST_NO_STDC_NAMESPACE)
|
||||
namespace std{
|
||||
using ::size_t;
|
||||
using ::memcpy;
|
||||
} // namespace std
|
||||
#endif
|
||||
|
||||
#include <boost/detail/workaround.hpp> // fixup for RogueWave
|
||||
|
||||
#include <boost/serialization/throw_exception.hpp>
|
||||
#include <boost/scoped_ptr.hpp>
|
||||
|
||||
#include <boost/archive/archive_exception.hpp>
|
||||
#include <boost/archive/codecvt_null.hpp>
|
||||
#include <boost/archive/add_facet.hpp>
|
||||
|
||||
namespace boost {
|
||||
namespace archive {
|
||||
|
||||
//////////////////////////////////////////////////////////////////////
|
||||
// implementation of basic_binary_iprimitive
|
||||
|
||||
template<class Archive, class Elem, class Tr>
|
||||
BOOST_ARCHIVE_OR_WARCHIVE_DECL(void)
|
||||
basic_binary_iprimitive<Archive, Elem, Tr>::init()
|
||||
{
|
||||
// Detect attempts to pass native binary archives across
|
||||
// incompatible platforms. This is not fool proof but its
|
||||
// better than nothing.
|
||||
unsigned char size;
|
||||
this->This()->load(size);
|
||||
if(sizeof(int) != size)
|
||||
boost::serialization::throw_exception(
|
||||
archive_exception(
|
||||
archive_exception::incompatible_native_format,
|
||||
"size of int"
|
||||
)
|
||||
);
|
||||
this->This()->load(size);
|
||||
if(sizeof(long) != size)
|
||||
boost::serialization::throw_exception(
|
||||
archive_exception(
|
||||
archive_exception::incompatible_native_format,
|
||||
"size of long"
|
||||
)
|
||||
);
|
||||
this->This()->load(size);
|
||||
if(sizeof(float) != size)
|
||||
boost::serialization::throw_exception(
|
||||
archive_exception(
|
||||
archive_exception::incompatible_native_format,
|
||||
"size of float"
|
||||
)
|
||||
);
|
||||
this->This()->load(size);
|
||||
if(sizeof(double) != size)
|
||||
boost::serialization::throw_exception(
|
||||
archive_exception(
|
||||
archive_exception::incompatible_native_format,
|
||||
"size of double"
|
||||
)
|
||||
);
|
||||
|
||||
// for checking endian
|
||||
int i;
|
||||
this->This()->load(i);
|
||||
if(1 != i)
|
||||
boost::serialization::throw_exception(
|
||||
archive_exception(
|
||||
archive_exception::incompatible_native_format,
|
||||
"endian setting"
|
||||
)
|
||||
);
|
||||
}
|
||||
|
||||
template<class Archive, class Elem, class Tr>
|
||||
BOOST_ARCHIVE_OR_WARCHIVE_DECL(void)
|
||||
basic_binary_iprimitive<Archive, Elem, Tr>::load(wchar_t * ws)
|
||||
{
|
||||
std::size_t l; // number of wchar_t !!!
|
||||
this->This()->load(l);
|
||||
load_binary(ws, l * sizeof(wchar_t) / sizeof(char));
|
||||
ws[l] = L'\0';
|
||||
}
|
||||
|
||||
template<class Archive, class Elem, class Tr>
|
||||
BOOST_ARCHIVE_OR_WARCHIVE_DECL(void)
|
||||
basic_binary_iprimitive<Archive, Elem, Tr>::load(std::string & s)
|
||||
{
|
||||
std::size_t l;
|
||||
this->This()->load(l);
|
||||
// borland de-allocator fixup
|
||||
#if BOOST_WORKAROUND(_RWSTD_VER, BOOST_TESTED_AT(20101))
|
||||
if(NULL != s.data())
|
||||
#endif
|
||||
s.resize(l);
|
||||
// note breaking a rule here - could be a problem on some platform
|
||||
if(0 < l)
|
||||
load_binary(&(*s.begin()), l);
|
||||
}
|
||||
|
||||
#ifndef BOOST_NO_CWCHAR
|
||||
template<class Archive, class Elem, class Tr>
|
||||
BOOST_ARCHIVE_OR_WARCHIVE_DECL(void)
|
||||
basic_binary_iprimitive<Archive, Elem, Tr>::load(char * s)
|
||||
{
|
||||
std::size_t l;
|
||||
this->This()->load(l);
|
||||
load_binary(s, l);
|
||||
s[l] = '\0';
|
||||
}
|
||||
#endif
|
||||
|
||||
#ifndef BOOST_NO_STD_WSTRING
|
||||
template<class Archive, class Elem, class Tr>
|
||||
BOOST_ARCHIVE_OR_WARCHIVE_DECL(void)
|
||||
basic_binary_iprimitive<Archive, Elem, Tr>::load(std::wstring & ws)
|
||||
{
|
||||
std::size_t l;
|
||||
this->This()->load(l);
|
||||
// borland de-allocator fixup
|
||||
#if BOOST_WORKAROUND(_RWSTD_VER, BOOST_TESTED_AT(20101))
|
||||
if(NULL != ws.data())
|
||||
#endif
|
||||
ws.resize(l);
|
||||
// note breaking a rule here - is could be a problem on some platform
|
||||
load_binary(const_cast<wchar_t *>(ws.data()), l * sizeof(wchar_t) / sizeof(char));
|
||||
}
|
||||
#endif
|
||||
|
||||
template<class Archive, class Elem, class Tr>
|
||||
BOOST_ARCHIVE_OR_WARCHIVE_DECL(BOOST_PP_EMPTY())
|
||||
basic_binary_iprimitive<Archive, Elem, Tr>::basic_binary_iprimitive(
|
||||
std::basic_streambuf<Elem, Tr> & sb,
|
||||
bool no_codecvt
|
||||
) :
|
||||
#ifndef BOOST_NO_STD_LOCALE
|
||||
m_sb(sb),
|
||||
archive_locale(NULL),
|
||||
locale_saver(m_sb)
|
||||
{
|
||||
if(! no_codecvt){
|
||||
archive_locale.reset(
|
||||
boost::archive::add_facet(
|
||||
std::locale::classic(),
|
||||
new codecvt_null<Elem>
|
||||
)
|
||||
);
|
||||
m_sb.pubimbue(* archive_locale);
|
||||
}
|
||||
}
|
||||
#else
|
||||
m_sb(sb)
|
||||
{}
|
||||
#endif
|
||||
|
||||
// some libraries including stl and libcomo fail if the
|
||||
// buffer isn't flushed before the code_cvt facet is changed.
|
||||
// I think this is a bug. We explicity invoke sync to when
|
||||
// we're done with the streambuf to work around this problem.
|
||||
// Note that sync is a protected member of stream buff so we
|
||||
// have to invoke it through a contrived derived class.
|
||||
namespace detail {
|
||||
// note: use "using" to get past msvc bug
|
||||
using namespace std;
|
||||
template<class Elem, class Tr>
|
||||
class input_streambuf_access : public std::basic_streambuf<Elem, Tr> {
|
||||
public:
|
||||
virtual int sync(){
|
||||
#if BOOST_WORKAROUND(__MWERKS__, BOOST_TESTED_AT(0x3206))
|
||||
return this->basic_streambuf::sync();
|
||||
#else
|
||||
return this->basic_streambuf<Elem, Tr>::sync();
|
||||
#endif
|
||||
}
|
||||
};
|
||||
} // detail
|
||||
|
||||
// scoped_ptr requires that archive_locale be a complete type at time of
|
||||
// destruction so define destructor here rather than in the header
|
||||
template<class Archive, class Elem, class Tr>
|
||||
BOOST_ARCHIVE_OR_WARCHIVE_DECL(BOOST_PP_EMPTY())
|
||||
basic_binary_iprimitive<Archive, Elem, Tr>::~basic_binary_iprimitive(){
|
||||
// push back unread characters
|
||||
//destructor can't throw !
|
||||
try{
|
||||
static_cast<detail::input_streambuf_access<Elem, Tr> &>(m_sb).sync();
|
||||
}
|
||||
catch(...){
|
||||
}
|
||||
}
|
||||
|
||||
} // namespace archive
|
||||
} // namespace boost
|
||||
|
|
@ -0,0 +1,46 @@
|
|||
/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
|
||||
// basic_binary_oarchive.ipp:
|
||||
|
||||
// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
|
||||
// Use, modification and distribution is subject to the Boost Software
|
||||
// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
// See http://www.boost.org for updates, documentation, and revision history.
|
||||
#include <string>
|
||||
#include <boost/assert.hpp>
|
||||
#include <algorithm>
|
||||
#include <cstring>
|
||||
|
||||
#include <boost/config.hpp> // for BOOST_DEDUCED_TYPENAME
|
||||
#if defined(BOOST_NO_STDC_NAMESPACE)
|
||||
namespace std{
|
||||
using ::memcpy;
|
||||
}
|
||||
#endif
|
||||
|
||||
#include <boost/archive/basic_binary_oarchive.hpp>
|
||||
|
||||
namespace boost {
|
||||
namespace archive {
|
||||
|
||||
/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
|
||||
// implementation of binary_binary_oarchive
|
||||
|
||||
template<class Archive>
|
||||
#if !defined(__BORLANDC__)
|
||||
BOOST_ARCHIVE_OR_WARCHIVE_DECL(void)
|
||||
#else
|
||||
void
|
||||
#endif
|
||||
basic_binary_oarchive<Archive>::init(){
|
||||
// write signature in an archive version independent manner
|
||||
const std::string file_signature(BOOST_ARCHIVE_SIGNATURE());
|
||||
* this->This() << file_signature;
|
||||
// write library version
|
||||
const library_version_type v(BOOST_ARCHIVE_VERSION());
|
||||
* this->This() << v;
|
||||
}
|
||||
|
||||
} // namespace archive
|
||||
} // namespace boost
|
||||
|
|
@ -0,0 +1,160 @@
|
|||
/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
|
||||
// basic_binary_oprimitive.ipp:
|
||||
|
||||
// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
|
||||
// Use, modification and distribution is subject to the Boost Software
|
||||
// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
// See http://www.boost.org for updates, documentation, and revision history.
|
||||
|
||||
#include <ostream>
|
||||
#include <cstddef> // NULL
|
||||
#include <cstring>
|
||||
|
||||
#include <boost/config.hpp>
|
||||
|
||||
#if defined(BOOST_NO_STDC_NAMESPACE) && ! defined(__LIBCOMO__)
|
||||
namespace std{
|
||||
using ::strlen;
|
||||
} // namespace std
|
||||
#endif
|
||||
|
||||
#ifndef BOOST_NO_CWCHAR
|
||||
#include <cwchar>
|
||||
#ifdef BOOST_NO_STDC_NAMESPACE
|
||||
namespace std{ using ::wcslen; }
|
||||
#endif
|
||||
#endif
|
||||
|
||||
#include <boost/detail/workaround.hpp>
|
||||
|
||||
#include <boost/archive/add_facet.hpp>
|
||||
#include <boost/archive/codecvt_null.hpp>
|
||||
|
||||
namespace boost {
|
||||
namespace archive {
|
||||
|
||||
//////////////////////////////////////////////////////////////////////
|
||||
// implementation of basic_binary_oprimitive
|
||||
|
||||
template<class Archive, class Elem, class Tr>
|
||||
BOOST_ARCHIVE_OR_WARCHIVE_DECL(void)
|
||||
basic_binary_oprimitive<Archive, Elem, Tr>::init()
|
||||
{
|
||||
// record native sizes of fundamental types
|
||||
// this is to permit detection of attempts to pass
|
||||
// native binary archives accross incompatible machines.
|
||||
// This is not foolproof but its better than nothing.
|
||||
this->This()->save(static_cast<unsigned char>(sizeof(int)));
|
||||
this->This()->save(static_cast<unsigned char>(sizeof(long)));
|
||||
this->This()->save(static_cast<unsigned char>(sizeof(float)));
|
||||
this->This()->save(static_cast<unsigned char>(sizeof(double)));
|
||||
// for checking endianness
|
||||
this->This()->save(int(1));
|
||||
}
|
||||
|
||||
template<class Archive, class Elem, class Tr>
|
||||
BOOST_ARCHIVE_OR_WARCHIVE_DECL(void)
|
||||
basic_binary_oprimitive<Archive, Elem, Tr>::save(const char * s)
|
||||
{
|
||||
std::size_t l = std::strlen(s);
|
||||
this->This()->save(l);
|
||||
save_binary(s, l);
|
||||
}
|
||||
|
||||
template<class Archive, class Elem, class Tr>
|
||||
BOOST_ARCHIVE_OR_WARCHIVE_DECL(void)
|
||||
basic_binary_oprimitive<Archive, Elem, Tr>::save(const std::string &s)
|
||||
{
|
||||
std::size_t l = static_cast<std::size_t>(s.size());
|
||||
this->This()->save(l);
|
||||
save_binary(s.data(), l);
|
||||
}
|
||||
|
||||
#ifndef BOOST_NO_CWCHAR
|
||||
template<class Archive, class Elem, class Tr>
|
||||
BOOST_ARCHIVE_OR_WARCHIVE_DECL(void)
|
||||
basic_binary_oprimitive<Archive, Elem, Tr>::save(const wchar_t * ws)
|
||||
{
|
||||
std::size_t l = std::wcslen(ws);
|
||||
this->This()->save(l);
|
||||
save_binary(ws, l * sizeof(wchar_t) / sizeof(char));
|
||||
}
|
||||
#endif
|
||||
|
||||
#ifndef BOOST_NO_STD_WSTRING
|
||||
template<class Archive, class Elem, class Tr>
|
||||
BOOST_ARCHIVE_OR_WARCHIVE_DECL(void)
|
||||
basic_binary_oprimitive<Archive, Elem, Tr>::save(const std::wstring &ws)
|
||||
{
|
||||
std::size_t l = ws.size();
|
||||
this->This()->save(l);
|
||||
save_binary(ws.data(), l * sizeof(wchar_t) / sizeof(char));
|
||||
}
|
||||
#endif
|
||||
|
||||
template<class Archive, class Elem, class Tr>
|
||||
BOOST_ARCHIVE_OR_WARCHIVE_DECL(BOOST_PP_EMPTY())
|
||||
basic_binary_oprimitive<Archive, Elem, Tr>::basic_binary_oprimitive(
|
||||
std::basic_streambuf<Elem, Tr> & sb,
|
||||
bool no_codecvt
|
||||
) :
|
||||
#ifndef BOOST_NO_STD_LOCALE
|
||||
m_sb(sb),
|
||||
archive_locale(NULL),
|
||||
locale_saver(m_sb)
|
||||
{
|
||||
if(! no_codecvt){
|
||||
archive_locale.reset(
|
||||
add_facet(
|
||||
std::locale::classic(),
|
||||
new codecvt_null<Elem>
|
||||
)
|
||||
);
|
||||
m_sb.pubimbue(* archive_locale);
|
||||
}
|
||||
}
|
||||
#else
|
||||
m_sb(sb)
|
||||
{}
|
||||
#endif
|
||||
|
||||
// some libraries including stl and libcomo fail if the
|
||||
// buffer isn't flushed before the code_cvt facet is changed.
|
||||
// I think this is a bug. We explicity invoke sync to when
|
||||
// we're done with the streambuf to work around this problem.
|
||||
// Note that sync is a protected member of stream buff so we
|
||||
// have to invoke it through a contrived derived class.
|
||||
namespace detail {
|
||||
// note: use "using" to get past msvc bug
|
||||
using namespace std;
|
||||
template<class Elem, class Tr>
|
||||
class output_streambuf_access : public std::basic_streambuf<Elem, Tr> {
|
||||
public:
|
||||
virtual int sync(){
|
||||
#if BOOST_WORKAROUND(__MWERKS__, BOOST_TESTED_AT(0x3206))
|
||||
return this->basic_streambuf::sync();
|
||||
#else
|
||||
return this->basic_streambuf<Elem, Tr>::sync();
|
||||
#endif
|
||||
}
|
||||
};
|
||||
} // detail
|
||||
|
||||
// scoped_ptr requires that g be a complete type at time of
|
||||
// destruction so define destructor here rather than in the header
|
||||
template<class Archive, class Elem, class Tr>
|
||||
BOOST_ARCHIVE_OR_WARCHIVE_DECL(BOOST_PP_EMPTY())
|
||||
basic_binary_oprimitive<Archive, Elem, Tr>::~basic_binary_oprimitive(){
|
||||
// flush buffer
|
||||
//destructor can't throw
|
||||
try{
|
||||
static_cast<detail::output_streambuf_access<Elem, Tr> &>(m_sb).sync();
|
||||
}
|
||||
catch(...){
|
||||
}
|
||||
}
|
||||
|
||||
} // namespace archive
|
||||
} // namespace boost
|
||||
|
|
@ -0,0 +1,79 @@
|
|||
/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
|
||||
// basic_text_iarchive.ipp:
|
||||
|
||||
// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
|
||||
// Use, modification and distribution is subject to the Boost Software
|
||||
// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
// See http://www.boost.org for updates, documentation, and revision history.
|
||||
#include <string>
|
||||
#include <algorithm>
|
||||
#include <cstring>
|
||||
|
||||
#include <boost/config.hpp> // for BOOST_DEDUCED_TYPENAME
|
||||
#if defined(BOOST_NO_STDC_NAMESPACE)
|
||||
namespace std{
|
||||
using ::memcpy;
|
||||
}
|
||||
#endif
|
||||
|
||||
#include <boost/detail/workaround.hpp>
|
||||
#include <boost/serialization/string.hpp>
|
||||
#include <boost/archive/basic_text_iarchive.hpp>
|
||||
|
||||
namespace boost {
|
||||
namespace archive {
|
||||
|
||||
/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
|
||||
// implementation of text_text_archive
|
||||
|
||||
template<class Archive>
|
||||
BOOST_ARCHIVE_OR_WARCHIVE_DECL(void)
|
||||
basic_text_iarchive<Archive>::load_override(class_name_type & t, int){
|
||||
std::string cn;
|
||||
cn.reserve(BOOST_SERIALIZATION_MAX_KEY_SIZE);
|
||||
load_override(cn, 0);
|
||||
if(cn.size() > (BOOST_SERIALIZATION_MAX_KEY_SIZE - 1))
|
||||
boost::serialization::throw_exception(
|
||||
archive_exception(archive_exception::invalid_class_name)
|
||||
);
|
||||
std::memcpy(t, cn.data(), cn.size());
|
||||
// borland tweak
|
||||
t.t[cn.size()] = '\0';
|
||||
}
|
||||
|
||||
template<class Archive>
|
||||
BOOST_ARCHIVE_OR_WARCHIVE_DECL(void)
|
||||
basic_text_iarchive<Archive>::init(void){
|
||||
// read signature in an archive version independent manner
|
||||
std::string file_signature;
|
||||
* this->This() >> file_signature;
|
||||
if(file_signature != BOOST_ARCHIVE_SIGNATURE())
|
||||
boost::serialization::throw_exception(
|
||||
archive_exception(archive_exception::invalid_signature)
|
||||
);
|
||||
|
||||
// make sure the version of the reading archive library can
|
||||
// support the format of the archive being read
|
||||
library_version_type input_library_version;
|
||||
* this->This() >> input_library_version;
|
||||
|
||||
#if BOOST_WORKAROUND(__MWERKS__, BOOST_TESTED_AT(0x3205))
|
||||
this->set_library_version(input_library_version);
|
||||
#else
|
||||
#if ! BOOST_WORKAROUND(BOOST_MSVC, <= 1200)
|
||||
detail::
|
||||
#endif
|
||||
basic_iarchive::set_library_version(input_library_version);
|
||||
#endif
|
||||
|
||||
// extra little .t is to get around borland quirk
|
||||
if(BOOST_ARCHIVE_VERSION() < input_library_version)
|
||||
boost::serialization::throw_exception(
|
||||
archive_exception(archive_exception::unsupported_version)
|
||||
);
|
||||
}
|
||||
|
||||
} // namespace archive
|
||||
} // namespace boost
|
||||
|
|
@ -0,0 +1,154 @@
|
|||
/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
|
||||
// basic_text_iprimitive.ipp:
|
||||
|
||||
// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
|
||||
// Distributed under the Boost Software License, Version 1.0. (See
|
||||
// accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
// See http://www.boost.org for updates, documentation, and revision history.
|
||||
|
||||
#include <cstddef> // size_t
|
||||
#include <cstddef> // NULL
|
||||
|
||||
#include <boost/config.hpp>
|
||||
#if defined(BOOST_NO_STDC_NAMESPACE)
|
||||
namespace std{
|
||||
using ::size_t;
|
||||
} // namespace std
|
||||
#endif
|
||||
|
||||
#include <boost/serialization/throw_exception.hpp>
|
||||
#include <boost/serialization/pfto.hpp>
|
||||
|
||||
#include <boost/archive/basic_text_iprimitive.hpp>
|
||||
#include <boost/archive/codecvt_null.hpp>
|
||||
#include <boost/archive/add_facet.hpp>
|
||||
|
||||
#include <boost/archive/iterators/remove_whitespace.hpp>
|
||||
#include <boost/archive/iterators/istream_iterator.hpp>
|
||||
#include <boost/archive/iterators/binary_from_base64.hpp>
|
||||
#include <boost/archive/iterators/transform_width.hpp>
|
||||
|
||||
namespace boost {
|
||||
namespace archive {
|
||||
|
||||
namespace {
|
||||
template<class CharType>
|
||||
bool is_whitespace(CharType c);
|
||||
|
||||
template<>
|
||||
bool is_whitespace(char t){
|
||||
return 0 != std::isspace(t);
|
||||
}
|
||||
|
||||
#ifndef BOOST_NO_CWCHAR
|
||||
template<>
|
||||
bool is_whitespace(wchar_t t){
|
||||
return 0 != std::iswspace(t);
|
||||
}
|
||||
#endif
|
||||
}
|
||||
|
||||
// translate base64 text into binary and copy into buffer
|
||||
// until buffer is full.
|
||||
template<class IStream>
|
||||
BOOST_ARCHIVE_OR_WARCHIVE_DECL(void)
|
||||
basic_text_iprimitive<IStream>::load_binary(
|
||||
void *address,
|
||||
std::size_t count
|
||||
){
|
||||
typedef BOOST_DEDUCED_TYPENAME IStream::char_type CharType;
|
||||
|
||||
if(0 == count)
|
||||
return;
|
||||
|
||||
BOOST_ASSERT(
|
||||
static_cast<std::size_t>((std::numeric_limits<std::streamsize>::max)())
|
||||
> (count + sizeof(CharType) - 1)/sizeof(CharType)
|
||||
);
|
||||
|
||||
if(is.fail())
|
||||
boost::serialization::throw_exception(
|
||||
archive_exception(archive_exception::input_stream_error)
|
||||
);
|
||||
// convert from base64 to binary
|
||||
typedef BOOST_DEDUCED_TYPENAME
|
||||
iterators::transform_width<
|
||||
iterators::binary_from_base64<
|
||||
iterators::remove_whitespace<
|
||||
iterators::istream_iterator<CharType>
|
||||
>
|
||||
,CharType
|
||||
>
|
||||
,8
|
||||
,6
|
||||
,CharType
|
||||
>
|
||||
binary;
|
||||
|
||||
binary ti_begin = binary(
|
||||
BOOST_MAKE_PFTO_WRAPPER(
|
||||
iterators::istream_iterator<CharType>(is)
|
||||
)
|
||||
);
|
||||
|
||||
char * caddr = static_cast<char *>(address);
|
||||
|
||||
// take care that we don't increment anymore than necessary
|
||||
while(--count > 0){
|
||||
*caddr++ = static_cast<char>(*ti_begin);
|
||||
++ti_begin;
|
||||
}
|
||||
*caddr++ = static_cast<char>(*ti_begin);
|
||||
|
||||
iterators::istream_iterator<CharType> i;
|
||||
for(;;){
|
||||
BOOST_DEDUCED_TYPENAME IStream::int_type r;
|
||||
r = is.get();
|
||||
if(is.eof())
|
||||
break;
|
||||
if(is_whitespace(static_cast<CharType>(r)))
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
template<class IStream>
|
||||
BOOST_ARCHIVE_OR_WARCHIVE_DECL(BOOST_PP_EMPTY())
|
||||
basic_text_iprimitive<IStream>::basic_text_iprimitive(
|
||||
IStream &is_,
|
||||
bool no_codecvt
|
||||
) :
|
||||
#ifndef BOOST_NO_STD_LOCALE
|
||||
is(is_),
|
||||
flags_saver(is_),
|
||||
precision_saver(is_),
|
||||
archive_locale(NULL),
|
||||
locale_saver(* is_.rdbuf())
|
||||
{
|
||||
if(! no_codecvt){
|
||||
archive_locale.reset(
|
||||
add_facet(
|
||||
std::locale::classic(),
|
||||
new codecvt_null<BOOST_DEDUCED_TYPENAME IStream::char_type>
|
||||
)
|
||||
);
|
||||
is.imbue(* archive_locale);
|
||||
}
|
||||
is >> std::noboolalpha;
|
||||
}
|
||||
#else
|
||||
is(is_),
|
||||
flags_saver(is_),
|
||||
precision_saver(is_)
|
||||
{}
|
||||
#endif
|
||||
|
||||
template<class IStream>
|
||||
BOOST_ARCHIVE_OR_WARCHIVE_DECL(BOOST_PP_EMPTY())
|
||||
basic_text_iprimitive<IStream>::~basic_text_iprimitive(){
|
||||
is.sync();
|
||||
}
|
||||
|
||||
} // namespace archive
|
||||
} // namespace boost
|
||||
|
|
@ -0,0 +1,62 @@
|
|||
/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
|
||||
// basic_text_oarchive.ipp:
|
||||
|
||||
// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
|
||||
// Use, modification and distribution is subject to the Boost Software
|
||||
// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
// See http://www.boost.org for updates, documentation, and revision history.
|
||||
#include <string>
|
||||
#include <boost/assert.hpp>
|
||||
#include <cstring>
|
||||
|
||||
#include <boost/config.hpp> // for BOOST_DEDUCED_TYPENAME
|
||||
#if defined(BOOST_NO_STDC_NAMESPACE)
|
||||
namespace std{
|
||||
using ::memcpy;
|
||||
}
|
||||
#endif
|
||||
|
||||
#include <boost/archive/basic_text_oarchive.hpp>
|
||||
|
||||
namespace boost {
|
||||
namespace archive {
|
||||
|
||||
/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
|
||||
// implementation of basic_text_oarchive
|
||||
|
||||
template<class Archive>
|
||||
BOOST_ARCHIVE_OR_WARCHIVE_DECL(void)
|
||||
basic_text_oarchive<Archive>::newtoken()
|
||||
{
|
||||
switch(delimiter){
|
||||
default:
|
||||
BOOST_ASSERT(false);
|
||||
break;
|
||||
case eol:
|
||||
this->This()->put('\n');
|
||||
delimiter = space;
|
||||
break;
|
||||
case space:
|
||||
this->This()->put(' ');
|
||||
break;
|
||||
case none:
|
||||
delimiter = space;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
template<class Archive>
|
||||
BOOST_ARCHIVE_OR_WARCHIVE_DECL(void)
|
||||
basic_text_oarchive<Archive>::init(){
|
||||
// write signature in an archive version independent manner
|
||||
const std::string file_signature(BOOST_ARCHIVE_SIGNATURE());
|
||||
* this->This() << file_signature;
|
||||
// write library version
|
||||
const library_version_type v(BOOST_ARCHIVE_VERSION());
|
||||
* this->This() << v;
|
||||
}
|
||||
|
||||
} // namespace archive
|
||||
} // namespace boost
|
||||
|
|
@ -0,0 +1,114 @@
|
|||
/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
|
||||
// basic_text_oprimitive.ipp:
|
||||
|
||||
// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
|
||||
// Use, modification and distribution is subject to the Boost Software
|
||||
// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
// See http://www.boost.org for updates, documentation, and revision history.
|
||||
|
||||
#include <cstddef> // NULL
|
||||
#include <boost/serialization/pfto.hpp>
|
||||
|
||||
#include <boost/archive/basic_text_oprimitive.hpp>
|
||||
#include <boost/archive/codecvt_null.hpp>
|
||||
#include <boost/archive/add_facet.hpp>
|
||||
|
||||
#include <boost/archive/iterators/base64_from_binary.hpp>
|
||||
#include <boost/archive/iterators/insert_linebreaks.hpp>
|
||||
#include <boost/archive/iterators/transform_width.hpp>
|
||||
#include <boost/archive/iterators/ostream_iterator.hpp>
|
||||
|
||||
namespace boost {
|
||||
namespace archive {
|
||||
|
||||
// translate to base64 and copy in to buffer.
|
||||
template<class OStream>
|
||||
BOOST_ARCHIVE_OR_WARCHIVE_DECL(void)
|
||||
basic_text_oprimitive<OStream>::save_binary(
|
||||
const void *address,
|
||||
std::size_t count
|
||||
){
|
||||
typedef BOOST_DEDUCED_TYPENAME OStream::char_type CharType;
|
||||
|
||||
if(0 == count)
|
||||
return;
|
||||
|
||||
if(os.fail())
|
||||
boost::serialization::throw_exception(
|
||||
archive_exception(archive_exception::output_stream_error)
|
||||
);
|
||||
|
||||
os.put('\n');
|
||||
|
||||
typedef
|
||||
boost::archive::iterators::insert_linebreaks<
|
||||
boost::archive::iterators::base64_from_binary<
|
||||
boost::archive::iterators::transform_width<
|
||||
const char *,
|
||||
6,
|
||||
8
|
||||
>
|
||||
>
|
||||
,72
|
||||
,const char // cwpro8 needs this
|
||||
>
|
||||
base64_text;
|
||||
|
||||
boost::archive::iterators::ostream_iterator<CharType> oi(os);
|
||||
std::copy(
|
||||
base64_text(BOOST_MAKE_PFTO_WRAPPER(static_cast<const char *>(address))),
|
||||
base64_text(
|
||||
BOOST_MAKE_PFTO_WRAPPER(static_cast<const char *>(address) + count)
|
||||
),
|
||||
oi
|
||||
);
|
||||
|
||||
std::size_t tail = count % 3;
|
||||
if(tail > 0){
|
||||
*oi++ = '=';
|
||||
if(tail < 2)
|
||||
*oi = '=';
|
||||
}
|
||||
}
|
||||
|
||||
template<class OStream>
|
||||
BOOST_ARCHIVE_OR_WARCHIVE_DECL(BOOST_PP_EMPTY())
|
||||
basic_text_oprimitive<OStream>::basic_text_oprimitive(
|
||||
OStream & os_,
|
||||
bool no_codecvt
|
||||
) :
|
||||
#ifndef BOOST_NO_STD_LOCALE
|
||||
os(os_),
|
||||
flags_saver(os_),
|
||||
precision_saver(os_),
|
||||
archive_locale(NULL),
|
||||
locale_saver(* os_.rdbuf())
|
||||
{
|
||||
if(! no_codecvt){
|
||||
archive_locale.reset(
|
||||
add_facet(
|
||||
std::locale::classic(),
|
||||
new codecvt_null<BOOST_DEDUCED_TYPENAME OStream::char_type>
|
||||
)
|
||||
);
|
||||
os.imbue(* archive_locale);
|
||||
}
|
||||
os << std::noboolalpha;
|
||||
}
|
||||
#else
|
||||
os(os_),
|
||||
flags_saver(os_),
|
||||
precision_saver(os_)
|
||||
{}
|
||||
#endif
|
||||
|
||||
template<class OStream>
|
||||
BOOST_ARCHIVE_OR_WARCHIVE_DECL(BOOST_PP_EMPTY())
|
||||
basic_text_oprimitive<OStream>::~basic_text_oprimitive(){
|
||||
os << std::endl;
|
||||
}
|
||||
|
||||
} //namespace boost
|
||||
} //namespace archive
|
||||
|
|
@ -0,0 +1,178 @@
|
|||
#ifndef BOOST_ARCHIVE_BASIC_XML_GRAMMAR_HPP
|
||||
#define BOOST_ARCHIVE_BASIC_XML_GRAMMAR_HPP
|
||||
|
||||
// MS compatible compilers support #pragma once
|
||||
#if defined(_MSC_VER) && (_MSC_VER >= 1020)
|
||||
# pragma once
|
||||
#endif
|
||||
|
||||
/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
|
||||
// basic_xml_grammar.hpp
|
||||
|
||||
// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
|
||||
// Use, modification and distribution is subject to the Boost Software
|
||||
// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
// See http://www.boost.org for updates, documentation, and revision history.
|
||||
|
||||
// this module is derived from simplexml.cpp - an example shipped as part of
|
||||
// the spirit parser. This example contains the following notice:
|
||||
/*=============================================================================
|
||||
simplexml.cpp
|
||||
|
||||
Spirit V1.3
|
||||
URL: http://spirit.sourceforge.net/
|
||||
|
||||
Copyright (c) 2001, Daniel C. Nuffer
|
||||
|
||||
This software is provided 'as-is', without any express or implied
|
||||
warranty. In no event will the copyright holder be held liable for
|
||||
any damages arising from the use of this software.
|
||||
|
||||
Permission is granted to anyone to use this software for any purpose,
|
||||
including commercial applications, and to alter it and redistribute
|
||||
it freely, subject to the following restrictions:
|
||||
|
||||
1. The origin of this software must not be misrepresented; you must
|
||||
not claim that you wrote the original software. If you use this
|
||||
software in a product, an acknowledgment in the product documentation
|
||||
would be appreciated but is not required.
|
||||
|
||||
2. Altered source versions must be plainly marked as such, and must
|
||||
not be misrepresented as being the original software.
|
||||
|
||||
3. This notice may not be removed or altered from any source
|
||||
distribution.
|
||||
=============================================================================*/
|
||||
#include <string>
|
||||
|
||||
#include <boost/config.hpp>
|
||||
#include <boost/detail/workaround.hpp>
|
||||
|
||||
// supress noise
|
||||
#if BOOST_WORKAROUND(BOOST_MSVC, <= 1200)
|
||||
# pragma warning (disable : 4786) // too long name, harmless warning
|
||||
#endif
|
||||
|
||||
#include <boost/spirit/include/classic_rule.hpp>
|
||||
#include <boost/spirit/include/classic_chset.hpp>
|
||||
|
||||
#include <boost/archive/basic_archive.hpp>
|
||||
#include <boost/serialization/tracking.hpp>
|
||||
#include <boost/serialization/version.hpp>
|
||||
|
||||
namespace boost {
|
||||
namespace archive {
|
||||
|
||||
/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
|
||||
// XML grammar parsing
|
||||
|
||||
template<class CharType>
|
||||
class basic_xml_grammar {
|
||||
public:
|
||||
// The following is not necessary according to DR45, but at least
|
||||
// one compiler (Compaq C++ 6.5 in strict_ansi mode) chokes otherwise.
|
||||
struct return_values;
|
||||
friend struct return_values;
|
||||
|
||||
private:
|
||||
typedef BOOST_DEDUCED_TYPENAME std::basic_istream<CharType> IStream;
|
||||
typedef BOOST_DEDUCED_TYPENAME std::basic_string<CharType> StringType;
|
||||
typedef BOOST_DEDUCED_TYPENAME boost::spirit::classic::chset<CharType> chset_t;
|
||||
typedef BOOST_DEDUCED_TYPENAME boost::spirit::classic::chlit<CharType> chlit_t;
|
||||
typedef BOOST_DEDUCED_TYPENAME boost::spirit::classic::scanner<
|
||||
BOOST_DEDUCED_TYPENAME std::basic_string<CharType>::iterator
|
||||
> scanner_t;
|
||||
typedef BOOST_DEDUCED_TYPENAME boost::spirit::classic::rule<scanner_t> rule_t;
|
||||
// Start grammar definition
|
||||
rule_t
|
||||
Reference,
|
||||
Eq,
|
||||
STag,
|
||||
ETag,
|
||||
LetterOrUnderscoreOrColon,
|
||||
AttValue,
|
||||
CharRef1,
|
||||
CharRef2,
|
||||
CharRef,
|
||||
AmpRef,
|
||||
LTRef,
|
||||
GTRef,
|
||||
AposRef,
|
||||
QuoteRef,
|
||||
CharData,
|
||||
CharDataChars,
|
||||
content,
|
||||
AmpName,
|
||||
LTName,
|
||||
GTName,
|
||||
ClassNameChar,
|
||||
ClassName,
|
||||
Name,
|
||||
XMLDecl,
|
||||
XMLDeclChars,
|
||||
DocTypeDecl,
|
||||
DocTypeDeclChars,
|
||||
ClassIDAttribute,
|
||||
ObjectIDAttribute,
|
||||
ClassNameAttribute,
|
||||
TrackingAttribute,
|
||||
VersionAttribute,
|
||||
UnusedAttribute,
|
||||
Attribute,
|
||||
SignatureAttribute,
|
||||
SerializationWrapper,
|
||||
NameHead,
|
||||
NameTail,
|
||||
AttributeList,
|
||||
S;
|
||||
|
||||
// XML Character classes
|
||||
chset_t
|
||||
BaseChar,
|
||||
Ideographic,
|
||||
Char,
|
||||
Letter,
|
||||
Digit,
|
||||
CombiningChar,
|
||||
Extender,
|
||||
Sch,
|
||||
NameChar;
|
||||
|
||||
void init_chset();
|
||||
|
||||
bool my_parse(
|
||||
IStream & is,
|
||||
const rule_t &rule_,
|
||||
const CharType delimiter = L'>'
|
||||
) const ;
|
||||
public:
|
||||
struct return_values {
|
||||
StringType object_name;
|
||||
StringType contents;
|
||||
//class_id_type class_id;
|
||||
int_least16_t class_id;
|
||||
//object_id_type object_id;
|
||||
uint_least32_t object_id;
|
||||
//version_type version;
|
||||
unsigned int version;
|
||||
tracking_type tracking_level;
|
||||
StringType class_name;
|
||||
return_values() :
|
||||
version(0),
|
||||
tracking_level(false)
|
||||
{}
|
||||
} rv;
|
||||
bool parse_start_tag(IStream & is) /*const*/;
|
||||
bool parse_end_tag(IStream & is) const;
|
||||
bool parse_string(IStream & is, StringType & s) /*const*/;
|
||||
void init(IStream & is);
|
||||
void windup(IStream & is);
|
||||
basic_xml_grammar();
|
||||
};
|
||||
|
||||
} // namespace archive
|
||||
} // namespace boost
|
||||
|
||||
#endif // BOOST_ARCHIVE_BASIC_XML_GRAMMAR_HPP
|
||||
|
|
@ -0,0 +1,114 @@
|
|||
/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
|
||||
// basic_xml_iarchive.ipp:
|
||||
|
||||
// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
|
||||
// Use, modification and distribution is subject to the Boost Software
|
||||
// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
// See http://www.boost.org for updates, documentation, and revision history.
|
||||
|
||||
#include <boost/assert.hpp>
|
||||
#include <cstddef> // NULL
|
||||
#include <algorithm>
|
||||
|
||||
#include <boost/serialization/throw_exception.hpp>
|
||||
#include <boost/archive/xml_archive_exception.hpp>
|
||||
#include <boost/archive/basic_xml_iarchive.hpp>
|
||||
#include <boost/serialization/tracking.hpp>
|
||||
|
||||
namespace boost {
|
||||
namespace archive {
|
||||
|
||||
/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
|
||||
// implementation of xml_text_archive
|
||||
|
||||
template<class Archive>
|
||||
BOOST_ARCHIVE_OR_WARCHIVE_DECL(void)
|
||||
basic_xml_iarchive<Archive>::load_start(const char *name){
|
||||
// if there's no name
|
||||
if(NULL == name)
|
||||
return;
|
||||
bool result = this->This()->gimpl->parse_start_tag(this->This()->get_is());
|
||||
if(true != result){
|
||||
boost::serialization::throw_exception(
|
||||
archive_exception(archive_exception::input_stream_error)
|
||||
);
|
||||
}
|
||||
// don't check start tag at highest level
|
||||
++depth;
|
||||
return;
|
||||
}
|
||||
|
||||
template<class Archive>
|
||||
BOOST_ARCHIVE_OR_WARCHIVE_DECL(void)
|
||||
basic_xml_iarchive<Archive>::load_end(const char *name){
|
||||
// if there's no name
|
||||
if(NULL == name)
|
||||
return;
|
||||
bool result = this->This()->gimpl->parse_end_tag(this->This()->get_is());
|
||||
if(true != result){
|
||||
boost::serialization::throw_exception(
|
||||
archive_exception(archive_exception::input_stream_error)
|
||||
);
|
||||
}
|
||||
|
||||
// don't check start tag at highest level
|
||||
if(0 == --depth)
|
||||
return;
|
||||
|
||||
if(0 == (this->get_flags() & no_xml_tag_checking)){
|
||||
// double check that the tag matches what is expected - useful for debug
|
||||
if(0 != name[this->This()->gimpl->rv.object_name.size()]
|
||||
|| ! std::equal(
|
||||
this->This()->gimpl->rv.object_name.begin(),
|
||||
this->This()->gimpl->rv.object_name.end(),
|
||||
name
|
||||
)
|
||||
){
|
||||
boost::serialization::throw_exception(
|
||||
xml_archive_exception(
|
||||
xml_archive_exception::xml_archive_tag_mismatch,
|
||||
name
|
||||
)
|
||||
);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
template<class Archive>
|
||||
BOOST_ARCHIVE_OR_WARCHIVE_DECL(void)
|
||||
basic_xml_iarchive<Archive>::load_override(object_id_type & t, int){
|
||||
t = object_id_type(this->This()->gimpl->rv.object_id);
|
||||
}
|
||||
|
||||
template<class Archive>
|
||||
BOOST_ARCHIVE_OR_WARCHIVE_DECL(void)
|
||||
basic_xml_iarchive<Archive>::load_override(version_type & t, int){
|
||||
t = version_type(this->This()->gimpl->rv.version);
|
||||
}
|
||||
|
||||
template<class Archive>
|
||||
BOOST_ARCHIVE_OR_WARCHIVE_DECL(void)
|
||||
basic_xml_iarchive<Archive>::load_override(class_id_type & t, int){
|
||||
t = class_id_type(this->This()->gimpl->rv.class_id);
|
||||
}
|
||||
|
||||
template<class Archive>
|
||||
BOOST_ARCHIVE_OR_WARCHIVE_DECL(void)
|
||||
basic_xml_iarchive<Archive>::load_override(tracking_type & t, int){
|
||||
t = this->This()->gimpl->rv.tracking_level;
|
||||
}
|
||||
|
||||
template<class Archive>
|
||||
BOOST_ARCHIVE_OR_WARCHIVE_DECL(BOOST_PP_EMPTY())
|
||||
basic_xml_iarchive<Archive>::basic_xml_iarchive(unsigned int flags) :
|
||||
detail::common_iarchive<Archive>(flags),
|
||||
depth(0)
|
||||
{}
|
||||
template<class Archive>
|
||||
BOOST_ARCHIVE_OR_WARCHIVE_DECL(BOOST_PP_EMPTY())
|
||||
basic_xml_iarchive<Archive>::~basic_xml_iarchive(){}
|
||||
|
||||
} // namespace archive
|
||||
} // namespace boost
|
||||
|
|
@ -0,0 +1,275 @@
|
|||
/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
|
||||
// basic_xml_oarchive.ipp:
|
||||
|
||||
// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
|
||||
// Distributed under the Boost Software License, Version 1.0. (See
|
||||
// accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
// See http://www.boost.org for updates, documentation, and revision history.
|
||||
|
||||
#include <algorithm>
|
||||
#include <cstddef> // NULL
|
||||
#include <cstring>
|
||||
#if defined(BOOST_NO_STDC_NAMESPACE) && ! defined(__LIBCOMO__)
|
||||
namespace std{
|
||||
using ::strlen;
|
||||
} // namespace std
|
||||
#endif
|
||||
|
||||
#include <boost/archive/basic_xml_archive.hpp>
|
||||
#include <boost/archive/basic_xml_oarchive.hpp>
|
||||
#include <boost/archive/xml_archive_exception.hpp>
|
||||
#include <boost/detail/no_exceptions_support.hpp>
|
||||
|
||||
namespace boost {
|
||||
namespace archive {
|
||||
|
||||
namespace detail {
|
||||
template<class CharType>
|
||||
struct XML_name {
|
||||
void operator()(CharType t) const{
|
||||
const unsigned char lookup_table[] = {
|
||||
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
|
||||
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
|
||||
0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,0, // -.
|
||||
1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0, // 0-9
|
||||
0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, // A-
|
||||
1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,1, // -Z _
|
||||
0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, // a-
|
||||
1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0, // -z
|
||||
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
|
||||
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
|
||||
};
|
||||
if((unsigned)t > 127)
|
||||
return;
|
||||
if(0 == lookup_table[(unsigned)t])
|
||||
boost::serialization::throw_exception(
|
||||
xml_archive_exception(
|
||||
xml_archive_exception::xml_archive_tag_name_error
|
||||
)
|
||||
);
|
||||
}
|
||||
};
|
||||
|
||||
} // namespace detail
|
||||
|
||||
/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
|
||||
// implemenations of functions common to both types of xml output
|
||||
|
||||
template<class Archive>
|
||||
BOOST_ARCHIVE_OR_WARCHIVE_DECL(void)
|
||||
basic_xml_oarchive<Archive>::write_attribute(
|
||||
const char *attribute_name,
|
||||
int t,
|
||||
const char *conjunction
|
||||
){
|
||||
this->This()->put(' ');
|
||||
this->This()->put(attribute_name);
|
||||
this->This()->put(conjunction);
|
||||
this->This()->save(t);
|
||||
this->This()->put('"');
|
||||
}
|
||||
|
||||
template<class Archive>
|
||||
BOOST_ARCHIVE_OR_WARCHIVE_DECL(void)
|
||||
basic_xml_oarchive<Archive>::write_attribute(
|
||||
const char *attribute_name,
|
||||
const char *key
|
||||
){
|
||||
this->This()->put(' ');
|
||||
this->This()->put(attribute_name);
|
||||
this->This()->put("=\"");
|
||||
this->This()->save(key);
|
||||
this->This()->put('"');
|
||||
}
|
||||
|
||||
template<class Archive>
|
||||
BOOST_ARCHIVE_OR_WARCHIVE_DECL(void)
|
||||
basic_xml_oarchive<Archive>::indent(){
|
||||
int i;
|
||||
for(i = depth; i-- > 0;)
|
||||
this->This()->put('\t');
|
||||
}
|
||||
|
||||
template<class Archive>
|
||||
BOOST_ARCHIVE_OR_WARCHIVE_DECL(void)
|
||||
basic_xml_oarchive<Archive>::save_start(const char *name)
|
||||
{
|
||||
if(NULL == name)
|
||||
return;
|
||||
|
||||
// be sure name has no invalid characters
|
||||
std::for_each(name, name + std::strlen(name), detail::XML_name<const char>());
|
||||
|
||||
end_preamble();
|
||||
if(depth > 0){
|
||||
this->This()->put('\n');
|
||||
indent();
|
||||
}
|
||||
++depth;
|
||||
this->This()->put('<');
|
||||
this->This()->save(name);
|
||||
pending_preamble = true;
|
||||
indent_next = false;
|
||||
}
|
||||
|
||||
template<class Archive>
|
||||
BOOST_ARCHIVE_OR_WARCHIVE_DECL(void)
|
||||
basic_xml_oarchive<Archive>::save_end(const char *name)
|
||||
{
|
||||
if(NULL == name)
|
||||
return;
|
||||
|
||||
// be sure name has no invalid characters
|
||||
std::for_each(name, name + std::strlen(name), detail::XML_name<const char>());
|
||||
|
||||
end_preamble();
|
||||
--depth;
|
||||
if(indent_next){
|
||||
this->This()->put('\n');
|
||||
indent();
|
||||
}
|
||||
indent_next = true;
|
||||
this->This()->put("</");
|
||||
this->This()->save(name);
|
||||
this->This()->put('>');
|
||||
if(0 == depth)
|
||||
this->This()->put('\n');
|
||||
}
|
||||
|
||||
template<class Archive>
|
||||
BOOST_ARCHIVE_OR_WARCHIVE_DECL(void)
|
||||
basic_xml_oarchive<Archive>::end_preamble(){
|
||||
if(pending_preamble){
|
||||
this->This()->put('>');
|
||||
pending_preamble = false;
|
||||
}
|
||||
}
|
||||
#if 0
|
||||
template<class Archive>
|
||||
BOOST_ARCHIVE_OR_WARCHIVE_DECL(void)
|
||||
basic_xml_oarchive<Archive>::save_override(const object_id_type & t, int)
|
||||
{
|
||||
int i = t.t; // extra .t is for borland
|
||||
write_attribute(BOOST_ARCHIVE_XML_OBJECT_ID(), i, "=\"_");
|
||||
}
|
||||
template<class Archive>
|
||||
BOOST_ARCHIVE_OR_WARCHIVE_DECL(void)
|
||||
basic_xml_oarchive<Archive>::save_override(
|
||||
const object_reference_type & t,
|
||||
int
|
||||
){
|
||||
int i = t.t; // extra .t is for borland
|
||||
write_attribute(BOOST_ARCHIVE_XML_OBJECT_REFERENCE(), i, "=\"_");
|
||||
}
|
||||
template<class Archive>
|
||||
BOOST_ARCHIVE_OR_WARCHIVE_DECL(void)
|
||||
basic_xml_oarchive<Archive>::save_override(const version_type & t, int)
|
||||
{
|
||||
int i = t.t; // extra .t is for borland
|
||||
write_attribute(BOOST_ARCHIVE_XML_VERSION(), i);
|
||||
}
|
||||
#endif
|
||||
|
||||
template<class Archive>
|
||||
BOOST_ARCHIVE_OR_WARCHIVE_DECL(void)
|
||||
basic_xml_oarchive<Archive>::save_override(const object_id_type & t, int)
|
||||
{
|
||||
// borland doesn't do conversion of STRONG_TYPEDEFs very well
|
||||
const unsigned int i = t;
|
||||
write_attribute(BOOST_ARCHIVE_XML_OBJECT_ID(), i, "=\"_");
|
||||
}
|
||||
template<class Archive>
|
||||
BOOST_ARCHIVE_OR_WARCHIVE_DECL(void)
|
||||
basic_xml_oarchive<Archive>::save_override(
|
||||
const object_reference_type & t,
|
||||
int
|
||||
){
|
||||
const unsigned int i = t;
|
||||
write_attribute(BOOST_ARCHIVE_XML_OBJECT_REFERENCE(), i, "=\"_");
|
||||
}
|
||||
template<class Archive>
|
||||
BOOST_ARCHIVE_OR_WARCHIVE_DECL(void)
|
||||
basic_xml_oarchive<Archive>::save_override(const version_type & t, int)
|
||||
{
|
||||
const unsigned int i = t;
|
||||
write_attribute(BOOST_ARCHIVE_XML_VERSION(), i);
|
||||
}
|
||||
|
||||
template<class Archive>
|
||||
BOOST_ARCHIVE_OR_WARCHIVE_DECL(void)
|
||||
basic_xml_oarchive<Archive>::save_override(const class_id_type & t, int)
|
||||
{
|
||||
write_attribute(BOOST_ARCHIVE_XML_CLASS_ID(), t);
|
||||
}
|
||||
template<class Archive>
|
||||
BOOST_ARCHIVE_OR_WARCHIVE_DECL(void)
|
||||
basic_xml_oarchive<Archive>::save_override(
|
||||
const class_id_reference_type & t,
|
||||
int
|
||||
){
|
||||
write_attribute(BOOST_ARCHIVE_XML_CLASS_ID_REFERENCE(), t);
|
||||
}
|
||||
template<class Archive>
|
||||
BOOST_ARCHIVE_OR_WARCHIVE_DECL(void)
|
||||
basic_xml_oarchive<Archive>::save_override(
|
||||
const class_id_optional_type & t,
|
||||
int
|
||||
){
|
||||
write_attribute(BOOST_ARCHIVE_XML_CLASS_ID(), t);
|
||||
}
|
||||
template<class Archive>
|
||||
BOOST_ARCHIVE_OR_WARCHIVE_DECL(void)
|
||||
basic_xml_oarchive<Archive>::save_override(const class_name_type & t, int)
|
||||
{
|
||||
const char * key = t;
|
||||
if(NULL == key)
|
||||
return;
|
||||
write_attribute(BOOST_ARCHIVE_XML_CLASS_NAME(), key);
|
||||
}
|
||||
|
||||
template<class Archive>
|
||||
BOOST_ARCHIVE_OR_WARCHIVE_DECL(void)
|
||||
basic_xml_oarchive<Archive>::save_override(const tracking_type & t, int)
|
||||
{
|
||||
write_attribute(BOOST_ARCHIVE_XML_TRACKING(), t.t);
|
||||
}
|
||||
|
||||
template<class Archive>
|
||||
BOOST_ARCHIVE_OR_WARCHIVE_DECL(void)
|
||||
basic_xml_oarchive<Archive>::init(){
|
||||
// xml header
|
||||
this->This()->put("<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\" ?>\n");
|
||||
this->This()->put("<!DOCTYPE boost_serialization>\n");
|
||||
// xml document wrapper - outer root
|
||||
this->This()->put("<boost_serialization");
|
||||
write_attribute("signature", BOOST_ARCHIVE_SIGNATURE());
|
||||
write_attribute("version", BOOST_ARCHIVE_VERSION());
|
||||
this->This()->put(">\n");
|
||||
}
|
||||
|
||||
template<class Archive>
|
||||
BOOST_ARCHIVE_OR_WARCHIVE_DECL(BOOST_PP_EMPTY())
|
||||
basic_xml_oarchive<Archive>::basic_xml_oarchive(unsigned int flags) :
|
||||
detail::common_oarchive<Archive>(flags),
|
||||
depth(0),
|
||||
indent_next(false),
|
||||
pending_preamble(false)
|
||||
{
|
||||
}
|
||||
|
||||
template<class Archive>
|
||||
BOOST_ARCHIVE_OR_WARCHIVE_DECL(BOOST_PP_EMPTY())
|
||||
basic_xml_oarchive<Archive>::~basic_xml_oarchive(){
|
||||
if(0 == (this->get_flags() & no_header)){
|
||||
BOOST_TRY{
|
||||
this->This()->put("</boost_serialization>\n");
|
||||
}
|
||||
BOOST_CATCH(...){}
|
||||
BOOST_CATCH_END
|
||||
}
|
||||
}
|
||||
|
||||
} // namespace archive
|
||||
} // namespace boost
|
||||
|
|
@ -0,0 +1,128 @@
|
|||
/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
|
||||
// text_iarchive_impl.ipp:
|
||||
|
||||
// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
|
||||
// Distributed under the Boost Software License, Version 1.0. (See
|
||||
// accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
// See http://www.boost.org for updates, documentation, and revision history.
|
||||
|
||||
//////////////////////////////////////////////////////////////////////
|
||||
// implementation of basic_text_iprimitive overrides for the combination
|
||||
// of template parameters used to implement a text_iprimitive
|
||||
|
||||
#include <cstddef> // size_t, NULL
|
||||
#include <boost/config.hpp>
|
||||
#if defined(BOOST_NO_STDC_NAMESPACE)
|
||||
namespace std{
|
||||
using ::size_t;
|
||||
} // namespace std
|
||||
#endif
|
||||
|
||||
#include <boost/detail/workaround.hpp> // RogueWave
|
||||
|
||||
#include <boost/archive/text_iarchive.hpp>
|
||||
|
||||
namespace boost {
|
||||
namespace archive {
|
||||
|
||||
template<class Archive>
|
||||
BOOST_ARCHIVE_DECL(void)
|
||||
text_iarchive_impl<Archive>::load(char *s)
|
||||
{
|
||||
std::size_t size;
|
||||
* this->This() >> size;
|
||||
// skip separating space
|
||||
is.get();
|
||||
// Works on all tested platforms
|
||||
is.read(s, size);
|
||||
s[size] = '\0';
|
||||
}
|
||||
|
||||
template<class Archive>
|
||||
BOOST_ARCHIVE_DECL(void)
|
||||
text_iarchive_impl<Archive>::load(std::string &s)
|
||||
{
|
||||
std::size_t size;
|
||||
* this->This() >> size;
|
||||
// skip separating space
|
||||
is.get();
|
||||
// borland de-allocator fixup
|
||||
#if BOOST_WORKAROUND(_RWSTD_VER, BOOST_TESTED_AT(20101))
|
||||
if(NULL != s.data())
|
||||
#endif
|
||||
s.resize(size);
|
||||
if(0 < size)
|
||||
is.read(&(*s.begin()), size);
|
||||
}
|
||||
|
||||
#ifndef BOOST_NO_CWCHAR
|
||||
#ifndef BOOST_NO_INTRINSIC_WCHAR_T
|
||||
template<class Archive>
|
||||
BOOST_ARCHIVE_DECL(void)
|
||||
text_iarchive_impl<Archive>::load(wchar_t *ws)
|
||||
{
|
||||
std::size_t size;
|
||||
* this->This() >> size;
|
||||
// skip separating space
|
||||
is.get();
|
||||
is.read((char *)ws, size * sizeof(wchar_t)/sizeof(char));
|
||||
ws[size] = L'\0';
|
||||
}
|
||||
#endif // BOOST_NO_INTRINSIC_WCHAR_T
|
||||
|
||||
#ifndef BOOST_NO_STD_WSTRING
|
||||
template<class Archive>
|
||||
BOOST_ARCHIVE_DECL(void)
|
||||
text_iarchive_impl<Archive>::load(std::wstring &ws)
|
||||
{
|
||||
std::size_t size;
|
||||
* this->This() >> size;
|
||||
// borland de-allocator fixup
|
||||
#if BOOST_WORKAROUND(_RWSTD_VER, BOOST_TESTED_AT(20101))
|
||||
if(NULL != ws.data())
|
||||
#endif
|
||||
ws.resize(size);
|
||||
// skip separating space
|
||||
is.get();
|
||||
is.read((char *)ws.data(), size * sizeof(wchar_t)/sizeof(char));
|
||||
}
|
||||
|
||||
#endif // BOOST_NO_STD_WSTRING
|
||||
#endif // BOOST_NO_CWCHAR
|
||||
|
||||
template<class Archive>
|
||||
BOOST_ARCHIVE_DECL(void)
|
||||
text_iarchive_impl<Archive>::load_override(class_name_type & t, int){
|
||||
basic_text_iarchive<Archive>::load_override(t, 0);
|
||||
}
|
||||
|
||||
template<class Archive>
|
||||
BOOST_ARCHIVE_DECL(void)
|
||||
text_iarchive_impl<Archive>::init(){
|
||||
basic_text_iarchive<Archive>::init();
|
||||
}
|
||||
|
||||
template<class Archive>
|
||||
BOOST_ARCHIVE_DECL(BOOST_PP_EMPTY())
|
||||
text_iarchive_impl<Archive>::text_iarchive_impl(
|
||||
std::istream & is,
|
||||
unsigned int flags
|
||||
) :
|
||||
basic_text_iprimitive<std::istream>(
|
||||
is,
|
||||
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
|
||||
|
|
@ -0,0 +1,124 @@
|
|||
/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
|
||||
// text_oarchive_impl.ipp:
|
||||
|
||||
// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
|
||||
// Distributed under the Boost Software License, Version 1.0. (See
|
||||
// accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
// See http://www.boost.org for updates, documentation, and revision history.
|
||||
|
||||
#include <string>
|
||||
#include <boost/config.hpp>
|
||||
#include <locale>
|
||||
#include <cstddef> // size_t
|
||||
|
||||
#include <boost/config.hpp>
|
||||
#if defined(BOOST_NO_STDC_NAMESPACE)
|
||||
namespace std{
|
||||
using ::size_t;
|
||||
} // namespace std
|
||||
#endif
|
||||
|
||||
#ifndef BOOST_NO_CWCHAR
|
||||
#include <cwchar>
|
||||
#ifdef BOOST_NO_STDC_NAMESPACE
|
||||
namespace std{ using ::wcslen; }
|
||||
#endif
|
||||
#endif
|
||||
|
||||
#include <boost/archive/add_facet.hpp>
|
||||
#include <boost/archive/text_oarchive.hpp>
|
||||
|
||||
namespace boost {
|
||||
namespace archive {
|
||||
|
||||
//////////////////////////////////////////////////////////////////////
|
||||
// implementation of basic_text_oprimitive overrides for the combination
|
||||
// of template parameters used to create a text_oprimitive
|
||||
|
||||
template<class Archive>
|
||||
BOOST_ARCHIVE_DECL(void)
|
||||
text_oarchive_impl<Archive>::save(const char * s)
|
||||
{
|
||||
const std::size_t len = std::ostream::traits_type::length(s);
|
||||
*this->This() << len;
|
||||
this->This()->newtoken();
|
||||
os << s;
|
||||
}
|
||||
|
||||
template<class Archive>
|
||||
BOOST_ARCHIVE_DECL(void)
|
||||
text_oarchive_impl<Archive>::save(const std::string &s)
|
||||
{
|
||||
const std::size_t size = s.size();
|
||||
*this->This() << size;
|
||||
this->This()->newtoken();
|
||||
os << s;
|
||||
}
|
||||
|
||||
#ifndef BOOST_NO_CWCHAR
|
||||
#ifndef BOOST_NO_INTRINSIC_WCHAR_T
|
||||
template<class Archive>
|
||||
BOOST_ARCHIVE_DECL(void)
|
||||
text_oarchive_impl<Archive>::save(const wchar_t * ws)
|
||||
{
|
||||
const std::size_t l = std::wcslen(ws);
|
||||
* this->This() << l;
|
||||
this->This()->newtoken();
|
||||
os.write((const char *)ws, l * sizeof(wchar_t)/sizeof(char));
|
||||
}
|
||||
#endif
|
||||
|
||||
#ifndef BOOST_NO_STD_WSTRING
|
||||
template<class Archive>
|
||||
BOOST_ARCHIVE_DECL(void)
|
||||
text_oarchive_impl<Archive>::save(const std::wstring &ws)
|
||||
{
|
||||
const std::size_t l = ws.size();
|
||||
* this->This() << l;
|
||||
this->This()->newtoken();
|
||||
os.write((const char *)(ws.data()), l * sizeof(wchar_t)/sizeof(char));
|
||||
}
|
||||
#endif
|
||||
#endif // BOOST_NO_CWCHAR
|
||||
|
||||
template<class Archive>
|
||||
BOOST_ARCHIVE_DECL(BOOST_PP_EMPTY())
|
||||
text_oarchive_impl<Archive>::text_oarchive_impl(
|
||||
std::ostream & os,
|
||||
unsigned int flags
|
||||
) :
|
||||
basic_text_oprimitive<std::ostream>(
|
||||
os,
|
||||
0 != (flags & no_codecvt)
|
||||
),
|
||||
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>
|
||||
BOOST_ARCHIVE_DECL(void)
|
||||
text_oarchive_impl<Archive>::save_binary(const void *address, std::size_t count){
|
||||
put('\n');
|
||||
this->end_preamble();
|
||||
#if ! defined(__MWERKS__)
|
||||
this->basic_text_oprimitive<std::ostream>::save_binary(
|
||||
#else
|
||||
this->basic_text_oprimitive::save_binary(
|
||||
#endif
|
||||
address,
|
||||
count
|
||||
);
|
||||
this->delimiter = this->eol;
|
||||
}
|
||||
|
||||
} // namespace archive
|
||||
} // namespace boost
|
||||
|
||||
|
|
@ -0,0 +1,118 @@
|
|||
/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
|
||||
// text_text_wiarchive_impl.ipp:
|
||||
|
||||
// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
|
||||
// Distributed under the Boost Software License, Version 1.0. (See
|
||||
// accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
// See http://www.boost.org for updates, documentation, and revision history.
|
||||
|
||||
#include <cstddef> // size_t, NULL
|
||||
|
||||
#include <boost/config.hpp>
|
||||
#if defined(BOOST_NO_STDC_NAMESPACE)
|
||||
namespace std{
|
||||
using ::size_t;
|
||||
} // namespace std
|
||||
#endif
|
||||
|
||||
#include <boost/detail/workaround.hpp> // fixup for RogueWave
|
||||
|
||||
#ifndef BOOST_NO_STD_WSTREAMBUF
|
||||
#include <boost/archive/basic_text_iprimitive.hpp>
|
||||
|
||||
namespace boost {
|
||||
namespace archive {
|
||||
|
||||
//////////////////////////////////////////////////////////////////////
|
||||
// implementation of wiprimtives functions
|
||||
//
|
||||
template<class Archive>
|
||||
BOOST_WARCHIVE_DECL(void)
|
||||
text_wiarchive_impl<Archive>::load(char *s)
|
||||
{
|
||||
std::size_t size;
|
||||
* this->This() >> size;
|
||||
// skip separating space
|
||||
is.get();
|
||||
while(size-- > 0){
|
||||
*s++ = is.narrow(is.get(), '\0');
|
||||
}
|
||||
*s = '\0';
|
||||
}
|
||||
|
||||
template<class Archive>
|
||||
BOOST_WARCHIVE_DECL(void)
|
||||
text_wiarchive_impl<Archive>::load(std::string &s)
|
||||
{
|
||||
std::size_t size;
|
||||
* this->This() >> size;
|
||||
// skip separating space
|
||||
is.get();
|
||||
#if BOOST_WORKAROUND(_RWSTD_VER, BOOST_TESTED_AT(20101))
|
||||
if(NULL != s.data())
|
||||
#endif
|
||||
s.resize(0);
|
||||
s.reserve(size);
|
||||
while(size-- > 0){
|
||||
int x = is.narrow(is.get(), '\0');
|
||||
s += x;
|
||||
}
|
||||
}
|
||||
|
||||
#ifndef BOOST_NO_INTRINSIC_WCHAR_T
|
||||
template<class Archive>
|
||||
BOOST_WARCHIVE_DECL(void)
|
||||
text_wiarchive_impl<Archive>::load(wchar_t *s)
|
||||
{
|
||||
std::size_t size;
|
||||
* this->This() >> size;
|
||||
// skip separating space
|
||||
is.get();
|
||||
// Works on all tested platforms
|
||||
is.read(s, size);
|
||||
s[size] = L'\0';
|
||||
}
|
||||
#endif
|
||||
|
||||
#ifndef BOOST_NO_STD_WSTRING
|
||||
template<class Archive>
|
||||
BOOST_WARCHIVE_DECL(void)
|
||||
text_wiarchive_impl<Archive>::load(std::wstring &ws)
|
||||
{
|
||||
std::size_t size;
|
||||
* this->This() >> size;
|
||||
// skip separating space
|
||||
is.get();
|
||||
// borland complains about resize
|
||||
// borland de-allocator fixup
|
||||
#if BOOST_WORKAROUND(_RWSTD_VER, BOOST_TESTED_AT(20101))
|
||||
if(NULL != ws.data())
|
||||
#endif
|
||||
ws.resize(size);
|
||||
// note breaking a rule here - is this a problem on some platform
|
||||
is.read(const_cast<wchar_t *>(ws.data()), size);
|
||||
}
|
||||
#endif
|
||||
|
||||
template<class Archive>
|
||||
BOOST_WARCHIVE_DECL(BOOST_PP_EMPTY())
|
||||
text_wiarchive_impl<Archive>::text_wiarchive_impl(
|
||||
std::wistream & is,
|
||||
unsigned int flags
|
||||
) :
|
||||
basic_text_iprimitive<std::wistream>(
|
||||
is,
|
||||
0 != (flags & no_codecvt)
|
||||
),
|
||||
basic_text_iarchive<Archive>(flags)
|
||||
{
|
||||
if(0 == (flags & no_header))
|
||||
basic_text_iarchive<Archive>::init();
|
||||
}
|
||||
|
||||
} // archive
|
||||
} // boost
|
||||
|
||||
#endif // BOOST_NO_STD_WSTREAMBUF
|
||||
|
|
@ -0,0 +1,85 @@
|
|||
/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
|
||||
// text_woarchive_impl.ipp:
|
||||
|
||||
// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
|
||||
// Distributed under the Boost Software License, Version 1.0. (See
|
||||
// accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
// See http://www.boost.org for updates, documentation, and revision history.
|
||||
|
||||
#include <boost/config.hpp>
|
||||
#ifndef BOOST_NO_STD_WSTREAMBUF
|
||||
|
||||
#include <cstring>
|
||||
#include <cstddef> // size_t
|
||||
#if defined(BOOST_NO_STDC_NAMESPACE) && ! defined(__LIBCOMO__)
|
||||
namespace std{
|
||||
using ::strlen;
|
||||
using ::size_t;
|
||||
} // namespace std
|
||||
#endif
|
||||
|
||||
#include <ostream>
|
||||
|
||||
#include <boost/archive/text_woarchive.hpp>
|
||||
|
||||
namespace boost {
|
||||
namespace archive {
|
||||
|
||||
//////////////////////////////////////////////////////////////////////
|
||||
// implementation of woarchive functions
|
||||
//
|
||||
template<class Archive>
|
||||
BOOST_WARCHIVE_DECL(void)
|
||||
text_woarchive_impl<Archive>::save(const char *s)
|
||||
{
|
||||
// note: superfluous local variable fixes borland warning
|
||||
const std::size_t size = std::strlen(s);
|
||||
* this->This() << size;
|
||||
this->This()->newtoken();
|
||||
while(*s != '\0')
|
||||
os.put(os.widen(*s++));
|
||||
}
|
||||
|
||||
template<class Archive>
|
||||
BOOST_WARCHIVE_DECL(void)
|
||||
text_woarchive_impl<Archive>::save(const std::string &s)
|
||||
{
|
||||
const std::size_t size = s.size();
|
||||
* this->This() << size;
|
||||
this->This()->newtoken();
|
||||
const char * cptr = s.data();
|
||||
for(std::size_t i = size; i-- > 0;)
|
||||
os.put(os.widen(*cptr++));
|
||||
}
|
||||
|
||||
#ifndef BOOST_NO_INTRINSIC_WCHAR_T
|
||||
template<class Archive>
|
||||
BOOST_WARCHIVE_DECL(void)
|
||||
text_woarchive_impl<Archive>::save(const wchar_t *ws)
|
||||
{
|
||||
const std::size_t size = std::wostream::traits_type::length(ws);
|
||||
* this->This() << size;
|
||||
this->This()->newtoken();
|
||||
os.write(ws, size);
|
||||
}
|
||||
#endif
|
||||
|
||||
#ifndef BOOST_NO_STD_WSTRING
|
||||
template<class Archive>
|
||||
BOOST_WARCHIVE_DECL(void)
|
||||
text_woarchive_impl<Archive>::save(const std::wstring &ws)
|
||||
{
|
||||
const std::size_t size = ws.length();
|
||||
* this->This() << size;
|
||||
this->This()->newtoken();
|
||||
os.write(ws.data(), size);
|
||||
}
|
||||
#endif
|
||||
|
||||
} // namespace archive
|
||||
} // namespace boost
|
||||
|
||||
#endif
|
||||
|
||||
|
|
@ -0,0 +1,204 @@
|
|||
/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
|
||||
// xml_iarchive_impl.cpp:
|
||||
|
||||
// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
|
||||
// Distributed under the Boost Software License, Version 1.0. (See
|
||||
// accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
// See http://www.boost.org for updates, documentation, and revision history.
|
||||
|
||||
#include <boost/config.hpp>
|
||||
#include <cstring> // memcpy
|
||||
#include <cstddef> // NULL
|
||||
#if defined(BOOST_NO_STDC_NAMESPACE)
|
||||
namespace std{
|
||||
using ::memcpy;
|
||||
} // namespace std
|
||||
#endif
|
||||
|
||||
#ifndef BOOST_NO_CWCHAR
|
||||
#include <cstdlib> // mbtowc
|
||||
#if defined(BOOST_NO_STDC_NAMESPACE)
|
||||
namespace std{
|
||||
using ::mbtowc;
|
||||
} // namespace std
|
||||
#endif
|
||||
#endif // BOOST_NO_CWCHAR
|
||||
|
||||
#include <boost/detail/workaround.hpp> // RogueWave and Dinkumware
|
||||
#if BOOST_WORKAROUND(BOOST_DINKUMWARE_STDLIB, == 1)
|
||||
#include <boost/archive/dinkumware.hpp>
|
||||
#endif
|
||||
|
||||
#include <boost/detail/no_exceptions_support.hpp>
|
||||
|
||||
#include <boost/archive/xml_archive_exception.hpp>
|
||||
#include <boost/archive/iterators/dataflow_exception.hpp>
|
||||
#include <boost/archive/basic_xml_archive.hpp>
|
||||
#include <boost/archive/xml_iarchive.hpp>
|
||||
|
||||
#include "basic_xml_grammar.hpp"
|
||||
|
||||
namespace boost {
|
||||
namespace archive {
|
||||
|
||||
/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
|
||||
// implemenations of functions specific to char archives
|
||||
|
||||
// wide char stuff used by char archives
|
||||
|
||||
#ifndef BOOST_NO_CWCHAR
|
||||
#ifndef BOOST_NO_STD_WSTRING
|
||||
template<class Archive>
|
||||
BOOST_ARCHIVE_DECL(void)
|
||||
xml_iarchive_impl<Archive>::load(std::wstring &ws){
|
||||
std::string s;
|
||||
bool result = gimpl->parse_string(is, s);
|
||||
if(! result)
|
||||
boost::serialization::throw_exception(
|
||||
xml_archive_exception(xml_archive_exception::xml_archive_parsing_error)
|
||||
);
|
||||
|
||||
#if BOOST_WORKAROUND(_RWSTD_VER, BOOST_TESTED_AT(20101))
|
||||
if(NULL != ws.data())
|
||||
#endif
|
||||
ws.resize(0);
|
||||
const char * start = s.data();
|
||||
const char * end = start + s.size();
|
||||
while(start < end){
|
||||
wchar_t wc;
|
||||
int resultx = std::mbtowc(&wc, start, end - start);
|
||||
if(0 < resultx){
|
||||
start += resultx;
|
||||
ws += wc;
|
||||
continue;
|
||||
}
|
||||
boost::serialization::throw_exception(
|
||||
iterators::dataflow_exception(
|
||||
iterators::dataflow_exception::invalid_conversion
|
||||
)
|
||||
);
|
||||
}
|
||||
}
|
||||
#endif // BOOST_NO_STD_WSTRING
|
||||
|
||||
#ifndef BOOST_NO_INTRINSIC_WCHAR_T
|
||||
template<class Archive>
|
||||
BOOST_ARCHIVE_DECL(void)
|
||||
xml_iarchive_impl<Archive>::load(wchar_t * ws){
|
||||
std::string s;
|
||||
bool result = gimpl->parse_string(is, s);
|
||||
if(! result)
|
||||
boost::serialization::throw_exception(
|
||||
xml_archive_exception(xml_archive_exception::xml_archive_parsing_error)
|
||||
);
|
||||
|
||||
const char * start = s.data();
|
||||
const char * end = start + s.size();
|
||||
while(start < end){
|
||||
wchar_t wc;
|
||||
int result = std::mbtowc(&wc, start, end - start);
|
||||
if(0 < result){
|
||||
start += result;
|
||||
*ws++ = wc;
|
||||
continue;
|
||||
}
|
||||
boost::serialization::throw_exception(
|
||||
iterators::dataflow_exception(
|
||||
iterators::dataflow_exception::invalid_conversion
|
||||
)
|
||||
);
|
||||
}
|
||||
*ws = L'\0';
|
||||
}
|
||||
#endif // BOOST_NO_INTRINSIC_WCHAR_T
|
||||
|
||||
#endif // BOOST_NO_CWCHAR
|
||||
|
||||
template<class Archive>
|
||||
BOOST_ARCHIVE_DECL(void)
|
||||
xml_iarchive_impl<Archive>::load(std::string &s){
|
||||
bool result = gimpl->parse_string(is, s);
|
||||
if(! result)
|
||||
boost::serialization::throw_exception(
|
||||
xml_archive_exception(xml_archive_exception::xml_archive_parsing_error)
|
||||
);
|
||||
}
|
||||
|
||||
template<class Archive>
|
||||
BOOST_ARCHIVE_DECL(void)
|
||||
xml_iarchive_impl<Archive>::load(char * s){
|
||||
std::string tstring;
|
||||
bool result = gimpl->parse_string(is, tstring);
|
||||
if(! result)
|
||||
boost::serialization::throw_exception(
|
||||
xml_archive_exception(xml_archive_exception::xml_archive_parsing_error)
|
||||
);
|
||||
std::memcpy(s, tstring.data(), tstring.size());
|
||||
s[tstring.size()] = 0;
|
||||
}
|
||||
|
||||
template<class Archive>
|
||||
BOOST_ARCHIVE_DECL(void)
|
||||
xml_iarchive_impl<Archive>::load_override(class_name_type & t, int){
|
||||
const std::string & s = gimpl->rv.class_name;
|
||||
if(s.size() > BOOST_SERIALIZATION_MAX_KEY_SIZE - 1)
|
||||
boost::serialization::throw_exception(
|
||||
archive_exception(archive_exception::invalid_class_name)
|
||||
);
|
||||
char * tptr = t;
|
||||
std::memcpy(tptr, s.data(), s.size());
|
||||
tptr[s.size()] = '\0';
|
||||
}
|
||||
|
||||
template<class Archive>
|
||||
BOOST_ARCHIVE_DECL(void)
|
||||
xml_iarchive_impl<Archive>::init(){
|
||||
gimpl->init(is);
|
||||
this->set_library_version(
|
||||
library_version_type(gimpl->rv.version)
|
||||
);
|
||||
}
|
||||
|
||||
template<class Archive>
|
||||
BOOST_ARCHIVE_DECL(BOOST_PP_EMPTY())
|
||||
xml_iarchive_impl<Archive>::xml_iarchive_impl(
|
||||
std::istream &is_,
|
||||
unsigned int flags
|
||||
) :
|
||||
basic_text_iprimitive<std::istream>(
|
||||
is_,
|
||||
0 != (flags & no_codecvt)
|
||||
),
|
||||
basic_xml_iarchive<Archive>(flags),
|
||||
gimpl(new xml_grammar())
|
||||
{
|
||||
if(0 == (flags & no_header)){
|
||||
BOOST_TRY{
|
||||
init();
|
||||
}
|
||||
BOOST_CATCH(...){
|
||||
delete gimpl;
|
||||
#ifndef BOOST_NO_EXCEPTIONS
|
||||
throw; // re-throw
|
||||
#endif
|
||||
}
|
||||
BOOST_CATCH_END
|
||||
}
|
||||
}
|
||||
|
||||
template<class Archive>
|
||||
BOOST_ARCHIVE_DECL(BOOST_PP_EMPTY())
|
||||
xml_iarchive_impl<Archive>::~xml_iarchive_impl(){
|
||||
if(0 == (this->get_flags() & no_header)){
|
||||
BOOST_TRY{
|
||||
gimpl->windup(is);
|
||||
}
|
||||
BOOST_CATCH(...){}
|
||||
BOOST_CATCH_END
|
||||
}
|
||||
delete gimpl;
|
||||
}
|
||||
} // namespace archive
|
||||
} // namespace boost
|
||||
|
|
@ -0,0 +1,117 @@
|
|||
/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
|
||||
// xml_oarchive_impl.ipp:
|
||||
|
||||
// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
|
||||
// Distributed under the Boost Software License, Version 1.0. (See
|
||||
// accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
#include <ostream>
|
||||
#include <iomanip>
|
||||
#include <algorithm>
|
||||
#include <string>
|
||||
|
||||
#include <cstring> // strlen
|
||||
#include <boost/config.hpp> // msvc 6.0 needs this to suppress warnings
|
||||
#if defined(BOOST_NO_STDC_NAMESPACE)
|
||||
namespace std{
|
||||
using ::strlen;
|
||||
} // namespace std
|
||||
#endif
|
||||
|
||||
#include <boost/archive/iterators/xml_escape.hpp>
|
||||
#include <boost/archive/iterators/ostream_iterator.hpp>
|
||||
|
||||
#ifndef BOOST_NO_CWCHAR
|
||||
#include <boost/archive/wcslen.hpp>
|
||||
#include <boost/archive/iterators/mb_from_wchar.hpp>
|
||||
#endif
|
||||
|
||||
namespace boost {
|
||||
namespace archive {
|
||||
|
||||
/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
|
||||
// implemenations of functions specific to char archives
|
||||
|
||||
// wide char stuff used by char archives
|
||||
#ifndef BOOST_NO_CWCHAR
|
||||
// copy chars to output escaping to xml and translating wide chars to mb chars
|
||||
template<class InputIterator>
|
||||
void save_iterator(std::ostream &os, InputIterator begin, InputIterator end){
|
||||
typedef boost::archive::iterators::mb_from_wchar<
|
||||
boost::archive::iterators::xml_escape<InputIterator>
|
||||
> translator;
|
||||
std::copy(
|
||||
translator(BOOST_MAKE_PFTO_WRAPPER(begin)),
|
||||
translator(BOOST_MAKE_PFTO_WRAPPER(end)),
|
||||
boost::archive::iterators::ostream_iterator<char>(os)
|
||||
);
|
||||
}
|
||||
|
||||
#ifndef BOOST_NO_STD_WSTRING
|
||||
template<class Archive>
|
||||
BOOST_ARCHIVE_DECL(void)
|
||||
xml_oarchive_impl<Archive>::save(const std::wstring & ws){
|
||||
// at least one library doesn't typedef value_type for strings
|
||||
// so rather than using string directly make a pointer iterator out of it
|
||||
// save_iterator(os, ws.data(), ws.data() + std::wcslen(ws.data()));
|
||||
save_iterator(os, ws.data(), ws.data() + ws.size());
|
||||
}
|
||||
#endif
|
||||
|
||||
#ifndef BOOST_NO_INTRINSIC_WCHAR_T
|
||||
template<class Archive>
|
||||
BOOST_ARCHIVE_DECL(void)
|
||||
xml_oarchive_impl<Archive>::save(const wchar_t * ws){
|
||||
save_iterator(os, ws, ws + std::wcslen(ws));
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif // BOOST_NO_CWCHAR
|
||||
|
||||
template<class Archive>
|
||||
BOOST_ARCHIVE_DECL(void)
|
||||
xml_oarchive_impl<Archive>::save(const std::string & s){
|
||||
// at least one library doesn't typedef value_type for strings
|
||||
// so rather than using string directly make a pointer iterator out of it
|
||||
typedef boost::archive::iterators::xml_escape<
|
||||
const char *
|
||||
> xml_escape_translator;
|
||||
std::copy(
|
||||
xml_escape_translator(BOOST_MAKE_PFTO_WRAPPER(s.data())),
|
||||
xml_escape_translator(BOOST_MAKE_PFTO_WRAPPER(s.data()+ s.size())),
|
||||
boost::archive::iterators::ostream_iterator<char>(os)
|
||||
);
|
||||
}
|
||||
|
||||
template<class Archive>
|
||||
BOOST_ARCHIVE_DECL(void)
|
||||
xml_oarchive_impl<Archive>::save(const char * s){
|
||||
typedef boost::archive::iterators::xml_escape<
|
||||
const char *
|
||||
> xml_escape_translator;
|
||||
std::copy(
|
||||
xml_escape_translator(BOOST_MAKE_PFTO_WRAPPER(s)),
|
||||
xml_escape_translator(BOOST_MAKE_PFTO_WRAPPER(s + std::strlen(s))),
|
||||
boost::archive::iterators::ostream_iterator<char>(os)
|
||||
);
|
||||
}
|
||||
|
||||
template<class Archive>
|
||||
BOOST_ARCHIVE_DECL(BOOST_PP_EMPTY())
|
||||
xml_oarchive_impl<Archive>::xml_oarchive_impl(
|
||||
std::ostream & os_,
|
||||
unsigned int flags
|
||||
) :
|
||||
basic_text_oprimitive<std::ostream>(
|
||||
os_,
|
||||
0 != (flags & no_codecvt)
|
||||
),
|
||||
basic_xml_oarchive<Archive>(flags)
|
||||
{
|
||||
if(0 == (flags & no_header))
|
||||
this->init();
|
||||
}
|
||||
|
||||
} // namespace archive
|
||||
} // namespace boost
|
||||
|
|
@ -0,0 +1,206 @@
|
|||
/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
|
||||
// xml_wiprimitive.cpp:
|
||||
|
||||
// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
|
||||
// Distributed under the Boost Software License, Version 1.0. (See
|
||||
// accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
// See http://www.boost.org for updates, documentation, and revision history.
|
||||
|
||||
#include <boost/config.hpp> // for BOOST_DEDUCED_TYPENAME
|
||||
|
||||
#include <cstring>
|
||||
#if defined(BOOST_NO_STDC_NAMESPACE)
|
||||
namespace std{
|
||||
using ::memcpy;
|
||||
} //std
|
||||
#endif
|
||||
|
||||
#include <boost/config.hpp> // msvc 6.0 needs this to suppress warnings
|
||||
#ifndef BOOST_NO_STD_WSTREAMBUF
|
||||
|
||||
#include <boost/assert.hpp>
|
||||
#include <algorithm>
|
||||
|
||||
#include <boost/detail/workaround.hpp> // Dinkumware and RogueWave
|
||||
#if BOOST_WORKAROUND(BOOST_DINKUMWARE_STDLIB, == 1)
|
||||
#include <boost/archive/dinkumware.hpp>
|
||||
#endif
|
||||
|
||||
#include <boost/io/ios_state.hpp>
|
||||
#include <boost/detail/no_exceptions_support.hpp>
|
||||
#include <boost/serialization/pfto.hpp>
|
||||
|
||||
#include <boost/serialization/string.hpp>
|
||||
#include <boost/archive/add_facet.hpp>
|
||||
#include <boost/archive/xml_archive_exception.hpp>
|
||||
#include <boost/archive/detail/utf8_codecvt_facet.hpp>
|
||||
|
||||
#include <boost/archive/iterators/mb_from_wchar.hpp>
|
||||
|
||||
#include <boost/archive/basic_xml_archive.hpp>
|
||||
#include <boost/archive/xml_wiarchive.hpp>
|
||||
|
||||
#include "basic_xml_grammar.hpp"
|
||||
|
||||
namespace boost {
|
||||
namespace archive {
|
||||
|
||||
/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
|
||||
// implemenations of functions specific to wide char archives
|
||||
|
||||
namespace { // anonymous
|
||||
|
||||
void copy_to_ptr(char * s, const std::wstring & ws){
|
||||
std::copy(
|
||||
iterators::mb_from_wchar<std::wstring::const_iterator>(
|
||||
BOOST_MAKE_PFTO_WRAPPER(ws.begin())
|
||||
),
|
||||
iterators::mb_from_wchar<std::wstring::const_iterator>(
|
||||
BOOST_MAKE_PFTO_WRAPPER(ws.end())
|
||||
),
|
||||
s
|
||||
);
|
||||
s[ws.size()] = 0;
|
||||
}
|
||||
|
||||
} // anonymous
|
||||
|
||||
template<class Archive>
|
||||
BOOST_WARCHIVE_DECL(void)
|
||||
xml_wiarchive_impl<Archive>::load(std::string & s){
|
||||
std::wstring ws;
|
||||
bool result = gimpl->parse_string(is, ws);
|
||||
if(! result)
|
||||
boost::serialization::throw_exception(
|
||||
xml_archive_exception(xml_archive_exception::xml_archive_parsing_error)
|
||||
);
|
||||
#if BOOST_WORKAROUND(_RWSTD_VER, BOOST_TESTED_AT(20101))
|
||||
if(NULL != s.data())
|
||||
#endif
|
||||
s.resize(0);
|
||||
s.reserve(ws.size());
|
||||
std::copy(
|
||||
iterators::mb_from_wchar<std::wstring::iterator>(
|
||||
BOOST_MAKE_PFTO_WRAPPER(ws.begin())
|
||||
),
|
||||
iterators::mb_from_wchar<std::wstring::iterator>(
|
||||
BOOST_MAKE_PFTO_WRAPPER(ws.end())
|
||||
),
|
||||
std::back_inserter(s)
|
||||
);
|
||||
}
|
||||
|
||||
#ifndef BOOST_NO_STD_WSTRING
|
||||
template<class Archive>
|
||||
BOOST_WARCHIVE_DECL(void)
|
||||
xml_wiarchive_impl<Archive>::load(std::wstring & ws){
|
||||
bool result = gimpl->parse_string(is, ws);
|
||||
if(! result)
|
||||
boost::serialization::throw_exception(
|
||||
xml_archive_exception(xml_archive_exception::xml_archive_parsing_error)
|
||||
);
|
||||
}
|
||||
#endif
|
||||
|
||||
template<class Archive>
|
||||
BOOST_WARCHIVE_DECL(void)
|
||||
xml_wiarchive_impl<Archive>::load(char * s){
|
||||
std::wstring ws;
|
||||
bool result = gimpl->parse_string(is, ws);
|
||||
if(! result)
|
||||
boost::serialization::throw_exception(
|
||||
xml_archive_exception(xml_archive_exception::xml_archive_parsing_error)
|
||||
);
|
||||
copy_to_ptr(s, ws);
|
||||
}
|
||||
|
||||
#ifndef BOOST_NO_INTRINSIC_WCHAR_T
|
||||
template<class Archive>
|
||||
BOOST_WARCHIVE_DECL(void)
|
||||
xml_wiarchive_impl<Archive>::load(wchar_t * ws){
|
||||
std::wstring twstring;
|
||||
bool result = gimpl->parse_string(is, twstring);
|
||||
if(! result)
|
||||
boost::serialization::throw_exception(
|
||||
xml_archive_exception(xml_archive_exception::xml_archive_parsing_error)
|
||||
);
|
||||
std::memcpy(ws, twstring.c_str(), twstring.size());
|
||||
ws[twstring.size()] = L'\0';
|
||||
}
|
||||
#endif
|
||||
|
||||
template<class Archive>
|
||||
BOOST_WARCHIVE_DECL(void)
|
||||
xml_wiarchive_impl<Archive>::load_override(class_name_type & t, int){
|
||||
const std::wstring & ws = gimpl->rv.class_name;
|
||||
if(ws.size() > BOOST_SERIALIZATION_MAX_KEY_SIZE - 1)
|
||||
boost::serialization::throw_exception(
|
||||
archive_exception(archive_exception::invalid_class_name)
|
||||
);
|
||||
copy_to_ptr(t, ws);
|
||||
}
|
||||
|
||||
template<class Archive>
|
||||
BOOST_WARCHIVE_DECL(void)
|
||||
xml_wiarchive_impl<Archive>::init(){
|
||||
gimpl->init(is);
|
||||
this->set_library_version(
|
||||
library_version_type(gimpl->rv.version)
|
||||
);
|
||||
}
|
||||
|
||||
template<class Archive>
|
||||
BOOST_WARCHIVE_DECL(BOOST_PP_EMPTY())
|
||||
xml_wiarchive_impl<Archive>::xml_wiarchive_impl(
|
||||
std::wistream &is_,
|
||||
unsigned int flags
|
||||
) :
|
||||
basic_text_iprimitive<std::wistream>(
|
||||
is_,
|
||||
true // don't change the codecvt - use the one below
|
||||
),
|
||||
basic_xml_iarchive<Archive>(flags),
|
||||
gimpl(new xml_wgrammar())
|
||||
{
|
||||
if(0 == (flags & no_codecvt)){
|
||||
archive_locale.reset(
|
||||
add_facet(
|
||||
std::locale::classic(),
|
||||
new boost::archive::detail::utf8_codecvt_facet
|
||||
)
|
||||
);
|
||||
is.imbue(* archive_locale);
|
||||
}
|
||||
if(0 == (flags & no_header)){
|
||||
BOOST_TRY{
|
||||
this->init();
|
||||
}
|
||||
BOOST_CATCH(...){
|
||||
delete gimpl;
|
||||
#ifndef BOOST_NO_EXCEPTIONS
|
||||
throw; // re-throw
|
||||
#endif
|
||||
}
|
||||
BOOST_CATCH_END
|
||||
}
|
||||
}
|
||||
|
||||
template<class Archive>
|
||||
BOOST_WARCHIVE_DECL(BOOST_PP_EMPTY())
|
||||
xml_wiarchive_impl<Archive>::~xml_wiarchive_impl(){
|
||||
if(0 == (this->get_flags() & no_header)){
|
||||
BOOST_TRY{
|
||||
gimpl->windup(is);
|
||||
}
|
||||
BOOST_CATCH(...){}
|
||||
BOOST_CATCH_END
|
||||
}
|
||||
delete gimpl;
|
||||
}
|
||||
|
||||
} // namespace archive
|
||||
} // namespace boost
|
||||
|
||||
#endif // BOOST_NO_STD_WSTREAMBUF
|
||||
|
|
@ -0,0 +1,160 @@
|
|||
/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
|
||||
// xml_woarchive_impl.ipp:
|
||||
|
||||
// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
|
||||
// Distributed under the Boost Software License, Version 1.0. (See
|
||||
// accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
#include <boost/config.hpp>
|
||||
#ifndef BOOST_NO_STD_WSTREAMBUF
|
||||
|
||||
#include <ostream>
|
||||
#include <string>
|
||||
#include <algorithm>
|
||||
#include <locale>
|
||||
|
||||
#include <boost/config.hpp> // msvc 6.0 needs this to suppress warnings
|
||||
// for BOOST_DEDUCED_TYPENAME
|
||||
#include <cstring> // strlen
|
||||
#include <cstdlib> // mbtowc
|
||||
#include <cwchar> // wcslen
|
||||
|
||||
#if defined(BOOST_NO_STDC_NAMESPACE)
|
||||
namespace std{
|
||||
using ::strlen;
|
||||
#if ! defined(BOOST_NO_INTRINSIC_WCHAR_T)
|
||||
using ::mbtowc;
|
||||
using ::wcslen;
|
||||
#endif
|
||||
} // namespace std
|
||||
#endif
|
||||
|
||||
#include <boost/serialization/throw_exception.hpp>
|
||||
#include <boost/serialization/pfto.hpp>
|
||||
|
||||
#include <boost/archive/iterators/xml_escape.hpp>
|
||||
#include <boost/archive/iterators/wchar_from_mb.hpp>
|
||||
#include <boost/archive/iterators/ostream_iterator.hpp>
|
||||
#include <boost/archive/iterators/dataflow_exception.hpp>
|
||||
|
||||
#include <boost/archive/add_facet.hpp>
|
||||
#include <boost/archive/detail/utf8_codecvt_facet.hpp>
|
||||
|
||||
namespace boost {
|
||||
namespace archive {
|
||||
|
||||
/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
|
||||
// implemenations of functions specific to wide char archives
|
||||
|
||||
// copy chars to output escaping to xml and widening characters as we go
|
||||
template<class InputIterator>
|
||||
void save_iterator(std::wostream &os, InputIterator begin, InputIterator end){
|
||||
typedef iterators::wchar_from_mb<
|
||||
iterators::xml_escape<InputIterator>
|
||||
> xmbtows;
|
||||
std::copy(
|
||||
xmbtows(BOOST_MAKE_PFTO_WRAPPER(begin)),
|
||||
xmbtows(BOOST_MAKE_PFTO_WRAPPER(end)),
|
||||
boost::archive::iterators::ostream_iterator<wchar_t>(os)
|
||||
);
|
||||
}
|
||||
|
||||
template<class Archive>
|
||||
BOOST_WARCHIVE_DECL(void)
|
||||
xml_woarchive_impl<Archive>::save(const std::string & s){
|
||||
// note: we don't use s.begin() and s.end() because dinkumware
|
||||
// doesn't have string::value_type defined. So use a wrapper
|
||||
// around these values to implement the definitions.
|
||||
const char * begin = s.data();
|
||||
const char * end = begin + s.size();
|
||||
save_iterator(os, begin, end);
|
||||
}
|
||||
|
||||
#ifndef BOOST_NO_STD_WSTRING
|
||||
template<class Archive>
|
||||
BOOST_WARCHIVE_DECL(void)
|
||||
xml_woarchive_impl<Archive>::save(const std::wstring & ws){
|
||||
#if 0
|
||||
typedef iterators::xml_escape<std::wstring::const_iterator> xmbtows;
|
||||
std::copy(
|
||||
xmbtows(BOOST_MAKE_PFTO_WRAPPER(ws.begin())),
|
||||
xmbtows(BOOST_MAKE_PFTO_WRAPPER(ws.end())),
|
||||
boost::archive::iterators::ostream_iterator<wchar_t>(os)
|
||||
);
|
||||
#endif
|
||||
typedef iterators::xml_escape<const wchar_t *> xmbtows;
|
||||
std::copy(
|
||||
xmbtows(BOOST_MAKE_PFTO_WRAPPER(ws.data())),
|
||||
xmbtows(BOOST_MAKE_PFTO_WRAPPER(ws.data() + ws.size())),
|
||||
boost::archive::iterators::ostream_iterator<wchar_t>(os)
|
||||
);
|
||||
}
|
||||
#endif //BOOST_NO_STD_WSTRING
|
||||
|
||||
template<class Archive>
|
||||
BOOST_WARCHIVE_DECL(void)
|
||||
xml_woarchive_impl<Archive>::save(const char * s){
|
||||
save_iterator(os, s, s + std::strlen(s));
|
||||
}
|
||||
|
||||
#ifndef BOOST_NO_INTRINSIC_WCHAR_T
|
||||
template<class Archive>
|
||||
BOOST_WARCHIVE_DECL(void)
|
||||
xml_woarchive_impl<Archive>::save(const wchar_t * ws){
|
||||
os << ws;
|
||||
typedef iterators::xml_escape<const wchar_t *> xmbtows;
|
||||
std::copy(
|
||||
xmbtows(BOOST_MAKE_PFTO_WRAPPER(ws)),
|
||||
xmbtows(BOOST_MAKE_PFTO_WRAPPER(ws + std::wcslen(ws))),
|
||||
boost::archive::iterators::ostream_iterator<wchar_t>(os)
|
||||
);
|
||||
}
|
||||
#endif
|
||||
|
||||
template<class Archive>
|
||||
BOOST_WARCHIVE_DECL(BOOST_PP_EMPTY())
|
||||
xml_woarchive_impl<Archive>::xml_woarchive_impl(
|
||||
std::wostream & os_,
|
||||
unsigned int flags
|
||||
) :
|
||||
basic_text_oprimitive<std::wostream>(
|
||||
os_,
|
||||
true // don't change the codecvt - use the one below
|
||||
),
|
||||
basic_xml_oarchive<Archive>(flags)
|
||||
{
|
||||
// Standard behavior is that imbue can be called
|
||||
// a) before output is invoked or
|
||||
// b) after flush has been called. This prevents one-to-many
|
||||
// transforms (such as one to many transforms from getting
|
||||
// mixed up. Unfortunately, STLPort doesn't respect b) above
|
||||
// so the restoration of the original archive locale done by
|
||||
// the locale_saver doesn't get processed,
|
||||
// before the current one is destroyed.
|
||||
// so the codecvt doesn't get replaced with the orginal
|
||||
// so closing the stream invokes codecvt::do_unshift
|
||||
// so it crashes because the corresponding locale that contained
|
||||
// the codecvt isn't around any more.
|
||||
// we can hack around this by using a static codecvt that never
|
||||
// gets destroyed.
|
||||
if(0 == (flags & no_codecvt)){
|
||||
boost::archive::detail::utf8_codecvt_facet *pfacet;
|
||||
#if defined(__SGI_STL_PORT)
|
||||
static boost::archive::detail::utf8_codecvt_facet
|
||||
facet(static_cast<size_t>(1));
|
||||
pfacet = & facet;
|
||||
#else
|
||||
pfacet = new boost::archive::detail::utf8_codecvt_facet;
|
||||
#endif
|
||||
archive_locale.reset(add_facet(std::locale::classic(), pfacet));
|
||||
os.imbue(* archive_locale);
|
||||
}
|
||||
if(0 == (flags & no_header))
|
||||
this->init();
|
||||
}
|
||||
|
||||
} // namespace archive
|
||||
} // namespace boost
|
||||
|
||||
#endif //BOOST_NO_STD_WSTREAMBUF
|
||||
|
|
@ -0,0 +1,68 @@
|
|||
#ifndef BOOST_ARCHIVE_ITERATORS_BASE64_EXCEPTION_HPP
|
||||
#define BOOST_ARCHIVE_ITERATORS_BASE64_EXCEPTION_HPP
|
||||
|
||||
// MS compatible compilers support #pragma once
|
||||
#if defined(_MSC_VER) && (_MSC_VER >= 1020)
|
||||
# pragma once
|
||||
#endif
|
||||
|
||||
/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
|
||||
// base64_exception.hpp:
|
||||
|
||||
// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
|
||||
// Use, modification and distribution is subject to the Boost Software
|
||||
// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
// See http://www.boost.org for updates, documentation, and revision history.
|
||||
|
||||
#include <boost/config.hpp>
|
||||
#ifndef BOOST_NO_EXCEPTIONS
|
||||
#include <exception>
|
||||
|
||||
#include <boost/assert.hpp>
|
||||
|
||||
namespace boost {
|
||||
namespace archive {
|
||||
namespace iterators {
|
||||
|
||||
//////////////////////////////////////////////////////////////////////
|
||||
// exceptions thrown by base64s
|
||||
//
|
||||
class base64_exception : public std::exception
|
||||
{
|
||||
public:
|
||||
typedef enum {
|
||||
invalid_code, // attempt to encode a value > 6 bits
|
||||
invalid_character, // decode a value not in base64 char set
|
||||
other_exception
|
||||
} exception_code;
|
||||
exception_code code;
|
||||
|
||||
base64_exception(exception_code c = other_exception) : code(c)
|
||||
{}
|
||||
|
||||
virtual const char *what( ) const throw( )
|
||||
{
|
||||
const char *msg = "unknown exception code";
|
||||
switch(code){
|
||||
case invalid_code:
|
||||
msg = "attempt to encode a value > 6 bits";
|
||||
break;
|
||||
case invalid_character:
|
||||
msg = "attempt to decode a value not in base64 char set";
|
||||
break;
|
||||
default:
|
||||
BOOST_ASSERT(false);
|
||||
break;
|
||||
}
|
||||
return msg;
|
||||
}
|
||||
};
|
||||
|
||||
} // namespace iterators
|
||||
} // namespace archive
|
||||
} // namespace boost
|
||||
|
||||
#endif //BOOST_NO_EXCEPTIONS
|
||||
#endif //BOOST_ARCHIVE_ITERATORS_ARCHIVE_EXCEPTION_HPP
|
||||
|
|
@ -0,0 +1,112 @@
|
|||
#ifndef BOOST_ARCHIVE_ITERATORS_BASE64_FROM_BINARY_HPP
|
||||
#define BOOST_ARCHIVE_ITERATORS_BASE64_FROM_BINARY_HPP
|
||||
|
||||
// MS compatible compilers support #pragma once
|
||||
#if defined(_MSC_VER) && (_MSC_VER >= 1020)
|
||||
# pragma once
|
||||
#endif
|
||||
|
||||
/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
|
||||
// base64_from_binary.hpp
|
||||
|
||||
// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
|
||||
// Use, modification and distribution is subject to the Boost Software
|
||||
// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
// See http://www.boost.org for updates, documentation, and revision history.
|
||||
|
||||
#include <boost/assert.hpp>
|
||||
|
||||
#include <cstddef> // size_t
|
||||
#include <boost/config.hpp> // for BOOST_DEDUCED_TYPENAME
|
||||
#if defined(BOOST_NO_STDC_NAMESPACE)
|
||||
namespace std{
|
||||
using ::size_t;
|
||||
} // namespace std
|
||||
#endif
|
||||
|
||||
#include <boost/serialization/pfto.hpp>
|
||||
|
||||
#include <boost/iterator/transform_iterator.hpp>
|
||||
#include <boost/archive/iterators/dataflow_exception.hpp>
|
||||
|
||||
namespace boost {
|
||||
namespace archive {
|
||||
namespace iterators {
|
||||
|
||||
/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
|
||||
// convert binary integers to base64 characters
|
||||
|
||||
namespace detail {
|
||||
|
||||
template<class CharType>
|
||||
struct from_6_bit {
|
||||
typedef CharType result_type;
|
||||
CharType operator()(CharType t) const{
|
||||
const char * lookup_table =
|
||||
"ABCDEFGHIJKLMNOPQRSTUVWXYZ"
|
||||
"abcdefghijklmnopqrstuvwxyz"
|
||||
"0123456789"
|
||||
"+/";
|
||||
BOOST_ASSERT(t < 64);
|
||||
return lookup_table[static_cast<size_t>(t)];
|
||||
}
|
||||
};
|
||||
|
||||
} // namespace detail
|
||||
|
||||
// note: what we would like to do is
|
||||
// template<class Base, class CharType = BOOST_DEDUCED_TYPENAME Base::value_type>
|
||||
// typedef transform_iterator<
|
||||
// from_6_bit<CharType>,
|
||||
// transform_width<Base, 6, sizeof(Base::value_type) * 8, CharType>
|
||||
// > base64_from_binary;
|
||||
// but C++ won't accept this. Rather than using a "type generator" and
|
||||
// using a different syntax, make a derivation which should be equivalent.
|
||||
//
|
||||
// Another issue addressed here is that the transform_iterator doesn't have
|
||||
// a templated constructor. This makes it incompatible with the dataflow
|
||||
// ideal. This is also addressed here.
|
||||
|
||||
//template<class Base, class CharType = BOOST_DEDUCED_TYPENAME Base::value_type>
|
||||
template<
|
||||
class Base,
|
||||
class CharType = BOOST_DEDUCED_TYPENAME boost::iterator_value<Base>::type
|
||||
>
|
||||
class base64_from_binary :
|
||||
public transform_iterator<
|
||||
detail::from_6_bit<CharType>,
|
||||
Base
|
||||
>
|
||||
{
|
||||
friend class boost::iterator_core_access;
|
||||
typedef transform_iterator<
|
||||
BOOST_DEDUCED_TYPENAME detail::from_6_bit<CharType>,
|
||||
Base
|
||||
> super_t;
|
||||
|
||||
public:
|
||||
// make composible buy using templated constructor
|
||||
template<class T>
|
||||
base64_from_binary(BOOST_PFTO_WRAPPER(T) start) :
|
||||
super_t(
|
||||
Base(BOOST_MAKE_PFTO_WRAPPER(static_cast< T >(start))),
|
||||
detail::from_6_bit<CharType>()
|
||||
)
|
||||
{}
|
||||
// intel 7.1 doesn't like default copy constructor
|
||||
base64_from_binary(const base64_from_binary & rhs) :
|
||||
super_t(
|
||||
Base(rhs.base_reference()),
|
||||
detail::from_6_bit<CharType>()
|
||||
)
|
||||
{}
|
||||
// base64_from_binary(){};
|
||||
};
|
||||
|
||||
} // namespace iterators
|
||||
} // namespace archive
|
||||
} // namespace boost
|
||||
|
||||
#endif // BOOST_ARCHIVE_ITERATORS_BASE64_FROM_BINARY_HPP
|
||||
|
|
@ -0,0 +1,120 @@
|
|||
#ifndef BOOST_ARCHIVE_ITERATORS_BINARY_FROM_BASE64_HPP
|
||||
#define BOOST_ARCHIVE_ITERATORS_BINARY_FROM_BASE64_HPP
|
||||
|
||||
// MS compatible compilers support #pragma once
|
||||
#if defined(_MSC_VER) && (_MSC_VER >= 1020)
|
||||
# pragma once
|
||||
#endif
|
||||
|
||||
/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
|
||||
// binary_from_base64.hpp
|
||||
|
||||
// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
|
||||
// Use, modification and distribution is subject to the Boost Software
|
||||
// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
// See http://www.boost.org for updates, documentation, and revision history.
|
||||
|
||||
#include <boost/assert.hpp>
|
||||
|
||||
#include <boost/config.hpp> // for BOOST_DEDUCED_TYPENAME
|
||||
#include <boost/serialization/throw_exception.hpp>
|
||||
#include <boost/serialization/pfto.hpp>
|
||||
#include <boost/static_assert.hpp>
|
||||
|
||||
#include <boost/iterator/transform_iterator.hpp>
|
||||
#include <boost/archive/iterators/dataflow_exception.hpp>
|
||||
|
||||
namespace boost {
|
||||
namespace archive {
|
||||
namespace iterators {
|
||||
|
||||
/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
|
||||
// convert base64 characters to binary data
|
||||
|
||||
namespace detail {
|
||||
|
||||
template<class CharType>
|
||||
struct to_6_bit {
|
||||
typedef CharType result_type;
|
||||
CharType operator()(CharType t) const{
|
||||
const signed char lookup_table[] = {
|
||||
-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
|
||||
-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
|
||||
-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,62,-1,-1,-1,63,
|
||||
52,53,54,55,56,57,58,59,60,61,-1,-1,-1,-1,-1,-1,
|
||||
-1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9,10,11,12,13,14,
|
||||
15,16,17,18,19,20,21,22,23,24,25,-1,-1,-1,-1,-1,
|
||||
-1,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,
|
||||
41,42,43,44,45,46,47,48,49,50,51,-1,-1,-1,-1,-1
|
||||
};
|
||||
// metrowerks trips this assertion - how come?
|
||||
#if ! defined(__MWERKS__)
|
||||
BOOST_STATIC_ASSERT(128 == sizeof(lookup_table));
|
||||
#endif
|
||||
signed char value = -1;
|
||||
if((unsigned)t <= 127)
|
||||
value = lookup_table[(unsigned)t];
|
||||
if(-1 == value)
|
||||
boost::serialization::throw_exception(
|
||||
dataflow_exception(dataflow_exception::invalid_base64_character)
|
||||
);
|
||||
return value;
|
||||
}
|
||||
};
|
||||
|
||||
} // namespace detail
|
||||
|
||||
// note: what we would like to do is
|
||||
// template<class Base, class CharType = BOOST_DEDUCED_TYPENAME Base::value_type>
|
||||
// typedef transform_iterator<
|
||||
// from_6_bit<CharType>,
|
||||
// transform_width<Base, 6, sizeof(Base::value_type) * 8, CharType>
|
||||
// > base64_from_binary;
|
||||
// but C++ won't accept this. Rather than using a "type generator" and
|
||||
// using a different syntax, make a derivation which should be equivalent.
|
||||
//
|
||||
// Another issue addressed here is that the transform_iterator doesn't have
|
||||
// a templated constructor. This makes it incompatible with the dataflow
|
||||
// ideal. This is also addressed here.
|
||||
|
||||
template<
|
||||
class Base,
|
||||
class CharType = BOOST_DEDUCED_TYPENAME boost::iterator_value<Base>::type
|
||||
>
|
||||
class binary_from_base64 : public
|
||||
transform_iterator<
|
||||
detail::to_6_bit<CharType>,
|
||||
Base
|
||||
>
|
||||
{
|
||||
friend class boost::iterator_core_access;
|
||||
typedef transform_iterator<
|
||||
detail::to_6_bit<CharType>,
|
||||
Base
|
||||
> super_t;
|
||||
public:
|
||||
// make composible buy using templated constructor
|
||||
template<class T>
|
||||
binary_from_base64(BOOST_PFTO_WRAPPER(T) start) :
|
||||
super_t(
|
||||
Base(BOOST_MAKE_PFTO_WRAPPER(static_cast< T >(start))),
|
||||
detail::to_6_bit<CharType>()
|
||||
)
|
||||
{}
|
||||
// intel 7.1 doesn't like default copy constructor
|
||||
binary_from_base64(const binary_from_base64 & rhs) :
|
||||
super_t(
|
||||
Base(rhs.base_reference()),
|
||||
detail::to_6_bit<CharType>()
|
||||
)
|
||||
{}
|
||||
// binary_from_base64(){};
|
||||
};
|
||||
|
||||
} // namespace iterators
|
||||
} // namespace archive
|
||||
} // namespace boost
|
||||
|
||||
#endif // BOOST_ARCHIVE_ITERATORS_BINARY_FROM_BASE64_HPP
|
||||
|
|
@ -0,0 +1,105 @@
|
|||
#ifndef BOOST_ARCHIVE_ITERATORS_DATAFLOW_HPP
|
||||
#define BOOST_ARCHIVE_ITERATORS_DATAFLOW_HPP
|
||||
|
||||
// MS compatible compilers support #pragma once
|
||||
#if defined(_MSC_VER) && (_MSC_VER >= 1020)
|
||||
# pragma once
|
||||
#endif
|
||||
|
||||
/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
|
||||
// dataflow.hpp
|
||||
|
||||
// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
|
||||
// Use, modification and distribution is subject to the Boost Software
|
||||
// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
// See http://www.boost.org for updates, documentation, and revision history.
|
||||
|
||||
#include <boost/assert.hpp>
|
||||
|
||||
#include <boost/config.hpp> // for BOOST_DEDUCED_TYPENAME
|
||||
|
||||
#include <boost/mpl/eval_if.hpp>
|
||||
#include <boost/mpl/if.hpp>
|
||||
#include <boost/mpl/bool.hpp>
|
||||
#include <boost/mpl/apply.hpp>
|
||||
#include <boost/mpl/plus.hpp>
|
||||
#include <boost/mpl/int.hpp>
|
||||
|
||||
#include <boost/type_traits/is_convertible.hpp>
|
||||
#include <boost/type_traits/is_base_and_derived.hpp>
|
||||
#include <boost/type_traits/is_pointer.hpp>
|
||||
#include <boost/iterator/iterator_adaptor.hpp>
|
||||
#include <boost/iterator/iterator_traits.hpp>
|
||||
#include <boost/static_assert.hpp>
|
||||
|
||||
namespace boost {
|
||||
namespace archive {
|
||||
namespace iterators {
|
||||
|
||||
// poor man's tri-state
|
||||
struct tri_state {
|
||||
enum state_enum {
|
||||
is_false = false,
|
||||
is_true = true,
|
||||
is_indeterminant
|
||||
} m_state;
|
||||
// convert to bool
|
||||
operator bool (){
|
||||
BOOST_ASSERT(is_indeterminant != m_state);
|
||||
return is_true == m_state ? true : false;
|
||||
}
|
||||
// assign from bool
|
||||
tri_state & operator=(bool rhs) {
|
||||
m_state = rhs ? is_true : is_false;
|
||||
return *this;
|
||||
}
|
||||
tri_state(bool rhs) :
|
||||
m_state(rhs ? is_true : is_false)
|
||||
{}
|
||||
tri_state(state_enum state) :
|
||||
m_state(state)
|
||||
{}
|
||||
bool operator==(const tri_state & rhs) const {
|
||||
return m_state == rhs.m_state;
|
||||
}
|
||||
bool operator!=(const tri_state & rhs) const {
|
||||
return m_state != rhs.m_state;
|
||||
}
|
||||
};
|
||||
|
||||
/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
|
||||
// implement functions common to dataflow iterators
|
||||
template<class Derived>
|
||||
class dataflow {
|
||||
bool m_eoi;
|
||||
protected:
|
||||
// test for iterator equality
|
||||
tri_state equal(const Derived & rhs) const {
|
||||
if(m_eoi && rhs.m_eoi)
|
||||
return true;
|
||||
if(m_eoi || rhs.m_eoi)
|
||||
return false;
|
||||
return tri_state(tri_state::is_indeterminant);
|
||||
}
|
||||
void eoi(bool tf){
|
||||
m_eoi = tf;
|
||||
}
|
||||
bool eoi() const {
|
||||
return m_eoi;
|
||||
}
|
||||
public:
|
||||
dataflow(bool tf) :
|
||||
m_eoi(tf)
|
||||
{}
|
||||
dataflow() : // used for iterator end
|
||||
m_eoi(true)
|
||||
{}
|
||||
};
|
||||
|
||||
} // namespace iterators
|
||||
} // namespace archive
|
||||
} // namespace boost
|
||||
|
||||
#endif // BOOST_ARCHIVE_ITERATORS_DATAFLOW_HPP
|
||||
|
|
@ -0,0 +1,80 @@
|
|||
#ifndef BOOST_ARCHIVE_ITERATORS_DATAFLOW_EXCEPTION_HPP
|
||||
#define BOOST_ARCHIVE_ITERATORS_DATAFLOW_EXCEPTION_HPP
|
||||
|
||||
// MS compatible compilers support #pragma once
|
||||
#if defined(_MSC_VER) && (_MSC_VER >= 1020)
|
||||
# pragma once
|
||||
#endif
|
||||
|
||||
/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
|
||||
// dataflow_exception.hpp:
|
||||
|
||||
// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
|
||||
// Use, modification and distribution is subject to the Boost Software
|
||||
// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
// See http://www.boost.org for updates, documentation, and revision history.
|
||||
|
||||
#include <boost/config.hpp>
|
||||
#ifndef BOOST_NO_EXCEPTIONS
|
||||
#include <exception>
|
||||
#endif //BOOST_NO_EXCEPTIONS
|
||||
|
||||
#include <boost/assert.hpp>
|
||||
|
||||
namespace boost {
|
||||
namespace archive {
|
||||
namespace iterators {
|
||||
|
||||
//////////////////////////////////////////////////////////////////////
|
||||
// exceptions thrown by dataflows
|
||||
//
|
||||
class dataflow_exception : public std::exception
|
||||
{
|
||||
public:
|
||||
typedef enum {
|
||||
invalid_6_bitcode,
|
||||
invalid_base64_character,
|
||||
invalid_xml_escape_sequence,
|
||||
comparison_not_permitted,
|
||||
invalid_conversion,
|
||||
other_exception
|
||||
} exception_code;
|
||||
exception_code code;
|
||||
|
||||
dataflow_exception(exception_code c = other_exception) : code(c)
|
||||
{}
|
||||
|
||||
virtual const char *what( ) const throw( )
|
||||
{
|
||||
const char *msg = "unknown exception code";
|
||||
switch(code){
|
||||
case invalid_6_bitcode:
|
||||
msg = "attempt to encode a value > 6 bits";
|
||||
break;
|
||||
case invalid_base64_character:
|
||||
msg = "attempt to decode a value not in base64 char set";
|
||||
break;
|
||||
case invalid_xml_escape_sequence:
|
||||
msg = "invalid xml escape_sequence";
|
||||
break;
|
||||
case comparison_not_permitted:
|
||||
msg = "cannot invoke iterator comparison now";
|
||||
break;
|
||||
case invalid_conversion:
|
||||
msg = "invalid multbyte/wide char conversion";
|
||||
break;
|
||||
default:
|
||||
BOOST_ASSERT(false);
|
||||
break;
|
||||
}
|
||||
return msg;
|
||||
}
|
||||
};
|
||||
|
||||
} // namespace iterators
|
||||
} // namespace archive
|
||||
} // namespace boost
|
||||
|
||||
#endif //BOOST_ARCHIVE_ITERATORS_DATAFLOW_EXCEPTION_HPP
|
||||
|
|
@ -0,0 +1,115 @@
|
|||
#ifndef BOOST_ARCHIVE_ITERATORS_ESCAPE_HPP
|
||||
#define BOOST_ARCHIVE_ITERATORS_ESCAPE_HPP
|
||||
|
||||
// MS compatible compilers support #pragma once
|
||||
#if defined(_MSC_VER) && (_MSC_VER >= 1020)
|
||||
# pragma once
|
||||
#endif
|
||||
|
||||
/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
|
||||
// escape.hpp
|
||||
|
||||
// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
|
||||
// Use, modification and distribution is subject to the Boost Software
|
||||
// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
// See http://www.boost.org for updates, documentation, and revision history.
|
||||
|
||||
#include <boost/assert.hpp>
|
||||
#include <cstddef> // NULL
|
||||
|
||||
#include <boost/config.hpp> // for BOOST_DEDUCED_TYPENAME
|
||||
#include <boost/iterator/iterator_adaptor.hpp>
|
||||
#include <boost/iterator/iterator_traits.hpp>
|
||||
|
||||
namespace boost {
|
||||
namespace archive {
|
||||
namespace iterators {
|
||||
|
||||
/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
|
||||
// insert escapes into text
|
||||
|
||||
template<class Derived, class Base>
|
||||
class escape :
|
||||
public boost::iterator_adaptor<
|
||||
Derived,
|
||||
Base,
|
||||
BOOST_DEDUCED_TYPENAME boost::iterator_value<Base>::type,
|
||||
single_pass_traversal_tag,
|
||||
BOOST_DEDUCED_TYPENAME boost::iterator_value<Base>::type
|
||||
>
|
||||
{
|
||||
typedef BOOST_DEDUCED_TYPENAME boost::iterator_value<Base>::type base_value_type;
|
||||
typedef BOOST_DEDUCED_TYPENAME boost::iterator_reference<Base>::type reference_type;
|
||||
friend class boost::iterator_core_access;
|
||||
|
||||
typedef BOOST_DEDUCED_TYPENAME boost::iterator_adaptor<
|
||||
Derived,
|
||||
Base,
|
||||
base_value_type,
|
||||
single_pass_traversal_tag,
|
||||
base_value_type
|
||||
> super_t;
|
||||
|
||||
typedef escape<Derived, Base> this_t;
|
||||
|
||||
void dereference_impl() {
|
||||
m_current_value = static_cast<Derived *>(this)->fill(m_bnext, m_bend);
|
||||
m_full = true;
|
||||
}
|
||||
|
||||
//Access the value referred to
|
||||
reference_type dereference() const {
|
||||
if(!m_full)
|
||||
const_cast<this_t *>(this)->dereference_impl();
|
||||
return m_current_value;
|
||||
}
|
||||
|
||||
bool equal(const this_t & rhs) const {
|
||||
if(m_full){
|
||||
if(! rhs.m_full)
|
||||
const_cast<this_t *>(& rhs)->dereference_impl();
|
||||
}
|
||||
else{
|
||||
if(rhs.m_full)
|
||||
const_cast<this_t *>(this)->dereference_impl();
|
||||
}
|
||||
if(m_bnext != rhs.m_bnext)
|
||||
return false;
|
||||
if(this->base_reference() != rhs.base_reference())
|
||||
return false;
|
||||
return true;
|
||||
}
|
||||
|
||||
void increment(){
|
||||
if(++m_bnext < m_bend){
|
||||
m_current_value = *m_bnext;
|
||||
return;
|
||||
}
|
||||
++(this->base_reference());
|
||||
m_bnext = NULL;
|
||||
m_bend = NULL;
|
||||
m_full = false;
|
||||
}
|
||||
|
||||
// buffer to handle pending characters
|
||||
const base_value_type *m_bnext;
|
||||
const base_value_type *m_bend;
|
||||
bool m_full;
|
||||
base_value_type m_current_value;
|
||||
public:
|
||||
escape(Base base) :
|
||||
super_t(base),
|
||||
m_bnext(NULL),
|
||||
m_bend(NULL),
|
||||
m_full(false)
|
||||
{
|
||||
}
|
||||
};
|
||||
|
||||
} // namespace iterators
|
||||
} // namespace archive
|
||||
} // namespace boost
|
||||
|
||||
#endif // BOOST_ARCHIVE_ITERATORS_ESCAPE_HPP
|
||||
|
|
@ -0,0 +1,80 @@
|
|||
#ifndef BOOST_ARCHIVE_ITERATORS_HEAD_ITERATOR_HPP
|
||||
#define BOOST_ARCHIVE_ITERATORS_HEAD_ITERATOR_HPP
|
||||
|
||||
// MS compatible compilers support #pragma once
|
||||
#if defined(_MSC_VER) && (_MSC_VER >= 1020)
|
||||
# pragma once
|
||||
#endif
|
||||
|
||||
/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
|
||||
// head_iterator.hpp
|
||||
|
||||
// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
|
||||
// Use, modification and distribution is subject to the Boost Software
|
||||
// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
// See http://www.boost.org for updates, documentation, and revision history.
|
||||
|
||||
#include <boost/iterator/iterator_adaptor.hpp>
|
||||
#include <boost/iterator/iterator_traits.hpp>
|
||||
|
||||
namespace boost {
|
||||
namespace archive {
|
||||
namespace iterators {
|
||||
|
||||
template<class Predicate, class Base>
|
||||
class head_iterator
|
||||
: public boost::iterator_adaptor<
|
||||
head_iterator<Predicate, Base>,
|
||||
Base,
|
||||
use_default,
|
||||
single_pass_traversal_tag
|
||||
>
|
||||
{
|
||||
private:
|
||||
friend class iterator_core_access;
|
||||
typedef boost::iterator_adaptor<
|
||||
head_iterator<Predicate, Base>,
|
||||
Base,
|
||||
use_default,
|
||||
single_pass_traversal_tag
|
||||
> super_t;
|
||||
|
||||
typedef head_iterator<Predicate, Base> this_t;
|
||||
typedef BOOST_DEDUCED_TYPENAME super_t::value_type value_type;
|
||||
typedef BOOST_DEDUCED_TYPENAME super_t::reference reference_type;
|
||||
|
||||
reference_type dereference_impl(){
|
||||
if(! m_end){
|
||||
while(! m_predicate(* this->base_reference()))
|
||||
++ this->base_reference();
|
||||
m_end = true;
|
||||
}
|
||||
return * this->base_reference();
|
||||
}
|
||||
|
||||
reference_type dereference() const {
|
||||
return const_cast<this_t *>(this)->dereference_impl();
|
||||
}
|
||||
|
||||
void increment(){
|
||||
++base_reference();
|
||||
}
|
||||
Predicate m_predicate;
|
||||
bool m_end;
|
||||
public:
|
||||
template<class T>
|
||||
head_iterator(Predicate f, T start) :
|
||||
super_t(Base(start)),
|
||||
m_predicate(f),
|
||||
m_end(false)
|
||||
{}
|
||||
|
||||
};
|
||||
|
||||
} // namespace iterators
|
||||
} // namespace archive
|
||||
} // namespace boost
|
||||
|
||||
#endif // BOOST_ARCHIVE_ITERATORS_HEAD_ITERATOR_HPP
|
||||
|
|
@ -0,0 +1,101 @@
|
|||
#ifndef BOOST_ARCHIVE_ITERATORS_INSERT_LINEBREAKS_HPP
|
||||
#define BOOST_ARCHIVE_ITERATORS_INSERT_LINEBREAKS_HPP
|
||||
|
||||
// MS compatible compilers support #pragma once
|
||||
#if defined(_MSC_VER) && (_MSC_VER >= 1020)
|
||||
# pragma once
|
||||
#endif
|
||||
|
||||
/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
|
||||
// insert_linebreaks.hpp
|
||||
|
||||
// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
|
||||
// Use, modification and distribution is subject to the Boost Software
|
||||
// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
// See http://www.boost.org for updates, documentation, and revision history.
|
||||
|
||||
#include <boost/assert.hpp>
|
||||
|
||||
#include <boost/config.hpp> // for BOOST_DEDUCED_TYPENAME
|
||||
#if defined(BOOST_NO_STDC_NAMESPACE)
|
||||
namespace std{ using ::memcpy; }
|
||||
#endif
|
||||
|
||||
#include <boost/serialization/pfto.hpp>
|
||||
|
||||
#include <boost/iterator/iterator_adaptor.hpp>
|
||||
#include <boost/iterator/iterator_traits.hpp>
|
||||
|
||||
namespace boost {
|
||||
namespace archive {
|
||||
namespace iterators {
|
||||
|
||||
/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
|
||||
// insert line break every N characters
|
||||
template<
|
||||
class Base,
|
||||
int N,
|
||||
class CharType = BOOST_DEDUCED_TYPENAME boost::iterator_value<Base>::type
|
||||
>
|
||||
class insert_linebreaks :
|
||||
public iterator_adaptor<
|
||||
insert_linebreaks<Base, N, CharType>,
|
||||
Base,
|
||||
CharType,
|
||||
single_pass_traversal_tag,
|
||||
CharType
|
||||
>
|
||||
{
|
||||
private:
|
||||
friend class boost::iterator_core_access;
|
||||
typedef iterator_adaptor<
|
||||
insert_linebreaks<Base, N, CharType>,
|
||||
Base,
|
||||
CharType,
|
||||
single_pass_traversal_tag,
|
||||
CharType
|
||||
> super_t;
|
||||
|
||||
bool equal(const insert_linebreaks<Base, N, CharType> & rhs) const {
|
||||
return
|
||||
// m_count == rhs.m_count
|
||||
// && base_reference() == rhs.base_reference()
|
||||
this->base_reference() == rhs.base_reference()
|
||||
;
|
||||
}
|
||||
|
||||
void increment() {
|
||||
if(m_count == N){
|
||||
m_count = 0;
|
||||
return;
|
||||
}
|
||||
++m_count;
|
||||
++(this->base_reference());
|
||||
}
|
||||
CharType dereference() const {
|
||||
if(m_count == N)
|
||||
return '\n';
|
||||
return * (this->base_reference());
|
||||
}
|
||||
unsigned int m_count;
|
||||
public:
|
||||
// make composible buy using templated constructor
|
||||
template<class T>
|
||||
insert_linebreaks(BOOST_PFTO_WRAPPER(T) start) :
|
||||
super_t(Base(BOOST_MAKE_PFTO_WRAPPER(static_cast< T >(start)))),
|
||||
m_count(0)
|
||||
{}
|
||||
// intel 7.1 doesn't like default copy constructor
|
||||
insert_linebreaks(const insert_linebreaks & rhs) :
|
||||
super_t(rhs.base_reference()),
|
||||
m_count(rhs.m_count)
|
||||
{}
|
||||
};
|
||||
|
||||
} // namespace iterators
|
||||
} // namespace archive
|
||||
} // namespace boost
|
||||
|
||||
#endif // BOOST_ARCHIVE_ITERATORS_INSERT_LINEBREAKS_HPP
|
||||
|
|
@ -0,0 +1,95 @@
|
|||
#ifndef BOOST_ARCHIVE_ITERATORS_ISTREAM_ITERATOR_HPP
|
||||
#define BOOST_ARCHIVE_ITERATORS_ISTREAM_ITERATOR_HPP
|
||||
|
||||
// MS compatible compilers support #pragma once
|
||||
#if defined(_MSC_VER) && (_MSC_VER >= 1020)
|
||||
# pragma once
|
||||
#endif
|
||||
|
||||
/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
|
||||
// istream_iterator.hpp
|
||||
|
||||
// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
|
||||
// Use, modification and distribution is subject to the Boost Software
|
||||
// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
// See http://www.boost.org for updates, documentation, and revision history.
|
||||
|
||||
// note: this is a custom version of the standard istream_iterator.
|
||||
// This is necessary as the standard version doesn't work as expected
|
||||
// for wchar_t based streams on systems for which wchar_t not a true
|
||||
// type but rather a synonym for some integer type.
|
||||
|
||||
#include <cstddef> // NULL
|
||||
#include <istream>
|
||||
#include <boost/iterator/iterator_facade.hpp>
|
||||
|
||||
namespace boost {
|
||||
namespace archive {
|
||||
namespace iterators {
|
||||
|
||||
// given a type, make an input iterator based on a pointer to that type
|
||||
template<class Elem = char>
|
||||
class istream_iterator :
|
||||
public boost::iterator_facade<
|
||||
istream_iterator<Elem>,
|
||||
Elem,
|
||||
std::input_iterator_tag,
|
||||
Elem
|
||||
>
|
||||
{
|
||||
friend class boost::iterator_core_access;
|
||||
typedef istream_iterator this_t ;
|
||||
typedef BOOST_DEDUCED_TYPENAME boost::iterator_facade<
|
||||
istream_iterator<Elem>,
|
||||
Elem,
|
||||
std::input_iterator_tag,
|
||||
Elem
|
||||
> super_t;
|
||||
typedef BOOST_DEDUCED_TYPENAME std::basic_istream<Elem> istream_type;
|
||||
|
||||
//Access the value referred to
|
||||
Elem dereference() const {
|
||||
return m_current_value;
|
||||
}
|
||||
|
||||
bool equal(const this_t & rhs) const {
|
||||
// note: only works for comparison against end of stream
|
||||
return m_istream == rhs.m_istream;
|
||||
}
|
||||
|
||||
void increment(){
|
||||
if(NULL != m_istream){
|
||||
m_current_value = static_cast<Elem>(m_istream->get());
|
||||
if(! m_istream->good()){
|
||||
const_cast<this_t *>(this)->m_istream = NULL;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
istream_type *m_istream;
|
||||
Elem m_current_value;
|
||||
public:
|
||||
istream_iterator(istream_type & is) :
|
||||
m_istream(& is)
|
||||
{
|
||||
increment();
|
||||
}
|
||||
|
||||
istream_iterator() :
|
||||
m_istream(NULL)
|
||||
{}
|
||||
|
||||
istream_iterator(const istream_iterator<Elem> & rhs) :
|
||||
m_istream(rhs.m_istream),
|
||||
m_current_value(rhs.m_current_value)
|
||||
{}
|
||||
|
||||
};
|
||||
|
||||
} // namespace iterators
|
||||
} // namespace archive
|
||||
} // namespace boost
|
||||
|
||||
#endif // BOOST_ARCHIVE_ITERATORS_ISTREAM_ITERATOR_HPP
|
||||
|
|
@ -0,0 +1,136 @@
|
|||
#ifndef BOOST_ARCHIVE_ITERATORS_MB_FROM_WCHAR_HPP
|
||||
#define BOOST_ARCHIVE_ITERATORS_MB_FROM_WCHAR_HPP
|
||||
|
||||
// MS compatible compilers support #pragma once
|
||||
#if defined(_MSC_VER) && (_MSC_VER >= 1020)
|
||||
# pragma once
|
||||
#endif
|
||||
|
||||
/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
|
||||
// mb_from_wchar.hpp
|
||||
|
||||
// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
|
||||
// Use, modification and distribution is subject to the Boost Software
|
||||
// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
// See http://www.boost.org for updates, documentation, and revision history.
|
||||
|
||||
#include <boost/assert.hpp>
|
||||
#include <cstddef> // size_t
|
||||
#include <cstdlib> // for wctomb()
|
||||
|
||||
#include <boost/config.hpp> // for BOOST_DEDUCED_TYPENAME
|
||||
#if defined(BOOST_NO_STDC_NAMESPACE)
|
||||
namespace std{
|
||||
using ::size_t;
|
||||
using ::wctomb;
|
||||
} // namespace std
|
||||
#endif
|
||||
|
||||
#include <boost/serialization/pfto.hpp>
|
||||
#include <boost/iterator/iterator_adaptor.hpp>
|
||||
|
||||
namespace boost {
|
||||
namespace archive {
|
||||
namespace iterators {
|
||||
|
||||
/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
|
||||
// class used by text archives to translate wide strings and to char
|
||||
// strings of the currently selected locale
|
||||
template<class Base> // the input iterator
|
||||
class mb_from_wchar
|
||||
: public boost::iterator_adaptor<
|
||||
mb_from_wchar<Base>,
|
||||
Base,
|
||||
wchar_t,
|
||||
single_pass_traversal_tag,
|
||||
char
|
||||
>
|
||||
{
|
||||
friend class boost::iterator_core_access;
|
||||
|
||||
typedef BOOST_DEDUCED_TYPENAME boost::iterator_adaptor<
|
||||
mb_from_wchar<Base>,
|
||||
Base,
|
||||
wchar_t,
|
||||
single_pass_traversal_tag,
|
||||
char
|
||||
> super_t;
|
||||
|
||||
typedef mb_from_wchar<Base> this_t;
|
||||
|
||||
char dereference_impl() {
|
||||
if(! m_full){
|
||||
fill();
|
||||
m_full = true;
|
||||
}
|
||||
return m_buffer[m_bnext];
|
||||
}
|
||||
char dereference() const {
|
||||
return (const_cast<this_t *>(this))->dereference_impl();
|
||||
}
|
||||
|
||||
// test for iterator equality
|
||||
bool equal(const mb_from_wchar<Base> & rhs) const {
|
||||
// once the value is filled, the base_reference has been incremented
|
||||
// so don't permit comparison anymore.
|
||||
return
|
||||
0 == m_bend
|
||||
&& 0 == m_bnext
|
||||
&& this->base_reference() == rhs.base_reference()
|
||||
;
|
||||
}
|
||||
|
||||
void fill(){
|
||||
wchar_t value = * this->base_reference();
|
||||
#if (defined(__MINGW32__) && ((__MINGW32_MAJOR_VERSION > 3) \
|
||||
|| ((__MINGW32_MAJOR_VERSION == 3) && (__MINGW32_MINOR_VERSION >= 8))))
|
||||
m_bend = std::wcrtomb(m_buffer, value, 0);
|
||||
#else
|
||||
m_bend = std::wctomb(m_buffer, value);
|
||||
#endif
|
||||
BOOST_ASSERT(-1 != m_bend);
|
||||
BOOST_ASSERT((std::size_t)m_bend <= sizeof(m_buffer));
|
||||
BOOST_ASSERT(m_bend > 0);
|
||||
m_bnext = 0;
|
||||
}
|
||||
|
||||
void increment(){
|
||||
if(++m_bnext < m_bend)
|
||||
return;
|
||||
m_bend =
|
||||
m_bnext = 0;
|
||||
++(this->base_reference());
|
||||
m_full = false;
|
||||
}
|
||||
|
||||
// buffer to handle pending characters
|
||||
int m_bend;
|
||||
int m_bnext;
|
||||
char m_buffer[9];
|
||||
bool m_full;
|
||||
|
||||
public:
|
||||
// make composible buy using templated constructor
|
||||
template<class T>
|
||||
mb_from_wchar(BOOST_PFTO_WRAPPER(T) start) :
|
||||
super_t(Base(BOOST_MAKE_PFTO_WRAPPER(static_cast< T >(start)))),
|
||||
m_bend(0),
|
||||
m_bnext(0),
|
||||
m_full(false)
|
||||
{}
|
||||
// intel 7.1 doesn't like default copy constructor
|
||||
mb_from_wchar(const mb_from_wchar & rhs) :
|
||||
super_t(rhs.base_reference()),
|
||||
m_bend(rhs.m_bend),
|
||||
m_bnext(rhs.m_bnext),
|
||||
m_full(rhs.m_full)
|
||||
{}
|
||||
};
|
||||
|
||||
} // namespace iterators
|
||||
} // namespace archive
|
||||
} // namespace boost
|
||||
|
||||
#endif // BOOST_ARCHIVE_ITERATORS_MB_FROM_WCHAR_HPP
|
||||
|
|
@ -0,0 +1,83 @@
|
|||
#ifndef BOOST_ARCHIVE_ITERATORS_OSTREAM_ITERATOR_HPP
|
||||
#define BOOST_ARCHIVE_ITERATORS_OSTREAM_ITERATOR_HPP
|
||||
|
||||
// MS compatible compilers support #pragma once
|
||||
#if defined(_MSC_VER) && (_MSC_VER >= 1020)
|
||||
# pragma once
|
||||
#endif
|
||||
|
||||
/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
|
||||
// ostream_iterator.hpp
|
||||
|
||||
// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
|
||||
// Use, modification and distribution is subject to the Boost Software
|
||||
// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
// See http://www.boost.org for updates, documentation, and revision history.
|
||||
|
||||
// note: this is a custom version of the standard ostream_iterator.
|
||||
// This is necessary as the standard version doesn't work as expected
|
||||
// for wchar_t based streams on systems for which wchar_t not a true
|
||||
// type but rather a synonym for some integer type.
|
||||
|
||||
#include <ostream>
|
||||
#include <boost/iterator/iterator_facade.hpp>
|
||||
|
||||
namespace boost {
|
||||
namespace archive {
|
||||
namespace iterators {
|
||||
|
||||
// given a type, make an input iterator based on a pointer to that type
|
||||
template<class Elem>
|
||||
class ostream_iterator :
|
||||
public boost::iterator_facade<
|
||||
ostream_iterator<Elem>,
|
||||
Elem,
|
||||
std::output_iterator_tag,
|
||||
ostream_iterator<Elem> &
|
||||
>
|
||||
{
|
||||
friend class boost::iterator_core_access;
|
||||
typedef ostream_iterator this_t ;
|
||||
typedef Elem char_type;
|
||||
typedef std::basic_ostream<char_type> ostream_type;
|
||||
|
||||
//emulate the behavior of std::ostream
|
||||
ostream_iterator & dereference() const {
|
||||
return const_cast<ostream_iterator &>(*this);
|
||||
}
|
||||
bool equal(const this_t & rhs) const {
|
||||
return m_ostream == rhs.m_ostream;
|
||||
}
|
||||
void increment(){}
|
||||
protected:
|
||||
ostream_type *m_ostream;
|
||||
void put_val(char_type e){
|
||||
if(NULL != m_ostream){
|
||||
m_ostream->put(e);
|
||||
if(! m_ostream->good())
|
||||
m_ostream = NULL;
|
||||
}
|
||||
}
|
||||
public:
|
||||
this_t & operator=(char_type c){
|
||||
put_val(c);
|
||||
return *this;
|
||||
}
|
||||
ostream_iterator(ostream_type & os) :
|
||||
m_ostream (& os)
|
||||
{}
|
||||
ostream_iterator() :
|
||||
m_ostream (NULL)
|
||||
{}
|
||||
ostream_iterator(const ostream_iterator & rhs) :
|
||||
m_ostream (rhs.m_ostream)
|
||||
{}
|
||||
};
|
||||
|
||||
} // namespace iterators
|
||||
} // namespace archive
|
||||
} // namespace boost
|
||||
|
||||
#endif // BOOST_ARCHIVE_ITERATORS_OSTREAM_ITERATOR_HPP
|
||||
|
|
@ -0,0 +1,169 @@
|
|||
#ifndef BOOST_ARCHIVE_ITERATORS_REMOVE_WHITESPACE_HPP
|
||||
#define BOOST_ARCHIVE_ITERATORS_REMOVE_WHITESPACE_HPP
|
||||
|
||||
// MS compatible compilers support #pragma once
|
||||
#if defined(_MSC_VER) && (_MSC_VER >= 1020)
|
||||
# pragma once
|
||||
#endif
|
||||
|
||||
/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
|
||||
// remove_whitespace.hpp
|
||||
|
||||
// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
|
||||
// Use, modification and distribution is subject to the Boost Software
|
||||
// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
// See http://www.boost.org for updates, documentation, and revision history.
|
||||
|
||||
#include <boost/assert.hpp>
|
||||
|
||||
#include <boost/config.hpp> // for BOOST_DEDUCED_TYPENAME
|
||||
|
||||
#include <boost/serialization/pfto.hpp>
|
||||
|
||||
#include <boost/iterator/iterator_adaptor.hpp>
|
||||
#include <boost/iterator/filter_iterator.hpp>
|
||||
|
||||
//#include <boost/detail/workaround.hpp>
|
||||
//#if ! BOOST_WORKAROUND(BOOST_MSVC, <=1300)
|
||||
|
||||
// here is the default standard implementation of the functor used
|
||||
// by the filter iterator to remove spaces. Unfortunately usage
|
||||
// of this implementation in combination with spirit trips a bug
|
||||
// VC 6.5. The only way I can find to work around it is to
|
||||
// implement a special non-standard version for this platform
|
||||
|
||||
#ifndef BOOST_NO_CWCTYPE
|
||||
#include <cwctype> // iswspace
|
||||
#if defined(BOOST_NO_STDC_NAMESPACE)
|
||||
namespace std{ using ::iswspace; }
|
||||
#endif
|
||||
#endif
|
||||
|
||||
#include <cctype> // isspace
|
||||
#if defined(BOOST_NO_STDC_NAMESPACE)
|
||||
namespace std{ using ::isspace; }
|
||||
#endif
|
||||
|
||||
#if defined(__STD_RWCOMPILER_H__) || defined(_RWSTD_VER)
|
||||
// this is required for the RW STL on Linux and Tru64.
|
||||
#undef isspace
|
||||
#undef iswspace
|
||||
#endif
|
||||
|
||||
//#endif // BOOST_WORKAROUND
|
||||
|
||||
namespace { // anonymous
|
||||
|
||||
template<class CharType>
|
||||
struct remove_whitespace_predicate;
|
||||
|
||||
template<>
|
||||
struct remove_whitespace_predicate<char>
|
||||
{
|
||||
bool operator()(unsigned char t){
|
||||
return ! std::isspace(t);
|
||||
}
|
||||
};
|
||||
|
||||
#ifndef BOOST_NO_CWCHAR
|
||||
template<>
|
||||
struct remove_whitespace_predicate<wchar_t>
|
||||
{
|
||||
bool operator()(wchar_t t){
|
||||
return ! std::iswspace(t);
|
||||
}
|
||||
};
|
||||
#endif
|
||||
|
||||
} // namespace anonymous
|
||||
|
||||
/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
|
||||
// convert base64 file data (including whitespace and padding) to binary
|
||||
|
||||
namespace boost {
|
||||
namespace archive {
|
||||
namespace iterators {
|
||||
|
||||
// custom version of filter iterator which doesn't look ahead further than
|
||||
// necessary
|
||||
|
||||
template<class Predicate, class Base>
|
||||
class filter_iterator
|
||||
: public boost::iterator_adaptor<
|
||||
filter_iterator<Predicate, Base>,
|
||||
Base,
|
||||
use_default,
|
||||
single_pass_traversal_tag
|
||||
>
|
||||
{
|
||||
friend class boost::iterator_core_access;
|
||||
typedef BOOST_DEDUCED_TYPENAME boost::iterator_adaptor<
|
||||
filter_iterator<Predicate, Base>,
|
||||
Base,
|
||||
use_default,
|
||||
single_pass_traversal_tag
|
||||
> super_t;
|
||||
typedef filter_iterator<Predicate, Base> this_t;
|
||||
typedef BOOST_DEDUCED_TYPENAME super_t::reference reference_type;
|
||||
|
||||
reference_type dereference_impl(){
|
||||
if(! m_full){
|
||||
while(! m_predicate(* this->base_reference()))
|
||||
++(this->base_reference());
|
||||
m_full = true;
|
||||
}
|
||||
return * this->base_reference();
|
||||
}
|
||||
|
||||
reference_type dereference() const {
|
||||
return const_cast<this_t *>(this)->dereference_impl();
|
||||
}
|
||||
|
||||
Predicate m_predicate;
|
||||
bool m_full;
|
||||
public:
|
||||
// note: this function is public only because comeau compiler complained
|
||||
// I don't know if this is because the compiler is wrong or what
|
||||
void increment(){
|
||||
m_full = false;
|
||||
++(this->base_reference());
|
||||
}
|
||||
filter_iterator(Base start) :
|
||||
super_t(start),
|
||||
m_full(false)
|
||||
{}
|
||||
filter_iterator(){}
|
||||
};
|
||||
|
||||
template<class Base>
|
||||
class remove_whitespace :
|
||||
public filter_iterator<
|
||||
remove_whitespace_predicate<BOOST_DEDUCED_TYPENAME Base::value_type>,
|
||||
Base
|
||||
>
|
||||
{
|
||||
friend class boost::iterator_core_access;
|
||||
typedef filter_iterator<
|
||||
remove_whitespace_predicate<BOOST_DEDUCED_TYPENAME Base::value_type>,
|
||||
Base
|
||||
> super_t;
|
||||
public:
|
||||
// remove_whitespace(){} // why is this needed?
|
||||
// make composible buy using templated constructor
|
||||
template<class T>
|
||||
remove_whitespace(BOOST_PFTO_WRAPPER(T) start) :
|
||||
super_t(Base(BOOST_MAKE_PFTO_WRAPPER(static_cast< T >(start))))
|
||||
{}
|
||||
// intel 7.1 doesn't like default copy constructor
|
||||
remove_whitespace(const remove_whitespace & rhs) :
|
||||
super_t(rhs.base_reference())
|
||||
{}
|
||||
};
|
||||
|
||||
} // namespace iterators
|
||||
} // namespace archive
|
||||
} // namespace boost
|
||||
|
||||
#endif // BOOST_ARCHIVE_ITERATORS_REMOVE_WHITESPACE_HPP
|
||||
|
|
@ -0,0 +1,170 @@
|
|||
#ifndef BOOST_ARCHIVE_ITERATORS_TRANSFORM_WIDTH_HPP
|
||||
#define BOOST_ARCHIVE_ITERATORS_TRANSFORM_WIDTH_HPP
|
||||
|
||||
// MS compatible compilers support #pragma once
|
||||
#if defined(_MSC_VER) && (_MSC_VER >= 1020)
|
||||
# pragma once
|
||||
#endif
|
||||
|
||||
/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
|
||||
// transform_width.hpp
|
||||
|
||||
// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
|
||||
// Use, modification and distribution is subject to the Boost Software
|
||||
// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
// See http://www.boost.org for updates, documentation, and revision history.
|
||||
|
||||
// iterator which takes elements of x bits and returns elements of y bits.
|
||||
// used to change streams of 8 bit characters into streams of 6 bit characters.
|
||||
// and vice-versa for implementing base64 encodeing/decoding. Be very careful
|
||||
// when using and end iterator. end is only reliable detected when the input
|
||||
// stream length is some common multiple of x and y. E.G. Base64 6 bit
|
||||
// character and 8 bit bytes. Lowest common multiple is 24 => 4 6 bit characters
|
||||
// or 3 8 bit characters
|
||||
|
||||
#include <algorithm>
|
||||
|
||||
#include <boost/config.hpp> // for BOOST_DEDUCED_TYPENAME & PTFO
|
||||
#include <boost/serialization/pfto.hpp>
|
||||
|
||||
#include <boost/iterator/iterator_adaptor.hpp>
|
||||
#include <boost/iterator/iterator_traits.hpp>
|
||||
|
||||
namespace boost {
|
||||
namespace archive {
|
||||
namespace iterators {
|
||||
|
||||
/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
|
||||
// class used by text archives to translate char strings to wchar_t
|
||||
// strings of the currently selected locale
|
||||
template<
|
||||
class Base,
|
||||
int BitsOut,
|
||||
int BitsIn,
|
||||
class CharType = BOOST_DEDUCED_TYPENAME boost::iterator_value<Base>::type // output character
|
||||
>
|
||||
class transform_width :
|
||||
public boost::iterator_adaptor<
|
||||
transform_width<Base, BitsOut, BitsIn, CharType>,
|
||||
Base,
|
||||
CharType,
|
||||
single_pass_traversal_tag,
|
||||
CharType
|
||||
>
|
||||
{
|
||||
friend class boost::iterator_core_access;
|
||||
typedef BOOST_DEDUCED_TYPENAME boost::iterator_adaptor<
|
||||
transform_width<Base, BitsOut, BitsIn, CharType>,
|
||||
Base,
|
||||
CharType,
|
||||
single_pass_traversal_tag,
|
||||
CharType
|
||||
> super_t;
|
||||
|
||||
typedef transform_width<Base, BitsOut, BitsIn, CharType> this_t;
|
||||
typedef BOOST_DEDUCED_TYPENAME iterator_value<Base>::type base_value_type;
|
||||
|
||||
CharType fill();
|
||||
|
||||
CharType dereference_impl(){
|
||||
if(! m_full){
|
||||
m_current_value = fill();
|
||||
m_full = true;
|
||||
}
|
||||
return m_current_value;
|
||||
}
|
||||
|
||||
CharType dereference() const {
|
||||
return const_cast<this_t *>(this)->dereference_impl();
|
||||
}
|
||||
|
||||
// test for iterator equality
|
||||
bool equal(const this_t & rhs) const {
|
||||
return
|
||||
this->base_reference() == rhs.base_reference();
|
||||
;
|
||||
}
|
||||
|
||||
void increment(){
|
||||
m_displacement += BitsOut;
|
||||
|
||||
while(m_displacement >= BitsIn){
|
||||
m_displacement -= BitsIn;
|
||||
if(0 == m_displacement)
|
||||
m_bufferfull = false;
|
||||
if(! m_bufferfull){
|
||||
// note: suspect that this is not invoked for borland
|
||||
++(this->base_reference());
|
||||
}
|
||||
}
|
||||
m_full = false;
|
||||
}
|
||||
|
||||
CharType m_current_value;
|
||||
// number of bits left in current input character buffer
|
||||
unsigned int m_displacement;
|
||||
base_value_type m_buffer;
|
||||
// flag to current output character is ready - just used to save time
|
||||
bool m_full;
|
||||
// flag to indicate that m_buffer has data
|
||||
bool m_bufferfull;
|
||||
|
||||
public:
|
||||
// make composible buy using templated constructor
|
||||
template<class T>
|
||||
transform_width(BOOST_PFTO_WRAPPER(T) start) :
|
||||
super_t(Base(BOOST_MAKE_PFTO_WRAPPER(static_cast< T >(start)))),
|
||||
m_displacement(0),
|
||||
m_full(false),
|
||||
m_bufferfull(false)
|
||||
{}
|
||||
// intel 7.1 doesn't like default copy constructor
|
||||
transform_width(const transform_width & rhs) :
|
||||
super_t(rhs.base_reference()),
|
||||
m_current_value(rhs.m_current_value),
|
||||
m_displacement(rhs.m_displacement),
|
||||
m_buffer(rhs.m_buffer),
|
||||
m_full(rhs.m_full),
|
||||
m_bufferfull(rhs.m_bufferfull)
|
||||
{}
|
||||
};
|
||||
|
||||
template<class Base, int BitsOut, int BitsIn, class CharType>
|
||||
CharType transform_width<Base, BitsOut, BitsIn, CharType>::fill(){
|
||||
CharType retval = 0;
|
||||
unsigned int missing_bits = BitsOut;
|
||||
for(;;){
|
||||
unsigned int bcount;
|
||||
if(! m_bufferfull){
|
||||
m_buffer = * this->base_reference();
|
||||
m_bufferfull = true;
|
||||
bcount = BitsIn;
|
||||
}
|
||||
else
|
||||
bcount = BitsIn - m_displacement;
|
||||
unsigned int i = (std::min)(bcount, missing_bits);
|
||||
// shift interesting bits to least significant position
|
||||
unsigned int j = m_buffer >> (bcount - i);
|
||||
// strip off uninteresting bits
|
||||
// (note presumption of two's complement arithmetic)
|
||||
j &= ~(-(1 << i));
|
||||
// append then interesting bits to the output value
|
||||
retval <<= i;
|
||||
retval |= j;
|
||||
missing_bits -= i;
|
||||
if(0 == missing_bits)
|
||||
break;
|
||||
// note: suspect that this is not invoked for borland 5.51
|
||||
++(this->base_reference());
|
||||
m_bufferfull = false;
|
||||
}
|
||||
return retval;
|
||||
}
|
||||
|
||||
} // namespace iterators
|
||||
} // namespace archive
|
||||
} // namespace boost
|
||||
|
||||
#endif // BOOST_ARCHIVE_ITERATORS_TRANSFORM_WIDTH_HPP
|
||||
|
|
@ -0,0 +1,91 @@
|
|||
#ifndef BOOST_ARCHIVE_ITERATORS_UNESCAPE_HPP
|
||||
#define BOOST_ARCHIVE_ITERATORS_UNESCAPE_HPP
|
||||
|
||||
// MS compatible compilers support #pragma once
|
||||
#if defined(_MSC_VER) && (_MSC_VER >= 1020)
|
||||
# pragma once
|
||||
#endif
|
||||
|
||||
/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
|
||||
// unescape.hpp
|
||||
|
||||
// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
|
||||
// Use, modification and distribution is subject to the Boost Software
|
||||
// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
// See http://www.boost.org for updates, documentation, and revision history.
|
||||
|
||||
#include <boost/assert.hpp>
|
||||
|
||||
#include <boost/config.hpp> // for BOOST_DEDUCED_TYPENAME
|
||||
#include <boost/iterator/iterator_adaptor.hpp>
|
||||
//#include <boost/iterator/iterator_traits.hpp>
|
||||
#include <boost/pointee.hpp>
|
||||
|
||||
namespace boost {
|
||||
namespace archive {
|
||||
namespace iterators {
|
||||
|
||||
/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
|
||||
// class used by text archives to translate char strings to wchar_t
|
||||
// strings of the currently selected locale
|
||||
template<class Derived, class Base>
|
||||
class unescape
|
||||
: public boost::iterator_adaptor<
|
||||
unescape<Derived, Base>,
|
||||
Base,
|
||||
BOOST_DEDUCED_TYPENAME pointee<Base>::type,
|
||||
single_pass_traversal_tag,
|
||||
BOOST_DEDUCED_TYPENAME pointee<Base>::type
|
||||
>
|
||||
{
|
||||
friend class boost::iterator_core_access;
|
||||
typedef BOOST_DEDUCED_TYPENAME boost::iterator_adaptor<
|
||||
unescape<Derived, Base>,
|
||||
Base,
|
||||
BOOST_DEDUCED_TYPENAME pointee<Base>::type,
|
||||
single_pass_traversal_tag,
|
||||
BOOST_DEDUCED_TYPENAME pointee<Base>::type
|
||||
> super_t;
|
||||
|
||||
typedef unescape<Derived, Base> this_t;
|
||||
public:
|
||||
typedef BOOST_DEDUCED_TYPENAME this_t::value_type value_type;
|
||||
typedef BOOST_DEDUCED_TYPENAME this_t::reference reference;
|
||||
private:
|
||||
value_type dereference_impl() {
|
||||
if(! m_full){
|
||||
m_current_value = static_cast<Derived *>(this)->drain();
|
||||
m_full = true;
|
||||
}
|
||||
return m_current_value;
|
||||
}
|
||||
|
||||
reference dereference() const {
|
||||
return const_cast<this_t *>(this)->dereference_impl();
|
||||
}
|
||||
|
||||
value_type m_current_value;
|
||||
bool m_full;
|
||||
|
||||
void increment(){
|
||||
++(this->base_reference());
|
||||
dereference_impl();
|
||||
m_full = false;
|
||||
};
|
||||
|
||||
public:
|
||||
|
||||
unescape(Base base) :
|
||||
super_t(base),
|
||||
m_full(false)
|
||||
{}
|
||||
|
||||
};
|
||||
|
||||
} // namespace iterators
|
||||
} // namespace archive
|
||||
} // namespace boost
|
||||
|
||||
#endif // BOOST_ARCHIVE_ITERATORS_UNESCAPE_HPP
|
||||
|
|
@ -0,0 +1,129 @@
|
|||
#ifndef BOOST_ARCHIVE_ITERATORS_WCHAR_FROM_MB_HPP
|
||||
#define BOOST_ARCHIVE_ITERATORS_WCHAR_FROM_MB_HPP
|
||||
|
||||
// MS compatible compilers support #pragma once
|
||||
#if defined(_MSC_VER) && (_MSC_VER >= 1020)
|
||||
# pragma once
|
||||
#endif
|
||||
|
||||
/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
|
||||
// wchar_from_mb.hpp
|
||||
|
||||
// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
|
||||
// Use, modification and distribution is subject to the Boost Software
|
||||
// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
// See http://www.boost.org for updates, documentation, and revision history.
|
||||
|
||||
#include <boost/assert.hpp>
|
||||
#include <cctype>
|
||||
#include <cstddef> // size_t
|
||||
#include <cstdlib> // mblen
|
||||
|
||||
#include <boost/config.hpp> // for BOOST_DEDUCED_TYPENAME
|
||||
#if defined(BOOST_NO_STDC_NAMESPACE)
|
||||
namespace std{
|
||||
using ::mblen;
|
||||
using ::mbtowc;
|
||||
} // namespace std
|
||||
#endif
|
||||
|
||||
#include <boost/serialization/throw_exception.hpp>
|
||||
#include <boost/serialization/pfto.hpp>
|
||||
|
||||
#include <boost/iterator/iterator_adaptor.hpp>
|
||||
#include <boost/archive/iterators/dataflow_exception.hpp>
|
||||
|
||||
namespace boost {
|
||||
namespace archive {
|
||||
namespace iterators {
|
||||
|
||||
/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
|
||||
// class used by text archives to translate char strings to wchar_t
|
||||
// strings of the currently selected locale
|
||||
template<class Base>
|
||||
class wchar_from_mb
|
||||
: public boost::iterator_adaptor<
|
||||
wchar_from_mb<Base>,
|
||||
Base,
|
||||
wchar_t,
|
||||
single_pass_traversal_tag,
|
||||
wchar_t
|
||||
>
|
||||
{
|
||||
friend class boost::iterator_core_access;
|
||||
typedef BOOST_DEDUCED_TYPENAME boost::iterator_adaptor<
|
||||
wchar_from_mb<Base>,
|
||||
Base,
|
||||
wchar_t,
|
||||
single_pass_traversal_tag,
|
||||
wchar_t
|
||||
> super_t;
|
||||
|
||||
typedef wchar_from_mb<Base> this_t;
|
||||
|
||||
wchar_t drain();
|
||||
|
||||
wchar_t dereference_impl() {
|
||||
if(! m_full){
|
||||
m_current_value = drain();
|
||||
m_full = true;
|
||||
}
|
||||
return m_current_value;
|
||||
}
|
||||
|
||||
wchar_t dereference() const {
|
||||
return const_cast<this_t *>(this)->dereference_impl();
|
||||
}
|
||||
|
||||
void increment(){
|
||||
dereference_impl();
|
||||
m_full = false;
|
||||
++(this->base_reference());
|
||||
};
|
||||
|
||||
wchar_t m_current_value;
|
||||
bool m_full;
|
||||
|
||||
public:
|
||||
// make composible buy using templated constructor
|
||||
template<class T>
|
||||
wchar_from_mb(BOOST_PFTO_WRAPPER(T) start) :
|
||||
super_t(Base(BOOST_MAKE_PFTO_WRAPPER(static_cast< T >(start)))),
|
||||
m_full(false)
|
||||
{}
|
||||
// intel 7.1 doesn't like default copy constructor
|
||||
wchar_from_mb(const wchar_from_mb & rhs) :
|
||||
super_t(rhs.base_reference()),
|
||||
m_full(rhs.m_full)
|
||||
{}
|
||||
};
|
||||
|
||||
template<class Base>
|
||||
wchar_t wchar_from_mb<Base>::drain(){
|
||||
char buffer[9];
|
||||
char * bptr = buffer;
|
||||
char val;
|
||||
for(std::size_t i = 0; i++ < (unsigned)MB_CUR_MAX;){
|
||||
val = * this->base_reference();
|
||||
*bptr++ = val;
|
||||
int result = std::mblen(buffer, i);
|
||||
if(-1 != result)
|
||||
break;
|
||||
++(this->base_reference());
|
||||
}
|
||||
wchar_t retval;
|
||||
int result = std::mbtowc(& retval, buffer, MB_CUR_MAX);
|
||||
if(0 >= result)
|
||||
boost::serialization::throw_exception(iterators::dataflow_exception(
|
||||
iterators::dataflow_exception::invalid_conversion
|
||||
));
|
||||
return retval;
|
||||
}
|
||||
|
||||
} // namespace iterators
|
||||
} // namespace archive
|
||||
} // namespace boost
|
||||
|
||||
#endif // BOOST_ARCHIVE_ITERATORS_WCHAR_FROM_MB_HPP
|
||||
|
|
@ -0,0 +1,125 @@
|
|||
#ifndef BOOST_ARCHIVE_ITERATORS_XML_ESCAPE_HPP
|
||||
#define BOOST_ARCHIVE_ITERATORS_XML_ESCAPE_HPP
|
||||
|
||||
// MS compatible compilers support #pragma once
|
||||
#if defined(_MSC_VER) && (_MSC_VER >= 1020)
|
||||
# pragma once
|
||||
#endif
|
||||
|
||||
/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
|
||||
// xml_escape.hpp
|
||||
|
||||
// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
|
||||
// Use, modification and distribution is subject to the Boost Software
|
||||
// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
// See http://www.boost.org for updates, documentation, and revision history.
|
||||
|
||||
#include <boost/assert.hpp>
|
||||
|
||||
#include <boost/config.hpp> // for BOOST_DEDUCED_TYPENAME
|
||||
#include <boost/serialization/pfto.hpp>
|
||||
|
||||
#include <boost/archive/iterators/escape.hpp>
|
||||
|
||||
namespace boost {
|
||||
namespace archive {
|
||||
namespace iterators {
|
||||
|
||||
/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
|
||||
// insert escapes into xml text
|
||||
|
||||
template<class Base>
|
||||
class xml_escape
|
||||
: public escape<xml_escape<Base>, Base>
|
||||
{
|
||||
friend class boost::iterator_core_access;
|
||||
|
||||
typedef escape<xml_escape<Base>, Base> super_t;
|
||||
|
||||
public:
|
||||
char fill(const char * & bstart, const char * & bend);
|
||||
wchar_t fill(const wchar_t * & bstart, const wchar_t * & bend);
|
||||
|
||||
template<class T>
|
||||
xml_escape(BOOST_PFTO_WRAPPER(T) start) :
|
||||
super_t(Base(BOOST_MAKE_PFTO_WRAPPER(static_cast< T >(start))))
|
||||
{}
|
||||
// intel 7.1 doesn't like default copy constructor
|
||||
xml_escape(const xml_escape & rhs) :
|
||||
super_t(rhs.base_reference())
|
||||
{}
|
||||
};
|
||||
|
||||
template<class Base>
|
||||
char xml_escape<Base>::fill(
|
||||
const char * & bstart,
|
||||
const char * & bend
|
||||
){
|
||||
char current_value = * this->base_reference();
|
||||
switch(current_value){
|
||||
case '<':
|
||||
bstart = "<";
|
||||
bend = bstart + 4;
|
||||
break;
|
||||
case '>':
|
||||
bstart = ">";
|
||||
bend = bstart + 4;
|
||||
break;
|
||||
case '&':
|
||||
bstart = "&";
|
||||
bend = bstart + 5;
|
||||
break;
|
||||
case '"':
|
||||
bstart = """;
|
||||
bend = bstart + 6;
|
||||
break;
|
||||
case '\'':
|
||||
bstart = "'";
|
||||
bend = bstart + 6;
|
||||
break;
|
||||
default:
|
||||
return current_value;
|
||||
}
|
||||
return *bstart;
|
||||
}
|
||||
|
||||
template<class Base>
|
||||
wchar_t xml_escape<Base>::fill(
|
||||
const wchar_t * & bstart,
|
||||
const wchar_t * & bend
|
||||
){
|
||||
wchar_t current_value = * this->base_reference();
|
||||
switch(current_value){
|
||||
case '<':
|
||||
bstart = L"<";
|
||||
bend = bstart + 4;
|
||||
break;
|
||||
case '>':
|
||||
bstart = L">";
|
||||
bend = bstart + 4;
|
||||
break;
|
||||
case '&':
|
||||
bstart = L"&";
|
||||
bend = bstart + 5;
|
||||
break;
|
||||
case '"':
|
||||
bstart = L""";
|
||||
bend = bstart + 6;
|
||||
break;
|
||||
case '\'':
|
||||
bstart = L"'";
|
||||
bend = bstart + 6;
|
||||
break;
|
||||
default:
|
||||
return current_value;
|
||||
}
|
||||
return *bstart;
|
||||
}
|
||||
|
||||
} // namespace iterators
|
||||
} // namespace archive
|
||||
} // namespace boost
|
||||
|
||||
#endif // BOOST_ARCHIVE_ITERATORS_XML_ESCAPE_HPP
|
||||
|
|
@ -0,0 +1,128 @@
|
|||
#ifndef BOOST_ARCHIVE_ITERATORS_XML_UNESCAPE_HPP
|
||||
#define BOOST_ARCHIVE_ITERATORS_XML_UNESCAPE_HPP
|
||||
|
||||
// MS compatible compilers support #pragma once
|
||||
#if defined(_MSC_VER) && (_MSC_VER >= 1020)
|
||||
# pragma once
|
||||
#endif
|
||||
|
||||
/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
|
||||
// xml_unescape.hpp
|
||||
|
||||
// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
|
||||
// Use, modification and distribution is subject to the Boost Software
|
||||
// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
// See http://www.boost.org for updates, documentation, and revision history.
|
||||
|
||||
#include <boost/assert.hpp>
|
||||
|
||||
#include <boost/config.hpp> // for BOOST_DEDUCED_TYPENAME
|
||||
|
||||
#include <boost/serialization/throw_exception.hpp>
|
||||
#include <boost/serialization/pfto.hpp>
|
||||
|
||||
#include <boost/archive/iterators/unescape.hpp>
|
||||
#include <boost/archive/iterators/dataflow_exception.hpp>
|
||||
|
||||
namespace boost {
|
||||
namespace archive {
|
||||
namespace iterators {
|
||||
|
||||
/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
|
||||
// replace &??? xml escape sequences with the corresponding characters
|
||||
template<class Base>
|
||||
class xml_unescape
|
||||
: public unescape<xml_unescape<Base>, Base>
|
||||
{
|
||||
friend class boost::iterator_core_access;
|
||||
typedef xml_unescape<Base> this_t;
|
||||
typedef unescape<this_t, Base> super_t;
|
||||
typedef BOOST_DEDUCED_TYPENAME boost::iterator_reference<this_t> reference_type;
|
||||
|
||||
reference_type dereference() const {
|
||||
return unescape<xml_unescape<Base>, Base>::dereference();
|
||||
}
|
||||
public:
|
||||
// workaround msvc 7.1 ICU crash
|
||||
#if defined(BOOST_MSVC)
|
||||
typedef int value_type;
|
||||
#else
|
||||
typedef BOOST_DEDUCED_TYPENAME this_t::value_type value_type;
|
||||
#endif
|
||||
|
||||
void drain_residue(const char *literal);
|
||||
value_type drain();
|
||||
|
||||
template<class T>
|
||||
xml_unescape(BOOST_PFTO_WRAPPER(T) start) :
|
||||
super_t(Base(BOOST_MAKE_PFTO_WRAPPER(static_cast< T >(start))))
|
||||
{}
|
||||
// intel 7.1 doesn't like default copy constructor
|
||||
xml_unescape(const xml_unescape & rhs) :
|
||||
super_t(rhs.base_reference())
|
||||
{}
|
||||
};
|
||||
|
||||
template<class Base>
|
||||
void xml_unescape<Base>::drain_residue(const char * literal){
|
||||
do{
|
||||
if(* literal != * ++(this->base_reference()))
|
||||
boost::serialization::throw_exception(
|
||||
dataflow_exception(
|
||||
dataflow_exception::invalid_xml_escape_sequence
|
||||
)
|
||||
);
|
||||
}
|
||||
while('\0' != * ++literal);
|
||||
}
|
||||
|
||||
// note key constraint on this function is that can't "look ahead" any
|
||||
// more than necessary into base iterator. Doing so would alter the base
|
||||
// iterator refenence which would make subsequent iterator comparisons
|
||||
// incorrect and thereby break the composiblity of iterators.
|
||||
template<class Base>
|
||||
BOOST_DEDUCED_TYPENAME xml_unescape<Base>::value_type
|
||||
//int
|
||||
xml_unescape<Base>::drain(){
|
||||
value_type retval = * this->base_reference();
|
||||
if('&' != retval){
|
||||
return retval;
|
||||
}
|
||||
retval = * ++(this->base_reference());
|
||||
switch(retval){
|
||||
case 'l': // <
|
||||
drain_residue("t;");
|
||||
retval = '<';
|
||||
break;
|
||||
case 'g': // >
|
||||
drain_residue("t;");
|
||||
retval = '>';
|
||||
break;
|
||||
case 'a':
|
||||
retval = * ++(this->base_reference());
|
||||
switch(retval){
|
||||
case 'p': // '
|
||||
drain_residue("os;");
|
||||
retval = '\'';
|
||||
break;
|
||||
case 'm': // &
|
||||
drain_residue("p;");
|
||||
retval = '&';
|
||||
break;
|
||||
}
|
||||
break;
|
||||
case 'q':
|
||||
drain_residue("uot;");
|
||||
retval = '"';
|
||||
break;
|
||||
}
|
||||
return retval;
|
||||
}
|
||||
|
||||
} // namespace iterators
|
||||
} // namespace archive
|
||||
} // namespace boost
|
||||
|
||||
#endif // BOOST_ARCHIVE_ITERATORS_XML_UNESCAPE_HPP
|
||||
|
|
@ -0,0 +1,49 @@
|
|||
#ifndef BOOST_ARCHIVE_ITERATORS_XML_UNESCAPE_EXCEPTION_HPP
|
||||
#define BOOST_ARCHIVE_ITERATORS_XML_UNESCAPE_EXCEPTION_HPP
|
||||
|
||||
// MS compatible compilers support #pragma once
|
||||
#if defined(_MSC_VER) && (_MSC_VER >= 1020)
|
||||
# pragma once
|
||||
#endif
|
||||
|
||||
/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
|
||||
// xml_unescape_exception.hpp:
|
||||
|
||||
// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
|
||||
// Use, modification and distribution is subject to the Boost Software
|
||||
// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
// See http://www.boost.org for updates, documentation, and revision history.
|
||||
|
||||
#include <boost/config.hpp>
|
||||
#ifndef BOOST_NO_EXCEPTIONS
|
||||
#include <exception>
|
||||
|
||||
#include <boost/assert.hpp>
|
||||
|
||||
namespace boost {
|
||||
namespace archive {
|
||||
namespace iterators {
|
||||
|
||||
//////////////////////////////////////////////////////////////////////
|
||||
// exceptions thrown by xml_unescapes
|
||||
//
|
||||
class xml_unescape_exception : public std::exception
|
||||
{
|
||||
public:
|
||||
xml_unescape_exception()
|
||||
{}
|
||||
|
||||
virtual const char *what( ) const throw( )
|
||||
{
|
||||
return "xml contained un-recognized escape code";
|
||||
}
|
||||
};
|
||||
|
||||
} // namespace iterators
|
||||
} // namespace archive
|
||||
} // namespace boost
|
||||
|
||||
#endif //BOOST_NO_EXCEPTIONS
|
||||
#endif //BOOST_ARCHIVE_ITERATORS_XML_UNESCAPE_EXCEPTION_HPP
|
||||
|
|
@ -0,0 +1,54 @@
|
|||
#ifndef BOOST_ARCHIVE_POLYMORPHIC_BINARY_IARCHIVE_HPP
|
||||
#define BOOST_ARCHIVE_POLYMORPHIC_BINARY_IARCHIVE_HPP
|
||||
|
||||
// MS compatible compilers support #pragma once
|
||||
#if defined(_MSC_VER) && (_MSC_VER >= 1020)
|
||||
# pragma once
|
||||
#endif
|
||||
|
||||
/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
|
||||
// polymorphic_binary_iarchive.hpp
|
||||
|
||||
// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
|
||||
// Use, modification and distribution is subject to the Boost Software
|
||||
// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
// See http://www.boost.org for updates, documentation, and revision history.
|
||||
|
||||
#include <boost/config.hpp>
|
||||
#include <boost/archive/binary_iarchive.hpp>
|
||||
#include <boost/archive/detail/polymorphic_iarchive_route.hpp>
|
||||
|
||||
#ifdef BOOST_MSVC
|
||||
# pragma warning(push)
|
||||
# pragma warning(disable : 4511 4512)
|
||||
#endif
|
||||
|
||||
namespace boost {
|
||||
namespace archive {
|
||||
|
||||
class polymorphic_binary_iarchive :
|
||||
public detail::polymorphic_iarchive_route<naked_binary_iarchive>
|
||||
{
|
||||
public:
|
||||
polymorphic_binary_iarchive(std::istream & is, unsigned int flags = 0) :
|
||||
detail::polymorphic_iarchive_route<naked_binary_iarchive>(is, flags)
|
||||
{}
|
||||
~polymorphic_binary_iarchive(){}
|
||||
};
|
||||
|
||||
} // namespace archive
|
||||
} // namespace boost
|
||||
|
||||
#ifdef BOOST_MSVC
|
||||
#pragma warning(pop)
|
||||
#endif
|
||||
|
||||
// required by export
|
||||
BOOST_SERIALIZATION_REGISTER_ARCHIVE(
|
||||
boost::archive::polymorphic_binary_iarchive
|
||||
)
|
||||
|
||||
#endif // BOOST_ARCHIVE_POLYMORPHIC_BINARY_IARCHIVE_HPP
|
||||
|
||||
|
|
@ -0,0 +1,43 @@
|
|||
#ifndef BOOST_ARCHIVE_POLYMORPHIC_BINARY_OARCHIVE_HPP
|
||||
#define BOOST_ARCHIVE_POLYMORPHIC_BINARY_OARCHIVE_HPP
|
||||
|
||||
// MS compatible compilers support #pragma once
|
||||
#if defined(_MSC_VER) && (_MSC_VER >= 1020)
|
||||
# pragma once
|
||||
#endif
|
||||
|
||||
/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
|
||||
// polymorphic_binary_oarchive.hpp
|
||||
|
||||
// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
|
||||
// Use, modification and distribution is subject to the Boost Software
|
||||
// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
// See http://www.boost.org for updates, documentation, and revision history.
|
||||
|
||||
#include <boost/config.hpp>
|
||||
#include <boost/archive/binary_oarchive.hpp>
|
||||
#include <boost/archive/detail/polymorphic_oarchive_route.hpp>
|
||||
|
||||
namespace boost {
|
||||
namespace archive {
|
||||
|
||||
typedef detail::polymorphic_oarchive_route<
|
||||
binary_oarchive_impl<
|
||||
naked_binary_oarchive,
|
||||
std::ostream::char_type,
|
||||
std::ostream::traits_type
|
||||
>
|
||||
> polymorphic_binary_oarchive;
|
||||
|
||||
} // namespace archive
|
||||
} // namespace boost
|
||||
|
||||
// required by export
|
||||
BOOST_SERIALIZATION_REGISTER_ARCHIVE(
|
||||
boost::archive::polymorphic_binary_oarchive
|
||||
)
|
||||
|
||||
#endif // BOOST_ARCHIVE_POLYMORPHIC_BINARY_OARCHIVE_HPP
|
||||
|
||||
|
|
@ -0,0 +1,181 @@
|
|||
#ifndef BOOST_ARCHIVE_POLYMORPHIC_IARCHIVE_HPP
|
||||
#define BOOST_ARCHIVE_POLYMORPHIC_IARCHIVE_HPP
|
||||
|
||||
// MS compatible compilers support #pragma once
|
||||
#if defined(_MSC_VER) && (_MSC_VER >= 1020)
|
||||
# pragma once
|
||||
#endif
|
||||
|
||||
/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
|
||||
// polymorphic_iarchive.hpp
|
||||
|
||||
// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
|
||||
// Use, modification and distribution is subject to the Boost Software
|
||||
// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
// See http://www.boost.org for updates, documentation, and revision history.
|
||||
|
||||
#include <cstddef> // std::size_t
|
||||
#include <climits> // ULONG_MAX
|
||||
#include <string>
|
||||
|
||||
#include <boost/config.hpp>
|
||||
#if defined(BOOST_NO_STDC_NAMESPACE)
|
||||
namespace std{
|
||||
using ::size_t;
|
||||
} // namespace std
|
||||
#endif
|
||||
|
||||
#include <boost/cstdint.hpp>
|
||||
|
||||
#include <boost/serialization/pfto.hpp>
|
||||
#include <boost/archive/detail/iserializer.hpp>
|
||||
#include <boost/archive/detail/interface_iarchive.hpp>
|
||||
#include <boost/serialization/nvp.hpp>
|
||||
#include <boost/archive/detail/register_archive.hpp>
|
||||
|
||||
#include <boost/archive/detail/decl.hpp>
|
||||
#include <boost/archive/detail/abi_prefix.hpp> // must be the last header
|
||||
|
||||
namespace boost {
|
||||
template<class T>
|
||||
class shared_ptr;
|
||||
namespace serialization {
|
||||
class extended_type_info;
|
||||
} // namespace serialization
|
||||
namespace archive {
|
||||
namespace detail {
|
||||
class BOOST_ARCHIVE_DECL(BOOST_PP_EMPTY()) basic_iarchive;
|
||||
class BOOST_ARCHIVE_DECL(BOOST_PP_EMPTY()) basic_iarchive;
|
||||
}
|
||||
|
||||
class polymorphic_iarchive;
|
||||
|
||||
class polymorphic_iarchive_impl :
|
||||
public detail::interface_iarchive<polymorphic_iarchive>
|
||||
{
|
||||
#ifdef BOOST_NO_MEMBER_TEMPLATE_FRIENDS
|
||||
public:
|
||||
#else
|
||||
friend class detail::interface_iarchive<polymorphic_iarchive>;
|
||||
friend class load_access;
|
||||
#endif
|
||||
// primitive types the only ones permitted by polymorphic archives
|
||||
virtual void load(bool & t) = 0;
|
||||
|
||||
virtual void load(char & t) = 0;
|
||||
virtual void load(signed char & t) = 0;
|
||||
virtual void load(unsigned char & t) = 0;
|
||||
#ifndef BOOST_NO_CWCHAR
|
||||
#ifndef BOOST_NO_INTRINSIC_WCHAR_T
|
||||
virtual void load(wchar_t & t) = 0;
|
||||
#endif
|
||||
#endif
|
||||
virtual void load(short & t) = 0;
|
||||
virtual void load(unsigned short & t) = 0;
|
||||
virtual void load(int & t) = 0;
|
||||
virtual void load(unsigned int & t) = 0;
|
||||
virtual void load(long & t) = 0;
|
||||
virtual void load(unsigned long & t) = 0;
|
||||
|
||||
#if defined(BOOST_HAS_LONG_LONG)
|
||||
virtual void load(boost::long_long_type & t) = 0;
|
||||
virtual void load(boost::ulong_long_type & t) = 0;
|
||||
#elif defined(BOOST_HAS_MS_INT64)
|
||||
virtual void load(__int64 & t) = 0;
|
||||
virtual void load(unsigned __int64 & t) = 0;
|
||||
#endif
|
||||
|
||||
virtual void load(float & t) = 0;
|
||||
virtual void load(double & t) = 0;
|
||||
|
||||
// string types are treated as primitives
|
||||
virtual void load(std::string & t) = 0;
|
||||
#ifndef BOOST_NO_STD_WSTRING
|
||||
virtual void load(std::wstring & t) = 0;
|
||||
#endif
|
||||
|
||||
// used for xml and other tagged formats
|
||||
virtual void load_start(const char * name) = 0;
|
||||
virtual void load_end(const char * name) = 0;
|
||||
virtual void register_basic_serializer(const detail::basic_iserializer & bis) = 0;
|
||||
|
||||
// msvc and borland won't automatically pass these to the base class so
|
||||
// make it explicit here
|
||||
template<class T>
|
||||
void load_override(T & t, BOOST_PFTO int)
|
||||
{
|
||||
archive::load(* this->This(), t);
|
||||
}
|
||||
// special treatment for name-value pairs.
|
||||
template<class T>
|
||||
void load_override(
|
||||
#ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING
|
||||
const
|
||||
#endif
|
||||
boost::serialization::nvp< T > & t,
|
||||
int
|
||||
){
|
||||
load_start(t.name());
|
||||
archive::load(* this->This(), t.value());
|
||||
load_end(t.name());
|
||||
}
|
||||
protected:
|
||||
virtual ~polymorphic_iarchive_impl(){};
|
||||
public:
|
||||
// utility function implemented by all legal archives
|
||||
virtual void set_library_version(library_version_type archive_library_version) = 0;
|
||||
virtual library_version_type get_library_version() const = 0;
|
||||
virtual unsigned int get_flags() const = 0;
|
||||
virtual void delete_created_pointers() = 0;
|
||||
virtual void reset_object_address(
|
||||
const void * new_address,
|
||||
const void * old_address
|
||||
) = 0;
|
||||
|
||||
virtual void load_binary(void * t, std::size_t size) = 0;
|
||||
|
||||
// these are used by the serialization library implementation.
|
||||
virtual void load_object(
|
||||
void *t,
|
||||
const detail::basic_iserializer & bis
|
||||
) = 0;
|
||||
virtual const detail::basic_pointer_iserializer * load_pointer(
|
||||
void * & t,
|
||||
const detail::basic_pointer_iserializer * bpis_ptr,
|
||||
const detail::basic_pointer_iserializer * (*finder)(
|
||||
const boost::serialization::extended_type_info & type
|
||||
)
|
||||
) = 0;
|
||||
};
|
||||
|
||||
} // namespace archive
|
||||
} // namespace boost
|
||||
|
||||
#include <boost/archive/detail/abi_suffix.hpp> // pops abi_suffix.hpp pragmas
|
||||
|
||||
// note special treatment of shared_ptr. This type needs a special
|
||||
// structure associated with every archive. We created a "mix-in"
|
||||
// class to provide this functionality. Since shared_ptr holds a
|
||||
// special esteem in the boost library - we included it here by default.
|
||||
#include <boost/archive/shared_ptr_helper.hpp>
|
||||
|
||||
namespace boost {
|
||||
namespace archive {
|
||||
|
||||
class polymorphic_iarchive :
|
||||
public polymorphic_iarchive_impl,
|
||||
public detail::shared_ptr_helper
|
||||
{
|
||||
public:
|
||||
virtual ~polymorphic_iarchive(){};
|
||||
};
|
||||
|
||||
} // namespace archive
|
||||
} // namespace boost
|
||||
|
||||
// required by export
|
||||
BOOST_SERIALIZATION_REGISTER_ARCHIVE(boost::archive::polymorphic_iarchive)
|
||||
|
||||
#endif // BOOST_ARCHIVE_POLYMORPHIC_IARCHIVE_HPP
|
||||
|
|
@ -0,0 +1,159 @@
|
|||
#ifndef BOOST_ARCHIVE_POLYMORPHIC_OARCHIVE_HPP
|
||||
#define BOOST_ARCHIVE_POLYMORPHIC_OARCHIVE_HPP
|
||||
|
||||
// MS compatible compilers support #pragma once
|
||||
#if defined(_MSC_VER) && (_MSC_VER >= 1020)
|
||||
# pragma once
|
||||
#endif
|
||||
|
||||
/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
|
||||
// polymorphic_oarchive.hpp
|
||||
|
||||
// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
|
||||
// Use, modification and distribution is subject to the Boost Software
|
||||
// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
// See http://www.boost.org for updates, documentation, and revision history.
|
||||
|
||||
#include <cstddef> // size_t
|
||||
#include <climits> // ULONG_MAX
|
||||
#include <string>
|
||||
|
||||
#include <boost/config.hpp>
|
||||
#if defined(BOOST_NO_STDC_NAMESPACE)
|
||||
namespace std{
|
||||
using ::size_t;
|
||||
} // namespace std
|
||||
#endif
|
||||
|
||||
#include <boost/cstdint.hpp>
|
||||
#include <boost/serialization/pfto.hpp>
|
||||
#include <boost/archive/detail/oserializer.hpp>
|
||||
#include <boost/archive/detail/interface_oarchive.hpp>
|
||||
#include <boost/serialization/nvp.hpp>
|
||||
#include <boost/archive/detail/register_archive.hpp>
|
||||
|
||||
#include <boost/archive/detail/decl.hpp>
|
||||
#include <boost/archive/detail/abi_prefix.hpp> // must be the last header
|
||||
|
||||
namespace boost {
|
||||
template<class T>
|
||||
class shared_ptr;
|
||||
namespace serialization {
|
||||
class extended_type_info;
|
||||
} // namespace serialization
|
||||
namespace archive {
|
||||
namespace detail {
|
||||
class BOOST_ARCHIVE_DECL(BOOST_PP_EMPTY()) basic_oarchive;
|
||||
class BOOST_ARCHIVE_DECL(BOOST_PP_EMPTY()) basic_oserializer;
|
||||
}
|
||||
|
||||
class polymorphic_oarchive;
|
||||
|
||||
class polymorphic_oarchive_impl :
|
||||
public detail::interface_oarchive<polymorphic_oarchive>
|
||||
{
|
||||
#ifdef BOOST_NO_MEMBER_TEMPLATE_FRIENDS
|
||||
public:
|
||||
#else
|
||||
friend class detail::interface_oarchive<polymorphic_oarchive>;
|
||||
friend class save_access;
|
||||
#endif
|
||||
// primitive types the only ones permitted by polymorphic archives
|
||||
virtual void save(const bool t) = 0;
|
||||
|
||||
virtual void save(const char t) = 0;
|
||||
virtual void save(const signed char t) = 0;
|
||||
virtual void save(const unsigned char t) = 0;
|
||||
#ifndef BOOST_NO_CWCHAR
|
||||
#ifndef BOOST_NO_INTRINSIC_WCHAR_T
|
||||
virtual void save(const wchar_t t) = 0;
|
||||
#endif
|
||||
#endif
|
||||
virtual void save(const short t) = 0;
|
||||
virtual void save(const unsigned short t) = 0;
|
||||
virtual void save(const int t) = 0;
|
||||
virtual void save(const unsigned int t) = 0;
|
||||
virtual void save(const long t) = 0;
|
||||
virtual void save(const unsigned long t) = 0;
|
||||
|
||||
#if defined(BOOST_HAS_LONG_LONG)
|
||||
virtual void save(const boost::long_long_type t) = 0;
|
||||
virtual void save(const boost::ulong_long_type t) = 0;
|
||||
#elif defined(BOOST_HAS_MS_INT64)
|
||||
virtual void save(const __int64 t) = 0;
|
||||
virtual void save(const unsigned __int64 t) = 0;
|
||||
#endif
|
||||
|
||||
virtual void save(const float t) = 0;
|
||||
virtual void save(const double t) = 0;
|
||||
|
||||
// string types are treated as primitives
|
||||
virtual void save(const std::string & t) = 0;
|
||||
#ifndef BOOST_NO_STD_WSTRING
|
||||
virtual void save(const std::wstring & t) = 0;
|
||||
#endif
|
||||
|
||||
virtual void save_null_pointer() = 0;
|
||||
// used for xml and other tagged formats
|
||||
virtual void save_start(const char * name) = 0;
|
||||
virtual void save_end(const char * name) = 0;
|
||||
virtual void register_basic_serializer(const detail::basic_oserializer & bos) = 0;
|
||||
|
||||
virtual void end_preamble() = 0;
|
||||
|
||||
// msvc and borland won't automatically pass these to the base class so
|
||||
// make it explicit here
|
||||
template<class T>
|
||||
void save_override(T & t, BOOST_PFTO int)
|
||||
{
|
||||
archive::save(* this->This(), t);
|
||||
}
|
||||
// special treatment for name-value pairs.
|
||||
template<class T>
|
||||
void save_override(
|
||||
#ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING
|
||||
const
|
||||
#endif
|
||||
::boost::serialization::nvp< T > & t, int
|
||||
){
|
||||
save_start(t.name());
|
||||
archive::save(* this->This(), t.const_value());
|
||||
save_end(t.name());
|
||||
}
|
||||
protected:
|
||||
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 void save_binary(const void * t, std::size_t size) = 0;
|
||||
|
||||
virtual void save_object(
|
||||
const void *x,
|
||||
const detail::basic_oserializer & bos
|
||||
) = 0;
|
||||
virtual void save_pointer(
|
||||
const void * t,
|
||||
const detail::basic_pointer_oserializer * bpos_ptr
|
||||
) = 0;
|
||||
};
|
||||
|
||||
// note: preserve naming symmetry
|
||||
class polymorphic_oarchive :
|
||||
public polymorphic_oarchive_impl
|
||||
{
|
||||
public:
|
||||
virtual ~polymorphic_oarchive(){};
|
||||
};
|
||||
|
||||
} // namespace archive
|
||||
} // namespace boost
|
||||
|
||||
// required by export
|
||||
BOOST_SERIALIZATION_REGISTER_ARCHIVE(boost::archive::polymorphic_oarchive)
|
||||
|
||||
#include <boost/archive/detail/abi_suffix.hpp> // pops abi_suffix.hpp pragmas
|
||||
|
||||
#endif // BOOST_ARCHIVE_POLYMORPHIC_OARCHIVE_HPP
|
||||
|
|
@ -0,0 +1,54 @@
|
|||
#ifndef BOOST_ARCHIVE_POLYMORPHIC_TEXT_IARCHIVE_HPP
|
||||
#define BOOST_ARCHIVE_POLYMORPHIC_TEXT_IARCHIVE_HPP
|
||||
|
||||
// MS compatible compilers support #pragma once
|
||||
#if defined(_MSC_VER) && (_MSC_VER >= 1020)
|
||||
# pragma once
|
||||
#endif
|
||||
|
||||
/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
|
||||
// polymorphic_text_iarchive.hpp
|
||||
|
||||
// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
|
||||
// Use, modification and distribution is subject to the Boost Software
|
||||
// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
// See http://www.boost.org for updates, documentation, and revision history.
|
||||
|
||||
#include <boost/config.hpp>
|
||||
#include <boost/archive/text_iarchive.hpp>
|
||||
#include <boost/archive/detail/polymorphic_iarchive_route.hpp>
|
||||
|
||||
#ifdef BOOST_MSVC
|
||||
# pragma warning(push)
|
||||
# pragma warning(disable : 4511 4512)
|
||||
#endif
|
||||
|
||||
namespace boost {
|
||||
namespace archive {
|
||||
|
||||
class polymorphic_text_iarchive :
|
||||
public detail::polymorphic_iarchive_route<naked_text_iarchive>
|
||||
{
|
||||
public:
|
||||
polymorphic_text_iarchive(std::istream & is, unsigned int flags = 0) :
|
||||
detail::polymorphic_iarchive_route<naked_text_iarchive>(is, flags)
|
||||
{}
|
||||
~polymorphic_text_iarchive(){}
|
||||
};
|
||||
|
||||
} // namespace archive
|
||||
} // namespace boost
|
||||
|
||||
#ifdef BOOST_MSVC
|
||||
#pragma warning(pop)
|
||||
#endif
|
||||
|
||||
// required by export
|
||||
BOOST_SERIALIZATION_REGISTER_ARCHIVE(
|
||||
boost::archive::polymorphic_text_iarchive
|
||||
)
|
||||
|
||||
#endif // BOOST_ARCHIVE_POLYMORPHIC_TEXT_IARCHIVE_HPP
|
||||
|
||||
|
|
@ -0,0 +1,39 @@
|
|||
#ifndef BOOST_ARCHIVE_POLYMORPHIC_TEXT_OARCHIVE_HPP
|
||||
#define BOOST_ARCHIVE_POLYMORPHIC_TEXT_OARCHIVE_HPP
|
||||
|
||||
// MS compatible compilers support #pragma once
|
||||
#if defined(_MSC_VER) && (_MSC_VER >= 1020)
|
||||
# pragma once
|
||||
#endif
|
||||
|
||||
/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
|
||||
// polymorphic_text_oarchive.hpp
|
||||
|
||||
// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
|
||||
// Use, modification and distribution is subject to the Boost Software
|
||||
// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
// See http://www.boost.org for updates, documentation, and revision history.
|
||||
|
||||
#include <boost/config.hpp>
|
||||
#include <boost/archive/text_oarchive.hpp>
|
||||
#include <boost/archive/detail/polymorphic_oarchive_route.hpp>
|
||||
|
||||
namespace boost {
|
||||
namespace archive {
|
||||
|
||||
typedef detail::polymorphic_oarchive_route<
|
||||
text_oarchive_impl<naked_text_oarchive>
|
||||
> polymorphic_text_oarchive;
|
||||
|
||||
} // namespace archive
|
||||
} // namespace boost
|
||||
|
||||
// required by export
|
||||
BOOST_SERIALIZATION_REGISTER_ARCHIVE(
|
||||
boost::archive::polymorphic_text_oarchive
|
||||
)
|
||||
|
||||
#endif // BOOST_ARCHIVE_POLYMORPHIC_TEXT_OARCHIVE_HPP
|
||||
|
||||
|
|
@ -0,0 +1,59 @@
|
|||
#ifndef BOOST_ARCHIVE_POLYMORPHIC_TEXT_WIARCHIVE_HPP
|
||||
#define BOOST_ARCHIVE_POLYMORPHIC_TEXT_WIARCHIVE_HPP
|
||||
|
||||
// MS compatible compilers support #pragma once
|
||||
#if defined(_MSC_VER) && (_MSC_VER >= 1020)
|
||||
# pragma once
|
||||
#endif
|
||||
|
||||
/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
|
||||
// polymorphic_text_wiarchive.hpp
|
||||
|
||||
// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
|
||||
// Use, modification and distribution is subject to the Boost Software
|
||||
// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
// See http://www.boost.org for updates, documentation, and revision history.
|
||||
|
||||
#include <boost/config.hpp>
|
||||
#ifdef BOOST_NO_STD_WSTREAMBUF
|
||||
#error "wide char i/o not supported on this platform"
|
||||
#else
|
||||
|
||||
#include <boost/archive/text_wiarchive.hpp>
|
||||
#include <boost/archive/detail/polymorphic_iarchive_route.hpp>
|
||||
|
||||
#ifdef BOOST_MSVC
|
||||
# pragma warning(push)
|
||||
# pragma warning(disable : 4511 4512)
|
||||
#endif
|
||||
|
||||
namespace boost {
|
||||
namespace archive {
|
||||
|
||||
class polymorphic_text_wiarchive :
|
||||
public detail::polymorphic_iarchive_route<naked_text_wiarchive>
|
||||
{
|
||||
public:
|
||||
polymorphic_text_wiarchive(std::wistream & is, unsigned int flags = 0) :
|
||||
detail::polymorphic_iarchive_route<naked_text_wiarchive>(is, flags)
|
||||
{}
|
||||
~polymorphic_text_wiarchive(){}
|
||||
};
|
||||
|
||||
} // namespace archive
|
||||
} // namespace boost
|
||||
|
||||
#ifdef BOOST_MSVC
|
||||
#pragma warning(pop)
|
||||
#endif
|
||||
|
||||
// required by export
|
||||
BOOST_SERIALIZATION_REGISTER_ARCHIVE(
|
||||
boost::archive::polymorphic_text_wiarchive
|
||||
)
|
||||
|
||||
#endif // BOOST_NO_STD_WSTREAMBUF
|
||||
#endif // BOOST_ARCHIVE_POLYMORPHIC_TEXT_WIARCHIVE_HPP
|
||||
|
||||
|
|
@ -0,0 +1,44 @@
|
|||
#ifndef BOOST_ARCHIVE_POLYMORPHIC_TEXT_WOARCHIVE_HPP
|
||||
#define BOOST_ARCHIVE_POLYMORPHIC_TEXT_WOARCHIVE_HPP
|
||||
|
||||
// MS compatible compilers support #pragma once
|
||||
#if defined(_MSC_VER) && (_MSC_VER >= 1020)
|
||||
# pragma once
|
||||
#endif
|
||||
|
||||
/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
|
||||
// polymorphic_text_oarchive.hpp
|
||||
|
||||
// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
|
||||
// Use, modification and distribution is subject to the Boost Software
|
||||
// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
// See http://www.boost.org for updates, documentation, and revision history.
|
||||
|
||||
#include <boost/config.hpp>
|
||||
#ifdef BOOST_NO_STD_WSTREAMBUF
|
||||
#error "wide char i/o not supported on this platform"
|
||||
#else
|
||||
|
||||
#include <boost/archive/text_woarchive.hpp>
|
||||
#include <boost/archive/detail/polymorphic_oarchive_route.hpp>
|
||||
|
||||
namespace boost {
|
||||
namespace archive {
|
||||
|
||||
typedef detail::polymorphic_oarchive_route<
|
||||
text_woarchive_impl<naked_text_woarchive>
|
||||
> polymorphic_text_woarchive;
|
||||
|
||||
} // namespace archive
|
||||
} // namespace boost
|
||||
|
||||
// required by export
|
||||
BOOST_SERIALIZATION_REGISTER_ARCHIVE(
|
||||
boost::archive::polymorphic_text_woarchive
|
||||
)
|
||||
|
||||
#endif // BOOST_NO_STD_WSTREAMBUF
|
||||
#endif // BOOST_ARCHIVE_POLYMORPHIC_TEXT_WOARCHIVE_HPP
|
||||
|
||||
|
|
@ -0,0 +1,54 @@
|
|||
#ifndef BOOST_ARCHIVE_POLYMORPHIC_XML_IARCHIVE_HPP
|
||||
#define BOOST_ARCHIVE_POLYMORPHIC_XML_IARCHIVE_HPP
|
||||
|
||||
// MS compatible compilers support #pragma once
|
||||
#if defined(_MSC_VER) && (_MSC_VER >= 1020)
|
||||
# pragma once
|
||||
#endif
|
||||
|
||||
/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
|
||||
// polymorphic_xml_iarchive.hpp
|
||||
|
||||
// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
|
||||
// Use, modification and distribution is subject to the Boost Software
|
||||
// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
// See http://www.boost.org for updates, documentation, and revision history.
|
||||
|
||||
#include <boost/config.hpp>
|
||||
#include <boost/archive/xml_iarchive.hpp>
|
||||
#include <boost/archive/detail/polymorphic_iarchive_route.hpp>
|
||||
|
||||
#ifdef BOOST_MSVC
|
||||
# pragma warning(push)
|
||||
# pragma warning(disable : 4511 4512)
|
||||
#endif
|
||||
|
||||
namespace boost {
|
||||
namespace archive {
|
||||
|
||||
class polymorphic_xml_iarchive :
|
||||
public detail::polymorphic_iarchive_route<naked_xml_iarchive>
|
||||
{
|
||||
public:
|
||||
polymorphic_xml_iarchive(std::istream & is, unsigned int flags = 0) :
|
||||
detail::polymorphic_iarchive_route<naked_xml_iarchive>(is, flags)
|
||||
{}
|
||||
~polymorphic_xml_iarchive(){}
|
||||
};
|
||||
|
||||
} // namespace archive
|
||||
} // namespace boost
|
||||
|
||||
#ifdef BOOST_MSVC
|
||||
#pragma warning(pop)
|
||||
#endif
|
||||
|
||||
// required by export
|
||||
BOOST_SERIALIZATION_REGISTER_ARCHIVE(
|
||||
boost::archive::polymorphic_xml_iarchive
|
||||
)
|
||||
|
||||
#endif // BOOST_ARCHIVE_POLYMORPHIC_XML_IARCHIVE_HPP
|
||||
|
||||
|
|
@ -0,0 +1,39 @@
|
|||
#ifndef BOOST_ARCHIVE_POLYMORPHIC_XML_OARCHIVE_HPP
|
||||
#define BOOST_ARCHIVE_POLYMORPHIC_XML_OARCHIVE_HPP
|
||||
|
||||
// MS compatible compilers support #pragma once
|
||||
#if defined(_MSC_VER) && (_MSC_VER >= 1020)
|
||||
# pragma once
|
||||
#endif
|
||||
|
||||
/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
|
||||
// polymorphic_xml_oarchive.hpp
|
||||
|
||||
// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
|
||||
// Use, modification and distribution is subject to the Boost Software
|
||||
// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
// See http://www.boost.org for updates, documentation, and revision history.
|
||||
|
||||
#include <boost/config.hpp>
|
||||
#include <boost/archive/xml_oarchive.hpp>
|
||||
#include <boost/archive/detail/polymorphic_oarchive_route.hpp>
|
||||
|
||||
namespace boost {
|
||||
namespace archive {
|
||||
|
||||
typedef detail::polymorphic_oarchive_route<
|
||||
xml_oarchive_impl<naked_xml_oarchive>
|
||||
> polymorphic_xml_oarchive;
|
||||
|
||||
} // namespace archive
|
||||
} // namespace boost
|
||||
|
||||
// required by export
|
||||
BOOST_SERIALIZATION_REGISTER_ARCHIVE(
|
||||
boost::archive::polymorphic_xml_oarchive
|
||||
)
|
||||
|
||||
#endif // BOOST_ARCHIVE_POLYMORPHIC_XML_OARCHIVE_HPP
|
||||
|
||||
|
|
@ -0,0 +1,50 @@
|
|||
#ifndef BOOST_ARCHIVE_POLYMORPHIC_XML_WIARCHIVE_HPP
|
||||
#define BOOST_ARCHIVE_POLYMORPHIC_XML_WIARCHIVE_HPP
|
||||
|
||||
// MS compatible compilers support #pragma once
|
||||
#if defined(_MSC_VER) && (_MSC_VER >= 1020)
|
||||
# pragma once
|
||||
#endif
|
||||
|
||||
/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
|
||||
// polymorphic_xml_wiarchive.hpp
|
||||
|
||||
// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
|
||||
// Use, modification and distribution is subject to the Boost Software
|
||||
// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
// See http://www.boost.org for updates, documentation, and revision history.
|
||||
|
||||
#include <boost/config.hpp>
|
||||
#ifdef BOOST_NO_STD_WSTREAMBUF
|
||||
#error "wide char i/o not supported on this platform"
|
||||
#else
|
||||
|
||||
#include <boost/archive/xml_wiarchive.hpp>
|
||||
#include <boost/archive/detail/polymorphic_iarchive_route.hpp>
|
||||
|
||||
namespace boost {
|
||||
namespace archive {
|
||||
|
||||
class polymorphic_xml_wiarchive :
|
||||
public detail::polymorphic_iarchive_route<naked_xml_wiarchive>
|
||||
{
|
||||
public:
|
||||
polymorphic_xml_wiarchive(std::wistream & is, unsigned int flags = 0) :
|
||||
detail::polymorphic_iarchive_route<naked_xml_wiarchive>(is, flags)
|
||||
{}
|
||||
~polymorphic_xml_wiarchive(){}
|
||||
};
|
||||
|
||||
} // namespace archive
|
||||
} // namespace boost
|
||||
|
||||
// required by export
|
||||
BOOST_SERIALIZATION_REGISTER_ARCHIVE(
|
||||
boost::archive::polymorphic_xml_wiarchive
|
||||
)
|
||||
|
||||
#endif // BOOST_NO_STD_WSTREAMBUF
|
||||
#endif // BOOST_ARCHIVE_POLYMORPHIC_XML_WIARCHIVE_HPP
|
||||
|
||||
|
|
@ -0,0 +1,44 @@
|
|||
#ifndef BOOST_ARCHIVE_POLYMORPHIC_XML_WOARCHIVE_HPP
|
||||
#define BOOST_ARCHIVE_POLYMORPHIC_XML_WOARCHIVE_HPP
|
||||
|
||||
// MS compatible compilers support #pragma once
|
||||
#if defined(_MSC_VER) && (_MSC_VER >= 1020)
|
||||
# pragma once
|
||||
#endif
|
||||
|
||||
/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
|
||||
// polymorphic_xml_oarchive.hpp
|
||||
|
||||
// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
|
||||
// Use, modification and distribution is subject to the Boost Software
|
||||
// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
// See http://www.boost.org for updates, documentation, and revision history.
|
||||
|
||||
#include <boost/config.hpp>
|
||||
#ifdef BOOST_NO_STD_WSTREAMBUF
|
||||
#error "wide char i/o not supported on this platform"
|
||||
#else
|
||||
|
||||
#include <boost/archive/xml_woarchive.hpp>
|
||||
#include <boost/archive/detail/polymorphic_oarchive_route.hpp>
|
||||
|
||||
namespace boost {
|
||||
namespace archive {
|
||||
|
||||
typedef detail::polymorphic_oarchive_route<
|
||||
xml_woarchive_impl<naked_xml_woarchive>
|
||||
> polymorphic_xml_woarchive;
|
||||
|
||||
} // namespace archive
|
||||
} // namespace boost
|
||||
|
||||
// required by export
|
||||
BOOST_SERIALIZATION_REGISTER_ARCHIVE(
|
||||
boost::archive::polymorphic_xml_woarchive
|
||||
)
|
||||
|
||||
#endif // BOOST_NO_STD_WSTREAMBUF
|
||||
#endif // BOOST_ARCHIVE_POLYMORPHIC_XML_WOARCHIVE_HPP
|
||||
|
||||
Some files were not shown because too many files have changed in this diff Show More
Loading…
Reference in New Issue