source: NonGTP/Boost/boost/python/object/inheritance.hpp @ 857

Revision 857, 3.6 KB checked in by igarcia, 19 years ago (diff)
Line 
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
15namespace boost { namespace python { namespace objects {
16
17typedef type_info class_id;
18using python::type_id;
19
20// Types used to get address and id of most derived type
21typedef std::pair<void*,class_id> dynamic_id_t;
22typedef dynamic_id_t (*dynamic_id_function)(void*);
23
24BOOST_PYTHON_DECL void register_dynamic_id_aux(
25    class_id static_id, dynamic_id_function get_dynamic_id);
26
27BOOST_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
37template <class T>
38struct polymorphic_id_generator
39{
40    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.
48template <class T>
49struct non_polymorphic_id_generator
50{
51    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
58template <class T>
59struct 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.
69template <class T>
70void 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
83template <class Source, class Target>
84struct dynamic_cast_generator
85{
86    static void* execute(void* source)
87    {
88        return dynamic_cast<Target*>(
89            static_cast<Source*>(source));
90    }
91       
92};
93
94template <class Source, class Target>
95struct implicit_cast_generator
96{
97    static void* execute(void* source)
98    {
99        Target* result = static_cast<Source*>(source);
100        return result;
101    }
102};
103
104template <class Source, class Target>
105struct 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
114template <class Source, class Target>
115inline 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
Note: See TracBrowser for help on using the repository browser.