SYMBOL INDEX (4671 symbols across 289 files)

FILE: actix-files/examples/guarded-listing.rs
  constant EXAMPLES_DIR (line 4) | const EXAMPLES_DIR: &str = concat![env!("CARGO_MANIFEST_DIR"), "/example...
  function index (line 7) | async fn index() -> impl Responder {
  function main (line 12) | async fn main() -> std::io::Result<()> {

FILE: actix-files/src/chunked.rs
  type ReadMode (line 18) | pub(crate) enum ReadMode {
  function fmt (line 58) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  function new_chunked_read (line 63) | pub(crate) fn new_chunked_read(
  function chunked_read_file_callback_sync (line 89) | fn chunked_read_file_callback_sync(
  function chunked_read_file_callback (line 111) | async fn chunked_read_file_callback(
  function chunked_read_file_callback (line 129) | async fn chunked_read_file_callback(
  type Item (line 155) | type Item = Result<Bytes, Error>;
  method poll_next (line 157) | fn poll_next(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Opt...
  type Item (line 204) | type Item = Result<Bytes, Error>;
  method poll_next (line 206) | fn poll_next(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Opt...

FILE: actix-files/src/directory.rs
  type Directory (line 14) | pub struct Directory {
    method new (line 24) | pub fn new(base: PathBuf, path: PathBuf) -> Directory {
    method is_visible (line 29) | pub fn is_visible(&self, entry: &io::Result<DirEntry>) -> bool {
  type DirectoryRenderer (line 45) | pub(crate) type DirectoryRenderer =
  function directory_listing (line 71) | pub(crate) fn directory_listing(

FILE: actix-files/src/encoding.rs
  function equiv_utf8_text (line 12) | pub(crate) fn equiv_utf8_text(ct: Mime) -> Mime {
  function test_equiv_utf8_text (line 47) | fn test_equiv_utf8_text() {

FILE: actix-files/src/error.rs
  type FilesError (line 6) | pub enum FilesError {
  method status_code (line 19) | fn status_code(&self) -> StatusCode {
  type UriSegmentError (line 27) | pub enum UriSegmentError {
  method status_code (line 47) | fn status_code(&self) -> StatusCode {

FILE: actix-files/src/files.rs
  type Files (line 38) | pub struct Files {
    method fmt (line 58) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
    method new (line 107) | pub fn new<T: Into<PathBuf>>(mount_path: &str, serve_from: T) -> Files {
    method show_files_listing (line 144) | pub fn show_files_listing(mut self) -> Self {
    method redirect_to_slash_directory (line 152) | pub fn redirect_to_slash_directory(mut self) -> Self {
    method with_permanent_redirect (line 160) | pub fn with_permanent_redirect(mut self) -> Self {
    method files_listing_renderer (line 166) | pub fn files_listing_renderer<F>(mut self, f: F) -> Self
    method mime_override (line 176) | pub fn mime_override<F>(mut self, f: F) -> Self
    method path_filter (line 208) | pub fn path_filter<F>(mut self, f: F) -> Self
    method index_file (line 227) | pub fn index_file<T: Into<String>>(mut self, index: T) -> Self {
    method read_mode_threshold (line 244) | pub fn read_mode_threshold(mut self, size: u64) -> Self {
    method use_etag (line 252) | pub fn use_etag(mut self, value: bool) -> Self {
    method use_last_modified (line 260) | pub fn use_last_modified(mut self, value: bool) -> Self {
    method prefer_utf8 (line 268) | pub fn prefer_utf8(mut self, value: bool) -> Self {
    method guard (line 292) | pub fn guard<G: Guard + 'static>(mut self, guard: G) -> Self {
    method method_guard (line 302) | pub fn method_guard<G: Guard + 'static>(mut self, guard: G) -> Self {
    method use_guards (line 310) | pub fn use_guards<G: Guard + 'static>(self, guard: G) -> Self {
    method disable_content_disposition (line 317) | pub fn disable_content_disposition(mut self) -> Self {
    method default_handler (line 342) | pub fn default_handler<F, U>(mut self, f: F) -> Self
    method use_hidden_files (line 357) | pub fn use_hidden_files(mut self) -> Self {
    method try_compressed (line 366) | pub fn try_compressed(mut self) -> Self {
    type Response (line 401) | type Response = ServiceResponse;
    type Error (line 402) | type Error = Error;
    type Config (line 403) | type Config = ();
    type Service (line 404) | type Service = FilesService;
    type InitError (line 405) | type InitError = ();
    type Future (line 406) | type Future = LocalBoxFuture<'static, Result<Self::Service, Self::Init...
    method new_service (line 408) | fn new_service(&self, _: ()) -> Self::Future {
  method clone (line 64) | fn clone(&self) -> Self {
  method register (line 373) | fn register(mut self, config: &mut AppService) {
  function custom_files_listing_renderer (line 454) | async fn custom_files_listing_renderer() {

FILE: actix-files/src/lib.rs
  type HttpService (line 48) | type HttpService = BoxService<ServiceRequest, ServiceResponse, Error>;
  type HttpNewService (line 49) | type HttpNewService = BoxServiceFactory<(), ServiceRequest, ServiceRespo...
  function file_extension_to_mime (line 55) | pub fn file_extension_to_mime(ext: &str) -> mime::Mime {
  type MimeOverride (line 59) | type MimeOverride = dyn Fn(&mime::Name<'_>) -> DispositionType;
  type PathFilter (line 61) | type PathFilter = dyn Fn(&Path, &RequestHead) -> bool;
  function test_file_extension_to_mime (line 89) | async fn test_file_extension_to_mime() {
  function test_if_modified_since_without_if_none_match (line 104) | async fn test_if_modified_since_without_if_none_match() {
  function test_if_modified_since_without_if_none_match_same (line 116) | async fn test_if_modified_since_without_if_none_match_same() {
  function test_if_modified_since_with_if_none_match (line 128) | async fn test_if_modified_since_with_if_none_match() {
  function test_if_unmodified_since (line 141) | async fn test_if_unmodified_since() {
  function test_if_unmodified_since_failed (line 153) | async fn test_if_unmodified_since_failed() {
  function test_named_file_text (line 165) | async fn test_named_file_text() {
  function test_named_file_content_disposition (line 189) | async fn test_named_file_content_disposition() {
  function test_named_file_non_ascii_file_name (line 217) | async fn test_named_file_non_ascii_file_name() {
  function test_named_file_set_content_type (line 252) | async fn test_named_file_set_content_type() {
  function test_named_file_image (line 278) | async fn test_named_file_image() {
  function test_named_file_javascript (line 301) | async fn test_named_file_javascript() {
  function test_named_file_image_attachment (line 317) | async fn test_named_file_image_attachment() {
  function test_named_file_binary (line 347) | async fn test_named_file_binary() {
  function status_code_customize_same_output (line 371) | async fn status_code_customize_same_output() {
  function test_named_file_status_code_text (line 392) | async fn test_named_file_status_code_text() {
  function test_mime_override (line 420) | async fn test_mime_override() {
  function test_named_file_ranges_status_code (line 449) | async fn test_named_file_ranges_status_code() {
  function test_named_file_empty_range_headers (line 474) | async fn test_named_file_empty_range_headers() {
  function test_named_file_content_range_headers (line 492) | async fn test_named_file_content_range_headers() {
  function test_named_file_range_header_from_zero_to_end_returns_partial_content (line 517) | async fn test_named_file_range_header_from_zero_to_end_returns_partial_c...
  function test_named_file_content_length_headers (line 541) | async fn test_named_file_content_length_headers() {
  function test_head_content_length_headers (line 580) | async fn test_head_content_length_headers() {
  function test_static_files_with_spaces (line 596) | async fn test_static_files_with_spaces() {
  function test_static_files_with_special_characters (line 613) | async fn test_static_files_with_special_characters() {
  function test_files_not_allowed (line 636) | async fn test_files_not_allowed() {
  function test_files_guards (line 657) | async fn test_files_guards() {
  function test_named_file_content_encoding (line 673) | async fn test_named_file_content_encoding() {
  function test_named_file_content_encoding_gzip (line 695) | async fn test_named_file_content_encoding_gzip() {
  function test_named_file_allowed_method (line 723) | async fn test_named_file_allowed_method() {
  function test_static_files (line 731) | async fn test_static_files() {
  function test_redirect_to_slash_directory (line 759) | async fn test_redirect_to_slash_directory() {
  function test_static_files_bad_directory (line 816) | async fn test_static_files_bad_directory() {
  function test_static_files_bad_directory_does_not_serve_cwd_files (line 826) | async fn test_static_files_bad_directory_does_not_serve_cwd_files() {
  function test_default_handler_file_missing (line 836) | async fn test_default_handler_file_missing() {
  function test_serve_index_nested (line 853) | async fn test_serve_index_nested() {
  function integration_serve_index (line 875) | async fn integration_serve_index() {
  function integration_percent_encoded (line 909) | async fn integration_percent_encoded() {
  function test_percent_encoding_2 (line 930) | async fn test_percent_encoding_2() {
  function test_serve_named_file (line 955) | async fn test_serve_named_file() {
  function test_serve_named_file_prefix (line 973) | async fn test_serve_named_file_prefix() {
  function test_named_file_default_service (line 992) | async fn test_named_file_default_service() {
  function test_default_handler_named_file (line 1008) | async fn test_default_handler_named_file() {
  function test_symlinks (line 1025) | async fn test_symlinks() {
  function test_index_with_show_files_listing (line 1040) | async fn test_index_with_show_files_listing() {
  function test_path_filter (line 1069) | async fn test_path_filter() {
  function test_default_handler_filter (line 1087) | async fn test_default_handler_filter() {

FILE: actix-files/src/named.rs
  method default (line 41) | fn default() -> Self {
  type NamedFile (line 71) | pub struct NamedFile {
    method from_file (line 164) | pub fn from_file<P: AsRef<Path>>(file: File, path: P) -> io::Result<Na...
    method open (line 220) | pub fn open<P: AsRef<Path>>(path: P) -> io::Result<NamedFile> {
    method open_async (line 237) | pub async fn open_async<P: AsRef<Path>>(path: P) -> io::Result<NamedFi...
    method file (line 255) | pub fn file(&self) -> &File {
    method path (line 273) | pub fn path(&self) -> &Path {
    method modified (line 282) | pub fn modified(&self) -> Option<SystemTime> {
    method metadata (line 288) | pub fn metadata(&self) -> &Metadata {
    method content_type (line 294) | pub fn content_type(&self) -> &Mime {
    method content_disposition (line 300) | pub fn content_disposition(&self) -> &ContentDisposition {
    method content_encoding (line 309) | pub fn content_encoding(&self) -> Option<ContentEncoding> {
    method set_status_code (line 315) | pub fn set_status_code(mut self, status: StatusCode) -> Self {
    method set_content_type (line 323) | pub fn set_content_type(mut self, mime_type: Mime) -> Self {
    method set_content_disposition (line 336) | pub fn set_content_disposition(mut self, cd: ContentDisposition) -> Se...
    method disable_content_disposition (line 346) | pub fn disable_content_disposition(mut self) -> Self {
    method set_content_encoding (line 357) | pub fn set_content_encoding(mut self, enc: ContentEncoding) -> Self {
    method read_mode_threshold (line 374) | pub fn read_mode_threshold(mut self, size: u64) -> Self {
    method use_etag (line 383) | pub fn use_etag(mut self, value: bool) -> Self {
    method use_last_modified (line 392) | pub fn use_last_modified(mut self, value: bool) -> Self {
    method prefer_utf8 (line 401) | pub fn prefer_utf8(mut self, value: bool) -> Self {
    method etag (line 407) | pub(crate) fn etag(&self) -> Option<header::EntityTag> {
    method last_modified (line 456) | pub(crate) fn last_modified(&self) -> Option<header::HttpDate> {
    method into_response (line 473) | pub fn into_response(self, req: &HttpRequest) -> HttpResponse<BoxBody> {
    type Response (line 677) | type Response = ServiceResponse;
    type Error (line 678) | type Error = Error;
    type Config (line 679) | type Config = ();
    type Service (line 680) | type Service = NamedFileService;
    type InitError (line 681) | type InitError = ();
    type Future (line 682) | type Future = LocalBoxFuture<'static, Result<Self::Service, Self::Init...
    method new_service (line 684) | fn new_service(&self, _: ()) -> Self::Future {
  function get_content_type_and_disposition (line 94) | pub(crate) fn get_content_type_and_disposition(
  function any_match (line 629) | fn any_match(etag: Option<&header::EntityTag>, req: &HttpRequest) -> bool {
  function none_match (line 648) | fn none_match(etag: Option<&header::EntityTag>, req: &HttpRequest) -> bo...
  type Body (line 669) | type Body = BoxBody;
  method respond_to (line 671) | fn respond_to(self, req: &HttpRequest) -> HttpResponse<Self::Body> {
  type NamedFileService (line 695) | pub struct NamedFileService {
    type Response (line 700) | type Response = ServiceResponse;
    type Error (line 701) | type Error = Error;
    type Future (line 702) | type Future = LocalBoxFuture<'static, Result<Self::Response, Self::Err...
    method call (line 706) | fn call(&self, req: ServiceRequest) -> Self::Future {
  method register (line 719) | fn register(self, config: &mut AppService) {
  function audio_files_use_inline_content_disposition (line 734) | fn audio_files_use_inline_content_disposition() {

FILE: actix-files/src/path_buf.rs
  type PathBufWrap (line 15) | pub struct PathBufWrap(PathBuf);
    method parse_unprocessed_req (line 37) | pub fn parse_unprocessed_req(
    method parse_req_path (line 53) | pub fn parse_req_path(req: &HttpRequest, hidden_files: bool) -> Result...
    method parse_path (line 60) | pub fn parse_path(path: &str, hidden_files: bool) -> Result<Self, UriS...
    method as_ref (line 118) | fn as_ref(&self) -> &Path {
  type Err (line 18) | type Err = UriSegmentError;
  method from_str (line 20) | fn from_str(path: &str) -> Result<Self, Self::Err> {
  type Error (line 124) | type Error = UriSegmentError;
  type Future (line 125) | type Future = Ready<Result<Self, Self::Error>>;
  method from_request (line 127) | fn from_request(req: &HttpRequest, _: &mut Payload) -> Self::Future {
  function test_path_buf (line 138) | fn test_path_buf() {
  function test_parse_path (line 170) | fn test_parse_path() {
  function path_traversal (line 183) | fn path_traversal() {
  function windows_drive_traversal (line 204) | fn windows_drive_traversal() {

FILE: actix-files/src/range.rs
  type HttpRangeParseError (line 7) | enum HttpRangeParseError {
    method from (line 13) | fn from(err: http_range::HttpRangeParseError) -> Self {
  type ParseRangeErr (line 23) | pub struct ParseRangeErr(#[error(not(source))] HttpRangeParseError);
    method fmt (line 26) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  type HttpRange (line 37) | pub struct HttpRange {
    method parse (line 50) | pub fn parse(header: &str, size: u64) -> Result<Vec<HttpRange>, ParseR...
  type T (line 68) | struct T(&'static str, u64, Vec<HttpRange>);
  function test_parse (line 71) | fn test_parse() {

FILE: actix-files/src/service.rs
  type FilesService (line 25) | pub struct FilesService(pub(crate) Rc<FilesServiceInner>);
    method handle_err (line 59) | async fn handle_err(
    method serve_named_file_with_encoding (line 73) | fn serve_named_file_with_encoding(
    method serve_named_file (line 112) | fn serve_named_file(&self, req: ServiceRequest, named_file: NamedFile)...
    method show_index (line 116) | fn show_index(&self, req: ServiceRequest, path: PathBuf) -> ServiceRes...
    method fmt (line 126) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
    type Response (line 132) | type Response = ServiceResponse<BoxBody>;
    type Error (line 133) | type Error = Error;
    type Future (line 134) | type Future = LocalBoxFuture<'static, Result<Self::Response, Self::Err...
    method call (line 138) | fn call(&self, req: ServiceRequest) -> Self::Future {
  type Target (line 28) | type Target = FilesServiceInner;
  method deref (line 30) | fn deref(&self) -> &Self::Target {
  type FilesServiceInner (line 35) | pub struct FilesServiceInner {
    method fmt (line 53) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  constant SUPPORTED_PRECOMPRESSION_ENCODINGS (line 243) | const SUPPORTED_PRECOMPRESSION_ENCODINGS: &[header::ContentEncoding] = &[
  function find_compressed (line 253) | async fn find_compressed(

FILE: actix-files/tests/encoding.rs
  function test_utf8_file_contents (line 12) | async fn test_utf8_file_contents() {
  function test_compression_encodings (line 40) | async fn test_compression_encodings() {
  function partial_range_response_encoding (line 170) | async fn partial_range_response_encoding() {

FILE: actix-files/tests/guard.rs
  function test_guard_filter (line 11) | async fn test_guard_filter() {

FILE: actix-files/tests/pre_epoch_mtime.rs
  function serves_file_with_pre_epoch_mtime (line 12) | async fn serves_file_with_pre_epoch_mtime() {

FILE: actix-files/tests/traversal.rs
  function test_directory_traversal_prevention (line 9) | async fn test_directory_traversal_prevention() {

FILE: actix-http-test/src/lib.rs
  function test_server (line 57) | pub async fn test_server<F: ServerServiceFactory<TcpStream>>(factory: F)...
  function test_server_with_addr (line 63) | pub async fn test_server_with_addr<F: ServerServiceFactory<TcpStream>>(
  type TestServer (line 137) | pub struct TestServer {
    method addr (line 147) | pub fn addr(&self) -> net::SocketAddr {
    method url (line 152) | pub fn url(&self, uri: &str) -> String {
    method surl (line 161) | pub fn surl(&self, uri: &str) -> String {
    method get (line 170) | pub fn get<S: AsRef<str>>(&self, path: S) -> ClientRequest {
    method sget (line 175) | pub fn sget<S: AsRef<str>>(&self, path: S) -> ClientRequest {
    method post (line 180) | pub fn post<S: AsRef<str>>(&self, path: S) -> ClientRequest {
    method spost (line 185) | pub fn spost<S: AsRef<str>>(&self, path: S) -> ClientRequest {
    method head (line 190) | pub fn head<S: AsRef<str>>(&self, path: S) -> ClientRequest {
    method shead (line 195) | pub fn shead<S: AsRef<str>>(&self, path: S) -> ClientRequest {
    method put (line 200) | pub fn put<S: AsRef<str>>(&self, path: S) -> ClientRequest {
    method sput (line 205) | pub fn sput<S: AsRef<str>>(&self, path: S) -> ClientRequest {
    method patch (line 210) | pub fn patch<S: AsRef<str>>(&self, path: S) -> ClientRequest {
    method spatch (line 215) | pub fn spatch<S: AsRef<str>>(&self, path: S) -> ClientRequest {
    method delete (line 220) | pub fn delete<S: AsRef<str>>(&self, path: S) -> ClientRequest {
    method sdelete (line 225) | pub fn sdelete<S: AsRef<str>>(&self, path: S) -> ClientRequest {
    method options (line 230) | pub fn options<S: AsRef<str>>(&self, path: S) -> ClientRequest {
    method soptions (line 235) | pub fn soptions<S: AsRef<str>>(&self, path: S) -> ClientRequest {
    method request (line 240) | pub fn request<S: AsRef<str>>(&self, method: Method, path: S) -> Clien...
    method load_body (line 244) | pub async fn load_body<S>(
    method ws_at (line 255) | pub async fn ws_at(
    method ws (line 265) | pub async fn ws(
    method client_headers (line 275) | pub fn client_headers(&mut self) -> Option<&mut HeaderMap> {
    method stop (line 282) | pub async fn stop(&mut self) {
  method drop (line 296) | fn drop(&mut self) {
  function unused_addr (line 310) | pub fn unused_addr() -> net::SocketAddr {

FILE: actix-http/benches/date-formatting.rs
  function date_formatting (line 10) | fn date_formatting(b: Bencher<'_, '_>) {
  function main (line 18) | fn main() {

FILE: actix-http/benches/response-body-compression.rs
  function compression_responses (line 9) | fn compression_responses(c: &mut Criterion) {

FILE: actix-http/examples/actix-web.rs
  function index (line 7) | async fn index() -> impl Responder {
  function main (line 12) | async fn main() -> std::io::Result<()> {

FILE: actix-http/examples/bench.rs
  function main (line 10) | async fn main() -> io::Result<()> {

FILE: actix-http/examples/echo.rs
  function main (line 11) | async fn main() -> io::Result<()> {

FILE: actix-http/examples/echo2.rs
  function handle_request (line 8) | async fn handle_request(mut req: Request) -> Result<Response<impl Messag...
  function main (line 22) | async fn main() -> io::Result<()> {

FILE: actix-http/examples/h2c-detect.rs
  function main (line 15) | async fn main() -> io::Result<()> {

FILE: actix-http/examples/h2spec.rs
  function main (line 10) | async fn main() -> io::Result<()> {

FILE: actix-http/examples/hello-world.rs
  function main (line 8) | async fn main() -> io::Result<()> {

FILE: actix-http/examples/streaming-error.rs
  function main (line 18) | async fn main() -> io::Result<()> {

FILE: actix-http/examples/tls_rustls.rs
  function main (line 23) | async fn main() -> io::Result<()> {
  function rustls_config (line 45) | fn rustls_config() -> rustls::ServerConfig {

FILE: actix-http/examples/ws.rs
  function main (line 22) | async fn main() -> io::Result<()> {
  function handler (line 38) | async fn handler(req: Request) -> Result<Response<BodyStream<Heartbeat>>...
  type Heartbeat (line 48) | struct Heartbeat {
    method new (line 54) | fn new(codec: ws::Codec) -> Self {
  type Item (line 63) | type Item = Result<Bytes, Error>;
  method poll_next (line 65) | fn poll_next(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Opt...
  function tls_config (line 84) | fn tls_config() -> rustls::ServerConfig {

FILE: actix-http/src/body/body_stream.rs
  function new (line 31) | pub fn new(stream: S) -> Self {
  type Error (line 41) | type Error = E;
  method size (line 44) | fn size(&self) -> BodySize {
  method poll_next (line 52) | fn poll_next(
  function skips_empty_chunks (line 99) | async fn skips_empty_chunks() {
  function read_to_bytes (line 124) | async fn read_to_bytes() {
  type StreamErr (line 135) | struct StreamErr;
  function stream_immediate_error (line 138) | async fn stream_immediate_error() {
  function stream_string_error (line 144) | async fn stream_string_error() {
  function stream_boxed_error (line 153) | async fn stream_boxed_error() {
  function stream_delayed_error (line 168) | async fn stream_delayed_error() {

FILE: actix-http/src/body/boxed.rs
  type BoxBody (line 15) | pub struct BoxBody(BoxBodyInner);
    method new (line 39) | pub fn new<B>(body: B) -> Self
    method as_pin_mut (line 57) | pub fn as_pin_mut(&mut self) -> Pin<&mut Self> {
  type BoxBodyInner (line 17) | enum BoxBodyInner {
    method fmt (line 24) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  type Error (line 63) | type Error = Box<dyn StdError>;
  method size (line 66) | fn size(&self) -> BodySize {
  method poll_next (line 75) | fn poll_next(
  method try_into_bytes (line 87) | fn try_into_bytes(self) -> Result<Bytes, Self> {
  method boxed (line 96) | fn boxed(self) -> BoxBody {
  function nested_boxed_body (line 112) | async fn nested_boxed_body() {

FILE: actix-http/src/body/either.rs
  function new (line 41) | pub fn new(body: L) -> Self {
  function left (line 49) | pub fn left(body: L) -> Self {
  function right (line 55) | pub fn right(body: R) -> Self {
  type Error (line 65) | type Error = Error;
  method size (line 68) | fn size(&self) -> BodySize {
  method poll_next (line 76) | fn poll_next(
  method try_into_bytes (line 91) | fn try_into_bytes(self) -> Result<Bytes, Self> {
  method boxed (line 103) | fn boxed(self) -> BoxBody {
  function type_parameter_inference (line 116) | fn type_parameter_inference() {

FILE: actix-http/src/body/message_body.rs
  type MessageBody (line 55) | pub trait MessageBody {
    method size (line 65) | fn size(&self) -> BodySize;
    method poll_next (line 84) | fn poll_next(
    method try_into_bytes (line 101) | fn try_into_bytes(self) -> Result<Bytes, Self>
    method boxed (line 114) | fn boxed(self) -> BoxBody
    type Error (line 131) | type Error = B::Error;
    method size (line 133) | fn size(&self) -> BodySize {
    method poll_next (line 137) | fn poll_next(
    type Error (line 146) | type Error = Infallible;
    method size (line 148) | fn size(&self) -> BodySize {
    method poll_next (line 152) | fn poll_next(
    type Error (line 161) | type Error = Infallible;
    method size (line 164) | fn size(&self) -> BodySize {
    method poll_next (line 169) | fn poll_next(
    method try_into_bytes (line 177) | fn try_into_bytes(self) -> Result<Bytes, Self> {
    type Error (line 186) | type Error = B::Error;
    method size (line 189) | fn size(&self) -> BodySize {
    method poll_next (line 194) | fn poll_next(
    type Error (line 207) | type Error = B::Error;
    method size (line 210) | fn size(&self) -> BodySize {
    method poll_next (line 215) | fn poll_next(
    type Error (line 224) | type Error = Infallible;
    method size (line 227) | fn size(&self) -> BodySize {
    method poll_next (line 232) | fn poll_next(
    method try_into_bytes (line 244) | fn try_into_bytes(self) -> Result<Bytes, Self> {
    type Error (line 250) | type Error = Infallible;
    method size (line 253) | fn size(&self) -> BodySize {
    method poll_next (line 258) | fn poll_next(
    method try_into_bytes (line 270) | fn try_into_bytes(self) -> Result<Bytes, Self> {
    type Error (line 276) | type Error = Infallible;
    method size (line 279) | fn size(&self) -> BodySize {
    method poll_next (line 284) | fn poll_next(
    method try_into_bytes (line 296) | fn try_into_bytes(self) -> Result<Bytes, Self> {
    type Error (line 302) | type Error = Infallible;
    method size (line 305) | fn size(&self) -> BodySize {
    method poll_next (line 310) | fn poll_next(
    method try_into_bytes (line 322) | fn try_into_bytes(self) -> Result<Bytes, Self> {
    type Error (line 328) | type Error = Infallible;
    method size (line 331) | fn size(&self) -> BodySize {
    method poll_next (line 336) | fn poll_next(
    method try_into_bytes (line 352) | fn try_into_bytes(self) -> Result<Bytes, Self> {
    type Error (line 361) | type Error = Infallible;
    method size (line 364) | fn size(&self) -> BodySize {
    method poll_next (line 369) | fn poll_next(
    method try_into_bytes (line 383) | fn try_into_bytes(self) -> Result<Bytes, Self> {
    type Error (line 389) | type Error = Infallible;
    method size (line 392) | fn size(&self) -> BodySize {
    method poll_next (line 397) | fn poll_next(
    method try_into_bytes (line 410) | fn try_into_bytes(self) -> Result<Bytes, Self> {
    type Error (line 416) | type Error = Infallible;
    method size (line 419) | fn size(&self) -> BodySize {
    method poll_next (line 424) | fn poll_next(
    method try_into_bytes (line 440) | fn try_into_bytes(self) -> Result<Bytes, Self> {
    type Error (line 449) | type Error = Infallible;
    method size (line 452) | fn size(&self) -> BodySize {
    method poll_next (line 457) | fn poll_next(
    method try_into_bytes (line 466) | fn try_into_bytes(self) -> Result<Bytes, Self> {
    type Error (line 499) | type Error = E;
    method size (line 502) | fn size(&self) -> BodySize {
    method poll_next (line 506) | fn poll_next(
    method try_into_bytes (line 524) | fn try_into_bytes(self) -> Result<Bytes, Self> {
  function new (line 485) | pub(crate) fn new(body: B, mapper: F) -> Self {
  function boxing_equivalence (line 559) | async fn boxing_equivalence() {
  function mut_equivalence (line 573) | async fn mut_equivalence() {
  function test_unit (line 602) | async fn test_unit() {
  function test_static_str (line 610) | async fn test_static_str() {
  function test_static_bytes (line 620) | async fn test_static_bytes() {
  function test_vec (line 630) | async fn test_vec() {
  function test_bytes (line 640) | async fn test_bytes() {
  function test_bytes_mut (line 650) | async fn test_bytes_mut() {
  function test_string (line 660) | async fn test_string() {
  function complete_body_combinators (line 670) | async fn complete_body_combinators() {
  function complete_body_combinators_poll (line 683) | async fn complete_body_combinators_poll() {
  function none_body_combinators (line 696) | async fn none_body_combinators() {
  function test_body_casting (line 713) | async fn test_body_casting() {
  function non_owning_to_bytes (line 728) | async fn non_owning_to_bytes() {

FILE: actix-http/src/body/none.rs
  type None (line 21) | pub struct None;
    method new (line 26) | pub fn new() -> Self {
  type Error (line 32) | type Error = Infallible;
  method size (line 35) | fn size(&self) -> BodySize {
  method poll_next (line 40) | fn poll_next(
  method try_into_bytes (line 48) | fn try_into_bytes(self) -> Result<Bytes, Self> {

FILE: actix-http/src/body/size.rs
  type BodySize (line 3) | pub enum BodySize {
    constant ZERO (line 24) | pub const ZERO: Self = Self::Sized(0);
    method is_eof (line 38) | pub fn is_eof(&self) -> bool {

FILE: actix-http/src/body/sized_stream.rs
  function new (line 31) | pub fn new(size: u64, stream: S) -> Self {
  type Error (line 43) | type Error = E;
  method size (line 46) | fn size(&self) -> BodySize {
  method poll_next (line 55) | fn poll_next(
  function skips_empty_chunks (line 96) | async fn skips_empty_chunks() {
  function read_to_bytes (line 126) | async fn read_to_bytes() {
  function stream_string_error (line 140) | async fn stream_string_error() {
  function stream_boxed_error (line 152) | async fn stream_boxed_error() {

FILE: actix-http/src/body/utils.rs
  function to_bytes (line 33) | pub async fn to_bytes<B: MessageBody>(body: B) -> Result<Bytes, B::Error> {
  type BodyLimitExceeded (line 43) | pub struct BodyLimitExceeded;
  function to_bytes_limited (line 71) | pub async fn to_bytes_limited<B: MessageBody>(
  function to_bytes_complete (line 134) | async fn to_bytes_complete() {
  function to_bytes_streams (line 144) | async fn to_bytes_streams() {
  function to_bytes_limited_complete (line 153) | async fn to_bytes_limited_complete() {
  function to_bytes_limited_streams (line 171) | async fn to_bytes_limited_streams() {
  function to_body_limit_error (line 192) | async fn to_body_limit_error() {

FILE: actix-http/src/builder.rs
  type HttpServiceBuilder (line 17) | pub struct HttpServiceBuilder<T, S, X = ExpectHandler, U = UpgradeHandle...
  method default (line 40) | fn default() -> Self {
  function keep_alive (line 80) | pub fn keep_alive<W: Into<KeepAlive>>(mut self, val: W) -> Self {
  function secure (line 86) | pub fn secure(mut self) -> Self {
  function local_addr (line 92) | pub fn local_addr(mut self, addr: net::SocketAddr) -> Self {
  function client_request_timeout (line 106) | pub fn client_request_timeout(mut self, dur: Duration) -> Self {
  function client_timeout (line 113) | pub fn client_timeout(self, dur: Duration) -> Self {
  function client_disconnect_timeout (line 125) | pub fn client_disconnect_timeout(mut self, dur: Duration) -> Self {
  function tcp_nodelay (line 131) | pub fn tcp_nodelay(mut self, nodelay: bool) -> Self {
  function client_disconnect (line 138) | pub fn client_disconnect(self, dur: Duration) -> Self {
  function h1_allow_half_closed (line 149) | pub fn h1_allow_half_closed(mut self, allow: bool) -> Self {
  function h2_initial_window_size (line 157) | pub fn h2_initial_window_size(mut self, size: u32) -> Self {
  function h2_initial_connection_window_size (line 165) | pub fn h2_initial_connection_window_size(mut self, size: u32) -> Self {
  function expect (line 175) | pub fn expect<F, X1>(self, expect: F) -> HttpServiceBuilder<T, S, X1, U>
  function upgrade (line 203) | pub fn upgrade<F, U1>(self, upgrade: F) -> HttpServiceBuilder<T, S, X, U1>
  function on_connect_ext (line 232) | pub fn on_connect_ext<F>(mut self, f: F) -> Self
  function h1 (line 241) | pub fn h1<F, B>(self, service: F) -> H1Service<T, S, B, X, U>
  function h2 (line 269) | pub fn h2<F, B>(self, service: F) -> crate::h2::H2Service<T, S, B>
  function finish (line 295) | pub fn finish<F, B>(self, service: F) -> HttpService<T, S, B, X, U>

FILE: actix-http/src/config.rs
  constant DEFAULT_H2_CONN_WINDOW_SIZE (line 14) | pub(crate) const DEFAULT_H2_CONN_WINDOW_SIZE: u32 = 1024 * 1024 * 2;
  constant DEFAULT_H2_STREAM_WINDOW_SIZE (line 19) | pub(crate) const DEFAULT_H2_STREAM_WINDOW_SIZE: u32 = 1024 * 1024;
  type ServiceConfigBuilder (line 23) | pub struct ServiceConfigBuilder {
    method new (line 38) | pub fn new() -> Self {
    method secure (line 43) | pub fn secure(mut self, secure: bool) -> Self {
    method local_addr (line 49) | pub fn local_addr(mut self, local_addr: Option<SocketAddr>) -> Self {
    method keep_alive (line 55) | pub fn keep_alive(mut self, keep_alive: KeepAlive) -> Self {
    method client_request_timeout (line 61) | pub fn client_request_timeout(mut self, timeout: Duration) -> Self {
    method client_disconnect_timeout (line 68) | pub fn client_disconnect_timeout(mut self, timeout: Duration) -> Self {
    method tcp_nodelay (line 74) | pub fn tcp_nodelay(mut self, nodelay: Option<bool>) -> Self {
    method h1_allow_half_closed (line 84) | pub fn h1_allow_half_closed(mut self, allow: bool) -> Self {
    method h2_initial_window_size (line 95) | pub fn h2_initial_window_size(mut self, size: u32) -> Self {
    method h2_initial_connection_window_size (line 106) | pub fn h2_initial_connection_window_size(mut self, size: u32) -> Self {
    method build (line 112) | pub fn build(self) -> ServiceConfig {
  type ServiceConfig (line 119) | pub struct ServiceConfig(Rc<Inner>);
    method new (line 154) | pub fn new(
    method secure (line 177) | pub fn secure(&self) -> bool {
    method local_addr (line 185) | pub fn local_addr(&self) -> Option<SocketAddr> {
    method keep_alive (line 191) | pub fn keep_alive(&self) -> KeepAlive {
    method keep_alive_deadline (line 199) | pub fn keep_alive_deadline(&self) -> Option<Instant> {
    method client_request_deadline (line 211) | pub fn client_request_deadline(&self) -> Option<Instant> {
    method client_disconnect_deadline (line 217) | pub fn client_disconnect_deadline(&self) -> Option<Instant> {
    method h1_allow_half_closed (line 227) | pub fn h1_allow_half_closed(&self) -> bool {
    method tcp_nodelay (line 232) | pub fn tcp_nodelay(&self) -> Option<bool> {
    method h2_initial_window_size (line 237) | pub fn h2_initial_window_size(&self) -> u32 {
    method h2_initial_connection_window_size (line 242) | pub fn h2_initial_connection_window_size(&self) -> u32 {
    method now (line 246) | pub(crate) fn now(&self) -> Instant {
    method write_date_header (line 255) | pub fn write_date_header(&self, dst: &mut BytesMut, camel_case: bool) {
    method write_date_header_value (line 269) | pub(crate) fn write_date_header_value(&self, dst: &mut BytesMut) {
  type Inner (line 122) | struct Inner {
  method default (line 136) | fn default() -> Self {
  function test_date_service_update (line 288) | async fn test_date_service_update() {
  function test_date_service_drop (line 321) | async fn test_date_service_drop() {
  function test_date_len (line 350) | fn test_date_len() {
  function test_date (line 355) | async fn test_date() {
  function test_date_camel_case (line 368) | async fn test_date_camel_case() {

FILE: actix-http/src/date.rs
  constant DATE_VALUE_LENGTH (line 11) | pub(crate) const DATE_VALUE_LENGTH: usize = 29;
  type Date (line 14) | pub(crate) struct Date {
    method new (line 20) | fn new() -> Date {
    method update (line 29) | fn update(&mut self) {
    method write_str (line 36) | fn write_str(&mut self, s: &str) -> fmt::Result {
  type DateService (line 45) | pub(crate) struct DateService {
    method new (line 51) | pub(crate) fn new() -> Self {
    method now (line 72) | pub(crate) fn now(&self) -> Instant {
    method with_date (line 76) | pub(crate) fn with_date<F: FnMut(&Date)>(&self, mut f: F) {
    method fmt (line 82) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  method drop (line 88) | fn drop(&mut self) {

FILE: actix-http/src/encoding/decoder.rs
  constant MAX_CHUNK_SIZE_DECODE_IN_PLACE (line 24) | const MAX_CHUNK_SIZE_DECODE_IN_PLACE: usize = 2049;
  function new (line 42) | pub fn new(stream: S, encoding: ContentEncoding) -> Decoder<S> {
  function from_headers (line 79) | pub fn from_headers(stream: S, headers: &HeaderMap) -> Decoder<S> {
  type Item (line 95) | type Item = Result<Bytes, PayloadError>;
  method poll_next (line 97) | fn poll_next(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<...
  type ContentDecoder (line 161) | enum ContentDecoder {
    method feed_eof (line 178) | fn feed_eof(&mut self) -> io::Result<Option<Bytes>> {
    method feed_data (line 236) | fn feed_data(&mut self, data: Bytes) -> io::Result<Option<Bytes>> {

FILE: actix-http/src/encoding/encoder.rs
  constant MAX_CHUNK_SIZE_ENCODE_IN_PLACE (line 29) | const MAX_CHUNK_SIZE_ENCODE_IN_PLACE: usize = 1024;
  function none (line 42) | fn none() -> Self {
  function empty (line 53) | fn empty() -> Self {
  function response (line 62) | pub fn response(encoding: ContentEncoding, head: &mut ResponseHead, body...
  type Error (line 117) | type Error = EncoderError;
  method size (line 120) | fn size(&self) -> BodySize {
  method poll_next (line 128) | fn poll_next(
  method try_into_bytes (line 146) | fn try_into_bytes(self) -> Result<Bytes, Self>
  type Error (line 162) | type Error = EncoderError;
  method size (line 165) | fn size(&self) -> BodySize {
  method poll_next (line 173) | fn poll_next(
  method try_into_bytes (line 247) | fn try_into_bytes(mut self) -> Result<Bytes, Self>
  function update_head (line 265) | fn update_head(encoding: ContentEncoding, head: &mut ResponseHead) {
  type ContentEncoder (line 274) | enum ContentEncoder {
    method select (line 291) | fn select(encoding: ContentEncoding) -> Option<Self> {
    method take (line 319) | pub(crate) fn take(&mut self) -> Bytes {
    method finish (line 335) | fn finish(self) -> Result<Bytes, io::Error> {
    method write (line 363) | fn write(&mut self, data: &[u8]) -> Result<(), io::Error> {
  function new_brotli_compressor (line 405) | fn new_brotli_compressor() -> Box<brotli::CompressorWriter<Writer>> {
  type EncoderError (line 416) | pub enum EncoderError {
  method source (line 427) | fn source(&self) -> Option<&(dyn StdError + 'static)> {
  function from (line 436) | fn from(err: EncoderError) -> Self {

FILE: actix-http/src/encoding/mod.rs
  type Writer (line 15) | struct Writer {
    method new (line 20) | fn new() -> Writer {
    method take (line 26) | fn take(&mut self) -> Bytes {
    method write (line 32) | fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
    method flush (line 37) | fn flush(&mut self) -> io::Result<()> {

FILE: actix-http/src/error.rs
  type Error (line 11) | pub struct Error {
    method new (line 22) | fn new(kind: Kind) -> Self {
    method with_cause (line 28) | pub(crate) fn with_cause(mut self, cause: impl Into<Box<dyn StdError>>...
    method new_http (line 33) | pub(crate) fn new_http() -> Self {
    method new_parse (line 37) | pub(crate) fn new_parse() -> Self {
    method new_payload (line 41) | pub(crate) fn new_payload() -> Self {
    method new_body (line 45) | pub(crate) fn new_body() -> Self {
    method new_send_response (line 49) | pub(crate) fn new_send_response() -> Self {
    method new_io (line 54) | pub(crate) fn new_io() -> Self {
    method new_encoder (line 59) | pub(crate) fn new_encoder() -> Self {
    method new_ws (line 64) | pub(crate) fn new_ws() -> Self {
    method fmt (line 109) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
    method fmt (line 118) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
    method from (line 133) | fn from(err: std::convert::Infallible) -> Self {
    method from (line 139) | fn from(err: HttpError) -> Self {
    method from (line 146) | fn from(err: crate::ws::HandshakeError) -> Self {
    method from (line 153) | fn from(err: crate::ws::ProtocolError) -> Self {
    method from (line 243) | fn from(err: ParseError) -> Self {
    method from (line 319) | fn from(err: PayloadError) -> Self {
  type ErrorInner (line 15) | pub(crate) struct ErrorInner {
  function from (line 70) | fn from(err: Error) -> Self {
  type Kind (line 82) | pub(crate) enum Kind {
  method source (line 127) | fn source(&self) -> Option<&(dyn StdError + 'static)> {
  type ParseError (line 161) | pub enum ParseError {
    method from (line 205) | fn from(err: io::Error) -> ParseError {
    method from (line 211) | fn from(err: InvalidUri) -> ParseError {
    method from (line 217) | fn from(err: Utf8Error) -> ParseError {
    method from (line 223) | fn from(err: FromUtf8Error) -> ParseError {
    method from (line 229) | fn from(err: httparse::Error) -> ParseError {
  function from (line 249) | fn from(err: ParseError) -> Self {
  type PayloadError (line 257) | pub enum PayloadError {
    method source (line 285) | fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
    method from (line 301) | fn from(err: ::h2::Error) -> Self {
    method from (line 307) | fn from(err: Option<io::Error>) -> Self {
    method from (line 313) | fn from(err: io::Error) -> Self {
  type DispatchError (line 327) | pub enum DispatchError {
  method source (line 371) | fn source(&self) -> Option<&(dyn StdError + 'static)> {
  type ContentTypeError (line 390) | pub enum ContentTypeError {
  function test_into_response (line 407) | fn test_into_response() {
  function test_as_response (line 417) | fn test_as_response() {
  function test_error_display (line 427) | fn test_error_display() {
  function test_error_http_response (line 434) | fn test_error_http_response() {
  function test_payload_error (line 442) | fn test_payload_error() {
  function test_from (line 477) | fn test_from() {

FILE: actix-http/src/extensions.rs
  type NoOpHasher (line 13) | struct NoOpHasher(u64);
  method write (line 16) | fn write(&mut self, _bytes: &[u8]) {
  method write_u64 (line 20) | fn write_u64(&mut self, i: u64) {
  method finish (line 24) | fn finish(&self) -> u64 {
  type Extensions (line 33) | pub struct Extensions {
    method new (line 41) | pub fn new() -> Extensions {
    method insert (line 59) | pub fn insert<T: 'static>(&mut self, val: T) -> Option<T> {
    method contains (line 75) | pub fn contains<T: 'static>(&self) -> bool {
    method get (line 87) | pub fn get<T: 'static>(&self) -> Option<&T> {
    method get_mut (line 101) | pub fn get_mut<T: 'static>(&mut self) -> Option<&mut T> {
    method get_or_insert (line 121) | pub fn get_or_insert<T: 'static>(&mut self, value: T) -> &mut T {
    method get_or_insert_with (line 139) | pub fn get_or_insert_with<T: 'static, F: FnOnce() -> T>(&mut self, def...
    method remove (line 161) | pub fn remove<T: 'static>(&mut self) -> Option<T> {
    method clear (line 178) | pub fn clear(&mut self) {
    method extend (line 183) | pub fn extend(&mut self, other: Extensions) {
    method fmt (line 189) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  function downcast_owned (line 194) | fn downcast_owned<T: 'static>(boxed: Box<dyn Any>) -> Option<T> {
  function test_remove (line 203) | fn test_remove() {
  function test_clear (line 214) | fn test_clear() {
  function test_integers (line 236) | fn test_integers() {
  function test_composition (line 266) | fn test_composition() {
  function test_extensions (line 293) | fn test_extensions() {
  function test_extend (line 313) | fn test_extend() {

FILE: actix-http/src/h1/chunked.rs
  type ChunkedState (line 19) | pub(super) enum ChunkedState {
    method step (line 33) | pub(super) fn step(
    method read_size (line 54) | fn read_size(rdr: &mut BytesMut, size: &mut u64) -> Poll<Result<Chunke...
    method read_size_lws (line 89) | fn read_size_lws(rdr: &mut BytesMut) -> Poll<Result<ChunkedState, io::...
    method read_extension (line 101) | fn read_extension(rdr: &mut BytesMut) -> Poll<Result<ChunkedState, io:...
    method read_size_lf (line 112) | fn read_size_lf(rdr: &mut BytesMut, size: u64) -> Poll<Result<ChunkedS...
    method read_body (line 123) | fn read_body(
    method read_body_cr (line 151) | fn read_body_cr(rdr: &mut BytesMut) -> Poll<Result<ChunkedState, io::E...
    method read_body_lf (line 160) | fn read_body_lf(rdr: &mut BytesMut) -> Poll<Result<ChunkedState, io::E...
    method read_end_cr (line 169) | fn read_end_cr(rdr: &mut BytesMut) -> Poll<Result<ChunkedState, io::Er...
    method read_end_lf (line 178) | fn read_end_lf(rdr: &mut BytesMut) -> Poll<Result<ChunkedState, io::Er...
  function test_parse_chunked_payload_chunk_extension (line 224) | fn test_parse_chunked_payload_chunk_extension() {
  function test_request_chunked (line 246) | fn test_request_chunked() {
  function test_http_request_chunked_payload (line 268) | fn test_http_request_chunked_payload() {
  function test_http_request_chunked_payload_and_next_message (line 291) | fn test_http_request_chunked_payload_and_next_message() {
  function test_http_request_chunked_payload_chunks (line 321) | fn test_http_request_chunked_payload_chunks() {
  function chunk_extension_quoted (line 366) | fn chunk_extension_quoted() {
  function hrs_chunk_extension_invalid (line 385) | fn hrs_chunk_extension_invalid() {
  function hrs_chunk_size_overflow (line 407) | fn hrs_chunk_size_overflow() {

FILE: actix-http/src/h1/client.rs
  type ClientCodec (line 28) | pub struct ClientCodec {
    method fmt (line 56) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
    method new (line 67) | pub fn new(config: ServiceConfig) -> Self {
    method upgrade (line 89) | pub fn upgrade(&self) -> bool {
    method keep_alive (line 94) | pub fn keep_alive(&self) -> bool {
    method message_type (line 99) | pub fn message_type(&self) -> MessageType {
    method into_payload_codec (line 110) | pub fn into_payload_codec(self) -> ClientPayloadCodec {
    type Error (line 192) | type Error = io::Error;
    method encode (line 194) | fn encode(
  type ClientPayloadCodec (line 33) | pub struct ClientPayloadCodec {
    method keep_alive (line 117) | pub fn keep_alive(&self) -> bool {
    method into_message_codec (line 122) | pub fn into_message_codec(self) -> ClientCodec {
  type ClientCodecInner (line 37) | struct ClientCodecInner {
  method default (line 50) | fn default() -> Self {
  type Item (line 128) | type Item = ResponseHead;
  type Error (line 129) | type Error = ParseError;
  method decode (line 131) | fn decode(&mut self, src: &mut BytesMut) -> Result<Option<Self::Item>, S...
  type Item (line 168) | type Item = Option<Bytes>;
  type Error (line 169) | type Error = PayloadError;
  method decode (line 171) | fn decode(&mut self, src: &mut BytesMut) -> Result<Option<Self::Item>, S...

FILE: actix-http/src/h1/codec.rs
  type Codec (line 24) | pub struct Codec {
    method fmt (line 43) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
    method new (line 54) | pub fn new(config: ServiceConfig) -> Self {
    method upgrade (line 74) | pub fn upgrade(&self) -> bool {
    method keep_alive (line 80) | pub fn keep_alive(&self) -> bool {
    method keep_alive_enabled (line 86) | pub fn keep_alive_enabled(&self) -> bool {
    method message_type (line 92) | pub fn message_type(&self) -> MessageType {
    method config (line 103) | pub fn config(&self) -> &ServiceConfig {
    type Error (line 150) | type Error = io::Error;
    method encode (line 152) | fn encode(
  method default (line 37) | fn default() -> Self {
  type Item (line 109) | type Item = Message<Request>;
  type Error (line 110) | type Error = ParseError;
  method decode (line 112) | fn decode(&mut self, src: &mut BytesMut) -> Result<Option<Self::Item>, S...
  function test_http_request_chunked_payload_and_next_message (line 205) | async fn test_http_request_chunked_payload_and_next_message() {

FILE: actix-http/src/h1/decoder.rs
  constant MAX_BUFFER_SIZE (line 14) | pub(crate) const MAX_BUFFER_SIZE: usize = 131_072;
  constant MAX_HEADERS (line 15) | const MAX_HEADERS: usize = 96;
  type MessageDecoder (line 18) | pub(crate) struct MessageDecoder<T: MessageType>(PhantomData<T>);
  type PayloadType (line 22) | pub(crate) enum PayloadType {
    method unwrap (line 570) | pub(crate) fn unwrap(self) -> PayloadDecoder {
    method is_unhandled (line 577) | pub(crate) fn is_unhandled(&self) -> bool {
  method default (line 29) | fn default() -> Self {
  type Item (line 35) | type Item = (T, PayloadType);
  type Error (line 36) | type Error = ParseError;
  method decode (line 38) | fn decode(&mut self, src: &mut BytesMut) -> Result<Option<Self::Item>, S...
  type PayloadLength (line 43) | pub(crate) enum PayloadLength {
    method is_none (line 51) | fn is_none(&self) -> bool {
    method is_zero (line 56) | fn is_zero(&self) -> bool {
  type MessageType (line 66) | pub(crate) trait MessageType: Sized {
    method set_connection_type (line 67) | fn set_connection_type(&mut self, conn_type: Option<ConnectionType>);
    method set_expect (line 69) | fn set_expect(&mut self);
    method headers_mut (line 71) | fn headers_mut(&mut self) -> &mut HeaderMap;
    method decode (line 73) | fn decode(src: &mut BytesMut) -> Result<Option<(Self, PayloadType)>, P...
    method set_headers (line 75) | fn set_headers(
    method set_connection_type (line 217) | fn set_connection_type(&mut self, conn_type: Option<ConnectionType>) {
    method set_expect (line 223) | fn set_expect(&mut self) {
    method headers_mut (line 227) | fn headers_mut(&mut self) -> &mut HeaderMap {
    method decode (line 231) | fn decode(src: &mut BytesMut) -> Result<Option<(Self, PayloadType)>, P...
    method set_connection_type (line 318) | fn set_connection_type(&mut self, conn_type: Option<ConnectionType>) {
    method set_expect (line 324) | fn set_expect(&mut self) {}
    method headers_mut (line 326) | fn headers_mut(&mut self) -> &mut HeaderMap {
    method decode (line 330) | fn decode(src: &mut BytesMut) -> Result<Option<(Self, PayloadType)>, P...
  type HeaderIndex (line 408) | pub(crate) struct HeaderIndex {
    method record (line 422) | pub(crate) fn record(
  constant EMPTY_HEADER_INDEX (line 413) | pub(crate) const EMPTY_HEADER_INDEX: HeaderIndex = HeaderIndex {
  constant EMPTY_HEADER_INDEX_ARRAY (line 418) | pub(crate) const EMPTY_HEADER_INDEX_ARRAY: [HeaderIndex; MAX_HEADERS] =
  type PayloadItem (line 441) | pub enum PayloadItem {
    method chunk (line 583) | pub(crate) fn chunk(self) -> Bytes {
    method eof (line 590) | pub(crate) fn eof(&self) -> bool {
  type PayloadDecoder (line 450) | pub struct PayloadDecoder {
    method length (line 456) | pub fn length(x: u64) -> PayloadDecoder {
    method chunked (line 463) | pub fn chunked() -> PayloadDecoder {
    method eof (line 470) | pub fn eof() -> PayloadDecoder {
  type Kind (line 476) | enum Kind {
  type Item (line 501) | type Item = PayloadItem;
  type Error (line 502) | type Error = io::Error;
  method decode (line 504) | fn decode(&mut self, src: &mut BytesMut) -> Result<Option<Self::Item>, S...
  function test_parse (line 618) | fn test_parse() {
  function test_parse_partial (line 633) | fn test_parse_partial() {
  function parse_h09_reject (line 647) | fn parse_h09_reject() {
  function parse_h10_get (line 668) | fn parse_h10_get() {
  function parse_h10_post (line 707) | fn parse_h10_post() {
  function test_parse_body (line 744) | fn test_parse_body() {
  function test_parse_body_crlf (line 760) | fn test_parse_body_crlf() {
  function test_parse_partial_eof (line 776) | fn test_parse_partial_eof() {
  function test_headers_split_field (line 789) | fn test_headers_split_field() {
  function test_headers_multi_value (line 816) | fn test_headers_multi_value() {
  function test_conn_default_1_0 (line 835) | fn test_conn_default_1_0() {
  function test_conn_default_1_1 (line 841) | fn test_conn_default_1_1() {
  function test_conn_close (line 847) | fn test_conn_close() {
  function test_conn_close_1_0 (line 862) | fn test_conn_close_1_0() {
  function test_conn_keep_alive_1_0 (line 871) | fn test_conn_keep_alive_1_0() {
  function test_conn_keep_alive_1_1 (line 886) | fn test_conn_keep_alive_1_1() {
  function test_conn_other_1_0 (line 895) | fn test_conn_other_1_0() {
  function test_conn_other_1_1 (line 904) | fn test_conn_other_1_1() {
  function test_conn_upgrade (line 913) | fn test_conn_upgrade() {
  function test_conn_upgrade_connect_method (line 934) | fn test_conn_upgrade_connect_method() {
  function test_headers_bad_content_length (line 944) | fn test_headers_bad_content_length() {
  function octal_ish_cl_parsed_as_decimal (line 959) | fn octal_ish_cl_parsed_as_decimal() {
  function test_invalid_header (line 973) | fn test_invalid_header() {
  function test_invalid_name (line 981) | fn test_invalid_name() {
  function test_http_request_bad_status_line (line 989) | fn test_http_request_bad_status_line() {
  function test_http_request_upgrade_websocket (line 994) | fn test_http_request_upgrade_websocket() {
  function test_http_request_upgrade_h2c (line 1009) | fn test_http_request_upgrade_h2c() {
  function test_http_request_parser_utf8 (line 1029) | fn test_http_request_parser_utf8() {
  function test_http_request_parser_two_slashes (line 1042) | fn test_http_request_parser_two_slashes() {
  function test_http_request_parser_bad_method (line 1048) | fn test_http_request_parser_bad_method() {
  function test_http_request_parser_bad_version (line 1053) | fn test_http_request_parser_bad_version() {
  function test_response_http10_read_until_eof (line 1058) | fn test_response_http10_read_until_eof() {
  function hrs_multiple_content_length (line 1070) | fn hrs_multiple_content_length() {
  function hrs_content_length_plus (line 1091) | fn hrs_content_length_plus() {
  function hrs_te_http10 (line 1102) | fn hrs_te_http10() {
  function hrs_cl_and_te_http10 (line 1118) | fn hrs_cl_and_te_http10() {
  function hrs_unknown_transfer_encoding (line 1134) | fn hrs_unknown_transfer_encoding() {
  function hrs_multiple_transfer_encoding (line 1150) | fn hrs_multiple_transfer_encoding() {
  function transfer_encoding_agrees (line 1168) | fn transfer_encoding_agrees() {

FILE: actix-http/src/h1/dispatcher.rs
  constant LW_BUFFER_SIZE (line 37) | const LW_BUFFER_SIZE: usize = 1024;
  constant HW_BUFFER_SIZE (line 38) | const HW_BUFFER_SIZE: usize = 1024 * 8;
  constant MAX_PIPELINED_MESSAGES (line 39) | const MAX_PIPELINED_MESSAGES: usize = 16;
  type DispatcherMessage (line 175) | enum DispatcherMessage {
  function is_none (line 203) | pub(super) fn is_none(&self) -> bool {
  function fmt (line 214) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  type PollResponse (line 232) | enum PollResponse {
  function new (line 255) | pub(crate) fn new(
  function can_read (line 310) | fn can_read(&self, cx: &mut Context<'_>) -> bool {
  function client_disconnected (line 323) | fn client_disconnected(self: Pin<&mut Self>) {
  function poll_flush (line 334) | fn poll_flush(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Result...
  function send_response_inner (line 364) | fn send_response_inner(
  function send_response (line 386) | fn send_response(
  function send_error_response (line 413) | fn send_error_response(
  function send_continue (line 440) | fn send_continue(self: Pin<&mut Self>) {
  function poll_response (line 446) | fn poll_response(
  function handle_request (line 655) | fn handle_request(
  function poll_request (line 740) | fn poll_request(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Resul...
  function poll_head_timer (line 889) | fn poll_head_timer(
  function poll_ka_timer (line 913) | fn poll_ka_timer(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Resu...
  function poll_shutdown_timer (line 956) | fn poll_shutdown_timer(
  function poll_timers (line 978) | fn poll_timers(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Result...
  function read_available (line 992) | fn read_available(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Result<...
  function upgrade (line 1078) | fn upgrade(self: Pin<&mut Self>, req: Request) -> U::Future {
  type Output (line 1107) | type Output = Result<(), DispatchError>;
  method poll (line 1110) | fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Ou...
  function trace_timer_states (line 1299) | fn trace_timer_states(

FILE: actix-http/src/h1/dispatcher_tests.rs
  type YieldService (line 26) | struct YieldService;
    type Response (line 29) | type Response = Response<BoxBody>;
    type Error (line 30) | type Error = Response<BoxBody>;
    type Future (line 31) | type Future = Pin<Box<dyn Future<Output = Result<Self::Response, Self:...
    method call (line 35) | fn call(&self, _: Request) -> Self::Future {
  function find_slice (line 46) | fn find_slice(haystack: &[u8], needle: &[u8], from: usize) -> Option<usi...
  function stabilize_date_header (line 50) | fn stabilize_date_header(payload: &mut [u8]) {
  function ok_service (line 59) | fn ok_service() -> impl Service<Request, Response = Response<impl Messag...
  function status_service (line 63) | fn status_service(
  function echo_path_service (line 69) | fn echo_path_service() -> impl Service<Request, Response = Response<impl...
  function drop_payload_service (line 79) | fn drop_payload_service() -> impl Service<Request, Response = Response<&...
  function echo_payload_service (line 87) | fn echo_payload_service() -> impl Service<Request, Response = Response<B...
  function late_request (line 104) | async fn late_request() {
  function oneshot_connection (line 171) | async fn oneshot_connection() {
  function keep_alive_timeout (line 232) | async fn keep_alive_timeout() {
  function keep_alive_follow_up_req (line 311) | async fn keep_alive_follow_up_req() {
  function req_parse_err (line 436) | async fn req_parse_err() {
  function pipelining_ok_then_ok (line 469) | async fn pipelining_ok_then_ok() {
  function early_response_with_payload_closes_connection (line 539) | async fn early_response_with_payload_closes_connection() {
  function pipelining_ok_then_bad (line 606) | async fn pipelining_ok_then_bad() {
  function expect_handling (line 675) | async fn expect_handling() {
  function expect_eager (line 752) | async fn expect_eager() {
  function upgrade_handling (line 818) | async fn upgrade_handling() {
  function handler_drop_payload (line 880) | async fn handler_drop_payload() {
  function handler_drop_payload_drains_body (line 1025) | async fn handler_drop_payload_drains_body() {
  function allow_half_closed (line 1143) | async fn allow_half_closed() {
  function disallow_half_closed (line 1191) | async fn disallow_half_closed() {
  function http_msg (line 1227) | fn http_msg(msg: impl AsRef<str>) -> BytesMut {
  function http_msg_creates_msg (line 1247) | fn http_msg_creates_msg() {

FILE: actix-http/src/h1/encoder.rs
  constant AVERAGE_HEADER_SIZE (line 19) | const AVERAGE_HEADER_SIZE: usize = 30;
  type MessageEncoder (line 22) | pub(crate) struct MessageEncoder<T: MessageType> {
  method default (line 30) | fn default() -> Self {
  type MessageType (line 39) | pub(crate) trait MessageType: Sized {
    method status (line 40) | fn status(&self) -> Option<StatusCode>;
    method headers (line 42) | fn headers(&self) -> &HeaderMap;
    method extra_headers (line 44) | fn extra_headers(&self) -> Option<&HeaderMap>;
    method camel_case (line 46) | fn camel_case(&self) -> bool {
    method chunked (line 50) | fn chunked(&self) -> bool;
    method encode_status (line 52) | fn encode_status(&mut self, dst: &mut BytesMut) -> io::Result<()>;
    method encode_headers (line 54) | fn encode_headers(
    method write_headers (line 230) | fn write_headers<F>(&mut self, mut f: F)
    method status (line 250) | fn status(&self) -> Option<StatusCode> {
    method chunked (line 254) | fn chunked(&self) -> bool {
    method headers (line 258) | fn headers(&self) -> &HeaderMap {
    method extra_headers (line 262) | fn extra_headers(&self) -> Option<&HeaderMap> {
    method camel_case (line 266) | fn camel_case(&self) -> bool {
    method encode_status (line 272) | fn encode_status(&mut self, dst: &mut BytesMut) -> io::Result<()> {
    method status (line 285) | fn status(&self) -> Option<StatusCode> {
    method chunked (line 289) | fn chunked(&self) -> bool {
    method camel_case (line 293) | fn camel_case(&self) -> bool {
    method headers (line 297) | fn headers(&self) -> &HeaderMap {
    method extra_headers (line 301) | fn extra_headers(&self) -> Option<&HeaderMap> {
    method encode_status (line 305) | fn encode_status(&mut self, dst: &mut BytesMut) -> io::Result<()> {
  function encode_chunk (line 328) | pub fn encode_chunk(&mut self, msg: &[u8], buf: &mut BytesMut) -> io::Re...
  function encode_eof (line 333) | pub fn encode_eof(&mut self, buf: &mut BytesMut) -> io::Result<()> {
  function encode (line 338) | pub fn encode(
  type TransferEncoding (line 374) | pub(crate) struct TransferEncoding {
    method empty (line 396) | pub fn empty() -> TransferEncoding {
    method eof (line 403) | pub fn eof() -> TransferEncoding {
    method chunked (line 410) | pub fn chunked() -> TransferEncoding {
    method length (line 417) | pub fn length(len: u64) -> TransferEncoding {
    method encode (line 425) | pub fn encode(&mut self, msg: &[u8], buf: &mut BytesMut) -> io::Result...
    method encode_eof (line 470) | pub fn encode_eof(&mut self, buf: &mut BytesMut) -> io::Result<()> {
  type TransferEncodingKind (line 379) | enum TransferEncodingKind {
  function write_data (line 494) | unsafe fn write_data(value: &[u8], buf: *mut u8, len: usize) {
  function write_camel_case (line 502) | unsafe fn write_camel_case(value: &[u8], buf: *mut u8, len: usize) {
  function test_chunked_te (line 547) | fn test_chunked_te() {
  function test_camel_case (line 561) | async fn test_camel_case() {
  function test_extra_headers (line 635) | async fn test_extra_headers() {
  function test_no_content_length (line 668) | async fn test_no_content_length() {

FILE: actix-http/src/h1/expect.rs
  type ExpectHandler (line 6) | pub struct ExpectHandler;
    type Response (line 9) | type Response = Request;
    type Error (line 10) | type Error = Error;
    type Config (line 11) | type Config = ();
    type Service (line 12) | type Service = ExpectHandler;
    type InitError (line 13) | type InitError = Error;
    type Future (line 14) | type Future = Ready<Result<Self::Service, Self::InitError>>;
    method new_service (line 16) | fn new_service(&self, _: Self::Config) -> Self::Future {
    type Response (line 22) | type Response = Request;
    type Error (line 23) | type Error = Error;
    type Future (line 24) | type Future = Ready<Result<Self::Response, Self::Error>>;
    method call (line 28) | fn call(&self, req: Request) -> Self::Future {

FILE: actix-http/src/h1/mod.rs
  type Message (line 33) | pub enum Message<T> {
  function from (line 42) | fn from(item: T) -> Self {
  type MessageType (line 49) | pub enum MessageType {
  constant LW (line 55) | const LW: usize = 2 * 1024;
  constant HW (line 56) | const HW: usize = 32 * 1024;
  function reserve_readbuf (line 58) | pub(crate) fn reserve_readbuf(src: &mut BytesMut) {
  function message (line 71) | pub fn message(self) -> Request {
  function chunk (line 78) | pub fn chunk(self) -> Bytes {
  function eof (line 85) | pub fn eof(self) -> bool {

FILE: actix-http/src/h1/payload.rs
  constant MAX_BUFFER_SIZE (line 17) | pub(crate) const MAX_BUFFER_SIZE: usize = 32_768;
  type PayloadStatus (line 20) | pub enum PayloadStatus {
  type Payload (line 33) | pub struct Payload {
    method create (line 43) | pub fn create(eof: bool) -> (PayloadSender, Payload) {
    method empty (line 53) | pub(crate) fn empty() -> Payload {
    method len (line 61) | pub fn len(&self) -> usize {
    method is_empty (line 67) | pub fn is_empty(&self) -> bool {
    method unread_data (line 73) | pub fn unread_data(&mut self, data: Bytes) {
  type Item (line 79) | type Item = Result<Bytes, PayloadError>;
  method poll_next (line 81) | fn poll_next(
  type PayloadSender (line 90) | pub struct PayloadSender {
    method new (line 95) | fn new(inner: Weak<RefCell<Inner>>) -> Self {
    method set_error (line 100) | pub fn set_error(&mut self, err: PayloadError) {
    method feed_eof (line 107) | pub fn feed_eof(&mut self) {
    method feed_data (line 114) | pub fn feed_data(&mut self, data: Bytes) {
    method need_read (line 122) | pub fn need_read(&self, cx: &mut Context<'_>) -> PayloadStatus {
    method is_dropped (line 138) | pub fn is_dropped(&self) -> bool {
  type Inner (line 144) | struct Inner {
    method new (line 155) | fn new(eof: bool) -> Self {
    method wake (line 168) | fn wake(&mut self) {
    method wake_io (line 175) | fn wake_io(&mut self) {
    method register (line 183) | fn register(&mut self, cx: &Context<'_>) {
    method register_io (line 191) | fn register_io(&mut self, cx: &Context<'_>) {
    method set_error (line 202) | fn set_error(&mut self, err: PayloadError) {
    method feed_eof (line 208) | fn feed_eof(&mut self) {
    method feed_data (line 214) | fn feed_data(&mut self, data: Bytes) {
    method len (line 222) | fn len(&self) -> usize {
    method poll_next (line 226) | fn poll_next(
    method unread_data (line 251) | fn unread_data(&mut self, data: Bytes) {
  constant WAKE_TIMEOUT (line 274) | const WAKE_TIMEOUT: Duration = Duration::from_secs(2);
  function prepare_waking_test (line 276) | fn prepare_waking_test(
  function wake_on_error (line 316) | async fn wake_on_error() {
  function wake_on_eof (line 326) | async fn wake_on_eof() {
  function test_unread_data (line 336) | async fn test_unread_data() {

FILE: actix-http/src/h1/service.rs
  type H1Service (line 28) | pub struct H1Service<T, S, B, X = ExpectHandler, U = UpgradeHandler> {
  function with_config (line 46) | pub(crate) fn with_config<F: IntoServiceFactory<S, Request>>(
  function tcp (line 82) | pub fn tcp(
  function openssl (line 131) | pub fn openssl(
  function rustls (line 192) | pub fn rustls(
  function rustls_021 (line 253) | pub fn rustls_021(
  function rustls_0_22 (line 314) | pub fn rustls_0_22(
  function rustls_0_23 (line 375) | pub fn rustls_0_23(
  function expect (line 407) | pub fn expect<X1>(self, expect: X1) -> H1Service<T, S, B, X1, U>
  function upgrade (line 423) | pub fn upgrade<U1>(self, upgrade: Option<U1>) -> H1Service<T, S, B, X, U1>
  function on_connect_ext (line 440) | pub(crate) fn on_connect_ext(mut self, f: Option<Rc<ConnectCallback<T>>>...
  type Response (line 468) | type Response = ();
  type Error (line 469) | type Error = DispatchError;
  type Config (line 470) | type Config = ();
  type Service (line 471) | type Service = H1ServiceHandler<T, S::Service, B, X::Service, U::Service>;
  type InitError (line 472) | type InitError = ();
  type Future (line 473) | type Future = LocalBoxFuture<'static, Result<Self::Service, Self::InitEr...
  function new_service (line 475) | fn new_service(&self, _: ()) -> Self::Future {
  type H1ServiceHandler (line 513) | pub type H1ServiceHandler<T, S, B, X, U> = HttpServiceHandler<T, S, B, X...
  type Response (line 531) | type Response = ();
  type Error (line 532) | type Error = DispatchError;
  type Future (line 533) | type Future = Dispatcher<T, S, B, X, U>;
  function poll_ready (line 535) | fn poll_ready(&self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Erro...
  function call (line 542) | fn call(&self, (io, addr): (T, Option<net::SocketAddr>)) -> Self::Future {

FILE: actix-http/src/h1/timer.rs
  type TimerState (line 7) | pub(super) enum TimerState {
    method new (line 14) | pub(super) fn new(enabled: bool) -> Self {
    method is_enabled (line 22) | pub(super) fn is_enabled(&self) -> bool {
    method set (line 26) | pub(super) fn set(&mut self, timer: Sleep, line: u32) {
    method set_and_init (line 36) | pub(super) fn set_and_init(&mut self, cx: &mut Context<'_>, timer: Sle...
    method clear (line 41) | pub(super) fn clear(&mut self, line: u32) {
    method init (line 53) | pub(super) fn init(&mut self, cx: &mut Context<'_>) {
    method fmt (line 61) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {

FILE: actix-http/src/h1/upgrade.rs
  type UpgradeHandler (line 7) | pub struct UpgradeHandler;
    type Response (line 10) | type Response = ();
    type Error (line 11) | type Error = Error;
    type Config (line 12) | type Config = ();
    type Service (line 13) | type Service = UpgradeHandler;
    type InitError (line 14) | type InitError = Error;
    type Future (line 15) | type Future = LocalBoxFuture<'static, Result<Self::Service, Self::Init...
    method new_service (line 17) | fn new_service(&self, _: ()) -> Self::Future {
    type Response (line 23) | type Response = ();
    type Error (line 24) | type Error = Error;
    type Future (line 25) | type Future = LocalBoxFuture<'static, Result<Self::Response, Self::Err...
    method call (line 29) | fn call(&self, _: (Request, Framed<T, Codec>)) -> Self::Future {

FILE: actix-http/src/h1/utils.rs
  function new (line 34) | pub fn new(framed: Framed<T, Codec>, response: Response<B>) -> Self {
  type Output (line 51) | type Output = Result<Framed<T, Codec>, Error>;
  method poll (line 54) | fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Ou...

FILE: actix-http/src/h2/dispatcher.rs
  constant CHUNK_SIZE (line 34) | const CHUNK_SIZE: usize = 16_384;
  function new (line 53) | pub(crate) fn new(
  type H2PingPong (line 85) | struct H2PingPong {
  type Output (line 107) | type Output = Result<(), crate::error::DispatchError>;
  method poll (line 110) | fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
  type DispatchError (line 201) | enum DispatchError {
  function handle_response (line 207) | async fn handle_response<B>(
  function prepare_response (line 276) | fn prepare_response(

FILE: actix-http/src/h2/mod.rs
  type Payload (line 29) | pub struct Payload {
    method new (line 34) | pub(crate) fn new(stream: RecvStream) -> Self {
  type Item (line 40) | type Item = Result<Bytes, PayloadError>;
  method poll_next (line 42) | fn poll_next(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<...
  function handshake_with_timeout (line 60) | pub(crate) fn handshake_with_timeout<T>(io: T, config: &ServiceConfig) -...
  type HandshakeWithTimeout (line 77) | pub(crate) struct HandshakeWithTimeout<T: AsyncRead + AsyncWrite + Unpin> {
  type Output (line 86) | type Output = Result<(Connection<T, Bytes>, Option<Pin<Box<Sleep>>>), Di...
  method poll (line 88) | fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {

FILE: actix-http/src/h2/service.rs
  function desired_nodelay (line 29) | fn desired_nodelay(tcp_nodelay: Option<bool>) -> Option<bool> {
  function set_nodelay (line 34) | fn set_nodelay(stream: &TcpStream, nodelay: bool) {
  type H2Service (line 39) | pub struct H2Service<T, S, B> {
  function with_config (line 56) | pub(crate) fn with_config<F: IntoServiceFactory<S, Request>>(
  function on_connect_ext (line 69) | pub(crate) fn on_connect_ext(mut self, f: Option<Rc<ConnectCallback<T>>>...
  function tcp (line 86) | pub fn tcp(
  function openssl (line 134) | pub fn openssl(
  function rustls (line 186) | pub fn rustls(
  function rustls_021 (line 241) | pub fn rustls_021(
  function rustls_0_22 (line 296) | pub fn rustls_0_22(
  function rustls_0_23 (line 351) | pub fn rustls_0_23(
  type Response (line 395) | type Response = ();
  type Error (line 396) | type Error = DispatchError;
  type Config (line 397) | type Config = ();
  type Service (line 398) | type Service = H2ServiceHandler<T, S::Service, B>;
  type InitError (line 399) | type InitError = S::InitError;
  type Future (line 400) | type Future = LocalBoxFuture<'static, Result<Self::Service, Self::InitEr...
    type Output (line 519) | type Output = Result<(), DispatchError>;
    method poll (line 521) | fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::...
  function new_service (line 402) | fn new_service(&self, _: ()) -> Self::Future {
  type H2ServiceHandler (line 415) | pub struct H2ServiceHandler<T, S, B>
  function new (line 433) | fn new(
  type Response (line 456) | type Response = ();
  type Error (line 457) | type Error = DispatchError;
  type Future (line 458) | type Future = H2ServiceHandlerResponse<T, S, B>;
    type Output (line 519) | type Output = Result<(), DispatchError>;
    method poll (line 521) | fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::...
  function poll_ready (line 460) | fn poll_ready(&self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Erro...
  function call (line 468) | fn call(&self, (io, addr): (T, Option<net::SocketAddr>)) -> Self::Future {
  type State (line 483) | enum State<T, S: Service<Request>, B: MessageBody>
  type H2ServiceHandlerResponse (line 498) | pub struct H2ServiceHandlerResponse<T, S, B>

FILE: actix-http/src/header/as_name.rs
  type AsHeaderName (line 10) | pub trait AsHeaderName: Sealed {}
  type Seal (line 12) | pub struct Seal;
  type Sealed (line 14) | pub trait Sealed {
    method try_as_name (line 15) | fn try_as_name(&self, seal: Seal) -> Result<Cow<'_, HeaderName>, Inval...
    method try_as_name (line 20) | fn try_as_name(&self, _: Seal) -> Result<Cow<'_, HeaderName>, InvalidH...
    method try_as_name (line 28) | fn try_as_name(&self, _: Seal) -> Result<Cow<'_, HeaderName>, InvalidH...
    method try_as_name (line 36) | fn try_as_name(&self, _: Seal) -> Result<Cow<'_, HeaderName>, InvalidH...
    method try_as_name (line 44) | fn try_as_name(&self, _: Seal) -> Result<Cow<'_, HeaderName>, InvalidH...
    method try_as_name (line 52) | fn try_as_name(&self, _: Seal) -> Result<Cow<'_, HeaderName>, InvalidH...

FILE: actix-http/src/header/common.rs
  constant CACHE_STATUS (line 12) | pub const CACHE_STATUS: HeaderName = HeaderName::from_static("cache-stat...
  constant CDN_CACHE_CONTROL (line 19) | pub const CDN_CACHE_CONTROL: HeaderName = HeaderName::from_static("cdn-c...
  constant CLEAR_SITE_DATA (line 27) | pub const CLEAR_SITE_DATA: HeaderName = HeaderName::from_static("clear-s...
  constant CROSS_ORIGIN_EMBEDDER_POLICY (line 34) | pub const CROSS_ORIGIN_EMBEDDER_POLICY: HeaderName =
  constant CROSS_ORIGIN_OPENER_POLICY (line 39) | pub const CROSS_ORIGIN_OPENER_POLICY: HeaderName =
  constant CROSS_ORIGIN_RESOURCE_POLICY (line 44) | pub const CROSS_ORIGIN_RESOURCE_POLICY: HeaderName =
  constant PERMISSIONS_POLICY (line 49) | pub const PERMISSIONS_POLICY: HeaderName = HeaderName::from_static("perm...
  constant X_FORWARDED_FOR (line 53) | pub const X_FORWARDED_FOR: HeaderName = HeaderName::from_static("x-forwa...
  constant X_FORWARDED_HOST (line 57) | pub const X_FORWARDED_HOST: HeaderName = HeaderName::from_static("x-forw...
  constant X_FORWARDED_PROTO (line 61) | pub const X_FORWARDED_PROTO: HeaderName = HeaderName::from_static("x-for...

FILE: actix-http/src/header/into_pair.rs
  type TryIntoHeaderPair (line 12) | pub trait TryIntoHeaderPair: Sized {
    method try_into_pair (line 15) | fn try_into_pair(self) -> Result<(HeaderName, HeaderValue), Self::Error>;
    type Error (line 38) | type Error = InvalidHeaderPart;
    method try_into_pair (line 40) | fn try_into_pair(self) -> Result<(HeaderName, HeaderValue), Self::Erro...
    type Error (line 54) | type Error = InvalidHeaderPart;
    method try_into_pair (line 56) | fn try_into_pair(self) -> Result<(HeaderName, HeaderValue), Self::Erro...
    type Error (line 70) | type Error = InvalidHeaderPart;
    method try_into_pair (line 72) | fn try_into_pair(self) -> Result<(HeaderName, HeaderValue), Self::Erro...
    type Error (line 87) | type Error = InvalidHeaderPart;
    method try_into_pair (line 89) | fn try_into_pair(self) -> Result<(HeaderName, HeaderValue), Self::Erro...
    type Error (line 104) | type Error = InvalidHeaderPart;
    method try_into_pair (line 107) | fn try_into_pair(self) -> Result<(HeaderName, HeaderValue), Self::Erro...
    type Error (line 114) | type Error = <T as TryIntoHeaderValue>::Error;
    method try_into_pair (line 117) | fn try_into_pair(self) -> Result<(HeaderName, HeaderValue), Self::Erro...
  type InvalidHeaderPart (line 19) | pub enum InvalidHeaderPart {
  method from (line 25) | fn from(part_err: InvalidHeaderPart) -> Self {

FILE: actix-http/src/header/into_value.rs
  type TryIntoHeaderValue (line 8) | pub trait TryIntoHeaderValue: Sized {
    method try_into_value (line 13) | fn try_into_value(self) -> Result<HeaderValue, Self::Error>;
    type Error (line 17) | type Error = InvalidHeaderValue;
    method try_into_value (line 20) | fn try_into_value(self) -> Result<HeaderValue, Self::Error> {
    type Error (line 26) | type Error = InvalidHeaderValue;
    method try_into_value (line 29) | fn try_into_value(self) -> Result<HeaderValue, Self::Error> {
    type Error (line 35) | type Error = InvalidHeaderValue;
    method try_into_value (line 38) | fn try_into_value(self) -> Result<HeaderValue, Self::Error> {
    type Error (line 44) | type Error = InvalidHeaderValue;
    method try_into_value (line 47) | fn try_into_value(self) -> Result<HeaderValue, Self::Error> {
    type Error (line 53) | type Error = InvalidHeaderValue;
    method try_into_value (line 56) | fn try_into_value(self) -> Result<HeaderValue, Self::Error> {
    type Error (line 62) | type Error = InvalidHeaderValue;
    method try_into_value (line 65) | fn try_into_value(self) -> Result<HeaderValue, Self::Error> {
    type Error (line 71) | type Error = InvalidHeaderValue;
    method try_into_value (line 74) | fn try_into_value(self) -> Result<HeaderValue, Self::Error> {
    type Error (line 80) | type Error = InvalidHeaderValue;
    method try_into_value (line 83) | fn try_into_value(self) -> Result<HeaderValue, Self::Error> {
    type Error (line 89) | type Error = InvalidHeaderValue;
    method try_into_value (line 92) | fn try_into_value(self) -> Result<HeaderValue, Self::Error> {
    type Error (line 98) | type Error = InvalidHeaderValue;
    method try_into_value (line 101) | fn try_into_value(self) -> Result<HeaderValue, Self::Error> {
    type Error (line 107) | type Error = InvalidHeaderValue;
    method try_into_value (line 110) | fn try_into_value(self) -> Result<HeaderValue, Self::Error> {
    type Error (line 116) | type Error = InvalidHeaderValue;
    method try_into_value (line 119) | fn try_into_value(self) -> Result<HeaderValue, Self::Error> {
    type Error (line 125) | type Error = InvalidHeaderValue;
    method try_into_value (line 128) | fn try_into_value(self) -> Result<HeaderValue, Self::Error> {

FILE: actix-http/src/header/map.rs
  type HeaderMap (line 49) | pub struct HeaderMap {
    method new (line 100) | pub fn new() -> Self {
    method with_capacity (line 117) | pub fn with_capacity(capacity: usize) -> Self {
    method from_drain (line 124) | pub(crate) fn from_drain<I>(mut drain: I) -> Self
    method len (line 168) | pub fn len(&self) -> usize {
    method len_keys (line 189) | pub fn len_keys(&self) -> usize {
    method is_empty (line 204) | pub fn is_empty(&self) -> bool {
    method clear (line 224) | pub fn clear(&mut self) {
    method get_value (line 228) | fn get_value(&self, key: impl AsHeaderName) -> Option<&Value> {
    method get (line 264) | pub fn get(&self, key: impl AsHeaderName) -> Option<&HeaderValue> {
    method get_mut (line 294) | pub fn get_mut(&mut self, key: impl AsHeaderName) -> Option<&mut Heade...
    method get_all (line 323) | pub fn get_all(&self, key: impl AsHeaderName) -> std::slice::Iter<'_, ...
    method contains_key (line 345) | pub fn contains_key(&self, key: impl AsHeaderName) -> bool {
    method insert (line 387) | pub fn insert(&mut self, name: HeaderName, val: HeaderValue) -> Removed {
    method append (line 412) | pub fn append(&mut self, key: HeaderName, value: HeaderValue) {
    method remove (line 459) | pub fn remove(&mut self, key: impl AsHeaderName) -> Removed {
    method capacity (line 484) | pub fn capacity(&self) -> usize {
    method reserve (line 507) | pub fn reserve(&mut self, additional: usize) {
    method iter (line 539) | pub fn iter(&self) -> Iter<'_> {
    method keys (line 565) | pub fn keys(&self) -> Keys<'_> {
    method retain (line 590) | pub fn retain<F>(&mut self, mut retain_fn: F)
    method drain (line 628) | pub fn drain(&mut self) -> Drain<'_> {
    method from_iter (line 658) | fn from_iter<T: IntoIterator<Item = (HeaderName, HeaderValue)>>(iter: ...
    method from (line 669) | fn from(mut map: http::HeaderMap) -> Self {
  type Value (line 55) | pub(crate) struct Value {
    method one (line 60) | fn one(val: HeaderValue) -> Self {
    method first (line 66) | fn first(&self) -> &HeaderValue {
    method first_mut (line 70) | fn first_mut(&mut self) -> &mut HeaderValue {
    method append (line 74) | fn append(&mut self, new_val: HeaderValue) {
    type Target (line 80) | type Target = SmallVec<[HeaderValue; 4]>;
    method deref (line 82) | fn deref(&self) -> &Self::Target {
  type Item (line 637) | type Item = (HeaderName, HeaderValue);
  type IntoIter (line 638) | type IntoIter = IntoIter;
  method into_iter (line 641) | fn into_iter(self) -> Self::IntoIter {
  type Item (line 648) | type Item = (&'a HeaderName, &'a HeaderValue);
  type IntoIter (line 649) | type IntoIter = Iter<'a>;
  method into_iter (line 652) | fn into_iter(self) -> Self::IntoIter {
  function from (line 676) | fn from(map: HeaderMap) -> Self {
  function from (line 683) | fn from(map: &HeaderMap) -> Self {
  type Removed (line 693) | pub struct Removed {
    method new (line 698) | fn new(value: Option<Value>) -> Self {
    method is_empty (line 707) | pub fn is_empty(&self) -> bool {
  type Item (line 717) | type Item = HeaderValue;
  method next (line 720) | fn next(&mut self) -> Option<Self::Item> {
  method size_hint (line 725) | fn size_hint(&self) -> (usize, Option<usize>) {
  type Keys (line 739) | pub struct Keys<'a>(hash_map::Keys<'a, HeaderName, Value>);
  type Item (line 742) | type Item = &'a HeaderName;
  method next (line 745) | fn next(&mut self) -> Option<Self::Item> {
  method size_hint (line 750) | fn size_hint(&self) -> (usize, Option<usize>) {
  type Iter (line 761) | pub struct Iter<'a> {
  function new (line 769) | fn new(iter: hash_map::Iter<'a, HeaderName, Value>, remaining: usize) ->...
  type Item (line 780) | type Item = (&'a HeaderName, &'a HeaderValue);
  method next (line 782) | fn next(&mut self) -> Option<Self::Item> {
  method size_hint (line 807) | fn size_hint(&self) -> (usize, Option<usize>) {
  type Drain (line 820) | pub struct Drain<'a> {
  function new (line 828) | fn new(iter: hash_map::Drain<'a, HeaderName, Value>, remaining: usize) -...
  type Item (line 839) | type Item = (Option<HeaderName>, HeaderValue);
  method next (line 841) | fn next(&mut self) -> Option<Self::Item> {
  method size_hint (line 863) | fn size_hint(&self) -> (usize, Option<usize>) {
  type IntoIter (line 876) | pub struct IntoIter {
    method new (line 883) | fn new(inner: hash_map::IntoIter<HeaderName, Value>, remaining: usize)...
  type Item (line 893) | type Item = (HeaderName, HeaderValue);
  method next (line 895) | fn next(&mut self) -> Option<Self::Item> {
  method size_hint (line 918) | fn size_hint(&self) -> (usize, Option<usize>) {
  function create (line 945) | fn create() {
  function insert (line 956) | fn insert() {
  function contains (line 964) | fn contains() {
  function entries_iter (line 976) | fn entries_iter() {
  function drain_iter (line 996) | fn drain_iter() {
  function retain (line 1023) | fn retain() {
  function retain_removes_empty_value_lists (line 1051) | fn retain_removes_empty_value_lists() {
  function entries_into_iter (line 1072) | fn entries_into_iter() {
  function iter_and_into_iter_same_order (line 1087) | fn iter_and_into_iter_same_order() {
  function get_all_and_remove_same_order (line 1104) | fn get_all_and_remove_same_order() {
  function get_all_iteration_order_matches_insertion_order (line 1119) | fn get_all_iteration_order_matches_insertion_order() {
  function iter_len_counts_values (line 1169) | fn iter_len_counts_values() {
  function into_iter_len_counts_values (line 1180) | fn into_iter_len_counts_values() {
  function drain_len_counts_values (line 1191) | fn drain_len_counts_values() {
  function owned_pair (line 1202) | fn owned_pair<'a>((name, val): (&'a HeaderName, &'a HeaderValue)) -> (He...

FILE: actix-http/src/header/mod.rs
  type Header (line 60) | pub trait Header: TryIntoHeaderValue {
    method name (line 62) | fn name() -> HeaderName;
    method parse (line 65) | fn parse<M: HttpMessage>(msg: &M) -> Result<Self, ParseError>;
  constant HTTP_VALUE (line 70) | pub(crate) const HTTP_VALUE: &AsciiSet = &CONTROLS

FILE: actix-http/src/header/shared/charset.rs
  type Charset (line 12) | pub enum Charset {
    method label (line 66) | fn label(&self) -> &str {
    method fmt (line 98) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
    type Err (line 104) | type Err = crate::Error;
    method from_str (line 106) | fn from_str(s: &str) -> Result<Charset, crate::Error> {
  function test_parse (line 142) | fn test_parse() {
  function test_display (line 151) | fn test_display() {

FILE: actix-http/src/header/shared/content_encoding.rs
  type ContentEncodingParseError (line 15) | pub struct ContentEncodingParseError;
  type ContentEncoding (line 25) | pub enum ContentEncoding {
    method as_str (line 47) | pub const fn as_str(self) -> &'static str {
    method to_header_value (line 59) | pub const fn to_header_value(self) -> HeaderValue {
    type Error (line 100) | type Error = ContentEncodingParseError;
    method try_from (line 102) | fn try_from(val: &str) -> Result<Self, Self::Error> {
  method default (line 72) | fn default() -> Self {
  type Err (line 78) | type Err = ContentEncodingParseError;
  method from_str (line 80) | fn from_str(enc: &str) -> Result<Self, Self::Err> {
  type Error (line 108) | type Error = InvalidHeaderValue;
  method try_into_value (line 110) | fn try_into_value(self) -> Result<http::HeaderValue, Self::Error> {
  method name (line 116) | fn name() -> HeaderName {
  method parse (line 120) | fn parse<T: HttpMessage>(msg: &T) -> Result<Self, ParseError> {

FILE: actix-http/src/header/shared/extended.rs
  type ExtendedValue (line 16) | pub struct ExtendedValue {
    method fmt (line 100) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  function parse_extended_value (line 66) | pub fn parse_extended_value(val: &str) -> Result<ExtendedValue, crate::e...
  function test_parse_extended_value_with_encoding_and_language_tag (line 115) | fn test_parse_extended_value_with_encoding_and_language_tag() {
  function test_parse_extended_value_with_encoding (line 132) | fn test_parse_extended_value_with_encoding() {
  function test_parse_extended_value_missing_language_tag_and_encoding (line 151) | fn test_parse_extended_value_missing_language_tag_and_encoding() {
  function test_parse_extended_value_partially_formatted (line 158) | fn test_parse_extended_value_partially_formatted() {
  function test_parse_extended_value_partially_formatted_blank (line 164) | fn test_parse_extended_value_partially_formatted_blank() {
  function test_fmt_extended_value_with_encoding_and_language_tag (line 170) | fn test_fmt_extended_value_with_encoding_and_language_tag() {
  function test_fmt_extended_value_with_encoding (line 180) | fn test_fmt_extended_value_with_encoding() {

FILE: actix-http/src/header/shared/http_date.rs
  type HttpDate (line 12) | pub struct HttpDate(SystemTime);
    method fmt (line 26) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
    method from (line 46) | fn from(sys_time: SystemTime) -> HttpDate {
  type Err (line 15) | type Err = ParseError;
  method from_str (line 17) | fn from_str(s: &str) -> Result<HttpDate, ParseError> {
  type Error (line 32) | type Error = InvalidHeaderValue;
  method try_into_value (line 34) | fn try_into_value(self) -> Result<HeaderValue, Self::Error> {
  method from (line 52) | fn from(HttpDate(sys_time): HttpDate) -> SystemTime {
  function date_header (line 64) | fn date_header() {

FILE: actix-http/src/header/shared/quality.rs
  constant MAX_QUALITY_INT (line 5) | const MAX_QUALITY_INT: u16 = 1000;
  constant MAX_QUALITY_FLOAT (line 6) | const MAX_QUALITY_FLOAT: f32 = 1.0;
  type Quality (line 33) | pub struct Quality(pub(super) u16);
    constant MAX (line 37) | pub const MAX: Quality = Quality(MAX_QUALITY_INT);
    constant MIN (line 40) | pub const MIN: Quality = Quality(1);
    constant ZERO (line 43) | pub const ZERO: Quality = Quality(0);
    method from_f32 (line 51) | fn from_f32(value: f32) -> Self {
    method fmt (line 71) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
    type Error (line 133) | type Error = QualityOutOfBounds;
    method try_from (line 136) | fn try_from(value: f32) -> Result<Self, Self::Error> {
  method default (line 65) | fn default() -> Quality {
  function itoa_fmt (line 122) | pub fn itoa_fmt<W: fmt::Write, V: itoa::Integer>(mut wr: W, value: V) ->...
  type QualityOutOfBounds (line 130) | pub struct QualityOutOfBounds;
  function q (line 173) | pub fn q<T>(quality: T) -> Quality
  function q_helper (line 186) | fn q_helper() {
  function display_output (line 191) | fn display_output() {
  function negative_quality (line 213) | fn negative_quality() {
  function quality_out_of_bounds (line 219) | fn quality_out_of_bounds() {

FILE: actix-http/src/header/shared/quality_item.rs
  type QualityItem (line 34) | pub struct QualityItem<T> {
  function new (line 46) | pub fn new(item: T, quality: Quality) -> Self {
  function max (line 51) | pub fn max(item: T) -> Self {
  function min (line 56) | pub fn min(item: T) -> Self {
  function zero (line 61) | pub fn zero(item: T) -> Self {
  method partial_cmp (line 67) | fn partial_cmp(&self, other: &QualityItem<T>) -> Option<cmp::Ordering> {
  function fmt (line 73) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  type Err (line 90) | type Err = ParseError;
  function from_str (line 92) | fn from_str(q_item_str: &str) -> Result<Self, Self::Err> {
  type Encoding (line 150) | pub enum Encoding {
    method fmt (line 162) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
    type Err (line 178) | type Err = crate::error::ParseError;
    method from_str (line 179) | fn from_str(s: &str) -> Result<Encoding, crate::error::ParseError> {
  function test_quality_item_fmt_q_1 (line 195) | fn test_quality_item_fmt_q_1() {
  function test_quality_item_fmt_q_0001 (line 201) | fn test_quality_item_fmt_q_0001() {
  function test_quality_item_fmt_q_05 (line 207) | fn test_quality_item_fmt_q_05() {
  function test_quality_item_fmt_q_0 (line 218) | fn test_quality_item_fmt_q_0() {
  function test_quality_item_from_str1 (line 229) | fn test_quality_item_from_str1() {
  function test_quality_item_from_str2 (line 242) | fn test_quality_item_from_str2() {
  function test_quality_item_from_str3 (line 255) | fn test_quality_item_from_str3() {
  function test_quality_item_from_str4 (line 268) | fn test_quality_item_from_str4() {
  function test_quality_item_from_str5 (line 281) | fn test_quality_item_from_str5() {
  function test_quality_item_from_str6 (line 287) | fn test_quality_item_from_str6() {
  function test_quality_item_ordering (line 293) | fn test_quality_item_ordering() {
  function test_fuzzing_bugs (line 301) | fn test_fuzzing_bugs() {

FILE: actix-http/src/header/utils.rs
  function from_comma_delimited (line 10) | pub fn from_comma_delimited<'a, I, T>(all: I) -> Result<Vec<T>, ParseError>
  function from_one_raw_str (line 36) | pub fn from_one_raw_str<T: FromStr>(val: Option<&HeaderValue>) -> Result...
  function fmt_comma_delimited (line 50) | pub fn fmt_comma_delimited<T>(f: &mut fmt::Formatter<'_>, parts: &[T]) -...
  function http_percent_encode (line 72) | pub fn http_percent_encode(f: &mut fmt::Formatter<'_>, bytes: &[u8]) -> ...
  function comma_delimited_parsing (line 82) | fn comma_delimited_parsing() {

FILE: actix-http/src/helpers.rs
  constant DIGITS_START (line 6) | const DIGITS_START: u8 = b'0';
  function write_status_line (line 8) | pub(crate) fn write_status_line<B: BufMut>(version: Version, n: u16, buf...
  function write_content_length (line 33) | pub fn write_content_length<B: BufMut>(n: u64, buf: &mut B, camel_case: ...
  type MutWriter (line 62) | pub(crate) struct MutWriter<'a, B>(pub(crate) &'a mut B);
  function write (line 68) | fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
  function flush (line 73) | fn flush(&mut self) -> io::Result<()> {
  function test_status_line (line 87) | fn test_status_line() {
  function test_write_content_length (line 105) | fn test_write_content_length() {
  function write_content_length_camel_case (line 183) | fn write_content_length_camel_case() {

FILE: actix-http/src/http_message.rs
  type HttpMessage (line 18) | pub trait HttpMessage: Sized {
    method headers (line 23) | fn headers(&self) -> &HeaderMap;
    method take_payload (line 26) | fn take_payload(&mut self) -> Payload<Self::Stream>;
    method extensions (line 29) | fn extensions(&self) -> Ref<'_, Extensions>;
    method extensions_mut (line 32) | fn extensions_mut(&self) -> RefMut<'_, Extensions>;
    method get_header (line 36) | fn get_header<H: Header>(&self) -> Option<H>
    method content_type (line 49) | fn content_type(&self) -> &str {
    method encoding (line 61) | fn encoding(&self) -> Result<&'static Encoding, ContentTypeError> {
    method mime_type (line 78) | fn mime_type(&self) -> Result<Option<Mime>, ContentTypeError> {
    method chunked (line 93) | fn chunked(&self) -> Result<bool, ParseError> {
    type Stream (line 110) | type Stream = T::Stream;
    method headers (line 112) | fn headers(&self) -> &HeaderMap {
    method take_payload (line 117) | fn take_payload(&mut self) -> Payload<Self::Stream> {
    method extensions (line 122) | fn extensions(&self) -> Ref<'_, Extensions> {
    method extensions_mut (line 127) | fn extensions_mut(&self) -> RefMut<'_, Extensions> {
  function test_content_type (line 141) | fn test_content_type() {
  function test_mime_type (line 155) | fn test_mime_type() {
  function test_mime_type_error (line 172) | fn test_mime_type_error() {
  function test_encoding (line 180) | fn test_encoding() {
  function test_encoding_error (line 196) | fn test_encoding_error() {
  function test_chunked (line 212) | fn test_chunked() {

FILE: actix-http/src/keep_alive.rs
  type KeepAlive (line 5) | pub enum KeepAlive {
    method enabled (line 23) | pub(crate) fn enabled(&self) -> bool {
    method duration (line 28) | pub(crate) fn duration(&self) -> Option<Duration> {
    method normalize (line 36) | pub(crate) fn normalize(self) -> KeepAlive {
    method from (line 51) | fn from(dur: Duration) -> Self {
    method from (line 57) | fn from(ka_dur: Option<Duration>) -> Self {
  method default (line 45) | fn default() -> Self {
  function from_impls (line 71) | fn from_impls() {

FILE: actix-http/src/lib.rs
  type Protocol (line 82) | pub enum Protocol {
  type ConnectCallback (line 88) | type ConnectCallback<IO> = dyn Fn(&IO, &mut Extensions);
  type OnConnectData (line 95) | pub(crate) struct OnConnectData(Option<Extensions>);
    method from_io (line 99) | pub(crate) fn from_io<T>(io: &T, on_connect_ext: Option<&ConnectCallba...

FILE: actix-http/src/message.rs
  type ConnectionType (line 7) | pub enum ConnectionType {
  type Head (line 31) | pub trait Head: Default + 'static {
    method clear (line 32) | fn clear(&mut self);
    method with_pool (line 34) | fn with_pool<F, R>(f: F) -> R
  type Message (line 39) | pub struct Message<T: Head> {
  function new (line 48) | pub fn new() -> Self {
  type Target (line 54) | type Target = T;
  function deref (line 56) | fn deref(&self) -> &Self::Target {
  function deref_mut (line 62) | fn deref_mut(&mut self) -> &mut Self::Target {
  method drop (line 68) | fn drop(&mut self) {
  type MessagePool (line 75) | pub struct MessagePool<T: Head>(RefCell<Vec<Rc<T>>>);
  function create (line 78) | pub(crate) fn create() -> MessagePool<T> {
  function get_message (line 84) | fn get_message(&self) -> Message<T> {
  function release (line 101) | fn release(&self, msg: Rc<T>) {

FILE: actix-http/src/notify_on_drop.rs
  function is_dropped (line 15) | pub(crate) fn is_dropped() -> bool {
  type NotifyOnDrop (line 22) | pub(crate) struct NotifyOnDrop;
    method new (line 27) | pub(crate) fn new() -> Self {
  method drop (line 42) | fn drop(&mut self) {

FILE: actix-http/src/payload.rs
  type BoxedPayloadStream (line 14) | pub type BoxedPayloadStream = Pin<Box<dyn Stream<Item = Result<Bytes, Pa...
  type PayloadStream (line 18) | pub type PayloadStream = BoxedPayloadStream;
  function from (line 45) | fn from(payload: crate::h1::Payload) -> Self {
  function from (line 52) | fn from(bytes: Bytes) -> Self {
  function from (line 61) | fn from(vec: Vec<u8>) -> Self {
  function from (line 69) | fn from(payload: crate::h2::Payload) -> Self {
  function from (line 77) | fn from(stream: ::h2::RecvStream) -> Self {
  method from (line 86) | fn from(payload: BoxedPayloadStream) -> Self {
  function take (line 94) | pub fn take(&mut self) -> Payload<S> {
  type Item (line 103) | type Item = Result<Bytes, PayloadError>;
  method poll_next (line 106) | fn poll_next(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<...

FILE: actix-http/src/requests/head.rs
  type RequestHead (line 14) | pub struct RequestHead {
    method headers (line 55) | pub fn headers(&self) -> &HeaderMap {
    method headers_mut (line 60) | pub fn headers_mut(&mut self) -> &mut HeaderMap {
    method camel_case_headers (line 68) | pub fn camel_case_headers(&self) -> bool {
    method set_camel_case_headers (line 74) | pub fn set_camel_case_headers(&mut self, val: bool) {
    method set_connection_type (line 84) | pub fn set_connection_type(&mut self, ctype: ConnectionType) {
    method connection_type (line 94) | pub fn connection_type(&self) -> ConnectionType {
    method upgrade (line 109) | pub fn upgrade(&self) -> bool {
    method chunked (line 124) | pub fn chunked(&self) -> bool {
    method no_chunking (line 129) | pub fn no_chunking(&mut self, val: bool) {
    method expect (line 139) | pub fn expect(&self) -> bool {
    method set_expect (line 144) | pub(crate) fn set_expect(&mut self) {
  method default (line 27) | fn default() -> RequestHead {
  method clear (line 40) | fn clear(&mut self) {
  method with_pool (line 45) | fn with_pool<F, R>(f: F) -> R
  type RequestHeadType (line 151) | pub enum RequestHeadType {
    method extra_headers (line 157) | pub fn extra_headers(&self) -> Option<&HeaderMap> {
    method as_ref (line 166) | fn as_ref(&self) -> &RequestHead {
    method from (line 175) | fn from(head: RequestHead) -> Self {

FILE: actix-http/src/requests/request.rs
  type Request (line 17) | pub struct Request<P = BoxedPayloadStream> {
  type Stream (line 25) | type Stream = P;
  method headers (line 28) | fn headers(&self) -> &HeaderMap {
  method take_payload (line 32) | fn take_payload(&mut self) -> Payload<P> {
  method extensions (line 37) | fn extensions(&self) -> Ref<'_, Extensions> {
  method extensions_mut (line 42) | fn extensions_mut(&self) -> RefMut<'_, Extensions> {
  function from (line 48) | fn from(head: Message<RequestHead>) -> Self {
  function new (line 61) | pub fn new() -> Request<BoxedPayloadStream> {
  function with_payload (line 73) | pub fn with_payload(payload: Payload<P>) -> Request<P> {
  function replace_payload (line 83) | pub fn replace_payload<P1>(self, payload: Payload<P1>) -> (Request<P1>, ...
  function payload (line 98) | pub fn payload(&mut self) -> &mut Payload<P> {
  function take_payload (line 103) | pub fn take_payload(&mut self) -> Payload<P> {
  function into_parts (line 108) | pub fn into_parts(self) -> (Message<RequestHead>, Payload<P>) {
  function head (line 114) | pub fn head(&self) -> &RequestHead {
  function head_mut (line 121) | pub fn head_mut(&mut self) -> &mut RequestHead {
  function headers_mut (line 126) | pub fn headers_mut(&mut self) -> &mut HeaderMap {
  function uri (line 132) | pub fn uri(&self) -> &Uri {
  function uri_mut (line 138) | pub fn uri_mut(&mut self) -> &mut Uri {
  function method (line 144) | pub fn method(&self) -> &Method {
  function version (line 150) | pub fn version(&self) -> Version {
  function path (line 156) | pub fn path(&self) -> &str {
  function upgrade (line 162) | pub fn upgrade(&self) -> bool {
  function peer_addr (line 178) | pub fn peer_addr(&self) -> Option<net::SocketAddr> {
  function conn_data (line 189) | pub fn conn_data<T: 'static>(&self) -> Option<&T> {
  function take_conn_data (line 199) | pub fn take_conn_data(&mut self) -> Option<Rc<Extensions>> {
  function take_req_data (line 204) | pub fn take_req_data(&mut self) -> Extensions {
  function fmt (line 210) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  function test_basics (line 238) | fn test_basics() {

FILE: actix-http/src/responses/builder.rs
  type ResponseBuilder (line 38) | pub struct ResponseBuilder {
    method new (line 53) | pub fn new(status: StatusCode) -> Self {
    method status (line 69) | pub fn status(&mut self, status: StatusCode) -> &mut Self {
    method insert_header (line 90) | pub fn insert_header(&mut self, header: impl TryIntoHeaderPair) -> &mu...
    method append_header (line 118) | pub fn append_header(&mut self, header: impl TryIntoHeaderPair) -> &mu...
    method reason (line 131) | pub fn reason(&mut self, reason: &'static str) -> &mut Self {
    method keep_alive (line 140) | pub fn keep_alive(&mut self) -> &mut Self {
    method upgrade (line 149) | pub fn upgrade<V>(&mut self, value: V) -> &mut Self
    method force_close (line 166) | pub fn force_close(&mut self) -> &mut Self {
    method no_chunking (line 175) | pub fn no_chunking(&mut self, len: u64) -> &mut Self {
    method content_type (line 187) | pub fn content_type<V>(&mut self, value: V) -> &mut Self
    method body (line 205) | pub fn body<B>(&mut self, body: B) -> Response<EitherBody<B>>
    method message_body (line 218) | pub fn message_body<B>(&mut self, body: B) -> Result<Response<B>, Erro...
    method finish (line 236) | pub fn finish(&mut self) -> Response<EitherBody<()>> {
    method take (line 241) | pub fn take(&mut self) -> ResponseBuilder {
    method inner (line 249) | fn inner(&mut self) -> Option<&mut ResponseHead> {
    method from (line 266) | fn from(res: Response<B>) -> ResponseBuilder {
    method from (line 276) | fn from(head: &'a ResponseHead) -> ResponseBuilder {
    method fmt (line 295) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  method default (line 259) | fn default() -> Self {
  function test_basic_builder (line 321) | fn test_basic_builder() {
  function test_upgrade (line 329) | fn test_upgrade() {
  function test_force_close (line 341) | fn test_force_close() {
  function test_content_type (line 347) | fn test_content_type() {
  function test_into_builder (line 360) | fn test_into_builder() {
  function response_builder_header_insert_kv (line 378) | fn response_builder_header_insert_kv() {
  function response_builder_header_insert_typed (line 390) | fn response_builder_header_insert_typed() {
  function response_builder_header_append_kv (line 402) | fn response_builder_header_append_kv() {
  function response_builder_header_append_typed (line 415) | fn response_builder_header_append_typed() {

FILE: actix-http/src/responses/head.rs
  type ResponseHead (line 12) | pub struct ResponseHead {
    method new (line 23) | pub fn new(status: StatusCode) -> ResponseHead {
    method headers (line 35) | pub fn headers(&self) -> &HeaderMap {
    method headers_mut (line 41) | pub fn headers_mut(&mut self) -> &mut HeaderMap {
    method set_camel_case_headers (line 49) | pub fn set_camel_case_headers(&mut self, camel_case: bool) {
    method set_connection_type (line 59) | pub fn set_connection_type(&mut self, ctype: ConnectionType) {
    method connection_type (line 68) | pub fn connection_type(&self) -> ConnectionType {
    method keep_alive (line 84) | pub fn keep_alive(&self) -> bool {
    method upgrade (line 90) | pub fn upgrade(&self) -> bool {
    method reason (line 96) | pub fn reason(&self) -> &str {
    method conn_type (line 105) | pub(crate) fn conn_type(&self) -> Option<ConnectionType> {
    method chunked (line 119) | pub fn chunked(&self) -> bool {
    method no_chunking (line 125) | pub fn no_chunking(&mut self, val: bool) {
  type BoxedResponseHead (line 134) | pub(crate) struct BoxedResponseHead {
    method new (line 140) | pub fn new(status: StatusCode) -> Self {
    type Target (line 146) | type Target = ResponseHead;
    method deref (line 148) | fn deref(&self) -> &Self::Target {
    method deref_mut (line 154) | fn deref_mut(&mut self) -> &mut Self::Target {
  method drop (line 160) | fn drop(&mut self) {
  type BoxedResponsePool (line 169) | pub struct BoxedResponsePool(#[allow(clippy::vec_box)] RefCell<Vec<Box<R...
    method create (line 172) | fn create() -> BoxedResponsePool {
    method get_message (line 178) | fn get_message(&self, status: StatusCode) -> BoxedResponseHead {
    method release (line 194) | fn release(&self, msg: Box<ResponseHead>) {
  function camel_case_headers (line 219) | async fn camel_case_headers() {

FILE: actix-http/src/responses/response.rs
  type Response (line 19) | pub struct Response<B> {
  function new (line 28) | pub fn new(status: StatusCode) -> Self {
  function build (line 38) | pub fn build(status: StatusCode) -> ResponseBuilder {
  function ok (line 47) | pub fn ok() -> Self {
  function bad_request (line 53) | pub fn bad_request() -> Self {
  function not_found (line 59) | pub fn not_found() -> Self {
  function internal_server_error (line 65) | pub fn internal_server_error() -> Self {
  function with_body (line 75) | pub fn with_body(status: StatusCode, body: B) -> Response<B> {
  function head (line 85) | pub fn head(&self) -> &ResponseHead {
  function head_mut (line 91) | pub fn head_mut(&mut self) -> &mut ResponseHead {
  function status (line 97) | pub fn status(&self) -> StatusCode {
  function status_mut (line 103) | pub fn status_mut(&mut self) -> &mut StatusCode {
  function headers (line 109) | pub fn headers(&self) -> &HeaderMap {
  function headers_mut (line 115) | pub fn headers_mut(&mut self) -> &mut HeaderMap {
  function upgrade (line 121) | pub fn upgrade(&self) -> bool {
  function keep_alive (line 127) | pub fn keep_alive(&self) -> bool {
  function extensions (line 133) | pub fn extensions(&self) -> Ref<'_, Extensions> {
  function extensions_mut (line 139) | pub fn extensions_mut(&mut self) -> RefMut<'_, Extensions> {
  function body (line 145) | pub fn body(&self) -> &B {
  function set_body (line 151) | pub fn set_body<B2>(self, body: B2) -> Response<B2> {
  function drop_body (line 161) | pub fn drop_body(self) -> Response<()> {
  function replace_body (line 167) | pub(crate) fn replace_body<B2>(self, body: B2) -> (Response<B2>, B) {
  function into_parts (line 184) | pub fn into_parts(self) -> (Response<()>, B) {
  function map_body (line 192) | pub fn map_body<F, B2>(mut self, f: F) -> Response<B2>
  function map_into_boxed_body (line 207) | pub fn map_into_boxed_body(self) -> Response<BoxBody>
  function into_body (line 216) | pub fn into_body(self) -> B {
  function fmt (line 225) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  method default (line 244) | fn default() -> Response<B> {
  function from (line 250) | fn from(res: Result<I, E>) -> Self {
  function from (line 259) | fn from(mut builder: ResponseBuilder) -> Self {
  function from (line 265) | fn from(val: std::convert::Infallible) -> Self {
  function from (line 271) | fn from(val: &'static str) -> Self {
  function from (line 280) | fn from(val: &'static [u8]) -> Self {
  function from (line 289) | fn from(val: Vec<u8>) -> Self {
  function from (line 298) | fn from(val: &Vec<u8>) -> Self {
  function from (line 307) | fn from(val: String) -> Self {
  function from (line 316) | fn from(val: &String) -> Self {
  function from (line 325) | fn from(val: Bytes) -> Self {
  function from (line 334) | fn from(val: BytesMut) -> Self {
  function from (line 343) | fn from(val: ByteString) -> Self {
  function test_debug (line 360) | fn test_debug() {
  function test_into_response (line 370) | async fn test_into_response() {

FILE: actix-http/src/service.rs
  function desired_nodelay (line 28) | fn desired_nodelay(tcp_nodelay: Option<bool>) -> Option<bool> {
  function set_nodelay (line 33) | fn set_nodelay(stream: &TcpStream, nodelay: bool) {
  type HttpService (line 70) | pub struct HttpService<T, S, B, X = h1::ExpectHandler, U = h1::UpgradeHa...
  function build (line 89) | pub fn build() -> HttpServiceBuilder<T, S> {
  function new (line 104) | pub fn new<F: IntoServiceFactory<S, Request>>(service: F) -> Self {
  function with_config (line 116) | pub(crate) fn with_config<F: IntoServiceFactory<S, Request>>(
  function expect (line 144) | pub fn expect<X1>(self, expect: X1) -> HttpService<T, S, B, X1, U>
  function upgrade (line 164) | pub fn upgrade<U1>(self, upgrade: Option<U1>) -> HttpService<T, S, B, X,...
  function on_connect_ext (line 181) | pub(crate) fn on_connect_ext(mut self, f: Option<Rc<ConnectCallback<T>>>...
  function tcp (line 211) | pub fn tcp(
  function tcp_auto_h2c (line 231) | pub fn tcp_auto_h2c(
  type TlsAcceptorConfig (line 268) | pub struct TlsAcceptorConfig {
    method handshake_timeout (line 275) | pub fn handshake_timeout(self, dur: std::time::Duration) -> Self {
  function openssl (line 322) | pub fn openssl(
  function openssl_with_config (line 336) | pub fn openssl_with_config(
  function rustls (line 420) | pub fn rustls(
  function rustls_with_config (line 434) | pub fn rustls_with_config(
  function rustls_021 (line 522) | pub fn rustls_021(
  function rustls_021_with_config (line 536) | pub fn rustls_021_with_config(
  function rustls_0_22 (line 624) | pub fn rustls_0_22(
  function rustls_0_22_with_config (line 638) | pub fn rustls_0_22_with_config(
  function rustls_0_23 (line 726) | pub fn rustls_0_23(
  function rustls_0_23_with_config (line 740) | pub fn rustls_0_23_with_config(
  type Response (line 814) | type Response = ();
  type Error (line 815) | type Error = DispatchError;
  type Config (line 816) | type Config = ();
  type Service (line 817) | type Service = HttpServiceHandler<T, S::Service, B, X::Service, U::Servi...
  type InitError (line 818) | type InitError = ();
  type Future (line 819) | type Future = LocalBoxFuture<'static, Result<Self::Service, Self::InitEr...
    type Output (line 1099) | type Output = Result<(), DispatchError>;
    method poll (line 1101) | fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::...
  function new_service (line 821) | fn new_service(&self, _: ()) -> Self::Future {
  type HttpServiceHandler (line 859) | pub struct HttpServiceHandler<T, S, B, X, U>
  function new (line 880) | pub(super) fn new(
  function _poll_ready (line 895) | pub(super) fn _poll_ready(&self, cx: &mut Context<'_>) -> Poll<Result<()...
  type HttpFlow (line 909) | pub(super) struct HttpFlow<S, X, U> {
  function new (line 916) | pub(super) fn new(service: S, expect: X, upgrade: Option<U>) -> Rc<Self> {
  type Response (line 943) | type Response = ();
  type Error (line 944) | type Error = DispatchError;
  type Future (line 945) | type Future = HttpServiceHandlerResponse<T, S, B, X, U>;
    type Output (line 1099) | type Output = Result<(), DispatchError>;
    method poll (line 1101) | fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::...
  function poll_ready (line 947) | fn poll_ready(&self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Erro...
  function call (line 954) | fn call(&self, (io, proto, peer_addr): (T, Protocol, Option<net::SocketA...

FILE: actix-http/src/test.rs
  type TestRequest (line 23) | pub struct TestRequest(Option<Inner>);
    method with_uri (line 47) | pub fn with_uri(path: &str) -> TestRequest {
    method version (line 52) | pub fn version(&mut self, ver: Version) -> &mut Self {
    method method (line 58) | pub fn method(&mut self, meth: Method) -> &mut Self {
    method uri (line 67) | pub fn uri(&mut self, path: &str) -> &mut Self {
    method insert_header (line 73) | pub fn insert_header(&mut self, header: impl TryIntoHeaderPair) -> &mu...
    method append_header (line 87) | pub fn append_header(&mut self, header: impl TryIntoHeaderPair) -> &mu...
    method set_payload (line 103) | pub fn set_payload(&mut self, data: impl Into<Bytes>) -> &mut Self {
    method take (line 112) | pub fn take(&mut self) -> TestRequest {
    method finish (line 117) | pub fn finish(&mut self) -> Request {
  type Inner (line 25) | struct Inner {
  method default (line 34) | fn default() -> TestRequest {
  function parts (line 137) | fn parts(parts: &mut Option<Inner>) -> &mut Inner {
  type TestBuffer (line 143) | pub struct TestBuffer {
    method new (line 151) | pub fn new<T>(data: T) -> Self
    method clone (line 164) | pub(crate) fn clone(&self) -> Self {
    method empty (line 173) | pub fn empty() -> Self {
    method read_buf_slice (line 178) | pub(crate) fn read_buf_slice(&self) -> Ref<'_, [u8]> {
    method read_buf_slice_mut (line 183) | pub(crate) fn read_buf_slice_mut(&self) -> RefMut<'_, [u8]> {
    method write_buf_slice (line 188) | pub(crate) fn write_buf_slice(&self) -> Ref<'_, [u8]> {
    method write_buf_slice_mut (line 193) | pub(crate) fn write_buf_slice_mut(&self) -> RefMut<'_, [u8]> {
    method take_write_buf (line 198) | pub(crate) fn take_write_buf(&self) -> Bytes {
    method extend_read_buf (line 203) | pub fn extend_read_buf<T: AsRef<[u8]>>(&mut self, data: T) {
    method read (line 209) | fn read(&mut self, dst: &mut [u8]) -> Result<usize, io::Error> {
    method write (line 226) | fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
    method flush (line 231) | fn flush(&mut self) -> io::Result<()> {
  method poll_read (line 237) | fn poll_read(
  method poll_write (line 249) | fn poll_write(
  method poll_flush (line 257) | fn poll_flush(self: Pin<&mut Self>, _: &mut Context<'_>) -> Poll<io::Res...
  method poll_shutdown (line 261) | fn poll_shutdown(self: Pin<&mut Self>, _: &mut Context<'_>) -> Poll<io::...
  type TestSeqBuffer (line 268) | pub struct TestSeqBuffer(Rc<RefCell<TestSeqInner>>);
    method new (line 272) | pub fn new<T>(data: T) -> Self
    method empty (line 285) | pub fn empty() -> Self {
    method read_buf (line 289) | pub fn read_buf(&self) -> Ref<'_, BytesMut> {
    method write_buf (line 293) | pub fn write_buf(&self) -> Ref<'_, BytesMut> {
    method take_write_buf (line 297) | pub fn take_write_buf(&self) -> Bytes {
    method err (line 301) | pub fn err(&self) -> Ref<'_, Option<io::Error>> {
    method extend_read_buf (line 310) | pub fn extend_read_buf<T: AsRef<[u8]>>(&mut self, data: T) {
    method close_read (line 323) | pub fn close_read(&self) {
    method read (line 336) | fn read(&mut self, dst: &mut [u8]) -> Result<usize, io::Error> {
    method write (line 357) | fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
    method flush (line 362) | fn flush(&mut self) -> io::Result<()> {
  type TestSeqInner (line 328) | pub struct TestSeqInner {
  method poll_read (line 368) | fn poll_read(
  method poll_write (line 387) | fn poll_write(
  method poll_flush (line 395) | fn poll_flush(self: Pin<&mut Self>, _: &mut Context<'_>) -> Poll<io::Res...
  method poll_shutdown (line 399) | fn poll_shutdown(self: Pin<&mut Self>, _: &mut Context<'_>) -> Poll<io::...

FILE: actix-http/src/ws/codec.rs
  type Message (line 15) | pub enum Message {
  type Frame (line 40) | pub enum Frame {
  type Item (line 62) | pub enum Item {
  type Codec (line 71) | pub struct Codec {
    method new (line 87) | pub const fn new() -> Codec {
    method max_size (line 98) | pub fn max_size(mut self, size: usize) -> Self {
    method client_mode (line 107) | pub fn client_mode(mut self) -> Self {
    type Error (line 120) | type Error = ProtocolError;
    method encode (line 122) | fn encode(&mut self, item: Message, dst: &mut BytesMut) -> Result<(), ...
  method default (line 114) | fn default() -> Self {
  type Item (line 219) | type Item = Frame;
  type Error (line 220) | type Error = ProtocolError;
  method decode (line 222) | fn decode(&mut self, src: &mut BytesMut) -> Result<Option<Self::Item>, S...

FILE: actix-http/src/ws/dispatcher.rs
  function new (line 33) | pub fn new<F: IntoService<S, Frame>>(io: T, service: F) -> Self {
  function with (line 39) | pub fn with<F: IntoService<S, Frame>>(framed: Framed<T, Codec>, service:...
  type Output (line 53) | type Output = Result<(), inner::DispatcherError<S::Error, Codec, Message>>;
  method poll (line 55) | fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
  type DispatcherError (line 85) | pub enum DispatcherError<E, U, I>
  function from (line 103) | fn from(err: E) -> Self {
  function fmt (line 115) | fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
  function fmt (line 137) | fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
  function from (line 153) | fn from(err: DispatcherError<E, U, I>) -> Self {
  type Message (line 159) | pub enum Message<T> {
  type State (line 190) | enum State<S, U, I>
  function take_error (line 207) | fn take_error(&mut self) -> DispatcherError<S::Error, U, I> {
  function take_framed_error (line 214) | fn take_framed_error(&mut self) -> DispatcherError<S::Error, U, I> {
  function new (line 234) | pub fn new<F>(framed: Framed<T, U>, service: F) -> Self
  function with_rx (line 249) | pub fn with_rx<F>(
  function tx (line 268) | pub fn tx(&self) -> mpsc::Sender<Result<Message<I>, S::Error>> {
  function service (line 273) | pub fn service(&self) -> &S {
  function service_mut (line 278) | pub fn service_mut(&mut self) -> &mut S {
  function framed (line 283) | pub fn framed(&self) -> &Framed<T, U> {
  function framed_mut (line 288) | pub fn framed_mut(&mut self) -> &mut Framed<T, U> {
  function poll_read (line 293) | fn poll_read(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> bool
  function poll_write (line 337) | fn poll_write(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> bool
  type Output (line 399) | type Output = Result<(), DispatcherError<S::Error, U, I>>;
  method poll (line 401) | fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Ou...

FILE: actix-http/src/ws/frame.rs
  type Parser (line 14) | pub struct Parser;
    method parse_metadata (line 17) | fn parse_metadata(
    method parse (line 86) | pub fn parse(
    method parse_close_payload (line 154) | pub fn parse_close_payload(payload: &[u8]) -> Option<CloseReason> {
    method write_message (line 170) | pub fn write_message<B: AsRef<[u8]>>(
    method write_close (line 216) | pub fn write_close(dst: &mut BytesMut, reason: Option<CloseReason>, ma...
  type F (line 238) | struct F {
  function is_none (line 244) | fn is_none(frm: &Result<Option<(bool, OpCode, Option<BytesMut>)>, Protoc...
  function extract (line 248) | fn extract(frm: Result<Option<(bool, OpCode, Option<BytesMut>)>, Protoco...
  function test_parse (line 262) | fn test_parse() {
  function test_parse_length0 (line 276) | fn test_parse_length0() {
  function test_parse_length2 (line 285) | fn test_parse_length2() {
  function test_parse_length4 (line 300) | fn test_parse_length4() {
  function test_parse_frame_mask (line 315) | fn test_parse_frame_mask() {
  function test_parse_frame_no_mask (line 329) | fn test_parse_frame_no_mask() {
  function test_parse_frame_max_size (line 342) | fn test_parse_frame_max_size() {
  function test_parse_frame_max_size_recoverability (line 355) | fn test_parse_frame_max_size_recoverability() {
  function test_ping_frame (line 379) | fn test_ping_frame() {
  function test_pong_frame (line 389) | fn test_pong_frame() {
  function test_close_frame (line 399) | fn test_close_frame() {
  function test_empty_close_frame (line 410) | fn test_empty_close_frame() {
  function test_parse_length_overflow (line 417) | fn test_parse_length_overflow() {

FILE: actix-http/src/ws/mask.rs
  function apply_mask (line 5) | pub fn apply_mask(buf: &mut [u8], mask: [u8; 4]) {
  function apply_mask_fallback (line 11) | fn apply_mask_fallback(buf: &mut [u8], mask: [u8; 4]) {
  function apply_mask_fast32 (line 19) | pub fn apply_mask_fast32(buf: &mut [u8], mask: [u8; 4]) {
  function test_apply_mask (line 51) | fn test_apply_mask() {

FILE: actix-http/src/ws/mod.rs
  type ProtocolError (line 28) | pub enum ProtocolError {
  type HandshakeError (line 72) | pub enum HandshakeError {
  function from (line 99) | fn from(err: HandshakeError) -> Self {
  function from (line 143) | fn from(err: &HandshakeError) -> Self {
  function handshake (line 149) | pub fn handshake(req: &RequestHead) -> Result<ResponseBuilder, Handshake...
  function verify_handshake (line 155) | pub fn verify_handshake(req: &RequestHead) -> Result<(), HandshakeError> {
  function handshake_response (line 205) | pub fn handshake_response(req: &RequestHead) -> ResponseBuilder {
  function test_handshake (line 227) | fn test_handshake() {
  function test_ws_error_http_response (line 337) | fn test_ws_error_http_response() {

FILE: actix-http/src/ws/proto.rs
  type OpCode (line 10) | pub enum OpCode {
    method fmt (line 34) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
    method from (line 69) | fn from(byte: u8) -> OpCode {
  function from (line 50) | fn from(op: OpCode) -> u8 {
  type CloseCode (line 86) | pub enum CloseCode {
    method from (line 175) | fn from(code: u16) -> CloseCode {
  function from (line 152) | fn from(code: CloseCode) -> u16 {
  type CloseReason (line 199) | pub struct CloseReason {
    method from (line 208) | fn from(code: CloseCode) -> Self {
    method from (line 217) | fn from(info: (CloseCode, T)) -> Self {
  function hash_key (line 232) | pub fn hash_key(key: &[u8]) -> [u8; 28] {
  function test_to_opcode (line 276) | fn test_to_opcode() {
  function test_from_opcode (line 287) | fn test_from_opcode() {
  function test_from_opcode_debug (line 298) | fn test_from_opcode_debug() {
  function test_from_opcode_display (line 303) | fn test_from_opcode_display() {
  function test_hash_key (line 314) | fn test_hash_key() {
  function close_code_from_u16 (line 320) | fn close_code_from_u16() {
  function close_code_into_u16 (line 338) | fn close_code_into_u16() {

FILE: actix-http/tests/test_client.rs
  constant STR (line 11) | const STR: &str = "Hello World Hello World Hello World Hello World Hello...
  function h1_v2 (line 34) | async fn h1_v2() {
  function connection_close (line 62) | async fn connection_close() {
  function with_query_parameter (line 76) | async fn with_query_parameter() {
  type ExpectFailed (line 98) | struct ExpectFailed;
  function from (line 101) | fn from(_: ExpectFailed) -> Self {
  function h1_expect (line 107) | async fn h1_expect() {

FILE: actix-http/tests/test_h2_timer.rs
  function h2_ping_pong (line 8) | async fn h2_ping_pong() -> io::Result<()> {
  function h2_handshake_timeout (line 81) | async fn h2_handshake_timeout() -> io::Result<()> {

FILE: actix-http/tests/test_openssl.rs
  function load_body (line 26) | async fn load_body<S>(stream: S) -> Result<BytesMut, PayloadError>
  function tls_config (line 44) | fn tls_config() -> SslAcceptor {
  function h2 (line 71) | async fn h2() -> io::Result<()> {
  function h2_1 (line 86) | async fn h2_1() -> io::Result<()> {
  function h2_body (line 108) | async fn h2_body() -> io::Result<()> {
  function h2_content_length (line 130) | async fn h2_content_length() {
  function h2_headers (line 178) | async fn h2_headers() {
  constant STR (line 220) | const STR: &str = "Hello World Hello World Hello World Hello World Hello...
  function h2_body2 (line 243) | async fn h2_body2() {
  function h2_head_empty (line 261) | async fn h2_head_empty() {
  function h2_head_binary (line 285) | async fn h2_head_binary() {
  function h2_head_binary2 (line 308) | async fn h2_head_binary2() {
  function h2_body_length (line 327) | async fn h2_body_length() {
  function h2_body_chunked_explicit (line 351) | async fn h2_body_chunked_explicit() {
  function h2_response_http_error_handling (line 379) | async fn h2_response_http_error_handling() {
  type BadRequest (line 408) | struct BadRequest;
  function from (line 411) | fn from(err: BadRequest) -> Self {
  function h2_service_error (line 419) | async fn h2_service_error() {
  function h2_on_connect (line 437) | async fn h2_on_connect() {

FILE: actix-http/tests/test_rustls.rs
  function load_body (line 34) | async fn load_body<S>(stream: S) -> Result<BytesMut, PayloadError>
  function tls_config_with_alpn (line 56) | fn tls_config_with_alpn(protocols: &[&[u8]]) -> RustlsServerConfig {
  function tls_config (line 72) | fn tls_config() -> RustlsServerConfig {
  function tls_config_h1 (line 76) | fn tls_config_h1() -> RustlsServerConfig {
  function tls_config_h2 (line 80) | fn tls_config_h2() -> RustlsServerConfig {
  function h1_client (line 84) | fn h1_client() -> Client {
  function get_negotiated_alpn_protocol (line 99) | pub fn get_negotiated_alpn_protocol(
  function h1 (line 125) | async fn h1() -> io::Result<()> {
  function h2 (line 140) | async fn h2() -> io::Result<()> {
  function h1_1 (line 155) | async fn h1_1() -> io::Result<()> {
  function h2_1 (line 174) | async fn h2_1() -> io::Result<()> {
  function h2_tcp_nodelay_override_true (line 196) | async fn h2_tcp_nodelay_override_true() -> io::Result<()> {
  function h2_tcp_nodelay_override_false (line 218) | async fn h2_tcp_nodelay_override_false() -> io::Result<()> {
  function h2_body1 (line 240) | async fn h2_body1() -> io::Result<()> {
  function h2_content_length (line 262) | async fn h2_content_length() {
  function h2_headers (line 326) | async fn h2_headers() {
  constant STR (line 368) | const STR: &str = "Hello World Hello World Hello World Hello World Hello...
  function h2_body2 (line 391) | async fn h2_body2() {
  function h2_head_empty (line 409) | async fn h2_head_empty() {
  function h2_head_binary (line 436) | async fn h2_head_binary() {
  function h2_head_binary2 (line 462) | async fn h2_head_binary2() {
  function h2_body_length (line 485) | async fn h2_body_length() {
  function h2_body_chunked_explicit (line 508) | async fn h2_body_chunked_explicit() {
  function h2_response_http_error_handling (line 536) | async fn h2_response_http_error_handling() {
  type BadRequest (line 567) | struct BadRequest;
  function from (line 570) | fn from(_: BadRequest) -> Self {
  function h2_service_error (line 576) | async fn h2_service_error() {
  function h1_service_error (line 594) | async fn h1_service_error() {
  constant H2_ALPN_PROTOCOL (line 611) | const H2_ALPN_PROTOCOL: &[u8] = b"h2";
  constant HTTP1_1_ALPN_PROTOCOL (line 612) | const HTTP1_1_ALPN_PROTOCOL: &[u8] = b"http/1.1";
  constant CUSTOM_ALPN_PROTOCOL (line 613) | const CUSTOM_ALPN_PROTOCOL: &[u8] = b"custom";
  function alpn_h1 (line 616) | async fn alpn_h1() -> io::Result<()> {
  function alpn_h2 (line 639) | async fn alpn_h2() -> io::Result<()> {
  function alpn_h2_1 (line 666) | async fn alpn_h2_1() -> io::Result<()> {

FILE: actix-http/tests/test_server.rs
  function h1_basic (line 26) | async fn h1_basic() {
  function h1_2 (line 47) | async fn h1_2() {
  type ExpectFailed (line 70) | struct ExpectFailed;
  function from (line 73) | fn from(_: ExpectFailed) -> Self {
  function expect_continue (line 79) | async fn expect_continue() {
  function expect_continue_h1 (line 110) | async fn expect_continue_h1() {
  function chunked_payload (line 143) | async fn chunked_payload() {
  function slow_request_408 (line 203) | async fn slow_request_408() {
  function http1_malformed_request (line 239) | async fn http1_malformed_request() {
  function http1_keepalive (line 257) | async fn http1_keepalive() {
  function http1_keepalive_timeout (line 280) | async fn http1_keepalive_timeout() {
  function http1_keepalive_close (line 306) | async fn http1_keepalive_close() {
  function http10_keepalive_default_close (line 328) | async fn http10_keepalive_default_close() {
  function http10_keepalive (line 350) | async fn http10_keepalive() {
  function http1_keepalive_disabled (line 378) | async fn http1_keepalive_disabled() {
  function content_length (line 401) | async fn content_length() {
  function content_length_truncated (line 450) | async fn content_length_truncated() {
  function h1_headers (line 504) | async fn h1_headers() {
  constant STR (line 547) | const STR: &str = "Hello World Hello World Hello World Hello World Hello...
  function h1_body (line 570) | async fn h1_body() {
  function h1_head_empty (line 589) | async fn h1_head_empty() {
  function h1_head_binary (line 616) | async fn h1_head_binary() {
  function h1_head_binary2 (line 643) | async fn h1_head_binary2() {
  function h1_body_length (line 666) | async fn h1_body_length() {
  function h1_body_chunked_explicit (line 690) | async fn h1_body_chunked_explicit() {
  function h1_body_chunked_implicit (line 727) | async fn h1_body_chunked_implicit() {
  function h1_response_http_error_handling (line 758) | async fn h1_response_http_error_handling() {
  type BadRequest (line 788) | struct BadRequest;
  function from (line 791) | fn from(_: BadRequest) -> Self {
  function h1_service_error (line 797) | async fn h1_service_error() {
  function h1_on_connect (line 816) | async fn h1_on_connect() {
  function not_modified_spec_h1 (line 839) | async fn not_modified_spec_h1() {
  function h2c_auto (line 920) | async fn h2c_auto() {
  function h2_flow_control_window_sizes (line 961) | async fn h2_flow_control_window_sizes() {

FILE: actix-http/tests/test_ws.rs
  type WsService (line 22) | struct WsService(Cell<bool>);
    method new (line 25) | fn new() -> Self {
    method set_polled (line 29) | fn set_polled(&self) {
    method was_polled (line 33) | fn was_polled(&self) -> bool {
    type Response (line 70) | type Response = ();
    type Error (line 71) | type Error = WsServiceError;
    type Future (line 72) | type Future = LocalBoxFuture<'static, Result<Self::Response, Self::Err...
    method poll_ready (line 74) | fn poll_ready(&self, _: &mut Context<'_>) -> Poll<Result<(), Self::Err...
    method call (line 79) | fn call(&self, (req, mut framed): (Request, Framed<T, h1::Codec>)) -> ...
  type WsServiceError (line 39) | enum WsServiceError {
  function from (line 54) | fn from(err: WsServiceError) -> Self {
  function service (line 98) | async fn service(msg: Frame) -> Result<Message, Error> {
  function simple (line 112) | async fn simple() {

FILE: actix-multipart-derive/src/lib.rs
  type DuplicateField (line 20) | enum DuplicateField {
  type MultipartFormAttrs (line 29) | struct MultipartFormAttrs {
  type FieldAttrs (line 37) | struct FieldAttrs {
  type ParsedField (line 42) | struct ParsedField<'t> {
  function impl_multipart_form (line 150) | pub fn impl_multipart_form(input: proc_macro::TokenStream) -> proc_macro...
  function compile_err (line 308) | fn compile_err(err: syn::Error) -> TokenStream {

FILE: actix-multipart-derive/tests/trybuild.rs
  function compile_macros (line 3) | fn compile_macros() {

FILE: actix-multipart-derive/tests/trybuild/all-required.rs
  type ImageUpload (line 6) | struct ImageUpload {
  function handler (line 12) | async fn handler(_form: MultipartForm<ImageUpload>) -> impl Responder {
  function main (line 17) | async fn main() {

FILE: actix-multipart-derive/tests/trybuild/deny-duplicates.rs
  type Form (line 7) | struct Form {}
  function handler (line 9) | async fn handler(_form: MultipartForm<Form>) -> impl Responder {
  function main (line 14) | async fn main() {

FILE: actix-multipart-derive/tests/trybuild/deny-parse-fail.rs
  type Form (line 5) | struct Form {}
  function main (line 7) | fn main() {}

FILE: actix-multipart-derive/tests/trybuild/deny-unknown.rs
  type Form (line 7) | struct Form {}
  function handler (line 9) | async fn handler(_form: MultipartForm<Form>) -> impl Responder {
  function main (line 14) | async fn main() {

FILE: actix-multipart-derive/tests/trybuild/optional-and-list.rs
  type Form (line 6) | struct Form {
  function handler (line 11) | async fn handler(_form: MultipartForm<Form>) -> impl Responder {
  function main (line 16) | async fn main() {

FILE: actix-multipart-derive/tests/trybuild/rename.rs
  type Form (line 6) | struct Form {
  function handler (line 11) | async fn handler(_form: MultipartForm<Form>) -> impl Responder {
  function main (line 16) | async fn main() {

FILE: actix-multipart-derive/tests/trybuild/size-limit-parse-fail.rs
  type Form (line 4) | struct Form {
  type Form2 (line 10) | struct Form2 {
  type Form3 (line 16) | struct Form3 {
  function main (line 21) | fn main() {}

FILE: actix-multipart-derive/tests/trybuild/size-limits.rs
  type Form (line 6) | struct Form {
  function handler (line 14) | async fn handler(_form: MultipartForm<Form>) -> impl Responder {
  function main (line 19) | async fn main() {

FILE: actix-multipart/examples/form.rs
  type Metadata (line 8) | struct Metadata {
  type UploadForm (line 13) | struct UploadForm {
  function post_video (line 21) | async fn post_video(MultipartForm(form): MultipartForm<UploadForm>) -> i...
  function main (line 31) | async fn main() -> std::io::Result<()> {

FILE: actix-multipart/src/error.rs
  type Error (line 13) | pub enum Error {
  method status_code (line 99) | fn status_code(&self) -> StatusCode {
  function test_multipart_error (line 113) | fn test_multipart_error() {

FILE: actix-multipart/src/extractor.rs
  type Error (line 32) | type Error = Error;
  type Future (line 33) | type Future = Ready<Result<Multipart, Error>>;
  method from_request (line 36) | fn from_request(req: &HttpRequest, payload: &mut Payload) -> Self::Future {

FILE: actix-multipart/src/field.rs
  type LimitExceeded (line 30) | pub struct LimitExceeded;
  type Field (line 33) | pub struct Field {
    method new (line 56) | pub(crate) fn new(
    method headers (line 75) | pub fn headers(&self) -> &HeaderMap {
    method content_type (line 84) | pub fn content_type(&self) -> Option<&Mime> {
    method content_disposition (line 104) | pub fn content_disposition(&self) -> Option<&ContentDisposition> {
    method name (line 112) | pub fn name(&self) -> Option<&str> {
    method bytes (line 126) | pub async fn bytes(&mut self, limit: usize) -> Result<Result<Bytes, Er...
    method fmt (line 194) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  type Item (line 168) | type Item = Result<Bytes, Error>;
  method poll_next (line 170) | fn poll_next(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<...
  type InnerField (line 209) | pub(crate) struct InnerField {
    method new_in_rc (line 224) | pub(crate) fn new_in_rc(
    method new (line 232) | pub(crate) fn new(
    method read_len (line 257) | pub(crate) fn read_len(
    method read_stream (line 288) | pub(crate) fn read_stream(
    method poll (line 362) | pub(crate) fn poll(&mut self, safety: &Safety) -> Poll<Option<Result<B...
  function create_double_request_with_header (line 420) | fn create_double_request_with_header() -> (Bytes, HeaderMap) {
  function bytes_unlimited (line 446) | async fn bytes_unlimited() {
  function bytes_limited (line 475) | async fn bytes_limited() {

FILE: actix-multipart/src/form/bytes.rs
  type Bytes (line 15) | pub struct Bytes {
    type Future (line 27) | type Future = LocalBoxFuture<'t, Result<Self, MultipartError>>;
    method read_field (line 29) | fn read_field(_: &'t HttpRequest, mut field: Field, limits: &'t mut Li...

FILE: actix-multipart/src/form/json.rs
  type Json (line 18) | pub struct Json<T: DeserializeOwned>(pub T);
  function into_inner (line 21) | pub fn into_inner(self) -> T {
  type Future (line 30) | type Future = LocalBoxFuture<'t, Result<Self, MultipartError>>;
  function read_field (line 32) | fn read_field(req: &'t HttpRequest, field: Field, limits: &'t mut Limits...
  type JsonFieldError (line 67) | pub enum JsonFieldError {
  method status_code (line 78) | fn status_code(&self) -> StatusCode {
  type JsonConfig (line 85) | pub struct JsonConfig {
    method error_handler (line 96) | pub fn error_handler<F>(mut self, f: F) -> Self
    method from_req (line 106) | fn from_req(req: &HttpRequest) -> &Self {
    method map_error (line 112) | fn map_error(&self, req: &HttpRequest, err: JsonFieldError) -> Error {
    method validate_content_type (line 121) | pub fn validate_content_type(mut self, validate_content_type: bool) ->...
  constant DEFAULT_CONFIG (line 90) | const DEFAULT_CONFIG: JsonConfig = JsonConfig {
  method default (line 128) | fn default() -> Self {
  type JsonForm (line 145) | struct JsonForm {
  function test_json_route (line 149) | async fn test_json_route(form: MultipartForm<JsonForm>) -> impl Responder {
  constant TEST_JSON (line 157) | const TEST_JSON: &str = r#"{"key1": "value1", "key2": "value2"}"#;
  function test_json_without_content_type (line 160) | async fn test_json_without_content_type() {
  function test_content_type_validation (line 180) | async fn test_content_type_validation() {

FILE: actix-multipart/src/form/mod.rs
  type FieldErrorHandler (line 26) | type FieldErrorHandler<T> = Option<Arc<dyn Fn(T, &HttpRequest) -> Error ...
  type FieldReader (line 31) | pub trait FieldReader<'t>: Sized + Any {
    method read_field (line 44) | fn read_field(req: &'t HttpRequest, field: Field, limits: &'t mut Limi...
  type State (line 50) | pub struct State(pub HashMap<String, Box<dyn Any>>);
  type FieldGroupReader (line 54) | pub trait FieldGroupReader<'t>: Sized + Any {
    method handle_field (line 58) | fn handle_field(
    method from_state (line 67) | fn from_state(name: &str, state: &'t mut State) -> Result<Self, Multip...
  type Future (line 74) | type Future = LocalBoxFuture<'t, Result<(), MultipartError>>;
  function handle_field (line 76) | fn handle_field(
  function from_state (line 105) | fn from_state(name: &str, state: &'t mut State) -> Result<Self, Multipar...
  type Future (line 114) | type Future = LocalBoxFuture<'t, Result<(), MultipartError>>;
  function handle_field (line 116) | fn handle_field(
  function from_state (line 139) | fn from_state(name: &str, state: &'t mut State) -> Result<Self, Multipar...
  type Future (line 151) | type Future = LocalBoxFuture<'t, Result<(), MultipartError>>;
  method handle_field (line 153) | fn handle_field(
  method from_state (line 182) | fn from_state(name: &str, state: &'t mut State) -> Result<Self, Multipar...
  type Future (line 194) | type Future = LocalBoxFuture<'t, Result<(), MultipartError>>;
  function handle_field (line 196) | fn handle_field(
  function from_state (line 219) | fn from_state(name: &str, state: &'t mut State) -> Result<Self, Multipar...
  type MultipartCollect (line 232) | pub trait MultipartCollect: Sized {
    method limit (line 235) | fn limit(field_name: &str) -> Option<usize>;
    method handle_field (line 239) | fn handle_field<'t>(
    method from_state (line 248) | fn from_state(state: State) -> Result<Self, MultipartError>;
  type DuplicateField (line 252) | pub enum DuplicateField {
  type Limits (line 264) | pub struct Limits {
    method new (line 271) | pub fn new(total_limit: usize, memory_limit: usize) -> Self {
    method try_consume_limits (line 286) | pub fn try_consume_limits(
  type MultipartForm (line 326) | pub struct MultipartForm<T: MultipartCollect>(pub T);
  function into_inner (line 330) | pub fn into_inner(self) -> T {
  type Error (line 339) | type Error = Error;
  type Future (line 340) | type Future = LocalBoxFuture<'static, Result<Self, Self::Error>>;
  method from_request (line 343) | fn from_request(req: &HttpRequest, payload: &mut dev::Payload) -> Self::...
  type MultipartFormErrorHandler (line 403) | type MultipartFormErrorHandler =
  type MultipartFormConfig (line 410) | pub struct MultipartFormConfig {
    method total_limit (line 418) | pub fn total_limit(mut self, total_limit: usize) -> Self {
    method memory_limit (line 424) | pub fn memory_limit(mut self, memory_limit: usize) -> Self {
    method error_handler (line 430) | pub fn error_handler<F>(mut self, f: F) -> Self
    method from_req (line 440) | fn from_req(req: &HttpRequest) -> &Self {
  constant DEFAULT_CONFIG (line 447) | const DEFAULT_CONFIG: MultipartFormConfig = MultipartFormConfig {
  method default (line 454) | fn default() -> Self {
  function send_form (line 479) | pub async fn send_form(
  type TestOptions (line 494) | struct TestOptions {
  function test_options_route (line 499) | async fn test_options_route(form: MultipartForm<TestOptions>) -> impl Re...
  function test_options (line 506) | async fn test_options() {
  type TestVec (line 518) | struct TestVec {
  function test_vec_route (line 523) | async fn test_vec_route(form: MultipartForm<TestVec>) -> impl Responder {
  function test_vec (line 536) | async fn test_vec() {
  type TestOptionVec (line 550) | struct TestOptionVec {
  function test_option_vec_route (line 555) | async fn test_option_vec_route(form: MultipartForm<TestOptionVec>) -> im...
  function test_option_vec (line 569) | async fn test_option_vec() {
  type TestFieldRenaming (line 584) | struct TestFieldRenaming {
  function test_field_renaming_route (line 592) | async fn test_field_renaming_route(form: MultipartForm<TestFieldRenaming...
  function test_field_renaming (line 600) | async fn test_field_renaming() {
  type TestDenyUnknown (line 616) | struct TestDenyUnknown {}
  type TestAllowUnknown (line 619) | struct TestAllowUnknown {}
  function test_deny_unknown_route (line 621) | async fn test_deny_unknown_route(_: MultipartForm<TestDenyUnknown>) -> i...
  function test_allow_unknown_route (line 625) | async fn test_allow_unknown_route(_: MultipartForm<TestAllowUnknown>) ->...
  function test_deny_unknown (line 630) | async fn test_deny_unknown() {
  type TestDuplicateDeny (line 651) | struct TestDuplicateDeny {
  type TestDuplicateReplace (line 657) | struct TestDuplicateReplace {
  type TestDuplicateIgnore (line 663) | struct TestDuplicateIgnore {
  function test_duplicate_deny_route (line 667) | async fn test_duplicate_deny_route(_: MultipartForm<TestDuplicateDeny>) ...
  function test_duplicate_replace_route (line 671) | async fn test_duplicate_replace_route(
  function test_duplicate_ignore_route (line 678) | async fn test_duplicate_ignore_route(
  function test_duplicate_field (line 686) | async fn test_duplicate_field() {
  type TestMemoryUploadLimits (line 715) | struct TestMemoryUploadLimits {
  type TestFileUploadLimits (line 720) | struct TestFileUploadLimits {
  function test_upload_limits_memory (line 724) | async fn test_upload_limits_memory(
  function test_upload_limits_file (line 731) | async fn test_upload_limits_file(form: MultipartForm<TestFileUploadLimit...
  function test_memory_limits (line 737) | async fn test_memory_limits() {
  function test_total_limit (line 763) | async fn test_total_limit() {
  type TestFieldLevelLimits (line 795) | struct TestFieldLevelLimits {
  function test_field_level_limits_route (line 800) | async fn test_field_level_limits_route(
  function test_field_level_limits (line 808) | async fn test_field_level_limits() {
  function non_multipart_form_data (line 847) | async fn non_multipart_form_data() {
  function field_try_next_panic (line 883) | async fn field_try_next_panic() {

FILE: actix-multipart/src/form/tempfile.rs
  type TempFile (line 25) | pub struct TempFile {
    type Future (line 40) | type Future = LocalBoxFuture<'t, Result<Self, MultipartError>>;
    method read_field (line 42) | fn read_field(req: &'t HttpRequest, mut field: Field, limits: &'t mut ...
  type TempFileError (line 83) | pub enum TempFileError {
  method status_code (line 90) | fn status_code(&self) -> StatusCode {
  type TempFileConfig (line 97) | pub struct TempFileConfig {
    method create_tempfile (line 103) | fn create_tempfile(&self) -> io::Result<NamedTempFile> {
    method error_handler (line 114) | pub fn error_handler<F>(mut self, f: F) -> Self
    method from_req (line 124) | fn from_req(req: &HttpRequest) -> &Self {
    method map_error (line 130) | fn map_error(&self, req: &HttpRequest, field_name: &str, err: TempFile...
    method directory (line 146) | pub fn directory(mut self, dir: impl AsRef<Path>) -> Self {
  constant DEFAULT_CONFIG (line 152) | const DEFAULT_CONFIG: TempFileConfig = TempFileConfig {
  method default (line 158) | fn default() -> Self {
  type FileForm (line 173) | struct FileForm {
  function test_file_route (line 177) | async fn test_file_route(form: MultipartForm<FileForm>) -> impl Responder {
  function test_file_upload (line 188) | async fn test_file_upload() {

FILE: actix-multipart/src/form/text.rs
  type Text (line 21) | pub struct Text<T: DeserializeOwned>(pub T);
  function into_inner (line 25) | pub fn into_inner(self) -> T {
  type Future (line 34) | type Future = LocalBoxFuture<'t, Result<Self, MultipartError>>;
  function read_field (line 36) | fn read_field(req: &'t HttpRequest, field: Field, limits: &'t mut Limits...
  type TextError (line 78) | pub enum TextError {
  method status_code (line 93) | fn status_code(&self) -> StatusCode {
  type TextConfig (line 100) | pub struct TextConfig {
    method error_handler (line 107) | pub fn error_handler<F>(mut self, f: F) -> Self
    method from_req (line 117) | fn from_req(req: &HttpRequest) -> &Self {
    method map_error (line 123) | fn map_error(&self, req: &HttpRequest, err: TextError) -> Error {
    method validate_content_type (line 135) | pub fn validate_content_type(mut self, validate_content_type: bool) ->...
  constant DEFAULT_CONFIG (line 141) | const DEFAULT_CONFIG: TextConfig = TextConfig {
  method default (line 147) | fn default() -> Self {
  type TextForm (line 166) | struct TextForm {
  function test_text_route (line 170) | async fn test_text_route(form: MultipartForm<TextForm>) -> impl Responder {
  function test_content_type_validation (line 176) | async fn test_content_type_validation() {

FILE: actix-multipart/src/multipart.rs
  constant MAX_HEADERS (line 28) | const MAX_HEADERS: usize = 32;
  type Multipart (line 35) | pub struct Multipart {
    method new (line 49) | pub fn new<S>(headers: &HeaderMap, stream: S) -> Self
    method from_req (line 60) | pub(crate) fn from_req(req: &HttpRequest, payload: &mut dev::Payload) ...
    method find_ct_and_boundary (line 68) | pub(crate) fn find_ct_and_boundary(headers: &HeaderMap) -> Result<(Mim...
    method from_ct_and_boundary (line 91) | pub(crate) fn from_ct_and_boundary<S>(ct: Mime, boundary: String, stre...
    method from_error (line 108) | pub(crate) fn from_error(err: Error) -> Multipart {
    method content_type_or_bail (line 116) | pub(crate) fn content_type_or_bail(&mut self) -> Result<mime::Mime, Er...
  type Flow (line 40) | enum Flow {
  type Item (line 127) | type Item = Result<Field, Error>;
  method poll_next (line 129) | fn poll_next(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<...
  type State (line 155) | enum State {
  type Item (line 169) | enum Item {
  type Inner (line 174) | struct Inner {
    method read_field_headers (line 191) | fn read_field_headers(payload: &mut PayloadBuffer) -> Result<Option<He...
    method read_boundary (line 241) | fn read_boundary(payload: &mut PayloadBuffer, boundary: &str) -> Resul...
    method skip_until_boundary (line 286) | fn skip_until_boundary(
    method poll (line 328) | fn poll(&mut self, safety: &Safety, cx: &Context<'_>) -> Poll<Option<R...
  method drop (line 466) | fn drop(&mut self) {
  constant BOUNDARY (line 492) | const BOUNDARY: &str = "abbc761f78ff4d7cb7573b5a23f96ef0";
  function test_boundary (line 495) | async fn test_boundary() {
  function create_stream (line 537) | fn create_stream() -> (
  function create_simple_request_with_header (line 549) | fn create_simple_request_with_header() -> (Bytes, HeaderMap) {
  function create_double_request_with_header (line 569) | fn create_double_request_with_header() -> (Bytes, HeaderMap) {
  function test_multipart_no_end_crlf (line 593) | async fn test_multipart_no_end_crlf() {
  function test_multipart (line 620) | async fn test_multipart() {
  function get_whole_field (line 672) | async fn get_whole_field(field: &mut Field) -> BytesMut {
  function test_stream (line 684) | async fn test_stream() {
  function test_multipart_from_error (line 722) | async fn test_multipart_from_error() {
  function test_multipart_from_boundary (line 729) | async fn test_multipart_from_boundary() {
  function test_multipart_payload_consumption (line 737) | async fn test_multipart_payload_consumption() {
  function no_content_disposition_form_data (line 755) | async fn no_content_disposition_form_data() {
  function no_content_disposition_non_form_data (line 787) | async fn no_content_disposition_non_form_data() {
  function no_name_in_form_data_content_disposition (line 814) | async fn no_name_in_form_data_content_disposition() {
  function test_drop_multipart_dont_hang (line 845) | async fn test_drop_multipart_dont_hang() {
  function test_drop_field_awaken_multipart (line 864) | async fn test_drop_field_awaken_multipart() {

FILE: actix-multipart/src/payload.rs
  type PayloadRef (line 17) | pub(crate) struct PayloadRef {
    method new (line 22) | pub(crate) fn new(payload: PayloadBuffer) -> PayloadRef {
    method get_mut (line 28) | pub(crate) fn get_mut(&self, safety: &Safety) -> Option<RefMut<'_, Pay...
  method clone (line 38) | fn clone(&self) -> PayloadRef {
  type PayloadBuffer (line 46) | pub(crate) struct PayloadBuffer {
    method new (line 55) | pub(crate) fn new<S>(stream: S) -> Self
    method poll_stream (line 66) | pub(crate) fn poll_stream(&mut self, cx: &mut Context<'_>) -> Result<(...
    method read_exact (line 86) | pub(crate) fn read_exact(&mut self, size: usize) -> Option<Bytes> {
    method read_max (line 94) | pub(crate) fn read_max(&mut self, size: u64) -> Result<Option<Bytes>, ...
    method read_until (line 112) | pub(crate) fn read_until(&mut self, needle: &[u8]) -> Result<Option<By...
    method readline (line 133) | pub(crate) fn readline(&mut self) -> Result<Option<Bytes>, Error> {
    method readline_or_eof (line 139) | pub(crate) fn readline_or_eof(&mut self) -> Result<Option<Bytes>, Erro...
    method unprocessed (line 147) | pub(crate) fn unprocessed(&mut self, data: Bytes) {
  function basic (line 163) | async fn basic() {
  function eof (line 173) | async fn eof() {
  function err (line 189) | async fn err() {
  function read_max (line 198) | async fn read_max() {
  function read_exactly (line 215) | async fn read_exactly() {
  function read_until (line 233) | async fn read_until() {

FILE: actix-multipart/src/safety.rs
  type Safety (line 12) | pub(crate) struct Safety {
    method new (line 20) | pub(crate) fn new() -> Safety {
    method current (line 30) | pub(crate) fn current(&self) -> bool {
    method is_clean (line 34) | pub(crate) fn is_clean(&self) -> bool {
    method clone (line 38) | pub(crate) fn clone(&self, cx: &task::Context<'_>) -> Safety {
  method drop (line 52) | fn drop(&mut self) {

FILE: actix-multipart/src/test.rs
  constant CRLF (line 10) | const CRLF: &[u8] = b"\r\n";
  constant CRLF_CRLF (line 11) | const CRLF_CRLF: &[u8] = b"\r\n\r\n";
  constant HYPHENS (line 12) | const HYPHENS: &[u8] = b"--";
  constant BOUNDARY_PREFIX (line 13) | const BOUNDARY_PREFIX: &str = "------------------------";
  function create_form_data_payload_and_headers (line 58) | pub fn create_form_data_payload_and_headers(
  function create_form_data_payload_and_headers_with_boundary (line 78) | pub fn create_form_data_payload_and_headers_with_boundary(
  function find_boundary (line 135) | fn find_boundary(headers: &HeaderMap) -> String {
  function wire_format (line 150) | fn wire_format() {
  function ecosystem_compat (line 198) | async fn ecosystem_compat() {

FILE: actix-router/benches/quoter.rs
  function compare_quoters (line 5) | fn compare_quoters(c: &mut Criterion) {

FILE: actix-router/benches/router.rs
  function call (line 154) | fn call() -> impl Iterator<Item = &'static str> {
  function compare_routers (line 166) | fn compare_routers(c: &mut Criterion) {

FILE: actix-router/src/de.rs
  type PathDeserializer (line 75) | pub struct PathDeserializer<'de, T: ResourcePath> {
  function new (line 80) | pub fn new(path: &'de Path<T>) -> Self {
  type Error (line 86) | type Error = de::value::Error;
  function deserialize_map (line 88) | fn deserialize_map<V>(self, visitor: V) -> Result<V::Value, Self::Error>
  function deserialize_struct (line 98) | fn deserialize_struct<V>(
  function deserialize_unit (line 110) | fn deserialize_unit<V>(self, visitor: V) -> Result<V::Value, Self::Error>
  function deserialize_unit_struct (line 117) | fn deserialize_unit_struct<V>(
  function deserialize_newtype_struct (line 128) | fn deserialize_newtype_struct<V>(
  function deserialize_tuple (line 139) | fn deserialize_tuple<V>(self, len: usize, visitor: V) -> Result<V::Value...
  function deserialize_tuple_struct (line 159) | fn deserialize_tuple_struct<V>(
  function deserialize_enum (line 184) | fn deserialize_enum<V>(
  function deserialize_seq (line 202) | fn deserialize_seq<V>(self, visitor: V) -> Result<V::Value, Self::Error>
  type ParamsDeserializer (line 234) | struct ParamsDeserializer<'de, T: ResourcePath> {
  type Error (line 240) | type Error = de::value::Error;
  function next_key_seed (line 242) | fn next_key_seed<K>(&mut self, seed: K) -> Result<Option<K::Value>, Self...
  function next_value_seed (line 253) | fn next_value_seed<V>(&mut self, seed: V) -> Result<V::Value, Self::Error>
  type Key (line 265) | struct Key<'de> {
  type Error (line 270) | type Error = de::value::Error;
  function deserialize_identifier (line 272) | fn deserialize_identifier<V>(self, visitor: V) -> Result<V::Value, Self:...
  function deserialize_any (line 279) | fn deserialize_any<V>(self, _visitor: V) -> Result<V::Value, Self::Error>
  type Value (line 293) | struct Value<'de> {
  type Error (line 298) | type Error = de::value::Error;
  function deserialize_ignored_any (line 313) | fn deserialize_ignored_any<V>(self, visitor: V) -> Result<V::Value, Self...
  function deserialize_unit (line 320) | fn deserialize_unit<V>(self, visitor: V) -> Result<V::Value, Self::Error>
  function deserialize_unit_struct (line 327) | fn deserialize_unit_struct<V>(
  function deserialize_str (line 338) | fn deserialize_str<V>(self, visitor: V) -> Result<V::Value, Self::Error>
  function deserialize_bytes (line 348) | fn deserialize_bytes<V>(self, visitor: V) -> Result<V::Value, Self::Error>
  function deserialize_byte_buf (line 358) | fn deserialize_byte_buf<V>(self, visitor: V) -> Result<V::Value, Self::E...
  function deserialize_string (line 365) | fn deserialize_string<V>(self, visitor: V) -> Result<V::Value, Self::Error>
  function deserialize_option (line 372) | fn deserialize_option<V>(self, visitor: V) -> Result<V::Value, Self::Error>
  function deserialize_enum (line 379) | fn deserialize_enum<V>(
  function deserialize_newtype_struct (line 391) | fn deserialize_newtype_struct<V>(
  function deserialize_tuple (line 402) | fn deserialize_tuple<V>(self, _: usize, _: V) -> Result<V::Value, Self::...
  function deserialize_struct (line 409) | fn deserialize_struct<V>(
  function deserialize_tuple_struct (line 421) | fn deserialize_tuple_struct<V>(
  function deserialize_any (line 433) | fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
  type ParamsSeq (line 471) | struct ParamsSeq<'de, T: ResourcePath> {
  type Error (line 476) | type Error = de::value::Error;
  function next_element_seed (line 478) | fn next_element_seed<U>(&mut self, seed: U) -> Result<Option<U::Value>, ...
  type ValueEnum (line 489) | struct ValueEnum<'de> {
  type Error (line 494) | type Error = de::value::Error;
  type Variant (line 495) | type Variant = UnitVariant;
  function variant_seed (line 497) | fn variant_seed<V>(self, seed: V) -> Result<(V::Value, Self::Variant), S...
  type UnitVariant (line 505) | struct UnitVariant;
    type Error (line 508) | type Error = de::value::Error;
    method unit_variant (line 510) | fn unit_variant(self) -> Result<(), Self::Error> {
    method newtype_variant_seed (line 514) | fn newtype_variant_seed<T>(self, _seed: T) -> Result<T::Value, Self::E...
    method tuple_variant (line 521) | fn tuple_variant<V>(self, _len: usize, _visitor: V) -> Result<V::Value...
    method struct_variant (line 528) | fn struct_variant<V>(self, _: &'static [&'static str], _: V) -> Result...
  type MyStruct (line 544) | struct MyStruct {
  type Test1 (line 550) | struct Test1(String, u32);
  type Test2 (line 553) | struct Test2 {
  type TestEnum (line 560) | enum TestEnum {
  type Test3 (line 566) | struct Test3 {
  function test_request_extract (line 571) | fn test_request_extract() {
  function test_extract_path_single (line 613) | fn test_extract_path_single() {
  function test_extract_enum (line 625) | fn test_extract_enum() {
  function test_extract_enum_value (line 647) | fn test_extract_enum_value() {
  function test_extract_errors (line 666) | fn test_extract_errors() {
  function deserialize_path_decode_string (line 696) | fn deserialize_path_decode_string() {
  function deserialize_path_decode_seq (line 713) | fn deserialize_path_decode_seq() {
  function deserialize_path_decode_map (line 725) | fn deserialize_path_decode_map() {
  function deserialize_path_decode_any (line 743) | fn deserialize_path_decode_any() {
  function deserialize_borrowed (line 856) | fn deserialize_borrowed() {

FILE: actix-router/src/path.rs
  type PathItem (line 11) | pub(crate) enum PathItem {
  method default (line 17) | fn default() -> Self {
  type Path (line 26) | pub struct Path<T> {
  function new (line 38) | pub fn new(path: T) -> Path<T> {
  function get_ref (line 48) | pub fn get_ref(&self) -> &T {
  function get_mut (line 54) | pub fn get_mut(&mut self) -> &mut T {
  function as_str (line 60) | pub fn as_str(&self) -> &str {
  function unprocessed (line 68) | pub fn unprocessed(&self) -> &str {
  function path (line 78) | pub fn path(&self) -> &str {
  function set (line 90) | pub fn set(&mut self, path: T) {
  function update_with_reindex (line 101) | pub fn update_with_reindex<F>(&mut self, path: T, mut reindex: F)
  function reset (line 137) | pub fn reset(&mut self) {
  function skip (line 144) | pub fn skip(&mut self, n: u16) {
  function add (line 148) | pub(crate) fn add(&mut self, name: impl Into<Cow<'static, str>>, value: ...
  function add_static (line 159) | pub fn add_static(
  function is_empty (line 170) | pub fn is_empty(&self) -> bool {
  function segment_count (line 176) | pub fn segment_count(&self) -> usize {
  function get (line 181) | pub fn get(&self, name: &str) -> Option<&str> {
  function query (line 199) | pub fn query(&self, key: &str) -> &str {
  function iter (line 204) | pub fn iter(&self) -> PathIter<'_, T> {
  function load (line 216) | pub fn load<'de, U: Deserialize<'de>>(&'de self) -> Result<U, de::value:...
  function clamp_to_char_boundary (line 221) | fn clamp_to_char_boundary(path: &str, idx: u16) -> u16 {
  type PathIter (line 232) | pub struct PathIter<'a, T> {
  type Item (line 238) | type Item = (&'a str, &'a str);
  method next (line 241) | fn next(&mut self) -> Option<(&'a str, &'a str)> {
  type Output (line 258) | type Output = str;
  function index (line 260) | fn index(&self, name: &'a str) -> &str {
  type Output (line 267) | type Output = str;
  function index (line 269) | fn index(&self, idx: usize) -> &str {
  type Path (line 278) | type Path = T;
  method resource_path (line 280) | fn resource_path(&mut self) -> &mut Path<Self::Path> {
  type Path (line 290) | type Path = P;
  method resource_path (line 292) | fn resource_path(&mut self) -> &mut Path<Self::Path> {
  function deref_impls (line 305) | fn deref_impls() {

FILE: actix-router/src/pattern.rs
  type Patterns (line 3) | pub enum Patterns {
    method is_empty (line 9) | pub fn is_empty(&self) -> bool {
  type IntoPatterns (line 18) | pub trait IntoPatterns {
    method patterns (line 19) | fn patterns(&self) -> Patterns;
    method patterns (line 23) | fn patterns(&self) -> Patterns {
    method patterns (line 29) | fn patterns(&self) -> Patterns {
    method patterns (line 35) | fn patterns(&self) -> Patterns {
    method patterns (line 41) | fn patterns(&self) -> Patterns {
    method patterns (line 47) | fn patterns(&self) -> Patterns {
    method patterns (line 53) | fn patterns(&self) -> Patterns {
    method patterns (line 59) | fn patterns(&self) -> Patterns {

FILE: actix-router/src/quoter.rs
  type Quoter (line 14) | pub struct Quoter {
    method new (line 26) | pub fn new(_: &[u8], protected: &[u8]) -> Quoter {
    method decode_next (line 39) | fn decode_next<'a>(&self, val: &mut &'a [u8]) -> Option<(&'a [u8], u8)> {
    method requote (line 62) | pub fn requote(&self, val: &[u8]) -> Option<Vec<u8>> {
    method requote_str_lossy (line 89) | pub(crate) fn requote_str_lossy(&self, val: &str) -> Option<String> {
  function hex_pair_to_char (line 103) | fn hex_pair_to_char(d1: u8, d2: u8) -> Option<u8> {
  type AsciiBitmap (line 112) | struct AsciiBitmap {
    method set_bit (line 121) | fn set_bit(&mut self, ch: u8) {
    method bit_at (line 129) | fn bit_at(&self, ch: u8) -> bool {
  function custom_quoter (line 139) | fn custom_quoter() {
  function non_ascii (line 154) | fn non_ascii() {
  function invalid_sequences (line 161) | fn invalid_sequences() {
  function quoter_no_modification (line 168) | fn quoter_no_modification() {

FILE: actix-router/src/regex_set.rs
  type RegexSet (line 12) | pub(crate) struct RegexSet(regex::RegexSet);
    method new (line 24) | pub(crate) fn new(re_set: Vec<String>) -> Self {
    method empty (line 35) | pub(crate) fn empty() -> Self {
    method is_match (line 46) | pub(crate) fn is_match(&self, path: &str) -> bool {
    method first_match_idx (line 57) | pub(crate) fn first_match_idx(&self, path: &str) -> Option<usize> {
  type RegexSet (line 16) | pub(crate) struct RegexSet(Vec<regex_lite::Regex>);
    method new (line 24) | pub(crate) fn new(re_set: Vec<String>) -> Self {
    method empty (line 35) | pub(crate) fn empty() -> Self {
    method is_match (line 46) | pub(crate) fn is_match(&self, path: &str) -> bool {
    method first_match_idx (line 57) | pub(crate) fn first_match_idx(&self, path: &str) -> Option<usize> {

FILE: actix-router/src/resource.rs
  constant MAX_DYNAMIC_SEGMENTS (line 16) | const MAX_DYNAMIC_SEGMENTS: usize = 16;
  constant REGEX_FLAGS (line 21) | const REGEX_FLAGS: &str = "(?s-m)";
  type ResourceDef (line 212) | pub struct ResourceDef {
    method new (line 276) | pub fn new<T: IntoPatterns>(paths: T) -> Self {
    method prefix (line 303) | pub fn prefix<T: IntoPatterns>(paths: T) -> Self {
    method root_prefix (line 327) | pub fn root_prefix(path: &str) -> Self {
    method id (line 344) | pub fn id(&self) -> u16 {
    method set_id (line 357) | pub fn set_id(&mut self, id: u16) {
    method name (line 371) | pub fn name(&self) -> Option<&str> {
    method set_name (line 387) | pub fn set_name(&mut self, name: impl Into<String>) {
    method is_prefix (line 403) | pub fn is_prefix(&self) -> bool {
    method pattern (line 421) | pub fn pattern(&self) -> Option<&str> {
    method pattern_iter (line 443) | pub fn pattern_iter(&self) -> impl Iterator<Item = &str> {
    method join (line 503) | pub fn join(&self, other: &ResourceDef) -> ResourceDef {
    method is_match (line 555) | pub fn is_match(&self, path: &str) -> bool {
    method find_match (line 602) | pub fn find_match(&self, path: &str) -> Option<usize> {
    method capture_match_info (line 636) | pub fn capture_match_info<R: Resource>(&self, resource: &mut R) -> bool {
    method capture_match_info_fn (line 677) | pub fn capture_match_info_fn<R, F>(&self, resource: &mut R, check_fn: ...
    method build_resource_path (line 754) | fn build_resource_path<F, I>(&self, path: &mut String, mut vars: F) ->...
    method resource_path_from_iter (line 788) | pub fn resource_path_from_iter<I>(&self, path: &mut String, values: I)...
    method resource_path_from_map (line 818) | pub fn resource_path_from_map<K, V, S>(
    method static_match (line 832) | fn static_match(&self, pattern: &str, path: &str) -> Option<usize> {
    method construct (line 847) | fn construct<T: IntoPatterns>(paths: T, is_prefix: bool) -> Self {
    method parse_param (line 906) | fn parse_param(pattern: &str) -> (PatternSegment, String, &str, bool) {
    method parse (line 971) | fn parse(
    method from (line 1097) | fn from(path: &'a str) -> ResourceDef {
    method from (line 1103) | fn from(path: String) -> ResourceDef {
  type PatternSegment (line 231) | enum PatternSegment {
  type PatternType (line 241) | enum PatternType {
  method eq (line 1085) | fn eq(&self, other: &ResourceDef) -> bool {
  method hash (line 1091) | fn hash<H: Hasher>(&self, state: &mut H) {
  function insert_slash (line 1108) | pub(crate) fn insert_slash(path: &str) -> Cow<'_, str> {
  function equivalence (line 1125) | fn equivalence() {
  function parse_static (line 1152) | fn parse_static() {
  function parse_param (line 1197) | fn parse_param() {
  function dynamic_set (line 1239) | fn dynamic_set() {
  function dynamic_set_prefix (line 1305) | fn dynamic_set_prefix() {
  function parse_tail (line 1323) | fn parse_tail() {
  function static_tail (line 1344) | fn static_tail() {
  function dynamic_tail (line 1363) | fn dynamic_tail() {
  function newline_patterns_and_paths (line 1375) | fn newline_patterns_and_paths() {
  function parse_urlencoded_param (line 1402) | fn parse_urlencoded_param() {
  function prefix_static (line 1420) | fn prefix_static() {
  function prefix_dynamic (line 1469) | fn prefix_dynamic() {
  function prefix_empty (line 1501) | fn prefix_empty() {
  function build_path_list (line 1512) | fn build_path_list() {
  function multi_pattern_build_path (line 1552) | fn multi_pattern_build_path() {
  function multi_pattern_capture_segment_values (line 1560) | fn multi_pattern_capture_segment_values() {
  function dynamic_prefix_proper_segmentation (line 1585) | fn dynamic_prefix_proper_segmentation() {
  function build_path_map (line 1600) | fn build_path_map() {
  function build_path_tail (line 1617) | fn build_path_tail() {
  function prefix_trailing_slash (line 1635) | fn prefix_trailing_slash() {
  function join (line 1649) | fn join() {
  function match_methods_agree (line 1698) | fn match_methods_agree() {
  function duplicate_segment_name (line 1737) | fn duplicate_segment_name() {
  function invalid_dynamic_segment_delimiter (line 1743) | fn invalid_dynamic_segment_delimiter() {
  function invalid_dynamic_segment_name (line 1749) | fn invalid_dynamic_segment_name() {
  function invalid_too_many_dynamic_segments (line 1755) | fn invalid_too_many_dynamic_segments() {
  function invalid_custom_regex_for_tail (line 1765) | fn invalid_custom_regex_for_tail() {
  function invalid_unnamed_tail_segment (line 1771) | fn invalid_unnamed_tail_segment() {
  function prefix_plus_tail_match_disallowed (line 1777) | fn prefix_plus_tail_match_disallowed() {

FILE: actix-router/src/resource_path.rs
  type Resource (line 9) | pub trait Resource {
    method resource_path (line 14) | fn resource_path(&mut self) -> &mut Path<Self::Path>;
  type ResourcePath (line 17) | pub trait ResourcePath {
    method path (line 18) | fn path(&self) -> &str;
    method path (line 22) | fn path(&self) -> &str {
    method path (line 28) | fn path(&self) -> &str {
    method path (line 34) | fn path(&self) -> &str {
    method path (line 41) | fn path(&self) -> &str {

FILE: actix-router/src/router.rs
  type ResourceId (line 4) | pub struct ResourceId(pub u16);
  type Router (line 14) | pub struct Router<T, U = ()> {
  function build (line 20) | pub fn build() -> RouterBuilder<T, U> {
  function recognize (line 27) | pub fn recognize<R>(&self, resource: &mut R) -> Option<(&T, ResourceId)>
  function recognize_mut (line 35) | pub fn recognize_mut<R>(&mut self, resource: &mut R) -> Option<(&mut T, ...
  function recognize_fn (line 49) | pub fn recognize_fn<R, F>(&self, resource: &mut R, mut check: F) -> Opti...
  function recognize_mut_fn (line 65) | pub fn recognize_mut_fn<R, F>(
  type RouterBuilder (line 85) | pub struct RouterBuilder<T, U = ()> {
  function push (line 93) | pub fn push(
  function finish (line 108) | pub fn finish(self) -> Router<T, U> {
  function path (line 121) | pub fn path(&mut self, path: impl IntoPatterns, val: T) -> (&mut Resourc...
  function prefix (line 126) | pub fn prefix(
  function rdef (line 135) | pub fn rdef(&mut self, rdef: ResourceDef, val: T) -> (&mut ResourceDef, ...
  function test_recognizer_1 (line 150) | fn test_recognizer_1() {
  function test_recognizer_2 (line 218) | fn test_recognizer_2() {
  function test_recognizer_with_prefix (line 234) | fn test_recognizer_with_prefix() {

FILE: actix-router/src/url.rs
  type Url (line 8) | pub struct Url {
    method new (line 15) | pub fn new(uri: http::Uri) -> Url {
    method new_with_quoter (line 21) | pub fn new_with_quoter(uri: http::Uri, quoter: &Quoter) -> Url {
    method uri (line 30) | pub fn uri(&self) -> &http::Uri {
    method path (line 36) | pub fn path(&self) -> &str {
    method update (line 44) | pub fn update(&mut self, uri: &http::Uri) {
    method update_with_quoter (line 50) | pub fn update_with_quoter(&mut self, uri: &http::Uri, quoter: &Quoter) {
  method path (line 58) | fn path(&self) -> &str {
  constant PROTECTED (line 72) | const PROTECTED: &[u8] = b"%/+";
  function match_url (line 74) | fn match_url(pattern: &'static str, url: impl AsRef<str>) -> Path<Url> {
  function percent_encode (line 82) | fn percent_encode(data: &[u8]) -> String {
  function parse_url (line 91) | fn parse_url() {
  function protected_chars (line 99) | fn protected_chars() {
  function non_protected_ascii (line 117) | fn non_protected_ascii() {
  function valid_utf8_multi_byte (line 127) | fn valid_utf8_multi_byte() {
  function invalid_utf8 (line 135) | fn invalid_utf8() {

FILE: actix-test/src/lib.rs
  function start (line 81) | pub fn start<F, I, S, B>(factory: F) -> TestServer
  function start_with (line 120) | pub fn start_with<F, I, S, B>(cfg: TestServerConfig, factory: F) -> Test...
  type HttpVer (line 484) | enum HttpVer {
  type StreamType (line 492) | enum StreamType {
  function config (line 507) | pub fn config() -> TestServerConfig {
  type TestServerConfig (line 512) | pub struct TestServerConfig {
    method new (line 530) | pub(crate) fn new() -> TestServerConfig {
    method h1 (line 543) | pub fn h1(mut self) -> Self {
    method h2 (line 549) | pub fn h2(mut self) -> Self {
    method openssl (line 556) | pub fn openssl(mut self, acceptor: openssl::ssl::SslAcceptor) -> Self {
    method rustls (line 564) | pub fn rustls(mut self, config: tls_rustls_0_20::ServerConfig) -> Self {
    method rustls_0_20 (line 571) | pub fn rustls_0_20(mut self, config: tls_rustls_0_20::ServerConfig) ->...
    method rustls_021 (line 579) | pub fn rustls_021(mut self, config: tls_rustls_0_21::ServerConfig) -> ...
    method rustls_0_21 (line 586) | pub fn rustls_0_21(mut self, config: tls_rustls_0_21::ServerConfig) ->...
    method rustls_0_22 (line 593) | pub fn rustls_0_22(mut self, config: tls_rustls_0_22::ServerConfig) ->...
    method rustls_0_23 (line 600) | pub fn rustls_0_23(mut self, config: tls_rustls_0_23::ServerConfig) ->...
    method client_request_timeout (line 606) | pub fn client_request_timeout(mut self, dur: Duration) -> Self {
    method listen_address (line 614) | pub fn listen_address(mut self, addr: impl Into<String>) -> Self {
    method port (line 622) | pub fn port(mut self, port: u16) -> Self {
    method workers (line 630) | pub fn workers(mut self, workers: usize) -> Self {
    method disable_redirects (line 639) | pub fn disable_redirects(mut self) -> Self {
  method default (line 523) | fn default() -> Self {
  type TestServer (line 649) | pub struct TestServer {
    method addr (line 660) | pub fn addr(&self) -> net::SocketAddr {
    method url (line 665) | pub fn url(&self, uri: &str) -> String {
    method get (line 676) | pub fn get(&self, path: impl AsRef<str>) -> ClientRequest {
    method post (line 681) | pub fn post(&self, path: impl AsRef<str>) -> ClientRequest {
    method head (line 686) | pub fn head(&self, path: impl AsRef<str>) -> ClientRequest {
    method put (line 691) | pub fn put(&self, path: impl AsRef<str>) -> ClientRequest {
    method patch (line 696) | pub fn patch(&self, path: impl AsRef<str>) -> ClientRequest {
    method delete (line 701) | pub fn delete(&self, path: impl AsRef<str>) -> ClientRequest {
    method options (line 706) | pub fn options(&self, path: impl AsRef<str>) -> ClientRequest {
    method request (line 711) | pub fn request(&self, method: Method, path: impl AsRef<str>) -> Client...
    method load_body (line 715) | pub async fn load_body<S>(
    method ws_at (line 726) | pub async fn ws_at(
    method ws (line 736) | pub async fn ws(
    method client_headers (line 746) | pub fn client_headers(&mut self) -> Option<&mut HeaderMap> {
    method stop (line 753) | pub async fn stop(mut self) {
  method drop (line 767) | fn drop(&mut self) {

FILE: actix-web-actors/src/context.rs
  type HttpContext (line 71) | pub struct HttpContext<A>
  method stop (line 83) | fn stop(&mut self) {
  method terminate (line 86) | fn terminate(&mut self) {
  method state (line 89) | fn state(&self) -> ActorState {
  function spawn (line 99) | fn spawn<F>(&mut self, fut: F) -> SpawnHandle
  function wait (line 107) | fn wait<F>(&mut self, fut: F)
  function waiting (line 116) | fn waiting(&self) -> bool {
  function cancel_future (line 123) | fn cancel_future(&mut self, handle: SpawnHandle) -> bool {
  function address (line 128) | fn address(&self) -> Addr<A> {
  function create (line 139) | pub fn create(actor: A) -> impl Stream<Item = Result<Bytes, Error>> {
  function with_factory (line 149) | pub fn with_factory<F>(f: F) -> impl Stream<Item = Result<Bytes, Error>>
  function write (line 170) | pub fn write(&mut self, data: Bytes) {
  function write_eof (line 176) | pub fn write_eof(&mut self) {
  function handle (line 183) | pub fn handle(&self) -> SpawnHandle {
  function parts (line 192) | fn parts(&mut self) -> &mut ContextParts<A> {
  type HttpContextFut (line 197) | struct HttpContextFut<A>
  function new (line 208) | fn new(ctx: HttpContext<A>, act: A, mailbox: Mailbox<A>) -> Self {
  type Item (line 218) | type Item = Result<Bytes, Error>;
  method poll_next (line 220) | fn poll_next(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Opt...
  function pack (line 242) | fn pack(msg: M, tx: Option<Sender<M::Result>>) -> Envelope<A> {
  type MyActor (line 259) | struct MyActor {
    method write (line 272) | fn write(&mut self, ctx: &mut HttpContext<Self>) {
  type Context (line 264) | type Context = HttpContext<Self>;
  method started (line 266) | fn started(&mut self, ctx: &mut Self::Context) {
  function test_default_resource (line 284) | async fn test_default_resource() {

FILE: actix-web-actors/src/ws.rs
  type WsResponseBuilder (line 142) | pub struct WsResponseBuilder<'a, A, T>
  function new (line 163) | pub fn new(actor: A, req: &'a HttpRequest, stream: T) -> Self {
  function protocols (line 175) | pub fn protocols(mut self, protocols: &'a [&'a str]) -> Self {
  function frame_size (line 183) | pub fn frame_size(mut self, frame_size: usize) -> Self {
  function codec (line 190) | pub fn codec(mut self, codec: Codec) -> Self {
  function handshake_resp (line 195) | fn handshake_resp(&self) -> Result<HttpResponseBuilder, HandshakeError> {
  function set_frame_size (line 202) | fn set_frame_size(&mut self) {
  function create_with_codec_addr (line 224) | fn create_with_codec_addr<S>(
  function start (line 255) | pub fn start(mut self) -> Result<HttpResponse, Error> {
  function start_with_addr (line 281) | pub fn start_with_addr(mut self) -> Result<(Addr<A>, HttpResponse), Erro...
  function start (line 303) | pub fn start<A, T>(actor: A, req: &HttpRequest, stream: T) -> Result<Htt...
  function start_with_addr (line 323) | pub fn start_with_addr<A, T>(
  function start_with_protocols (line 344) | pub fn start_with_protocols<A, T>(
  function handshake (line 362) | pub fn handshake(req: &HttpRequest) -> Result<HttpResponseBuilder, Hands...
  function handshake_with_protocols (line 373) | pub fn handshake_with_protocols(
  type WebsocketContext (line 454) | pub struct WebsocketContext<A>
  method stop (line 466) | fn stop(&mut self) {
  method terminate (line 470) | fn terminate(&mut self) {
  method state (line 474) | fn state(&self) -> ActorState {
  function spawn (line 483) | fn spawn<F>(&mut self, fut: F) -> SpawnHandle
  function wait (line 490) | fn wait<F>(&mut self, fut: F)
  function waiting (line 499) | fn waiting(&self) -> bool {
  function cancel_future (line 505) | fn cancel_future(&mut self, handle: SpawnHandle) -> bool {
  function address (line 510) | fn address(&self) -> Addr<A> {
  function create (line 521) | pub fn create<S>(actor: A, stream: S) -> impl Stream<Item = Result<Bytes...
  function create_with_addr (line 535) | pub fn create_with_addr<S>(
  function with_codec (line 556) | pub fn with_codec<S>(
  function with_factory (line 576) | pub fn with_factory<S, F>(stream: S, f: F) -> impl Stream<Item = Result<...
  function write_raw (line 606) | pub fn write_raw(&mut self, msg: Message) {
  function text (line 612) | pub fn text(&mut self, text: impl Into<ByteString>) {
  function binary (line 618) | pub fn binary(&mut self, data: impl Into<Bytes>) {
  function ping (line 624) | pub fn ping(&mut self, message: &[u8]) {
  function pong (line 630) | pub fn pong(&mut self, message: &[u8]) {
  function close (line 636) | pub fn close(&mut self, reason: Option<CloseReason>) {
  function handle (line 643) | pub fn handle(&self) -> SpawnHandle {
  function set_mailbox_capacity (line 650) | pub fn set_mailbox_capacity(&mut self, cap: usize) {
  function parts (line 659) | fn parts(&mut self) -> &mut ContextParts<A> {
  type WebsocketContextFut (line 664) | struct WebsocketContextFut<A>
  function new (line 678) | fn new(ctx: WebsocketContext<A>, act: A, mailbox: Mailbox<A>, codec: Cod...
  type Item (line 693) | type Item = Result<Bytes, Error>;
  method poll_next (line 695) | fn poll_next(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<...
  function pack (line 728) | fn pack(msg: M, tx: Option<oneshot::Sender<M::Result>>) -> Envelope<A> {
  function new (line 748) | fn new(stream: S, codec: Codec) -> Self {
  type Item (line 762) | type Item = Result<Message, ProtocolError>;
  method poll_next (line 764) | fn poll_next(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Opt...
  function test_handshake (line 818) | fn test_handshake() {

FILE: actix-web-actors/tests/test_ws.rs
  type Ws (line 8) | struct Ws;
    method handle (line 15) | fn handle(&mut self, msg: Result<ws::Message, ws::ProtocolError>, ctx:...
  type Context (line 11) | type Context = ws::WebsocketContext<Self>;
  constant MAX_FRAME_SIZE (line 26) | const MAX_FRAME_SIZE: usize = 10_000;
  constant DEFAULT_FRAME_SIZE (line 27) | const DEFAULT_FRAME_SIZE: usize = 10;
  function common_test_code (line 29) | async fn common_test_code(mut srv: actix_test::TestServer, frame_size: u...
  function simple_builder (line 58) | async fn simple_builder() {
  function builder_with_frame_size (line 71) | async fn builder_with_frame_size() {
  function builder_with_frame_size_exceeded (line 86) | async fn builder_with_frame_size_exceeded() {
  function builder_with_codec (line 115) | async fn builder_with_codec() {
  function builder_with_protocols (line 130) | async fn builder_with_protocols() {
  function builder_with_codec_and_frame_size (line 145) | async fn builder_with_codec_and_frame_size() {
  function builder_full (line 161) | async fn builder_full() {
  function simple_start (line 178) | async fn simple_start() {

FILE: actix-web-codegen/src/lib.rs
  function route (line 116) | pub fn route(args: TokenStream, input: TokenStream) -> TokenStream {
  function routes (line 149) | pub fn routes(_: TokenStream, input: TokenStream) -> TokenStream {
  function scope (line 232) | pub fn scope(args: TokenStream, input: TokenStream) -> TokenStream {
  function main (line 250) | pub fn main(_: TokenStream, item: TokenStream) -> TokenStream {
  function test (line 270) | pub fn test(_: TokenStream, item: TokenStream) -> TokenStream {
  function input_and_compile_error (line 286) | fn input_and_compile_error(mut item: TokenStream, err: syn::Error) -> To...

FILE: actix-web-codegen/src/route.rs
  type RouteArgs (line 12) | pub struct RouteArgs {
    method parse (line 18) | fn parse(input: syn::parse::ParseStream<'_>) -> syn::Result<Self> {
  type Error (line 107) | type Error = syn::Error;
  method try_from (line 109) | fn try_from(value: &syn::LitStr) -> Result<Self, Self::Error> {
  method to_tokens (line 116) | fn to_tokens(&self, stream: &mut TokenStream2) {
  type MethodTypeExt (line 123) | enum MethodTypeExt {
    method to_tokens_single_guard (line 130) | fn to_tokens_single_guard(&self) -> TokenStream2 {
    method to_tokens_multi_guard (line 148) | fn to_tokens_multi_guard(&self, or_chain: Vec<impl ToTokens>) -> Token...
    method to_tokens_multi_guard_or_chain (line 180) | fn to_tokens_multi_guard_or_chain(&self) -> TokenStream2 {
    type Error (line 213) | type Error = syn::Error;
    method try_from (line 215) | fn try_from(value: &syn::LitStr) -> Result<Self, Self::Error> {
  method to_tokens (line 201) | fn to_tokens(&self, stream: &mut TokenStream2) {
  type Args (line 226) | struct Args {
    method new (line 235) | fn new(args: RouteArgs, method: Option<MethodType>) -> syn::Result<Sel...
  type Route (line 327) | pub struct Route {
    method new (line 344) | pub fn new(args: RouteArgs, ast: syn::ItemFn, method: Option<MethodTyp...
    method multiple (line 380) | fn multiple(args: Vec<Args>, ast: syn::ItemFn) -> syn::Result<Self> {
  method to_tokens (line 409) | fn to_tokens(&self, output: &mut TokenStream2) {
  function with_method (line 485) | pub(crate) fn with_method(
  function with_methods (line 509) | pub(crate) fn with_methods(input: TokenStream) -> TokenStream {

FILE: actix-web-codegen/src/scope.rs
  function with_scope (line 10) | pub fn with_scope(args: TokenStream, input: TokenStream) -> TokenStream {
  function with_scope_inner (line 17) | fn with_scope_inner(args: TokenStream, input: TokenStream) -> syn::Resul...
  function modify_attribute_with_scope (line 66) | fn modify_attribute_with_scope(attr: &syn::Attribute, scope_path: &str) ...
  function has_allowed_methods_in_scope (line 99) | fn has_allowed_methods_in_scope(attr: &syn::Attribute) -> bool {

FILE: actix-web-codegen/tests/routes.rs
  function config (line 20) | async fn config() -> impl Responder {
  function test_handler (line 25) | async fn test_handler() -> impl Responder {
  function put_test (line 30) | async fn put_test() -> impl Responder {
  function patch_test (line 35) | async fn patch_test() -> impl Responder {
  function post_test (line 40) | async fn post_test() -> impl Responder {
  function head_test (line 45) | async fn head_test() -> impl Responder {
  function connect_test (line 50) | async fn connect_test() -> impl Responder {
  function options_test (line 55) | async fn options_test() -> impl Responder {
  function trace_test (line 60) | async fn trace_test() -> impl Responder {
  function auto_async (line 65) | fn auto_async() -> impl Future<Output = Result<HttpResponse, actix_web::...
  function auto_sync (line 70) | fn auto_sync() -> impl Future<Output = Result<HttpResponse, actix_web::E...
  function put_param_test (line 75) | async fn put_param_test(_: web::Path<String>) -> impl Responder {
  function delete_param_test (line 80) | async fn delete_param_test(_: web::Path<String>) -> impl Responder {
  function get_param_test (line 85) | async fn get_param_test(_: web::Path<String>) -> impl Responder {
  function custom_route_test (line 90) | async fn custom_route_test() -> impl Responder {
  function route_test (line 101) | async fn route_test() -> impl Responder {
  function routes_test (line 109) | async fn routes_test() -> impl Responder {
  function routes_overlapping_test (line 117) | async fn routes_overlapping_test(req: HttpRequest) -> impl Responder {
  function routes_overlapping_inaccessible_test (line 131) | async fn routes_overlapping_inaccessible_test(req: HttpRequest) -> impl ...
  function custom_resource_name_test (line 139) | async fn custom_resource_name_test(req: HttpRequest) -> impl Responder {
  function guard (line 148) | pub fn guard(ctx: &GuardContext<'_>) -> bool {
  function guard_test (line 156) | async fn guard_test() -> impl Responder {
  type ChangeStatusCode (line 160) | pub struct ChangeStatusCode;
    type Response (line 168) | type Response = ServiceResponse<B>;
    type Error (line 169) | type Error = Error;
    type Transform (line 170) | type Transform = ChangeStatusCodeMiddleware<S>;
    type InitError (line 171) | type InitError = ();
    type Future (line 172) | type Future = Ready<Result<Self::Transform, Self::InitError>>;
    method new_transform (line 174) | fn new_transform(&self, service: S) -> Self::Future {
  type ChangeStatusCodeMiddleware (line 179) | pub struct ChangeStatusCodeMiddleware<S> {
  type Response (line 189) | type Response = ServiceResponse<B>;
  type Error (line 190) | type Error = Error;
  type Future (line 191) | type Future = LocalBoxFuture<'static, Result<Self::Response, Self::Error>>;
  function call (line 195) | fn call(&self, req: ServiceRequest) -> Self::Future {
  function get_wrap (line 210) | async fn get_wrap(_: web::Path<String>) -> impl Responder {
  function get_catalog (line 224) | async fn get_catalog() -> impl Responder {
  function test_params (line 229) | async fn test_params() {
  function test_body (line 251) | async fn test_body() {
  function test_auto_async (line 367) | async fn test_auto_async() {
  function test_wrap (line 376) | async fn test_wrap() {

FILE: actix-web-codegen/tests/scopes.rs
  function image_guard (line 4) | pub fn image_guard(ctx: &GuardContext<'_>) -> bool {
  function guard (line 16) | pub async fn guard() -> impl Responder {
  function test (line 21) | pub async fn test() -> impl Responder {
  function twice (line 26) | pub async fn twice(value: web::Path<String>) -> impl actix_web::Responder {
  function post (line 33) | pub async fn post() -> impl Responder {
  function delete (line 38) | pub async fn delete() -> impl Responder {
  function multiple_shared_path (line 43) | pub async fn multiple_shared_path() -> impl Responder {
  function multiple_separate_paths (line 52) | pub async fn multiple_separate_paths() -> impl Responder {
  function mod_common (line 57) | pub fn mod_common(message: String) -> impl actix_web::Responder {
  function test (line 69) | pub async fn test() -> impl Responder {
  type TestEnum (line 79) | enum TestEnum {
  function test (line 84) | pub async fn test() -> impl Responder {
  function scope_get_async (line 95) | async fn scope_get_async() {
  function scope_get_param_async (line 104) | async fn scope_get_param_async() {
  function scope_post_async (line 115) | async fn scope_post_async() {
  function multiple_shared_path_async (line 126) | async fn multiple_shared_path_async() {
  function multiple_multi_path_async (line 139) | async fn multiple_multi_path_async() {
  function scope_delete_async (line 160) | async fn scope_delete_async() {
  function scope_get_with_guard_async (line 171) | async fn scope_get_with_guard_async() {
  function scope_v1_v2_async (line 182) | async fn scope_v1_v2_async() {

FILE: actix-web-codegen/tests/trybuild.rs
  function compile_macros (line 3) | fn compile_macros() {

FILE: actix-web-codegen/tests/trybuild/docstring-ok.rs
  function index (line 6) | async fn index() -> impl Responder {
  function main (line 11) | async fn main() {

FILE: actix-web-codegen/tests/trybuild/route-custom-lowercase.rs
  function index (line 6) | async fn index() -> String {
  function main (line 11) | async fn main() {

FILE: actix-web-codegen/tests/trybuild/route-custom-method.rs
  function index (line 7) | async fn index() -> String {
  function custom (line 12) | async fn custom() -> String {
  function main (line 17) | async fn main() {

FILE: actix-web-codegen/tests/trybuild/route-duplicate-method-fail.rs
  function index (line 4) | async fn index() -> String {
  function main (line 9) | async fn main() {

FILE: actix-web-codegen/tests/trybuild/route-malformed-path-fail.rs
  function zero (line 4) | async fn zero() -> &'static str {
  function one (line 9) | async fn one() -> &'static str {
  function two (line 14) | async fn two() -> &'static str {
  function three (line 19) | async fn three() -> &'static str {
  function four (line 24) | async fn four() -> &'static str {
  function five (line 29) | async fn five() -> &'static str {
  function main (line 33) | fn main() {}

FILE: actix-web-codegen/tests/trybuild/route-missing-method-fail.rs
  function index (line 4) | async fn index() -> String {
  function main (line 9) | async fn main() {

FILE: actix-web-codegen/tests/trybuild/route-ok.rs
  function index (line 4) | async fn index() -> String {
  function main (line 9) | async fn main() {

FILE: actix-web-codegen/tests/trybuild/routes-missing-args-fail.rs
  function index (line 5) | async fn index() -> String {
  function main (line 10) | async fn main() {

FILE: actix-web-codegen/tests/trybuild/routes-missing-method-fail.rs
  function index (line 4) | async fn index() -> String {
  function main (line 9) | async fn main() {

FILE: actix-web-codegen/tests/trybuild/routes-ok.rs
  function index (line 6) | async fn index() -> String {
  function main (line 11) | async fn main() {

FILE: actix-web-codegen/tests/trybuild/scope-invalid-args.rs
  constant PATH (line 3) | const PATH: &str = "/api";
  function main (line 14) | fn main() {}

FILE: actix-web-codegen/tests/trybuild/scope-missing-args.rs
  function main (line 6) | fn main() {}

FILE: actix-web-codegen/tests/trybuild/scope-on-handler.rs
  function index (line 4) | async fn index() -> &'static str {
  function main (line 8) | fn main() {}

FILE: actix-web-codegen/tests/trybuild/scope-trailing-slash.rs
  function main (line 6) | fn main() {}

FILE: actix-web-codegen/tests/trybuild/simple-fail.rs
  function one (line 4) | async fn one() -> String {
  function two (line 9) | async fn two() -> String {
  function three (line 16) | async fn three() -> String {
  function four (line 21) | async fn four() -> String {
  function five (line 26) | async fn five() -> String {
  function main (line 30) | fn main() {}

FILE: actix-web-codegen/tests/trybuild/simple.rs
  function config (line 5) | async fn config() -> impl Responder {
  function main (line 10) | async fn main() {

FILE: actix-web-codegen/tests/trybuild/test-runtime.rs
  function my_test (line 2) | async fn my_test() {
  function main (line 6) | fn main() {}

FILE: actix-web/benches/responder.rs
  type FutureResponder (line 10) | trait FutureResponder {
    method future_respond_to (line 14) | fn future_respond_to(self, req: &HttpRequest) -> Self::Future;
    type Error (line 21) | type Error = Error;
    type Future (line 22) | type Future = Ready<Result<HttpResponse, Self::Error>>;
    method future_respond_to (line 24) | fn future_respond_to(self, _: &HttpRequest) -> Self::Future {
  type StringResponder (line 18) | struct StringResponder(String);
  type Body (line 33) | type Body = BoxBody;
  method respond_to (line 35) | fn respond_to(self, _: &HttpRequest) -> HttpResponse<Self::Body> {
  function future_responder (line 42) | fn future_responder(c: &mut Criterion) {
  function responder (line 65) | fn responder(c: &mut Criterion) {

FILE: actix-web/benches/server.rs
  constant STR (line 6) | const STR: &str = "Hello World Hello World Hello World Hello World Hello...
  function bench_async_burst (line 29) | fn bench_async_burst(c: &mut Criterion) {

FILE: actix-web/benches/service.rs
  function bench_async_service (line 25) | pub fn bench_async_service<S>(c: &mut Criterion, srv: S, name: &str)
  function index (line 61) | async fn index(req: ServiceRequest) -> Result<ServiceResponse, Error> {
  function async_web_service (line 69) | fn async_web_service(c: &mut Criterion) {
  function service_benches (line 102) | pub fn service_benches() {

FILE: actix-web/examples/basic.rs
  function index (line 4) | async fn index(req: HttpRequest, name: web::Path<String>) -> String {
  function index_async (line 9) | async fn index_async(req: HttpRequest) -> &'static str {
  function no_params (line 15) | async fn no_params() -> &'static str {
  function main (line 20) | async fn main() -> std::io::Result<()> {

FILE: actix-web/examples/from_fn.rs
  function noop (line 15) | async fn noop<B>(req: ServiceRequest, next: Next<B>) -> Result<ServiceRe...
  function print_range_header (line 19) | async fn print_range_header<B>(
  function mutate_body_type (line 33) | async fn mutate_body_type(
  function mutate_body_type_with_extractors (line 41) | async fn mutate_body_type_with_extractors(
  function timeout_10secs (line 55) | async fn timeout_10secs(
  type MyMw (line 65) | struct MyMw(bool);
    method mw_cb (line 68) | async fn mw_cb(
    method into_middleware (line 84) | pub fn into_middleware<S, B>(
  function main (line 106) | async fn main() -> io::Result<()> {

FILE: actix-web/examples/introspection.rs
  function main (line 5) | async fn main() -> std::io::Result<()> {

FILE: actix-web/examples/introspection_multi_servers.rs
  function main (line 5) | async fn main() -> std::io::Result<()> {

FILE: actix-web/examples/macroless.rs
  function index (line 3) | async fn index(req: HttpRequest) -> &'static str {
  function main (line 8) | fn main() -> std::io::Result<()> {

FILE: actix-web/examples/middleware_from_fn.rs
  function noop (line 14) | async fn noop<B>(req: ServiceRequest, next: Next<B>) -> Result<ServiceRe...
  function print_range_header (line 18) | async fn print_range_header<B>(
  function mutate_body_type (line 32) | async fn mutate_body_type(
  function mutate_body_type_with_extractors (line 40) | async fn mutate_body_type_with_extractors(
  function timeout_10secs (line 54) | async fn timeout_10secs(
  type MyMw (line 64) | struct MyMw(bool);
    method mw_cb (line 67) | async fn mw_cb(
    method into_middleware (line 83) | pub fn into_middleware<S, B>(
  function main (line 105) | async fn main() -> io::Result<()> {

FILE: actix-web/examples/on-connect.rs
  type ConnectionInfo (line 15) | struct ConnectionInfo {
  function route_whoami (line 21) | async fn route_whoami(req: HttpRequest) -> impl Responder {
  function get_conn_info (line 30) | fn get_conn_info(connection: &dyn Any, data: &mut Extensions) {
  function main (line 43) | async fn main() -> io::Result<()> {

FILE: actix-web/examples/uds.rs
  function index (line 6) | async fn index(req: HttpRequest, name: web::Path<String>) -> String {
  function index_async (line 12) | async fn index_async(req: HttpRequest) -> Result<&'static str, Error> {
  function no_params (line 18) | async fn no_params() -> &'static str {
  function main (line 24) | async fn main() -> std::io::Result<()> {
  function main (line 49) | fn main() {}

FILE: actix-web/examples/worker-cpu-pin.rs
  function hello (line 12) | async fn hello() -> &'static str {
  function main (line 17) | async fn main() -> io::Result<()> {

FILE: actix-web/src/app.rs
  type App (line 25) | pub struct App<T> {
  function new (line 40) | pub fn new() -> Self {
  function app_data (line 121) | pub fn app_data<U: 'static>(mut self, data: U) -> Self {
  function data (line 130) | pub fn data<U: 'static>(self, data: U) -> Self {
  function data_factory (line 140) | pub fn data_factory<F, Out, D, E>(mut self, data: F) -> Self
  function configure (line 191) | pub fn configure<F>(mut self, f: F) -> Self
  function route (line 227) | pub fn route(self, path: &str, mut route: Route) -> Self {
  function service (line 243) | pub fn service<F>(mut self, factory: F) -> Self
  function default_service (line 271) | pub fn default_service<F, U>(mut self, svc: F) -> Self
  function external_resource (line 307) | pub fn external_resource<N, U>(mut self, name: N, url: U) -> Self
  function wrap (line 345) | pub fn wrap<M, B>(
  function wrap_fn (line 415) | pub fn wrap_fn<F, R, B>(
  function into_factory (line 457) | fn into_factory(self) -> AppInit<T, B> {
  function test_default_resource (line 490) | async fn test_default_resource() {
  function test_data_factory (line 535) | async fn test_data_factory() {
  function test_data_factory_errors (line 560) | async fn test_data_factory_errors() {
  function test_extension (line 572) | async fn test_extension() {
  function test_wrap (line 586) | async fn test_wrap() {
  function test_router_wrap (line 606) | async fn test_router_wrap() {
  function test_wrap_fn (line 626) | async fn test_wrap_fn() {
  function test_router_wrap_fn (line 651) | async fn test_router_wrap_fn() {
  function test_external_resource (line 676) | async fn test_external_resource() {
  function can_be_returned_from_fn (line 697) | fn can_be_returned_from_fn() {

FILE: actix-web/src/app_service.rs
  type AppInit (line 27) | pub struct AppInit<T, B>
  type Response (line 59) | type Response = ServiceResponse<B>;
  type Error (line 60) | type Error = T::Error;
  type Config (line 61) | type Config = AppConfig;
  type Service (line 62) | type Service = AppInitService<T::Service, B>;
  type InitError (line 63) | type InitError = T::InitError;
  type Future (line 64) | type Future = LocalBoxFuture<'static, Result<Self::Service, Self::InitEr...
  function new_service (line 66) | fn new_service(&self, config: AppConfig) -> Self::Future {
  type AppInitService (line 166) | pub struct AppInitService<T, B>
  type AppInitServiceState (line 176) | pub(crate) struct AppInitServiceState {
    method new (line 184) | pub(crate) fn new(rmap: Rc<ResourceMap>, config: AppConfig) -> Rc<Self> {
    method rmap (line 194) | pub(crate) fn rmap(&self) -> &ResourceMap {
    method config (line 200) | pub(crate) fn config(&self) -> &AppConfig {
    method pool (line 206) | pub(crate) fn pool(&self) -> &HttpRequestPool {
  type Response (line 215) | type Response = ServiceResponse<B>;
  type Error (line 216) | type Error = T::Error;
  type Future (line 217) | type Future = T::Future;
  function call (line 221) | fn call(&self, mut req: Request) -> Self::Future {
  method drop (line 257) | fn drop(&mut self) {
  type AppRoutingFactory (line 262) | pub struct AppRoutingFactory {
    type Response (line 275) | type Response = ServiceResponse;
    type Error (line 276) | type Error = Error;
    type Config (line 277) | type Config = ();
    type Service (line 278) | type Service = AppRouting;
    type InitError (line 279) | type InitError = ();
    type Future (line 280) | type Future = LocalBoxFuture<'static, Result<Self::Service, Self::Init...
    method new_service (line 282) | fn new_service(&self, _: ()) -> Self::Future {
  type AppRouting (line 319) | pub struct AppRouting {
    type Response (line 325) | type Response = ServiceResponse<BoxBody>;
    type Error (line 326) | type Error = Error;
    type Future (line 327) | type Future = LocalBoxFuture<'static, Result<Self::Response, Self::Err...
    method call (line 331) | fn call(&self, mut req: ServiceRequest) -> Self::Future {
  type AppEntry (line 354) | pub struct AppEntry {
    method new (line 359) | pub fn new(factory: Rc<RefCell<Option<AppRoutingFactory>>>) -> Self {
    type Response (line 365) | type Response = ServiceResponse;
    type Error (line 366) | type Error = Error;
    type Config (line 367) | type Config = ();
    type Service (line 368) | type Service = AppRouting;
    type InitError (line 369) | type InitError = ();
    type Future (line 370) | type Future = LocalBoxFuture<'static, Result<Self::Service, Self::Init...
    method new_service (line 372) | fn new_service(&self, _: ()) -> Self::Future {
  type DropData (line 391) | struct DropData(Arc<AtomicBool>);
  method drop (line 394) | fn drop(&mut self) {
  function test_drop_data (line 402) | async fn test_drop_data() {

FILE: actix-web/src/config.rs
  type Guards (line 19) | type Guards = Vec<Box<dyn Guard>>;
  type AppService (line 22) | pub struct AppService {
    method new (line 46) | pub(crate) fn new(config: AppConfig, default: Rc<BoxedHttpServiceFacto...
    method is_root (line 66) | pub fn is_root(&self) -> bool {
    method into_services (line 72) | pub(crate) fn into_services(
    method into_services (line 89) | pub(crate) fn into_services(
    method clone_config (line 105) | pub(crate) fn clone_config(&self) -> Self {
    method config (line 123) | pub fn config(&self) -> &AppConfig {
    method default_service (line 128) | pub fn default_service(&self) -> Rc<BoxedHttpServiceFactory> {
    method register_service (line 133) | pub fn register_service<F, S>(
    method update_prefix (line 211) | pub(crate) fn update_prefix(&mut self, prefix: &str) {
    method prepare_scope_id (line 225) | pub(crate) fn prepare_scope_id(&mut self) -> usize {
  type AppConfig (line 234) | pub struct AppConfig {
    method new (line 241) | pub(crate) fn new(secure: bool, host: String, addr: SocketAddr) -> Self {
    method __priv_test_new (line 247) | pub fn __priv_test_new(secure: bool, host: String, addr: SocketAddr) -...
    method host (line 258) | pub fn host(&self) -> &str {
    method secure (line 263) | pub fn secure(&self) -> bool {
    method local_addr (line 268) | pub fn local_addr(&self) -> SocketAddr {
    method set_host (line 273) | pub(crate) fn set_host(&mut self, host: &str) {
  method default (line 289) | fn default() -> Self {
  type ServiceConfig (line 318) | pub struct ServiceConfig {
    method new (line 326) | pub(crate) fn new() -> Self {
    method data (line 339) | pub fn data<U: 'static>(&mut self, data: U) -> &mut Self {
    method app_data (line 347) | pub fn app_data<U: 'static>(&mut self, ext: U) -> &mut Self {
    method default_service (line 355) | pub fn default_service<F, U>(&mut self, f: F) -> &mut Self
    method configure (line 374) | pub fn configure<F>(&mut self, f: F) -> &mut Self
    method route (line 385) | pub fn route(&mut self, path: &str, mut route: Route) -> &mut Self {
    method service (line 396) | pub fn service<F>(&mut self, factory: F) -> &mut Self
    method external_resource (line 412) | pub fn external_resource<N, U>(&mut self, name: N, url: U) -> &mut Self
  function test_data (line 439) | async fn test_data() {
  function test_external_resource (line 458) | async fn test_external_resource() {
  function registers_default_service (line 481) | async fn registers_default_service() {
  function test_service (line 513) | async fn test_service() {
  function nested_service_configure (line 534) | async fn nested_service_configure() {

FILE: actix-web/src/data.rs
  type DataFactory (line 11) | pub(crate) trait DataFactory {
    method create (line 13) | fn create(&self, extensions: &mut Extensions) -> bool;
    method create (line 186) | fn create(&self, extensions: &mut Extensions) -> bool {
  type FnDataFactory (line 16) | pub(crate) type FnDataFactory =
  type Data (line 90) | pub struct Data<T: ?Sized>(Arc<T>);
  function new (line 94) | pub fn new(state: T) -> Data<T> {
  function get_ref (line 101) | pub fn get_ref(&self) -> &T {
  function into_inner (line 106) | pub fn into_inner(self) -> Arc<T> {
  type Target (line 112) | type Target = Arc<T>;
  method deref (line 114) | fn deref(&self) -> &Arc<T> {
  method clone (line 120) | fn clone(&self) -> Data<T> {
  function from (line 126) | fn from(arc: Arc<T>) -> Self {
  method default (line 132) | fn default() -> Self {
  method serialize (line 141) | fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
  function deserialize (line 152) | fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
  type Error (line 161) | type Error = Error;
  type Future (line 162) | type Future = Ready<Result<Self, Error>>;
  method from_request (line 165) | fn from_request(req: &HttpRequest, _: &mut Payload) -> Self::Future {
  function test_data_extractor (line 205) | async fn test_data_extractor() {
  function test_app_data_extractor (line 250) | async fn test_app_data_extractor() {
  function test_route_data_extractor (line 276) | async fn test_route_data_extractor() {
  function test_override_data (line 307) | async fn test_override_data() {
  function test_data_from_arc (line 326) | async fn test_data_from_arc() {
  function test_data_from_dyn_arc (line 333) | async fn test_data_from_dyn_arc() {
  function test_dyn_data_into_arc (line 353) | async fn test_dyn_data_into_arc() {
  function test_get_ref_from_dyn_data (line 370) | async fn test_get_ref_from_dyn_data() {

FILE: actix-web/src/dev.rs
  function ensure_leading_slash (line 30) | pub(crate) fn ensure_leading_slash(mut patterns: Patterns) -> Patterns {

FILE: actix-web/src/error/error.rs
  type Error (line 15) | pub struct Error {
    method as_response_error (line 21) | pub fn as_response_error(&self) -> &dyn ResponseError {
    method as_error (line 26) | pub fn as_error<T: ResponseError + 'static>(&self) -> Option<&T> {
    method error_response (line 31) | pub fn error_response(&self) -> HttpResponse {
    method fmt (line 37) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
    method fmt (line 43) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
    method from (line 56) | fn from(err: T) -> Error {
    method from (line 64) | fn from(value: Box<dyn ResponseError>) -> Self {
  method source (line 49) | fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
  function from (line 70) | fn from(err: Error) -> Response<BoxBody> {

FILE: actix-web/src/error/internal.rs
  type InternalError (line 27) | pub struct InternalError<T> {
  type InternalErrorType (line 32) | enum InternalErrorType {
  function new (line 39) | pub fn new(cause: T, status: StatusCode) -> Self {
  function from_response (line 47) | pub fn from_response(cause: T, response: HttpResponse) -> Self {
  function fmt (line 56) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  function fmt (line 62) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  method status_code (line 71) | fn status_code(&self) -> StatusCode {
  method error_response (line 84) | fn error_response(&self) -> HttpResponse {
  type Body (line 112) | type Body = BoxBody;
  method respond_to (line 114) | fn respond_to(self, _: &HttpRequest) -> HttpResponse<Self::Body> {
  function test_internal_error (line 191) | fn test_internal_error() {
  function test_error_helpers (line 198) | fn test_error_helpers() {

FILE: actix-web/src/error/macros.rs
  type MB (line 84) | trait MB {
  function test_any_casting (line 94) | async fn test_any_casting() {

FILE: actix-web/src/error/mod.rs
  type Result (line 29) | pub type Result<T, E = Error> = std::result::Result<T, E>;
  type BlockingError (line 35) | pub struct BlockingError;
  type UrlGenerationError (line 42) | pub enum UrlGenerationError {
  type UrlencodedError (line 61) | pub enum UrlencodedError {
  method status_code (line 100) | fn status_code(&self) -> StatusCode {
  type JsonPayloadError (line 114) | pub enum JsonPayloadError {
    method from (line 145) | fn from(err: PayloadError) -> Self {
  method status_code (line 151) | fn status_code(&self) -> StatusCode {
  type PathError (line 168) | pub enum PathError {
  method status_code (line 176) | fn status_code(&self) -> StatusCode {
  type QueryPayloadError (line 184) | pub enum QueryPayloadError {
  method status_code (line 191) | fn status_code(&self) -> StatusCode {
  type ReadlinesError (line 199) | pub enum ReadlinesError {
  method status_code (line 218) | fn status_code(&self) -> StatusCode {
  function test_urlencoded_error (line 231) | fn test_urlencoded_error() {
  function test_json_payload_error (line 241) | fn test_json_payload_error() {
  function test_query_payload_error (line 255) | fn test_query_payload_error() {
  function test_readlines_error (line 264) | fn test_readlines_error() {

FILE: actix-web/src/error/response_error.rs
  type ResponseError (line 25) | pub trait ResponseError: fmt::Debug + fmt::Display {
    method status_code (line 30) | fn status_code(&self) -> StatusCode {
    method error_response (line 38) | fn error_response(&self) -> HttpResponse<BoxBody> {
    method status_code (line 58) | fn status_code(&self) -> StatusCode {
    method error_response (line 61) | fn error_response(&self) -> HttpResponse<BoxBody> {
    method status_code (line 70) | fn status_code(&self) -> StatusCode {
    method status_code (line 80) | fn status_code(&self) -> StatusCode {
    method status_code (line 86) | fn status_code(&self) -> StatusCode {
    method status_code (line 98) | fn status_code(&self) -> StatusCode {
    method error_response (line 102) | fn error_response(&self) -> HttpResponse<BoxBody> {
    method status_code (line 108) | fn status_code(&self) -> StatusCode {
    method status_code (line 114) | fn status_code(&self) -> StatusCode {
    method status_code (line 120) | fn status_code(&self) -> StatusCode {
    method status_code (line 129) | fn status_code(&self) -> StatusCode {
    method error_response (line 136) | fn error_response(&self) -> HttpResponse<BoxBody> {
  function test_error_casting (line 151) | fn test_error_casting() {

FILE: actix-web/src/extract.rs
  type FromRequest (line 65) | pub trait FromRequest: Sized {
    method from_request (line 89) | fn from_request(req: &HttpRequest, payload: &mut Payload) -> Self::Fut...
    method extract (line 94) | fn extract(req: &HttpRequest) -> Self::Future {
    type Error (line 148) | type Error = Infallible;
    type Future (line 149) | type Future = FromRequestOptFuture<T::Future>;
    method from_request (line 152) | fn from_request(req: &HttpRequest, payload: &mut Payload) -> Self::Fut...
    type Error (line 234) | type Error = Infallible;
    type Future (line 235) | type Future = FromRequestResFuture<T::Future, E>;
    method from_request (line 238) | fn from_request(req: &HttpRequest, payload: &mut Payload) -> Self::Fut...
    type Error (line 281) | type Error = Infallible;
    type Future (line 282) | type Future = Ready<Result<Self, Self::Error>>;
    method from_request (line 284) | fn from_request(req: &HttpRequest, _: &mut Payload) -> Self::Future {
    type Error (line 302) | type Error = Infallible;
    type Future (line 303) | type Future = Ready<Result<Self, Self::Error>>;
    method from_request (line 305) | fn from_request(req: &HttpRequest, _: &mut Payload) -> Self::Future {
    type Error (line 399) | type Error = Infallible;
    type Future (line 400) | type Future = Ready<Result<Self, Self::Error>>;
    method from_request (line 402) | fn from_request(_: &HttpRequest, _: &mut Payload) -> Self::Future {
  type Output (line 171) | type Output = Result<Option<T>, Infallible>;
  method poll (line 173) | fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
  type Output (line 259) | type Output = Result<Result<T, E>, Infallible>;
  method poll (line 261) | fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
  type Info (line 438) | struct Info {
  function test_option (line 443) | async fn test_option() {
  function test_result (line 483) | async fn test_result() {
  function test_uri (line 521) | async fn test_uri() {
  function test_method (line 528) | async fn test_method() {
  function test_concurrent (line 535) | async fn test_concurrent() {

FILE: actix-web/src/guard/acceptable.rs
  type Acceptable (line 20) | pub struct Acceptable {
    method new (line 31) | pub fn new(mime: mime::Mime) -> Self {
    method match_star_star (line 39) | pub fn match_star_star(mut self) -> Self {
  method check (line 46) | fn check(&self, ctx: &GuardContext<'_>) -> bool {
  method name (line 68) | fn name(&self) -> String {
  method details (line 77) | fn details(&self) -> Option<Vec<super::GuardDetail>> {
  function test_acceptable (line 95) | fn test_acceptable() {
  function test_acceptable_star (line 111) | fn test_acceptable_star() {
  function acceptable_guard_details_include_mime (line 123) | fn acceptable_guard_details_include_mime() {

FILE: actix-web/src/guard/host.rs
  function Host (line 58) | pub fn Host(host: impl AsRef<str>) -> HostGuard {
  function get_host_uri (line 65) | fn get_host_uri(req: &RequestHead) -> Option<Uri> {
  type HostGuard (line 75) | pub struct HostGuard {
    method scheme (line 82) | pub fn scheme<H: AsRef<str>>(mut self, scheme: H) -> HostGuard {
  method check (line 89) | fn check(&self, ctx: &GuardContext<'_>) -> bool {
  method name (line 122) | fn name(&self) -> String {
  method details (line 131) | fn details(&self) -> Option<Vec<super::GuardDetail>> {
  function host_not_from_header_if_http2 (line 151) | fn host_not_from_header_if_http2() {
  function host_from_header (line 183) | fn host_from_header() {
  function host_without_header (line 211) | fn host_without_header() {
  function host_scheme (line 236) | fn host_scheme() {
  function host_guard_details_include_host_and_scheme (line 268) | fn host_guard_details_include_host_and_scheme() {

FILE: actix-web/src/guard/mod.rs
  type GuardDetail (line 73) | pub enum GuardDetail {
  type GuardContext (line 84) | pub struct GuardContext<'a> {
  function head (line 91) | pub fn head(&self) -> &RequestHead {
  function req_data (line 97) | pub fn req_data(&self) -> Ref<'a, Extensions> {
  function req_data_mut (line 103) | pub fn req_data_mut(&self) -> RefMut<'a, Extensions> {
  function header (line 123) | pub fn header<H: Header>(&self) -> Option<H> {
  function app_data (line 129) | pub fn app_data<T: 'static>(&self) -> Option<&T> {
  type Guard (line 137) | pub trait Guard {
    method check (line 139) | fn check(&self, ctx: &GuardContext<'_>) -> bool;
    method name (line 143) | fn name(&self) -> String {
    method details (line 151) | fn details(&self) -> Option<Vec<GuardDetail>> {
    method check (line 157) | fn check(&self, ctx: &GuardContext<'_>) -> bool {
    method name (line 162) | fn name(&self) -> String {
    method details (line 167) | fn details(&self) -> Option<Vec<GuardDetail>> {
    method check (line 197) | fn check(&self, ctx: &GuardContext<'_>) -> bool {
    method check (line 206) | fn check(&self, ctx: &GuardContext<'_>) -> bool {
    method check (line 250) | fn check(&self, ctx: &GuardContext<'_>) -> bool {
    method name (line 261) | fn name(&self) -> String {
    method details (line 273) | fn details(&self) -> Option<Vec<GuardDetail>> {
    method check (line 324) | fn check(&self, ctx: &GuardContext<'_>) -> bool {
    method name (line 335) | fn name(&self) -> String {
    method details (line 347) | fn details(&self) -> Option<Vec<GuardDetail>> {
    method check (line 372) | fn check(&self, ctx: &GuardContext<'_>) -> bool {
    method name (line 377) | fn name(&self) -> String {
    method details (line 382) | fn details(&self) -> Option<Vec<GuardDetail>> {
    method check (line 401) | fn check(&self, ctx: &GuardContext<'_>) -> bool {
    method name (line 416) | fn name(&self) -> String {
    method details (line 421) | fn details(&self) -> Option<Vec<GuardDetail>> {
    method check (line 479) | fn check(&self, ctx: &GuardContext<'_>) -> bool {
    method name (line 488) | fn name(&self) -> String {
    method details (line 493) | fn details(&self) -> Option<Vec<GuardDetail>> {
  function fn_guard (line 184) | pub fn fn_guard<F>(f: F) -> impl Guard
  type FnGuard (line 191) | struct FnGuard<F: Fn(&GuardContext<'_>) -> bool>(F);
  function Any (line 225) | pub fn Any<F: Guard + 'static>(guard: F) -> AnyGuard {
  type AnyGuard (line 236) | pub struct AnyGuard {
    method or (line 242) | pub fn or<F: Guard + 'static>(mut self, guard: F) -> Self {
  function All (line 299) | pub fn All<F: Guard + 'static>(guard: F) -> AllGuard {
  type AllGuard (line 310) | pub struct AllGuard {
    method and (line 316) | pub fn and<F: Guard + 'static>(mut self, guard: F) -> Self {
  type Not (line 368) | pub struct Not<G>(pub G);
  function Method (line 389) | pub fn Method(method: HttpMethod) -> impl Guard {
  type RegisteredMethods (line 394) | pub(crate) struct RegisteredMethods(pub(crate) Vec<HttpMethod>);
  type MethodGuard (line 398) | pub(crate) struct MethodGuard(HttpMethod);
  function Header (line 469) | pub fn Header(name: &'static str, value: &'static str) -> impl Guard {
  type HeaderGuard (line 476) | struct HeaderGuard(header::HeaderName, header::HeaderValue);
  function header_match (line 509) | fn header_match() {
  function method_guards (line 528) | fn method_guards() {
  function aggregate_any (line 574) | fn aggregate_any() {
  function aggregate_all (line 585) | fn aggregate_all() {
  function nested_not (line 596) | fn nested_not() {
  function function_guard (line 610) | fn function_guard() {
  function mega_nesting (line 624) | fn mega_nesting() {
  function app_data (line 637) | fn app_data() {

FILE: actix-web/src/handler.rs
  type Handler (line 89) | pub trait Handler<Args>: Clone + 'static {
    method call (line 93) | fn call(&self, args: Args) -> Self::Future;
  function handler_service (line 96) | pub(crate) fn handler_service<F, Args>(handler: F) -> BoxedHttpServiceFa...
  function assert_impl_handler (line 170) | fn assert_impl_handler<T: FromRequest>(_: impl Handler<T>) {}
  function arg_number (line 173) | fn arg_number() {

FILE: actix-web/src/helpers.rs
  type MutWriter (line 11) | pub(crate) struct MutWriter<'a, B>(pub(crate) &'a mut B);
  function write (line 17) | fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
  function flush (line 22) | fn flush(&mut self) -> io::Result<()> {

FILE: actix-web/src/http/header/accept.rs
  method star (line 126) | pub fn star() -> Accept {
  method json (line 131) | pub fn json() -> Accept {
  method text (line 136) | pub fn text() -> Accept {
  method image (line 141) | pub fn image() -> Accept {
  method html (line 146) | pub fn html() -> Accept {
  method preference (line 162) | pub fn preference(&self) -> Mime {
  method ranked (line 187) | pub fn ranked(&self) -> Vec<Mime> {
  function ranking_precedence (line 240) | fn ranking_precedence() {
  function preference_selection (line 275) | fn preference_selection() {

FILE: actix-web/src/http/header/accept_encoding.rs
  method negotiate (line 102) | pub fn negotiate<'a>(&self, supported: impl Iterator<Item = &'a Encoding...
  method preference (line 167) | pub fn preference(&self) -> Option<Preference<Encoding>> {
  method ranked (line 219) | pub fn ranked(&self) -> Vec<Preference<Encoding>> {
  method ranked_items (line 223) | fn ranked_items(&self) -> impl Iterator<Item = QualityItem<Preference<En...
  function encoding_rank (line 244) | fn encoding_rank(qv: &QualityItem<Preference<Encoding>>) -> u8 {
  function is_identity_acceptable (line 266) | fn is_identity_acceptable(items: &'_ [QualityItem<Preference<Encoding>>]...
  function enc (line 302) | fn enc(enc: &str) -> Preference<Encoding> {
  function detect_identity_acceptable (line 307) | fn detect_identity_acceptable() {
  function encoding_negotiation (line 339) | fn encoding_negotiation() {
  function ranking_precedence (line 424) | fn ranking_precedence() {
  function preference_selection (line 442) | fn preference_selection() {

FILE: actix-web/src/http/header/accept_language.rs
  method preference (line 104) | pub fn preference(&self) -> Preference<LanguageTag> {
  method ranked (line 127) | pub fn ranked(&self) -> Vec<Preference<LanguageTag>> {
  function ranking_precedence (line 150) | fn ranking_precedence() {
  function preference_selection (line 195) | fn preference_selection() {

FILE: actix-web/src/http/header/any_or_some.rs
  type AnyOrSome (line 14) | pub enum AnyOrSome<T> {
  function is_any (line 24) | pub fn is_any(&self) -> bool {
  function is_item (line 29) | pub fn is_item(&self) -> bool {
  function item (line 34) | pub fn item(&self) -> Option<&T> {
  function into_item (line 42) | pub fn into_item(self) -> Option<T> {
  function fmt (line 52) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  type Err (line 61) | type Err = T::Err;
  function from_str (line 64) | fn from_str(s: &str) -> Result<Self, Self::Err> {

FILE: actix-web/src/http/header/cache_control.rs
  type CacheDirective (line 97) | pub enum CacheDirective {
    method fmt (line 132) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
    type Err (line 160) | type Err = Option<<u32 as str::FromStr>::Err>;
    method from_str (line 162) | fn from_str(s: &str) -> Result<Self, Self::Err> {

FILE: actix-web/src/http/header/content_disposition.rs
  function split_once (line 25) | fn split_once(haystack: &str, needle: char) -> (&str, &str) {
  function split_once_and_trim (line 37) | fn split_once_and_trim(haystack: &str, needle: char) -> (&str, &str) {
  type DispositionType (line 44) | pub enum DispositionType {
    method from (line 62) | fn from(origin: &'a str) -> DispositionType {
    method fmt (line 510) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  type DispositionParam (line 87) | pub enum DispositionParam {
    method is_name (line 123) | pub fn is_name(&self) -> bool {
    method is_filename (line 129) | pub fn is_filename(&self) -> bool {
    method is_filename_ext (line 135) | pub fn is_filename_ext(&self) -> bool {
    method is_unknown (line 142) | pub fn is_unknown<T: AsRef<str>>(&self, name: T) -> bool {
    method is_unknown_ext (line 149) | pub fn is_unknown_ext<T: AsRef<str>>(&self, name: T) -> bool {
    method as_name (line 155) | pub fn as_name(&self) -> Option<&str> {
    method as_filename (line 164) | pub fn as_filename(&self) -> Option<&str> {
    method as_filename_ext (line 173) | pub fn as_filename_ext(&self) -> Option<&ExtendedValue> {
    method as_unknown (line 183) | pub fn as_unknown<T: AsRef<str>>(&self, name: T) -> Option<&str> {
    method as_unknown_ext (line 197) | pub fn as_unknown_ext<T: AsRef<str>>(&self, name: T) -> Option<&Extend...
    method fmt (line 521) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  type ContentDisposition (line 314) | pub struct ContentDisposition {
    method attachment (line 334) | pub fn attachment(filename: impl Into<String>) -> Self {
    method from_raw (line 342) | pub fn from_raw(hv: &header::HeaderValue) -> Result<Self, crate::error...
    method is_inline (line 431) | pub fn is_inline(&self) -> bool {
    method is_attachment (line 436) | pub fn is_attachment(&self) -> bool {
    method is_form_data (line 441) | pub fn is_form_data(&self) -> bool {
    method is_ext (line 446) | pub fn is_ext(&self, disp_type: impl AsRef<str>) -> bool {
    method get_name (line 454) | pub fn get_name(&self) -> Option<&str> {
    method get_filename (line 459) | pub fn get_filename(&self) -> Option<&str> {
    method get_filename_ext (line 466) | pub fn get_filename_ext(&self) -> Option<&ExtendedValue> {
    method get_unknown (line 473) | pub fn get_unknown(&self, name: impl AsRef<str>) -> Option<&str> {
    method get_unknown_ext (line 479) | pub fn get_unknown_ext(&self, name: impl AsRef<str>) -> Option<&Extend...
    method fmt (line 586) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  type Error (line 486) | type Error = header::InvalidHeaderValue;
  method try_into_value (line 488) | fn try_into_value(self) -> Result<header::HeaderValue, Self::Error> {
  method name (line 496) | fn name() -> header::HeaderName {
  method parse (line 500) | fn parse<T: crate::HttpMessage>(msg: &T) -> Result<Self, crate::error::P...
  function test_from_raw_basic (line 600) | fn test_from_raw_basic() {
  function test_from_raw_extended (line 647) | fn test_from_raw_extended() {
  function test_from_raw_extra_whitespace (line 684) | fn test_from_raw_extra_whitespace() {
  function test_from_raw_unordered (line 701) | fn test_from_raw_unordered() {
  function test_from_raw_only_disp (line 737) | fn test_from_raw_only_disp() {
  function from_raw_with_mixed_case (line 762) | fn from_raw_with_mixed_case() {
  function from_raw_with_unicode (line 783) | fn from_raw_with_unicode() {
  function test_from_raw_escape (line 819) | fn test_from_raw_escape() {
  function test_from_raw_semicolon (line 840) | fn test_from_raw_semicolon() {
  function test_from_raw_unnecessary_percent_decode (line 853) | fn test_from_raw_unnecessary_percent_decode() {
  function test_from_raw_param_value_missing (line 890) | fn test_from_raw_param_value_missing() {
  function test_from_raw_param_name_missing (line 909) | fn test_from_raw_param_name_missing() {
  function test_display_extended (line 921) | fn test_display_extended() {
  function test_display_quote (line 938) | fn test_display_quote() {
  function test_display_space_tab (line 950) | fn test_display_space_tab() {
  function test_display_control_characters (line 966) | fn test_display_control_characters() {
  function test_param_methods (line 986) | fn test_param_methods() {
  function test_disposition_methods (line 997) | fn test_disposition_methods() {

FILE: actix-web/src/http/header/content_length.rs
  type ContentLength (line 42) | pub struct ContentLength(pub usize);
    method into_inner (line 46) | pub fn into_inner(&self) -> usize {
    type Err (line 52) | type Err = <usize as str::FromStr>::Err;
    method from_str (line 55) | fn from_str(val: &str) -> Result<Self, Self::Err> {
    method from (line 95) | fn from(len: usize) -> Self {
    method eq (line 101) | fn eq(&self, other: &usize) -> bool {
    method partial_cmp (line 113) | fn partial_cmp(&self, other: &usize) -> Option<std::cmp::Ordering> {
  type Error (line 66) | type Error = Infallible;
  method try_into_value (line 68) | fn try_into_value(self) -> Result<HeaderValue, Self::Error> {
  method name (line 74) | fn name() -> HeaderName {
  method parse (line 78) | fn parse<M: HttpMessage>(msg: &M) -> Result<Self, ParseError> {
  function from (line 89) | fn from(ContentLength(len): ContentLength) -> Self {
  function eq (line 107) | fn eq(&self, other: &ContentLength) -> bool {
  function partial_cmp (line 119) | fn partial_cmp(&self, other: &ContentLength) -> Option<std::cmp::Orderin...
  function req_from_raw_headers (line 131) | fn req_from_raw_headers<H: Header, I: IntoIterator<Item = V>, V: AsRef<[...
  function assert_parse_fail (line 143) | pub(crate) fn assert_parse_fail<
  function assert_parse_eq (line 155) | pub(crate) fn assert_parse_eq<
  function missing_header (line 168) | fn missing_header() {
  function bad_header (line 174) | fn bad_header() {
  function bad_header_plus (line 192) | fn bad_header_plus() {
  function bad_multiple_value (line 199) | fn bad_multiple_value() {
  function good_header (line 205) | fn good_header() {
  function equality (line 226) | fn equality() {
  function ordering (line 233) | fn ordering() {

FILE: actix-web/src/http/header/content_range.rs
  type ContentRangeSpec (line 94) | pub enum ContentRangeSpec {
  type Err (line 116) | type Err = ParseError;
  method from_str (line 118) | fn from_str(s: &str) -> Result<Self, ParseError> {
  method fmt (line 158) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  type Error (line 190) | type Error = InvalidHeaderValue;
  method try_into_value (line 192) | fn try_into_value(self) -> Result<HeaderValue, Self::Error> {

FILE: actix-web/src/http/header/content_type.rs
  method json (line 61) | pub fn json() -> ContentType {
  method plaintext (line 67) | pub fn plaintext() -> ContentType {
  method html (line 73) | pub fn html() -> ContentType {
  method xml (line 79) | pub fn xml() -> ContentType {
  method form_url_encoded (line 85) | pub fn form_url_encoded() -> ContentType {
  method jpeg (line 91) | pub fn jpeg() -> ContentType {
  method png (line 97) | pub fn png() -> ContentType {
  method octet_stream (line 103) | pub fn octet_stream() -> ContentType {

FILE: actix-web/src/http/header/date.rs
  method now (line 41) | pub fn now() -> Date {

FILE: actix-web/src/http/header/encoding.rs
  type Encoding (line 7) | pub enum Encoding {
    method identity (line 16) | pub const fn identity() -> Self {
    method brotli (line 20) | pub const fn brotli() -> Self {
    method deflate (line 24) | pub const fn deflate() -> Self {
    method gzip (line 28) | pub const fn gzip() -> Self {
    method zstd (line 32) | pub const fn zstd() -> Self {
    method fmt (line 38) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
    type Err (line 47) | type Err = crate::error::ParseError;
    method from_str (line 49) | fn from_str(enc: &str) -> Result<Self, crate::error::ParseError> {

FILE: actix-web/src/http/header/entity.rs
  function entity_validate_char (line 12) | fn entity_validate_char(c: u8) -> bool {
  function check_slice_validity (line 16) | fn check_slice_validity(slice: &str) -> bool {
  type EntityTag (line 53) | pub struct EntityTag {
    method new (line 66) | pub fn new(weak: bool, tag: String) -> EntityTag {
    method new_weak (line 75) | pub fn new_weak(tag: String) -> EntityTag {
    method weak (line 80) | pub fn weak(tag: String) -> EntityTag {
    method new_strong (line 88) | pub fn new_strong(tag: String) -> EntityTag {
    method strong (line 93) | pub fn strong(tag: String) -> EntityTag {
    method tag (line 98) | pub fn tag(&self) -> &str {
    method set_tag (line 106) | pub fn set_tag(&mut self, tag: impl Into<String>) {
    method strong_eq (line 114) | pub fn strong_eq(&self, other: &EntityTag) -> bool {
    method weak_eq (line 120) | pub fn weak_eq(&self, other: &EntityTag) -> bool {
    method strong_ne (line 125) | pub fn strong_ne(&self, other: &EntityTag) -> bool {
    method weak_ne (line 130) | pub fn weak_ne(&self, other: &EntityTag) -> bool {
  method fmt (line 136) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  type Err (line 146) | type Err = crate::error::ParseError;
  method from_str (line 148) | fn from_str(slice: &str) -> Result<EntityTag, crate::error::ParseError> {
  type Error (line 177) | type Error = InvalidHeaderValue;
  method try_into_value (line 179) | fn try_into_value(self) -> Result<HeaderValue, Self::Error> {
  function test_etag_parse_success (line 191) | fn test_etag_parse_success() {
  function test_etag_parse_failures (line 216) | fn test_etag_parse_failures() {
  function test_etag_fmt (line 229) | fn test_etag_fmt() {
  function test_cmp (line 247) | fn test_cmp() {

FILE: actix-web/src/http/header/if_none_match.rs
  function test_if_none_match (line 76) | fn test_if_none_match() {

FILE: actix-web/src/http/header/if_range.rs
  type IfRange (line 59) | pub enum IfRange {
  method name (line 68) | fn name() -> HeaderName {
  method parse (line 72) | fn parse<T>(msg: &T) -> Result<Self, ParseError>
  method fmt (line 89) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  type Error (line 98) | type Error = InvalidHeaderValue;
  method try_into_value (line 100) | fn try_into_value(self) -> Result<HeaderValue, Self::Error> {

FILE: actix-web/src/http/header/mod.rs
  type Writer (line 77) | struct Writer {
    method new (line 83) | pub fn new() -> Writer {
    method take (line 88) | pub fn take(&mut self) -> Bytes {
    method write_str (line 95) | fn write_str(&mut self, s: &str) -> fmt::Result {
    method write_fmt (line 101) | fn write_fmt(&mut self, args: fmt::Arguments<'_>) -> fmt::Result {

FILE: actix-web/src/http/header/preference.rs
  type Preference (line 14) | pub enum Preference<T> {
  function is_any (line 24) | pub fn is_any(&self) -> bool {
  function is_specific (line 29) | pub fn is_specific(&self) -> bool {
  function item (line 34) | pub fn item(&self) -> Option<&T> {
  function into_item (line 42) | pub fn into_item(self) -> Option<T> {
  function fmt (line 52) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  type Err (line 61) | type Err = T::Err;
  function from_str (line 64) | fn from_str(s: &str) -> Result<Self, Self::Err> {

FILE: actix-web/src/http/header/range.rs
  type Range (line 63) | pub enum Range {
    method bytes (line 172) | pub fn bytes(from: u64, to: u64) -> Range {
    method bytes_multi (line 179) | pub fn bytes_multi(ranges: Vec<(u64, u64)>) -> Range {
    method fmt (line 200) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  type ByteRangeSpec (line 77) | pub enum ByteRangeSpec {
    method to_satisfiable_range (line 128) | pub fn to_satisfiable_range(&self, full_length: u64) -> Option<(u64, u...
    method fmt (line 190) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  type Err (line 223) | type Err = ParseError;
  method from_str (line 225) | fn from_str(s: &str) -> Result<Range, ParseError> {
  type Err (line 248) | type Err = ParseError;
  method from_str (line 250) | fn from_str(s: &str) -> Result<ByteRangeSpec, ParseError> {
  method name (line 273) | fn name() -> HeaderName {
  method parse (line 278) | fn parse<T: HttpMessage>(msg: &T) -> Result<Self, ParseError> {
  type Error (line 284) | type Error = InvalidHeaderValue;
  method try_into_value (line 286) | fn try_into_value(self) -> Result<HeaderValue, Self::Error> {
  function from_comma_delimited (line 294) | fn from_comma_delimited<T: FromStr>(s: &str) -> Vec<T> {
  function req (line 310) | fn req(s: &str) -> Request {
  function test_parse_bytes_range_valid (line 317) | fn test_parse_bytes_range_valid() {
  function test_parse_unregistered_range_valid (line 348) | fn test_parse_unregistered_range_valid() {
  function test_parse_invalid (line 363) | fn test_parse_invalid() {
  function test_fmt (line 387) | fn test_fmt() {
  function test_byte_range_spec_to_satisfiable_range (line 404) | fn test_byte_range_spec_to_satisfiable_range() {

FILE: actix-web/src/info.rs
  function unquote (line 20) | fn unquote(val: &str) -> &str {
  function bare_address (line 25) | fn bare_address(val: &str) -> &str {
  function first_header_value (line 39) | fn first_header_value<'a>(req: &'a RequestHead, name: &'_ HeaderName) ->...
  type ConnectionInfo (line 77) | pub struct ConnectionInfo {
    method new (line 85) | pub(crate) fn new(req: &RequestHead, cfg: &AppConfig) -> ConnectionInfo {
    method realip_remote_addr (line 168) | pub fn realip_remote_addr(&self) -> Option<&str> {
    method peer_addr (line 178) | pub fn peer_addr(&self) -> Option<&str> {
    method host (line 191) | pub fn host(&self) -> &str {
    method scheme (line 202) | pub fn scheme(&self) -> &str {
    method remote_addr (line 208) | pub fn remote_addr(&self) -> Option<&str> {
  type Error (line 214) | type Error = Infallible;
  type Future (line 215) | type Future = Ready<Result<Self, Self::Error>>;
  method from_request (line 217) | fn from_request(req: &HttpRequest, _: &mut Payload) -> Self::Future {
  type PeerAddr (line 239) | pub struct PeerAddr(pub SocketAddr);
    method into_inner (line 243) | pub fn into_inner(self) -> SocketAddr {
  type MissingPeerAddr (line 251) | pub struct MissingPeerAddr;
  type Error (line 256) | type Error = MissingPeerAddr;
  type Future (line 257) | type Future = Ready<Result<Self, Self::Error>>;
  method from_request (line 259) | fn from_request(req: &HttpRequest, _: &mut Payload) -> Self::Future {
  constant X_FORWARDED_FOR (line 275) | const X_FORWARDED_FOR: &str = "x-forwarded-for";
  constant X_FORWARDED_HOST (line 276) | const X_FORWARDED_HOST: &str = "x-forwarded-host";
  constant X_FORWARDED_PROTO (line 277) | const X_FORWARDED_PROTO: &str = "x-forwarded-proto";
  function info_default (line 280) | fn info_default() {
  function host_header (line 288) | fn host_header() {
  function x_forwarded_for_header (line 300) | fn x_forwarded_for_header() {
  function x_forwarded_host_header (line 309) | fn x_forwarded_host_header() {
  function x_forwarded_proto_header (line 319) | fn x_forwarded_proto_header() {
  function forwarded_header (line 328) | fn forwarded_header() {
  function forwarded_case_sensitivity (line 355) | fn forwarded_case_sensitivity() {
  function forwarded_weird_whitespace (line 364) | fn forwarded_weird_whitespace() {
  function forwarded_for_quoted (line 380) | fn forwarded_for_quoted() {
  function forwarded_for_ipv6 (line 389) | fn forwarded_for_ipv6() {
  function forwarded_for_ipv6_with_port (line 398) | fn forwarded_for_ipv6_with_port() {
  function forwarded_for_multiple (line 407) | fn forwarded_for_multiple() {
  function scheme_from_uri (line 417) | fn scheme_from_uri() {
  function host_from_uri (line 426) | fn host_from_uri() {
  function host_from_server_hostname (line 435) | fn host_from_server_hostname() {
  function conn_info_extract (line 445) | async fn conn_info_extract() {
  function peer_addr_extract (line 455) | async fn peer_addr_extract() {
  function remote_address (line 467) | async fn remote_address() {
  function real_ip_from_socket_addr (line 479) | async fn real_ip_from_socket_addr() {

FILE: actix-web/src/introspection.rs
  type RouteDetail (line 37) | struct RouteDetail {
  type RouteInfo (line 48) | pub(crate) struct RouteInfo {
    method new (line 58) | pub(crate) fn new(
  type GuardReport (line 79) | pub struct GuardReport {
  type GuardDetailReport (line 88) | pub enum GuardDetailReport {
    method from (line 548) | fn from(detail: GuardDetail) -> Self {
  type HeaderReport (line 96) | pub struct HeaderReport {
  type ExternalResourceReportItem (line 107) | pub struct ExternalResourceReportItem {
  type RegistrationKind (line 115) | enum RegistrationKind {
  type Registration (line 121) | struct Registration {
  type ShadowingContext (line 133) | struct ShadowingContext {
  type ResourceType (line 141) | pub enum ResourceType {
  function resource_type_label (line 150) | fn resource_type_label(kind: ResourceType) -> &'static str {
  type IntrospectionNode (line 161) | pub struct IntrospectionNode {
    method new (line 230) | pub fn new(kind: ResourceType, pattern: String, full_path: String) -> ...
  type IntrospectionReportItem (line 189) | pub struct IntrospectionReportItem {
  function from (line 248) | fn from(node: &IntrospectionNode) -> Self {
  type IntrospectionCollector (line 294) | pub(crate) struct IntrospectionCollector {
    method new (line 304) | pub(crate) fn new() -> Self {
    method next_scope_id (line 314) | pub(crate) fn next_scope_id(&mut self) -> usize {
    method register_service (line 320) | pub(crate) fn register_service(
    method register_route (line 345) | pub(crate) fn register_route(&mut self, info: RouteInfo, scope_id: Opt...
    method register_external (line 363) | pub(crate) fn register_external(&mut self, rdef: &ResourceDef, origin_...
    method register_pattern_detail (line 383) | fn register_pattern_detail(&mut self, full_path: &str, info: &RouteInf...
    method finalize (line 411) | pub(crate) fn finalize(&mut self) -> IntrospectionTree {
  type IntrospectionTree (line 472) | pub struct IntrospectionTree {
    method report_as_text (line 481) | pub fn report_as_text(&self) -> String {
    method report_as_json (line 513) | pub fn report_as_json(&self) -> String {
    method report_externals_as_json (line 520) | pub fn report_externals_as_json(&self) -> String {
  function guard_reports_from_iter (line 526) | pub(crate) fn guard_reports_from_iter<'a, I>(guards: I) -> Vec<GuardReport>
  function external_report_from_rdef (line 562) | pub(crate) fn external_report_from_rdef(
  function expand_patterns (line 576) | pub(crate) fn expand_patterns(prefix: &str, rdef: &ResourceDef) -> Vec<S...
  function analyze_reachability (line 596) | fn analyze_reachability(registrations: &[Registration]) -> BTreeMap<Stri...
  function shadowed_scope_context (line 639) | fn shadowed_scope_context(registrations: &[Registration]) -> BTreeMap<us...
  function shadowed_route_context (line 690) | fn shadowed_route_context(
  function apply_reachability (line 755) | fn apply_reachability(root: &mut IntrospectionNode, notes: &BTreeMap<Str...
  function normalize_path (line 770) | fn normalize_path(path: &str) -> String {
  function split_path_segments (line 785) | fn split_path_segments(path: &str) -> Vec<&str> {
  function matches_all (line 795) | fn matches_all(methods: &[Method], guards: &[String]) -> bool {
  function guards_only_methods (line 799) | fn guards_only_methods(guards: &[String], methods: &[Method]) -> bool {
  function has_conflicting_methods (line 803) | fn has_conflicting_methods(methods: &[Method], guards: &[String]) -> bool {
  function method_set (line 922) | fn method_set(methods: &[Method]) -> BTreeSet<String> {
  function filter_guard_names (line 926) | fn filter_guard_names(guards: &[String], methods: &[Method]) -> Vec<Stri...
  function merge_guard_reports (line 935) | fn merge_guard_reports(existing: &mut Vec<GuardReport>, incoming: &[Guar...
  function merge_guard_detail_reports (line 947) | fn merge_guard_detail_reports(existing: &mut Vec<GuardDetailReport>, inc...
  function update_unique (line 984) | fn update_unique<T: Clone + PartialEq>(existing: &mut Vec<T>, new_items:...
  function is_false (line 992) | fn is_false(value: &bool) -> bool {
  function format_reachability (line 996) | fn format_reachability(item: &IntrospectionReportItem) -> String {
  function sanitize_text (line 1013) | fn sanitize_text(value: &str) -> String {
  function warn_release_mode_once (line 1031) | fn warn_release_mode_once() {
  function route_info (line 1050) | fn route_info(
  function report_includes_resources_without_methods (line 1069) | fn report_includes_resources_without_methods() {
  function report_includes_guard_details_and_metadata (line 1096) | fn report_includes_guard_details_and_metadata() {
  function expand_patterns_handles_scope_paths (line 1134) | fn expand_patterns_handles_scope_paths() {
  function expand_patterns_handles_multi_patterns (line 1145) | fn expand_patterns_handles_multi_patterns() {
  function conflicting_method_guards_mark_unreachable (line 1151) | fn conflicting_method_guards_mark_unreachable() {
  function allguard_anyguard_does_not_mark_conflict_when_methods_are_feasible (line 1177) | fn allguard_anyguard_does_not_mark_conflict_when_methods_are_feasible() {
  function allguard_anyguard_marks_conflict_when_methods_are_impossible (line 1206) | fn allguard_anyguard_marks_conflict_when_methods_are_impossible() {
  function shadowed_scopes_mark_routes (line 1232) | fn shadowed_scopes_mark_routes() {
  function shadowed_routes_include_context (line 1296) | fn shadowed_routes_include_context() {

FILE: actix-web/src/lib.rs
  type BoxError (line 160) | pub(crate) type BoxError = Box<dyn std::error::Error>;

FILE: actix-web/src/middleware/compat.rs
  type Compat (line 37) | pub struct Compat<T> {
  function new (line 43) | pub fn new(middleware: T) -> Self {
  type Response (line 58) | type Response = ServiceResponse<BoxBody>;
  type Error (line 59) | type Error = Error;
  type Transform (line 60) | type Transform = CompatMiddleware<T::Transform>;
  type InitError (line 61) | type InitError = T::InitError;
  type Future (line 62) | type Future = LocalBoxFuture<'static, Result<Self::Transform, Self::Init...
    type Output (line 108) | type Output = Result<ServiceResponse<BoxBody>, Error>;
    method poll (line 110) | fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Outp...
  function new_transform (line 64) | fn new_transform(&self, service: S) -> Self::Future {
  type CompatMiddleware (line 73) | pub struct CompatMiddleware<S> {
  type Response (line 83) | type Response = ServiceResponse<BoxBody>;
  type Error (line 84) | type Error = Error;
  type Future (line 85) | type Future = CompatMiddlewareFuture<S::Future>;
    type Output (line 108) | type Output = Result<ServiceResponse<BoxBody>, Error>;
    method poll (line 110) | fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Outp...
  function call (line 89) | fn call(&self, req: Req) -> Self::Future {
  type MapServiceResponseBody (line 121) | pub trait MapServiceResponseBody {
    method map_body (line 122) | fn map_body(self) -> ServiceResponse<BoxBody>;
    method map_body (line 130) | fn map_body(self) -> ServiceResponse<BoxBody> {
  function test_scope_middleware (line 153) | async fn test_scope_middleware() {
  function test_resource_scope_middleware (line 176) | async fn test_resource_scope_middleware() {
  function test_condition_scope_middleware (line 198) | async fn test_condition_scope_middleware() {
  function compat_noop_is_noop (line 216) | async fn compat_noop_is_noop() {

FILE: actix-web/src/middleware/compress.rs
  type Compress (line 77) | pub struct Compress;
    type Response (line 84) | type Response = ServiceResponse<EitherBody<Encoder<B>>>;
    type Error (line 85) | type Error = Error;
    type Transform (line 86) | type Transform = CompressMiddleware<S>;
    type InitError (line 87) | type InitError = ();
    type Future (line 88) | type Future = Ready<Result<Self::Transform, Self::InitError>>;
    method new_transform (line 90) | fn new_transform(&self, service: S) -> Self::Future {
  type CompressMiddleware (line 95) | pub struct CompressMiddleware<S> {
  type Response (line 104) | type Response = ServiceResponse<EitherBody<Encoder<B>>>;
  type Error (line 105) | type Error = Error;
  type Future (line 107) | type Future = Either<CompressResponse<S, B>, Ready<Result<Self::Response...
    type Output (line 172) | type Output = Result<ServiceResponse<EitherBody<Encoder<B>>>, Error>;
    method poll (line 174) | fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::...
  function call (line 112) | fn call(&self, req: ServiceRequest) -> Self::Future {
  constant HTML_DATA_PART (line 278) | const HTML_DATA_PART: &str = "<html><h1>hello world</h1></html";
  constant HTML_DATA (line 279) | const HTML_DATA: &str = const_str::repeat!(HTML_DATA_PART, 100);
  constant TEXT_DATA_PART (line 281) | const TEXT_DATA_PART: &str = "hello world ";
  constant TEXT_DATA (line 282) | const TEXT_DATA: &str = const_str::repeat!(TEXT_DATA_PART, 100);
  function gzip_decode (line 286) | pub fn gzip_decode(bytes: impl AsRef<[u8]>) -> Vec<u8> {
  function assert_successful_res_with_content_type (line 295) | fn assert_successful_res_with_content_type<B>(res: &ServiceResponse<B>, ...
  function assert_successful_gzip_res_with_content_type (line 310) | fn assert_successful_gzip_res_with_content_type<B>(res: &ServiceResponse...
  function assert_successful_identity_res_with_content_type (line 321) | fn assert_successful_identity_res_with_content_type<B>(res: &ServiceResp...
  function prevents_double_compressing (line 330) | async fn prevents_double_compressing() {
  function retains_previously_set_vary_header (line 371) | async fn retains_previously_set_vary_header() {
  function configure_predicate_test (line 394) | fn configure_predicate_test(cfg: &mut web::ServiceConfig) {
  function prevents_compression_jpeg (line 414) | async fn prevents_compression_jpeg() {
  function prevents_compression_empty (line 436) | async fn prevents_compression_empty() {
  function skips_compression_partial_content (line 454) | async fn skips_compression_partial_content() {
  function prevents_compression_empty (line 484) | async fn prevents_compression_empty() {

FILE: actix-web/src/middleware/condition.rs
  type Condition (line 29) | pub struct Condition<T> {
  function new (line 35) | pub fn new(enable: bool, transformer: T) -> Self {
  type Response (line 51) | type Response = ServiceResponse<EitherBody<BE, BD>>;
  type Error (line 52) | type Error = Err;
  type Transform (line 53) | type Transform = ConditionMiddleware<T::Transform, S>;
  type InitError (line 54) | type InitError = T::InitError;
  type Future (line 55) | type Future = LocalBoxFuture<'static, Result<Self::Transform, Self::Init...
    type Output (line 118) | type Output = Result<ServiceResponse<EitherBody<BE, BD>>, Err>;
    method poll (line 121) | fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Outp...
  function new_transform (line 57) | fn new_transform(&self, service: S) -> Self::Future {
  type ConditionMiddleware (line 71) | pub enum ConditionMiddleware<E, D> {
  type Response (line 81) | type Response = ServiceResponse<EitherBody<BE, BD>>;
  type Error (line 82) | type Error = Err;
  type Future (line 83) | type Future = ConditionMiddlewareFuture<E::Future, D::Future>;
    type Output (line 118) | type Output = Result<ServiceResponse<EitherBody<BE, BD>>, Err>;
    method poll (line 121) | fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Outp...
  function poll_ready (line 85) | fn poll_ready(&self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Erro...
  function call (line 92) | fn call(&self, req: Req) -> Self::Future {
  function render_500 (line 151) | fn render_500<B>(mut res: ServiceResponse<B>) -> Result<ErrorHandlerResp...
  function compat_with_builtin_middleware (line 160) | fn compat_with_builtin_middleware() {
  function test_handler_enabled (line 171) | async fn test_handler_enabled() {
  function test_handler_disabled (line 190) | async fn test_handler_disabled() {

FILE: actix-web/src/middleware/default_headers.rs
  type DefaultHeaders (line 40) | pub struct DefaultHeaders {
    method new (line 52) | pub fn new() -> DefaultHeaders {
    method add (line 61) | pub fn add(mut self, header: impl TryIntoHeaderPair) -> Self {
    method header (line 81) | pub fn header<K, V>(self, key: K, value: V) -> Self
    method add_content_type (line 101) | pub fn add_content_type(self) -> Self {
    type Response (line 113) | type Response = ServiceResponse<B>;
    type Error (line 114) | type Error = Error;
    type Transform (line 115) | type Transform = DefaultHeadersMiddleware<S>;
    type InitError (line 116) | type InitError = ();
    type Future (line 117) | type Future = Ready<Result<Self::Transform, Self::InitError>>;
    method new_transform (line 119) | fn new_transform(&self, service: S) -> Self::Future {
  type Inner (line 45) | struct Inner {
  type DefaultHeadersMiddleware (line 127) | pub struct DefaultHeadersMiddleware<S> {
  type Response (line 137) | type Response = ServiceResponse<B>;
  type Error (line 138) | type Error = Error;
  type Future (line 139) | type Future = DefaultHeaderFuture<S, B>;
    type Output (line 168) | type Output = <S::Future as Future>::Output;
    method poll (line 171) | fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Outp...
  function call (line 143) | fn call(&self, req: ServiceRequest) -> Self::Future {
  function adding_default_headers (line 198) | async fn adding_default_headers() {
  function no_override_existing (line 213) | async fn no_override_existing() {
  function adding_content_type (line 232) | async fn adding_content_type() {
  function invalid_header_name (line 249) | fn invalid_header_name() {
  function invalid_header_value (line 255) | fn invalid_header_value() {

FILE: actix-web/src/middleware/err_handlers.rs
  type ErrorHandlerResponse (line 23) | pub enum ErrorHandlerResponse<B> {
  type ErrorHandler (line 31) | type ErrorHandler<B> = dyn Fn(ServiceResponse<B>) -> Result<ErrorHandler...
  type DefaultHandler (line 33) | type DefaultHandler<B> = Option<Rc<ErrorHandler<B>>>;
  type ErrorHandlers (line 182) | pub struct ErrorHandlers<B> {
  type Handlers (line 188) | type Handlers<B> = Rc<FoldHashMap<StatusCode, Box<ErrorHandler<B>>>>;
  method default (line 191) | fn default() -> Self {
  function new (line 202) | pub fn new() -> Self {
  function handler (line 207) | pub fn handler<F>(mut self, status: StatusCode, handler: F) -> Self
  function default_handler (line 229) | pub fn default_handler<F>(self, handler: F) -> Self
  function default_handler_client (line 243) | pub fn default_handler_client<F>(self, handler: F) -> Self
  function default_handler_server (line 254) | pub fn default_handler_server<F>(self, handler: F) -> Self
  function get_handler (line 268) | fn get_handler<'a>(
  type Response (line 288) | type Response = ServiceResponse<EitherBody<B>>;
  type Error (line 289) | type Error = Error;
  type Transform (line 290) | type Transform = ErrorHandlersMiddleware<S, B>;
  type InitError (line 291) | type InitError = ();
  type Future (line 292) | type Future = LocalBoxFuture<'static, Result<Self::Transform, Self::Init...
    type Output (line 366) | type Output = Result<ServiceResponse<EitherBody<B>>, Error>;
    method poll (line 368) | fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::...
  function new_transform (line 294) | fn new_transform(&self, service: S) -> Self::Future {
  type ErrorHandlersMiddleware (line 310) | pub struct ErrorHandlersMiddleware<S, B> {
  type Response (line 323) | type Response = ServiceResponse<EitherBody<B>>;
  type Error (line 324) | type Error = Error;
  type Future (line 325) | type Future = ErrorHandlersFuture<S::Future, B>;
    type Output (line 366) | type Output = Result<ServiceResponse<EitherBody<B>>, Error>;
    method poll (line 368) | fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::...
  function call (line 329) | fn call(&self, req: ServiceRequest) -> Self::Future {
  function add_header_error_handler (line 419) | async fn add_header_error_handler() {
  function add_header_error_handler_async (line 442) | async fn add_header_error_handler_async() {
  function changes_body_type (line 469) | async fn changes_body_type() {
  function error_thrown (line 495) | async fn error_thrown() {
  function default_error_handler (line 525) | async fn default_error_handler() {
  function default_handlers_separate_client_server (line 552) | async fn default_handlers_separate_client_server() {
  function default_handlers_specialization (line 588) | async fn default_handlers_specialization() {

FILE: actix-web/src/middleware/from_fn.rs
  function from_fn (line 83) | pub fn from_fn<F, Es>(mw_fn: F) -> MiddlewareFn<F, Es> {
  type MiddlewareFn (line 92) | pub struct MiddlewareFn<F, Es> {
  type Response (line 104) | type Response = ServiceResponse<B2>;
  type Error (line 105) | type Error = Error;
  type Transform (line 106) | type Transform = MiddlewareFnService<F, B, ()>;
  type InitError (line 107) | type InitError = ();
  type Future (line 108) | type Future = Ready<Result<Self::Transform, Self::InitError>>;
  function new_transform (line 110) | fn new_transform(&self, service: S) -> Self::Future {
  type MiddlewareFnService (line 121) | pub struct MiddlewareFnService<F, B, Es> {
  type Response (line 133) | type Response = ServiceResponse<B2>;
  type Error (line 134) | type Error = Error;
  type Future (line 135) | type Future = Fut;
  function call (line 139) | fn call(&self, req: ServiceRequest) -> Self::Future {
  type Next (line 220) | pub struct Next<B> {
  function call (line 226) | pub fn call(&self, req: ServiceRequest) -> <Self as Service<ServiceReque...
  type Response (line 232) | type Response = ServiceResponse<B>;
  type Error (line 233) | type Error = Error;
  type Future (line 234) | type Future = BoxFuture<Result<Self::Response, Self::Error>>;
  function call (line 238) | fn call(&self, req: ServiceRequest) -> Self::Future {
  function noop (line 252) | async fn noop<B>(req: ServiceRequest, next: Next<B>) -> Result<ServiceRe...
  function add_res_header (line 256) | async fn add_res_header<B>(
  function mutate_body_type (line 266) | async fn mutate_body_type(
  type MyMw (line 274) | struct MyMw(bool);
    method mw_cb (line 277) | async fn mw_cb(
    method into_middleware (line 291) | pub fn into_middleware<S, B>(
  function compat_compat (line 313) | async fn compat_compat() {
  function permits_different_in_and_out_body_types (line 319) | async fn permits_different_in_and_out_body_types() {
  function closure_capture_and_return_from_fn (line 336) | async fn closure_capture_and_return_from_fn() {

FILE: actix-web/src/middleware/identity.rs
  type Identity (line 10) | pub struct Identity;
    type Response (line 13) | type Response = S::Response;
    type Error (line 14) | type Error = S::Error;
    type Transform (line 15) | type Transform = IdentityMiddleware<S>;
    type InitError (line 16) | type InitError = ();
    type Future (line 17) | type Future = Ready<Result<Self::Transform, Self::InitError>>;
    method new_transform (line 20) | fn new_transform(&self, service: S) -> Self::Future {
  type IdentityMiddleware (line 26) | pub struct IdentityMiddleware<S> {
  type Response (line 31) | type Response = S::Response;
  type Error (line 32) | type Error = S::Error;
  type Future (line 33) | type Future = S::Future;
  function call (line 38) | fn call(&self, req: Req) -> Self::Future {

FILE: actix-web/src/middleware/logger.rs
  type Logger (line 87) | pub struct Logger(Rc<Inner>);
    method new (line 100) | pub fn new(format: &str) -> Logger {
    method exclude (line 111) | pub fn exclude<T: Into<String>>(mut self, path: T) -> Self {
    method exclude_regex (line 120) | pub fn exclude_regex<T: Into<String>>(mut self, path: T) -> Self {
    method log_target (line 138) | pub fn log_target(mut self, target: impl Into<Cow<'static, str>>) -> S...
    method log_level (line 155) | pub fn log_level(mut self, level: log::Level) -> Self {
    method custom_request_replace (line 175) | pub fn custom_request_replace(
    method custom_response_replace (line 226) | pub fn custom_response_replace(
    type Response (line 274) | type Response = ServiceResponse<StreamLog<B>>;
    type Error (line 275) | type Error = Error;
    type Transform (line 276) | type Transform = LoggerMiddleware<S>;
    type InitError (line 277) | type InitError = ();
    type Future (line 278) | type Future = Ready<Result<Self::Transform, Self::InitError>>;
    method new_transform (line 280) | fn new_transform(&self, service: S) -> Self::Future {
  type Inner (line 90) | struct Inner {
  method default (line 258) | fn default() -> Logger {
  type LoggerMiddleware (line 305) | pub struct LoggerMiddleware<S> {
  type Response (line 315) | type Response = ServiceResponse<StreamLog<B>>;
  type Error (line 316) | type Error = Error;
  type Future (line 317) | type Future = LoggerResponse<S, B>;
    type Output (line 379) | type Output = Result<ServiceResponse<StreamLog<B>>, Error>;
    method poll (line 381) | fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Outp...
  function call (line 321) | fn call(&self, req: ServiceRequest) -> Self::Future {
  type Error (line 461) | type Error = B::Error;
  method size (line 464) | fn size(&self) -> BodySize {
  method poll_next (line 468) | fn poll_next(
  type Format (line 487) | struct Format(Vec<FormatText>);
    method new (line 500) | pub fn new(s: &str) -> Format {
  method default (line 491) | fn default() -> Format {
  type FormatText (line 559) | enum FormatText {
    method render (line 613) | fn render(
    method render_response (line 644) | fn render_response(&mut self, res: &ServiceResponse) {
    method render_request (line 672) | fn render_request(&mut self, now: OffsetDateTime, req: &ServiceRequest) {
  type CustomRequestFn (line 579) | struct CustomRequestFn {
    method call (line 584) | fn call(&self, req: &ServiceRequest) -> String {
    method fmt (line 590) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  type CustomResponseFn (line 596) | struct CustomResponseFn {
    method call (line 601) | fn call(&self, res: &ServiceResponse) -> String {
    method fmt (line 607) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  type FormatDisplay (line 732) | pub(crate) struct FormatDisplay<'a>(&'a dyn Fn(&mut fmt::Formatter<'_>) ...
  function fmt (line 735) | fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> Result<(), fmt::Error> {
  function test_logger (line 753) | async fn test_logger() {
  function test_logger_exclude_regex (line 775) | async fn test_logger_exclude_regex() {
  function test_escape_percent (line 798) | async fn test_escape_percent() {
  function test_url_path (line 831) | async fn test_url_path() {
  function test_default_format (line 863) | async fn test_default_format() {
  function test_request_time_format (line 900) | async fn test_request_time_format() {
  function test_remote_addr_format (line 926) | async fn test_remote_addr_format() {
  function test_custom_closure_req_log (line 959) | async fn test_custom_closure_req_log() {
  function test_custom_closure_response_log (line 985) | async fn test_custom_closure_response_log() {
  function test_closure_logger_in_middleware (line 1017) | async fn test_closure_logger_in_middleware() {

FILE: actix-web/src/middleware/mod.rs
  function common_combinations (line 275) | fn common_combinations() {

FILE: actix-web/src/middleware/normalize.rs
  function build_byte_index_map (line 18) | fn build_byte_index_map(old_path: &str, new_path: &str) -> Vec<u16> {
  type TrailingSlash (line 45) | pub enum TrailingSlash {
  type NormalizePath (line 110) | pub struct NormalizePath(TrailingSlash);
    method new (line 125) | pub fn new(trailing_slash_style: TrailingSlash) -> Self {
    method trim (line 132) | pub fn trim() -> Self {
    type Response (line 142) | type Response = ServiceResponse<B>;
    type Error (line 143) | type Error = Error;
    type Transform (line 144) | type Transform = NormalizePathNormalization<S>;
    type InitError (line 145) | type InitError = ();
    type Future (line 146) | type Future = Ready<Result<Self::Transform, Self::InitError>>;
    method new_transform (line 148) | fn new_transform(&self, service: S) -> Self::Future {
  method default (line 113) | fn default() -> Self {
  type NormalizePathNormalization (line 157) | pub struct NormalizePathNormalization<S> {
  type Response (line 168) | type Response = ServiceResponse<B>;
  type Error (line 169) | type Error = Error;
  type Future (line 170) | type Future = S::Future;
  function call (line 174) | fn call(&self, mut req: ServiceRequest) -> Self::Future {
  function test_wrap (line 245) | async fn test_wrap() {
  function trim_trailing_slashes (line 281) | async fn trim_trailing_slashes() {
  function trim_root_trailing_slashes_with_query (line 318) | async fn trim_root_trailing_slashes_with_query() {
  function ensure_trailing_slash (line 338) | async fn ensure_trailing_slash() {
  function ensure_root_trailing_slash_with_query (line 375) | async fn ensure_root_trailing_slash_with_query() {
  function keep_trailing_slash_unchanged (line 397) | async fn keep_trailing_slash_unchanged() {
  function scope_dynamic_tail_path_is_reindexed (line 438) | async fn scope_dynamic_tail_path_is_reindexed() {
  function scope_static_prefix_skip_is_reindexed (line 460) | async fn scope_static_prefix_skip_is_reindexed() {
  function no_path (line 477) | async fn no_path() {
  function test_in_place_normalization (line 493) | async fn test_in_place_normalization() {
  function should_normalize_nothing (line 519) | async fn should_normalize_nothing() {
  function should_normalize_no_trail (line 538) | async fn should_normalize_no_trail() {

FILE: actix-web/src/redirect.rs
  type Redirect (line 45) | pub struct Redirect {
    method new (line 73) | pub fn new(from: impl Into<Cow<'static, str>>, to: impl Into<Cow<'stat...
    method to (line 95) | pub fn to(to: impl Into<Cow<'static, str>>) -> Self {
    method permanent (line 108) | pub fn permanent(self) -> Self {
    method temporary (line 117) | pub fn temporary(self) -> Self {
    method see_other (line 124) | pub fn see_other(self) -> Self {
    method using_status_code (line 144) | pub fn using_status_code(mut self, status: StatusCode) -> Self {
  method register (line 151) | fn register(self, config: &mut AppService) {
  type Body (line 164) | type Body = ();
  method respond_to (line 166) | fn respond_to(self, _req: &HttpRequest) -> HttpResponse<Self::Body> {
  function absolute_redirects (line 188) | async fn absolute_redirects() {
  function relative_redirects (line 201) | async fn relative_redirects() {
  function temporary_redirects (line 214) | async fn temporary_redirects() {
  function as_responder (line 227) | async fn as_responder() {

FILE: actix-web/src/request.rs
  type Cookies (line 30) | struct Cookies(Vec<Cookie<'static>>);
  type HttpRequest (line 34) | pub struct HttpRequest {
    method new (line 55) | pub(crate) fn new(
    method head (line 84) | pub fn head(&self) -> &RequestHead {
    method head_mut (line 91) | pub(crate) fn head_mut(&mut self) -> &mut RequestHead {
    method uri (line 97) | pub fn uri(&self) -> &Uri {
    method full_url (line 117) | pub fn full_url(&self) -> url::Url {
    method method (line 132) | pub fn method(&self) -> &Method {
    method version (line 138) | pub fn version(&self) -> Version {
    method headers (line 144) | pub fn headers(&self) -> &HeaderMap {
    method path (line 150) | pub fn path(&self) -> &str {
    method query_string (line 158) | pub fn query_string(&self) -> &str {
    method match_info (line 174) | pub fn match_info(&self) -> &Path<Url> {
    method match_info_mut (line 183) | pub(crate) fn match_info_mut(&mut self) -> &mut Path<Url> {
    method push_resource_id (line 188) | pub(crate) fn push_resource_id(&mut self, id: u16) {
    method mark_resource_path (line 193) | pub(crate) fn mark_resource_path(&mut self, is_matched: bool) {
    method resource_path (line 198) | pub(crate) fn resource_path(&self) -> &[u16] {
    method is_resource_path_matched (line 203) | pub(crate) fn is_resource_path_matched(&self) -> bool {
    method match_pattern (line 214) | pub fn match_pattern(&self) -> Option<String> {
    method match_name (line 231) | pub fn match_name(&self) -> Option<&str> {
    method conn_data (line 251) | pub fn conn_data<T: 'static>(&self) -> Option<&T> {
    method url_for (line 282) | pub fn url_for<U, I>(&self, name: &str, elements: U) -> Result<url::Ur...
    method url_for_map (line 313) | pub fn url_for_map<K, V, S>(
    method url_for_iter (line 347) | pub fn url_for_iter<K, V, I>(
    method url_for_static (line 364) | pub fn url_for_static(&self, name: &str) -> Result<url::Url, UrlGenera...
    method resource_map (line 371) | pub fn resource_map(&self) -> &ResourceMap {
    method peer_addr (line 389) | pub fn peer_addr(&self) -> Option<net::SocketAddr> {
    method connection_info (line 400) | pub fn connection_info(&self) -> Ref<'_, ConnectionInfo> {
    method app_config (line 411) | pub fn app_config(&self) -> &AppConfig {
    method app_data (line 443) | pub fn app_data<T: 'static>(&self) -> Option<&T> {
    method app_state (line 454) | fn app_state(&self) -> &AppInitServiceState {
    method cookies (line 463) | pub fn cookies(&self) -> Result<Ref<'_, Vec<Cookie<'static>>>, CookieP...
    method cookie (line 486) | pub fn cookie(&self, name: &str) -> Option<Cookie<'static>> {
    method fmt (line 579) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  type HttpRequestInner (line 42) | pub(crate) struct HttpRequestInner {
  type Stream (line 499) | type Stream = ();
  method headers (line 502) | fn headers(&self) -> &HeaderMap {
  method extensions (line 507) | fn extensions(&self) -> Ref<'_, Extensions> {
  method extensions_mut (line 512) | fn extensions_mut(&self) -> RefMut<'_, Extensions> {
  method take_payload (line 517) | fn take_payload(&mut self) -> Payload<Self::Stream> {
  method drop (line 523) | fn drop(&mut self) {
  type Error (line 569) | type Error = Error;
  type Future (line 570) | type Future = Ready<Result<Self, Error>>;
  method from_request (line 573) | fn from_request(req: &HttpRequest, _: &mut Payload) -> Self::Future {
  type HttpRequestPool (line 623) | pub(crate) struct HttpRequestPool {
    method with_capacity (line 635) | pub(crate) fn with_capacity(cap: usize) -> Self {
    method pop (line 644) | pub(crate) fn pop(&self) -> Option<HttpRequest> {
    method is_available (line 653) | pub(crate) fn is_available(&self) -> bool {
    method push (line 659) | pub(crate) fn push(&self, req: Rc<HttpRequestInner>) {
    method clear (line 664) | pub(crate) fn clear(&self) {
  method default (line 629) | fn default() -> Self {
  function test_debug (line 685) | fn test_debug() {
  function test_no_request_cookies (line 695) | fn test_no_request_cookies() {
  function test_request_cookies (line 702) | fn test_request_cookies() {
  function test_empty_key (line 728) | fn test_empty_key() {
  function test_request_query (line 743) | fn test_request_query() {
  function test_url_for (line 749) | fn test_url_for() {
  function test_url_for_map (line 779) | fn test_url_for_map() {
  function test_url_for_iter (line 809) | fn test_url_for_iter() {
  function test_url_for_static (line 832) | fn test_url_for_static() {
  function test_match_name (line 853) | fn test_match_name() {
  function test_url_for_external (line 871) | fn test_url_for_external() {
  function test_drop_http_request_pool (line 888) | async fn test_drop_http_request_pool() {
  function test_data (line 907) | async fn test_data() {
  function test_cascading_data (line 940) | async fn test_cascading_data() {
  function test_overwrite_data (line 971) | async fn test_overwrite_data() {
  function test_app_data_dropped (line 1002) | async fn test_app_data_dropped() {
  function extract_path_pattern (line 1037) | async fn extract_path_pattern() {
  function extract_path_pattern_with_guards (line 1066) | async fn extract_path_pattern_with_guards() {
  function extract_path_pattern_complex (line 1104) | async fn extract_path_pattern_complex() {
  function url_for_closest_named_resource (line 1140) | async fn url_for_closest_named_resource() {
  function authorization_header_hidden_in_debug (line 1184) | fn authorization_header_hidden_in_debug() {
  function proxy_authorization_header_hidden_in_debug (line 1194) | fn proxy_authorization_header_hidden_in_debug() {
  function cookie_header_hidden_in_debug (line 1207) | fn cookie_header_hidden_in_debug() {
  function other_header_visible_in_debug (line 1217) | fn other_header_visible_in_debug() {
  function check_full_url (line 1227) | fn check_full_url() {

FILE: actix-web/src/request_data.rs
  type ReqData (line 50) | pub struct ReqData<T: Clone + 'static>(T);
  function into_inner (line 54) | pub fn into_inner(self) -> T {
  type Target (line 60) | type Target = T;
  method deref (line 62) | fn deref(&self) -> &T {
  type Error (line 68) | type Error = Error;
  type Future (line 69) | type Future = Ready<Result<Self, Error>>;
  method from_request (line 71) | fn from_request(req: &HttpRequest, _: &mut Payload) -> Self::Future {
  function req_data_extractor (line 103) | async fn req_data_extractor() {
  function req_data_internal_mutability (line 143) | async fn req_data_internal_mutability() {

FILE: actix-web/src/resource.rs
  type Resource (line 51) | pub struct Resource<T = ResourceEndpoint> {
    method new (line 64) | pub fn new<T: IntoPatterns>(path: T) -> Resource {
  function name (line 101) | pub fn name(mut self, name: &str) -> Self {
  function guard (line 127) | pub fn guard<G: Guard + 'static>(mut self, guard: G) -> Self {
  function add_guards (line 132) | pub(crate) fn add_guards(mut self, guards: Vec<Box<dyn Guard>>) -> Self {
  function route (line 168) | pub fn route(mut self, route: Route) -> Self {
  function app_data (line 206) | pub fn app_data<U: 'static>(mut self, data: U) -> Self {
  function data (line 218) | pub fn data<U: 'static>(self, data: U) -> Self {
  function to (line 241) | pub fn to<F, Args>(mut self, handler: F) -> Self
  function wrap (line 259) | pub fn wrap<M, B>(
  function wrap_fn (line 302) | pub fn wrap_fn<F, R, B>(
  function default_service (line 353) | pub fn default_service<F, U>(mut self, f: F) -> Self
  method register (line 419) | fn register(mut self, config: &mut AppService) {
  type ResourceFactory (line 518) | pub struct ResourceFactory {
    type Response (line 524) | type Response = ServiceResponse;
    type Error (line 525) | type Error = Error;
    type Config (line 526) | type Config = ();
    type Service (line 527) | type Service = ResourceService;
    type InitError (line 528) | type InitError = ();
    type Future (line 529) | type Future = LocalBoxFuture<'static, Result<Self::Service, Self::Init...
    method new_service (line 531) | fn new_service(&self, _: ()) -> Self::Future {
  type ResourceService (line 550) | pub struct ResourceService {
    type Response (line 556) | type Response = ServiceResponse;
    type Error (line 557) | type Error = Error;
    type Future (line 558) | type Future = LocalBoxFuture<'static, Result<Self::Response, Self::Err...
    method call (line 562) | fn call(&self, mut req: ServiceRequest) -> Self::Future {
  type ResourceEndpoint (line 574) | pub struct ResourceEndpoint {
    method new (line 579) | fn new(factory: Rc<RefCell<Option<ResourceFactory>>>) -> Self {
    type Response (line 585) | type Response = ServiceResponse;
    type Error (line 586) | type Error = Error;
    type Config (line 587) | type Config = ();
    type Service (line 588) | type Service = ResourceService;
    type InitError (line 589) | type InitError = ();
    type Future (line 590) | type Future = LocalBoxFuture<'static, Result<Self::Service, Self::Init...
    method new_service (line 592) | fn new_service(&self, _: ()) -> Self::Future {
  function can_be_returned_from_fn (line 613) | fn can_be_returned_from_fn() {
  function test_middleware (line 646) | async fn test_middleware() {
  function test_middleware_fn (line 669) | async fn test_middleware_fn() {
  function test_to (line 697) | async fn test_to() {
  function test_pattern (line 709) | async fn test_pattern() {
  function test_default_resource (line 723) | async fn test_default_resource() {
  function test_resource_guards (line 773) | async fn test_resource_guards() {
  function test_data (line 816) | async fn test_data() {
  function test_data_default_service (line 850) | async fn test_data_default_service() {
  function test_middleware_app_data (line 870) | async fn test_middleware_app_data() {
  function test_middleware_body_type (line 905) | async fn test_middleware_body_type() {

FILE: actix-web/src/response/builder.rs
  type HttpResponseBuilder (line 27) | pub struct HttpResponseBuilder {
    method new (line 35) | pub fn new(status: StatusCode) -> Self {
    method status (line 44) | pub fn status(&mut self, status: StatusCode) -> &mut Self {
    method insert_header (line 61) | pub fn insert_header(&mut self, header: impl TryIntoHeaderPair) -> &mu...
    method append_header (line 85) | pub fn append_header(&mut self, header: impl TryIntoHeaderPair) -> &mu...
    method set_header (line 102) | pub fn set_header<K, V>(&mut self, key: K, value: V) -> &mut Self
    method header (line 127) | pub fn header<K, V>(&mut self, key: K, value: V) -> &mut Self
    method reason (line 148) | pub fn reason(&mut self, reason: &'static str) -> &mut Self {
    method keep_alive (line 157) | pub fn keep_alive(&mut self) -> &mut Self {
    method upgrade (line 166) | pub fn upgrade<V>(&mut self, value: V) -> &mut Self
    method force_close (line 183) | pub fn force_close(&mut self) -> &mut Self {
    method no_chunking (line 192) | pub fn no_chunking(&mut self, len: u64) -> &mut Self {
    method content_type (line 204) | pub fn content_type<V>(&mut self, value: V) -> &mut Self
    method cookie (line 257) | pub fn cookie(&mut self, cookie: cookie::Cookie<'_>) -> &mut Self {
    method extensions (line 269) | pub fn extensions(&self) -> Ref<'_, Extensions> {
    method extensions_mut (line 278) | pub fn extensions_mut(&mut self) -> RefMut<'_, Extensions> {
    method body (line 291) | pub fn body<B>(&mut self, body: B) -> HttpResponse<BoxBody>
    method message_body (line 304) | pub fn message_body<B>(&mut self, body: B) -> Result<HttpResponse<B>, ...
    method streaming (line 326) | pub fn streaming<S, E>(&mut self, stream: S) -> HttpResponse
    method json (line 355) | pub fn json(&mut self, value: impl Serialize) -> HttpResponse {
    method finish (line 378) | pub fn finish(&mut self) -> HttpResponse {
    method take (line 383) | pub fn take(&mut self) -> Self {
    method inner (line 390) | fn inner(&mut self) -> Option<&mut ResponseHead> {
  method from (line 400) | fn from(mut builder: HttpResponseBuilder) -> Self {
  function from (line 406) | fn from(mut builder: HttpResponseBuilder) -> Self {
  type Output (line 412) | type Output = Result<HttpResponse, Error>;
  method poll (line 414) | fn poll(mut self: Pin<&mut Self>, _: &mut Context<'_>) -> Poll<Self::Out...
  type Body (line 420) | type Body = BoxBody;
  method respond_to (line 423) | fn respond_to(mut self, _: &HttpRequest) -> HttpResponse<Self::Body> {
  function test_basic_builder (line 438) | fn test_basic_builder() {
  function test_upgrade (line 446) | fn test_upgrade() {
  function test_force_close (line 458) | fn test_force_close() {
  function test_content_type (line 466) | fn test_content_type() {
  function test_json (line 474) | async fn test_json() {
  function test_serde_json_in_body (line 495) | async fn test_serde_json_in_body() {
  function response_builder_header_insert_kv (line 506) | fn response_builder_header_insert_kv() {
  function response_builder_header_insert_typed (line 518) | fn response_builder_header_insert_typed() {
  function response_builder_header_append_kv (line 530) | fn response_builder_header_append_kv() {
  function response_builder_header_append_typed (line 543) | fn response_builder_header_append_typed() {

FILE: actix-web/src/response/customize_responder.rs
  type CustomizeResponder (line 13) | pub struct CustomizeResponder<R> {
  type CustomizeResponderInner (line 18) | struct CustomizeResponderInner<R> {
  function new (line 26) | pub(crate) fn new(responder: R) -> Self {
  function with_status (line 50) | pub fn with_status(mut self, status: StatusCode) -> Self {
  function insert_header (line 79) | pub fn insert_header(mut self, header: impl TryIntoHeaderPair) -> Self {
  function append_header (line 111) | pub fn append_header(mut self, header: impl TryIntoHeaderPair) -> Self {
  function with_header (line 126) | pub fn with_header(self, header: impl TryIntoHeaderPair) -> Self
  function inner (line 133) | fn inner(&mut self) -> Option<&mut CustomizeResponderInner<R>> {
  function add_cookie (line 147) | pub fn add_cookie(mut self, cookie: &crate::cookie::Cookie<'_>) -> Self {
  type Body (line 169) | type Body = EitherBody<T::Body>;
  method respond_to (line 171) | fn respond_to(self, req: &HttpRequest) -> HttpResponse<Self::Body> {
  function customize_responder (line 207) | async fn customize_responder() {
  function tuple_responder_with_status_code (line 255) | async fn tuple_responder_with_status_code() {

FILE: actix-web/src/response/http_codes.rs
  function test_build (line 104) | fn test_build() {

FILE: actix-web/src/response/responder.rs
  type Responder (line 39) | pub trait Responder {
    method respond_to (line 43) | fn respond_to(self, req: &HttpRequest) -> HttpResponse<Self::Body>;
    method customize (line 64) | fn customize(self) -> CustomizeResponder<Self>
    method with_status (line 73) | fn with_status(self, status: StatusCode) -> CustomizeResponder<Self>
    method with_header (line 82) | fn with_header(self, header: impl TryIntoHeaderPair) -> CustomizeRespo...
    type Body (line 91) | type Body = BoxBody;
    method respond_to (line 94) | fn respond_to(self, _: &HttpRequest) -> HttpResponse<Self::Body> {
    type Body (line 100) | type Body = BoxBody;
    method respond_to (line 103) | fn respond_to(mut self, req: &HttpRequest) -> HttpResponse<Self::Body> {
    type Body (line 109) | type Body = EitherBody<R::Body>;
    method respond_to (line 111) | fn respond_to(self, req: &HttpRequest) -> HttpResponse<Self::Body> {
    type Body (line 124) | type Body = EitherBody<R::Body>;
    method respond_to (line 126) | fn respond_to(self, req: &HttpRequest) -> HttpResponse<Self::Body> {
    type Body (line 141) | type Body = BoxBody;
    method respond_to (line 143) | fn respond_to(self, _req: &HttpRequest) -> HttpResponse {
    type Body (line 152) | type Body = R::Body;
    method respond_to (line 154) | fn respond_to(self, req: &HttpRequest) -> HttpResponse<Self::Body> {
  function test_option_responder (line 218) | async fn test_option_responder() {
  function test_responder (line 237) | async fn test_responder() {
  function test_result_responder (line 346) | async fn test_result_responder() {

FILE: actix-web/src/response/response.rs
  type HttpResponse (line 23) | pub struct HttpResponse<B = BoxBody> {
    method from (line 317) | fn from(err: Error) -> Self {
  function new (line 31) | pub fn new(status: StatusCode) -> Self {
  function build (line 40) | pub fn build(status: StatusCode) -> HttpResponseBuilder {
  function from_error (line 46) | pub fn from_error(error: impl Into<Error>) -> Self {
  function with_body (line 57) | pub fn with_body(status: StatusCode, body: B) -> Self {
  function head (line 66) | pub fn head(&self) -> &ResponseHead {
  function head_mut (line 72) | pub fn head_mut(&mut self) -> &mut ResponseHead {
  function error (line 78) | pub fn error(&self) -> Option<&Error> {
  function status (line 84) | pub fn status(&self) -> StatusCode {
  function status_mut (line 90) | pub fn status_mut(&mut self) -> &mut StatusCode {
  function headers (line 96) | pub fn headers(&self) -> &HeaderMap {
  function headers_mut (line 102) | pub fn headers_mut(&mut self) -> &mut HeaderMap {
  function cookies (line 108) | pub fn cookies(&self) -> CookieIter<'_> {
  function add_cookie (line 119) | pub fn add_cookie(&mut self, cookie: &Cookie<'_>) -> Result<(), HttpErro...
  function add_removal_cookie (line 143) | pub fn add_removal_cookie(&mut self, cookie: &Cookie<'_>) -> Result<(), ...
  function del_cookie (line 163) | pub fn del_cookie(&mut self, name: &str) -> usize {
  function upgrade (line 194) | pub fn upgrade(&self) -> bool {
  function keep_alive (line 199) | pub fn keep_alive(&self) -> bool {
  function extensions (line 205) | pub fn extensions(&self) -> Ref<'_, Extensions> {
  function extensions_mut (line 211) | pub fn extensions_mut(&mut self) -> RefMut<'_, Extensions> {
  function body (line 217) | pub fn body(&self) -> &B {
  function set_body (line 222) | pub fn set_body<B2>(self, body: B2) -> HttpResponse<B2> {
  function into_parts (line 234) | pub fn into_parts(self) -> (HttpResponse<()>, B) {
  function drop_body (line 247) | pub fn drop_body(self) -> HttpResponse<()> {
  function map_body (line 257) | pub fn map_body<F, B2>(self, f: F) -> HttpResponse<B2>
  function map_into_left_body (line 271) | pub fn map_into_left_body<R>(self) -> HttpResponse<EitherBody<B, R>> {
  function map_into_right_body (line 279) | pub fn map_into_right_body<L>(self) -> HttpResponse<EitherBody<L, B>> {
  function map_into_boxed_body (line 285) | pub fn map_into_boxed_body(self) -> HttpResponse<BoxBody>
  function into_body (line 293) | pub fn into_body(self) -> B {
  function fmt (line 302) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  function from (line 311) | fn from(res: Response<B>) -> Self {
  function from (line 323) | fn from(res: HttpResponse<B>) -> Self {
  type Output (line 350) | type Output = Result<Response<BoxBody>, Error>;
  method poll (line 352) | fn poll(mut self: Pin<&mut Self>, _: &mut Context<'_>) -> Poll<Self::Out...
  type Body (line 369) | type Body = B;
  method respond_to (line 372) | fn respond_to(self, _: &HttpRequest) -> HttpResponse<Self::Body> {
  type CookieIter (line 378) | pub struct CookieIter<'a> {
  type Item (line 384) | type Item = Cookie<'a>;
  method next (line 387) | fn next(&mut self) -> Option<Cookie<'a>> {
  function test_debug (line 410) | fn test_debug() {
  function removal_cookies (line 426) | fn removal_cookies() {

FILE: actix-web/src/rmap.rs
  constant AVG_PATH_LEN (line 16) | const AVG_PATH_LEN: usize = 24;
  type ResourceMap (line 19) | pub struct ResourceMap {
    method new (line 34) | pub fn new(root: ResourceDef) -> Self {
    method tree (line 45) | pub(crate) fn tree(&self) -> String {
    method _tree (line 51) | pub(crate) fn _tree(&self, buf: &mut String, level: usize) {
    method add (line 77) | pub fn add(&mut self, pattern: &mut ResourceDef, nested: Option<Rc<Res...
    method finish (line 112) | pub(crate) fn finish(self: &Rc<Self>) {
    method url_for (line 122) | pub fn url_for<U, I>(
    method url_for_map (line 151) | pub fn url_for_map<K, V, S>(
    method url_for_iter (line 179) | pub fn url_for_iter<K, V, I>(
    method url_from_path (line 194) | fn url_from_path(&self, req: &HttpRequest, path: String) -> Result<Url...
    method has_resource (line 220) | pub fn has_resource(&self, path: &str) -> bool {
    method match_name (line 226) | pub fn match_name(&self, path: &str) -> Option<&str> {
    method match_pattern (line 232) | pub fn match_pattern(&self, path: &str) -> Option<String> {
    method is_resource_path_match (line 243) | pub(crate) fn is_resource_path_match(&self, resource_path: &[u16]) -> ...
    method match_name_by_resource_path (line 248) | pub(crate) fn match_name_by_resource_path(&self, resource_path: &[u16]...
    method match_pattern_by_resource_path (line 254) | pub(crate) fn match_pattern_by_resource_path(&self, resource_path: &[u...
    method find_matching_node (line 263) | fn find_matching_node(&self, path: &str) -> Option<&ResourceMap> {
    method find_node_by_resource_path (line 267) | fn find_node_by_resource_path(&self, resource_path: &[u16]) -> Option<...
    method _find_matching_node (line 280) | fn _find_matching_node(&self, path: &str) -> Option<Option<&ResourceMa...
    method root_rmap_fn (line 298) | fn root_rmap_fn<F, B>(&self, init: B, mut f: F) -> Option<B>
    method _root_rmap_fn (line 306) | fn _root_rmap_fn<F, B>(&self, init: B, f: &mut F) -> Option<B>
  function extract_matched_pattern (line 324) | fn extract_matched_pattern() {
  function extract_matched_name (line 398) | fn extract_matched_name() {
  function bug_fix_issue_1582_debug_print_exits (line 442) | fn bug_fix_issue_1582_debug_print_exits() {
  function short_circuit (line 488) | fn short_circuit() {
  function url_for (line 510) | fn url_for() {
  function url_for_parser (line 543) | fn url_for_parser() {
  function external_resource_with_no_name (line 579) | fn external_resource_with_no_name() {
  function external_resource_with_name (line 592) | fn external_resource_with_name() {
  function url_for_override_within_map (line 615) | fn url_for_override_within_map() {

FILE: actix-web/src/route.rs
  type Route (line 23) | pub struct Route {
    method new (line 32) | pub fn new() -> Route {
    method wrap (line 61) | pub fn wrap<M, B>(self, mw: M) -> Route
    method take_guards (line 79) | pub(crate) fn take_guards(&mut self) -> Vec<Box<dyn Guard>> {
    method panic_after_wrap (line 86) | fn panic_after_wrap(replaced: &str, example: &str) -> ! {
    type Response (line 96) | type Response = ServiceResponse;
    type Error (line 97) | type Error = Error;
    type Config (line 98) | type Config = ();
    type Service (line 99) | type Service = RouteService;
    type InitError (line 100) | type InitError = ();
    type Future (line 101) | type Future = LocalBoxFuture<'static, Result<Self::Service, Self::Init...
    method new_service (line 103) | fn new_service(&self, _: ()) -> Self::Future {
    method method (line 161) | pub fn method(mut self, method: Method) -> Self {
    method guard (line 182) | pub fn guard<F: Guard + 'static>(mut self, f: F) -> Self {
    method guards (line 188) | pub(crate) fn guards(&self) -> &Vec<Box<dyn Guard>> {
    method to (line 245) | pub fn to<F, Args>(mut self, handler: F) -> Self
    method service (line 296) | pub fn service<S, E>(mut self, service_factory: S) -> Self
  type RouteService (line 114) | pub struct RouteService {
    method check (line 122) | pub fn check(&self, req: &mut ServiceRequest) -> bool {
    type Response (line 135) | type Response = ServiceResponse;
    type Error (line 136) | type Error = Error;
    type Future (line 137) | type Future = LocalBoxFuture<'static, Result<Self::Response, Self::Err...
    method call (line 141) | fn call(&self, req: ServiceRequest) -> Self::Future {
  type MyObject (line 336) | struct MyObject {
  function test_route (line 341) | async fn test_route() {
  function route_middleware (line 408) | async fn route_middleware() {
  function test_service_handler (line 446) | async fn test_service_handler() {
  function wrap_before_to_panics (line 508) | fn wrap_before_to_panics() {
  function wrap_before_service_panics (line 516) | fn wrap_before_service_panics() {

FILE: actix-web/src/scope.rs
  type Guards (line 25) | type Guards = Vec<Box<dyn Guard>>;
  type Scope (line 57) | pub struct Scope<T = ScopeEndpoint> {
    method new (line 70) | pub fn new(path: &str) -> Scope {
  function guard (line 108) | pub fn guard<G: Guard + 'static>(mut self, guard: G) -> Self {
  function app_data (line 146) | pub fn app_data<U: 'static>(mut self, data: U) -> Self {
  function data (line 158) | pub fn data<U: 'static>(self, data: U) -> Self {
  function configure (line 186) | pub fn configure<F>(mut self, cfg_fn: F) -> Self
  function service (line 232) | pub fn service<F>(mut self, factory: F) -> Self
  function route (line 260) | pub fn route(self, path: &str, mut route: Route) -> Self {
  function default_service (line 272) | pub fn default_service<F, U>(mut self, f: F) -> Self
  function wrap (line 297) | pub fn wrap<M, B>(
  function wrap_fn (line 340) | pub fn wrap_fn<F, R, B>(
  method register (line 381) | fn register(mut self, config: &mut AppService) {
  type ScopeFactory (line 462) | pub struct ScopeFactory {
    type Response (line 475) | type Response = ServiceResponse;
    type Error (line 476) | type Error = Error;
    type Config (line 477) | type Config = ();
    type Service (line 478) | type Service = ScopeService;
    type InitError (line 479) | type InitError = ();
    type Future (line 480) | type Future = LocalBoxFuture<'static, Result<Self::Service, Self::Init...
    method new_service (line 482) | fn new_service(&self, _: ()) -> Self::Future {
  type ScopeService (line 518) | pub struct ScopeService {
    type Response (line 524) | type Response = ServiceResponse;
    type Error (line 525) | type Error = Error;
    type Future (line 526) | type Future = LocalBoxFuture<'static, Result<Self::Response, Self::Err...
    method call (line 530) | fn call(&self, mut req: ServiceRequest) -> Self::Future {
  type ScopeEndpoint (line 553) | pub struct ScopeEndpoint {
    method new (line 558) | fn new(factory: Rc<RefCell<Option<ScopeFactory>>>) -> Self {
    type Response (line 564) | type Response = ServiceResponse;
    type Error (line 565) | type Error = Error;
    type Config (line 566) | type Config = ();
    type Service (line 567) | type Service = ScopeService;
    type InitError (line 568) | type InitError = ();
    type Future (line 569) | type Future = LocalBoxFuture<'static, Result<Self::Service, Self::Init...
    method new_service (line 571) | fn new_service(&self, _: ()) -> Self::Future {
  function can_be_returned_from_fn (line 594) | fn can_be_returned_from_fn() {
  function test_scope (line 628) | async fn test_scope() {
  function test_scope_root (line 641) | async fn test_scope_root() {
  function test_scope_root2 (line 661) | async fn test_scope_root2() {
  function test_scope_root3 (line 677) | async fn test_scope_root3() {
  function test_scope_route (line 694) | async fn test_scope_route() {
  function test_scope_route_without_leading_slash (line 722) | async fn test_scope_route_without_leading_slash() {
  function test_scope_guard (line 752) | async fn test_scope_guard() {
  function test_scope_variable_segment (line 776) | async fn test_scope_variable_segment() {
  function test_nested_scope (line 795) | async fn test_nested_scope() {
  function test_nested_scope_no_slash (line 807) | async fn test_nested_scope_no_slash() {
  function test_nested_scope_root (line 820) | async fn test_nested_scope_root() {
  function test_nested_scope_filter (line 842) | async fn test_nested_scope_filter() {
  function test_nested_scope_with_variable_segment (line 868) | async fn test_nested_scope_with_variable_segment() {
  function test_nested2_scope_with_variable_segment (line 883) | async fn test_nested2_scope_with_variable_segment() {
  function test_default_resource (line 908) | async fn test_default_resource() {
  function test_default_resource_propagation (line 930) | async fn test_default_resource_propagation() {
  function test_middleware (line 955) | async fn test_middleware() {
  function test_middleware_body_type (line 978) | async fn test_middleware_body_type() {
  function test_middleware_fn (line 1001) | async fn test_middleware_fn() {
  function test_middleware_app_data (line 1029) | async fn test_middleware_app_data() {
  function test_override_data (line 1066) | async fn test_override_data() {
  function test_override_data_default_service (line 1086) | async fn test_override_data_default_service() {
  function test_override_app_data (line 1104) | async fn test_override_app_data() {
  function test_scope_config (line 1122) | async fn test_scope_config() {
  function test_scope_config_2 (line 1134) | async fn test_scope_config_2() {
  function test_url_for_external (line 1148) | async fn test_url_for_external() {
  function test_url_for_nested (line 1171) | async fn test_url_for_nested() {
  function dynamic_scopes (line 1192) | async fn dynamic_scopes() {

FILE: actix-web/src/server.rs
  type Socket (line 24) | struct Socket {
  type Config (line 29) | struct Config {
  type HttpServer (line 74) | pub struct HttpServer<F, I, S, B>
  function new (line 115) | pub fn new(factory: F) -> Self {
  function workers (line 151) | pub fn workers(mut self, num: usize) -> Self {
  function keep_alive (line 159) | pub fn keep_alive<T: Into<KeepAlive>>(self, val: T) -> Self {
  function tcp_nodelay (line 168) | pub fn tcp_nodelay(self, enabled: bool) -> Self {
  function backlog (line 182) | pub fn backlog(mut self, backlog: u32) -> Self {
  function max_connections (line 194) | pub fn max_connections(mut self, num: usize) -> Self {
  function max_connection_rate (line 206) | pub fn max_connection_rate(self, num: usize) -> Self {
  function worker_max_blocking_threads (line 217) | pub fn worker_max_blocking_threads(mut self, num: usize) -> Self {
  function client_request_timeout (line 230) | pub fn client_request_timeout(self, dur: Duration) -> Self {
  function client_timeout (line 237) | pub fn client_timeout(self, dur: Duration) -> Self {
  function client_disconnect_timeout (line 249) | pub fn client_disconnect_timeout(self, dur: Duration) -> Self {
  function tls_handshake_timeout (line 261) | pub fn tls_handshake_timeout(self, dur: Duration) -> Self {
  function client_shutdown (line 273) | pub fn client_shutdown(self, dur: u64) -> Self {
  function h1_allow_half_closed (line 284) | pub fn h1_allow_half_closed(self, allow: bool) -> Self {
  function h2_initial_window_size (line 296) | pub fn h2_initial_window_size(self, size: u32) -> Self {
  function h2_initial_connection_window_size (line 308) | pub fn h2_initial_connection_window_size(self, size: u32) -> Self {
  function on_connect (line 334) | pub fn on_connect<CB>(mut self, f: CB) -> HttpServer<F, I, S, B>
  function server_hostname (line 348) | pub fn server_hostname<T: AsRef<str>>(self, val: T) -> Self {
  function system_exit (line 356) | pub fn system_exit(mut self) -> Self {
  function disable_signals (line 362) | pub fn disable_signals(mut self) -> Self {
  function shutdown_signal (line 390) | pub fn shutdown_signal<Fut>(mut self, shutdown_signal: Fut) -> Self
  function shutdown_timeout (line 404) | pub fn shutdown_timeout(mut self, sec: u64) -> Self {
  function addrs (line 410) | pub fn addrs(&self) -> Vec<net::SocketAddr> {
  function addrs_with_scheme (line 419) | pub fn addrs_with_scheme(&self) -> Vec<(net::SocketAddr, &str)> {
  function bind (line 469) | pub fn bind<A: net::ToSocketAddrs>(mut self, addrs: A) -> io::Result<Sel...
  function bind_auto_h2c (line 484) | pub fn bind_auto_h2c<A: net::ToSocketAddrs>(mut self, addrs: A) -> io::R...
  function bind_rustls (line 501) | pub fn bind_rustls<A: net::ToSocketAddrs>(
  function bind_rustls_021 (line 520) | pub fn bind_rustls_021<A: net::ToSocketAddrs>(
  function bind_rustls_0_22 (line 539) | pub fn bind_rustls_0_22<A: net::ToSocketAddrs>(
  function bind_rustls_0_23 (line 558) | pub fn bind_rustls_0_23<A: net::ToSocketAddrs>(
  function bind_openssl (line 577) | pub fn bind_openssl<A>(mut self, addrs: A, builder: SslAcceptorBuilder) ...
  function listen (line 595) | pub fn listen(mut self, lst: net::TcpListener) -> io::Result<Self> {
  function listen_auto_h2c (line 652) | pub fn listen_auto_h2c(mut self, lst: net::TcpListener) -> io::Result<Se...
  function listen_rustls (line 714) | pub fn listen_rustls(
  function listen_rustls_0_21 (line 729) | pub fn listen_rustls_0_21(
  function listen_rustls_0_20_inner (line 738) | fn listen_rustls_0_20_inner(
  function listen_rustls_0_21_inner (line 801) | fn listen_rustls_0_21_inner(
  function listen_rustls_0_22 (line 870) | pub fn listen_rustls_0_22(
  function listen_rustls_0_22_inner (line 879) | fn listen_rustls_0_22_inner(
  function listen_rustls_0_23 (line 948) | pub fn listen_rustls_0_23(
  function listen_rustls_0_23_inner (line 957) | fn listen_rustls_0_23_inner(
  function listen_openssl (line 1025) | pub fn listen_openssl(
  function listen_openssl_inner (line 1034) | fn listen_openssl_inner(
  function bind_uds (line 1102) | pub fn bind_uds<A>(mut self, uds_path: A) -> io::Result<Self>
  function listen_uds (line 1151) | pub fn listen_uds(mut self, lst: std::os::unix::net::UnixListener) -> io...
  function run (line 1223) | pub fn run(self) -> Server {
  function bind_addrs (line 1229) | fn bind_addrs(addrs: impl net::ToSocketAddrs, backlog: u32) -> io::Resul...
  function create_tcp_listener (line 1254) | fn create_tcp_listener(addr: net::SocketAddr, backlog: u32) -> io::Resul...
  function openssl_acceptor (line 1271) | fn openssl_acceptor(mut builder: SslAcceptorBuilder) -> io::Result<SslAc...

FILE: actix-web/src/service.rs
  type BoxedHttpService (line 30) | pub(crate) type BoxedHttpService = BoxService<ServiceRequest, ServiceRes...
  type BoxedHttpServiceFactory (line 31) | pub(crate) type BoxedHttpServiceFactory =
  type HttpServiceFactory (line 34) | pub trait HttpServiceFactory {
    method register (line 35) | fn register(self, config: &mut AppService);
    method register (line 39) | fn register(self, config: &mut AppService) {
    method register (line 634) | fn register(mut self, config: &mut AppService) {
  type AppServiceFactory (line 45) | pub(crate) trait AppServiceFactory {
    method register (line 46) | fn register(&mut self, config: &mut AppService);
    method register (line 65) | fn register(&mut self, config: &mut AppService) {
  type ServiceFactoryWrapper (line 49) | pub(crate) struct ServiceFactoryWrapper<T> {
  function new (line 54) | pub fn new(factory: T) -> Self {
  type ServiceRequest (line 75) | pub struct ServiceRequest {
    method new (line 82) | pub(crate) fn new(req: HttpRequest, payload: Payload) -> Self {
    method into_parts (line 88) | pub fn into_parts(self) -> (HttpRequest, Payload) {
    method parts_mut (line 94) | pub fn parts_mut(&mut self) -> (&mut HttpRequest, &mut Payload) {
    method parts (line 100) | pub fn parts(&self) -> (&HttpRequest, &Payload) {
    method request (line 106) | pub fn request(&self) -> &HttpRequest {
    method extract (line 128) | pub fn extract<T>(&mut self) -> <T as FromRequest>::Future
    method from_parts (line 136) | pub fn from_parts(req: HttpRequest, payload: Payload) -> Self {
    method from_request (line 147) | pub fn from_request(req: HttpRequest) -> Self {
    method into_response (line 156) | pub fn into_response<B, R: Into<Response<B>>>(self, res: R) -> Service...
    method error_response (line 163) | pub fn error_response<E: Into<Error>>(self, err: E) -> ServiceResponse {
    method head (line 170) | pub fn head(&self) -> &RequestHead {
    method head_mut (line 176) | pub fn head_mut(&mut self) -> &mut RequestHead {
    method uri (line 182) | pub fn uri(&self) -> &Uri {
    method method (line 188) | pub fn method(&self) -> &Method {
    method version (line 194) | pub fn version(&self) -> Version {
    method headers (line 200) | pub fn headers(&self) -> &HeaderMap {
    method headers_mut (line 206) | pub fn headers_mut(&mut self) -> &mut HeaderMap {
    method path (line 212) | pub fn path(&self) -> &str {
    method query_string (line 218) | pub fn query_string(&self) -> &str {
    method peer_addr (line 228) | pub fn peer_addr(&self) -> Option<net::SocketAddr> {
    method connection_info (line 234) | pub fn connection_info(&self) -> Ref<'_, ConnectionInfo> {
    method match_info (line 240) | pub fn match_info(&self) -> &Path<Url> {
    method match_info_mut (line 246) | pub fn match_info_mut(&mut self) -> &mut Path<Url> {
    method match_name (line 252) | pub fn match_name(&self) -> Option<&str> {
    method match_pattern (line 258) | pub fn match_pattern(&self) -> Option<String> {
    method resource_map (line 265) | pub fn resource_map(&self) -> &ResourceMap {
    method app_config (line 271) | pub fn app_config(&self) -> &AppConfig {
    method app_data (line 277) | pub fn app_data<T: 'static>(&self) -> Option<&T> {
    method conn_data (line 289) | pub fn conn_data<T: 'static>(&self) -> Option<&T> {
    method cookies (line 296) | pub fn cookies(&self) -> Result<Ref<'_, Vec<Cookie<'static>>>, CookieP...
    method cookie (line 303) | pub fn cookie(&self, name: &str) -> Option<Cookie<'static>> {
    method set_payload (line 309) | pub fn set_payload(&mut self, payload: Payload) {
    method add_data_container (line 317) | pub fn add_data_container(&mut self, extensions: Rc<Extensions>) {
    method push_resource_id (line 325) | pub(crate) fn push_resource_id(&mut self, id: u16) {
    method mark_resource_path (line 330) | pub(crate) fn mark_resource_path(&mut self, is_matched: bool) {
    method resource_id_path (line 335) | pub(crate) fn resource_id_path(&self) -> &[u16] {
    method guard_ctx (line 341) | pub fn guard_ctx(&self) -> GuardContext<'_> {
    method fmt (line 380) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  type Path (line 347) | type Path = Url;
  method resource_path (line 350) | fn resource_path(&mut self) -> &mut Path<Self::Path> {
  type Stream (line 356) | type Stream = BoxedPayloadStream;
  method headers (line 359) | fn headers(&self) -> &HeaderMap {
  method extensions (line 364) | fn extensions(&self) -> Ref<'_, Extensions> {
  method extensions_mut (line 369) | fn extensions_mut(&self) -> RefMut<'_, Extensions> {
  method take_payload (line 374) | fn take_payload(&mut self) -> Payload<Self::Stream> {
  type ServiceResponse (line 403) | pub struct ServiceResponse<B = BoxBody> {
  function from_err (line 410) | pub fn from_err<E: Into<Error>>(err: E, request: HttpRequest) -> Self {
  function new (line 418) | pub fn new(request: HttpRequest, response: HttpResponse<B>) -> Self {
  function error_response (line 424) | pub fn error_response<E: Into<Error>>(self, err: E) -> ServiceResponse {
  function into_response (line 430) | pub fn into_response<B1>(self, response: HttpResponse<B1>) -> ServiceRes...
  function request (line 436) | pub fn request(&self) -> &HttpRequest {
  function response (line 442) | pub fn response(&self) -> &HttpResponse<B> {
  function response_mut (line 448) | pub fn response_mut(&mut self) -> &mut HttpResponse<B> {
  function status (line 454) | pub fn status(&self) -> StatusCode {
  function headers (line 460) | pub fn headers(&self) -> &HeaderMap {
  function headers_mut (line 466) | pub fn headers_mut(&mut self) -> &mut HeaderMap {
  function into_parts (line 472) | pub fn into_parts(self) -> (HttpRequest, HttpResponse<B>) {
  function map_body (line 480) | pub fn map_body<F, B2>(self, f: F) -> ServiceResponse<B2>
  function map_into_left_body (line 493) | pub fn map_into_left_body<R>(self) -> ServiceResponse<EitherBody<B, R>> {
  function map_into_right_body (line 498) | pub fn map_into_right_body<L>(self) -> ServiceResponse<EitherBody<L, B>> {
  function map_into_boxed_body (line 503) | pub fn map_into_boxed_body(self) -> ServiceResponse<BoxBody>
  function into_body (line 512) | pub fn into_body(self) -> B {
  function from (line 518) | fn from(res: ServiceResponse<B>) -> HttpResponse<B> {
  function from (line 524) | fn from(res: ServiceResponse<B>) -> Response<B> {
  function fmt (line 534) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  type WebService (line 551) | pub struct WebService {
    method new (line 559) | pub fn new<T: IntoPatterns>(path: T) -> Self {
    method name (line 570) | pub fn name(mut self, name: &str) -> Self {
    method guard (line 591) | pub fn guard<G: Guard + 'static>(mut self, guard: G) -> Self {
    method finish (line 597) | pub fn finish<T, F>(self, service: F) -> impl HttpServiceFactory
  type WebServiceImpl (line 617) | struct WebServiceImpl<T> {
  function test_service (line 723) | async fn test_service() {
  function test_service_data (line 752) | async fn test_service_data() {
  function test_fmt_debug (line 772) | fn test_fmt_debug() {
  function test_services_macro (line 793) | async fn test_services_macro() {
  function test_services_vec (line 831) | async fn test_services_vec() {
  function cloning_request_panics (line 868) | async fn cloning_request_panics() {
  function define_services_macro_with_multiple_arguments (line 891) | fn define_services_macro_with_multiple_arguments() {
  function define_services_macro_with_single_argument (line 897) | fn define_services_macro_with_single_argument() {
  function define_services_macro_with_no_arguments (line 903) | fn define_services_macro_with_no_arguments() {
  function define_services_macro_with_trailing_comma (line 909) | fn define_services_macro_with_trailing_comma() {
  function define_services_macro_with_comments_in_arguments (line 915) | fn define_services_macro_with_comments_in_arguments() {

FILE: actix-web/src/test/mod.rs
  function assert_body_works_for_service_and_regular_response (line 80) | async fn assert_body_works_for_service_and_regular_response() {

FILE: actix-web/src/test/test_request.rs
  type TestRequest (line 61) | pub struct TestRequest {
    method with_uri (line 90) | pub fn with_uri(uri: &str) -> TestRequest {
    method get (line 95) | pub fn get() -> TestRequest {
    method post (line 100) | pub fn post() -> TestRequest {
    method put (line 105) | pub fn put() -> TestRequest {
    method patch (line 110) | pub fn patch() -> TestRequest {
    method delete (line 115) | pub fn delete() -> TestRequest {
    method version (line 120) | pub fn version(mut self, ver: Version) -> Self {
    method method (line 126) | pub fn method(mut self, meth: Method) -> Self {
    method uri (line 132) | pub fn uri(mut self, path: &str) -> Self {
    method insert_header (line 138) | pub fn insert_header(mut self, header: impl TryIntoHeaderPair) -> Self {
    method append_header (line 144) | pub fn append_header(mut self, header: impl TryIntoHeaderPair) -> Self {
    method cookie (line 151) | pub fn cookie(mut self, cookie: Cookie<'_>) -> Self {
    method param (line 166) | pub fn param(
    method peer_addr (line 176) | pub fn peer_addr(mut self, addr: SocketAddr) -> Self {
    method set_payload (line 182) | pub fn set_payload(mut self, data: impl Into<Bytes>) -> Self {
    method set_form (line 190) | pub fn set_form(mut self, data: impl Serialize) -> Self {
    method set_json (line 201) | pub fn set_json(mut self, data: impl Serialize) -> Self {
    method app_data (line 211) | pub fn app_data<T: 'static>(mut self, data: T) -> Self {
    method data (line 220) | pub fn data<T: 'static>(mut self, data: T) -> Self {
    method rmap (line 227) | pub(crate) fn rmap(mut self, rmap: ResourceMap) -> Self {
    method finish (line 235) | fn finish(&mut self) -> Request {
    method to_request (line 262) | pub fn to_request(mut self) -> Request {
    method to_srv_request (line 269) | pub fn to_srv_request(mut self) -> ServiceRequest {
    method to_srv_response (line 290) | pub fn to_srv_response<B>(self, res: HttpResponse<B>) -> ServiceRespon...
    method to_http_request (line 295) | pub fn to_http_request(mut self) -> HttpRequest {
    method to_http_parts (line 313) | pub fn to_http_parts(mut self) -> (HttpRequest, Payload) {
    method send_request (line 333) | pub async fn send_request<S, B, E>(self, app: &S) -> S::Response
    method set_server_hostname (line 343) | pub fn set_server_hostname(&mut self, host: &str) {
  method default (line 73) | fn default() -> TestRequest {
  function test_basics (line 356) | async fn test_basics() {
  function test_send_request (line 384) | async fn test_send_request() {
  function test_async_with_block (line 403) | async fn test_async_with_block() {
  function test_server_data (line 427) | async fn test_server_data() {

FILE: actix-web/src/test/test_services.rs
  function ok_service (line 11) | pub fn ok_service(
  function status_service (line 17) | pub fn status_service(
  function simple_service (line 27) | pub fn simple_service(
  function default_service (line 35) | pub fn default_service(

FILE: actix-web/src/test/test_utils.rs
  function init_service (line 41) | pub async fn init_service<R, S, B, E>(
  function try_init_service (line 55) | pub(crate) async fn try_init_service<R, S, B, E>(
  function call_service (line 93) | pub async fn call_service<S, R, B, E>(app: &S, req: R) -> S::Response
  function try_call_service (line 104) | pub async fn try_call_service<S, R, B, E>(app: &S, req: R) -> Result<S::...
  function call_and_read_body (line 143) | pub async fn call_and_read_body<S, B>(app: &S, req: Request) -> Bytes
  function read_response (line 154) | pub async fn read_response<S, B>(app: &S, req: Request) -> Bytes
  function read_body (line 193) | pub async fn read_body<B>(res: ServiceResponse<B>) -> Bytes
  function try_read_body (line 204) | pub async fn try_read_body<B>(res: ServiceResponse<B>) -> Result<Bytes, ...
  function read_body_json (line 255) | pub async fn read_body_json<T, B>(res: ServiceResponse<B>) -> T
  function try_read_body_json (line 270) | pub async fn try_read_body_json<T, B>(res: ServiceResponse<B>) -> Result...
  function call_and_read_body_json (line 322) | pub async fn call_and_read_body_json<S, B, T>(app: &S, req: Request) -> T
  function try_call_and_read_body_json (line 332) | pub async fn try_call_and_read_body_json<S, B, T>(
  function read_response_json (line 349) | pub async fn read_response_json<S, B, T>(app: &S, req: Request) -> T
  function test_request_methods (line 368) | async fn test_request_methods() {
  type Person (line 401) | pub struct Person {
  function test_response_json (line 407) | async fn test_response_json() {
  function test_try_response_json_error (line 427) | async fn test_try_response_json_error() {
  function test_body_json (line 448) | async fn test_body_json() {
  function test_try_body_json_error (line 469) | async fn test_try_body_json_error() {
  function test_request_response_form (line 491) | async fn test_request_response_form() {
  function test_response (line 516) | async fn test_response() {
  function test_request_response_json (line 535) | async fn test_request_response_json() {
  function return_opaque_types (line 561) | async fn return_opaque_types() {

FILE: actix-web/src/thin_data.rs
  type ThinData (line 47) | pub struct ThinData<T>(pub T);
  type Error (line 54) | type Error = crate::Error;
  type Future (line 55) | type Future = Ready<Result<Self, Self::Error>>;
  method from_request (line 58) | fn from_request(req: &HttpRequest, _: &mut Payload) -> Self::Future {
  type TestT (line 87) | type TestT = Arc<Mutex<u32>>;
  function thin_data (line 90) | async fn thin_data() {
  function thin_data_missing (line 111) | async fn thin_data_missing() {

FILE: actix-web/src/types/either.rs
  type Either (line 77) | pub enum Either<L, R> {
  function into_inner (line 86) | pub fn into_inner(self) -> T {
  function into_inner (line 95) | pub fn into_inner(self) -> T {
  function unwrap_left (line 105) | pub(self) fn unwrap_left(self) -> L {
  function unwrap_right (line 114) | pub(self) fn unwrap_right(self) -> R {
  type Body (line 130) | type Body = EitherBody<L::Body, R::Body>;
  method respond_to (line 132) | fn respond_to(self, req: &HttpRequest) -> HttpResponse<Self::Body> {
  type EitherExtractError (line 145) | pub enum EitherExtractError<L, R> {
  method from (line 158) | fn from(err: EitherExtractError<L, R>) -> Error {
  type Error (line 172) | type Error = EitherExtractError<L::Error, R::Error>;
  type Future (line 173) | type Future = EitherExtractFut<L, R>;
  method from_request (line 175) | fn from_request(req: &HttpRequest, payload: &mut dev::Payload) -> Self::...
  type Output (line 230) | type Output = Result<Either<L, R>, EitherExtractError<LE, RE>>;
  method poll (line 232) | fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
  type TestForm (line 287) | struct TestForm {
  function test_either_extract_first_try (line 292) | async fn test_either_extract_first_try() {
  function test_either_extract_fallback (line 308) | async fn test_either_extract_fallback() {
  function test_either_extract_recursive_fallback (line 324) | async fn test_either_extract_recursive_fallback() {
  function test_either_extract_recursive_fallback_inner (line 338) | async fn test_either_extract_recursive_fallback_inner() {

FILE: actix-web/src/types/form.rs
  type Form (line 88) | pub struct Form<T>(pub T);
  function into_inner (line 92) | pub fn into_inner(self) -> T {
  type Target (line 98) | type Target = T;
  function deref (line 100) | fn deref(&self) -> &T {
  function deref_mut (line 106) | fn deref_mut(&mut self) -> &mut T {
  method serialize (line 115) | fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
  type Error (line 128) | type Error = Error;
  type Future (line 129) | type Future = FormExtractFut<T>;
  method from_request (line 132) | fn from_request(req: &HttpRequest, payload: &mut Payload) -> Self::Future {
  type FormErrHandler (line 143) | type FormErrHandler = Option<Rc<dyn Fn(UrlencodedError, &HttpRequest) ->...
  type FormExtractFut (line 145) | pub struct FormExtractFut<T> {
  type Output (line 155) | type Output = Result<Form<T>, Error>;
  method poll (line 157) | fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
  function fmt (line 175) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  type Body (line 182) | type Body = EitherBody<String>;
  method respond_to (line 184) | fn respond_to(self, _: &HttpRequest) -> HttpResponse<Self::Body> {
  type FormConfig (line 224) | pub struct FormConfig {
    method limit (line 231) | pub fn limit(mut self, limit: usize) -> Self {
    method error_handler (line 237) | pub fn error_handler<F>(mut self, f: F) -> Self
    method from_req (line 248) | fn from_req(req: &HttpRequest) -> &Self {
  constant DEFAULT_CONFIG (line 256) | const DEFAULT_CONFIG: FormConfig = FormConfig {
  method default (line 262) | fn default() -> Self {
  type UrlEncoded (line 274) | pub struct UrlEncoded<T> {
  function new (line 290) | pub fn new(req: &HttpRequest, payload: &mut Payload) -> Self {
  function err (line 333) | fn err(err: UrlencodedError) -> Self {
  function limit (line 345) | pub fn limit(mut self, limit: usize) -> Self {
  type Output (line 355) | type Output = Result<T, UrlencodedError>;
  method poll (line 357) | fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Ou...
  type Info (line 428) | struct Info {
  function test_form (line 434) | async fn test_form() {
  function eq (line 451) | fn eq(err: UrlencodedError, other: UrlencodedError) -> bool {
  function test_urlencoded_error (line 463) | async fn test_urlencoded_error() {
  function test_urlencoded (line 490) | async fn test_urlencoded() {
  function test_responder (line 526) | async fn test_responder() {
  function test_with_config_in_data_wrapper (line 543) | async fn test_with_config_in_data_wrapper() {

FILE: actix-web/src/types/header.rs
  type Header (line 27) | pub struct Header<T>(pub T);
  function into_inner (line 31) | pub fn into_inner(self) -> T {
  type Target (line 37) | type Target = T;
  function deref (line 39) | fn deref(&self) -> &T {
  function deref_mut (line 45) | fn deref_mut(&mut self) -> &mut T {
  function fmt (line 54) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  type Error (line 63) | type Error = ParseError;
  type Future (line 64) | type Future = Ready<Result<Self, Self::Error>>;
  method from_request (line 67) | fn from_request(req: &HttpRequest, _: &mut Payload) -> Self::Future {
  function test_header_extract (line 84) | async fn test_header_extract() {

FILE: actix-web/src/types/html.rs
  type Html (line 22) | pub struct Html(String);
    method new (line 26) | pub fn new(html: impl Into<String>) -> Self {
  type Body (line 32) | type Body = String;
  method respond_to (line 34) | fn respond_to(self, _req: &HttpRequest) -> HttpResponse<Self::Body> {
  function responder (line 50) | fn responder() {

FILE: actix-web/src/types/json.rs
  type Json (line 77) | pub struct Json<T>(pub T);
  function into_inner (line 81) | pub fn into_inner(self) -> T {
  type Target (line 87) | type Target = T;
  function deref (line 89) | fn deref(&self) -> &T {
  function deref_mut (line 95) | fn deref_mut(&mut self) -> &mut T {
  function fmt (line 101) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  method serialize (line 107) | fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
  type Body (line 119) | type Body = EitherBody<String>;
  method respond_to (line 121) | fn respond_to(self, _: &HttpRequest) -> HttpResponse<Self::Body> {
  type Error (line 140) | type Error = Error;
  type Future (line 141) | type Future = JsonExtractFut<T>;
  method from_request (line 144) | fn from_request(req: &HttpRequest, payload: &mut Payload) -> Self::Future {
  type JsonErrorHandler (line 160) | type JsonErrorHandler = Option<Arc<dyn Fn(JsonPayloadError, &HttpRequest...
  type JsonExtractFut (line 162) | pub struct JsonExtractFut<T> {
  type Output (line 169) | type Output = Result<Json<T>, Error>;
  method poll (line 171) | fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
  type JsonConfig (line 232) | pub struct JsonConfig {
    method limit (line 241) | pub fn limit(mut self, limit: usize) -> Self {
    method error_handler (line 247) | pub fn error_handler<F>(mut self, f: F) -> Self
    method content_type (line 256) | pub fn content_type<F>(mut self, predicate: F) -> Self
    method content_type_required (line 265) | pub fn content_type_required(mut self, content_type_required: bool) ->...
    method from_req (line 272) | fn from_req(req: &HttpRequest) -> &Self {
  constant DEFAULT_LIMIT (line 279) | const DEFAULT_LIMIT: usize = 2_097_152;
  constant DEFAULT_CONFIG (line 282) | const DEFAULT_CONFIG: JsonConfig = JsonConfig {
  method default (line 290) | fn default() -> Self {
  type JsonBody (line 304) | pub enum JsonBody<T> {
  function new (line 324) | pub fn new(
  function limit (line 376) | pub fn limit(self, limit: usize) -> Self {
  type Output (line 407) | type Output = Result<T, JsonPayloadError>;
  method poll (line 409) | fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
  type MyObject (line 459) | struct MyObject {
  function json_eq (line 463) | fn json_eq(err: JsonPayloadError, other: JsonPayloadError) -> bool {
  function test_responder (line 477) | async fn test_responder() {
  function test_custom_error_responder (line 493) | async fn test_custom_error_responder() {
  function test_extract (line 523) | async fn test_extract() {
  function test_json_body (line 583) | async fn test_json_body() {
  function test_with_json_and_bad_content_type (line 659) | async fn test_with_json_and_bad_content_type() {
  function test_with_json_and_good_custom_content_type (line 678) | async fn test_with_json_and_good_custom_content_type() {
  function test_with_json_and_bad_custom_content_type (line 699) | async fn test_with_json_and_bad_custom_content_type() {
  function test_json_with_no_content_type (line 720) | async fn test_json_with_no_content_type() {
  function test_json_ignoring_content_type (line 735) | async fn test_json_ignoring_content_type() {
  function test_with_config_in_data_wrapper (line 754) | async fn test_with_config_in_data_wrapper() {

FILE: actix-web/src/types/path.rs
  type Path (line 57) | pub struct Path<T>(T);
  function into_inner (line 61) | pub fn into_inner(self) -> T {
  type Error (line 71) | type Error = Error;
  type Future (line 72) | type Future = Ready<Result<Self, Self::Error>>;
  method from_request (line 75) | fn from_request(req: &HttpRequest, _: &mut Payload) -> Self::Future {
  type PathConfig (line 136) | pub struct PathConfig {
    method error_handler (line 143) | pub fn error_handler<F>(mut self, f: F) -> Self
  type MyStruct (line 163) | struct MyStruct {
  type Test2 (line 169) | struct Test2 {
  function test_extract_path_single (line 175) | async fn test_extract_path_single() {
  function test_tuple_extract (line 188) | async fn test_tuple_extract() {
  function test_request_extract (line 214) | async fn test_request_extract() {
  function paths_decoded (line 262) | async fn paths_decoded() {
  function test_custom_err_handler (line 275) | async fn test_custom_err_handler() {

FILE: actix-web/src/types/payload.rs
  type Payload (line 46) | pub struct Payload(dev::Payload);
    method into_inner (line 51) | pub fn into_inner(self) -> dev::Payload {
    method to_bytes_limited (line 82) | pub async fn to_bytes_limited(
    method to_bytes (line 116) | pub async fn to_bytes(self) -> crate::Result<Bytes> {
  type Item (line 123) | type Item = Result<Bytes, PayloadError>;
  method poll_next (line 126) | fn poll_next(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Opt...
  type Error (line 133) | type Error = Error;
  type Future (line 134) | type Future = Ready<Result<Self, Self::Error>>;
  method from_request (line 137) | fn from_request(_: &HttpRequest, payload: &mut dev::Payload) -> Self::Fu...
  type Error (line 159) | type Error = Error;
  type Future (line 160) | type Future = Either<BytesExtractFut, Ready<Result<Bytes, Error>>>;
  method from_request (line 163) | fn from_request(req: &HttpRequest, payload: &mut dev::Payload) -> Self::...
  type BytesExtractFut (line 178) | pub struct BytesExtractFut {
  type Output (line 183) | type Output = Result<Bytes, Error>;
  method poll (line 185) | fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Ou...
  type Error (line 206) | type Error = Error;
  type Future (line 207) | type Future = Either<StringExtractFut, Ready<Result<String, Error>>>;
  method from_request (line 210) | fn from_request(req: &HttpRequest, payload: &mut dev::Payload) -> Self::...
  type StringExtractFut (line 231) | pub struct StringExtractFut {
  type Output (line 237) | type Output = Result<String, Error>;
  method poll (line 239) | fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Ou...
  function bytes_to_string (line 249) | fn bytes_to_string(body: Bytes, encoding: &'static Encoding) -> Result<S...
  type PayloadConfig (line 274) | pub struct PayloadConfig {
    method new (line 281) | pub fn new(limit: usize) -> Self {
    method limit (line 289) | pub fn limit(mut self, limit: usize) -> Self {
    method mimetype (line 295) | pub fn mimetype(mut self, mt: Mime) -> Self {
    method check_mimetype (line 300) | fn check_mimetype(&self, req: &HttpRequest) -> Result<(), Error> {
    method from_req (line 323) | fn from_req(req: &HttpRequest) -> &Self {
  constant DEFAULT_CONFIG_LIMIT (line 330) | const DEFAULT_CONFIG_LIMIT: usize = 262_144;
  constant DEFAULT_CONFIG (line 333) | const DEFAULT_CONFIG: PayloadConfig = PayloadConfig {
  method default (line 339) | fn default() -> Self {
  type HttpMessageBody (line 348) | pub struct HttpMessageBody {
    method new (line 362) | pub fn new(req: &HttpRequest, payload: &mut dev::Payload) -> HttpMessa...
    method limit (line 401) | pub fn limit(mut self, limit: usize) -> Self {
  type Output (line 415) | type Output = Result<Bytes, PayloadError>;
  method poll (line 417) | fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
  function payload_to_bytes (line 451) | async fn payload_to_bytes() {
  function test_payload_config (line 494) | async fn test_payload_config() {
  function test_config_recall_locations (line 513) | async fn test_config_recall_locations() {
  function test_bytes (line 589) | async fn test_bytes() {
  function test_string (line 600) | async fn test_string() {
  function test_message_body (line 611) | async fn test_message_body() {

FILE: actix-web/src/types/query.rs
  type Query (line 61) | pub struct Query<T>(pub T);
  function into_inner (line 65) | pub fn into_inner(self) -> T {
  function from_query (line 81) | pub fn from_query(query_str: &str) -> Result<Self, QueryPayloadError> {
  type Target (line 89) | type Target = T;
  function deref (line 91) | fn deref(&self) -> &T {
  function deref_mut (line 97) | fn deref_mut(&mut self) -> &mut T {
  function fmt (line 103) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  type Error (line 110) | type Error = Error;
  type Future (line 111) | type Future = Ready<Result<Self, Error>>;
  method from_request (line 114) | fn from_request(req: &HttpRequest, _: &mut Payload) -> Self::Future {
  type QueryConfig (line 171) | pub struct QueryConfig {
    method error_handler (line 178) | pub fn error_handler<F>(mut self, f: F) -> Self
  type Id (line 197) | struct Id {
  function test_service_request_extract (line 202) | async fn test_service_request_extract() {
  function test_request_extract (line 221) | async fn test_request_extract() {
  function test_tuple_panic (line 243) | async fn test_tuple_panic() {
  function test_custom_error_responder (line 253) | async fn test_custom_error_responder() {

FILE: actix-web/src/types/readlines.rs
  type Readlines (line 21) | pub struct Readlines<T: HttpMessage> {
  function new (line 36) | pub fn new(req: &mut T) -> Self {
  function limit (line 53) | pub fn limit(mut self, limit: usize) -> Self {
  function err (line 58) | fn err(err: ReadlinesError) -> Self {
  function decode (line 73) | fn decode(encoding: &'static Encoding, bytes: &[u8]) -> Result<String, R...
  type Item (line 92) | type Item = Result<String, ReadlinesError>;
  method poll_next (line 94) | fn poll_next(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<...
  function test_readlines (line 182) | async fn test_readlines() {
  function test_readlines_limit_across_chunks (line 209) | fn test_readlines_limit_across_chunks() {
  function test_readlines_returns_full_line_across_chunks (line 230) | fn test_readlines_returns_full_line_across_chunks() {

FILE: actix-web/src/web.rs
  function resource (line 60) | pub fn resource<T: IntoPatterns>(path: T) -> Resource {
  function scope (line 93) | pub fn scope(path: &str) -> Scope {
  function route (line 98) | pub fn route() -> Route {
  function method (line 144) | pub fn method(method: Method) -> Route {
  function to (line 162) | pub fn to<F, Args>(handler: F) -> Route
  function service (line 186) | pub fn service<T: IntoPatterns>(path: T) -> WebService {
  function redirect (line 202) | pub fn redirect(from: impl Into<Cow<'static, str>>, to: impl Into<Cow<'s...
  function block (line 208) | pub fn block<F, R>(f: F) -> impl Future<Output = Result<R, BlockingError>>

FILE: actix-web/tests/compression.rs
  function negotiate_encoding_identity (line 75) | async fn negotiate_encoding_identity() {
  function negotiate_encoding_gzip (line 94) | async fn negotiate_encoding_gzip() {
  function negotiate_encoding_br (line 123) | async fn negotiate_encoding_br() {
  function negotiate_encoding_zstd (line 170) | async fn negotiate_encoding_zstd() {
  function client_encoding_prefers_brotli (line 204) | async fn client_encoding_prefers_brotli() {
  function gzip_no_decompress (line 220) | async fn gzip_no_decompress() {
  function manual_custom_coding (line 242) | async fn manual_custom_coding() {
  function deny_identity_coding (line 264) | async fn deny_identity_coding() {
  function deny_identity_coding_no_decompress (line 284) | async fn deny_identity_coding_no_decompress() {
  function deny_identity_for_manual_coding (line 309) | async fn deny_identity_for_manual_coding() {

FILE: actix-web/tests/introspection.rs
  function introspection_handler (line 5) | async fn introspection_handler(
  function externals_handler (line 13) | async fn externals_handler(
  function find_item (line 21) | fn find_item<'a>(items: &'a [serde_json::Value], path: &str) -> &'a serd...
  function find_external (line 28) | fn find_external<'a>(items: &'a [serde_json::Value], name: &str) -> &'a ...
  function introspection_report_includes_details_and_metadata (line 36) | async fn introspection_report_includes_details_and_metadata() {

FILE: actix-web/tests/test-macro-import-conflict.rs
  function test_macro_naming_conflict (line 12) | async fn test_macro_naming_conflict() {

FILE: actix-web/tests/test_error_propagation.rs
  type MyError (line 14) | pub struct MyError;
    method fmt (line 19) | fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
  function test (line 25) | async fn test() -> Result<actix_web::HttpResponse, actix_web::error::Err...
  type SpyMiddleware (line 30) | pub struct SpyMiddleware(Arc<Mutex<Option<bool>>>);
    type Response (line 38) | type Response = ServiceResponse<B>;
    type Error (line 39) | type Error = actix_web::Error;
    type Transform (line 40) | type Transform = Middleware<S>;
    type InitError (line 41) | type InitError = ();
    type Future (line 42) | type Future = Ready<Result<Self::Transform, Self::InitError>>;
    method new_transform (line 44) | fn new_transform(&self, service: S) -> Self::Future {
  type Middleware (line 53) | pub struct Middleware<S> {
  type Response (line 64) | type Response = ServiceResponse<B>;
  type Error (line 65) | type Error = actix_web::Error;
  type Future (line 66) | type Future = LocalBoxFuture<'static, Result<Self::Response, Self::Error>>;
  function call (line 70) | fn call(&self, req: ServiceRequest) -> Self::Future {
  function error_cause_should_be_propagated_to_middlewares (line 84) | async fn error_cause_should_be_propagated_to_middlewares() {

FILE: actix-web/tests/test_httpserver.rs
  function test_start (line 9) | async fn test_start() {
  function ssl_acceptor (line 78) | fn ssl_acceptor() -> openssl::ssl::SslAcceptorBuilder {
  function test_start_ssl (line 102) | async fn test_start_ssl() {
  function assert_tcp_nodelay_config (line 157) | async fn assert_tcp_nodelay_config(nodelay: bool) {
  function test_tcp_nodelay_enabled (line 212) | async fn test_tcp_nodelay_enabled() {
  function test_tcp_nodelay_disabled (line 217) | async fn test_tcp_nodelay_disabled() {

FILE: actix-web/tests/test_server.rs
  constant S (line 32) | const S: &str = "Hello World ";
  constant STR (line 33) | const STR: &str = const_str::repeat!(S, 100);
  function openssl_config (line 36) | fn openssl_config() -> SslAcceptor {
  type TestBody (line 62) | struct TestBody {
    method new (line 69) | fn new(data: Bytes, chunk_size: usize) -> Self {
    type Item (line 79) | type Item = Result<Bytes, Error>;
    method poll_next (line 81) | fn poll_next(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<O...
  function test_body (line 96) | async fn test_body() {
  function body_gzip_large (line 159) | async fn body_gzip_large() {
  function test_body_gzip_large_random (line 190) | async fn test_body_gzip_large_random() {
  function test_body_chunked_implicit (line 220) | async fn test_body_chunked_implicit() {
  function test_body_br_streaming (line 249) | async fn test_body_br_streaming() {
  function test_head_binary (line 274) | async fn test_head_binary() {
  function test_no_chunking (line 295) | async fn test_no_chunking() {
  function test_body_deflate (line 315) | async fn test_body_deflate() {
  function test_body_brotli (line 338) | async fn test_body_brotli() {
  function test_body_zstd (line 361) | async fn test_body_zstd() {
  function test_body_zstd_streaming (line 384) | async fn test_body_zstd_streaming() {
  function test_zstd_encoding (line 409) | async fn test_zstd_encoding() {
  function test_zstd_encoding_large (line 430) | async fn test_zstd_encoding_large() {
  function test_encoding (line 457) | async fn test_encoding() {
  function test_gzip_encoding (line 480) | async fn test_gzip_encoding() {
  function test_gzip_encoding_large (line 501) | async fn test_gzip_encoding_large() {
  function test_reading_gzip_encoding_large_random (line 523) | async fn test_reading_gzip_encoding_large_random() {
  function test_reading_deflate_encoding (line 546) | async fn test_reading_deflate_encoding() {
  function test_reading_deflate_encoding_large (line 567) | async fn test_reading_deflate_encoding_large() {
  function test_reading_deflate_encoding_large_random (line 589) | async fn test_reading_deflate_encoding_large_random() {
  function test_brotli_encoding (line 613) | async fn test_brotli_encoding() {
  function test_brotli_encoding_large (line 634) | async fn test_brotli_encoding_large() {
  function test_brotli_encoding_large_openssl (line 662) | async fn test_brotli_encoding_large_openssl() {
  function tls_config (line 696) | fn tls_config() -> RustlsServerConfig {
  function test_reading_deflate_encoding_large_random_rustls (line 709) | async fn test_reading_deflate_encoding_large_random_rustls() {
  function test_server_cookies (line 741) | async fn test_server_cookies() {
  function test_slow_request (line 798) | async fn test_slow_request() {
  function test_normalize (line 821) | async fn test_normalize() {
  function test_data_drop (line 837) | async fn test_data_drop() {
  function test_accept_encoding_no_match (line 885) | async fn test_accept_encoding_no_match() {

FILE: actix-web/tests/test_streaming_response.rs
  type FixedSizeStream (line 13) | struct FixedSizeStream {
    method new (line 19) | fn new(size: usize) -> Self {
  type Item (line 28) | type Item = Result<Bytes, std::io::Error>;
  method poll_next (line 30) | fn poll_next(mut self: Pin<&mut Self>, _: &mut Context<'_>) -> Poll<Opti...
  function test_streaming_response_with_content_length (line 42) | async fn test_streaming_response_with_content_length() {
  function test_streaming_response_default_content_type (line 75) | async fn test_streaming_response_default_content_type() {
  function test_streaming_response_user_defined_content_type (line 88) | async fn test_streaming_response_user_defined_content_type() {
  function test_streaming_response_empty_stream (line 103) | async fn test_streaming_response_empty_stream() {

FILE: actix-web/tests/utils.rs
  function encode (line 11) | pub fn encode(bytes: impl AsRef<[u8]>) -> Vec<u8> {
  function decode (line 17) | pub fn decode(bytes: impl AsRef<[u8]>) -> Vec<u8> {
  function encode (line 30) | pub fn encode(bytes: impl AsRef<[u8]>) -> Vec<u8> {
  function decode (line 36) | pub fn decode(bytes: impl AsRef<[u8]>) -> Vec<u8> {
  function encode (line 49) | pub fn encode(bytes: impl AsRef<[u8]>) -> Vec<u8> {
  function decode (line 61) | pub fn decode(bytes: impl AsRef<[u8]>) -> Vec<u8> {
  function encode (line 74) | pub fn encode(bytes: impl AsRef<[u8]>) -> Vec<u8> {
  function decode (line 80) | pub fn decode(bytes: impl AsRef<[u8]>) -> Vec<u8> {

FILE: awc/examples/client.rs
  function main (line 11) | async fn main() -> Result<(), Box<dyn StdError>> {

FILE: awc/src/any_body.rs
  method none (line 29) | pub fn none() -> Self {
  method empty (line 34) | pub fn empty() -> Self {
  method new_boxed (line 39) | pub fn new_boxed<B>(body: B) -> Self
  method copy_from_slice (line 49) | pub fn copy_from_slice(s: &[u8]) -> Self {
  method from_slice (line 57) | pub fn from_slice(s: &[u8]) -> Self {
  function new (line 66) | pub fn new(body: B) -> Self {
  function from_message_body (line 78) | pub fn from_message_body(body: B) -> Self
  function into_boxed (line 92) | pub fn into_boxed(self) -> AnyBody {
  type Error (line 105) | type Error = crate::BoxError;
  method size (line 107) | fn size(&self) -> BodySize {
  method poll_next (line 115) | fn poll_next(
  method eq (line 136) | fn eq(&self, other: &AnyBody) -> bool {
  function fmt (line 149) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  type PinType (line 167) | struct PinType(PhantomPinned);
  type Error (line 170) | type Error = crate::BoxError;
  method size (line 172) | fn size(&self) -> BodySize {
  method poll_next (line 176) | fn poll_next(

FILE: awc/src/builder.rs
  type ClientBuilder (line 26) | pub struct ClientBuilder<S = (), M = ()> {
    method new (line 47) | pub fn new() -> ClientBuilder<
  function connector (line 78) | pub fn connector<S1, Io1>(self, connector: Connector<S1>) -> ClientBuild...
  function timeout (line 103) | pub fn timeout(mut self, timeout: Duration) -> Self {
  function disable_timeout (line 109) | pub fn disable_timeout(mut self) -> Self {
  function local_address (line 115) | pub fn local_address(mut self, addr: IpAddr) -> Self {
  function max_http_version (line 123) | pub fn max_http_version(mut self, val: http::Version) -> Self {
  function disable_redirects (line 131) | pub fn disable_redirects(mut self) -> Self {
  function max_redirects (line 139) | pub fn max_redirects(mut self, num: u8) -> Self {
  function initial_window_size (line 148) | pub fn initial_window_size(mut self, size: u32) -> Self {
  function initial_connection_window_size (line 157) | pub fn initial_connection_window_size(mut self, size: u32) -> Self {
  function no_default_headers (line 165) | pub fn no_default_headers(mut self) -> Self {
  function add_default_header (line 176) | pub fn add_default_header(mut self, header: impl TryIntoHeaderPair) -> S...
  function header (line 187) | pub fn header<K, V>(mut self, key: K, value: V) -> Self
  function basic_auth (line 207) | pub fn basic_auth<N>(self, username: N, password: Option<&str>) -> Self
  function bearer_auth (line 222) | pub fn bearer_auth<T>(self, token: T) -> Self
  function wrap (line 232) | pub fn wrap<S1, M1>(self, mw: M1) -> ClientBuilder<S, NestTransform<M, M...
  function finish (line 252) | pub fn finish(self) -> Client
  function _finish (line 267) | fn _finish(self) -> Client
  function client_basic_auth (line 303) | fn client_basic_auth() {
  function client_bearer_auth (line 328) | fn client_bearer_auth() {

FILE: awc/src/client/config.rs
  constant DEFAULT_H2_CONN_WINDOW (line 3) | const DEFAULT_H2_CONN_WINDOW: u32 = 1024 * 1024 * 2;
  constant DEFAULT_H2_STREAM_WINDOW (line 4) | const DEFAULT_H2_STREAM_WINDOW: u32 = 1024 * 1024;
  type ConnectorConfig (line 8) | pub(crate) struct ConnectorConfig {
    method no_disconnect_timeout (line 37) | pub(crate) fn no_disconnect_timeout(&self) -> Self {
  method default (line 21) | fn default() -> Self {

FILE: awc/src/client/connection.rs
  type ConnectionIo (line 20) | pub trait ConnectionIo: AsyncRead + AsyncWrite + Unpin + 'static {}
  type H1Connection (line 25) | pub struct H1Connection<Io: ConnectionIo> {
  function on_release (line 33) | pub(super) fn on_release(&mut self, keep_alive: bool) {
  function close (line 42) | fn close(&mut self) {
  function release (line 48) | fn release(&mut self) {
  function io_pin_mut (line 54) | fn io_pin_mut(self: Pin<&mut Self>) -> Pin<&mut Io> {
  method poll_read (line 60) | fn poll_read(
  method poll_write (line 70) | fn poll_write(
  method poll_flush (line 78) | fn poll_flush(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<io::Re...
  method poll_shutdown (line 82) | fn poll_shutdown(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Res...
  method poll_write_vectored (line 86) | fn poll_write_vectored(
  method is_write_vectored (line 94) | fn is_write_vectored(&self) -> bool {
  type H2Connection (line 100) | pub struct H2Connection<Io: ConnectionIo> {
  type Target (line 107) | type Target = SendRequest<Bytes>;
  method deref (line 109) | fn deref(&self) -> &Self::Target {
  method deref_mut (line 115) | fn deref_mut(&mut self) -> &mut Self::Target {
  function on_release (line 122) | pub(super) fn on_release(&mut self, close: bool) {
  function close (line 131) | fn close(&mut self) {
  function release (line 137) | fn release(&mut self) {
  type H2ConnectionInner (line 148) | pub(super) struct H2ConnectionInner {
    method new (line 154) | pub(super) fn new<Io: ConnectionIo>(
  method drop (line 168) | fn drop(&mut self) {
  type Connection (line 182) | pub enum Connection<A, B = Box<dyn ConnectionIo>>
  type ConnectionType (line 192) | pub enum ConnectionType<Io: ConnectionIo> {
  type ConnectionInnerType (line 198) | pub(super) enum ConnectionInnerType<Io> {
  function from_pool (line 204) | pub(super) fn from_pool(
  function from_h1 (line 215) | pub(super) fn from_h1(io: Io, created: time::Instant, acquired: Acquired...
  function from_h2 (line 223) | pub(super) fn from_h2(
  function send_request (line 242) | pub fn send_request<RB, H>(
  function open_tunnel (line 271) | pub fn open_tunnel<H: Into<RequestHeadType> + 'static>(
  method poll_read (line 305) | fn poll_read(
  constant H2_UNREACHABLE_WRITE (line 318) | const H2_UNREACHABLE_WRITE: &str = "H2Connection can not impl AsyncWrite...
  method poll_write (line 325) | fn poll_write(
  method poll_flush (line 337) | fn poll_flush(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<io::Re...
  method poll_shutdown (line 345) | fn poll_shutdown(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<io:...
  method poll_write_vectored (line 353) | fn poll_write_vectored(
  method is_write_vectored (line 369) | fn is_write_vectored(&self) -> bool {
  function test_h2_connection_drop (line 394) | async fn test_h2_connection_drop() {

FILE: awc/src/client/connector.rs
  type OurTlsConnector (line 33) | enum OurTlsConnector {
  type Connector (line 78) | pub struct Connector<T> {
  function new (line 96) | pub fn new() -> Connector<
  function connector (line 214) | pub fn connector<S1, Io1>(self, connector: S1) -> Connector<S1>
  function timeout (line 247) | pub fn timeout(mut self, timeout: Duration) -> Self {
  function handshake_timeout (line 258) | pub fn handshake_timeout(mut self, timeout: Duration) -> Self {
  function openssl (line 265) | pub fn openssl(
  function ssl (line 277) | pub fn ssl(mut self, connector: actix_tls::connect::openssl::reexports::...
  function rustls (line 284) | pub fn rustls(
  function rustls_021 (line 294) | pub fn rustls_021(
  function rustls_0_22 (line 307) | pub fn rustls_0_22(
  function rustls_0_23 (line 325) | pub fn rustls_0_23(
  function max_http_version (line 336) | pub fn max_http_version(mut self, val: http::Version) -> Self {
  function initial_window_size (line 352) | pub fn initial_window_size(mut self, size: u32) -> Self {
  function initial_connection_window_size (line 361) | pub fn initial_connection_window_size(mut self, size: u32) -> Self {
  function limit (line 371) | pub fn limit(mut self, limit: usize) -> Self {
  function conn_keep_alive (line 387) | pub fn conn_keep_alive(mut self, dur: Duration) -> Self {
  function conn_lifetime (line 397) | pub fn conn_lifetime(mut self, dur: Duration) -> Self {
  function disconnect_timeout (line 410) | pub fn disconnect_timeout(mut self, dur: Duration) -> Self {
  function local_address (line 416) | pub fn local_address(mut self, addr: IpAddr) -> Self {
  function finish (line 424) | pub fn finish(self) -> ConnectorService<S, IO> {
  type TcpConnectorService (line 698) | pub struct TcpConnectorService<S: Clone> {
  type Response (line 706) | type Response = (Io, Protocol);
  type Error (line 707) | type Error = ConnectError;
  type Future (line 708) | type Future = TcpConnectorFuture<S::Future>;
    type Output (line 731) | type Output = Result<(Io, Protocol), ConnectError>;
    method poll (line 733) | fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Outp...
    type Output (line 836) | type Output = Result<(Box<dyn ConnectionIo>, Protocol), ConnectError>;
    method poll (line 838) | fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::...
    type Output (line 921) | type Output = Result<TcpConnection<Uri, Io>, ConnectError>;
    method poll (line 923) | fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Outp...
    type Output (line 1027) | type Output = Result<Connection<Io1, Io2>, ConnectError>;
    method poll (line 1029) | fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Outp...
  function call (line 712) | fn call(&self, req: Connect) -> Self::Future {
  type TlsConnectorService (line 754) | struct TlsConnectorService<Tcp, Tls> {
  type Response (line 781) | type Response = (Box<dyn ConnectionIo>, Protocol);
  type Error (line 782) | type Error = ConnectError;
  type Future (line 783) | type Future = TlsConnectorFuture<Tls, Tcp::Future, Tls::Future>;
    type Output (line 731) | type Output = Result<(Io, Protocol), ConnectError>;
    method poll (line 733) | fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Outp...
    type Output (line 836) | type Output = Result<(Box<dyn ConnectionIo>, Protocol), ConnectError>;
    method poll (line 838) | fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::...
    type Output (line 921) | type Output = Result<TcpConnection<Uri, Io>, ConnectError>;
    method poll (line 923) | fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Outp...
    type Output (line 1027) | type Output = Result<Connection<Io1, Io2>, ConnectError>;
    method poll (line 1029) | fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Outp...
  function poll_ready (line 785) | fn poll_ready(&self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Erro...
  function call (line 791) | fn call(&self, req: Connect) -> Self::Future {
  type IntoConnectionIo (line 824) | trait IntoConnectionIo {
    method into_connection_io (line 825) | fn into_connection_io(self) -> (Box<dyn ConnectionIo>, Protocol);
  type TcpConnectorInnerService (line 865) | pub struct TcpConnectorInnerService<S: Clone> {
  function new (line 872) | fn new(service: S, timeout: Duration, local_address: Option<std::net::Ip...
  type Response (line 887) | type Response = S::Response;
  type Error (line 888) | type Error = ConnectError;
  type Future (line 889) | type Future = TcpConnectorInnerFuture<S::Future>;
    type Output (line 731) | type Output = Result<(Io, Protocol), ConnectError>;
    method poll (line 733) | fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Outp...
    type Output (line 836) | type Output = Result<(Box<dyn ConnectionIo>, Protocol), ConnectError>;
    method poll (line 838) | fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::...
    type Output (line 921) | type Output = Result<TcpConnection<Uri, Io>, ConnectError>;
    method poll (line 923) | fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Outp...
    type Output (line 1027) | type Output = Result<Connection<Io1, Io2>, ConnectError>;
    method poll (line 1029) | fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Outp...
  function call (line 893) | fn call(&self, req: Connect) -> Self::Future {
  type ConnectorService (line 933) | pub type ConnectorService<Svc, IO> = ConnectorServicePriv<
  type ConnectorServicePriv (line 950) | pub struct ConnectorServicePriv<S1, S2, Io1, Io2>
  type Response (line 968) | type Response = Connection<Io1, Io2>;
  type Error (line 969) | type Error = ConnectError;
  type Future (line 970) | type Future = ConnectorServiceFuture<S1, S2, Io1, Io2>;
    type Output (line 731) | type Output = Result<(Io, Protocol), ConnectError>;
    method poll (line 733) | fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Outp...
    type Output (line 836) | type Output = Result<(Box<dyn ConnectionIo>, Protocol), ConnectError>;
    method poll (line 838) | fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::...
    type Output (line 921) | type Output = Result<TcpConnection<Uri, Io>, ConnectError>;
    method poll (line 923) | fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Outp...
    type Output (line 1027) | type Output = Result<Connection<Io1, Io2>, ConnectError>;
    method poll (line 1029) | fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Outp...
  function poll_ready (line 972) | fn poll_ready(&self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Erro...
  function call (line 980) | fn call(&self, req: Connect) -> Self::Future {
  function resolver (line 1044) | pub(super) fn resolver() -> Resolver {
  function resolver (line 1063) | pub(super) fn resolver() -> Resolver {
  function h2c_connector (line 1129) | async fn h2c_connector() {

FILE: awc/src/client/error.rs
  type ConnectError (line 13) | pub enum ConnectError {
    method from (line 55) | fn from(err: actix_tls::connect::ConnectError) -> ConnectError {
  type InvalidUrl (line 68) | pub enum InvalidUrl {
  type SendRequestError (line 87) | pub enum SendRequestError {
    method from (line 148) | fn from(err: FreezeRequestError) -> Self {
  type FreezeRequestError (line 131) | pub enum FreezeRequestError {

FILE: awc/src/client/h1proto.rs
  function send_request (line 27) | pub(crate) async fn send_request<Io, B>(
  function open_tunnel (line 168) | pub(crate) async fn open_tunnel<Io>(
  function send_body (line 188) | pub(crate) async fn send_body<Io, B>(
  function new (line 245) | fn new(framed: Framed<H1Connection<Io>, h1::ClientCodec>) -> Self {
  type Item (line 253) | type Item = Result<Bytes, PayloadError>;
  method poll_next (line 255) | fn poll_next(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<...

FILE: awc/src/client/h2proto.rs
  function send_request (line 28) | pub(crate) async fn send_request<Io, B>(
  function send_body (line 138) | async fn send_body<B>(body: B, mut send: SendStream<Bytes>) -> Result<()...
  function handshake (line 187) | pub(crate) fn handshake<Io: ConnectionIo>(

FILE: awc/src/client/mod.rs
  type Connect (line 29) | pub struct Connect {
  type Client (line 56) | pub struct Client(pub(crate) ClientConfig);
    method new (line 73) | pub fn new() -> Client {
    method builder (line 80) | pub fn builder() -> ClientBuilder<
    method request (line 91) | pub fn request<U>(&self, method: Method, url: U) -> ClientRequest
    method request_from (line 109) | pub fn request_from<U>(&self, url: U, head: &RequestHead) -> ClientReq...
    method get (line 122) | pub fn get<U>(&self, url: U) -> ClientRequest
    method head (line 131) | pub fn head<U>(&self, url: U) -> ClientRequest
    method put (line 140) | pub fn put<U>(&self, url: U) -> ClientRequest
    method post (line 149) | pub fn post<U>(&self, url: U) -> ClientRequest
    method patch (line 158) | pub fn patch<U>(&self, url: U) -> ClientRequest
    method delete (line 167) | pub fn delete<U>(&self, url: U) -> ClientRequest
    method options (line 176) | pub fn options<U>(&self, url: U) -> ClientRequest
    method ws (line 186) | pub fn ws<U>(&self, url: U) -> ws::WebsocketsRequest
    method headers (line 202) | pub fn headers(&mut self) -> Option<&mut HeaderMap> {
  type ClientConfig (line 59) | pub(crate) struct ClientConfig {
  method default (line 66) | fn default() -> Self {

FILE: awc/src/client/pool.rs
  type Key (line 35) | pub struct Key {
    method from (line 40) | fn from(authority: Authority) -> Key {
  type ConnectionPool (line 47) | pub struct ConnectionPool<S, Io>
  type ConnectionPoolInner (line 56) | pub struct ConnectionPoolInner<Io>(Rc<ConnectionPoolInnerPriv<Io>>)
  function new (line 64) | fn new(config: ConnectorConfig) -> Self {
  function close (line 76) | fn close(&self, conn: ConnectionInnerType<Io>) {
  method clone (line 91) | fn clone(&self) -> Self {
  type Target (line 100) | type Target = ConnectionPoolInnerPriv<Io>;
  method deref (line 102) | fn deref(&self) -> &Self::Target {
  method drop (line 111) | fn drop(&mut self) {
  type ConnectionPoolInnerPriv (line 125) | pub struct ConnectionPoolInnerPriv<Io>
  function new (line 148) | pub(crate) fn new(connector: S, config: ConnectorConfig) -> Self {
  type Response (line 160) | type Response = ConnectionType<Io>;
  type Error (line 161) | type Error = ConnectError;
  type Future (line 162) | type Future = LocalBoxFuture<'static, Result<Self::Response, Self::Error>>;
    type Output (line 279) | type Output = ConnectionState;
    method poll (line 283) | fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Outp...
    type Output (line 330) | type Output = ();
    method poll (line 332) | fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<()> {
  function call (line 166) | fn call(&self, req: Connect) -> Self::Future {
  type ConnectionCheckFuture (line 260) | struct ConnectionCheckFuture<'a, Io> {
  type ConnectionState (line 264) | enum ConnectionState {
  type PooledConnection (line 299) | struct PooledConnection<Io> {
  function new (line 318) | fn new(io: Io, timeout: Duration) -> Self {
  type Acquired (line 342) | pub struct Acquired<Io>
  function close (line 356) | pub(super) fn close(&self, conn: ConnectionInnerType<Io>) {
  function release (line 361) | pub(super) fn release(&self, conn: ConnectionInnerType<Io>, created: Ins...
  type TestStream (line 390) | struct TestStream(Rc<Cell<usize>>);
  method drop (line 393) | fn drop(&mut self) {
  method poll_read (line 399) | fn poll_read(
  method poll_write (line 409) | fn poll_write(
  method poll_flush (line 417) | fn poll_flush(self: Pin<&mut Self>, _: &mut Context<'_>) -> Poll<io::Res...
  method poll_shutdown (line 421) | fn poll_shutdown(self: Pin<&mut Self>, _: &mut Context<'_>) -> Poll<io::...
  type TestPoolConnector (line 427) | struct TestPoolConnector {
    type Response (line 432) | type Response = (TestStream, Protocol);
    type Error (line 433) | type Error = ConnectError;
    type Future (line 434) | type Future = LocalBoxFuture<'static, Result<Self::Response, Self::Err...
    method call (line 438) | fn call(&self, _: Connect) -> Self::Future {
  function release (line 445) | fn release<T>(conn: ConnectionType<T>)
  function test_pool_limit (line 456) | async fn test_pool_limit() {
  function test_pool_keep_alive (line 495) | async fn test_pool_keep_alive() {
  function test_pool_lifetime (line 537) | async fn test_pool_lifetime() {
  function test_pool_authority_key (line 579) | async fn test_pool_authority_key() {
  function test_pool_drop (line 616) | async fn test_pool_drop() {

FILE: awc/src/connect.rs
  type BoxConnectorService (line 20) | pub type BoxConnectorService = Rc<
  type BoxedSocket (line 29) | pub type BoxedSocket = Box<dyn ConnectionIo>;
  type ConnectRequest (line 32) | pub enum ConnectRequest {
  type ConnectResponse (line 45) | pub enum ConnectResponse {
    method into_client_response (line 60) | pub fn into_client_response(self) -> ClientResponse {
    method into_tunnel_response (line 73) | pub fn into_tunnel_response(self) -> (ResponseHead, Framed<BoxedSocket...
  type DefaultConnector (line 83) | pub struct DefaultConnector<S> {
  function new (line 88) | pub(crate) fn new(connector: S) -> Self {
  type Response (line 98) | type Response = ConnectResponse;
  type Error (line 99) | type Error = SendRequestError;
  type Future (line 100) | type Future = ConnectRequestFuture<S::Future, Io>;
    type Output (line 152) | type Output = Result<ConnectResponse, SendRequestError>;
    method poll (line 154) | fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::...
  function call (line 104) | fn call(&self, req: ConnectRequest) -> Self::Future {

FILE: awc/src/error.rs
  type WsClientError (line 19) | pub enum WsClientError {
    method from (line 56) | fn from(err: InvalidUrl) -> Self {
    method from (line 62) | fn from(err: HttpError) -> Self {
  type JsonPayloadError (line 69) | pub enum JsonPayloadError {

FILE: awc/src/frozen.rs
  type FrozenClientRequest (line 23) | pub struct FrozenClientRequest {
    method get_uri (line 33) | pub fn get_uri(&self) -> &Uri {
    method get_method (line 38) | pub fn get_method(&self) -> &Method {
    method headers (line 43) | pub fn headers(&self) -> &HeaderMap {
    method send_body (line 48) | pub fn send_body<B>(&self, body: B) -> SendClientRequest
    method send_json (line 62) | pub fn send_json<T: Serialize>(&self, value: &T) -> SendClientRequest {
    method send_form (line 73) | pub fn send_form<T: Serialize>(&self, value: &T) -> SendClientRequest {
    method send_stream (line 84) | pub fn send_stream<S, E>(&self, stream: S) -> SendClientRequest
    method send (line 99) | pub fn send(&self) -> SendClientRequest {
    method extra_headers (line 109) | pub fn extra_headers(&self, extra_headers: HeaderMap) -> FrozenSendBui...
    method extra_header (line 114) | pub fn extra_header(&self, header: impl TryIntoHeaderPair) -> FrozenSe...
  type FrozenSendBuilder (line 120) | pub struct FrozenSendBuilder {
    method new (line 127) | pub(crate) fn new(req: FrozenClientRequest, extra_headers: HeaderMap) ...
    method extra_header (line 136) | pub fn extra_header(mut self, header: impl TryIntoHeaderPair) -> Self {
    method send_body (line 149) | pub fn send_body(self, body: impl MessageBody + 'static) -> SendClient...
    method send_json (line 164) | pub fn send_json(self, value: impl Serialize) -> SendClientRequest {
    method send_form (line 179) | pub fn send_form(self, value: impl Serialize) -> SendClientRequest {
    method send_stream (line 194) | pub fn send_stream<S, E>(self, stream: S) -> SendClientRequest
    method send (line 213) | pub fn send(self) -> SendClientRequest {

FILE: awc/src/lib.rs
  type BoxError (line 148) | pub(crate) type BoxError = Box<dyn std::error::Error>;

FILE: awc/src/middleware/mod.rs
  type Transform (line 11) | pub trait Transform<S, Req> {
    method new_transform (line 15) | fn new_transform(self, service: S) -> Self::Transform;
  type NestTransform (line 24) | pub struct NestTransform<T1, T2, S, Req>
  function new (line 39) | pub(crate) fn new(child: T1, parent: T2) -> Self {
  type Transform (line 53) | type Transform = T2::Transform;
    method new_transform (line 15) | fn new_transform(self, service: S) -> Self::Transform;
  function new_transform (line 55) | fn new_transform(self, service: S) -> Self::Transform {
  type Transform (line 66) | type Transform = S;
    method new_transform (line 15) | fn new_transform(self, service: S) -> Self::Transform;
  function new_transform (line 68) | fn new_transform(self, service: S) -> Self::Transform {

FILE: awc/src/middleware/redirect.rs
  type Redirect (line 22) | pub struct Redirect {
    method new (line 33) | pub fn new() -> Self {
    method max_redirect_times (line 39) | pub fn max_redirect_times(mut self, times: u8) -> Self {
    type Transform (line 49) | type Transform = RedirectService<S>;
    method new_transform (line 51) | fn new_transform(self, service: S) -> Self::Transform {
  method default (line 27) | fn default() -> Self {
  type RedirectService (line 59) | pub struct RedirectService<S> {
  type Response (line 68) | type Response = S::Response;
  type Error (line 69) | type Error = S::Error;
  type Future (line 70) | type Future = RedirectServiceFuture<S>;
    type Output (line 142) | type Output = Result<ConnectResponse, SendRequestError>;
    method poll (line 144) | fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::...
  function call (line 74) | fn call(&self, req: ConnectRequest) -> Self::Future {
  function build_next_uri (line 247) | fn build_next_uri(res: &ClientResponse, prev_uri: &Uri) -> Result<Uri, S...
  function remove_sensitive_headers (line 288) | fn remove_sensitive_headers(headers: &mut header::HeaderMap, prev_uri: &...
  function basic_redirect (line 309) | async fn basic_redirect() {
  function redirect_relative_without_leading_slash (line 335) | async fn redirect_relative_without_leading_slash() {
  function redirect_without_location (line 356) | async fn redirect_without_location() {
  function test_redirect_limit (line 373) | async fn test_redirect_limit() {
  function test_redirect_status_kind_307_308 (line 414) | async fn test_redirect_status_kind_307_308() {
  function test_redirect_status_kind_301_302_303 (line 440) | async fn test_redirect_status_kind_301_302_303() {
  function test_redirect_headers (line 470) | async fn test_redirect_headers() {
  function test_redirect_cross_origin_headers (line 529) | async fn test_redirect_cross_origin_headers() {
  function test_double_slash_redirect (line 594) | async fn test_double_slash_redirect() {
  function test_remove_sensitive_headers (line 629) | async fn test_remove_sensitive_headers() {

FILE: awc/src/request.rs
  type ClientRequest (line 44) | pub struct ClientRequest {
    method new (line 58) | pub(crate) fn new<U>(method: Method, uri: U, config: ClientConfig) -> ...
    method uri (line 79) | pub fn uri<U>(mut self, uri: U) -> Self
    method get_uri (line 92) | pub fn get_uri(&self) -> &Uri {
    method address (line 100) | pub fn address(mut self, addr: net::SocketAddr) -> Self {
    method method (line 107) | pub fn method(mut self, method: Method) -> Self {
    method get_method (line 113) | pub fn get_method(&self) -> &Method {
    method version (line 122) | pub fn version(mut self, version: Version) -> Self {
    method get_version (line 128) | pub fn get_version(&self) -> &Version {
    method get_peer_addr (line 133) | pub fn get_peer_addr(&self) -> &Option<net::SocketAddr> {
    method headers (line 139) | pub fn headers(&self) -> &HeaderMap {
    method headers_mut (line 145) | pub fn headers_mut(&mut self) -> &mut HeaderMap {
    method insert_header (line 150) | pub fn insert_header(mut self, header: impl TryIntoHeaderPair) -> Self {
    method insert_header_if_none (line 162) | pub fn insert_header_if_none(mut self, header: impl TryIntoHeaderPair)...
    method append_header (line 185) | pub fn append_header(mut self, header: impl TryIntoHeaderPair) -> Self {
    method camel_case (line 196) | pub fn camel_case(mut self) -> Self {
    method force_close (line 204) | pub fn force_close(mut self) -> Self {
    method content_type (line 211) | pub fn content_type<V>(mut self, value: V) -> Self
    method content_length (line 227) | pub fn content_length(self, len: u64) -> Self {
    method basic_auth (line 235) | pub fn basic_auth(self, username: impl fmt::Display, password: impl fm...
    method bearer_auth (line 245) | pub fn bearer_auth(self, token: impl fmt::Display) -> Self {
    method cookie (line 265) | pub fn cookie(mut self, cookie: Cookie<'_>) -> Self {
    method no_decompress (line 273) | pub fn no_decompress(mut self) -> Self {
    method timeout (line 282) | pub fn timeout(mut self, timeout: Duration) -> Self {
    method query (line 288) | pub fn query<T: Serialize>(mut self, query: &T) -> Result<Self, serde_...
    method freeze (line 307) | pub fn freeze(self) -> Result<FrozenClientRequest, FreezeRequestError> {
    method send_body (line 322) | pub fn send_body<B>(self, body: B) -> SendClientRequest
    method send_json (line 341) | pub fn send_json<T: Serialize>(self, value: &T) -> SendClientRequest {
    method send_form (line 359) | pub fn send_form<T: Serialize>(self, value: &T) -> SendClientRequest {
    method send_stream (line 375) | pub fn send_stream<S, E>(self, stream: S) -> SendClientRequest
    method send (line 395) | pub fn send(self) -> SendClientRequest {
    method prep_for_sending (line 410) | fn prep_for_sending(#[allow(unused_mut)] mut self) -> Result<Self, Pre...
    method fmt (line 494) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  function test_debug (line 518) | async fn test_debug() {
  function test_basics (line 526) | async fn test_basics() {
  function test_client_header (line 563) | async fn test_client_header() {
  function test_client_header_override (line 581) | async fn test_client_header_override() {
  function client_basic_auth (line 600) | async fn client_basic_auth() {
  function client_bearer_auth (line 625) | async fn client_bearer_auth() {
  function client_query (line 639) | async fn client_query() {

FILE: awc/src/responses/json_body.rs
  function new (line 41) | pub fn new(res: &mut ClientResponse<S>) -> Self {
  function limit (line 75) | pub fn limit(mut self, limit: usize) -> Self {
  type Output (line 89) | type Output = Result<T, JsonPayloadError>;
  method poll (line 91) | fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
  type MyObject (line 126) | struct MyObject {
  function json_eq (line 130) | fn json_eq(err: JsonPayloadError, other: JsonPayloadError) -> bool {
  function read_json_body (line 141) | async fn read_json_body() {

FILE: awc/src/responses/mod.rs
  constant DEFAULT_BODY_LIMIT (line 16) | const DEFAULT_BODY_LIMIT: usize = 2 * 1024 * 1024;
  type ResponseTimeout (line 21) | pub(crate) enum ResponseTimeout {
    method poll_timeout (line 33) | fn poll_timeout(&mut self, cx: &mut Context<'_>) -> Result<(), Payload...
  method default (line 27) | fn default() -> Self {

FILE: awc/src/responses/read_body.rs
  function new (line 22) | pub(crate) fn new(stream: Payload<S>, limit: usize) -> Self {
  type Output (line 35) | type Output = Result<Bytes, PayloadError>;
  method poll (line 37) | fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {

FILE: awc/src/responses/response.rs
  function new (line 37) | pub(crate) fn new(head: ResponseHead, payload: Payload<S>) -> Self {
  function head (line 47) | pub(crate) fn head(&self) -> &ResponseHead {
  function version (line 53) | pub fn version(&self) -> Version {
  function status (line 59) | pub fn status(&self) -> StatusCode {
  function headers (line 65) | pub fn headers(&self) -> &HeaderMap {
  function map_body (line 72) | pub fn map_body<F, U>(mut self, f: F) -> ClientResponse<U>
  function timeout (line 92) | pub fn timeout(self, dur: Duration) -> Self {
  function _timeout (line 116) | pub(crate) fn _timeout(mut self, timeout: Option<Pin<Box<Sleep>>>) -> Se...
  function cookies (line 123) | pub fn cookies(&self) -> Result<Ref<'_, Vec<Cookie<'static>>>, CookiePar...
  function cookie (line 142) | pub fn cookie(&self, name: &str) -> Option<Cookie<'static>> {
  function body (line 178) | pub fn body(&mut self) -> ResponseBody<S> {
  function json (line 204) | pub fn json<T: DeserializeOwned>(&mut self) -> JsonBody<S, T> {
  function fmt (line 210) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  type Stream (line 221) | type Stream = S;
  method headers (line 223) | fn headers(&self) -> &HeaderMap {
  method take_payload (line 227) | fn take_payload(&mut self) -> Payload<S> {
  method extensions (line 231) | fn extensions(&self) -> Ref<'_, Extensions> {
  method extensions_mut (line 235) | fn extensions_mut(&self) -> RefMut<'_, Extensions> {
  type Item (line 244) | type Item = Result<Bytes, PayloadError>;
  method poll_next (line 246) | fn poll_next(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<...

FILE: awc/src/responses/response_body.rs
  type MessageBody (line 33) | pub type MessageBody<B> = ResponseBody<B>;
  function new (line 40) | pub fn new(res: &mut ClientResponse<S>) -> ResponseBody<S> {
  function limit (line 64) | pub fn limit(mut self, limit: usize) -> Self {
  function err (line 72) | fn err(err: PayloadError) -> Self {
  type Output (line 86) | type Output = Result<Bytes, PayloadError>;
  method poll (line 88) | fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
  function read_body (line 118) | async fn read_body() {

FILE: awc/src/sender.rs
  type PrepForSendingError (line 32) | pub(crate) enum PrepForSendingError {
  method from (line 40) | fn from(err: PrepForSendingError) -> FreezeRequestError {
  method from (line 55) | fn from(err: PrepForSendingError) -> SendRequestError {
  type SendClientRequest (line 71) | pub enum SendClientRequest {
    method new (line 82) | pub(crate) fn new(
    method from (line 159) | fn from(err: SendRequestError) -> Self {
    method from (line 165) | fn from(err: HttpError) -> Self {
    method from (line 171) | fn from(err: PrepForSendingError) -> Self {
  type Output (line 94) | type Output = Result<ClientResponse<Decoder<Payload>>, SendRequestError>;
  method poll (line 96) | fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
  type Output (line 135) | type Output = Result<ClientResponse, SendRequestError>;
  method poll (line 137) | fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
  type RequestSender (line 177) | pub(crate) enum RequestSender {
    method send_body (line 183) | pub(crate) fn send_body(
    method send_json (line 209) | pub(crate) fn send_json(
    method send_form (line 229) | pub(crate) fn send_form(
    method send_stream (line 252) | pub(crate) fn send_stream<S, E>(
    method send (line 273) | pub(crate) fn send(
    method set_header_if_none (line 283) | fn set_header_if_none<V>(&mut self, key: HeaderName, value: V) -> Resu...

FILE: awc/src/test.rs
  type TestResponse (line 11) | pub struct TestResponse {
    method with_header (line 31) | pub fn with_header(header: impl TryIntoHeaderPair) -> Self {
    method version (line 36) | pub fn version(mut self, ver: Version) -> Self {
    method insert_header (line 42) | pub fn insert_header(mut self, header: impl TryIntoHeaderPair) -> Self {
    method append_header (line 51) | pub fn append_header(mut self, header: impl TryIntoHeaderPair) -> Self {
    method cookie (line 61) | pub fn cookie(mut self, cookie: Cookie<'_>) -> Self {
    method set_payload (line 67) | pub fn set_payload<B: Into<Bytes>>(mut self, data: B) -> Self {
    method finish (line 73) | pub fn finish(self) -> ClientResponse {
  method default (line 19) | fn default() -> TestResponse {
  function test_basics (line 107) | fn test_basics() {

FILE: awc/src/ws.rs
  type WebsocketsRequest (line 52) | pub struct WebsocketsRequest {
    method new (line 68) | pub(crate) fn new<U>(uri: U, config: ClientConfig) -> Self
    method address (line 106) | pub fn address(mut self, addr: SocketAddr) -> Self {
    method protocols (line 112) | pub fn protocols<U, V>(mut self, protos: U) -> Self
    method cookie (line 127) | pub fn cookie(mut self, cookie: Cookie<'_>) -> Self {
    method origin (line 135) | pub fn origin<V, E>(mut self, origin: V) -> Self
    method max_frame_size (line 150) | pub fn max_frame_size(mut self, size: usize) -> Self {
    method server_mode (line 156) | pub fn server_mode(mut self) -> Self {
    method header (line 165) | pub fn header<K, V>(mut self, key: K, value: V) -> Self
    method set_header (line 184) | pub fn set_header<K, V>(mut self, key: K, value: V) -> Self
    method set_header_if_none (line 203) | pub fn set_header_if_none<K, V>(mut self, key: K, value: V) -> Self
    method basic_auth (line 226) | pub fn basic_auth<U>(self, username: U, password: Option<&str>) -> Self
    method bearer_auth (line 241) | pub fn bearer_auth<T>(self, token: T) -> Self
    method camel_case_headers (line 252) | pub fn camel_case_headers(&self) -> bool {
    method set_camel_case_headers (line 258) | pub fn set_camel_case_headers(mut self, val: bool) -> Self {
    method connect (line 264) | pub async fn connect(
    method fmt (line 438) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  type Host (line 453) | struct Host<'a> {
  function fmt (line 459) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  function test_debug (line 477) | async fn test_debug() {
  function test_header_override (line 485) | async fn test_header_override() {
  function basic_auth (line 504) | async fn basic_auth() {
  function bearer_auth (line 531) | async fn bearer_auth() {
  function camel_case_headers (line 548) | async fn camel_case_headers() {
  function basics (line 554) | async fn basics() {

FILE: awc/tests/test_client.rs
  constant S (line 27) | const S: &str = "Hello World ";
  constant STR (line 28) | const STR: &str = const_str::repeat!(S, 100);
  function simple (line 31) | async fn simple() {
  function json (line 58) | async fn json() {
  function form (line 73) | async fn form() {
  function timeout (line 92) | async fn timeout() {
  function timeout_override (line 117) | async fn timeout_override() {
  function response_timeout (line 139) | async fn response_timeout() {
  function connection_reuse (line 212) | async fn connection_reuse() {
  function connection_force_close (line 249) | async fn connection_force_close() {
  function connection_server_close (line 286) | async fn connection_server_close() {
  function connection_wait_queue (line 325) | async fn connection_wait_queue() {
  function connection_wait_queue_force_close (line 373) | async fn connection_wait_queue_force_close() {
  function with_query_parameter (line 421) | async fn with_query_parameter() {
  function no_decompress (line 442) | async fn no_decompress() {
  function client_gzip_encoding (line 478) | async fn client_gzip_encoding() {
  function client_gzip_encoding_large (line 498) | async fn client_gzip_encoding_large() {
  function client_gzip_encoding_large_random (line 518) | async fn client_gzip_encoding_large_random() {
  function client_brotli_encoding (line 540) | async fn client_brotli_encoding() {
  function client_brotli_encoding_large_random (line 560) | async fn client_brotli_encoding_large_random() {
  function client_deflate_encoding (line 581) | async fn client_deflate_encoding() {
  function client_deflate_encoding_large_random (line 601) | async fn client_deflate_encoding_large_random() {
  function client_streaming_explicit (line 623) | async fn client_streaming_explicit() {
  function body_streaming_implicit (line 645) | async fn body_streaming_implicit() {
  function client_cookie_handling (line 667) | async fn client_cookie_handling() {
  function client_unread_response (line 729) | async fn client_unread_response() {
  function client_basic_auth (line 756) | async fn client_basic_auth() {
  function client_bearer_auth (line 784) | async fn client_bearer_auth() {
  function local_address (line 812) | async fn local_address() {

FILE: awc/tests/test_connector.rs
  function tls_config (line 15) | fn tls_config() -> SslAcceptor {
  function test_connection_window_size (line 42) | async fn test_connection_window_size() {

FILE: awc/tests/test_empty_stream.rs
  function empty_body_stream_does_not_use_chunked_encoding (line 13) | async fn empty_body_stream_does_not_use_chunked_encoding() {

FILE: awc/tests/test_rustls_client.rs
  function tls_config (line 19) | fn tls_config() -> ServerConfig {
  type NoCertificateVerification (line 40) | pub struct NoCertificateVerification;
  method verify_server_cert (line 43) | fn verify_server_cert(
  method verify_tls12_signature (line 54) | fn verify_tls12_signature(
  method verify_tls13_signature (line 63) | fn verify_tls13_signature(
  method supported_verify_schemes (line 72) | fn supported_verify_schemes(&self) -> Vec<rustls::SignatureScheme> {
  function test_connection_reuse_h2 (line 81) | async fn test_connection_reuse_h2() {

FILE: awc/tests/test_ssl_client.rs
  function tls_config (line 21) | fn tls_config() -> SslAcceptor {
  function test_connection_reuse_h2 (line 48) | async fn test_connection_reuse_h2() {

FILE: awc/tests/test_ws.rs
  function ws_service (line 10) | async fn ws_service(req: ws::Frame) -> Result<ws::Message, io::Error> {
  function test_simple (line 23) | async fn test_simple() {

FILE: awc/tests/utils.rs
  function encode (line 11) | pub fn encode(bytes: impl AsRef<[u8]>) -> Vec<u8> {
  function decode (line 17) | pub fn decode(bytes: impl AsRef<[u8]>) -> Vec<u8> {
  function encode (line 30) | pub fn encode(bytes: impl AsRef<[u8]>) -> Vec<u8> {
  function decode (line 36) | pub fn decode(bytes: impl AsRef<[u8]>) -> Vec<u8> {
  function encode (line 49) | pub fn encode(bytes: impl AsRef<[u8]>) -> Vec<u8> {
  function decode (line 61) | pub fn decode(bytes: impl AsRef<[u8]>) -> Vec<u8> {
  function encode (line 74) | pub fn encode(bytes: impl AsRef<[u8]>) -> Vec<u8> {
  function decode (line 80) | pub fn decode(bytes: impl AsRef<[u8]>) -> Vec<u8> {