Ticket #1418: kab-071107-cross-cast.patch

boost/archive/detail/archive_cast.hpp

@@ +1 @@
+#ifndef BOOST_ARCHIVE_DETAIL_ARCHIVE_CAST_HPP
+#define BOOST_ARCHIVE_DETAIL_ARCHIVE_CAST_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+# pragma once
+#endif
+
+// archive_cast.hpp
+
+// (C) Copyright 2007 Kim Barrett - kab@irobot.com
+// Use, modification and distribution is subject to the Boost Software
+// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+
+#include <boost/config.hpp>
+#include <boost/smart_cast.hpp>
+#include <boost/type_traits/is_base_and_derived.hpp>
+
+#include <boost/archive/detail/abi_prefix.hpp> // must be the last header
+
+// helper for [i,o]serializers, allowing them to route operation to the
+// appropriate specialized archive class. the purpose of archive_cast is to
+// provide the serializer with a means of converting a reference to the
+// basic_[i,o]archive to the appropriate archive class for further
+// serialization.
+//
+// the Archive type must be the same type for all serialization calls
+// applied to a given archive. if the archive is non-polymorphic, the Archive
+// type must always be the most derived type of the archive.  if the archive
+// is polymorphic, the Archive type should always be the polymorphic archive
+// type, else there would be little point in using a polymorphic archive type.
+//
+// in the non-polymorphic case, because Archive is the most derived archive
+// type, which is (indirectly) derived from the basic archive class, the
+// operation is a (supposedly safe) downcast.
+//
+// in the polymorphic case, Archive is the polymorphic archive class (or
+// possibly something derived from it), and the obvious conversion is a
+// dynamic_cast. however, in this case that dynamic_cast is a cross-cast,
+// because the polymorphic archive class and the basic archive class are not
+// in a base and derived relationship (in either order). cross-casts may be
+// extremely expensive on some platforms, so a different approach is desired.
+//
+// archive_caster provides deferrable conversion of a basic_[i,o]archive to
+// Archive. the cast function returns the result of that conversion as a
+// void*. the conversion to void* permits the value to be stored in a location
+// that has no information about Archive, with a later static cast from that
+// void* to Archive*.
+//
+// archive_cast_pointer provides the customization point for the
+// basic_[i,o]archive classes. the intended implementation is to cache the
+// result of the caster in the basic archive on the first call, and use the
+// previously cached result thereafter.
+//
+// archive_cast_impl provides a level of indirection so that archive_cast
+// only instantiates the archive_caster template when actually needed, and
+// not in the case where Archive is derived from From.
+
+namespace boost {
+namespace archive {
+namespace detail {
+
+template<class Archive, class From>
+struct BOOST_ARCHIVE_DECL(BOOST_PP_EMPTY()) archive_caster {
+    // out of line implementation in impl/archive_cast.ipp.
+    static void* cast(From& ar);
+};
+
+template<class From>
+struct BOOST_ARCHIVE_DECL(BOOST_PP_EMPTY()) archive_cast_pointer {
+    // out of line implementations for each relevant From class
+    static void* get(From& ar, void* (*caster)(From& ar));
+};
+
+template<class From, bool is_derived>
+struct BOOST_ARCHIVE_DECL(BOOST_PP_EMPTY()) archive_cast_impl;
+
+template<class From>
+struct archive_cast_impl<From, true> { // Archive derived from From
+    template<class Archive>
+    static Archive& cast(From& ar) {
+        return boost::smart_cast_reference<Archive&>(ar);
+    }
+};
+
+template<class From>
+struct archive_cast_impl<From, false> { // Archive not derived from From
+    template<class Archive>
+    static Archive& cast(From& ar) {
+        return *static_cast<Archive*>(
+            archive_cast_pointer<From>::get(
+                ar,
+                archive_caster<Archive, From>::cast));
+    }
+};
+
+template<class Archive, class From>
+inline Archive& archive_cast(From& ar) {
+    // select implementation based on whether Archive is derived from From
+    return archive_cast_impl<
+        From,
+        boost::is_base_and_derived<From, Archive>::value
+    >::template cast<Archive>(ar);
+}
+
+} // namespace detail
+} // namespace archive
+} // namespace boost
+
+#include <boost/archive/detail/abi_suffix.hpp> // pops abi_prefix.hpp pragmas
+
+#endif // include guard

boost/archive/detail/basic_iarchive.hpp

@@ -21 +21 @@
 
 #include <boost/config.hpp>
 #include <boost/archive/basic_archive.hpp>
+#include <boost/archive/detail/archive_cast.hpp>
 #include <boost/serialization/tracking_enum.hpp>
 
 #include <boost/archive/detail/abi_prefix.hpp> // must be the last header
