You cannot select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and dots ('.'), can be up to 35 characters long. Letters must be lowercase.
132 lines
3.5 KiB
132 lines
3.5 KiB
// 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
|
|
|