wreq

https://docs.rs/wreq
Admin
wreq is an ergonomic all-in-one HTTP client for browser emulation, providing features like TLS,...
Tokens:181,596
Snippets:1,214
Trust Score:9.7
Update:1 month ago
Show doc for...
Tokens:
Raw
### Chunked Extensions Limit Test

Source: https://docs.rs/wreq-proto/0.2.6/src/wreq_proto/proto/http1/decode.rs.html

Setup for testing chunked extension size limits.

```rust
#[tokio::test]
async fn test_read_chunked_extensions_over_limit() {
    // construct a chunked body where each individual chunked extension
    // is totally fine, but combined is over the limit.
    let per_chunk = super::CHUNKED_EXTENSIONS_LIMIT * 2 / 3;
    let mut scratch = vec![];
    for _ in 0..2 {
        scratch.extend(b"1;");
```

--------------------------------

### Initialize Http2Options

Source: https://docs.rs/wreq-proto/0.2.6/src/wreq_proto/proto/http2.rs.html

Methods for creating a new builder instance and defining default HTTP/2 configuration values.

```rust
pub fn builder() -> Http2OptionsBuilder {
    // Reset optional frame size and header size settings to None to allow explicit
    // customization This ensures users can configure these via builder methods without
    // being constrained by defaults
    Http2OptionsBuilder {
        opts: Http2Options {
            max_frame_size: None,
            max_header_list_size: None,
            ..Default::default()
        },
    }
}
```

```rust
#[inline]
fn default() -> Self {
    Http2Options {
        adaptive_window: false,
        initial_stream_id: None,
        initial_conn_window_size: DEFAULT_CONN_WINDOW,
        initial_window_size: DEFAULT_STREAM_WINDOW,
        initial_max_send_streams: DEFAULT_INITIAL_MAX_SEND_STREAMS,
        max_frame_size: Some(DEFAULT_MAX_FRAME_SIZE),
        max_header_list_size: Some(DEFAULT_MAX_HEADER_LIST_SIZE),
        keep_alive_interval: None,
        keep_alive_timeout: Duration::from_secs(20),
        keep_alive_while_idle: false,
        max_concurrent_reset_streams: None,
        max_send_buffer_size: DEFAULT_MAX_SEND_BUF_SIZE,
        max_pending_accept_reset_streams: None,
        header_table_size: None,
        max_concurrent_streams: None,
        enable_push: None,
        enable_connect_protocol: None,
        no_rfc7540_priorities: None,
        settings_order: None,
        headers_pseudo_order: None,
        headers_stream_dependency: None,
        priorities: None,
    }
}
```

--------------------------------

### FromIterator Implementation Examples

Source: https://docs.rs/wreq-proto/0.2.6/wreq_proto/type.Result.html?search=std%3A%3Avec

Examples showing how Result implements FromIterator, allowing collection of results into a container. Collection stops at the first Err encountered.

```rust
let v = vec![1, 2];
let res: Result<Vec<u32>, &'static str> = v.iter().map(|x: &u32|
    x.checked_add(1).ok_or("Overflow!")
).collect();
assert_eq!(res, Ok(vec![2, 3]));
```

```rust
let v = vec![1, 2, 0];
let res: Result<Vec<u32>, &'static str> = v.iter().map(|x: &u32|
    x.checked_sub(1).ok_or("Underflow!")
).collect();
assert_eq!(res, Err("Underflow!"));
```

```rust
let v = vec![3, 2, 1, 10];
let mut shared = 0;
let res: Result<Vec<u32>, &'static str> = v.iter().map(|x: &u32| {
    shared += x;
    x.checked_sub(2).ok_or("Underflow!")
}).collect();
assert_eq!(res, Err("Underflow!"));
assert_eq!(shared, 6);
```

--------------------------------

### Prepare Protocol Upgrade

Source: https://docs.rs/wreq-proto/0.2.6/src/wreq_proto/proto/http1/conn.rs.html

Initializes an upgrade channel and returns the receiver for handling protocol switching.

```rust
#[inline]
fn prepare_upgrade(&mut self) -> upgrade::OnUpgrade {
    let (tx, rx) = upgrade::pending();
    self.upgrade = Some(tx);
    rx
}
```

--------------------------------

### Transposing Result and Option

Source: https://docs.rs/wreq-proto/0.2.6/wreq_proto/type.Result.html?search=std%3A%3Avec

Example of transposing a Result of an Option into an Option of a Result.

```rust
#[derive(Debug, Eq, PartialEq)]
struct SomeErr;

let x: Result<Option<i32>, SomeErr> = Ok(Some(5));
let y: Option<Result<i32, SomeErr>> = Some(Ok(5));
assert_eq!(x.transpose(), y);
```

--------------------------------

### Build HTTP/1 Options

Source: https://docs.rs/wreq-proto/0.2.6/x86_64-unknown-linux-gnu/src/wreq_proto/proto/http1.rs.html

Methods to finalize the builder configuration and initialize a new builder instance.

```rust
#[inline]
pub fn build(self) -> Http1Options {
    self.opts
}
```

```rust
pub fn builder() -> Http1OptionsBuilder {
    Http1OptionsBuilder {
        opts: Http1Options::default(),
    }
}
```

--------------------------------

### Usage Example for on_informational

Source: https://docs.rs/wreq-proto/0.2.6/wreq_proto/ext/fn.on_informational.html?search=

Demonstrates how to register a callback to print the status of informational responses.

```rust
let mut req = http::Request::new(some_body);

wreq_proto::ext::on_informational(&mut req, |res| {
    println!("informational: {:?}", res.status());
});

// send request on a client connection...
```

--------------------------------

### HTTP/2 Client Handshake

Source: https://docs.rs/wreq-proto/0.2.6/src/wreq_proto/proto/http2/client.rs.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Initializes the HTTP/2 connection, sets up ping/pong configuration, and spawns the connection task.

