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

update boost

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

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

@@ -1,7 +1,7 @@
/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
// abi_prefix.hpp
// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
// Use, modification and distribution is subject to the Boost Software
// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)

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

@@ -1,7 +1,7 @@
/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
// abi_suffix.hpp
// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
// Use, modification and distribution is subject to the Boost Software
// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)

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

@@ -7,10 +7,10 @@
#endif
/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
// archive_serializer_map.hpp: extenstion of type_info required for
// archive_serializer_map.hpp: extenstion of type_info required for
// serialization.
// (C) Copyright 2009 Robert Ramey - http://www.rrsd.com .
// (C) Copyright 2009 Robert Ramey - http://www.rrsd.com .
// Use, modification and distribution is subject to the Boost Software
// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
@@ -18,7 +18,7 @@
// See http://www.boost.org for updates, documentation, and revision history.
// note: this is nothing more than the thinest of wrappers around
// basic_serializer_map so we can have a one map / archive type.
// basic_serializer_map so we can have a one map / archive type.
#include <boost/config.hpp>
#include <boost/archive/detail/auto_link_archive.hpp>

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

@@ -16,12 +16,12 @@
// See library home page at http://www.boost.org/libs/serialization
//----------------------------------------------------------------------------//
//----------------------------------------------------------------------------//
// This header implements separate compilation features as described in
// http://www.boost.org/more/separate_compilation.html
// enable automatic library variant selection ------------------------------//
// enable automatic library variant selection ------------------------------//
#include <boost/archive/detail/decl.hpp>

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

@@ -16,12 +16,12 @@
// See library home page at http://www.boost.org/libs/serialization
//----------------------------------------------------------------------------//
//----------------------------------------------------------------------------//
// This header implements separate compilation features as described in
// http://www.boost.org/more/separate_compilation.html
// enable automatic library variant selection ------------------------------//
// enable automatic library variant selection ------------------------------//
#include <boost/archive/detail/decl.hpp>

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

@@ -9,7 +9,7 @@
/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
// basic_iarchive.hpp:
// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
// Use, modification and distribution is subject to the Boost Software
// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
@@ -72,27 +72,27 @@ public:
const basic_iserializer & bis
);
BOOST_ARCHIVE_DECL void load_object(
void *t,
void *t,
const basic_iserializer & bis
);
BOOST_ARCHIVE_DECL const basic_pointer_iserializer *
BOOST_ARCHIVE_DECL const basic_pointer_iserializer *
load_pointer(
void * & t,
void * & t,
const basic_pointer_iserializer * bpis_ptr,
const basic_pointer_iserializer * (*finder)(
const boost::serialization::extended_type_info & eti
)
);
// real public API starts here
BOOST_ARCHIVE_DECL void
set_library_version(library_version_type archive_library_version);
BOOST_ARCHIVE_DECL library_version_type
BOOST_ARCHIVE_DECL void
set_library_version(boost::serialization::library_version_type archive_library_version);
BOOST_ARCHIVE_DECL boost::serialization::library_version_type
get_library_version() const;
BOOST_ARCHIVE_DECL unsigned int
get_flags() const;
BOOST_ARCHIVE_DECL void
BOOST_ARCHIVE_DECL void
reset_object_address(const void * new_address, const void * old_address);
BOOST_ARCHIVE_DECL void
BOOST_ARCHIVE_DECL void
delete_created_pointers();
};

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

@@ -9,7 +9,7 @@
/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
// basic_iserializer.hpp: extenstion of type_info required for serialization.
// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
// Use, modification and distribution is subject to the Boost Software
// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
@@ -42,7 +42,7 @@ namespace detail {
class basic_iarchive;
class basic_pointer_iserializer;
class BOOST_SYMBOL_VISIBLE basic_iserializer :
class BOOST_SYMBOL_VISIBLE basic_iserializer :
public basic_serializer
{
private:
@@ -63,7 +63,7 @@ public:
return m_bpis;
}
virtual void load_object_data(
basic_iarchive & ar,
basic_iarchive & ar,
void *x,
const unsigned int file_version
) const = 0;

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

@@ -9,7 +9,7 @@
/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
// basic_oarchive.hpp:
// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
// Use, modification and distribution is subject to the Boost Software
// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
@@ -69,19 +69,19 @@ public:
const basic_oserializer & bos
);
BOOST_ARCHIVE_DECL void save_object(
const void *x,
const void *x,
const basic_oserializer & bos
);
BOOST_ARCHIVE_DECL void save_pointer(
const void * t,
const void * t,
const basic_pointer_oserializer * bpos_ptr
);
void save_null_pointer(){
vsave(NULL_POINTER_TAG);
vsave(BOOST_SERIALIZATION_NULL_POINTER_TAG);
}
// real public interface starts here
BOOST_ARCHIVE_DECL void end_preamble(); // default implementation does nothing
BOOST_ARCHIVE_DECL library_version_type get_library_version() const;
BOOST_ARCHIVE_DECL boost::serialization::library_version_type get_library_version() const;
BOOST_ARCHIVE_DECL unsigned int get_flags() const;
};

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

