Struct DynHttpClient 

pub struct DynHttpClient { /* private fields */ }

A type-erased, cheaply cloneable HTTP transport.

Clones share the transport and middleware instances but copy the middleware list. Erasing an already erased transport clones it without another layer. Debug prints only the type name to avoid exposing transport credentials. The transport is not serializable.

fn assert_serialize<T: serde::Serialize>() {}
assert_serialize::<rig_http::http_client::DynHttpClient>();

Implementations

impl DynHttpClient

pub fn new<H>(http: H) -> Self

where H: HttpClientExt + 'static,

Erase http. If http is already a DynHttpClient, this is a clone (its attached middleware included).

pub fn with_middleware<M>(self, middleware: M) -> Self

where M: HttpMiddleware + 'static,

Attach a transport-boundary HttpMiddleware to this handle.

Hooks run in attachment order with the phases defined by HttpMiddleware. Existing clones keep their previous stack. The underlying transport stays shared, so Self::ptr_eq is unaffected.

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

Whether two handles share the same underlying transport.

Compares the transport only: handles that differ in attached middleware but wrap the same transport still compare equal.

Trait Implementations

impl Clone for DynHttpClient

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for DynHttpClient

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

Formats the value using the given formatter.

impl HttpClientExt for DynHttpClient

fn send<T, U>( &self, req: Request<T>, ) -> impl Future<Output = Result<Response<LazyBody<U>>>> + WasmCompatSend + 'static

where T: Into<Bytes> + WasmCompatSend, U: From<Bytes> + WasmCompatSend + 'static,

Sends a request and returns headers with a lazy body converted from bytes to U.

fn send_multipart<U>( &self, req: Request<MultipartForm>, ) -> impl Future<Output = Result<Response<LazyBody<U>>>> + WasmCompatSend + 'static

where U: From<Bytes> + WasmCompatSend + 'static,

Sends a multipart request and returns headers with a lazy body converted to U.

fn send_streaming<T>( &self, req: Request<T>, ) -> impl Future<Output = Result<StreamingResponse>> + WasmCompatSend

where T: Into<Bytes> + WasmCompatSend,

Sends a request and returns headers with a stream of transport byte chunks.