```rust
pub(crate) async fn handshake<T, B, E>(
    io: T,
    req_rx: ClientRx<B>,
    builder: Builder,
    ping_config: ping::Config,
    mut exec: E,
    timer: Time,
) -> Result<ClientTask<B, E, T>>
where
    T: AsyncRead + AsyncWrite + Unpin,
    B: Body + 'static,
    B::Data: Send + 'static,
    E: Http2ClientConnExec<B, T> + Unpin,
    B::Error: Into<BoxError>,
{
    let (h2_tx, mut conn) = builder
        .handshake::<_, SendBuf<B::Data>>(io)
        .await
        .map_err(Error::new_h2)?;

    // An mpsc channel is used entirely to detect when the
    // 'Client' has been dropped. This is to get around a bug
    // in h2 where dropping all SendRequests won't notify a
    // parked Connection.
    let (conn_drop_ref, conn_drop_rx) = mpsc::channel(1);
    let (cancel_tx, conn_eof) = oneshot::channel();

    let (conn, ping) = if ping_config.is_enabled() {
        let pp = conn.ping_pong().expect("conn.ping_pong");
        let (recorder, ponger) = ping::channel(pp, ping_config, timer);

        let conn: Conn<_, B> = Conn { ponger, conn };
        (Either::Left(conn), recorder)
    } else {
        (Either::Right(conn), ping::Recorder::disabled())
    };
    let conn: ConnMapErr<T, B> = ConnMapErr {
        conn,
        is_terminated: false,
    };

    exec.execute_h2_future(H2ClientFuture::Task {
        task: ConnTask::new(conn, conn_drop_rx, cancel_tx),
    });

    Ok(ClientTask {
        ping,
        conn_drop_ref,
        conn_eof,
        executor: exec,
        h2_tx,
        req_rx,
        fut_ctx: None,
        marker: PhantomData,
    })
}
```

--------------------------------

### Configure HTTP/1 Connection Options

Source: https://docs.rs/wreq-proto/0.2.6/src/wreq_proto/proto/http1.rs.html

Methods for setting buffer sizes, header limits, and parsing behavior for HTTP/1 connections.

```rust
#[inline]
pub fn max_headers(mut self, max_headers: usize) -> Self {
    self.opts.h1_max_headers = Some(max_headers);
    self
}
```

```rust
#[inline]
pub fn read_buf_exact_size(mut self, sz: Option<usize>) -> Self {
    self.opts.h1_read_buf_exact_size = sz;
    self.opts.h1_max_buf_size = None;
    self
}
```

```rust
#[inline]
pub fn max_buf_size(mut self, max: usize) -> Self {
    assert!(
        max >= MINIMUM_MAX_BUFFER_SIZE,
        "the max_buf_size cannot be smaller than the minimum that h1 specifies."
    );

    self.opts.h1_max_buf_size = Some(max);
    self.opts.h1_read_buf_exact_size = None;
    self
}
```

```rust
#[inline]
pub fn allow_spaces_after_header_name_in_responses(mut self, enabled: bool) -> Self {
    self.opts.allow_spaces_after_header_name_in_responses = enabled;
    self
}
```

```rust
#[inline]
pub fn ignore_invalid_headers_in_responses(mut self, enabled: bool) -> Self {
    self.opts.ignore_invalid_headers_in_responses = enabled;
    self
}
```

```rust
#[inline]
pub fn allow_obsolete_multiline_headers_in_responses(mut self, value: bool) -> Self {
    self.opts.allow_obsolete_multiline_headers_in_responses = value;
    self
}
```

```rust
#[inline]
pub fn build(self) -> Http1Options {
    self.opts
}
```

--------------------------------

### Checking Result State

Source: https://docs.rs/wreq-proto/0.2.6/wreq_proto/type.Result.html?search=std%3A%3Avec

Examples of using is_ok, is_ok_and, and is_err to inspect the state of a Result.

```rust
let x: Result<i32, &str> = Ok(-3);
assert_eq!(x.is_ok(), true);

let x: Result<i32, &str> = Err("Some error message");
assert_eq!(x.is_ok(), false);
```

```rust
let x: Result<u32, &str> = Ok(2);
assert_eq!(x.is_ok_and(|x| x > 1), true);

let x: Result<u32, &str> = Ok(0);
assert_eq!(x.is_ok_and(|x| x > 1), false);

let x: Result<u32, &str> = Err("hey");
assert_eq!(x.is_ok_and(|x| x > 1), false);

let x: Result<String, &str> = Ok("ownership".to_string());
assert_eq!(x.as_ref().is_ok_and(|x| x.len() > 1), true);
println!("still alive {:?}", x);
```

```rust
let x: Result<i32, &str> = Ok(-3);
assert_eq!(x.is_err(), false);

let x: Result<i32, &str> = Err("Some error message");
assert_eq!(x.is_err(), true);
```

--------------------------------

### Configure HTTP/2 Flow Control and Stream Settings

Source: https://docs.rs/wreq-proto/0.2.6/src/wreq_proto/proto/http2.rs.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Methods for setting initial window sizes, stream limits, and adaptive flow control configurations.

```rust
    #[inline]
    pub fn initial_window_size(mut self, sz: impl Into<Option<u32>>) -> Self {
        if let Some(sz) = sz.into() {
            self.opts.adaptive_window = false;
            self.opts.initial_window_size = sz;
        }
        self
    }
```

```rust
    #[inline]
    pub fn initial_connection_window_size(mut self, sz: impl Into<Option<u32>>) -> Self {
        if let Some(sz) = sz.into() {
            self.opts.adaptive_window = false;
            self.opts.initial_conn_window_size = sz;
        }
        self
    }
```

```rust
    #[inline]
    pub fn initial_max_send_streams(mut self, initial: impl Into<Option<usize>>) -> Self {
        if let Some(initial) = initial.into() {
            self.opts.initial_max_send_streams = initial;
        }
        self
    }
```

```rust
    #[inline]
    pub fn initial_stream_id(mut self, id: impl Into<Option<u32>>) -> Self {
        if let Some(id) = id.into() {
            self.opts.initial_stream_id = Some(id);
        }
        self
    }
```

```rust
    #[inline]
    pub fn adaptive_window(mut self, enabled: bool) -> Self {
        self.opts.adaptive_window = enabled;
        if enabled {
            self.opts.initial_window_size = SPEC_WINDOW_SIZE;
            self.opts.initial_conn_window_size = SPEC_WINDOW_SIZE;
        }
        self
    }
```

```rust
    #[inline]
    pub fn max_frame_size(mut self, sz: impl Into<Option<u32>>) -> Self {
        if let Some(sz) = sz.into() {
            self.opts.max_frame_size = Some(sz);
        }
        self
    }
```

