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 ARG_FROM_PYTHON_DWA2002127_HPP
6 # define ARG_FROM_PYTHON_DWA2002127_HPP
7
8 # include <boost/python/detail/prefix.hpp>
9 # include <boost/python/converter/from_python.hpp>
10 # include <boost/python/detail/indirect_traits.hpp>
11 # include <boost/type_traits/transform_traits.hpp>
12 # include <boost/type_traits/cv_traits.hpp>
13 # include <boost/python/converter/rvalue_from_python_data.hpp>
14 # include <boost/mpl/eval_if.hpp>
15 # include <boost/mpl/if.hpp>
16 # include <boost/mpl/identity.hpp>
17 # include <boost/mpl/and.hpp>
18 # include <boost/mpl/or.hpp>
19 # include <boost/mpl/not.hpp>
20 # include <boost/python/converter/registry.hpp>
21 # include <boost/python/converter/registered.hpp>
22 # include <boost/python/converter/registered_pointee.hpp>
23 # include <boost/python/detail/void_ptr.hpp>
24 # include <boost/python/back_reference.hpp>
25 # include <boost/python/detail/referent_storage.hpp>
26 # include <boost/python/converter/obj_mgr_arg_from_python.hpp>
27
28 namespace boost { namespace python
29 {
30 template <class T> struct arg_from_python;
31 }}
32
33 // This header defines Python->C++ function argument converters,
34 // parametrized on the argument type.
35
36 namespace boost { namespace python { namespace converter {
37
38 //
39 // lvalue converters
40 //
41 // These require that an lvalue of the type U is stored somewhere in
42 // the Python object being converted.
43
44 // Used when T == U*const&
45 template <class T>
46 struct pointer_cref_arg_from_python
47 {
48 typedef T result_type;
49
50 pointer_cref_arg_from_python(PyObject*);
51 T operator()() const;
52 bool convertible() const;
53
54 private: // storage for a U*
55 // needed because not all compilers will let us declare U* as the
56 // return type of operator() -- we return U*const& instead
57 typename python::detail::referent_storage<T>::type m_result;
58 };
59
60 // Base class for pointer and reference converters
61 struct arg_lvalue_from_python_base
62 {
63 public: // member functions
64 arg_lvalue_from_python_base(void* result);
65 bool convertible() const;
66
67 protected: // member functions
68 void*const& result() const;
69
70 private: // data members
71 void* m_result;
72 };
73
74 // Used when T == U*
75 template <class T>
76 struct pointer_arg_from_python : arg_lvalue_from_python_base
77 {
78 typedef T result_type;
79
80 pointer_arg_from_python(PyObject*);
81 T operator()() const;
82 };
83
84 // Used when T == U& and (T != V const& or T == W volatile&)
85 template <class T>
86 struct reference_arg_from_python : arg_lvalue_from_python_base
87 {
88 typedef T result_type;
89
90 reference_arg_from_python(PyObject*);
91 T operator()() const;
92 };
93
94 // ===================
95
96 //
97 // rvalue converters
98 //
99 // These require only that an object of type T can be created from
100 // the given Python object, but not that the T object exist
101 // somewhere in storage.
102 //
103
104 // Used when T is a plain value (non-pointer, non-reference) type or
105 // a (non-volatile) const reference to a plain value type.
106 template <class T>
107 struct arg_rvalue_from_python
108 {
109 typedef typename boost::add_reference<
110 T
111 // We can't add_const here, or it would be impossible to pass
112 // auto_ptr<U> args from Python to C++
113 >::type result_type;
114
115 arg_rvalue_from_python(PyObject*);
116 bool convertible() const;
117
118 # if BOOST_MSVC < 1301 || _MSC_FULL_VER > 13102196
119 typename arg_rvalue_from_python<T>::
120 # endif
121 result_type operator()();
122
123 private:
124 rvalue_from_python_data<result_type> m_data;
125 PyObject* m_source;
126 };
127
128
129 // ==================
130
131 // Converts to a (PyObject*,T) bundle, for when you need a reference
132 // back to the Python object
133 template <class T>
134 struct back_reference_arg_from_python
135 : boost::python::arg_from_python<typename T::type>
136 {
137 typedef T result_type;
138
139 back_reference_arg_from_python(PyObject*);
140 T operator()();
141 private:
142 typedef boost::python::arg_from_python<typename T::type> base;
143 PyObject* m_source;
144 };
145
146
147 // ==================
148
149 template <class C, class T, class F>
150 struct if_2
151 {
152 typedef typename mpl::eval_if<C, mpl::identity<T>, F>::type type;
153 };
154
155 // This metafunction selects the appropriate arg_from_python converter
156 // type for an argument of type T.
157 template <class T>
158 struct select_arg_from_python
159 {
160 typedef typename if_2<
161 is_object_manager<T>
162 , object_manager_value_arg_from_python<T>
163 , if_2<
164 is_reference_to_object_manager<T>
165 , object_manager_ref_arg_from_python<T>
166 , if_2<
167 is_pointer<T>
168 , pointer_arg_from_python<T>
169 , if_2<
170 mpl::and_<
171 indirect_traits::is_reference_to_pointer<T>
172 , indirect_traits::is_reference_to_const<T>
173 , mpl::not_<indirect_traits::is_reference_to_volatile<T> >
174 >
175 , pointer_cref_arg_from_python<T>
176 , if_2<
177 mpl::or_<
178 indirect_traits::is_reference_to_non_const<T>
179 , indirect_traits::is_reference_to_volatile<T>
180 >
181 , reference_arg_from_python<T>
182 , mpl::if_<
183 boost::python::is_back_reference<T>
184 , back_reference_arg_from_python<T>
185 , arg_rvalue_from_python<T>
186 >
187 >
188 >
189 >
190 >
191 >::type type;
192 };
193
194 // ==================
195
196 //
197 // implementations
198 //
199
200 // arg_lvalue_from_python_base
201 //
arg_lvalue_from_python_base(void * result)202 inline arg_lvalue_from_python_base::arg_lvalue_from_python_base(void* result)
203 : m_result(result)
204 {
205 }
206
convertible() const207 inline bool arg_lvalue_from_python_base::convertible() const
208 {
209 return m_result != 0;
210 }
211
result() const212 inline void*const& arg_lvalue_from_python_base::result() const
213 {
214 return m_result;
215 }
216
217 // pointer_cref_arg_from_python
218 //
219 namespace detail
220 {
221 // null_ptr_reference -- a function returning a reference to a null
222 // pointer of type U. Needed so that extractors for T*const& can
223 // convert Python's None.
224 template <class T>
225 struct null_ptr_owner
226 {
227 static T value;
228 };
229 template <class T> T null_ptr_owner<T>::value = 0;
230
231 template <class U>
null_ptr_reference(U & (*)())232 inline U& null_ptr_reference(U&(*)())
233 {
234 return null_ptr_owner<U>::value;
235 }
236 }
237
238 template <class T>
pointer_cref_arg_from_python(PyObject * p)239 inline pointer_cref_arg_from_python<T>::pointer_cref_arg_from_python(PyObject* p)
240 {
241 // T == U*const&: store a U* in the m_result storage. Nonzero
242 // indicates success. If find returns nonzero, it's a pointer to
243 // a U object.
244 python::detail::write_void_ptr_reference(
245 m_result.bytes
246 , p == Py_None ? p : converter::get_lvalue_from_python(p, registered_pointee<T>::converters)
247 , (T(*)())0);
248 }
249
250 template <class T>
convertible() const251 inline bool pointer_cref_arg_from_python<T>::convertible() const
252 {
253 return python::detail::void_ptr_to_reference(m_result.bytes, (T(*)())0) != 0;
254 }
255 template <class T>
operator ()() const256 inline T pointer_cref_arg_from_python<T>::operator()() const
257 {
258 return (*(void**)m_result.bytes == Py_None) // None ==> 0
259 ? detail::null_ptr_reference((T(*)())0)
260 // Otherwise, return a U*const& to the m_result storage.
261 : python::detail::void_ptr_to_reference(m_result.bytes, (T(*)())0);
262 }
263
264 // pointer_arg_from_python
265 //
266 template <class T>
pointer_arg_from_python(PyObject * p)267 inline pointer_arg_from_python<T>::pointer_arg_from_python(PyObject* p)
268 : arg_lvalue_from_python_base(
269 p == Py_None ? p : converter::get_lvalue_from_python(p, registered_pointee<T>::converters))
270 {
271 }
272
273 template <class T>
operator ()() const274 inline T pointer_arg_from_python<T>::operator()() const
275 {
276 return (result() == Py_None) ? 0 : T(result());
277 }
278
279 // reference_arg_from_python
280 //
281 template <class T>
reference_arg_from_python(PyObject * p)282 inline reference_arg_from_python<T>::reference_arg_from_python(PyObject* p)
283 : arg_lvalue_from_python_base(converter::get_lvalue_from_python(p,registered<T>::converters))
284 {
285 }
286
287 template <class T>
operator ()() const288 inline T reference_arg_from_python<T>::operator()() const
289 {
290 return python::detail::void_ptr_to_reference(result(), (T(*)())0);
291 }
292
293
294 // arg_rvalue_from_python
295 //
296 template <class T>
arg_rvalue_from_python(PyObject * obj)297 inline arg_rvalue_from_python<T>::arg_rvalue_from_python(PyObject* obj)
298 : m_data(converter::rvalue_from_python_stage1(obj, registered<T>::converters))
299 , m_source(obj)
300 {
301 }
302
303 template <class T>
convertible() const304 inline bool arg_rvalue_from_python<T>::convertible() const
305 {
306 return m_data.stage1.convertible != 0;
307 }
308
309 template <class T>
310 inline typename arg_rvalue_from_python<T>::result_type
operator ()()311 arg_rvalue_from_python<T>::operator()()
312 {
313 if (m_data.stage1.construct != 0)
314 m_data.stage1.construct(m_source, &m_data.stage1);
315
316 return python::detail::void_ptr_to_reference(m_data.stage1.convertible, (result_type(*)())0);
317 }
318
319 // back_reference_arg_from_python
320 //
321 template <class T>
back_reference_arg_from_python(PyObject * x)322 back_reference_arg_from_python<T>::back_reference_arg_from_python(PyObject* x)
323 : base(x), m_source(x)
324 {
325 }
326
327 template <class T>
328 inline T
operator ()()329 back_reference_arg_from_python<T>::operator()()
330 {
331 return T(m_source, base::operator()());
332 }
333
334 }}} // namespace boost::python::converter
335
336 #endif // ARG_FROM_PYTHON_DWA2002127_HPP
337