|
|
Boost-Commit : |
Subject: [Boost-commit] svn:boost r66107 - in trunk/boost: archive archive/detail archive/impl archive/iterators serialization serialization/detail
From: ramey_at_[hidden]
Date: 2010-10-19 15:45:24
Author: ramey
Date: 2010-10-19 15:45:11 EDT (Tue, 19 Oct 2010)
New Revision: 66107
URL: http://svn.boost.org/trac/boost/changeset/66107
Log:
fix compatibility with archive versions 1.41-, 1.42, 1.43,1.44+
and a bunch of miscelleneas stuff
Text files modified:
trunk/boost/archive/basic_binary_iprimitive.hpp | 4 +-
trunk/boost/archive/basic_binary_oprimitive.hpp | 4 +-
trunk/boost/archive/basic_xml_iarchive.hpp | 4 +-
trunk/boost/archive/basic_xml_oarchive.hpp | 4 +-
trunk/boost/archive/detail/check.hpp | 20 +++++++-------
trunk/boost/archive/detail/iserializer.hpp | 56 ++++++++++++++++++++--------------------
trunk/boost/archive/detail/oserializer.hpp | 56 ++++++++++++++++++++--------------------
trunk/boost/archive/detail/polymorphic_iarchive_route.hpp | 8 ++++-
trunk/boost/archive/detail/polymorphic_oarchive_route.hpp | 6 ++++
trunk/boost/archive/impl/archive_serializer_map.ipp | 8 ++--
trunk/boost/archive/impl/basic_binary_iarchive.ipp | 34 +++++++++++++++++++++++
trunk/boost/archive/iterators/base64_from_binary.hpp | 2
trunk/boost/archive/iterators/binary_from_base64.hpp | 2
trunk/boost/archive/iterators/insert_linebreaks.hpp | 2
trunk/boost/archive/iterators/mb_from_wchar.hpp | 2
trunk/boost/archive/iterators/remove_whitespace.hpp | 2
trunk/boost/archive/iterators/transform_width.hpp | 2
trunk/boost/archive/iterators/wchar_from_mb.hpp | 2
trunk/boost/archive/iterators/xml_escape.hpp | 2
trunk/boost/archive/iterators/xml_unescape.hpp | 2
trunk/boost/archive/polymorphic_iarchive.hpp | 2
trunk/boost/archive/polymorphic_oarchive.hpp | 2
trunk/boost/archive/shared_ptr_helper.hpp | 20 +++++++-------
trunk/boost/serialization/array.hpp | 8 ++--
trunk/boost/serialization/assume_abstract.hpp | 2
trunk/boost/serialization/complex.hpp | 16 +++++-----
trunk/boost/serialization/detail/shared_count_132.hpp | 8 ++--
trunk/boost/serialization/detail/shared_ptr_132.hpp | 52 ++++++++++++++++++------------------
trunk/boost/serialization/detail/shared_ptr_nmt_132.hpp | 16 +++++-----
trunk/boost/serialization/export.hpp | 10 +++---
trunk/boost/serialization/extended_type_info.hpp | 5 ++
trunk/boost/serialization/extended_type_info_no_rtti.hpp | 22 +++++++-------
trunk/boost/serialization/extended_type_info_typeid.hpp | 18 ++++++------
trunk/boost/serialization/is_bitwise_serializable.hpp | 2
trunk/boost/serialization/level.hpp | 12 ++++----
trunk/boost/serialization/nvp.hpp | 10 +++---
trunk/boost/serialization/optional.hpp | 12 ++++----
trunk/boost/serialization/pfto.hpp | 8 ++--
trunk/boost/serialization/scoped_ptr.hpp | 6 ++--
trunk/boost/serialization/shared_ptr.hpp | 24 ++++++++--------
trunk/boost/serialization/shared_ptr_132.hpp | 14 +++++-----
trunk/boost/serialization/singleton.hpp | 10 +++---
trunk/boost/serialization/smart_cast.hpp | 32 +++++++++++-----------
trunk/boost/serialization/state_saver.hpp | 2
trunk/boost/serialization/tracking.hpp | 8 ++--
trunk/boost/serialization/type_info_implementation.hpp | 4 +-
trunk/boost/serialization/utility.hpp | 2
trunk/boost/serialization/valarray.hpp | 2
trunk/boost/serialization/vector.hpp | 2
trunk/boost/serialization/version.hpp | 2
trunk/boost/serialization/weak_ptr.hpp | 10 +++---
51 files changed, 305 insertions(+), 260 deletions(-)
Modified: trunk/boost/archive/basic_binary_iprimitive.hpp
==============================================================================
--- trunk/boost/archive/basic_binary_iprimitive.hpp (original)
+++ trunk/boost/archive/basic_binary_iprimitive.hpp 2010-10-19 15:45:11 EDT (Tue, 19 Oct 2010)
@@ -126,10 +126,10 @@
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
};
Modified: trunk/boost/archive/basic_binary_oprimitive.hpp
==============================================================================
--- trunk/boost/archive/basic_binary_oprimitive.hpp (original)
+++ trunk/boost/archive/basic_binary_oprimitive.hpp 2010-10-19 15:45:11 EDT (Tue, 19 Oct 2010)
@@ -122,10 +122,10 @@
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
};
Modified: trunk/boost/archive/basic_xml_iarchive.hpp
==============================================================================
--- trunk/boost/archive/basic_xml_iarchive.hpp (original)
+++ trunk/boost/archive/basic_xml_iarchive.hpp 2010-10-19 15:45:11 EDT (Tue, 19 Oct 2010)
@@ -67,7 +67,7 @@
// 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 @@
#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());
Modified: trunk/boost/archive/basic_xml_oarchive.hpp
==============================================================================
--- trunk/boost/archive/basic_xml_oarchive.hpp (original)
+++ trunk/boost/archive/basic_xml_oarchive.hpp 2010-10-19 15:45:11 EDT (Tue, 19 Oct 2010)
@@ -89,7 +89,7 @@
// 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 @@
#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());
Modified: trunk/boost/archive/detail/check.hpp
==============================================================================
--- trunk/boost/archive/detail/check.hpp (original)
+++ trunk/boost/archive/detail/check.hpp 2010-10-19 15:45:11 EDT (Tue, 19 Oct 2010)
@@ -51,7 +51,7 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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
Modified: trunk/boost/archive/detail/iserializer.hpp
==============================================================================
--- trunk/boost/archive/detail/iserializer.hpp (original)
+++ trunk/boost/archive/detail/iserializer.hpp 2010-10-19 15:45:11 EDT (Tue, 19 Oct 2010)
@@ -128,7 +128,7 @@
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 @@
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(){};
};
@@ -236,7 +236,7 @@
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(){
@@ -256,7 +256,7 @@
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;
@@ -302,7 +302,7 @@
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()) ;
@@ -337,7 +337,7 @@
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()
)
{
@@ -373,7 +373,7 @@
boost::serialization::serialize_adl(
ar,
const_cast<T &>(t),
- boost::serialization::version<T>::value
+ boost::serialization::version< T >::value
);
}
};
@@ -408,7 +408,7 @@
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>,
@@ -416,7 +416,7 @@
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
@@ -425,7 +425,7 @@
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
@@ -434,8 +434,8 @@
// 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);
}
};
@@ -447,7 +447,7 @@
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);
}
};
@@ -472,7 +472,7 @@
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>
@@ -488,7 +488,7 @@
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
)
@@ -498,8 +498,8 @@
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 *
@@ -536,7 +536,7 @@
// 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);
}
};
@@ -544,7 +544,7 @@
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
@@ -574,15 +574,15 @@
// 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> >
@@ -619,7 +619,7 @@
#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
Modified: trunk/boost/archive/detail/oserializer.hpp
==============================================================================
--- trunk/boost/archive/detail/oserializer.hpp (original)
+++ trunk/boost/archive/detail/oserializer.hpp 2010-10-19 15:45:11 EDT (Tue, 19 Oct 2010)
@@ -107,7 +107,7 @@
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 @@
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 @@
) 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 @@
// 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 @@
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 @@
boost::serialization::serialize_adl(
ar,
const_cast<T &>(t),
- ::boost::serialization::version<T>::value
+ ::boost::serialization::version< T >::value
);
}
};
@@ -278,7 +278,7 @@
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 @@
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 @@
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 @@
// 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 @@
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 @@
// 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 @@
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 @@
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 @@
{
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 @@
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> >
Modified: trunk/boost/archive/detail/polymorphic_iarchive_route.hpp
==============================================================================
--- trunk/boost/archive/detail/polymorphic_iarchive_route.hpp (original)
+++ trunk/boost/archive/detail/polymorphic_iarchive_route.hpp 2010-10-19 15:45:11 EDT (Tue, 19 Oct 2010)
@@ -180,13 +180,17 @@
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(
Modified: trunk/boost/archive/detail/polymorphic_oarchive_route.hpp
==============================================================================
--- trunk/boost/archive/detail/polymorphic_oarchive_route.hpp (original)
+++ trunk/boost/archive/detail/polymorphic_oarchive_route.hpp 2010-10-19 15:45:11 EDT (Tue, 19 Oct 2010)
@@ -175,6 +175,12 @@
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(
Modified: trunk/boost/archive/impl/archive_serializer_map.ipp
==============================================================================
--- trunk/boost/archive/impl/archive_serializer_map.ipp (original)
+++ trunk/boost/archive/impl/archive_serializer_map.ipp 2010-10-19 15:45:11 EDT (Tue, 19 Oct 2010)
@@ -40,7 +40,7 @@
BOOST_ARCHIVE_OR_WARCHIVE_DECL(bool)
archive_serializer_map<Archive>::insert(const basic_serializer * bs){
return boost::serialization::singleton<
- map<Archive>
+ boost::archive::detail::map<Archive>
>::get_mutable_instance().insert(bs);
}
@@ -48,11 +48,11 @@
BOOST_ARCHIVE_OR_WARCHIVE_DECL(void)
archive_serializer_map<Archive>::erase(const basic_serializer * bs){
if(boost::serialization::singleton<
- map<Archive>
+ boost::archive::detail::map<Archive>
>::is_destroyed())
return;
boost::serialization::singleton<
- map<Archive>
+ boost::archive::detail::map<Archive>
>::get_mutable_instance().erase(bs);
}
@@ -62,7 +62,7 @@
const boost::serialization::extended_type_info & eti
) {
return boost::serialization::singleton<
- map<Archive>
+ boost::archive::detail::map<Archive>
>::get_const_instance().find(eti);
}
Modified: trunk/boost/archive/impl/basic_binary_iarchive.ipp
==============================================================================
--- trunk/boost/archive/impl/basic_binary_iarchive.ipp (original)
+++ trunk/boost/archive/impl/basic_binary_iarchive.ipp 2010-10-19 15:45:11 EDT (Tue, 19 Oct 2010)
@@ -22,6 +22,7 @@
#endif
#include <boost/detail/workaround.hpp>
+#include <boost/detail/endian.hpp>
#include <boost/archive/basic_binary_iarchive.hpp>
@@ -76,7 +77,38 @@
// 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();
+ }
+ #else 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);
Modified: trunk/boost/archive/iterators/base64_from_binary.hpp
==============================================================================
--- trunk/boost/archive/iterators/base64_from_binary.hpp (original)
+++ trunk/boost/archive/iterators/base64_from_binary.hpp 2010-10-19 15:45:11 EDT (Tue, 19 Oct 2010)
@@ -91,7 +91,7 @@
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>()
)
{}
Modified: trunk/boost/archive/iterators/binary_from_base64.hpp
==============================================================================
--- trunk/boost/archive/iterators/binary_from_base64.hpp (original)
+++ trunk/boost/archive/iterators/binary_from_base64.hpp 2010-10-19 15:45:11 EDT (Tue, 19 Oct 2010)
@@ -99,7 +99,7 @@
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>()
)
{}
Modified: trunk/boost/archive/iterators/insert_linebreaks.hpp
==============================================================================
--- trunk/boost/archive/iterators/insert_linebreaks.hpp (original)
+++ trunk/boost/archive/iterators/insert_linebreaks.hpp 2010-10-19 15:45:11 EDT (Tue, 19 Oct 2010)
@@ -84,7 +84,7 @@
// 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
Modified: trunk/boost/archive/iterators/mb_from_wchar.hpp
==============================================================================
--- trunk/boost/archive/iterators/mb_from_wchar.hpp (original)
+++ trunk/boost/archive/iterators/mb_from_wchar.hpp 2010-10-19 15:45:11 EDT (Tue, 19 Oct 2010)
@@ -115,7 +115,7 @@
// 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)
Modified: trunk/boost/archive/iterators/remove_whitespace.hpp
==============================================================================
--- trunk/boost/archive/iterators/remove_whitespace.hpp (original)
+++ trunk/boost/archive/iterators/remove_whitespace.hpp 2010-10-19 15:45:11 EDT (Tue, 19 Oct 2010)
@@ -154,7 +154,7 @@
// 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) :
Modified: trunk/boost/archive/iterators/transform_width.hpp
==============================================================================
--- trunk/boost/archive/iterators/transform_width.hpp (original)
+++ trunk/boost/archive/iterators/transform_width.hpp 2010-10-19 15:45:11 EDT (Tue, 19 Oct 2010)
@@ -113,7 +113,7 @@
// 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)
Modified: trunk/boost/archive/iterators/wchar_from_mb.hpp
==============================================================================
--- trunk/boost/archive/iterators/wchar_from_mb.hpp (original)
+++ trunk/boost/archive/iterators/wchar_from_mb.hpp 2010-10-19 15:45:11 EDT (Tue, 19 Oct 2010)
@@ -90,7 +90,7 @@
// 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
Modified: trunk/boost/archive/iterators/xml_escape.hpp
==============================================================================
--- trunk/boost/archive/iterators/xml_escape.hpp (original)
+++ trunk/boost/archive/iterators/xml_escape.hpp 2010-10-19 15:45:11 EDT (Tue, 19 Oct 2010)
@@ -44,7 +44,7 @@
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) :
Modified: trunk/boost/archive/iterators/xml_unescape.hpp
==============================================================================
--- trunk/boost/archive/iterators/xml_unescape.hpp (original)
+++ trunk/boost/archive/iterators/xml_unescape.hpp 2010-10-19 15:45:11 EDT (Tue, 19 Oct 2010)
@@ -57,7 +57,7 @@
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) :
Modified: trunk/boost/archive/polymorphic_iarchive.hpp
==============================================================================
--- trunk/boost/archive/polymorphic_iarchive.hpp (original)
+++ trunk/boost/archive/polymorphic_iarchive.hpp 2010-10-19 15:45:11 EDT (Tue, 19 Oct 2010)
@@ -114,7 +114,7 @@
#ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING
const
#endif
- boost::serialization::nvp<T> & t,
+ boost::serialization::nvp< T > & t,
int
){
load_start(t.name());
Modified: trunk/boost/archive/polymorphic_oarchive.hpp
==============================================================================
--- trunk/boost/archive/polymorphic_oarchive.hpp (original)
+++ trunk/boost/archive/polymorphic_oarchive.hpp 2010-10-19 15:45:11 EDT (Tue, 19 Oct 2010)
@@ -116,7 +116,7 @@
#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());
Modified: trunk/boost/archive/shared_ptr_helper.hpp
==============================================================================
--- trunk/boost/archive/shared_ptr_helper.hpp (original)
+++ trunk/boost/archive/shared_ptr_helper.hpp 2010-10-19 15:45:11 EDT (Tue, 19 Oct 2010)
@@ -44,7 +44,7 @@
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 @@
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 @@
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 @@
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 @@
append(sp);
}
else{
- s = shared_ptr<T>(
+ s = shared_ptr< T >(
r,
static_cast<T *>(r.get())
);
Modified: trunk/boost/serialization/array.hpp
==============================================================================
--- trunk/boost/serialization/array.hpp (original)
+++ trunk/boost/serialization/array.hpp 2010-10-19 15:45:11 EDT (Tue, 19 Oct 2010)
@@ -43,7 +43,7 @@
template<class T>
class array :
- public wrapper_traits<const array<T> >
+ public wrapper_traits<const array< T > >
{
public:
typedef T value_type;
@@ -99,7 +99,7 @@
{
typedef BOOST_DEDUCED_TYPENAME
boost::serialization::use_array_optimization<Archive>::template apply<
- BOOST_DEDUCED_TYPENAME remove_const<T>::type
+ BOOST_DEDUCED_TYPENAME remove_const< T >::type
>::type use_optimized;
serialize_optimized(ar,version,use_optimized());
}
@@ -124,8 +124,8 @@
#ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING
const
#endif
-array<T> make_array( T* t, std::size_t s){
- return array<T>(t, s);
+array< T > make_array( T* t, std::size_t s){
+ return array< T >(t, s);
}
template <class Archive, class T, std::size_t N>
Modified: trunk/boost/serialization/assume_abstract.hpp
==============================================================================
--- trunk/boost/serialization/assume_abstract.hpp (original)
+++ trunk/boost/serialization/assume_abstract.hpp 2010-10-19 15:45:11 EDT (Tue, 19 Oct 2010)
@@ -29,7 +29,7 @@
namespace boost {
namespace serialization {
template<class T>
- struct is_abstract : boost::is_abstract<T> {} ;
+ struct is_abstract : boost::is_abstract< T > {} ;
} // namespace serialization
} // namespace boost
Modified: trunk/boost/serialization/complex.hpp
==============================================================================
--- trunk/boost/serialization/complex.hpp (original)
+++ trunk/boost/serialization/complex.hpp 2010-10-19 15:45:11 EDT (Tue, 19 Oct 2010)
@@ -30,7 +30,7 @@
template<class Archive, class T>
inline void serialize(
Archive & ar,
- std::complex<T> & t,
+ std::complex< T > & t,
const unsigned int file_version
){
boost::serialization::split_free(ar, t, file_version);
@@ -39,7 +39,7 @@
template<class Archive, class T>
inline void save(
Archive & ar,
- std::complex<T> const & t,
+ std::complex< T > const & t,
const unsigned int /* file_version */
){
const T re = t.real();
@@ -51,28 +51,28 @@
template<class Archive, class T>
inline void load(
Archive & ar,
- std::complex<T>& t,
+ std::complex< T >& t,
const unsigned int /* file_version */
){
T re;
T im;
ar >> boost::serialization::make_nvp("real", re);
ar >> boost::serialization::make_nvp("imag", im);
- t = std::complex<T>(re,im);
+ t = std::complex< T >(re,im);
}
// specialization of serialization traits for complex
template <class T>
-struct is_bitwise_serializable<std::complex<T> >
- : public is_bitwise_serializable<T> {};
+struct is_bitwise_serializable<std::complex< T > >
+ : public is_bitwise_serializable< T > {};
template <class T>
-struct implementation_level<std::complex<T> >
+struct implementation_level<std::complex< T > >
: mpl::int_<object_serializable> {} ;
// treat complex just like builtin arithmetic types for tracking
template <class T>
-struct tracking_level<std::complex<T> >
+struct tracking_level<std::complex< T > >
: mpl::int_<track_never> {} ;
} // serialization
Modified: trunk/boost/serialization/detail/shared_count_132.hpp
==============================================================================
--- trunk/boost/serialization/detail/shared_count_132.hpp (original)
+++ trunk/boost/serialization/detail/shared_count_132.hpp 2010-10-19 15:45:11 EDT (Tue, 19 Oct 2010)
@@ -201,12 +201,12 @@
#if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)
-template<class T> void cbi_call_constructor_hook(sp_counted_base * pn, T * px, checked_deleter<T> const &, int)
+template<class T> void cbi_call_constructor_hook(sp_counted_base * pn, T * px, checked_deleter< T > const &, int)
{
boost::sp_scalar_constructor_hook(px, sizeof(T), pn);
}
-template<class T> void cbi_call_constructor_hook(sp_counted_base *, T * px, checked_array_deleter<T> const &, int)
+template<class T> void cbi_call_constructor_hook(sp_counted_base *, T * px, checked_array_deleter< T > const &, int)
{
boost::sp_array_constructor_hook(px);
}
@@ -215,12 +215,12 @@
{
}
-template<class T> void cbi_call_destructor_hook(sp_counted_base * pn, T * px, checked_deleter<T> const &, int)
+template<class T> void cbi_call_destructor_hook(sp_counted_base * pn, T * px, checked_deleter< T > const &, int)
{
boost::sp_scalar_destructor_hook(px, sizeof(T), pn);
}
-template<class T> void cbi_call_destructor_hook(sp_counted_base *, T * px, checked_array_deleter<T> const &, int)
+template<class T> void cbi_call_destructor_hook(sp_counted_base *, T * px, checked_array_deleter< T > const &, int)
{
boost::sp_array_destructor_hook(px);
}
Modified: trunk/boost/serialization/detail/shared_ptr_132.hpp
==============================================================================
--- trunk/boost/serialization/detail/shared_ptr_132.hpp (original)
+++ trunk/boost/serialization/detail/shared_ptr_132.hpp 2010-10-19 15:45:11 EDT (Tue, 19 Oct 2010)
@@ -83,7 +83,7 @@
// enable_shared_from_this support
-template<class T, class Y> void sp_enable_shared_from_this( shared_count const & pn, enable_shared_from_this<T> const * pe, Y const * px )
+template<class T, class Y> void sp_enable_shared_from_this( shared_count const & pn, enable_shared_from_this< T > const * pe, Y const * px )
{
if(pe != 0) pe->_internal_weak_this._internal_assign(const_cast<Y*>(px), pn);
}
@@ -107,14 +107,14 @@
{
private:
// Borland 5.5.1 specific workaround
- typedef shared_ptr<T> this_type;
+ typedef shared_ptr< T > this_type;
public:
typedef T element_type;
typedef T value_type;
typedef T * pointer;
- typedef BOOST_DEDUCED_TYPENAME detail::shared_ptr_traits<T>::reference reference;
+ typedef BOOST_DEDUCED_TYPENAME detail::shared_ptr_traits< T >::reference reference;
shared_ptr(): px(0), pn() // never throws in 1.30+
{
@@ -309,7 +309,7 @@
return pn.use_count();
}
- void swap(shared_ptr<T> & other) // never throws
+ void swap(shared_ptr< T > & other) // never throws
{
std::swap(px, other.px);
pn.swap(other.pn);
@@ -343,12 +343,12 @@
}; // shared_ptr
-template<class T, class U> inline bool operator==(shared_ptr<T> const & a, shared_ptr<U> const & b)
+template<class T, class U> inline bool operator==(shared_ptr< T > const & a, shared_ptr<U> const & b)
{
return a.get() == b.get();
}
-template<class T, class U> inline bool operator!=(shared_ptr<T> const & a, shared_ptr<U> const & b)
+template<class T, class U> inline bool operator!=(shared_ptr< T > const & a, shared_ptr<U> const & b)
{
return a.get() != b.get();
}
@@ -357,64 +357,64 @@
// Resolve the ambiguity between our op!= and the one in rel_ops
-template<class T> inline bool operator!=(shared_ptr<T> const & a, shared_ptr<T> const & b)
+template<class T> inline bool operator!=(shared_ptr< T > const & a, shared_ptr< T > const & b)
{
return a.get() != b.get();
}
#endif
-template<class T, class U> inline bool operator<(shared_ptr<T> const & a, shared_ptr<U> const & b)
+template<class T, class U> inline bool operator<(shared_ptr< T > const & a, shared_ptr<U> const & b)
{
return a._internal_less(b);
}
-template<class T> inline void swap(shared_ptr<T> & a, shared_ptr<T> & b)
+template<class T> inline void swap(shared_ptr< T > & a, shared_ptr< T > & b)
{
a.swap(b);
}
-template<class T, class U> shared_ptr<T> static_pointer_cast(shared_ptr<U> const & r)
+template<class T, class U> shared_ptr< T > static_pointer_cast(shared_ptr<U> const & r)
{
- return shared_ptr<T>(r, detail::static_cast_tag());
+ return shared_ptr< T >(r, detail::static_cast_tag());
}
-template<class T, class U> shared_ptr<T> const_pointer_cast(shared_ptr<U> const & r)
+template<class T, class U> shared_ptr< T > const_pointer_cast(shared_ptr<U> const & r)
{
- return shared_ptr<T>(r, detail::const_cast_tag());
+ return shared_ptr< T >(r, detail::const_cast_tag());
}
-template<class T, class U> shared_ptr<T> dynamic_pointer_cast(shared_ptr<U> const & r)
+template<class T, class U> shared_ptr< T > dynamic_pointer_cast(shared_ptr<U> const & r)
{
- return shared_ptr<T>(r, detail::dynamic_cast_tag());
+ return shared_ptr< T >(r, detail::dynamic_cast_tag());
}
// shared_*_cast names are deprecated. Use *_pointer_cast instead.
-template<class T, class U> shared_ptr<T> shared_static_cast(shared_ptr<U> const & r)
+template<class T, class U> shared_ptr< T > shared_static_cast(shared_ptr<U> const & r)
{
- return shared_ptr<T>(r, detail::static_cast_tag());
+ return shared_ptr< T >(r, detail::static_cast_tag());
}
-template<class T, class U> shared_ptr<T> shared_dynamic_cast(shared_ptr<U> const & r)
+template<class T, class U> shared_ptr< T > shared_dynamic_cast(shared_ptr<U> const & r)
{
- return shared_ptr<T>(r, detail::dynamic_cast_tag());
+ return shared_ptr< T >(r, detail::dynamic_cast_tag());
}
-template<class T, class U> shared_ptr<T> shared_polymorphic_cast(shared_ptr<U> const & r)
+template<class T, class U> shared_ptr< T > shared_polymorphic_cast(shared_ptr<U> const & r)
{
- return shared_ptr<T>(r, detail::polymorphic_cast_tag());
+ return shared_ptr< T >(r, detail::polymorphic_cast_tag());
}
-template<class T, class U> shared_ptr<T> shared_polymorphic_downcast(shared_ptr<U> const & r)
+template<class T, class U> shared_ptr< T > shared_polymorphic_downcast(shared_ptr<U> const & r)
{
BOOST_ASSERT(dynamic_cast<T *>(r.get()) == r.get());
- return shared_static_cast<T>(r);
+ return shared_static_cast< T >(r);
}
// get_pointer() enables boost::mem_fn to recognize shared_ptr
-template<class T> inline T * get_pointer(shared_ptr<T> const & p)
+template<class T> inline T * get_pointer(shared_ptr< T > const & p)
{
return p.get();
}
@@ -452,7 +452,7 @@
// g++ 2.9x doesn't allow static_cast<X const *>(void *)
// apparently EDG 2.38 also doesn't accept it
-template<class D, class T> D * get_deleter(shared_ptr<T> const & p)
+template<class D, class T> D * get_deleter(shared_ptr< T > const & p)
{
void const * q = p._internal_get_deleter(typeid(D));
return const_cast<D *>(static_cast<D const *>(q));
@@ -460,7 +460,7 @@
#else
-template<class D, class T> D * get_deleter(shared_ptr<T> const & p)
+template<class D, class T> D * get_deleter(shared_ptr< T > const & p)
{
return static_cast<D *>(p._internal_get_deleter(typeid(D)));
}
Modified: trunk/boost/serialization/detail/shared_ptr_nmt_132.hpp
==============================================================================
--- trunk/boost/serialization/detail/shared_ptr_nmt_132.hpp (original)
+++ trunk/boost/serialization/detail/shared_ptr_nmt_132.hpp 2010-10-19 15:45:11 EDT (Tue, 19 Oct 2010)
@@ -91,13 +91,13 @@
#ifndef BOOST_NO_AUTO_PTR
- explicit shared_ptr(std::auto_ptr<T> & r)
+ explicit shared_ptr(std::auto_ptr< T > & r)
{
pn = new count_type(1); // may throw
px = r.release(); // fix: moved here to stop leak if new throws
}
- shared_ptr & operator=(std::auto_ptr<T> & r)
+ shared_ptr & operator=(std::auto_ptr< T > & r)
{
shared_ptr(r).swap(*this);
return *this;
@@ -138,7 +138,7 @@
return *pn == 1;
}
- void swap(shared_ptr<T> & other) // never throws
+ void swap(shared_ptr< T > & other) // never throws
{
std::swap(px, other.px);
std::swap(pn, other.pn);
@@ -150,29 +150,29 @@
count_type * pn; // ptr to reference counter
};
-template<class T, class U> inline bool operator==(shared_ptr<T> const & a, shared_ptr<U> const & b)
+template<class T, class U> inline bool operator==(shared_ptr< T > const & a, shared_ptr<U> const & b)
{
return a.get() == b.get();
}
-template<class T, class U> inline bool operator!=(shared_ptr<T> const & a, shared_ptr<U> const & b)
+template<class T, class U> inline bool operator!=(shared_ptr< T > const & a, shared_ptr<U> const & b)
{
return a.get() != b.get();
}
-template<class T> inline bool operator<(shared_ptr<T> const & a, shared_ptr<T> const & b)
+template<class T> inline bool operator<(shared_ptr< T > const & a, shared_ptr< T > const & b)
{
return std::less<T*>()(a.get(), b.get());
}
-template<class T> void swap(shared_ptr<T> & a, shared_ptr<T> & b)
+template<class T> void swap(shared_ptr< T > & a, shared_ptr< T > & b)
{
a.swap(b);
}
// get_pointer() enables boost::mem_fn to recognize shared_ptr
-template<class T> inline T * get_pointer(shared_ptr<T> const & p)
+template<class T> inline T * get_pointer(shared_ptr< T > const & p)
{
return p.get();
}
Modified: trunk/boost/serialization/export.hpp
==============================================================================
--- trunk/boost/serialization/export.hpp (original)
+++ trunk/boost/serialization/export.hpp 2010-10-19 15:45:11 EDT (Tue, 19 Oct 2010)
@@ -134,12 +134,12 @@
const void export_guid(mpl::true_) const {
}
guid_initializer const & export_guid() const {
- BOOST_STATIC_WARNING(boost::is_polymorphic<T>::value);
+ BOOST_STATIC_WARNING(boost::is_polymorphic< T >::value);
// note: exporting an abstract base class will have no effect
// and cannot be used to instantitiate serialization code
// (one might be using this in a DLL to instantiate code)
- //BOOST_STATIC_WARNING(! boost::serialization::is_abstract<T>::value);
- export_guid(boost::serialization::is_abstract<T>());
+ //BOOST_STATIC_WARNING(! boost::serialization::is_abstract< T >::value);
+ export_guid(boost::serialization::is_abstract< T >());
return *this;
}
};
@@ -172,9 +172,9 @@
namespace boost { \
namespace serialization { \
template<> \
-struct guid_defined<T> : boost::mpl::true_ {}; \
+struct guid_defined< T > : boost::mpl::true_ {}; \
template<> \
-inline const char * guid<T>(){ \
+inline const char * guid< T >(){ \
return K; \
} \
} /* serialization */ \
Modified: trunk/boost/serialization/extended_type_info.hpp
==============================================================================
--- trunk/boost/serialization/extended_type_info.hpp (original)
+++ trunk/boost/serialization/extended_type_info.hpp 2010-10-19 15:45:11 EDT (Tue, 19 Oct 2010)
@@ -80,7 +80,10 @@
bool operator!=(const extended_type_info &rhs) const {
return !(operator==(rhs));
}
- static const extended_type_info * find(const char *key);
+ // note explicit "export" of static function to work around
+ // gcc 4.5 mingw error
+ static const extended_type_info *
+ find(const char *key);
// for plugins
virtual void * construct(unsigned int /*count*/ = 0, ...) const = 0;
virtual void destroy(void const * const /*p*/) const = 0;
Modified: trunk/boost/serialization/extended_type_info_no_rtti.hpp
==============================================================================
--- trunk/boost/serialization/extended_type_info_no_rtti.hpp (original)
+++ trunk/boost/serialization/extended_type_info_no_rtti.hpp 2010-10-19 15:45:11 EDT (Tue, 19 Oct 2010)
@@ -70,13 +70,13 @@
template<class T>
class extended_type_info_no_rtti :
public no_rtti_system::extended_type_info_no_rtti_0,
- public singleton<extended_type_info_no_rtti<T> >
+ public singleton<extended_type_info_no_rtti< T > >
{
template<bool tf>
struct action {
struct defined {
static const char * invoke(){
- return guid<T>();
+ return guid< T >();
}
};
struct undefined {
@@ -113,16 +113,16 @@
// that the specified type has a function of the following signature.
// A common implemention of such a function is to define as a virtual
// function. So if the is not a polymporphic type it's likely an error
- BOOST_STATIC_WARNING(boost::is_polymorphic<T>::value);
+ BOOST_STATIC_WARNING(boost::is_polymorphic< T >::value);
const char * derived_key = t.get_key();
assert(NULL != derived_key);
return boost::serialization::extended_type_info::find(derived_key);
}
const char * get_key() const{
- return action<guid_defined<T>::value >::invoke();
+ return action<guid_defined< T >::value >::invoke();
}
virtual const char * get_debug_info() const{
- return action<guid_defined<T>::value >::invoke();
+ return action<guid_defined< T >::value >::invoke();
}
virtual void * construct(unsigned int count, ...) const{
// count up the arguments
@@ -130,15 +130,15 @@
va_start(ap, count);
switch(count){
case 0:
- return factory<BOOST_DEDUCED_TYPENAME boost::remove_const<T>::type, 0>(ap);
+ return factory<BOOST_DEDUCED_TYPENAME boost::remove_const< T >::type, 0>(ap);
case 1:
- return factory<BOOST_DEDUCED_TYPENAME boost::remove_const<T>::type, 1>(ap);
+ return factory<BOOST_DEDUCED_TYPENAME boost::remove_const< T >::type, 1>(ap);
case 2:
- return factory<BOOST_DEDUCED_TYPENAME boost::remove_const<T>::type, 2>(ap);
+ return factory<BOOST_DEDUCED_TYPENAME boost::remove_const< T >::type, 2>(ap);
case 3:
- return factory<BOOST_DEDUCED_TYPENAME boost::remove_const<T>::type, 3>(ap);
+ return factory<BOOST_DEDUCED_TYPENAME boost::remove_const< T >::type, 3>(ap);
case 4:
- return factory<BOOST_DEDUCED_TYPENAME boost::remove_const<T>::type, 4>(ap);
+ return factory<BOOST_DEDUCED_TYPENAME boost::remove_const< T >::type, 4>(ap);
default:
assert(false); // too many arguments
// throw exception here?
@@ -168,7 +168,7 @@
template<class T>
struct extended_type_info_impl {
typedef BOOST_DEDUCED_TYPENAME
- boost::serialization::extended_type_info_no_rtti<T> type;
+ boost::serialization::extended_type_info_no_rtti< T > type;
};
} // namespace serialization
} // namespace boost
Modified: trunk/boost/serialization/extended_type_info_typeid.hpp
==============================================================================
--- trunk/boost/serialization/extended_type_info_typeid.hpp (original)
+++ trunk/boost/serialization/extended_type_info_typeid.hpp 2010-10-19 15:45:11 EDT (Tue, 19 Oct 2010)
@@ -80,7 +80,7 @@
template<class T>
class extended_type_info_typeid :
public typeid_system::extended_type_info_typeid_0,
- public singleton<extended_type_info_typeid<T> >
+ public singleton<extended_type_info_typeid< T > >
{
public:
extended_type_info_typeid() :
@@ -99,14 +99,14 @@
get_derived_extended_type_info(const T & t) const {
// note: this implementation - based on usage of typeid (rtti)
// only does something if the class has at least one virtual function.
- BOOST_STATIC_WARNING(boost::is_polymorphic<T>::value);
+ BOOST_STATIC_WARNING(boost::is_polymorphic< T >::value);
return
typeid_system::extended_type_info_typeid_0::get_extended_type_info(
typeid(t)
);
}
const char * get_key() const {
- return boost::serialization::guid<T>();
+ return boost::serialization::guid< T >();
}
virtual void * construct(unsigned int count, ...) const{
// count up the arguments
@@ -114,15 +114,15 @@
va_start(ap, count);
switch(count){
case 0:
- return factory<BOOST_DEDUCED_TYPENAME boost::remove_const<T>::type, 0>(ap);
+ return factory<BOOST_DEDUCED_TYPENAME boost::remove_const< T >::type, 0>(ap);
case 1:
- return factory<BOOST_DEDUCED_TYPENAME boost::remove_const<T>::type, 1>(ap);
+ return factory<BOOST_DEDUCED_TYPENAME boost::remove_const< T >::type, 1>(ap);
case 2:
- return factory<BOOST_DEDUCED_TYPENAME boost::remove_const<T>::type, 2>(ap);
+ return factory<BOOST_DEDUCED_TYPENAME boost::remove_const< T >::type, 2>(ap);
case 3:
- return factory<BOOST_DEDUCED_TYPENAME boost::remove_const<T>::type, 3>(ap);
+ return factory<BOOST_DEDUCED_TYPENAME boost::remove_const< T >::type, 3>(ap);
case 4:
- return factory<BOOST_DEDUCED_TYPENAME boost::remove_const<T>::type, 4>(ap);
+ return factory<BOOST_DEDUCED_TYPENAME boost::remove_const< T >::type, 4>(ap);
default:
assert(false); // too many arguments
// throw exception here?
@@ -151,7 +151,7 @@
template<class T>
struct extended_type_info_impl {
typedef BOOST_DEDUCED_TYPENAME
- boost::serialization::extended_type_info_typeid<T> type;
+ boost::serialization::extended_type_info_typeid< T > type;
};
} // namespace serialization
} // namespace boost
Modified: trunk/boost/serialization/is_bitwise_serializable.hpp
==============================================================================
--- trunk/boost/serialization/is_bitwise_serializable.hpp (original)
+++ trunk/boost/serialization/is_bitwise_serializable.hpp 2010-10-19 15:45:11 EDT (Tue, 19 Oct 2010)
@@ -28,7 +28,7 @@
namespace serialization {
template<class T>
struct is_bitwise_serializable
- : public is_arithmetic<T>
+ : public is_arithmetic< T >
{};
} // namespace serialization
} // namespace boost
Modified: trunk/boost/serialization/level.hpp
==============================================================================
--- trunk/boost/serialization/level.hpp (original)
+++ trunk/boost/serialization/level.hpp 2010-10-19 15:45:11 EDT (Tue, 19 Oct 2010)
@@ -52,18 +52,18 @@
typedef
BOOST_DEDUCED_TYPENAME mpl::eval_if<
is_base_and_derived<boost::serialization::basic_traits, T>,
- traits_class_level<T>,
+ traits_class_level< T >,
//else
BOOST_DEDUCED_TYPENAME mpl::eval_if<
- is_fundamental<T>,
+ is_fundamental< T >,
mpl::int_<primitive_type>,
//else
BOOST_DEDUCED_TYPENAME mpl::eval_if<
- is_class<T>,
+ is_class< T >,
mpl::int_<object_class_info>,
//else
BOOST_DEDUCED_TYPENAME mpl::eval_if<
- is_array<T>,
+ is_array< T >,
#if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x560))
mpl::int_<not_serializable>,
#else
@@ -71,7 +71,7 @@
#endif
//else
BOOST_DEDUCED_TYPENAME mpl::eval_if<
- is_enum<T>,
+ is_enum< T >,
//#if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x560))
// mpl::int_<not_serializable>,
//#else
@@ -95,7 +95,7 @@
};
template<class T, BOOST_MPL_AUX_NTTP_DECL(int, L) >
-inline bool operator>=(implementation_level<T> t, enum level_type l)
+inline bool operator>=(implementation_level< T > t, enum level_type l)
{
return t.value >= (int)l;
}
Modified: trunk/boost/serialization/nvp.hpp
==============================================================================
--- trunk/boost/serialization/nvp.hpp (original)
+++ trunk/boost/serialization/nvp.hpp 2010-10-19 15:45:11 EDT (Tue, 19 Oct 2010)
@@ -41,7 +41,7 @@
template<class T>
struct nvp :
public std::pair<const char *, T *>,
- public wrapper_traits<const nvp<T> >
+ public wrapper_traits<const nvp< T > >
{
explicit nvp(const char * name_, T & t) :
// note: redundant cast works around borland issue
@@ -94,8 +94,8 @@
#ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING
const
#endif
-nvp<T> make_nvp(const char * name, T & t){
- return nvp<T>(name, t);
+nvp< T > make_nvp(const char * name, T & t){
+ return nvp< T >(name, t);
}
// to maintain efficiency and portability, we want to assign
@@ -107,7 +107,7 @@
#if 0 // #ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
template <class T>
-struct implementation_level<nvp<T> >
+struct implementation_level<nvp< T > >
{
typedef mpl::integral_c_tag tag;
typedef mpl::int_<object_serializable> type;
@@ -116,7 +116,7 @@
// nvp objects are generally created on the stack and are never tracked
template<class T>
-struct tracking_level<nvp<T> >
+struct tracking_level<nvp< T > >
{
typedef mpl::integral_c_tag tag;
typedef mpl::int_<track_never> type;
Modified: trunk/boost/serialization/optional.hpp
==============================================================================
--- trunk/boost/serialization/optional.hpp (original)
+++ trunk/boost/serialization/optional.hpp 2010-10-19 15:45:11 EDT (Tue, 19 Oct 2010)
@@ -34,13 +34,13 @@
template<class Archive, class T>
void save(
Archive & ar,
- const boost::optional<T> & t,
+ const boost::optional< T > & t,
const unsigned int /*version*/
){
const bool tflag = t.is_initialized();
ar << boost::serialization::make_nvp("initialized", tflag);
if (tflag){
- const boost::serialization::item_version_type item_version(version<T>::value);
+ const boost::serialization::item_version_type item_version(version< T >::value);
#if 0
const boost::archive::library_version_type library_version(
ar.get_library_version()
@@ -58,7 +58,7 @@
template<class Archive, class T>
void load(
Archive & ar,
- boost::optional<T> & t,
+ boost::optional< T > & t,
const unsigned int /*version*/
){
bool tflag;
@@ -84,7 +84,7 @@
template<class Archive, class T>
void serialize(
Archive & ar,
- boost::optional<T> & t,
+ boost::optional< T > & t,
const unsigned int version
){
boost::serialization::split_free(ar, t, version);
@@ -98,7 +98,7 @@
#if 0
template <class T>
-struct implementation_level<optional<T> >
+struct implementation_level<optional< T > >
{
typedef mpl::integral_c_tag tag;
typedef mpl::int_<boost::serialization::object_serializable> type;
@@ -109,7 +109,7 @@
};
template<class T>
-struct tracking_level<optional<T> >
+struct tracking_level<optional< T > >
{
typedef mpl::integral_c_tag tag;
typedef mpl::int_<boost::serialization::track_never> type;
Modified: trunk/boost/serialization/pfto.hpp
==============================================================================
--- trunk/boost/serialization/pfto.hpp (original)
+++ trunk/boost/serialization/pfto.hpp 2010-10-19 15:45:11 EDT (Tue, 19 Oct 2010)
@@ -53,12 +53,12 @@
};
template<class T>
-pfto_wrapper<T> make_pfto_wrapper(const T & t, BOOST_PFTO int){
- return pfto_wrapper<T>(t);
+pfto_wrapper< T > make_pfto_wrapper(const T & t, BOOST_PFTO int){
+ return pfto_wrapper< T >(t);
}
template<class T>
-pfto_wrapper<T> make_pfto_wrapper(const pfto_wrapper<T> & t, int){
+pfto_wrapper< T > make_pfto_wrapper(const pfto_wrapper< T > & t, int){
return t;
}
@@ -67,7 +67,7 @@
#ifdef BOOST_NO_FUNCTION_TEMPLATE_ORDERING
#define BOOST_PFTO_WRAPPER(T) \
- boost::serialization::pfto_wrapper<T>
+ boost::serialization::pfto_wrapper< T >
#define BOOST_MAKE_PFTO_WRAPPER(t) \
boost::serialization::make_pfto_wrapper(t, 0)
#else
Modified: trunk/boost/serialization/scoped_ptr.hpp
==============================================================================
--- trunk/boost/serialization/scoped_ptr.hpp (original)
+++ trunk/boost/serialization/scoped_ptr.hpp 2010-10-19 15:45:11 EDT (Tue, 19 Oct 2010)
@@ -25,7 +25,7 @@
template<class Archive, class T>
void save(
Archive & ar,
- const boost::scoped_ptr<T> & t,
+ const boost::scoped_ptr< T > & t,
const unsigned int /* version */
){
T* r = t.get();
@@ -35,7 +35,7 @@
template<class Archive, class T>
void load(
Archive & ar,
- boost::scoped_ptr<T> & t,
+ boost::scoped_ptr< T > & t,
const unsigned int /* version */
){
T* r;
@@ -46,7 +46,7 @@
template<class Archive, class T>
void serialize(
Archive& ar,
- boost::scoped_ptr<T>& t,
+ boost::scoped_ptr< T >& t,
const unsigned int version
){
boost::serialization::split_free(ar, t, version);
Modified: trunk/boost/serialization/shared_ptr.hpp
==============================================================================
--- trunk/boost/serialization/shared_ptr.hpp (original)
+++ trunk/boost/serialization/shared_ptr.hpp 2010-10-19 15:45:11 EDT (Tue, 19 Oct 2010)
@@ -39,7 +39,7 @@
namespace boost {
namespace serialization{
template<class T>
- struct version< ::boost::shared_ptr<T> > {
+ struct version< ::boost::shared_ptr< T > > {
typedef mpl::integral_c_tag tag;
#if BOOST_WORKAROUND(__MWERKS__, BOOST_TESTED_AT(0x3206))
typedef BOOST_DEDUCED_TYPENAME mpl::int_<1> type;
@@ -54,7 +54,7 @@
};
// don't track shared pointers
template<class T>
- struct tracking_level< ::boost::shared_ptr<T> > {
+ struct tracking_level< ::boost::shared_ptr< T > > {
typedef mpl::integral_c_tag tag;
#if BOOST_WORKAROUND(__MWERKS__, BOOST_TESTED_AT(0x3206))
typedef BOOST_DEDUCED_TYPENAME mpl::int_< ::boost::serialization::track_never> type;
@@ -96,13 +96,13 @@
template<class Archive, class T>
inline void save(
Archive & ar,
- const boost::shared_ptr<T> &t,
+ const boost::shared_ptr< T > &t,
const unsigned int /* file_version */
){
// The most common cause of trapping here would be serializing
// something like shared_ptr<int>. This occurs because int
// is never tracked by default. Wrap int in a trackable type
- BOOST_STATIC_ASSERT((tracking_level<T>::value != track_never));
+ BOOST_STATIC_ASSERT((tracking_level< T >::value != track_never));
const T * t_ptr = t.get();
ar << boost::serialization::make_nvp("px", t_ptr);
}
@@ -111,22 +111,22 @@
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
){
// The most common cause of trapping here would be serializing
// something like shared_ptr<int>. This occurs because int
// is never tracked by default. Wrap int in a trackable type
- BOOST_STATIC_ASSERT((tracking_level<T>::value != track_never));
+ BOOST_STATIC_ASSERT((tracking_level< T >::value != track_never));
T* r;
if(file_version < 1){
//ar.register_type(static_cast<
- // boost_132::detail::sp_counted_base_impl<T *, boost::checked_deleter<T> > *
+ // boost_132::detail::sp_counted_base_impl<T *, boost::checked_deleter< T > > *
//>(NULL));
ar.register_type(static_cast<
boost_132::detail::sp_counted_base_impl<T *, null_deleter > *
>(NULL));
- boost_132::shared_ptr<T> sp;
+ boost_132::shared_ptr< T > sp;
ar >> boost::serialization::make_nvp("px", sp.px);
ar >> boost::serialization::make_nvp("pn", sp.pn);
// got to keep the sps around so the sp.pns don't disappear
@@ -143,13 +143,13 @@
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*/
){
// The most common cause of trapping here would be serializing
// something like shared_ptr<int>. This occurs because int
// is never tracked by default. Wrap int in a trackable type
- BOOST_STATIC_ASSERT((tracking_level<T>::value != track_never));
+ BOOST_STATIC_ASSERT((tracking_level< T >::value != track_never));
T* r;
ar >> boost::serialization::make_nvp("px", r);
ar.reset(t,r);
@@ -159,13 +159,13 @@
template<class Archive, class T>
inline void serialize(
Archive & ar,
- boost::shared_ptr<T> &t,
+ boost::shared_ptr< T > &t,
const unsigned int file_version
){
// correct shared_ptr serialization depends upon object tracking
// being used.
BOOST_STATIC_ASSERT(
- boost::serialization::tracking_level<T>::value
+ boost::serialization::tracking_level< T >::value
!= boost::serialization::track_never
);
boost::serialization::split_free(ar, t, file_version);
Modified: trunk/boost/serialization/shared_ptr_132.hpp
==============================================================================
--- trunk/boost/serialization/shared_ptr_132.hpp (original)
+++ trunk/boost/serialization/shared_ptr_132.hpp 2010-10-19 15:45:11 EDT (Tue, 19 Oct 2010)
@@ -147,7 +147,7 @@
BOOST_SERIALIZATION_SPLIT_FREE(boost_132::detail::shared_count)
/////////////////////////////////////////////////////////////
-// implement serialization for shared_ptr<T>
+// implement serialization for shared_ptr< T >
namespace boost {
namespace serialization {
@@ -155,13 +155,13 @@
template<class Archive, class T>
inline void save(
Archive & ar,
- const boost_132::shared_ptr<T> &t,
+ const boost_132::shared_ptr< T > &t,
const unsigned int /* file_version */
){
// only the raw pointer has to be saved
// the ref count is maintained automatically as shared pointers are loaded
ar.register_type(static_cast<
- boost_132::detail::sp_counted_base_impl<T *, boost::checked_deleter<T> > *
+ boost_132::detail::sp_counted_base_impl<T *, boost::checked_deleter< T > > *
>(NULL));
ar << boost::serialization::make_nvp("px", t.px);
ar << boost::serialization::make_nvp("pn", t.pn);
@@ -170,13 +170,13 @@
template<class Archive, class T>
inline void load(
Archive & ar,
- boost_132::shared_ptr<T> &t,
+ boost_132::shared_ptr< T > &t,
const unsigned int /* file_version */
){
// only the raw pointer has to be saved
// the ref count is maintained automatically as shared pointers are loaded
ar.register_type(static_cast<
- boost_132::detail::sp_counted_base_impl<T *, boost::checked_deleter<T> > *
+ boost_132::detail::sp_counted_base_impl<T *, boost::checked_deleter< T > > *
>(NULL));
ar >> boost::serialization::make_nvp("px", t.px);
ar >> boost::serialization::make_nvp("pn", t.pn);
@@ -185,13 +185,13 @@
template<class Archive, class T>
inline void serialize(
Archive & ar,
- boost_132::shared_ptr<T> &t,
+ boost_132::shared_ptr< T > &t,
const unsigned int file_version
){
// correct shared_ptr serialization depends upon object tracking
// being used.
BOOST_STATIC_ASSERT(
- boost::serialization::tracking_level<T>::value
+ boost::serialization::tracking_level< T >::value
!= boost::serialization::track_never
);
boost::serialization::split_free(ar, t, file_version);
Modified: trunk/boost/serialization/singleton.hpp
==============================================================================
--- trunk/boost/serialization/singleton.hpp (original)
+++ trunk/boost/serialization/singleton.hpp 2010-10-19 15:45:11 EDT (Tue, 19 Oct 2010)
@@ -113,7 +113,7 @@
};
template<class T>
-bool detail::singleton_wrapper<T>::m_is_destroyed = false;
+bool detail::singleton_wrapper< T >::m_is_destroyed = false;
} // detail
@@ -125,10 +125,10 @@
// include this to provoke instantiation at pre-execution time
static void use(T const &) {}
BOOST_DLLEXPORT static T & get_instance() {
- static detail::singleton_wrapper<T> t;
+ static detail::singleton_wrapper< T > t;
// refer to instance, causing it to be instantiated (and
// initialized at startup on working compilers)
- assert(! detail::singleton_wrapper<T>::m_is_destroyed);
+ assert(! detail::singleton_wrapper< T >::m_is_destroyed);
use(instance);
return static_cast<T &>(t);
}
@@ -141,12 +141,12 @@
return get_instance();
}
BOOST_DLLEXPORT static bool is_destroyed(){
- return detail::singleton_wrapper<T>::m_is_destroyed;
+ return detail::singleton_wrapper< T >::m_is_destroyed;
}
};
template<class T>
-BOOST_DLLEXPORT T & singleton<T>::instance = singleton<T>::get_instance();
+BOOST_DLLEXPORT T & singleton< T >::instance = singleton< T >::get_instance();
} // namespace serialization
} // namespace boost
Modified: trunk/boost/serialization/smart_cast.hpp
==============================================================================
--- trunk/boost/serialization/smart_cast.hpp (original)
+++ trunk/boost/serialization/smart_cast.hpp 2010-10-19 15:45:11 EDT (Tue, 19 Oct 2010)
@@ -68,14 +68,14 @@
struct linear {
template<class U>
static T cast(U & u){
- return static_cast<T>(u);
+ return static_cast< T >(u);
}
};
struct cross {
template<class U>
static T cast(U & u){
- return dynamic_cast<T>(u);
+ return dynamic_cast< T >(u);
}
};
@@ -96,12 +96,12 @@
typedef BOOST_DEDUCED_TYPENAME mpl::eval_if<
BOOST_DEDUCED_TYPENAME mpl::and_<
mpl::not_<is_base_and_derived<
- BOOST_DEDUCED_TYPENAME remove_reference<T>::type,
+ BOOST_DEDUCED_TYPENAME remove_reference< T >::type,
U
> >,
mpl::not_<is_base_and_derived<
U,
- BOOST_DEDUCED_TYPENAME remove_reference<T>::type
+ BOOST_DEDUCED_TYPENAME remove_reference< T >::type
> >
>,
// borland chokes w/o full qualification here
@@ -117,7 +117,7 @@
struct non_polymorphic {
template<class U>
static T cast(U & u){
- return static_cast<T>(u);
+ return static_cast< T >(u);
}
};
template<class U>
@@ -150,14 +150,14 @@
struct linear {
template<class U>
static T cast(U * u){
- return static_cast<T>(u);
+ return static_cast< T >(u);
}
};
struct cross {
template<class U>
static T cast(U * u){
- T tmp = dynamic_cast<T>(u);
+ T tmp = dynamic_cast< T >(u);
#ifndef NDEBUG
if ( tmp == 0 ) throw std::bad_cast();
#endif
@@ -181,12 +181,12 @@
BOOST_DEDUCED_TYPENAME mpl::eval_if<
BOOST_DEDUCED_TYPENAME mpl::and_<
mpl::not_<is_base_and_derived<
- BOOST_DEDUCED_TYPENAME remove_pointer<T>::type,
+ BOOST_DEDUCED_TYPENAME remove_pointer< T >::type,
U
> >,
mpl::not_<is_base_and_derived<
U,
- BOOST_DEDUCED_TYPENAME remove_pointer<T>::type
+ BOOST_DEDUCED_TYPENAME remove_pointer< T >::type
> >
>,
// borland chokes w/o full qualification here
@@ -199,7 +199,7 @@
#else
template<class U>
static T cast(U * u){
- T tmp = dynamic_cast<T>(u);
+ T tmp = dynamic_cast< T >(u);
#ifndef NDEBUG
if ( tmp == 0 ) throw std::bad_cast();
#endif
@@ -211,7 +211,7 @@
struct non_polymorphic {
template<class U>
static T cast(U * u){
- return static_cast<T>(u);
+ return static_cast< T >(u);
}
};
@@ -272,15 +272,15 @@
boost::is_same<const void *, U>,
boost::is_same<const void *, T>
>,
- mpl::identity<smart_cast_impl::void_pointer<T> >,
+ mpl::identity<smart_cast_impl::void_pointer< T > >,
// else
BOOST_DEDUCED_TYPENAME mpl::eval_if<boost::is_pointer<U>,
- mpl::identity<smart_cast_impl::pointer<T> >,
+ mpl::identity<smart_cast_impl::pointer< T > >,
// else
BOOST_DEDUCED_TYPENAME mpl::eval_if<boost::is_reference<U>,
- mpl::identity<smart_cast_impl::reference<T> >,
+ mpl::identity<smart_cast_impl::reference< T > >,
// else
- mpl::identity<smart_cast_impl::error<T>
+ mpl::identity<smart_cast_impl::error< T >
>
>
>
@@ -292,7 +292,7 @@
// smart_cast_reference<Target &>(Source & s)
template<class T, class U>
T smart_cast_reference(U & u) {
- return smart_cast_impl::reference<T>::cast(u);
+ return smart_cast_impl::reference< T >::cast(u);
}
} // namespace serialization
Modified: trunk/boost/serialization/state_saver.hpp
==============================================================================
--- trunk/boost/serialization/state_saver.hpp (original)
+++ trunk/boost/serialization/state_saver.hpp 2010-10-19 15:45:11 EDT (Tue, 19 Oct 2010)
@@ -78,7 +78,7 @@
~state_saver() {
#ifndef BOOST_NO_EXCEPTIONS
typedef BOOST_DEDUCED_TYPENAME mpl::eval_if<
- has_nothrow_copy<T>,
+ has_nothrow_copy< T >,
mpl::identity<restore>,
mpl::identity<restore_with_exception>
>::type typex;
Modified: trunk/boost/serialization/tracking.hpp
==============================================================================
--- trunk/boost/serialization/tracking.hpp (original)
+++ trunk/boost/serialization/tracking.hpp 2010-10-19 15:45:11 EDT (Tue, 19 Oct 2010)
@@ -49,17 +49,17 @@
typedef
BOOST_DEDUCED_TYPENAME mpl::eval_if<
is_base_and_derived<boost::serialization::basic_traits, T>,
- traits_class_tracking<T>,
+ traits_class_tracking< T >,
//else
BOOST_DEDUCED_TYPENAME mpl::eval_if<
- is_pointer<T>,
+ is_pointer< T >,
// pointers are not tracked by default
mpl::int_<track_never>,
//else
BOOST_DEDUCED_TYPENAME mpl::eval_if<
// for primitives
BOOST_DEDUCED_TYPENAME mpl::equal_to<
- implementation_level<T>,
+ implementation_level< T >,
mpl::int_<primitive_type>
>,
// is never
@@ -77,7 +77,7 @@
};
template<class T, enum tracking_type L>
-inline bool operator>=(tracking_level<T> t, enum tracking_type l)
+inline bool operator>=(tracking_level< T > t, enum tracking_type l)
{
return t.value >= (int)l;
}
Modified: trunk/boost/serialization/type_info_implementation.hpp
==============================================================================
--- trunk/boost/serialization/type_info_implementation.hpp (original)
+++ trunk/boost/serialization/type_info_implementation.hpp 2010-10-19 15:45:11 EDT (Tue, 19 Oct 2010)
@@ -42,10 +42,10 @@
typedef
BOOST_DEDUCED_TYPENAME mpl::eval_if<
is_base_and_derived<boost::serialization::basic_traits, T>,
- traits_class_typeinfo_implementation<T>,
+ traits_class_typeinfo_implementation< T >,
//else
mpl::identity<
- BOOST_DEDUCED_TYPENAME extended_type_info_impl<T>::type
+ BOOST_DEDUCED_TYPENAME extended_type_info_impl< T >::type
>
>::type type;
};
Modified: trunk/boost/serialization/utility.hpp
==============================================================================
--- trunk/boost/serialization/utility.hpp (original)
+++ trunk/boost/serialization/utility.hpp 2010-10-19 15:45:11 EDT (Tue, 19 Oct 2010)
@@ -46,7 +46,7 @@
/// specialization of is_bitwise_serializable for pairs
template <class T, class U>
struct is_bitwise_serializable<std::pair<T,U> >
- : public mpl::and_<is_bitwise_serializable<T>,is_bitwise_serializable<U> >
+ : public mpl::and_<is_bitwise_serializable< T >,is_bitwise_serializable<U> >
{
};
Modified: trunk/boost/serialization/valarray.hpp
==============================================================================
--- trunk/boost/serialization/valarray.hpp (original)
+++ trunk/boost/serialization/valarray.hpp 2010-10-19 15:45:11 EDT (Tue, 19 Oct 2010)
@@ -34,7 +34,7 @@
namespace boost { namespace serialization {
/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// valarray<T>
+// valarray< T >
template<class Archive, class U>
void save( Archive & ar, const STD::valarray<U> &t, const unsigned int /*file_version*/ )
Modified: trunk/boost/serialization/vector.hpp
==============================================================================
--- trunk/boost/serialization/vector.hpp (original)
+++ trunk/boost/serialization/vector.hpp 2010-10-19 15:45:11 EDT (Tue, 19 Oct 2010)
@@ -39,7 +39,7 @@
namespace serialization {
/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// vector<T>
+// vector< T >
// the default versions
Modified: trunk/boost/serialization/version.hpp
==============================================================================
--- trunk/boost/serialization/version.hpp (original)
+++ trunk/boost/serialization/version.hpp 2010-10-19 15:45:11 EDT (Tue, 19 Oct 2010)
@@ -46,7 +46,7 @@
typedef
BOOST_DEDUCED_TYPENAME mpl::eval_if<
is_base_and_derived<boost::serialization::basic_traits,T>,
- traits_class_version<T>,
+ traits_class_version< T >,
mpl::int_<0>
>::type type;
BOOST_STATIC_CONSTANT(int, value = version::type::value);
Modified: trunk/boost/serialization/weak_ptr.hpp
==============================================================================
--- trunk/boost/serialization/weak_ptr.hpp (original)
+++ trunk/boost/serialization/weak_ptr.hpp 2010-10-19 15:45:11 EDT (Tue, 19 Oct 2010)
@@ -25,20 +25,20 @@
template<class Archive, class T>
inline void save(
Archive & ar,
- const boost::weak_ptr<T> &t,
+ const boost::weak_ptr< T > &t,
const unsigned int /* file_version */
){
- const boost::shared_ptr<T> sp = t.lock();
+ const boost::shared_ptr< T > sp = t.lock();
ar << boost::serialization::make_nvp("weak_ptr", sp);
}
template<class Archive, class T>
inline void load(
Archive & ar,
- boost::weak_ptr<T> &t,
+ boost::weak_ptr< T > &t,
const unsigned int /* file_version */
){
- boost::shared_ptr<T> sp;
+ boost::shared_ptr< T > sp;
ar >> boost::serialization::make_nvp("weak_ptr", sp);
t = sp;
}
@@ -46,7 +46,7 @@
template<class Archive, class T>
inline void serialize(
Archive & ar,
- boost::weak_ptr<T> &t,
+ boost::weak_ptr< T > &t,
const unsigned int file_version
){
boost::serialization::split_free(ar, t, file_version);
Boost-Commit list run by bdawes at acm.org, david.abrahams at rcn.com, gregod at cs.rpi.edu, cpdaniel at pacbell.net, john at johnmaddock.co.uk