Website : rimsha.abasa.com
backdoor
Home
Console
Upload
information
Create File
Create Folder
About
Tools
:
/
usr
/
include
/
boost
/
python
/
converter
/
Filename :
arg_to_python.hpp
back
Copy
// 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_TO_PYTHON_DWA200265_HPP # define ARG_TO_PYTHON_DWA200265_HPP # include <boost/python/ptr.hpp> # include <boost/python/tag.hpp> # include <boost/python/to_python_indirect.hpp> # include <boost/python/converter/registered.hpp> # include <boost/python/converter/registered_pointee.hpp> # include <boost/python/converter/arg_to_python_base.hpp> # include <boost/python/converter/shared_ptr_to_python.hpp> // Bring in specializations # include <boost/python/converter/builtin_converters.hpp> # include <boost/python/object/function_handle.hpp> # include <boost/python/base_type_traits.hpp> # include <boost/python/detail/indirect_traits.hpp> # include <boost/python/detail/convertible.hpp> # include <boost/python/detail/string_literal.hpp> # include <boost/python/detail/value_is_shared_ptr.hpp> # include <boost/python/detail/type_traits.hpp> # include <boost/mpl/or.hpp> namespace boost { namespace python { namespace converter { template <class T> struct is_object_manager; namespace detail { template <class T> struct function_arg_to_python : handle<> { function_arg_to_python(T const& x); }; template <class T> struct reference_arg_to_python : handle<> { reference_arg_to_python(T& x); private: static PyObject* get_object(T& x); }; template <class T> struct shared_ptr_arg_to_python : handle<> { shared_ptr_arg_to_python(T const& x); private: static PyObject* get_object(T& x); }; template <class T> struct value_arg_to_python : arg_to_python_base { // Throw an exception if the conversion can't succeed value_arg_to_python(T const&); }; template <class Ptr> struct pointer_deep_arg_to_python : arg_to_python_base { // Throw an exception if the conversion can't succeed pointer_deep_arg_to_python(Ptr); }; template <class Ptr> struct pointer_shallow_arg_to_python : handle<> { // Throw an exception if the conversion can't succeed pointer_shallow_arg_to_python(Ptr); private: static PyObject* get_object(Ptr p); }; // Convert types that manage a Python object to_python template <class T> struct object_manager_arg_to_python { object_manager_arg_to_python(T const& x) : m_src(x) {} PyObject* get() const { return python::upcast<PyObject>(get_managed_object(m_src, tag)); } private: T const& m_src; }; template <class T> struct select_arg_to_python { typedef typename unwrap_reference<T>::type unwrapped_referent; typedef typename unwrap_pointer<T>::type unwrapped_ptr; typedef typename mpl::if_< // Special handling for char const[N]; interpret them as char // const* for the sake of conversion python::detail::is_string_literal<T const> , arg_to_python<char const*> , typename mpl::if_< python::detail::value_is_shared_ptr<T> , shared_ptr_arg_to_python<T> , typename mpl::if_< mpl::or_< boost::python::detail::is_function<T> , indirect_traits::is_pointer_to_function<T> , boost::python::detail::is_member_function_pointer<T> > , function_arg_to_python<T> , typename mpl::if_< is_object_manager<T> , object_manager_arg_to_python<T> , typename mpl::if_< boost::python::detail::is_pointer<T> , pointer_deep_arg_to_python<T> , typename mpl::if_< is_pointer_wrapper<T> , pointer_shallow_arg_to_python<unwrapped_ptr> , typename mpl::if_< is_reference_wrapper<T> , reference_arg_to_python<unwrapped_referent> , value_arg_to_python<T> >::type >::type >::type >::type >::type >::type >::type type; }; } template <class T> struct arg_to_python : detail::select_arg_to_python<T>::type { typedef typename detail::select_arg_to_python<T>::type base; public: // member functions // Throw an exception if the conversion can't succeed arg_to_python(T const& x); }; // // implementations // namespace detail { // reject_raw_object_ptr -- cause a compile-time error if the user // should pass a raw Python object pointer using python::detail::yes_convertible; using python::detail::no_convertible; using python::detail::unspecialized; template <class T> struct cannot_convert_raw_PyObject; template <class T, class Convertibility> struct reject_raw_object_helper { static void error(Convertibility) { cannot_convert_raw_PyObject<T*>::to_python_use_handle_instead(); } static void error(...) {} }; template <class T> inline void reject_raw_object_ptr(T*) { reject_raw_object_helper<T,yes_convertible>::error( python::detail::convertible<PyObject const volatile*>::check((T*)0)); typedef typename remove_cv<T>::type value_type; reject_raw_object_helper<T,no_convertible>::error( python::detail::convertible<unspecialized*>::check( (base_type_traits<value_type>*)0 )); } // --------- template <class T> inline function_arg_to_python<T>::function_arg_to_python(T const& x) : handle<>(python::objects::make_function_handle(x)) { } template <class T> inline value_arg_to_python<T>::value_arg_to_python(T const& x) : arg_to_python_base(&x, registered<T>::converters) { } template <class Ptr> inline pointer_deep_arg_to_python<Ptr>::pointer_deep_arg_to_python(Ptr x) : arg_to_python_base(x, registered_pointee<Ptr>::converters) { detail::reject_raw_object_ptr((Ptr)0); } template <class T> inline PyObject* reference_arg_to_python<T>::get_object(T& x) { to_python_indirect<T&,python::detail::make_reference_holder> convert; return convert(x); } template <class T> inline reference_arg_to_python<T>::reference_arg_to_python(T& x) : handle<>(reference_arg_to_python<T>::get_object(x)) { } template <class T> inline shared_ptr_arg_to_python<T>::shared_ptr_arg_to_python(T const& x) : handle<>(shared_ptr_to_python(x)) { } template <class Ptr> inline pointer_shallow_arg_to_python<Ptr>::pointer_shallow_arg_to_python(Ptr x) : handle<>(pointer_shallow_arg_to_python<Ptr>::get_object(x)) { detail::reject_raw_object_ptr((Ptr)0); } template <class Ptr> inline PyObject* pointer_shallow_arg_to_python<Ptr>::get_object(Ptr x) { to_python_indirect<Ptr,python::detail::make_reference_holder> convert; return convert(x); } } template <class T> inline arg_to_python<T>::arg_to_python(T const& x) : base(x) {} }}} // namespace boost::python::converter #endif // ARG_TO_PYTHON_DWA200265_HPP