23 static constexpr
auto name = const_name<ConstRefCasted>();
32 return std::move(
value);
53 template <
typename T_>
61 const ConstRefCasted &,
67 ConstRefCasted &&>>>>;
77 m.def(
"string_roundtrip", [](
const char *
s) {
return s; });
82 char32_t a32 = 0x61 , z32 = 0x7a , ib32 = 0x203d , cake32 = 0x1f382 ,
84 char16_t b16 = 0x62 , z16 = 0x7a, ib16 = 0x203d, cake16_1 = 0xd83c, cake16_2 = 0xdf82,
85 mathbfA16_1 = 0xd835, mathbfA16_2 = 0xdc00;
88 wstr.push_back(0x2e18);
90 wstr.push_back(mathbfA16_1);
91 wstr.push_back(mathbfA16_2);
94 wstr.push_back((
wchar_t) mathbfA32);
98 m.def(
"good_utf8_string", []() {
99 return std::string((
const char *) u8
"Say utf8\u203d \U0001f382 \U0001d400");
101 m.def(
"good_utf16_string", [=]() {
102 return std::u16string({b16, ib16, cake16_1, cake16_2, mathbfA16_1, mathbfA16_2, z16});
104 m.def(
"good_utf32_string", [=]() {
105 return std::u32string({a32, mathbfA32, cake32, ib32, z32});
107 m.def(
"good_wchar_string", [=]() {
return wstr; });
108 m.def(
"bad_utf8_string", []() {
109 return std::string(
"abc\xd0" 112 m.def(
"bad_utf16_string", [=]() {
return std::u16string({b16, char16_t(0xd800), z16}); });
115 m.def(
"bad_utf32_string", [=]() {
return std::u32string({a32, char32_t(0xd800), z32}); });
117 m.def(
"bad_wchar_string", [=]() {
118 return std::wstring({wchar_t(0x61), wchar_t(0xd800)});
121 m.def(
"u8_Z", []() ->
char {
return 'Z'; });
122 m.def(
"u8_eacute", []() ->
char {
return '\xe9'; });
123 m.def(
"u16_ibang", [=]() -> char16_t {
return ib16; });
124 m.def(
"u32_mathbfA", [=]() -> char32_t {
return mathbfA32; });
125 m.def(
"wchar_heart", []() ->
wchar_t {
return 0x2665; });
128 m.attr(
"wchar_size") =
py::cast(
sizeof(
wchar_t));
129 m.def(
"ord_char", [](
char c) ->
int {
return static_cast<unsigned char>(
c); });
130 m.def(
"ord_char_lv", [](
char &
c) ->
int {
return static_cast<unsigned char>(
c); });
131 m.def(
"ord_char16", [](char16_t
c) ->
uint16_t {
return c; });
132 m.def(
"ord_char16_lv", [](char16_t &
c) ->
uint16_t {
return c; });
133 m.def(
"ord_char32", [](char32_t
c) ->
uint32_t {
return c; });
134 m.def(
"ord_wchar", [](
wchar_t c) ->
int {
return c; });
137 m.def(
"strlen", [](
char *
s) {
return strlen(
s); });
138 m.def(
"string_length", [](
const std::string &
s) {
return s.length(); });
140 #ifdef PYBIND11_HAS_U8STRING 141 m.attr(
"has_u8string") =
true;
142 m.def(
"good_utf8_u8string", []() {
143 return std::u8string(u8
"Say utf8\u203d \U0001f382 \U0001d400");
145 m.def(
"bad_utf8_u8string", []() {
146 return std::u8string((
const char8_t *)
"abc\xd0" 150 m.def(
"u8_char8_Z", []() -> char8_t {
return u8
'Z'; });
153 m.def(
"ord_char8", [](char8_t
c) ->
int {
return static_cast<unsigned char>(
c); });
154 m.def(
"ord_char8_lv", [](char8_t &
c) ->
int {
return static_cast<unsigned char>(
c); });
158 #ifdef PYBIND11_HAS_STRING_VIEW 159 m.attr(
"has_string_view") =
true;
160 m.def(
"string_view_print", [](std::string_view
s) {
py::print(
s,
s.size()); });
161 m.def(
"string_view16_print", [](std::u16string_view
s) {
py::print(
s,
s.size()); });
162 m.def(
"string_view32_print", [](std::u32string_view
s) {
py::print(
s,
s.size()); });
163 m.def(
"string_view_chars", [](std::string_view
s) {
170 m.def(
"string_view16_chars", [](std::u16string_view
s) {
177 m.def(
"string_view32_chars", [](std::u32string_view
s) {
184 m.def(
"string_view_return",
185 []() {
return std::string_view((
const char *) u8
"utf8 secret \U0001f382"); });
186 m.def(
"string_view16_return",
187 []() {
return std::u16string_view(u
"utf16 secret \U0001f382"); });
188 m.def(
"string_view32_return",
189 []() {
return std::u32string_view(
U"utf32 secret \U0001f382"); });
192 using namespace std::literals;
193 m.def(
"string_view_bytes",
194 []() {
return [](py::bytes
b) {
return b; }(
"abc \x80\x80 def"sv); });
195 m.def(
"string_view_str",
196 []() {
return [](
py::str s) {
return s; }(
"abc \342\200\275 def"sv); });
197 m.def(
"string_view_from_bytes",
198 [](
const py::bytes &
b) {
return [](std::string_view
s) {
return s; }(
b); });
199 m.def(
"string_view_memoryview", []() {
200 static constexpr
auto val =
"Have some \360\237\216\202"sv;
201 return py::memoryview::from_memory(val);
204 # ifdef PYBIND11_HAS_U8STRING 205 m.def(
"string_view8_print", [](std::u8string_view
s) {
py::print(
s,
s.size()); });
206 m.def(
"string_view8_chars", [](std::u8string_view
s) {
212 m.def(
"string_view8_return", []() {
return std::u8string_view(u8
"utf8 secret \U0001f382"); });
213 m.def(
"string_view8_str", []() {
return py::str{std::u8string_view{u8
"abc β½ def"}}; });
216 struct TypeWithBothOperatorStringAndStringView {
218 operator std::string()
const {
return "success"; }
220 operator std::string_view()
const {
return "failure"; }
222 m.def(
"bytes_from_type_with_both_operator_string_and_string_view",
223 []() {
return py::bytes(TypeWithBothOperatorStringAndStringView()); });
224 m.def(
"str_from_type_with_both_operator_string_and_string_view",
225 []() {
return py::str(TypeWithBothOperatorStringAndStringView()); });
235 m.def(
"int_passthrough", [](
int arg) {
return arg; });
237 "int_passthrough_noconvert", [](
int arg) {
return arg; },
py::arg{}.noconvert());
242 [](
const std::pair<bool, std::string> &input) {
243 return std::make_pair(input.second, input.first);
245 "Return a pair in reversed order");
248 [](std::tuple<bool, std::string, int> input) {
249 return std::make_tuple(std::get<2>(input), std::get<1>(input), std::get<0>(input));
251 "Return a triple in reversed order");
252 m.def(
"empty_tuple", []() {
return std::tuple<>(); });
253 static std::pair<RValueCaster, RValueCaster> lvpair;
254 static std::tuple<RValueCaster, RValueCaster, RValueCaster> lvtuple;
255 static std::pair<RValueCaster, std::tuple<RValueCaster, std::pair<RValueCaster, RValueCaster>>>
258 m.def(
"lvalue_pair", []() ->
const decltype(lvpair) & {
return lvpair; });
259 m.def(
"rvalue_tuple",
261 m.def(
"lvalue_tuple", []() ->
const decltype(lvtuple) & {
return lvtuple; });
262 m.def(
"rvalue_nested", []() {
263 return std::make_pair(
267 m.def(
"lvalue_nested", []() ->
const decltype(lvnested) & {
return lvnested; });
269 static std::pair<int, std::string> int_string_pair{2,
"items"};
271 "int_string_pair", []() {
return &int_string_pair; }, py::return_value_policy::reference);
274 m.def(
"return_none_string", []() -> std::string * {
return nullptr; });
275 m.def(
"return_none_char", []() ->
const char * {
return nullptr; });
276 m.def(
"return_none_bool", []() ->
bool * {
return nullptr; });
277 m.def(
"return_none_int", []() ->
int * {
return nullptr; });
278 m.def(
"return_none_float", []() ->
float * {
return nullptr; });
279 m.def(
"return_none_pair", []() -> std::pair<int, int> * {
return nullptr; });
282 m.def(
"defer_none_cstring", [](
char *) {
return false; });
283 m.def(
"defer_none_cstring", [](
const py::none &) {
return true; });
284 m.def(
"defer_none_custom", [](UserType *) {
return false; });
285 m.def(
"defer_none_custom", [](
const py::none &) {
return true; });
286 m.def(
"nodefer_none_void", [](
void *) {
return true; });
287 m.def(
"nodefer_none_void", [](
const py::none &) {
return false; });
290 m.def(
"load_nullptr_t", [](std::nullptr_t) {});
291 m.def(
"cast_nullptr_t", []() {
return std::nullptr_t{}; });
296 m.def(
"bool_passthrough", [](
bool arg) {
return arg; });
298 "bool_passthrough_noconvert", [](
bool arg) {
return arg; },
py::arg{}.noconvert());
301 #if !defined(__INTEL_COMPILER) 307 "bool_passthrough_noconvert2", [](
bool arg) {
return arg; },
py::arg().noconvert());
311 m.def(
"refwrap_builtin", [](std::reference_wrapper<int>
p) {
return 10 *
p.get(); });
312 m.def(
"refwrap_usertype", [](std::reference_wrapper<UserType>
p) {
return p.get().value(); });
313 m.def(
"refwrap_usertype_const",
314 [](std::reference_wrapper<const UserType>
p) {
return p.get().value(); });
316 m.def(
"refwrap_lvalue", []() -> std::reference_wrapper<UserType> {
317 static UserType
x(1);
320 m.def(
"refwrap_lvalue_const", []() -> std::reference_wrapper<const UserType> {
321 static UserType
x(1);
332 static IncType
x1(1),
x2(2);
342 m.def(
"refwrap_iiw", [](
const IncType &
w) {
return w.value(); });
343 m.def(
"refwrap_call_iiw", [](IncType &
w,
const py::function &
f) {
346 l.append(
f(std::cref(
w)));
347 IncType
x(
w.value());
349 IncType
y(
w.value());
356 m.def(
"complex_cast", [](
float x) {
return "{}"_s.format(
x); });
357 m.def(
"complex_cast",
358 [](std::complex<float>
x) {
return "({}, {})"_s.format(
x.real(),
x.imag()); });
361 m.def(
"int_cast", []() {
return (
int) 42; });
362 m.def(
"long_cast", []() {
return (
long) 42; });
363 m.def(
"longlong_cast", []() {
return ULLONG_MAX; });
366 m.def(
"test_void_caster", []() ->
bool {
367 void *
v = (
void *) 0xabcd;
369 return py::cast<void *>(o) == v;
377 m.def(
"takes_ref_wrap", [](std::reference_wrapper<ConstRefCasted> x) {
return x.get().
tag; });
380 m.def(
"takes_const_ref_wrap",
381 [](std::reference_wrapper<const ConstRefCasted> x) {
return x.get().
tag; });
typename std::conditional< B, T, F >::type conditional_t
conditional_t< std::is_same< remove_reference_t< T_ >, const ConstRefCasted * >::value, const ConstRefCasted *, conditional_t< std::is_same< T_, const ConstRefCasted & >::value, const ConstRefCasted &, conditional_t< std::is_same< remove_reference_t< T_ >, ConstRefCasted * >::value, ConstRefCasted *, conditional_t< std::is_same< T_, ConstRefCasted & >::value, ConstRefCasted &, ConstRefCasted && > >> > cast_op_type
#define PYBIND11_SILENCE_MSVC_C4127(...)
Pose3 x2(Rot3::Ypr(0.0, 0.0, 0.0), l2)
EIGEN_STRONG_INLINE Packet4f print(const Packet4f &a)
static const Line3 l(Rot3(), 1, 1)
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const ArgReturnType arg() const
Array< int, Dynamic, 1 > v
unsigned __int64 uint64_t
EIGEN_DEVICE_FUNC NewType cast(const OldType &x)
Point2(* f)(const Point3 &, OptionalJacobian< 2, 3 >)
Annotation for function names.
int EIGEN_BLAS_FUNC() copy(int *n, RealScalar *px, int *incx, RealScalar *py, int *incy)
set noclip points set clip one set noclip two set bar set border lt lw set xdata set ydata set zdata set x2data set y2data set boxwidth set dummy x
#define PYBIND11_NAMESPACE_END(name)
#define PYBIND11_NAMESPACE_BEGIN(name)
TEST_SUBMODULE(builtin_casters, m)