SYMBOL INDEX (1010 symbols across 82 files)

FILE: examples/body.rs
  type Employee (line 8) | struct Employee {
  function main (line 14) | async fn main() {

FILE: examples/compression.rs
  function main (line 6) | async fn main() {

FILE: examples/dir.rs
  function main (line 4) | async fn main() {

FILE: examples/file.rs
  function main (line 6) | async fn main() {

FILE: examples/futures.rs
  function main (line 9) | async fn main() {
  function sleepy (line 18) | async fn sleepy(Seconds(seconds): Seconds) -> Result<impl warp::Reply, I...
  type Seconds (line 24) | struct Seconds(u64);
  type Err (line 27) | type Err = ();
  method from_str (line 28) | fn from_str(src: &str) -> Result<Self, Self::Err> {

FILE: examples/handlebars_template.rs
  type WithTemplate (line 9) | struct WithTemplate<T: Serialize> {
  function render (line 14) | fn render<T>(template: WithTemplate<T>, hbs: Arc<Handlebars<'_>>) -> imp...
  function main (line 25) | async fn main() {

FILE: examples/headers.rs
  function main (line 12) | async fn main() {

FILE: examples/hello.rs
  function main (line 5) | async fn main() {

FILE: examples/multipart.rs
  function main (line 7) | async fn main() {

FILE: examples/query_string.rs
  type MyObject (line 9) | struct MyObject {
  function main (line 15) | async fn main() {

FILE: examples/rejections.rs
  function main (line 14) | async fn main() {
  function div_by (line 42) | fn div_by() -> impl Filter<Extract = (NonZeroU16,), Error = Rejection> +...
  type DenomRequest (line 53) | struct DenomRequest {
  type DivideByZero (line 58) | struct DivideByZero;
  type Math (line 66) | struct Math {
  type ErrorMessage (line 73) | struct ErrorMessage {
  function handle_rejection (line 80) | async fn handle_rejection(err: Rejection) -> Result<impl Reply, Infallib...

FILE: examples/returning.rs
  function assets_filter (line 7) | pub fn assets_filter() -> BoxedFilter<(impl Reply,)> {
  function index_filter (line 12) | pub fn index_filter() -> impl Filter<Extract = (&'static str,), Error = ...
  function main (line 17) | async fn main() {

FILE: examples/routing.rs
  function main (line 6) | async fn main() {

FILE: examples/sse.rs
  function sse_counter (line 9) | fn sse_counter(counter: u64) -> Result<Event, Infallible> {
  function main (line 14) | async fn main() {

FILE: examples/sse_chat.rs
  function main (line 12) | async fn main() {
  type Message (line 63) | enum Message {
  type NotUtf8 (line 69) | struct NotUtf8;
  type Users (line 76) | type Users = Arc<Mutex<HashMap<usize, mpsc::UnboundedSender<Message>>>>;
  function user_connected (line 78) | fn user_connected(users: Users) -> impl Stream<Item = Result<Event, warp...
  function user_message (line 103) | fn user_message(my_id: usize, msg: String, users: &Users) {

FILE: examples/tls.rs
  function main (line 8) | async fn main() {
  function main (line 27) | fn main() {

FILE: examples/todos.rs
  function main (line 15) | async fn main() {
  function todos (line 39) | pub fn todos(
  function todos_list (line 49) | pub fn todos_list(
  function todos_create (line 60) | pub fn todos_create(
  function todos_update (line 71) | pub fn todos_update(
  function todos_delete (line 82) | pub fn todos_delete(
  function with_db (line 99) | fn with_db(db: Db) -> impl Filter<Extract = (Db,), Error = std::convert:...
  function json_body (line 103) | fn json_body() -> impl Filter<Extract = (Todo,), Error = warp::Rejection...
  function list_todos (line 119) | pub async fn list_todos(opts: ListOptions, db: Db) -> Result<impl warp::...
  function create_todo (line 131) | pub async fn create_todo(create: Todo, db: Db) -> Result<impl warp::Repl...
  function update_todo (line 150) | pub async fn update_todo(
  function delete_todo (line 172) | pub async fn delete_todo(id: u64, db: Db) -> Result<impl warp::Reply, In...
  type Db (line 205) | pub type Db = Arc<Mutex<Vec<Todo>>>;
  function blank_db (line 207) | pub fn blank_db() -> Db {
  type Todo (line 212) | pub struct Todo {
  type ListOptions (line 220) | pub struct ListOptions {
  function test_post (line 237) | async fn test_post() {
  function test_post_conflict (line 252) | async fn test_post_conflict() {
  function test_put_unknown (line 268) | async fn test_put_unknown() {
  function todo1 (line 284) | fn todo1() -> Todo {

FILE: examples/tracing.rs
  function main (line 12) | async fn main() {

FILE: examples/unix_socket.rs
  function main (line 5) | async fn main() {
  function main (line 24) | async fn main() {

FILE: examples/websockets.rs
  function main (line 7) | async fn main() {

FILE: examples/websockets_chat.rs
  type Users (line 21) | type Users = Arc<RwLock<HashMap<usize, mpsc::UnboundedSender<Message>>>>;
  function main (line 24) | async fn main() {
  function user_connected (line 51) | async fn user_connected(ws: WebSocket, users: Users) {
  function user_message (line 100) | async fn user_message(my_id: usize, msg: Message, users: &Users) {
  function user_disconnected (line 122) | async fn user_disconnected(my_id: usize, users: &Users) {

FILE: src/bodyt.rs
  type Body (line 11) | pub struct Body(BoxBody<Bytes, crate::Error>);
    type Data (line 20) | type Data = Bytes;
    type Error (line 21) | type Error = crate::Error;
    method poll_frame (line 23) | fn poll_frame(
    method is_end_stream (line 30) | fn is_end_stream(&self) -> bool {
    method size_hint (line 34) | fn size_hint(&self) -> http_body::SizeHint {
    method empty (line 40) | pub(crate) fn empty() -> Self {
    method wrap (line 48) | pub(crate) fn wrap<B>(body: B) -> Self
    method wrap_stream (line 59) | pub(crate) fn wrap_stream<S, B, E>(stream: S) -> Self
    method from (line 74) | fn from(b: Bytes) -> Self {
    method from (line 84) | fn from(s: &'static str) -> Self {
    method from (line 90) | fn from(s: String) -> Self {
    method from (line 96) | fn from(v: &'static [u8]) -> Self {
    method from (line 102) | fn from(v: Vec<u8>) -> Self {
    method from (line 108) | fn from(opt: Option<Bytes>) -> Self {
  method default (line 14) | fn default() -> Self {

FILE: src/error.rs
  type BoxError (line 5) | type BoxError = Box<dyn std::error::Error + Send + Sync>;
  type Error (line 8) | pub struct Error {
    method new (line 13) | pub(crate) fn new<E: Into<BoxError>>(err: E) -> Error {
    method fmt (line 19) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
    method fmt (line 26) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
    method from (line 38) | fn from(infallible: Infallible) -> Error {
  method source (line 32) | fn source(&self) -> Option<&(dyn StdError + 'static)> {
  function error_size_of (line 44) | fn error_size_of() {
  function error_source (line 52) | fn error_source() {

FILE: src/filter/and.rs
  type And (line 13) | pub struct And<T, U> {
  type Extract (line 27) | type Extract = CombinedTuples<T::Extract, U::Extract>;
  type Error (line 28) | type Error = <U::Error as CombineRejection<T::Error>>::One;
  type Future (line 29) | type Future = AndFuture<T, U>;
  method filter (line 31) | fn filter(&self, _: Internal) -> Self::Future {
  type AndFuture (line 40) | pub struct AndFuture<T: Filter, U: Filter> {
  type State (line 46) | enum State<T, TE, U: Filter> {
  type Output (line 59) | type Output = Result<
  method poll (line 64) | fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
  type Output (line 77) | type Output = Result<CombinedTuples<TE, U::Extract>, <U::Error as Combin...
  method poll (line 79) | fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Ou...

FILE: src/filter/and_then.rs
  type AndThen (line 12) | pub struct AndThen<T, F> {
  type Extract (line 24) | type Extract = (<F::Output as TryFuture>::Ok,);
  type Error (line 25) | type Error = <<F::Output as TryFuture>::Error as CombineRejection<T::Err...
  type Future (line 26) | type Future = AndThenFuture<T, F>;
  method filter (line 28) | fn filter(&self, _: Internal) -> Self::Future {
  type AndThenFuture (line 37) | pub struct AndThenFuture<T, F>
  type State (line 49) | enum State<T, F>
  type Output (line 68) | type Output = Result<
  method poll (line 73) | fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
  type Output (line 85) | type Output = Result<
  method poll (line 90) | fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Ou...

FILE: src/filter/boxed.rs
  type BoxedFilter (line 30) | pub struct BoxedFilter<T: Tuple> {
  function new (line 42) | pub(super) fn new<F>(filter: F) -> BoxedFilter<T>
  method clone (line 56) | fn clone(&self) -> BoxedFilter<T> {
  function fmt (line 64) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  function _assert_send (line 69) | fn _assert_send() {
  type Extract (line 75) | type Extract = T;
  type Error (line 76) | type Error = Rejection;
  type Future (line 77) | type Future = Pin<Box<dyn Future<Output = Result<T, Rejection>> + Send>>;
  method filter (line 79) | fn filter(&self, _: Internal) -> Self::Future {
  type BoxingFilter (line 84) | struct BoxingFilter<F> {
  type Extract (line 93) | type Extract = F::Extract;
  type Error (line 94) | type Error = F::Error;
  type Future (line 95) | type Future = Pin<Box<dyn Future<Output = Result<Self::Extract, Self::Er...
  method filter (line 97) | fn filter(&self, _: Internal) -> Self::Future {

FILE: src/filter/map.rs
  type Map (line 11) | pub struct Map<T, F> {
  type Extract (line 21) | type Extract = (F::Output,);
  type Error (line 22) | type Error = T::Error;
  type Future (line 23) | type Future = MapFuture<T, F>;
  method filter (line 25) | fn filter(&self, _: Internal) -> Self::Future {
  type MapFuture (line 35) | pub struct MapFuture<T: Filter, F> {
  type Output (line 46) | type Output = Result<(F::Output,), T::Error>;
  method poll (line 49) | fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {

FILE: src/filter/map_err.rs
  type MapErr (line 12) | pub struct MapErr<T, F> {
  type Extract (line 23) | type Extract = T::Extract;
  type Error (line 24) | type Error = E;
  type Future (line 25) | type Future = MapErrFuture<T, F>;
  method filter (line 27) | fn filter(&self, _: Internal) -> Self::Future {
  type MapErrFuture (line 37) | pub struct MapErrFuture<T: Filter, F> {
  type Output (line 48) | type Output = Result<T::Extract, E>;
  method poll (line 51) | fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Ou...

FILE: src/filter/mod.rs
  type FilterBase (line 39) | pub trait FilterBase {
    method filter (line 44) | fn filter(&self, internal: Internal) -> Self::Future;
    method map_err (line 46) | fn map_err<F, E>(self, _internal: Internal, fun: F) -> MapErr<Self, F>
    type Extract (line 484) | type Extract = U::Ok;
    type Error (line 485) | type Error = U::Error;
    type Future (line 486) | type Future = future::IntoFuture<U>;
    method filter (line 489) | fn filter(&self, _: Internal) -> Self::Future {
  type Internal (line 70) | pub struct Internal;
  type Filter (line 93) | pub trait Filter: FilterBase {
    method and (line 113) | fn and<F>(self, other: F) -> And<Self, F>
    method or (line 138) | fn or<F>(self, other: F) -> Or<Self, F>
    method map (line 191) | fn map<F>(self, fun: F) -> Map<Self, F>
    method then (line 217) | fn then<F>(self, fun: F) -> Then<Self, F>
    method and_then (line 255) | fn and_then<F>(self, fun: F) -> AndThen<Self, F>
    method or_else (line 272) | fn or_else<F>(self, fun: F) -> OrElse<Self, F>
    method recover (line 292) | fn recover<F>(self, fun: F) -> Recover<Self, F>
    method unify (line 327) | fn unify<T>(self) -> Unify<Self>
    method untuple_one (line 370) | fn untuple_one<T>(self) -> UntupleOne<Self>
    method with (line 394) | fn with<W>(self, wrapper: W) -> W::Wrapped
    method boxed (line 426) | fn boxed(self) -> BoxedFilter<Self::Extract>
  type FilterClone (line 438) | pub trait FilterClone: Filter + Clone {}
  function _assert_object_safe (line 442) | fn _assert_object_safe() {
  function filter_fn (line 448) | pub(crate) fn filter_fn<F, U>(func: F) -> FilterFn<F>
  function filter_fn_one (line 458) | pub(crate) fn filter_fn_one<F, U>(
  type FilterFn (line 472) | pub(crate) struct FilterFn<F> {

FILE: src/filter/or.rs
  type Combined (line 13) | type Combined<E1, E2> = <E1 as CombineRejection<E2>>::Combined;
  type Or (line 16) | pub struct Or<T, U> {
  type Extract (line 27) | type Extract = (Either<T::Extract, U::Extract>,);
  type Error (line 29) | type Error = Combined<U::Error, T::Error>;
  type Future (line 30) | type Future = EitherFuture<T, U>;
  method filter (line 32) | fn filter(&self, _: Internal) -> Self::Future {
  type EitherFuture (line 43) | pub struct EitherFuture<T: Filter, U: Filter> {
  type State (line 50) | enum State<T: Filter, U: Filter> {
  type PathIndex (line 57) | struct PathIndex(usize);
    method reset_path (line 60) | fn reset_path(&self) {
  type Output (line 71) | type Output = Result<(Either<T::Extract, U::Extract>,), Combined<U::Erro...
  method poll (line 73) | fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Ou...

FILE: src/filter/or_else.rs
  type OrElse (line 13) | pub struct OrElse<T, F> {
  type Extract (line 25) | type Extract = <F::Output as TryFuture>::Ok;
  type Error (line 26) | type Error = <F::Output as TryFuture>::Error;
  type Future (line 27) | type Future = OrElseFuture<T, F>;
  method filter (line 29) | fn filter(&self, _: Internal) -> Self::Future {
  type OrElseFuture (line 40) | pub struct OrElseFuture<T: Filter, F>
  type State (line 52) | enum State<T, F>
  type PathIndex (line 64) | struct PathIndex(usize);
    method reset_path (line 67) | fn reset_path(&self) {
  type Output (line 78) | type Output = Result<<F::Output as TryFuture>::Ok, <F::Output as TryFutu...
  method poll (line 80) | fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Ou...

FILE: src/filter/recover.rs
  type Recover (line 14) | pub struct Recover<T, F> {
  type Extract (line 26) | type Extract = (Either<T::Extract, (<F::Output as TryFuture>::Ok,)>,);
  type Error (line 27) | type Error = <F::Output as TryFuture>::Error;
  type Future (line 28) | type Future = RecoverFuture<T, F>;
  method filter (line 30) | fn filter(&self, _: Internal) -> Self::Future {
  type RecoverFuture (line 41) | pub struct RecoverFuture<T: Filter, F>
  type State (line 54) | enum State<T, F>
  type PathIndex (line 67) | struct PathIndex(usize);
    method reset_path (line 70) | fn reset_path(&self) {
  type Output (line 82) | type Output = Result<
  method poll (line 87) | fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Ou...

FILE: src/filter/service.rs
  function service (line 43) | pub fn service<F>(filter: F) -> FilteredService<F>
  type FilteredService (line 53) | pub struct FilteredService<F> {
  function call_route (line 64) | pub(crate) fn call_route(&self, req: Request) -> FilteredFuture<F::Futur...
  type Response (line 81) | type Response = Response;
  type Error (line 82) | type Error = Infallible;
  type Future (line 83) | type Future = FilteredFuture<F::Future>;
    type Output (line 110) | type Output = Result<Response, Infallible>;
    method poll (line 113) | fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Outp...
  function poll_ready (line 85) | fn poll_ready(&mut self, _: &mut Context<'_>) -> Poll<Result<(), Self::E...
  function call (line 90) | fn call(&mut self, req: http::Request<B>) -> Self::Future {
  type FilteredFuture (line 98) | pub struct FilteredFuture<F> {

FILE: src/filter/then.rs
  type Then (line 11) | pub struct Then<T, F> {
  type Extract (line 22) | type Extract = (<F::Output as Future>::Output,);
  type Error (line 23) | type Error = T::Error;
  type Future (line 24) | type Future = ThenFuture<T, F>;
  method filter (line 26) | fn filter(&self, _: Internal) -> Self::Future {
  type ThenFuture (line 35) | pub struct ThenFuture<T, F>
  type State (line 46) | enum State<T, F>
  type Output (line 63) | type Output = Result<(<F::Output as Future>::Output,), T::Error>;
  method poll (line 65) | fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
  type Output (line 76) | type Output = Result<(<F::Output as Future>::Output,), T::Error>;
  method poll (line 78) | fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Ou...

FILE: src/filter/unify.rs
  type Unify (line 11) | pub struct Unify<F> {
  type Extract (line 20) | type Extract = T;
  type Error (line 21) | type Error = F::Error;
  type Future (line 22) | type Future = UnifyFuture<F::Future>;
  method filter (line 24) | fn filter(&self, _: Internal) -> Self::Future {
  type UnifyFuture (line 33) | pub struct UnifyFuture<F> {
  type Output (line 42) | type Output = Result<T, F::Error>;
  method poll (line 45) | fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {

FILE: src/filter/untuple_one.rs
  type UntupleOne (line 11) | pub struct UntupleOne<F> {
  type Extract (line 20) | type Extract = T;
  type Error (line 21) | type Error = F::Error;
  type Future (line 22) | type Future = UntupleOneFuture<F>;
  method filter (line 24) | fn filter(&self, _: Internal) -> Self::Future {
  type UntupleOneFuture (line 33) | pub struct UntupleOneFuture<F: Filter> {
  type Output (line 43) | type Output = Result<T, F::Error>;
  method poll (line 46) | fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {

FILE: src/filter/wrap.rs
  type WrapSealed (line 3) | pub trait WrapSealed<F: Filter> {
    method wrap (line 6) | fn wrap(&self, filter: F) -> Self::Wrapped;
  type Wrapped (line 14) | type Wrapped = T::Wrapped;
  function wrap (line 15) | fn wrap(&self, filter: F) -> Self::Wrapped {
  type Wrap (line 20) | pub trait Wrap<F: Filter>: WrapSealed<F> {}
  function wrap_fn (line 42) | pub fn wrap_fn<F, T, U>(func: F) -> WrapFn<F>
  type WrapFn (line 52) | pub struct WrapFn<F> {
  type Wrapped (line 62) | type Wrapped = U;
  function wrap (line 64) | fn wrap(&self, filter: T) -> Self::Wrapped {

FILE: src/filters/addr.rs
  function remote (line 26) | pub fn remote() -> impl Filter<Extract = (Option<SocketAddr>,), Error = ...
  type RemoteAddr (line 38) | pub(crate) struct RemoteAddr(pub(crate) SocketAddr);

FILE: src/filters/any.rs
  function any (line 47) | pub fn any() -> impl Filter<Extract = (), Error = Infallible> + Copy {
  type Any (line 53) | struct Any;
  type Extract (line 56) | type Extract = ();
  type Error (line 57) | type Error = Infallible;
  type Future (line 58) | type Future = AnyFut;
  method filter (line 61) | fn filter(&self, _: Internal) -> Self::Future {
  type AnyFut (line 67) | struct AnyFut;
  type Output (line 70) | type Output = Result<(), Infallible>;
  method poll (line 73) | fn poll(self: Pin<&mut Self>, _cx: &mut Context<'_>) -> Poll<Self::Outpu...

FILE: src/filters/body.rs
  type BoxError (line 22) | type BoxError = Box<dyn StdError + Send + Sync>;
  function body (line 27) | pub(crate) fn body() -> impl Filter<Extract = (Body,), Error = Rejection...
  function content_length_limit (line 50) | pub fn content_length_limit(limit: u64) -> impl Filter<Extract = (), Err...
  function stream (line 78) | pub fn stream(
  function bytes (line 107) | pub fn bytes() -> impl Filter<Extract = (Bytes,), Error = Rejection> + C...
  function aggregate (line 148) | pub fn aggregate() -> impl Filter<Extract = (impl Buf,), Error = Rejecti...
  function json (line 180) | pub fn json<T: DeserializeOwned + Send>() -> impl Filter<Extract = (T,),...
  function form (line 215) | pub fn form<T: DeserializeOwned + Send>() -> impl Filter<Extract = (T,),...
  type Decode (line 228) | trait Decode {
    constant MIME (line 229) | const MIME: (mime::Name<'static>, mime::Name<'static>);
    constant WITH_NO_CONTENT_TYPE (line 230) | const WITH_NO_CONTENT_TYPE: bool;
    method decode (line 232) | fn decode<B: Buf, T: DeserializeOwned>(buf: B) -> Result<T, BoxError>;
    constant MIME (line 238) | const MIME: (mime::Name<'static>, mime::Name<'static>) = (mime::APPLIC...
    constant WITH_NO_CONTENT_TYPE (line 239) | const WITH_NO_CONTENT_TYPE: bool = true;
    method decode (line 241) | fn decode<B: Buf, T: DeserializeOwned>(mut buf: B) -> Result<T, BoxErr...
    constant MIME (line 249) | const MIME: (mime::Name<'static>, mime::Name<'static>) =
    constant WITH_NO_CONTENT_TYPE (line 251) | const WITH_NO_CONTENT_TYPE: bool = true;
    method decode (line 253) | fn decode<B: Buf, T: DeserializeOwned>(buf: B) -> Result<T, BoxError> {
  type Json (line 235) | struct Json;
  type Form (line 246) | struct Form;
  function is_content_type (line 260) | fn is_content_type<D: Decode>() -> impl Filter<Extract = (), Error = Rej...
  type BodyDeserializeError (line 300) | pub struct BodyDeserializeError {
    method fmt (line 305) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  method source (line 311) | fn source(&self) -> Option<&(dyn StdError + 'static)> {
  type BodyReadError (line 317) | pub(crate) struct BodyReadError(crate::Error);
    method fmt (line 320) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {

FILE: src/filters/compression.rs
  type CompressionAlgo (line 21) | enum CompressionAlgo {
  method from (line 32) | fn from(algo: CompressionAlgo) -> Self {
  type Compression (line 46) | pub struct Compression<F> {
  function gzip (line 67) | pub fn gzip() -> Compression<impl Fn(CompressionProps) -> Response + Cop...
  function deflate (line 96) | pub fn deflate() -> Compression<impl Fn(CompressionProps) -> Response + ...
  function brotli (line 125) | pub fn brotli() -> Compression<impl Fn(CompressionProps) -> Response + C...
  type Wrapped (line 147) | type Wrapped = WithCompression<FN, F>;
  function wrap (line 149) | fn wrap(&self, filter: F) -> Self::Wrapped {
  type CompressableBody (line 178) | pub struct CompressableBody<S, E>
  type Item (line 192) | type Item = std::io::Result<Bytes>;
  method poll_next (line 194) | fn poll_next(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<...
  function from (line 203) | fn from(body: Body) -> Self {
  type CompressionProps (line 212) | pub struct CompressionProps {
    method from (line 218) | fn from(resp: http::Response<Body>) -> Self {
  type Compressed (line 228) | pub struct Compressed(pub(super) Response);
  method into_response (line 232) | fn into_response(self) -> Response {
  type WithCompression (line 239) | pub struct WithCompression<FN, F> {
  type Extract (line 251) | type Extract = (Compressed,);
  type Error (line 252) | type Error = F::Error;
  type Future (line 253) | type Future = WithCompressionFuture<FN, F::Future>;
  method filter (line 255) | fn filter(&self, _: Internal) -> Self::Future {
  type WithCompressionFuture (line 265) | pub struct WithCompressionFuture<FN, F> {
  type Output (line 278) | type Output = Result<(Compressed,), F::Error>;
  method poll (line 280) | fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Ou...

FILE: src/filters/cookie.rs
  function cookie (line 15) | pub fn cookie<T>(name: &'static str) -> impl Filter<Extract = One<T>, Er...
  function optional (line 32) | pub fn optional<T>(

FILE: src/filters/cors.rs
  function cors (line 45) | pub fn cors() -> Builder {
  type Cors (line 58) | pub struct Cors {
    type Wrapped (line 300) | type Wrapped = CorsFilter<F>;
    method wrap (line 302) | fn wrap(&self, inner: F) -> Self::Wrapped {
  type Builder (line 64) | pub struct Builder {
    method allow_credentials (line 75) | pub fn allow_credentials(mut self, allow: bool) -> Self {
    method allow_method (line 85) | pub fn allow_method<M>(mut self, method: M) -> Self
    method allow_methods (line 102) | pub fn allow_methods<I>(mut self, methods: I) -> Self
    method allow_header (line 122) | pub fn allow_header<H>(mut self, header: H) -> Self
    method allow_headers (line 141) | pub fn allow_headers<I>(mut self, headers: I) -> Self
    method expose_header (line 159) | pub fn expose_header<H>(mut self, header: H) -> Self
    method expose_headers (line 176) | pub fn expose_headers<I>(mut self, headers: I) -> Self
    method allow_any_origin (line 195) | pub fn allow_any_origin(mut self) -> Self {
    method allow_origin (line 205) | pub fn allow_origin(self, origin: impl IntoOrigin) -> Self {
    method allow_origins (line 214) | pub fn allow_origins<I>(mut self, origins: I) -> Self
    method max_age (line 247) | pub fn max_age(mut self, seconds: impl Seconds) -> Self {
    method build (line 257) | pub fn build(self) -> Cors {
    type Wrapped (line 284) | type Wrapped = CorsFilter<F>;
    method wrap (line 286) | fn wrap(&self, inner: F) -> Self::Wrapped {
  type CorsForbidden (line 310) | pub struct CorsForbidden {
    method fmt (line 322) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
    method fmt (line 328) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  type Forbidden (line 315) | enum Forbidden {
  type Configured (line 341) | struct Configured {
    method check_request (line 355) | fn check_request(
    method is_method_allowed (line 409) | fn is_method_allowed(&self, header: &HeaderValue) -> bool {
    method is_header_allowed (line 415) | fn is_header_allowed(&self, header: &str) -> bool {
    method is_origin_allowed (line 421) | fn is_origin_allowed(&self, origin: &HeaderValue) -> bool {
    method append_preflight_headers (line 429) | fn append_preflight_headers(&self, headers: &mut http::HeaderMap) {
    method append_common_headers (line 440) | fn append_common_headers(&self, headers: &mut http::HeaderMap) {
  type Validated (line 348) | enum Validated {
  type CorsFilter (line 471) | pub struct CorsFilter<F> {
  type Extract (line 483) | type Extract =
  type Error (line 485) | type Error = <F::Error as CombineRejection<Rejection>>::One;
  type Future (line 486) | type Future = future::Either<
  method filter (line 491) | fn filter(&self, _: Internal) -> Self::Future {
  type Preflight (line 520) | pub struct Preflight {
    method into_response (line 526) | fn into_response(self) -> crate::reply::Response {
  type Wrapped (line 536) | pub struct Wrapped<R> {
  function into_response (line 546) | fn into_response(self) -> crate::reply::Response {
  type WrappedFuture (line 557) | pub struct WrappedFuture<F> {
  type Output (line 568) | type Output = Result<
  method poll (line 573) | fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
  type Seconds (line 594) | pub trait Seconds {
    method seconds (line 595) | fn seconds(self) -> u64;
    method seconds (line 599) | fn seconds(self) -> u64 {
    method seconds (line 605) | fn seconds(self) -> u64 {
  type IntoOrigin (line 610) | pub trait IntoOrigin {
    method into_origin (line 611) | fn into_origin(self) -> Origin;
    method into_origin (line 615) | fn into_origin(self) -> Origin {

FILE: src/filters/ext.rs
  function get (line 13) | pub fn get<T: Clone + Send + Sync + 'static>(
  function optional (line 28) | pub fn optional<T: Clone + Send + Sync + 'static>(

FILE: src/filters/fs.rs
  function file (line 48) | pub fn file(path: impl Into<PathBuf>) -> impl FilterClone<Extract = One<...
  function dir (line 81) | pub fn dir(path: impl Into<PathBuf>) -> impl FilterClone<Extract = One<F...
  function path_from_tail (line 91) | fn path_from_tail(
  function sanitize_path (line 111) | fn sanitize_path(base: impl AsRef<Path>, tail: &str) -> Result<PathBuf, ...
  type Conditionals (line 139) | struct Conditionals {
    method check (line 152) | fn check(self, last_modified: Option<LastModified>) -> Cond {
  type Cond (line 146) | enum Cond {
  function conditionals (line 201) | fn conditionals() -> impl Filter<Extract = One<Conditionals>, Error = In...
  type File (line 218) | pub struct File {
    method path (line 243) | pub fn path(&self) -> &Path {
  type ArcPath (line 250) | struct ArcPath(Arc<PathBuf>);
    method as_ref (line 253) | fn as_ref(&self) -> &Path {
  method into_response (line 259) | fn into_response(self) -> Response {
  function file_reply (line 264) | fn file_reply(
  function file_metadata (line 294) | async fn file_metadata(f: TkFile) -> Result<(TkFile, Metadata), Rejectio...
  function file_conditional (line 304) | fn file_conditional(
  type BadRange (line 361) | struct BadRange;
  function bytes_range (line 363) | fn bytes_range(range: Option<Range>, max_len: u64) -> Result<(u64, u64),...
  function file_stream (line 406) | fn file_stream(
  function reserve_at_least (line 462) | fn reserve_at_least(buf: &mut BytesMut, cap: usize) {
  constant DEFAULT_READ_BUF_SIZE (line 468) | const DEFAULT_READ_BUF_SIZE: usize = 8_192;
  function optimal_buf_size (line 470) | fn optimal_buf_size(metadata: &Metadata) -> usize {
  function get_block_size (line 479) | fn get_block_size(metadata: &Metadata) -> usize {
  function get_block_size (line 489) | fn get_block_size(_metadata: &Metadata) -> usize {
  function test_sanitize_path (line 509) | fn test_sanitize_path() {
  function test_reserve_at_least (line 528) | fn test_reserve_at_least() {

FILE: src/filters/header.rs
  function header (line 37) | pub fn header<T: FromStr + Send + 'static>(
  function header2 (line 52) | pub(crate) fn header2<T: Header + Send + 'static>(
  function optional (line 76) | pub fn optional<T>(
  function optional2 (line 100) | pub(crate) fn optional2<T>() -> impl Filter<Extract = One<Option<T>>, Er...
  function exact (line 137) | pub fn exact(
  function exact_ignore_case (line 169) | pub fn exact_ignore_case(
  function value (line 202) | pub fn value(
  function headers_cloned (line 228) | pub fn headers_cloned() -> impl Filter<Extract = One<HeaderMap>, Error =...

FILE: src/filters/host.rs
  function exact (line 23) | pub fn exact(expected: &str) -> impl Filter<Extract = (), Error = Reject...
  function optional (line 58) | pub fn optional() -> impl Filter<Extract = One<Option<Authority>>, Error...

FILE: src/filters/log.rs
  function log (line 33) | pub fn log(name: &'static str) -> Log<impl Fn(Info<'_>) + Copy> {
  function custom (line 73) | pub fn custom<F>(func: F) -> Log<F>
  type Log (line 82) | pub struct Log<F> {
  type Info (line 88) | pub struct Info<'a> {
  type Wrapped (line 101) | type Wrapped = WithLog<FN, F>;
  function wrap (line 103) | fn wrap(&self, filter: F) -> Self::Wrapped {
  function remote_addr (line 113) | pub fn remote_addr(&self) -> Option<SocketAddr> {
  function method (line 118) | pub fn method(&self) -> &http::Method {
  function path (line 123) | pub fn path(&self) -> &str {
  function version (line 128) | pub fn version(&self) -> http::Version {
  function status (line 133) | pub fn status(&self) -> http::StatusCode {
  function referer (line 138) | pub fn referer(&self) -> Option<&str> {
  function user_agent (line 146) | pub fn user_agent(&self) -> Option<&str> {
  function elapsed (line 154) | pub fn elapsed(&self) -> Duration {
  function host (line 159) | pub fn host(&self) -> Option<&str> {
  function request_headers (line 167) | pub fn request_headers(&self) -> &http::HeaderMap {
  type OptFmt (line 172) | struct OptFmt<T>(Option<T>);
  function fmt (line 175) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  type Logged (line 200) | pub struct Logged(pub(super) Response);
  method into_response (line 204) | fn into_response(self) -> Response {
  type WithLog (line 211) | pub struct WithLog<FN, F> {
  type Extract (line 223) | type Extract = (Logged,);
  type Error (line 224) | type Error = F::Error;
  type Future (line 225) | type Future = WithLogFuture<FN, F::Future>;
  method filter (line 227) | fn filter(&self, _: Internal) -> Self::Future {
  type WithLogFuture (line 239) | pub struct WithLogFuture<FN, F> {
  type Output (line 253) | type Output = Result<(Logged,), F::Error>;
  method poll (line 255) | fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Ou...

FILE: src/filters/method.rs
  function get (line 25) | pub fn get() -> impl Filter<Extract = (), Error = Rejection> + Copy {
  function post (line 38) | pub fn post() -> impl Filter<Extract = (), Error = Rejection> + Copy {
  function put (line 51) | pub fn put() -> impl Filter<Extract = (), Error = Rejection> + Copy {
  function delete (line 64) | pub fn delete() -> impl Filter<Extract = (), Error = Rejection> + Copy {
  function head (line 77) | pub fn head() -> impl Filter<Extract = (), Error = Rejection> + Copy {
  function options (line 90) | pub fn options() -> impl Filter<Extract = (), Error = Rejection> + Copy {
  function patch (line 103) | pub fn patch() -> impl Filter<Extract = (), Error = Rejection> + Copy {
  function method (line 121) | pub fn method() -> impl Filter<Extract = One<Method>, Error = Infallible...
  function method_is (line 128) | fn method_is<F>(func: F) -> impl Filter<Extract = (), Error = Rejection>...
  function method_size_of (line 146) | fn method_size_of() {

FILE: src/filters/multipart.rs
  constant DEFAULT_FORM_DATA_MAX_LENGTH (line 24) | const DEFAULT_FORM_DATA_MAX_LENGTH: u64 = 1024 * 1024 * 2;
  type FormOptions (line 30) | pub struct FormOptions {
    method max_length (line 65) | pub fn max_length(mut self, max: impl Into<Option<u64>>) -> Self {
  type FormData (line 37) | pub struct FormData {
    method fmt (line 112) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  type Part (line 44) | pub struct Part {
    method name (line 140) | pub fn name(&self) -> &str {
    method filename (line 147) | pub fn filename(&self) -> Option<&str> {
    method content_type (line 152) | pub fn content_type(&self) -> Option<&str> {
    method data (line 158) | pub async fn data(&mut self) -> Option<Result<impl Buf, crate::Error>> {
    method stream (line 163) | pub fn stream(self) -> impl Stream<Item = Result<impl Buf, crate::Erro...
    method poll_next (line 167) | fn poll_next(&mut self, cx: &mut Context<'_>) -> Poll<Option<Result<By...
    method fmt (line 178) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  function form (line 52) | pub fn form() -> FormOptions {
  type FormFut (line 71) | type FormFut = Pin<Box<dyn Future<Output = Result<(FormData,), Rejection...
  type Extract (line 74) | type Extract = (FormData,);
  type Error (line 75) | type Error = Rejection;
  type Future (line 76) | type Future = FormFut;
  method filter (line 78) | fn filter(&self, _: Internal) -> Self::Future {
  type Item (line 118) | type Item = Result<Part, crate::Error>;
  method poll_next (line 120) | fn poll_next(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Opt...
  type PartStream (line 194) | struct PartStream(Part);
  type Item (line 197) | type Item = Result<Bytes, crate::Error>;
  method poll_next (line 199) | fn poll_next(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Opt...
  type BodyIoError (line 204) | struct BodyIoError(BodyDataStream<Body>);
  type Item (line 207) | type Item = io::Result<Bytes>;
  method poll_next (line 209) | fn poll_next(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Opt...
  type MultipartFieldMissingName (line 223) | struct MultipartFieldMissingName;
  method fmt (line 226) | fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {

FILE: src/filters/path.rs
  function path (line 167) | pub fn path<P>(p: P) -> Exact<Opaque<P>>
  type Exact (line 197) | pub struct Exact<P>(P);
  type Extract (line 203) | type Extract = ();
  type Error (line 204) | type Error = Rejection;
  type Future (line 205) | type Future = future::Ready<Result<Self::Extract, Self::Error>>;
  method filter (line 208) | fn filter(&self, _: Internal) -> Self::Future {
  function end (line 238) | pub fn end() -> impl Filter<Extract = (), Error = Rejection> + Copy {
  function param (line 266) | pub fn param<T: FromStr + Send + 'static>(
  function tail (line 294) | pub fn tail() -> impl Filter<Extract = One<Tail>, Error = Infallible> + ...
  type Tail (line 312) | pub struct Tail {
    method as_str (line 319) | pub fn as_str(&self) -> &str {
    method fmt (line 325) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  function peek (line 348) | pub fn peek() -> impl Filter<Extract = One<Peek>, Error = Infallible> + ...
  type Peek (line 361) | pub struct Peek {
    method as_str (line 368) | pub fn as_str(&self) -> &str {
    method segments (line 373) | pub fn segments(&self) -> impl Iterator<Item = &str> {
    method fmt (line 379) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  function full (line 415) | pub fn full() -> impl Filter<Extract = One<FullPath>, Error = Infallible...
  type FullPath (line 420) | pub struct FullPath(PathAndQuery);
    method as_str (line 424) | pub fn as_str(&self) -> &str {
    method fmt (line 430) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  function filter_segment (line 435) | fn filter_segment<F, U>(func: F) -> impl Filter<Extract = U, Error = Rej...
  function with_segment (line 443) | fn with_segment<F, U>(route: &mut Route, func: F) -> Result<U, Rejection>
  function segment (line 456) | fn segment(route: &Route) -> &str {
  function path_and_query (line 464) | fn path_and_query(route: &Route) -> PathAndQuery {
  function _path_macro_compile_fail (line 607) | fn _path_macro_compile_fail() {}
  type Opaque (line 616) | pub struct Opaque<T>(pub(super) T);
  function as_ref (line 620) | fn as_ref(&self) -> &str {
  function test_path_exact_size (line 631) | fn test_path_exact_size() {

FILE: src/filters/query.rs
  function query (line 64) | pub fn query<T: DeserializeOwned + Send + 'static>(
  function raw (line 81) | pub fn raw() -> impl Filter<Extract = One<String>, Error = Rejection> + ...

FILE: src/filters/reply.rs
  function header (line 49) | pub fn header<K, V>(name: K, value: V) -> WithHeader
  function headers (line 83) | pub fn headers(headers: HeaderMap) -> WithHeaders {
  function default_header (line 110) | pub fn default_header<K, V>(name: K, value: V) -> WithDefaultHeader
  type WithHeader (line 123) | pub struct WithHeader {
    type Wrapped (line 133) | type Wrapped = Map<F, WithHeader_>;
    method wrap (line 135) | fn wrap(&self, filter: F) -> Self::Wrapped {
  type WithHeaders (line 143) | pub struct WithHeaders {
    type Wrapped (line 152) | type Wrapped = Map<F, WithHeaders_>;
    method wrap (line 154) | fn wrap(&self, filter: F) -> Self::Wrapped {
  type WithDefaultHeader (line 162) | pub struct WithDefaultHeader {
    type Wrapped (line 172) | type Wrapped = Map<F, WithDefaultHeader_>;
    method wrap (line 174) | fn wrap(&self, filter: F) -> Self::Wrapped {
  function assert_name_and_value (line 180) | fn assert_name_and_value<K, V>(name: K, value: V) -> (HeaderName, Header...
  type WithHeader_ (line 205) | pub struct WithHeader_ {
    type Output (line 210) | type Output = Reply_;
    method call (line 212) | fn call(&self, args: One<R>) -> Self::Output {
  type WithHeaders_ (line 223) | pub struct WithHeaders_ {
    type Output (line 228) | type Output = Reply_;
    method call (line 230) | fn call(&self, args: One<R>) -> Self::Output {
  type WithDefaultHeader_ (line 241) | pub struct WithDefaultHeader_ {
    type Output (line 246) | type Output = Reply_;
    method call (line 248) | fn call(&self, args: One<R>) -> Self::Output {

FILE: src/filters/sse.rs
  type DataType (line 69) | enum DataType {
  type Event (line 76) | pub struct Event {
    method data (line 87) | pub fn data<T: Into<String>>(mut self, data: T) -> Event {
    method json_data (line 94) | pub fn json_data<T: Serialize>(mut self, data: T) -> Result<Event, Err...
    method comment (line 101) | pub fn comment<T: Into<String>>(mut self, comment: T) -> Event {
    method event (line 108) | pub fn event<T: Into<String>>(mut self, event: T) -> Event {
    method retry (line 115) | pub fn retry(mut self, duration: Duration) -> Event {
    method id (line 122) | pub fn id<T: Into<String>>(mut self, id: T) -> Event {
    method fmt (line 129) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  function last_event_id (line 230) | pub fn last_event_id<T>() -> impl Filter<Extract = One<Option<T>>, Error...
  function reply (line 314) | pub fn reply<S>(event_stream: S) -> impl Reply
  type SseReply (line 323) | struct SseReply<S> {
  method into_response (line 333) | fn into_response(self) -> Response {
  type KeepAlive (line 358) | pub struct KeepAlive {
    method interval (line 367) | pub fn interval(mut self, time: Duration) -> Self {
    method text (line 375) | pub fn text(mut self, text: impl Into<Cow<'static, str>>) -> Self {
    method stream (line 383) | pub fn stream<S>(
  type SseKeepAlive (line 403) | struct SseKeepAlive<S> {
  function keep_alive (line 457) | pub fn keep_alive() -> KeepAlive {
  type Item (line 469) | type Item = Result<Event, SseError>;
  method poll_next (line 471) | fn poll_next(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<...
  type SseError (line 505) | pub struct SseError;
    method fmt (line 508) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {

FILE: src/filters/trace.rs
  function request (line 40) | pub fn request() -> Trace<impl Fn(Info<'_>) -> Span + Clone> {
  function trace (line 85) | pub fn trace<F>(func: F) -> Trace<F>
  function named (line 116) | pub fn named(name: &'static str) -> Trace<impl Fn(Info<'_>) -> Span + Co...
  type Trace (line 126) | pub struct Trace<F> {
  type Info (line 132) | pub struct Info<'a> {
  type Wrapped (line 143) | type Wrapped = WithTrace<FN, F>;
  function wrap (line 145) | fn wrap(&self, filter: F) -> Self::Wrapped {
  function method (line 155) | pub fn method(&self) -> &http::Method {
  function path (line 160) | pub fn path(&self) -> &str {
  function version (line 165) | pub fn version(&self) -> http::Version {
  function referer (line 170) | pub fn referer(&self) -> Option<&str> {
  function user_agent (line 178) | pub fn user_agent(&self) -> Option<&str> {
  function host (line 186) | pub fn host(&self) -> Option<&str> {
  function request_headers (line 194) | pub fn request_headers(&self) -> &http::HeaderMap {
  type Traced (line 210) | pub struct Traced(pub(super) Response);
  method into_response (line 214) | fn into_response(self) -> Response {
  type WithTrace (line 221) | pub struct WithTrace<FN, F> {
  function finished_logger (line 229) | fn finished_logger<E: IsReject>(reply: &Result<(Traced,), E>) {
  function convert_reply (line 266) | fn convert_reply<R: Reply>(reply: R) -> (Traced,) {
  type Extract (line 277) | type Extract = (Traced,);
  type Error (line 278) | type Error = F::Error;
  type Future (line 279) | type Future = Instrumented<
  method filter (line 286) | fn filter(&self, _: Internal) -> Self::Future {

FILE: src/filters/ws.rs
  function ws (line 44) | pub fn ws() -> impl Filter<Extract = One<Ws>, Error = Rejection> + Copy {
  type Ws (line 73) | pub struct Ws {
    method on_upgrade (line 83) | pub fn on_upgrade<F, U>(self, func: F) -> impl Reply
    method max_send_queue (line 102) | pub fn max_send_queue(self, _max: usize) -> Self {
    method max_write_buffer_size (line 107) | pub fn max_write_buffer_size(mut self, max: usize) -> Self {
    method max_message_size (line 115) | pub fn max_message_size(mut self, max: usize) -> Self {
    method max_frame_size (line 123) | pub fn max_frame_size(mut self, max: usize) -> Self {
    method fmt (line 132) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  type WsReply (line 138) | struct WsReply<F> {
  method into_response (line 148) | fn into_response(self) -> Response {
  function on_upgrade (line 182) | fn on_upgrade() -> impl Filter<Extract = (Option<OnUpgrade>,), Error = R...
  type WebSocket (line 194) | pub struct WebSocket {
    method from_raw_socket (line 199) | pub(crate) async fn from_raw_socket(
    method close (line 211) | pub async fn close(mut self) -> Result<(), crate::Error> {
    type Error (line 235) | type Error = crate::Error;
    method poll_ready (line 237) | fn poll_ready(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<...
    method start_send (line 244) | fn start_send(mut self: Pin<&mut Self>, item: Message) -> Result<(), S...
    method poll_flush (line 254) | fn poll_flush(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<...
    method poll_close (line 261) | fn poll_close(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<...
    method fmt (line 273) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  type Item (line 217) | type Item = Result<Message, crate::Error>;
  method poll_next (line 219) | fn poll_next(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Opt...
  type Message (line 283) | pub struct Message {
    method text (line 289) | pub fn text<B: Into<String>>(bytes: B) -> Message {
    method binary (line 296) | pub fn binary<B: Into<Bytes>>(bytes: B) -> Message {
    method ping (line 303) | pub fn ping<B: Into<Bytes>>(bytes: B) -> Message {
    method pong (line 314) | pub fn pong<B: Into<Bytes>>(bytes: B) -> Message {
    method close (line 321) | pub fn close() -> Message {
    method close_with (line 328) | pub fn close_with(code: impl Into<u16>, reason: impl Into<Cow<'static,...
    method is_text (line 341) | pub fn is_text(&self) -> bool {
    method is_binary (line 346) | pub fn is_binary(&self) -> bool {
    method is_close (line 351) | pub fn is_close(&self) -> bool {
    method is_ping (line 356) | pub fn is_ping(&self) -> bool {
    method is_pong (line 361) | pub fn is_pong(&self) -> bool {
    method close_frame (line 366) | pub fn close_frame(&self) -> Option<(u16, &str)> {
    method to_str (line 375) | pub fn to_str(&self) -> Result<&str, ()> {
    method as_bytes (line 383) | pub fn as_bytes(&self) -> &[u8] {
    method into_bytes (line 395) | pub fn into_bytes(self) -> Bytes {
    method fmt (line 401) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  method from (line 407) | fn from(m: Message) -> Self {
  type MissingConnectionUpgrade (line 416) | pub struct MissingConnectionUpgrade;
    method fmt (line 419) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {

FILE: src/generic.rs
  type Product (line 2) | pub struct Product<H, T: HList>(pub(crate) H, pub(crate) T);
  type One (line 4) | pub type One<T> = (T,);
  function one (line 7) | pub(crate) fn one<T>(val: T) -> One<T> {
  type Either (line 12) | pub enum Either<T, U> {
  type HList (line 18) | pub trait HList: Sized {
    method flatten (line 21) | fn flatten(self) -> Self::Tuple;
    type Tuple (line 81) | type Tuple = ();
    method flatten (line 83) | fn flatten(self) -> Self::Tuple {}
  type Tuple (line 25) | pub trait Tuple: Sized {
    method hlist (line 28) | fn hlist(self) -> Self::HList;
    method combine (line 31) | fn combine<T>(self, other: T) -> CombinedTuples<Self, T>
    type HList (line 87) | type HList = ();
    method hlist (line 90) | fn hlist(self) -> Self::HList {}
  type CombinedTuples (line 41) | pub type CombinedTuples<T, U> =
  type Combine (line 45) | pub trait Combine<T: HList> {
    method combine (line 48) | fn combine(self, other: T) -> Self::Output;
  type Func (line 51) | pub trait Func<Args> {
    method call (line 54) | fn call(&self, args: Args) -> Self::Output;
  type Output (line 60) | type Output = T;
  function combine (line 62) | fn combine(self, other: T) -> Self::Output {
  type Output (line 72) | type Output = Product<H, <T as Combine<U>>::Output>;
  function combine (line 75) | fn combine(self, other: U) -> Self::Output {
  type Output (line 97) | type Output = R;
  method call (line 100) | fn call(&self, _args: ()) -> Self::Output {
  type Output (line 109) | type Output = R;
  method call (line 112) | fn call(&self, arg: crate::Rejection) -> Self::Output {

FILE: src/lib.rs
  type Request (line 184) | pub(crate) type Request = http::Request<crate::bodyt::Body>;

FILE: src/redirect.rs
  function redirect (line 26) | pub fn redirect(uri: impl AsLocation) -> impl Reply {
  function found (line 49) | pub fn found(uri: impl AsLocation) -> impl Reply {
  function see_other (line 70) | pub fn see_other(uri: impl AsLocation) -> impl Reply {
  function temporary (line 92) | pub fn temporary(uri: impl AsLocation) -> impl Reply {
  function permanent (line 118) | pub fn permanent(uri: impl AsLocation) -> impl Reply {
  type AsLocation (line 134) | pub trait AsLocation: Sealed {}
  type Sealed (line 135) | pub trait Sealed {
    method header_value (line 136) | fn header_value(self) -> HeaderValue;
    method header_value (line 142) | fn header_value(self) -> HeaderValue {

FILE: src/reject.rs
  function reject (line 74) | pub fn reject() -> Rejection {
  function not_found (line 80) | pub fn not_found() -> Rejection {
  function invalid_query (line 88) | pub(crate) fn invalid_query() -> Rejection {
  function missing_header (line 94) | pub(crate) fn missing_header(name: &'static str) -> Rejection {
  function invalid_header (line 100) | pub(crate) fn invalid_header(name: &'static str) -> Rejection {
  function missing_cookie (line 106) | pub(crate) fn missing_cookie(name: &'static str) -> Rejection {
  function method_not_allowed (line 112) | pub(crate) fn method_not_allowed() -> Rejection {
  function length_required (line 118) | pub(crate) fn length_required() -> Rejection {
  function payload_too_large (line 124) | pub(crate) fn payload_too_large() -> Rejection {
  function unsupported_media_type (line 133) | pub(crate) fn unsupported_media_type() -> Rejection {
  function custom (line 143) | pub fn custom<T: Reject>(err: T) -> Rejection {
  function __reject_custom_compilefail (line 154) | fn __reject_custom_compilefail() {}
  type Reject (line 176) | pub trait Reject: fmt::Debug + Sized + Send + Sync + 'static {}
  type Cause (line 178) | trait Cause: fmt::Debug + Send + Sync + 'static {
    method as_any (line 179) | fn as_any(&self) -> &dyn Any;
    method as_any (line 186) | fn as_any(&self) -> &dyn Any {
  function downcast_ref (line 192) | fn downcast_ref<T: Any>(&self) -> Option<&T> {
  function known (line 197) | pub(crate) fn known<T: Into<Known>>(err: T) -> Rejection {
  type Rejection (line 204) | pub struct Rejection {
    method known (line 294) | fn known(known: Known) -> Self {
    method custom (line 300) | fn custom(other: Box<dyn Cause>) -> Self {
    method find (line 325) | pub fn find<T: 'static>(&self) -> Option<&T> {
    method is_not_found (line 341) | pub fn is_not_found(&self) -> bool {
    method from (line 348) | fn from(err: T) -> Rejection {
    method from (line 355) | fn from(infallible: Infallible) -> Rejection {
    method fmt (line 391) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
    type One (line 658) | type One = Rejection;
    type Combined (line 659) | type Combined = Rejection;
    method combine (line 661) | fn combine(self, other: Rejection) -> Self::Combined {
    type One (line 679) | type One = Rejection;
    type Combined (line 680) | type Combined = Infallible;
    method combine (line 682) | fn combine(self, other: Infallible) -> Self::Combined {
  type Reason (line 208) | enum Reason {
    method fmt (line 397) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  type Rejections (line 213) | enum Rejections {
    method status (line 417) | fn status(&self) -> StatusCode {
    method into_response (line 442) | fn into_response(&self) -> crate::reply::Response {
    method find (line 471) | fn find<T: 'static>(&self) -> Option<&T> {
    method debug_list (line 479) | fn debug_list(&self, f: &mut fmt::DebugList<'_, '_>) {
    method preferred (line 494) | fn preferred(&self) -> &Rejections {
  type MissingHeader (line 547) | pub struct MissingHeader {
    method name (line 553) | pub fn name(&self) -> &str {
    method fmt (line 559) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  type InvalidHeader (line 568) | pub struct InvalidHeader {
    method name (line 574) | pub fn name(&self) -> &str {
    method fmt (line 580) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  type MissingCookie (line 589) | pub struct MissingCookie {
    method name (line 595) | pub fn name(&self) -> &str {
    method fmt (line 601) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  type IsReject (line 616) | pub trait IsReject: fmt::Debug + Send + Sync {
    method status (line 361) | fn status(&self) -> StatusCode {
    method into_response (line 365) | fn into_response(&self) -> crate::reply::Response {
    method status (line 371) | fn status(&self) -> StatusCode {
    method into_response (line 378) | fn into_response(&self) -> crate::reply::Response {
    method status (line 617) | fn status(&self) -> StatusCode;
    method into_response (line 618) | fn into_response(&self) -> crate::reply::Response;
  function _assert_object_safe (line 621) | fn _assert_object_safe() {
  type CombineRejection (line 634) | pub trait CombineRejection<E>: Send + Sized {
    method combine (line 654) | fn combine(self, other: E) -> Self::Combined;
  type One (line 688) | type One = Rejection;
  type Combined (line 689) | type Combined = Infallible;
  method combine (line 691) | fn combine(self, _: Rejection) -> Self::Combined {
  type One (line 697) | type One = Infallible;
  type Combined (line 698) | type Combined = Infallible;
  method combine (line 700) | fn combine(self, _: Infallible) -> Self::Combined {
  type Left (line 711) | struct Left;
  type Right (line 714) | struct Right;
  function rejection_status (line 720) | fn rejection_status() {
  function combine_rejection_causes_with_some_left_and_none_right (line 736) | async fn combine_rejection_causes_with_some_left_and_none_right() {
  function combine_rejection_causes_with_none_left_and_some_right (line 750) | async fn combine_rejection_causes_with_none_left_and_some_right() {
  function unhandled_customs (line 764) | async fn unhandled_customs() {
  function response_body_string (line 800) | async fn response_body_string(resp: crate::reply::Response) -> String {
  function find_cause (line 808) | fn find_cause() {
  function size_of_rejection (line 820) | fn size_of_rejection() {
  type X (line 828) | struct X(#[allow(unused)] u32);
  function combine_n (line 831) | fn combine_n<F, R>(n: u32, new_reject: F) -> Rejection
  function test_debug (line 846) | fn test_debug() {
  function convert_big_rejections_into_response (line 854) | fn convert_big_rejections_into_response() {

FILE: src/reply.rs
  type Response (line 51) | pub type Response = ::http::Response<crate::bodyt::Body>;
  function reply (line 68) | pub fn reply() -> impl Reply {
  function json (line 98) | pub fn json<T>(val: &T) -> Json
  type Json (line 111) | pub struct Json {
  function stream (line 144) | pub fn stream<S, B, E>(stream: S) -> impl Reply
  function html (line 176) | pub fn html<T>(body: T) -> Html<T>
  type Html (line 186) | pub struct Html<T> {
  type Reply (line 236) | pub trait Reply: BoxedReply + Send {
    method into_response (line 117) | fn into_response(self) -> Response {
    method into_response (line 196) | fn into_response(self) -> Response {
    method into_response (line 240) | fn into_response(self) -> Response;
    method into_response (line 302) | fn into_response(self) -> Response {
    method into_response (line 338) | fn into_response(self) -> Response {
    method into_response (line 394) | fn into_response(self) -> Response {
    method into_response (line 408) | fn into_response(self) -> Response {
    method into_response (line 415) | fn into_response(self) -> Response {
    method into_response (line 424) | fn into_response(self) -> Response {
    method into_response (line 436) | fn into_response(self) -> Response {
    method into_response (line 455) | fn into_response(self) -> Response {
    method into_response (line 462) | fn into_response(self) -> Response {
    method into_response (line 475) | fn into_response(self) -> Response {
    method into_response (line 482) | fn into_response(self) -> Response {
    method into_response (line 492) | fn into_response(self) -> Response {
    method into_response (line 509) | fn into_response(self) -> Response {
    method into_response (line 522) | fn into_response(self) -> Response {
    method into_response (line 529) | fn into_response(self) -> Response {
    method into_response (line 543) | fn into_response(self) -> Response {
  function _assert_object_safe (line 307) | fn _assert_object_safe() {
  function with_status (line 324) | pub fn with_status<T: Reply>(reply: T, status: StatusCode) -> WithStatus...
  type WithStatus (line 332) | pub struct WithStatus<T> {
  function with_header (line 358) | pub fn with_header<T: Reply, K, V>(reply: T, name: K, value: V) -> WithH...
  type WithHeader (line 388) | pub struct WithHeader<T> {
  function text_plain (line 444) | fn text_plain<T: Into<Body>>(body: T) -> Response {
  type Reply_ (line 539) | pub struct Reply_(pub(crate) Response);
  type Internal (line 549) | pub struct Internal;
  type BoxedReply (line 555) | pub trait BoxedReply {
    method boxed_into_response (line 556) | fn boxed_into_response(self: Box<Self>, internal: Internal) -> Response;
    method boxed_into_response (line 560) | fn boxed_into_response(self: Box<Self>, _: Internal) -> Response {
  function json_serde_error (line 573) | fn json_serde_error() {
  function response_builder_error (line 583) | fn response_builder_error() {
  function boxed_reply (line 593) | fn boxed_reply() {

FILE: src/route.rs
  function set (line 11) | pub(crate) fn set<F, U>(r: &RefCell<Route>, func: F) -> U
  function is_set (line 18) | pub(crate) fn is_set() -> bool {
  function with (line 22) | pub(crate) fn with<F, R>(func: F) -> R
  type Route (line 30) | pub(crate) struct Route {
    method new (line 43) | pub(crate) fn new(req: http::Request<Body>) -> RefCell<Route> {
    method method (line 58) | pub(crate) fn method(&self) -> &http::Method {
    method headers (line 62) | pub(crate) fn headers(&self) -> &http::HeaderMap {
    method version (line 66) | pub(crate) fn version(&self) -> http::Version {
    method extensions (line 70) | pub(crate) fn extensions(&self) -> &http::Extensions {
    method extensions_mut (line 75) | pub(crate) fn extensions_mut(&mut self) -> &mut http::Extensions {
    method uri (line 79) | pub(crate) fn uri(&self) -> &http::Uri {
    method path (line 83) | pub(crate) fn path(&self) -> &str {
    method full_path (line 87) | pub(crate) fn full_path(&self) -> &str {
    method set_unmatched_path (line 91) | pub(crate) fn set_unmatched_path(&mut self, index: usize) {
    method query (line 105) | pub(crate) fn query(&self) -> Option<&str> {
    method matched_path_index (line 109) | pub(crate) fn matched_path_index(&self) -> usize {
    method reset_matched_path_index (line 113) | pub(crate) fn reset_matched_path_index(&mut self, index: usize) {
    method remote_addr (line 123) | pub(crate) fn remote_addr(&self) -> Option<SocketAddr> {
    method take_body (line 130) | pub(crate) fn take_body(&mut self) -> Option<Body> {
  type BodyState (line 37) | enum BodyState {

FILE: src/server.rs
  function serve (line 15) | pub fn serve<F>(filter: F) -> Server<F, accept::LazyTcp, run::Standard>
  type Server (line 40) | pub struct Server<F, A, R> {
  function run (line 63) | pub async fn run(self, addr: impl Into<SocketAddr>) {
  function bind (line 74) | pub async fn bind(self, addr: impl Into<SocketAddr>) -> Server<F, tokio:...
  function incoming (line 84) | pub fn incoming<A>(self, acceptor: A) -> Server<F, A, R> {
  function tls (line 105) | pub fn tls(self) -> Server<F, accept::Tls<A>, R> {}
  function graceful (line 123) | pub fn graceful<Fut>(self, shutdown_signal: Fut) -> Server<F, A, run::Gr...
  function run (line 136) | pub async fn run(self) {
  function key_path (line 157) | pub fn key_path(self, path: impl AsRef<Path>) -> Self {
  function cert_path (line 164) | pub fn cert_path(self, path: impl AsRef<Path>) -> Self {
  function client_auth_optional_path (line 174) | pub fn client_auth_optional_path(self, path: impl AsRef<Path>) -> Self {
  function client_auth_required_path (line 184) | pub fn client_auth_required_path(self, path: impl AsRef<Path>) -> Self {
  function key (line 191) | pub fn key(self, key: impl AsRef<[u8]>) -> Self {
  function cert (line 198) | pub fn cert(self, cert: impl AsRef<[u8]>) -> Self {
  function client_auth_optional (line 208) | pub fn client_auth_optional(self, trust_anchor: impl AsRef<[u8]>) -> Self {
  function client_auth_required (line 218) | pub fn client_auth_required(self, trust_anchor: impl AsRef<[u8]>) -> Self {
  function ocsp_resp (line 225) | pub fn ocsp_resp(self, resp: impl AsRef<[u8]>) -> Self {
  function with_tls (line 229) | fn with_tls<Func>(self, func: Func) -> Self
  type Accept (line 240) | pub trait Accept {
    method accept (line 247) | async fn accept(&mut self) -> Result<Self::Accepting, std::io::Error>;
    type IO (line 254) | type IO = hyper_util::rt::TokioIo<tokio::net::TcpStream>;
    type AcceptError (line 255) | type AcceptError = std::convert::Infallible;
    type Accepting (line 256) | type Accepting =
    method accept (line 258) | async fn accept(&mut self) -> Result<Self::Accepting, std::io::Error> {
    type IO (line 269) | type IO = hyper_util::rt::TokioIo<tokio::net::UnixStream>;
    type AcceptError (line 270) | type AcceptError = std::convert::Infallible;
    type Accepting (line 271) | type Accepting =
    method accept (line 273) | async fn accept(&mut self) -> Result<Self::Accepting, std::io::Error> {
    type IO (line 288) | type IO = hyper_util::rt::TokioIo<tokio::net::TcpStream>;
    type AcceptError (line 289) | type AcceptError = std::convert::Infallible;
    type Accepting (line 290) | type Accepting =
    method accept (line 292) | async fn accept(&mut self) -> Result<Self::Accepting, std::io::Error> {
  type LazyTcp (line 251) | pub struct LazyTcp;
  type Tls (line 284) | pub struct Tls<A>(pub(super) A);
  type RemoteAddrService (line 310) | pub(super) struct RemoteAddrService<S> {
  function new (line 316) | pub(super) fn new(inner: S, remote_addr: Option<SocketAddr>) -> Self {
  type Response (line 325) | type Response = S::Response;
  type Error (line 326) | type Error = S::Error;
  type Future (line 327) | type Future = S::Future;
  function poll_ready (line 329) | fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll<Result<(), Self::...
  function call (line 333) | fn call(&mut self, mut req: http::Request<B>) -> Self::Future {
  type Run (line 343) | pub trait Run {
    method run (line 345) | async fn run<F, A>(server: super::Server<F, A, Self>)
    method run (line 358) | async fn run<F, A>(mut server: super::Server<F, A, Self>)
    method run (line 408) | async fn run<F, A>(mut server: super::Server<F, A, Self>)
  type Standard (line 355) | pub struct Standard;
  type Graceful (line 402) | pub struct Graceful<Fut>(pub(super) Fut);
  function handle_accept_error (line 464) | async fn handle_accept_error(e: std::io::Error) {
  function is_connection_error (line 481) | fn is_connection_error(e: &std::io::Error) -> bool {

FILE: src/test.rs
  function request (line 125) | pub fn request() -> RequestBuilder {
  function ws (line 133) | pub fn ws() -> WsBuilder {
  type RequestBuilder (line 142) | pub struct RequestBuilder {
    method method (line 185) | pub fn method(mut self, method: &str) -> Self {
    method path (line 205) | pub fn path(mut self, p: &str) -> Self {
    method header (line 224) | pub fn header<K, V>(mut self, key: K, value: V) -> Self
    method remote_addr (line 250) | pub fn remote_addr(mut self, addr: SocketAddr) -> Self {
    method extension (line 256) | pub fn extension<T>(mut self, ext: T) -> Self
    method body (line 274) | pub fn body(mut self, body: impl AsRef<[u8]>) -> Self {
    method json (line 289) | pub fn json(mut self, val: &impl Serialize) -> Self {
    method filter (line 322) | pub async fn filter<F>(self, f: &F) -> Result<<F::Extract as OneOrTupl...
    method matches (line 356) | pub async fn matches<F>(self, f: &F) -> bool
    method reply (line 369) | pub async fn reply<F>(self, f: &F) -> Response<Bytes>
    method apply_filter (line 401) | fn apply_filter<F>(self, f: &F) -> impl Future<Output = Result<F::Extr...
  type WsBuilder (line 152) | pub struct WsBuilder {
    method path (line 435) | pub fn path(self, p: &str) -> Self {
    method header (line 454) | pub fn header<K, V>(self, key: K, value: V) -> Self
    method handshake (line 488) | pub async fn handshake<F>(self, f: F) -> Result<WsClient, WsError>
  type WsClient (line 158) | pub struct WsClient {
    method send_text (line 588) | pub async fn send_text(&mut self, text: impl Into<String>) {
    method send (line 593) | pub async fn send(&mut self, msg: crate::ws::Message) {
    method recv (line 598) | pub async fn recv(&mut self) -> Result<crate::filters::ws::Message, Ws...
    method recv_closed (line 610) | pub async fn recv_closed(&mut self) -> Result<(), WsError> {
    method pinned_tx (line 624) | fn pinned_tx(self: Pin<&mut Self>) -> Pin<&mut mpsc::UnboundedSender<c...
    method fmt (line 632) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
    type Error (line 639) | type Error = WsError;
    method poll_ready (line 641) | fn poll_ready(
    method start_send (line 648) | fn start_send(self: Pin<&mut Self>, message: Message) -> Result<(), Se...
    method poll_flush (line 652) | fn poll_flush(
    method poll_close (line 659) | fn poll_close(
  type WsError (line 165) | pub struct WsError {
    method new (line 686) | fn new<E: Into<Box<dyn StdError + Send + Sync>>>(cause: E) -> Self {
    method fmt (line 694) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  type Item (line 669) | type Item = Result<crate::ws::Message, WsError>;
  method poll_next (line 671) | fn poll_next(self: Pin<&mut Self>, context: &mut Context<'_>) -> Poll<Op...
  method description (line 700) | fn description(&self) -> &str {
  type OneOrTuple (line 706) | pub trait OneOrTuple {
    method one_or_tuple (line 709) | fn one_or_tuple(self) -> Self::Output;
    type Output (line 713) | type Output = ();
    method one_or_tuple (line 714) | fn one_or_tuple(self) -> Self::Output {}

FILE: src/tls.rs
  type TlsConfigError (line 22) | pub(crate) enum TlsConfigError {
    method fmt (line 39) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  type TlsClientAuth (line 58) | pub(crate) enum TlsClientAuth {
  type TlsConfigBuilder (line 68) | pub(crate) struct TlsConfigBuilder {
    method fmt (line 76) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
    method new (line 83) | pub(crate) fn new() -> TlsConfigBuilder {
    method key_path (line 93) | pub(crate) fn key_path(mut self, path: impl AsRef<Path>) -> Self {
    method key (line 102) | pub(crate) fn key(mut self, key: &[u8]) -> Self {
    method cert_path (line 108) | pub(crate) fn cert_path(mut self, path: impl AsRef<Path>) -> Self {
    method cert (line 117) | pub(crate) fn cert(mut self, cert: &[u8]) -> Self {
    method client_auth_optional_path (line 126) | pub(crate) fn client_auth_optional_path(mut self, path: impl AsRef<Pat...
    method client_auth_optional (line 139) | pub(crate) fn client_auth_optional(mut self, trust_anchor: &[u8]) -> S...
    method client_auth_required_path (line 149) | pub(crate) fn client_auth_required_path(mut self, path: impl AsRef<Pat...
    method client_auth_required (line 162) | pub(crate) fn client_auth_required(mut self, trust_anchor: &[u8]) -> S...
    method ocsp_resp (line 169) | pub(crate) fn ocsp_resp(mut self, ocsp_resp: &[u8]) -> Self {
    method build (line 174) | pub(crate) fn build(mut self) -> Result<ServerConfig, TlsConfigError> {
  type LazyFile (line 256) | struct LazyFile {
    method lazy_read (line 262) | fn lazy_read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
  method read (line 272) | fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
  method remote_addr (line 284) | fn remote_addr(&self) -> Option<SocketAddr> {
  type State (line 289) | enum State {
  type TlsStream (line 297) | pub(crate) struct TlsStream {
    method new (line 303) | fn new(stream: AddrStream, config: Arc<ServerConfig>) -> TlsStream {
  method poll_read (line 314) | fn poll_read(
  method poll_write (line 335) | fn poll_write(
  method poll_flush (line 354) | fn poll_flush(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<io...
  method poll_shutdown (line 361) | fn poll_shutdown(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll...
  type TlsAcceptor (line 369) | pub(crate) struct TlsAcceptor {
    method new (line 375) | pub(crate) fn new(config: ServerConfig, incoming: AddrIncoming) -> Tls...
  type Conn (line 384) | type Conn = TlsStream;
  type Error (line 385) | type Error = io::Error;
  method poll_accept (line 387) | fn poll_accept(
  function file_cert_key (line 405) | fn file_cert_key() {
  function bytes_cert_key (line 414) | fn bytes_cert_key() {
  function file_ecc_cert_key (line 426) | fn file_ecc_cert_key() {
  function bytes_ecc_cert_key (line 435) | fn bytes_ecc_cert_key() {

FILE: tests/addr.rs
  function remote_addr_missing (line 6) | async fn remote_addr_missing() {
  function remote_addr_present (line 15) | async fn remote_addr_present() {

FILE: tests/body.rs
  function matches (line 8) | async fn matches() {
  function server_error_if_taking_body_multiple_times (line 26) | async fn server_error_if_taking_body_multiple_times() {
  function content_length_limit (line 39) | async fn content_length_limit() {
  function json (line 61) | async fn json() {
  function json_rejects_bad_content_type (line 80) | async fn json_rejects_bad_content_type() {
  function json_invalid (line 98) | async fn json_invalid() {
  function json_size_of (line 110) | fn json_size_of() {
  function form (line 116) | async fn form() {
  function form_rejects_bad_content_type (line 132) | async fn form_rejects_bad_content_type() {
  function form_allows_charset (line 156) | async fn form_allows_charset() {
  function form_invalid (line 174) | async fn form_invalid() {
  function stream (line 186) | async fn stream() {

FILE: tests/cookie.rs
  function cookie (line 4) | async fn cookie() {
  function optional (line 21) | async fn optional() {
  function missing (line 38) | async fn missing() {

FILE: tests/cors.rs
  function allow_methods (line 5) | async fn allow_methods() {
  function origin_not_allowed (line 30) | async fn origin_not_allowed() {
  function headers_not_exposed (line 56) | async fn headers_not_exposed() {
  function headers_not_allowed (line 88) | async fn headers_not_allowed() {
  function success (line 107) | async fn success() {
  function with_log (line 166) | async fn with_log() {

FILE: tests/ext.rs
  type Ext1 (line 5) | struct Ext1(i32);
  function set_and_get (line 8) | async fn set_and_get() {
  function get_missing (line 21) | async fn get_missing() {

FILE: tests/filter.rs
  function flattens_tuples (line 6) | async fn flattens_tuples() {
  function map (line 72) | async fn map() {
  function or (line 83) | async fn or() {
  function or_else (line 95) | async fn or_else() {
  function recover (line 115) | async fn recover() {
  function unify (line 137) | async fn unify() {
  function nested (line 151) | async fn nested() {

FILE: tests/fs.rs
  function file (line 5) | async fn file() {
  function dir (line 30) | async fn dir() {
  function dir_encoded (line 52) | async fn dir_encoded() {
  function dir_not_found (line 69) | async fn dir_not_found() {
  function dir_bad_path (line 81) | async fn dir_bad_path() {
  function dir_bad_encoded_path (line 93) | async fn dir_bad_encoded_path() {
  function dir_fallback_index_on_dir (line 105) | async fn dir_fallback_index_on_dir() {
  function not_modified (line 121) | async fn not_modified() {
  function precondition (line 152) | async fn precondition() {
  function byte_ranges (line 178) | async fn byte_ranges() {
  function byte_ranges_with_excluded_file_size (line 234) | async fn byte_ranges_with_excluded_file_size() {

FILE: tests/header.rs
  function exact (line 5) | async fn exact() {
  function exact_rejections (line 22) | async fn exact_rejections() {
  function optional (line 45) | async fn optional() {

FILE: tests/host.rs
  function exact (line 5) | async fn exact() {
  function optional (line 76) | async fn optional() {

FILE: tests/method.rs
  function method (line 5) | async fn method() {
  function method_not_allowed_trumps_not_found (line 21) | async fn method_not_allowed_trumps_not_found() {
  function bad_request_trumps_method_not_allowed (line 36) | async fn bad_request_trumps_method_not_allowed() {

FILE: tests/multipart.rs
  function form_fields (line 7) | async fn form_fields() {
  function max_length_is_enforced (line 57) | async fn max_length_is_enforced() {
  function max_length_can_be_disabled (line 81) | async fn max_length_can_be_disabled() {

FILE: tests/path.rs
  function path (line 9) | async fn path() {
  function param (line 32) | async fn param() {
  function end (line 63) | async fn end() {
  function tail (line 116) | async fn tail() {
  function or (line 164) | async fn or() {
  function or_else (line 200) | async fn or_else() {
  function path_macro (line 215) | async fn path_macro() {
  function full_path (line 262) | async fn full_path() {
  function peek (line 334) | async fn peek() {
  function peek_segments (line 394) | async fn peek_segments() {

FILE: tests/query.rs
  function query (line 8) | async fn query() {
  function query_struct (line 19) | async fn query_struct() {
  function empty_query_struct (line 35) | async fn empty_query_struct() {
  function query_struct_no_values (line 51) | async fn query_struct_no_values() {
  function missing_query_struct (line 67) | async fn missing_query_struct() {
  type MyArgs (line 83) | struct MyArgs {
  function required_query_struct (line 89) | async fn required_query_struct() {
  function missing_required_query_struct_partial (line 105) | async fn missing_required_query_struct_partial() {
  function missing_required_query_struct_no_query (line 115) | async fn missing_required_query_struct_no_query() {
  type MyRequiredArgs (line 126) | struct MyRequiredArgs {
  function raw_query (line 132) | async fn raw_query() {

FILE: tests/redirect.rs
  function redirect_uri (line 5) | async fn redirect_uri() {
  function redirect_found_uri (line 16) | async fn redirect_found_uri() {
  function redirect_see_other_uri (line 27) | async fn redirect_see_other_uri() {
  function redirect_temporary_uri (line 38) | async fn redirect_temporary_uri() {
  function redirect_permanent_uri (line 49) | async fn redirect_permanent_uri() {

FILE: tests/reply_with.rs
  function header (line 6) | async fn header() {
  function headers (line 24) | async fn headers() {
  function default_header (line 47) | async fn default_header() {

FILE: tests/tracing.rs
  function uses_tracing (line 4) | async fn uses_tracing() {

FILE: tests/ws.rs
  function upgrade (line 9) | async fn upgrade() {
  function fail (line 43) | async fn fail() {
  function text (line 55) | async fn text() {
  function binary (line 70) | async fn binary() {
  function wsclient_sink_and_stream (line 85) | async fn wsclient_sink_and_stream() {
  function close_frame (line 100) | async fn close_frame() {
  function send_ping (line 115) | async fn send_ping() {
  function echo_pings (line 140) | async fn echo_pings() {
  function pongs_only (line 168) | async fn pongs_only() {
  function closed (line 190) | async fn closed() {
  function limit_message_size (line 202) | async fn limit_message_size() {
  function limit_frame_size (line 226) | async fn limit_frame_size() {
  type MyQuery (line 250) | struct MyQuery {
  function ws_with_query (line 255) | async fn ws_with_query() {
  function ws_echo (line 278) | fn ws_echo() -> impl Filter<Extract = (impl warp::Reply,), Error = warp:...