Struct ContentEncoding 

pub struct ContentEncoding { /* private fields */ }

The codings a response says its body carries.

Read from every Content-Encoding line together: a representation encoded more than once may arrive comma-joined on one line or split across several, and it is the same list either way.

Implementations

impl ContentEncoding

pub fn codings(&self) -> &[Coding]

The codings the header carried, in the order it applied them.

Empty for a response that declared none, and for one whose header could not be read.

pub fn layer(&self, coding: Coding) -> Self

Add a coding on top of the ones already here.

Applied last, so it is last in the header: the codings are listed in the order they were applied, and a reader unwinds them in reverse.

Examples found in repository

examples/codings.rs (line 53)

async fn main() {
	let accept = AcceptEncoding::from(DEFAULT_ACCEPT_ENCODING);

	let mut headers = HeaderMap::new();
	headers.insert("content-encoding", HeaderValue::from_static("gzip"));
	headers.insert("content-length", HeaderValue::from_static("42"));
	// Just the header half, so the coding is in hand for the round trip below; `response::decode`
	// does this and the body together.
	let coding = ContentEncoding::peel_one_header(&mut headers, &accept)
		.expect("gzip is in the default Accept-Encoding");
	println!("negotiated: {coding:?}");
	println!("headers after decoding: {:?}", headers.keys().count());

	// Round-trip a body through the coding that was negotiated.
	let original = b"the quick brown fox jumps over the lazy dog".repeat(8);
	let compressed = compress_buffer(&original, coding.clone())
		.await
		.expect("gzip compresses");
	println!(
		"{} bytes in, {} bytes out",
		original.len(),
		compressed.len()
	);

	let stream = futures::stream::once(async move { Ok(Bytes::from(compressed)) });
	let mut decoded = decode_stream(Box::pin(stream), coding);
	let mut round_tripped = Vec::new();
	while let Some(chunk) = decoded.next().await {
		round_tripped.extend_from_slice(&chunk.expect("the body decodes"));
	}
	println!("round-tripped intact: {}", round_tripped == original);

	// Compressing a request on top of a coding the caller already applied declares both, in the
	// order they were applied.
	let mut request = HeaderMap::new();
	request.insert("content-encoding", HeaderValue::from_static("br"));

	let layered = ContentEncoding::from(&request).layer(Coding::Gzip);
	if let Some(value) = layered.to_header_value() {
		request.insert("content-encoding", value);
	}
	println!(
		"Content-Encoding: {}",
		request["content-encoding"].to_str().unwrap()
	);
}

pub fn to_header_value(&self) -> Option<HeaderValue>

The header value these codings make, or None when there are none to declare.

Examples found in repository

examples/codings.rs (line 54)

async fn main() {
	let accept = AcceptEncoding::from(DEFAULT_ACCEPT_ENCODING);

	let mut headers = HeaderMap::new();
	headers.insert("content-encoding", HeaderValue::from_static("gzip"));
	headers.insert("content-length", HeaderValue::from_static("42"));
	// Just the header half, so the coding is in hand for the round trip below; `response::decode`
	// does this and the body together.
	let coding = ContentEncoding::peel_one_header(&mut headers, &accept)
		.expect("gzip is in the default Accept-Encoding");
	println!("negotiated: {coding:?}");
	println!("headers after decoding: {:?}", headers.keys().count());

	// Round-trip a body through the coding that was negotiated.
	let original = b"the quick brown fox jumps over the lazy dog".repeat(8);
	let compressed = compress_buffer(&original, coding.clone())
		.await
		.expect("gzip compresses");
	println!(
		"{} bytes in, {} bytes out",
		original.len(),
		compressed.len()
	);

	let stream = futures::stream::once(async move { Ok(Bytes::from(compressed)) });
	let mut decoded = decode_stream(Box::pin(stream), coding);
	let mut round_tripped = Vec::new();
	while let Some(chunk) = decoded.next().await {
		round_tripped.extend_from_slice(&chunk.expect("the body decodes"));
	}
	println!("round-tripped intact: {}", round_tripped == original);

	// Compressing a request on top of a coding the caller already applied declares both, in the
	// order they were applied.
	let mut request = HeaderMap::new();
	request.insert("content-encoding", HeaderValue::from_static("br"));

	let layered = ContentEncoding::from(&request).layer(Coding::Gzip);
	if let Some(value) = layered.to_header_value() {
		request.insert("content-encoding", value);
	}
	println!(
		"Content-Encoding: {}",
		request["content-encoding"].to_str().unwrap()
	);
}

