trampoline.hpp

Go to the documentation of this file.

#pragma once
#include <cstddef>
#include <meta>
#include <type_traits>
#include <utility>
 
#include <welder/rods/python/trampoline.hpp> // virtual_slot_count, trampoline_for, …
 
#include <pybind11/pybind11.h>

 
namespace welder::inline v0::rods::pybind11 {
 
// The unqualified name `pybind11` resolves to *this* namespace inside it; alias the
// real library the way pybind11's own docs do (see rod.hpp).
namespace py = ::pybind11;

template <auto Fn, typename Self, typename BaseCall, typename... Args>
decltype(auto) override_dispatch(const Self& self, BaseCall&& base_call,
                                 Args&&... args) {
    using ret_type = [:std::meta::return_type_of(Fn):];
    static_assert(
        !std::is_reference_v<ret_type>,
        "welder: cannot trampoline a virtual method that returns a reference "
        "(pybind11 cannot keep the referent alive across the C++/Python boundary); "
        "return by value, or mark the type [[=welder::rods::python::bind_flat]].");
 
    constexpr const char* name{
        std::define_static_string(std::meta::identifier_of(Fn))};
 
    py::gil_scoped_acquire gil;
    py::function override{py::get_override(&self, name)};
    if (override)
        return py::detail::cast_safe<ret_type>(
            override(std::forward<Args>(args)...));
 
    if constexpr (std::meta::is_pure_virtual(Fn))
        // No base to fall back to and no Python override: pybind11's own diagnostic.
        py::pybind11_fail(
            "welder: tried to call a pure virtual method with no Python override");
    else
        return std::forward<BaseCall>(base_call)(std::forward<Args>(args)...);
}
 
} // namespace welder::rods::pybind11

#define WELDER_PY_TRAMPOLINE(BASE)                                             \
    using welder_py_base = BASE;                                              \
    using welder_py_base::welder_py_base

#define WELDER_PY_OVERRIDE_AS(SLOT, FUNC, ...)                                 \
    return ::welder::rods::pybind11::override_dispatch<(SLOT)>(                \
        static_cast<const welder_py_base&>(*this),                           \
        [&](auto&&... _welder_a) -> decltype(auto) {                         \
            return welder_py_base::FUNC(                                      \
                static_cast<decltype(_welder_a)&&>(_welder_a)...);           \
        } __VA_OPT__(, ) __VA_ARGS__)

#define WELDER_PY_OVERRIDE(FUNC, ...)                                          \
    WELDER_PY_OVERRIDE_AS(^^welder_py_base::FUNC, FUNC __VA_OPT__(, ) __VA_ARGS__)