141 lines
5.9 KiB
Plaintext
141 lines
5.9 KiB
Plaintext
// 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
|