Struct CallbackProtocol 

pub struct CallbackProtocol<'a> {
    pub binding: &'a CallbackInterfaceBinding,
    pub method_args: Vec<Vec<RetPass>>,
    pub method_returns: Vec<RetPass>,
    pub method_errors: Vec<ErrorStrategy>,
}

The callback-interface contract every backend renders.

A callback interface is the consumer’s side of the boundary: the consumer supplies an implementation, the producer calls it. The contract has five clauses:

1. One static vtable per interface. The wrapper emits exactly one process-wide vtable value for the interface. It starts with the fixed header, size (sizeof the vtable as the wrapper compiled it), flags (0), and free, followed by one trampoline per method from the C signature (CallbackMethodBinding::abi_params) into the native implementation. The producer rejects a vtable smaller than the one it was built with, so a stale binding fails with -3 instead of calling through a missing slot.
2. Context is a handle-table key. The wrapper stores the native implementation in a table keyed by an integer or pointer it passes as ctx, so the implementation stays alive as long as the producer holds the callback and garbage collectors never see a raw pointer. free may run on any producer thread.
3. Arguments are received like returns. Strings, bytes, and buffers arriving in a trampoline are borrowed for the call: the wrapper copies or decodes them before returning and frees nothing. Object arguments transfer one strong reference the wrapper adopts.
4. Returns transfer to the producer (method_returns). A direct value is the C return. An object is returned as one strong reference (a fresh _clone of the wrapper’s handle). A string, bytes, or buffer is written to the trailing out_ptr/out_len slots as a run the wrapper allocates with {prefix}_alloc; the producer adopts it.
5. Failures go through out_err. When the native implementation raises, the trampoline calls {prefix}_error_set(out_err, code, message) and returns a zero value; it must never let an exception unwind through the C frame. A method whose method_errors entry is ErrorStrategy::Throws reports a declared domain error with its positive code and its payload fields ({prefix}_error_set_payload); every other failure uses -4, and the producer treats any code it can’t attribute to the method’s domain as -4.

Trampolines may be invoked from any producer thread; the wrapper is responsible for whatever thread affinity its runtime demands (a GIL acquisition, a JNI attach, a threadsafe-function hop).

Fields

binding: &'a CallbackInterfaceBinding

The lowered callback interface: vtable tag and methods.

method_args: Vec<Vec<RetPass>>

How each method’s parameters are received inside a trampoline, in method order then parameter order.

method_returns: Vec<RetPass>

How each method’s return value crosses back to the producer, in method order. RetPass::String, RetPass::Bytes, and RetPass::Buffer are written to the out_ptr/out_len slots as a {prefix}_alloc run.

method_errors: Vec<ErrorStrategy>

How each method may report failure, in method order.

Trait Implementations

impl<'a> Clone for CallbackProtocol<'a>

fn clone(&self) -> Self

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<'a> Debug for CallbackProtocol<'a>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'a> Eq for CallbackProtocol<'a>

impl<'a> PartialEq for CallbackProtocol<'a>

fn eq(&self, other: &Self) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl<'a> StructuralPartialEq for CallbackProtocol<'a>