Struct BatchableCall 

pub struct BatchableCall<C, O> { /* private fields */ }

A typed unary RPC call that has been prepared but not yet sent.

Produced by every macro-generated unary RPC method on the typed client (model CRUD + unary procedures). Two consumption modes:

• Eager. .await directly — IntoFuture desugars to the same HTTP request RpcClient::call would have made.
• Batched. .queue(&mut batch) registers the call with a BatchBuilder for a single multiplexed POST /rpc/batch. Returns a typed BatchHandle for .take(...) on the results after batch.send().await resolves.

The input is eagerly converted to serde_json::Value at construction time so the same prepared call can flow into either consumption mode without re-borrowing the input. Conversion errors surface lazily — eagerly on .await, per-handle on the batch path.

Implementations

impl<C, O> BatchableCall<C, O>

where C: HttpClientCodec + Clone + Send + 'static, O: DeserializeOwned + Send + 'static,

pub fn new<I>(rpc: RpcClient<C>, op_id: impl Into<String>, input: &I) -> Self

where I: Serialize,

Construct a prepared call. Callers should generally use the macro-generated typed methods rather than building this by hand.

pub fn queue(self, batch: &mut BatchBuilder<C>) -> BatchHandle<O>

Queue this call into a BatchBuilder for deferred execution. The returned BatchHandle is the key to retrieve the typed result via [BatchResults::take] after BatchBuilder::send resolves.

Input-encoding errors observed at construction time are preserved per-handle, so a single bad input in a batch produces a per-handle take(...)? error rather than poisoning the whole batch.

Trait Implementations

impl<C, O> IntoFuture for BatchableCall<C, O>

where C: HttpClientCodec + Clone + Send + 'static, O: DeserializeOwned + Send + 'static,

type Output = Result<O, RpcClientError>

The output that the future will produce on completion.

type IntoFuture = Pin<Box<dyn Future<Output = <BatchableCall<C, O> as IntoFuture>::Output> + Send>>

Which kind of future are we turning this into?

fn into_future(self) -> Self::IntoFuture

Creates a future from a value.