map-per/organicmaps
1
Fork 0
forked from organicmaps/organicmaps
Code Pull requests Activity

Updated boost to 1.45

Browse source
This commit is contained in:
Alex Zolotarev 2011-01-13 00:15:31 +02:00 • committed by Alex Zolotarev
parent dc3802b910
commit da761273ed
598 changed files with 21653 additions and 5431 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
3party/boost/boost/algorithm/string/detail/find_format_store.hpp
View file

@ -71,7 +71,7 @@ namespace boost {
};
template<typename InputT, typename FindResultT>
bool check_find_result(InputT& Input, FindResultT& FindResult)
bool check_find_result(InputT&, FindResultT& FindResult)
{
typedef BOOST_STRING_TYPENAME
range_const_iterator<InputT>::type input_iterator_type;

23
3party/boost/boost/archive/basic_archive.hpp
View file

@ -54,7 +54,7 @@ public:
return *this;
}
// used for text output
operator const base_type () const {
operator base_type () const {
return t;
}
// used for text input
@ -90,7 +90,7 @@ public:
return *this;
}
// used for text output
operator const base_type () const {
operator base_type () const {
return t;
}
// used for text intput
@ -127,7 +127,7 @@ public:
}
// used for text output
operator const int () const {
operator int () const {
return t;
}
// used for text input
@ -161,7 +161,7 @@ public:
return *this;
}
// used for text output
operator const uint_least32_t () const {
operator uint_least32_t () const {
return t;
}
// used for text input
@ -282,4 +282,19 @@ BOOST_CLASS_IMPLEMENTATION(boost::archive::object_id_type, primitive_type)
BOOST_CLASS_IMPLEMENTATION(boost::archive::object_reference_type, primitive_type)
BOOST_CLASS_IMPLEMENTATION(boost::archive::tracking_type, primitive_type)
#include <boost/serialization/is_bitwise_serializable.hpp>
// set types used internally by the serialization library
// to be bitwise serializable
BOOST_IS_BITWISE_SERIALIZABLE(boost::archive::library_version_type)
BOOST_IS_BITWISE_SERIALIZABLE(boost::archive::version_type)
BOOST_IS_BITWISE_SERIALIZABLE(boost::archive::class_id_type)
BOOST_IS_BITWISE_SERIALIZABLE(boost::archive::class_id_reference_type)
BOOST_IS_BITWISE_SERIALIZABLE(boost::archive::class_id_optional_type)
BOOST_IS_BITWISE_SERIALIZABLE(boost::archive::class_name_type)
BOOST_IS_BITWISE_SERIALIZABLE(boost::archive::object_id_type)
BOOST_IS_BITWISE_SERIALIZABLE(boost::archive::object_reference_type)
BOOST_IS_BITWISE_SERIALIZABLE(boost::archive::tracking_type)
#endif //BOOST_ARCHIVE_BASIC_ARCHIVE_HPP

71
3party/boost/boost/archive/basic_binary_iarchive.hpp
View file

@ -32,6 +32,7 @@
#include <boost/serialization/collection_size_type.hpp>
#include <boost/serialization/string.hpp>
#include <boost/serialization/item_version_type.hpp>
#include <boost/integer_traits.hpp>
#ifdef BOOST_MSVC
# pragma warning(push)
@ -71,7 +72,7 @@ public:
// include these to trap a change in binary format which
// isn't specifically handled
BOOST_STATIC_ASSERT(sizeof(tracking_type) == sizeof(char));
BOOST_STATIC_ASSERT(sizeof(tracking_type) == sizeof(bool));
// upto 32K classes
BOOST_STATIC_ASSERT(sizeof(class_id_type) == sizeof(int_least16_t));
BOOST_STATIC_ASSERT(sizeof(class_id_reference_type) == sizeof(int_least16_t));
@ -82,21 +83,61 @@ public:
// binary files don't include the optional information
void load_override(class_id_optional_type & /* t */, int){}
void load_override(boost::serialization::item_version_type & t, int version){
if(library_version_type(6) < this->get_library_version()){
void load_override(class_id_type & t, int version){
library_version_type lvt = this->get_library_version();
if(boost::archive::library_version_type(7) < lvt){
this->detail_common_iarchive::load_override(t, version);
}
else
if(boost::archive::library_version_type(6) < lvt){
int_least16_t x=0;
* this->This() >> x;
t = boost::archive::class_id_type(x);
}
else{
unsigned int x=0;
int x=0;
* this->This() >> x;
t = boost::serialization::item_version_type(x);
t = boost::archive::class_id_type(x);
}
}
void load_override(class_id_reference_type & t, int version){
load_override(static_cast<class_id_type &>(t), version);
}
#if 0
void load_override(class_id_reference_type & t, int version){
library_version_type lvt = this->get_library_version();
if(boost::archive::library_version_type(7) < lvt){
this->detail_common_iarchive::load_override(t, version);
}
else
if(boost::archive::library_version_type(6) < lvt){
int_least16_t x=0;
* this->This() >> x;
t = boost::archive::class_id_reference_type(
boost::archive::class_id_type(x)
);
}
else{
int x=0;
* this->This() >> x;
t = boost::archive::class_id_reference_type(
boost::archive::class_id_type(x)
);
}
}
#endif
void load_override(version_type & t, int version){
if(boost::archive::library_version_type(6) < this->get_library_version()){
library_version_type lvt = this->get_library_version();
if(boost::archive::library_version_type(7) < lvt){
this->detail_common_iarchive::load_override(t, version);
}
else
if(boost::archive::library_version_type(6) < lvt){
uint_least16_t x=0;
* this->This() >> x;
t = boost::archive::version_type(x);
}
else{
unsigned int x=0;
* this->This() >> x;
@ -104,6 +145,24 @@ public:
}
}
void load_override(boost::serialization::item_version_type & t, int version){
library_version_type lvt = this->get_library_version();
if(boost::archive::library_version_type(7) < lvt){
this->detail_common_iarchive::load_override(t, version);
}
else
if(boost::archive::library_version_type(6) < lvt){
uint_least16_t x=0;
* this->This() >> x;
t = boost::serialization::item_version_type(x);
}
else{
unsigned int x=0;
* this->This() >> x;
t = boost::serialization::item_version_type(x);
}
}
void load_override(serialization::collection_size_type & t, int version){
if(boost::archive::library_version_type(5) < this->get_library_version()){
this->detail_common_iarchive::load_override(t, version);

4
3party/boost/boost/archive/basic_binary_iprimitive.hpp
View file

@ -126,10 +126,10 @@ public:
template <class T>
#if defined(BOOST_NO_DEPENDENT_NESTED_DERIVATIONS)
struct apply {
typedef BOOST_DEDUCED_TYPENAME boost::serialization::is_bitwise_serializable<T>::type type;
typedef BOOST_DEDUCED_TYPENAME boost::serialization::is_bitwise_serializable< T >::type type;
};
#else
struct apply : public boost::serialization::is_bitwise_serializable<T> {};
struct apply : public boost::serialization::is_bitwise_serializable< T > {};
#endif
};

55
3party/boost/boost/archive/basic_binary_oarchive.hpp
View file

@ -34,6 +34,7 @@
#include <boost/archive/detail/common_oarchive.hpp>
#include <boost/serialization/string.hpp>
#include <boost/serialization/collection_size_type.hpp>
#include <boost/serialization/item_version_type.hpp>
#include <boost/archive/detail/abi_prefix.hpp> // must be the last header
@ -76,7 +77,7 @@ public:
// include these to trap a change in binary format which
// isn't specifically handled
BOOST_STATIC_ASSERT(sizeof(tracking_type) == sizeof(char));
BOOST_STATIC_ASSERT(sizeof(tracking_type) == sizeof(bool));
// upto 32K classes
BOOST_STATIC_ASSERT(sizeof(class_id_type) == sizeof(int_least16_t));
BOOST_STATIC_ASSERT(sizeof(class_id_reference_type) == sizeof(int_least16_t));
@ -87,14 +88,58 @@ public:
// binary files don't include the optional information
void save_override(const class_id_optional_type & /* t */, int){}
#if 0 // enable this if we decide to support generation of previous versions
// enable this if we decide to support generation of previous versions
#if 0
void save_override(const boost::archive::version_type & t, int version){
if(this->get_library_version() < boost::archive::library_version_type(7)){
* this->This() << static_cast<int_least16_t >(t);
library_version_type lvt = this->get_library_version();
if(boost::archive::library_version_type(7) < lvt){
this->detail_common_oarchive::save_override(t, version);
}
else
this->detail_common_oarchive::save_override(t, version);
if(boost::archive::library_version_type(6) < lvt){
const boost::uint_least16_t x = t;
* this->This() << x;
}
else{
const unsigned int x = t;
* this->This() << x;
}
}
void save_override(const boost::serialization::item_version_type & t, int version){
library_version_type lvt = this->get_library_version();
if(boost::archive::library_version_type(7) < lvt){
this->detail_common_oarchive::save_override(t, version);
}
else
if(boost::archive::library_version_type(6) < lvt){
const boost::uint_least16_t x = t;
* this->This() << x;
}
else{
const unsigned int x = t;
* this->This() << x;
}
}
void save_override(class_id_type & t, int version){
library_version_type lvt = this->get_library_version();
if(boost::archive::library_version_type(7) < lvt){
this->detail_common_oarchive::save_override(t, version);
}
else
if(boost::archive::library_version_type(6) < lvt){
const boost::int_least16_t x = t;
* this->This() << x;
}
else{
const int x = t;
* this->This() << x;
}
}
void save_override(class_id_reference_type & t, int version){
save_override(static_cast<class_id_type &>(t), version);
}
#endif
// explicitly convert to char * to avoid compile ambiguities

4
3party/boost/boost/archive/basic_binary_oprimitive.hpp
View file

@ -122,10 +122,10 @@ public:
template <class T>
#if defined(BOOST_NO_DEPENDENT_NESTED_DERIVATIONS)
struct apply {
typedef BOOST_DEDUCED_TYPENAME boost::serialization::is_bitwise_serializable<T>::type type;
typedef BOOST_DEDUCED_TYPENAME boost::serialization::is_bitwise_serializable< T >::type type;
};
#else
struct apply : public boost::serialization::is_bitwise_serializable<T> {};
struct apply : public boost::serialization::is_bitwise_serializable< T > {};
#endif
};

4
3party/boost/boost/archive/basic_xml_iarchive.hpp
View file

@ -67,7 +67,7 @@ public:
// If your program fails to compile here, its most likely due to
// not specifying an nvp wrapper around the variable to
// be serialized.
BOOST_MPL_ASSERT((serialization::is_wrapper<T>));
BOOST_MPL_ASSERT((serialization::is_wrapper< T >));
this->detail_common_iarchive::load_override(t, 0);
}
@ -79,7 +79,7 @@ public:
#ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING
const
#endif
boost::serialization::nvp<T> & t,
boost::serialization::nvp< T > & t,
int
){
this->This()->load_start(t.name());

4
3party/boost/boost/archive/basic_xml_oarchive.hpp
View file

@ -89,7 +89,7 @@ public:
// If your program fails to compile here, its most likely due to
// not specifying an nvp wrapper around the variable to
// be serialized.
BOOST_MPL_ASSERT((serialization::is_wrapper<T>));
BOOST_MPL_ASSERT((serialization::is_wrapper< T >));
this->detail_common_oarchive::save_override(t, 0);
}
@ -100,7 +100,7 @@ public:
#ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING
const
#endif
::boost::serialization::nvp<T> & t,
::boost::serialization::nvp< T > & t,
int
){
this->This()->save_start(t.name());

20
3party/boost/boost/archive/detail/check.hpp
View file

@ -51,7 +51,7 @@ template<class T>
inline void check_object_level(){
typedef
BOOST_DEDUCED_TYPENAME mpl::greater_equal<
serialization::implementation_level<T>,
serialization::implementation_level< T >,
mpl::int_<serialization::primitive_type>
>::type typex;
@ -65,11 +65,11 @@ inline void check_object_versioning(){
typedef
BOOST_DEDUCED_TYPENAME mpl::or_<
BOOST_DEDUCED_TYPENAME mpl::greater<
serialization::implementation_level<T>,
serialization::implementation_level< T >,
mpl::int_<serialization::object_serializable>
>,
BOOST_DEDUCED_TYPENAME mpl::equal_to<
serialization::version<T>,
serialization::version< T >,
mpl::int_<0>
>
> typex;
@ -82,9 +82,9 @@ template<class T>
inline void check_object_tracking(){
// presume it has already been determined that
// T is not a const
BOOST_STATIC_ASSERT(! boost::is_const<T>::value);
BOOST_STATIC_ASSERT(! boost::is_const< T >::value);
typedef BOOST_DEDUCED_TYPENAME mpl::equal_to<
serialization::tracking_level<T>,
serialization::tracking_level< T >,
mpl::int_<serialization::track_never>
>::type typex;
// saving an non-const object of a type not marked "track_never)
@ -107,12 +107,12 @@ inline void check_pointer_level(){
typedef
BOOST_DEDUCED_TYPENAME mpl::or_<
BOOST_DEDUCED_TYPENAME mpl::greater<
serialization::implementation_level<T>,
serialization::implementation_level< T >,
mpl::int_<serialization::object_serializable>
>,
BOOST_DEDUCED_TYPENAME mpl::not_<
BOOST_DEDUCED_TYPENAME mpl::equal_to<
serialization::tracking_level<T>,
serialization::tracking_level< T >,
mpl::int_<serialization::track_selectively>
>
>
@ -140,7 +140,7 @@ inline void check_pointer_level(){
template<class T>
void inline check_pointer_tracking(){
typedef BOOST_DEDUCED_TYPENAME mpl::greater<
serialization::tracking_level<T>,
serialization::tracking_level< T >,
mpl::int_<serialization::track_never>
>::type typex;
// serializing an object of a type marked "track_never" through a pointer
@ -152,9 +152,9 @@ template<class T>
inline void check_const_loading(){
typedef
BOOST_DEDUCED_TYPENAME mpl::or_<
BOOST_DEDUCED_TYPENAME boost::serialization::is_wrapper<T>,
BOOST_DEDUCED_TYPENAME boost::serialization::is_wrapper< T >,
BOOST_DEDUCED_TYPENAME mpl::not_<
BOOST_DEDUCED_TYPENAME boost::is_const<T>
BOOST_DEDUCED_TYPENAME boost::is_const< T >
>
>::type typex;
// cannot load data into a "const" object unless it's a

64
3party/boost/boost/archive/detail/iserializer.hpp
View file

@ -128,7 +128,7 @@ protected:
basic_iserializer(
boost::serialization::singleton<
BOOST_DEDUCED_TYPENAME
boost::serialization::type_info_implementation<T>::type
boost::serialization::type_info_implementation< T >::type
>::get_const_instance()
)
{}
@ -139,21 +139,21 @@ public:
const unsigned int file_version
) const BOOST_USED;
virtual bool class_info() const {
return boost::serialization::implementation_level<T>::value
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
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 {
return version_type(::boost::serialization::version<T>::value);
return version_type(::boost::serialization::version< T >::value);
}
virtual bool is_polymorphic() const {
return boost::is_polymorphic<T>::value;
return boost::is_polymorphic< T >::value;
}
virtual ~iserializer(){};
};
@ -168,6 +168,12 @@ BOOST_DLLEXPORT void iserializer<Archive, T>::load_object_data(
void *x,
const unsigned int file_version
) const {
// note: we now comment this out. Before we permited archive
// version # to be very large. Now we don't. To permit
// readers of these old archives, we have to suppress this
// code. Perhaps in the future we might re-enable it but
// permit its suppression with a runtime switch.
#if 0
// trap case where the program cannot handle the current version
if(file_version > static_cast<const unsigned int>(version()))
boost::serialization::throw_exception(
@ -176,7 +182,7 @@ BOOST_DLLEXPORT void iserializer<Archive, T>::load_object_data(
get_debug_info()
)
);
#endif
// make sure call is routed through the higest interface that might
// be specialized by the user.
boost::serialization::serialize_adl(
@ -230,7 +236,7 @@ protected:
template<class T>
struct heap_allocator
{
// boost::has_new_operator<T> doesn't work on these compilers
// boost::has_new_operator< T > doesn't work on these compilers
#if DONT_USE_HAS_NEW_OPERATOR
// This doesn't handle operator new overload for class T
static T * invoke(){
@ -250,7 +256,7 @@ struct heap_allocator
static T * invoke() {
typedef BOOST_DEDUCED_TYPENAME
mpl::eval_if<
boost::has_new_operator<T>,
boost::has_new_operator< T >,
mpl::identity<has_new_operator >,
mpl::identity<doesnt_have_new_operator >
>::type typex;
@ -296,7 +302,7 @@ BOOST_DLLEXPORT void pointer_iserializer<Archive, T>::load_object_ptr(
Archive & ar_impl =
boost::serialization::smart_cast_reference<Archive &>(ar);
auto_ptr_with_deleter<T> ap(heap_allocator<T>::invoke());
auto_ptr_with_deleter< T > ap(heap_allocator< T >::invoke());
if(NULL == ap.get())
boost::serialization::throw_exception(std::bad_alloc()) ;
@ -331,7 +337,7 @@ pointer_iserializer<Archive, T>::pointer_iserializer() :
basic_pointer_iserializer(
boost::serialization::singleton<
BOOST_DEDUCED_TYPENAME
boost::serialization::type_info_implementation<T>::type
boost::serialization::type_info_implementation< T >::type
>::get_const_instance()
)
{
@ -367,7 +373,7 @@ struct load_non_pointer_type {
boost::serialization::serialize_adl(
ar,
const_cast<T &>(t),
boost::serialization::version<T>::value
boost::serialization::version< T >::value
);
}
};
@ -402,7 +408,7 @@ struct load_non_pointer_type {
typedef BOOST_DEDUCED_TYPENAME mpl::eval_if<
// if its primitive
mpl::equal_to<
boost::serialization::implementation_level<T>,
boost::serialization::implementation_level< T >,
mpl::int_<boost::serialization::primitive_type>
>,
mpl::identity<load_primitive>,
@ -410,7 +416,7 @@ struct load_non_pointer_type {
BOOST_DEDUCED_TYPENAME mpl::eval_if<
// class info / version
mpl::greater_equal<
boost::serialization::implementation_level<T>,
boost::serialization::implementation_level< T >,
mpl::int_<boost::serialization::object_class_info>
>,
// do standard load
@ -419,7 +425,7 @@ struct load_non_pointer_type {
BOOST_DEDUCED_TYPENAME mpl::eval_if<
// no tracking
mpl::equal_to<
boost::serialization::tracking_level<T>,
boost::serialization::tracking_level< T >,
mpl::int_<boost::serialization::track_never>
>,
// do a fast load
@ -428,8 +434,8 @@ struct load_non_pointer_type {
// do a fast load only tracking is turned off
mpl::identity<load_conditional>
> > >::type typex;
check_object_versioning<T>();
check_object_level<T>();
check_object_versioning< T >();
check_object_level< T >();
typex::invoke(ar, t);
}
};
@ -441,7 +447,7 @@ struct load_pointer_type {
template<class T>
static const basic_pointer_iserializer * register_type(Archive & /* ar */){
// it has? to be polymorphic
BOOST_STATIC_ASSERT(boost::is_polymorphic<T>::value);
BOOST_STATIC_ASSERT(boost::is_polymorphic< T >::value);
return static_cast<basic_pointer_iserializer *>(NULL);
}
};
@ -466,7 +472,7 @@ struct load_pointer_type {
boost::mpl::identity<abstract>,
boost::mpl::identity<non_abstract>
>::type typex;
return typex::template register_type<T>(ar);
return typex::template register_type< T >(ar);
}
template<class T>
@ -482,7 +488,7 @@ struct load_pointer_type {
eti,
boost::serialization::singleton<
BOOST_DEDUCED_TYPENAME
boost::serialization::type_info_implementation<T>::type
boost::serialization::type_info_implementation< T >::type
>::get_const_instance(),
t
)
@ -492,8 +498,8 @@ struct load_pointer_type {
template<class T>
static void check_load(T & /* t */){
check_pointer_level<T>();
check_pointer_tracking<T>();
check_pointer_level< T >();
check_pointer_tracking< T >();
}
static const basic_pointer_iserializer *
@ -530,7 +536,7 @@ struct load_enum_type {
// convert integers to correct enum to load
int i;
ar >> boost::serialization::make_nvp(NULL, i);
t = static_cast<T>(i);
t = static_cast< T >(i);
}
};
@ -538,7 +544,7 @@ template<class Archive>
struct load_array_type {
template<class T>
static void invoke(Archive &ar, T &t){
typedef BOOST_DEDUCED_TYPENAME remove_extent<T>::type value_type;
typedef BOOST_DEDUCED_TYPENAME remove_extent< T >::type value_type;
// convert integers to correct enum to load
// determine number of elements in the array. Consider the
@ -568,15 +574,15 @@ inline void load(Archive & ar, T &t){
// const object with a compiler that doesn't have correct
// funtion template ordering. On other compilers, this is
// handled below.
detail::check_const_loading<T>();
detail::check_const_loading< T >();
typedef
BOOST_DEDUCED_TYPENAME mpl::eval_if<is_pointer<T>,
BOOST_DEDUCED_TYPENAME mpl::eval_if<is_pointer< T >,
mpl::identity<detail::load_pointer_type<Archive> >
,//else
BOOST_DEDUCED_TYPENAME mpl::eval_if<is_array<T>,
BOOST_DEDUCED_TYPENAME mpl::eval_if<is_array< T >,
mpl::identity<detail::load_array_type<Archive> >
,//else
BOOST_DEDUCED_TYPENAME mpl::eval_if<is_enum<T>,
BOOST_DEDUCED_TYPENAME mpl::eval_if<is_enum< T >,
mpl::identity<detail::load_enum_type<Archive> >
,//else
mpl::identity<detail::load_non_pointer_type<Archive> >
@ -613,7 +619,7 @@ inline void load_wrapper(Archive &ar, const T&t, mpl::true_){
#if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x560))
template<class Archive, class T>
inline void load(Archive &ar, const T&t){
load_wrapper(ar,t,serialization::is_wrapper<T>());
load_wrapper(ar,t,serialization::is_wrapper< T >());
}
#endif
#endif

56
3party/boost/boost/archive/detail/oserializer.hpp
View file

@ -107,7 +107,7 @@ public:
basic_oserializer(
boost::serialization::singleton<
BOOST_DEDUCED_TYPENAME
boost::serialization::type_info_implementation<T>::type
boost::serialization::type_info_implementation< T >::type
>::get_const_instance()
)
{}
@ -116,19 +116,19 @@ public:
const void *x
) const BOOST_USED;
virtual bool class_info() const {
return boost::serialization::implementation_level<T>::value
return boost::serialization::implementation_level< T >::value
>= boost::serialization::object_class_info;
}
virtual bool tracking(const unsigned int /* flags */) const {
return boost::serialization::tracking_level<T>::value == boost::serialization::track_always
|| (boost::serialization::tracking_level<T>::value == boost::serialization::track_selectively
return boost::serialization::tracking_level< T >::value == boost::serialization::track_always
|| (boost::serialization::tracking_level< T >::value == boost::serialization::track_selectively
&& serialized_as_pointer());
}
virtual version_type version() const {
return version_type(::boost::serialization::version<T>::value);
return version_type(::boost::serialization::version< T >::value);
}
virtual bool is_polymorphic() const {
return boost::is_polymorphic<T>::value;
return boost::is_polymorphic< T >::value;
}
virtual ~oserializer(){}
};
@ -144,7 +144,7 @@ BOOST_DLLEXPORT void oserializer<Archive, T>::save_object_data(
) const {
// make sure call is routed through the highest interface that might
// be specialized by the user.
BOOST_STATIC_ASSERT(boost::is_const<T>::value == false);
BOOST_STATIC_ASSERT(boost::is_const< T >::value == false);
boost::serialization::serialize_adl(
boost::serialization::smart_cast_reference<Archive &>(ar),
* static_cast<T *>(const_cast<void *>(x)),
@ -190,7 +190,7 @@ BOOST_DLLEXPORT void pointer_oserializer<Archive, T>::save_object_ptr(
// make sure call is routed through the highest interface that might
// be specialized by the user.
T * t = static_cast<T *>(const_cast<void *>(x));
const unsigned int file_version = boost::serialization::version<T>::value;
const unsigned int file_version = boost::serialization::version< T >::value;
Archive & ar_impl
= boost::serialization::smart_cast_reference<Archive &>(ar);
boost::serialization::save_construct_data_adl<Archive, T>(
@ -206,7 +206,7 @@ pointer_oserializer<Archive, T>::pointer_oserializer() :
basic_pointer_oserializer(
boost::serialization::singleton<
BOOST_DEDUCED_TYPENAME
boost::serialization::type_info_implementation<T>::type
boost::serialization::type_info_implementation< T >::type
>::get_const_instance()
)
{
@ -241,7 +241,7 @@ struct save_non_pointer_type {
boost::serialization::serialize_adl(
ar,
const_cast<T &>(t),
::boost::serialization::version<T>::value
::boost::serialization::version< T >::value
);
}
};
@ -278,7 +278,7 @@ struct save_non_pointer_type {
BOOST_DEDUCED_TYPENAME mpl::eval_if<
// if its primitive
mpl::equal_to<
boost::serialization::implementation_level<T>,
boost::serialization::implementation_level< T >,
mpl::int_<boost::serialization::primitive_type>
>,
mpl::identity<save_primitive>,
@ -286,7 +286,7 @@ struct save_non_pointer_type {
BOOST_DEDUCED_TYPENAME mpl::eval_if<
// class info / version
mpl::greater_equal<
boost::serialization::implementation_level<T>,
boost::serialization::implementation_level< T >,
mpl::int_<boost::serialization::object_class_info>
>,
// do standard save
@ -295,7 +295,7 @@ struct save_non_pointer_type {
BOOST_DEDUCED_TYPENAME mpl::eval_if<
// no tracking
mpl::equal_to<
boost::serialization::tracking_level<T>,
boost::serialization::tracking_level< T >,
mpl::int_<boost::serialization::track_never>
>,
// do a fast save
@ -304,13 +304,13 @@ struct save_non_pointer_type {
// do a fast save only tracking is turned off
mpl::identity<save_conditional>
> > >::type typex;
check_object_versioning<T>();
check_object_versioning< T >();
typex::invoke(ar, t);
}
template<class T>
static void invoke(Archive & ar, T & t){
check_object_level<T>();
check_object_tracking<T>();
check_object_level< T >();
check_object_tracking< T >();
invoke(ar, const_cast<const T &>(t));
}
};
@ -322,7 +322,7 @@ struct save_pointer_type {
template<class T>
static const basic_pointer_oserializer * register_type(Archive & /* ar */){
// it has? to be polymorphic
BOOST_STATIC_ASSERT(boost::is_polymorphic<T>::value);
BOOST_STATIC_ASSERT(boost::is_polymorphic< T >::value);
return NULL;
}
};
@ -343,11 +343,11 @@ struct save_pointer_type {
// virtual serialize functions used for plug-ins
typedef
BOOST_DEDUCED_TYPENAME mpl::eval_if<
boost::serialization::is_abstract<T>,
boost::serialization::is_abstract< T >,
mpl::identity<abstract>,
mpl::identity<non_abstract>
>::type typex;
return typex::template register_type<T>(ar);
return typex::template register_type< T >(ar);
}
struct non_polymorphic
@ -374,10 +374,10 @@ struct save_pointer_type {
T & t
){
BOOST_DEDUCED_TYPENAME
boost::serialization::type_info_implementation<T>::type const
boost::serialization::type_info_implementation< T >::type const
& i = boost::serialization::singleton<
BOOST_DEDUCED_TYPENAME
boost::serialization::type_info_implementation<T>::type
boost::serialization::type_info_implementation< T >::type
>::get_const_instance();
boost::serialization::extended_type_info const * const this_type = & i;
@ -450,10 +450,10 @@ struct save_pointer_type {
Archive & ar,
const T & t
){
check_pointer_level<T>();
check_pointer_tracking<T>();
check_pointer_level< T >();
check_pointer_tracking< T >();
typedef BOOST_DEDUCED_TYPENAME mpl::eval_if<
is_polymorphic<T>,
is_polymorphic< T >,
mpl::identity<polymorphic>,
mpl::identity<non_polymorphic>
>::type type;
@ -490,7 +490,7 @@ struct save_array_type
{
template<class T>
static void invoke(Archive &ar, const T &t){
typedef BOOST_DEDUCED_TYPENAME boost::remove_extent<T>::type value_type;
typedef BOOST_DEDUCED_TYPENAME boost::remove_extent< T >::type value_type;
save_access::end_preamble(ar);
// consider alignment
@ -509,13 +509,13 @@ struct save_array_type
template<class Archive, class T>
inline void save(Archive & ar, /*const*/ T &t){
typedef
BOOST_DEDUCED_TYPENAME mpl::eval_if<is_pointer<T>,
BOOST_DEDUCED_TYPENAME mpl::eval_if<is_pointer< T >,
mpl::identity<detail::save_pointer_type<Archive> >,
//else
BOOST_DEDUCED_TYPENAME mpl::eval_if<is_enum<T>,
BOOST_DEDUCED_TYPENAME mpl::eval_if<is_enum< T >,
mpl::identity<detail::save_enum_type<Archive> >,
//else
BOOST_DEDUCED_TYPENAME mpl::eval_if<is_array<T>,
BOOST_DEDUCED_TYPENAME mpl::eval_if<is_array< T >,
mpl::identity<detail::save_array_type<Archive> >,
//else
mpl::identity<detail::save_non_pointer_type<Archive> >

8
3party/boost/boost/archive/detail/polymorphic_iarchive_route.hpp
View file

@ -180,13 +180,17 @@ public:
polymorphic_iarchive & operator>>(T & t){
return polymorphic_iarchive::operator>>(t);
}
// the & operator
template<class T>
polymorphic_iarchive & operator&(T & t){
return polymorphic_iarchive::operator&(t);
}
// register type function
template<class T>
const basic_pointer_iserializer *
register_type(T * t = NULL){
return ArchiveImplementation::register_type(t);
}
// all current archives take a stream as constructor argument
template <class _Elem, class _Tr>
polymorphic_iarchive_route(

6
3party/boost/boost/archive/detail/polymorphic_oarchive_route.hpp
View file

@ -175,6 +175,12 @@ public:
polymorphic_oarchive & operator&(T & t){
return polymorphic_oarchive::operator&(t);
}
// register type function
template<class T>
const basic_pointer_oserializer *
register_type(T * t = NULL){
return ArchiveImplementation::register_type(t);
}
// all current archives take a stream as constructor argument
template <class _Elem, class _Tr>
polymorphic_oarchive_route(

10
3party/boost/boost/archive/impl/archive_serializer_map.ipp
View file

@ -26,7 +26,7 @@ namespace detail {
# pragma warning(disable : 4511 4512)
#endif
namespace { // anon
namespace extra_detail { // anon
template<class Archive>
class map : public basic_serializer_map
{};
@ -40,7 +40,7 @@ template<class Archive>
BOOST_ARCHIVE_OR_WARCHIVE_DECL(bool)
archive_serializer_map<Archive>::insert(const basic_serializer * bs){
return boost::serialization::singleton<
map<Archive>
extra_detail::map<Archive>
>::get_mutable_instance().insert(bs);
}
@ -48,11 +48,11 @@ template<class Archive>
BOOST_ARCHIVE_OR_WARCHIVE_DECL(void)
archive_serializer_map<Archive>::erase(const basic_serializer * bs){
if(boost::serialization::singleton<
map<Archive>
extra_detail::map<Archive>
>::is_destroyed())
return;
boost::serialization::singleton<
map<Archive>
extra_detail::map<Archive>
>::get_mutable_instance().erase(bs);
}
@ -62,7 +62,7 @@ archive_serializer_map<Archive>::find(
const boost::serialization::extended_type_info & eti
) {
return boost::serialization::singleton<
map<Archive>
extra_detail::map<Archive>
>::get_const_instance().find(eti);
}

34
3party/boost/boost/archive/impl/basic_binary_iarchive.ipp
View file

@ -22,6 +22,7 @@ namespace std{
#endif
#include <boost/detail/workaround.hpp>
#include <boost/detail/endian.hpp>
#include <boost/archive/basic_binary_iarchive.hpp>
@ -76,7 +77,38 @@ basic_binary_iarchive<Archive>::init(){
// make sure the version of the reading archive library can
// support the format of the archive being read
library_version_type input_library_version;
* this->This() >> input_library_version;
//* this->This() >> input_library_version;
{
int v = 0;
v = this->This()->m_sb.sbumpc();
#if defined(BOOST_LITTLE_ENDIAN)
if(v < 6){
;
}
else
if(v < 7){
// version 6 - next byte should be zero
this->This()->m_sb.sbumpc();
}
else
if(v < 8){
int x1;
// version 7 = might be followed by zero or some other byte
x1 = this->This()->m_sb.sgetc();
// it's =a zero, push it back
if(0 == x1)
this->This()->m_sb.sbumpc();
}
else{
// version 8+ followed by a zero
this->This()->m_sb.sbumpc();
}
#elif defined(BOOST_BIG_ENDIAN)
if(v == 0)
v = this->This()->m_sb.sbumpc();
#endif
input_library_version = static_cast<library_version_type>(v);
}
#if BOOST_WORKAROUND(__MWERKS__, BOOST_TESTED_AT(0x3205))
this->set_library_version(input_library_version);

2
3party/boost/boost/archive/iterators/base64_from_binary.hpp
View file

@ -91,7 +91,7 @@ public:
template<class T>
base64_from_binary(BOOST_PFTO_WRAPPER(T) start) :
super_t(
Base(BOOST_MAKE_PFTO_WRAPPER(static_cast<T>(start))),
Base(BOOST_MAKE_PFTO_WRAPPER(static_cast< T >(start))),
detail::from_6_bit<CharType>()
)
{}

2
3party/boost/boost/archive/iterators/binary_from_base64.hpp
View file

@ -99,7 +99,7 @@ public:
template<class T>
binary_from_base64(BOOST_PFTO_WRAPPER(T) start) :
super_t(
Base(BOOST_MAKE_PFTO_WRAPPER(static_cast<T>(start))),
Base(BOOST_MAKE_PFTO_WRAPPER(static_cast< T >(start))),
detail::to_6_bit<CharType>()
)
{}

2
3party/boost/boost/archive/iterators/insert_linebreaks.hpp
View file

@ -84,7 +84,7 @@ public:
// make composible buy using templated constructor
template<class T>
insert_linebreaks(BOOST_PFTO_WRAPPER(T) start) :
super_t(Base(BOOST_MAKE_PFTO_WRAPPER(static_cast<T>(start)))),
super_t(Base(BOOST_MAKE_PFTO_WRAPPER(static_cast< T >(start)))),
m_count(0)
{}
// intel 7.1 doesn't like default copy constructor

2
3party/boost/boost/archive/iterators/mb_from_wchar.hpp
View file

@ -115,7 +115,7 @@ public:
// make composible buy using templated constructor
template<class T>
mb_from_wchar(BOOST_PFTO_WRAPPER(T) start) :
super_t(Base(BOOST_MAKE_PFTO_WRAPPER(static_cast<T>(start)))),
super_t(Base(BOOST_MAKE_PFTO_WRAPPER(static_cast< T >(start)))),
m_bend(0),
m_bnext(0),
m_full(false)

2
3party/boost/boost/archive/iterators/remove_whitespace.hpp
View file

@ -154,7 +154,7 @@ public:
// make composible buy using templated constructor
template<class T>
remove_whitespace(BOOST_PFTO_WRAPPER(T) start) :
super_t(Base(BOOST_MAKE_PFTO_WRAPPER(static_cast<T>(start))))
super_t(Base(BOOST_MAKE_PFTO_WRAPPER(static_cast< T >(start))))
{}
// intel 7.1 doesn't like default copy constructor
remove_whitespace(const remove_whitespace & rhs) :

2
3party/boost/boost/archive/iterators/transform_width.hpp
View file

@ -113,7 +113,7 @@ public:
// make composible buy using templated constructor
template<class T>
transform_width(BOOST_PFTO_WRAPPER(T) start) :
super_t(Base(BOOST_MAKE_PFTO_WRAPPER(static_cast<T>(start)))),
super_t(Base(BOOST_MAKE_PFTO_WRAPPER(static_cast< T >(start)))),
m_displacement(0),
m_full(false),
m_bufferfull(false)

2
3party/boost/boost/archive/iterators/wchar_from_mb.hpp
View file

@ -90,7 +90,7 @@ public:
// make composible buy using templated constructor
template<class T>
wchar_from_mb(BOOST_PFTO_WRAPPER(T) start) :
super_t(Base(BOOST_MAKE_PFTO_WRAPPER(static_cast<T>(start)))),
super_t(Base(BOOST_MAKE_PFTO_WRAPPER(static_cast< T >(start)))),
m_full(false)
{}
// intel 7.1 doesn't like default copy constructor

2
3party/boost/boost/archive/iterators/xml_escape.hpp
View file

@ -44,7 +44,7 @@ public:
template<class T>
xml_escape(BOOST_PFTO_WRAPPER(T) start) :
super_t(Base(BOOST_MAKE_PFTO_WRAPPER(static_cast<T>(start))))
super_t(Base(BOOST_MAKE_PFTO_WRAPPER(static_cast< T >(start))))
{}
// intel 7.1 doesn't like default copy constructor
xml_escape(const xml_escape & rhs) :

2
3party/boost/boost/archive/iterators/xml_unescape.hpp
View file

@ -57,7 +57,7 @@ public:
template<class T>
xml_unescape(BOOST_PFTO_WRAPPER(T) start) :
super_t(Base(BOOST_MAKE_PFTO_WRAPPER(static_cast<T>(start))))
super_t(Base(BOOST_MAKE_PFTO_WRAPPER(static_cast< T >(start))))
{}
// intel 7.1 doesn't like default copy constructor
xml_unescape(const xml_unescape & rhs) :

2
3party/boost/boost/archive/polymorphic_iarchive.hpp
View file

@ -114,7 +114,7 @@ public:
#ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING
const
#endif
boost::serialization::nvp<T> & t,
boost::serialization::nvp< T > & t,
int
){
load_start(t.name());

2
3party/boost/boost/archive/polymorphic_oarchive.hpp
View file

@ -116,7 +116,7 @@ public:
#ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING
const
#endif
::boost::serialization::nvp<T> & t, int
::boost::serialization::nvp< T > & t, int
){
save_start(t.name());
archive::save(* this->This(), t.const_value());

20
3party/boost/boost/archive/shared_ptr_helper.hpp
View file

@ -44,7 +44,7 @@ namespace boost {
template<class Archive, class T>
inline void load(
Archive & ar,
boost::shared_ptr<T> &t,
boost::shared_ptr< T > &t,
const unsigned int file_version
);
}
@ -95,7 +95,7 @@ public:
template<class Archive, class T>
friend inline void boost::serialization::load(
Archive & ar,
boost::shared_ptr<T> &t,
boost::shared_ptr< T > &t,
const unsigned int file_version
);
#endif
@ -130,7 +130,7 @@ public:
get_object_identifier(T & t){
return & boost::serialization::singleton<
BOOST_DEDUCED_TYPENAME
boost::serialization::type_info_implementation<T>::type
boost::serialization::type_info_implementation< T >::type
>::get_const_instance();
}
};
@ -140,27 +140,27 @@ public:
get_object_identifier(T & t){
return boost::serialization::singleton<
BOOST_DEDUCED_TYPENAME
boost::serialization::type_info_implementation<T>::type
boost::serialization::type_info_implementation< T >::type
>::get_const_instance().get_derived_extended_type_info(t);
}
};
public:
template<class T>
void reset(shared_ptr<T> & s, T * t){
void reset(shared_ptr< T > & s, T * t){
if(NULL == t){
s.reset();
return;
}
const boost::serialization::extended_type_info * this_type
= & boost::serialization::type_info_implementation<T>::type
= & boost::serialization::type_info_implementation< T >::type
::get_const_instance();
// get pointer to the most derived object. This is effectively
// the object identifern
typedef BOOST_DEDUCED_TYPENAME mpl::eval_if<
is_polymorphic<T>,
mpl::identity<polymorphic<T> >,
mpl::identity<non_polymorphic<T> >
is_polymorphic< T >,
mpl::identity<polymorphic< T > >,
mpl::identity<non_polymorphic< T > >
>::type type;
const boost::serialization::extended_type_info * true_type
@ -192,7 +192,7 @@ public:
append(sp);
}
else{
s = shared_ptr<T>(
s = shared_ptr< T >(
r,
static_cast<T *>(r.get())
);

5
3party/boost/boost/archive/xml_archive_exception.hpp
View file

@ -19,9 +19,10 @@
#include <exception>
#include <cassert>
#include <boost/archive/archive_exception.hpp>
#include <boost/config.hpp>
#include <boost/preprocessor/empty.hpp>
#include <boost/archive/detail/decl.hpp>
#include <boost/archive/archive_exception.hpp>
#include <boost/archive/detail/abi_prefix.hpp> // must be the last header
@ -32,7 +33,7 @@ namespace archive {
// exceptions thrown by xml archives
//
class BOOST_ARCHIVE_DECL(BOOST_PP_EMPTY()) xml_archive_exception :
public virtual archive_exception
public virtual boost::archive::archive_exception
{
public:
typedef enum {

4
3party/boost/boost/asio/detail/buffer_sequence_adapter.hpp
View file

@ -161,7 +161,7 @@ public:
explicit buffer_sequence_adapter(
const boost::asio::mutable_buffers_1& buffers)
{
init_native_buffer(buffer_, buffers);
init_native_buffer(buffer_, Buffer(buffers));
total_buffer_size_ = boost::asio::buffer_size(buffers);
}
@ -208,7 +208,7 @@ public:
explicit buffer_sequence_adapter(
const boost::asio::const_buffers_1& buffers)
{
init_native_buffer(buffer_, buffers);
init_native_buffer(buffer_, Buffer(buffers));
total_buffer_size_ = boost::asio::buffer_size(buffers);
}

2
3party/boost/boost/asio/detail/impl/kqueue_reactor.hpp
View file

@ -55,7 +55,7 @@ void kqueue_reactor::schedule_timer(timer_queue<Time_Traits>& queue,
bool earliest = queue.enqueue_timer(time, timer, op);
io_service_.work_started();
if (earliest)
interrupter_.interrupt();
interrupt();
}
template <typename Time_Traits>

35
3party/boost/boost/asio/detail/impl/kqueue_reactor.ipp
View file

@ -26,6 +26,15 @@
#include <boost/asio/detail/push_options.hpp>
#if defined(__NetBSD__)
# define BOOST_ASIO_KQUEUE_EV_SET(ev, ident, filt, flags, fflags, data, udata) \
EV_SET(ev, ident, filt, flags, fflags, \
data, reinterpret_cast<intptr_t>(udata))
#else
# define BOOST_ASIO_KQUEUE_EV_SET(ev, ident, filt, flags, fflags, data, udata) \
EV_SET(ev, ident, filt, flags, fflags, data, udata)
#endif
namespace boost {
namespace asio {
namespace detail {
@ -73,7 +82,7 @@ void kqueue_reactor::init_task()
io_service_.init_task();
}
int kqueue_reactor::register_descriptor(socket_type descriptor,
int kqueue_reactor::register_descriptor(socket_type,
kqueue_reactor::per_descriptor_data& descriptor_data)
{
mutex::scoped_lock lock(registered_descriptors_mutex_);
@ -129,17 +138,17 @@ void kqueue_reactor::start_op(int op_type, socket_type descriptor,
switch (op_type)
{
case read_op:
EV_SET(&event, descriptor, EVFILT_READ,
BOOST_ASIO_KQUEUE_EV_SET(&event, descriptor, EVFILT_READ,
EV_ADD | EV_ONESHOT, 0, 0, descriptor_data);
break;
case write_op:
EV_SET(&event, descriptor, EVFILT_WRITE,
BOOST_ASIO_KQUEUE_EV_SET(&event, descriptor, EVFILT_WRITE,
EV_ADD | EV_ONESHOT, 0, 0, descriptor_data);
break;
case except_op:
if (!descriptor_data->op_queue_[read_op].empty())
return; // Already registered for read events.
EV_SET(&event, descriptor, EVFILT_READ,
BOOST_ASIO_KQUEUE_EV_SET(&event, descriptor, EVFILT_READ,
EV_ADD | EV_ONESHOT, EV_OOBAND, 0, descriptor_data);
break;
}
@ -178,7 +187,7 @@ void kqueue_reactor::cancel_ops(socket_type,
io_service_.post_deferred_completions(ops);
}
void kqueue_reactor::close_descriptor(socket_type descriptor,
void kqueue_reactor::close_descriptor(socket_type,
kqueue_reactor::per_descriptor_data& descriptor_data)
{
if (!descriptor_data)
@ -234,7 +243,7 @@ void kqueue_reactor::run(bool block, op_queue<operation>& ops)
for (int i = 0; i < num_events; ++i)
{
int descriptor = events[i].ident;
void* ptr = events[i].udata;
void* ptr = reinterpret_cast<void*>(events[i].udata);
if (ptr == &interrupter_)
{
// No need to reset the interrupter since we're leaving the descriptor
@ -247,7 +256,11 @@ void kqueue_reactor::run(bool block, op_queue<operation>& ops)
// Exception operations must be processed first to ensure that any
// out-of-band data is read before normal data.
#if defined(__NetBSD__)
static const unsigned int filter[max_ops] =
#else
static const int filter[max_ops] =
#endif
{ EVFILT_READ, EVFILT_WRITE, EVFILT_READ };
for (int j = max_ops - 1; j >= 0; --j)
{
@ -282,16 +295,16 @@ void kqueue_reactor::run(bool block, op_queue<operation>& ops)
{
case EVFILT_READ:
if (!descriptor_data->op_queue_[read_op].empty())
EV_SET(&event, descriptor, EVFILT_READ,
BOOST_ASIO_KQUEUE_EV_SET(&event, descriptor, EVFILT_READ,
EV_ADD | EV_ONESHOT, 0, 0, descriptor_data);
else if (!descriptor_data->op_queue_[except_op].empty())
EV_SET(&event, descriptor, EVFILT_READ,
BOOST_ASIO_KQUEUE_EV_SET(&event, descriptor, EVFILT_READ,
EV_ADD | EV_ONESHOT, EV_OOBAND, 0, descriptor_data);
else
continue;
case EVFILT_WRITE:
if (!descriptor_data->op_queue_[write_op].empty())
EV_SET(&event, descriptor, EVFILT_WRITE,
BOOST_ASIO_KQUEUE_EV_SET(&event, descriptor, EVFILT_WRITE,
EV_ADD | EV_ONESHOT, 0, 0, descriptor_data);
else
continue;
@ -322,7 +335,7 @@ void kqueue_reactor::run(bool block, op_queue<operation>& ops)
void kqueue_reactor::interrupt()
{
struct kevent event;
EV_SET(&event, interrupter_.read_descriptor(),
BOOST_ASIO_KQUEUE_EV_SET(&event, interrupter_.read_descriptor(),
EVFILT_READ, EV_ADD | EV_ONESHOT, 0, 0, &interrupter_);
::kevent(kqueue_fd_, &event, 1, 0, 0, 0);
}
@ -365,6 +378,8 @@ timespec* kqueue_reactor::get_timeout(timespec& ts)
} // namespace asio
} // namespace boost
#undef BOOST_ASIO_KQUEUE_EV_SET
#include <boost/asio/detail/pop_options.hpp>
#endif // defined(BOOST_ASIO_HAS_KQUEUE)

27
3party/boost/boost/asio/detail/impl/socket_ops.ipp
View file

@ -119,7 +119,7 @@ socket_type sync_accept(socket_type s, state_type state,
socket_type new_socket = socket_ops::accept(s, addr, addrlen, ec);
// Check if operation succeeded.
if (new_socket >= 0)
if (new_socket != invalid_socket)
return new_socket;
// Operation failed.
@ -210,7 +210,7 @@ bool non_blocking_accept(socket_type s,
new_socket = socket_ops::accept(s, addr, addrlen, ec);
// Check if operation succeeded.
if (new_socket >= 0)
if (new_socket != invalid_socket)
return true;
// Retry operation if interrupted by signal.
@ -312,14 +312,14 @@ int close(socket_type s, state_type& state,
clear_last_error();
#if defined(BOOST_WINDOWS) || defined(__CYGWIN__)
int result = error_wrapper(::closesocket(s), ec);
result = error_wrapper(::closesocket(s), ec);
#else // defined(BOOST_WINDOWS) || defined(__CYGWIN__)
int result = error_wrapper(::close(s), ec);
result = error_wrapper(::close(s), ec);
#endif // defined(BOOST_WINDOWS) || defined(__CYGWIN__)
if (result == 0)
ec = boost::system::error_code();
}
if (result == 0)
ec = boost::system::error_code();
return result;
}
@ -1414,7 +1414,7 @@ int getsockname(socket_type s, socket_addr_type* addr,
return result;
}
int ioctl(socket_type s, state_type& state, long cmd,
int ioctl(socket_type s, state_type& state, int cmd,
ioctl_arg_type* arg, boost::system::error_code& ec)
{
if (s == invalid_socket)
@ -1426,9 +1426,13 @@ int ioctl(socket_type s, state_type& state, long cmd,
clear_last_error();
#if defined(BOOST_WINDOWS) || defined(__CYGWIN__)
int result = error_wrapper(::ioctlsocket(s, cmd, arg), ec);
#else // defined(BOOST_WINDOWS) || defined(__CYGWIN__)
#elif defined(__MACH__) && defined(__APPLE__) \
|| defined(__NetBSD__) || defined(__FreeBSD__) || defined(__OpenBSD__)
int result = error_wrapper(::ioctl(s,
static_cast<unsigned int>(cmd), arg), ec);
#else
int result = error_wrapper(::ioctl(s, cmd, arg), ec);
#endif // defined(BOOST_WINDOWS) || defined(__CYGWIN__)
#endif
if (result >= 0)
{
ec = boost::system::error_code();
@ -1438,7 +1442,7 @@ int ioctl(socket_type s, state_type& state, long cmd,
// the correct state. This ensures that the underlying socket is put into
// the state that has been requested by the user. If the ioctl syscall was
// successful then we need to update the flags to match.
if (cmd == static_cast<long>(FIONBIO))
if (cmd == static_cast<int>(FIONBIO))
{
if (*arg)
{
@ -1483,7 +1487,7 @@ int select(int nfds, fd_set* readfds, fd_set* writefds,
timeout->tv_usec = 1000;
#endif // defined(BOOST_WINDOWS) || defined(__CYGWIN__)
#if defined(__hpux) && defined(__HP_aCC)
#if defined(__hpux) && defined(__SELECT)
timespec ts;
ts.tv_sec = timeout ? timeout->tv_sec : 0;
ts.tv_nsec = timeout ? timeout->tv_usec * 1000 : 0;
@ -2669,6 +2673,7 @@ boost::system::error_code getaddrinfo(const char* host,
addrinfo_type** result, boost::system::error_code& ec)
{
host = (host && *host) ? host : 0;
service = (service && *service) ? service : 0;
clear_last_error();
#if defined(BOOST_WINDOWS) || defined(__CYGWIN__)
# if defined(_WIN32_WINNT) && (_WIN32_WINNT >= 0x0501) || defined(UNDER_CE)

6
3party/boost/boost/asio/detail/impl/win_iocp_io_service.ipp
View file

@ -447,6 +447,12 @@ void win_iocp_io_service::do_add_timer_queue(timer_queue_base& queue)
boost::asio::error::get_system_category());
boost::asio::detail::throw_error(ec, "timer");
}
LARGE_INTEGER timeout;
timeout.QuadPart = -max_timeout_usec;
timeout.QuadPart *= 10;
::SetWaitableTimer(waitable_timer_.handle,
&timeout, max_timeout_msec, 0, 0, FALSE);
}
if (!timer_thread_)

6
3party/boost/boost/asio/detail/impl/win_mutex.ipp
View file

@ -45,7 +45,8 @@ int win_mutex::do_init()
# if defined(UNDER_CE)
::InitializeCriticalSection(&crit_section_);
# else
::InitializeCriticalSectionAndSpinCount(&crit_section_, 0x80000000);
if (!::InitializeCriticalSectionAndSpinCount(&crit_section_, 0x80000000))
return ::GetLastError();
# endif
return 0;
#else
@ -54,7 +55,8 @@ int win_mutex::do_init()
# if defined(UNDER_CE)
::InitializeCriticalSection(&crit_section_);
# else
::InitializeCriticalSectionAndSpinCount(&crit_section_, 0x80000000);
if (!::InitializeCriticalSectionAndSpinCount(&crit_section_, 0x80000000))
return ::GetLastError();
# endif
}
__except(GetExceptionCode() == STATUS_NO_MEMORY

2
3party/boost/boost/asio/detail/null_thread.hpp
View file

@ -35,7 +35,7 @@ class null_thread
public:
// Constructor.
template <typename Function>
null_thread(Function)
null_thread(Function, unsigned int = 0)
{
boost::asio::detail::throw_error(
boost::asio::error::operation_not_supported, "thread");

10
3party/boost/boost/asio/detail/pop_options.hpp
View file

@ -31,6 +31,16 @@
# pragma pack (pop)
# endif
# if defined(__OBJC__)
# if !defined(__APPLE_CC__) || (__APPLE_CC__ <= 1)
# if defined(BOOST_ASIO_OBJC_WORKAROUND)
# undef Protocol
# undef id
# undef BOOST_ASIO_OBJC_WORKAROUND
# endif
# endif
# endif
#elif defined(__KCC)
// Kai C++

12
3party/boost/boost/asio/detail/push_options.hpp
View file

@ -31,6 +31,18 @@
# pragma pack (push, 8)
# endif
# if defined(__OBJC__)
# if !defined(__APPLE_CC__) || (__APPLE_CC__ <= 1)
# if !defined(BOOST_ASIO_DISABLE_OBJC_WORKAROUND)
# if !defined(Protocol) && !defined(id)
# define Protocol cpp_Protocol
# define id cpp_id
# define BOOST_ASIO_OBJC_WORKAROUND
# endif
# endif
# endif
# endif
#elif defined(__KCC)
// Kai C++

2
3party/boost/boost/asio/detail/reactive_socket_service.hpp
View file

@ -326,7 +326,7 @@ public:
peer_endpoint ? &addr_len : 0, ec));
// On success, assign new connection to peer socket object.
if (new_socket.get() >= 0)
if (new_socket.get() != invalid_socket)
{
if (peer_endpoint)
peer_endpoint->resize(addr_len);

5
3party/boost/boost/asio/detail/service_registry.hpp
View file

@ -75,13 +75,14 @@ public:
private:
// Initialise a service's key based on its id.
BOOST_ASIO_DECL void init_key(boost::asio::io_service::service::key& key,
BOOST_ASIO_DECL static void init_key(
boost::asio::io_service::service::key& key,
const boost::asio::io_service::id& id);
#if !defined(BOOST_ASIO_NO_TYPEID)
// Initialise a service's key based on its id.
template <typename Service>
void init_key(boost::asio::io_service::service::key& key,
static void init_key(boost::asio::io_service::service::key& key,
const boost::asio::detail::service_id<Service>& /*id*/);
#endif // !defined(BOOST_ASIO_NO_TYPEID)

2
3party/boost/boost/asio/detail/socket_ops.hpp
View file

@ -222,7 +222,7 @@ BOOST_ASIO_DECL int getsockname(socket_type s, socket_addr_type* addr,
std::size_t* addrlen, boost::system::error_code& ec);
BOOST_ASIO_DECL int ioctl(socket_type s, state_type& state,
long cmd, ioctl_arg_type* arg, boost::system::error_code& ec);
int cmd, ioctl_arg_type* arg, boost::system::error_code& ec);
BOOST_ASIO_DECL int select(int nfds, fd_set* readfds, fd_set* writefds,
fd_set* exceptfds, timeval* timeout, boost::system::error_code& ec);

5
3party/boost/boost/asio/detail/socket_types.hpp
View file

@ -52,9 +52,10 @@
# include <sys/types.h>
# include <sys/stat.h>
# include <fcntl.h>
# if defined(__hpux) && !defined(__HP_aCC)
# if defined(__hpux)
# include <sys/time.h>
# else
# endif
# if !defined(__hpux) || defined(__SELECT)
# include <sys/select.h>
# endif
# include <sys/socket.h>

41
3party/boost/boost/asio/detail/timer_queue.hpp
View file

@ -79,36 +79,37 @@ public:
// function call may need to be interrupted and restarted.
bool enqueue_timer(const time_type& time, per_timer_data& timer, timer_op* op)
{
// Ensure that there is space for the timer in the heap. We reserve here so
// that the push_back below will not throw due to a reallocation failure.
heap_.reserve(heap_.size() + 1);
timer.op_queue_.push(op);
// Enqueue the timer object.
if (timer.prev_ == 0 && &timer != timers_)
{
if (this->is_positive_infinity(time))
{
// No heap entry is required for timers that never expire.
timer.heap_index_ = (std::numeric_limits<std::size_t>::max)();
}
else
{
// Put the new timer at the correct position in the heap. This is done
// first since push_back() can throw due to allocation failure.
timer.heap_index_ = heap_.size();
heap_entry entry = { time, &timer };
heap_.push_back(entry);
up_heap(heap_.size() - 1);
}
// Insert the new timer into the linked list of active timers.
timer.next_ = timers_;
timer.prev_ = 0;
if (timers_)
timers_->prev_ = &timer;
timers_ = &timer;
// Put the new timer at the correct position in the heap.
if (this->is_positive_infinity(time))
{
timer.heap_index_ = (std::numeric_limits<std::size_t>::max)();
return false; // No need to interrupt reactor as timer never expires.
}
else
{
timer.heap_index_ = heap_.size();
heap_entry entry = { time, &timer };
heap_.push_back(entry);
up_heap(heap_.size() - 1);
}
}
return (heap_[0].timer_ == &timer);
// Enqueue the individual timer operation.
timer.op_queue_.push(op);
// Interrupt reactor only if newly added timer is first to expire.
return timer.heap_index_ == 0 && timer.op_queue_.front() == op;
}
// Whether there are no timers in the queue.

4
3party/boost/boost/asio/error.hpp
View file

@ -19,7 +19,7 @@
#include <boost/cerrno.hpp>
#include <boost/system/error_code.hpp>
#if defined(BOOST_WINDOWS) || defined(__CYGWIN__)
# include <WinError.h>
# include <winerror.h>
#else
# include <cerrno>
# include <netdb.h>
@ -217,7 +217,7 @@ enum ssl_errors
inline const boost::system::error_category& get_system_category()
{
return boost::system::get_system_category();
return boost::system::system_category();
}
#if !defined(BOOST_WINDOWS) && !defined(__CYGWIN__)

6
3party/boost/boost/asio/impl/read.hpp
View file

@ -160,7 +160,7 @@ namespace detail
break;
}
handler_(ec, static_cast<const std::size_t>(total_transferred_));
handler_(ec, static_cast<const std::size_t&>(total_transferred_));
}
}
@ -212,7 +212,7 @@ namespace detail
break;
}
handler_(ec, static_cast<const std::size_t>(total_transferred_));
handler_(ec, static_cast<const std::size_t&>(total_transferred_));
}
}
@ -317,7 +317,7 @@ namespace detail
break;
}
handler_(ec, static_cast<const std::size_t>(total_transferred_));
handler_(ec, static_cast<const std::size_t&>(total_transferred_));
}
}

6
3party/boost/boost/asio/impl/read_at.hpp
View file

@ -173,7 +173,7 @@ namespace detail
break;
}
handler_(ec, static_cast<const std::size_t>(total_transferred_));
handler_(ec, static_cast<const std::size_t&>(total_transferred_));
}
}
@ -226,7 +226,7 @@ namespace detail
break;
}
handler_(ec, static_cast<const std::size_t>(total_transferred_));
handler_(ec, static_cast<const std::size_t&>(total_transferred_));
}
}
@ -338,7 +338,7 @@ namespace detail
break;
}
handler_(ec, static_cast<const std::size_t>(total_transferred_));
handler_(ec, static_cast<const std::size_t&>(total_transferred_));
}
}

44
3party/boost/boost/asio/impl/read_until.hpp
View file

@ -392,8 +392,15 @@ namespace detail
break;
}
handler_(search_position_ == not_found ? error::not_found : ec,
ec || search_position_ == not_found ? 0 : search_position_);
const boost::system::error_code result_ec =
(search_position_ == not_found)
? error::not_found : ec;
const std::size_t result_n =
(ec || search_position_ == not_found)
? 0 : search_position_;
handler_(result_ec, result_n);
}
}
@ -529,8 +536,15 @@ namespace detail
break;
}
handler_(search_position_ == not_found ? error::not_found : ec,
ec || search_position_ == not_found ? 0 : search_position_);
const boost::system::error_code result_ec =
(search_position_ == not_found)
? error::not_found : ec;
const std::size_t result_n =
(ec || search_position_ == not_found)
? 0 : search_position_;
handler_(result_ec, result_n);
}
}
@ -671,8 +685,15 @@ namespace detail
break;
}
handler_(search_position_ == not_found ? error::not_found : ec,
ec || search_position_ == not_found ? 0 : search_position_);
const boost::system::error_code result_ec =
(search_position_ == not_found)
? error::not_found : ec;
const std::size_t result_n =
(ec || search_position_ == not_found)
? 0 : search_position_;
handler_(result_ec, result_n);
}
}
@ -811,8 +832,15 @@ namespace detail
break;
}
handler_(search_position_ == not_found ? error::not_found : ec,
ec || search_position_ == not_found ? 0 : search_position_);
const boost::system::error_code result_ec =
(search_position_ == not_found)
? error::not_found : ec;
const std::size_t result_n =
(ec || search_position_ == not_found)
? 0 : search_position_;
handler_(result_ec, result_n);
}
}

13
3party/boost/boost/asio/impl/serial_port_base.ipp
View file

@ -253,12 +253,16 @@ boost::system::error_code serial_port_base::flow_control::store(
storage.c_iflag &= ~(IXOFF | IXON);
# if defined(_BSD_SOURCE)
storage.c_cflag &= ~CRTSCTS;
# elif defined(__QNXNTO__)
storage.c_cflag &= ~(IHFLOW | OHFLOW);
# endif
break;
case software:
storage.c_iflag |= IXOFF | IXON;
# if defined(_BSD_SOURCE)
storage.c_cflag &= ~CRTSCTS;
# elif defined(__QNXNTO__)
storage.c_cflag &= ~(IHFLOW | OHFLOW);
# endif
break;
case hardware:
@ -266,6 +270,10 @@ boost::system::error_code serial_port_base::flow_control::store(
storage.c_iflag &= ~(IXOFF | IXON);
storage.c_cflag |= CRTSCTS;
break;
# elif defined(__QNXNTO__)
storage.c_iflag &= ~(IXOFF | IXON);
storage.c_cflag |= (IHFLOW | OHFLOW);
break;
# else
ec = boost::asio::error::operation_not_supported;
return ec;
@ -304,6 +312,11 @@ boost::system::error_code serial_port_base::flow_control::load(
{
value_ = hardware;
}
# elif defined(__QNXNTO__)
else if (storage.c_cflag & IHFLOW && storage.c_cflag & OHFLOW)
{
value_ = hardware;
}
# endif
else
{

60
3party/boost/boost/asio/impl/src.cpp
View file

@ -8,52 +8,18 @@
// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
//
#define BOOST_ASIO_SOURCE
#include <boost/asio/detail/config.hpp>
#if defined(BOOST_ASIO_HEADER_ONLY)
# error Do not compile Asio library source with BOOST_ASIO_HEADER_ONLY defined
#if defined(_MSC_VER) \
|| defined(__BORLANDC__) \
|| defined(__DMC__)
# pragma message ( \
"This file is deprecated. " \
"Please #include <boost/asio/impl/src.hpp> instead.>)
#elif defined(__GNUC__) \
|| defined(__HP_aCC) \
|| defined(__SUNPRO_CC) \
|| defined(__IBMCPP__)
# warning "This file is deprecated."
# warning "Please #include <boost/asio/impl/src.hpp> instead.>
#endif
#include <boost/asio/impl/error.ipp>
#include <boost/asio/impl/io_service.ipp>
#include <boost/asio/impl/serial_port_base.ipp>
#include <boost/asio/detail/impl/descriptor_ops.ipp>
#include <boost/asio/detail/impl/dev_poll_reactor.ipp>
#include <boost/asio/detail/impl/epoll_reactor.ipp>
#include <boost/asio/detail/impl/eventfd_select_interrupter.ipp>
#include <boost/asio/detail/impl/kqueue_reactor.ipp>
#include <boost/asio/detail/impl/pipe_select_interrupter.ipp>
#include <boost/asio/detail/impl/posix_event.ipp>
#include <boost/asio/detail/impl/posix_mutex.ipp>
#include <boost/asio/detail/impl/posix_thread.ipp>
#include <boost/asio/detail/impl/posix_tss_ptr.ipp>
#include <boost/asio/detail/impl/reactive_descriptor_service.ipp>
#include <boost/asio/detail/impl/reactive_serial_port_service.ipp>
#include <boost/asio/detail/impl/reactive_socket_service_base.ipp>
#include <boost/asio/detail/impl/resolver_service_base.ipp>
#include <boost/asio/detail/impl/select_reactor.ipp>
#include <boost/asio/detail/impl/service_registry.ipp>
#include <boost/asio/detail/impl/socket_ops.ipp>
#include <boost/asio/detail/impl/socket_select_interrupter.ipp>
#include <boost/asio/detail/impl/strand_service.ipp>
#include <boost/asio/detail/impl/task_io_service.ipp>
#include <boost/asio/detail/impl/throw_error.ipp>
#include <boost/asio/detail/impl/timer_queue.ipp>
#include <boost/asio/detail/impl/timer_queue_set.ipp>
#include <boost/asio/detail/impl/win_iocp_handle_service.ipp>
#include <boost/asio/detail/impl/win_iocp_io_service.ipp>
#include <boost/asio/detail/impl/win_iocp_serial_port_service.ipp>
#include <boost/asio/detail/impl/win_iocp_socket_service_base.ipp>
#include <boost/asio/detail/impl/win_event.ipp>
#include <boost/asio/detail/impl/win_mutex.ipp>
#include <boost/asio/detail/impl/win_thread.ipp>
#include <boost/asio/detail/impl/win_tss_ptr.ipp>
#include <boost/asio/detail/impl/winsock_init.ipp>
#include <boost/asio/ip/impl/address.ipp>
#include <boost/asio/ip/impl/address_v4.ipp>
#include <boost/asio/ip/impl/address_v6.ipp>
#include <boost/asio/ip/impl/host_name.ipp>
#include <boost/asio/ip/detail/impl/endpoint.ipp>
#include <boost/asio/local/detail/impl/endpoint.ipp>
#include <boost/asio/impl/src.hpp>

64
3party/boost/boost/asio/impl/src.hpp Normal file
View file

@ -0,0 +1,64 @@
//
// impl/src.hpp
// ~~~~~~~~~~~~
//
// Copyright (c) 2003-2010 Christopher M. Kohlhoff (chris at kohlhoff dot com)
//
// Distributed under the Boost Software License, Version 1.0. (See accompanying
// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
//
#ifndef BOOST_ASIO_IMPL_SRC_HPP
#define BOOST_ASIO_IMPL_SRC_HPP
#define BOOST_ASIO_SOURCE
#include <boost/asio/detail/config.hpp>
#if defined(BOOST_ASIO_HEADER_ONLY)
# error Do not compile Asio library source with BOOST_ASIO_HEADER_ONLY defined
#endif
#include <boost/asio/impl/error.ipp>
#include <boost/asio/impl/io_service.ipp>
#include <boost/asio/impl/serial_port_base.ipp>
#include <boost/asio/detail/impl/descriptor_ops.ipp>
#include <boost/asio/detail/impl/dev_poll_reactor.ipp>
#include <boost/asio/detail/impl/epoll_reactor.ipp>
#include <boost/asio/detail/impl/eventfd_select_interrupter.ipp>
#include <boost/asio/detail/impl/kqueue_reactor.ipp>
#include <boost/asio/detail/impl/pipe_select_interrupter.ipp>
#include <boost/asio/detail/impl/posix_event.ipp>
#include <boost/asio/detail/impl/posix_mutex.ipp>
#include <boost/asio/detail/impl/posix_thread.ipp>
#include <boost/asio/detail/impl/posix_tss_ptr.ipp>
#include <boost/asio/detail/impl/reactive_descriptor_service.ipp>
#include <boost/asio/detail/impl/reactive_serial_port_service.ipp>
#include <boost/asio/detail/impl/reactive_socket_service_base.ipp>
#include <boost/asio/detail/impl/resolver_service_base.ipp>
#include <boost/asio/detail/impl/select_reactor.ipp>
#include <boost/asio/detail/impl/service_registry.ipp>
#include <boost/asio/detail/impl/socket_ops.ipp>
#include <boost/asio/detail/impl/socket_select_interrupter.ipp>
#include <boost/asio/detail/impl/strand_service.ipp>
#include <boost/asio/detail/impl/task_io_service.ipp>
#include <boost/asio/detail/impl/throw_error.ipp>
#include <boost/asio/detail/impl/timer_queue.ipp>
#include <boost/asio/detail/impl/timer_queue_set.ipp>
#include <boost/asio/detail/impl/win_iocp_handle_service.ipp>
#include <boost/asio/detail/impl/win_iocp_io_service.ipp>
#include <boost/asio/detail/impl/win_iocp_serial_port_service.ipp>
#include <boost/asio/detail/impl/win_iocp_socket_service_base.ipp>
#include <boost/asio/detail/impl/win_event.ipp>
#include <boost/asio/detail/impl/win_mutex.ipp>
#include <boost/asio/detail/impl/win_thread.ipp>
#include <boost/asio/detail/impl/win_tss_ptr.ipp>
#include <boost/asio/detail/impl/winsock_init.ipp>
#include <boost/asio/ip/impl/address.ipp>
#include <boost/asio/ip/impl/address_v4.ipp>
#include <boost/asio/ip/impl/address_v6.ipp>
#include <boost/asio/ip/impl/host_name.ipp>
#include <boost/asio/ip/detail/impl/endpoint.ipp>
#include <boost/asio/local/detail/impl/endpoint.ipp>
#endif // BOOST_ASIO_IMPL_SRC_HPP

6
3party/boost/boost/asio/impl/write.hpp
View file

@ -146,7 +146,7 @@ namespace detail
break;
}
handler_(ec, static_cast<const std::size_t>(total_transferred_));
handler_(ec, static_cast<const std::size_t&>(total_transferred_));
}
}
@ -198,7 +198,7 @@ namespace detail
break;
}
handler_(ec, static_cast<const std::size_t>(total_transferred_));
handler_(ec, static_cast<const std::size_t&>(total_transferred_));
}
}
@ -249,7 +249,7 @@ namespace detail
break;
}
handler_(ec, static_cast<const std::size_t>(total_transferred_));
handler_(ec, static_cast<const std::size_t&>(total_transferred_));
}
}

6
3party/boost/boost/asio/impl/write_at.hpp
View file

@ -157,7 +157,7 @@ namespace detail
break;
}
handler_(ec, static_cast<const std::size_t>(total_transferred_));
handler_(ec, static_cast<const std::size_t&>(total_transferred_));
}
}
@ -211,7 +211,7 @@ namespace detail
break;
}
handler_(ec, static_cast<const std::size_t>(total_transferred_));
handler_(ec, static_cast<const std::size_t&>(total_transferred_));
}
}
@ -264,7 +264,7 @@ namespace detail
break;
}
handler_(ec, static_cast<const std::size_t>(total_transferred_));
handler_(ec, static_cast<const std::size_t&>(total_transferred_));
}
}

2
3party/boost/boost/asio/version.hpp
View file

@ -18,6 +18,6 @@
// BOOST_ASIO_VERSION % 100 is the sub-minor version
// BOOST_ASIO_VERSION / 100 % 1000 is the minor version
// BOOST_ASIO_VERSION / 100000 is the major version
#define BOOST_ASIO_VERSION 100406 // 1.4.6
#define BOOST_ASIO_VERSION 100407 // 1.4.7
#endif // BOOST_ASIO_VERSION_HPP

38
3party/boost/boost/concept_check.hpp
View file

@ -1,5 +1,7 @@
//
// (C) Copyright Jeremy Siek 2000.
// Copyright 2002 The Trustees of Indiana University.
//
// 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)
@ -999,6 +1001,42 @@ namespace boost
// HashedAssociativeContainer
BOOST_concept(Collection,(C))
{
BOOST_CONCEPT_USAGE(Collection)
{
boost::function_requires<boost::InputIteratorConcept<iterator> >();
boost::function_requires<boost::InputIteratorConcept<const_iterator> >();
boost::function_requires<boost::CopyConstructibleConcept<value_type> >();
const_constraints(c);
i = c.begin();
i = c.end();
c.swap(c);
}
void const_constraints(const C& c) {
ci = c.begin();
ci = c.end();
n = c.size();
b = c.empty();
}
private:
typedef typename C::value_type value_type;
typedef typename C::iterator iterator;
typedef typename C::const_iterator const_iterator;
typedef typename C::reference reference;
typedef typename C::const_reference const_reference;
// typedef typename C::pointer pointer;
typedef typename C::difference_type difference_type;
typedef typename C::size_type size_type;
C c;
bool b;
iterator i;
const_iterator ci;
size_type n;
};
} // namespace boost
# include <boost/concept/detail/concept_undef.hpp>

2
3party/boost/boost/config/auto_link.hpp
View file

@ -362,7 +362,7 @@ BOOST_LIB_VERSION: The Boost version, in the form x_y, for Boost version x.y.
&& defined(BOOST_LIB_VERSION)
#ifdef BOOST_AUTO_LINK_TAGGED
# pragma commentcomment(lib, BOOST_LIB_PREFIX BOOST_STRINGIZE(BOOST_LIB_NAME) BOOST_LIB_THREAD_OPT BOOST_LIB_RT_OPT ".lib")
# pragma comment(lib, BOOST_LIB_PREFIX BOOST_STRINGIZE(BOOST_LIB_NAME) BOOST_LIB_THREAD_OPT BOOST_LIB_RT_OPT ".lib")
# ifdef BOOST_LIB_DIAGNOSTIC
# pragma message ("Linking to lib file: " BOOST_LIB_PREFIX BOOST_STRINGIZE(BOOST_LIB_NAME) "-" BOOST_LIB_TOOLSET BOOST_LIB_THREAD_OPT BOOST_LIB_RT_OPT "-" BOOST_LIB_VERSION ".lib")
# endif

2
3party/boost/boost/config/compiler/borland.hpp
View file

@ -46,6 +46,8 @@
// Borland C++Builder 5, command-line compiler 5.5:
# define BOOST_NO_OPERATORS_IN_NAMESPACE
# endif
// Variadic macros do not exist for C++ Builder versions 5 and below
#define BOOST_NO_VARIADIC_MACROS
# endif
// Version 5.51 and below:

1
3party/boost/boost/config/compiler/clang.hpp
View file

@ -48,6 +48,7 @@
#define BOOST_NO_TEMPLATE_ALIASES
#define BOOST_NO_UNICODE_LITERALS
#define BOOST_NO_VARIADIC_TEMPLATES
#define BOOST_NO_VARIADIC_MACROS
// HACK: Clang does support extern templates, but Boost's test for
// them is wrong.

4
3party/boost/boost/config/compiler/common_edg.hpp
View file

@ -88,12 +88,10 @@
#define BOOST_NO_TEMPLATE_ALIASES
#define BOOST_NO_UNICODE_LITERALS
#define BOOST_NO_VARIADIC_TEMPLATES
#define BOOST_NO_VARIADIC_MACROS
#ifdef c_plusplus
// EDG has "long long" in non-strict mode
// However, some libraries have insufficient "long long" support
// #define BOOST_HAS_LONG_LONG
#endif

3
3party/boost/boost/config/compiler/digitalmars.hpp
View file

@ -80,6 +80,9 @@
#define BOOST_NO_TEMPLATE_ALIASES
#define BOOST_NO_UNICODE_LITERALS
#define BOOST_NO_VARIADIC_TEMPLATES
#if (__DMC__ < 0x812)
#define BOOST_NO_VARIADIC_MACROS
#endif
#if __DMC__ < 0x800
#error "Compiler not supported or configured - please reconfigure"

4
3party/boost/boost/config/compiler/gcc.hpp
View file

@ -43,6 +43,8 @@
# define BOOST_FUNCTION_SCOPE_USING_DECLARATION_BREAKS_ADL
# define BOOST_NO_IS_ABSTRACT
# define BOOST_NO_EXTERN_TEMPLATE
// Variadic macros do not exist for gcc versions before 3.0
# define BOOST_NO_VARIADIC_MACROS
#elif __GNUC__ == 3
# if defined (__PATHSCALE__)
# define BOOST_NO_TWO_PHASE_NAME_LOOKUP
@ -113,7 +115,7 @@
// Dynamic shared object (DSO) and dynamic-link library (DLL) support
//
#if __GNUC__ >= 4
# if defined(_WIN32) || defined(__WIN32__) || defined(WIN32)
# if (defined(_WIN32) || defined(__WIN32__) || defined(WIN32)) && !defined(__CYGWIN__)
// All Win32 development environments, including 64-bit Windows and MinGW, define
// _WIN32 or one of its variant spellings. Note that Cygwin is a POSIX environment,
// so does not define _WIN32 or its variants.

1
3party/boost/boost/config/compiler/gcc_xml.hpp
View file

@ -35,6 +35,7 @@
# define BOOST_NO_RVALUE_REFERENCES
# define BOOST_NO_STATIC_ASSERT
# define BOOST_NO_VARIADIC_TEMPLATES
# define BOOST_NO_VARIADIC_MACROS
# define BOOST_NO_AUTO_DECLARATIONS
# define BOOST_NO_AUTO_MULTIDECLARATIONS
# define BOOST_NO_CHAR16_T

10
3party/boost/boost/config/compiler/hp_acc.hpp
View file

@ -115,6 +115,16 @@
#define BOOST_NO_TEMPLATE_ALIASES
#define BOOST_NO_UNICODE_LITERALS
#define BOOST_NO_VARIADIC_TEMPLATES
/*
See https://forums13.itrc.hp.com/service/forums/questionanswer.do?threadId=1443331 and
https://forums13.itrc.hp.com/service/forums/questionanswer.do?threadId=1443436
*/
#if (__HP_aCC < 62500) || !defined(HP_CXX0x_SOURCE)
#define BOOST_NO_VARIADIC_MACROS
#endif
#endif
//

1
3party/boost/boost/config/compiler/metrowerks.hpp
View file

@ -114,6 +114,7 @@
#define BOOST_NO_TEMPLATE_ALIASES
#define BOOST_NO_UNICODE_LITERALS
#define BOOST_NO_VARIADIC_TEMPLATES
#define BOOST_NO_VARIADIC_MACROS
#define BOOST_COMPILER "Metrowerks CodeWarrior C++ version " BOOST_STRINGIZE(BOOST_COMPILER_VERSION)

1
3party/boost/boost/config/compiler/mpw.hpp
View file

@ -63,6 +63,7 @@
#define BOOST_NO_TEMPLATE_ALIASES
#define BOOST_NO_UNICODE_LITERALS
#define BOOST_NO_VARIADIC_TEMPLATES
#define BOOST_NO_VARIADIC_MACROS
//
// versions check:

1
3party/boost/boost/config/compiler/nvcc.hpp
View file

@ -37,6 +37,7 @@
#define BOOST_HAS_DIRENT_H
#define BOOST_HAS_CLOCK_GETTIME
#define BOOST_NO_VARIADIC_TEMPLATES
#define BOOST_NO_VARIADIC_MACROS
#define BOOST_NO_UNICODE_LITERALS
#define BOOST_NO_TEMPLATE_ALIASES
#define BOOST_NO_STD_UNORDERED

1
3party/boost/boost/config/compiler/pgi.hpp
View file

@ -70,6 +70,7 @@
#define BOOST_NO_TEMPLATE_ALIASES
#define BOOST_NO_UNICODE_LITERALS
#define BOOST_NO_VARIADIC_TEMPLATES
#define BOOST_NO_VARIADIC_MACROS
//
// version check:

1
3party/boost/boost/config/compiler/sunpro_cc.hpp
View file

@ -122,6 +122,7 @@
#define BOOST_NO_TEMPLATE_ALIASES
#define BOOST_NO_UNICODE_LITERALS
#define BOOST_NO_VARIADIC_TEMPLATES
#define BOOST_NO_VARIADIC_MACROS
//
// Version

1
3party/boost/boost/config/compiler/vacpp.hpp
View file

@ -91,6 +91,7 @@
#define BOOST_NO_TEMPLATE_ALIASES
#define BOOST_NO_UNICODE_LITERALS
#define BOOST_NO_VARIADIC_TEMPLATES
#define BOOST_NO_VARIADIC_MACROS

2
3party/boost/boost/config/compiler/visualc.hpp
View file

@ -81,6 +81,8 @@
# define BOOST_NO_SWPRINTF
// Our extern template tests also fail for this compiler:
# define BOOST_NO_EXTERN_TEMPLATE
// Variadic macros do not exist for VC7.1 and lower
# define BOOST_NO_VARIADIC_MACROS
#endif
#if defined(UNDER_CE)

2
3party/boost/boost/config/platform/bsd.hpp
View file

@ -56,7 +56,7 @@
#endif
#if !((defined(__FreeBSD__) && (__FreeBSD__ >= 5)) \
|| (__NetBSD_GCC__ >= 2095003) || defined(__DragonFly__))
|| (defined(__NetBSD_GCC__) && (__NetBSD_GCC__ >= 2095003)) || defined(__DragonFly__))
# define BOOST_NO_CWCHAR
#endif
//

7
3party/boost/boost/config/platform/cygwin.hpp
View file

@ -41,6 +41,13 @@
// boilerplate code:
#include <boost/config/posix_features.hpp>
//
// Cygwin lies about XSI conformance, there is no nl_types.h:
//
#ifdef BOOST_HAS_NL_TYPES_H
# undef BOOST_HAS_NL_TYPES_H
#endif

25
3party/boost/boost/config/platform/vms.hpp Normal file
View file

@ -0,0 +1,25 @@
// (C) Copyright Artyom Beilis 2010.
// Use, modification and distribution are subject to the
// Boost Software License, Version 1.0. (See accompanying file
// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
#ifndef BOOST_CONFIG_PLATFORM_VMS_HPP
#define BOOST_CONFIG_PLATFORM_VMS_HPP
#define BOOST_PLATFORM "OpenVMS"
#undef BOOST_HAS_STDINT_H
#define BOOST_HAS_UNISTD_H
#define BOOST_HAS_NL_TYPES_H
#define BOOST_HAS_GETTIMEOFDAY
#define BOOST_HAS_DIRENT_H
#define BOOST_HAS_PTHREADS
#define BOOST_HAS_NANOSLEEP
#define BOOST_HAS_CLOCK_GETTIME
#define BOOST_HAS_PTHREAD_MUTEXATTR_SETTYPE
#define BOOST_HAS_LOG1P
#define BOOST_HAS_EXPM1
#define BOOST_HAS_THREADS
#undef BOOST_HAS_SCHED_YIELD
#endif

3
3party/boost/boost/config/select_platform_config.hpp
View file

@ -69,6 +69,9 @@
// Symbian:
# define BOOST_PLATFORM_CONFIG "boost/config/platform/symbian.hpp"
#elif defined(__VMS)
// VMS:
# define BOOST_PLATFORM_CONFIG "boost/config/platform/vms.hpp"
#else
# if defined(unix) \

1
3party/boost/boost/config/stdlib/dinkumware.hpp
View file

@ -125,6 +125,7 @@
# define BOOST_NO_0X_HDR_MUTEX
# define BOOST_NO_0X_HDR_RATIO
# define BOOST_NO_0X_HDR_THREAD
# define BOOST_NO_NUMERIC_LIMITS_LOWEST
#ifdef _CPPLIB_VER
# define BOOST_DINKUMWARE_STDLIB _CPPLIB_VER

1
3party/boost/boost/config/stdlib/libcomo.hpp
View file

@ -58,6 +58,7 @@
# define BOOST_NO_STD_UNORDERED // deprecated; see following
# define BOOST_NO_0X_HDR_UNORDERED_MAP
# define BOOST_NO_0X_HDR_UNORDERED_SET
# define BOOST_NO_NUMERIC_LIMITS_LOWEST
//
// Intrinsic type_traits support.

6
3party/boost/boost/config/stdlib/libstdcpp3.hpp
View file

@ -115,6 +115,12 @@
# define BOOST_NO_0X_HDR_THREAD
#endif
// C++0x features in GCC 4.5.0 and later
//
#if __GNUC__ < 4 || (__GNUC__ == 4 && __GNUC_MINOR__ < 5) || !defined(__GXX_EXPERIMENTAL_CXX0X__)
# define BOOST_NO_NUMERIC_LIMITS_LOWEST
#endif
// C++0x headers not yet implemented
//
# define BOOST_NO_0X_HDR_CODECVT

1
3party/boost/boost/config/stdlib/modena.hpp
View file

@ -47,6 +47,7 @@
# define BOOST_NO_STD_UNORDERED // deprecated; see following
# define BOOST_NO_0X_HDR_UNORDERED_MAP
# define BOOST_NO_0X_HDR_UNORDERED_SET
# define BOOST_NO_NUMERIC_LIMITS_LOWEST
#define BOOST_STDLIB "Modena C++ standard library"

1
3party/boost/boost/config/stdlib/msl.hpp
View file

@ -71,6 +71,7 @@
# define BOOST_NO_STD_UNORDERED // deprecated; see following
# define BOOST_NO_0X_HDR_UNORDERED_MAP
# define BOOST_NO_0X_HDR_UNORDERED_SET
# define BOOST_NO_NUMERIC_LIMITS_LOWEST
#define BOOST_STDLIB "Metrowerks Standard Library version " BOOST_STRINGIZE(__MSL_CPP__)

1
3party/boost/boost/config/stdlib/roguewave.hpp
View file

@ -177,4 +177,5 @@
# define BOOST_NO_STD_UNORDERED // deprecated; see following
# define BOOST_NO_0X_HDR_UNORDERED_MAP
# define BOOST_NO_0X_HDR_UNORDERED_SET
# define BOOST_NO_NUMERIC_LIMITS_LOWEST

1
3party/boost/boost/config/stdlib/sgi.hpp
View file

@ -130,6 +130,7 @@
# define BOOST_NO_STD_UNORDERED // deprecated; see following
# define BOOST_NO_0X_HDR_UNORDERED_MAP
# define BOOST_NO_0X_HDR_UNORDERED_SET
# define BOOST_NO_NUMERIC_LIMITS_LOWEST
#define BOOST_STDLIB "SGI standard library"

1
3party/boost/boost/config/stdlib/stlport.hpp
View file

@ -225,6 +225,7 @@ namespace boost { using std::min; using std::max; }
# define BOOST_NO_STD_UNORDERED // deprecated; see following
# define BOOST_NO_0X_HDR_UNORDERED_MAP
# define BOOST_NO_0X_HDR_UNORDERED_SET
# define BOOST_NO_NUMERIC_LIMITS_LOWEST
#define BOOST_STDLIB "STLPort standard library version " BOOST_STRINGIZE(__SGI_STL_PORT)

1
3party/boost/boost/config/stdlib/vacpp.hpp
View file

@ -37,6 +37,7 @@
# define BOOST_NO_STD_UNORDERED // deprecated; see following
# define BOOST_NO_0X_HDR_UNORDERED_MAP
# define BOOST_NO_0X_HDR_UNORDERED_SET
# define BOOST_NO_NUMERIC_LIMITS_LOWEST
#define BOOST_STDLIB "Visual Age default standard library"

8
3party/boost/boost/config/suffix.hpp
View file

@ -25,6 +25,14 @@
#ifndef BOOST_CONFIG_SUFFIX_HPP
#define BOOST_CONFIG_SUFFIX_HPP
#if defined(__GNUC__) && (__GNUC__ >= 4)
//
// Some GCC-4.x versions issue warnings even when __extension__ is used,
// so use this as a workaround:
//
#pragma GCC system_header
#endif
//
// ensure that visibility macros are always defined, thus symplifying use
//

25
3party/boost/boost/cstdint.hpp
View file

@ -137,7 +137,7 @@ namespace boost
} // namespace boost
#elif defined(__FreeBSD__) && (__FreeBSD__ <= 4) || defined(__osf__)
#elif defined(__FreeBSD__) && (__FreeBSD__ <= 4) || defined(__osf__) || defined(__VMS)
// FreeBSD and Tru64 have an <inttypes.h> that contains much of what we need.
# include <inttypes.h>
@ -256,20 +256,27 @@ namespace boost
// 32-bit types -----------------------------------------------------------//
# if ULONG_MAX == 0xffffffff
typedef long int32_t;
typedef long int_least32_t;
typedef long int_fast32_t;
typedef unsigned long uint32_t;
typedef unsigned long uint_least32_t;
typedef unsigned long uint_fast32_t;
# elif UINT_MAX == 0xffffffff
# if UINT_MAX == 0xffffffff
typedef int int32_t;
typedef int int_least32_t;
typedef int int_fast32_t;
typedef unsigned int uint32_t;
typedef unsigned int uint_least32_t;
typedef unsigned int uint_fast32_t;
# elif (USHRT_MAX == 0xffffffff)
typedef short int32_t;
typedef short int_least32_t;
typedef short int_fast32_t;
typedef unsigned short uint32_t;
typedef unsigned short uint_least32_t;
typedef unsigned short uint_fast32_t;
# elif ULONG_MAX == 0xffffffff
typedef long int32_t;
typedef long int_least32_t;
typedef long int_fast32_t;
typedef unsigned long uint32_t;
typedef unsigned long uint_least32_t;
typedef unsigned long uint_fast32_t;
# elif (UINT_MAX == 0xffffffffffffffff) && defined(__MTA__)
// Integers are 64 bits on the MTA / XMT
typedef __int32 int32_t;

3
3party/boost/boost/date_time/gregorian/greg_serialize.hpp
View file

@ -6,12 +6,13 @@
* Boost Software License, Version 1.0. (See accompanying
* file LICENSE_1_0.txt or http://www.boost.org/LICENSE_1_0.txt)
* Author: Jeff Garland, Bart Garst
* $Date: 2008-11-12 14:37:53 -0500 (Wed, 12 Nov 2008) $
* $Date: 2010-11-11 15:19:38 -0500 (Thu, 11 Nov 2010) $
*/
#include "boost/date_time/gregorian/gregorian_types.hpp"
#include "boost/date_time/gregorian/parsers.hpp"
#include "boost/serialization/split_free.hpp"
#include "boost/serialization/nvp.hpp"
// macros to split serialize functions into save & load functions

3
3party/boost/boost/date_time/posix_time/time_serialize.hpp
View file

@ -6,12 +6,13 @@
* Boost Software License, Version 1.0. (See accompanying
* file LICENSE_1_0.txt or http://www.boost.org/LICENSE_1_0.txt)
* Author: Jeff Garland, Bart Garst
* $Date: 2010-06-09 13:41:14 -0400 (Wed, 09 Jun 2010) $
* $Date: 2010-11-11 15:19:38 -0500 (Thu, 11 Nov 2010) $
*/
#include "boost/date_time/posix_time/posix_time.hpp"
#include "boost/date_time/gregorian/greg_serialize.hpp"
#include "boost/serialization/split_free.hpp"
#include "boost/serialization/nvp.hpp"
// macros to split serialize functions into save & load functions

8
3party/boost/boost/detail/is_incrementable.hpp
View file

@ -70,10 +70,10 @@ namespace is_incrementable_
# endif
// two check overloads help us identify which operator++ was picked
char (& check(tag) )[2];
char (& check_(tag) )[2];
template <class T>
char check(T const&);
char check_(T const&);
template <class T>
@ -83,7 +83,7 @@ namespace is_incrementable_
BOOST_STATIC_CONSTANT(
bool
, value = sizeof(is_incrementable_::check(BOOST_comma(++x,0))) == 1
, value = sizeof(is_incrementable_::check_(BOOST_comma(++x,0))) == 1
);
};
@ -94,7 +94,7 @@ namespace is_incrementable_
BOOST_STATIC_CONSTANT(
bool
, value = sizeof(is_incrementable_::check(BOOST_comma(x++,0))) == 1
, value = sizeof(is_incrementable_::check_(BOOST_comma(x++,0))) == 1
);
};

6
3party/boost/boost/detail/sp_typeinfo.hpp
View file

@ -74,7 +74,13 @@ template<class T> struct sp_typeid_
}
};
#if defined(__SUNPRO_CC)
// see #4199, the Sun Studio compiler gets confused about static initialization
// constructor arguments. But an assignment works just fine.
template<class T> sp_typeinfo sp_typeid_< T >::ti_ = sp_typeid_< T >::name();
#else
template<class T> sp_typeinfo sp_typeid_< T >::ti_(sp_typeid_< T >::name());
#endif
template<class T> struct sp_typeid_< T & >: sp_typeid_< T >
{

2
3party/boost/boost/filesystem/v2/operations.hpp
View file

@ -1188,7 +1188,9 @@ namespace boost
using filesystem2::copy_file;
using filesystem2::copy_option;
using filesystem2::create_directory;
# if !defined(BOOST_WINDOWS_API) || defined(BOOST_FS_HARD_LINK)
using filesystem2::create_hard_link;
# endif
using filesystem2::create_symlink;
using filesystem2::current_path;
using filesystem2::directory_entry;

5
3party/boost/boost/filesystem/v2/path.hpp
View file

@ -1532,6 +1532,11 @@ namespace boost
{
using filesystem2::basic_path;
using filesystem2::path_traits;
using filesystem2::slash;
using filesystem2::dot;
using filesystem2::colon;
using filesystem2::path;
# ifndef BOOST_FILESYSTEM2_NARROW_ONLY
using filesystem2::wpath_traits;

19
3party/boost/boost/filesystem/v3/operations.hpp
View file

@ -68,14 +68,17 @@ namespace boost
file_not_found,
regular_file,
directory_file,
// the following will never be reported by some operating or file systems
// the following may not apply to some operating systems or file systems
symlink_file,
block_file,
character_file,
fifo_file,
socket_file,
type_unknown // file does exist, but isn't one of the above types or
// we don't have strong enough permission to find its type
reparse_file, // Windows: FILE_ATTRIBUTE_REPARSE_POINT that is not a symlink
type_unknown, // file does exist, but isn't one of the above types or
// we don't have strong enough permission to find its type
_detail_directory_symlink // internal use only; never exposed to users
};
class BOOST_FILESYSTEM_DECL file_status
@ -145,7 +148,7 @@ namespace boost
BOOST_SCOPED_ENUM(copy_option) option, // See ticket #2925
system::error_code* ec=0);
BOOST_FILESYSTEM_DECL
void copy_symlink(const path& from, const path& to, system::error_code* ec=0);
void copy_symlink(const path& existing_symlink, const path& new_symlink, system::error_code* ec=0);
BOOST_FILESYSTEM_DECL
bool create_directories(const path& p, system::error_code* ec=0);
BOOST_FILESYSTEM_DECL
@ -304,11 +307,11 @@ namespace boost
void copy_file(const path& from, const path& to, system::error_code& ec)
{detail::copy_file(from, to, copy_option::fail_if_exists, &ec);}
inline
void copy_symlink(const path& from, const path& to) {detail::copy_symlink(from, to);}
void copy_symlink(const path& existing_symlink, const path& new_symlink) {detail::copy_symlink(existing_symlink, new_symlink);}
inline
void copy_symlink(const path& from, const path& to, system::error_code& ec)
{detail::copy_symlink(from, to, &ec);}
void copy_symlink(const path& existing_symlink, const path& new_symlink, system::error_code& ec)
{detail::copy_symlink(existing_symlink, new_symlink, &ec);}
inline
bool create_directories(const path& p) {return detail::create_directories(p);}
@ -938,6 +941,7 @@ namespace boost
using filesystem3::absolute;
using filesystem3::block_file;
using filesystem3::character_file;
// using filesystem3::copy;
using filesystem3::copy_file;
using filesystem3::copy_option;
using filesystem3::copy_symlink;
@ -945,6 +949,7 @@ namespace boost
using filesystem3::create_directory;
using filesystem3::create_hard_link;
using filesystem3::create_symlink;
using filesystem3::create_directory_symlink;
using filesystem3::current_path;
using filesystem3::directory_entry;
using filesystem3::directory_file;

14
3party/boost/boost/filesystem/v3/path.hpp
View file

@ -22,7 +22,7 @@
# endif
#include <boost/filesystem/v3/config.hpp>
#include <boost/filesystem/v3/path_traits.hpp>
#include <boost/filesystem/v3/path_traits.hpp> // includes <cwchar>
#include <boost/system/error_code.hpp>
#include <boost/system/system_error.hpp>
#include <boost/iterator/iterator_facade.hpp>
@ -127,7 +127,9 @@ namespace filesystem3
path(const path& p) : m_pathname(p.m_pathname) {}
template <class Source>
path(Source const& source)
path(Source const& source,
typename boost::enable_if<path_traits::is_pathable<
typename boost::decay<Source>::type> >::type* =0)
{
path_traits::dispatch(source, m_pathname, codecvt());
}
@ -170,7 +172,9 @@ namespace filesystem3
}
template <class Source>
path& operator=(Source const& source)
typename boost::enable_if<path_traits::is_pathable<
typename boost::decay<Source>::type>, path&>::type
operator=(Source const& source)
{
m_pathname.clear();
path_traits::dispatch(source, m_pathname, codecvt());
@ -212,7 +216,9 @@ namespace filesystem3
path& operator/=(const path& p);
template <class Source>
path& operator/=(Source const& source)
typename boost::enable_if<path_traits::is_pathable<
typename boost::decay<Source>::type>, path&>::type
operator/=(Source const& source)
{
return append(source, codecvt());
}

29
3party/boost/boost/filesystem/v3/path_traits.hpp
View file

@ -19,9 +19,12 @@
#include <boost/filesystem/v3/config.hpp>
#include <boost/utility/enable_if.hpp>
#include <boost/type_traits/is_array.hpp>
#include <boost/type_traits/decay.hpp>
#include <boost/system/error_code.hpp>
#include <cwchar> // for mbstate_t
#include <string>
#include <vector>
#include <list>
#include <iterator>
#include <locale>
#include <boost/assert.hpp>
@ -48,6 +51,23 @@ namespace path_traits {
typedef std::codecvt<wchar_t, char, std::mbstate_t> codecvt_type;
// is_pathable type trait; allows disabling over-agressive class path member templates
template <class T>
struct is_pathable { static const bool value = false; };
template<> struct is_pathable<char*> { static const bool value = true; };
template<> struct is_pathable<const char*> { static const bool value = true; };
template<> struct is_pathable<wchar_t*> { static const bool value = true; };
template<> struct is_pathable<const wchar_t*> { static const bool value = true; };
template<> struct is_pathable<std::string> { static const bool value = true; };
template<> struct is_pathable<std::wstring> { static const bool value = true; };
template<> struct is_pathable<std::vector<char> > { static const bool value = true; };
template<> struct is_pathable<std::vector<wchar_t> > { static const bool value = true; };
template<> struct is_pathable<std::list<char> > { static const bool value = true; };
template<> struct is_pathable<std::list<wchar_t> > { static const bool value = true; };
template<> struct is_pathable<directory_entry> { static const bool value = true; };
// Pathable empty
template <class Container> inline
@ -195,13 +215,8 @@ namespace path_traits {
convert(c_str, to, cvt);
}
// C-style array
template <typename T, size_t N, class U> inline
void dispatch(T (&array)[N], U& to, const codecvt_type& cvt) // T, N, U deduced
{
// std::cout << "dispatch() array, N=" << N << "\n";
convert(array, array + N - 1, to, cvt);
}
// Note: there is no dispatch on C-style arrays because the array may
// contain a string smaller than the array size.
BOOST_FILESYSTEM_DECL
void dispatch(const directory_entry & de,

81
3party/boost/boost/flyweight/detail/process_id.hpp
View file

@ -1,81 +0,0 @@
/* Copyright 2006-2008 Joaquin M Lopez Munoz.
* Distributed under the Boost Software License, Version 1.0.
* (See accompanying file LICENSE_1_0.txt or copy at
* http://www.boost.org/LICENSE_1_0.txt)
*
* See http://www.boost.org/libs/flyweight for library home page.
*/
#ifndef BOOST_FLYWEIGHT_DETAIL_PROCESS_ID_HPP
#define BOOST_FLYWEIGHT_DETAIL_PROCESS_ID_HPP
#if defined(_MSC_VER)&&(_MSC_VER>=1200)
#pragma once
#endif
#include <boost/config.hpp>
#if defined(BOOST_WINDOWS)&&!defined(BOOST_DISABLE_WIN32)
#if defined(BOOST_USE_WINDOWS_H)
#include <windows.h>
#else
namespace boost{
namespace flyweights{
namespace detail{
extern "C" __declspec(dllimport)
unsigned long __stdcall GetCurrentProcessId(void);
} /* namespace flyweights::detail */
} /* namespace flyweights */
} /* namespace boost */
#endif
namespace boost{
namespace flyweights{
namespace detail{
typedef unsigned long process_id_t;
inline process_id_t process_id()
{
return GetCurrentProcessId();
}
} /* namespace flyweights::detail */
} /* namespace flyweights */
} /* namespace boost */
#elif defined(BOOST_HAS_UNISTD_H)
#include <unistd.h>
namespace boost{
namespace flyweights{
namespace detail{
typedef pid_t process_id_t;
inline process_id_t process_id()
{
return ::getpid();
}
} /* namespace flyweights::detail */
} /* namespace flyweights */
} /* namespace boost */
#else
#error Unknown platform
#endif
#endif

144
3party/boost/boost/flyweight/intermodule_holder.hpp
View file

@ -1,4 +1,4 @@
/* Copyright 2006-2009 Joaquin M Lopez Munoz.
/* Copyright 2006-2010 Joaquin M Lopez Munoz.
* 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)
@ -16,15 +16,8 @@
#include <boost/config.hpp> /* keep it first to prevent nasty warns in MSVC */
#include <boost/flyweight/holder_tag.hpp>
#include <boost/flyweight/intermodule_holder_fwd.hpp>
#include <boost/flyweight/detail/process_id.hpp>
#include <boost/functional/hash.hpp>
#include <boost/interprocess/sync/named_mutex.hpp>
#include <boost/interprocess/sync/scoped_lock.hpp>
#include <boost/interprocess/managed_shared_memory.hpp>
#include <boost/interprocess/detail/intermodule_singleton.hpp>
#include <boost/mpl/aux_/lambda_support.hpp>
#include <cstdio>
#include <cstring>
#include <memory>
/* intermodule_holder_class guarantees a unique instance across all dynamic
* modules of a program.
@ -35,137 +28,10 @@ namespace boost{
namespace flyweights{
template<typename C>
struct intermodule_holder_class:holder_marker
struct intermodule_holder_class:
interprocess::detail::intermodule_singleton<C,true>,
holder_marker
{
static C& get()
{
static instantiator instance;
return instance.get();
}
private:
struct instantiator
{
instantiator():
mutex(interprocess::open_or_create,compute_mutex_name()),
seg(interprocess::open_or_create,compute_segment_name(),16384),
ppref(0),
pc(0)
{
/* Instance creation is done according to a two-phase protocol so
* that we call "new" in an unlocked situation, thus minimizing the
* chance of leaving dangling locks due to catastrophic failure.
*/
{
interprocess::scoped_lock<interprocess::named_mutex> lock(mutex);
ppref=seg.find_or_construct<referenced_instance*>(
typeid(C).name())((referenced_instance*)0);
if(*ppref){
/* As in some OSes Boost.Interprocess memory segments can outlive
* their associated processes, there is a possibility that we
* retrieve a dangling pointer (coming from a previous aborted run,
* for instance). Try to protect against this by checking that
* the contents of the pointed object are consistent.
*/
if(std::strcmp(segment_name,(*ppref)->segment_name)!=0){
*ppref=0; /* dangling pointer! */
}
else ++((*ppref)->ref);
}
}
if(!*ppref){
std::auto_ptr<referenced_instance> apc(
new referenced_instance(segment_name));
interprocess::scoped_lock<interprocess::named_mutex> lock(mutex);
ppref=seg.find_or_construct<referenced_instance*>(
typeid(C).name())((referenced_instance*)0);
if(!*ppref)*ppref=apc.release();
++((*ppref)->ref);
}
pc=&(*ppref)->c;
}
~instantiator()
{
/* As in construction time, actual deletion is performed outside the
* lock to avoid leaving the lock dangling in case of crash.
*/
referenced_instance* pref=0;
{
interprocess::scoped_lock<interprocess::named_mutex> lock(mutex);
if(--((*ppref)->ref)==0){
pref=*ppref;
*ppref=0;
}
}
if(pref)delete pref;
}
C& get()const{return *pc;}
private:
/* Although mutex and seg are system-wide, their names intend to
* make them specific for the current process and type, hence their
* containing process id and type id info.
*/
char mutex_name[128];
char segment_name[128];
const char* compute_mutex_name()
{
std::sprintf(
mutex_name,
"boost_flyweight_intermodule_holder_mutex_"
"%ld_%u_%u",
(long)detail::process_id(),
(unsigned)compute_hash(typeid(C).name(),0),
(unsigned)compute_hash(typeid(C).name(),1));
return mutex_name;
}
const char* compute_segment_name()
{
std::sprintf(
segment_name,
"boost_flyweight_intermodule_holder_segment_"
"%ld_%u_%u",
(long)detail::process_id(),
(unsigned)compute_hash(typeid(C).name(),0),
(unsigned)compute_hash(typeid(C).name(),1));
return segment_name;
}
static std::size_t compute_hash(const char* str,std::size_t off)
{
std::size_t len=std::strlen(str);
if(off>len)off=len;
return hash_range(str+off,str+len);
}
interprocess::named_mutex mutex;
interprocess::managed_shared_memory seg;
struct referenced_instance
{
referenced_instance(const char* segment_name_):ref(0)
{
std::strcpy(segment_name,segment_name_);
}
~referenced_instance(){segment_name[0]='\0';}
char segment_name[128]; /* used to detect dangling pointers */
mutable long ref;
C c;
}** ppref;
C* pc;
};
public:
typedef intermodule_holder_class type;
BOOST_MPL_AUX_LAMBDA_SUPPORT(1,intermodule_holder_class,(C))
};

18
3party/boost/boost/flyweight/refcounted.hpp
View file

@ -1,4 +1,4 @@
/* Copyright 2006-2009 Joaquin M Lopez Munoz.
/* Copyright 2006-2010 Joaquin M Lopez Munoz.
* 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)
@ -15,7 +15,6 @@
#include <boost/config.hpp> /* keep it first to prevent nasty warns in MSVC */
#include <algorithm>
#include <boost/assert.hpp>
#include <boost/detail/atomic_count.hpp>
#include <boost/detail/workaround.hpp>
#include <boost/flyweight/refcounted_fwd.hpp>
@ -36,7 +35,9 @@
* Here is where the deleter count comes into play. This count is
* incremented when the reference count changes from 0 to 1, and decremented
* when a thread is about to check a value for erasure; it can be seen that a
* value is effectively erasable only when the deleter count goes down to 0.
* value is effectively erasable only when the deleter count goes down to 0
* (unless there are dangling references due to abnormal program termination,
* for instance if std::exit is called).
*/
namespace boost{
@ -57,17 +58,6 @@ public:
x(r.x),ref(0),del_ref(0)
{}
~refcounted_value()
{
/* count()!=0 most likely indicates that the flyweight factory
* has been destructed before some of the flyweight objects using
* it. Check for static initialization order problems with this
* flyweight type.
*/
BOOST_ASSERT(count()==0);
}
refcounted_value& operator=(const refcounted_value& r)
{
x=r.x;

65
3party/boost/boost/foreach.hpp
View file

@ -246,7 +246,7 @@ struct auto_any_base
template<typename T>
struct auto_any : auto_any_base
{
auto_any(T const &t)
explicit auto_any(T const &t)
: item(t)
{
}
@ -606,7 +606,7 @@ should_copy_impl(boost::mpl::false_ *, boost::mpl::false_ *, bool *is_rvalue)
template<typename T>
inline auto_any<T> contain(T const &t, boost::mpl::true_ *) // rvalue
{
return t;
return auto_any<T>(t);
}
template<typename T>
@ -614,18 +614,18 @@ inline auto_any<T *> contain(T &t, boost::mpl::false_ *) // lvalue
{
// Cannot seem to get sunpro to handle addressof() with array types.
#if BOOST_WORKAROUND(__SUNPRO_CC, BOOST_TESTED_AT(0x570))
return &t;
return auto_any<T *>(&t);
#else
return boost::addressof(t);
return auto_any<T *>(boost::addressof(t));
#endif
}
#ifdef BOOST_FOREACH_RUN_TIME_CONST_RVALUE_DETECTION
template<typename T>
auto_any<simple_variant<T> >
inline auto_any<simple_variant<T> >
contain(T const &t, bool *rvalue)
{
return *rvalue ? simple_variant<T>(t) : simple_variant<T>(&t);
return auto_any<simple_variant<T> >(*rvalue ? simple_variant<T>(t) : simple_variant<T>(&t));
}
#endif
@ -636,7 +636,8 @@ template<typename T, typename C>
inline auto_any<BOOST_DEDUCED_TYPENAME foreach_iterator<T, C>::type>
begin(auto_any_t col, type2type<T, C> *, boost::mpl::true_ *) // rvalue
{
return boost::begin(auto_any_cast<T, C>(col));
return auto_any<BOOST_DEDUCED_TYPENAME foreach_iterator<T, C>::type>(
boost::begin(auto_any_cast<T, C>(col)));
}
template<typename T, typename C>
@ -645,15 +646,17 @@ begin(auto_any_t col, type2type<T, C> *, boost::mpl::false_ *) // lvalue
{
typedef BOOST_DEDUCED_TYPENAME type2type<T, C>::type type;
typedef BOOST_DEDUCED_TYPENAME foreach_iterator<T, C>::type iterator;
return iterator(boost::begin(derefof(auto_any_cast<type *, boost::mpl::false_>(col))));
return auto_any<BOOST_DEDUCED_TYPENAME foreach_iterator<T, C>::type>(
iterator(boost::begin(derefof(auto_any_cast<type *, boost::mpl::false_>(col)))));
}
#ifdef BOOST_FOREACH_RUN_TIME_CONST_RVALUE_DETECTION
template<typename T>
auto_any<BOOST_DEDUCED_TYPENAME foreach_iterator<T, const_>::type>
inline auto_any<BOOST_DEDUCED_TYPENAME foreach_iterator<T, const_>::type>
begin(auto_any_t col, type2type<T, const_> *, bool *)
{
return boost::begin(*auto_any_cast<simple_variant<T>, boost::mpl::false_>(col).get());
return auto_any<BOOST_DEDUCED_TYPENAME foreach_iterator<T, const_>::type>(
boost::begin(*auto_any_cast<simple_variant<T>, boost::mpl::false_>(col).get()));
}
#endif
@ -662,7 +665,7 @@ template<typename T, typename C>
inline auto_any<T *>
begin(auto_any_t col, type2type<T *, C> *, boost::mpl::true_ *) // null-terminated C-style strings
{
return auto_any_cast<T *, boost::mpl::false_>(col);
return auto_any<T *>(auto_any_cast<T *, boost::mpl::false_>(col));
}
#endif
@ -673,7 +676,8 @@ template<typename T, typename C>
inline auto_any<BOOST_DEDUCED_TYPENAME foreach_iterator<T, C>::type>
end(auto_any_t col, type2type<T, C> *, boost::mpl::true_ *) // rvalue
{
return boost::end(auto_any_cast<T, C>(col));
return auto_any<BOOST_DEDUCED_TYPENAME foreach_iterator<T, C>::type>(
boost::end(auto_any_cast<T, C>(col)));
}
template<typename T, typename C>
@ -682,15 +686,17 @@ end(auto_any_t col, type2type<T, C> *, boost::mpl::false_ *) // lvalue
{
typedef BOOST_DEDUCED_TYPENAME type2type<T, C>::type type;
typedef BOOST_DEDUCED_TYPENAME foreach_iterator<T, C>::type iterator;
return iterator(boost::end(derefof(auto_any_cast<type *, boost::mpl::false_>(col))));
return auto_any<BOOST_DEDUCED_TYPENAME foreach_iterator<T, C>::type>(
iterator(boost::end(derefof(auto_any_cast<type *, boost::mpl::false_>(col)))));
}
#ifdef BOOST_FOREACH_RUN_TIME_CONST_RVALUE_DETECTION
template<typename T>
auto_any<BOOST_DEDUCED_TYPENAME foreach_iterator<T, const_>::type>
inline auto_any<BOOST_DEDUCED_TYPENAME foreach_iterator<T, const_>::type>
end(auto_any_t col, type2type<T, const_> *, bool *)
{
return boost::end(*auto_any_cast<simple_variant<T>, boost::mpl::false_>(col).get());
return auto_any<BOOST_DEDUCED_TYPENAME foreach_iterator<T, const_>::type>(
boost::end(*auto_any_cast<simple_variant<T>, boost::mpl::false_>(col).get()));
}
#endif
@ -699,7 +705,7 @@ template<typename T, typename C>
inline auto_any<int>
end(auto_any_t, type2type<T *, C> *, boost::mpl::true_ *) // null-terminated C-style strings
{
return 0; // not used
return auto_any<int>(0); // not used
}
#endif
@ -749,7 +755,8 @@ template<typename T, typename C>
inline auto_any<BOOST_DEDUCED_TYPENAME foreach_reverse_iterator<T, C>::type>
rbegin(auto_any_t col, type2type<T, C> *, boost::mpl::true_ *) // rvalue
{
return boost::rbegin(auto_any_cast<T, C>(col));
return auto_any<BOOST_DEDUCED_TYPENAME foreach_reverse_iterator<T, C>::type>(
boost::rbegin(auto_any_cast<T, C>(col)));
}
template<typename T, typename C>
@ -758,15 +765,17 @@ rbegin(auto_any_t col, type2type<T, C> *, boost::mpl::false_ *) // lvalue
{
typedef BOOST_DEDUCED_TYPENAME type2type<T, C>::type type;
typedef BOOST_DEDUCED_TYPENAME foreach_reverse_iterator<T, C>::type iterator;
return iterator(boost::rbegin(derefof(auto_any_cast<type *, boost::mpl::false_>(col))));
return auto_any<BOOST_DEDUCED_TYPENAME foreach_reverse_iterator<T, C>::type>(
iterator(boost::rbegin(derefof(auto_any_cast<type *, boost::mpl::false_>(col)))));
}
#ifdef BOOST_FOREACH_RUN_TIME_CONST_RVALUE_DETECTION
template<typename T>
auto_any<BOOST_DEDUCED_TYPENAME foreach_reverse_iterator<T, const_>::type>
inline auto_any<BOOST_DEDUCED_TYPENAME foreach_reverse_iterator<T, const_>::type>
rbegin(auto_any_t col, type2type<T, const_> *, bool *)
{
return boost::rbegin(*auto_any_cast<simple_variant<T>, boost::mpl::false_>(col).get());
return auto_any<BOOST_DEDUCED_TYPENAME foreach_reverse_iterator<T, const_>::type>(
boost::rbegin(*auto_any_cast<simple_variant<T>, boost::mpl::false_>(col).get()));
}
#endif
@ -778,7 +787,7 @@ rbegin(auto_any_t col, type2type<T *, C> *, boost::mpl::true_ *) // null-termina
T *p = auto_any_cast<T *, boost::mpl::false_>(col);
while(0 != *p)
++p;
return reverse_iterator<T *>(p);
return auto_any<reverse_iterator<T *> >(reverse_iterator<T *>(p));
}
#endif
@ -789,7 +798,8 @@ template<typename T, typename C>
inline auto_any<BOOST_DEDUCED_TYPENAME foreach_reverse_iterator<T, C>::type>
rend(auto_any_t col, type2type<T, C> *, boost::mpl::true_ *) // rvalue
{
return boost::rend(auto_any_cast<T, C>(col));
return auto_any<BOOST_DEDUCED_TYPENAME foreach_reverse_iterator<T, C>::type>(
boost::rend(auto_any_cast<T, C>(col)));
}
template<typename T, typename C>
@ -798,15 +808,17 @@ rend(auto_any_t col, type2type<T, C> *, boost::mpl::false_ *) // lvalue
{
typedef BOOST_DEDUCED_TYPENAME type2type<T, C>::type type;
typedef BOOST_DEDUCED_TYPENAME foreach_reverse_iterator<T, C>::type iterator;
return iterator(boost::rend(derefof(auto_any_cast<type *, boost::mpl::false_>(col))));
return auto_any<BOOST_DEDUCED_TYPENAME foreach_reverse_iterator<T, C>::type>(
iterator(boost::rend(derefof(auto_any_cast<type *, boost::mpl::false_>(col)))));
}
#ifdef BOOST_FOREACH_RUN_TIME_CONST_RVALUE_DETECTION
template<typename T>
auto_any<BOOST_DEDUCED_TYPENAME foreach_reverse_iterator<T, const_>::type>
inline auto_any<BOOST_DEDUCED_TYPENAME foreach_reverse_iterator<T, const_>::type>
rend(auto_any_t col, type2type<T, const_> *, bool *)
{
return boost::rend(*auto_any_cast<simple_variant<T>, boost::mpl::false_>(col).get());
return auto_any<BOOST_DEDUCED_TYPENAME foreach_reverse_iterator<T, const_>::type>(
boost::rend(*auto_any_cast<simple_variant<T>, boost::mpl::false_>(col).get()));
}
#endif
@ -815,7 +827,8 @@ template<typename T, typename C>
inline auto_any<reverse_iterator<T *> >
rend(auto_any_t col, type2type<T *, C> *, boost::mpl::true_ *) // null-terminated C-style strings
{
return reverse_iterator<T *>(auto_any_cast<T *, boost::mpl::false_>(col));
return auto_any<reverse_iterator<T *> >(
reverse_iterator<T *>(auto_any_cast<T *, boost::mpl::false_>(col)));
}
#endif

8
3party/boost/boost/functional/hash/hash.hpp
View file

@ -209,9 +209,15 @@ namespace boost
template <class T> std::size_t hash_value(T* v)
#endif
{
#if defined(__VMS) && __INITIAL_POINTER_SIZE == 64
// for some reason ptrdiff_t on OpenVMS compiler with
// 64 bit is not 64 bit !!!
std::size_t x = static_cast<std::size_t>(
reinterpret_cast<long long int>(v));
#else
std::size_t x = static_cast<std::size_t>(
reinterpret_cast<std::ptrdiff_t>(v));
#endif
return x + (x >> 3);
}

2
3party/boost/boost/fusion/adapted.hpp
View file

@ -8,10 +8,10 @@
#if !defined(BOOST_FUSION_ADAPTED_30122005_1420)
#define BOOST_FUSION_ADAPTED_30122005_1420
#include <boost/fusion/adapted/adt.hpp>
#include <boost/fusion/adapted/array.hpp>
#include <boost/fusion/adapted/boost_array.hpp>
#include <boost/fusion/adapted/boost_tuple.hpp>
#include <boost/fusion/adapted/class.hpp>
#include <boost/fusion/adapted/mpl.hpp>
#include <boost/fusion/adapted/std_pair.hpp>
#include <boost/fusion/adapted/struct.hpp>

12
3party/boost/boost/fusion/adapted/class.hpp → 3party/boost/boost/fusion/adapted/adt.hpp
View file

@ -7,12 +7,12 @@
file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
==============================================================================*/
#ifndef BOOST_FUSION_ADAPTED_CLASS_HPP
#define BOOST_FUSION_ADAPTED_CLASS_HPP
#ifndef BOOST_FUSION_ADAPTED_ADT_HPP
#define BOOST_FUSION_ADAPTED_ADT_HPP
#include <boost/fusion/adapted/class/adapt_assoc_class_named.hpp>
#include <boost/fusion/adapted/class/adapt_assoc_class.hpp>
#include <boost/fusion/adapted/class/adapt_class_named.hpp>
#include <boost/fusion/adapted/class/adapt_class.hpp>
#include <boost/fusion/adapted/adt/adapt_assoc_adt_named.hpp>
#include <boost/fusion/adapted/adt/adapt_assoc_adt.hpp>
#include <boost/fusion/adapted/adt/adapt_adt_named.hpp>
#include <boost/fusion/adapted/adt/adapt_adt.hpp>
#endif

43
3party/boost/boost/fusion/adapted/class/adapt_class.hpp → 3party/boost/boost/fusion/adapted/adt/adapt_adt.hpp
View file

@ -7,8 +7,8 @@
file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
==============================================================================*/
#ifndef BOOST_FUSION_ADAPTED_CLASS_ADAPT_CLASS_HPP
#define BOOST_FUSION_ADAPTED_CLASS_ADAPT_CLASS_HPP
#ifndef BOOST_FUSION_ADAPTED_ADT_ADAPT_ADT_HPP
#define BOOST_FUSION_ADAPTED_ADT_ADAPT_ADT_HPP
#include <boost/preprocessor/cat.hpp>
#include <boost/preprocessor/empty.hpp>
@ -29,46 +29,45 @@
#include <boost/fusion/adapted/struct/detail/end_impl.hpp>
#include <boost/fusion/adapted/struct/detail/value_of_impl.hpp>
#include <boost/fusion/adapted/struct/detail/deref_impl.hpp>
#include <boost/fusion/adapted/class/detail/extension.hpp>
#include <boost/fusion/adapted/class/detail/adapt_base.hpp>
#include <boost/fusion/adapted/adt/detail/extension.hpp>
#include <boost/fusion/adapted/adt/detail/adapt_base.hpp>
#define BOOST_FUSION_ADAPT_CLASS_FILLER_0(A, B, C, D)\
((A, B, C, D)) BOOST_FUSION_ADAPT_CLASS_FILLER_1
#define BOOST_FUSION_ADAPT_CLASS_FILLER_1(A, B, C, D)\
((A, B, C, D)) BOOST_FUSION_ADAPT_CLASS_FILLER_0
#define BOOST_FUSION_ADAPT_CLASS_FILLER_0_END
#define BOOST_FUSION_ADAPT_CLASS_FILLER_1_END
#define BOOST_FUSION_ADAPT_ADT_FILLER_0(A, B, C, D)\
((A, B, C, D)) BOOST_FUSION_ADAPT_ADT_FILLER_1
#define BOOST_FUSION_ADAPT_ADT_FILLER_1(A, B, C, D)\
((A, B, C, D)) BOOST_FUSION_ADAPT_ADT_FILLER_0
#define BOOST_FUSION_ADAPT_ADT_FILLER_0_END
#define BOOST_FUSION_ADAPT_ADT_FILLER_1_END
#define BOOST_FUSION_ADAPT_CLASS_C(TEMPLATE_PARAMS_SEQ, NAME_SEQ, I, ATTRIBUTE) \
BOOST_FUSION_ADAPT_CLASS_C_BASE( \
#define BOOST_FUSION_ADAPT_ADT_C(TEMPLATE_PARAMS_SEQ, NAME_SEQ, I, ATTRIBUTE) \
BOOST_FUSION_ADAPT_ADT_C_BASE( \
TEMPLATE_PARAMS_SEQ, NAME_SEQ, I, ATTRIBUTE, 4)
#define BOOST_FUSION_ADAPT_TPL_CLASS(TEMPLATE_PARAMS_SEQ, NAME_SEQ , ATTRIBUTES)\
#define BOOST_FUSION_ADAPT_TPL_ADT(TEMPLATE_PARAMS_SEQ, NAME_SEQ , ATTRIBUTES) \
BOOST_FUSION_ADAPT_STRUCT_BASE( \
(1)TEMPLATE_PARAMS_SEQ, \
(1)NAME_SEQ, \
struct_tag, \
0, \
BOOST_PP_CAT(BOOST_FUSION_ADAPT_CLASS_FILLER_0 ATTRIBUTES,_END), \
BOOST_FUSION_ADAPT_CLASS_C)
BOOST_PP_CAT(BOOST_FUSION_ADAPT_ADT_FILLER_0 ATTRIBUTES,_END), \
BOOST_FUSION_ADAPT_ADT_C)
#define BOOST_FUSION_ADAPT_CLASS(NAME, ATTRIBUTES) \
#define BOOST_FUSION_ADAPT_ADT(NAME, ATTRIBUTES) \
BOOST_FUSION_ADAPT_STRUCT_BASE( \
(0), \
(0)(NAME), \
struct_tag, \
0, \
BOOST_PP_CAT(BOOST_FUSION_ADAPT_CLASS_FILLER_0 ATTRIBUTES,_END), \
BOOST_FUSION_ADAPT_CLASS_C)
BOOST_PP_CAT(BOOST_FUSION_ADAPT_ADT_FILLER_0 ATTRIBUTES,_END), \
BOOST_FUSION_ADAPT_ADT_C)
#define BOOST_FUSION_ADAPT_CLASS_AS_VIEW(NAME, ATTRIBUTES) \
#define BOOST_FUSION_ADAPT_ADT_AS_VIEW(NAME, ATTRIBUTES) \
BOOST_FUSION_ADAPT_STRUCT_BASE( \
(0), \
(0)(NAME), \
struct_tag, \
1, \
BOOST_PP_CAT(BOOST_FUSION_ADAPT_CLASS_FILLER_0 ATTRIBUTES,_END), \
BOOST_FUSION_ADAPT_CLASS_C)
BOOST_PP_CAT(BOOST_FUSION_ADAPT_ADT_FILLER_0 ATTRIBUTES,_END), \
BOOST_FUSION_ADAPT_ADT_C)
#endif

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