262 lines
6.0 KiB
C++
262 lines
6.0 KiB
C++
// 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
|