```rust
    #[inline]
    pub fn max_header_list_size(mut self, max: u32) -> Self {
        self.opts.max_header_list_size = Some(max);
        self
    }
```

```rust
    #[inline]
    pub fn header_table_size(mut self, size: impl Into<Option<u32>>) -> Self {
        if let Some(size) = size.into() {
            self.opts.header_table_size = Some(size);
        }
        self
    }
```

--------------------------------

### Flattening Nested Results

Source: https://docs.rs/wreq-proto/0.2.6/wreq_proto/type.Result.html?search=std%3A%3Avec

Examples of using flatten to reduce nesting levels in Result types.

```rust
let x: Result<Result<&'static str, u32>, u32> = Ok(Ok("hello"));
assert_eq!(Ok("hello"), x.flatten());

let x: Result<Result<&'static str, u32>, u32> = Ok(Err(6));
assert_eq!(Err(6), x.flatten());

let x: Result<Result<&'static str, u32>, u32> = Err(6);
assert_eq!(Err(6), x.flatten());
```

```rust
let x: Result<Result<Result<&'static str, u32>, u32>, u32> = Ok(Ok(Ok("hello")));
assert_eq!(Ok(Ok("hello")), x.flatten());
assert_eq!(Ok("hello"), x.flatten().flatten());
```

--------------------------------

### HTTP/2 Client Handshake Initialization

Source: https://docs.rs/wreq-proto/0.2.6/src/wreq_proto/conn/http2.rs.html

Configures connection options and performs the HTTP/2 handshake to establish a client connection.

```rust
        if let Some(order) = self.opts.headers_pseudo_order {
            builder.headers_pseudo_order(order);
        }
        if let Some(priority) = self.opts.priorities {
            builder.priorities(priority);
        }

        // Create the ping configuration for the connection.
        let ping_config = ping::Config::new(
            self.opts.adaptive_window,
            self.opts.initial_window_size,
            self.opts.keep_alive_interval,
            self.opts.keep_alive_timeout,
            self.opts.keep_alive_while_idle,
        );

        let (tx, rx) = dispatch::channel();
        let h2 =
            proto::http2::client::handshake(io, rx, builder, ping_config, self.exec, self.timer)
                .await?;
        Ok((
            SendRequest {
                dispatch: tx.unbound(),
            },
            Connection {
                inner: (PhantomData, h2),
            },
        ))
    }
}
```

--------------------------------

### Get Result references with as_ref

Source: https://docs.rs/wreq-proto/0.2.6/wreq_proto/type.Result.html?search=std%3A%3Avec

Creates a new Result containing references to the original values.

```rust
let x: Result<u32, &str> = Ok(2);
assert_eq!(x.as_ref(), Ok(&2));

let x: Result<u32, &str> = Err("Error");
assert_eq!(x.as_ref(), Err(&"Error"));
```

--------------------------------

### Cloning Result Contents

Source: https://docs.rs/wreq-proto/0.2.6/wreq_proto/type.Result.html?search=std%3A%3Avec

Examples of using the cloned method to convert Result<&T, E> to Result<T, E>.

```rust
let val = 12;
let x: Result<&i32, i32> = Ok(&val);
assert_eq!(x, Ok(&12));
let cloned = x.cloned();
assert_eq!(cloned, Ok(12));
```

```rust
let mut val = 12;
let x: Result<&mut i32, i32> = Ok(&mut val);
assert_eq!(x, Ok(&mut 12));
let cloned = x.cloned();
assert_eq!(cloned, Ok(12));
```

--------------------------------

### Initialize HTTP/1 Options Builder

Source: https://docs.rs/wreq-proto/0.2.6/src/wreq_proto/proto/http1.rs.html

Creates a new builder instance for configuring HTTP/1 options.

```rust
impl Http1Options {
    /// Create a new [`Http1OptionsBuilder`].
    pub fn builder() -> Http1OptionsBuilder {
        Http1OptionsBuilder {
            opts: Http1Options::default(),
        }
    }
}
```

--------------------------------

### Create a SettingsOrderBuilder

Source: https://docs.rs/wreq-proto/0.2.6/wreq_proto/http2/struct.SettingsOrder.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Method to initialize a new builder for constructing a SettingsOrder instance.

```rust
pub fn builder() -> SettingsOrderBuilder
```

--------------------------------

### Copying Result Contents

Source: https://docs.rs/wreq-proto/0.2.6/wreq_proto/type.Result.html?search=std%3A%3Avec

Examples of using the copied method to convert Result<&T, E> to Result<T, E>.

```rust
let val = 12;
let x: Result<&i32, i32> = Ok(&val);
assert_eq!(x, Ok(&12));
let copied = x.copied();
assert_eq!(copied, Ok(12));
```

```rust
let mut val = 12;
let x: Result<&mut i32, i32> = Ok(&mut val);
assert_eq!(x, Ok(&mut 12));
let copied = x.copied();
assert_eq!(copied, Ok(12));
```

--------------------------------

### build()

Source: https://docs.rs/wreq-proto/0.2.6/src/wreq_proto/proto/http2.rs.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Finalizes the configuration and returns the Http2Options instance.

```APIDOC
## build()

### Description
Consumes the builder and returns the configured Http2Options instance.

### Returns
- **Http2Options** - The resulting configuration object.
```

--------------------------------

### Chunked Extensions Limit Test

Source: https://docs.rs/wreq-proto/0.2.6/src/wreq_proto/proto/http1/decode.rs.html?search=

Setup for testing that combined chunked extensions do not exceed the defined limit.

```rust
#[tokio::test]
async fn test_read_chunked_extensions_over_limit() {
    // construct a chunked body where each individual chunked extension
    // is totally fine, but combined is over the limit.
    let per_chunk = super::CHUNKED_EXTENSIONS_LIMIT * 2 / 3;
    let mut scratch = vec![];
    for _ in 0..2 {
        scratch.extend(b"1;");
        scratch.extend(b"x".repeat(per_chunk as usize));
```

--------------------------------

### Prepare HTTP/1 Connection Upgrade

Source: https://docs.rs/wreq-proto/0.2.6/src/wreq_proto/proto/http1/conn.rs.html?search=std%3A%3Avec

Initializes an upgrade channel and returns the receiver for handling protocol upgrades.

```rust
    #[inline]
    fn prepare_upgrade(&mut self) -> upgrade::OnUpgrade {
        let (tx, rx) = upgrade::pending();
        self.upgrade = Some(tx);
        rx
    }
```

