SYMBOL INDEX (1695 symbols across 77 files)

FILE: benches/end_to_end.rs
  type BoxedBody (line 17) | type BoxedBody = http_body_util::combinators::BoxBody<bytes::Bytes, Infa...
  function http1_consecutive_x1_empty (line 22) | fn http1_consecutive_x1_empty(b: &mut test::Bencher) {
  function http1_consecutive_x1_req_10b (line 27) | fn http1_consecutive_x1_req_10b(b: &mut test::Bencher) {
  function http1_consecutive_x1_both_100kb (line 35) | fn http1_consecutive_x1_both_100kb(b: &mut test::Bencher) {
  function http1_consecutive_x1_both_10mb (line 45) | fn http1_consecutive_x1_both_10mb(b: &mut test::Bencher) {
  function http1_parallel_x10_empty (line 56) | fn http1_parallel_x10_empty(b: &mut test::Bencher) {
  function http1_parallel_x10_req_10mb (line 62) | fn http1_parallel_x10_req_10mb(b: &mut test::Bencher) {
  function http1_parallel_x10_req_10kb_100_chunks (line 73) | fn http1_parallel_x10_req_10kb_100_chunks(b: &mut test::Bencher) {
  function http1_parallel_x10_res_1mb (line 84) | fn http1_parallel_x10_res_1mb(b: &mut test::Bencher) {
  function http1_parallel_x10_res_10mb (line 91) | fn http1_parallel_x10_res_10mb(b: &mut test::Bencher) {
  constant HTTP2_MAX_WINDOW (line 98) | const HTTP2_MAX_WINDOW: u32 = std::u32::MAX >> 1;
  function http2_consecutive_x1_empty (line 101) | fn http2_consecutive_x1_empty(b: &mut test::Bencher) {
  function http2_consecutive_x1_req_10b (line 106) | fn http2_consecutive_x1_req_10b(b: &mut test::Bencher) {
  function http2_consecutive_x1_req_100kb (line 115) | fn http2_consecutive_x1_req_100kb(b: &mut test::Bencher) {
  function http2_parallel_x10_empty (line 125) | fn http2_parallel_x10_empty(b: &mut test::Bencher) {
  function http2_parallel_x10_req_10mb (line 130) | fn http2_parallel_x10_req_10mb(b: &mut test::Bencher) {
  function http2_parallel_x10_req_10kb_100_chunks (line 143) | fn http2_parallel_x10_req_10kb_100_chunks(b: &mut test::Bencher) {
  function http2_parallel_x10_req_10kb_100_chunks_adaptive_window (line 154) | fn http2_parallel_x10_req_10kb_100_chunks_adaptive_window(b: &mut test::...
  function http2_parallel_x10_req_10kb_100_chunks_max_window (line 166) | fn http2_parallel_x10_req_10kb_100_chunks_max_window(b: &mut test::Bench...
  function http2_parallel_x10_res_1mb (line 179) | fn http2_parallel_x10_res_1mb(b: &mut test::Bencher) {
  function http2_parallel_x10_res_10mb (line 191) | fn http2_parallel_x10_res_10mb(b: &mut test::Bencher) {
  type Opts (line 205) | struct Opts {
    method http2 (line 232) | fn http2(mut self) -> Self {
    method http2_stream_window (line 237) | fn http2_stream_window(mut self, sz: impl Into<Option<u32>>) -> Self {
    method http2_conn_window (line 243) | fn http2_conn_window(mut self, sz: impl Into<Option<u32>>) -> Self {
    method http2_adaptive_window (line 249) | fn http2_adaptive_window(mut self) -> Self {
    method method (line 256) | fn method(mut self, m: Method) -> Self {
    method request_body (line 261) | fn request_body(mut self, body: &'static [u8]) -> Self {
    method request_chunks (line 266) | fn request_chunks(mut self, chunk: &'static [u8], cnt: usize) -> Self {
    method response_body (line 273) | fn response_body(mut self, body: &'static [u8]) -> Self {
    method parallel (line 278) | fn parallel(mut self, cnt: u32) -> Self {
    method bench (line 284) | fn bench(self, b: &mut test::Bencher) {
  function opts (line 217) | fn opts() -> Opts {
  function spawn_server (line 404) | fn spawn_server(rt: &tokio::runtime::Runtime, opts: &Opts) -> SocketAddr {

FILE: benches/pipeline.rs
  constant PIPELINED_REQUESTS (line 23) | const PIPELINED_REQUESTS: usize = 16;
  function hello_world_16 (line 26) | fn hello_world_16(b: &mut test::Bencher) {

FILE: benches/server.rs
  function body (line 95) | fn body(b: &'static [u8]) -> Full<Bytes> {
  function throughput_fixedsize_small_payload (line 100) | fn throughput_fixedsize_small_payload(b: &mut test::Bencher) {
  function throughput_fixedsize_large_payload (line 105) | fn throughput_fixedsize_large_payload(b: &mut test::Bencher) {
  function throughput_fixedsize_many_chunks (line 112) | fn throughput_fixedsize_many_chunks(b: &mut test::Bencher) {
  function throughput_chunked_small_payload (line 122) | fn throughput_chunked_small_payload(b: &mut test::Bencher) {
  function throughput_chunked_large_payload (line 129) | fn throughput_chunked_large_payload(b: &mut test::Bencher) {
  function throughput_chunked_many_chunks (line 136) | fn throughput_chunked_many_chunks(b: &mut test::Bencher) {
  function raw_tcp_throughput_small_payload (line 146) | fn raw_tcp_throughput_small_payload(b: &mut test::Bencher) {
  function raw_tcp_throughput_large_payload (line 184) | fn raw_tcp_throughput_large_payload(b: &mut test::Bencher) {

FILE: benches/support/tokiort.rs
  type TokioExecutor (line 15) | pub struct TokioExecutor;
    method execute (line 22) | fn execute(&self, fut: F) {
  type TokioTimer (line 30) | pub struct TokioTimer;
    method new (line 58) | pub fn new() -> Self {
  method sleep (line 33) | fn sleep(&self, duration: Duration) -> Pin<Box<dyn Sleep>> {
  method sleep_until (line 39) | fn sleep_until(&self, deadline: Instant) -> Pin<Box<dyn Sleep>> {
  method now (line 45) | fn now(&self) -> Instant {
  method reset (line 49) | fn reset(&self, sleep: &mut Pin<Box<dyn Sleep>>, new_deadline: Instant) {
  type Output (line 73) | type Output = ();
  method poll (line 75) | fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
  method reset (line 83) | pub fn reset(self: Pin<&mut Self>, deadline: Instant) {
  function new (line 97) | pub fn new(inner: T) -> Self {
  function inner (line 101) | pub fn inner(self) -> T {
  function poll_read (line 110) | fn poll_read(
  function poll_write (line 134) | fn poll_write(
  function poll_flush (line 142) | fn poll_flush(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Result...
  function poll_shutdown (line 146) | fn poll_shutdown(
  function is_write_vectored (line 153) | fn is_write_vectored(&self) -> bool {
  function poll_write_vectored (line 157) | fn poll_write_vectored(
  function poll_read (line 170) | fn poll_read(
  function poll_write (line 202) | fn poll_write(
  function poll_flush (line 210) | fn poll_flush(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Result...
  function poll_shutdown (line 214) | fn poll_shutdown(
  function is_write_vectored (line 221) | fn is_write_vectored(&self) -> bool {
  function poll_write_vectored (line 225) | fn poll_write_vectored(

FILE: capi/examples/client.c
  type conn_data (line 17) | struct conn_data {
  function read_cb (line 23) | static size_t read_cb(void *userdata, hyper_context *ctx, uint8_t *buf, ...
  function write_cb (line 44) | static size_t write_cb(void *userdata, hyper_context *ctx, const uint8_t...
  function free_conn_data (line 65) | static void free_conn_data(struct conn_data *conn) {
  function connect_to (line 78) | static int connect_to(const char *host, const char *port) {
  function print_each_header (line 115) | static int print_each_header(void *userdata,
  function print_each_chunk (line 124) | static int print_each_chunk(void *userdata, const hyper_buf *chunk) {
  type example_id (line 133) | typedef enum {
  function main (line 142) | int main(int argc, char *argv[]) {

FILE: capi/examples/upload.c
  type conn_data (line 17) | struct conn_data {
  function read_cb (line 23) | static size_t read_cb(void *userdata, hyper_context *ctx, uint8_t *buf, ...
  function write_cb (line 44) | static size_t write_cb(void *userdata, hyper_context *ctx, const uint8_t...
  function free_conn_data (line 65) | static void free_conn_data(struct conn_data *conn) {
  function connect_to (line 78) | static int connect_to(const char *host, const char *port) {
  type upload_body (line 115) | struct upload_body {
  function poll_req_upload (line 121) | static int poll_req_upload(void *userdata,
  function print_each_header (line 143) | static int print_each_header(void *userdata,
  function print_informational (line 152) | static void print_informational(void *userdata, hyper_response *resp) {
  type example_id (line 158) | typedef enum {
  function main (line 167) | int main(int argc, char *argv[]) {

FILE: capi/include/hyper.h
  type hyper_code (line 73) | typedef enum hyper_code {
  type hyper_task_return_type (line 107) | typedef enum hyper_task_return_type {
  type hyper_body (line 133) | typedef struct hyper_body hyper_body;
  type hyper_buf (line 138) | typedef struct hyper_buf hyper_buf;
  type hyper_clientconn (line 143) | typedef struct hyper_clientconn hyper_clientconn;
  type hyper_clientconn_options (line 148) | typedef struct hyper_clientconn_options hyper_clientconn_options;
  type hyper_context (line 153) | typedef struct hyper_context hyper_context;
  type hyper_error (line 158) | typedef struct hyper_error hyper_error;
  type hyper_executor (line 163) | typedef struct hyper_executor hyper_executor;
  type hyper_headers (line 168) | typedef struct hyper_headers hyper_headers;
  type hyper_io (line 173) | typedef struct hyper_io hyper_io;
  type hyper_request (line 178) | typedef struct hyper_request hyper_request;
  type hyper_response (line 183) | typedef struct hyper_response hyper_response;
  type hyper_task (line 188) | typedef struct hyper_task hyper_task;
  type hyper_waker (line 193) | typedef struct hyper_waker hyper_waker;
  type hyper_buf (line 195) | struct hyper_buf
  type hyper_context (line 197) | struct hyper_context
  type hyper_buf (line 197) | struct hyper_buf
  type hyper_response (line 199) | struct hyper_response
  type hyper_context (line 203) | struct hyper_context
  type hyper_context (line 205) | struct hyper_context
  type hyper_body (line 219) | struct hyper_body
  type hyper_body (line 224) | struct hyper_body
  type hyper_task (line 229) | struct hyper_task
  type hyper_body (line 229) | struct hyper_body
  type hyper_task (line 234) | struct hyper_task
  type hyper_body (line 234) | struct hyper_body
  type hyper_body (line 241) | struct hyper_body
  type hyper_body (line 246) | struct hyper_body
  type hyper_buf (line 251) | struct hyper_buf
  type hyper_buf (line 256) | struct hyper_buf
  type hyper_buf (line 261) | struct hyper_buf
  type hyper_buf (line 266) | struct hyper_buf
  type hyper_task (line 271) | struct hyper_task
  type hyper_io (line 271) | struct hyper_io
  type hyper_clientconn_options (line 272) | struct hyper_clientconn_options
  type hyper_task (line 277) | struct hyper_task
  type hyper_clientconn (line 277) | struct hyper_clientconn
  type hyper_request (line 277) | struct hyper_request
  type hyper_clientconn (line 282) | struct hyper_clientconn
  type hyper_clientconn_options (line 287) | struct hyper_clientconn_options
  type hyper_clientconn_options (line 292) | struct hyper_clientconn_options
  type hyper_clientconn_options (line 298) | struct hyper_clientconn_options
  type hyper_clientconn_options (line 304) | struct hyper_clientconn_options
  type hyper_clientconn_options (line 309) | struct hyper_clientconn_options
  type hyper_executor (line 310) | struct hyper_executor
  type hyper_code (line 315) | enum hyper_code
  type hyper_clientconn_options (line 315) | struct hyper_clientconn_options
  type hyper_code (line 320) | enum hyper_code
  type hyper_clientconn_options (line 320) | struct hyper_clientconn_options
  type hyper_error (line 326) | struct hyper_error
  type hyper_code (line 331) | enum hyper_code
  type hyper_error (line 331) | struct hyper_error
  type hyper_error (line 336) | struct hyper_error
  type hyper_request (line 341) | struct hyper_request
  type hyper_request (line 346) | struct hyper_request
  type hyper_code (line 351) | enum hyper_code
  type hyper_request (line 351) | struct hyper_request
  type hyper_code (line 358) | enum hyper_code
  type hyper_request (line 358) | struct hyper_request
  type hyper_code (line 365) | enum hyper_code
  type hyper_request (line 365) | struct hyper_request
  type hyper_code (line 376) | enum hyper_code
  type hyper_request (line 376) | struct hyper_request
  type hyper_headers (line 381) | struct hyper_headers
  type hyper_request (line 381) | struct hyper_request
  type hyper_code (line 386) | enum hyper_code
  type hyper_request (line 386) | struct hyper_request
  type hyper_body (line 386) | struct hyper_body
  type hyper_code (line 391) | enum hyper_code
  type hyper_request (line 391) | struct hyper_request
  type hyper_response (line 398) | struct hyper_response
  type hyper_response (line 403) | struct hyper_response
  type hyper_response (line 408) | struct hyper_response
  type hyper_response (line 413) | struct hyper_response
  type hyper_response (line 418) | struct hyper_response
  type hyper_headers (line 423) | struct hyper_headers
  type hyper_response (line 423) | struct hyper_response
  type hyper_body (line 428) | struct hyper_body
  type hyper_response (line 428) | struct hyper_response
  type hyper_headers (line 433) | struct hyper_headers
  type hyper_code (line 440) | enum hyper_code
  type hyper_headers (line 440) | struct hyper_headers
  type hyper_code (line 449) | enum hyper_code
  type hyper_headers (line 449) | struct hyper_headers
  type hyper_io (line 458) | struct hyper_io
  type hyper_io (line 463) | struct hyper_io
  type hyper_io (line 468) | struct hyper_io
  type hyper_io (line 473) | struct hyper_io
  type hyper_io (line 478) | struct hyper_io
  type hyper_executor (line 483) | struct hyper_executor
  type hyper_executor (line 488) | struct hyper_executor
  type hyper_code (line 493) | enum hyper_code
  type hyper_executor (line 493) | struct hyper_executor
  type hyper_task (line 493) | struct hyper_task
  type hyper_task (line 498) | struct hyper_task
  type hyper_executor (line 498) | struct hyper_executor
  type hyper_task (line 503) | struct hyper_task
  type hyper_task (line 508) | struct hyper_task
  type hyper_task_return_type (line 513) | enum hyper_task_return_type
  type hyper_task (line 513) | struct hyper_task
  type hyper_task (line 518) | struct hyper_task
  type hyper_task (line 523) | struct hyper_task
  type hyper_waker (line 528) | struct hyper_waker
  type hyper_context (line 528) | struct hyper_context
  type hyper_waker (line 533) | struct hyper_waker
  type hyper_waker (line 538) | struct hyper_waker

FILE: examples/client.rs
  type Result (line 16) | type Result<T> = std::result::Result<T, Box<dyn std::error::Error + Send...
  function main (line 19) | async fn main() -> Result<()> {
  function fetch_url (line 42) | async fn fetch_url(url: hyper::Uri) -> Result<()> {

FILE: examples/client_json.rs
  type Result (line 15) | type Result<T> = std::result::Result<T, Box<dyn std::error::Error + Send...
  function main (line 18) | async fn main() -> Result<()> {
  function fetch_json (line 30) | async fn fetch_json(url: hyper::Uri) -> Result<Vec<User>> {
  type User (line 65) | struct User {

FILE: examples/echo.rs
  function echo (line 19) | async fn echo(
  function empty (line 79) | fn empty() -> BoxBody<Bytes, hyper::Error> {
  function full (line 85) | fn full<T: Into<Bytes>>(chunk: T) -> BoxBody<Bytes, hyper::Error> {
  function main (line 92) | async fn main() -> Result<(), Box<dyn std::error::Error + Send + Sync>> {

FILE: examples/gateway.rs
  function main (line 12) | async fn main() -> Result<(), Box<dyn std::error::Error>> {

FILE: examples/graceful_shutdown.rs
  function hello (line 21) | async fn hello(_: Request<hyper::body::Incoming>) -> Result<Response<Ful...
  function main (line 32) | pub async fn main() -> Result<(), Box<dyn std::error::Error + Send + Syn...

FILE: examples/hello-http2.rs
  function hello (line 23) | async fn hello(_: Request<hyper::body::Incoming>) -> Result<Response<Ful...
  type TokioExecutor (line 29) | pub struct TokioExecutor;
    method execute (line 40) | fn execute(&self, fut: F) {
  function main (line 47) | async fn main() -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
  function main (line 87) | fn main() {

FILE: examples/hello.rs
  function hello (line 21) | async fn hello(_: Request<impl hyper::body::Body>) -> Result<Response<Fu...
  function main (line 26) | pub async fn main() -> Result<(), Box<dyn std::error::Error + Send + Syn...

FILE: examples/http_proxy.rs
  type ClientBuilder (line 17) | type ClientBuilder = hyper::client::conn::http1::Builder;
  type ServerBuilder (line 18) | type ServerBuilder = hyper::server::conn::http1::Builder;
  function main (line 28) | async fn main() -> Result<(), Box<dyn std::error::Error>> {
  function proxy (line 52) | async fn proxy(
  function host_addr (line 114) | fn host_addr(uri: &http::Uri) -> Option<String> {
  function empty (line 118) | fn empty() -> BoxBody<Bytes, hyper::Error> {
  function full (line 124) | fn full<T: Into<Bytes>>(chunk: T) -> BoxBody<Bytes, hyper::Error> {
  function tunnel (line 132) | async fn tunnel(upgraded: Upgraded, addr: String) -> std::io::Result<()> {

FILE: examples/multi_server.rs
  function index1 (line 21) | async fn index1(_: Request<hyper::body::Incoming>) -> Result<Response<Fu...
  function index2 (line 25) | async fn index2(_: Request<hyper::body::Incoming>) -> Result<Response<Fu...
  function main (line 30) | async fn main() -> Result<(), Box<dyn std::error::Error + Send + Sync>> {

FILE: examples/params.rs
  function param_example (line 24) | async fn param_example(
  function empty (line 112) | fn empty() -> BoxBody<Bytes, Infallible> {
  function full (line 116) | fn full<T: Into<Bytes>>(chunk: T) -> BoxBody<Bytes, Infallible> {
  function main (line 121) | async fn main() -> Result<(), Box<dyn std::error::Error + Send + Sync>> {

FILE: examples/send_file.rs
  function main (line 23) | async fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
  function response_examples (line 46) | async fn response_examples(
  function not_found (line 60) | fn not_found() -> Response<BoxBody<Bytes, std::io::Error>> {
  function simple_file_send (line 67) | async fn simple_file_send(filename: &str) -> Result<Response<BoxBody<Byt...

FILE: examples/service_struct_impl.rs
  type Counter (line 17) | type Counter = i32;
  function main (line 20) | async fn main() -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
  type Svc (line 43) | struct Svc {
    type Response (line 48) | type Response = Response<Full<Bytes>>;
    type Error (line 49) | type Error = hyper::Error;
    type Future (line 50) | type Future = Pin<Box<dyn Future<Output = Result<Self::Response, Self:...
    method call (line 52) | fn call(&self, req: Request<IncomingBody>) -> Self::Future {

FILE: examples/single_threaded.rs
  type Body (line 35) | struct Body {
    method from (line 42) | fn from(a: String) -> Self {
  type Data (line 51) | type Data = Bytes;
  type Error (line 52) | type Error = Error;
  method poll_frame (line 54) | fn poll_frame(
  function main (line 62) | fn main() {
  function http1_server (line 130) | async fn http1_server() -> Result<(), Box<dyn std::error::Error>> {
  function http1_client (line 163) | async fn http1_client(url: hyper::Uri) -> Result<(), Box<dyn std::error:...
  function http2_server (line 219) | async fn http2_server() -> Result<(), Box<dyn std::error::Error>> {
  function http2_client (line 264) | async fn http2_client(url: hyper::Uri) -> Result<(), Box<dyn std::error:...
  type LocalExec (line 325) | struct LocalExec;
    method execute (line 331) | fn execute(&self, fut: F) {
  type IOTypeNotSend (line 337) | struct IOTypeNotSend {
    method new (line 343) | fn new(stream: TokioIo<TcpStream>) -> Self {
    method poll_write (line 352) | fn poll_write(
    method poll_flush (line 360) | fn poll_flush(
    method poll_shutdown (line 367) | fn poll_shutdown(
    method poll_read (line 376) | fn poll_read(

FILE: examples/state.rs
  function main (line 20) | async fn main() -> Result<(), Box<dyn std::error::Error>> {

FILE: examples/upgrades.rs
  type Result (line 24) | type Result<T> = std::result::Result<T, Box<dyn std::error::Error + Send...
  function server_upgraded_io (line 27) | async fn server_upgraded_io(upgraded: Upgraded) -> Result<()> {
  function server_upgrade (line 46) | async fn server_upgrade(mut req: Request<hyper::body::Incoming>) -> Resu...
  function client_upgraded_io (line 83) | async fn client_upgraded_io(upgraded: Upgraded) -> Result<()> {
  function client_upgrade_request (line 98) | async fn client_upgrade_request(addr: SocketAddr) -> Result<()> {
  function main (line 135) | async fn main() {

FILE: examples/web_api.rs
  type GenericError (line 16) | type GenericError = Box<dyn std::error::Error + Send + Sync>;
  type Result (line 17) | type Result<T> = std::result::Result<T, GenericError>;
  type BoxBody (line 18) | type BoxBody = http_body_util::combinators::BoxBody<Bytes, hyper::Error>;
  function client_request_response (line 26) | async fn client_request_response() -> Result<Response<BoxBody>> {
  function api_post_response (line 54) | async fn api_post_response(req: Request<IncomingBody>) -> Result<Respons...
  function api_get_response (line 70) | async fn api_get_response() -> Result<Response<BoxBody>> {
  function response_examples (line 85) | async fn response_examples(req: Request<IncomingBody>) -> Result<Respons...
  function full (line 101) | fn full<T: Into<Bytes>>(chunk: T) -> BoxBody {
  function main (line 108) | async fn main() -> Result<()> {

FILE: src/body/incoming.rs
  type BodySender (line 32) | type BodySender = mpsc::Sender<Result<Bytes, crate::Error>>;
  type TrailersSender (line 34) | type TrailersSender = oneshot::Sender<HeaderMap>;
  type Incoming (line 52) | pub struct Incoming {
    method channel (line 109) | pub(crate) fn channel() -> (Sender, Incoming) {
    method new_channel (line 114) | pub(crate) fn new_channel(content_length: DecodedLength, wanter: bool)...
    method new (line 139) | fn new(kind: Kind) -> Incoming {
    method empty (line 144) | pub(crate) fn empty() -> Incoming {
    method ffi (line 149) | pub(crate) fn ffi() -> Incoming {
    method h2 (line 154) | pub(crate) fn h2(
    method as_ffi_mut (line 174) | pub(crate) fn as_ffi_mut(&mut self) -> &mut crate::ffi::UserBody {
    method fmt (line 320) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  type Kind (line 56) | enum Kind {
  type Sender (line 91) | pub(crate) struct Sender {
    method poll_ready (line 353) | pub(crate) fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll<crat...
    method poll_want (line 361) | fn poll_want(&mut self, cx: &mut Context<'_>) -> Poll<crate::Result<()...
    method ready (line 371) | async fn ready(&mut self) -> crate::Result<()> {
    method send_data (line 378) | pub(crate) async fn send_data(&mut self, chunk: Bytes) -> crate::Resul...
    method send_trailers (line 387) | pub(crate) async fn send_trailers(&mut self, trailers: HeaderMap) -> c...
    method try_send_data (line 408) | pub(crate) fn try_send_data(&mut self, chunk: Bytes) -> Result<(), Byt...
    method try_send_trailers (line 415) | pub(crate) fn try_send_trailers(
    method abort (line 428) | pub(crate) fn abort(mut self) {
    method send_error (line 432) | pub(crate) fn send_error(&mut self, err: crate::Error) {
    method fmt (line 443) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  constant WANT_PENDING (line 98) | const WANT_PENDING: usize = 1;
  constant WANT_READY (line 100) | const WANT_READY: usize = 2;
  type Data (line 190) | type Data = Bytes;
  type Error (line 191) | type Error = crate::Error;
  method poll_frame (line 193) | fn poll_frame(
  method is_end_stream (line 282) | fn is_end_stream(&self) -> bool {
  method size_hint (line 294) | fn size_hint(&self) -> SizeHint {
  function test_size_of (line 475) | fn test_size_of() {
  function size_hint (line 505) | fn size_hint() {
  function channel_abort (line 526) | async fn channel_abort() {
  function channel_abort_when_buffer_is_full (line 538) | async fn channel_abort_when_buffer_is_full() {
  function channel_buffers_one (line 560) | fn channel_buffers_one() {
  function channel_empty (line 573) | async fn channel_empty() {
  function channel_ready (line 581) | fn channel_ready() {
  function channel_wanter (line 591) | fn channel_wanter() {
  function channel_notices_closure (line 614) | fn channel_notices_closure() {

FILE: src/body/length.rs
  type DecodedLength (line 4) | pub(crate) struct DecodedLength(u64);
    method from (line 8) | fn from(len: Option<u64>) -> Self {
    constant CLOSE_DELIMITED (line 21) | pub(crate) const CLOSE_DELIMITED: DecodedLength = DecodedLength(u64::M...
    constant CHUNKED (line 22) | pub(crate) const CHUNKED: DecodedLength = DecodedLength(u64::MAX - 1);
    constant ZERO (line 23) | pub(crate) const ZERO: DecodedLength = DecodedLength(0);
    method new (line 26) | pub(crate) fn new(len: u64) -> Self {
    method danger_len (line 37) | pub(crate) fn danger_len(self) -> u64 {
    method into_opt (line 47) | pub(crate) fn into_opt(self) -> Option<u64> {
    method checked_new (line 56) | pub(crate) fn checked_new(len: u64) -> Result<Self, crate::error::Pars...
    method sub_if (line 69) | pub(crate) fn sub_if(&mut self, amt: u64) {
    method is_exact (line 84) | pub(crate) fn is_exact(&self) -> bool {
    method fmt (line 90) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
    method fmt (line 100) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  constant MAX_LEN (line 18) | const MAX_LEN: u64 = u64::MAX - 2;
  function sub_if_known (line 115) | fn sub_if_known() {
  function sub_if_chunked (line 123) | fn sub_if_chunked() {

FILE: src/body/mod.rs
  function _assert_send_sync (line 44) | fn _assert_send_sync() {

FILE: src/client/conn/http1.rs
  type Dispatcher (line 19) | type Dispatcher<T, B> =
  type SendRequest (line 23) | pub struct SendRequest<B> {
  type Parts (line 33) | pub struct Parts<T> {
  type Connection (line 54) | pub struct Connection<T, B>
  function into_parts (line 71) | pub fn into_parts(self) -> Parts<T> {
  function poll_without_shutdown (line 87) | pub fn poll_without_shutdown(&mut self, cx: &mut Context<'_>) -> Poll<cr...
  function without_shutdown (line 93) | pub async fn without_shutdown(self) -> crate::Result<Parts<T>> {
  type Builder (line 110) | pub struct Builder {
    method new (line 308) | pub fn new() -> Builder {
    method http09_responses (line 326) | pub fn http09_responses(&mut self, enabled: bool) -> &mut Builder {
    method allow_spaces_after_header_name_in_responses (line 348) | pub fn allow_spaces_after_header_name_in_responses(&mut self, enabled:...
    method allow_obsolete_multiline_headers_in_responses (line 386) | pub fn allow_obsolete_multiline_headers_in_responses(&mut self, enable...
    method ignore_invalid_headers_in_responses (line 399) | pub fn ignore_invalid_headers_in_responses(&mut self, enabled: bool) -...
    method writev (line 417) | pub fn writev(&mut self, enabled: bool) -> &mut Builder {
    method title_case_headers (line 426) | pub fn title_case_headers(&mut self, enabled: bool) -> &mut Builder {
    method preserve_header_case (line 442) | pub fn preserve_header_case(&mut self, enabled: bool) -> &mut Builder {
    method max_headers (line 460) | pub fn max_headers(&mut self, val: usize) -> &mut Self {
    method preserve_header_order (line 473) | pub fn preserve_header_order(&mut self, enabled: bool) -> &mut Builder {
    method read_buf_exact_size (line 483) | pub fn read_buf_exact_size(&mut self, sz: Option<usize>) -> &mut Build...
    method max_buf_size (line 498) | pub fn max_buf_size(&mut self, max: usize) -> &mut Self {
    method handshake (line 514) | pub fn handshake<T, B>(
  function handshake (line 127) | pub async fn handshake<T, B>(io: T) -> crate::Result<(SendRequest<B>, Co...
  function poll_ready (line 143) | pub fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll<crate::Result...
  function ready (line 150) | pub async fn ready(&mut self) -> crate::Result<()> {
  function is_ready (line 161) | pub fn is_ready(&self) -> bool {
  function is_closed (line 166) | pub fn is_closed(&self) -> bool {
  function send_request (line 191) | pub fn send_request(
  function try_send_request (line 221) | pub fn try_send_request(
  function fmt (line 248) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  function with_upgrades (line 264) | pub fn with_upgrades(self) -> upgrades::UpgradeableConnection<T, B> {
  function fmt (line 274) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  type Output (line 286) | type Output = crate::Result<()>;
  method poll (line 288) | fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Ou...
  type UpgradeableConnection (line 581) | pub struct UpgradeableConnection<T, B>
  type Output (line 597) | type Output = crate::Result<()>;
  method poll (line 599) | fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Ou...

FILE: src/client/conn/http2.rs
  type SendRequest (line 24) | pub struct SendRequest<B> {
  method clone (line 29) | fn clone(&self) -> SendRequest<B> {
  type Connection (line 43) | pub struct Connection<T, B, E>
  type Builder (line 60) | pub struct Builder<Ex> {
  function handshake (line 70) | pub async fn handshake<E, T, B>(
  function poll_ready (line 90) | pub fn poll_ready(&mut self, _cx: &mut Context<'_>) -> Poll<crate::Resul...
  function ready (line 101) | pub async fn ready(&mut self) -> crate::Result<()> {
  function is_ready (line 112) | pub fn is_ready(&self) -> bool {
  function is_closed (line 117) | pub fn is_closed(&self) -> bool {
  function send_request (line 134) | pub fn send_request(
  function try_send_request (line 165) | pub fn try_send_request(
  function fmt (line 192) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  function is_extended_connect_protocol_enabled (line 216) | pub fn is_extended_connect_protocol_enabled(&self) -> bool {
  function fmt (line 228) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  type Output (line 242) | type Output = crate::Result<()>;
  method poll (line 244) | fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Ou...
  function new (line 261) | pub fn new(exec: Ex) -> Builder<Ex> {
  function timer (line 270) | pub fn timer<M>(&mut self, timer: M) -> &mut Builder<Ex>
  function initial_stream_window_size (line 286) | pub fn initial_stream_window_size(&mut self, sz: impl Into<Option<u32>>)...
  function initial_connection_window_size (line 299) | pub fn initial_connection_window_size(&mut self, sz: impl Into<Option<u3...
  function initial_max_send_streams (line 317) | pub fn initial_max_send_streams(&mut self, initial: impl Into<Option<usi...
  function adaptive_window (line 329) | pub fn adaptive_window(&mut self, enabled: bool) -> &mut Self {
  function max_frame_size (line 343) | pub fn max_frame_size(&mut self, sz: impl Into<Option<u32>>) -> &mut Self {
  function max_header_list_size (line 351) | pub fn max_header_list_size(&mut self, max: u32) -> &mut Self {
  function header_table_size (line 363) | pub fn header_table_size(&mut self, size: impl Into<Option<u32>>) -> &mu...
  function max_concurrent_streams (line 391) | pub fn max_concurrent_streams(&mut self, max: impl Into<Option<u32>>) ->...
  function keep_alive_interval (line 402) | pub fn keep_alive_interval(&mut self, interval: impl Into<Option<Duratio...
  function keep_alive_timeout (line 413) | pub fn keep_alive_timeout(&mut self, timeout: Duration) -> &mut Self {
  function keep_alive_while_idle (line 426) | pub fn keep_alive_while_idle(&mut self, enabled: bool) -> &mut Self {
  function max_concurrent_reset_streams (line 439) | pub fn max_concurrent_reset_streams(&mut self, max: usize) -> &mut Self {
  function max_send_buf_size (line 451) | pub fn max_send_buf_size(&mut self, max: usize) -> &mut Self {
  function max_pending_accept_reset_streams (line 463) | pub fn max_pending_accept_reset_streams(&mut self, max: impl Into<Option...
  function max_local_error_reset_streams (line 474) | pub fn max_local_error_reset_streams(&mut self, max: impl Into<Option<us...
  function handshake (line 484) | pub fn handshake<T, B>(
  function send_sync_executor_of_non_send_futures (line 520) | async fn send_sync_executor_of_non_send_futures() {
  function not_send_not_sync_executor_of_not_send_futures (line 552) | async fn not_send_not_sync_executor_of_not_send_futures() {
  function send_not_sync_executor_of_not_send_futures (line 588) | async fn send_not_sync_executor_of_not_send_futures() {
  function send_sync_executor_of_send_futures (line 624) | async fn send_sync_executor_of_send_futures() {
  function send_not_sync_executor_of_send_futures (line 656) | async fn send_not_sync_executor_of_send_futures() {

FILE: src/client/dispatch.rs
  type RetryPromise (line 16) | pub(crate) type RetryPromise<T, U> = oneshot::Receiver<Result<U, TrySend...
  type Promise (line 17) | pub(crate) type Promise<T> = oneshot::Receiver<Result<T, crate::Error>>;
  type TrySendError (line 26) | pub struct TrySendError<T> {
  function channel (line 31) | pub(crate) fn channel<T, U>() -> (Sender<T, U>, Receiver<T, U>) {
  type Sender (line 48) | pub(crate) struct Sender<T, U> {
  type UnboundedSender (line 68) | pub(crate) struct UnboundedSender<T, U> {
  function poll_ready (line 76) | pub(crate) fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll<crate:...
  function is_ready (line 83) | pub(crate) fn is_ready(&self) -> bool {
  function is_closed (line 88) | pub(crate) fn is_closed(&self) -> bool {
  function can_send (line 93) | fn can_send(&mut self) -> bool {
  function try_send (line 107) | pub(crate) fn try_send(&mut self, val: T) -> Result<RetryPromise<T, U>, ...
  function send (line 119) | pub(crate) fn send(&mut self, val: T) -> Result<Promise<U>, T> {
  function unbound (line 131) | pub(crate) fn unbound(self) -> UnboundedSender<T, U> {
  function is_ready (line 141) | pub(crate) fn is_ready(&self) -> bool {
  function is_closed (line 145) | pub(crate) fn is_closed(&self) -> bool {
  function try_send (line 149) | pub(crate) fn try_send(&mut self, val: T) -> Result<RetryPromise<T, U>, ...
  function send (line 157) | pub(crate) fn send(&mut self, val: T) -> Result<Promise<U>, T> {
  method clone (line 168) | fn clone(&self) -> Self {
  type Receiver (line 176) | pub(crate) struct Receiver<T, U> {
  function poll_recv (line 182) | pub(crate) fn poll_recv(&mut self, cx: &mut Context<'_>) -> Poll<Option<...
  function close (line 195) | pub(crate) fn close(&mut self) {
  function try_recv (line 201) | pub(crate) fn try_recv(&mut self) -> Option<(T, Callback<T, U>)> {
  method drop (line 210) | fn drop(&mut self) {
  type Envelope (line 217) | struct Envelope<T, U>(Option<(T, Callback<T, U>)>);
  method drop (line 220) | fn drop(&mut self) {
  type Callback (line 230) | pub(crate) enum Callback<T, U> {
  method drop (line 237) | fn drop(&mut self) {
  function dispatch_gone (line 257) | fn dispatch_gone() -> crate::Error {
  function is_canceled (line 268) | pub(crate) fn is_canceled(&self) -> bool {
  function poll_canceled (line 276) | pub(crate) fn poll_canceled(&mut self, cx: &mut Context<'_>) -> Poll<()> {
  function send (line 284) | pub(crate) fn send(mut self, val: Result<U, TrySendError<T>>) {
  function take_message (line 302) | pub fn take_message(&mut self) -> Option<T> {
  function message (line 311) | pub fn message(&self) -> Option<&T> {
  function into_error (line 316) | pub fn into_error(self) -> crate::Error {
  function error (line 321) | pub fn error(&self) -> &crate::Error {
  type Output (line 346) | type Output = ();
  method poll (line 348) | fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
  type Custom (line 391) | struct Custom(#[allow(dead_code)] i32);
  type Output (line 394) | type Output = Option<(T, Callback<T, U>)>;
  method poll (line 396) | fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Ou...
  type PollOnce (line 402) | struct PollOnce<'a, F>(&'a mut F);
  type Output (line 408) | type Output = Option<()>;
  method poll (line 410) | fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Ou...
  function drop_receiver_sends_cancel_errors (line 420) | async fn drop_receiver_sends_cancel_errors() {
  function sender_checks_for_want_on_send (line 443) | async fn sender_checks_for_want_on_send() {
  function unbounded_sender_doesnt_bound_on_want (line 463) | fn unbounded_sender_doesnt_bound_on_want() {
  function giver_queue_throughput (line 478) | fn giver_queue_throughput(b: &mut test::Bencher) {
  function giver_queue_not_ready (line 502) | fn giver_queue_not_ready(b: &mut test::Bencher) {
  function giver_queue_cancel (line 517) | fn giver_queue_cancel(b: &mut test::Bencher) {

FILE: src/common/buf.rs
  type BufList (line 6) | pub(crate) struct BufList<T> {
  function new (line 11) | pub(crate) fn new() -> BufList<T> {
  function push (line 18) | pub(crate) fn push(&mut self, buf: T) {
  function bufs_cnt (line 24) | pub(crate) fn bufs_cnt(&self) -> usize {
  method remaining (line 31) | fn remaining(&self) -> usize {
  method chunk (line 36) | fn chunk(&self) -> &[u8] {
  method advance (line 41) | fn advance(&mut self, mut cnt: usize) {
  method chunks_vectored (line 59) | fn chunks_vectored<'t>(&'t self, dst: &mut [IoSlice<'t>]) -> usize {
  method copy_to_bytes (line 74) | fn copy_to_bytes(&mut self, len: usize) -> Bytes {
  function hello_world_buf (line 100) | fn hello_world_buf() -> BufList<Bytes> {
  function to_bytes_shorter (line 107) | fn to_bytes_shorter() {
  function to_bytes_eq (line 119) | fn to_bytes_eq() {
  function to_bytes_longer (line 130) | fn to_bytes_longer() {
  function one_long_buf_to_bytes (line 138) | fn one_long_buf_to_bytes() {
  function buf_to_bytes_too_many (line 147) | fn buf_to_bytes_too_many() {

FILE: src/common/date.rs
  constant DATE_VALUE_LENGTH (line 11) | pub(crate) const DATE_VALUE_LENGTH: usize = 29;
  function extend (line 14) | pub(crate) fn extend(dst: &mut Vec<u8>) {
  function update (line 21) | pub(crate) fn update() {
  function update_and_header_value (line 28) | pub(crate) fn update_and_header_value() -> HeaderValue {
  type CachedDate (line 36) | struct CachedDate {
    method new (line 47) | fn new() -> Self {
    method buffer (line 59) | fn buffer(&self) -> &[u8] {
    method check (line 63) | fn check(&mut self) {
    method update (line 70) | fn update(&mut self, now: SystemTime) {
    method render (line 80) | fn render(&mut self, now: SystemTime) {
    method render_http2 (line 88) | fn render_http2(&mut self) {
    method render_http2 (line 94) | fn render_http2(&mut self) {}
    method write_str (line 98) | fn write_str(&mut self, s: &str) -> fmt::Result {
  function test_date_len (line 114) | fn test_date_len() {
  function bench_date_check (line 120) | fn bench_date_check(b: &mut Bencher) {
  function bench_date_render (line 132) | fn bench_date_render(b: &mut Bencher) {

FILE: src/common/either.rs
  function left (line 24) | pub(crate) fn left(fut: F1) -> Self {
  function right (line 28) | pub(crate) fn right(fut: F2) -> Self {
  type Output (line 38) | type Output = F1::Output;
  method poll (line 40) | fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {

FILE: src/common/future.rs
  function poll_fn (line 8) | pub(crate) fn poll_fn<T, F>(f: F) -> PollFn<F>
  type PollFn (line 15) | pub(crate) struct PollFn<F> {
  type Output (line 25) | type Output = T;
  method poll (line 27) | fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Ou...

FILE: src/common/io/compat.rs
  type Compat (line 8) | pub(crate) struct Compat<T>(pub(crate) T);
  function new (line 11) | pub(crate) fn new(io: T) -> Self {
  function p (line 15) | fn p(self: Pin<&mut Self>) -> Pin<&mut T> {
  function poll_read (line 26) | fn poll_read(
  function poll_write (line 58) | fn poll_write(
  function poll_flush (line 66) | fn poll_flush(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Result...
  function poll_shutdown (line 70) | fn poll_shutdown(
  function is_write_vectored (line 77) | fn is_write_vectored(&self) -> bool {
  function poll_write_vectored (line 81) | fn poll_write_vectored(
  function poll_read (line 95) | fn poll_read(
  function poll_write (line 120) | fn poll_write(
  function poll_flush (line 128) | fn poll_flush(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Result...
  function poll_shutdown (line 132) | fn poll_shutdown(
  function is_write_vectored (line 139) | fn is_write_vectored(&self) -> bool {
  function poll_write_vectored (line 143) | fn poll_write_vectored(

FILE: src/common/io/rewind.rs
  type Rewind (line 11) | pub(crate) struct Rewind<T> {
  function new (line 22) | pub(crate) fn new(io: T) -> Self {
  function new_buffered (line 29) | pub(crate) fn new_buffered(io: T, buf: Bytes) -> Self {
  function rewind (line 41) | pub(crate) fn rewind(&mut self, bs: Bytes) {
  function into_inner (line 46) | pub(crate) fn into_inner(self) -> (T, Bytes) {
  method poll_read (line 59) | fn poll_read(
  method poll_write (line 87) | fn poll_write(
  method poll_write_vectored (line 95) | fn poll_write_vectored(
  method poll_flush (line 103) | fn poll_flush(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<io...
  method poll_shutdown (line 107) | fn poll_shutdown(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll...
  method is_write_vectored (line 111) | fn is_write_vectored(&self) -> bool {
  function partial_rewind (line 129) | async fn partial_rewind() {
  function full_rewind (line 152) | async fn full_rewind() {

FILE: src/common/task.rs
  function yield_now (line 8) | pub(crate) fn yield_now(cx: &mut Context<'_>) -> Poll<std::convert::Infa...
  function noop_waker (line 15) | fn noop_waker() -> Waker {
  function now_or_never (line 36) | pub(crate) fn now_or_never<F: std::future::Future>(fut: F) -> Option<F::...

FILE: src/common/time.rs
  type Time (line 14) | pub(crate) enum Time {
    method fmt (line 27) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
    method sleep (line 34) | pub(crate) fn sleep(&self, duration: Duration) -> Pin<Box<dyn Sleep>> {
    method sleep_until (line 44) | pub(crate) fn sleep_until(&self, deadline: Instant) -> Pin<Box<dyn Sle...
    method now (line 53) | pub(crate) fn now(&self) -> Instant {
    method reset (line 60) | pub(crate) fn reset(&self, sleep: &mut Pin<Box<dyn Sleep>>, new_deadli...
    method check (line 70) | pub(crate) fn check(&self, dur: Dur, name: &'static str) -> Option<Dur...
  type Dur (line 21) | pub(crate) enum Dur {

FILE: src/common/watch.rs
  type Value (line 14) | type Value = usize;
  constant CLOSED (line 16) | pub(crate) const CLOSED: usize = 0;
  function channel (line 18) | pub(crate) fn channel(initial: Value) -> (Sender, Receiver) {
  type Sender (line 37) | pub(crate) struct Sender {
    method send (line 51) | pub(crate) fn send(&mut self, value: Value) {
  type Receiver (line 41) | pub(crate) struct Receiver {
    method load (line 65) | pub(crate) fn load(&mut self, cx: &mut task::Context<'_>) -> Value {
    method peek (line 70) | pub(crate) fn peek(&self) -> Value {
  type Shared (line 45) | struct Shared {
  method drop (line 59) | fn drop(&mut self) {

FILE: src/error.rs
  type Result (line 6) | pub type Result<T> = std::result::Result<T, Error>;
  type Cause (line 8) | type Cause = Box<dyn StdError + Send + Sync>;
  type Error (line 31) | pub struct Error {
    method is_parse (line 176) | pub fn is_parse(&self) -> bool {
    method is_parse_too_large (line 182) | pub fn is_parse_too_large(&self) -> bool {
    method is_parse_status (line 191) | pub fn is_parse_status(&self) -> bool {
    method is_user (line 196) | pub fn is_user(&self) -> bool {
    method is_canceled (line 201) | pub fn is_canceled(&self) -> bool {
    method is_closed (line 206) | pub fn is_closed(&self) -> bool {
    method is_incomplete_message (line 237) | pub fn is_incomplete_message(&self) -> bool {
    method is_body_write_aborted (line 246) | pub fn is_body_write_aborted(&self) -> bool {
    method is_shutdown (line 261) | pub fn is_shutdown(&self) -> bool {
    method is_timeout (line 270) | pub fn is_timeout(&self) -> bool {
    method new (line 278) | pub(super) fn new(kind: Kind) -> Error {
    method with (line 284) | pub(super) fn with<C: Into<Cause>>(mut self, cause: C) -> Error {
    method kind (line 290) | pub(super) fn kind(&self) -> &Kind {
    method find_source (line 294) | pub(crate) fn find_source<E: StdError + 'static>(&self) -> Option<&E> {
    method h2_reason (line 308) | pub(super) fn h2_reason(&self) -> h2::Reason {
    method new_canceled (line 316) | pub(super) fn new_canceled() -> Error {
    method new_incomplete (line 321) | pub(super) fn new_incomplete() -> Error {
    method new_too_large (line 326) | pub(super) fn new_too_large() -> Error {
    method new_version_h2 (line 331) | pub(super) fn new_version_h2() -> Error {
    method new_unexpected_message (line 336) | pub(super) fn new_unexpected_message() -> Error {
    method new_io (line 344) | pub(super) fn new_io(cause: std::io::Error) -> Error {
    method new_closed (line 352) | pub(super) fn new_closed() -> Error {
    method new_body (line 360) | pub(super) fn new_body<E: Into<Cause>>(cause: E) -> Error {
    method new_body_write (line 368) | pub(super) fn new_body_write<E: Into<Cause>>(cause: E) -> Error {
    method new_body_write_aborted (line 376) | pub(super) fn new_body_write_aborted() -> Error {
    method new_user (line 380) | fn new_user(user: User) -> Error {
    method new_user_header (line 386) | pub(super) fn new_user_header() -> Error {
    method new_header_timeout (line 391) | pub(super) fn new_header_timeout() -> Error {
    method new_user_unsupported_status_code (line 397) | pub(super) fn new_user_unsupported_status_code() -> Error {
    method new_user_no_upgrade (line 401) | pub(super) fn new_user_no_upgrade() -> Error {
    method new_user_manual_upgrade (line 406) | pub(super) fn new_user_manual_upgrade() -> Error {
    method new_user_service (line 414) | pub(super) fn new_user_service<E: Into<Cause>>(cause: E) -> Error {
    method new_user_body (line 422) | pub(super) fn new_user_body<E: Into<Cause>>(cause: E) -> Error {
    method new_user_invalid_connect (line 427) | pub(super) fn new_user_invalid_connect() -> Error {
    method new_shutdown (line 432) | pub(super) fn new_shutdown(cause: std::io::Error) -> Error {
    method new_user_aborted_by_callback (line 437) | pub(super) fn new_user_aborted_by_callback() -> Error {
    method new_user_dispatch_gone (line 442) | pub(super) fn new_user_dispatch_gone() -> Error {
    method new_h2 (line 447) | pub(super) fn new_h2(cause: ::h2::Error) -> Error {
    method description (line 455) | fn description(&self) -> &str {
    method fmt (line 557) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
    method fmt (line 568) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
    method from (line 584) | fn from(err: Parse) -> Error {
  type ErrorImpl (line 35) | struct ErrorImpl {
  type Kind (line 41) | pub(super) enum Kind {
  type Parse (line 89) | pub(super) enum Parse {
    method content_length_invalid (line 592) | pub(crate) fn content_length_invalid() -> Self {
    method transfer_encoding_invalid (line 597) | pub(crate) fn transfer_encoding_invalid() -> Self {
    method transfer_encoding_unexpected (line 602) | pub(crate) fn transfer_encoding_unexpected() -> Self {
    method from (line 609) | fn from(err: httparse::Error) -> Parse {
    method from (line 623) | fn from(_: http::method::InvalidMethod) -> Parse {
    method from (line 629) | fn from(_: http::status::InvalidStatusCode) -> Parse {
    method from (line 635) | fn from(_: http::uri::InvalidUri) -> Parse {
    method from (line 641) | fn from(_: http::uri::InvalidUriParts) -> Parse {
  type Header (line 110) | pub(super) enum Header {
  type User (line 121) | pub(super) enum User {
  type TimedOut (line 172) | pub(super) struct TimedOut;
    method fmt (line 649) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  method source (line 574) | fn source(&self) -> Option<&(dyn StdError + 'static)> {
  function assert_send_sync (line 661) | fn assert_send_sync<T: Send + Sync + 'static>() {}
  function error_satisfies_send_sync (line 664) | fn error_satisfies_send_sync() {
  function error_size_of (line 669) | fn error_size_of() {
  function h2_reason_unknown (line 675) | fn h2_reason_unknown() {
  function h2_reason_one_level (line 682) | fn h2_reason_one_level() {
  function h2_reason_nested (line 689) | fn h2_reason_nested() {

FILE: src/ext/h1_reason_phrase.rs
  type ReasonPhrase (line 34) | pub struct ReasonPhrase(Bytes);
    method as_bytes (line 38) | pub fn as_bytes(&self) -> &[u8] {
    method from_static (line 43) | pub const fn from_static(reason: &'static [u8]) -> Self {
    method from_bytes_unchecked (line 57) | pub(crate) fn from_bytes_unchecked(reason: Bytes) -> Self {
    type Error (line 63) | type Error = InvalidReasonPhrase;
    method try_from (line 65) | fn try_from(reason: &[u8]) -> Result<Self, Self::Error> {
    type Error (line 75) | type Error = InvalidReasonPhrase;
    method try_from (line 77) | fn try_from(reason: Vec<u8>) -> Result<Self, Self::Error> {
    type Error (line 87) | type Error = InvalidReasonPhrase;
    method try_from (line 89) | fn try_from(reason: String) -> Result<Self, Self::Error> {
    type Error (line 99) | type Error = InvalidReasonPhrase;
    method try_from (line 101) | fn try_from(reason: Bytes) -> Result<Self, Self::Error> {
    method as_ref (line 117) | fn as_ref(&self) -> &[u8] {
  method from (line 111) | fn from(reason: ReasonPhrase) -> Self {
  type InvalidReasonPhrase (line 128) | pub struct InvalidReasonPhrase {
    method fmt (line 133) | fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
  function is_valid_byte (line 140) | const fn is_valid_byte(b: u8) -> bool {
  function find_invalid_byte (line 159) | const fn find_invalid_byte(bytes: &[u8]) -> Option<u8> {
  function basic_valid (line 176) | fn basic_valid() {
  function empty_valid (line 183) | fn empty_valid() {
  function obs_text_valid (line 190) | fn obs_text_valid() {
  constant NEWLINE_PHRASE (line 196) | const NEWLINE_PHRASE: &[u8] = b"hyp\ner";
  function newline_invalid_panic (line 200) | fn newline_invalid_panic() {
  function newline_invalid_err (line 205) | fn newline_invalid_err() {
  constant CR_PHRASE (line 209) | const CR_PHRASE: &[u8] = b"hyp\rer";
  function cr_invalid_panic (line 213) | fn cr_invalid_panic() {
  function cr_invalid_err (line 218) | fn cr_invalid_err() {

FILE: src/ext/informational.rs
  type OnInformational (line 4) | pub(crate) struct OnInformational(Arc<dyn OnInformationalCallback + Send...
    method call (line 41) | pub(crate) fn call(&self, res: http::Response<()>) {
  function on_informational (line 20) | pub fn on_informational<B, F>(req: &mut http::Request<B>, callback: F)
  function on_informational_raw (line 27) | pub(crate) fn on_informational_raw<B, C>(req: &mut http::Request<B>, cal...
  type OnInformationalCallback (line 36) | pub(crate) trait OnInformationalCallback {
    method on_informational (line 37) | fn on_informational(&self, res: http::Response<()>);
    method on_informational (line 52) | fn on_informational(&self, res: http::Response<()>) {
  type OnInformationalClosure (line 46) | struct OnInformationalClosure<F>(F);
  type Response (line 69) | pub struct Response<'a>(&'a http::Response<()>);
  function status (line 73) | pub fn status(&self) -> http::StatusCode {
  function version (line 78) | pub fn version(&self) -> http::Version {
  function headers (line 83) | pub fn headers(&self) -> &http::HeaderMap {

FILE: src/ext/mod.rs
  type Protocol (line 86) | pub struct Protocol {
    method from_static (line 93) | pub const fn from_static(value: &'static str) -> Self {
    method as_str (line 100) | pub fn as_str(&self) -> &str {
    method from_inner (line 105) | pub(crate) fn from_inner(inner: h2::ext::Protocol) -> Self {
    method into_inner (line 110) | pub(crate) fn into_inner(self) -> h2::ext::Protocol {
    method from (line 117) | fn from(value: &'a str) -> Self {
    method as_ref (line 126) | fn as_ref(&self) -> &[u8] {
    method fmt (line 133) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  type HeaderCaseMap (line 161) | pub(crate) struct HeaderCaseMap(HeaderMap<Bytes>);
    method get_all (line 168) | pub(crate) fn get_all<'a>(
    method get_all_internal (line 178) | pub(crate) fn get_all_internal(&self, name: &HeaderName) -> ValueIter<...
    method default (line 183) | pub(crate) fn default() -> Self {
    method insert (line 188) | pub(crate) fn insert(&mut self, name: HeaderName, orig: Bytes) {
    method append (line 193) | pub(crate) fn append<N>(&mut self, name: N, orig: Bytes)
  type OriginalHeaderOrder (line 204) | pub(crate) struct OriginalHeaderOrder {
    method default (line 218) | pub(crate) fn default() -> Self {
    method insert (line 225) | pub(crate) fn insert(&mut self, name: HeaderName) {
    method append (line 236) | pub(crate) fn append<N>(&mut self, name: N)
    method get_in_order (line 292) | pub(crate) fn get_in_order(&self) -> impl Iterator<Item = &(HeaderName...

FILE: src/ffi/body.rs
  type hyper_body (line 33) | pub struct hyper_body(pub(super) IncomingBody);
  type hyper_buf (line 47) | pub struct hyper_buf(pub(crate) Bytes);
  type UserBody (line 49) | pub(crate) struct UserBody {
    method new (line 204) | pub(crate) fn new() -> UserBody {
    method poll_data (line 211) | pub(crate) fn poll_data(
  type hyper_body_foreach_callback (line 56) | type hyper_body_foreach_callback = extern "C" fn(*mut c_void, *const hyp...
  type hyper_body_data_callback (line 58) | type hyper_body_data_callback =
  function data_noop (line 238) | extern "C" fn data_noop(
  method as_task_type (line 299) | fn as_task_type(&self) -> hyper_task_return_type {

FILE: src/ffi/client.rs
  type hyper_clientconn_options (line 24) | pub struct hyper_clientconn_options {
  type hyper_clientconn (line 71) | pub struct hyper_clientconn {
  type Tx (line 75) | enum Tx {
  method as_task_type (line 173) | fn as_task_type(&self) -> hyper_task_return_type {

FILE: src/ffi/error.rs
  type hyper_error (line 13) | pub struct hyper_error(crate::Error);
    method code (line 41) | fn code(&self) -> hyper_code {
    method print_to (line 54) | fn print_to(&self, dst: &mut [u8]) -> usize {
  type hyper_code (line 17) | pub enum hyper_code {

FILE: src/ffi/http_types.rs
  type hyper_request (line 31) | pub struct hyper_request(pub(super) Request<IncomingBody>);
    method finalize_request (line 292) | pub(super) fn finalize_request(&mut self) {
  type hyper_response (line 51) | pub struct hyper_response(pub(super) Response<IncomingBody>);
    method wrap (line 391) | pub(super) fn wrap(mut resp: Response<IncomingBody>) -> hyper_response {
    method reason_phrase (line 410) | fn reason_phrase(&self) -> &[u8] {
  type hyper_headers (line 66) | pub struct hyper_headers {
    method get_or_default (line 435) | pub(super) fn get_or_default(ext: &mut http::Extensions) -> &mut hyper...
  type OnInformational (line 73) | struct OnInformational {
    method on_informational (line 583) | fn on_informational(&self, res: http::Response<()>) {
  type hyper_request_on_informational_callback (line 78) | type hyper_request_on_informational_callback = extern "C" fn(*mut c_void...
  method as_task_type (line 424) | fn as_task_type(&self) -> hyper_task_return_type {
  type hyper_headers_foreach_callback (line 431) | type hyper_headers_foreach_callback =
  method default (line 549) | fn default() -> Self {
  function raw_name_value (line 558) | unsafe fn raw_name_value(
  function test_headers_foreach_cases_preserved (line 595) | fn test_headers_foreach_cases_preserved() {
  function test_headers_foreach_order_preserved (line 645) | fn test_headers_foreach_order_preserved() {

FILE: src/ffi/io.rs
  constant HYPER_IO_PENDING (line 11) | pub const HYPER_IO_PENDING: size_t = 0xFFFFFFFF;
  constant HYPER_IO_ERROR (line 14) | pub const HYPER_IO_ERROR: size_t = 0xFFFFFFFE;
  type hyper_io_read_callback (line 16) | type hyper_io_read_callback =
  type hyper_io_write_callback (line 18) | type hyper_io_write_callback =
  type hyper_io (line 35) | pub struct hyper_io {
  function read_noop (line 125) | extern "C" fn read_noop(
  function write_noop (line 135) | extern "C" fn write_noop(
  method poll_read (line 145) | fn poll_read(
  method poll_write (line 170) | fn poll_write(
  method poll_flush (line 188) | fn poll_flush(self: Pin<&mut Self>, _: &mut Context<'_>) -> Poll<std::io...
  method poll_shutdown (line 192) | fn poll_shutdown(self: Pin<&mut Self>, _: &mut Context<'_>) -> Poll<std:...

FILE: src/ffi/mod.rs
  constant HYPER_ITER_CONTINUE (line 65) | pub const HYPER_ITER_CONTINUE: std::ffi::c_int = 0;
  constant HYPER_ITER_BREAK (line 68) | pub const HYPER_ITER_BREAK: std::ffi::c_int = 1;
  constant HYPER_HTTP_VERSION_NONE (line 71) | pub const HYPER_HTTP_VERSION_NONE: std::ffi::c_int = 0;
  constant HYPER_HTTP_VERSION_1_0 (line 73) | pub const HYPER_HTTP_VERSION_1_0: std::ffi::c_int = 10;
  constant HYPER_HTTP_VERSION_1_1 (line 75) | pub const HYPER_HTTP_VERSION_1_1: std::ffi::c_int = 11;
  constant HYPER_HTTP_VERSION_2 (line 77) | pub const HYPER_HTTP_VERSION_2: std::ffi::c_int = 20;
  type UserDataPointer (line 80) | struct UserDataPointer(*mut std::ffi::c_void);
  type size_t (line 92) | type size_t = usize;

FILE: src/ffi/task.rs
  type BoxFuture (line 16) | type BoxFuture<T> = Pin<Box<dyn Future<Output = T> + Send>>;
  type BoxAny (line 17) | type BoxAny = Box<dyn AsTaskType + Send + Sync>;
  constant HYPER_POLL_READY (line 20) | pub const HYPER_POLL_READY: c_int = 0;
  constant HYPER_POLL_PENDING (line 25) | pub const HYPER_POLL_PENDING: c_int = 1;
  constant HYPER_POLL_ERROR (line 27) | pub const HYPER_POLL_ERROR: c_int = 3;
  type hyper_executor (line 52) | pub struct hyper_executor {
    method new (line 184) | fn new() -> Arc<hyper_executor> {
    method downgrade (line 192) | pub(crate) fn downgrade(exec: &Arc<hyper_executor>) -> WeakExec {
    method spawn (line 196) | fn spawn(&self, task: Box<hyper_task>) {
    method poll_next (line 203) | fn poll_next(&self) -> Option<Box<hyper_task>> {
    method drain_queue (line 240) | fn drain_queue(&self) -> bool {
  type WeakExec (line 74) | pub(crate) struct WeakExec(Weak<hyper_executor>);
    method new (line 265) | pub(crate) fn new() -> Self {
    method execute (line 275) | fn execute(&self, fut: F) {
  type ExecWaker (line 76) | struct ExecWaker(AtomicBool);
    method wake_by_ref (line 257) | fn wake_by_ref(me: &Arc<ExecWaker>) {
  type hyper_task (line 113) | pub struct hyper_task {
    method boxed (line 343) | pub(crate) fn boxed<F>(fut: F) -> Box<hyper_task>
    method output_type (line 355) | fn output_type(&self) -> hyper_task_return_type {
  type TaskFuture (line 119) | struct TaskFuture {
  type hyper_context (line 129) | pub struct hyper_context<'a>(Context<'a>);
  type hyper_waker (line 154) | pub struct hyper_waker {
  type hyper_task_return_type (line 160) | pub enum hyper_task_return_type {
  type AsTaskType (line 173) | pub(crate) unsafe trait AsTaskType {
    method as_task_type (line 174) | fn as_task_type(&self) -> hyper_task_return_type;
    method as_task_type (line 454) | fn as_task_type(&self) -> hyper_task_return_type {
    method as_task_type (line 460) | fn as_task_type(&self) -> hyper_task_return_type {
  type IntoDynTaskType (line 177) | pub(crate) trait IntoDynTaskType {
    method into_dyn_task_type (line 178) | fn into_dyn_task_type(self) -> BoxAny;
    method into_dyn_task_type (line 469) | fn into_dyn_task_type(self) -> BoxAny {
    method into_dyn_task_type (line 478) | fn into_dyn_task_type(self) -> BoxAny {
    method into_dyn_task_type (line 490) | fn into_dyn_task_type(self) -> BoxAny {
  type Output (line 364) | type Output = Box<hyper_task>;
  method poll (line 366) | fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Ou...
  function wrap (line 501) | pub(crate) fn wrap<'a, 'b>(cx: &'a mut Context<'b>) -> &'a mut hyper_con...

FILE: src/headers.rs
  function connection_keep_alive (line 13) | pub(super) fn connection_keep_alive(value: &HeaderValue) -> bool {
  function connection_close (line 18) | pub(super) fn connection_close(value: &HeaderValue) -> bool {
  function connection_has (line 23) | fn connection_has(value: &HeaderValue, needle: &str) -> bool {
  function content_length_parse (line 35) | pub(super) fn content_length_parse(value: &HeaderValue) -> Option<u64> {
  function content_length_parse_all (line 40) | pub(super) fn content_length_parse_all(headers: &HeaderMap) -> Option<u6...
  function content_length_parse_all_values (line 45) | pub(super) fn content_length_parse_all_values(values: ValueIter<'_, Head...
  function from_digits (line 72) | fn from_digits(bytes: &[u8]) -> Option<u64> {
  function method_has_defined_payload_semantics (line 100) | pub(super) fn method_has_defined_payload_semantics(method: &Method) -> b...
  function set_content_length_if_missing (line 108) | pub(super) fn set_content_length_if_missing(headers: &mut HeaderMap, len...
  function transfer_encoding_is_chunked (line 115) | pub(super) fn transfer_encoding_is_chunked(headers: &HeaderMap) -> bool {
  function is_chunked (line 120) | pub(super) fn is_chunked(mut encodings: ValueIter<'_, HeaderValue>) -> b...
  function is_chunked_ (line 130) | pub(super) fn is_chunked_(value: &HeaderValue) -> bool {
  function add_chunked (line 142) | pub(super) fn add_chunked(mut entry: http::header::OccupiedEntry<'_, Hea...

FILE: src/proto/h1/conn.rs
  constant H2_PREFACE (line 29) | const H2_PREFACE: &[u8] = b"PRI * HTTP/2.0\r\n\r\nSM\r\n\r\n";
  type Conn (line 38) | pub(crate) struct Conn<I, B, T> {
  function new (line 50) | pub(crate) fn new(io: I) -> Conn<I, B, T> {
  function set_timer (line 92) | pub(crate) fn set_timer(&mut self, timer: Time) {
  function set_flush_pipeline (line 97) | pub(crate) fn set_flush_pipeline(&mut self, enabled: bool) {
  function set_write_strategy_queue (line 101) | pub(crate) fn set_write_strategy_queue(&mut self) {
  function set_max_buf_size (line 105) | pub(crate) fn set_max_buf_size(&mut self, max: usize) {
  function set_read_buf_exact_size (line 110) | pub(crate) fn set_read_buf_exact_size(&mut self, sz: usize) {
  function set_write_strategy_flatten (line 114) | pub(crate) fn set_write_strategy_flatten(&mut self) {
  function set_h1_parser_config (line 118) | pub(crate) fn set_h1_parser_config(&mut self, parser_config: ParserConfi...
  function set_title_case_headers (line 122) | pub(crate) fn set_title_case_headers(&mut self) {
  function set_preserve_header_case (line 126) | pub(crate) fn set_preserve_header_case(&mut self) {
  function set_preserve_header_order (line 131) | pub(crate) fn set_preserve_header_order(&mut self) {
  function set_h09_responses (line 136) | pub(crate) fn set_h09_responses(&mut self) {
  function set_http1_max_headers (line 140) | pub(crate) fn set_http1_max_headers(&mut self, val: usize) {
  function set_http1_header_read_timeout (line 145) | pub(crate) fn set_http1_header_read_timeout(&mut self, val: Duration) {
  function set_allow_half_close (line 150) | pub(crate) fn set_allow_half_close(&mut self) {
  function disable_date_header (line 155) | pub(crate) fn disable_date_header(&mut self) {
  function into_inner (line 159) | pub(crate) fn into_inner(self) -> (I, Bytes) {
  function pending_upgrade (line 163) | pub(crate) fn pending_upgrade(&mut self) -> Option<crate::upgrade::Pendi...
  function is_read_closed (line 167) | pub(crate) fn is_read_closed(&self) -> bool {
  function is_write_closed (line 171) | pub(crate) fn is_write_closed(&self) -> bool {
  function can_read_head (line 175) | pub(crate) fn can_read_head(&self) -> bool {
  function can_read_body (line 187) | pub(crate) fn can_read_body(&self) -> bool {
  function has_initial_read_write_state (line 195) | pub(crate) fn has_initial_read_write_state(&self) -> bool {
  function should_error_on_eof (line 201) | fn should_error_on_eof(&self) -> bool {
  function has_h2_prefix (line 206) | fn has_h2_prefix(&self) -> bool {
  function poll_read_head (line 211) | pub(super) fn poll_read_head(
  function on_read_head_error (line 337) | fn on_read_head_error<Z>(&mut self, e: crate::Error) -> Poll<Option<crat...
  function poll_read_body (line 363) | pub(crate) fn poll_read_body(
  function wants_read_again (line 428) | pub(crate) fn wants_read_again(&mut self) -> bool {
  function poll_read_keep_alive (line 434) | pub(crate) fn poll_read_keep_alive(&mut self, cx: &mut Context<'_>) -> P...
  function is_mid_message (line 446) | fn is_mid_message(&self) -> bool {
  function require_empty_read (line 457) | fn require_empty_read(&mut self, cx: &mut Context<'_>) -> Poll<crate::Re...
  function mid_message_detect_eof (line 490) | fn mid_message_detect_eof(&mut self, cx: &mut Context<'_>) -> Poll<crate...
  function force_io_read (line 509) | fn force_io_read(&mut self, cx: &mut Context<'_>) -> Poll<io::Result<usi...
  function maybe_notify (line 520) | fn maybe_notify(&mut self, cx: &mut Context<'_>) {
  function try_keep_alive (line 567) | fn try_keep_alive(&mut self, cx: &mut Context<'_>) {
  function can_write_head (line 572) | pub(crate) fn can_write_head(&self) -> bool {
  function can_write_body (line 583) | pub(crate) fn can_write_body(&self) -> bool {
  function can_buffer_body (line 590) | pub(crate) fn can_buffer_body(&self) -> bool {
  function write_head (line 594) | pub(crate) fn write_head(&mut self, head: MessageHead<T::Outgoing>, body...
  function encode_head (line 606) | fn encode_head(
  function fix_keep_alive (line 655) | fn fix_keep_alive(&mut self, head: &mut MessageHead<T::Outgoing>) {
  function enforce_version (line 681) | fn enforce_version(&mut self, head: &mut MessageHead<T::Outgoing>) {
  function write_body (line 703) | pub(crate) fn write_body(&mut self, chunk: B) {
  function write_trailers (line 728) | pub(crate) fn write_trailers(&mut self, trailers: HeaderMap) {
  function write_body_and_end (line 753) | pub(crate) fn write_body_and_end(&mut self, chunk: B) {
  function end_body (line 773) | pub(crate) fn end_body(&mut self) -> crate::Result<()> {
  function on_parse_error (line 808) | fn on_parse_error(&mut self, err: crate::Error) -> crate::Result<()> {
  function poll_flush (line 827) | pub(crate) fn poll_flush(&mut self, cx: &mut Context<'_>) -> Poll<io::Re...
  function poll_shutdown (line 834) | pub(crate) fn poll_shutdown(&mut self, cx: &mut Context<'_>) -> Poll<io:...
  function poll_drain_or_close_read (line 848) | pub(super) fn poll_drain_or_close_read(&mut self, cx: &mut Context<'_>) {
  function close_read (line 866) | pub(crate) fn close_read(&mut self) {
  function close_write (line 870) | pub(crate) fn close_write(&mut self) {
  function disable_keep_alive (line 875) | pub(crate) fn disable_keep_alive(&mut self) {
  function take_error (line 885) | pub(crate) fn take_error(&mut self) -> crate::Result<()> {
  function on_upgrade (line 893) | pub(super) fn on_upgrade(&mut self) -> crate::upgrade::OnUpgrade {
  function fmt (line 900) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  type State (line 911) | struct State {
    method fmt (line 979) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
    method close (line 1048) | fn close(&mut self) {
    method close_read (line 1055) | fn close_read(&mut self) {
    method close_write (line 1061) | fn close_write(&mut self) {
    method wants_keep_alive (line 1067) | fn wants_keep_alive(&self) -> bool {
    method try_keep_alive (line 1071) | fn try_keep_alive<T: Http1Transaction>(&mut self) {
    method disable_keep_alive (line 1092) | fn disable_keep_alive(&mut self) {
    method busy (line 1096) | fn busy(&mut self) {
    method idle (line 1103) | fn idle<T: Http1Transaction>(&mut self) {
    method is_idle (line 1135) | fn is_idle(&self) -> bool {
    method is_read_closed (line 1139) | fn is_read_closed(&self) -> bool {
    method is_write_closed (line 1143) | fn is_write_closed(&self) -> bool {
    method prepare_upgrade (line 1147) | fn prepare_upgrade(&mut self) -> crate::upgrade::OnUpgrade {
  type Reading (line 963) | enum Reading {
  type Writing (line 971) | enum Writing {
    method fmt (line 1002) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  type KA (line 1022) | enum KA {
    method bitand_assign (line 1013) | fn bitand_assign(&mut self, enabled: bool) {
    method idle (line 1030) | fn idle(&mut self) {
    method busy (line 1034) | fn busy(&mut self) {
    method disable (line 1038) | fn disable(&mut self) {
    method status (line 1042) | fn status(&self) -> KA {
  function bench_read_head_short (line 1158) | fn bench_read_head_short(b: &mut ::test::Bencher) {

FILE: src/proto/h1/decode.rs
  constant CHUNKED_EXTENSIONS_LIMIT (line 20) | const CHUNKED_EXTENSIONS_LIMIT: u64 = 1024 * 16;
  constant TRAILER_LIMIT (line 25) | const TRAILER_LIMIT: usize = 1024 * 16;
  type Decoder (line 32) | pub(crate) struct Decoder {
    method length (line 89) | pub(crate) fn length(x: u64) -> Decoder {
    method chunked (line 95) | pub(crate) fn chunked(
    method eof (line 112) | pub(crate) fn eof() -> Decoder {
    method new (line 118) | pub(super) fn new(
    method is_eof (line 132) | pub(crate) fn is_eof(&self) -> bool {
    method decode (line 144) | pub(crate) fn decode<R: MemRead>(
    method decode_fut (line 248) | async fn decode_fut<R: MemRead>(&mut self, body: &mut R) -> Result<Fra...
    method fmt (line 254) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  type Kind (line 37) | enum Kind {
  type ChunkedState (line 70) | enum ChunkedState {
    method new (line 307) | fn new() -> ChunkedState {
    method step (line 310) | fn step<R: MemRead>(
    method read_start (line 349) | fn read_start<R: MemRead>(
    method read_size (line 381) | fn read_size<R: MemRead>(
    method read_size_lws (line 414) | fn read_size_lws<R: MemRead>(
    method read_extension (line 430) | fn read_extension<R: MemRead>(
    method read_size_lf (line 461) | fn read_size_lf<R: MemRead>(
    method read_body (line 483) | fn read_body<R: MemRead>(
    method read_body_cr (line 517) | fn read_body_cr<R: MemRead>(
    method read_body_lf (line 529) | fn read_body_lf<R: MemRead>(
    method read_trailer (line 542) | fn read_trailer<R: MemRead>(
    method read_trailer_lf (line 563) | fn read_trailer_lf<R: MemRead>(
    method read_end_cr (line 597) | fn read_end_cr<R: MemRead>(
    method read_end_lf (line 628) | fn read_end_lf<R: MemRead>(
  type StepArgs (line 296) | struct StepArgs<'a> {
  function decode_trailers (line 651) | fn decode_trailers(buf: &mut BytesMut, count: usize) -> Result<HeaderMap...
  type IncompleteBody (line 693) | struct IncompleteBody;
    method fmt (line 696) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  method read_mem (line 711) | fn read_mem(&mut self, _: &mut Context<'_>, len: usize) -> Poll<io::Resu...
  method read_mem (line 725) | fn read_mem(&mut self, cx: &mut Context<'_>, len: usize) -> Poll<io::Res...
  method read_mem (line 734) | fn read_mem(&mut self, _: &mut Context<'_>, len: usize) -> Poll<io::Resu...
  function test_read_chunk_size (line 753) | async fn test_read_chunk_size() {
  function test_read_sized_early_eof (line 869) | async fn test_read_sized_early_eof() {
  function test_read_chunked_early_eof (line 888) | async fn test_read_chunked_early_eof() {
  function test_read_chunked_single_read (line 910) | async fn test_read_chunked_single_read() {
  function test_read_chunked_with_missing_zero_digit (line 924) | async fn test_read_chunked_with_missing_zero_digit() {
  function test_read_chunked_extensions_over_limit (line 944) | async fn test_read_chunked_extensions_over_limit() {
  function test_read_chunked_trailer_with_missing_lf (line 976) | async fn test_read_chunked_trailer_with_missing_lf() {
  function test_read_chunked_after_eof (line 986) | async fn test_read_chunked_after_eof() {
  function read_async (line 1022) | async fn read_async(mut decoder: Decoder, content: &[u8], block_at: usiz...
  function all_async_cases (line 1058) | async fn all_async_cases(content: &str, expected: &str, decoder: Decoder) {
  function test_read_length_async (line 1068) | async fn test_read_length_async() {
  function test_read_chunked_async (line 1075) | async fn test_read_chunked_async() {
  function test_read_eof_async (line 1083) | async fn test_read_eof_async() {
  function bench_decode_chunked_1kb (line 1090) | fn bench_decode_chunked_1kb(b: &mut test::Bencher) {
  function bench_decode_length_1kb (line 1119) | fn bench_decode_length_1kb(b: &mut test::Bencher) {
  function new_runtime (line 1142) | fn new_runtime() -> tokio::runtime::Runtime {
  function test_decode_trailers (line 1150) | fn test_decode_trailers() {
  function test_trailer_max_headers_enforced (line 1165) | async fn test_trailer_max_headers_enforced() {
  function test_trailer_max_header_size_huge_trailer (line 1195) | async fn test_trailer_max_header_size_huge_trailer() {
  function test_trailer_max_header_size_many_small_trailers (line 1223) | async fn test_trailer_max_header_size_many_small_trailers() {

FILE: src/proto/h1/dispatch.rs
  type Dispatcher (line 22) | pub(crate) struct Dispatcher<D, Bs: Body, I, T> {
  type Dispatch (line 30) | pub(crate) trait Dispatch {
    method poll_msg (line 35) | fn poll_msg(
    method recv_msg (line 39) | fn recv_msg(&mut self, msg: crate::Result<(Self::RecvItem, IncomingBod...
    method poll_ready (line 41) | fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll<Result<(), ()>>;
    method should_poll (line 42) | fn should_poll(&self) -> bool;
  function new (line 80) | pub(crate) fn new(dispatch: D, conn: Conn<I, Bs::Data, T>) -> Self {
  function disable_keep_alive (line 91) | pub(crate) fn disable_keep_alive(&mut self) {
  function into_inner (line 102) | pub(crate) fn into_inner(self) -> (I, Bytes, D) {
  function poll_without_shutdown (line 112) | pub(crate) fn poll_without_shutdown(
  function poll_catch (line 123) | fn poll_catch(
  function poll_inner (line 142) | fn poll_inner(
  function poll_loop (line 165) | fn poll_loop(&mut self, cx: &mut Context<'_>) -> Poll<crate::Result<()>> {
  function poll_read (line 195) | fn poll_read(&mut self, cx: &mut Context<'_>) -> Poll<crate::Result<()>> {
  function poll_read_head (line 271) | fn poll_read_head(&mut self, cx: &mut Context<'_>) -> Poll<crate::Result...
  function poll_write (line 328) | fn poll_write(&mut self, cx: &mut Context<'_>) -> Poll<crate::Result<()>> {
  function poll_flush (line 423) | fn poll_flush(&mut self, cx: &mut Context<'_>) -> Poll<crate::Result<()>> {
  function close (line 430) | fn close(&mut self) {
  function is_done (line 436) | fn is_done(&self) -> bool {
  type Output (line 467) | type Output = crate::Result<Dispatched>;
  method poll (line 470) | fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Ou...
  type OptGuard (line 479) | struct OptGuard<'a, T>(Pin<&'a mut Option<T>>, bool);
  function new (line 482) | fn new(pin: Pin<&'a mut Option<T>>) -> Self {
  function guard_mut (line 486) | fn guard_mut(&mut self) -> (Option<Pin<&mut T>>, &mut bool) {
  method drop (line 492) | fn drop(&mut self) {
  function client_read_bytes_before_writing_request (line 713) | fn client_read_bytes_before_writing_request() {
  function client_flushing_is_not_ready_for_next_request (line 749) | async fn client_flushing_is_not_ready_for_next_request() {
  function body_empty_chunks_ignored (line 781) | async fn body_empty_chunks_ignored() {

FILE: src/proto/h1/encode.rs
  type StaticBuf (line 18) | type StaticBuf = &'static [u8];
  type Encoder (line 22) | pub(crate) struct Encoder {
    method new (line 61) | fn new(kind: Kind) -> Encoder {
    method chunked (line 67) | pub(crate) fn chunked() -> Encoder {
    method length (line 71) | pub(crate) fn length(len: u64) -> Encoder {
    method close_delimited (line 76) | pub(crate) fn close_delimited() -> Encoder {
    method into_chunked_with_trailing_fields (line 80) | pub(crate) fn into_chunked_with_trailing_fields(self, trailers: Vec<He...
    method is_eof (line 90) | pub(crate) fn is_eof(&self) -> bool {
    method set_last (line 95) | pub(crate) fn set_last(mut self, is_last: bool) -> Self {
    method is_last (line 100) | pub(crate) fn is_last(&self) -> bool {
    method is_close_delimited (line 104) | pub(crate) fn is_close_delimited(&self) -> bool {
    method is_chunked (line 112) | pub(crate) fn is_chunked(&self) -> bool {
    method end (line 116) | pub(crate) fn end<B>(&self) -> Result<Option<EncodedBuf<B>>, NotEof> {
    method encode (line 128) | pub(crate) fn encode<B>(&mut self, msg: B) -> EncodedBuf<B>
    method encode_trailers (line 163) | pub(crate) fn encode_trailers<B>(
    method encode_and_end (line 219) | pub(super) fn encode_and_end<B>(&self, msg: B, dst: &mut WriteBuf<Enco...
  type EncodedBuf (line 28) | pub(crate) struct EncodedBuf<B> {
  type NotEof (line 33) | pub(crate) struct NotEof(u64);
    method fmt (line 423) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  type Kind (line 36) | enum Kind {
  type BufKind (line 52) | enum BufKind<B> {
  function is_valid_trailer_field (line 264) | fn is_valid_trailer_field(name: &HeaderName) -> bool {
  method remaining (line 287) | fn remaining(&self) -> usize {
  method chunk (line 298) | fn chunk(&self) -> &[u8] {
  method advance (line 309) | fn advance(&mut self, cnt: usize) {
  method chunks_vectored (line 320) | fn chunks_vectored<'t>(&'t self, dst: &mut [IoSlice<'t>]) -> usize {
  constant USIZE_BYTES (line 332) | const USIZE_BYTES: usize = 4;
  constant USIZE_BYTES (line 335) | const USIZE_BYTES: usize = 8;
  constant CHUNK_SIZE_MAX_BYTES (line 338) | const CHUNK_SIZE_MAX_BYTES: usize = USIZE_BYTES * 2;
  type ChunkSize (line 341) | struct ChunkSize {
    method new (line 348) | fn new(len: usize) -> ChunkSize {
    method fmt (line 379) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
    method write_str (line 388) | fn write_str(&mut self, num: &str) -> fmt::Result {
  method remaining (line 362) | fn remaining(&self) -> usize {
  method chunk (line 367) | fn chunk(&self) -> &[u8] {
  method advance (line 372) | fn advance(&mut self, cnt: usize) {
  function from (line 399) | fn from(buf: B) -> Self {
  function from (line 407) | fn from(buf: Take<B>) -> Self {
  function from (line 415) | fn from(buf: Chain<Chain<ChunkSize, B>, StaticBuf>) -> Self {
  function chunked (line 445) | fn chunked() {
  function length (line 470) | fn length() {
  function eof (line 495) | fn eof() {
  function chunked_with_valid_trailers (line 517) | fn chunked_with_valid_trailers() {
  function chunked_with_multiple_trailer_headers (line 541) | fn chunked_with_multiple_trailer_headers() {
  function chunked_with_no_trailer_header (line 571) | fn chunked_with_no_trailer_header() {
  function chunked_with_invalid_trailers (line 590) | fn chunked_with_invalid_trailers() {
  function chunked_with_title_case_headers (line 627) | fn chunked_with_title_case_headers() {
  function chunked_trailers_case_insensitive_matching (line 644) | fn chunked_trailers_case_insensitive_matching() {

FILE: src/proto/h1/io.rs
  constant INIT_BUFFER_SIZE (line 15) | pub(crate) const INIT_BUFFER_SIZE: usize = 8192;
  constant MINIMUM_MAX_BUFFER_SIZE (line 18) | pub(crate) const MINIMUM_MAX_BUFFER_SIZE: usize = INIT_BUFFER_SIZE;
  constant DEFAULT_MAX_BUFFER_SIZE (line 23) | pub(crate) const DEFAULT_MAX_BUFFER_SIZE: usize = 8192 + 4096 * 100;
  constant MAX_BUF_LIST_BUFFERS (line 30) | const MAX_BUF_LIST_BUFFERS: usize = 16;
  type Buffered (line 32) | pub(crate) struct Buffered<T, B> {
  function fmt (line 46) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  function new (line 59) | pub(crate) fn new(io: T) -> Buffered<T, B> {
  function set_flush_pipeline (line 78) | pub(crate) fn set_flush_pipeline(&mut self, enabled: bool) {
  function set_max_buf_size (line 86) | pub(crate) fn set_max_buf_size(&mut self, max: usize) {
  function set_read_buf_exact_size (line 97) | pub(crate) fn set_read_buf_exact_size(&mut self, sz: usize) {
  function set_write_strategy_flatten (line 101) | pub(crate) fn set_write_strategy_flatten(&mut self) {
  function set_write_strategy_queue (line 108) | pub(crate) fn set_write_strategy_queue(&mut self) {
  function read_buf (line 115) | pub(crate) fn read_buf(&self) -> &[u8] {
  function read_buf_mut (line 121) | pub(super) fn read_buf_mut(&mut self) -> &mut BytesMut {
  function read_buf_remaining_mut (line 127) | fn read_buf_remaining_mut(&self) -> usize {
  function can_headers_buf (line 136) | pub(crate) fn can_headers_buf(&self) -> bool {
  function headers_buf (line 140) | pub(crate) fn headers_buf(&mut self) -> &mut Vec<u8> {
  function write_buf (line 145) | pub(super) fn write_buf(&mut self) -> &mut WriteBuf<B> {
  function buffer (line 149) | pub(crate) fn buffer<BB: Buf + Into<B>>(&mut self, buf: BB) {
  function can_buffer (line 153) | pub(crate) fn can_buffer(&self) -> bool {
  function consume_leading_lines (line 157) | pub(crate) fn consume_leading_lines(&mut self) {
  function parse (line 170) | pub(super) fn parse<S>(
  function poll_read_from_io (line 223) | pub(crate) fn poll_read_from_io(&mut self, cx: &mut Context<'_>) -> Poll...
  function into_inner (line 255) | pub(crate) fn into_inner(self) -> (T, Bytes) {
  function io_mut (line 259) | pub(crate) fn io_mut(&mut self) -> &mut T {
  function is_read_blocked (line 263) | pub(crate) fn is_read_blocked(&self) -> bool {
  function poll_flush (line 267) | pub(crate) fn poll_flush(&mut self, cx: &mut Context<'_>) -> Poll<io::Re...
  function poll_flush_flattened (line 307) | fn poll_flush_flattened(&mut self, cx: &mut Context<'_>) -> Poll<io::Res...
  function flush (line 327) | fn flush(&mut self) -> impl std::future::Future<Output = io::Result<()>>...
  type MemRead (line 336) | pub(crate) trait MemRead {
    method read_mem (line 337) | fn read_mem(&mut self, cx: &mut Context<'_>, len: usize) -> Poll<io::R...
    method read_mem (line 345) | fn read_mem(&mut self, cx: &mut Context<'_>, len: usize) -> Poll<io::R...
  type ReadStrategy (line 357) | enum ReadStrategy {
    method with_max (line 368) | fn with_max(max: usize) -> ReadStrategy {
    method next (line 376) | fn next(&self) -> usize {
    method max (line 384) | fn max(&self) -> usize {
    method record (line 392) | fn record(&mut self, bytes_read: usize) {
  function incr_power_of_two (line 427) | fn incr_power_of_two(n: usize) -> usize {
  function prev_power_of_two (line 431) | fn prev_power_of_two(n: usize) -> usize {
  method default (line 439) | fn default() -> ReadStrategy {
  type Cursor (line 445) | pub(crate) struct Cursor<T> {
  function new (line 452) | pub(crate) fn new(bytes: T) -> Cursor<T> {
  function maybe_unshift (line 461) | fn maybe_unshift(&mut self, additional: usize) {
  function reset (line 476) | fn reset(&mut self) {
  function fmt (line 483) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  method remaining (line 493) | fn remaining(&self) -> usize {
  method chunk (line 498) | fn chunk(&self) -> &[u8] {
  method advance (line 503) | fn advance(&mut self, cnt: usize) {
  type WriteBuf (line 510) | pub(super) struct WriteBuf<B> {
  function new (line 520) | fn new(strategy: WriteStrategy) -> WriteBuf<B> {
  function set_strategy (line 534) | fn set_strategy(&mut self, strategy: WriteStrategy) {
  function buffer (line 538) | pub(super) fn buffer<BB: Buf + Into<B>>(&mut self, mut buf: BB) {
  function can_buffer (line 575) | fn can_buffer(&self) -> bool {
  function headers_mut (line 584) | fn headers_mut(&mut self) -> &mut Cursor<Vec<u8>> {
  function fmt (line 591) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  method remaining (line 601) | fn remaining(&self) -> usize {
  method chunk (line 606) | fn chunk(&self) -> &[u8] {
  method advance (line 616) | fn advance(&mut self, cnt: usize) {
  method chunks_vectored (line 631) | fn chunks_vectored<'t>(&'t self, dst: &mut [IoSlice<'t>]) -> usize {
  type WriteStrategy (line 638) | enum WriteStrategy {
  function iobuf_write_empty_slice (line 666) | async fn iobuf_write_empty_slice() {
  function parse_reads_until_blocked (line 687) | async fn parse_reads_until_blocked() {
  function read_strategy_adaptive_increments (line 730) | fn read_strategy_adaptive_increments() {
  function read_strategy_adaptive_decrements (line 756) | fn read_strategy_adaptive_decrements() {
  function read_strategy_adaptive_stays_the_same (line 787) | fn read_strategy_adaptive_stays_the_same() {
  function read_strategy_adaptive_max_fuzz (line 808) | fn read_strategy_adaptive_max_fuzz() {
  function write_buf_requires_non_empty_bufs (line 839) | fn write_buf_requires_non_empty_bufs() {
  function write_buf_flatten (line 871) | async fn write_buf_flatten() {
  function write_buf_flatten_partially_flushed (line 889) | fn write_buf_flatten_partially_flushed() {
  function write_buf_queue_disable_auto (line 925) | async fn write_buf_queue_disable_auto() {

FILE: src/proto/h1/mod.rs
  type Http1Transaction (line 30) | pub(crate) trait Http1Transaction {
    constant LOG (line 34) | const LOG: &'static str;
    method parse (line 35) | fn parse(bytes: &mut BytesMut, ctx: ParseContext<'_>) -> ParseResult<S...
    method encode (line 36) | fn encode(enc: Encode<'_, Self::Outgoing>, dst: &mut Vec<u8>) -> crate...
    method on_error (line 38) | fn on_error(err: &crate::Error) -> Option<MessageHead<Self::Outgoing>>;
    method is_client (line 40) | fn is_client() -> bool {
    method is_server (line 44) | fn is_server() -> bool {
    method should_error_on_parse_eof (line 48) | fn should_error_on_parse_eof() -> bool {
    method should_read_first (line 52) | fn should_read_first() -> bool {
    method update_date (line 56) | fn update_date() {}
  type ParseResult (line 60) | pub(crate) type ParseResult<T> = Result<Option<ParsedMessage<T>>, crate:...
  type ParsedMessage (line 63) | pub(crate) struct ParsedMessage<T> {
  type ParseContext (line 71) | pub(crate) struct ParseContext<'a> {
  type Encode (line 85) | pub(crate) struct Encode<'a, T> {
  type Wants (line 98) | struct Wants(u8);
    constant EMPTY (line 101) | const EMPTY: Wants = Wants(0b00);
    constant EXPECT (line 102) | const EXPECT: Wants = Wants(0b01);
    constant UPGRADE (line 103) | const UPGRADE: Wants = Wants(0b10);
    method add (line 106) | fn add(self, other: Wants) -> Wants {
    method contains (line 110) | fn contains(&self, other: Wants) -> bool {

FILE: src/proto/h1/role.rs
  constant DEFAULT_MAX_HEADERS (line 31) | pub(crate) const DEFAULT_MAX_HEADERS: usize = 100;
  constant AVERAGE_HEADER_SIZE (line 32) | const AVERAGE_HEADER_SIZE: usize = 30;
  constant MAX_URI_LEN (line 34) | const MAX_URI_LEN: usize = (u16::MAX - 1) as usize;
  function parse_headers (line 67) | pub(super) fn parse_headers<T>(
  function is_complete_fast (line 94) | fn is_complete_fast(bytes: &[u8], prev_len: usize) -> bool {
  function encode_headers (line 111) | pub(super) fn encode_headers<T>(
  type Client (line 125) | pub(crate) enum Client {}
    method decoder (line 1246) | fn decoder(
    method set_length (line 1309) | fn set_length(head: &mut RequestHead, body: Option<BodyLength>) -> Enc...
    method obs_fold_line (line 1442) | fn obs_fold_line(all: &mut [u8], idx: &mut HeaderIndices) {
  type Server (line 128) | pub(crate) enum Server {}
    method can_have_body (line 496) | fn can_have_body(method: &Option<Method>, status: StatusCode) -> bool {
    method can_chunked (line 500) | fn can_chunked(method: &Option<Method>, status: StatusCode) -> bool {
    method can_have_content_length (line 511) | fn can_have_content_length(method: &Option<Method>, status: StatusCode...
    method can_have_implicit_zero_content_length (line 519) | fn can_have_implicit_zero_content_length(method: &Option<Method>, stat...
    method encode_headers_with_lower_case (line 523) | fn encode_headers_with_lower_case(
    method encode_headers_with_original_case (line 564) | fn encode_headers_with_original_case(
    method encode_headers (line 634) | fn encode_headers<W>(
    method record_path_range (line 980) | fn record_path_range(bytes: &[u8], req_path: &str) -> std::ops::Range<...
  type Incoming (line 132) | type Incoming = RequestLine;
  type Outgoing (line 133) | type Outgoing = StatusCode;
  constant LOG (line 135) | const LOG: &'static str = "{role=server}";
  method parse (line 137) | fn parse(buf: &mut BytesMut, ctx: ParseContext<'_>) -> ParseResult<Reque...
  method encode (line 363) | fn encode(mut msg: Encode<'_, Self::Outgoing>, dst: &mut Vec<u8>) -> cra...
  method on_error (line 465) | fn on_error(err: &crate::Error) -> Option<MessageHead<Self::Outgoing>> {
  method is_server (line 485) | fn is_server() -> bool {
  method update_date (line 489) | fn update_date() {
  type HeaderNameWriter (line 989) | trait HeaderNameWriter {
    method write_full_header_line (line 990) | fn write_full_header_line(
    method write_header_name_with_colon (line 996) | fn write_header_name_with_colon(
    method write_header_name (line 1002) | fn write_header_name(&mut self, dst: &mut Vec<u8>, name: &HeaderName);
  type Incoming (line 1007) | type Incoming = StatusCode;
  type Outgoing (line 1008) | type Outgoing = RequestLine;
  constant LOG (line 1010) | const LOG: &'static str = "{role=client}";
  method parse (line 1012) | fn parse(buf: &mut BytesMut, ctx: ParseContext<'_>) -> ParseResult<Statu...
  method encode (line 1182) | fn encode(msg: Encode<'_, Self::Outgoing>, dst: &mut Vec<u8>) -> crate::...
  method on_error (line 1231) | fn on_error(_err: &crate::Error) -> Option<MessageHead<Self::Outgoing>> {
  method is_client (line 1236) | fn is_client() -> bool {
  function set_content_length (line 1503) | fn set_content_length(headers: &mut HeaderMap, len: u64) -> Encoder {
  type HeaderIndices (line 1537) | struct HeaderIndices {
  function record_header_indices (line 1542) | fn record_header_indices(
  function title_case (line 1569) | fn title_case(dst: &mut Vec<u8>, name: &[u8]) {
  function write_headers_title_case (line 1583) | pub(crate) fn write_headers_title_case(headers: &HeaderMap, dst: &mut Ve...
  function write_headers (line 1592) | pub(crate) fn write_headers(headers: &HeaderMap, dst: &mut Vec<u8>) {
  function write_headers_original_case (line 1603) | fn write_headers_original_case(
  type FastWrite (line 1639) | struct FastWrite<'a>(&'a mut Vec<u8>);
  function write_str (line 1644) | fn write_str(&mut self, s: &str) -> fmt::Result {
  function write_fmt (line 1650) | fn write_fmt(&mut self, args: fmt::Arguments<'_>) -> fmt::Result {
  function extend (line 1656) | fn extend(dst: &mut Vec<u8>, data: &[u8]) {
  function test_parse_request (line 1668) | fn test_parse_request() {
  function test_parse_response (line 1699) | fn test_parse_response() {
  function test_parse_request_errors (line 1724) | fn test_parse_request_errors() {
  constant H09_RESPONSE (line 1741) | const H09_RESPONSE: &str = "Baguettes are super delicious, don't you agr...
  function test_parse_response_h09_allowed (line 1744) | fn test_parse_response_h09_allowed() {
  function test_parse_response_h09_rejected (line 1767) | fn test_parse_response_h09_rejected() {
  constant RESPONSE_WITH_WHITESPACE_BETWEEN_HEADER_NAME_AND_COLON (line 1786) | const RESPONSE_WITH_WHITESPACE_BETWEEN_HEADER_NAME_AND_COLON: &str =
  function test_parse_allow_response_with_spaces_before_colons (line 1790) | fn test_parse_allow_response_with_spaces_before_colons() {
  function test_parse_reject_response_with_spaces_before_colons (line 1818) | fn test_parse_reject_response_with_spaces_before_colons() {
  constant REQUEST_WITH_MULTIPLE_SPACES_IN_REQUEST_LINE (line 1836) | const REQUEST_WITH_MULTIPLE_SPACES_IN_REQUEST_LINE: &str =
  function test_parse_allow_request_with_multiple_spaces_in_request_line (line 1841) | fn test_parse_allow_request_with_multiple_spaces_in_request_line() {
  function test_parse_reject_request_with_multiple_spaces_in_request_line (line 1873) | fn test_parse_reject_request_with_multiple_spaces_in_request_line() {
  function test_parse_preserve_header_case_in_request (line 1893) | fn test_parse_preserve_header_case_in_request() {
  function test_decoder_request (line 1930) | fn test_decoder_request() {
  function test_decoder_response (line 2177) | fn test_decoder_response() {
  function test_client_obs_fold_line (line 2506) | fn test_client_obs_fold_line() {
  function test_client_request_encode_title_case (line 2523) | fn test_client_request_encode_title_case() {
  function test_client_request_encode_orig_case (line 2554) | fn test_client_request_encode_orig_case() {
  function test_client_request_encode_orig_and_title_case (line 2591) | fn test_client_request_encode_orig_and_title_case() {
  function test_server_encode_connect_method (line 2630) | fn test_server_encode_connect_method() {
  function test_server_response_encode_title_case (line 2652) | fn test_server_response_encode_title_case() {
  function test_server_response_encode_orig_case (line 2686) | fn test_server_response_encode_orig_case() {
  function test_server_response_encode_orig_and_title_case (line 2722) | fn test_server_response_encode_orig_and_title_case() {
  function test_disabled_date_header (line 2759) | fn test_disabled_date_header() {
  function parse_header_htabs (line 2794) | fn parse_header_htabs() {
  function parse_too_large_headers (line 2819) | fn parse_too_large_headers() {
  function test_is_complete_fast (line 2948) | fn test_is_complete_fast() {
  function test_write_headers_orig_case_empty_value (line 2970) | fn test_write_headers_orig_case_empty_value() {
  function test_write_headers_orig_case_multiple_entries (line 2987) | fn test_write_headers_orig_case_multiple_entries() {
  function bench_parse_incoming (line 3008) | fn bench_parse_incoming(b: &mut Bencher) {
  function bench_parse_short (line 3070) | fn bench_parse_short(b: &mut Bencher) {
  function bench_server_encode_headers_preset (line 3111) | fn bench_server_encode_headers_preset(b: &mut Bencher) {
  function bench_server_encode_no_headers (line 3145) | fn bench_server_encode_no_headers(b: &mut Bencher) {

FILE: src/proto/h2/client.rs
  type ClientRx (line 35) | type ClientRx<B> = crate::client::dispatch::Receiver<Request<B>, Respons...
  type ConnDropRef (line 39) | type ConnDropRef = mpsc::Sender<Infallible>;
  type ConnEof (line 43) | type ConnEof = oneshot::Receiver<Infallible>;
  constant DEFAULT_CONN_WINDOW (line 48) | const DEFAULT_CONN_WINDOW: u32 = 1024 * 1024 * 5;
  constant DEFAULT_STREAM_WINDOW (line 49) | const DEFAULT_STREAM_WINDOW: u32 = 1024 * 1024 * 2;
  constant DEFAULT_MAX_FRAME_SIZE (line 50) | const DEFAULT_MAX_FRAME_SIZE: u32 = 1024 * 16;
  constant DEFAULT_MAX_SEND_BUF_SIZE (line 51) | const DEFAULT_MAX_SEND_BUF_SIZE: usize = 1024 * 1024;
  constant DEFAULT_MAX_HEADER_LIST_SIZE (line 52) | const DEFAULT_MAX_HEADER_LIST_SIZE: u32 = 1024 * 16;
  constant DEFAULT_INITIAL_MAX_SEND_STREAMS (line 61) | const DEFAULT_INITIAL_MAX_SEND_STREAMS: usize = 100;
  type Config (line 64) | pub(crate) struct Config {
  method default (line 83) | fn default() -> Config {
  function new_builder (line 104) | fn new_builder(config: &Config) -> Builder {
  function new_ping_config (line 132) | fn new_ping_config(config: &Config) -> ping::Config {
  function handshake (line 145) | pub(crate) async fn handshake<T, B, E>(
  function new (line 220) | fn new(ponger: Ponger, conn: Connection<Compat<T>, SendBuf<<B as Body>::...
  type Output (line 230) | type Output = Result<(), h2::Error>;
  method poll (line 232) | fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
  type Output (line 270) | type Output = Result<(), ()>;
  method poll (line 272) | fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
  method is_terminated (line 293) | fn is_terminated(&self) -> bool {
  function new (line 320) | fn new(
  type Output (line 338) | type Output = ();
  method poll (line 340) | fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
  type Output (line 393) | type Output = ();
  method poll (line 395) | fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> std::task::Poll<S...
  type FutCtx (line 406) | struct FutCtx<B>
  type ClientTask (line 420) | pub(crate) struct ClientTask<B, E, T>
  function is_extended_connect_protocol_enabled (line 442) | pub(crate) fn is_extended_connect_protocol_enabled(&self) -> bool {
  type Output (line 466) | type Output = ();
  method poll (line 468) | fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> std::task::Poll<S...
  function poll_pipe (line 494) | fn poll_pipe(&mut self, f: FutCtx<B>, cx: &mut Context<'_>) {
  type Output (line 563) | type Output = Result<Response<crate::body::Incoming>, (crate::Error, Opt...
  method poll (line 565) | fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Ou...
  type Output (line 628) | type Output = crate::Result<Dispatched>;
  method poll (line 630) | fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Ou...

FILE: src/proto/h2/mod.rs
  constant SPEC_WINDOW_SIZE (line 30) | pub(crate) const SPEC_WINDOW_SIZE: u32 = 65_535;
  function strip_connection_headers (line 43) | fn strip_connection_headers(headers: &mut HeaderMap, is_request: bool) {
  function new (line 100) | fn new(stream: S, tx: SendStream<SendBuf<S::Data>>) -> PipeToSendStream<...
  type Output (line 114) | type Output = crate::Result<()>;
  method poll (line 116) | fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
  type SendStreamExt (line 192) | trait SendStreamExt {
    method on_user_err (line 193) | fn on_user_err<E>(&mut self, err: E) -> crate::Error
    method send_eos_frame (line 196) | fn send_eos_frame(&mut self) -> crate::Result<()>;
    method on_user_err (line 200) | fn on_user_err<E>(&mut self, err: E) -> crate::Error
    method send_eos_frame (line 210) | fn send_eos_frame(&mut self) -> crate::Result<()> {
  type SendBuf (line 218) | enum SendBuf<B> {
  method remaining (line 226) | fn remaining(&self) -> usize {
  method chunk (line 235) | fn chunk(&self) -> &[u8] {
  method advance (line 244) | fn advance(&mut self, cnt: usize) {
  method chunks_vectored (line 252) | fn chunks_vectored<'a>(&'a self, dst: &mut [IoSlice<'a>]) -> usize {

FILE: src/proto/h2/ping.rs
  type WindowSize (line 34) | type WindowSize = u32;
  function disabled (line 36) | pub(super) fn disabled() -> Recorder {
  function channel (line 40) | pub(super) fn channel(ping_pong: PingPong, config: Config, timer: Time) ...
  type Config (line 96) | pub(super) struct Config {
    method is_enabled (line 184) | pub(super) fn is_enabled(&self) -> bool {
  type Recorder (line 108) | pub(crate) struct Recorder {
    method record_data (line 192) | pub(crate) fn record_data(&self, len: usize) {
    method record_non_data (line 226) | pub(crate) fn record_non_data(&self) {
    method for_stream (line 241) | pub(super) fn for_stream(self, stream: &h2::RecvStream) -> Self {
    method ensure_not_timed_out (line 249) | pub(super) fn ensure_not_timed_out(&self) -> crate::Result<()> {
  type Ponger (line 112) | pub(super) struct Ponger {
    method poll (line 265) | pub(super) fn poll(&mut self, cx: &mut task::Context<'_>) -> Poll<Pong...
    method is_idle (line 325) | fn is_idle(&self) -> bool {
  type Shared (line 118) | struct Shared {
    method send_ping (line 333) | fn send_ping(&mut self) {
    method is_ping_sent (line 345) | fn is_ping_sent(&self) -> bool {
    method update_last_read_at (line 349) | fn update_last_read_at(&mut self) {
    method last_read_at (line 355) | fn last_read_at(&self) -> Instant {
  type Bdp (line 139) | struct Bdp {
    method calculate (line 366) | fn calculate(&mut self, bytes: usize, rtt: Duration) -> Option<WindowS...
    method stabilize_delay (line 410) | fn stabilize_delay(&mut self) {
  type KeepAlive (line 154) | struct KeepAlive {
    method maybe_schedule (line 431) | fn maybe_schedule(&mut self, is_idle: bool, shared: &Shared) {
    method schedule (line 450) | fn schedule(&mut self, shared: &Shared) {
    method maybe_ping (line 456) | fn maybe_ping(&mut self, cx: &mut task::Context<'_>, is_idle: bool, sh...
    method maybe_timeout (line 482) | fn maybe_timeout(&mut self, cx: &mut task::Context<'_>) -> Result<(), ...
  type KeepAliveState (line 167) | enum KeepAliveState {
  type Ponged (line 173) | pub(super) enum Ponged {
  type KeepAliveTimedOut (line 179) | pub(super) struct KeepAliveTimedOut;
    method crate_error (line 499) | pub(super) fn crate_error(self) -> crate::Error {
    method fmt (line 505) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
    method source (line 511) | fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
  constant BDP_LIMIT (line 363) | const BDP_LIMIT: usize = 1024 * 1024 * 16;
  function seconds (line 422) | fn seconds(dur: Duration) -> f64 {

FILE: src/proto/h2/server.rs
  constant DEFAULT_CONN_WINDOW (line 36) | const DEFAULT_CONN_WINDOW: u32 = 1024 * 1024;
  constant DEFAULT_STREAM_WINDOW (line 37) | const DEFAULT_STREAM_WINDOW: u32 = 1024 * 1024;
  constant DEFAULT_MAX_FRAME_SIZE (line 38) | const DEFAULT_MAX_FRAME_SIZE: u32 = 1024 * 16;
  constant DEFAULT_MAX_SEND_BUF_SIZE (line 39) | const DEFAULT_MAX_SEND_BUF_SIZE: usize = 1024 * 400;
  constant DEFAULT_SETTINGS_MAX_HEADER_LIST_SIZE (line 40) | const DEFAULT_SETTINGS_MAX_HEADER_LIST_SIZE: u32 = 1024 * 16;
  constant DEFAULT_MAX_LOCAL_ERROR_RESET_STREAMS (line 41) | const DEFAULT_MAX_LOCAL_ERROR_RESET_STREAMS: usize = 1024;
  type Config (line 44) | pub(crate) struct Config {
  method default (line 61) | fn default() -> Config {
  type State (line 95) | enum State<T, B>
  type Serving (line 106) | struct Serving<T, B>
  function new (line 124) | pub(crate) fn new(
  function graceful_shutdown (line 178) | pub(crate) fn graceful_shutdown(&mut self) {
  type Output (line 201) | type Output = crate::Result<Dispatched>;
  method poll (line 203) | fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Ou...
  function poll_server (line 244) | fn poll_server<S, E>(
  function poll_ping (line 341) | fn poll_ping(&mut self, cx: &mut Context<'_>) {
  type ConnectParts (line 390) | struct ConnectParts {
  function new (line 400) | fn new(
  function poll2 (line 438) | fn poll2(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<crate::...
  type Output (line 541) | type Output = ();
  method poll (line 543) | fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {

FILE: src/proto/h2/upgrade.rs
  function pair (line 16) | pub(super) fn pair<B>(
  type H2Upgraded (line 39) | pub(super) struct H2Upgraded {
  type UpgradedSendStreamBridge (line 46) | struct UpgradedSendStreamBridge {
  function tick (line 68) | fn tick(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Result<(), c...
  type Output (line 140) | type Output = ();
  method poll (line 142) | fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Ou...
  method poll_read (line 159) | fn poll_read(
  method poll_write (line 196) | fn poll_write(
  method poll_flush (line 238) | fn poll_flush(
  method poll_shutdown (line 257) | fn poll_shutdown(
  function io_error (line 270) | fn io_error(e: crate::Error) -> std::io::Error {
  function h2_to_io_error (line 274) | fn h2_to_io_error(e: h2::Error) -> std::io::Error {

FILE: src/proto/mod.rs
  type MessageHead (line 22) | pub(crate) struct MessageHead<S> {
  type RequestHead (line 35) | pub(crate) type RequestHead = MessageHead<RequestLine>;
  type RequestLine (line 39) | pub(crate) struct RequestLine(pub(crate) http::Method, pub(crate) http::...
  type ResponseHead (line 43) | pub(crate) type ResponseHead = MessageHead<http::StatusCode>;
  type BodyLength (line 47) | pub(crate) enum BodyLength {
  type Dispatched (line 55) | pub(crate) enum Dispatched {
  function into_response (line 65) | fn into_response<B>(self, body: B) -> http::Response<B> {

FILE: src/rt/bounds.rs
  type Http2UpgradedExec (line 19) | pub trait Http2UpgradedExec<B> {
    method execute_upgrade (line 21) | fn execute_upgrade(&self, fut: UpgradedSendStreamTask<B>);
  method execute_upgrade (line 29) | fn execute_upgrade(&self, fut: UpgradedSendStreamTask<B>) {
  type Http2ClientConnExec (line 51) | pub trait Http2ClientConnExec<B, T>:
    method execute_h2_future (line 59) | fn execute_h2_future(&mut self, future: H2ClientFuture<B, T, Self>);
  method execute_h2_future (line 72) | fn execute_h2_future(&mut self, future: H2ClientFuture<B, T, E>) {
  type Sealed (line 90) | pub trait Sealed<X> {}
  type Http2ServerConnExec (line 109) | pub trait Http2ServerConnExec<F, B: Body>:
    method execute_h2stream (line 113) | fn execute_h2stream(&mut self, fut: H2Stream<F, B, Self>);
  method execute_h2stream (line 125) | fn execute_h2stream(&mut self, fut: H2Stream<F, B, E>) {
  type Sealed (line 141) | pub trait Sealed<T> {}

FILE: src/rt/io.rs
  type Read (line 74) | pub trait Read {
    method poll_read (line 84) | fn poll_read(
    method poll_read (line 412) | fn poll_read(
  type Write (line 94) | pub trait Write {
    method poll_write (line 105) | fn poll_write(
    method poll_flush (line 118) | fn poll_flush(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Resu...
    method poll_shutdown (line 121) | fn poll_shutdown(
    method is_write_vectored (line 130) | fn is_write_vectored(&self) -> bool {
    method poll_write_vectored (line 135) | fn poll_write_vectored(
    method poll_write (line 469) | fn poll_write(
    method poll_write_vectored (line 477) | fn poll_write_vectored(
    method is_write_vectored (line 485) | fn is_write_vectored(&self) -> bool {
    method poll_flush (line 489) | fn poll_flush(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<std:...
    method poll_shutdown (line 493) | fn poll_shutdown(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<s...
  type ReadBuf (line 167) | pub struct ReadBuf<'a> {
  type ReadBufCursor (line 230) | pub struct ReadBufCursor<'a> {
  function new (line 237) | pub fn new(raw: &'data mut [u8]) -> Self {
  function uninit (line 249) | pub fn uninit(raw: &'data mut [MaybeUninit<u8>]) -> Self {
  function filled (line 259) | pub fn filled(&self) -> &[u8] {
  function unfilled (line 266) | pub fn unfilled<'cursor>(&'cursor mut self) -> ReadBufCursor<'cursor> {
  function set_init (line 280) | pub(crate) unsafe fn set_init(&mut self, n: usize) {
  function set_filled (line 286) | pub(crate) unsafe fn set_filled(&mut self, n: usize) {
  function len (line 292) | pub(crate) fn len(&self) -> usize {
  function init_len (line 298) | pub(crate) fn init_len(&self) -> usize {
  function remaining (line 303) | fn remaining(&self) -> usize {
  function capacity (line 308) | fn capacity(&self) -> usize {
  function fmt (line 314) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  function as_mut (line 331) | pub unsafe fn as_mut(&mut self) -> &mut [MaybeUninit<u8>] {
  function advance (line 341) | pub unsafe fn advance(&mut self, n: usize) {
  function remaining (line 351) | pub fn remaining(&self) -> usize {
  function put_slice (line 362) | pub fn put_slice(&mut self, src: &[u8]) {
  function pin_as_deref_mut (line 500) | fn pin_as_deref_mut<P: DerefMut>(pin: Pin<&mut Pin<P>>) -> Pin<&mut P::T...

FILE: src/rt/mod.rs
  type Executor (line 45) | pub trait Executor<Fut> {
    method execute (line 47) | fn execute(&self, fut: Fut);

FILE: src/rt/timer.rs
  type Timer (line 70) | pub trait Timer {
    method sleep (line 72) | fn sleep(&self, duration: Duration) -> Pin<Box<dyn Sleep>>;
    method sleep_until (line 75) | fn sleep_until(&self, deadline: Instant) -> Pin<Box<dyn Sleep>>;
    method now (line 80) | fn now(&self) -> Instant {
    method reset (line 85) | fn reset(&self, sleep: &mut Pin<Box<dyn Sleep>>, new_deadline: Instant) {
  type Sleep (line 91) | pub trait Sleep: Send + Sync + Future<Output = ()> {
    method __type_id (line 94) | fn __type_id(&self, _: private::Sealed) -> TypeId
  function is (line 106) | pub fn is<T>(&self) -> bool
  function downcast_mut_pin (line 114) | pub fn downcast_mut_pin<T>(self: Pin<&mut Self>) -> Option<Pin<&mut T>>
  type Sealed (line 133) | pub struct Sealed {}

FILE: src/server/conn/http1.rs
  type Http1Dispatcher (line 24) | type Http1Dispatcher<T, B, S> = proto::h1::Dispatcher<
  type Builder (line 71) | pub struct Builder {
    method new (line 233) | pub fn new() -> Self {
    method half_close (line 257) | pub fn half_close(&mut self, val: bool) -> &mut Self {
    method keep_alive (line 265) | pub fn keep_alive(&mut self, val: bool) -> &mut Self {
    method title_case_headers (line 274) | pub fn title_case_headers(&mut self, enabled: bool) -> &mut Self {
    method allow_multiple_spaces_in_request_line_delimiters (line 282) | pub fn allow_multiple_spaces_in_request_line_delimiters(&mut self, ena...
    method ignore_invalid_headers (line 295) | pub fn ignore_invalid_headers(&mut self, enabled: bool) -> &mut Builder {
    method preserve_header_case (line 312) | pub fn preserve_header_case(&mut self, enabled: bool) -> &mut Self {
    method max_headers (line 330) | pub fn max_headers(&mut self, val: usize) -> &mut Self {
    method header_read_timeout (line 344) | pub fn header_read_timeout(&mut self, read_timeout: impl Into<Option<D...
    method writev (line 361) | pub fn writev(&mut self, val: bool) -> &mut Self {
    method max_buf_size (line 373) | pub fn max_buf_size(&mut self, max: usize) -> &mut Self {
    method auto_date_header (line 387) | pub fn auto_date_header(&mut self, enabled: bool) -> &mut Self {
    method pipeline_flush (line 397) | pub fn pipeline_flush(&mut self, enabled: bool) -> &mut Self {
    method timer (line 403) | pub fn timer<M>(&mut self, timer: M) -> &mut Self
    method serve_connection (line 444) | pub fn serve_connection<I, S>(&self, io: I, service: S) -> Connection<...
  type Parts (line 92) | pub struct Parts<T, S> {
  function fmt (line 114) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  function graceful_shutdown (line 137) | pub fn graceful_shutdown(mut self: Pin<&mut Self>) {
  function into_parts (line 150) | pub fn into_parts(self) -> Parts<I, S> {
  function poll_without_shutdown (line 166) | pub fn poll_without_shutdown(&mut self, cx: &mut Context<'_>) -> Poll<cr...
  function without_shutdown (line 180) | pub fn without_shutdown(self) -> impl Future<Output = crate::Result<Part...
  function with_upgrades (line 191) | pub fn with_upgrades(self) -> UpgradeableConnection<I, S>
  type Output (line 207) | type Output = crate::Result<()>;
  method poll (line 209) | fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Ou...
  type UpgradeableConnection (line 499) | pub struct UpgradeableConnection<T, S>
  function graceful_shutdown (line 518) | pub fn graceful_shutdown(mut self: Pin<&mut Self>) {
  type Output (line 535) | type Output = crate::Result<()>;
  method poll (line 537) | fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Ou...

FILE: src/server/conn/http2.rs
  type Builder (line 42) | pub struct Builder<E> {
  function fmt (line 54) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  function graceful_shutdown (line 78) | pub fn graceful_shutdown(mut self: Pin<&mut Self>) {
  type Output (line 92) | type Output = crate::Result<()>;
  method poll (line 94) | fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Ou...
  function new (line 115) | pub fn new(exec: E) -> Self {
  function max_pending_accept_reset_streams (line 129) | pub fn max_pending_accept_reset_streams(&mut self, max: impl Into<Option...
  function max_local_error_reset_streams (line 144) | pub fn max_local_error_reset_streams(&mut self, max: impl Into<Option<us...
  function initial_stream_window_size (line 157) | pub fn initial_stream_window_size(&mut self, sz: impl Into<Option<u32>>)...
  function initial_connection_window_size (line 170) | pub fn initial_connection_window_size(&mut self, sz: impl Into<Option<u3...
  function adaptive_window (line 183) | pub fn adaptive_window(&mut self, enabled: bool) -> &mut Self {
  function max_frame_size (line 199) | pub fn max_frame_size(&mut self, sz: impl Into<Option<u32>>) -> &mut Self {
  function max_concurrent_streams (line 215) | pub fn max_concurrent_streams(&mut self, max: impl Into<Option<u32>>) ->...
  function keep_alive_interval (line 226) | pub fn keep_alive_interval(&mut self, interval: impl Into<Option<Duratio...
  function keep_alive_timeout (line 237) | pub fn keep_alive_timeout(&mut self, timeout: Duration) -> &mut Self {
  function max_send_buf_size (line 249) | pub fn max_send_buf_size(&mut self, max: usize) -> &mut Self {
  function enable_connect_protocol (line 258) | pub fn enable_connect_protocol(&mut self) -> &mut Self {
  function max_header_list_size (line 266) | pub fn max_header_list_size(&mut self, max: u32) -> &mut Self {
  function timer (line 272) | pub fn timer<M>(&mut self, timer: M) -> &mut Self
  function auto_date_header (line 285) | pub fn auto_date_header(&mut self, enabled: bool) -> &mut Self {
  function serve_connection (line 294) | pub fn serve_connection<S, I, Bd>(&self, io: I, service: S) -> Connectio...

FILE: src/service/http.rs
  type HttpService (line 20) | pub trait HttpService<ReqBody>: sealed::Sealed<ReqBody> {
    method call (line 37) | fn call(&mut self, req: Request<ReqBody>) -> Self::Future;
  type ResBody (line 46) | type ResBody = B2;
  type Error (line 48) | type Error = T::Error;
  type Future (line 49) | type Future = T::Future;
  method call (line 51) | fn call(&mut self, req: Request<B1>) -> Self::Future {
  type Sealed (line 64) | pub trait Sealed<T> {}

FILE: src/service/service.rs
  type Service (line 32) | pub trait Service<Request> {
    method call (line 56) | fn call(&self, req: Request) -> Self::Future;
  type Response (line 60) | type Response = S::Response;
  type Error (line 61) | type Error = S::Error;
  type Future (line 62) | type Future = S::Future;
  function call (line 65) | fn call(&self, req: Request) -> Self::Future {
  type Response (line 71) | type Response = S::Response;
  type Error (line 72) | type Error = S::Error;
  type Future (line 73) | type Future = S::Future;
  function call (line 76) | fn call(&self, req: Request) -> Self::Future {
  type Response (line 82) | type Response = S::Response;
  type Error (line 83) | type Error = S::Error;
  type Future (line 84) | type Future = S::Future;
  function call (line 87) | fn call(&self, req: Request) -> Self::Future {
  type Response (line 93) | type Response = S::Response;
  type Error (line 94) | type Error = S::Error;
  type Future (line 95) | type Future = S::Future;
  function call (line 98) | fn call(&self, req: Request) -> Self::Future {
  type Response (line 104) | type Response = S::Response;
  type Error (line 105) | type Error = S::Error;
  type Future (line 106) | type Future = S::Future;
  function call (line 109) | fn call(&self, req: Request) -> Self::Future {

FILE: src/service/util.rs
  function service_fn (line 30) | pub fn service_fn<F, R, S>(f: F) -> ServiceFn<F, R>
  type ServiceFn (line 42) | pub struct ServiceFn<F, R> {
  type Response (line 55) | type Response = crate::Response<ResBody>;
  type Error (line 56) | type Error = E;
  type Future (line 57) | type Future = Ret;
  function call (line 59) | fn call(&self, req: Request<ReqBody>) -> Self::Future {
  function fmt (line 65) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  method clone (line 74) | fn clone(&self) -> Self {

FILE: src/upgrade.rs
  type Upgraded (line 65) | pub struct Upgraded {
    method new (line 138) | pub(super) fn new<T>(io: T, read_buf: Bytes) -> Self
    method downcast (line 151) | pub fn downcast<T: Read + Write + Unpin + 'static>(self) -> Result<Par...
    method fmt (line 206) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  type OnUpgrade (line 73) | pub struct OnUpgrade {
    method none (line 214) | pub(super) fn none() -> Self {
    method is_none (line 219) | pub(super) fn is_none(&self) -> bool {
    method fmt (line 244) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  type Parts (line 83) | pub struct Parts<T> {
  function on (line 105) | pub fn on<T: sealed::CanUpgrade>(msg: T) -> OnUpgrade {
  type Pending (line 113) | pub(super) struct Pending {
    method fulfill (line 256) | pub(super) fn fulfill(self, upgraded: Upgraded) {
    method manual (line 264) | pub(super) fn manual(self) {
  function pending (line 121) | pub(super) fn pending() -> (Pending, OnUpgrade) {
  method poll_read (line 166) | fn poll_read(
  method poll_write (line 176) | fn poll_write(
  method poll_write_vectored (line 184) | fn poll_write_vectored(
  method poll_flush (line 192) | fn poll_flush(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<io...
  method poll_shutdown (line 196) | fn poll_shutdown(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll...
  method is_write_vectored (line 200) | fn is_write_vectored(&self) -> bool {
  type Output (line 225) | type Output = Result<Upgraded, crate::Error>;
  method poll (line 227) | fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
  type UpgradeExpected (line 278) | struct UpgradeExpected;
    method fmt (line 281) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  type Io (line 290) | pub(super) trait Io: Read + Write + Unpin + 'static {
    method __hyper_type_id (line 291) | fn __hyper_type_id(&self) -> TypeId {
  function __hyper_is (line 299) | fn __hyper_is<T: Io>(&self) -> bool {
  function __hyper_downcast (line 304) | fn __hyper_downcast<T: Io>(self: Box<Self>) -> Result<Box<T>, Box<Self>> {
  type CanUpgrade (line 320) | pub trait CanUpgrade {
    method on_upgrade (line 321) | fn on_upgrade(self) -> OnUpgrade;
    method on_upgrade (line 325) | fn on_upgrade(mut self) -> OnUpgrade {
    method on_upgrade (line 333) | fn on_upgrade(self) -> OnUpgrade {
    method on_upgrade (line 341) | fn on_upgrade(mut self) -> OnUpgrade {
    method on_upgrade (line 349) | fn on_upgrade(self) -> OnUpgrade {
  function upgraded_downcast (line 366) | fn upgraded_downcast() {
  type Mock (line 377) | struct Mock;
  method poll_read (line 380) | fn poll_read(
  method poll_write (line 390) | fn poll_write(
  method poll_flush (line 399) | fn poll_flush(self: Pin<&mut Self>, _cx: &mut Context<'_>) -> Poll<io::R...
  method poll_shutdown (line 403) | fn poll_shutdown(self: Pin<&mut Self>, _cx: &mut Context<'_>) -> Poll<io...

FILE: tests/client.rs
  function s (line 26) | fn s(buf: &[u8]) -> &str {
  function concat (line 30) | async fn concat<B>(b: B) -> Result<Bytes, B::Error>
  function concat_with_trailers (line 37) | async fn concat_with_trailers<B>(b: B) -> Result<(Bytes, Option<HeaderMa...
  function tcp_connect (line 48) | async fn tcp_connect(addr: &SocketAddr) -> std::io::Result<TokioIo<TcpSt...
  type HttpInfo (line 53) | struct HttpInfo {
  type Error (line 58) | enum Error {
    method is_incomplete_message (line 66) | fn is_incomplete_message(&self) -> bool {
    method is_parse (line 73) | fn is_parse(&self) -> bool {
    method is_parse_too_large (line 80) | fn is_parse_too_large(&self) -> bool {
    method is_parse_status (line 87) | fn is_parse_status(&self) -> bool {
    method fmt (line 96) | fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
    method from (line 107) | fn from(err: std::io::Error) -> Self {
    method from (line 113) | fn from(err: hyper::Error) -> Self {
  function setup_logger (line 1587) | fn setup_logger() {
  function setup_tk_test_server (line 1591) | async fn setup_tk_test_server() -> (TkTcpListener, SocketAddr) {
  function setup_std_test_server (line 1600) | fn setup_std_test_server() -> (TcpListener, SocketAddr) {
  function setup_duplex_test_server (line 1607) | fn setup_duplex_test_server() -> (DuplexStream, DuplexStream, SocketAddr) {
  function get (line 1623) | async fn get() {
  function get_custom_reason_phrase (line 1663) | async fn get_custom_reason_phrase() {
  function incoming_content_length (line 1715) | fn incoming_content_length() {
  function aborted_body_isnt_completed (line 1761) | fn aborted_body_isnt_completed() {
  function uri_absolute_form (line 1817) | fn uri_absolute_form() {
  function http1_conn_coerces_http2_request (line 1862) | fn http1_conn_coerces_http2_request() {
  function pipeline (line 1907) | fn pipeline() {
  function upgrade (line 1959) | fn upgrade() {
  function connect_method (line 2044) | fn connect_method() {
  function client_100_then_http09 (line 2134) | async fn client_100_then_http09() {
  function client_on_informational_ext (line 2191) | async fn client_on_informational_ext() {
  function test_try_send_request (line 2231) | async fn test_try_send_request() {
  function http2_detect_conn_eof (line 2314) | async fn http2_detect_conn_eof() {
  function http2_connect_detect_close (line 2395) | async fn http2_connect_detect_close() {
  function http2_keep_alive_detects_unresponsive_server (line 2469) | async fn http2_keep_alive_detects_unresponsive_server() {
  function http2_keep_alive_not_while_idle (line 2500) | async fn http2_keep_alive_not_while_idle() {
  function http2_keep_alive_closes_open_streams (line 2534) | async fn http2_keep_alive_closes_open_streams() {
  function http2_keep_alive_with_responsive_server (line 2574) | async fn http2_keep_alive_with_responsive_server() {
  function http2_responds_before_consuming_request_body (line 2629) | async fn http2_responds_before_consuming_request_body() {
  function h2_connect (line 2685) | async fn h2_connect() {
  function h2_connect_rejected (line 2740) | async fn h2_connect_rejected() {
  function test_body_panics (line 2790) | async fn test_body_panics() {
  function drain_til_eof (line 2821) | async fn drain_til_eof<T: tokio::io::AsyncRead + Unpin>(mut sock: T) -> ...
  type DebugStream (line 2832) | struct DebugStream {
    method poll_shutdown (line 2838) | fn poll_shutdown(
    method poll_flush (line 2846) | fn poll_flush(
    method poll_write (line 2853) | fn poll_write(
    method poll_read (line 2863) | fn poll_read(
  type FutureHyperExt (line 2873) | trait FutureHyperExt: TryFuture {
    method expect (line 2874) | fn expect(self, msg: &'static str) -> Pin<Box<dyn Future<Output = Self...
    method expect (line 2882) | fn expect(self, msg: &'static str) -> Pin<Box<dyn Future<Output = Self...

FILE: tests/server.rs
  function get_should_ignore_body (line 38) | fn get_should_ignore_body() {
  function get_with_body (line 59) | fn get_with_body() {
  type TestCase (line 81) | struct TestCase {
  type Bd (line 89) | enum Bd {
  function run_test (line 94) | fn run_test(case: TestCase) {
  function fixed_response_known (line 181) | fn fixed_response_known() {
  function fixed_response_unknown (line 192) | fn fixed_response_unknown() {
  function fixed_response_known_empty (line 203) | fn fixed_response_known_empty() {
  function chunked_response_known (line 214) | fn chunked_response_known() {
  function chunked_response_known_empty (line 226) | fn chunked_response_known_empty() {
  function chunked_response_unknown (line 237) | fn chunked_response_unknown() {
  function te_response_adds_chunked (line 248) | fn te_response_adds_chunked() {
  function chunked_response_trumps_length (line 263) | fn chunked_response_trumps_length() {
  function auto_response_with_unknown_length (line 278) | fn auto_response_with_unknown_length() {
  function auto_response_with_known_length (line 290) | fn auto_response_with_known_length() {
  function auto_response_known_empty (line 302) | fn auto_response_known_empty() {
  function http10_auto_response_with_unknown_length (line 314) | fn http10_auto_response_with_unknown_length() {
  function http10_chunked_response (line 326) | fn http10_chunked_response() {
  function http2_auto_response_with_known_length (line 339) | async fn http2_auto_response_with_known_length() {
  function http2_auto_response_with_conflicting_lengths (line 355) | async fn http2_auto_response_with_conflicting_lengths() {
  function http2_implicit_empty_size_hint (line 374) | async fn http2_implicit_empty_size_hint() {
  function get_response_custom_reason_phrase (line 391) | fn get_response_custom_reason_phrase() {
  function get_chunked_response_with_ka (line 418) | fn get_chunked_response_with_ka() {
  function post_with_content_length_body (line 460) | fn post_with_content_length_body() {
  function post_with_invalid_prefix_content_length (line 478) | fn post_with_invalid_prefix_content_length() {
  function post_with_chunked_body (line 498) | fn post_with_chunked_body() {
  function post_with_chunked_overflow (line 524) | fn post_with_chunked_overflow() {
  function post_with_incomplete_body (line 554) | fn post_with_incomplete_body() {
  function post_with_chunked_missing_final_digit (line 576) | fn post_with_chunked_missing_final_digit() {
  function head_response_can_send_content_length (line 599) | fn head_response_can_send_content_length() {
  function head_response_doesnt_send_body (line 628) | fn head_response_doesnt_send_body() {
  function response_does_not_set_chunked_if_body_not_allowed (line 658) | fn response_does_not_set_chunked_if_body_not_allowed() {
  function keep_alive (line 691) | fn keep_alive() {
  function http_10_keep_alive (line 731) | fn http_10_keep_alive() {
  function http_10_close_on_no_ka (line 780) | fn http_10_close_on_no_ka() {
  function disable_keep_alive (line 818) | fn disable_keep_alive() {
  function header_connection_close (line 844) | fn header_connection_close() {
  function expect_continue_sends_100 (line 877) | fn expect_continue_sends_100() {
  function expect_continue_accepts_upper_cased_expectation (line 910) | fn expect_continue_accepts_upper_cased_expectation() {
  function expect_continue_but_http_10_is_ignored (line 943) | fn expect_continue_but_http_10_is_ignored() {
  function expect_continue_but_no_body_is_ignored (line 976) | fn expect_continue_but_no_body_is_ignored() {
  function setup_tcp_listener (line 1000) | fn setup_tcp_listener() -> (TcpListener, SocketAddr) {
  function setup_duplex_test_server (line 1007) | fn setup_duplex_test_server() -> (DuplexStream, DuplexStream, SocketAddr) {
  function expect_continue_waits_for_body_poll (line 1023) | async fn expect_continue_waits_for_body_poll() {
  function pipeline_disabled (line 1072) | fn pipeline_disabled() {
  function pipeline_enabled (line 1116) | fn pipeline_enabled() {
  function http_10_request_receives_http_10_response (line 1169) | fn http_10_request_receives_http_10_response() {
  function http_11_uri_too_long (line 1189) | fn http_11_uri_too_long() {
  function disable_keep_alive_mid_request (line 1206) | async fn disable_keep_alive_mid_request() {
  function disable_keep_alive_post_request (line 1260) | async fn disable_keep_alive_post_request() {
  function http1_graceful_shutdown_after_upgrade (line 1309) | async fn http1_graceful_shutdown_after_upgrade() {
  function empty_parse_eof_does_not_return_error (line 1370) | async fn empty_parse_eof_does_not_return_error() {
  function nonempty_parse_eof_returns_error (line 1385) | async fn nonempty_parse_eof_returns_error() {
  function http1_allow_half_close (line 1403) | async fn http1_allow_half_close() {
  function disconnect_after_reading_request_before_responding (line 1437) | async fn disconnect_after_reading_request_before_responding() {
  function returning_1xx_response_is_error (line 1464) | async fn returning_1xx_response_is_error() {
  function header_name_too_long (line 1496) | fn header_name_too_long() {
  function header_read_timeout_slow_writes (line 1513) | async fn header_read_timeout_slow_writes() {
  function header_read_timeout_starts_immediately (line 1560) | async fn header_read_timeout_starts_immediately() {
  function header_read_timeout_slow_writes_multiple_requests (line 1581) | async fn header_read_timeout_slow_writes_multiple_requests() {
  function header_read_timeout_as_idle_timeout (line 1657) | async fn header_read_timeout_as_idle_timeout() {
  function upgrades (line 1701) | async fn upgrades() {
  function http_connect (line 1757) | async fn http_connect() {
  function upgrades_new (line 1810) | async fn upgrades_new() {
  function upgrades_ignored (line 1879) | async fn upgrades_ignored() {
  function http_connect_new (line 1922) | async fn http_connect_new() {
  function h2_connect (line 1985) | async fn h2_connect() {
  function h2_connect_multiplex (line 2051) | async fn h2_connect_multiplex() {
  function h2_connect_large_body (line 2161) | async fn h2_connect_large_body() {
  function h2_connect_empty_frames (line 2234) | async fn h2_connect_empty_frames() {
  function parse_errors_send_4xx_response (line 2304) | async fn parse_errors_send_4xx_response() {
  function illegal_request_length_returns_400_response (line 2326) | async fn illegal_request_length_returns_400_response() {
  function max_buf_size_panic_too_small (line 2351) | fn max_buf_size_panic_too_small() {
  function max_buf_size_no_panic (line 2358) | fn max_buf_size_no_panic() {
  function max_buf_size (line 2365) | async fn max_buf_size() {
  function graceful_shutdown_before_first_request_no_block (line 2392) | async fn graceful_shutdown_before_first_request_no_block() {
  function streaming_body (line 2417) | fn streaming_body() {
  function http1_response_with_http2_version (line 2442) | fn http1_response_with_http2_version() {
  function http1_only (line 2459) | fn http1_only() {
  function http2_service_error_sends_reset_reason (line 2474) | async fn http2_service_error_sends_reset_reason() {
  function http2_body_user_error_sends_reset_reason (line 2502) | fn http2_body_user_error_sends_reset_reason() {
  function skips_content_length_for_304_responses (line 2535) | fn skips_content_length_for_304_responses() {
  function skips_content_length_and_body_for_304_responses (line 2558) | fn skips_content_length_and_body_for_304_responses() {
  function no_implicit_zero_content_length_for_head_responses (line 2587) | fn no_implicit_zero_content_length_for_head_responses() {
  function http2_keep_alive_detects_unresponsive_client (line 2607) | async fn http2_keep_alive_detects_unresponsive_client() {
  function http2_keep_alive_with_responsive_client (line 2654) | async fn http2_keep_alive_with_responsive_client() {
  function http2_check_date_header_disabled (line 2687) | async fn http2_check_date_header_disabled() {
  function is_ping_frame (line 2722) | fn is_ping_frame(buf: &[u8]) -> bool {
  function assert_ping_frame (line 2726) | fn assert_ping_frame(buf: &[u8], len: usize) {
  function write_pong_frame (line 2741) | async fn write_pong_frame(conn: &mut TkTcpStream) {
  function http2_keep_alive_count_server_pings (line 2754) | async fn http2_keep_alive_count_server_pings() {
  function http1_trailer_send_fields (line 2809) | fn http1_trailer_send_fields() {
  function http1_trailer_send_fields_titlecase (line 2854) | fn http1_trailer_send_fields_titlecase() {
  function http1_trailer_fields_not_allowed (line 2899) | fn http1_trailer_fields_not_allowed() {
  function http1_trailer_recv_fields (line 2942) | fn http1_trailer_recv_fields() {
  type Serve (line 2974) | struct Serve {
    method addr (line 2984) | fn addr(&self) -> &SocketAddr {
    method body (line 2988) | fn body(&self) -> Vec<u8> {
    method body_err (line 2992) | fn body_err(&self) -> hyper::Error {
    method try_body (line 2996) | fn try_body(&self) -> Result<Vec<u8>, hyper::Error> {
    method trailers (line 3011) | fn trailers(&self) -> HeaderMap {
    method reply (line 3015) | fn reply(&self) -> ReplyBuilder<'_> {
  type BoxError (line 3020) | type BoxError = Box<dyn std::error::Error + Send + Sync>;
  type BoxFuture (line 3021) | type BoxFuture = Pin<Box<dyn Future<Output = Result<Response<ReplyBody>,...
  type ReplyBuilder (line 3023) | struct ReplyBuilder<'a> {
  function status (line 3028) | fn status(self, status: hyper::StatusCode) -> Self {
  function reason_phrase (line 3033) | fn reason_phrase(self, reason: &str) -> Self {
  function version (line 3044) | fn version(self, version: hyper::Version) -> Self {
  function header (line 3053) | fn header<V: AsRef<str>>(self, name: &str, value: V) -> Self {
  function body (line 3064) | fn body<T: AsRef<[u8]>>(self, body: T) {
  function body_stream (line 3070) | fn body_stream<S>(self, stream: S)
  function body_stream_with_trailers (line 3080) | fn body_stream_with_trailers<S>(self, stream: S, trailers: HeaderMap)
  function error (line 3094) | fn error<E: Into<BoxError>>(self, err: E) {
  method drop (line 3104) | fn drop(&mut self) {
  method drop (line 3112) | fn drop(&mut self) {
  type TestService (line 3126) | struct TestService {
    type Response (line 3153) | type Response = Response<ReplyBody>;
    type Error (line 3154) | type Error = BoxError;
    type Future (line 3155) | type Future = BoxFuture;
    method call (line 3157) | fn call(&self, mut req: Request<IncomingBody>) -> Self::Future {
    method build_reply (line 3189) | fn build_reply(replies: spmc::Receiver<Reply>) -> Result<Response<Repl...
  type ReplyBody (line 3132) | type ReplyBody = BoxBody<Bytes, BoxError>;
  type Reply (line 3135) | enum Reply {
  type Msg (line 3146) | enum Msg {
  constant HELLO (line 3218) | const HELLO: &str = "hello";
  type HelloWorld (line 3220) | struct HelloWorld;
    type Response (line 3223) | type Response = Response<Full<Bytes>>;
    type Error (line 3224) | type Error = hyper::Error;
    type Future (line 3225) | type Future = future::Ready<Result<Self::Response, Self::Error>>;
    method call (line 3227) | fn call(&self, _req: Request<IncomingBody>) -> Self::Future {
  function unreachable_service (line 3233) | fn unreachable_service() -> impl Service<
  function connect (line 3242) | fn connect(addr: &SocketAddr) -> TcpStream {
  function connect_async (line 3249) | async fn connect_async(addr: SocketAddr) -> TkTcpStream {
  function serve (line 3253) | fn serve() -> Serve {
  function serve_opts (line 3257) | fn serve_opts() -> ServeOptions {
  type ServeOptions (line 3262) | struct ServeOptions {
    method http2 (line 3279) | fn http2(mut self) -> Self {
    method keep_alive (line 3284) | fn keep_alive(mut self, enabled: bool) -> Self {
    method pipeline (line 3289) | fn pipeline(mut self, enabled: bool) -> Self {
    method serve (line 3294) | fn serve(self) -> Serve {
  method default (line 3269) | fn default() -> Self {
  function s (line 3374) | fn s(buf: &[u8]) -> &str {
  function has_header (line 3378) | fn has_header(msg: &str, name: &str) -> bool {
  function tcp_bind (line 3384) | fn tcp_bind(addr: &SocketAddr) -> std::io::Result<TcpListener> {
  function read_until (line 3390) | fn read_until<R, F>(io: &mut R, func: F) -> io::Result<Vec<u8>>
  type DebugStream (line 3415) | struct DebugStream<T, D> {
  method read (line 3423) | fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
  method write (line 3429) | fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
  method flush (line 3433) | fn flush(&mut self) -> io::Result<()> {
  method poll_write (line 3439) | fn poll_write(
  method poll_flush (line 3447) | fn poll_flush(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Re...
  method poll_shutdown (line 3451) | fn poll_shutdown(
  method poll_read (line 3460) | fn poll_read(
  type Dropped (line 3470) | struct Dropped(Arc<AtomicBool>);
    method new (line 3473) | pub fn new() -> Dropped {
    method load (line 3477) | pub fn load(&self) -> bool {
  method drop (line 3483) | fn drop(&mut self) {
  type TestClient (line 3488) | struct TestClient {
    method new (line 3493) | fn new() -> Self {
    method http2_only (line 3497) | fn http2_only(mut self) -> Self {
    method get (line 3502) | async fn get(&self, uri: Uri) -> Result<Response<IncomingBody>, hyper:...
    method request (line 3513) | async fn request(

FILE: tests/support/mod.rs
  type __CReq (line 253) | pub struct __CReq {
  method default (line 261) | fn default() -> __CReq {
  type __CRes (line 272) | pub struct __CRes {
  type __SReq (line 279) | pub struct __SReq {
  method default (line 287) | fn default() -> __SReq {
  type __SRes (line 298) | pub struct __SRes {
  type __HeadersEq (line 304) | pub type __HeadersEq = Vec<Arc<dyn Fn(&HeaderMap) + Send + Sync>>;
  type __TestConfig (line 306) | pub struct __TestConfig {
  function runtime (line 318) | pub fn runtime() -> tokio::runtime::Runtime {
  function __run_test (line 325) | pub fn __run_test(cfg: __TestConfig) {
  function async_test (line 330) | async fn async_test(cfg: __TestConfig) {
  type ProxyConfig (line 491) | struct ProxyConfig {
  function naive_proxy (line 497) | async fn naive_proxy(cfg: ProxyConfig) -> (SocketAddr, impl Future<Outpu...

FILE: tests/support/trailers.rs
  function new (line 23) | pub fn new(stream: S) -> Self {
  function with_trailers (line 30) | pub fn with_trailers(stream: S, trailers: HeaderMap) -> Self {
  function set_trailers (line 37) | pub fn set_trailers(&mut self, trailers: HeaderMap) {
  type Data (line 47) | type Data = D;
  type Error (line 48) | type Error = E;
  method poll_frame (line 50) | fn poll_frame(
  type Item (line 67) | type Item = S::Item;
  method poll_next (line 69) | fn poll_next(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<...
  method size_hint (line 73) | fn size_hint(&self) -> (usize, Option<usize>) {