51 lines
1.6 KiB
Rust
51 lines
1.6 KiB
Rust
//! Streaming bodies for Requests and Responses
|
|
//!
|
|
//! For both [Clients](crate::client) and [Servers](crate::server), requests and
|
|
//! responses use streaming bodies, instead of complete buffering. This
|
|
//! allows applications to not use memory they don't need, and allows exerting
|
|
//! back-pressure on connections by only reading when asked.
|
|
//!
|
|
//! There are two pieces to this in hyper:
|
|
//!
|
|
//! - **The [`Body`] trait** describes all possible bodies.
|
|
//! hyper allows any body type that implements `Body`, allowing
|
|
//! applications to have fine-grained control over their streaming.
|
|
//! - **The [`Incoming`] concrete type**, which is an implementation
|
|
//! of `Body`, and returned by hyper as a "receive stream" (so, for server
|
|
//! requests and client responses).
|
|
//!
|
|
//! There are additional implementations available in [`http-body-util`][],
|
|
//! such as a `Full` or `Empty` body.
|
|
//!
|
|
//! [`http-body-util`]: https://docs.rs/http-body-util
|
|
|
|
pub use bytes::{Buf, Bytes};
|
|
pub use http_body::Body;
|
|
pub use http_body::Frame;
|
|
pub use http_body::SizeHint;
|
|
|
|
pub use self::incoming::Incoming;
|
|
|
|
#[cfg(all(any(feature = "client", feature = "server"), feature = "http1"))]
|
|
pub(crate) use self::incoming::Sender;
|
|
#[cfg(all(
|
|
any(feature = "http1", feature = "http2"),
|
|
any(feature = "client", feature = "server")
|
|
))]
|
|
pub(crate) use self::length::DecodedLength;
|
|
|
|
mod incoming;
|
|
#[cfg(all(
|
|
any(feature = "http1", feature = "http2"),
|
|
any(feature = "client", feature = "server")
|
|
))]
|
|
mod length;
|
|
|
|
fn _assert_send_sync() {
|
|
fn _assert_send<T: Send>() {}
|
|
fn _assert_sync<T: Sync>() {}
|
|
|
|
_assert_send::<Incoming>();
|
|
_assert_sync::<Incoming>();
|
|
}
|