--------------------------------

### IntoIterator Implementation Examples

Source: https://docs.rs/wreq-proto/0.2.6/wreq_proto/type.Result.html?search=std%3A%3Avec

Demonstrates converting a Result into an iterator that yields the contained value if it is Ok, or nothing if it is Err.

```rust
let x: Result<u32, &str> = Ok(5);
let v: Vec<u32> = x.into_iter().collect();
assert_eq!(v, [5]);

let x: Result<u32, &str> = Err("nothing!");
let v: Vec<u32> = x.into_iter().collect();
assert_eq!(v, []);
```

--------------------------------

### Unwrap Unchecked Examples

Source: https://docs.rs/wreq-proto/0.2.6/wreq_proto/type.Result.html?search=std%3A%3Avec

Demonstrates the use of unwrap_unchecked, which skips safety checks. Calling this on an Err variant results in undefined behavior.

```rust
let x: Result<u32, &str> = Ok(2);
assert_eq!(unsafe { x.unwrap_unchecked() }, 2);
```

```rust
let x: Result<u32, &str> = Err("emergency failure");
unsafe { x.unwrap_unchecked() }; // Undefined behavior!
```

--------------------------------

### Initialize Http2OptionsBuilder

Source: https://docs.rs/wreq-proto/0.2.6/src/wreq_proto/proto/http2.rs.html?search=std%3A%3Avec

Creates a new builder instance with default settings, resetting frame and header size constraints to None.

```rust
pub fn builder() -> Http2OptionsBuilder {
        // Reset optional frame size and header size settings to None to allow explicit
        // customization This ensures users can configure these via builder methods without
        // being constrained by defaults
        Http2OptionsBuilder {
            opts: Http2Options {
                max_frame_size: None,
                max_header_list_size: None,
                ..Default::default()
            },
        }
    }
```

--------------------------------

### Unwrap Err Unchecked Examples

Source: https://docs.rs/wreq-proto/0.2.6/wreq_proto/type.Result.html?search=std%3A%3Avec

Demonstrates the use of unwrap_err_unchecked, which skips safety checks. Calling this on an Ok variant results in undefined behavior.

```rust
let x: Result<u32, &str> = Ok(2);
unsafe { x.unwrap_err_unchecked() }; // Undefined behavior!
```

```rust
let x: Result<u32, &str> = Err("emergency failure");
assert_eq!(unsafe { x.unwrap_err_unchecked() }, "emergency failure");
```

--------------------------------

### Configure HTTP/2 Frame and Header Settings

Source: https://docs.rs/wreq-proto/0.2.6/src/wreq_proto/proto/http2.rs.html?search=

Methods for setting maximum frame sizes, header list sizes, and header table compression sizes.

```rust
#[inline]
    pub fn max_frame_size(mut self, sz: impl Into<Option<u32>>) -> Self {
        if let Some(sz) = sz.into() {
            self.opts.max_frame_size = Some(sz);
        }
        self
    }
```

```rust
#[inline]
    pub fn max_header_list_size(mut self, max: u32) -> Self {
        self.opts.max_header_list_size = Some(max);
        self
    }
```

```rust
#[inline]
    pub fn header_table_size(mut self, size: impl Into<Option<u32>>) -> Self {
        if let Some(size) = size.into() {
            self.opts.header_table_size = Some(size);
        }
        self
    }
```

--------------------------------

### Create new Builder

Source: https://docs.rs/wreq-proto/0.2.6/wreq_proto/conn/http2/struct.Builder.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Initializes a new connection builder with the provided executor.

```rust
pub fn new(exec: Ex) -> Builder<Ex>
```

--------------------------------

### HTTP/2 Configuration Structures

Source: https://docs.rs/wreq-proto/0.2.6/src/wreq_proto/proto/http2.rs.html?search=std%3A%3Avec

Builder and configuration structs for tuning HTTP/2 connection parameters.

```rust
/// Builder for `Http2Options`.
463#[must_use]
464#[derive(Debug)]
465pub struct Http2OptionsBuilder {
466    opts: Http2Options,
467}
468
469/// Options for tuning HTTP/2 connections.
470///
471/// `Http2Options` lets you adjust how HTTP/2 works—stream limits, window sizes, frame and header
472/// settings, and more. Most fields are optional and have sensible defaults. See each field for
473/// details.
474#[non_exhaustive]
475#[derive(Debug, Clone)]
476pub struct Http2Options {
477    /// Whether to use adaptive flow control.
478    pub adaptive_window: bool,
479
480    /// The initial stream ID for the connection.
481    pub initial_stream_id: Option<u32>,
482
483    /// The initial window size for HTTP/2 connection-level flow control.
484    pub initial_conn_window_size: u32,
485
486    /// The initial window size for HTTP/2 streams.
487    pub initial_window_size: u32,
488
489    /// The initial maximum number of locally initiated (send) streams.
490    pub initial_max_send_streams: usize,
491
492    /// The maximum frame size to use for HTTP/2.
493    pub max_frame_size: Option<u32>,
494
495    /// The interval for HTTP/2 keep-alive ping frames.
496    pub keep_alive_interval: Option<Duration>,
497
498    /// The timeout for receiving an acknowledgement of the keep-alive ping.
499    pub keep_alive_timeout: Duration,
500
501    /// Whether HTTP/2 keep-alive should apply while the connection is idle.
502    pub keep_alive_while_idle: bool,
503
504    /// The maximum number of concurrent locally reset streams.
505    pub max_concurrent_reset_streams: Option<usize>,
506
507    /// The maximum size of the send buffer for HTTP/2 streams.
508    pub max_send_buffer_size: usize,
509
510    /// The maximum number of concurrent streams initiated by the remote peer.
511    pub max_concurrent_streams: Option<u32>,
512
513    /// The maximum size of the header list.
514    pub max_header_list_size: Option<u32>,
515
516    /// The maximum number of pending accept reset streams.
517    pub max_pending_accept_reset_streams: Option<usize>,
518
519    /// Whether to enable push promises.
520    pub enable_push: Option<bool>,
521
522    /// The header table size for HPACK compression.
523    pub header_table_size: Option<u32>,
524
525    /// Whether to enable the CONNECT protocol.
526    pub enable_connect_protocol: Option<bool>,
527
528    /// Whether to disable RFC 7540 Stream Priorities.
529    pub no_rfc7540_priorities: Option<bool>,
530
531    /// The HTTP/2 pseudo-header field order for outgoing HEADERS frames.
532    pub headers_pseudo_order: Option<PseudoOrder>,
```

