diff options
Diffstat (limited to '3rdParty/Boost/src/boost/serialization/void_cast.hpp')
-rw-r--r-- | 3rdParty/Boost/src/boost/serialization/void_cast.hpp | 298 |
1 files changed, 298 insertions, 0 deletions
diff --git a/3rdParty/Boost/src/boost/serialization/void_cast.hpp b/3rdParty/Boost/src/boost/serialization/void_cast.hpp new file mode 100644 index 0000000..b5b1e85 --- /dev/null +++ b/3rdParty/Boost/src/boost/serialization/void_cast.hpp @@ -0,0 +1,298 @@ +#ifndef BOOST_SERIALIZATION_VOID_CAST_HPP +#define BOOST_SERIALIZATION_VOID_CAST_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 +// void_cast.hpp: interface for run-time casting of void pointers. + +// (C) Copyright 2002-2009 Robert Ramey - http://www.rrsd.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) +// gennadiy.rozental@tfn.com + +// See http://www.boost.org for updates, documentation, and revision history. + +#include <cstddef> // for ptrdiff_t +#include <boost/config.hpp> +#include <boost/noncopyable.hpp> + +#include <boost/serialization/smart_cast.hpp> +#include <boost/serialization/singleton.hpp> +#include <boost/serialization/force_include.hpp> +#include <boost/serialization/type_info_implementation.hpp> +#include <boost/serialization/extended_type_info.hpp> +#include <boost/type_traits/is_virtual_base_of.hpp> +#include <boost/serialization/void_cast_fwd.hpp> + +#include <boost/serialization/config.hpp> +#include <boost/config/abi_prefix.hpp> // must be the last header + +#ifdef BOOST_MSVC +# pragma warning(push) +# pragma warning(disable : 4251 4231 4660 4275) +#endif + +namespace boost { +namespace serialization { + +class extended_type_info; + +// Given a void *, assume that it really points to an instance of one type +// and alter it so that it would point to an instance of a related type. +// Return the altered pointer. If there exists no sequence of casts that +// can transform from_type to to_type, return a NULL. + +BOOST_SERIALIZATION_DECL(void const *) +void_upcast( + extended_type_info const & derived, + extended_type_info const & base, + void const * const t +); + +inline void * +void_upcast( + extended_type_info const & derived, + extended_type_info const & base, + void * const t +){ + return const_cast<void*>(void_upcast( + derived, + base, + const_cast<void const *>(t) + )); +} + +BOOST_SERIALIZATION_DECL(void const *) +void_downcast( + extended_type_info const & derived, + extended_type_info const & base, + void const * const t +); + +inline void * +void_downcast( + extended_type_info const & derived, + extended_type_info const & base, + void * const t +){ + return const_cast<void*>(void_downcast( + derived, + base, + const_cast<void const *>(t) + )); +} + +namespace void_cast_detail { + +class BOOST_SERIALIZATION_DECL(BOOST_PP_EMPTY()) void_caster : + private boost::noncopyable +{ + friend + BOOST_SERIALIZATION_DECL(void const *) + boost::serialization::void_upcast( + extended_type_info const & derived, + extended_type_info const & base, + void const * const + ); + friend + BOOST_SERIALIZATION_DECL(void const *) + boost::serialization::void_downcast( + extended_type_info const & derived, + extended_type_info const & base, + void const * const + ); +protected: + void recursive_register(bool includes_virtual_base = false) const; + void recursive_unregister() const; + virtual bool has_virtual_base() const = 0; +public: + // Data members + const extended_type_info * m_derived; + const extended_type_info * m_base; + /*const*/ std::ptrdiff_t m_difference; + void_caster const * const m_parent; + + // note that void_casters are keyed on value of + // member extended type info records - NOT their + // addresses. This is necessary in order for the + // void cast operations to work across dll and exe + // module boundries. + bool operator<(const void_caster & rhs) const; + + const void_caster & operator*(){ + return *this; + } + // each derived class must re-implement these; + virtual void const * upcast(void const * const t) const = 0; + virtual void const * downcast(void const * const t) const = 0; + // Constructor + void_caster( + extended_type_info const * derived, + extended_type_info const * base, + std::ptrdiff_t difference = 0, + void_caster const * const parent = 0 + ) : + m_derived(derived), + m_base(base), + m_difference(difference), + m_parent(parent) + {} + virtual ~void_caster(){} +}; + +#ifdef BOOST_MSVC +# pragma warning(push) +# pragma warning(disable : 4251 4231 4660 4275 4511 4512) +#endif + +template <class Derived, class Base> +class void_caster_primitive : + public void_caster +{ + virtual void const * downcast(void const * const t) const { + const Derived * d = + boost::serialization::smart_cast<const Derived *, const Base *>( + static_cast<const Base *>(t) + ); + return d; + } + virtual void const * upcast(void const * const t) const { + const Base * b = + boost::serialization::smart_cast<const Base *, const Derived *>( + static_cast<const Derived *>(t) + ); + return b; + } + virtual bool has_virtual_base() const { + return false; + } +public: + void_caster_primitive(); + virtual ~void_caster_primitive(); +}; + +template <class Derived, class Base> +void_caster_primitive<Derived, Base>::void_caster_primitive() : + void_caster( + & type_info_implementation<Derived>::type::get_const_instance(), + & type_info_implementation<Base>::type::get_const_instance(), + // note:I wanted to display from 0 here, but at least one compiler + // treated 0 by not shifting it at all. + reinterpret_cast<std::ptrdiff_t>( + static_cast<Derived *>( + reinterpret_cast<Base *>(1) + ) + ) - 1 + ) +{ + recursive_register(); +} + +template <class Derived, class Base> +void_caster_primitive<Derived, Base>::~void_caster_primitive(){ + recursive_unregister(); +} + +template <class Derived, class Base> +class void_caster_virtual_base : + public void_caster +{ + virtual bool has_virtual_base() const { + return true; + } +public: + virtual void const * downcast(void const * const t) const { + const Derived * d = + dynamic_cast<const Derived *>( + static_cast<const Base *>(t) + ); + return d; + } + virtual void const * upcast(void const * const t) const { + const Base * b = + dynamic_cast<const Base *>( + static_cast<const Derived *>(t) + ); + return b; + } + void_caster_virtual_base(); + virtual ~void_caster_virtual_base(); +}; + +#ifdef BOOST_MSVC +#pragma warning(pop) +#endif + +template <class Derived, class Base> +void_caster_virtual_base<Derived,Base>::void_caster_virtual_base() : + void_caster( + & (type_info_implementation<Derived>::type::get_const_instance()), + & (type_info_implementation<Base>::type::get_const_instance()) + ) +{ + recursive_register(true); +} + +template <class Derived, class Base> +void_caster_virtual_base<Derived,Base>::~void_caster_virtual_base(){ + recursive_unregister(); +} + +template <class Derived, class Base> +struct void_caster_base : + public void_caster +{ + typedef + BOOST_DEDUCED_TYPENAME mpl::eval_if<boost::is_virtual_base_of<Base,Derived>, + mpl::identity< + void_cast_detail::void_caster_virtual_base<Derived, Base> + > + ,// else + mpl::identity< + void_cast_detail::void_caster_primitive<Derived, Base> + > + >::type type; +}; + +} // void_cast_detail + +template<class Derived, class Base> +BOOST_DLLEXPORT +inline const void_cast_detail::void_caster & void_cast_register( + Derived const * /* dnull = NULL */, + Base const * /* bnull = NULL */ +){ + typedef + BOOST_DEDUCED_TYPENAME mpl::eval_if<boost::is_virtual_base_of<Base,Derived>, + mpl::identity< + void_cast_detail::void_caster_virtual_base<Derived, Base> + > + ,// else + mpl::identity< + void_cast_detail::void_caster_primitive<Derived, Base> + > + >::type typex; + return singleton<typex>::get_const_instance(); +} + +template<class Derived, class Base> +class void_caster : + public void_cast_detail::void_caster_base<Derived, Base>::type +{ +}; + +} // namespace serialization +} // namespace boost + +#ifdef BOOST_MSVC +# pragma warning(pop) +#endif + +#include <boost/config/abi_suffix.hpp> // pops abi_suffix.hpp pragmas + +#endif // BOOST_SERIALIZATION_VOID_CAST_HPP |