@@ -9,7 +9,7 @@
/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
// basic_oserializer.hpp: extenstion of type_info required for serialization.
// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
// Use, modification and distribution is subject to the Boost Software
// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)

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

@@ -7,10 +7,10 @@
#endif
/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
// basic_pointer_oserializer.hpp: extenstion of type_info required for
// basic_pointer_oserializer.hpp: extenstion of type_info required for
// serialization.
// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
// Use, modification and distribution is subject to the Boost Software
// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
@@ -51,7 +51,7 @@ public:
virtual void * heap_allocation() const = 0;
virtual const basic_iserializer & get_basic_serializer() const = 0;
virtual void load_object_ptr(
basic_iarchive & ar,
basic_iarchive & ar,
void * x,
const unsigned int file_version
) const = 0;

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

@@ -7,10 +7,10 @@
#endif
/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
// basic_pointer_oserializer.hpp: extenstion of type_info required for
// basic_pointer_oserializer.hpp: extenstion of type_info required for
// serialization.
// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
// Use, modification and distribution is subject to the Boost Software
// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
@@ -39,7 +39,7 @@ namespace detail {
class basic_oarchive;
class basic_oserializer;
class BOOST_SYMBOL_VISIBLE basic_pointer_oserializer :
class BOOST_SYMBOL_VISIBLE basic_pointer_oserializer :
public basic_serializer
{
protected:

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

@@ -9,7 +9,7 @@
/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
// basic_serializer.hpp: extenstion of type_info required for serialization.
// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
// Use, modification and distribution is subject to the Boost Software
// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
@@ -32,18 +32,18 @@ namespace boost {
namespace archive {
namespace detail {
class basic_serializer :
class basic_serializer :
private boost::noncopyable
{
const boost::serialization::extended_type_info * m_eti;
protected:
explicit basic_serializer(
const boost::serialization::extended_type_info & eti
) :
) :
m_eti(& eti)
{}
public:
inline bool
inline bool
operator<(const basic_serializer & rhs) const {
// can't compare address since there can be multiple eti records
// for the same type in different execution modules (that is, DLLS)

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

@@ -9,7 +9,7 @@
/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
// basic_serializer_map.hpp: extenstion of type_info required for serialization.
// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
// Use, modification and distribution is subject to the Boost Software
// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
@@ -24,7 +24,7 @@
#include <boost/archive/detail/abi_prefix.hpp> // must be the last header
namespace boost {
namespace boost {
namespace serialization {
class extended_type_info;
}
@@ -45,7 +45,7 @@ basic_serializer_map : public
) const ;
};
typedef std::set<
const basic_serializer *,
const basic_serializer *,
type_info_pointer_compare
> map_type;
map_type m_map;

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

@@ -4,18 +4,20 @@
// MS compatible compilers support #pragma once
#if defined(_MSC_VER)
# pragma once
#pragma inline_depth(511)
#if !defined(__clang__)
#pragma inline_depth(255)
#pragma inline_recursion(on)
#endif
#endif
#if defined(__MWERKS__)
#pragma inline_depth(511)
#pragma inline_depth(255)
#endif
/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
// check.hpp: interface for serialization system.
// (C) Copyright 2009 Robert Ramey - http://www.rrsd.com .
// (C) Copyright 2009 Robert Ramey - http://www.rrsd.com .
// Use, modification and distribution is subject to the Boost Software
// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
@@ -49,7 +51,7 @@ namespace detail {
template<class T>
inline void check_object_level(){
typedef
typedef
typename mpl::greater_equal<
serialization::implementation_level< T >,
mpl::int_<serialization::primitive_type>
@@ -62,7 +64,7 @@ inline void check_object_level(){
template<class T>
inline void check_object_versioning(){
typedef
typedef
typename mpl::or_<
typename mpl::greater<
serialization::implementation_level< T >,
@@ -90,8 +92,8 @@ inline void check_object_tracking(){
// saving an non-const object of a type not marked "track_never)
// may be an indicator of an error usage of the
// serialization library and should be double checked.
// See documentation on object tracking. Also, see the
// serialization library and should be double checked.
// See documentation on object tracking. Also, see the
// "rationale" section of the documenation
// for motivation for this checking.
@@ -104,7 +106,7 @@ template<class T>
inline void check_pointer_level(){
// we should only invoke this once we KNOW that T
// has been used as a pointer!!
typedef
typedef
typename mpl::or_<
typename mpl::greater<
serialization::implementation_level< T >,
@@ -126,12 +128,12 @@ inline void check_pointer_level(){
// in this case, indication that an object is tracked is
// not stored in the archive itself - see level == object_serializable
// but rather the existence of the operation ar >> T * is used to
// but rather the existence of the operation ar >> T * is used to
// infer that an object of this type should be tracked. So, if
// you save via a pointer but don't load via a pointer the operation
// will fail on load without given any valid reason for the failure.
// So if your program traps here, consider changing the
// So if your program traps here, consider changing the
// tracking or implementation level traits - or not
// serializing via a pointer.
BOOST_STATIC_WARNING(typex::value);

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

@@ -9,7 +9,7 @@
/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
// common_iarchive.hpp
// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
// Use, modification and distribution is subject to the Boost Software
// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
@@ -42,22 +42,22 @@ class BOOST_SYMBOL_VISIBLE common_iarchive :
friend class interface_iarchive<Archive>;
friend class basic_iarchive;
private:
virtual void vload(version_type & t){
* this->This() >> t;
}
virtual void vload(object_id_type & t){
void vload(version_type & t) BOOST_OVERRIDE {
* this->This() >> t;
}
virtual void vload(class_id_type & t){
void vload(object_id_type & t) BOOST_OVERRIDE {
* this->This() >> t;
}
virtual void vload(class_id_optional_type & t){
void vload(class_id_type & t) BOOST_OVERRIDE {
* this->This() >> t;
}
virtual void vload(tracking_type & t){
void vload(class_id_optional_type & t) BOOST_OVERRIDE {
* this->This() >> t;
}
virtual void vload(class_name_type &s){
void vload(tracking_type & t) BOOST_OVERRIDE {
* this->This() >> t;
}
void vload(class_name_type &s) BOOST_OVERRIDE {
* this->This() >> s;
}
protected:
@@ -71,7 +71,7 @@ protected:
void load_start(const char * /*name*/){}
void load_end(const char * /*name*/){}
// default archive initialization
common_iarchive(unsigned int flags = 0) :
common_iarchive(unsigned int flags = 0) :
basic_iarchive(flags),
interface_iarchive<Archive>()
{}
@@ -86,4 +86,3 @@ protected:
#endif
#endif // BOOST_ARCHIVE_DETAIL_COMMON_IARCHIVE_HPP

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

@@ -9,7 +9,7 @@
/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
// common_oarchive.hpp
// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
// Use, modification and distribution is subject to the Boost Software
// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
@@ -40,28 +40,28 @@ class BOOST_SYMBOL_VISIBLE common_oarchive :
friend class interface_oarchive<Archive>;
friend class basic_oarchive;
private:
virtual void vsave(const version_type t){
void vsave(const version_type t) BOOST_OVERRIDE {
* this->This() << t;
}
virtual void vsave(const object_id_type t){
void vsave(const object_id_type t) BOOST_OVERRIDE {
* this->This() << t;
}
virtual void vsave(const object_reference_type t){
void vsave(const object_reference_type t) BOOST_OVERRIDE {
* this->This() << t;
}
virtual void vsave(const class_id_type t){
void vsave(const class_id_type t) BOOST_OVERRIDE {
* this->This() << t;
}
virtual void vsave(const class_id_reference_type t){
void vsave(const class_id_reference_type t) BOOST_OVERRIDE {
* this->This() << t;
}
virtual void vsave(const class_id_optional_type t){
void vsave(const class_id_optional_type t) BOOST_OVERRIDE {
* this->This() << t;
}
virtual void vsave(const class_name_type & t){
void vsave(const class_name_type & t) BOOST_OVERRIDE {
* this->This() << t;
}
virtual void vsave(const tracking_type t){
void vsave(const tracking_type t) BOOST_OVERRIDE {
* this->This() << t;
}
protected:
@@ -72,7 +72,7 @@ protected:
}
void save_start(const char * /*name*/){}
void save_end(const char * /*name*/){}
common_oarchive(unsigned int flags = 0) :
common_oarchive(unsigned int flags = 0) :
basic_oarchive(flags),
interface_oarchive<Archive>()
{}

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

@@ -1,10 +1,10 @@
#ifndef BOOST_ARCHIVE_DETAIL_DECL_HPP
#define BOOST_ARCHIVE_DETAIL_DECL_HPP
#define BOOST_ARCHIVE_DETAIL_DECL_HPP
// MS compatible compilers support #pragma once
#if defined(_MSC_VER)
# pragma once
#endif
#endif
/////////1/////////2///////// 3/////////4/////////5/////////6/////////7/////////8
// decl.hpp
@@ -16,7 +16,7 @@
// See library home page at http://www.boost.org/libs/serialization
//----------------------------------------------------------------------------//
//----------------------------------------------------------------------------//
// This header implements separate compilation features as described in
// http://www.boost.org/more/separate_compilation.html

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

@@ -9,7 +9,7 @@
/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
// interface_iarchive.hpp
// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
// Use, modification and distribution is subject to the Boost Software
// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
@@ -31,10 +31,10 @@ namespace detail {
class basic_pointer_iserializer;
template<class Archive>
class interface_iarchive
class interface_iarchive
{
protected:
interface_iarchive(){};
interface_iarchive() {}
public:
/////////////////////////////////////////////////////////
// archive public interface
@@ -47,11 +47,11 @@ public:
}
template<class T>
const basic_pointer_iserializer *
const basic_pointer_iserializer *
register_type(T * = NULL){
const basic_pointer_iserializer & bpis =
boost::serialization::singleton<
pointer_iserializer<Archive, T>
pointer_iserializer<Archive, T>
>::get_const_instance();
this->This()->register_basic_serializer(bpis.get_basic_serializer());
return & bpis;
@@ -62,14 +62,14 @@ public:
helper_collection & hc = this->This()->get_helper_collection();
return hc.template find_helper<Helper>(id);
}
template<class T>
Archive & operator>>(T & t){
this->This()->load_override(t);
return * this->This();
}
// the & operator
// the & operator
template<class T>
Archive & operator&(T & t){
return *(this->This()) >> t;

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

@@ -9,7 +9,7 @@
/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
// interface_oarchive.hpp
// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
// Use, modification and distribution is subject to the Boost Software
// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
@@ -32,10 +32,10 @@ namespace detail {
class basic_pointer_oserializer;
template<class Archive>
class interface_oarchive
class interface_oarchive
{
protected:
interface_oarchive(){};
interface_oarchive() {}
public:
/////////////////////////////////////////////////////////
// archive public interface
@@ -48,7 +48,7 @@ public:
}
template<class T>
const basic_pointer_oserializer *
const basic_pointer_oserializer *
register_type(const T * = NULL){
const basic_pointer_oserializer & bpos =
boost::serialization::singleton<
@@ -57,7 +57,7 @@ public:
this->This()->register_basic_serializer(bpos.get_basic_serializer());
return & bpos;
}
template<class Helper>
Helper &
get_helper(void * const id = 0){
@@ -70,8 +70,8 @@ public:
this->This()->save_override(t);
return * this->This();
}
// the & operator
// the & operator
template<class T>
Archive & operator&(const T & t){
return * this ->This() << t;

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

@@ -2,20 +2,22 @@
#define BOOST_ARCHIVE_DETAIL_ISERIALIZER_HPP
// MS compatible compilers support #pragma once
#if defined(_MSC_VER)
#if defined(BOOST_MSVC)
# pragma once
#pragma inline_depth(511)
#if !defined(__clang__)
#pragma inline_depth(255)
#pragma inline_recursion(on)
#endif
#endif
#if defined(__MWERKS__)
#pragma inline_depth(511)
#pragma inline_depth(255)
#endif
/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
// iserializer.hpp: interface for serialization system.
// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
// Use, modification and distribution is subject to the Boost Software
// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
@@ -28,8 +30,8 @@
#include <boost/config.hpp>
#include <boost/detail/workaround.hpp>
#if defined(BOOST_NO_STDC_NAMESPACE)
namespace std{
using ::size_t;
namespace std{
using ::size_t;
} // namespace std
#endif
@@ -41,8 +43,8 @@ namespace std{
#include <boost/mpl/equal_to.hpp>
#include <boost/core/no_exceptions_support.hpp>
#ifndef BOOST_SERIALIZATION_DEFAULT_TYPE_INFO
#include <boost/serialization/extended_type_info_typeid.hpp>
#ifndef BOOST_SERIALIZATION_DEFAULT_TYPE_INFO
#include <boost/serialization/extended_type_info_typeid.hpp>
#endif
#include <boost/serialization/throw_exception.hpp>
#include <boost/serialization/smart_cast.hpp>
@@ -60,12 +62,12 @@ namespace std{
#if !defined(BOOST_MSVC) && \
(BOOST_WORKAROUND(__IBMCPP__, < 1210) || \
defined(__SUNPRO_CC) && (__SUNPRO_CC < 0x590))
#define DONT_USE_HAS_NEW_OPERATOR 1
#define BOOST_SERIALIZATION_DONT_USE_HAS_NEW_OPERATOR 1
#else
#define DONT_USE_HAS_NEW_OPERATOR 0
#define BOOST_SERIALIZATION_DONT_USE_HAS_NEW_OPERATOR 0
#endif
#if ! DONT_USE_HAS_NEW_OPERATOR
#if ! BOOST_SERIALIZATION_DONT_USE_HAS_NEW_OPERATOR
#include <boost/type_traits/has_new_operator.hpp>
#endif
@@ -120,41 +122,41 @@ template<class Archive, class T>
class iserializer : public basic_iserializer
{
private:
virtual void destroy(/*const*/ void *address) const {
void destroy(/*const*/ void *address) const BOOST_OVERRIDE {
boost::serialization::access::destroy(static_cast<T *>(address));
}
public:
explicit iserializer() :
basic_iserializer(
boost::serialization::singleton<
typename
typename
boost::serialization::type_info_implementation< T >::type
>::get_const_instance()
)
{}
virtual BOOST_DLLEXPORT void load_object_data(
BOOST_DLLEXPORT void load_object_data(
basic_iarchive & ar,
void *x,
void *x,
const unsigned int file_version
) const BOOST_USED;
virtual bool class_info() const {
return boost::serialization::implementation_level< T >::value
) const BOOST_OVERRIDE BOOST_USED;
bool class_info() const BOOST_OVERRIDE {
return boost::serialization::implementation_level< T >::value
>= boost::serialization::object_class_info;
}
virtual bool tracking(const unsigned int /* flags */) const {
return boost::serialization::tracking_level< T >::value
bool tracking(const unsigned int /* flags */) const BOOST_OVERRIDE {
return boost::serialization::tracking_level< T >::value
== boost::serialization::track_always
|| ( boost::serialization::tracking_level< T >::value
|| ( boost::serialization::tracking_level< T >::value
== boost::serialization::track_selectively
&& serialized_as_pointer());
}
virtual version_type version() const {
version_type version() const BOOST_OVERRIDE {
return version_type(::boost::serialization::version< T >::value);
}
virtual bool is_polymorphic() const {
bool is_polymorphic() const BOOST_OVERRIDE {
return boost::is_polymorphic< T >::value;
}
virtual ~iserializer(){};
~iserializer() BOOST_OVERRIDE {}
};
#ifdef BOOST_MSVC
@@ -164,12 +166,12 @@ public:
template<class Archive, class T>
BOOST_DLLEXPORT void iserializer<Archive, T>::load_object_data(
basic_iarchive & ar,
void *x,
void *x,
const unsigned int file_version
) const {
// note: we now comment this out. Before we permited archive
// version # to be very large. Now we don't. To permit
// readers of these old archives, we have to suppress this
// readers of these old archives, we have to suppress this
// code. Perhaps in the future we might re-enable it but
// permit its suppression with a runtime switch.
#if 0
@@ -186,7 +188,7 @@ BOOST_DLLEXPORT void iserializer<Archive, T>::load_object_data(
// be specialized by the user.
boost::serialization::serialize_adl(
boost::serialization::smart_cast_reference<Archive &>(ar),
* static_cast<T *>(x),
* static_cast<T *>(x),
file_version
);
}
@@ -199,7 +201,7 @@ BOOST_DLLEXPORT void iserializer<Archive, T>::load_object_data(
// the purpose of this code is to allocate memory for an object
// without requiring the constructor to be called. Presumably
// the allocated object will be subsequently initialized with
// "placement new".
// "placement new".
// note: we have the boost type trait has_new_operator but we
// have no corresponding has_delete_operator. So we presume
// that the former being true would imply that the a delete
@@ -208,7 +210,7 @@ BOOST_DLLEXPORT void iserializer<Archive, T>::load_object_data(
template<class T>
struct heap_allocation {
// boost::has_new_operator< T > doesn't work on these compilers
#if DONT_USE_HAS_NEW_OPERATOR
#if BOOST_SERIALIZATION_DONT_USE_HAS_NEW_OPERATOR
// This doesn't handle operator new overload for class T
static T * invoke_new(){
return static_cast<T *>(operator new(sizeof(T)));
@@ -250,7 +252,7 @@ struct heap_allocation {
mpl::eval_if<
boost::has_new_operator< T >,
mpl::identity<has_new_operator >,
mpl::identity<doesnt_have_new_operator >
mpl::identity<doesnt_have_new_operator >
>::type typex;
return typex::invoke_new();
}
@@ -259,7 +261,7 @@ struct heap_allocation {
mpl::eval_if<
boost::has_new_operator< T >,
mpl::identity<has_new_operator >,
mpl::identity<doesnt_have_new_operator >
mpl::identity<doesnt_have_new_operator >
>::type typex;
typex::invoke_delete(t);
}
@@ -289,26 +291,26 @@ class pointer_iserializer :
public basic_pointer_iserializer
{
private:
virtual void * heap_allocation() const {
void * heap_allocation() const BOOST_OVERRIDE {
detail::heap_allocation<T> h;
T * t = h.get();
h.release();
return t;
}
virtual const basic_iserializer & get_basic_serializer() const {
const basic_iserializer & get_basic_serializer() const BOOST_OVERRIDE {
return boost::serialization::singleton<
iserializer<Archive, T>
>::get_const_instance();
}
BOOST_DLLEXPORT virtual void load_object_ptr(
basic_iarchive & ar,
BOOST_DLLEXPORT void load_object_ptr(
basic_iarchive & ar,
void * x,
const unsigned int file_version
) const BOOST_USED;
) const BOOST_OVERRIDE BOOST_USED;
public:
// this should alway be a singleton so make the constructor protected
pointer_iserializer();
~pointer_iserializer();
~pointer_iserializer() BOOST_OVERRIDE;
};
#ifdef BOOST_MSVC
@@ -319,12 +321,12 @@ public:
// serialized only through base class won't get optimized out
template<class Archive, class T>
BOOST_DLLEXPORT void pointer_iserializer<Archive, T>::load_object_ptr(
basic_iarchive & ar,
basic_iarchive & ar,
void * t,
const unsigned int file_version
) const
{
Archive & ar_impl =
Archive & ar_impl =
boost::serialization::smart_cast_reference<Archive &>(ar);
// note that the above will throw std::bad_alloc if the allocation
@@ -334,7 +336,7 @@ BOOST_DLLEXPORT void pointer_iserializer<Archive, T>::load_object_ptr(
// automatically delete the t which is most likely not fully
// constructed
BOOST_TRY {
// this addresses an obscure situation that occurs when
// this addresses an obscure situation that occurs when
// load_constructor de-serializes something through a pointer.
ar.next_object_pointer(t);
boost::serialization::load_construct_data_adl<Archive, T>(
@@ -358,7 +360,7 @@ template<class Archive, class T>
pointer_iserializer<Archive, T>::pointer_iserializer() :
basic_pointer_iserializer(
boost::serialization::singleton<
typename
typename
boost::serialization::type_info_implementation< T >::type
>::get_const_instance()
)
@@ -393,8 +395,8 @@ struct load_non_pointer_type {
// make sure call is routed through the higest interface that might
// be specialized by the user.
boost::serialization::serialize_adl(
ar,
const_cast<T &>(t),
ar,
const_cast<T &>(t),
boost::serialization::version< T >::value
);
}
@@ -407,7 +409,7 @@ struct load_non_pointer_type {
static void invoke(Archive &ar, const T & t){
void * x = boost::addressof(const_cast<T &>(t));
ar.load_object(
x,
x,
boost::serialization::singleton<
iserializer<Archive, T>
>::get_const_instance()
@@ -484,7 +486,7 @@ struct load_pointer_type {
template<class T>
static const basic_pointer_iserializer * register_type(Archive &ar, const T* const /*t*/){
// there should never be any need to load an abstract polymorphic
// there should never be any need to load an abstract polymorphic
// class pointer. Inhibiting code generation for this
// permits abstract base classes to be used - note: exception
// virtual serialize functions used for plug-ins
@@ -492,7 +494,7 @@ struct load_pointer_type {
mpl::eval_if<
boost::serialization::is_abstract<const T>,
boost::mpl::identity<abstract>,
boost::mpl::identity<non_abstract>
boost::mpl::identity<non_abstract>
>::type typex;
return typex::template register_type< T >(ar);
}
@@ -508,7 +510,7 @@ struct load_pointer_type {
boost::serialization::void_upcast(
eti,
boost::serialization::singleton<
typename
typename
boost::serialization::type_info_implementation< T >::type
>::get_const_instance(),
t
@@ -570,13 +572,13 @@ struct load_array_type {
template<class T>
static void invoke(Archive &ar, T &t){
typedef typename remove_extent< T >::type value_type;
// convert integers to correct enum to load
// determine number of elements in the array. Consider the
// fact that some machines will align elements on boundries
// fact that some machines will align elements on boundaries
// other than characters.
std::size_t current_count = sizeof(t) / (
static_cast<char *>(static_cast<void *>(&t[1]))
static_cast<char *>(static_cast<void *>(&t[1]))
- static_cast<char *>(static_cast<void *>(&t[0]))
);
boost::serialization::collection_size_type count;

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

@@ -4,18 +4,20 @@
// MS compatible compilers support #pragma once
#if defined(_MSC_VER)
# pragma once
#pragma inline_depth(511)
#if !defined(__clang__)
#pragma inline_depth(255)
#pragma inline_recursion(on)
#endif
#endif
#if defined(__MWERKS__)
#pragma inline_depth(511)
#pragma inline_depth(255)
#endif
/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
// oserializer.hpp: interface for serialization system.
// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
// Use, modification and distribution is subject to the Boost Software
// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
@@ -36,8 +38,8 @@
#include <boost/mpl/identity.hpp>
#include <boost/mpl/bool_fwd.hpp>
#ifndef BOOST_SERIALIZATION_DEFAULT_TYPE_INFO
#include <boost/serialization/extended_type_info_typeid.hpp>
#ifndef BOOST_SERIALIZATION_DEFAULT_TYPE_INFO
#include <boost/serialization/extended_type_info_typeid.hpp>
#endif
#include <boost/serialization/throw_exception.hpp>
#include <boost/serialization/smart_cast.hpp>
@@ -105,37 +107,37 @@ template<class Archive, class T>
class oserializer : public basic_oserializer
{
private:
// private constructor to inhibit any existence other than the
// private constructor to inhibit any existence other than the
// static one
public:
explicit BOOST_DLLEXPORT oserializer() :
basic_oserializer(
boost::serialization::singleton<
typename
typename
boost::serialization::type_info_implementation< T >::type
>::get_const_instance()
)
{}
virtual BOOST_DLLEXPORT void save_object_data(
basic_oarchive & ar,
BOOST_DLLEXPORT void save_object_data(
basic_oarchive & ar,
const void *x
) const BOOST_USED;
virtual bool class_info() const {
return boost::serialization::implementation_level< T >::value
) const BOOST_OVERRIDE BOOST_USED;
bool class_info() const BOOST_OVERRIDE {
return boost::serialization::implementation_level< T >::value
>= boost::serialization::object_class_info;
}
virtual bool tracking(const unsigned int /* flags */) const {
bool tracking(const unsigned int /* flags */) const BOOST_OVERRIDE {
return boost::serialization::tracking_level< T >::value == boost::serialization::track_always
|| (boost::serialization::tracking_level< T >::value == boost::serialization::track_selectively
&& serialized_as_pointer());
}
virtual version_type version() const {
version_type version() const BOOST_OVERRIDE {
return version_type(::boost::serialization::version< T >::value);
}
virtual bool is_polymorphic() const {
bool is_polymorphic() const BOOST_OVERRIDE {
return boost::is_polymorphic< T >::value;
}
virtual ~oserializer(){}
~oserializer() BOOST_OVERRIDE {}
};
#ifdef BOOST_MSVC
@@ -144,7 +146,7 @@ public:
template<class Archive, class T>
BOOST_DLLEXPORT void oserializer<Archive, T>::save_object_data(
basic_oarchive & ar,
basic_oarchive & ar,
const void *x
) const {
// make sure call is routed through the highest interface that might
@@ -167,19 +169,19 @@ class pointer_oserializer :
public basic_pointer_oserializer
{
private:
const basic_oserializer &
get_basic_serializer() const {
const basic_oserializer &
get_basic_serializer() const BOOST_OVERRIDE {
return boost::serialization::singleton<
oserializer<Archive, T>
>::get_const_instance();
}
virtual BOOST_DLLEXPORT void save_object_ptr(
BOOST_DLLEXPORT void save_object_ptr(
basic_oarchive & ar,
const void * x
) const BOOST_USED;
) const BOOST_OVERRIDE BOOST_USED;
public:
pointer_oserializer();
~pointer_oserializer();
~pointer_oserializer() BOOST_OVERRIDE;
};
#ifdef BOOST_MSVC
@@ -196,11 +198,11 @@ BOOST_DLLEXPORT void pointer_oserializer<Archive, T>::save_object_ptr(
// be specialized by the user.
T * t = static_cast<T *>(const_cast<void *>(x));
const unsigned int file_version = boost::serialization::version< T >::value;
Archive & ar_impl
Archive & ar_impl
= boost::serialization::smart_cast_reference<Archive &>(ar);
boost::serialization::save_construct_data_adl<Archive, T>(
ar_impl,
t,
ar_impl,
t,
file_version
);
ar_impl << boost::serialization::make_nvp(NULL, * t);
@@ -210,14 +212,14 @@ template<class Archive, class T>
pointer_oserializer<Archive, T>::pointer_oserializer() :
basic_pointer_oserializer(
boost::serialization::singleton<
typename
typename
boost::serialization::type_info_implementation< T >::type
>::get_const_instance()
)
{
// make sure appropriate member function is instantiated
boost::serialization::singleton<
oserializer<Archive, T>
oserializer<Archive, T>
>::get_mutable_instance().set_bpos(this);
archive_serializer_map<Archive>::insert(this);
}
@@ -244,8 +246,8 @@ struct save_non_pointer_type {
// make sure call is routed through the highest interface that might
// be specialized by the user.
boost::serialization::serialize_adl(
ar,
const_cast<T &>(t),
ar,
const_cast<T &>(t),
::boost::serialization::version< T >::value
);
}
@@ -281,7 +283,7 @@ struct save_non_pointer_type {
template<class T>
static void invoke(Archive & ar, const T & t){
typedef
typedef
typename mpl::eval_if<
// if its primitive
mpl::equal_to<
@@ -310,7 +312,7 @@ struct save_non_pointer_type {
// else
// do a fast save only tracking is turned off
mpl::identity<save_conditional>
> > >::type typex;
> > >::type typex;
check_object_versioning< T >();
typex::invoke(ar, t);
}
@@ -344,15 +346,15 @@ struct save_pointer_type {
template<class T>
static const basic_pointer_oserializer * register_type(Archive &ar, T* const /*t*/){
// there should never be any need to save an abstract polymorphic
// there should never be any need to save an abstract polymorphic
// class pointer. Inhibiting code generation for this
// permits abstract base classes to be used - note: exception
// virtual serialize functions used for plug-ins
typedef
typedef
typename mpl::eval_if<
boost::serialization::is_abstract< T >,
mpl::identity<abstract>,
mpl::identity<non_abstract>
mpl::identity<non_abstract>
>::type typex;
return typex::template register_type< T >(ar);
}
@@ -361,10 +363,10 @@ struct save_pointer_type {
{
template<class T>
static void save(
Archive &ar,
Archive &ar,
T & t
){
const basic_pointer_oserializer & bpos =
const basic_pointer_oserializer & bpos =
boost::serialization::singleton<
pointer_oserializer<Archive, T>
>::get_const_instance();
@@ -377,13 +379,13 @@ struct save_pointer_type {
{
template<class T>
static void save(
Archive &ar,
Archive &ar,
T & t
){
typename
typename
boost::serialization::type_info_implementation< T >::type const
& i = boost::serialization::singleton<
typename
typename
boost::serialization::type_info_implementation< T >::type
>::get_const_instance();
@@ -417,8 +419,8 @@ struct save_pointer_type {
// convert pointer to more derived type. if this is thrown
// it means that the base/derived relationship hasn't be registered
vp = serialization::void_downcast(
*true_type,
*this_type,
*true_type,
*this_type,
static_cast<const void *>(&t)
);
if(NULL == vp){
@@ -431,7 +433,7 @@ struct save_pointer_type {
);
}
// since true_type is valid, and this only gets made if the
// since true_type is valid, and this only gets made if the
// pointer oserializer object has been created, this should never
// fail
const basic_pointer_oserializer * bpos
@@ -454,7 +456,7 @@ struct save_pointer_type {
template<class T>
static void save(
Archive & ar,
Archive & ar,
const T & t
){
check_pointer_level< T >();
@@ -471,7 +473,7 @@ struct save_pointer_type {
static void invoke(Archive &ar, const TPtr t){
register_type(ar, t);
if(NULL == t){
basic_oarchive & boa
basic_oarchive & boa
= boost::serialization::smart_cast_reference<basic_oarchive &>(ar);
boa.save_null_pointer();
save_access::end_preamble(ar);
@@ -498,11 +500,11 @@ struct save_array_type
template<class T>
static void invoke(Archive &ar, const T &t){
typedef typename boost::remove_extent< T >::type value_type;
save_access::end_preamble(ar);
// consider alignment
std::size_t c = sizeof(t) / (
static_cast<const char *>(static_cast<const void *>(&t[1]))
static_cast<const char *>(static_cast<const void *>(&t[1]))
- static_cast<const char *>(static_cast<const void *>(&t[0]))
);
boost::serialization::collection_size_type count(c);
@@ -522,7 +524,7 @@ struct save_array_type
template<class Archive, class T>
inline void save(Archive & ar, /*const*/ T &t){
typedef
typedef
typename mpl::eval_if<is_pointer< T >,
mpl::identity<detail::save_pointer_type<Archive> >,
//else

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

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

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

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

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

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

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

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