--------------------------------

### Configure Builder options

Source: https://docs.rs/wreq-proto/0.2.6/wreq_proto/conn/http2/struct.Builder.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Sets the HTTP/2 configuration options for the connection.

```rust
pub fn options(self, opts: Http2Options) -> Self
```

--------------------------------

### Builder Handshake and Configuration

Source: https://docs.rs/wreq-proto/0.2.6/src/wreq_proto/conn/http1.rs.html?search=std%3A%3Avec

Methods for configuring HTTP/1 options and performing the connection handshake.

```rust
impl Builder {
    /// Provide a options configuration for the HTTP/1 connection.
    #[inline
    pub fn options(mut self, opts: Http1Options) -> Self {
        self.opts = opts;
        self
    }

    /// Constructs a connection with the configured options and IO.
    ///
    /// Note, if [`Connection`] is not `await`-ed, [`SendRequest`] will
    /// do nothing.
    pub async fn handshake<T, B>(self, io: T) -> Result<(SendRequest<B>, Connection<T, B>)>
    where
        T: AsyncRead + AsyncWrite + Unpin,
        B: Body + 'static,
        B::Data: Send,
        B::Error: Into<BoxError>,
    {
        trace!("client handshake HTTP/1");

        let (tx, rx) = dispatch::channel();
        let mut conn = Conn::new(io);

        // Set the HTTP/1 parser configuration
        let h1_parser_config = {
            let mut h1_parser_config = ParserConfig::default();
            h1_parser_config
                .ignore_invalid_headers_in_responses(self.opts.ignore_invalid_headers_in_responses)
                .allow_spaces_after_header_name_in_responses(
                    self.opts.allow_spaces_after_header_name_in_responses,
                )
                .allow_obsolete_multiline_headers_in_responses(
                    self.opts.allow_obsolete_multiline_headers_in_responses,
                );
            h1_parser_config
        };
        conn.set_h1_parser_config(h1_parser_config);

        // Set the h1 write strategy
        if let Some(writev) = self.opts.h1_writev {
            if writev {
                conn.set_write_strategy_queue();
```

--------------------------------

### Builder Interface

Source: https://docs.rs/wreq-proto/0.2.6/src/wreq_proto/conn/http2.rs.html?search=

Methods for configuring and initiating an HTTP/2 client connection.

```APIDOC
## Builder::new

### Description
Creates a new connection builder instance.

### Signature
`pub fn new(exec: Ex) -> Builder<Ex>`

## Builder::timer

### Description
Configures a timer to execute background HTTP/2 tasks.

### Signature
`pub fn timer<M>(mut self, timer: M) -> Self`

## Builder::options

### Description
Sets the configuration options for the HTTP/2 connection.

### Signature
`pub fn options(mut self, opts: Http2Options) -> Self`

## Builder::handshake

### Description
Constructs a connection with the configured options and IO, returning a SendRequest and the Connection.

### Signature
`pub async fn handshake<T, B>(self, io: T) -> Result<(SendRequest<B>, Connection<T, B, Ex>)>`
```

--------------------------------

### Builder::options

Source: https://docs.rs/wreq-proto/0.2.6/wreq_proto/conn/http2/struct.Builder.html?search=

Configures HTTP/2 connection options.

```APIDOC
## pub fn options(self, opts: Http2Options) -> Self

### Description
Provides an options configuration for the HTTP/2 connection.

### Parameters
- **opts** (Http2Options) - Required - The configuration options.
```

--------------------------------

### Builder::options

Source: https://docs.rs/wreq-proto/0.2.6/src/wreq_proto/conn/http1.rs.html?search=u32+-%3E+bool

Configures the HTTP/1 connection options.

```APIDOC
## pub fn options(mut self, opts: Http1Options) -> Self

### Description
Provide a options configuration for the HTTP/1 connection.
```

--------------------------------

### Dispatcher Implementation Methods

Source: https://docs.rs/wreq-proto/0.2.6/src/wreq_proto/proto/http1/dispatch.rs.html?search=std%3A%3Avec

Core methods for initializing the dispatcher and polling the connection state.

```rust
impl<D, Bs, I, T> Dispatcher<D, Bs, I, T>
where
    D: Dispatch<
            PollItem = MessageHead<T::Outgoing>,
            PollBody = Bs,
            RecvItem = MessageHead<T::Incoming>,
        > + Unpin,
    D::PollError: Into<BoxError>,
    I: AsyncRead + AsyncWrite + Unpin,
    T: Http1Transaction + Unpin,
    Bs: Body + 'static,
    Bs::Error: Into<BoxError>,
{
    #[inline]
    pub(crate) fn new(dispatch: D, conn: Conn<I, Bs::Data, T>) -> Self {
        Dispatcher {
            conn,
            dispatch,
            body_tx: SenderGuard(None),
            body_rx: Box::pin(None),
            is_closing: false,
        }
    }

    #[inline]
    pub(crate) fn into_inner(self) -> (I, Bytes, D) {
        let (io, buf) = self.conn.into_inner();
        (io, buf, self.dispatch)
    }

    /// Run this dispatcher until HTTP says this connection is done,
    /// but don't call `Write::shutdown` on the underlying IO.
    ///
    /// This is useful for old-style HTTP upgrades, but ignores
    /// newer-style upgrade API.
    pub(crate) fn poll_without_shutdown(
        &mut self,
        cx: &mut Context<'_>,
    ) -> Poll<crate::Result<()>> {
        Pin::new(self).poll_catch(cx, false).map_ok(|ds| {
            if let Dispatched::Upgrade(pending) = ds {
                pending.manual();
            }
        })
    }

    fn poll_catch(
        &mut self,
        cx: &mut Context<'_>,
        should_shutdown: bool,
    ) -> Poll<Result<Dispatched>> {
        Poll::Ready(ready!(self.poll_inner(cx, should_shutdown)).or_else(|e| {
            // Be sure to alert a streaming body of the failure.
            if let Some(mut body) = self.body_tx.take() {
                body.send_error(Error::new_body("connection error"))
            }
            // An error means we're shutting down either way.
            // We just try to give the error to the user,
            // and close the connection with an Ok. If we
            // cannot give it to the user, then return the Err.
            self.dispatch.recv_msg(Err(e))?;
            Ok(Dispatched::Shutdown)
        }))
    }

    fn poll_inner(
        &mut self,
        cx: &mut Context<'_>,
        should_shutdown: bool,
    ) -> Poll<Result<Dispatched>> {
        T::update_date();

        ready!(self.poll_loop(cx))?;

        if self.is_done() {
            if let Some(pending) = self.conn.pending_upgrade() {
                self.conn.take_error()?;
                return Poll::Ready(Ok(Dispatched::Upgrade(pending)));
            } else if should_shutdown {
                ready!(self.conn.poll_shutdown(cx)).map_err(Error::new_shutdown)?;
            }
            self.conn.take_error()?;
            Poll::Ready(Ok(Dispatched::Shutdown))
        } else {
            Poll::Pending
        }
    }

    fn poll_loop(&mut self, cx: &mut Context<'_>) -> Poll<Result<()>> {
        // Limit the looping on this connection, in case it is ready far too
        // often, so that other futures don't starve.
```

