github.com/kaydxh/golang@v0.0.131/pkg/gocv/cgo/third_path/pybind11/tests/test_local_bindings.cpp (about) 1 /* 2 tests/test_local_bindings.cpp -- tests the py::module_local class feature which makes a class 3 binding local to the module in which it is defined. 4 5 Copyright (c) 2017 Jason Rhinelander <jason@imaginary.ca> 6 7 All rights reserved. Use of this source code is governed by a 8 BSD-style license that can be found in the LICENSE file. 9 */ 10 11 #include <pybind11/stl.h> 12 #include <pybind11/stl_bind.h> 13 14 #include "local_bindings.h" 15 #include "pybind11_tests.h" 16 17 #include <numeric> 18 #include <utility> 19 20 TEST_SUBMODULE(local_bindings, m) { 21 // test_load_external 22 m.def("load_external1", [](ExternalType1 &e) { return e.i; }); 23 m.def("load_external2", [](ExternalType2 &e) { return e.i; }); 24 25 // test_local_bindings 26 // Register a class with py::module_local: 27 bind_local<LocalType, -1>(m, "LocalType", py::module_local()).def("get3", [](LocalType &t) { 28 return t.i + 3; 29 }); 30 31 m.def("local_value", [](LocalType &l) { return l.i; }); 32 33 // test_nonlocal_failure 34 // The main pybind11 test module is loaded first, so this registration will succeed (the second 35 // one, in pybind11_cross_module_tests.cpp, is designed to fail): 36 bind_local<NonLocalType, 0>(m, "NonLocalType") 37 .def(py::init<int>()) 38 .def("get", [](LocalType &i) { return i.i; }); 39 40 // test_duplicate_local 41 // py::module_local declarations should be visible across compilation units that get linked 42 // together; this tries to register a duplicate local. It depends on a definition in 43 // test_class.cpp and should raise a runtime error from the duplicate definition attempt. If 44 // test_class isn't available it *also* throws a runtime error (with "test_class not enabled" 45 // as value). 46 m.def("register_local_external", [m]() { 47 auto main = py::module_::import("pybind11_tests"); 48 if (py::hasattr(main, "class_")) { 49 bind_local<LocalExternal, 7>(m, "LocalExternal", py::module_local()); 50 } else { 51 throw std::runtime_error("test_class not enabled"); 52 } 53 }); 54 55 // test_stl_bind_local 56 // stl_bind.h binders defaults to py::module_local if the types are local or converting: 57 py::bind_vector<LocalVec>(m, "LocalVec"); 58 py::bind_map<LocalMap>(m, "LocalMap"); 59 // and global if the type (or one of the types, for the map) is global: 60 py::bind_vector<NonLocalVec>(m, "NonLocalVec"); 61 py::bind_map<NonLocalMap>(m, "NonLocalMap"); 62 63 // test_stl_bind_global 64 // They can, however, be overridden to global using `py::module_local(false)`: 65 bind_local<NonLocal2, 10>(m, "NonLocal2"); 66 py::bind_vector<LocalVec2>(m, "LocalVec2", py::module_local()); 67 py::bind_map<NonLocalMap2>(m, "NonLocalMap2", py::module_local(false)); 68 69 // test_mixed_local_global 70 // We try this both with the global type registered first and vice versa (the order shouldn't 71 // matter). 72 m.def("register_mixed_global", [m]() { 73 bind_local<MixedGlobalLocal, 100>(m, "MixedGlobalLocal", py::module_local(false)); 74 }); 75 m.def("register_mixed_local", [m]() { 76 bind_local<MixedLocalGlobal, 1000>(m, "MixedLocalGlobal", py::module_local()); 77 }); 78 m.def("get_mixed_gl", [](int i) { return MixedGlobalLocal(i); }); 79 m.def("get_mixed_lg", [](int i) { return MixedLocalGlobal(i); }); 80 81 // test_internal_locals_differ 82 m.def("local_cpp_types_addr", 83 []() { return (uintptr_t) &py::detail::get_local_internals().registered_types_cpp; }); 84 85 // test_stl_caster_vs_stl_bind 86 m.def("load_vector_via_caster", 87 [](std::vector<int> v) { return std::accumulate(v.begin(), v.end(), 0); }); 88 89 // test_cross_module_calls 90 m.def("return_self", [](LocalVec *v) { return v; }); 91 m.def("return_copy", [](const LocalVec &v) { return LocalVec(v); }); 92 93 class Cat : public pets::Pet { 94 public: 95 explicit Cat(std::string name) : Pet(std::move(name)) {} 96 }; 97 py::class_<pets::Pet>(m, "Pet", py::module_local()).def("get_name", &pets::Pet::name); 98 // Binding for local extending class: 99 py::class_<Cat, pets::Pet>(m, "Cat").def(py::init<std::string>()); 100 m.def("pet_name", [](pets::Pet &p) { return p.name(); }); 101 102 py::class_<MixGL>(m, "MixGL").def(py::init<int>()); 103 m.def("get_gl_value", [](MixGL &o) { return o.i + 10; }); 104 105 py::class_<MixGL2>(m, "MixGL2").def(py::init<int>()); 106 }