From: ramey_at_[hidden]
Date: 2007-10-29 15:37:11
Author: ramey
Date: 2007-10-29 15:37:09 EDT (Mon, 29 Oct 2007)
New Revision: 40560
URL: http://svn.boost.org/trac/boost/changeset/40560
Log:
First implementation of thread safe lock free serialization
Added:
branches/serialization_next_release/boost/boost/serialization/array.hpp (contents, props changed)
branches/serialization_next_release/boost/boost/serialization/collection_size_type.hpp (contents, props changed)
branches/serialization_next_release/boost/boost/serialization/ephemeral.hpp (contents, props changed)
branches/serialization_next_release/boost/boost/serialization/singleton.hpp (contents, props changed)
branches/serialization_next_release/boost/boost/serialization/valarray.hpp (contents, props changed)
branches/serialization_next_release/boost/boost/serialization/wrapper.hpp (contents, props changed)
Text files modified:
branches/serialization_next_release/boost/boost/serialization/export.hpp | 62 ++++++++++------------
branches/serialization_next_release/boost/boost/serialization/extended_type_info.hpp | 51 ++++++-----------
branches/serialization_next_release/boost/boost/serialization/extended_type_info_no_rtti.hpp | 59 +++------------------
branches/serialization_next_release/boost/boost/serialization/extended_type_info_typeid.hpp | 53 ++++++++----------
branches/serialization_next_release/boost/boost/serialization/type_info_implementation.hpp | 2
branches/serialization_next_release/boost/boost/serialization/void_cast.hpp | 110 +++++++++++++--------------------------
6 files changed, 117 insertions(+), 220 deletions(-)
Added: branches/serialization_next_release/boost/boost/serialization/array.hpp
==============================================================================
--- (empty file)
+++ branches/serialization_next_release/boost/boost/serialization/array.hpp 2007-10-29 15:37:09 EDT (Mon, 29 Oct 2007)
@@ -0,0 +1,107 @@
+#ifndef BOOST_SERIALIZATION_ARRAY_HPP
+#define BOOST_SERIALIZATION_ARRAY_HPP
+
+// (C) Copyright 2005 Matthias Troyer and Dave Abrahams
+// Use, modification and distribution is subject to the Boost Software
+// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+
+#include <boost/serialization/nvp.hpp>
+#include <boost/serialization/split_free.hpp>
+#include <boost/serialization/wrapper.hpp>
+#include <boost/serialization/collection_size_type.hpp>
+#include <boost/archive/archive_exception.hpp>
+#include <boost/throw_exception.hpp>
+#include <iostream>
+
+namespace boost { namespace serialization {
+
+template<class T>
+class array
+ : public wrapper_traits<array<T> >
+{
+public:
+ typedef T value_type;
+
+ array(value_type* t, std::size_t s) :
+ m_t(t),
+ m_element_count(s)
+ {}
+
+ // default implementation
+ template<class Archive>
+ void serialize(Archive &ar, const unsigned int) const
+ {
+ // default implemention does the loop
+ std::size_t c = count();
+ value_type * t = address();
+ while(0 < c--)
+ ar & make_nvp("item", *t++);
+ }
+
+ value_type* address() const
+ {
+ return m_t;
+ }
+
+ std::size_t count() const
+ {
+ return m_element_count;
+ }
+
+
+private:
+ value_type* m_t;
+ std::size_t const m_element_count;
+};
+
+template<class T>
+inline
+#ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING
+const
+#endif
+array<T> make_array( T* t, std::size_t s){
+ return array<T>(t, s);
+}
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// T[N]
+
+/*
+
+template<class Archive, class U, std::size_t N>
+void save( Archive & ar, U const (& t)[N], const unsigned int file_version )
+{
+ const serialization::collection_size_type count(N);
+ ar << BOOST_SERIALIZATION_NVP(count);
+ if (N)
+ ar << serialization::make_array(&t[0],N);
+}
+
+template<class Archive, class U, std::size_t N>
+void load( Archive & ar, U (& t)[N], const unsigned int file_version )
+{
+ serialization::collection_size_type count;
+ ar >> BOOST_SERIALIZATION_NVP(count);
+ if(count > N)
+ boost::throw_exception(archive::archive_exception(
+ boost::archive::archive_exception::array_size_too_short
+ ));
+ if (N)
+ ar >> serialization::make_array(&t[0],count);
+}
+
+
+// split non-intrusive serialization function member into separate
+// non intrusive save/load member functions
+template<class Archive, class U, std::size_t N>
+inline void serialize( Archive & ar, U (& t)[N], const unsigned int file_version)
+{
+ boost::serialization::split_free(ar, t, file_version);
+}
+*/
+
+
+} } // end namespace boost::serialization
+
+#endif //BOOST_SERIALIZATION_ARRAY_HPP
Added: branches/serialization_next_release/boost/boost/serialization/collection_size_type.hpp
==============================================================================
--- (empty file)
+++ branches/serialization_next_release/boost/boost/serialization/collection_size_type.hpp 2007-10-29 15:37:09 EDT (Mon, 29 Oct 2007)
@@ -0,0 +1,20 @@
+#ifndef BOOST_SERIALIZATION_COLLECTION_SIZE_TYPE_HPP
+#define BOOST_SERIALIZATION_COLLECTION_SIZE_TYPE_HPP
+
+// (C) Copyright 2005 Matthias Troyer
+// Use, modification and distribution is subject to the Boost Software
+// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+
+#include <boost/strong_typedef.hpp>
+#include <boost/serialization/level.hpp>
+
+namespace boost { namespace serialization {
+
+BOOST_STRONG_TYPEDEF(std::size_t, collection_size_type)
+
+} } // end namespace boost::serialization
+
+BOOST_CLASS_IMPLEMENTATION(boost::serialization::collection_size_type, primitive_type)
+
+#endif //BOOST_SERIALIZATION_COLLECTION_SIZE_TYPE_HPP
Added: branches/serialization_next_release/boost/boost/serialization/ephemeral.hpp
==============================================================================
--- (empty file)
+++ branches/serialization_next_release/boost/boost/serialization/ephemeral.hpp 2007-10-29 15:37:09 EDT (Mon, 29 Oct 2007)
@@ -0,0 +1,80 @@
+#ifndef BOOST_SERIALIZATION_EPHEMERAL_HPP
+#define BOOST_SERIALIZATION_EPHEMERAL_HPP
+
+// MS compatible compilers support
+#pragma once
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+# pragma once
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// ephemeral_object.hpp: interface for serialization system.
+
+// (C) Copyright 2007 Matthias Troyer.
+// Use, modification and distribution is subject to the Boost Software
+// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+
+// See http://www.boost.org for updates, documentation, and revision history.
+
+#include <utility>
+
+#include <boost/config.hpp>
+#include <boost/detail/workaround.hpp>
+// supress noise
+#if BOOST_WORKAROUND(BOOST_MSVC, <= 1200)
+# pragma warning (disable : 4786) // too long name, harmless warning
+#endif
+
+#include <boost/mpl/integral_c.hpp>
+#include <boost/mpl/integral_c_tag.hpp>
+
+#include <boost/serialization/level.hpp>
+#include <boost/serialization/tracking.hpp>
+#include <boost/serialization/split_member.hpp>
+#include <boost/serialization/base_object.hpp>
+#include <boost/serialization/traits.hpp>
+#include <boost/serialization/wrapper.hpp>
+
+namespace boost {
+namespace serialization {
+
+template<class T>
+struct ephemeral_object :
+ public wrapper_traits<ephemeral_object<T> >
+{
+ explicit ephemeral_object(T& t) :
+ val(t)
+ {}
+
+ T & value() const {
+ return val;
+ }
+
+ const T & const_value() const {
+ return val;
+ }
+
+ template<class Archive>
+ void serialize(Archive &ar, const unsigned int) const
+ {
+ ar & val;
+ }
+
+private:
+ T & val;
+};
+
+template<class T>
+inline
+#ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING
+const
+#endif
+ephemeral_object<T> ephemeral(const char * name, T & t){
+ return ephemeral_object<T>(name, t);
+}
+
+} // seralization
+} // boost
+
+#endif // BOOST_SERIALIZATION_EPHEMERAL_HPP
Modified: branches/serialization_next_release/boost/boost/serialization/export.hpp
==============================================================================
--- branches/serialization_next_release/boost/boost/serialization/export.hpp (original)
+++ branches/serialization_next_release/boost/boost/serialization/export.hpp 2007-10-29 15:37:09 EDT (Mon, 29 Oct 2007)
@@ -26,11 +26,12 @@
#include <boost/config.hpp>
#include <boost/static_assert.hpp>
#include <boost/preprocessor/stringize.hpp>
+#include <boost/type_traits/is_polymorphic.hpp>
-#include <boost/archive/detail/dynamically_initialized.hpp>
#include <boost/serialization/type_info_implementation.hpp>
#include <boost/serialization/is_abstract.hpp>
#include <boost/serialization/force_include.hpp>
+#include <boost/serialization/singleton.hpp>
#include <boost/archive/detail/register_archive.hpp>
#include <boost/mpl/assert.hpp>
@@ -56,12 +57,16 @@
{
static const basic_pointer_iserializer &
enable_load(mpl::true_){
- return pointer_iserializer<Archive, Serializable>::get_instance();
+ return boost::serialization::singleton<
+ pointer_iserializer<Archive, Serializable>
+ >::get_const_instance();
}
static const basic_pointer_oserializer &
enable_save(mpl::true_){
- return pointer_oserializer<Archive, Serializable>::get_instance();
+ return boost::serialization::singleton<
+ pointer_oserializer<Archive, Serializable>
+ >::get_const_instance();
}
inline static void enable_load(mpl::false_) {}
@@ -70,37 +75,22 @@
template<class T>
struct guid_initializer
-{
- typedef typename
- boost::serialization::type_info_implementation<T>::type eti_type;
-
- static void export_register(const char *key)
- {
- eti_type::export_register(key);
- }
-
- static const guid_initializer& get_instance(char const* key)
+{
+ const guid_initializer & export_guid(char const* key)
{
- static guid_initializer const instance(key);
- return instance;
+ assert(NULL != key);
+ boost::serialization::singleton<
+ boost::serialization::type_info_implementation<T>::type
+ >::get_mutable_instance().key_register(key);
+
+ // generates the statically-initialized objects whose constructors
+ // register the information allowing serialization of T objects
+ // through pointers to their base classes.
+ instantiate_ptr_serialization((T*)0, 0);
+ return *this;
}
-
- BOOST_DLLEXPORT guid_initializer(const char *key = 0) BOOST_USED ;
};
-
-template<class T>
-BOOST_DLLEXPORT guid_initializer<T>::guid_initializer(const char *key)
-{
- if(0 != key)
- export_register(key);
-
- // generates the statically-initialized objects whose constructors
- // register the information allowing serialization of T objects
- // through pointers to their base classes.
- instantiate_ptr_serialization((T*)0, 0);
-}
-
// On many platforms, naming a specialization of this template is
// enough to cause its argument to be instantiated.
template <void(*)()>
@@ -146,9 +136,11 @@
#define BOOST_CLASS_EXPORT_GUID(T, K) \
namespace \
{ \
- ::boost::archive::detail::guid_initializer< T > const& \
+ ::boost::archive::detail::guid_initializer< T > const & \
BOOST_PP_CAT(boost_serialization_guid_initializer_, __LINE__) \
- = ::boost::archive::detail::guid_initializer< T >::get_instance(K); \
+ = ::boost::serialization::singleton< \
+ ::boost::archive::detail::guid_initializer< T > \
+ >::get_mutable_instance().export_guid(K); \
}
// the following is solely to support de-serialization of pointers serialized
@@ -156,9 +148,11 @@
#define BOOST_CLASS_EXPORT_GUID_1(T, K) \
namespace \
{ \
- ::boost::archive::detail::guid_initializer< T > const& \
+ ::boost::archive::detail::guid_initializer< T > const & \
BOOST_PP_CAT(boost_serialization_guid_initializer_, __LINE__ ## _1) \
- = ::boost::archive::detail::guid_initializer< T >::get_instance(K); \
+ = ::boost::serialization::singleton< \
+ ::boost::archive::detail::guid_initializer< T > \
+ >::get_mutable_instance().export_guid(K); \
}
#if BOOST_WORKAROUND(__MWERKS__, BOOST_TESTED_AT(0x3205))
Modified: branches/serialization_next_release/boost/boost/serialization/extended_type_info.hpp
==============================================================================
--- branches/serialization_next_release/boost/boost/serialization/extended_type_info.hpp (original)
+++ branches/serialization_next_release/boost/boost/serialization/extended_type_info.hpp 2007-10-29 15:37:09 EDT (Mon, 29 Oct 2007)
@@ -36,52 +36,39 @@
class BOOST_SERIALIZATION_DECL(BOOST_PP_EMPTY()) extended_type_info :
private boost::noncopyable
{
-private:
- virtual bool
- less_than(const extended_type_info &rhs) const = 0;
- int type_info_key_cmp(const extended_type_info & rhs) const;
-
- // used to uniquely identify the type of class derived from this one
- // so that different derivations of this class can be simultaneously
- // included in implementation of sets and maps.
- const char * m_type_info_key;
- // flag to indicate wheter its been registered by type;
- bool m_self_registered;
- // flag to indicate wheter its been registered by type;
- bool m_key_registered;
- // flag indicating that no virtual function should be called here
- // this is necessary since it seems that at least one compiler (borland
- // and one version of gcc call less_than above when erasing even
- // when given an iterator argument.
- bool m_is_destructing;
protected:
const char * m_key;
- extended_type_info(const char * type_info_key);
+
+ // this class can't be used as is. It's just the
+ // common functionality for all type_info replacement
+ // systems. Hence, make these protected
+ extended_type_info();
// account for bogus gcc warning
#if defined(__GNUC__)
virtual
#endif
- ~extended_type_info();
+ virtual ~extended_type_info();
public:
- void self_register();
void key_register(const char *key);
- bool is_destructing() const {
- return m_is_destructing;
- }
- bool operator<(const extended_type_info &rhs) const;
- bool operator==(const extended_type_info &rhs) const {
- return this == & rhs;
- }
- bool operator!=(const extended_type_info &rhs) const {
- return this != & rhs;
- }
const char * get_key() const {
return m_key;
}
static const extended_type_info * find(const char *key);
- static const extended_type_info * find(const extended_type_info * t);
};
+// in order
+BOOST_SERIALIZATION_DECL(bool)
+operator==(
+ const extended_type_info & lhs,
+ const extended_type_info & rhs
+);
+
+BOOST_SERIALIZATION_DECL(bool)
+operator<(
+ const extended_type_info & lhs,
+ const extended_type_info & rhs
+);
+
} // namespace serialization
} // namespace boost
Modified: branches/serialization_next_release/boost/boost/serialization/extended_type_info_no_rtti.hpp
==============================================================================
--- branches/serialization_next_release/boost/boost/serialization/extended_type_info_no_rtti.hpp (original)
+++ branches/serialization_next_release/boost/boost/serialization/extended_type_info_no_rtti.hpp 2007-10-29 15:37:09 EDT (Mon, 29 Oct 2007)
@@ -32,44 +32,26 @@
namespace boost {
namespace serialization {
-namespace detail {
///////////////////////////////////////////////////////////////////////
// define a special type_info that doesn't depend on rtti which is not
// available in all situations.
-// common base class to share type_info_key. This is used to
-// identify the method used to keep track of the extended type
-class BOOST_SERIALIZATION_DECL(BOOST_PP_EMPTY()) extended_type_info_no_rtti_0 :
+template<class T>
+class extended_type_info_no_rtti :
public extended_type_info
{
- virtual bool
- less_than(const boost::serialization::extended_type_info &rhs) const ;
-protected:
- extended_type_info_no_rtti_0();
- // account for bogus gcc warning
- #if defined(__GNUC__)
- virtual
- #endif
- ~extended_type_info_no_rtti_0();
public:
struct is_polymorphic
{
typedef boost::mpl::bool_<true> type;
BOOST_STATIC_CONSTANT(bool, value = is_polymorphic::type::value);
};
-};
-
-template<class T>
-class extended_type_info_no_rtti_1 :
- public extended_type_info_no_rtti_0
-{
-protected:
- extended_type_info_no_rtti_1(){}
-public:
- // note borland complains at making this destructor protected
- ~extended_type_info_no_rtti_1(){};
- static const boost::serialization::extended_type_info *
- get_derived_extended_type_info(const T & t){
+ // private constructor to inhibit any existence other than the
+ // static one
+ extended_type_info_no_rtti(){}
+ ~extended_type_info_no_rtti(){};
+ const boost::serialization::extended_type_info *
+ get_derived_extended_type_info(const T & t) const {
// find the type that corresponds to the most derived type.
// this implementation doesn't depend on typeid() but assumes
// that the specified type has a function of the following signature.
@@ -79,29 +61,6 @@
assert(NULL != derived_key);
return boost::serialization::extended_type_info::find(derived_key);
}
- static boost::serialization::extended_type_info *
- get_instance(){
- static extended_type_info_no_rtti_1<T> instance;
- return & instance;
- }
- static void
- export_register(const char * key){
- boost::serialization::extended_type_info * eti;
- eti = get_instance();
- eti->key_register(key); // initialize key and add to table
- eti->self_register(); // add type to type table
- }
-};
-} // namespace detail
-
-template<class T>
-class extended_type_info_no_rtti :
- public detail::extended_type_info_no_rtti_1<const T>
-{
- // private constructor to inhibit any existence other than the
- // static one
- extended_type_info_no_rtti(){}
- ~extended_type_info_no_rtti(){};
};
} // namespace serialization
@@ -119,7 +78,7 @@
template<class T>
struct extended_type_info_impl {
typedef BOOST_DEDUCED_TYPENAME
- boost::serialization::extended_type_info_no_rtti<const T> type;
+ boost::serialization::extended_type_info_no_rtti<T> type;
};
} // namespace serialization
} // namespace boost
Modified: branches/serialization_next_release/boost/boost/serialization/extended_type_info_typeid.hpp
==============================================================================
--- branches/serialization_next_release/boost/boost/serialization/extended_type_info_typeid.hpp (original)
+++ branches/serialization_next_release/boost/boost/serialization/extended_type_info_typeid.hpp 2007-10-29 15:37:09 EDT (Mon, 29 Oct 2007)
@@ -19,11 +19,12 @@
#include <typeinfo>
#include <boost/config.hpp>
+#include <boost/detail/workaround.hpp>
//#include <boost/static_warning.hpp>
#include <boost/static_assert.hpp>
-#include <boost/type_traits/is_polymorphic.hpp>
#include <boost/type_traits/is_const.hpp>
+#include <boost/type_traits/is_polymorphic.hpp>
#include <boost/preprocessor/stringize.hpp>
#include <boost/serialization/extended_type_info.hpp>
@@ -36,26 +37,24 @@
namespace boost {
namespace serialization {
-
namespace detail {
class BOOST_SERIALIZATION_DECL(BOOST_PP_EMPTY()) extended_type_info_typeid_0 :
public extended_type_info
{
-private:
- virtual bool
- less_than(const extended_type_info &rhs) const;
protected:
+ const std::type_info * m_ti;
+ extended_type_info_typeid_0() :
+ m_ti(NULL)
+ {}
+ virtual ~extended_type_info_typeid_0();
+ void type_register(const std::type_info & ti);
static const extended_type_info *
get_derived_extended_type_info(const std::type_info & ti);
- extended_type_info_typeid_0();
- // account for bogus gcc warning
- #if defined(__GNUC__)
- virtual
- #endif
- ~extended_type_info_typeid_0();
public:
- virtual const std::type_info & get_eti() const = 0;
+ const std::type_info & get_typeid() const {
+ return *m_ti;
+ }
};
///////////////////////////////////////////////////////////////////////////////
@@ -64,41 +63,35 @@
class extended_type_info_typeid_1 :
public detail::extended_type_info_typeid_0
{
-private:
- virtual const std::type_info & get_eti() const {
- return typeid(T);
- }
protected:
- // private constructor to inhibit any existence other than the
+ // protected constructor to inhibit any existence other than the
// static one
extended_type_info_typeid_1() :
detail::extended_type_info_typeid_0()
{
- self_register(); // add type to type table
+ type_register(typeid(T));
}
+#if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x560))
+public:
+#endif
+ ~extended_type_info_typeid_1(){}
public:
struct is_polymorphic
{
typedef BOOST_DEDUCED_TYPENAME boost::is_polymorphic<T>::type type;
BOOST_STATIC_CONSTANT(bool, value = is_polymorphic::type::value);
};
- static const extended_type_info *
- get_derived_extended_type_info(const T & t){
+ const extended_type_info *
+ get_derived_extended_type_info(const T & t) const {
// note: this implementation - based on usage of typeid (rtti)
// only works if the class has at least one virtual function.
// BOOST_STATIC_WARNING(
// static_cast<bool>(is_polymorphic::value)
// );
- return detail::extended_type_info_typeid_0::get_derived_extended_type_info(typeid(t));
- }
- static extended_type_info *
- get_instance(){
- static extended_type_info_typeid_1<T> instance;
- return & instance;
- }
- static void
- export_register(const char * key){
- get_instance()->key_register(key);
+ return
+ detail::extended_type_info_typeid_0::get_derived_extended_type_info(
+ typeid(t)
+ );
}
};
Added: branches/serialization_next_release/boost/boost/serialization/singleton.hpp
==============================================================================
--- (empty file)
+++ branches/serialization_next_release/boost/boost/serialization/singleton.hpp 2007-10-29 15:37:09 EDT (Mon, 29 Oct 2007)
@@ -0,0 +1,114 @@
+#ifndef BOOST_SERIALIZATION_SINGLETON_HPP
+#define BOOST_SERIALIZATION_SINGLETON_HPP
+
+/////////1/////////2///////// 3/////////4/////////5/////////6/////////7/////////8
+// singleton.hpp
+//
+// Copyright David Abrahams 2006. Original version
+//
+// Copyright Robert Ramey 2007. Changes made to permit
+// application throughout the serialization library.
+//
+// Distributed under the Boost
+// Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+// The intention here is to define a template which will convert
+// any class into a singleton with the following features:
+//
+// a) initialized before first use.
+// b) thread-safe for const access to the class
+// c) non-locking
+//
+// In order to do this,
+// a) Initialize dynamically when used.
+// b) Require that all singletons be initialized before main
+// is called*. This guarentees no race condition for initialization.
+// In debug mode, assert that no non-const functions are called
+// after main is invoked.
+//
+// * note exception regarding dynamically loaded shared libraries.
+// check documentation
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+# pragma once
+#endif
+
+#include <cassert>
+#include <boost/noncopyable.hpp>
+#include <boost/serialization/force_include.hpp>
+
+namespace boost {
+namespace serialization {
+
+//////////////////////////////////////////////////////////////////////
+// Provides a dynamically-initialized (singleton) instance of T in a
+// way that avoids LNK1179 on vc6. See http://tinyurl.com/ljdp8 or
+// http://listarchives.boost.org/Archives/boost/2006/05/105286.php for
+// details.
+//
+
+template <class T>
+class singleton : public boost::noncopyable
+{
+ friend class global_lock;
+private:
+ BOOST_DLLEXPORT static T & instance;
+ // include this to provoke instantiation at pre-execution time
+ static void use(T const &) {}
+ static T & get_instance(){
+ static T t;
+ // refer to instance, causing it to be instantiated (and
+ // initialized at startup on working compilers)
+ use(instance);
+ return t;
+ }
+public:
+ static const T & get_const_instance();
+ static T & get_mutable_instance();
+};
+
+template<class T>
+BOOST_DLLEXPORT T & singleton<T>::instance = singleton<T>::get_instance();
+
+// make a singleton to lock/unlock all singletons for alteration.
+// The intent is that all singletons created/used by this code
+// are to be initialized before main is called. (note exception
+// for DLLS which is dealt with in the documentation). If
+// the singleton is then used only as read
+
+class global_lock : public singleton<global_lock> {
+ bool locked;
+public:
+ global_lock() : locked(false) {}
+ void lock(){
+ locked = true;
+ }
+ void unlock(){
+ locked = false;
+ }
+ bool is_locked() const {
+ return locked;
+ }
+ static global_lock & get_mutable_instance(){
+ return get_instance();
+ }
+};
+
+template<class T>
+inline T & singleton<T>::get_mutable_instance(){
+ assert(! global_lock::get_mutable_instance().is_locked());
+ return get_instance();
+}
+
+template<class T>
+inline const T & singleton<T>::get_const_instance(){
+ return get_instance();
+}
+
+
+} // namespace serialization
+} // namespace boost
+
+#endif // BOOST_SERIALIZATION_SINGLETON_HPP
Modified: branches/serialization_next_release/boost/boost/serialization/type_info_implementation.hpp
==============================================================================
--- branches/serialization_next_release/boost/boost/serialization/type_info_implementation.hpp (original)
+++ branches/serialization_next_release/boost/boost/serialization/type_info_implementation.hpp 2007-10-29 15:37:09 EDT (Mon, 29 Oct 2007)
@@ -61,7 +61,7 @@
namespace serialization { \
template<> \
struct type_info_implementation< T > { \
- typedef ETI type; \
+ typedef const ETI type; \
}; \
} \
} \
Added: branches/serialization_next_release/boost/boost/serialization/valarray.hpp
==============================================================================
--- (empty file)
+++ branches/serialization_next_release/boost/boost/serialization/valarray.hpp 2007-10-29 15:37:09 EDT (Mon, 29 Oct 2007)
@@ -0,0 +1,74 @@
+#ifndef BOOST_SERIALIZATION_VALARAY_HPP
+#define BOOST_SERIALIZATION_VALARAY_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+# pragma once
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// vector.hpp: serialization for stl vector templates
+
+// (C) Copyright 2005 Matthias Troyer .
+// Use, modification and distribution is subject to the Boost Software
+// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+
+// See http://www.boost.org for updates, documentation, and revision history.
+
+#include <valarray>
+#include <boost/config.hpp>
+#include <boost/serialization/split_free.hpp>
+#include <boost/serialization/array.hpp>
+#include <boost/serialization/collection_size_type.hpp>
+#include <boost/serialization/detail/get_data.hpp>
+
+// function specializations must be defined in the appropriate
+// namespace - boost::serialization
+#if defined(__SGI_STL_PORT) || defined(_STLPORT_VERSION)
+#define STD _STLP_STD
+#else
+#define STD std
+#endif
+
+namespace boost { namespace serialization {
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// valarray<T>
+
+template<class Archive, class U>
+void save( Archive & ar, const STD::valarray<U> &t, const unsigned int file_version )
+{
+ const collection_size_type count(t.size());
+ ar << BOOST_SERIALIZATION_NVP(count);
+ if (count)
+ ar << make_array(detail::get_data(t), t.size());
+}
+
+
+template<class Archive, class U>
+void load( Archive & ar, STD::valarray<U> &t, const unsigned int file_version )
+{
+ collection_size_type count;
+ ar >> BOOST_SERIALIZATION_NVP(count);
+ t.resize(count);
+ if (count)
+ ar >> make_array(detail::get_data(t), t.size());
+}
+
+// split non-intrusive serialization function member into separate
+// non intrusive save/load member functions
+template<class Archive, class U>
+inline void serialize( Archive & ar, STD::valarray<U> & t, const unsigned int file_version)
+{
+ boost::serialization::split_free(ar, t, file_version);
+}
+
+} } // end namespace boost::serialization
+
+#include <boost/serialization/collection_traits.hpp>
+
+BOOST_SERIALIZATION_COLLECTION_TRAITS(STD::valarray)
+#undef STD
+
+#endif // BOOST_SERIALIZATION_VALARAY_HPP
Modified: branches/serialization_next_release/boost/boost/serialization/void_cast.hpp
==============================================================================
--- branches/serialization_next_release/boost/boost/serialization/void_cast.hpp (original)
+++ branches/serialization_next_release/boost/boost/serialization/void_cast.hpp 2007-10-29 15:37:09 EDT (Mon, 29 Oct 2007)
@@ -18,10 +18,9 @@
// See http://www.boost.org for updates, documentation, and revision history.
#include <boost/smart_cast.hpp>
-#include <boost/mpl/eval_if.hpp>
-#include <boost/mpl/identity.hpp>
#include <boost/serialization/config.hpp>
+#include <boost/serialization/singleton.hpp>
#include <boost/serialization/force_include.hpp>
#include <boost/serialization/type_info_implementation.hpp>
@@ -46,8 +45,7 @@
void_upcast(
extended_type_info const & derived_type,
extended_type_info const & base_type,
- void const * const t,
- bool top = true
+ void const * const t
);
inline void *
@@ -67,63 +65,59 @@
void_downcast(
extended_type_info const & derived_type,
extended_type_info const & base_type,
- void const * const t,
- bool top = true
+ void const * const t
);
inline void *
void_downcast(
- extended_type_info const & derived_type_,
- extended_type_info const & base_type_,
+ extended_type_info const & derived_type,
+ extended_type_info const & base_type,
void * const t
){
return const_cast<void*>(void_downcast(
- derived_type_,
- base_type_,
+ derived_type,
+ base_type,
const_cast<void const *>(t)
));
}
namespace void_cast_detail {
-// note: can't be abstract because an instance is used as a search argument
class BOOST_SERIALIZATION_DECL(BOOST_PP_EMPTY()) void_caster
{
friend struct void_caster_compare ;
friend
- BOOST_SERIALIZATION_DECL(void const *)
+ BOOST_SERIALIZATION_DECL(void const *)
boost::serialization::void_upcast(
- const extended_type_info & derived_type,
- const extended_type_info & base_type,
- const void * t,
- bool top
+ const extended_type_info & derived,
+ const extended_type_info & base,
+ const void * t
);
friend
BOOST_SERIALIZATION_DECL(void const *)
boost::serialization::void_downcast(
- const extended_type_info & derived_type,
- const extended_type_info & base_type,
- const void * t,
- bool top
+ const extended_type_info & derived,
+ const extended_type_info & base,
+ const void * t
);
+ // Data members
+ const extended_type_info & m_derived;
+ const extended_type_info & m_base;
// each derived class must re-implement these;
virtual void const * upcast(void const * t) const = 0;
virtual void const * downcast(void const * t) const = 0;
- // Data members
- extended_type_info const & m_derived_type;
- extended_type_info const & m_base_type;
protected:
- static void static_register(const void_caster *);
+ BOOST_SERIALIZATION_DECL(void)
+ static_register() const;
+ BOOST_SERIALIZATION_DECL(void)
+ static_unregister() const;
public:
// Constructor
void_caster(
- extended_type_info const & derived_type_,
- extended_type_info const & base_type_
+ extended_type_info const & derived,
+ extended_type_info const & base
);
- // predicate used to determine if this void caster includes
- // a particular eti *
- bool includes(const extended_type_info * eti) const;
- virtual ~void_caster();
+ virtual ~void_caster(){};
private:
// cw 8.3 requires this!!
void_caster& operator=(void_caster const&);
@@ -134,66 +128,36 @@
public void_caster
{
virtual void const* downcast( void const * t ) const {
- Derived * d = boost::smart_cast<const Derived *, const Base *>(
+ const Derived * d = boost::smart_cast<const Derived *, const Base *>(
static_cast<const Base *>(t)
);
return d;
}
virtual void const* upcast(void const * t) const {
- Base * b = boost::smart_cast<const Base *, const Derived *>(
+ const Base * b = boost::smart_cast<const Base *, const Derived *>(
static_cast<const Derived *>(t)
);
return b;
}
-
+public:
BOOST_DLLEXPORT void_caster_primitive() BOOST_USED;
-
- static BOOST_DLLEXPORT void_caster_primitive const& instance;
-
- // Something we can use to force instantiation without generating
- // warnings.
- static void use(void_caster_primitive const&) {}
-
- public:
- // CodeWarrior fails to construct static members of class
- // templates when they are instantiated from within templates, so
- // we do everything with void_caster_primitive in terms of
- // get_instance. On CodeWarrior, the user must invoke
- // BOOST_SERIALIZATION_MWERKS_BASE_AND_DERIVED to make this work
- // (see boost/serialization/export.hpp). On other compilers (and
- // if the bug is fixed in a future version of CodeWarriror), the
- // initialization of instance (above) obviates the need for
- // BOOST_SERIALIZATION_MWERKS_BASE_AND_DERIVED.
- static BOOST_DLLEXPORT void_caster_primitive const& get_instance()
- {
- static void_caster_primitive instance_;
-
- // refer to instance, causing it to be instantiated (and
- // initialized at startup on working compilers)
- use(instance);
-
- return instance_;
- }
+ BOOST_DLLEXPORT ~void_caster_primitive() BOOST_USED;
};
template <class Derived, class Base>
BOOST_DLLEXPORT void_caster_primitive<Derived, Base>::void_caster_primitive() :
void_caster(
- * type_info_implementation<Derived>::type::get_instance(),
- * type_info_implementation<Base>::type::get_instance()
+ singleton<type_info_implementation<Derived>::type>::get_const_instance(),
+ singleton<type_info_implementation<Base>::type>::get_const_instance()
)
{
- // calling get_instance() causes infinite recursion, and the
- // instance reference isn't initialized yet, so we must pass this
- // to static_register. It *is* the same object as instance, but
- // there's no way even to assert that here.
- this->static_register(this);
+ static_register();
}
template <class Derived, class Base>
-BOOST_DLLEXPORT void_caster_primitive<Derived,Base> const&
-void_caster_primitive<Derived,Base>::instance
-= void_caster_primitive<Derived,Base>::get_instance();
+BOOST_DLLEXPORT void_caster_primitive<Derived, Base>::~void_caster_primitive(){
+ static_unregister();
+}
} // void_cast_detail
@@ -213,9 +177,9 @@
const Derived * /* dnull = NULL */,
const Base * /* bnull = NULL */
){
- return void_cast_detail::void_caster_primitive<
- const Derived, const Base
- >::get_instance();
+ return singleton<void_cast_detail::void_caster_primitive<
+ Derived, Base
+ > >::get_const_instance();
}
} // namespace serialization
Added: branches/serialization_next_release/boost/boost/serialization/wrapper.hpp
==============================================================================
--- (empty file)
+++ branches/serialization_next_release/boost/boost/serialization/wrapper.hpp 2007-10-29 15:37:09 EDT (Mon, 29 Oct 2007)
@@ -0,0 +1,63 @@
+#ifndef BOOST_SERIALIZATION_WRAPPER_HPP
+#define BOOST_SERIALIZATION_WRAPPER_HPP
+
+// (C) Copyright 2005-2006 Matthias Troyer
+// Use, modification and distribution is subject to the Boost Software
+// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+
+#include <boost/serialization/traits.hpp>
+#include <boost/type_traits/is_base_and_derived.hpp>
+#include <boost/mpl/eval_if.hpp>
+
+namespace boost { namespace serialization {
+
+/// the base class for serialization wrappers
+///
+/// wrappers need to be treated differently at various places in the serialization library,
+/// e.g. saving of non-const wrappers has to be possible. Since partial specialization
+// is not supported by all compilers, we derive all wrappers from wrapper_traits.
+
+template<
+ class T,
+ int Level = object_serializable,
+ int Tracking = track_never,
+ unsigned int Version = 0,
+ class ETII = extended_type_info_impl< T >
+>
+struct wrapper_traits : public traits<T,Level,Tracking,Version,ETII,mpl::true_>
+{};
+
+/// the is_wrapper type traits class.
+
+namespace detail {
+template <class T>
+struct is_wrapper_member
+{
+ typedef BOOST_DEDUCED_TYPENAME T::is_wrapper type;
+};
+
+}
+
+
+template<class T>
+struct is_wrapper
+ : mpl::eval_if<
+ is_base_and_derived<basic_traits,T>,
+ detail::is_wrapper_member<T>,
+ mpl::false_
+ >::type
+{};
+
+} } // end namespace boost::serialization
+
+// A macro to define that a class is a wrapper
+#define BOOST_CLASS_IS_WRAPPER(T) \
+namespace boost { \
+namespace serialization { \
+template<> \
+struct is_wrapper< T > : mpl::true_ {}; \
+}}
+
+
+#endif //BOOST_SERIALIZATION_WRAPPER_HPP