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  }