mirror of
https://github.com/pybind/pybind11.git
synced 2024-11-14 09:34:46 +00:00
b4498ef44d
Allows checking the Python types before creating an object instead of
after. For example:
```c++
auto l = list(ptr, true);
if (l.check())
// ...
```
The above is replaced with:
```c++
if (isinstance<list>(ptr)) {
auto l = reinterpret_borrow(ptr);
// ...
}
```
This deprecates `py::object::check()`. `py::isinstance()` covers the
same use case, but it can also check for user-defined types:
```c++
class Pet { ... };
py::class_<Pet>(...);
m.def("is_pet", [](py::object obj) {
return py::isinstance<Pet>(obj); // works as expected
});
```
101 lines
3.0 KiB
C++
101 lines
3.0 KiB
C++
/*
|
|
tests/test_inheritance.cpp -- inheritance, automatic upcasting for polymorphic types
|
|
|
|
Copyright (c) 2016 Wenzel Jakob <wenzel.jakob@epfl.ch>
|
|
|
|
All rights reserved. Use of this source code is governed by a
|
|
BSD-style license that can be found in the LICENSE file.
|
|
*/
|
|
|
|
#include "pybind11_tests.h"
|
|
|
|
class Pet {
|
|
public:
|
|
Pet(const std::string &name, const std::string &species)
|
|
: m_name(name), m_species(species) {}
|
|
std::string name() const { return m_name; }
|
|
std::string species() const { return m_species; }
|
|
private:
|
|
std::string m_name;
|
|
std::string m_species;
|
|
};
|
|
|
|
class Dog : public Pet {
|
|
public:
|
|
Dog(const std::string &name) : Pet(name, "dog") {}
|
|
std::string bark() const { return "Woof!"; }
|
|
};
|
|
|
|
class Rabbit : public Pet {
|
|
public:
|
|
Rabbit(const std::string &name) : Pet(name, "parrot") {}
|
|
};
|
|
|
|
class Hamster : public Pet {
|
|
public:
|
|
Hamster(const std::string &name) : Pet(name, "rodent") {}
|
|
};
|
|
|
|
std::string pet_name_species(const Pet &pet) {
|
|
return pet.name() + " is a " + pet.species();
|
|
}
|
|
|
|
std::string dog_bark(const Dog &dog) {
|
|
return dog.bark();
|
|
}
|
|
|
|
|
|
struct BaseClass { virtual ~BaseClass() {} };
|
|
struct DerivedClass1 : BaseClass { };
|
|
struct DerivedClass2 : BaseClass { };
|
|
|
|
test_initializer inheritance([](py::module &m) {
|
|
py::class_<Pet> pet_class(m, "Pet");
|
|
pet_class
|
|
.def(py::init<std::string, std::string>())
|
|
.def("name", &Pet::name)
|
|
.def("species", &Pet::species);
|
|
|
|
/* One way of declaring a subclass relationship: reference parent's class_ object */
|
|
py::class_<Dog>(m, "Dog", pet_class)
|
|
.def(py::init<std::string>());
|
|
|
|
/* Another way of declaring a subclass relationship: reference parent's C++ type */
|
|
py::class_<Rabbit, Pet>(m, "Rabbit")
|
|
.def(py::init<std::string>());
|
|
|
|
/* And another: list parent in class template arguments */
|
|
py::class_<Hamster, Pet>(m, "Hamster")
|
|
.def(py::init<std::string>());
|
|
|
|
m.def("pet_name_species", pet_name_species);
|
|
m.def("dog_bark", dog_bark);
|
|
|
|
py::class_<BaseClass>(m, "BaseClass").def(py::init<>());
|
|
py::class_<DerivedClass1>(m, "DerivedClass1").def(py::init<>());
|
|
py::class_<DerivedClass2>(m, "DerivedClass2").def(py::init<>());
|
|
|
|
m.def("return_class_1", []() -> BaseClass* { return new DerivedClass1(); });
|
|
m.def("return_class_2", []() -> BaseClass* { return new DerivedClass2(); });
|
|
m.def("return_class_n", [](int n) -> BaseClass* {
|
|
if (n == 1) return new DerivedClass1();
|
|
if (n == 2) return new DerivedClass2();
|
|
return new BaseClass();
|
|
});
|
|
m.def("return_none", []() -> BaseClass* { return nullptr; });
|
|
|
|
m.def("test_isinstance", [](py::list l) {
|
|
struct Unregistered { }; // checks missing type_info code path
|
|
|
|
return py::make_tuple(
|
|
py::isinstance<py::tuple>(l[0]),
|
|
py::isinstance<py::dict>(l[1]),
|
|
py::isinstance<Pet>(l[2]),
|
|
py::isinstance<Pet>(l[3]),
|
|
py::isinstance<Dog>(l[4]),
|
|
py::isinstance<Rabbit>(l[5]),
|
|
py::isinstance<Unregistered>(l[6])
|
|
);
|
|
});
|
|
});
|