You cannot select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and dots ('.'), can be up to 35 characters long. Letters must be lowercase.
336 lines
9.0 KiB
336 lines
9.0 KiB
// Copyright David Abrahams 2002. |
|
// 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 ARG_FROM_PYTHON_DWA2002127_HPP |
|
# define ARG_FROM_PYTHON_DWA2002127_HPP |
|
|
|
# include <boost/python/detail/prefix.hpp> |
|
# include <boost/python/converter/from_python.hpp> |
|
# include <boost/python/detail/indirect_traits.hpp> |
|
# include <boost/type_traits/transform_traits.hpp> |
|
# include <boost/type_traits/cv_traits.hpp> |
|
# include <boost/python/converter/rvalue_from_python_data.hpp> |
|
# include <boost/mpl/eval_if.hpp> |
|
# include <boost/mpl/if.hpp> |
|
# include <boost/mpl/identity.hpp> |
|
# include <boost/mpl/and.hpp> |
|
# include <boost/mpl/or.hpp> |
|
# include <boost/mpl/not.hpp> |
|
# include <boost/python/converter/registry.hpp> |
|
# include <boost/python/converter/registered.hpp> |
|
# include <boost/python/converter/registered_pointee.hpp> |
|
# include <boost/python/detail/void_ptr.hpp> |
|
# include <boost/python/back_reference.hpp> |
|
# include <boost/python/detail/referent_storage.hpp> |
|
# include <boost/python/converter/obj_mgr_arg_from_python.hpp> |
|
|
|
namespace boost { namespace python |
|
{ |
|
template <class T> struct arg_from_python; |
|
}} |
|
|
|
// This header defines Python->C++ function argument converters, |
|
// parametrized on the argument type. |
|
|
|
namespace boost { namespace python { namespace converter { |
|
|
|
// |
|
// lvalue converters |
|
// |
|
// These require that an lvalue of the type U is stored somewhere in |
|
// the Python object being converted. |
|
|
|
// Used when T == U*const& |
|
template <class T> |
|
struct pointer_cref_arg_from_python |
|
{ |
|
typedef T result_type; |
|
|
|
pointer_cref_arg_from_python(PyObject*); |
|
T operator()() const; |
|
bool convertible() const; |
|
|
|
private: // storage for a U* |
|
// needed because not all compilers will let us declare U* as the |
|
// return type of operator() -- we return U*const& instead |
|
typename python::detail::referent_storage<T>::type m_result; |
|
}; |
|
|
|
// Base class for pointer and reference converters |
|
struct arg_lvalue_from_python_base |
|
{ |
|
public: // member functions |
|
arg_lvalue_from_python_base(void* result); |
|
bool convertible() const; |
|
|
|
protected: // member functions |
|
void*const& result() const; |
|
|
|
private: // data members |
|
void* m_result; |
|
}; |
|
|
|
// Used when T == U* |
|
template <class T> |
|
struct pointer_arg_from_python : arg_lvalue_from_python_base |
|
{ |
|
typedef T result_type; |
|
|
|
pointer_arg_from_python(PyObject*); |
|
T operator()() const; |
|
}; |
|
|
|
// Used when T == U& and (T != V const& or T == W volatile&) |
|
template <class T> |
|
struct reference_arg_from_python : arg_lvalue_from_python_base |
|
{ |
|
typedef T result_type; |
|
|
|
reference_arg_from_python(PyObject*); |
|
T operator()() const; |
|
}; |
|
|
|
// =================== |
|
|
|
// |
|
// rvalue converters |
|
// |
|
// These require only that an object of type T can be created from |
|
// the given Python object, but not that the T object exist |
|
// somewhere in storage. |
|
// |
|
|
|
// Used when T is a plain value (non-pointer, non-reference) type or |
|
// a (non-volatile) const reference to a plain value type. |
|
template <class T> |
|
struct arg_rvalue_from_python |
|
{ |
|
typedef typename boost::add_reference< |
|
T |
|
// We can't add_const here, or it would be impossible to pass |
|
// auto_ptr<U> args from Python to C++ |
|
>::type result_type; |
|
|
|
arg_rvalue_from_python(PyObject*); |
|
bool convertible() const; |
|
|
|
# if BOOST_MSVC < 1301 || _MSC_FULL_VER > 13102196 |
|
typename arg_rvalue_from_python<T>:: |
|
# endif |
|
result_type operator()(); |
|
|
|
private: |
|
rvalue_from_python_data<result_type> m_data; |
|
PyObject* m_source; |
|
}; |
|
|
|
|
|
// ================== |
|
|
|
// Converts to a (PyObject*,T) bundle, for when you need a reference |
|
// back to the Python object |
|
template <class T> |
|
struct back_reference_arg_from_python |
|
: boost::python::arg_from_python<typename T::type> |
|
{ |
|
typedef T result_type; |
|
|
|
back_reference_arg_from_python(PyObject*); |
|
T operator()(); |
|
private: |
|
typedef boost::python::arg_from_python<typename T::type> base; |
|
PyObject* m_source; |
|
}; |
|
|
|
|
|
// ================== |
|
|
|
template <class C, class T, class F> |
|
struct if_2 |
|
{ |
|
typedef typename mpl::eval_if<C, mpl::identity<T>, F>::type type; |
|
}; |
|
|
|
// This metafunction selects the appropriate arg_from_python converter |
|
// type for an argument of type T. |
|
template <class T> |
|
struct select_arg_from_python |
|
{ |
|
typedef typename if_2< |
|
is_object_manager<T> |
|
, object_manager_value_arg_from_python<T> |
|
, if_2< |
|
is_reference_to_object_manager<T> |
|
, object_manager_ref_arg_from_python<T> |
|
, if_2< |
|
is_pointer<T> |
|
, pointer_arg_from_python<T> |
|
, if_2< |
|
mpl::and_< |
|
indirect_traits::is_reference_to_pointer<T> |
|
, indirect_traits::is_reference_to_const<T> |
|
, mpl::not_<indirect_traits::is_reference_to_volatile<T> > |
|
> |
|
, pointer_cref_arg_from_python<T> |
|
, if_2< |
|
mpl::or_< |
|
indirect_traits::is_reference_to_non_const<T> |
|
, indirect_traits::is_reference_to_volatile<T> |
|
> |
|
, reference_arg_from_python<T> |
|
, mpl::if_< |
|
boost::python::is_back_reference<T> |
|
, back_reference_arg_from_python<T> |
|
, arg_rvalue_from_python<T> |
|
> |
|
> |
|
> |
|
> |
|
> |
|
>::type type; |
|
}; |
|
|
|
// ================== |
|
|
|
// |
|
// implementations |
|
// |
|
|
|
// arg_lvalue_from_python_base |
|
// |
|
inline arg_lvalue_from_python_base::arg_lvalue_from_python_base(void* result) |
|
: m_result(result) |
|
{ |
|
} |
|
|
|
inline bool arg_lvalue_from_python_base::convertible() const |
|
{ |
|
return m_result != 0; |
|
} |
|
|
|
inline void*const& arg_lvalue_from_python_base::result() const |
|
{ |
|
return m_result; |
|
} |
|
|
|
// pointer_cref_arg_from_python |
|
// |
|
namespace detail |
|
{ |
|
// null_ptr_reference -- a function returning a reference to a null |
|
// pointer of type U. Needed so that extractors for T*const& can |
|
// convert Python's None. |
|
template <class T> |
|
struct null_ptr_owner |
|
{ |
|
static T value; |
|
}; |
|
template <class T> T null_ptr_owner<T>::value = 0; |
|
|
|
template <class U> |
|
inline U& null_ptr_reference(U&(*)()) |
|
{ |
|
return null_ptr_owner<U>::value; |
|
} |
|
} |
|
|
|
template <class T> |
|
inline pointer_cref_arg_from_python<T>::pointer_cref_arg_from_python(PyObject* p) |
|
{ |
|
// T == U*const&: store a U* in the m_result storage. Nonzero |
|
// indicates success. If find returns nonzero, it's a pointer to |
|
// a U object. |
|
python::detail::write_void_ptr_reference( |
|
m_result.bytes |
|
, p == Py_None ? p : converter::get_lvalue_from_python(p, registered_pointee<T>::converters) |
|
, (T(*)())0); |
|
} |
|
|
|
template <class T> |
|
inline bool pointer_cref_arg_from_python<T>::convertible() const |
|
{ |
|
return python::detail::void_ptr_to_reference(m_result.bytes, (T(*)())0) != 0; |
|
} |
|
template <class T> |
|
inline T pointer_cref_arg_from_python<T>::operator()() const |
|
{ |
|
return (*(void**)m_result.bytes == Py_None) // None ==> 0 |
|
? detail::null_ptr_reference((T(*)())0) |
|
// Otherwise, return a U*const& to the m_result storage. |
|
: python::detail::void_ptr_to_reference(m_result.bytes, (T(*)())0); |
|
} |
|
|
|
// pointer_arg_from_python |
|
// |
|
template <class T> |
|
inline pointer_arg_from_python<T>::pointer_arg_from_python(PyObject* p) |
|
: arg_lvalue_from_python_base( |
|
p == Py_None ? p : converter::get_lvalue_from_python(p, registered_pointee<T>::converters)) |
|
{ |
|
} |
|
|
|
template <class T> |
|
inline T pointer_arg_from_python<T>::operator()() const |
|
{ |
|
return (result() == Py_None) ? 0 : T(result()); |
|
} |
|
|
|
// reference_arg_from_python |
|
// |
|
template <class T> |
|
inline reference_arg_from_python<T>::reference_arg_from_python(PyObject* p) |
|
: arg_lvalue_from_python_base(converter::get_lvalue_from_python(p,registered<T>::converters)) |
|
{ |
|
} |
|
|
|
template <class T> |
|
inline T reference_arg_from_python<T>::operator()() const |
|
{ |
|
return python::detail::void_ptr_to_reference(result(), (T(*)())0); |
|
} |
|
|
|
|
|
// arg_rvalue_from_python |
|
// |
|
template <class T> |
|
inline arg_rvalue_from_python<T>::arg_rvalue_from_python(PyObject* obj) |
|
: m_data(converter::rvalue_from_python_stage1(obj, registered<T>::converters)) |
|
, m_source(obj) |
|
{ |
|
} |
|
|
|
template <class T> |
|
inline bool arg_rvalue_from_python<T>::convertible() const |
|
{ |
|
return m_data.stage1.convertible != 0; |
|
} |
|
|
|
template <class T> |
|
inline typename arg_rvalue_from_python<T>::result_type |
|
arg_rvalue_from_python<T>::operator()() |
|
{ |
|
if (m_data.stage1.construct != 0) |
|
m_data.stage1.construct(m_source, &m_data.stage1); |
|
|
|
return python::detail::void_ptr_to_reference(m_data.stage1.convertible, (result_type(*)())0); |
|
} |
|
|
|
// back_reference_arg_from_python |
|
// |
|
template <class T> |
|
back_reference_arg_from_python<T>::back_reference_arg_from_python(PyObject* x) |
|
: base(x), m_source(x) |
|
{ |
|
} |
|
|
|
template <class T> |
|
inline T |
|
back_reference_arg_from_python<T>::operator()() |
|
{ |
|
return T(m_source, base::operator()()); |
|
} |
|
|
|
}}} // namespace boost::python::converter |
|
|
|
#endif // ARG_FROM_PYTHON_DWA2002127_HPP
|
|
|