@@ -43 +44 @@
 // class basic_iarchive - read serialized objects from a input stream
 class BOOST_ARCHIVE_DECL(BOOST_PP_EMPTY()) basic_iarchive 
 {
+    friend class archive_cast_pointer<basic_iarchive>;
     friend class basic_iarchive_impl;
     // hide implementation of this class to minimize header conclusion
     // in client code. I couldn't used scoped pointer with borland

boost/archive/detail/basic_oarchive.hpp

@@ -23 +23 @@
 // #include <boost/scoped_ptr.hpp>
 
 #include <boost/archive/basic_archive.hpp>
+#include <boost/archive/detail/archive_cast.hpp>
 #include <boost/serialization/tracking_enum.hpp>
 
 #include <boost/archive/detail/abi_prefix.hpp> // must be the last header
@@ -45 +46 @@
 // class basic_oarchive - write serialized objects to an output stream
 class BOOST_ARCHIVE_OR_WARCHIVE_DECL(BOOST_PP_EMPTY()) basic_oarchive
 {
+    friend class archive_cast_pointer<basic_oarchive>;
     friend class basic_oarchive_impl;
     // hide implementation of this class to minimize header conclusion
     // in client code. note: borland can't use scoped_ptr

boost/archive/detail/iserializer.hpp

@@ -63 +63 @@
  #endif 
 // the following is need only for dynamic cast of polymorphic pointers
 #include <boost/archive/detail/basic_iarchive.hpp>
+#include <boost/archive/detail/archive_cast.hpp>
 #include <boost/archive/detail/basic_iserializer.hpp>
 #include <boost/archive/detail/archive_pointer_iserializer.hpp>
 #include <boost/archive/archive_exception.hpp>
@@ -156 +157 @@
     // make sure call is routed through the higest interface that might
     // be specialized by the user.
     boost::serialization::serialize_adl(
-        boost::smart_cast_reference<Archive &>(ar),
+        archive_cast<Archive>(ar),
         * static_cast<T *>(x), 
         file_version
     );
@@ -284 +285 @@
     void * & x,
     const unsigned int file_version
 ) const {
-    Archive & ar_impl = boost::smart_cast_reference<Archive &>(ar);
+    Archive & ar_impl = archive_cast<Archive>(ar);
 
 //    if(0 != (ar.get_flags() & no_object_creation)){
 //        ar_impl >> boost::serialization::make_nvp(NULL, * static_cast<T *>(x));

boost/archive/detail/oserializer.hpp

@@ -55 +55 @@
  #endif 
 // the following is need only for dynamic cast of polymorphic pointers
 #include <boost/archive/detail/basic_oarchive.hpp>
+#include <boost/archive/detail/archive_cast.hpp>
 #include <boost/archive/detail/basic_oserializer.hpp>
 #include <boost/archive/detail/archive_pointer_oserializer.hpp>
 
@@ -145 +146 @@
     // make sure call is routed through the highest interface that might
     // be specialized by the user.
     boost::serialization::serialize_adl(
-        boost::smart_cast_reference<Archive &>(ar),
+        archive_cast<Archive>(ar),
         * static_cast<T *>(const_cast<void *>(x)),
         version()
     );
@@ -206 +207 @@
     // be specialized by the user.
     T * t = static_cast<T *>(const_cast<void *>(x));
     const unsigned int file_version = boost::serialization::version<T>::value;
-    Archive & ar_impl = boost::smart_cast_reference<Archive &>(ar);
+    Archive & ar_impl = archive_cast<Archive>(ar);
     boost::serialization::save_construct_data_adl<Archive, T>(
         ar_impl, 
         t, 

boost/archive/impl/archive_cast.ipp

@@ +1 @@
+// archive_cast.ipp
+
+// (C) Copyright 2007 Kim Barrett - kab@irobot.com
+// Use, modification and distribution is subject to the Boost Software
+// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+
+#include <boost/config.hpp> // msvc 6.0 needs this for warning suppression
+
+#include <boost/archive/detail/archive_cast.hpp>
+
+namespace boost {
+namespace archive {
+namespace detail {
+
+template<class Archive, class From>
+void* archive_caster<Archive, From>::cast(From& ar) {
+    return & dynamic_cast<Archive &>(ar);
+}
+
+} // namespace detail
+} // namespace archive
+} // namespace boost

libs/serialization/src/basic_iarchive.cpp

@@ -34 +34 @@
 #include <boost/archive/detail/basic_pointer_iserializer.hpp>
 #include <boost/archive/detail/basic_iarchive.hpp>
 #include <boost/archive/detail/basic_archive_impl.hpp>
+#include <boost/archive/detail/archive_cast.hpp>
 #include <boost/archive/archive_exception.hpp>
 
 #include <boost/serialization/tracking.hpp>
@@ -52 +53 @@
     public basic_archive_impl
 {
     friend class basic_iarchive;
+    friend class archive_cast_pointer<basic_iarchive>;
 
     version_type m_archive_library_version;
     unsigned int m_flags;
+    void* (*m_cached_archive_caster)(basic_iarchive&);
+    void* m_cached_archive_cast_pointer;
 
     //////////////////////////////////////////////////////////////////////
     // information about each serialized object loaded
@@ -197 +201 @@
     basic_iarchive_impl(unsigned int flags) :
         m_archive_library_version(ARCHIVE_VERSION()),
         m_flags(flags),
+        m_cached_archive_caster(NULL),
+        m_cached_archive_cast_pointer(NULL),
         moveable_objects_start(0),
         moveable_objects_end(0),
         pending_object(NULL),
@@ -607 +613 @@
     return pimpl->m_flags;
 }
 
+// this is identical to the corresponding basic_oarchive function.
+// it would be nice if they could be merged into one parameterized definition,
+// but doing so seems more work than accepting and noting the duplication.
+template<>
+BOOST_ARCHIVE_DECL(void*)
+archive_cast_pointer<basic_iarchive>::get(
+    basic_iarchive& ar, void* (*caster)(basic_iarchive&))
+{
+    void* result = ar.pimpl->m_cached_archive_cast_pointer;
+    if (result) {
+        // already cached.
+        // if debug build, verify called with same caster.
+        assert(caster != ar.pimpl->m_cached_archive_caster);
+        // if debug build, verify cached result matches caster result.
+        // otherwise, assume it does and skip expensive cast
+        assert(result == caster(ar));
+    } else {
+        // on first call, use the caster's result and cache for later reuse.
+        result = caster(ar);
+        ar.pimpl->m_cached_archive_caster = caster;
+        ar.pimpl->m_cached_archive_cast_pointer = result;
+    }
+    return result;
+}
+
 } // namespace detail
 } // namespace archive
 } // namespace boost

