1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
|
// Copyright David Abrahams 2003.
// 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 PURE_VIRTUAL_DWA2003810_HPP
# define PURE_VIRTUAL_DWA2003810_HPP
# include <boost/python/def_visitor.hpp>
# include <boost/python/default_call_policies.hpp>
# include <boost/mpl/push_front.hpp>
# include <boost/mpl/pop_front.hpp>
# include <boost/python/detail/nullary_function_adaptor.hpp>
namespace boost { namespace python {
namespace detail
{
//
// @group Helpers for pure_virtual_visitor. {
//
// Raises a Python RuntimeError reporting that a pure virtual
// function was called.
void BOOST_PYTHON_DECL pure_virtual_called();
// Replace the two front elements of S with T1 and T2
template <class S, class T1, class T2>
struct replace_front2
{
// Metafunction forwarding seemed to confound vc6
typedef typename mpl::push_front<
typename mpl::push_front<
typename mpl::pop_front<
typename mpl::pop_front<
S
>::type
>::type
, T2
>::type
, T1
>::type type;
};
// Given an MPL sequence representing a member function [object]
// signature, returns a new MPL sequence whose return type is
// replaced by void, and whose first argument is replaced by C&.
template <class C, class S>
typename replace_front2<S,void,C&>::type
error_signature(S)
{
typedef typename replace_front2<S,void,C&>::type r;
return r();
}
//
// }
//
//
// A def_visitor which defines a method as usual, then adds a
// corresponding function which raises a "pure virtual called"
// exception unless it's been overridden.
//
template <class PointerToMemberFunction>
struct pure_virtual_visitor
: def_visitor<pure_virtual_visitor<PointerToMemberFunction> >
{
pure_virtual_visitor(PointerToMemberFunction pmf)
: m_pmf(pmf)
{}
private:
friend class python::def_visitor_access;
template <class C_, class Options>
void visit(C_& c, char const* name, Options& options) const
{
// This should probably be a nicer error message
BOOST_STATIC_ASSERT(!Options::has_default_implementation);
// Add the virtual function dispatcher
c.def(
name
, m_pmf
, options.doc()
, options.keywords()
, options.policies()
);
typedef BOOST_DEDUCED_TYPENAME C_::metadata::held_type held_type;
// Add the default implementation which raises the exception
c.def(
name
, make_function(
detail::nullary_function_adaptor<void(*)()>(pure_virtual_called)
, default_call_policies()
, detail::error_signature<held_type>(detail::get_signature(m_pmf))
)
);
}
private: // data members
PointerToMemberFunction m_pmf;
};
}
//
// Passed a pointer to member function, generates a def_visitor which
// creates a method that only dispatches to Python if the function has
// been overridden, either in C++ or in Python, raising a "pure
// virtual called" exception otherwise.
//
template <class PointerToMemberFunction>
detail::pure_virtual_visitor<PointerToMemberFunction>
pure_virtual(PointerToMemberFunction pmf)
{
return detail::pure_virtual_visitor<PointerToMemberFunction>(pmf);
}
}} // namespace boost::python
#endif // PURE_VIRTUAL_DWA2003810_HPP
|
