# lib.rs.html -- source
Source to the Rust file `src/lib.rs`.
Keywords: rust, rustlang, rust-lang

      1
      2
      3
      4
      5
      6
      7
      8
      9
     10
     11
     12
     13
     14
     15
     16
     17
     18
     19
     20
     21
     22
     23
     24
     25
     26
     27
     28
     29
     30
     31
     32
     33
     34
     35
     36
     37
     38
     39
     40
     41
     42
     43
     44
     45
     46
     47
     48
     49
     50
     51
     52
     53
     54
     55
     56
     57
     58
     59
     60
     61
     62
     63
     64
     65
     66
     67
     68
     69
     70
     71
     72
     73
     74
     75
     76
     77
     78
     79
     80
     81
     82
     83
     84
     85
     86
     87
     88
     89
     90
     91
     92
     93
     94
     95
     96
     97
     98
     99
    100
    101
    102
    103
    104
    105
    106
    107
    108
    109
    110
    111
    112
    113
    114
    115
    116
    117
    118
    119
    120
    121
    122
    123
    124
    125
    126
    127
    128
    129
    130
    131
    132
    133
    134
    135
    136
    137
    138
    139
    140
    141
    142
    143
    144
    145
    146
    147
    148
    149
    150
    151
    152
    153
    154
    155
    156
    157
    158
    159
    160
    161
    162
    163
    164
    165
    166
    167
    168
    169
    170
    171
    172
    173
    174
    175
    176
    177
    178
    179
    180
    181
    182
    183
    184
    185
    186
    187
    188
    189
    190
    191
    192
    193
    194
    195
    196
    197
    198
    199
    200
    201
    202
    203
    204
    205
    206
    207
    208
    209
    210
    211
    212
    213
    214
    215
    216
    217
    218
    219
    220
    221
    222
    223
    224
    225
    226
    227
    228
    229
    230
    231
    232
    233
    234
    235
    236
    237
    238
    239
    240
    241
    242
    243
    244
    245
    246
    247
    248
    249
    250
    251
    252
    253
    254
    255
    256
    257
    258
    259
    260
    261
    262
    263
    264
    265
    266
    267
    268
    269
    270
    271
    272
    273
    274
    275
    276
    277
    278
    279
    280
    281
    282
    283
    284
    285
    286
    287
    288
    289
    290
    291
    292
    293
    294

    //! Actix web is a small, pragmatic, and extremely fast web framework
    //! for Rust.
    //!
    //! ```rust
    //! use actix_web::{server, App, Path, Responder};
    //! # use std::thread;
    //!
    //! fn index(info: Path<(String, u32)>) -> impl Responder {
    //!     format!("Hello {}! id:{}", info.0, info.1)
    //! }
    //!
    //! fn main() {
    //!     # thread::spawn(|| {
    //!     server::new(|| {
    //!         App::new().resource("/{name}/{id}/index.html", |r| r.with(index))
    //!     }).bind("127.0.0.1:8080")
    //!         .unwrap()
    //!         .run();
    //!     # });
    //! }
    //! ```
    //!
    //! ## Documentation & community resources
    //!
    //! Besides the API documentation (which you are currently looking
    //! at!), several other resources are available:
    //!
    //! * [User Guide](https://actix.rs/docs/)
    //! * [Chat on gitter](https://gitter.im/actix/actix)
    //! * [GitHub repository](https://github.com/actix/actix-web)
    //! * [Cargo package](https://crates.io/crates/actix-web)
    //!
    //! To get started navigating the API documentation you may want to
    //! consider looking at the following pages:
    //!
    //! * [App](struct.App.html): This struct represents an actix-web
    //!   application and is used to configure routes and other common
    //!   settings.
    //!
    //! * [HttpServer](server/struct.HttpServer.html): This struct
    //!   represents an HTTP server instance and is used to instantiate and
    //!   configure servers.
    //!
    //! * [HttpRequest](struct.HttpRequest.html) and
    //!   [HttpResponse](struct.HttpResponse.html): These structs
    //!   represent HTTP requests and responses and expose various methods
    //!   for inspecting, creating and otherwise utilizing them.
    //!
    //! ## Features
    //!
    //! * Supported *HTTP/1.x* and *HTTP/2.0* protocols
    //! * Streaming and pipelining
    //! * Keep-alive and slow requests handling
    //! * `WebSockets` server/client
    //! * Transparent content compression/decompression (br, gzip, deflate)
    //! * Configurable request routing
    //! * Graceful server shutdown
    //! * Multipart streams
    //! * SSL support with OpenSSL or `native-tls`
    //! * Middlewares (`Logger`, `Session`, `CORS`, `CSRF`, `DefaultHeaders`)
    //! * Built on top of [Actix actor framework](https://github.com/actix/actix)
    //! * Supported Rust version: 1.26 or later
    //!
    //! ## Package feature
    //!
    //! * `tls` - enables ssl support via `native-tls` crate
    //! * `ssl` - enables ssl support via `openssl` crate, supports `http/2`
    //! * `rust-tls` - enables ssl support via `rustls` crate, supports `http/2`
    //! * `uds` - enables support for making client requests via Unix Domain Sockets.
    //!   Unix only. Not necessary for *serving* requests.
    //! * `session` - enables session support, includes `ring` crate as
    //!   dependency
    //! * `brotli` - enables `brotli` compression support, requires `c`
    //!   compiler
    //! * `flate2-c` - enables `gzip`, `deflate` compression support, requires
    //!   `c` compiler
    //! * `flate2-rust` - experimental rust based implementation for
    //!   `gzip`, `deflate` compression.
    //!
    #![cfg_attr(actix_nightly, feature(
        specialization, // for impl ErrorResponse for std::error::Error
        extern_prelude,
        tool_lints,
    ))]
    #![warn(missing_docs)]

    #[macro_use]
    extern crate log;
    extern crate base64;
    extern crate byteorder;
    extern crate bytes;
    extern crate regex;
    extern crate sha1;
    extern crate time;
    #[macro_use]
    extern crate bitflags;
    #[macro_use]
    extern crate failure;
    #[macro_use]
    extern crate lazy_static;
    #[macro_use]
    extern crate futures;
    extern crate cookie;
    extern crate futures_cpupool;
    extern crate htmlescape;
    extern crate http as modhttp;
    extern crate httparse;
    extern crate language_tags;
    extern crate lazycell;
    extern crate mime;
    extern crate mime_guess;
    extern crate mio;
    extern crate net2;
    extern crate parking_lot;
    extern crate rand;
    extern crate slab;
    extern crate tokio;
    extern crate tokio_current_thread;
    extern crate tokio_io;
    extern crate tokio_reactor;
    extern crate tokio_tcp;
    extern crate tokio_timer;
    #[cfg(all(unix, feature = "uds"))]
    extern crate tokio_uds;
    extern crate url;
    #[macro_use]
    extern crate serde;
    #[cfg(feature = "brotli")]
    extern crate brotli2;
    extern crate encoding;
    #[cfg(feature = "flate2")]
    extern crate flate2;
    extern crate h2 as http2;
    extern crate num_cpus;
    extern crate serde_urlencoded;
    #[macro_use]
    extern crate percent_encoding;
    extern crate serde_json;
    extern crate smallvec;

    extern crate actix_net;
    #[macro_use]
    extern crate actix as actix_inner;

    #[cfg(test)]
    #[macro_use]
    extern crate serde_derive;

    #[cfg(feature = "tls")]
    extern crate native_tls;
    #[cfg(feature = "tls")]
    extern crate tokio_tls;

    #[cfg(feature = "openssl")]
    extern crate openssl;
    #[cfg(feature = "openssl")]
    extern crate tokio_openssl;

    #[cfg(feature = "rust-tls")]
    extern crate rustls;
    #[cfg(feature = "rust-tls")]
    extern crate tokio_rustls;
    #[cfg(feature = "rust-tls")]
    extern crate webpki;
    #[cfg(feature = "rust-tls")]
    extern crate webpki_roots;

    mod application;
    mod body;
    mod context;
    mod de;
    mod extensions;
    mod extractor;
    mod handler;
    mod header;
    mod helpers;
    mod httpcodes;
    mod httpmessage;
    mod httprequest;
    mod httpresponse;
    mod info;
    mod json;
    mod param;
    mod payload;
    mod pipeline;
    mod resource;
    mod route;
    mod router;
    mod scope;
    mod uri;
    mod with;

    pub mod client;
    pub mod error;
    pub mod fs;
    pub mod middleware;
    pub mod multipart;
    pub mod pred;
    pub mod server;
    pub mod test;
    pub mod ws;
    pub use application::App;
    pub use body::{Binary, Body};
    pub use context::HttpContext;
    pub use error::{Error, ResponseError, Result};
    pub use extensions::Extensions;
    pub use extractor::{Form, Path, Query};
    pub use handler::{
        AsyncResponder, Either, FromRequest, FutureResponse, Responder, State,
    };
    pub use httpmessage::HttpMessage;
    pub use httprequest::HttpRequest;
    pub use httpresponse::HttpResponse;
    pub use json::Json;
    pub use scope::Scope;
    pub use server::Request;

    pub mod actix {
        //! Re-exports [actix's](https://docs.rs/actix/) prelude

        extern crate actix;
        pub use self::actix::actors::resolver;
        pub use self::actix::actors::signal;
        pub use self::actix::fut;
        pub use self::actix::msgs;
        pub use self::actix::prelude::*;
        pub use self::actix::{run, spawn};
    }

    #[cfg(feature = "openssl")]
    pub(crate) const HAS_OPENSSL: bool = true;
    #[cfg(not(feature = "openssl"))]
    pub(crate) const HAS_OPENSSL: bool = false;

    #[cfg(feature = "tls")]
    pub(crate) const HAS_TLS: bool = true;
    #[cfg(not(feature = "tls"))]
    pub(crate) const HAS_TLS: bool = false;

    #[cfg(feature = "rust-tls")]
    pub(crate) const HAS_RUSTLS: bool = true;
    #[cfg(not(feature = "rust-tls"))]
    pub(crate) const HAS_RUSTLS: bool = false;

    pub mod dev {
        //! The `actix-web` prelude for library developers
        //!
        //! The purpose of this module is to alleviate imports of many common actix
        //! traits by adding a glob import to the top of actix heavy modules:
        //!
        //! ```
        //! # #![allow(unused_imports)]
        //! use actix_web::dev::*;
        //! ```

        pub use body::BodyStream;
        pub use context::Drain;
        pub use extractor::{FormConfig, PayloadConfig};
        pub use handler::{AsyncResult, Handler};
        pub use httpmessage::{MessageBody, Readlines, UrlEncoded};
        pub use httpresponse::HttpResponseBuilder;
        pub use info::ConnectionInfo;
        pub use json::{JsonBody, JsonConfig};
        pub use param::{FromParam, Params};
        pub use payload::{Payload, PayloadBuffer};
        pub use pipeline::Pipeline;
        pub use resource::Resource;
        pub use route::Route;
        pub use router::{ResourceDef, ResourceInfo, ResourceType, Router};
    }

    pub mod http {
        //! Various HTTP related types

        // re-exports
        pub use modhttp::{Method, StatusCode, Version};

        #[doc(hidden)]
        pub use modhttp::{uri, Error, Extensions, HeaderMap, HttpTryFrom, Uri};

        pub use cookie::{Cookie, CookieBuilder};

        pub use helpers::NormalizePath;

        /// Various http headers
        pub mod header {
            pub use header::*;
            pub use header::{
                Charset, ContentDisposition, DispositionParam, DispositionType, LanguageTag,
            };
        }
        pub use header::ContentEncoding;
        pub use httpresponse::ConnectionType;
    }

# Help

## Keyboard Shortcuts

`?`
  Show this help dialog
`S`
  Focus the search field
`↑`
  Move up in search results
`↓`
  Move down in search results
`↹`
  Switch tab
`⏎`
  Go to active search result
`+`
  Expand all sections
`-`
  Collapse all sections

## Search Tricks

Prefix searches with a type followed by a colon (e.g. `fn:`) to restrict the search to a given type.

Accepted types are: `fn`, `mod`, `struct`, `enum`, `trait`, `type`, `macro`, and `const`.

Search functions by type signature (e.g. `vec -> usize` or `* -> vec`)

Search multiple things at once by splitting your query with comma (e.g. `str,u8` or `String,struct:Vec,test`)