|
|
Boost-Commit : |
Subject: [Boost-commit] svn:boost r66415 - in branches/release/boost/serialization: . detail
From: ramey_at_[hidden]
Date: 2010-11-06 12:41:51
Author: ramey
Date: 2010-11-06 12:41:35 EDT (Sat, 06 Nov 2010)
New Revision: 66415
URL: http://svn.boost.org/trac/boost/changeset/66415
Log:
merge to release branch
Properties modified:
branches/release/boost/serialization/ (props changed)
Text files modified:
branches/release/boost/serialization/array.hpp | 8 +++---
branches/release/boost/serialization/assume_abstract.hpp | 2
branches/release/boost/serialization/complex.hpp | 16 ++++++------
branches/release/boost/serialization/detail/shared_count_132.hpp | 8 +++---
branches/release/boost/serialization/detail/shared_ptr_132.hpp | 52 ++++++++++++++++++++--------------------
branches/release/boost/serialization/detail/shared_ptr_nmt_132.hpp | 16 ++++++------
branches/release/boost/serialization/export.hpp | 14 +++++-----
branches/release/boost/serialization/extended_type_info.hpp | 5 +++
branches/release/boost/serialization/extended_type_info_no_rtti.hpp | 22 ++++++++--------
branches/release/boost/serialization/extended_type_info_typeid.hpp | 18 ++++++------
branches/release/boost/serialization/is_bitwise_serializable.hpp | 2
branches/release/boost/serialization/item_version_type.hpp | 8 ++++-
branches/release/boost/serialization/level.hpp | 12 ++++----
branches/release/boost/serialization/nvp.hpp | 10 +++---
branches/release/boost/serialization/optional.hpp | 12 ++++----
branches/release/boost/serialization/pfto.hpp | 8 +++---
branches/release/boost/serialization/scoped_ptr.hpp | 6 ++--
branches/release/boost/serialization/serialization.hpp | 1
branches/release/boost/serialization/shared_ptr.hpp | 24 +++++++++---------
branches/release/boost/serialization/shared_ptr_132.hpp | 14 +++++-----
branches/release/boost/serialization/singleton.hpp | 10 +++---
branches/release/boost/serialization/smart_cast.hpp | 32 ++++++++++++------------
branches/release/boost/serialization/state_saver.hpp | 2
branches/release/boost/serialization/tracking.hpp | 8 +++---
branches/release/boost/serialization/type_info_implementation.hpp | 4 +-
branches/release/boost/serialization/utility.hpp | 2
branches/release/boost/serialization/valarray.hpp | 2
branches/release/boost/serialization/variant.hpp | 1
branches/release/boost/serialization/vector.hpp | 2
branches/release/boost/serialization/version.hpp | 2
branches/release/boost/serialization/weak_ptr.hpp | 10 +++---
31 files changed, 170 insertions(+), 163 deletions(-)
Modified: branches/release/boost/serialization/array.hpp
==============================================================================
--- branches/release/boost/serialization/array.hpp (original)
+++ branches/release/boost/serialization/array.hpp 2010-11-06 12:41:35 EDT (Sat, 06 Nov 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: branches/release/boost/serialization/assume_abstract.hpp
==============================================================================
--- branches/release/boost/serialization/assume_abstract.hpp (original)
+++ branches/release/boost/serialization/assume_abstract.hpp 2010-11-06 12:41:35 EDT (Sat, 06 Nov 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: branches/release/boost/serialization/complex.hpp
==============================================================================
--- branches/release/boost/serialization/complex.hpp (original)
+++ branches/release/boost/serialization/complex.hpp 2010-11-06 12:41:35 EDT (Sat, 06 Nov 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: branches/release/boost/serialization/detail/shared_count_132.hpp
==============================================================================
--- branches/release/boost/serialization/detail/shared_count_132.hpp (original)
+++ branches/release/boost/serialization/detail/shared_count_132.hpp 2010-11-06 12:41:35 EDT (Sat, 06 Nov 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: branches/release/boost/serialization/detail/shared_ptr_132.hpp
==============================================================================
--- branches/release/boost/serialization/detail/shared_ptr_132.hpp (original)
+++ branches/release/boost/serialization/detail/shared_ptr_132.hpp 2010-11-06 12:41:35 EDT (Sat, 06 Nov 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: branches/release/boost/serialization/detail/shared_ptr_nmt_132.hpp
==============================================================================
--- branches/release/boost/serialization/detail/shared_ptr_nmt_132.hpp (original)
+++ branches/release/boost/serialization/detail/shared_ptr_nmt_132.hpp 2010-11-06 12:41:35 EDT (Sat, 06 Nov 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: branches/release/boost/serialization/export.hpp
==============================================================================
--- branches/release/boost/serialization/export.hpp (original)
+++ branches/release/boost/serialization/export.hpp 2010-11-06 12:41:35 EDT (Sat, 06 Nov 2010)
@@ -120,7 +120,7 @@
// This was made this way so that export.hpp could be included
// in other headers. This is still under study.
-namespace {
+namespace extra_detail {
template<class T>
struct guid_initializer
@@ -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;
}
};
@@ -156,7 +156,7 @@
namespace boost { \
namespace archive { \
namespace detail { \
- namespace { \
+ namespace extra_detail { \
template<> \
struct init_guid< T > { \
static guid_initializer< T > const & g; \
@@ -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: branches/release/boost/serialization/extended_type_info.hpp
==============================================================================
--- branches/release/boost/serialization/extended_type_info.hpp (original)
+++ branches/release/boost/serialization/extended_type_info.hpp 2010-11-06 12:41:35 EDT (Sat, 06 Nov 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: branches/release/boost/serialization/extended_type_info_no_rtti.hpp
==============================================================================
--- branches/release/boost/serialization/extended_type_info_no_rtti.hpp (original)
+++ branches/release/boost/serialization/extended_type_info_no_rtti.hpp 2010-11-06 12:41:35 EDT (Sat, 06 Nov 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: branches/release/boost/serialization/extended_type_info_typeid.hpp
==============================================================================
--- branches/release/boost/serialization/extended_type_info_typeid.hpp (original)
+++ branches/release/boost/serialization/extended_type_info_typeid.hpp 2010-11-06 12:41:35 EDT (Sat, 06 Nov 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: branches/release/boost/serialization/is_bitwise_serializable.hpp
==============================================================================
--- branches/release/boost/serialization/is_bitwise_serializable.hpp (original)
+++ branches/release/boost/serialization/is_bitwise_serializable.hpp 2010-11-06 12:41:35 EDT (Sat, 06 Nov 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: branches/release/boost/serialization/item_version_type.hpp
==============================================================================
--- branches/release/boost/serialization/item_version_type.hpp (original)
+++ branches/release/boost/serialization/item_version_type.hpp 2010-11-06 12:41:35 EDT (Sat, 06 Nov 2010)
@@ -11,6 +11,9 @@
#include <boost/serialization/level.hpp>
#include <boost/serialization/is_bitwise_serializable.hpp>
+// fixes broken example build on x86_64-linux-gnu-gcc-4.6.0
+#include <cassert>
+
namespace boost {
namespace serialization {
@@ -23,8 +26,9 @@
private:
typedef unsigned int base_type;
base_type t;
- item_version_type(): t(0) {};
public:
+ // should be private - but MPI fails if it's not!!!
+ item_version_type(): t(0) {};
explicit item_version_type(const unsigned int t_) : t(t_){
assert(t_ <= boost::integer_traits<base_type>::const_max);
}
@@ -36,7 +40,7 @@
return *this;
}
// used for text output
- operator const base_type () const {
+ operator base_type () const {
return t;
}
// used for text input
Modified: branches/release/boost/serialization/level.hpp
==============================================================================
--- branches/release/boost/serialization/level.hpp (original)
+++ branches/release/boost/serialization/level.hpp 2010-11-06 12:41:35 EDT (Sat, 06 Nov 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: branches/release/boost/serialization/nvp.hpp
==============================================================================
--- branches/release/boost/serialization/nvp.hpp (original)
+++ branches/release/boost/serialization/nvp.hpp 2010-11-06 12:41:35 EDT (Sat, 06 Nov 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: branches/release/boost/serialization/optional.hpp
==============================================================================
--- branches/release/boost/serialization/optional.hpp (original)
+++ branches/release/boost/serialization/optional.hpp 2010-11-06 12:41:35 EDT (Sat, 06 Nov 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: branches/release/boost/serialization/pfto.hpp
==============================================================================
--- branches/release/boost/serialization/pfto.hpp (original)
+++ branches/release/boost/serialization/pfto.hpp 2010-11-06 12:41:35 EDT (Sat, 06 Nov 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: branches/release/boost/serialization/scoped_ptr.hpp
==============================================================================
--- branches/release/boost/serialization/scoped_ptr.hpp (original)
+++ branches/release/boost/serialization/scoped_ptr.hpp 2010-11-06 12:41:35 EDT (Sat, 06 Nov 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: branches/release/boost/serialization/serialization.hpp
==============================================================================
--- branches/release/boost/serialization/serialization.hpp (original)
+++ branches/release/boost/serialization/serialization.hpp 2010-11-06 12:41:35 EDT (Sat, 06 Nov 2010)
@@ -11,7 +11,6 @@
#endif
#include <boost/config.hpp>
-#include <boost/archive/basic_archive.hpp>
#include <boost/serialization/strong_typedef.hpp>
#include <boost/serialization/pfto.hpp>
Modified: branches/release/boost/serialization/shared_ptr.hpp
==============================================================================
--- branches/release/boost/serialization/shared_ptr.hpp (original)
+++ branches/release/boost/serialization/shared_ptr.hpp 2010-11-06 12:41:35 EDT (Sat, 06 Nov 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: branches/release/boost/serialization/shared_ptr_132.hpp
==============================================================================
--- branches/release/boost/serialization/shared_ptr_132.hpp (original)
+++ branches/release/boost/serialization/shared_ptr_132.hpp 2010-11-06 12:41:35 EDT (Sat, 06 Nov 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: branches/release/boost/serialization/singleton.hpp
==============================================================================
--- branches/release/boost/serialization/singleton.hpp (original)
+++ branches/release/boost/serialization/singleton.hpp 2010-11-06 12:41:35 EDT (Sat, 06 Nov 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: branches/release/boost/serialization/smart_cast.hpp
==============================================================================
--- branches/release/boost/serialization/smart_cast.hpp (original)
+++ branches/release/boost/serialization/smart_cast.hpp 2010-11-06 12:41:35 EDT (Sat, 06 Nov 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: branches/release/boost/serialization/state_saver.hpp
==============================================================================
--- branches/release/boost/serialization/state_saver.hpp (original)
+++ branches/release/boost/serialization/state_saver.hpp 2010-11-06 12:41:35 EDT (Sat, 06 Nov 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: branches/release/boost/serialization/tracking.hpp
==============================================================================
--- branches/release/boost/serialization/tracking.hpp (original)
+++ branches/release/boost/serialization/tracking.hpp 2010-11-06 12:41:35 EDT (Sat, 06 Nov 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: branches/release/boost/serialization/type_info_implementation.hpp
==============================================================================
--- branches/release/boost/serialization/type_info_implementation.hpp (original)
+++ branches/release/boost/serialization/type_info_implementation.hpp 2010-11-06 12:41:35 EDT (Sat, 06 Nov 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: branches/release/boost/serialization/utility.hpp
==============================================================================
--- branches/release/boost/serialization/utility.hpp (original)
+++ branches/release/boost/serialization/utility.hpp 2010-11-06 12:41:35 EDT (Sat, 06 Nov 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: branches/release/boost/serialization/valarray.hpp
==============================================================================
--- branches/release/boost/serialization/valarray.hpp (original)
+++ branches/release/boost/serialization/valarray.hpp 2010-11-06 12:41:35 EDT (Sat, 06 Nov 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: branches/release/boost/serialization/variant.hpp
==============================================================================
--- branches/release/boost/serialization/variant.hpp (original)
+++ branches/release/boost/serialization/variant.hpp 2010-11-06 12:41:35 EDT (Sat, 06 Nov 2010)
@@ -41,6 +41,7 @@
#include <boost/serialization/split_free.hpp>
#include <boost/serialization/serialization.hpp>
+#include <boost/serialization/nvp.hpp>
namespace boost {
namespace serialization {
Modified: branches/release/boost/serialization/vector.hpp
==============================================================================
--- branches/release/boost/serialization/vector.hpp (original)
+++ branches/release/boost/serialization/vector.hpp 2010-11-06 12:41:35 EDT (Sat, 06 Nov 2010)
@@ -39,7 +39,7 @@
namespace serialization {
/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// vector<T>
+// vector< T >
// the default versions
Modified: branches/release/boost/serialization/version.hpp
==============================================================================
--- branches/release/boost/serialization/version.hpp (original)
+++ branches/release/boost/serialization/version.hpp 2010-11-06 12:41:35 EDT (Sat, 06 Nov 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: branches/release/boost/serialization/weak_ptr.hpp
==============================================================================
--- branches/release/boost/serialization/weak_ptr.hpp (original)
+++ branches/release/boost/serialization/weak_ptr.hpp 2010-11-06 12:41:35 EDT (Sat, 06 Nov 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