From 19fcec84d8d7d21e796c7624e521b60d28ee21ed Mon Sep 17 00:00:00 2001 From: Daniel Baumann Date: Sun, 7 Apr 2024 20:45:59 +0200 Subject: Adding upstream version 16.2.11+ds. Signed-off-by: Daniel Baumann --- src/boost/libs/python/test/builtin_converters.cpp | 152 ++++++++++++++++++++++ 1 file changed, 152 insertions(+) create mode 100644 src/boost/libs/python/test/builtin_converters.cpp (limited to 'src/boost/libs/python/test/builtin_converters.cpp') diff --git a/src/boost/libs/python/test/builtin_converters.cpp b/src/boost/libs/python/test/builtin_converters.cpp new file mode 100644 index 000000000..f66e61bd8 --- /dev/null +++ b/src/boost/libs/python/test/builtin_converters.cpp @@ -0,0 +1,152 @@ +// 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) +#include +#include +#include +#include +#include +#include +#include + +template +struct by_value +{ + static T rewrap(T x) + { + return x; + } + static int size(void) + { + return sizeof(T); + } +}; + +template +struct by_const_reference +{ + static T rewrap(T const& x) + { + return x; + } +}; + +template +struct by_reference +{ + static T rewrap(T& x) + { + return x; + } +}; + +using boost::python::def; +using boost::python::handle; +using boost::python::object; +using boost::python::borrowed; + +// Used to test that arbitrary handle<>s can be returned +handle get_type(handle<> x) +{ + return handle(borrowed(x->ob_type)); +} + +handle<> return_null_handle() +{ + return handle<>(); +} + +char const* rewrap_value_mutable_cstring(char* x) { return x; } + +object identity_(object x) { return x; } + +BOOST_PYTHON_MODULE(builtin_converters_ext) +{ + def("get_type", get_type); + def("return_null_handle", return_null_handle); + +// These methods are used solely for getting some C++ type sizes + def("bool_size", by_value::size); + def("char_size", by_value::size); + def("int_size", by_value::size); + def("short_size", by_value::size); + def("long_size", by_value::size); +#ifdef HAVE_LONG_LONG + def("long_long_size", by_value::size); +#endif + + def("rewrap_value_bool", by_value::rewrap); + def("rewrap_value_char", by_value::rewrap); + def("rewrap_value_signed_char", by_value::rewrap); + def("rewrap_value_unsigned_char", by_value::rewrap); + def("rewrap_value_int", by_value::rewrap); + def("rewrap_value_unsigned_int", by_value::rewrap); + def("rewrap_value_short", by_value::rewrap); + def("rewrap_value_unsigned_short", by_value::rewrap); + def("rewrap_value_long", by_value::rewrap); + def("rewrap_value_unsigned_long", by_value::rewrap); +// using Python's macro instead of Boost's - we don't seem to get the +// config right all the time. +#ifdef HAVE_LONG_LONG + def("rewrap_value_long_long", by_value::rewrap); + def("rewrap_value_unsigned_long_long", by_value::rewrap); +# endif + def("rewrap_value_float", by_value::rewrap); + def("rewrap_value_double", by_value::rewrap); + def("rewrap_value_long_double", by_value::rewrap); + def("rewrap_value_complex_float", by_value >::rewrap); + def("rewrap_value_complex_double", by_value >::rewrap); + def("rewrap_value_complex_long_double", by_value >::rewrap); + def("rewrap_value_wstring", +# if defined(BOOST_NO_STD_WSTRING) || !defined(Py_USING_UNICODE) + identity_ +# else + by_value::rewrap +# endif + ); + def("rewrap_value_string", +# if defined(BOOST_NO_STD_WSTRING) || !defined(Py_USING_UNICODE) + identity_ +# else + by_value::rewrap +# endif + ); + def("rewrap_value_string", by_value::rewrap); + def("rewrap_value_cstring", by_value::rewrap); + def("rewrap_value_handle", by_value >::rewrap); + def("rewrap_value_object", by_value::rewrap); + + // Expose this to illustrate our failings ;-). See test_builtin_converters.py + def("rewrap_value_mutable_cstring", rewrap_value_mutable_cstring); + + + def("rewrap_const_reference_bool", by_const_reference::rewrap); + def("rewrap_const_reference_char", by_const_reference::rewrap); + def("rewrap_const_reference_signed_char", by_const_reference::rewrap); + def("rewrap_const_reference_unsigned_char", by_const_reference::rewrap); + def("rewrap_const_reference_int", by_const_reference::rewrap); + def("rewrap_const_reference_unsigned_int", by_const_reference::rewrap); + def("rewrap_const_reference_short", by_const_reference::rewrap); + def("rewrap_const_reference_unsigned_short", by_const_reference::rewrap); + def("rewrap_const_reference_long", by_const_reference::rewrap); + def("rewrap_const_reference_unsigned_long", by_const_reference::rewrap); +// using Python's macro instead of Boost's - we don't seem to get the +// config right all the time. +# ifdef HAVE_LONG_LONG + def("rewrap_const_reference_long_long", by_const_reference::rewrap); + def("rewrap_const_reference_unsigned_long_long", by_const_reference::rewrap); +# endif + def("rewrap_const_reference_float", by_const_reference::rewrap); + def("rewrap_const_reference_double", by_const_reference::rewrap); + def("rewrap_const_reference_long_double", by_const_reference::rewrap); + def("rewrap_const_reference_complex_float", by_const_reference >::rewrap); + def("rewrap_const_reference_complex_double", by_const_reference >::rewrap); + def("rewrap_const_reference_complex_long_double", by_const_reference >::rewrap); + def("rewrap_const_reference_string", by_const_reference::rewrap); + def("rewrap_const_reference_cstring", by_const_reference::rewrap); + def("rewrap_const_reference_handle", by_const_reference >::rewrap); + def("rewrap_const_reference_object", by_const_reference::rewrap); + def("rewrap_reference_object", by_reference::rewrap); +} + -- cgit v1.2.3