--------------------------------

### Builder::new

Source: https://docs.rs/wreq-proto/0.2.6/wreq_proto/conn/http2/struct.Builder.html?search=

Creates a new instance of the connection builder.

```APIDOC
## pub fn new(exec: Ex) -> Builder<Ex>

### Description
Creates a new connection builder using the provided executor.

### Parameters
- **exec** (Ex) - Required - The executor used for background tasks.
```

--------------------------------

### Connection Implementation Methods

Source: https://docs.rs/wreq-proto/0.2.6/wreq_proto/conn/http1/struct.Connection.html?search=u32+-%3E+bool

Methods for managing connection lifecycle, including parts extraction, upgrades, and non-shutdown polling.

```rust
pub fn into_parts(self) -> Parts<T>
```

```rust
pub fn with_upgrades(self) -> UpgradeableConnection<T, B>
```

```rust
pub fn poll_without_shutdown( &mut self, cx: &mut Context<'_>, ) -> Poll<Result<()>>
```

```rust
pub async fn without_shutdown(self) -> Result<Parts<T>>
```

--------------------------------

### Configure HTTP/1 Header and Buffer Options

Source: https://docs.rs/wreq-proto/0.2.6/x86_64-unknown-linux-gnu/src/wreq_proto/proto/http1.rs.html

Methods for setting header limits and buffer sizes. Note that setting max_headers to a custom value forces heap allocation, and buffer size methods are mutually exclusive.

```rust
#[inline]
pub fn max_headers(mut self, max_headers: usize) -> Self {
    self.opts.h1_max_headers = Some(max_headers);
    self
}
```

```rust
#[inline]
pub fn read_buf_exact_size(mut self, sz: Option<usize>) -> Self {
    self.opts.h1_read_buf_exact_size = sz;
    self.opts.h1_max_buf_size = None;
    self
}
```

```rust
#[inline]
pub fn max_buf_size(mut self, max: usize) -> Self {
    assert!(
        max >= MINIMUM_MAX_BUFFER_SIZE,
        "the max_buf_size cannot be smaller than the minimum that h1 specifies."
    );

    self.opts.h1_max_buf_size = Some(max);
    self.opts.h1_read_buf_exact_size = None;
    self
}
```

--------------------------------

### Configure HTTP/1 Connection Parameters

Source: https://docs.rs/wreq-proto/0.2.6/src/wreq_proto/conn/http1.rs.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Sets various HTTP/1 connection options including header limits, buffer sizes, and HTTP/0.9 support before initializing the dispatcher.

```rust
        } else {
                conn.set_write_strategy_flatten();
            }
        }

        // Set the maximum size of the request headers
        if let Some(max_headers) = self.opts.h1_max_headers {
            conn.set_http1_max_headers(max_headers);
        }

        // Enable HTTP/0.9 responses if requested
        if self.opts.h09_responses {
            conn.set_h09_responses();
        }

        // Set the read buffer size if specified
        if let Some(sz) = self.opts.h1_read_buf_exact_size {
            conn.set_read_buf_exact_size(sz);
        }

        // Set the maximum buffer size for HTTP/1 connections
        if let Some(max) = self.opts.h1_max_buf_size {
            conn.set_max_buf_size(max);
        }

        let cd = http1::dispatch::Client::new(rx);
        let proto = http1::dispatch::Dispatcher::new(cd, conn);

        Ok((SendRequest { dispatch: tx }, Connection { inner: proto }))
    }
}
```

--------------------------------

### is_ready

Source: https://docs.rs/wreq-proto/0.2.6/wreq_proto/conn/http1/struct.SendRequest.html?search=

Checks if the connection is currently ready to send a request. Note that this is a hint and sending may still fail due to network latency.

```APIDOC
### pub fn is_ready(&self) -> bool

Checks if the connection is currently ready to send a request.
```

--------------------------------

### Builder::options

Source: https://docs.rs/wreq-proto/0.2.6/wreq_proto/conn/http2/struct.Builder.html?search=u32+-%3E+bool

Sets the configuration options for the HTTP/2 connection.

```APIDOC
## pub fn options(self, opts: Http2Options) -> Self

### Description
Configures the HTTP/2 connection with the provided options.

### Parameters
- **opts** (Http2Options) - Required - The configuration options for the connection.
```

--------------------------------

### Configure HTTP/1 Connection Options

Source: https://docs.rs/wreq-proto/0.2.6/src/wreq_proto/proto/http1.rs.html

Http1Options allows customization of HTTP/1 connection behavior, such as header limits and buffer sizes. Use the builder pattern to construct these options.

```rust
#[non_exhaustive]
#[derive(Debug, Default, Clone)]
pub struct Http1Options {
    /// Enable support for HTTP/0.9 responses.
    pub h09_responses: bool,

    /// Whether to use vectored writes for HTTP/1 connections.
    pub h1_writev: Option<bool>,

    /// Maximum number of headers allowed in HTTP/1 responses.
    pub h1_max_headers: Option<usize>,

    /// Exact size of the read buffer to use for HTTP/1 connections.
    pub h1_read_buf_exact_size: Option<usize>,

    /// Maximum buffer size for HTTP/1 connections.
    pub h1_max_buf_size: Option<usize>,

    /// Whether to ignore invalid headers in HTTP/1 responses.
    pub ignore_invalid_headers_in_responses: bool,

    /// Whether to allow spaces after header names in HTTP/1 responses.
    pub allow_spaces_after_header_name_in_responses: bool,

    /// Whether to allow obsolete multiline headers in HTTP/1 responses.
    pub allow_obsolete_multiline_headers_in_responses: bool,
}
```

