Struct CallbackProtocol 

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

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 four clauses:

1. One static vtable per interface. The wrapper emits exactly one process-wide vtable value for the interface whose entries are trampolines from the C signature (CallbackMethodBinding::abi_params) into the native implementation, plus a trailing free entry.
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.
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. Method returns are direct values written straight into the C return.
4. Foreign failures trap. When the native implementation raises, the trampoline calls {prefix}_error_set(out_err, -4, message) and returns a default value; it must never let an exception unwind through the C frame. The producer then aborts its call with FOREIGN_ERROR_CODE.

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.

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>