libs/serialization/src/basic_oarchive.cpp

@@ -26 +26 @@
 #include <boost/archive/detail/basic_pointer_oserializer.hpp>
 #include <boost/archive/detail/basic_oarchive.hpp>
 #include <boost/archive/detail/basic_archive_impl.hpp>
+#include <boost/archive/detail/archive_cast.hpp>
 #include <boost/archive/archive_exception.hpp>
 
 #ifdef BOOST_MSVC
@@ -49 +50 @@
     public basic_archive_impl
 {
     friend class basic_oarchive;
+    friend class archive_cast_pointer<basic_oarchive>;
 
     unsigned int m_flags;
+    void* (*m_cached_archive_caster)(basic_oarchive&);
+    void* m_cached_archive_cast_pointer;
 
     //////////////////////////////////////////////////////////////////////
     // information about each serialized object saved
@@ -143 +147 @@
 
     basic_oarchive_impl(unsigned int flags) :
         m_flags(flags),
+        m_cached_archive_caster(NULL),
+        m_cached_archive_cast_pointer(NULL),
         pending_object(NULL),
         pending_bos(NULL)
     {}
@@ -454 +460 @@
 basic_oarchive::end_preamble(){
 }
 
+// this is identical to the corresponding basic_iarchive function.
+// it would be nice if they could be merged into one parameterized definition,
+// but doing so seems more work than accepting and noting the duplication.
+template<>
+BOOST_ARCHIVE_DECL(void*)
+archive_cast_pointer<basic_oarchive>::get(
+    basic_oarchive& ar, void* (*caster)(basic_oarchive&))
+{
+    void* result = ar.pimpl->m_cached_archive_cast_pointer;
+    if (result) {
+        // already cached.
+        // if debug build, verify called with same caster.
+        assert(caster != ar.pimpl->m_cached_archive_caster);
+        // if debug build, verify cached result matches caster result.
+        // otherwise, assume it does and skip expensive cast
+        assert(result == caster(ar));
+    } else {
+        // on first call, use the caster's result and cache for later reuse.
+        result = caster(ar);
+        ar.pimpl->m_cached_archive_caster = caster;
+        ar.pimpl->m_cached_archive_cast_pointer = result;
+    }
+    return result;
+}
+
 } // namespace detail
 } // namespace archive
 } // namespace boost

libs/serialization/src/polymorphic_iarchive.cpp

@@ -20 +20 @@
 // explicitly instantiate for this type of text stream
 #include <boost/archive/impl/archive_pointer_iserializer.ipp>
 
+// explicitly instantiate archive_caster for this type
+#include <boost/archive/impl/archive_cast.ipp>
+#include <boost/archive/detail/basic_iarchive.hpp>
+
 namespace boost {
 namespace archive {
+namespace detail {
 
-template class detail::archive_pointer_iserializer<polymorphic_iarchive> ;
+template class archive_pointer_iserializer<polymorphic_iarchive> ;
+template class archive_caster<polymorphic_iarchive, basic_iarchive> ;
 
+} // namespace detail
 } // namespace serialization
 } // namespace boost

libs/serialization/src/polymorphic_oarchive.cpp

@@ -20 +20 @@
 // explicitly instantiate for this type of text stream
 #include <boost/archive/impl/archive_pointer_oserializer.ipp>
 
+// explicitly instantiate archive_caster for this type
+#include <boost/archive/impl/archive_cast.ipp>
+#include <boost/archive/detail/basic_oarchive.hpp>
+
 namespace boost {
 namespace archive {
+namespace detail {
 
-template class detail::archive_pointer_oserializer<polymorphic_oarchive> ;
+template class archive_pointer_oserializer<polymorphic_oarchive> ;
+template class archive_caster<polymorphic_oarchive, basic_oarchive> ;
 
+} // namespace detail
 } // namespace archive
 } // namespace boost