| // 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 |