try to find a matching file from given input request and generate http response with stream reader of matched file. # Examples ```rust # use http_fil

spawn a fresh connection using the crate-internal connection establishment logic. On success, returns a [SpawnOutCome] carrying either the raw connec

Use text(utf-8 encoded) as request body. [CONTENT_TYPE] header would be set with value: `text/plain; charset=utf-8`.

Record a reset caused by a protocol error or server error. Sets recv error (so RequestBody sees it), send error (so response_task's send_data exits),

Writes data into the socket from the specified buffer. Returns the original buffer and quantity of data written.

send request to server

insert typed route service with given path to application.

cloning of statement inside library must be carefully utlized to keep cancelation happen properly on drop.

Enclose Self with given `T as Service<<Self as Service<_>>::Response>>`. In other word T would take Self's `Service::Response` type as it's generic ar

Searches for a wildcard segment and checks the path for invalid characters.

Returns the entry located at the given index. The table is 1-indexed and constructed in such a way that the first entries belong to the static table,

Returns true if this stream ID is zero.

Parse an HTTP/2 frame header

Sets the `path` option, setting or replacing the path option to the command. The path may be absolute or relative. # Examples ```no_run use tokio_ur

Retains all keys in the rate limiter that were used recently enough. Any key whose rate limiting state is indistinguishable from a "fresh" state (i.e

pass certain [Service] type to Route so it can be matched against the methods Route contains.

Returns the negotiated ALPN protocol, if any.

If we are passed a reference to a shared fd, clone it so we keep it live during the Future. If we aren't, use the libc::AT_FDCWD value. If Path is Non

# Safety The callback `func` must uphold the following contract: - Writes must be sequential and contiguous, starting from index 0 of the slice. - On

Adds a child to this node, keeping wildcards at the end.

Begins the transaction with an owned client. The transaction will roll back by default - use [`Transaction::commit`] method to commit it.

call next/inner services to complete where they would produce either a http response or an error.

set capacity. pool would spawn up to amount of capacity concurrent connections to database. # Default capacity default to 1

optimized version of postgres_protocol::frontend::close

Closes the file using the uring asynchronous close operation and returns the possible error as described in the close(2) man page. The programmer has

Drain a `Form` synchronously. Works because `Once` bodies are always `Poll::Ready`.

Collect request or response body to Vec.

Collect request or response body and parse it to String.

Accumulate a connection-level WINDOW_UPDATE into `pending_conn_window`. Flushed as a single connection frame after `poll_encode` drains the queue.

Recursively create a directory and all of its parent components if they are missing. # Examples ```no_run tokio_uring_xitca::start(async { tokio_uri

Decodes the headers found in the given buffer.

Restores `route` to it's original, denormalized form.

Drain a taken write buffer to the network. Always returns the buffer (cleared on success) so the caller can put it back.

Encode an integer into the given destination buffer