// 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/utility.hpp> | |
# include <boost/call_traits.hpp> | |
#if BOOST_WORKAROUND(BOOST_MSVC, <= 1300) || BOOST_WORKAROUND(BOOST_INTEL_WIN, <= 900) | |
// workaround for VC++ 6.x or 7.0 | |
# 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 |