```rust
impl Http1OptionsBuilder {
    /// Set the `http09_responses` field.
    #[inline]
    pub fn http09_responses(mut self, enabled: bool) -> Self {
        self.opts.h09_responses = enabled;
        self
    }

    /// Set whether HTTP/1 connections should try to use vectored writes,
    /// or always flatten into a single buffer.
    ///
    /// Note that setting this to false may mean more copies of body data,
    /// but may also improve performance when an IO transport doesn't
    /// support vectored writes well, such as most TLS implementations.
    ///
    /// Setting this to true will force crate::core: to use queued strategy
    /// which may eliminate unnecessary cloning on some TLS backends
    ///
    /// Default is `auto`. In this mode crate::core: will try to guess which
    /// mode to use
    #[inline]
    pub fn writev(mut self, writev: Option<bool>) -> Self {
        self.opts.h1_writev = writev;
        self
    }

    /// Set the maximum number of headers.
    ///

```

--------------------------------

### options

Source: https://docs.rs/wreq-proto/0.2.6/wreq_proto/conn/http1/struct.Builder.html

Configures the HTTP/1 connection with the provided options.

```APIDOC
## pub fn options(self, opts: Http1Options) -> Self

### Description
Configures the HTTP/1 connection using the provided `Http1Options`.

### Parameters
- **opts** (Http1Options) - Required - The configuration options for the HTTP/1 connection.
```

--------------------------------

### is_ready

Source: https://docs.rs/wreq-proto/0.2.6/wreq_proto/conn/http1/struct.SendRequest.html

Checks if the connection is currently ready to send a request.

```APIDOC
## pub fn is_ready(&self) -> bool

### Description
Checks if the connection is currently ready to send a request. Note: This is a hint and sending may still fail due to network latency or connection closure.
```

--------------------------------

### Builder::handshake

Source: https://docs.rs/wreq-proto/0.2.6/src/wreq_proto/conn/http1.rs.html?search=u32+-%3E+bool

Constructs a connection with the configured options and IO.

```APIDOC
## pub async fn handshake<T, B>(self, io: T) -> Result<(SendRequest<B>, Connection<T, B>)>

### Description
Constructs a connection with the configured options and IO. Note, if `Connection` is not `await`-ed, `SendRequest` will do nothing.
```

--------------------------------

### Request Dispatching and Readiness

Source: https://docs.rs/wreq-proto/0.2.6/src/wreq_proto/conn/http1.rs.html?search=u32+-%3E+bool

Methods for checking connection readiness and sending requests over an established connection.

```rust
impl<B> SendRequest<B> {
    /// Polls to determine whether this sender can be used yet for a request.
    ///
    /// If the associated connection is closed, this returns an Error.
    #[inline]
    pub fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll<Result<()>> {
        self.dispatch.poll_ready(cx)
    }

    /// Waits until the dispatcher is ready
    ///
    /// If the associated connection is closed, this returns an Error.
    #[inline]
    pub async fn ready(&mut self) -> Result<()> {
        std::future::poll_fn(|cx| self.poll_ready(cx)).await
    }

    /// Checks if the connection is currently ready to send a request.
    ///
    /// # Note
    ///
    /// This is mostly a hint. Due to inherent latency of networks, it is
    /// possible that even after checking this is ready, sending a request
    /// may still fail because the connection was closed in the meantime.
    #[inline]
    pub fn is_ready(&self) -> bool {
        self.dispatch.is_ready()
    }
}
```

```rust
impl<B> SendRequest<B>
where
    B: Body + 'static,
{
    /// Sends a `Request` on the associated connection.
    ///
    /// Returns a future that if successful, yields the `Response`.
    ///
    /// # Error
    ///
    /// If there was an error before trying to serialize the request to the
    /// connection, the message will be returned as part of this error.
    pub fn try_send_request(
        &mut self,
        req: Request<B>,
    ) -> impl Future<Output = Result<Response<Incoming>, TrySendError<Request<B>>>> {
        let sent = self.dispatch.try_send(req);
        async move {
            match sent {
                Ok(rx) => match rx.await {
                    Ok(res) => res,
                    // this is definite bug if it happens, but it shouldn't happen!
                    Err(_) => panic!("dispatch dropped without returning error"),
                },
                Err(req) => {
```

--------------------------------

### SendRequest readiness methods

Source: https://docs.rs/wreq-proto/0.2.6/wreq_proto/conn/http1/struct.SendRequest.html?search=std%3A%3Avec

Methods to check or wait for the connection readiness before sending requests.

```rust
pub fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll<Result<()>>
```

```rust
pub async fn ready(&mut self) -> Result<()>
```

```rust
pub fn is_ready(&self) -> bool
```

--------------------------------

### Configure HTTP/2 Builder Options

Source: https://docs.rs/wreq-proto/0.2.6/src/wreq_proto/proto/http2.rs.html?search=std%3A%3Avec

Methods for setting stream dependencies, pseudo-header order, settings order, and priority frames on the Http2OptionsBuilder.

