mirror of
https://github.com/wheremyfoodat/Panda3DS.git
synced 2025-04-22 21:35:51 +12:00
Initial commit (I really need to remove Boost)
This commit is contained in:
wheremyfoodat
commit
b5371dc66c
3226 changed files with 668081 additions and 0 deletions
154
third_party/boost/libs/serialization/src/archive_exception.cpp
vendored
Normal file
154
third_party/boost/libs/serialization/src/archive_exception.cpp
vendored
Normal file
|
|
@ -0,0 +1,154 @@
|
|||
/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
|
||||
// archive_exception.cpp:
|
||||
|
||||
// (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.
|
||||
|
||||
#if (defined _MSC_VER) && (_MSC_VER == 1200)
|
||||
# pragma warning (disable : 4786) // too long name, harmless warning
|
||||
#endif
|
||||
|
||||
#include <exception>
|
||||
#include <string>
|
||||
#include <cstring>
|
||||
|
||||
#define BOOST_ARCHIVE_SOURCE
|
||||
#include <boost/serialization/config.hpp>
|
||||
#include <boost/archive/archive_exception.hpp>
|
||||
|
||||
namespace boost {
|
||||
namespace archive {
|
||||
|
||||
BOOST_ARCHIVE_DECL
|
||||
unsigned int
|
||||
archive_exception::append(unsigned int l, const char * a){
|
||||
while(l < (sizeof(m_buffer) - 1)){
|
||||
char c = *a++;
|
||||
if('\0' == c)
|
||||
break;
|
||||
m_buffer[l++] = c;
|
||||
}
|
||||
m_buffer[l] = '\0';
|
||||
return l;
|
||||
}
|
||||
|
||||
BOOST_ARCHIVE_DECL
|
||||
archive_exception::archive_exception(
|
||||
exception_code c,
|
||||
const char * e1,
|
||||
const char * e2
|
||||
) BOOST_NOEXCEPT :
|
||||
code(c)
|
||||
{
|
||||
unsigned int length = 0;
|
||||
switch(code){
|
||||
case no_exception:
|
||||
length = append(length, "uninitialized exception");
|
||||
break;
|
||||
case unregistered_class:
|
||||
length = append(length, "unregistered class");
|
||||
if(NULL != e1){
|
||||
length = append(length, " - ");
|
||||
length = append(length, e1);
|
||||
}
|
||||
break;
|
||||
case invalid_signature:
|
||||
length = append(length, "invalid signature");
|
||||
break;
|
||||
case unsupported_version:
|
||||
length = append(length, "unsupported version");
|
||||
break;
|
||||
case pointer_conflict:
|
||||
length = append(length, "pointer conflict");
|
||||
break;
|
||||
case incompatible_native_format:
|
||||
length = append(length, "incompatible native format");
|
||||
if(NULL != e1){
|
||||
length = append(length, " - ");
|
||||
length = append(length, e1);
|
||||
}
|
||||
break;
|
||||
case array_size_too_short:
|
||||
length = append(length, "array size too short");
|
||||
break;
|
||||
case input_stream_error:
|
||||
length = append(length, "input stream error");
|
||||
if(NULL != e1){
|
||||
length = append(length, "-");
|
||||
length = append(length, e1);
|
||||
}
|
||||
if(NULL != e2){
|
||||
length = append(length, "-");
|
||||
length = append(length, e2);
|
||||
}
|
||||
break;
|
||||
case invalid_class_name:
|
||||
length = append(length, "class name too long");
|
||||
break;
|
||||
case unregistered_cast:
|
||||
length = append(length, "unregistered void cast ");
|
||||
length = append(length, (NULL != e1) ? e1 : "?");
|
||||
length = append(length, "<-");
|
||||
length = append(length, (NULL != e2) ? e2 : "?");
|
||||
break;
|
||||
case unsupported_class_version:
|
||||
length = append(length, "class version ");
|
||||
length = append(length, (NULL != e1) ? e1 : "<unknown class>");
|
||||
break;
|
||||
case other_exception:
|
||||
// if get here - it indicates a derived exception
|
||||
// was sliced by passing by value in catch
|
||||
length = append(length, "unknown derived exception");
|
||||
break;
|
||||
case multiple_code_instantiation:
|
||||
length = append(length, "code instantiated in more than one module");
|
||||
if(NULL != e1){
|
||||
length = append(length, " - ");
|
||||
length = append(length, e1);
|
||||
}
|
||||
break;
|
||||
case output_stream_error:
|
||||
length = append(length, "output stream error");
|
||||
if(NULL != e1){
|
||||
length = append(length, "-");
|
||||
length = append(length, e1);
|
||||
}
|
||||
if(NULL != e2){
|
||||
length = append(length, "-");
|
||||
length = append(length, e2);
|
||||
}
|
||||
break;
|
||||
default:
|
||||
BOOST_ASSERT(false);
|
||||
length = append(length, "programming error");
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
BOOST_ARCHIVE_DECL
|
||||
archive_exception::archive_exception(archive_exception const & oth) BOOST_NOEXCEPT :
|
||||
std::exception(oth),
|
||||
code(oth.code)
|
||||
{
|
||||
std::memcpy(m_buffer,oth.m_buffer,sizeof m_buffer);
|
||||
}
|
||||
|
||||
BOOST_ARCHIVE_DECL
|
||||
archive_exception::~archive_exception() BOOST_NOEXCEPT_OR_NOTHROW {}
|
||||
|
||||
BOOST_ARCHIVE_DECL const char *
|
||||
archive_exception::what() const BOOST_NOEXCEPT_OR_NOTHROW {
|
||||
return m_buffer;
|
||||
}
|
||||
|
||||
BOOST_ARCHIVE_DECL
|
||||
archive_exception::archive_exception() BOOST_NOEXCEPT :
|
||||
code(no_exception)
|
||||
{}
|
||||
|
||||
} // archive
|
||||
} // boost
|
||||
90
third_party/boost/libs/serialization/src/basic_archive.cpp
vendored
Normal file
90
third_party/boost/libs/serialization/src/basic_archive.cpp
vendored
Normal file
|
|
@ -0,0 +1,90 @@
|
|||
/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
|
||||
// basic_archive.cpp:
|
||||
|
||||
// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
|
||||
// Use, modification and distribution is subject to the 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.
|
||||
|
||||
//////////////////////////////////////////////////////////////////////
|
||||
//
|
||||
// objects are stored as
|
||||
//
|
||||
// class_id* // -1 for a null pointer
|
||||
// if a new class id
|
||||
// [
|
||||
// exported key - class name*
|
||||
// tracking level - always/never
|
||||
// class version
|
||||
// ]
|
||||
//
|
||||
// if tracking
|
||||
// [
|
||||
// object_id
|
||||
// ]
|
||||
//
|
||||
// [ // if a new object id
|
||||
// data...
|
||||
// ]
|
||||
//
|
||||
// * required only for pointers - optional for objects
|
||||
|
||||
#define BOOST_ARCHIVE_SOURCE
|
||||
#include <boost/serialization/config.hpp>
|
||||
#include <boost/archive/basic_archive.hpp>
|
||||
|
||||
namespace boost {
|
||||
namespace archive {
|
||||
|
||||
///////////////////////////////////////////////////////////////////////
|
||||
// constants used in archive signature
|
||||
//This should never ever change. note that is not an std::string
|
||||
// string.
|
||||
BOOST_SYMBOL_VISIBLE const char *
|
||||
BOOST_ARCHIVE_SIGNATURE(){
|
||||
return "serialization::archive";
|
||||
}
|
||||
|
||||
// this should change if the capabilities are added to the library
|
||||
// such that archives can be created which can't be read by previous
|
||||
// versions of this library
|
||||
// 1 - initial version
|
||||
// 2 - made address tracking optional
|
||||
// 3 - numerous changes - can't guarentee compatibility with previous versions
|
||||
// 4 - Boost 1.34
|
||||
// added item_version to properly support versioning for collections
|
||||
// 5 - Boost 1.36
|
||||
// changed serialization of collections: adding version even for primitive
|
||||
// types caused backwards compatibility breaking change in 1.35
|
||||
// 6 - Boost 1.41 17 Nov 2009
|
||||
// serializing collection sizes as std::size_t
|
||||
// 7 Boost 1.42 2 Feb 2010
|
||||
// error - changed binary version to 16 bits w/o changing library version #
|
||||
// That is - binary archives are recorded with #6 even though they are
|
||||
// different from the previous versions. This means that binary archives
|
||||
// created with versions 1.42 and 1.43 will have to be fixed with a special
|
||||
// program which fixes the library version # in the header
|
||||
// Boost 1.43 6 May 2010
|
||||
// no change
|
||||
// 8 - Boost 1.44
|
||||
// separated version_type into library_version_type and class_version_type
|
||||
// changed version_type to be stored as 8 bits.
|
||||
// 10- fixed base64 output/input.
|
||||
// 11- not changes
|
||||
// 12- improved serialization of collections
|
||||
// 13- simplified visibility, removed Borland, removed pfto
|
||||
// 14- improved visibility, refactor map/set
|
||||
// 15- corrections to optional and collection loading
|
||||
// 16- eliminated dependency on <codecvt> which is buggy in some libraries
|
||||
// and now officially deprecated in the standard
|
||||
// 17- Boost 1.68 August 2018
|
||||
|
||||
BOOST_SYMBOL_VISIBLE library_version_type
|
||||
BOOST_ARCHIVE_VERSION(){
|
||||
return library_version_type(17);
|
||||
}
|
||||
|
||||
} // namespace archive
|
||||
} // namespace boost
|
||||
599
third_party/boost/libs/serialization/src/basic_iarchive.cpp
vendored
Normal file
599
third_party/boost/libs/serialization/src/basic_iarchive.cpp
vendored
Normal file
|
|
@ -0,0 +1,599 @@
|
|||
/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
|
||||
// basic_archive.cpp:
|
||||
|
||||
// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
|
||||
// Use, modification and distribution is subject to the 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> // msvc 6.0 needs this to suppress warnings
|
||||
|
||||
#include <boost/assert.hpp>
|
||||
#include <set>
|
||||
#include <list>
|
||||
#include <vector>
|
||||
#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/integer_traits.hpp>
|
||||
|
||||
#define BOOST_ARCHIVE_SOURCE
|
||||
// include this to prevent linker errors when the
|
||||
// same modules are marked export and import.
|
||||
#define BOOST_SERIALIZATION_SOURCE
|
||||
#include <boost/serialization/config.hpp>
|
||||
|
||||
#include <boost/serialization/state_saver.hpp>
|
||||
#include <boost/serialization/throw_exception.hpp>
|
||||
#include <boost/serialization/tracking.hpp>
|
||||
|
||||
#include <boost/archive/archive_exception.hpp>
|
||||
#include <boost/archive/detail/decl.hpp>
|
||||
#include <boost/archive/basic_archive.hpp>
|
||||
#include <boost/archive/detail/basic_iserializer.hpp>
|
||||
#include <boost/archive/detail/basic_pointer_iserializer.hpp>
|
||||
#include <boost/archive/detail/basic_iarchive.hpp>
|
||||
|
||||
#include <boost/archive/detail/auto_link_archive.hpp>
|
||||
|
||||
using namespace boost::serialization;
|
||||
|
||||
namespace boost {
|
||||
namespace archive {
|
||||
namespace detail {
|
||||
|
||||
class basic_iarchive_impl {
|
||||
friend class basic_iarchive;
|
||||
library_version_type m_archive_library_version;
|
||||
unsigned int m_flags;
|
||||
|
||||
//////////////////////////////////////////////////////////////////////
|
||||
// information about each serialized object loaded
|
||||
// indexed on object_id
|
||||
struct aobject
|
||||
{
|
||||
void * address;
|
||||
bool loaded_as_pointer;
|
||||
class_id_type class_id;
|
||||
aobject(
|
||||
void *a,
|
||||
class_id_type class_id_
|
||||
) :
|
||||
address(a),
|
||||
loaded_as_pointer(false),
|
||||
class_id(class_id_)
|
||||
{}
|
||||
aobject() :
|
||||
address(NULL),
|
||||
loaded_as_pointer(false),
|
||||
class_id(-2)
|
||||
{}
|
||||
};
|
||||
typedef std::vector<aobject> object_id_vector_type;
|
||||
object_id_vector_type object_id_vector;
|
||||
|
||||
//////////////////////////////////////////////////////////////////////
|
||||
// used to implement the reset_object_address operation.
|
||||
struct moveable_objects {
|
||||
object_id_type start;
|
||||
object_id_type end;
|
||||
object_id_type recent;
|
||||
bool is_pointer;
|
||||
moveable_objects() :
|
||||
start(0),
|
||||
end(0),
|
||||
recent(0),
|
||||
is_pointer(false)
|
||||
{}
|
||||
} m_moveable_objects;
|
||||
|
||||
void reset_object_address(
|
||||
const void * new_address,
|
||||
const void *old_address
|
||||
);
|
||||
|
||||
//////////////////////////////////////////////////////////////////////
|
||||
// used by load object to look up class id given basic_serializer
|
||||
struct cobject_type
|
||||
{
|
||||
const basic_iserializer * m_bis;
|
||||
const class_id_type m_class_id;
|
||||
cobject_type(
|
||||
std::size_t class_id,
|
||||
const basic_iserializer & bis
|
||||
) :
|
||||
m_bis(& bis),
|
||||
m_class_id(class_id)
|
||||
{}
|
||||
cobject_type(const cobject_type & rhs) :
|
||||
m_bis(rhs.m_bis),
|
||||
m_class_id(rhs.m_class_id)
|
||||
{}
|
||||
// the following cannot be defined because of the const
|
||||
// member. This will generate a link error if an attempt
|
||||
// is made to assign. This should never be necessary
|
||||
cobject_type & operator=(const cobject_type & rhs);
|
||||
bool operator<(const cobject_type &rhs) const
|
||||
{
|
||||
return *m_bis < *(rhs.m_bis);
|
||||
}
|
||||
};
|
||||
typedef std::set<cobject_type> cobject_info_set_type;
|
||||
cobject_info_set_type cobject_info_set;
|
||||
|
||||
//////////////////////////////////////////////////////////////////////
|
||||
// information about each serialized class indexed on class_id
|
||||
class cobject_id
|
||||
{
|
||||
public:
|
||||
cobject_id & operator=(const cobject_id & rhs){
|
||||
bis_ptr = rhs.bis_ptr;
|
||||
bpis_ptr = rhs.bpis_ptr;
|
||||
file_version = rhs.file_version;
|
||||
tracking_level = rhs.tracking_level;
|
||||
initialized = rhs.initialized;
|
||||
return *this;
|
||||
}
|
||||
const basic_iserializer * bis_ptr;
|
||||
const basic_pointer_iserializer * bpis_ptr;
|
||||
version_type file_version;
|
||||
tracking_type tracking_level;
|
||||
bool initialized;
|
||||
|
||||
cobject_id(const basic_iserializer & bis_) :
|
||||
bis_ptr(& bis_),
|
||||
bpis_ptr(NULL),
|
||||
file_version(0),
|
||||
tracking_level(track_never),
|
||||
initialized(false)
|
||||
{}
|
||||
cobject_id(const cobject_id &rhs):
|
||||
bis_ptr(rhs.bis_ptr),
|
||||
bpis_ptr(rhs.bpis_ptr),
|
||||
file_version(rhs.file_version),
|
||||
tracking_level(rhs.tracking_level),
|
||||
initialized(rhs.initialized)
|
||||
{}
|
||||
};
|
||||
typedef std::vector<cobject_id> cobject_id_vector_type;
|
||||
cobject_id_vector_type cobject_id_vector;
|
||||
|
||||
//////////////////////////////////////////////////////////////////////
|
||||
// address of the most recent object serialized as a poiner
|
||||
// whose data itself is now pending serialization
|
||||
struct pending {
|
||||
void * object;
|
||||
const basic_iserializer * bis;
|
||||
version_type version;
|
||||
pending() :
|
||||
object(NULL),
|
||||
bis(NULL),
|
||||
version(0)
|
||||
{}
|
||||
} m_pending;
|
||||
|
||||
basic_iarchive_impl(unsigned int flags) :
|
||||
m_archive_library_version(BOOST_ARCHIVE_VERSION()),
|
||||
m_flags(flags)
|
||||
{}
|
||||
void set_library_version(library_version_type archive_library_version){
|
||||
m_archive_library_version = archive_library_version;
|
||||
}
|
||||
bool
|
||||
track(
|
||||
basic_iarchive & ar,
|
||||
void * & t
|
||||
);
|
||||
void
|
||||
load_preamble(
|
||||
basic_iarchive & ar,
|
||||
cobject_id & co
|
||||
);
|
||||
class_id_type register_type(
|
||||
const basic_iserializer & bis
|
||||
);
|
||||
|
||||
// redirect through virtual functions to load functions for this archive
|
||||
template<class T>
|
||||
void load(basic_iarchive & ar, T & t){
|
||||
ar.vload(t);
|
||||
}
|
||||
|
||||
//public:
|
||||
void
|
||||
next_object_pointer(void * t){
|
||||
m_pending.object = t;
|
||||
}
|
||||
void delete_created_pointers();
|
||||
class_id_type register_type(
|
||||
const basic_pointer_iserializer & bpis
|
||||
);
|
||||
void load_object(
|
||||
basic_iarchive & ar,
|
||||
void * t,
|
||||
const basic_iserializer & bis
|
||||
);
|
||||
const basic_pointer_iserializer * load_pointer(
|
||||
basic_iarchive & ar,
|
||||
void * & t,
|
||||
const basic_pointer_iserializer * bpis,
|
||||
const basic_pointer_iserializer * (*finder)(
|
||||
const boost::serialization::extended_type_info & type
|
||||
)
|
||||
);
|
||||
};
|
||||
|
||||
inline void
|
||||
basic_iarchive_impl::reset_object_address(
|
||||
void const * const new_address,
|
||||
void const * const old_address
|
||||
){
|
||||
if(m_moveable_objects.is_pointer)
|
||||
return;
|
||||
|
||||
// this code handles a couple of situations.
|
||||
// a) where reset_object_address is applied to an untracked object.
|
||||
// In such a case the call is really superfluous and its really an
|
||||
// an error. But we don't have access to the types here so we can't
|
||||
// know that. However, this code will effectively turn this situation
|
||||
// into a no-op and every thing will work fine - albeat with a small
|
||||
// execution time penalty.
|
||||
// b) where the call to reset_object_address doesn't immediatly follow
|
||||
// the << operator to which it corresponds. This would be a bad idea
|
||||
// but the code may work anyway. Naturally, a bad practice on the part
|
||||
// of the programmer but we can't detect it - as above. So maybe we
|
||||
// can save a few more people from themselves as above.
|
||||
object_id_type i = m_moveable_objects.recent;
|
||||
for(; i < m_moveable_objects.end; ++i){
|
||||
if(old_address == object_id_vector[i].address)
|
||||
break;
|
||||
}
|
||||
for(; i < m_moveable_objects.end; ++i){
|
||||
void const * const this_address = object_id_vector[i].address;
|
||||
// calculate displacement from this level
|
||||
// warning - pointer arithmetic on void * is in herently non-portable
|
||||
// but expected to work on all platforms in current usage
|
||||
if(this_address > old_address){
|
||||
std::size_t member_displacement
|
||||
= reinterpret_cast<std::size_t>(this_address)
|
||||
- reinterpret_cast<std::size_t>(old_address);
|
||||
object_id_vector[i].address = reinterpret_cast<void *>(
|
||||
reinterpret_cast<std::size_t>(new_address) + member_displacement
|
||||
);
|
||||
}
|
||||
else{
|
||||
std::size_t member_displacement
|
||||
= reinterpret_cast<std::size_t>(old_address)
|
||||
- reinterpret_cast<std::size_t>(this_address);
|
||||
object_id_vector[i].address = reinterpret_cast<void *>(
|
||||
reinterpret_cast<std::size_t>(new_address) - member_displacement
|
||||
);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
inline void
|
||||
basic_iarchive_impl::delete_created_pointers()
|
||||
{
|
||||
object_id_vector_type::iterator i;
|
||||
for(
|
||||
i = object_id_vector.begin();
|
||||
i != object_id_vector.end();
|
||||
++i
|
||||
){
|
||||
if(i->loaded_as_pointer){
|
||||
// borland complains without this minor hack
|
||||
const int j = i->class_id;
|
||||
const cobject_id & co = cobject_id_vector[j];
|
||||
//const cobject_id & co = cobject_id_vector[i->class_id];
|
||||
// with the appropriate input serializer,
|
||||
// delete the indicated object
|
||||
co.bis_ptr->destroy(i->address);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
inline class_id_type
|
||||
basic_iarchive_impl::register_type(
|
||||
const basic_iserializer & bis
|
||||
){
|
||||
class_id_type cid(cobject_info_set.size());
|
||||
cobject_type co(cid, bis);
|
||||
std::pair<cobject_info_set_type::const_iterator, bool>
|
||||
result = cobject_info_set.insert(co);
|
||||
|
||||
if(result.second){
|
||||
cobject_id_vector.push_back(cobject_id(bis));
|
||||
BOOST_ASSERT(cobject_info_set.size() == cobject_id_vector.size());
|
||||
}
|
||||
cid = result.first->m_class_id;
|
||||
// borland complains without this minor hack
|
||||
const int tid = cid;
|
||||
cobject_id & coid = cobject_id_vector[tid];
|
||||
coid.bpis_ptr = bis.get_bpis_ptr();
|
||||
return cid;
|
||||
}
|
||||
|
||||
void
|
||||
basic_iarchive_impl::load_preamble(
|
||||
basic_iarchive & ar,
|
||||
cobject_id & co
|
||||
){
|
||||
if(! co.initialized){
|
||||
if(co.bis_ptr->class_info()){
|
||||
class_id_optional_type cid(class_id_type(0));
|
||||
load(ar, cid); // to be thrown away
|
||||
load(ar, co.tracking_level);
|
||||
load(ar, co.file_version);
|
||||
}
|
||||
else{
|
||||
// override tracking with indicator from class information
|
||||
co.tracking_level = co.bis_ptr->tracking(m_flags);
|
||||
co.file_version = version_type(
|
||||
co.bis_ptr->version()
|
||||
);
|
||||
}
|
||||
co.initialized = true;
|
||||
}
|
||||
}
|
||||
|
||||
bool
|
||||
basic_iarchive_impl::track(
|
||||
basic_iarchive & ar,
|
||||
void * & t
|
||||
){
|
||||
object_id_type oid;
|
||||
load(ar, oid);
|
||||
|
||||
// if its a reference to a old object
|
||||
if(object_id_type(object_id_vector.size()) > oid){
|
||||
// we're done
|
||||
t = object_id_vector[oid].address;
|
||||
return false;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
inline void
|
||||
basic_iarchive_impl::load_object(
|
||||
basic_iarchive & ar,
|
||||
void * t,
|
||||
const basic_iserializer & bis
|
||||
){
|
||||
m_moveable_objects.is_pointer = false;
|
||||
serialization::state_saver<bool> ss_is_pointer(m_moveable_objects.is_pointer);
|
||||
// if its been serialized through a pointer and the preamble's been done
|
||||
if(t == m_pending.object && & bis == m_pending.bis){
|
||||
// read data
|
||||
(bis.load_object_data)(ar, t, m_pending.version);
|
||||
return;
|
||||
}
|
||||
|
||||
const class_id_type cid = register_type(bis);
|
||||
const int i = cid;
|
||||
cobject_id & co = cobject_id_vector[i];
|
||||
|
||||
load_preamble(ar, co);
|
||||
|
||||
// save the current move stack position in case we want to truncate it
|
||||
boost::serialization::state_saver<object_id_type> ss_start(m_moveable_objects.start);
|
||||
|
||||
// note: extra line used to evade borland issue
|
||||
const bool tracking = co.tracking_level;
|
||||
|
||||
object_id_type this_id;
|
||||
m_moveable_objects.start =
|
||||
this_id = object_id_type(object_id_vector.size());
|
||||
|
||||
// if we tracked this object when the archive was saved
|
||||
if(tracking){
|
||||
// if it was already read
|
||||
if(!track(ar, t))
|
||||
// we're done
|
||||
return;
|
||||
// add a new enty into the tracking list
|
||||
object_id_vector.push_back(aobject(t, cid));
|
||||
// and add an entry for this object
|
||||
m_moveable_objects.end = object_id_type(object_id_vector.size());
|
||||
}
|
||||
// read data
|
||||
(bis.load_object_data)(ar, t, co.file_version);
|
||||
m_moveable_objects.recent = this_id;
|
||||
}
|
||||
|
||||
inline const basic_pointer_iserializer *
|
||||
basic_iarchive_impl::load_pointer(
|
||||
basic_iarchive &ar,
|
||||
void * & t,
|
||||
const basic_pointer_iserializer * bpis_ptr,
|
||||
const basic_pointer_iserializer * (*finder)(
|
||||
const boost::serialization::extended_type_info & type_
|
||||
)
|
||||
){
|
||||
m_moveable_objects.is_pointer = true;
|
||||
serialization::state_saver<bool> w(m_moveable_objects.is_pointer);
|
||||
|
||||
class_id_type cid;
|
||||
load(ar, cid);
|
||||
|
||||
if(NULL_POINTER_TAG == cid){
|
||||
t = NULL;
|
||||
return bpis_ptr;
|
||||
}
|
||||
|
||||
// if its a new class type - i.e. never been registered
|
||||
if(class_id_type(cobject_info_set.size()) <= cid){
|
||||
// if its either abstract
|
||||
if(NULL == bpis_ptr
|
||||
// or polymorphic
|
||||
|| bpis_ptr->get_basic_serializer().is_polymorphic()){
|
||||
// is must have been exported
|
||||
char key[BOOST_SERIALIZATION_MAX_KEY_SIZE];
|
||||
class_name_type class_name(key);
|
||||
load(ar, class_name);
|
||||
// if it has a class name
|
||||
const serialization::extended_type_info *eti = NULL;
|
||||
if(0 != key[0])
|
||||
eti = serialization::extended_type_info::find(key);
|
||||
if(NULL == eti)
|
||||
boost::serialization::throw_exception(
|
||||
archive_exception(archive_exception::unregistered_class)
|
||||
);
|
||||
bpis_ptr = (*finder)(*eti);
|
||||
}
|
||||
BOOST_ASSERT(NULL != bpis_ptr);
|
||||
// class_id_type new_cid = register_type(bpis_ptr->get_basic_serializer());
|
||||
BOOST_VERIFY(register_type(bpis_ptr->get_basic_serializer()) == cid);
|
||||
int i = cid;
|
||||
cobject_id_vector[i].bpis_ptr = bpis_ptr;
|
||||
}
|
||||
int i = cid;
|
||||
cobject_id & co = cobject_id_vector[i];
|
||||
bpis_ptr = co.bpis_ptr;
|
||||
|
||||
if (bpis_ptr == NULL) {
|
||||
boost::serialization::throw_exception(
|
||||
archive_exception(archive_exception::unregistered_class)
|
||||
);
|
||||
}
|
||||
|
||||
load_preamble(ar, co);
|
||||
|
||||
// extra line to evade borland issue
|
||||
const bool tracking = co.tracking_level;
|
||||
// if we're tracking and the pointer has already been read
|
||||
if(tracking && ! track(ar, t))
|
||||
// we're done
|
||||
return bpis_ptr;
|
||||
|
||||
// save state
|
||||
serialization::state_saver<object_id_type> w_start(m_moveable_objects.start);
|
||||
|
||||
// allocate space on the heap for the object - to be constructed later
|
||||
t = bpis_ptr->heap_allocation();
|
||||
BOOST_ASSERT(NULL != t);
|
||||
|
||||
if(! tracking){
|
||||
bpis_ptr->load_object_ptr(ar, t, co.file_version);
|
||||
}
|
||||
else{
|
||||
serialization::state_saver<void *> x(m_pending.object);
|
||||
serialization::state_saver<const basic_iserializer *> y(m_pending.bis);
|
||||
serialization::state_saver<version_type> z(m_pending.version);
|
||||
|
||||
m_pending.bis = & bpis_ptr->get_basic_serializer();
|
||||
m_pending.version = co.file_version;
|
||||
|
||||
// predict next object id to be created
|
||||
const size_t ui = object_id_vector.size();
|
||||
|
||||
serialization::state_saver<object_id_type> w_end(m_moveable_objects.end);
|
||||
|
||||
|
||||
// add to list of serialized objects so that we can properly handle
|
||||
// cyclic strucures
|
||||
object_id_vector.push_back(aobject(t, cid));
|
||||
|
||||
// remember that that the address of these elements could change
|
||||
// when we make another call so don't use the address
|
||||
bpis_ptr->load_object_ptr(
|
||||
ar,
|
||||
t,
|
||||
m_pending.version
|
||||
);
|
||||
object_id_vector[ui].loaded_as_pointer = true;
|
||||
}
|
||||
|
||||
return bpis_ptr;
|
||||
}
|
||||
|
||||
} // namespace detail
|
||||
} // namespace archive
|
||||
} // namespace boost
|
||||
|
||||
//////////////////////////////////////////////////////////////////////
|
||||
// implementation of basic_iarchive functions
|
||||
namespace boost {
|
||||
namespace archive {
|
||||
namespace detail {
|
||||
|
||||
BOOST_ARCHIVE_DECL void
|
||||
basic_iarchive::next_object_pointer(void *t){
|
||||
pimpl->next_object_pointer(t);
|
||||
}
|
||||
|
||||
BOOST_ARCHIVE_DECL
|
||||
basic_iarchive::basic_iarchive(unsigned int flags) :
|
||||
pimpl(new basic_iarchive_impl(flags))
|
||||
{}
|
||||
|
||||
BOOST_ARCHIVE_DECL
|
||||
basic_iarchive::~basic_iarchive()
|
||||
{}
|
||||
|
||||
BOOST_ARCHIVE_DECL void
|
||||
basic_iarchive::set_library_version(library_version_type archive_library_version){
|
||||
pimpl->set_library_version(archive_library_version);
|
||||
}
|
||||
|
||||
BOOST_ARCHIVE_DECL void
|
||||
basic_iarchive::reset_object_address(
|
||||
const void * new_address,
|
||||
const void * old_address
|
||||
){
|
||||
pimpl->reset_object_address(new_address, old_address);
|
||||
}
|
||||
|
||||
BOOST_ARCHIVE_DECL void
|
||||
basic_iarchive::load_object(
|
||||
void *t,
|
||||
const basic_iserializer & bis
|
||||
){
|
||||
pimpl->load_object(*this, t, bis);
|
||||
}
|
||||
|
||||
// load a pointer object
|
||||
BOOST_ARCHIVE_DECL const basic_pointer_iserializer *
|
||||
basic_iarchive::load_pointer(
|
||||
void * &t,
|
||||
const basic_pointer_iserializer * bpis_ptr,
|
||||
const basic_pointer_iserializer * (*finder)(
|
||||
const boost::serialization::extended_type_info & type_
|
||||
)
|
||||
|
||||
){
|
||||
return pimpl->load_pointer(*this, t, bpis_ptr, finder);
|
||||
}
|
||||
|
||||
BOOST_ARCHIVE_DECL void
|
||||
basic_iarchive::register_basic_serializer(const basic_iserializer & bis){
|
||||
pimpl->register_type(bis);
|
||||
}
|
||||
|
||||
BOOST_ARCHIVE_DECL void
|
||||
basic_iarchive::delete_created_pointers()
|
||||
{
|
||||
pimpl->delete_created_pointers();
|
||||
}
|
||||
|
||||
BOOST_ARCHIVE_DECL boost::archive::library_version_type
|
||||
basic_iarchive::get_library_version() const{
|
||||
return pimpl->m_archive_library_version;
|
||||
}
|
||||
|
||||
BOOST_ARCHIVE_DECL unsigned int
|
||||
basic_iarchive::get_flags() const{
|
||||
return pimpl->m_flags;
|
||||
}
|
||||
|
||||
} // namespace detail
|
||||
} // namespace archive
|
||||
} // namespace boost
|
||||
34
third_party/boost/libs/serialization/src/basic_iserializer.cpp
vendored
Normal file
34
third_party/boost/libs/serialization/src/basic_iserializer.cpp
vendored
Normal file
|
|
@ -0,0 +1,34 @@
|
|||
/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
|
||||
// basic_iserializer.cpp:
|
||||
|
||||
// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
|
||||
// Use, modification and distribution is subject to the 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
|
||||
|
||||
#define BOOST_ARCHIVE_SOURCE
|
||||
#include <boost/serialization/config.hpp>
|
||||
#include <boost/archive/detail/basic_iserializer.hpp>
|
||||
|
||||
namespace boost {
|
||||
namespace archive {
|
||||
namespace detail {
|
||||
|
||||
BOOST_ARCHIVE_DECL
|
||||
basic_iserializer::basic_iserializer(
|
||||
const boost::serialization::extended_type_info & eti
|
||||
) :
|
||||
basic_serializer(eti),
|
||||
m_bpis(NULL)
|
||||
{}
|
||||
|
||||
BOOST_ARCHIVE_DECL
|
||||
basic_iserializer::~basic_iserializer(){}
|
||||
|
||||
} // namespace detail
|
||||
} // namespace archive
|
||||
} // namespace boost
|
||||
470
third_party/boost/libs/serialization/src/basic_oarchive.cpp
vendored
Normal file
470
third_party/boost/libs/serialization/src/basic_oarchive.cpp
vendored
Normal file
|
|
@ -0,0 +1,470 @@
|
|||
/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
|
||||
// basic_oarchive.cpp:
|
||||
|
||||
// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
|
||||
// Use, modification and distribution is subject to the 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> // msvc 6.0 needs this for warning suppression
|
||||
|
||||
#include <boost/assert.hpp>
|
||||
#include <set>
|
||||
#include <cstddef> // NULL
|
||||
|
||||
#include <boost/limits.hpp>
|
||||
|
||||
// including this here to work around an ICC in intel 7.0
|
||||
// normally this would be part of basic_oarchive.hpp below.
|
||||
#define BOOST_ARCHIVE_SOURCE
|
||||
// include this to prevent linker errors when the
|
||||
// same modules are marked export and import.
|
||||
#define BOOST_SERIALIZATION_SOURCE
|
||||
#include <boost/serialization/config.hpp>
|
||||
#include <boost/serialization/state_saver.hpp>
|
||||
#include <boost/serialization/throw_exception.hpp>
|
||||
#include <boost/serialization/extended_type_info.hpp>
|
||||
|
||||
#include <boost/archive/detail/decl.hpp>
|
||||
#include <boost/archive/basic_archive.hpp>
|
||||
#include <boost/archive/detail/basic_oserializer.hpp>
|
||||
#include <boost/archive/detail/basic_pointer_oserializer.hpp>
|
||||
#include <boost/archive/detail/basic_oarchive.hpp>
|
||||
#include <boost/archive/archive_exception.hpp>
|
||||
|
||||
#ifdef BOOST_MSVC
|
||||
# pragma warning(push)
|
||||
# pragma warning(disable : 4251 4231 4660 4275)
|
||||
#endif
|
||||
|
||||
using namespace boost::serialization;
|
||||
|
||||
namespace boost {
|
||||
namespace archive {
|
||||
namespace detail {
|
||||
|
||||
class basic_oarchive_impl {
|
||||
friend class basic_oarchive;
|
||||
unsigned int m_flags;
|
||||
|
||||
//////////////////////////////////////////////////////////////////////
|
||||
// information about each serialized object saved
|
||||
// keyed on address, class_id
|
||||
struct aobject
|
||||
{
|
||||
const void * address;
|
||||
class_id_type class_id;
|
||||
object_id_type object_id;
|
||||
|
||||
bool operator<(const aobject &rhs) const
|
||||
{
|
||||
BOOST_ASSERT(NULL != address);
|
||||
BOOST_ASSERT(NULL != rhs.address);
|
||||
if( address < rhs.address )
|
||||
return true;
|
||||
if( address > rhs.address )
|
||||
return false;
|
||||
return class_id < rhs.class_id;
|
||||
}
|
||||
aobject & operator=(const aobject & rhs)
|
||||
{
|
||||
address = rhs.address;
|
||||
class_id = rhs.class_id;
|
||||
object_id = rhs.object_id;
|
||||
return *this;
|
||||
}
|
||||
aobject(
|
||||
const void *a,
|
||||
class_id_type class_id_,
|
||||
object_id_type object_id_
|
||||
) :
|
||||
address(a),
|
||||
class_id(class_id_),
|
||||
object_id(object_id_)
|
||||
{}
|
||||
aobject() : address(NULL){}
|
||||
};
|
||||
// keyed on class_id, address
|
||||
typedef std::set<aobject> object_set_type;
|
||||
object_set_type object_set;
|
||||
|
||||
//////////////////////////////////////////////////////////////////////
|
||||
// information about each serialized class saved
|
||||
// keyed on type_info
|
||||
struct cobject_type
|
||||
{
|
||||
const basic_oserializer * m_bos_ptr;
|
||||
const class_id_type m_class_id;
|
||||
bool m_initialized;
|
||||
cobject_type(
|
||||
std::size_t class_id,
|
||||
const basic_oserializer & bos
|
||||
) :
|
||||
m_bos_ptr(& bos),
|
||||
m_class_id(class_id),
|
||||
m_initialized(false)
|
||||
{}
|
||||
cobject_type(const basic_oserializer & bos) :
|
||||
m_bos_ptr(& bos),
|
||||
m_initialized(false)
|
||||
{}
|
||||
cobject_type(
|
||||
const cobject_type & rhs
|
||||
) :
|
||||
m_bos_ptr(rhs.m_bos_ptr),
|
||||
m_class_id(rhs.m_class_id),
|
||||
m_initialized(rhs.m_initialized)
|
||||
{}
|
||||
// the following cannot be defined because of the const
|
||||
// member. This will generate a link error if an attempt
|
||||
// is made to assign. This should never be necessary
|
||||
// use this only for lookup argument
|
||||
cobject_type & operator=(const cobject_type &rhs);
|
||||
bool operator<(const cobject_type &rhs) const {
|
||||
return *m_bos_ptr < *(rhs.m_bos_ptr);
|
||||
}
|
||||
};
|
||||
// keyed on type_info
|
||||
typedef std::set<cobject_type> cobject_info_set_type;
|
||||
cobject_info_set_type cobject_info_set;
|
||||
|
||||
// list of objects initially stored as pointers - used to detect errors
|
||||
// keyed on object id
|
||||
std::set<object_id_type> stored_pointers;
|
||||
|
||||
// address of the most recent object serialized as a poiner
|
||||
// whose data itself is now pending serialization
|
||||
const void * pending_object;
|
||||
const basic_oserializer * pending_bos;
|
||||
|
||||
basic_oarchive_impl(unsigned int flags) :
|
||||
m_flags(flags),
|
||||
pending_object(NULL),
|
||||
pending_bos(NULL)
|
||||
{}
|
||||
|
||||
const cobject_type &
|
||||
find(const basic_oserializer & bos);
|
||||
const basic_oserializer *
|
||||
find(const serialization::extended_type_info &ti) const;
|
||||
|
||||
//public:
|
||||
const cobject_type &
|
||||
register_type(const basic_oserializer & bos);
|
||||
void save_object(
|
||||
basic_oarchive & ar,
|
||||
const void *t,
|
||||
const basic_oserializer & bos
|
||||
);
|
||||
void save_pointer(
|
||||
basic_oarchive & ar,
|
||||
const void * t,
|
||||
const basic_pointer_oserializer * bpos
|
||||
);
|
||||
};
|
||||
|
||||
//////////////////////////////////////////////////////////////////////
|
||||
// basic_oarchive implementation functions
|
||||
|
||||
// given a type_info - find its bos
|
||||
// return NULL if not found
|
||||
inline const basic_oserializer *
|
||||
basic_oarchive_impl::find(const serialization::extended_type_info & ti) const {
|
||||
#ifdef BOOST_MSVC
|
||||
# pragma warning(push)
|
||||
# pragma warning(disable : 4511 4512)
|
||||
#endif
|
||||
class bosarg :
|
||||
public basic_oserializer
|
||||
{
|
||||
bool class_info() const {
|
||||
BOOST_ASSERT(false);
|
||||
return false;
|
||||
}
|
||||
// returns true if objects should be tracked
|
||||
bool tracking(const unsigned int) const {
|
||||
BOOST_ASSERT(false);
|
||||
return false;
|
||||
}
|
||||
// returns class version
|
||||
version_type version() const {
|
||||
BOOST_ASSERT(false);
|
||||
return version_type(0);
|
||||
}
|
||||
// returns true if this class is polymorphic
|
||||
bool is_polymorphic() const{
|
||||
BOOST_ASSERT(false);
|
||||
return false;
|
||||
}
|
||||
void save_object_data(
|
||||
basic_oarchive & /*ar*/, const void * /*x*/
|
||||
) const {
|
||||
BOOST_ASSERT(false);
|
||||
}
|
||||
public:
|
||||
bosarg(const serialization::extended_type_info & eti) :
|
||||
boost::archive::detail::basic_oserializer(eti)
|
||||
{}
|
||||
};
|
||||
#ifdef BOOST_MSVC
|
||||
#pragma warning(pop)
|
||||
#endif
|
||||
bosarg bos(ti);
|
||||
cobject_info_set_type::const_iterator cit
|
||||
= cobject_info_set.find(cobject_type(bos));
|
||||
// it should already have been "registered" - see below
|
||||
if(cit == cobject_info_set.end()){
|
||||
// if an entry is not found in the table it is because a pointer
|
||||
// of a derived class has been serialized through its base class
|
||||
// but the derived class hasn't been "registered"
|
||||
return NULL;
|
||||
}
|
||||
// return pointer to the real class
|
||||
return cit->m_bos_ptr;
|
||||
}
|
||||
|
||||
inline const basic_oarchive_impl::cobject_type &
|
||||
basic_oarchive_impl::find(const basic_oserializer & bos)
|
||||
{
|
||||
std::pair<cobject_info_set_type::iterator, bool> cresult =
|
||||
cobject_info_set.insert(cobject_type(cobject_info_set.size(), bos));
|
||||
return *(cresult.first);
|
||||
}
|
||||
|
||||
inline const basic_oarchive_impl::cobject_type &
|
||||
basic_oarchive_impl::register_type(
|
||||
const basic_oserializer & bos
|
||||
){
|
||||
cobject_type co(cobject_info_set.size(), bos);
|
||||
std::pair<cobject_info_set_type::const_iterator, bool>
|
||||
result = cobject_info_set.insert(co);
|
||||
return *(result.first);
|
||||
}
|
||||
|
||||
inline void
|
||||
basic_oarchive_impl::save_object(
|
||||
basic_oarchive & ar,
|
||||
const void *t,
|
||||
const basic_oserializer & bos
|
||||
){
|
||||
// if its been serialized through a pointer and the preamble's been done
|
||||
if(t == pending_object && pending_bos == & bos){
|
||||
// just save the object data
|
||||
ar.end_preamble();
|
||||
(bos.save_object_data)(ar, t);
|
||||
return;
|
||||
}
|
||||
|
||||
// get class information for this object
|
||||
const cobject_type & co = register_type(bos);
|
||||
if(bos.class_info()){
|
||||
if( ! co.m_initialized){
|
||||
ar.vsave(class_id_optional_type(co.m_class_id));
|
||||
ar.vsave(tracking_type(bos.tracking(m_flags)));
|
||||
ar.vsave(version_type(bos.version()));
|
||||
(const_cast<cobject_type &>(co)).m_initialized = true;
|
||||
}
|
||||
}
|
||||
|
||||
// we're not tracking this type of object
|
||||
if(! bos.tracking(m_flags)){
|
||||
// just windup the preamble - no object id to write
|
||||
ar.end_preamble();
|
||||
// and save the data
|
||||
(bos.save_object_data)(ar, t);
|
||||
return;
|
||||
}
|
||||
|
||||
// look for an existing object id
|
||||
object_id_type oid(object_set.size());
|
||||
// lookup to see if this object has already been written to the archive
|
||||
basic_oarchive_impl::aobject ao(t, co.m_class_id, oid);
|
||||
std::pair<basic_oarchive_impl::object_set_type::const_iterator, bool>
|
||||
aresult = object_set.insert(ao);
|
||||
oid = aresult.first->object_id;
|
||||
|
||||
// if its a new object
|
||||
if(aresult.second){
|
||||
// write out the object id
|
||||
ar.vsave(oid);
|
||||
ar.end_preamble();
|
||||
// and data
|
||||
(bos.save_object_data)(ar, t);
|
||||
return;
|
||||
}
|
||||
|
||||
// check that it wasn't originally stored through a pointer
|
||||
if(stored_pointers.end() != stored_pointers.find(oid)){
|
||||
// this has to be a user error. loading such an archive
|
||||
// would create duplicate objects
|
||||
boost::serialization::throw_exception(
|
||||
archive_exception(archive_exception::pointer_conflict)
|
||||
);
|
||||
}
|
||||
// just save the object id
|
||||
ar.vsave(object_reference_type(oid));
|
||||
ar.end_preamble();
|
||||
return;
|
||||
}
|
||||
|
||||
// save a pointer to an object instance
|
||||
inline void
|
||||
basic_oarchive_impl::save_pointer(
|
||||
basic_oarchive & ar,
|
||||
const void * t,
|
||||
const basic_pointer_oserializer * bpos_ptr
|
||||
){
|
||||
const basic_oserializer & bos = bpos_ptr->get_basic_serializer();
|
||||
std::size_t original_count = cobject_info_set.size();
|
||||
const cobject_type & co = register_type(bos);
|
||||
if(! co.m_initialized){
|
||||
ar.vsave(co.m_class_id);
|
||||
// if its a previously unregistered class
|
||||
if((cobject_info_set.size() > original_count)){
|
||||
if(bos.is_polymorphic()){
|
||||
const serialization::extended_type_info *eti = & bos.get_eti();
|
||||
const char * key = NULL;
|
||||
if(NULL != eti)
|
||||
key = eti->get_key();
|
||||
if(NULL != key){
|
||||
// the following is required by IBM C++ compiler which
|
||||
// makes a copy when passing a non-const to a const. This
|
||||
// is permitted by the standard but rarely seen in practice
|
||||
const class_name_type cn(key);
|
||||
if(cn.size() > (BOOST_SERIALIZATION_MAX_KEY_SIZE - 1))
|
||||
boost::serialization::throw_exception(
|
||||
boost::archive::archive_exception(
|
||||
boost::archive::archive_exception::
|
||||
invalid_class_name)
|
||||
);
|
||||
// write out the external class identifier
|
||||
ar.vsave(cn);
|
||||
}
|
||||
else
|
||||
// without an external class name
|
||||
// we won't be able to de-serialize it so bail now
|
||||
boost::serialization::throw_exception(
|
||||
archive_exception(archive_exception::unregistered_class)
|
||||
);
|
||||
}
|
||||
}
|
||||
if(bos.class_info()){
|
||||
ar.vsave(tracking_type(bos.tracking(m_flags)));
|
||||
ar.vsave(version_type(bos.version()));
|
||||
}
|
||||
(const_cast<cobject_type &>(co)).m_initialized = true;
|
||||
}
|
||||
else{
|
||||
ar.vsave(class_id_reference_type(co.m_class_id));
|
||||
}
|
||||
|
||||
// if we're not tracking
|
||||
if(! bos.tracking(m_flags)){
|
||||
// just save the data itself
|
||||
ar.end_preamble();
|
||||
serialization::state_saver<const void *> x(pending_object);
|
||||
serialization::state_saver<const basic_oserializer *> y(pending_bos);
|
||||
pending_object = t;
|
||||
pending_bos = & bpos_ptr->get_basic_serializer();
|
||||
bpos_ptr->save_object_ptr(ar, t);
|
||||
return;
|
||||
}
|
||||
|
||||
object_id_type oid(object_set.size());
|
||||
// lookup to see if this object has already been written to the archive
|
||||
basic_oarchive_impl::aobject ao(t, co.m_class_id, oid);
|
||||
std::pair<basic_oarchive_impl::object_set_type::const_iterator, bool>
|
||||
aresult = object_set.insert(ao);
|
||||
oid = aresult.first->object_id;
|
||||
// if the saved object already exists
|
||||
if(! aresult.second){
|
||||
// append the object id to he preamble
|
||||
ar.vsave(object_reference_type(oid));
|
||||
// and windup.
|
||||
ar.end_preamble();
|
||||
return;
|
||||
}
|
||||
|
||||
// append id of this object to preamble
|
||||
ar.vsave(oid);
|
||||
ar.end_preamble();
|
||||
|
||||
// and save the object itself
|
||||
serialization::state_saver<const void *> x(pending_object);
|
||||
serialization::state_saver<const basic_oserializer *> y(pending_bos);
|
||||
pending_object = t;
|
||||
pending_bos = & bpos_ptr->get_basic_serializer();
|
||||
bpos_ptr->save_object_ptr(ar, t);
|
||||
// add to the set of object initially stored through pointers
|
||||
stored_pointers.insert(oid);
|
||||
}
|
||||
|
||||
} // namespace detail
|
||||
} // namespace archive
|
||||
} // namespace boost
|
||||
|
||||
//////////////////////////////////////////////////////////////////////
|
||||
// implementation of basic_oarchive functions
|
||||
|
||||
namespace boost {
|
||||
namespace archive {
|
||||
namespace detail {
|
||||
|
||||
BOOST_ARCHIVE_DECL
|
||||
basic_oarchive::basic_oarchive(unsigned int flags)
|
||||
: pimpl(new basic_oarchive_impl(flags))
|
||||
{}
|
||||
|
||||
BOOST_ARCHIVE_DECL
|
||||
basic_oarchive::~basic_oarchive()
|
||||
{}
|
||||
|
||||
BOOST_ARCHIVE_DECL void
|
||||
basic_oarchive::save_object(
|
||||
const void *x,
|
||||
const basic_oserializer & bos
|
||||
){
|
||||
pimpl->save_object(*this, x, bos);
|
||||
}
|
||||
|
||||
BOOST_ARCHIVE_DECL void
|
||||
basic_oarchive::save_pointer(
|
||||
const void * t,
|
||||
const basic_pointer_oserializer * bpos_ptr
|
||||
){
|
||||
pimpl->save_pointer(*this, t, bpos_ptr);
|
||||
}
|
||||
|
||||
BOOST_ARCHIVE_DECL void
|
||||
basic_oarchive::register_basic_serializer(const basic_oserializer & bos){
|
||||
pimpl->register_type(bos);
|
||||
}
|
||||
|
||||
BOOST_ARCHIVE_DECL library_version_type
|
||||
basic_oarchive::get_library_version() const{
|
||||
return BOOST_ARCHIVE_VERSION();
|
||||
}
|
||||
|
||||
BOOST_ARCHIVE_DECL unsigned int
|
||||
basic_oarchive::get_flags() const{
|
||||
return pimpl->m_flags;
|
||||
}
|
||||
|
||||
BOOST_ARCHIVE_DECL void
|
||||
basic_oarchive::end_preamble(){
|
||||
}
|
||||
|
||||
BOOST_ARCHIVE_DECL helper_collection &
|
||||
basic_oarchive::get_helper_collection(){
|
||||
return *this;
|
||||
}
|
||||
|
||||
} // namespace detail
|
||||
} // namespace archive
|
||||
} // namespace boost
|
||||
|
||||
#ifdef BOOST_MSVC
|
||||
#pragma warning(pop)
|
||||
#endif
|
||||
34
third_party/boost/libs/serialization/src/basic_oserializer.cpp
vendored
Normal file
34
third_party/boost/libs/serialization/src/basic_oserializer.cpp
vendored
Normal file
|
|
@ -0,0 +1,34 @@
|
|||
/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
|
||||
// basic_oserializer.cpp:
|
||||
|
||||
// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
|
||||
// Use, modification and distribution is subject to the 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
|
||||
|
||||
#define BOOST_ARCHIVE_SOURCE
|
||||
#include <boost/serialization/config.hpp>
|
||||
#include <boost/archive/detail/basic_oserializer.hpp>
|
||||
|
||||
namespace boost {
|
||||
namespace archive {
|
||||
namespace detail {
|
||||
|
||||
BOOST_ARCHIVE_DECL
|
||||
basic_oserializer::basic_oserializer(
|
||||
const boost::serialization::extended_type_info & eti
|
||||
) :
|
||||
basic_serializer(eti),
|
||||
m_bpos(NULL)
|
||||
{}
|
||||
|
||||
BOOST_ARCHIVE_DECL
|
||||
basic_oserializer::~basic_oserializer(){}
|
||||
|
||||
} // namespace detail
|
||||
} // namespace archive
|
||||
} // namespace boost
|
||||
31
third_party/boost/libs/serialization/src/basic_pointer_iserializer.cpp
vendored
Normal file
31
third_party/boost/libs/serialization/src/basic_pointer_iserializer.cpp
vendored
Normal file
|
|
@ -0,0 +1,31 @@
|
|||
/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
|
||||
// basic_pointer_iserializer.cpp:
|
||||
|
||||
// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
|
||||
// Use, modification and distribution is subject to the 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.
|
||||
|
||||
#define BOOST_ARCHIVE_SOURCE
|
||||
#include <boost/serialization/config.hpp>
|
||||
#include <boost/archive/detail/basic_pointer_iserializer.hpp>
|
||||
|
||||
namespace boost {
|
||||
namespace archive {
|
||||
namespace detail {
|
||||
|
||||
BOOST_ARCHIVE_DECL
|
||||
basic_pointer_iserializer::basic_pointer_iserializer(
|
||||
const boost::serialization::extended_type_info & eti
|
||||
) :
|
||||
basic_serializer(eti)
|
||||
{}
|
||||
|
||||
BOOST_ARCHIVE_DECL
|
||||
basic_pointer_iserializer::~basic_pointer_iserializer() {}
|
||||
|
||||
} // namespace detail
|
||||
} // namespace archive
|
||||
} // namespace boost
|
||||
31
third_party/boost/libs/serialization/src/basic_pointer_oserializer.cpp
vendored
Normal file
31
third_party/boost/libs/serialization/src/basic_pointer_oserializer.cpp
vendored
Normal file
|
|
@ -0,0 +1,31 @@
|
|||
/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
|
||||
// basic_pointer_oserializer.cpp:
|
||||
|
||||
// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
|
||||
// Use, modification and distribution is subject to the 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.
|
||||
|
||||
#define BOOST_ARCHIVE_SOURCE
|
||||
#include <boost/serialization/config.hpp>
|
||||
#include <boost/archive/detail/basic_pointer_oserializer.hpp>
|
||||
|
||||
namespace boost {
|
||||
namespace archive {
|
||||
namespace detail {
|
||||
|
||||
BOOST_ARCHIVE_DECL
|
||||
basic_pointer_oserializer::basic_pointer_oserializer(
|
||||
const boost::serialization::extended_type_info & eti
|
||||
) :
|
||||
basic_serializer(eti)
|
||||
{}
|
||||
|
||||
BOOST_ARCHIVE_DECL
|
||||
basic_pointer_oserializer::~basic_pointer_oserializer() {}
|
||||
|
||||
} // namespace detail
|
||||
} // namespace archive
|
||||
} // namespace boost
|
||||
112
third_party/boost/libs/serialization/src/basic_serializer_map.cpp
vendored
Normal file
112
third_party/boost/libs/serialization/src/basic_serializer_map.cpp
vendored
Normal file
|
|
@ -0,0 +1,112 @@
|
|||
/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
|
||||
// serializer_map.cpp:
|
||||
|
||||
// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
|
||||
// Use, modification and distribution is subject to the Boost Software
|
||||
// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
// See http://www.boost.org for updates, documentation, and revision history.
|
||||
|
||||
#if (defined _MSC_VER) && (_MSC_VER == 1200)
|
||||
# pragma warning (disable : 4786) // too long name, harmless warning
|
||||
#endif
|
||||
|
||||
#include <set>
|
||||
#include <utility>
|
||||
|
||||
#define BOOST_ARCHIVE_SOURCE
|
||||
// include this to prevent linker errors when the
|
||||
// same modules are marked export and import.
|
||||
#define BOOST_SERIALIZATION_SOURCE
|
||||
#include <boost/serialization/config.hpp>
|
||||
#include <boost/serialization/throw_exception.hpp>
|
||||
|
||||
#include <boost/archive/archive_exception.hpp>
|
||||
#include <boost/archive/detail/basic_serializer.hpp>
|
||||
#include <boost/archive/detail/basic_serializer_map.hpp>
|
||||
|
||||
namespace boost {
|
||||
namespace serialization {
|
||||
class extended_type_info;
|
||||
}
|
||||
namespace archive {
|
||||
namespace detail {
|
||||
|
||||
bool
|
||||
basic_serializer_map::type_info_pointer_compare::operator()(
|
||||
const basic_serializer * lhs, const basic_serializer * rhs
|
||||
) const {
|
||||
return *lhs < *rhs;
|
||||
}
|
||||
|
||||
BOOST_ARCHIVE_DECL bool
|
||||
basic_serializer_map::insert(const basic_serializer * bs){
|
||||
// attempt to insert serializer into it's map
|
||||
// the following is commented out - rather than being just
|
||||
// deleted as a reminder not to try this.
|
||||
|
||||
// const std::pair<map_type::iterator, bool> result =
|
||||
m_map.insert(bs);
|
||||
|
||||
// At first it seemed like a good idea. It enforced the
|
||||
// idea that a type be exported from at most one code module
|
||||
// (DLL or mainline). This would enforce a "one definition rule"
|
||||
// across code modules. This seems a good idea to me.
|
||||
// But it seems that it's just too hard for many users to implement.
|
||||
|
||||
// Ideally, I would like to make this exception a warning -
|
||||
// but there isn't anyway to do that.
|
||||
|
||||
// if this fails, it's because it's been instantiated
|
||||
// in multiple modules - DLLS - a recipe for problems.
|
||||
// So trap this here
|
||||
// if(!result.second){
|
||||
// boost::serialization::throw_exception(
|
||||
// archive_exception(
|
||||
// archive_exception::multiple_code_instantiation,
|
||||
// bs->get_debug_info()
|
||||
// )
|
||||
// );
|
||||
// }
|
||||
return true;
|
||||
}
|
||||
|
||||
BOOST_ARCHIVE_DECL void
|
||||
basic_serializer_map::erase(const basic_serializer * bs){
|
||||
map_type::iterator it = m_map.begin();
|
||||
map_type::iterator it_end = m_map.end();
|
||||
|
||||
while(it != it_end){
|
||||
// note item 9 from Effective STL !!! it++
|
||||
if(*it == bs)
|
||||
m_map.erase(it++);
|
||||
else
|
||||
it++;
|
||||
}
|
||||
// note: we can't do this since some of the eti records
|
||||
// we're pointing to might be expired and the comparison
|
||||
// won't work. Leave this as a reminder not to "optimize" this.
|
||||
//it = m_map.find(bs);
|
||||
//assert(it != m_map.end());
|
||||
//if(*it == bs)
|
||||
// m_map.erase(it);
|
||||
}
|
||||
BOOST_ARCHIVE_DECL const basic_serializer *
|
||||
basic_serializer_map::find(
|
||||
const boost::serialization::extended_type_info & eti
|
||||
) const {
|
||||
const basic_serializer_arg bs(eti);
|
||||
map_type::const_iterator it;
|
||||
it = m_map.find(& bs);
|
||||
if(it == m_map.end()){
|
||||
BOOST_ASSERT(false);
|
||||
return 0;
|
||||
}
|
||||
return *it;
|
||||
}
|
||||
|
||||
} // namespace detail
|
||||
} // namespace archive
|
||||
} // namespace boost
|
||||
|
||||
29
third_party/boost/libs/serialization/src/basic_text_iprimitive.cpp
vendored
Normal file
29
third_party/boost/libs/serialization/src/basic_text_iprimitive.cpp
vendored
Normal file
|
|
@ -0,0 +1,29 @@
|
|||
/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
|
||||
// basic_text_iprimitive.cpp:
|
||||
|
||||
// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
|
||||
// Use, modification and distribution is subject to the Boost Software
|
||||
// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
// See http://www.boost.org for updates, documentation, and revision history.
|
||||
|
||||
#if (defined _MSC_VER) && (_MSC_VER == 1200)
|
||||
# pragma warning (disable : 4786) // too long name, harmless warning
|
||||
#endif
|
||||
|
||||
#include <istream>
|
||||
|
||||
#define BOOST_ARCHIVE_SOURCE
|
||||
#include <boost/serialization/config.hpp>
|
||||
#include <boost/archive/detail/auto_link_archive.hpp>
|
||||
#include <boost/archive/impl/basic_text_iprimitive.ipp>
|
||||
|
||||
namespace boost {
|
||||
namespace archive {
|
||||
|
||||
// explicitly instantiate for this type of text stream
|
||||
template class basic_text_iprimitive<std::istream> ;
|
||||
|
||||
} // namespace archive
|
||||
} // namespace boost
|
||||
29
third_party/boost/libs/serialization/src/basic_text_oprimitive.cpp
vendored
Normal file
29
third_party/boost/libs/serialization/src/basic_text_oprimitive.cpp
vendored
Normal file
|
|
@ -0,0 +1,29 @@
|
|||
/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
|
||||
// basic_text_oprimitive.cpp:
|
||||
|
||||
// (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.
|
||||
|
||||
#if (defined _MSC_VER) && (_MSC_VER == 1200)
|
||||
# pragma warning (disable : 4786) // too long name, harmless warning
|
||||
#endif
|
||||
|
||||
#include <ostream>
|
||||
|
||||
#define BOOST_ARCHIVE_SOURCE
|
||||
#include <boost/serialization/config.hpp>
|
||||
#include <boost/archive/detail/auto_link_archive.hpp>
|
||||
#include <boost/archive/impl/basic_text_oprimitive.ipp>
|
||||
|
||||
namespace boost {
|
||||
namespace archive {
|
||||
|
||||
// explicitly instantiate for this type of text stream
|
||||
template class basic_text_oprimitive<std::ostream> ;
|
||||
|
||||
} // namespace archive
|
||||
} // namespace boost
|
||||
36
third_party/boost/libs/serialization/src/basic_text_wiprimitive.cpp
vendored
Normal file
36
third_party/boost/libs/serialization/src/basic_text_wiprimitive.cpp
vendored
Normal file
|
|
@ -0,0 +1,36 @@
|
|||
/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
|
||||
// basic_text_wiprimitive.cpp:
|
||||
|
||||
// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
|
||||
// Use, modification and distribution is subject to the Boost Software
|
||||
// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
// See http://www.boost.org for updates, documentation, and revision history.
|
||||
|
||||
#include <istream>
|
||||
|
||||
#include <boost/config.hpp>
|
||||
|
||||
#ifdef BOOST_NO_STD_WSTREAMBUF
|
||||
#error "wide char i/o not supported on this platform"
|
||||
#else
|
||||
|
||||
#if (defined _MSC_VER) && (_MSC_VER == 1200)
|
||||
# pragma warning (disable : 4786) // too long name, harmless warning
|
||||
#endif
|
||||
|
||||
#define BOOST_WARCHIVE_SOURCE
|
||||
#include <boost/serialization/config.hpp>
|
||||
#include <boost/archive/detail/auto_link_warchive.hpp>
|
||||
#include <boost/archive/impl/basic_text_iprimitive.ipp>
|
||||
|
||||
namespace boost {
|
||||
namespace archive {
|
||||
|
||||
template class basic_text_iprimitive<std::wistream> ;
|
||||
|
||||
} // namespace archive
|
||||
} // namespace boost
|
||||
|
||||
#endif // BOOST_NO_STD_WSTREAMBUF
|
||||
36
third_party/boost/libs/serialization/src/basic_text_woprimitive.cpp
vendored
Normal file
36
third_party/boost/libs/serialization/src/basic_text_woprimitive.cpp
vendored
Normal file
|
|
@ -0,0 +1,36 @@
|
|||
/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
|
||||
// basic_text_woprimitive.cpp:
|
||||
|
||||
// (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 <ostream>
|
||||
|
||||
#include <boost/config.hpp>
|
||||
|
||||
#ifdef BOOST_NO_STD_WSTREAMBUF
|
||||
#error "wide char i/o not supported on this platform"
|
||||
#else
|
||||
|
||||
#if (defined _MSC_VER) && (_MSC_VER == 1200)
|
||||
# pragma warning (disable : 4786) // too long name, harmless warning
|
||||
#endif
|
||||
|
||||
#define BOOST_WARCHIVE_SOURCE
|
||||
#include <boost/serialization/config.hpp>
|
||||
#include <boost/archive/detail/auto_link_warchive.hpp>
|
||||
#include <boost/archive/impl/basic_text_oprimitive.ipp>
|
||||
|
||||
namespace boost {
|
||||
namespace archive {
|
||||
|
||||
template class basic_text_oprimitive<std::wostream> ;
|
||||
|
||||
} // namespace archive
|
||||
} // namespace boost
|
||||
|
||||
#endif // BOOST_NO_STD_WSTREAMBUF
|
||||
52
third_party/boost/libs/serialization/src/basic_xml_archive.cpp
vendored
Normal file
52
third_party/boost/libs/serialization/src/basic_xml_archive.cpp
vendored
Normal file
|
|
@ -0,0 +1,52 @@
|
|||
/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
|
||||
// basic_xml_archive.cpp:
|
||||
|
||||
// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
|
||||
// Use, modification and distribution is subject to the 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.
|
||||
|
||||
#define BOOST_ARCHIVE_SOURCE
|
||||
#include <boost/serialization/config.hpp>
|
||||
#include <boost/archive/basic_xml_archive.hpp>
|
||||
|
||||
namespace boost {
|
||||
namespace archive {
|
||||
|
||||
BOOST_SYMBOL_VISIBLE const char *
|
||||
BOOST_ARCHIVE_XML_OBJECT_ID(){
|
||||
return "object_id";
|
||||
}
|
||||
BOOST_SYMBOL_VISIBLE const char *
|
||||
BOOST_ARCHIVE_XML_OBJECT_REFERENCE(){
|
||||
return "object_id_reference";
|
||||
}
|
||||
BOOST_SYMBOL_VISIBLE const char *
|
||||
BOOST_ARCHIVE_XML_CLASS_ID(){
|
||||
return "class_id";
|
||||
}
|
||||
BOOST_SYMBOL_VISIBLE const char *
|
||||
BOOST_ARCHIVE_XML_CLASS_ID_REFERENCE(){
|
||||
return "class_id_reference";
|
||||
}
|
||||
BOOST_SYMBOL_VISIBLE const char *
|
||||
BOOST_ARCHIVE_XML_CLASS_NAME(){
|
||||
return "class_name";
|
||||
}
|
||||
BOOST_SYMBOL_VISIBLE const char *
|
||||
BOOST_ARCHIVE_XML_TRACKING(){
|
||||
return "tracking_level";
|
||||
}
|
||||
BOOST_SYMBOL_VISIBLE const char *
|
||||
BOOST_ARCHIVE_XML_VERSION(){
|
||||
return "version";
|
||||
}
|
||||
BOOST_SYMBOL_VISIBLE const char *
|
||||
BOOST_ARCHIVE_XML_SIGNATURE(){
|
||||
return "signature";
|
||||
}
|
||||
|
||||
}// namespace archive
|
||||
}// namespace boost
|
||||
468
third_party/boost/libs/serialization/src/basic_xml_grammar.ipp
vendored
Normal file
468
third_party/boost/libs/serialization/src/basic_xml_grammar.ipp
vendored
Normal file
|
|
@ -0,0 +1,468 @@
|
|||
/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
|
||||
// basic_xml_grammar.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.
|
||||
|
||||
#if (defined _MSC_VER) && (_MSC_VER == 1200)
|
||||
# pragma warning (disable : 4786) // too long name, harmless warning
|
||||
#endif
|
||||
|
||||
#include <istream>
|
||||
#include <algorithm>
|
||||
#include <boost/config.hpp> // typename
|
||||
|
||||
#ifdef BOOST_MSVC
|
||||
# pragma warning(push)
|
||||
# pragma warning(disable : 4244 4511 4512)
|
||||
#endif
|
||||
|
||||
#include <cerrno> // errno
|
||||
#include <cstring> // strerror(errno)
|
||||
|
||||
// spirit stuff
|
||||
#include <boost/spirit/include/classic_operators.hpp>
|
||||
#include <boost/spirit/include/classic_actions.hpp>
|
||||
#include <boost/spirit/include/classic_numerics.hpp>
|
||||
|
||||
#ifdef BOOST_MSVC
|
||||
#pragma warning(pop)
|
||||
#endif
|
||||
|
||||
// for head_iterator test
|
||||
#include <boost/function.hpp>
|
||||
|
||||
#include <boost/io/ios_state.hpp>
|
||||
#include <boost/serialization/throw_exception.hpp>
|
||||
#include <boost/archive/impl/basic_xml_grammar.hpp>
|
||||
#include <boost/archive/xml_archive_exception.hpp>
|
||||
#include <boost/archive/basic_xml_archive.hpp>
|
||||
#include <boost/archive/iterators/xml_unescape.hpp>
|
||||
|
||||
using namespace boost::spirit::classic;
|
||||
|
||||
namespace boost {
|
||||
namespace archive {
|
||||
|
||||
/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
|
||||
// template code for basic_xml_grammar of both wchar_t and char types
|
||||
|
||||
namespace xml { // anonymous
|
||||
|
||||
#ifdef BOOST_MSVC
|
||||
# pragma warning(push)
|
||||
# pragma warning(disable : 4511 4512)
|
||||
#endif
|
||||
|
||||
template<class T>
|
||||
struct assign_impl {
|
||||
T & t;
|
||||
void operator()(const T t_) const {
|
||||
t = t_;
|
||||
}
|
||||
assign_impl(T & t_)
|
||||
: t(t_)
|
||||
{}
|
||||
};
|
||||
|
||||
template<>
|
||||
struct assign_impl<std::string> {
|
||||
std::string & t;
|
||||
void operator()(
|
||||
std::string::const_iterator b,
|
||||
std::string::const_iterator e
|
||||
) const {
|
||||
t.resize(0);
|
||||
while(b != e){
|
||||
t += * b;
|
||||
++b;
|
||||
}
|
||||
}
|
||||
assign_impl<std::string> & operator=(
|
||||
assign_impl<std::string> & rhs
|
||||
);
|
||||
assign_impl(std::string & t_)
|
||||
: t(t_)
|
||||
{}
|
||||
};
|
||||
|
||||
#ifndef BOOST_NO_STD_WSTRING
|
||||
template<>
|
||||
struct assign_impl<std::wstring> {
|
||||
std::wstring & t;
|
||||
void operator()(
|
||||
std::wstring::const_iterator b,
|
||||
std::wstring::const_iterator e
|
||||
) const {
|
||||
t.resize(0);
|
||||
while(b != e){
|
||||
t += * b;
|
||||
++b;
|
||||
}
|
||||
}
|
||||
assign_impl(std::wstring & t_)
|
||||
: t(t_)
|
||||
{}
|
||||
};
|
||||
#endif
|
||||
|
||||
template<class T>
|
||||
assign_impl<T> assign_object(T &t){
|
||||
return assign_impl<T>(t);
|
||||
}
|
||||
|
||||
struct assign_level {
|
||||
tracking_type & tracking_level;
|
||||
void operator()(const unsigned int tracking_level_) const {
|
||||
tracking_level = (0 == tracking_level_) ? false : true;
|
||||
}
|
||||
assign_level(tracking_type & tracking_level_)
|
||||
: tracking_level(tracking_level_)
|
||||
{}
|
||||
};
|
||||
|
||||
template<class String, class Iterator>
|
||||
struct append_string {
|
||||
String & contents;
|
||||
void operator()(Iterator start, Iterator end) const {
|
||||
#if 0
|
||||
typedef boost::archive::iterators::xml_unescape<Iterator> translator;
|
||||
contents.append(
|
||||
translator(BOOST_MAKE_PFTO_WRAPPER(start)),
|
||||
translator(BOOST_MAKE_PFTO_WRAPPER(end))
|
||||
);
|
||||
#endif
|
||||
contents.append(start, end);
|
||||
}
|
||||
append_string(String & contents_)
|
||||
: contents(contents_)
|
||||
{}
|
||||
};
|
||||
|
||||
template<class String>
|
||||
struct append_char {
|
||||
String & contents;
|
||||
void operator()(const unsigned int char_value) const {
|
||||
contents += static_cast<typename String::value_type>(char_value);
|
||||
}
|
||||
append_char(String & contents_)
|
||||
: contents(contents_)
|
||||
{}
|
||||
};
|
||||
|
||||
template<class String, unsigned int c>
|
||||
struct append_lit {
|
||||
String & contents;
|
||||
template<class X, class Y>
|
||||
void operator()(const X & /*x*/, const Y & /*y*/) const {
|
||||
const typename String::value_type z = c;
|
||||
contents += z;
|
||||
}
|
||||
append_lit(String & contents_)
|
||||
: contents(contents_)
|
||||
{}
|
||||
};
|
||||
|
||||
#ifdef BOOST_MSVC
|
||||
#pragma warning(pop)
|
||||
#endif
|
||||
|
||||
} // namespace anonymous
|
||||
|
||||
template<class CharType>
|
||||
bool basic_xml_grammar<CharType>::my_parse(
|
||||
typename basic_xml_grammar<CharType>::IStream & is,
|
||||
const rule_t & rule_,
|
||||
CharType delimiter
|
||||
) const {
|
||||
if(is.fail()){
|
||||
return false;
|
||||
}
|
||||
|
||||
is >> std::noskipws;
|
||||
|
||||
std::basic_string<CharType> arg;
|
||||
|
||||
for(;;){
|
||||
CharType result;
|
||||
is.get(result);
|
||||
if(is.fail()){
|
||||
boost::serialization::throw_exception(
|
||||
boost::archive::archive_exception(
|
||||
archive_exception::input_stream_error,
|
||||
std::strerror(errno)
|
||||
)
|
||||
);
|
||||
}
|
||||
if(is.eof())
|
||||
return false;
|
||||
arg += result;
|
||||
if(result == delimiter)
|
||||
break;
|
||||
}
|
||||
|
||||
// read just one more character. This will be the newline after the tag
|
||||
// this is so that the next operation will return fail if the archive
|
||||
// is terminated. This will permit the archive to be used for debug
|
||||
// and transaction data logging in the standard way.
|
||||
|
||||
parse_info<typename std::basic_string<CharType>::iterator>
|
||||
result = boost::spirit::classic::parse(arg.begin(), arg.end(), rule_);
|
||||
return result.hit;
|
||||
}
|
||||
|
||||
template<class CharType>
|
||||
bool basic_xml_grammar<CharType>::parse_start_tag(
|
||||
typename basic_xml_grammar<CharType>::IStream & is
|
||||
){
|
||||
rv.class_name.resize(0);
|
||||
return my_parse(is, STag);
|
||||
}
|
||||
|
||||
template<class CharType>
|
||||
bool basic_xml_grammar<CharType>::parse_end_tag(IStream & is) const {
|
||||
return my_parse(is, ETag);
|
||||
}
|
||||
|
||||
template<class CharType>
|
||||
bool basic_xml_grammar<CharType>::parse_string(IStream & is, StringType & s){
|
||||
rv.contents.resize(0);
|
||||
bool result = my_parse(is, content, '<');
|
||||
// note: unget caused a problem with dinkumware. replace with
|
||||
// is.unget();
|
||||
// putback another delimiter instead
|
||||
is.putback('<');
|
||||
if(result)
|
||||
s = rv.contents;
|
||||
return result;
|
||||
}
|
||||
|
||||
template<class CharType>
|
||||
basic_xml_grammar<CharType>::basic_xml_grammar(){
|
||||
init_chset();
|
||||
|
||||
S =
|
||||
+(Sch)
|
||||
;
|
||||
|
||||
// refactoring to workaround template depth on darwin
|
||||
NameHead = (Letter | '_' | ':');
|
||||
NameTail = *NameChar ;
|
||||
Name =
|
||||
NameHead >> NameTail
|
||||
;
|
||||
|
||||
Eq =
|
||||
!S >> '=' >> !S
|
||||
;
|
||||
|
||||
AttributeList =
|
||||
*(S >> Attribute)
|
||||
;
|
||||
|
||||
STag =
|
||||
!S
|
||||
>> '<'
|
||||
>> Name [xml::assign_object(rv.object_name)]
|
||||
>> AttributeList
|
||||
>> !S
|
||||
>> '>'
|
||||
;
|
||||
|
||||
ETag =
|
||||
!S
|
||||
>> "</"
|
||||
>> Name [xml::assign_object(rv.object_name)]
|
||||
>> !S
|
||||
>> '>'
|
||||
;
|
||||
|
||||
// refactoring to workaround template depth on darwin
|
||||
CharDataChars = +(anychar_p - chset_p(L"&<"));
|
||||
CharData =
|
||||
CharDataChars [
|
||||
xml::append_string<
|
||||
StringType,
|
||||
typename std::basic_string<CharType>::const_iterator
|
||||
>(rv.contents)
|
||||
]
|
||||
;
|
||||
|
||||
// slight factoring works around ICE in msvc 6.0
|
||||
CharRef1 =
|
||||
str_p(L"&#") >> uint_p [xml::append_char<StringType>(rv.contents)] >> L';'
|
||||
;
|
||||
CharRef2 =
|
||||
str_p(L"&#x") >> hex_p [xml::append_char<StringType>(rv.contents)] >> L';'
|
||||
;
|
||||
CharRef = CharRef1 | CharRef2 ;
|
||||
|
||||
AmpRef = str_p(L"&")[xml::append_lit<StringType, L'&'>(rv.contents)];
|
||||
LTRef = str_p(L"<")[xml::append_lit<StringType, L'<'>(rv.contents)];
|
||||
GTRef = str_p(L">")[xml::append_lit<StringType, L'>'>(rv.contents)];
|
||||
AposRef = str_p(L"'")[xml::append_lit<StringType, L'\''>(rv.contents)];
|
||||
QuoteRef = str_p(L""")[xml::append_lit<StringType, L'"'>(rv.contents)];
|
||||
|
||||
Reference =
|
||||
AmpRef
|
||||
| LTRef
|
||||
| GTRef
|
||||
| AposRef
|
||||
| QuoteRef
|
||||
| CharRef
|
||||
;
|
||||
|
||||
content =
|
||||
L"<" // should be end_p
|
||||
| +(Reference | CharData) >> L"<"
|
||||
;
|
||||
|
||||
ClassIDAttribute =
|
||||
str_p(BOOST_ARCHIVE_XML_CLASS_ID()) >> NameTail
|
||||
>> Eq
|
||||
>> L'"'
|
||||
>> int_p [xml::assign_object(rv.class_id)]
|
||||
>> L'"'
|
||||
;
|
||||
|
||||
ObjectIDAttribute = (
|
||||
str_p(BOOST_ARCHIVE_XML_OBJECT_ID())
|
||||
|
|
||||
str_p(BOOST_ARCHIVE_XML_OBJECT_REFERENCE())
|
||||
)
|
||||
>> NameTail
|
||||
>> Eq
|
||||
>> L'"'
|
||||
>> L'_'
|
||||
>> uint_p [xml::assign_object(rv.object_id)]
|
||||
>> L'"'
|
||||
;
|
||||
|
||||
AmpName = str_p(L"&")[xml::append_lit<StringType, L'&'>(rv.class_name)];
|
||||
LTName = str_p(L"<")[xml::append_lit<StringType, L'<'>(rv.class_name)];
|
||||
GTName = str_p(L">")[xml::append_lit<StringType, L'>'>(rv.class_name)];
|
||||
ClassNameChar =
|
||||
AmpName
|
||||
| LTName
|
||||
| GTName
|
||||
| (anychar_p - chset_p(L"\"")) [xml::append_char<StringType>(rv.class_name)]
|
||||
;
|
||||
|
||||
ClassName =
|
||||
* ClassNameChar
|
||||
;
|
||||
|
||||
ClassNameAttribute =
|
||||
str_p(BOOST_ARCHIVE_XML_CLASS_NAME())
|
||||
>> Eq
|
||||
>> L'"'
|
||||
>> ClassName
|
||||
>> L'"'
|
||||
;
|
||||
|
||||
TrackingAttribute =
|
||||
str_p(BOOST_ARCHIVE_XML_TRACKING())
|
||||
>> Eq
|
||||
>> L'"'
|
||||
>> uint_p [xml::assign_level(rv.tracking_level)]
|
||||
>> L'"'
|
||||
;
|
||||
|
||||
VersionAttribute =
|
||||
str_p(BOOST_ARCHIVE_XML_VERSION())
|
||||
>> Eq
|
||||
>> L'"'
|
||||
>> uint_p [xml::assign_object(rv.version)]
|
||||
>> L'"'
|
||||
;
|
||||
|
||||
UnusedAttribute =
|
||||
Name
|
||||
>> Eq
|
||||
>> L'"'
|
||||
>> !CharData
|
||||
>> L'"'
|
||||
;
|
||||
|
||||
Attribute =
|
||||
ClassIDAttribute
|
||||
| ObjectIDAttribute
|
||||
| ClassNameAttribute
|
||||
| TrackingAttribute
|
||||
| VersionAttribute
|
||||
| UnusedAttribute
|
||||
;
|
||||
|
||||
XMLDeclChars = *(anychar_p - chset_p(L"?>"));
|
||||
XMLDecl =
|
||||
!S
|
||||
>> str_p(L"<?xml")
|
||||
>> S
|
||||
>> str_p(L"version")
|
||||
>> Eq
|
||||
>> str_p(L"\"1.0\"")
|
||||
>> XMLDeclChars
|
||||
>> !S
|
||||
>> str_p(L"?>")
|
||||
;
|
||||
|
||||
DocTypeDeclChars = *(anychar_p - chset_p(L">"));
|
||||
DocTypeDecl =
|
||||
!S
|
||||
>> str_p(L"<!DOCTYPE")
|
||||
>> DocTypeDeclChars
|
||||
>> L'>'
|
||||
;
|
||||
|
||||
SignatureAttribute =
|
||||
str_p(L"signature")
|
||||
>> Eq
|
||||
>> L'"'
|
||||
>> Name [xml::assign_object(rv.class_name)]
|
||||
>> L'"'
|
||||
;
|
||||
|
||||
SerializationWrapper =
|
||||
!S
|
||||
>> str_p(L"<boost_serialization")
|
||||
>> S
|
||||
>> ( (SignatureAttribute >> S >> VersionAttribute)
|
||||
| (VersionAttribute >> S >> SignatureAttribute)
|
||||
)
|
||||
>> !S
|
||||
>> L'>'
|
||||
;
|
||||
}
|
||||
|
||||
template<class CharType>
|
||||
void basic_xml_grammar<CharType>::init(IStream & is){
|
||||
init_chset();
|
||||
if(! my_parse(is, XMLDecl))
|
||||
boost::serialization::throw_exception(
|
||||
xml_archive_exception(xml_archive_exception::xml_archive_parsing_error)
|
||||
);
|
||||
if(! my_parse(is, DocTypeDecl))
|
||||
boost::serialization::throw_exception(
|
||||
xml_archive_exception(xml_archive_exception::xml_archive_parsing_error)
|
||||
);
|
||||
if(! my_parse(is, SerializationWrapper))
|
||||
boost::serialization::throw_exception(
|
||||
xml_archive_exception(xml_archive_exception::xml_archive_parsing_error)
|
||||
);
|
||||
if(! std::equal(rv.class_name.begin(), rv.class_name.end(), BOOST_ARCHIVE_SIGNATURE()))
|
||||
boost::serialization::throw_exception(
|
||||
archive_exception(archive_exception::invalid_signature)
|
||||
);
|
||||
}
|
||||
|
||||
template<class CharType>
|
||||
bool basic_xml_grammar<CharType>::windup(IStream & is) {
|
||||
return my_parse(is, ETag);
|
||||
}
|
||||
|
||||
} // namespace archive
|
||||
} // namespace boost
|
||||
40
third_party/boost/libs/serialization/src/binary_iarchive.cpp
vendored
Normal file
40
third_party/boost/libs/serialization/src/binary_iarchive.cpp
vendored
Normal file
|
|
@ -0,0 +1,40 @@
|
|||
/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
|
||||
// binary_iarchive.cpp:
|
||||
|
||||
// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
|
||||
// Use, modification and distribution is subject to the 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>
|
||||
|
||||
#define BOOST_ARCHIVE_SOURCE
|
||||
#include <boost/serialization/config.hpp>
|
||||
#include <boost/archive/binary_iarchive.hpp>
|
||||
#include <boost/archive/detail/archive_serializer_map.hpp>
|
||||
|
||||
#include <boost/archive/impl/archive_serializer_map.ipp>
|
||||
#include <boost/archive/impl/basic_binary_iprimitive.ipp>
|
||||
#include <boost/archive/impl/basic_binary_iarchive.ipp>
|
||||
|
||||
namespace boost {
|
||||
namespace archive {
|
||||
|
||||
// explicitly instantiate for this type of stream
|
||||
template class detail::archive_serializer_map<binary_iarchive>;
|
||||
template class basic_binary_iprimitive<
|
||||
binary_iarchive,
|
||||
std::istream::char_type,
|
||||
std::istream::traits_type
|
||||
>;
|
||||
template class basic_binary_iarchive<binary_iarchive> ;
|
||||
template class binary_iarchive_impl<
|
||||
binary_iarchive,
|
||||
std::istream::char_type,
|
||||
std::istream::traits_type
|
||||
>;
|
||||
|
||||
} // namespace archive
|
||||
} // namespace boost
|
||||
40
third_party/boost/libs/serialization/src/binary_oarchive.cpp
vendored
Normal file
40
third_party/boost/libs/serialization/src/binary_oarchive.cpp
vendored
Normal file
|
|
@ -0,0 +1,40 @@
|
|||
/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
|
||||
// binary_oarchive.cpp:
|
||||
|
||||
// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
|
||||
// Use, modification and distribution is subject to the 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>
|
||||
|
||||
#define BOOST_ARCHIVE_SOURCE
|
||||
#include <boost/serialization/config.hpp>
|
||||
#include <boost/archive/binary_oarchive.hpp>
|
||||
#include <boost/archive/detail/archive_serializer_map.hpp>
|
||||
|
||||
// explicitly instantiate for this type of binary stream
|
||||
#include <boost/archive/impl/archive_serializer_map.ipp>
|
||||
#include <boost/archive/impl/basic_binary_oprimitive.ipp>
|
||||
#include <boost/archive/impl/basic_binary_oarchive.ipp>
|
||||
|
||||
namespace boost {
|
||||
namespace archive {
|
||||
|
||||
template class detail::archive_serializer_map<binary_oarchive>;
|
||||
template class basic_binary_oprimitive<
|
||||
binary_oarchive,
|
||||
std::ostream::char_type,
|
||||
std::ostream::traits_type
|
||||
>;
|
||||
template class basic_binary_oarchive<binary_oarchive> ;
|
||||
template class binary_oarchive_impl<
|
||||
binary_oarchive,
|
||||
std::ostream::char_type,
|
||||
std::ostream::traits_type
|
||||
>;
|
||||
|
||||
} // namespace archive
|
||||
} // namespace boost
|
||||
47
third_party/boost/libs/serialization/src/binary_wiarchive.cpp
vendored
Normal file
47
third_party/boost/libs/serialization/src/binary_wiarchive.cpp
vendored
Normal file
|
|
@ -0,0 +1,47 @@
|
|||
/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
|
||||
// binary_wiarchive.cpp:
|
||||
|
||||
// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
|
||||
// Use, modification and distribution is subject to the 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
|
||||
|
||||
#define BOOST_WARCHIVE_SOURCE
|
||||
#include <boost/archive/binary_wiarchive.hpp>
|
||||
#include <boost/archive/detail/archive_serializer_map.hpp>
|
||||
|
||||
// explicitly instantiate for this type of text stream
|
||||
#include <boost/archive/impl/archive_serializer_map.ipp>
|
||||
#include <boost/archive/impl/basic_binary_iprimitive.ipp>
|
||||
#include <boost/archive/impl/basic_binary_iarchive.ipp>
|
||||
|
||||
namespace boost {
|
||||
namespace archive {
|
||||
|
||||
// explicitly instantiate for this type of text stream
|
||||
template class detail::archive_serializer_map<binary_wiarchive>;
|
||||
template class basic_binary_iprimitive<
|
||||
binary_wiarchive,
|
||||
wchar_t,
|
||||
std::char_traits<wchar_t>
|
||||
>;
|
||||
template class basic_binary_iarchive<binary_wiarchive> ;
|
||||
template class binary_iarchive_impl<
|
||||
binary_wiarchive,
|
||||
wchar_t,
|
||||
std::char_traits<wchar_t>
|
||||
>;
|
||||
|
||||
} // namespace archive
|
||||
} // namespace boost
|
||||
|
||||
#endif // BOOST_NO_STD_WSTREAMBUF
|
||||
|
||||
44
third_party/boost/libs/serialization/src/binary_woarchive.cpp
vendored
Normal file
44
third_party/boost/libs/serialization/src/binary_woarchive.cpp
vendored
Normal file
|
|
@ -0,0 +1,44 @@
|
|||
/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
|
||||
// binary_woarchive.cpp:
|
||||
|
||||
// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
|
||||
// Use, modification and distribution is subject to the 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
|
||||
|
||||
#define BOOST_WARCHIVE_SOURCE
|
||||
#include <boost/archive/binary_woarchive.hpp>
|
||||
|
||||
// explicitly instantiate for this type of text stream
|
||||
#include <boost/archive/impl/archive_serializer_map.ipp>
|
||||
#include <boost/archive/impl/basic_binary_oprimitive.ipp>
|
||||
#include <boost/archive/impl/basic_binary_oarchive.ipp>
|
||||
|
||||
namespace boost {
|
||||
namespace archive {
|
||||
|
||||
template class detail::archive_serializer_map<binary_woarchive>;
|
||||
template class basic_binary_oprimitive<
|
||||
binary_woarchive,
|
||||
wchar_t,
|
||||
std::char_traits<wchar_t>
|
||||
>;
|
||||
template class basic_binary_oarchive<binary_woarchive> ;
|
||||
template class binary_oarchive_impl<
|
||||
binary_woarchive,
|
||||
wchar_t,
|
||||
std::char_traits<wchar_t>
|
||||
>;
|
||||
|
||||
} // namespace archive
|
||||
} // namespace boost
|
||||
|
||||
#endif // BOOST_NO_STD_WSTREAMBUF
|
||||
84
third_party/boost/libs/serialization/src/codecvt_null.cpp
vendored
Normal file
84
third_party/boost/libs/serialization/src/codecvt_null.cpp
vendored
Normal file
|
|
@ -0,0 +1,84 @@
|
|||
/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
|
||||
// codecvt_null.cpp
|
||||
|
||||
// Copyright (c) 2004 Robert Ramey, Indiana University (garcia@osl.iu.edu)
|
||||
// Andrew Lumsdaine, Indiana University (lums@osl.iu.edu).
|
||||
// Use, modification and distribution is subject to the Boost Software
|
||||
// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
#define BOOST_WARCHIVE_SOURCE
|
||||
#include <boost/serialization/config.hpp>
|
||||
#include <boost/archive/codecvt_null.hpp>
|
||||
|
||||
// codecvt implementation for passing wchar_t objects to char output
|
||||
// without any translation whatever. Used to implement binary output
|
||||
// of wchar_t objects.
|
||||
|
||||
namespace boost {
|
||||
namespace archive {
|
||||
|
||||
std::codecvt_base::result
|
||||
codecvt_null<wchar_t>::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 {
|
||||
while(first1 != last1){
|
||||
// Per std::22.2.1.5.2/2, we can store no more that
|
||||
// last2-first2 characters. If we need to more encode
|
||||
// next internal char type, return 'partial'.
|
||||
if(static_cast<int>(sizeof(wchar_t)) > (last2 - first2)){
|
||||
next1 = first1;
|
||||
next2 = first2;
|
||||
return std::codecvt_base::partial;
|
||||
}
|
||||
* reinterpret_cast<wchar_t *>(first2) = * first1++;
|
||||
first2 += sizeof(wchar_t);
|
||||
|
||||
}
|
||||
next1 = first1;
|
||||
next2 = first2;
|
||||
return std::codecvt_base::ok;
|
||||
}
|
||||
|
||||
std::codecvt_base::result
|
||||
codecvt_null<wchar_t>::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 {
|
||||
// Process input characters until we've run of them,
|
||||
// or the number of remaining characters is not
|
||||
// enough to construct another output character,
|
||||
// or we've run out of place for output characters.
|
||||
while(first2 != last2){
|
||||
// Have we converted all input characters?
|
||||
// Return with 'ok', if so.
|
||||
if (first1 == last1)
|
||||
break;
|
||||
// Do we have less input characters than needed
|
||||
// for a single output character?
|
||||
if(static_cast<int>(sizeof(wchar_t)) > (last1 - first1)){
|
||||
next1 = first1;
|
||||
next2 = first2;
|
||||
return std::codecvt_base::partial;
|
||||
}
|
||||
*first2++ = * reinterpret_cast<const wchar_t *>(first1);
|
||||
first1 += sizeof(wchar_t);
|
||||
}
|
||||
next1 = first1;
|
||||
next2 = first2;
|
||||
return std::codecvt_base::ok;
|
||||
}
|
||||
|
||||
} // namespace archive
|
||||
} // namespace boost
|
||||
196
third_party/boost/libs/serialization/src/extended_type_info.cpp
vendored
Normal file
196
third_party/boost/libs/serialization/src/extended_type_info.cpp
vendored
Normal file
|
|
@ -0,0 +1,196 @@
|
|||
/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
|
||||
// extended_type_info.cpp: implementation for portable version of type_info
|
||||
|
||||
// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
|
||||
// Use, modification and distribution is subject to the Boost Software
|
||||
// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
// See http://www.boost.org for updates, documentation, and revision history.
|
||||
|
||||
#if (defined _MSC_VER) && (_MSC_VER == 1200)
|
||||
# pragma warning (disable : 4786) // too long name, harmless warning
|
||||
#endif
|
||||
|
||||
#include <algorithm>
|
||||
#include <set>
|
||||
#include <utility>
|
||||
#include <boost/assert.hpp>
|
||||
#include <cstddef> // NULL
|
||||
|
||||
#include <cstring>
|
||||
#if defined(BOOST_NO_STDC_NAMESPACE)
|
||||
namespace std{ using ::strcmp; }
|
||||
#endif
|
||||
|
||||
#include <boost/config.hpp> // msvc needs this to suppress warning
|
||||
|
||||
#include <boost/core/no_exceptions_support.hpp>
|
||||
|
||||
// it marks our code with proper attributes as being exported when
|
||||
// we're compiling it while marking it import when just the headers
|
||||
// is being included.
|
||||
#define BOOST_SERIALIZATION_SOURCE
|
||||
#include <boost/serialization/config.hpp>
|
||||
#include <boost/serialization/singleton.hpp>
|
||||
#include <boost/serialization/force_include.hpp>
|
||||
#include <boost/serialization/extended_type_info.hpp>
|
||||
|
||||
#ifdef BOOST_MSVC
|
||||
# pragma warning(push)
|
||||
# pragma warning(disable : 4511 4512)
|
||||
#endif
|
||||
|
||||
namespace boost {
|
||||
namespace serialization {
|
||||
namespace detail {
|
||||
|
||||
struct key_compare
|
||||
{
|
||||
bool
|
||||
operator()(
|
||||
const extended_type_info * lhs,
|
||||
const extended_type_info * rhs
|
||||
) const {
|
||||
// performance shortcut
|
||||
if(lhs == rhs)
|
||||
return false;
|
||||
const char * l = lhs->get_key();
|
||||
BOOST_ASSERT(NULL != l);
|
||||
const char * r = rhs->get_key();
|
||||
BOOST_ASSERT(NULL != r);
|
||||
// performance shortcut
|
||||
// shortcut to exploit string pooling
|
||||
if(l == r)
|
||||
return false;
|
||||
// for exported types, use the string key so that
|
||||
// multiple instances in different translation units
|
||||
// can be matched up
|
||||
return std::strcmp(l, r) < 0;
|
||||
}
|
||||
};
|
||||
|
||||
typedef std::multiset<const extended_type_info *, key_compare> ktmap;
|
||||
|
||||
#ifdef BOOST_MSVC
|
||||
# pragma warning(push)
|
||||
# pragma warning(disable : 4511 4512)
|
||||
#endif
|
||||
|
||||
class extended_type_info_arg : public extended_type_info
|
||||
{
|
||||
virtual bool
|
||||
is_less_than(const extended_type_info & /*rhs*/) const {
|
||||
BOOST_ASSERT(false);
|
||||
return false;
|
||||
};
|
||||
virtual bool
|
||||
is_equal(const extended_type_info & /*rhs*/) const {
|
||||
BOOST_ASSERT(false);
|
||||
return false;
|
||||
};
|
||||
virtual const char * get_debug_info() const {
|
||||
return get_key();
|
||||
}
|
||||
virtual void * construct(unsigned int /*count*/, ...) const{
|
||||
BOOST_ASSERT(false);
|
||||
return NULL;
|
||||
}
|
||||
virtual void destroy(void const * const /*p*/) const {
|
||||
BOOST_ASSERT(false);
|
||||
}
|
||||
public:
|
||||
extended_type_info_arg(const char * key) :
|
||||
extended_type_info(0, key)
|
||||
{}
|
||||
|
||||
~extended_type_info_arg(){
|
||||
}
|
||||
};
|
||||
|
||||
#ifdef BOOST_MSVC
|
||||
# pragma warning(pop)
|
||||
#endif
|
||||
|
||||
} // namespace detail
|
||||
|
||||
BOOST_SERIALIZATION_DECL void
|
||||
extended_type_info::key_register() const{
|
||||
if(NULL == get_key())
|
||||
return;
|
||||
singleton<detail::ktmap>::get_mutable_instance().insert(this);
|
||||
}
|
||||
|
||||
BOOST_SERIALIZATION_DECL void
|
||||
extended_type_info::key_unregister() const{
|
||||
if(NULL == get_key())
|
||||
return;
|
||||
// note: it's been discovered that at least one platform is not guaranteed
|
||||
// to destroy singletons reverse order of construction. So we can't
|
||||
// use a runtime assert here. Leave this in a reminder not to do this!
|
||||
// BOOST_ASSERT(! singleton<detail::ktmap>::is_destroyed());
|
||||
if(! singleton<detail::ktmap>::is_destroyed()){
|
||||
detail::ktmap & x = singleton<detail::ktmap>::get_mutable_instance();
|
||||
detail::ktmap::iterator start = x.lower_bound(this);
|
||||
detail::ktmap::iterator end = x.upper_bound(this);
|
||||
// remove entry in map which corresponds to this type
|
||||
for(;start != end; ++start){
|
||||
if(this == *start){
|
||||
x.erase(start);
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
BOOST_SERIALIZATION_DECL const extended_type_info *
|
||||
extended_type_info::find(const char *key) {
|
||||
BOOST_ASSERT(NULL != key);
|
||||
const detail::ktmap & k = singleton<detail::ktmap>::get_const_instance();
|
||||
const detail::extended_type_info_arg eti_key(key);
|
||||
const detail::ktmap::const_iterator it = k.find(& eti_key);
|
||||
if(k.end() == it)
|
||||
return NULL;
|
||||
return *(it);
|
||||
}
|
||||
|
||||
BOOST_SERIALIZATION_DECL
|
||||
extended_type_info::extended_type_info(
|
||||
const unsigned int type_info_key,
|
||||
const char * key
|
||||
) :
|
||||
m_type_info_key(type_info_key),
|
||||
m_key(key)
|
||||
{
|
||||
}
|
||||
|
||||
BOOST_SERIALIZATION_DECL
|
||||
extended_type_info::~extended_type_info(){
|
||||
}
|
||||
|
||||
BOOST_SERIALIZATION_DECL bool
|
||||
extended_type_info::operator<(const extended_type_info &rhs) const {
|
||||
// short cut for a common cases
|
||||
if(this == & rhs)
|
||||
return false;
|
||||
if(m_type_info_key == rhs.m_type_info_key){
|
||||
return is_less_than(rhs);
|
||||
}
|
||||
if(m_type_info_key < rhs.m_type_info_key)
|
||||
return true;
|
||||
return false;
|
||||
}
|
||||
|
||||
BOOST_SERIALIZATION_DECL bool
|
||||
extended_type_info::operator==(const extended_type_info &rhs) const {
|
||||
// short cut for a common cases
|
||||
if(this == & rhs)
|
||||
return true;
|
||||
if(m_type_info_key != rhs.m_type_info_key){
|
||||
return false;
|
||||
}
|
||||
return is_equal(rhs);
|
||||
}
|
||||
|
||||
} // namespace serialization
|
||||
} // namespace boost
|
||||
89
third_party/boost/libs/serialization/src/extended_type_info_no_rtti.cpp
vendored
Normal file
89
third_party/boost/libs/serialization/src/extended_type_info_no_rtti.cpp
vendored
Normal file
|
|
@ -0,0 +1,89 @@
|
|||
/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
|
||||
// extended_type_info_no_rtti.cpp: specific implementation of type info
|
||||
// that is NOT based on typeid
|
||||
|
||||
// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
|
||||
// Use, modification and distribution is subject to the Boost Software
|
||||
// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
// See http://www.boost.org for updates, documentation, and revision history.
|
||||
|
||||
#include <cstring>
|
||||
#include <cstddef> // NULL
|
||||
#include <boost/assert.hpp>
|
||||
|
||||
#include <boost/config.hpp>
|
||||
#if defined(BOOST_NO_STDC_NAMESPACE)
|
||||
namespace std{ using ::strcmp; }
|
||||
#endif
|
||||
|
||||
// it marks our code with proper attributes as being exported when
|
||||
// we're compiling it while marking it import when just the headers
|
||||
// is being included.
|
||||
#define BOOST_SERIALIZATION_SOURCE
|
||||
#include <boost/serialization/config.hpp>
|
||||
#include <boost/serialization/extended_type_info_no_rtti.hpp>
|
||||
|
||||
#define EXTENDED_TYPE_INFO_NO_RTTI_KEY 2
|
||||
|
||||
namespace boost {
|
||||
namespace serialization {
|
||||
namespace no_rtti_system {
|
||||
|
||||
BOOST_SERIALIZATION_DECL
|
||||
extended_type_info_no_rtti_0::extended_type_info_no_rtti_0(
|
||||
const char * key
|
||||
) :
|
||||
extended_type_info(EXTENDED_TYPE_INFO_NO_RTTI_KEY, key)
|
||||
{}
|
||||
|
||||
BOOST_SERIALIZATION_DECL bool
|
||||
extended_type_info_no_rtti_0::is_less_than(
|
||||
const boost::serialization::extended_type_info &rhs) const
|
||||
{
|
||||
// shortcut for common case
|
||||
if(this == & rhs)
|
||||
return false;
|
||||
const char * l = get_key();
|
||||
const char * r = rhs.get_key();
|
||||
// if this assertion is triggered, it could mean one of the following
|
||||
// a) This class was never exported - make sure all calls which use
|
||||
// this method of type id are in fact exported.
|
||||
// b) This class was used (e.g. serialized through a pointer) before
|
||||
// it was exported. Make sure that classes which use this method
|
||||
// of type id are NOT "automatically" registered by serializating
|
||||
// through a pointer to the to most derived class. OR make sure
|
||||
// that the BOOST_CLASS_EXPORT is included in every file
|
||||
// which does this.
|
||||
BOOST_ASSERT(NULL != l);
|
||||
BOOST_ASSERT(NULL != r);
|
||||
return std::strcmp(l, r) < 0;
|
||||
}
|
||||
|
||||
BOOST_SERIALIZATION_DECL bool
|
||||
extended_type_info_no_rtti_0::is_equal(
|
||||
const boost::serialization::extended_type_info &rhs) const
|
||||
{
|
||||
// shortcut for common case
|
||||
if(this == & rhs)
|
||||
return true;
|
||||
// null keys don't match with anything
|
||||
const char * l = get_key();
|
||||
BOOST_ASSERT(NULL != l);
|
||||
if(NULL == l)
|
||||
return false;
|
||||
const char * r = rhs.get_key();
|
||||
BOOST_ASSERT(NULL != r);
|
||||
if(NULL == r)
|
||||
return false;
|
||||
return 0 == std::strcmp(l, r);
|
||||
}
|
||||
|
||||
BOOST_SERIALIZATION_DECL
|
||||
extended_type_info_no_rtti_0::~extended_type_info_no_rtti_0()
|
||||
{}
|
||||
|
||||
} // namespece detail
|
||||
} // namespace serialization
|
||||
} // namespace boost
|
||||
167
third_party/boost/libs/serialization/src/extended_type_info_typeid.cpp
vendored
Normal file
167
third_party/boost/libs/serialization/src/extended_type_info_typeid.cpp
vendored
Normal file
|
|
@ -0,0 +1,167 @@
|
|||
/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
|
||||
// extended_type_info_typeid.cpp: specific implementation of type info
|
||||
// that is based on typeid
|
||||
|
||||
// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
|
||||
// Use, modification and distribution is subject to the 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 <set>
|
||||
#include <boost/assert.hpp>
|
||||
#include <typeinfo>
|
||||
#include <cstddef> // NULL
|
||||
|
||||
#include <boost/core/no_exceptions_support.hpp>
|
||||
|
||||
// it marks our code with proper attributes as being exported when
|
||||
// we're compiling it while marking it import when just the headers
|
||||
// is being included.
|
||||
#define BOOST_SERIALIZATION_SOURCE
|
||||
#include <boost/serialization/config.hpp>
|
||||
#include <boost/serialization/singleton.hpp>
|
||||
#include <boost/serialization/extended_type_info_typeid.hpp>
|
||||
|
||||
namespace boost {
|
||||
namespace serialization {
|
||||
namespace typeid_system {
|
||||
|
||||
#define EXTENDED_TYPE_INFO_TYPE_KEY 1
|
||||
|
||||
struct type_compare
|
||||
{
|
||||
bool
|
||||
operator()(
|
||||
const extended_type_info_typeid_0 * lhs,
|
||||
const extended_type_info_typeid_0 * rhs
|
||||
) const {
|
||||
return lhs->is_less_than(*rhs);
|
||||
}
|
||||
};
|
||||
|
||||
typedef std::multiset<
|
||||
const extended_type_info_typeid_0 *,
|
||||
type_compare
|
||||
> tkmap;
|
||||
|
||||
BOOST_SERIALIZATION_DECL bool
|
||||
extended_type_info_typeid_0::is_less_than(
|
||||
const boost::serialization::extended_type_info & rhs
|
||||
) const {
|
||||
// shortcut for common case
|
||||
if(this == & rhs)
|
||||
return false;
|
||||
return 0 != m_ti->before(
|
||||
*(static_cast<const extended_type_info_typeid_0 &>(rhs).m_ti)
|
||||
);
|
||||
}
|
||||
|
||||
BOOST_SERIALIZATION_DECL bool
|
||||
extended_type_info_typeid_0::is_equal(
|
||||
const boost::serialization::extended_type_info & rhs
|
||||
) const {
|
||||
return
|
||||
// note: std::type_info == operator returns an int !!!
|
||||
// the following permits conversion to bool without a warning.
|
||||
! (
|
||||
* m_ti
|
||||
!= *(static_cast<const extended_type_info_typeid_0 &>(rhs).m_ti)
|
||||
)
|
||||
;
|
||||
}
|
||||
|
||||
BOOST_SERIALIZATION_DECL
|
||||
extended_type_info_typeid_0::extended_type_info_typeid_0(
|
||||
const char * key
|
||||
) :
|
||||
extended_type_info(EXTENDED_TYPE_INFO_TYPE_KEY, key),
|
||||
m_ti(NULL)
|
||||
{}
|
||||
|
||||
BOOST_SERIALIZATION_DECL
|
||||
extended_type_info_typeid_0::~extended_type_info_typeid_0()
|
||||
{}
|
||||
|
||||
BOOST_SERIALIZATION_DECL void
|
||||
extended_type_info_typeid_0::type_register(const std::type_info & ti){
|
||||
m_ti = & ti;
|
||||
singleton<tkmap>::get_mutable_instance().insert(this);
|
||||
}
|
||||
|
||||
BOOST_SERIALIZATION_DECL void
|
||||
extended_type_info_typeid_0::type_unregister()
|
||||
{
|
||||
if(NULL != m_ti){
|
||||
// note: previously this conditional was a runtime assertion with
|
||||
// BOOST_ASSERT. We've changed it because we've discovered that at
|
||||
// least one platform is not guaranteed to destroy singletons in
|
||||
// reverse order of distruction.
|
||||
// BOOST_ASSERT(! singleton<tkmap>::is_destroyed());
|
||||
if(! singleton<tkmap>::is_destroyed()){
|
||||
tkmap & x = singleton<tkmap>::get_mutable_instance();
|
||||
|
||||
// remove all entries in map which corresponds to this type
|
||||
// make sure that we don't use any invalidated iterators
|
||||
for(;;){
|
||||
const tkmap::iterator & it = x.find(this);
|
||||
if(it == x.end())
|
||||
break;
|
||||
x.erase(it);
|
||||
};
|
||||
}
|
||||
}
|
||||
m_ti = NULL;
|
||||
}
|
||||
|
||||
#ifdef BOOST_MSVC
|
||||
# pragma warning(push)
|
||||
# pragma warning(disable : 4511 4512)
|
||||
#endif
|
||||
|
||||
// this derivation is used for creating search arguments
|
||||
class extended_type_info_typeid_arg :
|
||||
public extended_type_info_typeid_0
|
||||
{
|
||||
virtual void * construct(unsigned int /*count*/, ...) const{
|
||||
BOOST_ASSERT(false);
|
||||
return NULL;
|
||||
}
|
||||
virtual void destroy(void const * const /*p*/) const {
|
||||
BOOST_ASSERT(false);
|
||||
}
|
||||
public:
|
||||
extended_type_info_typeid_arg(const std::type_info & ti) :
|
||||
extended_type_info_typeid_0(NULL)
|
||||
{
|
||||
// note absense of self register and key as this is used only as
|
||||
// search argument given a type_info reference and is not to
|
||||
// be added to the map.
|
||||
m_ti = & ti;
|
||||
}
|
||||
~extended_type_info_typeid_arg(){
|
||||
m_ti = NULL;
|
||||
}
|
||||
};
|
||||
|
||||
#ifdef BOOST_MSVC
|
||||
# pragma warning(pop)
|
||||
#endif
|
||||
|
||||
BOOST_SERIALIZATION_DECL const extended_type_info *
|
||||
extended_type_info_typeid_0::get_extended_type_info(
|
||||
const std::type_info & ti
|
||||
) const {
|
||||
typeid_system::extended_type_info_typeid_arg etia(ti);
|
||||
const tkmap & t = singleton<tkmap>::get_const_instance();
|
||||
const tkmap::const_iterator it = t.find(& etia);
|
||||
if(t.end() == it)
|
||||
return NULL;
|
||||
return *(it);
|
||||
}
|
||||
|
||||
} // namespace detail
|
||||
} // namespace serialization
|
||||
} // namespace boost
|
||||
30
third_party/boost/libs/serialization/src/polymorphic_binary_iarchive.cpp
vendored
Normal file
30
third_party/boost/libs/serialization/src/polymorphic_binary_iarchive.cpp
vendored
Normal file
|
|
@ -0,0 +1,30 @@
|
|||
/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
|
||||
// polymorphic_binary_iarchive.cpp:
|
||||
|
||||
// (C) Copyright 2018 Robert Ramey - http://www.rrsd.com .
|
||||
// Use, modification and distribution is subject to the Boost Software
|
||||
// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
// See http://www.boost.org for updates, documentation, and revision history.
|
||||
|
||||
#if (defined _MSC_VER) && (_MSC_VER == 1200)
|
||||
# pragma warning (disable : 4786) // too long name, harmless warning
|
||||
#endif
|
||||
|
||||
#define BOOST_ARCHIVE_SOURCE
|
||||
#include <boost/serialization/config.hpp>
|
||||
#include <boost/archive/polymorphic_binary_iarchive.hpp>
|
||||
|
||||
// explicitly instantiate for this type of text stream
|
||||
#include <boost/archive/impl/archive_serializer_map.ipp>
|
||||
|
||||
namespace boost {
|
||||
namespace archive {
|
||||
namespace detail {
|
||||
|
||||
template class archive_serializer_map<polymorphic_binary_iarchive>;
|
||||
|
||||
} // detail
|
||||
} // archive
|
||||
} // boost
|
||||
30
third_party/boost/libs/serialization/src/polymorphic_binary_oarchive.cpp
vendored
Normal file
30
third_party/boost/libs/serialization/src/polymorphic_binary_oarchive.cpp
vendored
Normal file
|
|
@ -0,0 +1,30 @@
|
|||
/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
|
||||
// polymorphic_binary_oarchive.cpp:
|
||||
|
||||
// (C) Copyright 2018 Robert Ramey - http://www.rrsd.com .
|
||||
// Use, modification and distribution is subject to the Boost Software
|
||||
// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
// See http://www.boost.org for updates, documentation, and revision history.
|
||||
|
||||
#if (defined _MSC_VER) && (_MSC_VER == 1200)
|
||||
# pragma warning (disable : 4786) // too long name, harmless warning
|
||||
#endif
|
||||
|
||||
#define BOOST_ARCHIVE_SOURCE
|
||||
#include <boost/serialization/config.hpp>
|
||||
#include <boost/archive/polymorphic_binary_oarchive.hpp>
|
||||
|
||||
// explicitly instantiate for this type of text stream
|
||||
#include <boost/archive/impl/archive_serializer_map.ipp>
|
||||
|
||||
namespace boost {
|
||||
namespace archive {
|
||||
namespace detail {
|
||||
|
||||
template class detail::archive_serializer_map<polymorphic_binary_oarchive>;
|
||||
|
||||
} // detail
|
||||
} // archive
|
||||
} // boost
|
||||
30
third_party/boost/libs/serialization/src/polymorphic_iarchive.cpp
vendored
Normal file
30
third_party/boost/libs/serialization/src/polymorphic_iarchive.cpp
vendored
Normal file
|
|
@ -0,0 +1,30 @@
|
|||
/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
|
||||
// polymorphic_iarchive.cpp:
|
||||
|
||||
// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
|
||||
// Use, modification and distribution is subject to the Boost Software
|
||||
// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
// See http://www.boost.org for updates, documentation, and revision history.
|
||||
|
||||
#if (defined _MSC_VER) && (_MSC_VER == 1200)
|
||||
# pragma warning (disable : 4786) // too long name, harmless warning
|
||||
#endif
|
||||
|
||||
#define BOOST_ARCHIVE_SOURCE
|
||||
#include <boost/serialization/config.hpp>
|
||||
#include <boost/archive/detail/archive_serializer_map.hpp>
|
||||
|
||||
#include <boost/archive/impl/archive_serializer_map.ipp>
|
||||
#include <boost/archive/polymorphic_iarchive.hpp>
|
||||
|
||||
namespace boost {
|
||||
namespace archive {
|
||||
namespace detail {
|
||||
|
||||
template class archive_serializer_map<polymorphic_iarchive>;
|
||||
|
||||
} // detail
|
||||
} // archive
|
||||
} // boost
|
||||
30
third_party/boost/libs/serialization/src/polymorphic_oarchive.cpp
vendored
Normal file
30
third_party/boost/libs/serialization/src/polymorphic_oarchive.cpp
vendored
Normal file
|
|
@ -0,0 +1,30 @@
|
|||
/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
|
||||
// polymorphic_oarchive.cpp:
|
||||
|
||||
// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
|
||||
// Use, modification and distribution is subject to the Boost Software
|
||||
// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
// See http://www.boost.org for updates, documentation, and revision history.
|
||||
|
||||
#if (defined _MSC_VER) && (_MSC_VER == 1200)
|
||||
# pragma warning (disable : 4786) // too long name, harmless warning
|
||||
#endif
|
||||
|
||||
#define BOOST_ARCHIVE_SOURCE
|
||||
#include <boost/serialization/config.hpp>
|
||||
#include <boost/archive/detail/archive_serializer_map.hpp>
|
||||
|
||||
#include <boost/archive/impl/archive_serializer_map.ipp>
|
||||
#include <boost/archive/polymorphic_oarchive.hpp>
|
||||
|
||||
namespace boost {
|
||||
namespace archive {
|
||||
namespace detail {
|
||||
|
||||
template class archive_serializer_map<polymorphic_oarchive>;
|
||||
|
||||
} // detail
|
||||
} // archive
|
||||
} // boost
|
||||
30
third_party/boost/libs/serialization/src/polymorphic_text_iarchive.cpp
vendored
Normal file
30
third_party/boost/libs/serialization/src/polymorphic_text_iarchive.cpp
vendored
Normal file
|
|
@ -0,0 +1,30 @@
|
|||
/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
|
||||
// polymorphic_text_iarchive.cpp:
|
||||
|
||||
// (C) Copyright 2018 Robert Ramey - http://www.rrsd.com .
|
||||
// Use, modification and distribution is subject to the Boost Software
|
||||
// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
// See http://www.boost.org for updates, documentation, and revision history.
|
||||
|
||||
#if (defined _MSC_VER) && (_MSC_VER == 1200)
|
||||
# pragma warning (disable : 4786) // too long name, harmless warning
|
||||
#endif
|
||||
|
||||
#define BOOST_ARCHIVE_SOURCE
|
||||
#include <boost/serialization/config.hpp>
|
||||
#include <boost/archive/polymorphic_text_iarchive.hpp>
|
||||
|
||||
// explicitly instantiate for this type of text stream
|
||||
#include <boost/archive/impl/archive_serializer_map.ipp>
|
||||
|
||||
namespace boost {
|
||||
namespace archive {
|
||||
namespace detail {
|
||||
|
||||
template class archive_serializer_map<polymorphic_text_iarchive>;
|
||||
|
||||
} // detail
|
||||
} // archive
|
||||
} // boost
|
||||
30
third_party/boost/libs/serialization/src/polymorphic_text_oarchive.cpp
vendored
Normal file
30
third_party/boost/libs/serialization/src/polymorphic_text_oarchive.cpp
vendored
Normal file
|
|
@ -0,0 +1,30 @@
|
|||
/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
|
||||
// polymorphic_text_oarchive.cpp:
|
||||
|
||||
// (C) Copyright 2018 Robert Ramey - http://www.rrsd.com .
|
||||
// Use, modification and distribution is subject to the Boost Software
|
||||
// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
// See http://www.boost.org for updates, documentation, and revision history.
|
||||
|
||||
#if (defined _MSC_VER) && (_MSC_VER == 1200)
|
||||
# pragma warning (disable : 4786) // too long name, harmless warning
|
||||
#endif
|
||||
|
||||
#define BOOST_ARCHIVE_SOURCE
|
||||
#include <boost/serialization/config.hpp>
|
||||
#include <boost/archive/polymorphic_text_oarchive.hpp>
|
||||
|
||||
// explicitly instantiate for this type of text stream
|
||||
#include <boost/archive/impl/archive_serializer_map.ipp>
|
||||
|
||||
namespace boost {
|
||||
namespace archive {
|
||||
namespace detail {
|
||||
|
||||
template class detail::archive_serializer_map<polymorphic_text_oarchive>;
|
||||
|
||||
} // detail
|
||||
} // archive
|
||||
} // boost
|
||||
30
third_party/boost/libs/serialization/src/polymorphic_text_wiarchive.cpp
vendored
Normal file
30
third_party/boost/libs/serialization/src/polymorphic_text_wiarchive.cpp
vendored
Normal file
|
|
@ -0,0 +1,30 @@
|
|||
/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
|
||||
// polymorphic_text_wiarchive.cpp:
|
||||
|
||||
// (C) Copyright 2018 Robert Ramey - http://www.rrsd.com .
|
||||
// Use, modification and distribution is subject to the Boost Software
|
||||
// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
// See http://www.boost.org for updates, documentation, and revision history.
|
||||
|
||||
#if (defined _MSC_VER) && (_MSC_VER == 1200)
|
||||
# pragma warning (disable : 4786) // too long name, harmless warning
|
||||
#endif
|
||||
|
||||
#define BOOST_ARCHIVE_SOURCE
|
||||
#include <boost/serialization/config.hpp>
|
||||
#include <boost/archive/polymorphic_text_wiarchive.hpp>
|
||||
|
||||
// explicitly instantiate for this type of text stream
|
||||
#include <boost/archive/impl/archive_serializer_map.ipp>
|
||||
|
||||
namespace boost {
|
||||
namespace archive {
|
||||
namespace detail {
|
||||
|
||||
template class archive_serializer_map<polymorphic_text_wiarchive>;
|
||||
|
||||
} // detail
|
||||
} // archive
|
||||
} // boost
|
||||
30
third_party/boost/libs/serialization/src/polymorphic_text_woarchive.cpp
vendored
Normal file
30
third_party/boost/libs/serialization/src/polymorphic_text_woarchive.cpp
vendored
Normal file
|
|
@ -0,0 +1,30 @@
|
|||
/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
|
||||
// polymorphic_text_woarchive.cpp:
|
||||
|
||||
// (C) Copyright 2018 Robert Ramey - http://www.rrsd.com .
|
||||
// Use, modification and distribution is subject to the Boost Software
|
||||
// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
// See http://www.boost.org for updates, documentation, and revision history.
|
||||
|
||||
#if (defined _MSC_VER) && (_MSC_VER == 1200)
|
||||
# pragma warning (disable : 4786) // too long name, harmless warning
|
||||
#endif
|
||||
|
||||
#define BOOST_ARCHIVE_SOURCE
|
||||
#include <boost/serialization/config.hpp>
|
||||
#include <boost/archive/polymorphic_text_woarchive.hpp>
|
||||
|
||||
// explicitly instantiate for this type of text stream
|
||||
#include <boost/archive/impl/archive_serializer_map.ipp>
|
||||
|
||||
namespace boost {
|
||||
namespace archive {
|
||||
namespace detail {
|
||||
|
||||
template class detail::archive_serializer_map<polymorphic_text_woarchive>;
|
||||
|
||||
} // detail
|
||||
} // archive
|
||||
} // boost
|
||||
30
third_party/boost/libs/serialization/src/polymorphic_xml_iarchive.cpp
vendored
Normal file
30
third_party/boost/libs/serialization/src/polymorphic_xml_iarchive.cpp
vendored
Normal file
|
|
@ -0,0 +1,30 @@
|
|||
/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
|
||||
// polymorphic_xml_iarchive.cpp:
|
||||
|
||||
// (C) Copyright 2018 Robert Ramey - http://www.rrsd.com .
|
||||
// Use, modification and distribution is subject to the Boost Software
|
||||
// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
// See http://www.boost.org for updates, documentation, and revision history.
|
||||
|
||||
#if (defined _MSC_VER) && (_MSC_VER == 1200)
|
||||
# pragma warning (disable : 4786) // too long name, harmless warning
|
||||
#endif
|
||||
|
||||
#define BOOST_ARCHIVE_SOURCE
|
||||
#include <boost/serialization/config.hpp>
|
||||
#include <boost/archive/polymorphic_xml_iarchive.hpp>
|
||||
|
||||
// explicitly instantiate for this type of text stream
|
||||
#include <boost/archive/impl/archive_serializer_map.ipp>
|
||||
|
||||
namespace boost {
|
||||
namespace archive {
|
||||
namespace detail {
|
||||
|
||||
template class archive_serializer_map<polymorphic_xml_iarchive>;
|
||||
|
||||
} // detail
|
||||
} // archive
|
||||
} // boost
|
||||
30
third_party/boost/libs/serialization/src/polymorphic_xml_oarchive.cpp
vendored
Normal file
30
third_party/boost/libs/serialization/src/polymorphic_xml_oarchive.cpp
vendored
Normal file
|
|
@ -0,0 +1,30 @@
|
|||
/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
|
||||
// polymorphic_xml_oarchive.cpp:
|
||||
|
||||
// (C) Copyright 2018 Robert Ramey - http://www.rrsd.com .
|
||||
// Use, modification and distribution is subject to the Boost Software
|
||||
// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
// See http://www.boost.org for updates, documentation, and revision history.
|
||||
|
||||
#if (defined _MSC_VER) && (_MSC_VER == 1200)
|
||||
# pragma warning (disable : 4786) // too long name, harmless warning
|
||||
#endif
|
||||
|
||||
#define BOOST_ARCHIVE_SOURCE
|
||||
#include <boost/serialization/config.hpp>
|
||||
#include <boost/archive/polymorphic_xml_oarchive.hpp>
|
||||
|
||||
// explicitly instantiate for this type of text stream
|
||||
#include <boost/archive/impl/archive_serializer_map.ipp>
|
||||
|
||||
namespace boost {
|
||||
namespace archive {
|
||||
namespace detail {
|
||||
|
||||
template class detail::archive_serializer_map<polymorphic_xml_oarchive>;
|
||||
|
||||
} // detail
|
||||
} // archive
|
||||
} // boost
|
||||
30
third_party/boost/libs/serialization/src/polymorphic_xml_wiarchive.cpp
vendored
Normal file
30
third_party/boost/libs/serialization/src/polymorphic_xml_wiarchive.cpp
vendored
Normal file
|
|
@ -0,0 +1,30 @@
|
|||
/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
|
||||
// polymorphic_xml_wiarchive.cpp:
|
||||
|
||||
// (C) Copyright 2018 Robert Ramey - http://www.rrsd.com .
|
||||
// Use, modification and distribution is subject to the Boost Software
|
||||
// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
// See http://www.boost.org for updates, documentation, and revision history.
|
||||
|
||||
#if (defined _MSC_VER) && (_MSC_VER == 1200)
|
||||
# pragma warning (disable : 4786) // too long name, harmless warning
|
||||
#endif
|
||||
|
||||
#define BOOST_ARCHIVE_SOURCE
|
||||
#include <boost/serialization/config.hpp>
|
||||
#include <boost/archive/polymorphic_xml_wiarchive.hpp>
|
||||
|
||||
// explicitly instantiate for this type of text stream
|
||||
#include <boost/archive/impl/archive_serializer_map.ipp>
|
||||
|
||||
namespace boost {
|
||||
namespace archive {
|
||||
namespace detail {
|
||||
|
||||
template class archive_serializer_map<polymorphic_xml_wiarchive>;
|
||||
|
||||
} // detail
|
||||
} // archive
|
||||
} // boost
|
||||
30
third_party/boost/libs/serialization/src/polymorphic_xml_woarchive.cpp
vendored
Normal file
30
third_party/boost/libs/serialization/src/polymorphic_xml_woarchive.cpp
vendored
Normal file
|
|
@ -0,0 +1,30 @@
|
|||
/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
|
||||
// polymorphic_xml_woarchive.cpp:
|
||||
|
||||
// (C) Copyright 2018 Robert Ramey - http://www.rrsd.com .
|
||||
// Use, modification and distribution is subject to the Boost Software
|
||||
// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
// See http://www.boost.org for updates, documentation, and revision history.
|
||||
|
||||
#if (defined _MSC_VER) && (_MSC_VER == 1200)
|
||||
# pragma warning (disable : 4786) // too long name, harmless warning
|
||||
#endif
|
||||
|
||||
#define BOOST_ARCHIVE_SOURCE
|
||||
#include <boost/serialization/config.hpp>
|
||||
#include <boost/archive/polymorphic_xml_woarchive.hpp>
|
||||
|
||||
// explicitly instantiate for this type of text stream
|
||||
#include <boost/archive/impl/archive_serializer_map.ipp>
|
||||
|
||||
namespace boost {
|
||||
namespace archive {
|
||||
namespace detail {
|
||||
|
||||
template class detail::archive_serializer_map<polymorphic_xml_woarchive>;
|
||||
|
||||
} // detail
|
||||
} // archive
|
||||
} // boost
|
||||
42
third_party/boost/libs/serialization/src/stl_port.cpp
vendored
Normal file
42
third_party/boost/libs/serialization/src/stl_port.cpp
vendored
Normal file
|
|
@ -0,0 +1,42 @@
|
|||
/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
|
||||
// stl_port.cpp: implementation of run-time casting of void pointers
|
||||
|
||||
// (C) Copyright 2005 Robert Ramey - http://www.rrsd.com .
|
||||
// Use, modification and distribution is subject to the Boost Software
|
||||
// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
// See http://www.boost.org for updates, documentation, and revision history.
|
||||
|
||||
#if (defined _MSC_VER) && (_MSC_VER == 1200)
|
||||
# pragma warning (disable : 4786) // too long name, harmless warning
|
||||
#endif
|
||||
|
||||
// this befuddles the msvc 6 compiler so we can't use it
|
||||
#if ! ((defined _MSC_VER) && (_MSC_VER <= 1300))
|
||||
|
||||
#include <boost/config.hpp>
|
||||
|
||||
#if defined(__SGI_STL_PORT) && (__SGI_STL_PORT < 0x500)
|
||||
|
||||
#include <boost/archive/codecvt_null.hpp>
|
||||
|
||||
// explicit instantiation
|
||||
|
||||
namespace std {
|
||||
|
||||
template
|
||||
locale::locale(
|
||||
const locale& __loc, boost::archive::codecvt_null<char> * __f
|
||||
);
|
||||
|
||||
template
|
||||
locale::locale(
|
||||
const locale& __loc, boost::archive::codecvt_null<wchar_t> * __f
|
||||
);
|
||||
|
||||
} // namespace std
|
||||
|
||||
#endif
|
||||
|
||||
#endif
|
||||
33
third_party/boost/libs/serialization/src/text_iarchive.cpp
vendored
Normal file
33
third_party/boost/libs/serialization/src/text_iarchive.cpp
vendored
Normal file
|
|
@ -0,0 +1,33 @@
|
|||
/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
|
||||
// text_iarchive.cpp:
|
||||
|
||||
// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
|
||||
// Use, modification and distribution is subject to the Boost Software
|
||||
// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
// See http://www.boost.org for updates, documentation, and revision history.
|
||||
|
||||
#if (defined _MSC_VER) && (_MSC_VER == 1200)
|
||||
# pragma warning (disable : 4786) // too long name, harmless warning
|
||||
#endif
|
||||
|
||||
#define BOOST_ARCHIVE_SOURCE
|
||||
#include <boost/serialization/config.hpp>
|
||||
#include <boost/archive/text_iarchive.hpp>
|
||||
#include <boost/archive/detail/archive_serializer_map.hpp>
|
||||
|
||||
// explicitly instantiate for this type of text stream
|
||||
#include <boost/archive/impl/archive_serializer_map.ipp>
|
||||
#include <boost/archive/impl/basic_text_iarchive.ipp>
|
||||
#include <boost/archive/impl/text_iarchive_impl.ipp>
|
||||
|
||||
namespace boost {
|
||||
namespace archive {
|
||||
|
||||
template class detail::archive_serializer_map<text_iarchive>;
|
||||
template class basic_text_iarchive<text_iarchive> ;
|
||||
template class text_iarchive_impl<text_iarchive> ;
|
||||
|
||||
} // namespace archive
|
||||
} // namespace boost
|
||||
34
third_party/boost/libs/serialization/src/text_oarchive.cpp
vendored
Normal file
34
third_party/boost/libs/serialization/src/text_oarchive.cpp
vendored
Normal file
|
|
@ -0,0 +1,34 @@
|
|||
/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
|
||||
// text_oarchive.cpp:
|
||||
|
||||
// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
|
||||
// Use, modification and distribution is subject to the Boost Software
|
||||
// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
// See http://www.boost.org for updates, documentation, and revision history.
|
||||
|
||||
#if (defined _MSC_VER) && (_MSC_VER == 1200)
|
||||
# pragma warning (disable : 4786) // too long name, harmless warning
|
||||
#endif
|
||||
|
||||
#define BOOST_ARCHIVE_SOURCE
|
||||
#include <boost/serialization/config.hpp>
|
||||
#include <boost/archive/text_oarchive.hpp>
|
||||
#include <boost/archive/detail/archive_serializer_map.hpp>
|
||||
|
||||
// explicitly instantiate for this type of text stream
|
||||
#include <boost/archive/impl/archive_serializer_map.ipp>
|
||||
#include <boost/archive/impl/basic_text_oarchive.ipp>
|
||||
#include <boost/archive/impl/text_oarchive_impl.ipp>
|
||||
|
||||
namespace boost {
|
||||
namespace archive {
|
||||
|
||||
//template class basic_text_oprimitive<std::ostream> ;
|
||||
template class detail::archive_serializer_map<text_oarchive>;
|
||||
template class basic_text_oarchive<text_oarchive> ;
|
||||
template class text_oarchive_impl<text_oarchive> ;
|
||||
|
||||
} // namespace serialization
|
||||
} // namespace boost
|
||||
38
third_party/boost/libs/serialization/src/text_wiarchive.cpp
vendored
Normal file
38
third_party/boost/libs/serialization/src/text_wiarchive.cpp
vendored
Normal file
|
|
@ -0,0 +1,38 @@
|
|||
/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
|
||||
// text_wiarchive.cpp:
|
||||
|
||||
// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
|
||||
// Use, modification and distribution is subject to the 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
|
||||
|
||||
#define BOOST_WARCHIVE_SOURCE
|
||||
#include <boost/serialization/config.hpp>
|
||||
#include <boost/archive/text_wiarchive.hpp>
|
||||
#include <boost/archive/detail/archive_serializer_map.hpp>
|
||||
|
||||
// explicitly instantiate for this type of text stream
|
||||
#include <boost/archive/impl/archive_serializer_map.ipp>
|
||||
#include <boost/archive/impl/basic_text_iarchive.ipp>
|
||||
#include <boost/archive/impl/text_wiarchive_impl.ipp>
|
||||
|
||||
namespace boost {
|
||||
namespace archive {
|
||||
|
||||
template class detail::archive_serializer_map<text_wiarchive>;
|
||||
template class basic_text_iarchive<text_wiarchive> ;
|
||||
template class text_wiarchive_impl<text_wiarchive> ;
|
||||
|
||||
} // namespace archive
|
||||
} // namespace boost
|
||||
|
||||
#endif // BOOST_NO_STD_WSTREAMBUF
|
||||
|
||||
36
third_party/boost/libs/serialization/src/text_woarchive.cpp
vendored
Normal file
36
third_party/boost/libs/serialization/src/text_woarchive.cpp
vendored
Normal file
|
|
@ -0,0 +1,36 @@
|
|||
/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
|
||||
// text_woarchive.cpp:
|
||||
|
||||
// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
|
||||
// Use, modification and distribution is subject to the 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
|
||||
|
||||
#define BOOST_WARCHIVE_SOURCE
|
||||
#include <boost/serialization/config.hpp>
|
||||
#include <boost/archive/text_woarchive.hpp>
|
||||
#include <boost/archive/detail/archive_serializer_map.hpp>
|
||||
|
||||
// explicitly instantiate for this type of text stream
|
||||
#include <boost/archive/impl/archive_serializer_map.ipp>
|
||||
#include <boost/archive/impl/basic_text_oarchive.ipp>
|
||||
#include <boost/archive/impl/text_woarchive_impl.ipp>
|
||||
|
||||
namespace boost {
|
||||
namespace archive {
|
||||
|
||||
template class detail::archive_serializer_map<text_woarchive>;
|
||||
template class basic_text_oarchive<text_woarchive> ;
|
||||
template class text_woarchive_impl<text_woarchive> ;
|
||||
|
||||
} // namespace archive
|
||||
} // namespace boost
|
||||
|
||||
#endif // BOOST_NO_STD_WSTREAMBUF
|
||||
22
third_party/boost/libs/serialization/src/utf8_codecvt_facet.cpp
vendored
Normal file
22
third_party/boost/libs/serialization/src/utf8_codecvt_facet.cpp
vendored
Normal file
|
|
@ -0,0 +1,22 @@
|
|||
// Copyright Vladimir Prus 2004.
|
||||
// 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>
|
||||
|
||||
#ifdef BOOST_NO_STD_WSTREAMBUF
|
||||
#error "wide char i/o not supported on this platform"
|
||||
#endif
|
||||
|
||||
// include boost implementation of utf8 codecvt facet
|
||||
# define BOOST_ARCHIVE_SOURCE
|
||||
#include <boost/archive/detail/decl.hpp>
|
||||
#define BOOST_UTF8_BEGIN_NAMESPACE \
|
||||
namespace boost { namespace archive { namespace detail {
|
||||
#define BOOST_UTF8_DECL BOOST_ARCHIVE_DECL
|
||||
#define BOOST_UTF8_END_NAMESPACE }}}
|
||||
#include <boost/detail/utf8_codecvt_facet.ipp>
|
||||
#undef BOOST_UTF8_END_NAMESPACE
|
||||
#undef BOOST_UTF8_DECL
|
||||
#undef BOOST_UTF8_BEGIN_NAMESPACE
|
||||
382
third_party/boost/libs/serialization/src/void_cast.cpp
vendored
Normal file
382
third_party/boost/libs/serialization/src/void_cast.cpp
vendored
Normal file
|
|
@ -0,0 +1,382 @@
|
|||
/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
|
||||
// void_cast.cpp: implementation of run-time casting of void pointers
|
||||
|
||||
// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
|
||||
// Use, modification and distribution is subject to the Boost Software
|
||||
// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
// <gennadiy.rozental@tfn.com>
|
||||
|
||||
// See http://www.boost.org for updates, documentation, and revision history.
|
||||
|
||||
#if (defined _MSC_VER) && (_MSC_VER == 1200)
|
||||
# pragma warning (disable : 4786) // too long name, harmless warning
|
||||
#endif
|
||||
|
||||
// STL
|
||||
#include <set>
|
||||
#include <functional>
|
||||
#include <algorithm>
|
||||
#include <cstddef> // NULL
|
||||
#ifdef BOOST_SERIALIZATION_LOG
|
||||
#include <iostream>
|
||||
#endif
|
||||
|
||||
// BOOST
|
||||
#include <boost/config.hpp>
|
||||
#include <boost/assert.hpp>
|
||||
|
||||
#define BOOST_SERIALIZATION_SOURCE
|
||||
#include <boost/serialization/config.hpp>
|
||||
// it marks our code with proper attributes as being exported when
|
||||
// we're compiling it while marking it import when just the headers
|
||||
// is being included.
|
||||
#include <boost/serialization/singleton.hpp>
|
||||
#include <boost/serialization/extended_type_info.hpp>
|
||||
#include <boost/serialization/void_cast.hpp>
|
||||
|
||||
namespace boost {
|
||||
namespace serialization {
|
||||
namespace void_cast_detail {
|
||||
|
||||
// note that void_casters are keyed on value of
|
||||
// member extended type info records - NOT their
|
||||
// addresses. This is necessary in order for the
|
||||
// void cast operations to work across dll and exe
|
||||
// module boundries.
|
||||
bool void_caster::operator<(const void_caster & rhs) const {
|
||||
// include short cut to save time and eliminate
|
||||
// problems when when base class aren't virtual
|
||||
if(m_derived != rhs.m_derived){
|
||||
if(*m_derived < *rhs.m_derived)
|
||||
return true;
|
||||
if(*rhs.m_derived < *m_derived)
|
||||
return false;
|
||||
}
|
||||
// m_derived == rhs.m_derived
|
||||
if(m_base != rhs.m_base)
|
||||
return *m_base < *rhs.m_base;
|
||||
else
|
||||
return false;
|
||||
}
|
||||
|
||||
struct void_caster_compare {
|
||||
bool operator()(const void_caster * lhs, const void_caster * rhs) const {
|
||||
return *lhs < *rhs;
|
||||
}
|
||||
};
|
||||
|
||||
typedef std::set<const void_caster *, void_caster_compare> set_type;
|
||||
typedef boost::serialization::singleton<set_type> void_caster_registry;
|
||||
|
||||
#ifdef BOOST_MSVC
|
||||
# pragma warning(push)
|
||||
# pragma warning(disable : 4511 4512)
|
||||
#endif
|
||||
|
||||
// implementation of shortcut void caster
|
||||
class void_caster_shortcut : public void_caster
|
||||
{
|
||||
bool m_includes_virtual_base;
|
||||
|
||||
void const *
|
||||
vbc_upcast(
|
||||
void const * const t
|
||||
) const;
|
||||
void const *
|
||||
vbc_downcast(
|
||||
void const * const t
|
||||
) const;
|
||||
virtual void const *
|
||||
upcast(void const * const t) const{
|
||||
if(m_includes_virtual_base)
|
||||
return vbc_upcast(t);
|
||||
return static_cast<const char *> ( t ) - m_difference;
|
||||
}
|
||||
virtual void const *
|
||||
downcast(void const * const t) const{
|
||||
if(m_includes_virtual_base)
|
||||
return vbc_downcast(t);
|
||||
return static_cast<const char *> ( t ) + m_difference;
|
||||
}
|
||||
virtual bool is_shortcut() const {
|
||||
return true;
|
||||
}
|
||||
virtual bool has_virtual_base() const {
|
||||
return m_includes_virtual_base;
|
||||
}
|
||||
public:
|
||||
void_caster_shortcut(
|
||||
extended_type_info const * derived,
|
||||
extended_type_info const * base,
|
||||
std::ptrdiff_t difference,
|
||||
bool includes_virtual_base,
|
||||
void_caster const * const parent
|
||||
) :
|
||||
void_caster(derived, base, difference, parent),
|
||||
m_includes_virtual_base(includes_virtual_base)
|
||||
{
|
||||
recursive_register(includes_virtual_base);
|
||||
}
|
||||
virtual ~void_caster_shortcut(){
|
||||
recursive_unregister();
|
||||
}
|
||||
};
|
||||
|
||||
#ifdef BOOST_MSVC
|
||||
# pragma warning(pop)
|
||||
#endif
|
||||
|
||||
void const *
|
||||
void_caster_shortcut::vbc_downcast(
|
||||
void const * const t
|
||||
) const {
|
||||
// try to find a chain that gives us what we want
|
||||
const void_cast_detail::set_type & s
|
||||
= void_cast_detail::void_caster_registry::get_const_instance();
|
||||
void_cast_detail::set_type::const_iterator it;
|
||||
for(it = s.begin(); it != s.end(); ++it){
|
||||
// if the current candidate casts to the desired target type
|
||||
if ((*it)->m_derived == m_derived){
|
||||
// and if it's not us
|
||||
if ((*it)->m_base != m_base){
|
||||
// try to cast from the candidate base to our base
|
||||
const void * t_new;
|
||||
t_new = void_downcast(*(*it)->m_base, *m_base, t);
|
||||
// if we were successful
|
||||
if(NULL != t_new){
|
||||
// recast to our derived
|
||||
const void_caster * vc = *it;
|
||||
return vc->downcast(t_new);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
return NULL;
|
||||
}
|
||||
|
||||
void const *
|
||||
void_caster_shortcut::vbc_upcast(
|
||||
void const * const t
|
||||
) const {
|
||||
// try to find a chain that gives us what we want
|
||||
const void_cast_detail::set_type & s
|
||||
= void_cast_detail::void_caster_registry::get_const_instance();
|
||||
void_cast_detail::set_type::const_iterator it;
|
||||
for(it = s.begin(); it != s.end(); ++it){
|
||||
// if the current candidate casts from the desired base type
|
||||
if((*it)->m_base == m_base){
|
||||
// and if it's not us
|
||||
if ((*it)->m_derived != m_derived){
|
||||
// try to cast from the candidate derived to our our derived
|
||||
const void * t_new;
|
||||
t_new = void_upcast(*m_derived, *(*it)->m_derived, t);
|
||||
if(NULL != t_new)
|
||||
return (*it)->upcast(t_new);
|
||||
}
|
||||
}
|
||||
}
|
||||
return NULL;
|
||||
}
|
||||
|
||||
#ifdef BOOST_MSVC
|
||||
# pragma warning(push)
|
||||
# pragma warning(disable : 4511 4512)
|
||||
#endif
|
||||
|
||||
// just used as a search key
|
||||
class void_caster_argument : public void_caster
|
||||
{
|
||||
virtual void const *
|
||||
upcast(void const * const /*t*/) const {
|
||||
BOOST_ASSERT(false);
|
||||
return NULL;
|
||||
}
|
||||
virtual void const *
|
||||
downcast( void const * const /*t*/) const {
|
||||
BOOST_ASSERT(false);
|
||||
return NULL;
|
||||
}
|
||||
virtual bool has_virtual_base() const {
|
||||
BOOST_ASSERT(false);
|
||||
return false;
|
||||
}
|
||||
public:
|
||||
void_caster_argument(
|
||||
extended_type_info const * derived,
|
||||
extended_type_info const * base
|
||||
) :
|
||||
void_caster(derived, base)
|
||||
{}
|
||||
virtual ~void_caster_argument(){};
|
||||
};
|
||||
|
||||
#ifdef BOOST_MSVC
|
||||
# pragma warning(pop)
|
||||
#endif
|
||||
|
||||
// implementation of void caster base class
|
||||
BOOST_SERIALIZATION_DECL void
|
||||
void_caster::recursive_register(bool includes_virtual_base) const {
|
||||
void_cast_detail::set_type & s
|
||||
= void_cast_detail::void_caster_registry::get_mutable_instance();
|
||||
|
||||
#ifdef BOOST_SERIALIZATION_LOG
|
||||
std::clog << "recursive_register\n";
|
||||
std::clog << m_derived->get_debug_info();
|
||||
std::clog << "<-";
|
||||
std::clog << m_base->get_debug_info();
|
||||
std::clog << "\n";
|
||||
#endif
|
||||
|
||||
std::pair<void_cast_detail::set_type::const_iterator, bool> result;
|
||||
// comment this out for now.
|
||||
result = s.insert(this);
|
||||
//assert(result.second);
|
||||
|
||||
// generate all implied void_casts.
|
||||
void_cast_detail::set_type::const_iterator it;
|
||||
for(it = s.begin(); it != s.end(); ++it){
|
||||
if(* m_derived == * (*it)->m_base){
|
||||
const void_caster_argument vca(
|
||||
(*it)->m_derived,
|
||||
m_base
|
||||
);
|
||||
void_cast_detail::set_type::const_iterator i;
|
||||
i = s.find(& vca);
|
||||
if(i == s.end()){
|
||||
new void_caster_shortcut(
|
||||
(*it)->m_derived,
|
||||
m_base,
|
||||
m_difference + (*it)->m_difference,
|
||||
(*it)->has_virtual_base() || includes_virtual_base,
|
||||
this
|
||||
);
|
||||
}
|
||||
}
|
||||
if(* (*it)->m_derived == * m_base){
|
||||
const void_caster_argument vca(
|
||||
m_derived,
|
||||
(*it)->m_base
|
||||
);
|
||||
void_cast_detail::set_type::const_iterator i;
|
||||
i = s.find(& vca);
|
||||
if(i == s.end()){
|
||||
new void_caster_shortcut(
|
||||
m_derived,
|
||||
(*it)->m_base,
|
||||
m_difference + (*it)->m_difference,
|
||||
(*it)->has_virtual_base() || includes_virtual_base,
|
||||
this
|
||||
);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
BOOST_SERIALIZATION_DECL void
|
||||
void_caster::recursive_unregister() const {
|
||||
// note: it's been discovered that at least one platform is not guaranteed
|
||||
// to destroy singletons reverse order of construction. So we can't
|
||||
// use a runtime assert here. Leave this in a reminder not to do this!
|
||||
// BOOST_ASSERT(! void_caster_registry::is_destroyed());
|
||||
if(void_caster_registry::is_destroyed())
|
||||
return;
|
||||
|
||||
#ifdef BOOST_SERIALIZATION_LOG
|
||||
std::clog << "recursive_unregister\n";
|
||||
std::clog << m_derived->get_debug_info();
|
||||
std::clog << "<-";
|
||||
std::clog << m_base->get_debug_info();
|
||||
std::clog << "\n";
|
||||
#endif
|
||||
|
||||
void_cast_detail::set_type & s
|
||||
= void_caster_registry::get_mutable_instance();
|
||||
|
||||
// delete all shortcuts which use this primitive
|
||||
void_cast_detail::set_type::iterator it;
|
||||
for(it = s.begin(); it != s.end();){
|
||||
const void_caster * vc = *it;
|
||||
if(vc == this){
|
||||
s.erase(it++);
|
||||
}
|
||||
else
|
||||
if(vc->m_parent == this){
|
||||
s.erase(it);
|
||||
delete vc;
|
||||
it = s.begin();
|
||||
}
|
||||
else
|
||||
it++;
|
||||
}
|
||||
}
|
||||
|
||||
} // namespace void_cast_detail
|
||||
|
||||
BOOST_SYMBOL_VISIBLE void const *
|
||||
void_upcast(
|
||||
extended_type_info const & derived,
|
||||
extended_type_info const & base,
|
||||
void const * const t
|
||||
);
|
||||
|
||||
// Given a void *, assume that it really points to an instance of one type
|
||||
// and alter it so that it would point to an instance of a related type.
|
||||
// Return the altered pointer. If there exists no sequence of casts that
|
||||
// can transform from_type to to_type, return a NULL.
|
||||
BOOST_SERIALIZATION_DECL void const *
|
||||
void_upcast(
|
||||
extended_type_info const & derived,
|
||||
extended_type_info const & base,
|
||||
void const * const t
|
||||
){
|
||||
// same types - trivial case
|
||||
if (derived == base)
|
||||
return t;
|
||||
|
||||
// check to see if base/derived pair is found in the registry
|
||||
const void_cast_detail::set_type & s
|
||||
= void_cast_detail::void_caster_registry::get_const_instance();
|
||||
const void_cast_detail::void_caster_argument ca(& derived, & base);
|
||||
|
||||
void_cast_detail::set_type::const_iterator it;
|
||||
it = s.find(& ca);
|
||||
if (s.end() != it)
|
||||
return (*it)->upcast(t);
|
||||
|
||||
return NULL;
|
||||
}
|
||||
|
||||
BOOST_SYMBOL_VISIBLE void const *
|
||||
void_downcast(
|
||||
extended_type_info const & derived,
|
||||
extended_type_info const & base,
|
||||
void const * const t
|
||||
);
|
||||
|
||||
BOOST_SERIALIZATION_DECL void const *
|
||||
void_downcast(
|
||||
extended_type_info const & derived,
|
||||
extended_type_info const & base,
|
||||
void const * const t
|
||||
){
|
||||
// same types - trivial case
|
||||
if (derived == base)
|
||||
return t;
|
||||
|
||||
// check to see if base/derived pair is found in the registry
|
||||
const void_cast_detail::set_type & s
|
||||
= void_cast_detail::void_caster_registry::get_const_instance();
|
||||
const void_cast_detail::void_caster_argument ca(& derived, & base);
|
||||
|
||||
void_cast_detail::set_type::const_iterator it;
|
||||
it = s.find(&ca);
|
||||
if (s.end() != it)
|
||||
return(*it)->downcast(t);
|
||||
|
||||
return NULL;
|
||||
}
|
||||
|
||||
} // namespace serialization
|
||||
} // namespace boost
|
||||
68
third_party/boost/libs/serialization/src/xml_archive_exception.cpp
vendored
Normal file
68
third_party/boost/libs/serialization/src/xml_archive_exception.cpp
vendored
Normal file
|
|
@ -0,0 +1,68 @@
|
|||
/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
|
||||
// xml_archive_exception.cpp:
|
||||
|
||||
// (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.
|
||||
|
||||
#if (defined _MSC_VER) && (_MSC_VER == 1200)
|
||||
# pragma warning (disable : 4786) // too long name, harmless warning
|
||||
#endif
|
||||
|
||||
|
||||
#include <exception>
|
||||
#include <string>
|
||||
|
||||
#include <boost/assert.hpp>
|
||||
|
||||
#define BOOST_ARCHIVE_SOURCE
|
||||
#include <boost/serialization/config.hpp>
|
||||
#include <boost/archive/xml_archive_exception.hpp>
|
||||
|
||||
namespace boost {
|
||||
namespace archive {
|
||||
|
||||
BOOST_ARCHIVE_DECL
|
||||
xml_archive_exception::xml_archive_exception(
|
||||
exception_code c,
|
||||
const char * e1,
|
||||
const char * e2
|
||||
) :
|
||||
archive_exception(other_exception, e1, e2)
|
||||
{
|
||||
switch(c){
|
||||
case xml_archive_parsing_error:
|
||||
archive_exception::append(0, "unrecognized XML syntax");
|
||||
break;
|
||||
case xml_archive_tag_mismatch:{
|
||||
unsigned int l;
|
||||
l = archive_exception::append(0, "XML start/end tag mismatch");
|
||||
if(NULL != e1){
|
||||
l = archive_exception::append(l, " - ");
|
||||
archive_exception::append(l, e1);
|
||||
}
|
||||
break;
|
||||
}
|
||||
case xml_archive_tag_name_error:
|
||||
archive_exception::append(0, "Invalid XML tag name");
|
||||
break;
|
||||
default:
|
||||
BOOST_ASSERT(false);
|
||||
archive_exception::append(0, "programming error");
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
BOOST_ARCHIVE_DECL
|
||||
xml_archive_exception::xml_archive_exception(xml_archive_exception const & oth) :
|
||||
archive_exception(oth)
|
||||
{
|
||||
}
|
||||
|
||||
BOOST_ARCHIVE_DECL xml_archive_exception::~xml_archive_exception() BOOST_NOEXCEPT_OR_NOTHROW {}
|
||||
|
||||
} // archive
|
||||
} // boost
|
||||
74
third_party/boost/libs/serialization/src/xml_grammar.cpp
vendored
Normal file
74
third_party/boost/libs/serialization/src/xml_grammar.cpp
vendored
Normal file
|
|
@ -0,0 +1,74 @@
|
|||
/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
|
||||
// xml_grammar.cpp:
|
||||
|
||||
// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
|
||||
// Use, modification and distribution is subject to the Boost Software
|
||||
// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
// See http://www.boost.org for updates, documentation, and revision history.
|
||||
|
||||
#if (defined _MSC_VER) && (_MSC_VER == 1200)
|
||||
# pragma warning (disable : 4786) // too long name, harmless warning
|
||||
#endif
|
||||
|
||||
#include <boost/config.hpp>
|
||||
|
||||
#define BOOST_ARCHIVE_SOURCE
|
||||
#include <boost/serialization/config.hpp>
|
||||
#include <boost/archive/impl/basic_xml_grammar.hpp>
|
||||
|
||||
using namespace boost::spirit::classic;
|
||||
|
||||
// fixup for borland
|
||||
// The following code will be put into Boost.Config in a later revision
|
||||
#if ! defined(__SGI_STL_PORT) \
|
||||
&& defined(BOOST_RWSTD_VER) && BOOST_RWSTD_VER<=0x020101
|
||||
#include <string>
|
||||
namespace std {
|
||||
template<>
|
||||
inline string &
|
||||
string::replace (
|
||||
char * first1,
|
||||
char * last1,
|
||||
const char * first2,
|
||||
const char * last2
|
||||
){
|
||||
replace(first1-begin(),last1-first1,first2,last2-first2,0,last2-first2);
|
||||
return *this;
|
||||
}
|
||||
} // namespace std
|
||||
#endif
|
||||
|
||||
namespace boost {
|
||||
namespace archive {
|
||||
|
||||
typedef basic_xml_grammar<char> xml_grammar;
|
||||
|
||||
/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
|
||||
// specific definitions for char based XML
|
||||
|
||||
template<>
|
||||
void xml_grammar::init_chset(){
|
||||
Char = chset_t("\x9\xA\xD\x20-\x7f\x80\x81-\xFF");
|
||||
Letter = chset_t("\x41-\x5A\x61-\x7A\xC0-\xD6\xD8-\xF6\xF8-\xFF");
|
||||
Digit = chset_t("0-9");
|
||||
Extender = chset_t('\xB7');
|
||||
Sch = chset_t("\x20\x9\xD\xA");
|
||||
NameChar = Letter | Digit | chset_p("._:-") | Extender ;
|
||||
}
|
||||
|
||||
} // namespace archive
|
||||
} // namespace boost
|
||||
|
||||
#include "basic_xml_grammar.ipp"
|
||||
|
||||
namespace boost {
|
||||
namespace archive {
|
||||
|
||||
// explicit instantiation of xml for 8 bit characters
|
||||
template class basic_xml_grammar<char>;
|
||||
|
||||
} // namespace archive
|
||||
} // namespace boost
|
||||
|
||||
33
third_party/boost/libs/serialization/src/xml_iarchive.cpp
vendored
Normal file
33
third_party/boost/libs/serialization/src/xml_iarchive.cpp
vendored
Normal file
|
|
@ -0,0 +1,33 @@
|
|||
/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
|
||||
// xml_iarchive.cpp:
|
||||
|
||||
// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
|
||||
// Use, modification and distribution is subject to the Boost Software
|
||||
// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
// See http://www.boost.org for updates, documentation, and revision history.
|
||||
|
||||
#if (defined _MSC_VER) && (_MSC_VER == 1200)
|
||||
# pragma warning (disable : 4786) // too long name, harmless warning
|
||||
#endif
|
||||
|
||||
#define BOOST_ARCHIVE_SOURCE
|
||||
#include <boost/serialization/config.hpp>
|
||||
#include <boost/archive/xml_iarchive.hpp>
|
||||
#include <boost/archive/detail/archive_serializer_map.hpp>
|
||||
|
||||
// explicitly instantiate for this type of xml stream
|
||||
#include <boost/archive/impl/archive_serializer_map.ipp>
|
||||
#include <boost/archive/impl/basic_xml_iarchive.ipp>
|
||||
#include <boost/archive/impl/xml_iarchive_impl.ipp>
|
||||
|
||||
namespace boost {
|
||||
namespace archive {
|
||||
|
||||
template class detail::archive_serializer_map<xml_iarchive>;
|
||||
template class basic_xml_iarchive<xml_iarchive> ;
|
||||
template class xml_iarchive_impl<xml_iarchive> ;
|
||||
|
||||
} // namespace archive
|
||||
} // namespace boost
|
||||
33
third_party/boost/libs/serialization/src/xml_oarchive.cpp
vendored
Normal file
33
third_party/boost/libs/serialization/src/xml_oarchive.cpp
vendored
Normal file
|
|
@ -0,0 +1,33 @@
|
|||
/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
|
||||
// xml_oarchive.cpp:
|
||||
|
||||
// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
|
||||
// Use, modification and distribution is subject to the Boost Software
|
||||
// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
// See http://www.boost.org for updates, documentation, and revision history.
|
||||
|
||||
#if (defined _MSC_VER) && (_MSC_VER == 1200)
|
||||
# pragma warning (disable : 4786) // too long name, harmless warning
|
||||
#endif
|
||||
|
||||
#define BOOST_ARCHIVE_SOURCE
|
||||
#include <boost/serialization/config.hpp>
|
||||
#include <boost/archive/xml_oarchive.hpp>
|
||||
#include <boost/archive/detail/archive_serializer_map.hpp>
|
||||
|
||||
// explicitly instantiate for this type of xml stream
|
||||
#include <boost/archive/impl/archive_serializer_map.ipp>
|
||||
#include <boost/archive/impl/basic_xml_oarchive.ipp>
|
||||
#include <boost/archive/impl/xml_oarchive_impl.ipp>
|
||||
|
||||
namespace boost {
|
||||
namespace archive {
|
||||
|
||||
template class detail::archive_serializer_map<xml_oarchive>;
|
||||
template class basic_xml_oarchive<xml_oarchive> ;
|
||||
template class xml_oarchive_impl<xml_oarchive> ;
|
||||
|
||||
} // namespace archive
|
||||
} // namespace boost
|
||||
157
third_party/boost/libs/serialization/src/xml_wgrammar.cpp
vendored
Normal file
157
third_party/boost/libs/serialization/src/xml_wgrammar.cpp
vendored
Normal file
|
|
@ -0,0 +1,157 @@
|
|||
/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
|
||||
// xml_wgrammar.cpp:
|
||||
|
||||
// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
|
||||
// Use, modification and distribution is subject to the 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
|
||||
|
||||
#define BOOST_WARCHIVE_SOURCE
|
||||
#include <boost/serialization/config.hpp>
|
||||
#include <boost/archive/impl/basic_xml_grammar.hpp>
|
||||
|
||||
using namespace boost::spirit::classic;
|
||||
|
||||
// fixup for RogueWave
|
||||
#if ! defined(__SGI_STL_PORT) \
|
||||
&& defined(BOOST_RWSTD_VER) && BOOST_RWSTD_VER<=0x020101
|
||||
#include <string>
|
||||
namespace std {
|
||||
template<>
|
||||
inline wstring &
|
||||
wstring::replace (
|
||||
wchar_t * first1,
|
||||
wchar_t * last1,
|
||||
const wchar_t * first2,
|
||||
const wchar_t * last2
|
||||
){
|
||||
replace(first1-begin(),last1-first1,first2,last2-first2,0,last2-first2);
|
||||
return *this;
|
||||
}
|
||||
} // namespace std
|
||||
#endif
|
||||
|
||||
namespace boost {
|
||||
namespace archive {
|
||||
|
||||
typedef basic_xml_grammar<wchar_t> xml_wgrammar;
|
||||
|
||||
/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
|
||||
// specific definitions for wchar_t based XML
|
||||
|
||||
template<>
|
||||
void xml_wgrammar::init_chset(){
|
||||
Char = chset_t(
|
||||
#if defined(__GNUC__) && defined(linux)
|
||||
L"\x9\xA\xD\x20-\xD7FF\xE000-\xFFFD\x10000-\x10FFFF"
|
||||
#else
|
||||
L"\x9\xA\xD\x20-\xD7FF\xE000-\xFFFD"
|
||||
#endif
|
||||
);
|
||||
|
||||
Sch = chset_t(L"\x20\x9\xD\xA");
|
||||
|
||||
BaseChar = chset_t(
|
||||
L"\x41-\x5A\x61-\x7A\xC0-\xD6\xD8-\xF6\xF8-\xFF\x100-\x131\x134-\x13E"
|
||||
L"\x141-\x148\x14A-\x17E\x180-\x1C3\x1CD-\x1F0\x1F4-\x1F5\x1FA-\x217"
|
||||
L"\x250-\x2A8\x2BB-\x2C1\x386\x388-\x38A\x38C\x38E-\x3A1\x3A3-\x3CE"
|
||||
L"\x3D0-\x3D6\x3DA\x3DC\x3DE\x3E0\x3E2-\x3F3\x401-\x40C\x40E-\x44F"
|
||||
L"\x451-\x45C\x45E-\x481\x490-\x4C4\x4C7-\x4C8\x4CB-\x4CC\x4D0-\x4EB"
|
||||
L"\x4EE-\x4F5\x4F8-\x4F9\x531-\x556\x559\x561-\x586\x5D0-\x5EA"
|
||||
L"\x5F0-\x5F2\x621-\x63A\x641-\x64A\x671-\x6B7\x6BA-\x6BE\x6C0-\x6CE"
|
||||
L"\x6D0-\x6D3\x6D5\x6E5-\x6E6\x905-\x939\x93D\x958-\x961\x985-\x98C"
|
||||
L"\x98F-\x990\x993-\x9A8\x9AA-\x9B0\x9B2\x9B6-\x9B9\x9DC-\x9DD"
|
||||
L"\x9DF-\x9E1\x9F0-\x9F1\xA05-\xA0A\xA0F-\xA10\xA13-\xA28\xA2A-\xA30"
|
||||
L"\xA32-\xA33\xA35-\xA36\xA38-\xA39\xA59-\xA5C\xA5E\xA72-\xA74"
|
||||
L"\xA85-\xA8B\xA8D\xA8F-\xA91\xA93-\xAA8\xAAA-\xAB0\xAB2-\xAB3"
|
||||
L"\xAB5-\xAB9\xABD\xAE0\xB05-\xB0C\xB0F-\xB10\xB13-\xB28\xB2A-\xB30"
|
||||
L"\xB32-\xB33\xB36-\xB39\xB3D\xB5C-\xB5D\xB5F-\xB61\xB85-\xB8A"
|
||||
L"\xB8E-\xB90\xB92-\xB95\xB99-\xB9A\xB9C\xB9E-\xB9F\xBA3-\xBA4"
|
||||
L"\xBA8-\xBAA\xBAE-\xBB5\xBB7-\xBB9\xC05-\xC0C\xC0E-\xC10\xC12-\xC28"
|
||||
L"\xC2A-\xC33\xC35-\xC39\xC60-\xC61\xC85-\xC8C\xC8E-\xC90\xC92-\xCA8"
|
||||
L"\xCAA-\xCB3\xCB5-\xCB9\xCDE\xCE0-\xCE1\xD05-\xD0C\xD0E-\xD10"
|
||||
L"\xD12-\xD28\xD2A-\xD39\xD60-\xD61\xE01-\xE2E\xE30\xE32-\xE33"
|
||||
L"\xE40-\xE45\xE81-\xE82\xE84\xE87-\xE88\xE8A\xE8D\xE94-\xE97"
|
||||
L"\xE99-\xE9F\xEA1-\xEA3\xEA5\xEA7\xEAA-\xEAB\xEAD-\xEAE\xEB0"
|
||||
L"\xEB2-\xEB3\xEBD\xEC0-\xEC4\xF40-\xF47\xF49-\xF69\x10A0-\x10C5"
|
||||
L"\x10D0-\x10F6\x1100\x1102-\x1103\x1105-\x1107\x1109\x110B-\x110C"
|
||||
L"\x110E-\x1112\x113C\x113E\x1140\x114C\x114E\x1150\x1154-\x1155"
|
||||
L"\x1159\x115F-\x1161\x1163\x1165\x1167\x1169\x116D-\x116E"
|
||||
L"\x1172-\x1173\x1175\x119E\x11A8\x11AB\x11AE-\x11AF\x11B7-\x11B8"
|
||||
L"\x11BA\x11BC-\x11C2\x11EB\x11F0\x11F9\x1E00-\x1E9B\x1EA0-\x1EF9"
|
||||
L"\x1F00-\x1F15\x1F18-\x1F1D\x1F20-\x1F45\x1F48-\x1F4D\x1F50-\x1F57"
|
||||
L"\x1F59\x1F5B\x1F5D\x1F5F-\x1F7D\x1F80-\x1FB4\x1FB6-\x1FBC\x1FBE"
|
||||
L"\x1FC2-\x1FC4\x1FC6-\x1FCC\x1FD0-\x1FD3\x1FD6-\x1FDB\x1FE0-\x1FEC"
|
||||
L"\x1FF2-\x1FF4\x1FF6-\x1FFC\x2126\x212A-\x212B\x212E\x2180-\x2182"
|
||||
L"\x3041-\x3094\x30A1-\x30FA\x3105-\x312C\xAC00-\xD7A3"
|
||||
);
|
||||
|
||||
Ideographic = chset_t(L"\x4E00-\x9FA5\x3007\x3021-\x3029");
|
||||
|
||||
Letter = BaseChar | Ideographic;
|
||||
|
||||
CombiningChar = chset_t(
|
||||
L"\x0300-\x0345\x0360-\x0361\x0483-\x0486\x0591-\x05A1\x05A3-\x05B9"
|
||||
L"\x05BB-\x05BD\x05BF\x05C1-\x05C2\x05C4\x064B-\x0652\x0670"
|
||||
L"\x06D6-\x06DC\x06DD-\x06DF\x06E0-\x06E4\x06E7-\x06E8\x06EA-\x06ED"
|
||||
L"\x0901-\x0903\x093C\x093E-\x094C\x094D\x0951-\x0954\x0962-\x0963"
|
||||
L"\x0981-\x0983\x09BC\x09BE\x09BF\x09C0-\x09C4\x09C7-\x09C8"
|
||||
L"\x09CB-\x09CD\x09D7\x09E2-\x09E3\x0A02\x0A3C\x0A3E\x0A3F"
|
||||
L"\x0A40-\x0A42\x0A47-\x0A48\x0A4B-\x0A4D\x0A70-\x0A71\x0A81-\x0A83"
|
||||
L"\x0ABC\x0ABE-\x0AC5\x0AC7-\x0AC9\x0ACB-\x0ACD\x0B01-\x0B03\x0B3C"
|
||||
L"\x0B3E-\x0B43\x0B47-\x0B48\x0B4B-\x0B4D\x0B56-\x0B57\x0B82-\x0B83"
|
||||
L"\x0BBE-\x0BC2\x0BC6-\x0BC8\x0BCA-\x0BCD\x0BD7\x0C01-\x0C03"
|
||||
L"\x0C3E-\x0C44\x0C46-\x0C48\x0C4A-\x0C4D\x0C55-\x0C56\x0C82-\x0C83"
|
||||
L"\x0CBE-\x0CC4\x0CC6-\x0CC8\x0CCA-\x0CCD\x0CD5-\x0CD6\x0D02-\x0D03"
|
||||
L"\x0D3E-\x0D43\x0D46-\x0D48\x0D4A-\x0D4D\x0D57\x0E31\x0E34-\x0E3A"
|
||||
L"\x0E47-\x0E4E\x0EB1\x0EB4-\x0EB9\x0EBB-\x0EBC\x0EC8-\x0ECD"
|
||||
L"\x0F18-\x0F19\x0F35\x0F37\x0F39\x0F3E\x0F3F\x0F71-\x0F84"
|
||||
L"\x0F86-\x0F8B\x0F90-\x0F95\x0F97\x0F99-\x0FAD\x0FB1-\x0FB7\x0FB9"
|
||||
L"\x20D0-\x20DC\x20E1\x302A-\x302F\x3099\x309A"
|
||||
);
|
||||
|
||||
Digit = chset_t(
|
||||
L"\x0030-\x0039\x0660-\x0669\x06F0-\x06F9\x0966-\x096F\x09E6-\x09EF"
|
||||
L"\x0A66-\x0A6F\x0AE6-\x0AEF\x0B66-\x0B6F\x0BE7-\x0BEF\x0C66-\x0C6F"
|
||||
L"\x0CE6-\x0CEF\x0D66-\x0D6F\x0E50-\x0E59\x0ED0-\x0ED9\x0F20-\x0F29"
|
||||
);
|
||||
|
||||
Extender = chset_t(
|
||||
L"\x00B7\x02D0\x02D1\x0387\x0640\x0E46\x0EC6\x3005\x3031-\x3035"
|
||||
L"\x309D-\x309E\x30FC-\x30FE"
|
||||
);
|
||||
|
||||
NameChar =
|
||||
Letter
|
||||
| Digit
|
||||
| L'.'
|
||||
| L'-'
|
||||
| L'_'
|
||||
| L':'
|
||||
| CombiningChar
|
||||
| Extender
|
||||
;
|
||||
}
|
||||
} // namespace archive
|
||||
} // namespace boost
|
||||
|
||||
#include "basic_xml_grammar.ipp"
|
||||
|
||||
namespace boost {
|
||||
namespace archive {
|
||||
|
||||
// explicit instantiation of xml for wide characters
|
||||
template class basic_xml_grammar<wchar_t>;
|
||||
|
||||
} // namespace archive
|
||||
} // namespace boost
|
||||
|
||||
#endif
|
||||
40
third_party/boost/libs/serialization/src/xml_wiarchive.cpp
vendored
Normal file
40
third_party/boost/libs/serialization/src/xml_wiarchive.cpp
vendored
Normal file
|
|
@ -0,0 +1,40 @@
|
|||
/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
|
||||
// xml_wiarchive.cpp:
|
||||
|
||||
// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
|
||||
// Use, modification and distribution is subject to the Boost Software
|
||||
// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
// See http://www.boost.org for updates, documentation, and revision history.
|
||||
|
||||
#if (defined _MSC_VER) && (_MSC_VER == 1200)
|
||||
# pragma warning (disable : 4786) // too long name, harmless warning
|
||||
#endif
|
||||
|
||||
#include <boost/config.hpp>
|
||||
#ifdef BOOST_NO_STD_WSTREAMBUF
|
||||
#error "wide char i/o not supported on this platform"
|
||||
#else
|
||||
|
||||
#define BOOST_WARCHIVE_SOURCE
|
||||
#include <boost/serialization/config.hpp>
|
||||
#include <boost/archive/xml_wiarchive.hpp>
|
||||
#include <boost/archive/detail/archive_serializer_map.hpp>
|
||||
|
||||
// explicitly instantiate for this type of xml stream
|
||||
#include <boost/archive/impl/archive_serializer_map.ipp>
|
||||
#include <boost/archive/impl/basic_xml_iarchive.ipp>
|
||||
#include <boost/archive/impl/xml_wiarchive_impl.ipp>
|
||||
|
||||
namespace boost {
|
||||
namespace archive {
|
||||
|
||||
template class detail::archive_serializer_map<xml_wiarchive>;
|
||||
template class basic_xml_iarchive<xml_wiarchive> ;
|
||||
template class xml_wiarchive_impl<xml_wiarchive> ;
|
||||
|
||||
} // namespace archive
|
||||
} // namespace boost
|
||||
|
||||
#endif // BOOST_NO_STD_WSTREAMBUF
|
||||
40
third_party/boost/libs/serialization/src/xml_woarchive.cpp
vendored
Normal file
40
third_party/boost/libs/serialization/src/xml_woarchive.cpp
vendored
Normal file
|
|
@ -0,0 +1,40 @@
|
|||
/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
|
||||
// xml_woarchive.cpp:
|
||||
|
||||
// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
|
||||
// Use, modification and distribution is subject to the Boost Software
|
||||
// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
// See http://www.boost.org for updates, documentation, and revision history.
|
||||
|
||||
#if (defined _MSC_VER) && (_MSC_VER == 1200)
|
||||
# pragma warning (disable : 4786) // too long name, harmless warning
|
||||
#endif
|
||||
|
||||
#include <boost/config.hpp>
|
||||
#ifdef BOOST_NO_STD_WSTREAMBUF
|
||||
#error "wide char i/o not supported on this platform"
|
||||
#else
|
||||
|
||||
#define BOOST_WARCHIVE_SOURCE
|
||||
#include <boost/serialization/config.hpp>
|
||||
#include <boost/archive/xml_woarchive.hpp>
|
||||
#include <boost/archive/detail/archive_serializer_map.hpp>
|
||||
|
||||
// explicitly instantiate for this type of text stream
|
||||
#include <boost/archive/impl/archive_serializer_map.ipp>
|
||||
#include <boost/archive/impl/basic_xml_oarchive.ipp>
|
||||
#include <boost/archive/impl/xml_woarchive_impl.ipp>
|
||||
|
||||
namespace boost {
|
||||
namespace archive {
|
||||
|
||||
template class detail::archive_serializer_map<xml_woarchive>;
|
||||
template class basic_xml_oarchive<xml_woarchive> ;
|
||||
template class xml_woarchive_impl<xml_woarchive> ;
|
||||
|
||||
} // namespace archive
|
||||
} // namespace boost
|
||||
|
||||
#endif // BOOST_NO_STD_WSTREAMBUF
|
||||
Loading…
Add table
Add a link
Reference in a new issue