You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
259 lines
5.8 KiB
259 lines
5.8 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 EXTRACT_DWA200265_HPP |
|
# define EXTRACT_DWA200265_HPP |
|
|
|
# include <boost/python/detail/prefix.hpp> |
|
|
|
# include <boost/python/converter/object_manager.hpp> |
|
# include <boost/python/converter/from_python.hpp> |
|
# include <boost/python/converter/rvalue_from_python_data.hpp> |
|
# include <boost/python/converter/registered.hpp> |
|
# include <boost/python/converter/registered_pointee.hpp> |
|
|
|
# include <boost/python/object_core.hpp> |
|
# include <boost/python/refcount.hpp> |
|
|
|
# include <boost/python/detail/copy_ctor_mutates_rhs.hpp> |
|
# include <boost/python/detail/void_ptr.hpp> |
|
# include <boost/python/detail/void_return.hpp> |
|
# include <boost/call_traits.hpp> |
|
|
|
#if BOOST_WORKAROUND(BOOST_INTEL_WIN, <= 900) |
|
# define BOOST_EXTRACT_WORKAROUND () |
|
#else |
|
# define BOOST_EXTRACT_WORKAROUND |
|
#endif |
|
|
|
namespace boost { namespace python { |
|
|
|
namespace api |
|
{ |
|
class object; |
|
} |
|
|
|
namespace converter |
|
{ |
|
template <class Ptr> |
|
struct extract_pointer |
|
{ |
|
typedef Ptr result_type; |
|
extract_pointer(PyObject*); |
|
|
|
bool check() const; |
|
Ptr operator()() const; |
|
|
|
private: |
|
PyObject* m_source; |
|
void* m_result; |
|
}; |
|
|
|
template <class Ref> |
|
struct extract_reference |
|
{ |
|
typedef Ref result_type; |
|
extract_reference(PyObject*); |
|
|
|
bool check() const; |
|
Ref operator()() const; |
|
|
|
private: |
|
PyObject* m_source; |
|
void* m_result; |
|
}; |
|
|
|
template <class T> |
|
struct extract_rvalue : private noncopyable |
|
{ |
|
typedef typename mpl::if_< |
|
python::detail::copy_ctor_mutates_rhs<T> |
|
, T& |
|
, typename call_traits<T>::param_type |
|
>::type result_type; |
|
|
|
extract_rvalue(PyObject*); |
|
|
|
bool check() const; |
|
result_type operator()() const; |
|
private: |
|
PyObject* m_source; |
|
mutable rvalue_from_python_data<T> m_data; |
|
}; |
|
|
|
template <class T> |
|
struct extract_object_manager |
|
{ |
|
typedef T result_type; |
|
extract_object_manager(PyObject*); |
|
|
|
bool check() const; |
|
result_type operator()() const; |
|
private: |
|
PyObject* m_source; |
|
}; |
|
|
|
template <class T> |
|
struct select_extract |
|
{ |
|
BOOST_STATIC_CONSTANT( |
|
bool, obj_mgr = is_object_manager<T>::value); |
|
|
|
BOOST_STATIC_CONSTANT( |
|
bool, ptr = is_pointer<T>::value); |
|
|
|
BOOST_STATIC_CONSTANT( |
|
bool, ref = is_reference<T>::value); |
|
|
|
typedef typename mpl::if_c< |
|
obj_mgr |
|
, extract_object_manager<T> |
|
, typename mpl::if_c< |
|
ptr |
|
, extract_pointer<T> |
|
, typename mpl::if_c< |
|
ref |
|
, extract_reference<T> |
|
, extract_rvalue<T> |
|
>::type |
|
>::type |
|
>::type type; |
|
}; |
|
} |
|
|
|
template <class T> |
|
struct extract |
|
: converter::select_extract<T>::type |
|
{ |
|
private: |
|
typedef typename converter::select_extract<T>::type base; |
|
public: |
|
typedef typename base::result_type result_type; |
|
|
|
operator result_type() const |
|
{ |
|
return (*this)(); |
|
} |
|
|
|
extract(PyObject*); |
|
extract(api::object const&); |
|
}; |
|
|
|
// |
|
// Implementations |
|
// |
|
template <class T> |
|
inline extract<T>::extract(PyObject* o) |
|
: base(o) |
|
{ |
|
} |
|
|
|
template <class T> |
|
inline extract<T>::extract(api::object const& o) |
|
: base(o.ptr()) |
|
{ |
|
} |
|
|
|
namespace converter |
|
{ |
|
template <class T> |
|
inline extract_rvalue<T>::extract_rvalue(PyObject* x) |
|
: m_source(x) |
|
, m_data( |
|
(rvalue_from_python_stage1)(x, registered<T>::converters) |
|
) |
|
{ |
|
} |
|
|
|
template <class T> |
|
inline bool |
|
extract_rvalue<T>::check() const |
|
{ |
|
return m_data.stage1.convertible; |
|
} |
|
|
|
template <class T> |
|
inline typename extract_rvalue<T>::result_type |
|
extract_rvalue<T>::operator()() const |
|
{ |
|
return *(T*)( |
|
// Only do the stage2 conversion once |
|
m_data.stage1.convertible == m_data.storage.bytes |
|
? m_data.storage.bytes |
|
: (rvalue_from_python_stage2)(m_source, m_data.stage1, registered<T>::converters) |
|
); |
|
} |
|
|
|
template <class Ref> |
|
inline extract_reference<Ref>::extract_reference(PyObject* obj) |
|
: m_source(obj) |
|
, m_result( |
|
(get_lvalue_from_python)(obj, registered<Ref>::converters) |
|
) |
|
{ |
|
} |
|
|
|
template <class Ref> |
|
inline bool extract_reference<Ref>::check() const |
|
{ |
|
return m_result != 0; |
|
} |
|
|
|
template <class Ref> |
|
inline Ref extract_reference<Ref>::operator()() const |
|
{ |
|
if (m_result == 0) |
|
(throw_no_reference_from_python)(m_source, registered<Ref>::converters); |
|
|
|
return python::detail::void_ptr_to_reference(m_result, (Ref(*)())0); |
|
} |
|
|
|
template <class Ptr> |
|
inline extract_pointer<Ptr>::extract_pointer(PyObject* obj) |
|
: m_source(obj) |
|
, m_result( |
|
obj == Py_None ? 0 : (get_lvalue_from_python)(obj, registered_pointee<Ptr>::converters) |
|
) |
|
{ |
|
} |
|
|
|
template <class Ptr> |
|
inline bool extract_pointer<Ptr>::check() const |
|
{ |
|
return m_source == Py_None || m_result != 0; |
|
} |
|
|
|
template <class Ptr> |
|
inline Ptr extract_pointer<Ptr>::operator()() const |
|
{ |
|
if (m_result == 0 && m_source != Py_None) |
|
(throw_no_pointer_from_python)(m_source, registered_pointee<Ptr>::converters); |
|
|
|
return Ptr(m_result); |
|
} |
|
|
|
template <class T> |
|
inline extract_object_manager<T>::extract_object_manager(PyObject* obj) |
|
: m_source(obj) |
|
{ |
|
} |
|
|
|
template <class T> |
|
inline bool extract_object_manager<T>::check() const |
|
{ |
|
return object_manager_traits<T>::check(m_source); |
|
} |
|
|
|
template <class T> |
|
inline T extract_object_manager<T>::operator()() const |
|
{ |
|
return T( |
|
object_manager_traits<T>::adopt(python::incref(m_source)) |
|
); |
|
} |
|
} |
|
|
|
}} // namespace boost::python::converter |
|
|
|
#endif // EXTRACT_DWA200265_HPP
|
|
|