Struct GrpcRequestBuilder 

pub struct GrpcRequestBuilder { /* private fields */ }

Implementations

impl GrpcRequestBuilder

pub fn metadata( self, name: impl AsRef<str>, value: impl AsRef<str>, ) -> Result<Self>

pub fn metadata_map<I, K, V>(self, values: I) -> Result<Self>

where I: IntoIterator<Item = (K, V)>, K: AsRef<str>, V: AsRef<str>,

pub fn metadata_bin( self, name: impl AsRef<str>, value: impl AsRef<[u8]>, ) -> Result<Self>

pub fn message<T: Serialize>(self, value: &T) -> Result<Self>

pub fn messages<S, T>(self, stream: S) -> Result<Self>

where S: Stream<Item = Result<T>> + Send + 'static, T: Serialize + Send,

pub fn message_bytes(self, value: impl Into<Bytes>) -> Result<Self>

pub fn messages_bytes<S, B>(self, stream: S) -> Result<Self>

where S: Stream<Item = Result<B>> + Send + 'static, B: Into<Bytes> + Send + 'static,

pub fn codec(self, codec: GrpcCodec) -> Self

pub fn compression(self, algo: impl AsRef<str>) -> Self

pub fn protocol_policy(self, policy: ProtocolPolicy) -> Self

pub fn prefer_http3(self) -> Self

pub fn prefer_http2(self) -> Self

pub fn http2_only(self) -> Self

pub fn http3_only(self) -> Self

pub fn prior_knowledge_h2c(self, enabled: bool) -> Self

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

pub fn connect_timeout(self, duration: Duration) -> Self

pub fn read_timeout(self, duration: Duration) -> Self

pub fn write_timeout(self, duration: Duration) -> Self

pub fn tls_config(self, tls_config: TlsConfig) -> Self

pub fn danger_accept_invalid_certs(self, enabled: bool) -> Self

pub fn tls_backend(self, backend: TlsBackend) -> Self

pub async fn send_streaming(self) -> Result<GrpcStreamingResponse>

pub async fn open_duplex(self) -> Result<GrpcDuplexCall>

Trait Implementations

impl IntoFuture for GrpcRequestBuilder

type Output = Result<GrpcResponse, Error>

The output that the future will produce on completion.

type IntoFuture = Pin<Box<dyn Future<Output = <GrpcRequestBuilder 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.