source: NonGTP/Boost/boost/serialization/base_object.hpp @ 857

#ifndef BOOST_SERIALIZATION_BASE_OBJECT_HPP
#define BOOST_SERIALIZATION_BASE_OBJECT_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
// base_object.hpp:

// (C) Copyright 2002 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)

//  See http://www.boost.org for updates, documentation, and revision history.

// if no archive headers have been included this is a no op
// this is to permit BOOST_EXPORT etc to be included in a 
// file declaration header

#include <boost/config.hpp>
#include <boost/detail/workaround.hpp>

#include <boost/mpl/eval_if.hpp>
#include <boost/mpl/int.hpp>
#include <boost/type_traits/is_base_and_derived.hpp>
#include <boost/type_traits/is_pointer.hpp>
#include <boost/type_traits/is_const.hpp>

#include <boost/static_assert.hpp>
#include <boost/serialization/type_info_implementation.hpp>
#include <boost/serialization/force_include.hpp>
#include <boost/serialization/void_cast_fwd.hpp>

namespace boost {
namespace serialization {

namespace detail {
    // metrowerks CodeWarrior
    #if BOOST_WORKAROUND(__MWERKS__, BOOST_TESTED_AT(0x3206)) 
        // only register void casts if the types are polymorphic
        template<class Base, class Derived>
        struct base_register{
            struct nothing {
                static const void_cast_detail::void_caster & invoke(){
                    return static_cast<const void_cast_detail::void_caster &>(
                        * static_cast<const void_cast_detail::void_caster *>(NULL)
                    );
                }
            };

            // hold a reference to the void_cast_register and void_caster in the hope of 
            // ensuring code instantiation for some compilers with over-zealous link time 
            // optimiser. The compiler that demanded this was CW
            struct reg{
                typedef const void_cast_detail::void_caster & (* t_vcr)(
                    const Derived *,
                    const Base *
                );
                t_vcr m_vcr;
                static const void_cast_detail::void_caster & invoke(){
                    return  void_cast_register<const Derived, const Base>(
                        static_cast<const Derived *>(NULL),
                        static_cast<const Base *>(NULL)
                    );
                }
                reg() :
                    m_vcr(static_cast<t_vcr>(void_cast_register))
                {
                }
            } m_reg;

            static const void_cast_detail::void_caster & invoke(){
                typedef BOOST_DEDUCED_TYPENAME mpl::eval_if<
                    BOOST_DEDUCED_TYPENAME type_info_implementation<Base>::type::is_polymorphic,
                    mpl::identity<reg>,
                    mpl::identity<nothing>
                >::type typex;
                return typex::invoke();
            }

            const void_cast_detail::void_caster & m_vc;
            Derived & m_d;

            base_register(Derived & d) :
                m_vc(invoke()),
                m_d(d)
            {}
            Base & get_base() const {
                return m_d;
            }
        };
    #else
        // only register void casts if the types are polymorphic
        template<class Base, class Derived>
        struct base_register{
            struct nothing {
                static void invoke(){}
            };
            struct reg{
                static void invoke(){
                    void_cast_register<const Derived, const Base>(
                        static_cast<const Derived *>(NULL),
                        static_cast<const Base *>(NULL)
                    );
                }
            };
            static void invoke(){
                typedef BOOST_DEDUCED_TYPENAME mpl::eval_if<
                    BOOST_DEDUCED_TYPENAME type_info_implementation<Base>::type::is_polymorphic,
                    mpl::identity<reg>,
                    mpl::identity<nothing>
                >::type typex;
                typex::invoke();
            }
        };
    #endif
    // get the base type for a given derived type
    // preserving the const-ness
    template<class B, class D>
    struct base_cast
    {
        typedef BOOST_DEDUCED_TYPENAME
            mpl::if_<
                is_const<D>,
                const B,
                B
        >::type type;
        BOOST_STATIC_ASSERT(is_const<type>::value == is_const<D>::value);
    };
} // namespace detail

// metrowerks CodeWarrior
#if BOOST_WORKAROUND(__MWERKS__, BOOST_TESTED_AT(0x3206)) 
template<class Base, class Derived>
BOOST_DEDUCED_TYPENAME detail::base_cast<Base, Derived>::type & 
base_object(Derived &d)
{
    BOOST_STATIC_ASSERT(( is_base_and_derived<Base,Derived>::value));
    BOOST_STATIC_ASSERT(! is_pointer<Derived>::value);
    typedef BOOST_DEDUCED_TYPENAME detail::base_cast<Base, Derived>::type type;
    return detail::base_register<type, Derived>(d).get_base();
}
// BORLAND
#elif BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x560))
template<class Base, class Derived>
const Base & 
base_object(const Derived & d)
{
    BOOST_STATIC_ASSERT(! is_pointer<Derived>::value);
    detail::base_register<Base, Derived>::invoke();
    return static_cast<const Base &>(d);
}
#else
template<class Base, class Derived>
BOOST_DEDUCED_TYPENAME detail::base_cast<Base, Derived>::type & 
base_object(Derived &d)
{
    BOOST_STATIC_ASSERT(( is_base_and_derived<Base,Derived>::value));
    BOOST_STATIC_ASSERT(! is_pointer<Derived>::value);
    typedef BOOST_DEDUCED_TYPENAME detail::base_cast<Base, Derived>::type type;
    detail::base_register<type, Derived>::invoke();
    return static_cast<type &>(d);
}
#endif

} // namespace serialization
} // namespace boost

#endif // BOOST_SERIALIZATION_BASE_OBJECT_HPP