| // 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 FROM_PYTHON_AUX_DATA_DWA2002128_HPP |
| # define FROM_PYTHON_AUX_DATA_DWA2002128_HPP |
| |
| # include <boost/python/converter/constructor_function.hpp> |
| # include <boost/python/detail/referent_storage.hpp> |
| # include <boost/python/detail/destroy.hpp> |
| # include <boost/static_assert.hpp> |
| # include <boost/type_traits/add_reference.hpp> |
| # include <boost/type_traits/add_cv.hpp> |
| # include <cstddef> |
| |
| // Data management for potential rvalue conversions from Python to C++ |
| // types. When a client requests a conversion to T* or T&, we |
| // generally require that an object of type T exists in the source |
| // Python object, and the code here does not apply**. This implements |
| // conversions which may create new temporaries of type T. The classic |
| // example is a conversion which converts a Python tuple to a |
| // std::vector. Since no std::vector lvalue exists in the Python |
| // object -- it must be created "on-the-fly" by the converter, and |
| // which must manage the lifetime of the created object. |
| // |
| // Note that the client is not precluded from using a registered |
| // lvalue conversion to T in this case. In other words, we will |
| // happily accept a Python object which /does/ contain a std::vector |
| // lvalue, provided an appropriate converter is registered. So, while |
| // this is an rvalue conversion from the client's point-of-view, the |
| // converter registry may serve up lvalue or rvalue conversions for |
| // the target type. |
| // |
| // ** C++ argument from_python conversions to T const& are an |
| // exception to the rule for references: since in C++, const |
| // references can bind to temporary rvalues, we allow rvalue |
| // converters to be chosen when the target type is T const& for some |
| // T. |
| namespace boost { namespace python { namespace converter { |
| |
| // Conversions begin by filling in and returning a copy of this |
| // structure. The process looks up a converter in the rvalue converter |
| // registry for the target type. It calls the convertible() function |
| // of each registered converter, passing the source PyObject* as an |
| // argument, until a non-null result is returned. This result goes in |
| // the convertible field, and the converter's construct() function is |
| // stored in the construct field. |
| // |
| // If no appropriate converter is found, conversion fails and the |
| // convertible field is null. When used in argument conversion for |
| // wrapped C++ functions, it causes overload resolution to reject the |
| // current function but not to fail completely. If an exception is |
| // thrown, overload resolution stops and the exception propagates back |
| // through the caller. |
| // |
| // If an lvalue converter is matched, its convertible() function is |
| // expected to return a pointer to the stored T object; its |
| // construct() function will be NULL. The convertible() function of |
| // rvalue converters may return any non-singular pointer; the actual |
| // target object will only be available once the converter's |
| // construct() function is called. |
| struct rvalue_from_python_stage1_data |
| { |
| void* convertible; |
| constructor_function construct; |
| }; |
| |
| // Augments rvalue_from_python_stage1_data by adding storage for |
| // constructing an object of remove_reference<T>::type. The |
| // construct() function of rvalue converters (stored in m_construct |
| // above) will cast the rvalue_from_python_stage1_data to an |
| // appropriate instantiation of this template in order to access that |
| // storage. |
| template <class T> |
| struct rvalue_from_python_storage |
| { |
| rvalue_from_python_stage1_data stage1; |
| |
| // Storage for the result, in case an rvalue must be constructed |
| typename python::detail::referent_storage< |
| typename add_reference<T>::type |
| >::type storage; |
| }; |
| |
| // Augments rvalue_from_python_storage<T> with a destructor. If |
| // stage1.convertible == storage.bytes, it indicates that an object of |
| // remove_reference<T>::type has been constructed in storage and |
| // should will be destroyed in ~rvalue_from_python_data(). It is |
| // crucial that successful rvalue conversions establish this equality |
| // and that unsuccessful ones do not. |
| template <class T> |
| struct rvalue_from_python_data : rvalue_from_python_storage<T> |
| { |
| # if (!defined(__MWERKS__) || __MWERKS__ >= 0x3000) \ |
| && (!defined(__EDG_VERSION__) || __EDG_VERSION__ >= 245) \ |
| && (!defined(__DECCXX_VER) || __DECCXX_VER > 60590014) \ |
| && !defined(BOOST_PYTHON_SYNOPSIS) /* Synopsis' OpenCXX has trouble parsing this */ |
| // This must always be a POD struct with m_data its first member. |
| BOOST_STATIC_ASSERT(BOOST_PYTHON_OFFSETOF(rvalue_from_python_storage<T>,stage1) == 0); |
| # endif |
| |
| // The usual constructor |
| rvalue_from_python_data(rvalue_from_python_stage1_data const&); |
| |
| // This constructor just sets m_convertible -- used by |
| // implicitly_convertible<> to perform the final step of the |
| // conversion, where the construct() function is already known. |
| rvalue_from_python_data(void* convertible); |
| |
| // Destroys any object constructed in the storage. |
| ~rvalue_from_python_data(); |
| private: |
| typedef typename add_reference<typename add_cv<T>::type>::type ref_type; |
| }; |
| |
| // |
| // Implementataions |
| // |
| template <class T> |
| inline rvalue_from_python_data<T>::rvalue_from_python_data(rvalue_from_python_stage1_data const& _stage1) |
| { |
| this->stage1 = _stage1; |
| } |
| |
| template <class T> |
| inline rvalue_from_python_data<T>::rvalue_from_python_data(void* convertible) |
| { |
| this->stage1.convertible = convertible; |
| } |
| |
| template <class T> |
| inline rvalue_from_python_data<T>::~rvalue_from_python_data() |
| { |
| if (this->stage1.convertible == this->storage.bytes) |
| python::detail::destroy_referent<ref_type>(this->storage.bytes); |
| } |
| |
| }}} // namespace boost::python::converter |
| |
| #endif // FROM_PYTHON_AUX_DATA_DWA2002128_HPP |