source: NonGTP/Boost/boost/python/converter/arg_from_python.hpp @ 857

Revision 857, 9.4 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 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
28namespace 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
36namespace 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&
45template <class T>
46struct 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
61struct 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*
75template <class T>
76struct 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&)
85template <class T>
86struct 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.
106template <class T>
107struct 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
133template <class T>
134struct 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
149template <class C, class T, class F>
150struct 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.
157template <class T>
158struct 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//
202inline arg_lvalue_from_python_base::arg_lvalue_from_python_base(void* result)
203    : m_result(result)
204{
205}
206
207inline bool arg_lvalue_from_python_base::convertible() const
208{
209    return m_result != 0;
210}
211
212inline void*const& arg_lvalue_from_python_base::result() const
213{
214    return m_result;
215}
216
217// pointer_cref_arg_from_python
218//
219namespace 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>
232  inline U& null_ptr_reference(U&(*)())
233  {
234      return null_ptr_owner<U>::value;
235  }
236}
237
238template <class T>
239inline 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
250template <class T>
251inline 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}
255template <class T>
256inline 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//
266template <class T>
267inline 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
273template <class T>
274inline 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//
281template <class T>
282inline 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
287template <class T>
288inline 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//
296template <class T>
297inline 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
303template <class T>
304inline bool arg_rvalue_from_python<T>::convertible() const
305{
306    return m_data.stage1.convertible != 0;
307}
308
309template <class T>
310inline typename arg_rvalue_from_python<T>::result_type
311arg_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//
321template <class T>
322back_reference_arg_from_python<T>::back_reference_arg_from_python(PyObject* x)
323  : base(x), m_source(x)
324{
325}
326
327template <class T>
328inline T
329back_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
Note: See TracBrowser for help on using the repository browser.