Struct UnaryConn 

pub struct UnaryConn<Req, Resp> { /* private fields */ }

Available on crate feature client only.

A unary or client-streaming call: one request (or a stream of requests) in, exactly one response out.

Build it with the chainable with_* setters, then .await it — awaiting sends the request(s), reads the single response, drains the stream to its trailers, and enforces the one-response cardinality. Transport-level failures (connection, non-200 head) surface as the await’s Err; the RPC’s logical grpc-status is read afterward via status / into_message, so response metadata stays readable even on a logical error.

Implementations

impl<Req, Resp> UnaryConn<Req, Resp>

where Req: Send + 'static, Resp: Send + 'static,

pub fn unary<C>(client: &Client, path: &str, request: Req) -> Self

where C: Codec<Req> + Codec<Resp>,

A unary call sending the single request.

pub fn client_streaming<C>( client: &Client, path: &str, requests: impl Stream<Item = Req> + Send + 'static, ) -> Self

where C: Codec<Req> + Codec<Resp>,

A client-streaming call sending each message from requests.

pub fn with_ascii_metadata(self, key: &str, value: &str) -> Self

Attach an ASCII request-metadata entry. Chainable; takes effect when the call fires.

pub fn with_binary_metadata(self, key: &str, value: impl Into<Vec<u8>>) -> Self

Attach a binary (-bin) request-metadata entry. Chainable.

pub fn with_timeout(self, timeout: Duration) -> Self

Set this call’s deadline, timeout from now. Chainable.

pub fn cancel_handle(&self) -> CancelHandle

A handle that cancels this call from elsewhere (including before/while it is awaited).

pub fn metadata(&self) -> Option<&Headers>

The response’s initial metadata, once the call has run. None before.

pub fn trailers(&self) -> Option<&Headers>

The response’s trailing metadata, once the call has run. None before.

pub fn message(&self) -> Option<&Resp>

The response message, if the call ran and yielded one. None before the call, and on the error path.

pub fn status(&self) -> Result<(), Status>

The RPC’s logical verdict, once the call has run: Ok(()) on success, the server’s grpc-status (or a cardinality violation) as Err. Ok(()) before the call has run.

pub fn into_message(self) -> Result<Resp, Status>

Consume the conn and yield the response message, folding the logical verdict: Err on a grpc-status error (or cardinality violation), else the single message. Read metadata / trailers first if you need them on the error path.

Trait Implementations

impl<Req, Resp> IntoFuture for UnaryConn<Req, Resp>

where Req: Send + 'static, Resp: Send + 'static,

type Output = Result<UnaryConn<Req, Resp>, Status>

The output that the future will produce on completion.

type IntoFuture = Pin<Box<dyn Future<Output = <UnaryConn<Req, Resp> 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.