pub fn can_decode_as(&self, accept: &AcceptEncoding) -> Option<Coding>

The coding the next layer of the body is under, given what the request accepted.

The last coding, being the last applied and so the first to unwind. None leaves the body as it arrived, which covers a response that declared no coding, one whose outermost coding this crate cannot decode (identity among them) or the request did not accept, and one whose header was not readable.

pub fn peeled(&self) -> Self

These codings with the outermost removed, as the body stands once it is decoded.

pub fn peel_one_header( headers: &mut HeaderMap, accept: &AcceptEncoding, ) -> Option<Coding>

Take one layer off headers, returning the coding its body is under.

The headers are left describing the body once that coding has been decoded, which response::decode does in the same call. Reach for this only to drive the two halves separately.

Content-Encoding keeps whatever layers remain and goes when none do; Content-Length goes either way, no longer describing what the caller reads. None leaves headers as they are.

Examples found in repository

examples/codings.rs (line 24)

async fn main() {
	let accept = AcceptEncoding::from(DEFAULT_ACCEPT_ENCODING);

	let mut headers = HeaderMap::new();
	headers.insert("content-encoding", HeaderValue::from_static("gzip"));
	headers.insert("content-length", HeaderValue::from_static("42"));
	// Just the header half, so the coding is in hand for the round trip below; `response::decode`
	// does this and the body together.
	let coding = ContentEncoding::peel_one_header(&mut headers, &accept)
		.expect("gzip is in the default Accept-Encoding");
	println!("negotiated: {coding:?}");
	println!("headers after decoding: {:?}", headers.keys().count());

	// Round-trip a body through the coding that was negotiated.
	let original = b"the quick brown fox jumps over the lazy dog".repeat(8);
	let compressed = compress_buffer(&original, coding.clone())
		.await
		.expect("gzip compresses");
	println!(
		"{} bytes in, {} bytes out",
		original.len(),
		compressed.len()
	);

	let stream = futures::stream::once(async move { Ok(Bytes::from(compressed)) });
	let mut decoded = decode_stream(Box::pin(stream), coding);
	let mut round_tripped = Vec::new();
	while let Some(chunk) = decoded.next().await {
		round_tripped.extend_from_slice(&chunk.expect("the body decodes"));
	}
	println!("round-tripped intact: {}", round_tripped == original);

	// Compressing a request on top of a coding the caller already applied declares both, in the
	// order they were applied.
	let mut request = HeaderMap::new();
	request.insert("content-encoding", HeaderValue::from_static("br"));

	let layered = ContentEncoding::from(&request).layer(Coding::Gzip);
	if let Some(value) = layered.to_header_value() {
		request.insert("content-encoding", value);
	}
	println!(
		"Content-Encoding: {}",
		request["content-encoding"].to_str().unwrap()
	);
}

Trait Implementations

impl Clone for ContentEncoding

fn clone(&self) -> ContentEncoding

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ContentEncoding

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

Formats the value using the given formatter.

impl Default for ContentEncoding

fn default() -> ContentEncoding

Returns the “default value” for a type.

impl Display for ContentEncoding

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

Formats the value using the given formatter.

impl From<&HeaderMap> for ContentEncoding

fn from(headers: &HeaderMap) -> Self

Converts to this type from the input type.

impl From<&str> for ContentEncoding

fn from(value: &str) -> Self

Read one Content-Encoding header value.