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 <nanobind/nanobind.h>
#include <nanobind/trampoline.h>

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

template <auto Fn, std::size_t N, typename BaseCall, typename... Args>
decltype(auto) override_dispatch(const nb::detail::trampoline<N>& tr,
                                 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 "
        "(nanobind 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))};
 
    if constexpr (std::meta::is_pure_virtual(Fn)) {
        // Pure: there is no base to fall back to. nanobind's trampoline machinery
        // raises a descriptive error if Python supplied no override.
        nb::detail::ticket t(tr, name, /*pure=*/true);
        return nb::cast<ret_type>(tr.base().attr(t.key)(std::forward<Args>(args)...));
    } else {
        nb::detail::ticket t(tr, name, /*pure=*/false);
        if (t.key.is_valid())
            return nb::cast<ret_type>(
                tr.base().attr(t.key)(std::forward<Args>(args)...));
        return std::forward<BaseCall>(base_call)(std::forward<Args>(args)...);
    }
}
 
} // namespace welder::rods::nanobind

#define WELDER_PY_TRAMPOLINE(BASE)                                             \
    using welder_py_base = BASE;                                              \
    using welder_py_base::welder_py_base;                                     \
    ::nanobind::detail::trampoline<                                           \
        ::welder::rods::python::virtual_slot_count(^^BASE)>                   \
        welder_nb_trampoline{this}

#define WELDER_PY_OVERRIDE_AS(SLOT, FUNC, ...)                                 \
    return ::welder::rods::nanobind::override_dispatch<(SLOT)>(                \
        this->welder_nb_trampoline,                                          \
        [&](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__)