#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 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 <boost/smart_cast.hpp>

#include <boost/mpl/eval_if.hpp>

#include <boost/mpl/identity.hpp>

#include <boost/serialization/config.hpp>

#include <boost/serialization/force_include.hpp>

#include <boost/serialization/type_info_implementation.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 BOOST_SERIALIZATION_DECL(BOOST_PP_EMPTY()) 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_type,  

    extended_type_info const & base_type, 

    void const * const t,

    bool top = true

);

inline void *

void_upcast(

    extended_type_info const & derived_type_,

    extended_type_info const & base_type_,

    void * const t 

){

    return const_cast<void*>(void_upcast(

        derived_type_, 

        base_type_, 

        const_cast<void const *>(t)

    ));

}

BOOST_SERIALIZATION_DECL(void const *)

void_downcast(

    extended_type_info const & derived_type,  

    extended_type_info const & base_type, 

    void const * const t,

    bool top = true

);

inline void *

void_downcast(

    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_, 

        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::void_upcast(

        const extended_type_info & derived_type,

        const extended_type_info & base_type,

        const void * t,

        bool top

    );

    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

    );

    // 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 *);

public:

    // Constructor

    void_caster(

        extended_type_info const & derived_type_,

        extended_type_info const & base_type_ 

    );

    // predicate used to determine if this void caster includes

    // a particular eti *

    bool includes(const extended_type_info * eti) const;

    virtual ~void_caster();

private:

    // cw 8.3 requires this!!

    void_caster& operator=(void_caster const&);

};

template <class Derived, class Base>

class void_caster_primitive : 

    public void_caster

{

    virtual void const* downcast( void const * t ) 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 *>(

            static_cast<const Derived *>(t)

        );

        return b;

    }

public:

    static const void_caster_primitive instance;

    void_caster_primitive() BOOST_USED;

};

template <class Derived, class Base>

void_caster_primitive<Derived, Base>::void_caster_primitive() :

    void_caster( 

        * type_info_implementation<Derived>::type::get_instance(), 

        * type_info_implementation<Base>::type::get_instance() 

    )

{

    this->static_register(& instance);

}

// the purpose of this class is to create to->from and from->to instances

// of void_caster_primitive for each related pair of types.  This has to be

// done a pre-execution time - hence the usage of static variable.

template<class Derived, class Base>

const void_caster_primitive<Derived, Base>

    void_caster_primitive<Derived, Base>::instance;

} // void_cast_detail 

// Register a base/derived pair.  This indicates that it is possible

// to upcast a void pointer from Derived to Base and downcast a

// void pointer from Base to Derived.  Note bogus arguments to workaround

// bug in msvc 6.0

template<class Derived, class Base>

BOOST_DLLEXPORT 

inline const void_cast_detail::void_caster & void_cast_register(

    const Derived * dnull, 

    const Base * bnull

) BOOST_USED;

template<class Derived, class Base>

BOOST_DLLEXPORT 

inline const void_cast_detail::void_caster & void_cast_register(

    const Derived * /* dnull = NULL */, 

    const Base * /* bnull = NULL */

){

    return void_cast_detail::void_caster_primitive<

        const Derived, 

        const Base

    >::instance;

}

} // namespace serialization

} // namespace boost

#include <boost/config/abi_suffix.hpp> // pops abi_suffix.hpp pragmas

#endif // BOOST_SERIALIZATION_VOID_CAST_HPP