// Copyright David Abrahams 2002.

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

#ifndef INHERITANCE_DWA200216_HPP

# define INHERITANCE_DWA200216_HPP



# include <boost/python/type_id.hpp>

# include <boost/shared_ptr.hpp>

# include <boost/mpl/if.hpp>

# include <boost/type_traits/is_polymorphic.hpp>

# include <boost/type_traits/is_base_and_derived.hpp>

# include <boost/detail/workaround.hpp>



namespace boost { namespace python { namespace objects {



typedef type_info class_id;

using python::type_id;



// Types used to get address and id of most derived type

typedef std::pair<void*,class_id> dynamic_id_t;

typedef dynamic_id_t (*dynamic_id_function)(void*);



BOOST_PYTHON_DECL void register_dynamic_id_aux(

    class_id static_id, dynamic_id_function get_dynamic_id);



BOOST_PYTHON_DECL void add_cast(

    class_id src_t, class_id dst_t, void* (*cast)(void*), bool is_downcast);



//

// a generator with an execute() function which, given a source type

// and a pointer to an object of that type, returns its most-derived

// /reachable/ type identifier and object pointer.

//



// first, the case where T has virtual functions

template <class T>

struct polymorphic_id_generator

{

    static dynamic_id_t execute(void* p_)

    {

        T* p = static_cast<T*>(p_);

        return std::make_pair(dynamic_cast<void*>(p), class_id(typeid(*p)));

    }

};



// now, the non-polymorphic case.

template <class T>

struct non_polymorphic_id_generator

{

    static dynamic_id_t execute(void* p_)

    {

        return std::make_pair(p_, python::type_id<T>());

    }

};



// Now the generalized selector

template <class T>

struct dynamic_id_generator

  : mpl::if_<

        boost::is_polymorphic<T>

        , boost::python::objects::polymorphic_id_generator<T>

        , boost::python::objects::non_polymorphic_id_generator<T>

    >

{};



// Register the dynamic id function for T with the type-conversion

// system.

template <class T>

void register_dynamic_id(T* = 0)

{

    typedef typename dynamic_id_generator<T>::type generator;

    register_dynamic_id_aux(

        python::type_id<T>(), &generator::execute);

}



//

// a generator with an execute() function which, given a void*

// pointing to an object of type Source will attempt to convert it to

// an object of type Target.

//



template <class Source, class Target>

struct dynamic_cast_generator

{

    static void* execute(void* source)

    {

        return dynamic_cast<Target*>(

            static_cast<Source*>(source));

    }

        

};



template <class Source, class Target>

struct implicit_cast_generator

{

    static void* execute(void* source)

    {

        Target* result = static_cast<Source*>(source);

        return result;

    }

};



template <class Source, class Target>

struct cast_generator

  : mpl::if_<

        is_base_and_derived<Target,Source>

      , implicit_cast_generator<Source,Target>

      , dynamic_cast_generator<Source,Target>

    >

{

};



template <class Source, class Target>

inline void register_conversion(

    bool is_downcast = ::boost::is_base_and_derived<Source,Target>::value

    // These parameters shouldn't be used; they're an MSVC bug workaround

    , Source* = 0, Target* = 0)

{

    typedef typename cast_generator<Source,Target>::type generator;



    add_cast(

        python::type_id<Source>()

      , python::type_id<Target>()

      , &generator::execute

      , is_downcast

    );

}



}}} // namespace boost::python::object



#endif // INHERITANCE_DWA200216_HPP

