1 // Copyright David Abrahams 2002.
2 // Distributed under the Boost Software License, Version 1.0. (See
3 // accompanying file LICENSE_1_0.txt or copy at
4 // http://www.boost.org/LICENSE_1_0.txt)
5 #ifndef INHERITANCE_DWA200216_HPP
6 # define INHERITANCE_DWA200216_HPP
7
8 # include <boost/python/type_id.hpp>
9 # include <boost/shared_ptr.hpp>
10 # include <boost/mpl/if.hpp>
11 # include <boost/type_traits/is_polymorphic.hpp>
12 # include <boost/type_traits/is_base_and_derived.hpp>
13 # include <boost/detail/workaround.hpp>
14
15 namespace boost { namespace python { namespace objects {
16
17 typedef type_info class_id;
18 using python::type_id;
19
20 // Types used to get address and id of most derived type
21 typedef std::pair<void*,class_id> dynamic_id_t;
22 typedef dynamic_id_t (*dynamic_id_function)(void*);
23
24 BOOST_PYTHON_DECL void register_dynamic_id_aux(
25 class_id static_id, dynamic_id_function get_dynamic_id);
26
27 BOOST_PYTHON_DECL void add_cast(
28 class_id src_t, class_id dst_t, void* (*cast)(void*), bool is_downcast);
29
30 //
31 // a generator with an execute() function which, given a source type
32 // and a pointer to an object of that type, returns its most-derived
33 // /reachable/ type identifier and object pointer.
34 //
35
36 // first, the case where T has virtual functions
37 template <class T>
38 struct polymorphic_id_generator
39 {
executeboost::python::objects::polymorphic_id_generator40 static dynamic_id_t execute(void* p_)
41 {
42 T* p = static_cast<T*>(p_);
43 return std::make_pair(dynamic_cast<void*>(p), class_id(typeid(*p)));
44 }
45 };
46
47 // now, the non-polymorphic case.
48 template <class T>
49 struct non_polymorphic_id_generator
50 {
executeboost::python::objects::non_polymorphic_id_generator51 static dynamic_id_t execute(void* p_)
52 {
53 return std::make_pair(p_, python::type_id<T>());
54 }
55 };
56
57 // Now the generalized selector
58 template <class T>
59 struct dynamic_id_generator
60 : mpl::if_<
61 boost::is_polymorphic<T>
62 , boost::python::objects::polymorphic_id_generator<T>
63 , boost::python::objects::non_polymorphic_id_generator<T>
64 >
65 {};
66
67 // Register the dynamic id function for T with the type-conversion
68 // system.
69 template <class T>
register_dynamic_id(T * =0)70 void register_dynamic_id(T* = 0)
71 {
72 typedef typename dynamic_id_generator<T>::type generator;
73 register_dynamic_id_aux(
74 python::type_id<T>(), &generator::execute);
75 }
76
77 //
78 // a generator with an execute() function which, given a void*
79 // pointing to an object of type Source will attempt to convert it to
80 // an object of type Target.
81 //
82
83 template <class Source, class Target>
84 struct dynamic_cast_generator
85 {
executeboost::python::objects::dynamic_cast_generator86 static void* execute(void* source)
87 {
88 return dynamic_cast<Target*>(
89 static_cast<Source*>(source));
90 }
91
92 };
93
94 template <class Source, class Target>
95 struct implicit_cast_generator
96 {
executeboost::python::objects::implicit_cast_generator97 static void* execute(void* source)
98 {
99 Target* result = static_cast<Source*>(source);
100 return result;
101 }
102 };
103
104 template <class Source, class Target>
105 struct cast_generator
106 : mpl::if_<
107 is_base_and_derived<Target,Source>
108 , implicit_cast_generator<Source,Target>
109 , dynamic_cast_generator<Source,Target>
110 >
111 {
112 };
113
114 template <class Source, class Target>
115 inline void register_conversion(
116 bool is_downcast = ::boost::is_base_and_derived<Source,Target>::value
117 // These parameters shouldn't be used; they're an MSVC bug workaround
118 , Source* = 0, Target* = 0)
119 {
120 typedef typename cast_generator<Source,Target>::type generator;
121
122 add_cast(
123 python::type_id<Source>()
124 , python::type_id<Target>()
125 , &generator::execute
126 , is_downcast
127 );
128 }
129
130 }}} // namespace boost::python::object
131
132 #endif // INHERITANCE_DWA200216_HPP
133