```rust
pub fn headers_stream_dependency<T>(mut self, stream_dependency: T) -> Self
    where
        T: Into<Option<StreamDependency>>,
    {
        if let Some(stream_dependency) = stream_dependency.into() {
            self.opts.headers_stream_dependency = Some(stream_dependency);
        }
        self
    }

    /// Sets the HTTP/2 pseudo-header field order for outgoing HEADERS frames.
    ///
    /// This determines the order in which pseudo-header fields (such as `:method`, `:scheme`, etc.)
    /// are encoded in the HEADERS frame. Customizing the order may be useful for interoperability
    /// or testing purposes.
    #[inline]
    pub fn headers_pseudo_order<T>(mut self, headers_pseudo_order: T) -> Self
    where
        T: Into<Option<PseudoOrder>>,
    {
        if let Some(headers_pseudo_order) = headers_pseudo_order.into() {
            self.opts.headers_pseudo_order = Some(headers_pseudo_order);
        }
        self
    }

    /// Sets the order of settings parameters in the initial SETTINGS frame.
    ///
    /// This determines the order in which settings are sent during the HTTP/2 handshake.
    /// Customizing the order may be useful for testing or protocol compliance.
    #[inline]
    pub fn settings_order<T>(mut self, settings_order: T) -> Self
    where
        T: Into<Option<SettingsOrder>>,
    {
        if let Some(settings_order) = settings_order.into() {
            self.opts.settings_order = Some(settings_order);
        }
        self
    }

    /// Sets the list of PRIORITY frames to be sent immediately after the connection is established,
    /// but before the first request is sent.
    ///
    /// This allows you to pre-configure the HTTP/2 stream dependency tree by specifying a set of
    /// PRIORITY frames that will be sent as part of the connection preface. This can be useful for
    /// optimizing resource allocation or testing custom stream prioritization strategies.
    ///
    /// Each `Priority` in the list must have a valid (non-zero) stream ID. Any priority with a
    /// stream ID of zero will be ignored.
    #[inline]
    pub fn priorities<T>(mut self, priorities: T) -> Self
    where
        T: Into<Option<Priorities>>,
    {
        if let Some(priorities) = priorities.into() {
            self.opts.priorities = Some(priorities);
        }
        self
    }

    /// Builds the `Http2Options` instance.
    #[inline]
    pub fn build(self) -> Http2Options {
        self.opts
    }
```

--------------------------------

### Create a New Setting

Source: https://docs.rs/wreq-proto/0.2.6/wreq_proto/http2/struct.Setting.html

Creates a new Setting instance using a setting ID and a 32-bit unsigned integer value.

```rust
pub fn from_id(id: impl Into<SettingId>, value: u32) -> Option<Setting>
```

--------------------------------

### Configure HTTP/2 Stream and Connection Settings

Source: https://docs.rs/wreq-proto/0.2.6/src/wreq_proto/proto/http2.rs.html?search=std%3A%3Avec

Methods for managing HTTP/2 stream concurrency, keep-alive intervals, and connection timeouts.

```rust
#[inline]
pub fn max_concurrent_streams(mut self, max: impl Into<Option<u32>>) -> Self {
    if let Some(max) = max.into() {
        self.opts.max_concurrent_streams = Some(max);
    }
    self
}
```

```rust
#[inline]
pub fn keep_alive_interval(mut self, interval: impl Into<Option<Duration>>) -> Self {
    self.opts.keep_alive_interval = interval.into();
    self
}
```

```rust
#[inline]
pub fn keep_alive_timeout(mut self, timeout: Duration) -> Self {
    self.opts.keep_alive_timeout = timeout;
    self
}
```

```rust
#[inline]
pub fn keep_alive_while_idle(mut self, enabled: bool) -> Self {
    self.opts.keep_alive_while_idle = enabled;
    self
}
```

--------------------------------

### Write Buffer Queue Strategy

Source: https://docs.rs/wreq-proto/0.2.6/src/wreq_proto/proto/http1/io.rs.html?search=

Demonstrates the Queue strategy for write buffers, which maintains multiple buffers instead of flattening them.

```rust
    #[tokio::test]
    async fn write_buf_queue_disable_auto() {
        let _ = pretty_env_logger::try_init();

        let mock = Mock::new()
            .write(b"hello ")
            .write(b"world, ")
            .write(b"it's ")
            .write(b"crate::core:!")
            .build();

        let mut buffered = Buffered::<_, Cursor<Vec<u8>>>::new(mock);
        buffered.write_buf.set_strategy(WriteStrategy::Queue);

        // we have 4 buffers, and vec IO disabled, but explicitly said
        // don't try to auto detect (via setting strategy above)

        buffered.headers_buf().extend(b"hello ");
        buffered.buffer(Cursor::new(b"world, ".to_vec()));
        buffered.buffer(Cursor::new(b"it's ".to_vec()));
        buffered.buffer(Cursor::new(b"crate::core:!".to_vec()));
        assert_eq!(buffered.write_buf.queue.bufs_cnt(), 3);

        buffered.flush().await.expect("flush");

        assert_eq!(buffered.write_buf.queue.bufs_cnt(), 0);
    }
```

--------------------------------

### TokioTimer::new

Source: https://docs.rs/wreq-rt/0.2.2-rc.4/wreq_rt/rt/tokio/struct.TokioTimer.html

Creates a new instance of the TokioTimer.

```APIDOC
## pub fn new() -> Self

### Description
Creates a new TokioTimer instance.

### Signature
`pub fn new() -> Self`
```

--------------------------------

### Connection Utility Methods

Source: https://docs.rs/wreq-proto/0.2.6/src/wreq_proto/proto/http1/conn.rs.html?search=std%3A%3Avec

Helper methods for closing read/write sides, retrieving errors, and preparing for HTTP upgrades.

```rust
#[inline]
    pub(super) fn close_read(&mut self) {
        self.state.close_read();
    }

    #[inline]
    pub(super) fn close_write(&mut self) {
        self.state.close_write();
    }

    pub(super) fn take_error(&mut self) -> Result<()> {
        if let Some(err) = self.state.error.take() {
            Err(err)
        } else {
            Ok(())
        }
    }

    #[inline]
    pub(super) fn on_upgrade(&mut self) -> upgrade::OnUpgrade {
        trace!("{}: prepare possible HTTP upgrade", T::LOG);
        self.state.prepare_upgrade()
    }
```

--------------------------------

### Incoming Stream Metadata Methods

Source: https://docs.rs/wreq-proto/0.2.6/src/wreq_proto/body/incoming.rs.html?search=std%3A%3Avec

Utility methods for checking stream status and size hints.

```rust
    #[inline]
    fn is_end_stream(&self) -> bool {
        match self.kind {
            Kind::H1 { content_length, .. } => content_length == DecodedLength::ZERO,
            Kind::H2 { recv: ref h2, .. } => h2.is_end_stream(),
            Kind::Empty => true,
        }
    }

    #[inline]
    fn size_hint(&self) -> SizeHint {
        match self.kind {
            Kind::H1 { content_length, .. } | Kind::H2 { content_length, .. } => content_length
                .into_opt()
                .map_or_else(SizeHint::default, SizeHint::with_exact),
            Kind::Empty => SizeHint::with_exact(0),
        }
    }
```
Tokens:
Raw