10#include <pybind11/functional.h>
28 virtual int run(
int value) {
29 py::print(
"Original implementation of "
30 "ExampleVirt::run(state={}, value={}, str1={}, str2={})"_s.format(
46 const std::string
str1{
"default1"},
str2{
"default2"};
54 int run(
int value)
override {
110 return std::to_string(*
value);
146#if !defined(__INTEL_COMPILER) && !defined(__CUDACC__) && !defined(__PGIC__)
158 virtual std::string
dispatch()
const {
return {}; };
193 py::gil_scoped_acquire lock;
194 py::print(
"1st lock acquired");
198 py::gil_scoped_acquire lock;
199 py::print(
"2nd lock acquired");
204 py::gil_scoped_release release;
213 virtual int func() {
return 0; }
236 py::class_<ExampleVirt, PyExampleVirt>(m,
"ExampleVirt")
237 .def(py::init<int>())
243 py::class_<NonCopyable>(m,
"NonCopyable").def(py::init<int, int>());
245 py::class_<Movable>(m,
"Movable").def(py::init<int, int>());
248#if !defined(__INTEL_COMPILER) && !defined(__CUDACC__) && !defined(__PGIC__)
249 py::class_<NCVirt, NCVirtTrampoline>(m,
"NCVirt")
257 m.def(
"runExampleVirt", [](
ExampleVirt *ex,
int value) {
return ex->
run(value); });
261 m.def(
"cstats_debug", &ConstructorStats::get<ExampleVirt>);
269 A(
const A &) =
delete;
270 virtual ~A() =
default;
271 virtual void f() { py::print(
"A.f()"); }
275 PyA() { py::print(
"PyA.PyA()"); }
276 PyA(
const PyA &) =
delete;
277 ~PyA()
override { py::print(
"PyA.~PyA()"); }
280 py::print(
"PyA.f()");
287 py::class_<A, PyA>(m,
"A").def(py::init<>()).def(
"f", &A::f);
289 m.def(
"call_f", [](
A *a) { a->f(); });
295 A2(
const A2 &) =
delete;
296 virtual ~A2() =
default;
297 virtual void f() { py::print(
"A2.f()"); }
301 PyA2() { py::print(
"PyA2.PyA2()"); }
302 PyA2(
const PyA2 &) =
delete;
303 ~PyA2()
override { py::print(
"PyA2.~PyA2()"); }
305 py::print(
"PyA2.f()");
310 py::class_<A2, PyA2>(m,
"A2")
311 .def(py::init_alias<>())
312 .def(py::init([](
int) {
return new PyA2(); }))
315 m.def(
"call_f", [](A2 *a2) { a2->f(); });
319 py::class_<Base, DispatchIssue>(m,
"DispatchIssue")
323 m.def(
"dispatch_issue_go", [](
const Base *b) {
return b->
dispatch(); });
327 pybind11::class_<AdderBase, Adder>(m,
"Adder")
328 .def(pybind11::init<>())
329 .def(
"__call__", &AdderBase::operator());
331 pybind11::class_<AdderBase::Data>(m,
"Data").def(pybind11::init<>());
346 adder(first_plus_second,
357 std::string value =
"hi";
361 explicit OverrideTest(
const std::string &v) : v{v} {}
362 OverrideTest() =
default;
363 OverrideTest(
const OverrideTest &) =
delete;
364 virtual std::string str_value() {
return v; }
365 virtual std::string &str_ref() {
return v; }
366 virtual A A_value() {
return a; }
367 virtual A &A_ref() {
return a; }
368 virtual ~OverrideTest() =
default;
371 class PyOverrideTest :
public OverrideTest {
373 using OverrideTest::OverrideTest;
374 std::string str_value()
override {
380#ifdef PYBIND11_NEVER_DEFINED_EVER
381 std::string &str_ref()
override {
388 std::string str_ref_helper() {
PYBIND11_OVERRIDE(std::string, OverrideTest, str_ref); }
391 std::string &str_ref()
override {
return _tmp = str_ref_helper(); }
397 py::class_<OverrideTest::A>(m,
"OverrideTest_A")
398 .def_readwrite(
"value", &OverrideTest::A::value);
399 py::class_<OverrideTest, PyOverrideTest>(m,
"OverrideTest")
400 .def(py::init<const std::string &>())
401 .def(
"str_value", &OverrideTest::str_value)
402#ifdef PYBIND11_NEVER_DEFINED_EVER
403 .def(
"str_ref", &OverrideTest::str_ref)
405 .def(
"A_value", &OverrideTest::A_value)
406 .def(
"A_ref", &OverrideTest::A_ref);
410 std::shared_ptr<test_override_cache_helper>>(m,
"test_override_cache_helper")
411 .def(py::init_alias<>())
427 virtual int unlucky_number() = 0; \
428 virtual std::string say_something(unsigned times) { \
429 std::string s = ""; \
430 for (unsigned i = 0; i < times; ++i) \
434 std::string say_everything() { \
435 return say_something(1) + " " + std::to_string(unlucky_number()); \
445 int unlucky_number() override { return 13; } \
446 std::string say_something(unsigned times) override { \
447 return "B says hi " + std::to_string(times) + " times"; \
449 virtual double lucky_number() { return 7.0; }
455 int unlucky_number() override { return 4444; } \
456 double lucky_number() override { return 888; }
492 using B_Repeat::B_Repeat;
501 using C_Repeat::C_Repeat;
510 using D_Repeat::D_Repeat;
532template <
class Base = A_Tpl>
541template <
class Base = B_Tpl>
566 py::class_<A_Repeat, PyA_Repeat>(m,
"A_Repeat")
568 .def(
"unlucky_number", &A_Repeat::unlucky_number)
569 .def(
"say_something", &A_Repeat::say_something)
570 .def(
"say_everything", &A_Repeat::say_everything);
571 py::class_<B_Repeat, A_Repeat, PyB_Repeat>(m,
"B_Repeat")
573 .def(
"lucky_number", &B_Repeat::lucky_number);
574 py::class_<C_Repeat, B_Repeat, PyC_Repeat>(m,
"C_Repeat").def(py::init<>());
575 py::class_<D_Repeat, C_Repeat, PyD_Repeat>(m,
"D_Repeat").def(py::init<>());
579 py::class_<A_Tpl, PyA_Tpl<>>(m,
"A_Tpl")
581 .def(
"unlucky_number", &A_Tpl::unlucky_number)
582 .def(
"say_something", &A_Tpl::say_something)
583 .def(
"say_everything", &A_Tpl::say_everything);
584 py::class_<B_Tpl, A_Tpl, PyB_Tpl<>>(m,
"B_Tpl")
586 .def(
"lucky_number", &B_Tpl::lucky_number);
587 py::class_<C_Tpl, B_Tpl, PyB_Tpl<C_Tpl>>(m,
"C_Tpl").def(py::init<>());
588 py::class_<D_Tpl, C_Tpl, PyB_Tpl<D_Tpl>>(m,
"D_Tpl").def(py::init<>());
A_Repeat(const A_Repeat &)=delete
virtual ~A_Repeat()=default
A_METHODS A_Repeat()=default
A_Tpl(const A_Tpl &)=delete
ExampleVirt(const ExampleVirt &e)
virtual const std::string & get_string1()
virtual const std::string * get_string2()
virtual void pure_virtual()=0
ExampleVirt(ExampleVirt &&e) noexcept
virtual int run(int value)
virtual bool run_bool()=0
std::string get_value() const
Movable(const Movable &m)
Movable(Movable &&m) noexcept
std::string print_movable(int a, int b)
std::string print_nc(int a, int b)
virtual NonCopyable get_noncopyable(int a, int b)
virtual ~NCVirt()=default
virtual Movable get_movable(int a, int b)=0
NCVirt(const NCVirt &)=delete
Movable get_movable(int a, int b) override
NonCopyable get_noncopyable(int a, int b) override
std::unique_ptr< int > value
NonCopyable(int a, int b)
void operator=(NonCopyable &&)=delete
NonCopyable(const NonCopyable &)=delete
NonCopyable(NonCopyable &&o) noexcept
void operator=(const NonCopyable &)=delete
std::string get_value() const
std::string say_something(unsigned times) override
int unlucky_number() override
std::string say_something(unsigned times) override
int unlucky_number() override
std::string say_something(unsigned times) override
double lucky_number() override
int unlucky_number() override
double lucky_number() override
int unlucky_number() override
int unlucky_number() override
double lucky_number() override
std::string say_something(unsigned times) override
std::string say_something(unsigned times) override
int unlucky_number() override
double lucky_number() override
void pure_virtual() override
int run(int value) override
const std::string * get_string2() override
const std::string & get_string1() override
test_override_cache_helper()=default
test_override_cache_helper(test_override_cache_helper const &Copy)=delete
virtual ~test_override_cache_helper()=default
test_override_cache_helper & operator=(test_override_cache_helper const &Right)=delete
#define PYBIND11_TYPE(...)
Lets you pass a type containing a , through a macro parameter without needing a separate typedef,...
constexpr int first(int i)
Implementation details for constexpr functions.
#define PYBIND11_OVERRIDE_PURE(ret_type, cname, fn,...)
\rst Macro for pure virtual functions, this function is identical to :c:macro:PYBIND11_OVERRIDE,...
#define PYBIND11_OVERRIDE(ret_type, cname, fn,...)
\rst Macro to populate the virtual method in the trampoline class.
#define PYBIND11_OVERRIDE_PURE_NAME(ret_type, cname, name, fn,...)
\rst Macro for pure virtual functions, this function is identical to :c:macro:PYBIND11_OVERRIDE_NAME,...
void print_copy_created(T *inst, Values &&...values)
void print_created(T *inst, Values &&...values)
void print_destroyed(T *inst, Values &&...values)
void print_move_created(T *inst, Values &&...values)
#define TEST_SUBMODULE(name, variable)
static void test_gil_from_thread()
int test_override_cache(std::shared_ptr< test_override_cache_helper > const &instance)
void initialize_inherited_virtuals(py::module_ &m)
AdderBase(const AdderBase &)=delete
virtual void operator()(const Data &first, const Data &second, const DataVisitor &visitor) const =0
std::function< void(const Data &)> DataVisitor
virtual ~AdderBase()=default
void operator()(const Data &first, const Data &second, const DataVisitor &visitor) const override
virtual std::string dispatch() const
Base(const Base &)=delete
std::string dispatch() const override
The 'instance' type which needs to be standard layout (need to be able to use 'offsetof')