SYMBOL INDEX (4388 symbols across 412 files)

FILE: benchmarks/src/routing.rs
  function dummy_handler (line 7) | fn dummy_handler<'r>(req: &'r Request, _: Data<'r>) -> route::BoxFuture<...
  function parse_routes_table (line 11) | fn parse_routes_table(table: &str) -> Vec<Route> {
  function generate_matching_requests (line 40) | fn generate_matching_requests<'c>(client: &'c Client, routes: &[Route]) ...
  function client (line 78) | fn client(routes: Vec<Route>) -> Client {
  function bench_rust_lang_routes (line 101) | pub fn bench_rust_lang_routes(c: &mut Criterion) {
  function bench_bitwarden_routes (line 114) | pub fn bench_bitwarden_routes(c: &mut Criterion) {

FILE: contrib/db_pools/codegen/src/database.rs
  constant ONE_DATABASE_ATTR (line 7) | const ONE_DATABASE_ATTR: &str = "missing `#[database(\"name\")]` attribu...
  constant ONE_UNNAMED_FIELD (line 8) | const ONE_UNNAMED_FIELD: &str = "struct must have exactly one unnamed fi...
  type DatabaseAttribute (line 11) | struct DatabaseAttribute {
  function derive_database (line 16) | pub fn derive_database(input: TokenStream) -> TokenStream {

FILE: contrib/db_pools/codegen/src/lib.rs
  function derive_database (line 59) | pub fn derive_database(input: proc_macro::TokenStream) -> proc_macro::To...

FILE: contrib/db_pools/codegen/tests/ui-fail.rs
  function ui (line 3) | fn ui() {

FILE: contrib/db_pools/codegen/tests/ui-fail/database-syntax.rs
  type A (line 5) | struct A(deadpool_postgres::Pool);
  type B (line 9) | struct B(deadpool_postgres::Pool);
  type C (line 13) | struct C(deadpool_postgres::Pool);
  type D (line 17) | enum D {  }
  type E (line 20) | struct E(deadpool_postgres::Pool);
  type F (line 24) | struct F;
  type G (line 28) | struct G(deadpool_postgres::Pool, deadpool_postgres::Pool);
  type H (line 32) | struct H {
  function main (line 36) | fn main() {  }

FILE: contrib/db_pools/codegen/tests/ui-fail/database-types.rs
  type Unknown (line 3) | struct Unknown;
  type A (line 7) | struct A(Unknown);
  type B (line 11) | struct B(Vec<i32>);
  function main (line 13) | fn main() {  }

FILE: contrib/db_pools/lib/src/config.rs
  type Config (line 55) | pub struct Config {
  method default (line 98) | fn default() -> Self {
  function default_values_sane (line 115) | fn default_values_sane() {

FILE: contrib/db_pools/lib/src/database.rs
  type Database (line 34) | pub trait Database: From<Self::Pool> + DerefMut<Target = Self::Pool> + S...
    constant NAME (line 45) | const NAME: &'static str;
    method init (line 66) | fn init() -> Initializer<Self> {
    method fetch (line 118) | fn fetch<P: Phase>(rocket: &Rocket<P>) -> Option<&Self> {
  type Initializer (line 153) | pub struct Initializer<D: Database>(Option<&'static str>, PhantomData<fn...
  type Connection (line 195) | pub struct Connection<D: Database>(<D::Pool as Pool>::Connection);
  function new (line 202) | pub fn new() -> Self {
  function with_name (line 210) | pub fn with_name(name: &'static str) -> Self {
  function into_inner (line 241) | pub fn into_inner(self) -> <D::Pool as Pool>::Connection {
  method info (line 248) | fn info(&self) -> Info {
  method on_ignite (line 255) | async fn on_ignite(&self, rocket: Rocket<Build>) -> fairing::Result {
  method on_shutdown (line 274) | async fn on_shutdown(&self, rocket: &Rocket<Orbit>) {
  type Error (line 283) | type Error = Option<<D::Pool as Pool>::Error>;
  function from_request (line 285) | async fn from_request(req: &'r Request<'_>) -> Outcome<Self, Self::Error> {
  method abort (line 297) | fn abort(rocket: &Rocket<Ignite>) -> bool {
  type Target (line 303) | type Target = <D::Pool as Pool>::Connection;
  method deref (line 305) | fn deref(&self) -> &Self::Target {
  method deref_mut (line 311) | fn deref_mut(&mut self) -> &mut Self::Target {

FILE: contrib/db_pools/lib/src/diesel.rs
  type QueryResult (line 108) | pub type QueryResult<T, E = rocket::response::Debug<diesel::result::Erro...
  type MysqlPool (line 130) | pub type MysqlPool = Pool<AsyncMysqlConnection>;
  type PgPool (line 152) | pub type PgPool = Pool<AsyncPgConnection>;

FILE: contrib/db_pools/lib/src/error.rs
  type Error (line 7) | pub enum Error<A, B = A> {
  function fmt (line 19) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  function from (line 32) | fn from(e: crate::figment::Error) -> Self {

FILE: contrib/db_pools/lib/src/pool.rs
  type Pool (line 117) | pub trait Pool: Sized + Send + 'static {
    method init (line 136) | async fn init(figment: &Figment) -> Result<Self, Self::Error>;
    method get (line 145) | async fn get(&self) -> Result<Self::Connection, Self::Error>;
    method close (line 152) | async fn close(&self);
  type DeadManager (line 163) | pub trait DeadManager: Manager + Sized + Send + 'static {
    method new (line 164) | fn new(config: &Config) -> Result<Self, Self::Error>;
    method new (line 169) | fn new(config: &Config) -> Result<Self, Self::Error> {
    method new (line 176) | fn new(config: &Config) -> Result<Self, Self::Error> {
    method new (line 183) | fn new(config: &Config) -> Result<Self, Self::Error> {
    method new (line 190) | fn new(config: &Config) -> Result<Self, Self::Error> {
  type Error (line 199) | type Error = Error<PoolError<M::Error>>;
  type Connection (line 201) | type Connection = C;
  function init (line 203) | async fn init(figment: &Figment) -> Result<Self, Self::Error> {
  function get (line 217) | async fn get(&self) -> Result<Self::Connection, Self::Error> {
  function close (line 221) | async fn close(&self) {
  type Options (line 233) | type Options<D> = <<D as sqlx::Database>::Connection as sqlx::Connection...
  function specialize (line 236) | fn specialize(__options: &mut dyn std::any::Any, __config: &Config) {
  type Error (line 253) | type Error = Error<sqlx::Error>;
  type Connection (line 255) | type Connection = sqlx::pool::PoolConnection<D>;
  function init (line 257) | async fn init(figment: &Figment) -> Result<Self, Self::Error> {
  function get (line 287) | async fn get(&self) -> Result<Self::Connection, Self::Error> {
  function close (line 291) | async fn close(&self) {
  type Error (line 304) | type Error = Error<mongodb::error::Error, std::convert::Infallible>;
  type Connection (line 306) | type Connection = Client;
  method init (line 308) | async fn init(figment: &Figment) -> Result<Self, Self::Error> {
  method get (line 319) | async fn get(&self) -> Result<Self::Connection, Self::Error> {
  method close (line 323) | async fn close(&self) {

FILE: contrib/dyn_templates/src/context.rs
  type Callback (line 11) | pub(crate) type Callback =
  type Context (line 14) | pub(crate) struct Context {
    method initialize (line 29) | pub fn initialize(root: &Path, callback: &Callback) -> Option<Context> {
  type ContextManager (line 107) | pub(crate) struct ContextManager(Context);
    method new (line 110) | pub fn new(ctxt: Context) -> ContextManager {
    method context (line 114) | pub fn context<'a>(&'a self) -> impl Deref<Target=Context> + 'a {
    method is_reloading (line 118) | pub fn is_reloading(&self) -> bool {
    method new (line 144) | pub fn new(ctxt: Context) -> ContextManager {
    method context (line 163) | pub fn context(&self) -> impl Deref<Target=Context> + '_ {
    method is_reloading (line 167) | pub fn is_reloading(&self) -> bool {
    method context_mut (line 171) | fn context_mut(&self) -> impl DerefMut<Target=Context> + '_ {
    method reload_if_needed (line 179) | pub fn reload_if_needed(&self, callback: &Callback) {
  type ContextManager (line 136) | pub(crate) struct ContextManager {
    method new (line 110) | pub fn new(ctxt: Context) -> ContextManager {
    method context (line 114) | pub fn context<'a>(&'a self) -> impl Deref<Target=Context> + 'a {
    method is_reloading (line 118) | pub fn is_reloading(&self) -> bool {
    method new (line 144) | pub fn new(ctxt: Context) -> ContextManager {
    method context (line 163) | pub fn context(&self) -> impl Deref<Target=Context> + '_ {
    method is_reloading (line 167) | pub fn is_reloading(&self) -> bool {
    method context_mut (line 171) | fn context_mut(&self) -> impl DerefMut<Target=Context> + '_ {
    method reload_if_needed (line 179) | pub fn reload_if_needed(&self, callback: &Callback) {
  function remove_extension (line 198) | fn remove_extension(path: &Path) -> PathBuf {
  function split_path (line 212) | fn split_path(root: &Path, path: &Path) -> (String, Option<String>) {
  function template_path_index_html (line 231) | fn template_path_index_html() {
  function template_path_subdir_index_html (line 244) | fn template_path_subdir_index_html() {
  function template_path_doc_examples (line 260) | fn template_path_doc_examples() {

FILE: contrib/dyn_templates/src/engine/handlebars.rs
  constant EXT (line 9) | const EXT: &'static str = "hbs";
  method init (line 11) | fn init<'a>(templates: impl Iterator<Item = (&'a str, &'a Path)>) -> Opt...
  method render (line 26) | fn render<C: Serialize>(&self, template: &str, context: C) -> Option<Str...

FILE: contrib/dyn_templates/src/engine/minijinja.rs
  constant EXT (line 11) | const EXT: &'static str = "j2";
  method init (line 13) | fn init<'a>(templates: impl Iterator<Item = (&'a str, &'a Path)>) -> Opt...
  method render (line 45) | fn render<C: Serialize>(&self, template: &str, context: C) -> Option<Str...

FILE: contrib/dyn_templates/src/engine/mod.rs
  type Engine (line 23) | pub(crate) trait Engine: Send + Sync + Sized + 'static {
    constant EXT (line 24) | const EXT: &'static str;
    method init (line 26) | fn init<'a>(templates: impl Iterator<Item = (&'a str, &'a Path)>) -> O...
    method render (line 27) | fn render<C: Serialize>(&self, name: &str, context: C) -> Option<String>;
  type Engines (line 66) | pub struct Engines {
    constant ENABLED_EXTENSIONS (line 95) | pub(crate) const ENABLED_EXTENSIONS: &'static [&'static str] = &[
    method init (line 101) | pub(crate) fn init(templates: &HashMap<String, TemplateInfo>) -> Optio...
    method render (line 130) | pub(crate) fn render<C: Serialize>(
    method templates (line 158) | pub(crate) fn templates(&self) -> impl Iterator<Item = (&str, &'static...

FILE: contrib/dyn_templates/src/engine/tera.rs
  constant EXT (line 10) | const EXT: &'static str = "tera";
  method init (line 12) | fn init<'a>(templates: impl Iterator<Item = (&'a str, &'a Path)>) -> Opt...
  method render (line 38) | fn render<C: Serialize>(&self, template: &str, context: C) -> Option<Str...

FILE: contrib/dyn_templates/src/fairing.rs
  type TemplateFairing (line 14) | pub struct TemplateFairing {
  method info (line 23) | fn info(&self) -> Info {
  method on_ignite (line 35) | async fn on_ignite(&self, rocket: Rocket<Build>) -> fairing::Result {
  method on_liftoff (line 57) | async fn on_liftoff(&self, rocket: &Rocket<Orbit>) {
  method on_request (line 68) | async fn on_request(&self, req: &mut rocket::Request<'_>, _data: &mut ro...

FILE: contrib/dyn_templates/src/metadata.rs
  type Metadata (line 41) | pub struct Metadata<'a>(&'a ContextManager);
  function contains_template (line 61) | pub fn contains_template(&self, name: &str) -> bool {
  function reloading (line 81) | pub fn reloading(&self) -> bool {
  function render (line 120) | pub fn render<S, C>(&self, name: S, context: C) -> Option<(ContentType, ...
  function fmt (line 128) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  method abort (line 136) | fn abort(rocket: &Rocket<Ignite>) -> bool {
  type Error (line 155) | type Error = ();
  function from_request (line 157) | async fn from_request(request: &'r Request<'_>) -> request::Outcome<Self...

FILE: contrib/dyn_templates/src/template.rs
  constant DEFAULT_TEMPLATE_DIR (line 17) | pub(crate) const DEFAULT_TEMPLATE_DIR: &str = "templates";
  type Template (line 27) | pub struct Template {
    method fairing (line 73) | pub fn fairing() -> impl Fairing {
    method custom (line 104) | pub fn custom<F: Send + Sync + 'static>(f: F) -> impl Fairing
    method try_custom (line 136) | pub fn try_custom<F: Send + Sync + 'static>(f: F) -> impl Fairing
    method render (line 175) | pub fn render<S, C>(name: S, context: C) -> Template
    method show (line 218) | pub fn show<S, C>(rocket: &Rocket<Orbit>, name: S, context: C) -> Opti...
    method finalize (line 238) | pub(crate) fn finalize(self, ctxt: &Context) -> Result<(ContentType, S...
    method respond_to (line 268) | fn respond_to(self, req: &'r Request<'_>) -> response::Result<'static> {
  type TemplateInfo (line 33) | pub(crate) struct TemplateInfo {
  method abort (line 285) | fn abort(rocket: &Rocket<Ignite>) -> bool {

FILE: contrib/dyn_templates/tests/templates.rs
  function template_check (line 12) | fn template_check(md: Metadata<'_>, engine: &str, name: &str) -> Option<...
  function is_reloading (line 17) | fn is_reloading(md: Metadata<'_>) -> Option<()> {
  function template_root (line 21) | fn template_root() -> PathBuf {
  function rocket (line 25) | fn rocket() -> Rocket<Build> {
  function test_callback_error (line 32) | fn test_callback_error() {
  function test_sentinel (line 47) | fn test_sentinel() {
  function test_context_macro (line 101) | fn test_context_macro() {
  constant UNESCAPED_EXPECTED (line 211) | const UNESCAPED_EXPECTED: &'static str
  constant ESCAPED_EXPECTED (line 213) | const ESCAPED_EXPECTED: &'static str
  function test_tera_templates (line 217) | async fn test_tera_templates() {
  function test_globby_paths (line 242) | async fn test_globby_paths() {
  function test_template_metadata_with_tera (line 267) | fn test_template_metadata_with_tera() {
  function test_handlebars_templates (line 295) | async fn test_handlebars_templates() {
  function test_template_metadata_with_handlebars (line 332) | fn test_template_metadata_with_handlebars() {
  function test_template_reload (line 349) | fn test_template_reload() {
  constant UNESCAPED_EXPECTED (line 412) | const UNESCAPED_EXPECTED: &'static str
  constant ESCAPED_EXPECTED (line 414) | const ESCAPED_EXPECTED: &'static str
  function test_j2_templates (line 418) | async fn test_j2_templates() {
  function test_globby_paths (line 443) | async fn test_globby_paths() {
  function test_j2_u128 (line 453) | fn test_j2_u128() {
  function test_template_metadata_with_j2 (line 469) | fn test_template_metadata_with_j2() {

FILE: contrib/sync_db_pools/codegen/src/database.rs
  type DatabaseInvocation (line 7) | struct DatabaseInvocation {
  constant EXAMPLE (line 20) | const EXAMPLE: &str = "example: `struct MyDatabase(diesel::SqliteConnect...
  constant ONLY_ON_STRUCTS_MSG (line 21) | const ONLY_ON_STRUCTS_MSG: &str = "`database` attribute can only be used...
  constant ONLY_UNNAMED_FIELDS (line 22) | const ONLY_UNNAMED_FIELDS: &str = "`database` attribute can only be appl...
  constant NO_GENERIC_STRUCTS (line 24) | const NO_GENERIC_STRUCTS: &str = "`database` attribute cannot be applied...
  function parse_invocation (line 27) | fn parse_invocation(attr: TokenStream, input: TokenStream) -> Result<Dat...
  function database_attr (line 59) | pub fn database_attr(attr: TokenStream, input: TokenStream) -> Result<To...

FILE: contrib/sync_db_pools/codegen/src/lib.rs
  function database (line 53) | pub fn database(attr: TokenStream, input: TokenStream) -> TokenStream {

FILE: contrib/sync_db_pools/codegen/tests/ui-fail.rs
  function ui (line 3) | fn ui() {

FILE: contrib/sync_db_pools/codegen/tests/ui-fail/database-syntax.rs
  type Connection (line 3) | struct Connection;
  type Manager (line 4) | struct Manager;
    type Connection (line 10) | type Connection = Connection;
    type Error (line 11) | type Error = std::convert::Infallible;
    method connect (line 13) | fn connect(&self) -> Result<Self::Connection, Self::Error> { Ok(Connec...
    method is_valid (line 14) | fn is_valid(&self, _: &mut Self::Connection) -> Result<(), Self::Error...
    method has_broken (line 15) | fn has_broken(&self, _: &mut Self::Connection) -> bool { true }
  type Manager (line 19) | type Manager = Manager;
  type Error (line 20) | type Error = std::convert::Infallible;
  method pool (line 22) | fn pool(_: &str, _: &Rocket<Build>) -> PoolResult<Self> {
  type A (line 28) | struct A(Connection);
  type B (line 31) | struct B(Connection);
  type C (line 34) | struct C(Connection);
  type D (line 37) | struct D(Connection);
  type Foo (line 40) | enum Foo {  }
  type Bar (line 43) | struct Bar(Connection, Connection);
  type E (line 49) | struct E<'r>(&'r str);
  type F (line 52) | struct F<T>(T);
  function main (line 54) | fn main() {  }

FILE: contrib/sync_db_pools/codegen/tests/ui-fail/database-types.rs
  type Unknown (line 3) | struct Unknown;
  type A (line 6) | struct A(Unknown);
  type B (line 9) | struct B(Vec<i32>);
  function main (line 11) | fn main() {  }

FILE: contrib/sync_db_pools/lib/build.rs
  function main (line 1) | fn main() {

FILE: contrib/sync_db_pools/lib/src/config.rs
  type Config (line 33) | pub struct Config {
    method from (line 85) | pub fn from(db_name: &str, rocket: &Rocket<Build>) -> Result<Config, f...
    method figment (line 103) | pub fn figment(db_name: &str, rocket: &Rocket<Build>) -> Figment {

FILE: contrib/sync_db_pools/lib/src/connection.rs
  type ConnectionPool (line 21) | pub struct ConnectionPool<K, C: Poolable> {
  method clone (line 30) | fn clone(&self) -> Self {
  type Connection (line 45) | pub struct Connection<K, C: Poolable> {
  function run_blocking (line 52) | async fn run_blocking<F, R>(job: F) -> R
  function fairing (line 65) | pub fn fairing(fairing_name: &'static str, database: &'static str) -> im...
  function get (line 101) | pub async fn get(&self) -> Option<Connection<K, C>> {
  function get_one (line 129) | pub async fn get_one<P: Phase>(rocket: &Rocket<P>) -> Option<Connection<...
  function pool (line 146) | pub fn pool<P: Phase>(rocket: &Rocket<P>) -> Option<&Self> {
  function run (line 152) | pub async fn run<F, R>(&self, f: F) -> R
  method drop (line 181) | fn drop(&mut self) {
  method drop (line 214) | fn drop(&mut self) {
  type Error (line 226) | type Error = ();
  function from_request (line 229) | async fn from_request(request: &'r Request<'_>) -> Outcome<Self, ()> {
  method abort (line 243) | fn abort(rocket: &Rocket<Ignite>) -> bool {

FILE: contrib/sync_db_pools/lib/src/error.rs
  type Error (line 10) | pub enum Error<T> {
  function from (line 20) | fn from(error: figment::Error) -> Self {
  function from (line 26) | fn from(error: r2d2::Error) -> Self {

FILE: contrib/sync_db_pools/lib/src/lib.rs
  type ExampleDb (line 405) | pub struct ExampleDb(crate::Connection<Self, diesel::SqliteConnection>);
    method fairing (line 432) | pub fn fairing() -> impl crate::rocket::fairing::Fairing {
    method pool (line 488) | pub fn pool<P: crate::rocket::Phase>(
    method run (line 523) | pub async fn run<F, R>(&self, __f: F) -> R
    method get_one (line 534) | pub async fn get_one<P: crate::rocket::Phase>(
    type Error (line 548) | type Error = ();
    method from_request (line 557) | fn from_request<'life0, 'async_trait>(
    method abort (line 589) | fn abort(

FILE: contrib/sync_db_pools/lib/src/poolable.rs
  type Poolable (line 101) | pub trait Poolable: Send + Sized + 'static {
    method pool (line 111) | fn pool(db_name: &str, rocket: &Rocket<Build>) -> PoolResult<Self>;
    type Manager (line 120) | type Manager = diesel::r2d2::ConnectionManager<diesel::SqliteConnection>;
    type Error (line 121) | type Error = std::convert::Infallible;
    method pool (line 123) | fn pool(db_name: &str, rocket: &Rocket<Build>) -> PoolResult<Self> {
    type Manager (line 156) | type Manager = diesel::r2d2::ConnectionManager<diesel::PgConnection>;
    type Error (line 157) | type Error = std::convert::Infallible;
    method pool (line 159) | fn pool(db_name: &str, rocket: &Rocket<Build>) -> PoolResult<Self> {
    type Manager (line 173) | type Manager = diesel::r2d2::ConnectionManager<diesel::MysqlConnection>;
    type Error (line 174) | type Error = std::convert::Infallible;
    method pool (line 176) | fn pool(db_name: &str, rocket: &Rocket<Build>) -> PoolResult<Self> {
    type Manager (line 191) | type Manager = r2d2_postgres::PostgresConnectionManager<postgres::tls:...
    type Error (line 192) | type Error = postgres::Error;
    method pool (line 194) | fn pool(db_name: &str, rocket: &Rocket<Build>) -> PoolResult<Self> {
    type Manager (line 209) | type Manager = r2d2_sqlite::SqliteConnectionManager;
    type Error (line 210) | type Error = std::convert::Infallible;
    method pool (line 212) | fn pool(db_name: &str, rocket: &Rocket<Build>) -> PoolResult<Self> {
  type PoolResult (line 116) | pub type PoolResult<P: Poolable> = Result<r2d2::Pool<P::Manager>, Error<...
  type ConnectionManager (line 273) | pub struct ConnectionManager {
    method new (line 278) | pub fn new<C: Connectable>(target: C) -> Self {
    type Connection (line 284) | type Connection = Client;
    type Error (line 285) | type Error = MemcacheError;
    method connect (line 287) | fn connect(&self) -> Result<Client, MemcacheError> {
    method is_valid (line 291) | fn is_valid(&self, connection: &mut Client) -> Result<(), MemcacheErro...
    method has_broken (line 295) | fn has_broken(&self, _connection: &mut Client) -> bool {
  type Manager (line 301) | type Manager = ConnectionManager;
  type Error (line 302) | type Error = MemcacheError;
  function pool (line 304) | fn pool(db_name: &str, rocket: &Rocket<Build>) -> PoolResult<Self> {

FILE: contrib/sync_db_pools/lib/tests/databases.rs
  type ExampleDb (line 8) | struct ExampleDb(diesel::SqliteConnection);
  type PrimaryDb (line 11) | struct PrimaryDb(diesel::PgConnection);
  type MemcacheDb (line 21) | struct MemcacheDb(memcache::Client);
  type SqliteDb (line 32) | struct SqliteDb(pub rusqlite::Connection);
  type SqliteDb2 (line 36) | struct SqliteDb2(pub rusqlite::Connection);
  function test_db (line 39) | async fn test_db() {
  type ContainsRuntime (line 78) | struct ContainsRuntime(Runtime);
  type TestConnection (line 79) | struct TestConnection;
  type Connection (line 82) | type Connection = TestConnection;
  type Error (line 83) | type Error = std::convert::Infallible;
  method connect (line 85) | fn connect(&self) -> Result<Self::Connection, Self::Error> {
  method is_valid (line 89) | fn is_valid(&self, _conn: &mut Self::Connection) -> Result<(), Self::Err...
  method has_broken (line 93) | fn has_broken(&self, _conn: &mut Self::Connection) -> bool {
  type Manager (line 99) | type Manager = ContainsRuntime;
  type Error (line 100) | type Error = ();
  method pool (line 102) | fn pool(_db_name: &str, _rocket: &Rocket<Build>) -> PoolResult<Self> {
  type TestDb (line 109) | struct TestDb(TestConnection);
  function test_drop_runtime (line 112) | async fn test_drop_runtime() {
  function test_sentinel (line 123) | fn test_sentinel() {

FILE: contrib/sync_db_pools/lib/tests/drop-with-connection.rs
  type ExampleDb (line 7) | struct ExampleDb(diesel::SqliteConnection);
  function can_drop_connection_in_sync_context (line 10) | fn can_drop_connection_in_sync_context() {

FILE: contrib/sync_db_pools/lib/tests/shutdown.rs
  type Pool (line 8) | struct Pool(diesel::SqliteConnection);
  function rocket (line 10) | async fn rocket() -> Rocket<Build> {
  function test_shutdown (line 22) | fn test_shutdown() {

FILE: contrib/ws/src/duplex.rs
  type DuplexStream (line 36) | pub struct DuplexStream(tokio_tungstenite::WebSocketStream<IoStream>);
    method new (line 39) | pub(crate) async fn new(stream: IoStream, config: crate::Config) -> Se...
    method close (line 48) | pub async fn close(&mut self, msg: Option<CloseFrame<'_>>) -> Result<(...
    type Error (line 72) | type Error = Error;
    method poll_ready (line 74) | fn poll_ready(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Resu...
    method start_send (line 78) | fn start_send(self: Pin<&mut Self>, item: Message) -> Result<(), Self:...
    method poll_flush (line 82) | fn poll_flush(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Resu...
    method poll_close (line 86) | fn poll_close(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Resu...
  type Item (line 54) | type Item = Result<Message>;
  method poll_next (line 56) | fn poll_next(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<...
  method size_hint (line 60) | fn size_hint(&self) -> (usize, Option<usize>) {
  method is_terminated (line 66) | fn is_terminated(&self) -> bool {

FILE: contrib/ws/src/websocket.rs
  type WebSocket (line 33) | pub struct WebSocket {
    method config (line 61) | pub fn config(mut self, config: Config) -> Self {
    method channel (line 112) | pub fn channel<'r, F>(self, handler: F) -> Channel<'r>
    method stream (line 152) | pub fn stream<'r, F, S>(self, stream: F) -> MessageStream<'r, S>
    method accept_key (line 186) | pub fn accept_key(&self) -> &str {
    type Error (line 216) | type Error = std::convert::Infallible;
    method from_request (line 218) | async fn from_request(req: &'r Request<'_>) -> Outcome<Self, Self::Err...
  type Channel (line 195) | pub struct Channel<'r> {
  type MessageStream (line 209) | pub struct MessageStream<'r, S> {
  function respond_to (line 241) | fn respond_to(self, _: &'r Request<'_>) -> response::Result<'o> {
  function respond_to (line 253) | fn respond_to(self, _: &'r Request<'_>) -> response::Result<'o> {
  method io (line 264) | async fn io(self: Box<Self>, io: IoStream) -> io::Result<()> {
  method io (line 275) | async fn io(self: Box<Self>, io: IoStream) -> io::Result<()> {
  function handle_result (line 297) | fn handle_result(result: Result<()>) -> io::Result<bool> {

FILE: core/codegen/src/attribute/async_bound/mod.rs
  function _async_bound (line 8) | fn _async_bound(
  function async_bound (line 58) | pub fn async_bound(

FILE: core/codegen/src/attribute/catch/mod.rs
  function _catch (line 11) | pub fn _catch(
  function catch_attribute (line 98) | pub fn catch_attribute(

FILE: core/codegen/src/attribute/catch/parse.rs
  type Attribute (line 8) | pub struct Attribute {
    method parse (line 45) | pub fn parse(args: TokenStream, input: proc_macro::TokenStream) -> Res...
  type Meta (line 17) | struct Meta {
  type Code (line 24) | struct Code(Option<http::Status>);
  method from_meta (line 27) | fn from_meta(meta: &MetaItem) -> Result<Self> {

FILE: core/codegen/src/attribute/entry/launch.rs
  type Launch (line 12) | pub struct Launch;
  function likely_spawns (line 15) | fn likely_spawns(f: &syn::ItemFn) -> Option<&syn::ExprCall> {
  constant REQUIRES_ASYNC (line 57) | const REQUIRES_ASYNC: bool = false;
  method function (line 59) | fn function(f: &mut syn::ItemFn) -> Result<TokenStream> {

FILE: core/codegen/src/attribute/entry/main.rs
  type Main (line 10) | pub struct Main;
  constant REQUIRES_ASYNC (line 13) | const REQUIRES_ASYNC: bool = true;
  method function (line 15) | fn function(f: &mut syn::ItemFn) -> Result<TokenStream> {

FILE: core/codegen/src/attribute/entry/mod.rs
  type EntryAttr (line 12) | trait EntryAttr {
    constant REQUIRES_ASYNC (line 14) | const REQUIRES_ASYNC: bool;
    method function (line 17) | fn function(f: &mut syn::ItemFn) -> Result<TokenStream>;
  function _async_entry (line 20) | fn _async_entry<A: EntryAttr>(

FILE: core/codegen/src/attribute/entry/test.rs
  type Test (line 7) | pub struct Test;
  constant REQUIRES_ASYNC (line 10) | const REQUIRES_ASYNC: bool = true;
  method function (line 12) | fn function(f: &mut syn::ItemFn) -> Result<TokenStream> {

FILE: core/codegen/src/attribute/param/guard.rs
  method is_wild (line 11) | pub fn is_wild(&self) -> bool {
  method from_meta (line 17) | fn from_meta(meta: &MetaItem) -> Result<Self> {
  method eq (line 27) | fn eq(&self, other: &Dynamic) -> bool {
  method hash (line 35) | fn hash<H: Hasher>(&self, state: &mut H) {

FILE: core/codegen/src/attribute/param/mod.rs
  type Parameter (line 9) | pub enum Parameter {
    method r#static (line 31) | pub fn r#static(&self) -> Option<&Name> {
    method ignored (line 38) | pub fn ignored(&self) -> Option<&Dynamic> {
    method take_dynamic (line 45) | pub fn take_dynamic(self) -> Option<Dynamic> {
    method dynamic (line 53) | pub fn dynamic(&self) -> Option<&Dynamic> {
    method dynamic_mut (line 61) | pub fn dynamic_mut(&mut self) -> Option<&mut Dynamic> {
    method guard (line 69) | pub fn guard(&self) -> Option<&Guard> {
  type Dynamic (line 17) | pub struct Dynamic {
    method is_wild (line 79) | pub fn is_wild(&self) -> bool {
  type Guard (line 24) | pub struct Guard {
    method from (line 85) | pub fn from(source: Dynamic, fn_ident: syn::Ident, ty: syn::Type) -> S...

FILE: core/codegen/src/attribute/param/parse.rs
  type Error (line 12) | pub struct Error<'a> {
  type ErrorKind (line 21) | pub enum ErrorKind {
    method fmt (line 126) | fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
  method parse (line 31) | pub fn parse<P: Part>(
  method parse (line 44) | pub fn parse<P: Part>(
  method parse_many (line 90) | pub fn parse_many<P: Part>(
  function new (line 139) | pub fn new(segment: &str, span: Span, kind: ErrorKind) -> Error<'_> {
  function source (line 143) | pub fn source(mut self, source: &'a str, span: Span) -> Self {
  method from (line 151) | fn from(error: Error<'_>) -> Self {
  method from_meta (line 185) | fn from_meta(meta: &devise::MetaItem) -> devise::Result<Self> {
  function subspan (line 200) | fn subspan(needle: &str, haystack: &str, span: Span) -> Span {
  function trailspan (line 205) | fn trailspan(needle: &str, haystack: &str, span: Span) -> Span {
  function candidate_from_malformed (line 215) | fn candidate_from_malformed(segment: &str) -> String {
  function is_ident_start (line 229) | fn is_ident_start(c: char) -> bool {
  function is_ident_continue (line 236) | fn is_ident_continue(c: char) -> bool {
  function is_valid_ident (line 242) | fn is_valid_ident(string: &str) -> bool {

FILE: core/codegen/src/attribute/route/mod.rs
  method guards (line 20) | pub fn guards(&self) -> impl Iterator<Item = &Guard> {
  method param_guards (line 27) | pub fn param_guards(&self) -> impl Iterator<Item = &Guard> {
  method query_guards (line 31) | pub fn query_guards(&self) -> impl Iterator<Item = &Guard> {
  function query_decls (line 36) | fn query_decls(route: &Route) -> Option<TokenStream> {
  function request_guard_decl (line 125) | fn request_guard_decl(guard: &Guard) -> TokenStream {
  function param_guard_decl (line 163) | fn param_guard_decl(guard: &Guard) -> TokenStream {
  function data_guard_decl (line 220) | fn data_guard_decl(guard: &Guard) -> TokenStream {
  function internal_uri_macro_decl (line 256) | fn internal_uri_macro_decl(route: &Route) -> TokenStream {
  function responder_outcome_expr (line 297) | fn responder_outcome_expr(route: &Route) -> TokenStream {
  function sentinels_expr (line 317) | fn sentinels_expr(route: &Route) -> TokenStream {
  function codegen_route (line 379) | fn codegen_route(route: Route) -> Result<TokenStream> {
  function complete_route (line 452) | fn complete_route(args: TokenStream, input: TokenStream) -> Result<Token...
  function incomplete_route (line 462) | fn incomplete_route(
  function route_attribute (line 498) | pub fn route_attribute<M: Into<Option<crate::http::Method>>>(

FILE: core/codegen/src/attribute/route/parse.rs
  type Route (line 17) | pub struct Route {
    method upgrade_param (line 106) | pub fn upgrade_param(param: Parameter, args: &Arguments) -> Result<Par...
    method upgrade_dynamic (line 115) | pub fn upgrade_dynamic(param: Dynamic, args: &Arguments) -> Result<Gua...
    method from (line 125) | pub fn from(attr: Attribute, handler: syn::ItemFn) -> Result<Route> {
  type ArgumentMap (line 34) | type ArgumentMap = IndexMap<Name, (syn::Ident, syn::Type)>;
  type Arguments (line 37) | pub struct Arguments {
  type Attribute (line 44) | pub struct Attribute {
  type MethodAttribute (line 55) | pub struct MethodAttribute {
  type RouteUri (line 64) | pub struct RouteUri {
    type Target (line 234) | type Target = Origin<'static>;
    method deref (line 236) | fn deref(&self) -> &Self::Target {
  method from_meta (line 71) | fn from_meta(meta: &devise::MetaItem) -> Result<Self> {

FILE: core/codegen/src/attribute/suppress/lint.rs
  function span_to_range (line 50) | fn span_to_range(span: Span) -> Option<Range<usize>> {
  method suppress_attrs (line 59) | pub fn suppress_attrs(attrs: &[syn::Attribute], ctxt: Span) {
  method suppress_attr (line 63) | pub fn suppress_attr(attr: &syn::Attribute, ctxt: Span) -> Result<(), sy...
  method suppress_tokens (line 75) | pub fn suppress_tokens(attr_tokens: TokenStream, ctxt: Span) -> Result<(...
  method suppress (line 81) | pub fn suppress(self, ctxt: Span) {
  method is_suppressed (line 88) | pub fn is_suppressed(self, ctxt: Span) -> bool {
  method enabled (line 97) | pub fn enabled(self, ctxt: Span) -> bool {
  method how_to_suppress (line 101) | pub fn how_to_suppress(self) -> String {
  method parse (line 107) | fn parse(input: syn::parse::ParseStream<'_>) -> syn::Result<Self> {

FILE: core/codegen/src/attribute/suppress/mod.rs
  function suppress_attribute (line 8) | pub fn suppress_attribute(

FILE: core/codegen/src/bang/export.rs
  function _macro (line 9) | pub fn _macro(input: proc_macro::TokenStream) -> devise::Result<TokenStr...

FILE: core/codegen/src/bang/mod.rs
  function struct_maker_vec (line 13) | fn struct_maker_vec(
  function routes_macro (line 37) | pub fn routes_macro(input: proc_macro::TokenStream) -> TokenStream {
  function catchers_macro (line 42) | pub fn catchers_macro(input: proc_macro::TokenStream) -> TokenStream {
  function uri_macro (line 47) | pub fn uri_macro(input: proc_macro::TokenStream) -> TokenStream {
  function uri_internal_macro (line 54) | pub fn uri_internal_macro(input: proc_macro::TokenStream) -> TokenStream {
  function guide_tests_internal (line 66) | pub fn guide_tests_internal(input: proc_macro::TokenStream) -> TokenStre...
  function export_internal (line 71) | pub fn export_internal(input: proc_macro::TokenStream) -> TokenStream {
  function typed_stream (line 76) | pub fn typed_stream(input: proc_macro::TokenStream) -> TokenStream {

FILE: core/codegen/src/bang/test_guide.rs
  function _macro (line 8) | pub fn _macro(input: proc_macro::TokenStream) -> devise::Result<TokenStr...
  function entry_to_tests (line 16) | fn entry_to_tests(root_glob: &LitStr) -> Result<Vec<TokenStream>, Box<dy...

FILE: core/codegen/src/bang/typed_stream.rs
  type Input (line 5) | pub enum Input {
  type Invocation (line 11) | struct Invocation {
  function trait_obj_recast (line 19) | fn trait_obj_recast(ty: &syn::Type) -> Option<(syn::Type, syn::Token![+]...
  method parse (line 40) | fn parse(input: ParseStream<'_>) -> syn::Result<Self> {
  method parse (line 69) | fn parse(input: ParseStream<'_>) -> syn::Result<Self> {
  function _macro (line 83) | pub fn _macro(input: proc_macro::TokenStream) -> devise::Result<TokenStr...

FILE: core/codegen/src/bang/uri.rs
  function prefix_last_segment (line 25) | pub fn prefix_last_segment(path: &mut syn::Path, prefix: &str) {
  function _uri_macro (line 30) | pub fn _uri_macro(input: TokenStream) -> Result<TokenStream> {
  function extract_exprs (line 42) | fn extract_exprs(internal: &InternalUriParams) -> Result<(
  function add_binding (line 119) | fn add_binding<P: fmt::Part>(to: &mut Vec<TokenStream>, ident: &Ident, t...
  function explode_path (line 135) | fn explode_path<'a>(
  function explode_query (line 168) | fn explode_query<'a>(
  function _uri_internal_macro (line 224) | pub fn _uri_internal_macro(input: TokenStream) -> Result<TokenStream> {

FILE: core/codegen/src/bang/uri_parsing.rs
  type ArgExpr (line 21) | pub enum ArgExpr {
    method as_expr (line 451) | pub fn as_expr(&self) -> Option<&Expr> {
    method unwrap_expr (line 458) | pub fn unwrap_expr(&self) -> &Expr {
  type Arg (line 27) | pub enum Arg {
    method is_named (line 423) | fn is_named(&self) -> bool {
    method unnamed (line 427) | fn unnamed(&self) -> &ArgExpr {
    method named (line 434) | fn named(&self) -> (&Name, &Ident, &ArgExpr) {
  type Args (line 33) | pub enum Args {
    method num (line 443) | fn num(&self) -> usize {
  type UriLit (line 40) | pub struct UriLit(Uri<'static>, Span);
  type UriExpr (line 44) | pub enum UriExpr {
    method parse_prefix (line 472) | fn parse_prefix(input: ParseStream<'_>) -> syn::Result<Option<Self>> {
    method parse_suffix (line 496) | fn parse_suffix(input: ParseStream<'_>) -> syn::Result<Option<Self>> {
  type RouteInvocation (line 53) | pub struct RouteInvocation {
  type RoutedUri (line 60) | pub struct RoutedUri {
    method args_span (line 414) | pub fn args_span(&self) -> Span {
  type UriMacro (line 80) | pub enum UriMacro {
    method unary (line 217) | fn unary(input: ParseStream<'_>) -> parse::Result<Self> {
    method binary (line 229) | fn binary(prefix: TokenStream, middle: TokenStream) -> parse::Result<S...
    method ternary (line 237) | fn ternary(prefix: TokenStream, mid: TokenStream, suffix: TokenStream)...
  type Validation (line 86) | pub enum Validation<'a> {
  type InternalUriParams (line 115) | pub struct InternalUriParams {
    method fn_args_str (line 342) | pub fn fn_args_str(&self) -> String {
    method dynamic_path_params (line 354) | pub fn dynamic_path_params(&self) -> impl Iterator<Item = &Dynamic> + ...
    method dynamic_query_params (line 359) | pub fn dynamic_query_params(&self) -> impl Iterator<Item = &Dynamic> +...
    method validate (line 363) | pub fn validate(&self) -> Validation<'_> {
  type FnArg (line 124) | pub struct FnArg {
  function err (line 129) | fn err<T, S: AsRef<str>>(span: Span, s: S) -> parse::Result<T> {
  method parse (line 134) | fn parse(input: ParseStream<'_>) -> parse::Result<Self> {
  method parse (line 144) | fn parse(input: ParseStream<'_>) -> parse::Result<Self> {
  method parse (line 159) | fn parse(input: ParseStream<'_>) -> syn::Result<Self> {
  method parse (line 187) | fn parse(input: ParseStream<'_>) -> syn::Result<Self> {
  method parse (line 202) | fn parse(input: ParseStream<'_>) -> syn::Result<Self> {
  method parse (line 247) | fn parse(input: ParseStream<'_>) -> parse::Result<Self> {
  method parse (line 286) | fn parse(input: ParseStream<'_>) -> syn::Result<Self> {
  method parse (line 295) | fn parse(input: ParseStream<'_>) -> parse::Result<FnArg> {
  method parse (line 305) | fn parse(input: ParseStream<'_>) -> parse::Result<InternalUriParams> {
  function uri_err (line 466) | fn uri_err<T>(lit: &StringLit, error: Error<'_>) -> parse::Result<T> {
  type Target (line 533) | type Target = Uri<'static>;
  method deref (line 535) | fn deref(&self) -> &Self::Target {
  method to_tokens (line 541) | fn to_tokens(&self, t: &mut TokenStream) {
  method to_tokens (line 556) | fn to_tokens(&self, t: &mut TokenStream) {
  method to_tokens (line 565) | fn to_tokens(&self, tokens: &mut TokenStream) {
  method to_tokens (line 574) | fn to_tokens(&self, tokens: &mut TokenStream) {
  method to_tokens (line 587) | fn to_tokens(&self, tokens: &mut TokenStream) {

FILE: core/codegen/src/derive/form_field.rs
  type FieldName (line 21) | pub enum FieldName {
    type Target (line 134) | type Target = Name;
    method deref (line 136) | fn deref(&self) -> &Self::Target {
  type FieldAttr (line 27) | pub struct FieldAttr {
    constant NAME (line 35) | const NAME: &'static str = "field";
  type FieldExt (line 38) | pub(crate) trait FieldExt {
    method ident (line 39) | fn ident(&self) -> Option<&syn::Ident>;
    method member (line 40) | fn member(&self) -> syn::Member;
    method context_ident (line 41) | fn context_ident(&self) -> syn::Ident;
    method field_names (line 42) | fn field_names(&self) -> Result<Vec<FieldName>>;
    method first_field_name (line 43) | fn first_field_name(&self) -> Result<Option<FieldName>>;
    method stripped_ty (line 44) | fn stripped_ty(&self) -> syn::Type;
    method name_buf_opt (line 45) | fn name_buf_opt(&self) -> Result<TokenStream>;
    method ident (line 169) | fn ident(&self) -> Option<&syn::Ident> {
    method member (line 173) | fn member(&self) -> syn::Member {
    method context_ident (line 185) | fn context_ident(&self) -> syn::Ident {
    method field_names (line 190) | fn field_names(&self) -> Result<Vec<FieldName>> {
    method first_field_name (line 205) | fn first_field_name(&self) -> Result<Option<FieldName>> {
    method stripped_ty (line 209) | fn stripped_ty(&self) -> syn::Type {
    method name_buf_opt (line 213) | fn name_buf_opt(&self) -> Result<TokenStream> {
  type VariantAttr (line 49) | pub struct VariantAttr {
    constant NAME (line 54) | const NAME: &'static str = "field";
  type VariantExt (line 57) | pub(crate) trait VariantExt {
    method first_form_field_value (line 58) | fn first_form_field_value(&self) -> Result<FieldName>;
    method form_field_values (line 59) | fn form_field_values(&self) -> Result<Vec<FieldName>>;
    method first_form_field_value (line 63) | fn first_form_field_value(&self) -> Result<FieldName> {
    method form_field_values (line 73) | fn form_field_values(&self) -> Result<Vec<FieldName>> {
  method from_meta (line 88) | fn from_meta(meta: &MetaItem) -> Result<Self> {
  method to_tokens (line 144) | fn to_tokens(&self, tokens: &mut TokenStream) {
  method eq (line 150) | fn eq(&self, other: &Self) -> bool {
  function member_to_ident (line 161) | fn member_to_ident(member: syn::Member) -> syn::Ident {
  type RecordMemberAccesses (line 224) | struct RecordMemberAccesses {
    method visit_expr_reference (line 230) | fn visit_expr_reference(&mut self, i: &'a syn::ExprReference) {
    method visit_expr_field (line 236) | fn visit_expr_field(&mut self, i: &syn::ExprField) {
  type ValidationMutator (line 248) | struct ValidationMutator<'a> {
  function visit_token_stream (line 254) | fn visit_token_stream(&mut self, tt: TokenStream) -> TokenStream {
  method visit_expr_call_mut (line 288) | fn visit_expr_call_mut(&mut self, call: &mut syn::ExprCall) {
  method visit_macro_mut (line 300) | fn visit_macro_mut(&mut self, mac: &mut syn::Macro) {
  method visit_ident_mut (line 305) | fn visit_ident_mut(&mut self, i: &mut syn::Ident) {
  method visit_expr_mut (line 312) | fn visit_expr_mut(&mut self, i: &mut syn::Expr) {
  function validators (line 346) | pub fn validators(field: Field<'_>) -> Result<impl Iterator<Item = syn::...
  function default_expr (line 395) | fn default_expr(expr: &syn::Expr) -> TokenStream {
  function default (line 407) | pub fn default(field: Field<'_>) -> Result<Option<TokenStream>> {
  type Dup (line 457) | type Dup = (usize, Span, Span);
  function first_duplicate (line 459) | pub fn first_duplicate<K: Spanned, V: PartialEq + Spanned>(

FILE: core/codegen/src/derive/from_form.rs
  type WherePredicates (line 11) | type WherePredicates = syn::punctuated::Punctuated<syn::WherePredicate, ...
  function fields_map (line 22) | fn fields_map<F>(fields: Fields<'_>, map_f: F) -> Result<TokenStream>
  function generic_bounds_tokens (line 60) | fn generic_bounds_tokens(input: Input<'_>) -> Result<TokenStream> {
  function generic_bounds (line 76) | fn generic_bounds(input: Input<'_>) -> Result<WherePredicates> {
  function context_type (line 80) | fn context_type(input: Input<'_>) -> Result<(TokenStream, syn::Generics)> {
  function derive_from_form (line 93) | pub fn derive_from_form(input: proc_macro::TokenStream) -> TokenStream {

FILE: core/codegen/src/derive/from_form_field.rs
  function derive_from_form_field (line 7) | pub fn derive_from_form_field(input: proc_macro::TokenStream) -> TokenSt...

FILE: core/codegen/src/derive/from_param.rs
  function derive_from_param (line 10) | pub fn derive_from_param(input: proc_macro::TokenStream) -> TokenStream {

FILE: core/codegen/src/derive/responder.rs
  type ItemAttr (line 10) | struct ItemAttr {
  type FieldAttr (line 16) | struct FieldAttr {
  function derive_responder (line 20) | pub fn derive_responder(input: proc_macro::TokenStream) -> TokenStream {

FILE: core/codegen/src/derive/uri_display.rs
  constant NO_EMPTY_FIELDS (line 9) | const NO_EMPTY_FIELDS: &str = "fieldless structs are not supported";
  constant NO_NULLARY (line 10) | const NO_NULLARY: &str = "nullary items are not supported";
  constant NO_EMPTY_ENUMS (line 11) | const NO_EMPTY_ENUMS: &str = "empty enums are not supported";
  constant ONLY_ONE_UNNAMED (line 12) | const ONLY_ONE_UNNAMED: &str = "tuple structs or variants must have exac...
  constant EXACTLY_ONE_FIELD (line 13) | const EXACTLY_ONE_FIELD: &str = "struct must have exactly one field";
  constant Q_URI_DISPLAY (line 15) | const Q_URI_DISPLAY: StaticTokens = quote_static!(#_fmt::UriDisplay<#_fm...
  constant Q_FORMATTER (line 16) | const Q_FORMATTER: StaticTokens = quote_static!(#_fmt::Formatter<#_fmt::...
  constant P_URI_DISPLAY (line 18) | const P_URI_DISPLAY: StaticTokens = quote_static!(#_fmt::UriDisplay<#_fm...
  constant P_FORMATTER (line 19) | const P_FORMATTER: StaticTokens = quote_static!(#_fmt::Formatter<#_fmt::...
  function generic_bounds_mapper (line 21) | fn generic_bounds_mapper(bound: StaticTokens) -> MapperBuild {
  function derive_uri_display_query (line 36) | pub fn derive_uri_display_query(input: proc_macro::TokenStream) -> Token...
  function derive_uri_display_path (line 113) | pub fn derive_uri_display_path(input: proc_macro::TokenStream) -> TokenS...
  function from_uri_param (line 153) | fn from_uri_param<P: fmt::Part>(input: proc_macro::TokenStream, ty: Toke...

FILE: core/codegen/src/exports.rs
  type StaticPath (line 5) | pub struct StaticPath(pub Option<Span>, pub &'static str);
    method respanned (line 23) | pub fn respanned(mut self, span: Span) -> Self {
  type StaticTokens (line 8) | pub struct StaticTokens(pub fn() -> TokenStream);
  method to_tokens (line 17) | fn to_tokens(&self, tokens: &mut TokenStream) {
  method to_tokens (line 30) | fn to_tokens(&self, tokens: &mut TokenStream) {
  function mixed (line 113) | pub fn mixed(span: Span) -> Span {

FILE: core/codegen/src/http_codegen.rs
  type ContentType (line 8) | pub struct ContentType(pub http::ContentType);
  type Status (line 11) | pub struct Status(pub http::Status);
  type MediaType (line 14) | pub struct MediaType(pub http::MediaType);
  type Method (line 17) | pub struct Method(pub http::Method);
  type Optional (line 20) | pub struct Optional<T>(pub Option<T>);
  type Origin (line 23) | pub struct Origin<'a>(pub &'a http::uri::Origin<'a>, pub Span);
  type Absolute (line 26) | pub struct Absolute<'a>(pub &'a http::uri::Absolute<'a>, pub Span);
  type Authority (line 29) | pub struct Authority<'a>(pub &'a http::uri::Authority<'a>, pub Span);
  type Reference (line 32) | pub struct Reference<'a>(pub &'a http::uri::Reference<'a>, pub Span);
  type Asterisk (line 35) | pub struct Asterisk(pub http::uri::Asterisk, pub Span);
  method from_meta (line 38) | fn from_meta(meta: &MetaItem) -> Result<Self> {
  method to_tokens (line 49) | fn to_tokens(&self, tokens: &mut TokenStream) {
  method from_meta (line 56) | fn from_meta(meta: &MetaItem) -> Result<Self> {
  method to_tokens (line 64) | fn to_tokens(&self, tokens: &mut TokenStream) {
  method from_meta (line 72) | fn from_meta(meta: &MetaItem) -> Result<Self> {
  method to_tokens (line 89) | fn to_tokens(&self, tokens: &mut TokenStream) {
  method from_meta (line 101) | fn from_meta(meta: &MetaItem) -> Result<Self> {
  method to_tokens (line 126) | fn to_tokens(&self, tokens: &mut TokenStream) {
  method to_tokens (line 133) | fn to_tokens(&self, tokens: &mut TokenStream) {
  method to_tokens (line 147) | fn to_tokens(&self, tokens: &mut TokenStream) {
  method to_tokens (line 161) | fn to_tokens(&self, tokens: &mut TokenStream) {
  method to_tokens (line 177) | fn to_tokens(&self, tokens: &mut TokenStream) {
  method to_tokens (line 191) | fn to_tokens(&self, tokens: &mut TokenStream) {
  method to_tokens (line 208) | fn to_tokens(&self, tokens: &mut TokenStream) {

FILE: core/codegen/src/lib.rs
  function catch (line 362) | pub fn catch(args: TokenStream, input: TokenStream) -> TokenStream {
  function suppress (line 389) | pub fn suppress(args: TokenStream, input: TokenStream) -> TokenStream {
  function async_test (line 411) | pub fn async_test(args: TokenStream, input: TokenStream) -> TokenStream {
  function main (line 453) | pub fn main(args: TokenStream, input: TokenStream) -> TokenStream {
  function launch (line 512) | pub fn launch(args: TokenStream, input: TokenStream) -> TokenStream {
  function derive_from_form_field (line 579) | pub fn derive_from_form_field(input: TokenStream) -> TokenStream {
  function derive_from_form (line 780) | pub fn derive_from_form(input: TokenStream) -> TokenStream {
  function derive_from_param (line 822) | pub fn derive_from_param(input: TokenStream) -> TokenStream {
  function derive_responder (line 1015) | pub fn derive_responder(input: TokenStream) -> TokenStream {
  function derive_uri_display_query (line 1109) | pub fn derive_uri_display_query(input: TokenStream) -> TokenStream {
  function derive_uri_display_path (line 1135) | pub fn derive_uri_display_path(input: TokenStream) -> TokenStream {
  function routes (line 1191) | pub fn routes(input: TokenStream) -> TokenStream {
  function catchers (line 1249) | pub fn catchers(input: TokenStream) -> TokenStream {
  function uri (line 1545) | pub fn uri(input: TokenStream) -> TokenStream {
  function rocket_internal_uri (line 1552) | pub fn rocket_internal_uri(input: TokenStream) -> TokenStream {
  function __typed_stream (line 1559) | pub fn __typed_stream(input: TokenStream) -> TokenStream {
  function internal_guide_tests (line 1566) | pub fn internal_guide_tests(input: TokenStream) -> TokenStream {
  function export (line 1573) | pub fn export(input: TokenStream) -> TokenStream {
  function async_bound (line 1580) | pub fn async_bound(args: TokenStream, input: TokenStream) -> TokenStream {

FILE: core/codegen/src/name.rs
  type Name (line 18) | pub struct Name {
    method new (line 26) | pub fn new<S: Into<String>>(name: S, span: Span) -> Self {
    method as_str (line 32) | pub fn as_str(&self) -> &str {
    method as_uncased_str (line 37) | pub fn as_uncased_str(&self) -> &UncasedStr {
    method span (line 41) | pub fn span(&self) -> Span {
    method from_meta (line 47) | fn from_meta(meta: &devise::MetaItem) -> devise::Result<Self> {
    method to_tokens (line 59) | fn to_tokens(&self, tokens: &mut TokenStream) {
    method from (line 65) | fn from(ident: &Ident) -> Self {
    method as_ref (line 71) | fn as_ref(&self) -> &str {
    method hash (line 77) | fn hash<H: std::hash::Hasher>(&self, hasher: &mut H) {
    type Target (line 83) | type Target = str;
    method deref (line 85) | fn deref(&self) -> &Self::Target {
    method eq (line 93) | fn eq(&self, other: &S) -> bool {
    method fmt (line 99) | fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {

FILE: core/codegen/src/proc_macro_ext.rs
  type Diagnostics (line 7) | pub struct Diagnostics(Vec<Diagnostic>);
    method new (line 10) | pub fn new() -> Self {
    method push (line 14) | pub fn push(&mut self, diag: Diagnostic) {
    method emit_head (line 18) | pub fn emit_head(self) -> Diagnostic {
    method head_err_or (line 30) | pub fn head_err_or<T>(self, ok: T) -> devise::Result<T> {
    method from (line 39) | fn from(diag: Diagnostic) -> Self {
    method from (line 45) | fn from(diags: Vec<Diagnostic>) -> Self {
  type StringLit (line 50) | pub struct StringLit(pub String, pub Literal);
    method new (line 53) | pub fn new<S: Into<String>>(string: S, span: Span) -> Self {
    method span (line 60) | pub fn span(&self) -> Span {
    method subspan (line 67) | pub fn subspan<R: RangeBounds<usize>>(&self, range: R) -> Span {
    method parse (line 73) | fn parse(input: syn::parse::ParseStream<'_>) -> syn::Result<Self> {
    method from_meta (line 80) | fn from_meta(meta: &devise::MetaItem) -> devise::Result<Self> {
    type Target (line 86) | type Target = str;
    method deref (line 88) | fn deref(&self) -> &str {

FILE: core/codegen/src/syn_ext.rs
  type IdentExt (line 12) | pub trait IdentExt {
    method prepend (line 13) | fn prepend(&self, string: &str) -> syn::Ident;
    method append (line 14) | fn append(&self, string: &str) -> syn::Ident;
    method with_span (line 15) | fn with_span(self, span: Span) -> syn::Ident;
    method rocketized (line 16) | fn rocketized(&self) -> syn::Ident;
    method uniqueify_with (line 17) | fn uniqueify_with<F: FnMut(&mut dyn Hasher)>(&self, f: F) -> syn::Ident;
    method prepend (line 66) | fn prepend(&self, string: &str) -> syn::Ident {
    method append (line 70) | fn append(&self, string: &str) -> syn::Ident {
    method with_span (line 74) | fn with_span(mut self, span: Span) -> syn::Ident {
    method rocketized (line 79) | fn rocketized(&self) -> syn::Ident {
    method uniqueify_with (line 91) | fn uniqueify_with<F: FnMut(&mut dyn Hasher)>(&self, mut f: F) -> syn::...
  type ReturnTypeExt (line 20) | pub trait ReturnTypeExt {
    method ty (line 21) | fn ty(&self) -> Option<&syn::Type>;
    method ty (line 105) | fn ty(&self) -> Option<&syn::Type> {
  type FnArgExt (line 24) | pub trait FnArgExt {
    method typed (line 25) | fn typed(&self) -> Option<(&syn::Ident, &syn::Type)>;
    method wild (line 26) | fn wild(&self) -> Option<&syn::PatWild>;
    method typed (line 114) | fn typed(&self) -> Option<(&Ident, &syn::Type)> {
    method wild (line 124) | fn wild(&self) -> Option<&syn::PatWild> {
  type TypeExt (line 29) | pub trait TypeExt {
    method unfold_with_ty_macros (line 30) | fn unfold_with_ty_macros(&self, names: &[&str], mapper: MacTyMapFn) ->...
    method is_concrete (line 31) | fn is_concrete(&self, generic_ident: &[&Ident]) -> bool;
    method unfold_with_ty_macros (line 146) | fn unfold_with_ty_macros(&self, names: &[&str], mapper: MacTyMapFn) ->...
    method is_concrete (line 190) | fn is_concrete(&self, generics: &[&Ident]) -> bool {
  type GenericsExt (line 34) | pub trait GenericsExt {
    method type_idents (line 35) | fn type_idents(&self) -> Vec<&Ident>;
    method type_idents (line 219) | fn type_idents(&self) -> Vec<&Ident> {
  type Child (line 39) | pub struct Child<'a> {
  type Target (line 45) | type Target = syn::Type;
  method deref (line 47) | fn deref(&self) -> &Self::Target {
  type Owned (line 53) | type Owned = Child<'static>;
  method into_owned (line 55) | fn into_owned(self) -> Self::Owned {
  type MacTyMapFn (line 63) | type MacTyMapFn = fn(&TokenStream) -> Option<syn::Type>;
  function macro_inner_ty (line 135) | fn macro_inner_ty(t: &syn::TypeMacro, names: &[&str], m: MacTyMapFn) -> ...
  function test_type_unfold_is_generic (line 227) | fn test_type_unfold_is_generic() {

FILE: core/codegen/tests/async-entry.rs
  function rocket (line 6) | async fn rocket() -> rocket::Rocket<rocket::Build> {
  function use_it (line 11) | async fn use_it() {
  function main2 (line 19) | async fn main2() -> _ {
  function use_it (line 23) | async fn use_it() {
  function main2 (line 30) | async fn main2() -> _ { rocket::build() }
  function use_it (line 32) | async fn use_it() {
  function rocket (line 40) | fn rocket() -> _ {
  function use_it (line 44) | fn use_it() {
  function rocket (line 51) | fn rocket() -> _ { rocket::build() }
  function use_it (line 53) | fn use_it() {
  function main (line 61) | async fn main() {
  function main (line 69) | async fn main() { }
  function main (line 75) | async fn main() -> Result<(), rocket::Error> {
  function main (line 84) | async fn main() -> Result<(), String> {
  function main (line 91) | async fn main() -> Result<(), String> {

FILE: core/codegen/tests/async-routes.rs
  function noop (line 7) | async fn noop() { }
  function hello (line 10) | async fn hello(_origin: &Origin<'_>) -> &'static str {
  function repeated_query (line 16) | async fn repeated_query(sort: Vec<&str>) -> &str {
  function not_found (line 22) | async fn not_found(req: &Request<'_>) -> String {

FILE: core/codegen/tests/catcher.rs
  function not_found_0 (line 12) | fn not_found_0() -> &'static str { "404-0" }
  function not_found_1 (line 13) | fn not_found_1(_: &Request<'_>) -> &'static str { "404-1" }
  function not_found_2 (line 14) | fn not_found_2(_: Status, _: &Request<'_>) -> &'static str { "404-2" }
  function all (line 15) | fn all(_: Status, r: &Request<'_>) -> String { r.uri().to_string() }
  function test_simple_catchers (line 18) | fn test_simple_catchers() {
  function forward (line 39) | fn forward(code: u16) -> Status { Status::new(code) }
  function forward_400 (line 40) | fn forward_400(status: Status, _: &Request<'_>) -> String { status.code....
  function forward_404 (line 41) | fn forward_404(status: Status, _: &Request<'_>) -> String { status.code....
  function forward_444 (line 42) | fn forward_444(status: Status, _: &Request<'_>) -> String { status.code....
  function forward_500 (line 43) | fn forward_500(status: Status, _: &Request<'_>) -> String { status.code....
  function test_status_param (line 46) | fn test_status_param() {

FILE: core/codegen/tests/expansion.rs
  function easy (line 6) | fn easy(id: i32) -> String {
  function test_reexpansion (line 35) | fn test_reexpansion() {
  function test_index (line 61) | fn test_index() {

FILE: core/codegen/tests/from_form.rs
  function strict (line 12) | fn strict<'f, T: FromForm<'f>>(string: &'f str) -> Result<T, Errors<'f>> {
  function lenient (line 16) | fn lenient<'f, T: FromForm<'f>>(string: &'f str) -> Result<T, Errors<'f>> {
  function strict_encoded (line 20) | fn strict_encoded<T: 'static>(string: &str) -> Result<T, Errors<'static>>
  type TodoTask (line 27) | struct TodoTask {
  function simple (line 33) | fn simple() {
  type FormOption (line 60) | enum FormOption {
  type FormInput (line 65) | struct FormInput<'r> {
  type DefaultInput (line 75) | struct DefaultInput<'r> {
  type ManualMethod (line 80) | struct ManualMethod<'r> {
  type UnpresentCheckbox (line 86) | struct UnpresentCheckbox {
  type UnpresentCheckboxTwo (line 91) | struct UnpresentCheckboxTwo<'r> {
  type FieldNamedV (line 97) | struct FieldNamedV<'r> {
  function base_conditions (line 102) | fn base_conditions() {
  function lenient_parsing (line 165) | fn lenient_parsing() {
  function field_renaming (line 198) | fn field_renaming() {
  function generics (line 293) | fn generics() {
  function form_errors (line 338) | fn form_errors() {
  function form_validate_error_return_correct_field_name (line 413) | fn form_validate_error_return_correct_field_name() {
  function form_validate_contains_all_errors (line 433) | fn form_validate_contains_all_errors() {
  function raw_ident_form (line 458) | fn raw_ident_form() {
  function test_multi (line 469) | fn test_multi() {
  type Dog (line 521) | struct Dog {
  type Cat (line 527) | struct Cat<'r> {
  type Pet (line 533) | struct Pet<'r, T> {
  type Person (line 540) | struct Person<'r> {
  function test_nested_multi (line 547) | fn test_nested_multi() {
  function test_multipart (line 627) | fn test_multipart() {
  function test_default_removed (line 676) | fn test_default_removed() {
  function test_defaults (line 725) | fn test_defaults() {
  function test_lazy_default (line 891) | fn test_lazy_default() {
  type Token (line 935) | struct Token<'r>(&'r str);
  type TokenOwned (line 939) | struct TokenOwned(String);
  function wrapper_works (line 942) | fn wrapper_works() {
  type JsonToken (line 966) | struct JsonToken<T>(Json<T>);
  function json_wrapper_works (line 969) | fn json_wrapper_works() {
  type Q (line 989) | struct Q<T>(T);
  type JsonTokenBad (line 993) | pub struct JsonTokenBad<T>(Q<T>);
  function range (line 996) | fn range() {

FILE: core/codegen/tests/from_form_field.rs
  function parse (line 3) | fn parse<'v, T: FromForm<'v>>(value: &'v str) -> Result<T, Errors<'v>> {
  function from_form_value_simple (line 32) | fn from_form_value_simple() {
  function from_form_value_weirder (line 42) | fn from_form_value_weirder() {
  function from_form_value_no_parse (line 52) | fn from_form_value_no_parse() {
  function from_form_value_renames (line 61) | fn from_form_value_renames() {
  function from_form_value_raw (line 77) | fn from_form_value_raw() {
  function form_value_errors (line 91) | fn form_value_errors() {

FILE: core/codegen/tests/from_param.rs
  type Test (line 5) | enum Test {
  function derive_from_param (line 12) | fn derive_from_param() {

FILE: core/codegen/tests/responder.rs
  type Foo (line 8) | pub enum Foo<'r> {
  function responder_foo (line 25) | async fn responder_foo() {
  type Bar (line 65) | pub struct Bar<'r> {
  function responder_bar (line 74) | async fn responder_bar() {
  type Baz (line 94) | pub struct Baz {
  function responder_baz (line 99) | async fn responder_baz() {
  type MyResult (line 116) | enum MyResult<'a, T, E, H1, H2> {
  function generic_responder (line 125) | async fn generic_responder() {

FILE: core/codegen/tests/route-data.rs
  type Inner (line 12) | struct Inner<'r> {
  type Simple (line 16) | struct Simple<'r>(&'r str);
  type Error (line 20) | type Error = std::io::Error;
  function from_data (line 22) | async fn from_data(req: &'r Request<'_>, data: Data<'r>) -> data::Outcom...
  function form (line 28) | fn form<'r>(form: Form<Inner<'r>>) -> &'r str { form.into_inner().field }
  function simple (line 31) | fn simple<'r>(simple: Simple<'r>) -> &'r str { simple.0 }
  function test_data (line 34) | fn test_data() {

FILE: core/codegen/tests/route-format.rs
  function json (line 9) | fn json() -> &'static str { "json" }
  function xml (line 12) | fn xml() -> &'static str { "xml" }
  function json_long (line 16) | fn json_long() -> &'static str { "json_long" }
  function msgpack_long (line 19) | fn msgpack_long() -> &'static str { "msgpack_long" }
  function msgpack (line 23) | fn msgpack() -> &'static str { "msgpack" }
  function plain (line 26) | fn plain() -> &'static str { "plain" }
  function binary (line 29) | fn binary() -> &'static str { "binary" }
  function other (line 32) | fn other() -> &'static str { "other" }
  function test_formats (line 35) | fn test_formats() {
  function get_foo (line 71) | fn get_foo() -> &'static str { "get_foo" }
  function post_foo (line 75) | fn post_foo() -> &'static str { "post_foo" }
  function get_bar_baz (line 79) | fn get_bar_baz() -> &'static str { "get_bar_baz" }
  function put_bar_baz (line 83) | fn put_bar_baz() -> &'static str { "put_bar_baz" }
  function test_custom_formats (line 86) | fn test_custom_formats() {

FILE: core/codegen/tests/route-ranking.rs
  function get0 (line 8) | fn get0(_number: u8) -> &'static str { "0" }
  function get1 (line 11) | fn get1(_number: u16) -> &'static str { "1" }
  function get2 (line 14) | fn get2(_number: u32) -> &'static str { "2" }
  function get3 (line 17) | fn get3(_number: u64) -> &'static str { "3" }
  function test_ranking (line 20) | fn test_ranking() {
  function get0b (line 40) | fn get0b(_n: u8) {  }
  function test_rank_collision (line 43) | fn test_rank_collision() {

FILE: core/codegen/tests/route-raw.rs
  function get (line 8) | fn get(r#enum: String, r#type: i32) -> String {
  function swap (line 13) | fn swap(r#raw: String, bare: String) -> String {
  function catch (line 18) | fn catch(r#raw: &rocket::Request<'_>) -> String {
  function test_raw_ident (line 23) | fn test_raw_ident() {

FILE: core/codegen/tests/route-uniqueness.rs
  function index (line 4) | fn index() { }
  function index (line 11) | pub fn index() { }
  function test_uri_reachability (line 37) | fn test_uri_reachability() {
  function test_uri_calls (line 61) | fn test_uri_calls() {

FILE: core/codegen/tests/route.rs
  type Inner (line 19) | struct Inner<'r> {
  type Simple (line 23) | struct Simple(String);
    type Error (line 27) | type Error = std::io::Error;
    method from_data (line 29) | async fn from_data(req: &'r Request<'_>, data: Data<'r>) -> data::Outc...
  function post1 (line 40) | fn post1(
  function post2 (line 63) | fn post2(
  function test_unused_params (line 81) | fn test_unused_params(_unused_param: String, _unused_query: String, _unu...
  function test_full_route (line 85) | fn test_full_route() {
  function world (line 137) | pub fn world() -> &'static str {
  function hello (line 143) | pub fn hello() -> &'static str {
  function _rocket (line 149) | fn _rocket() -> rocket::Rocket<rocket::Build> {
  type Filtered (line 157) | struct Filtered<'r> {
  function filtered_raw_query (line 165) | fn filtered_raw_query(bird: usize, color: &str, rest: Contextual<'_, Fil...
  function test_filtered_raw_query (line 174) | fn test_filtered_raw_query() {
  type Dog (line 229) | struct Dog<'r> {
  type Q (line 235) | struct Q<'r> {
  function query_collection (line 240) | fn query_collection(color: Vec<&str>, q: Q<'_>) -> String {
  function query_collection_2 (line 245) | fn query_collection_2(color: Vec<&str>, dog: Dog<'_>) -> String {
  function test_query_collection (line 250) | fn test_query_collection() {
  type PathString (line 305) | struct PathString(String);
    type Error (line 308) | type Error = std::convert::Infallible;
    method from_segments (line 310) | fn from_segments(segments: Segments<'_, Path>) -> Result<Self, Self::E...
  function segments (line 317) | fn segments(path: PathString) -> String {
  function segments_empty (line 322) | fn segments_empty(path: PathString) -> String {
  function test_inclusive_segments (line 327) | fn test_inclusive_segments() {

FILE: core/codegen/tests/segment-ignore.rs
  function ig_1 (line 4) | fn ig_1() -> &'static str { "1" }
  function just_static (line 6) | fn just_static() -> &'static str { "static" }
  function ig_2 (line 8) | fn ig_2() -> &'static str { "2" }
  function ig_1_static (line 10) | fn ig_1_static() -> &'static str { "static_1" }
  function ig_3 (line 12) | fn ig_3() -> &'static str { "3" }
  function ig_1_static_static (line 14) | fn ig_1_static_static() -> &'static str { "static_1_static" }
  function wrapped (line 16) | fn wrapped(a: String, b: String) -> String { a + &b }
  function test_ignored_segments (line 19) | fn test_ignored_segments() {

FILE: core/codegen/tests/typed-uris.rs
  type User (line 25) | struct User<'a> {
  type Target (line 31) | type Target = User<'a>;
  function from_uri_param (line 32) | fn from_uri_param((name, nickname): (&'a str, &'b str)) -> User<'a> {
  type Second (line 41) | struct Second {
  function index (line 46) | fn index() { }
  function simple (line 49) | fn simple(id: i32) { }
  function simple2 (line 52) | fn simple2(id: i32, name: String) { }
  function simple2_flipped (line 55) | fn simple2_flipped(name: String, id: i32) { }
  function simple3 (line 58) | fn simple3(id: i32) { }
  function simple4 (line 61) | fn simple4(id: i32, name: String) { }
  function simple4_flipped (line 64) | fn simple4_flipped(name: String, id: i32) { }
  function unused_param (line 67) | fn unused_param(used: i32, _unused: i32) { }
  function guard_1 (line 70) | fn guard_1(cookies: &CookieJar<'_>, id: i32) { }
  function guard_2 (line 73) | fn guard_2(name: String, cookies: &CookieJar<'_>, id: i32) { }
  function guard_3 (line 76) | fn guard_3(id: i32, name: String, cookies: &CookieJar<'_>) { }
  function no_uri_display_okay (line 79) | fn no_uri_display_okay(id: i32, form: Form<Second>) { }
  function complex (line 82) | fn complex<'r>(
  function segments (line 92) | fn segments(path: PathBuf) { }
  function param_and_segments (line 95) | fn param_and_segments(path: PathBuf, id: usize) { }
  function guarded_segments (line 98) | fn guarded_segments(cookies: &CookieJar<'_>, path: PathBuf, id: usize) { }
  function check_simple_unnamed (line 101) | fn check_simple_unnamed() {
  function check_simple_named (line 141) | fn check_simple_named() {
  function check_route_prefix_suffix (line 186) | fn check_route_prefix_suffix() {
  function check_guards_ignored (line 307) | fn check_guards_ignored() {
  function check_with_segments (line 325) | fn check_with_segments() {
  function check_complex (line 351) | fn check_complex() {
  function check_location_promotion (line 394) | fn check_location_promotion() {
  function check_scoped (line 433) | fn check_scoped() {
  function simple (line 443) | fn simple(id: i32) { }
  function check_simple_scoped (line 446) | fn check_simple_scoped() {
  function simple (line 457) | fn simple(id: i32) { }
  function check_deep_scoped (line 460) | fn check_deep_scoped() {
  type Third (line 470) | struct Third<'r> {
  function optionals (line 476) | fn optionals(
  function test_optional_uri_parameters (line 484) | fn test_optional_uri_parameters() {
  function test_simple_ignored (line 554) | fn test_simple_ignored() {
  function test_maps (line 590) | fn test_maps() {
  function test_json (line 624) | fn test_json() {
  function test_route_uri_normalization_with_prefix (line 659) | fn test_route_uri_normalization_with_prefix() {
  function test_vec_in_query (line 678) | fn test_vec_in_query() {
  function test_either (line 714) | fn test_either() {

FILE: core/codegen/tests/ui-fail.rs
  function ui (line 3) | fn ui() {

FILE: core/codegen/tests/ui-fail/async-entry.rs
  function foo (line 5) | fn foo() { }
  function foo (line 11) | async fn foo() { }
  function main (line 17) | fn main() {
  function main (line 24) | async fn main() {
  function rocket (line 33) | async fn rocket() -> String {
  function rocket (line 42) | async fn rocket() -> _ {
  function main (line 50) | fn main() -> rocket::Rocket<rocket::Build> {
  function rocket (line 57) | async fn rocket() {
  function rocket (line 65) | fn rocket() {
  function rocket (line 72) | fn rocket() -> _ {
  function main (line 80) | fn main() -> &'static str {
  function main (line 88) | async fn main() -> _ {
  function main (line 94) | async fn main() -> rocket::Rocket<rocket::Build> {

FILE: core/codegen/tests/ui-fail/bad-ignored-segments.rs
  function i0 (line 4) | fn i0() {}
  function i1 (line 7) | fn i1() {}
  function i2 (line 10) | fn i2() {}
  function main (line 12) | fn main() {  }

FILE: core/codegen/tests/ui-fail/catch.rs
  type Catcher (line 6) | struct Catcher(String);
  constant CATCH (line 9) | const CATCH: &str = "Catcher";
  function e1 (line 12) | fn e1(_request: &Request) { }
  function e2 (line 15) | fn e2(_request: &Request) { }
  function e3 (line 18) | fn e3(_request: &Request) { }
  function e4 (line 21) | fn e4(_request: &Request) { }
  function e5 (line 24) | fn e5(_request: &Request) { }
  function e5 (line 27) | fn e5(_request: &Request) { }
  function f3 (line 30) | fn f3(_request: &Request, _other: bool) { }
  function main (line 32) | fn main() { }

FILE: core/codegen/tests/ui-fail/catch_type_errors.rs
  function f1 (line 6) | fn f1(_request: &Request) -> usize {
  function f2 (line 11) | fn f2(_request: &Request) -> bool {
  function f3 (line 16) | fn f3(_request: bool) -> usize {
  function f4 (line 21) | fn f4() -> usize {
  function main (line 25) | fn main() {  }

FILE: core/codegen/tests/ui-fail/catchers.rs
  function main (line 3) | fn main() {

FILE: core/codegen/tests/ui-fail/from_form.rs
  type Thing (line 4) | enum Thing { }
  type Foo1 (line 7) | struct Foo1;
  type Foo2 (line 10) | struct Foo2 {  }
  type Foo3 (line 13) | struct Foo3(usize);
  type Foo4 (line 16) | struct Foo4(usize, usize, usize);
  type NextTodoTask (line 19) | struct NextTodoTask<'f, 'a> {
  type BadName1 (line 27) | struct BadName1 {
  type Demo2 (line 33) | struct Demo2 {
  type MyForm9 (line 40) | struct MyForm9 {
  type MyForm10 (line 48) | struct MyForm10 {
  type MyForm (line 55) | struct MyForm {
  type MyForm1 (line 61) | struct MyForm1 {
  type MyForm2 (line 67) | struct MyForm2 {
  type MyForm3 (line 73) | struct MyForm3 {
  type MyForm4 (line 79) | struct MyForm4 {
  type MyForm5 (line 85) | struct MyForm5 {
  type MyForm6 (line 92) | struct MyForm6 {
  type MyForm7 (line 98) | struct MyForm7 {
  type MyForm8 (line 104) | struct MyForm8 {
  type MyForm11 (line 110) | struct MyForm11 {
  type MyForm12 (line 116) | struct MyForm12 {
  type MyForm13 (line 122) | struct MyForm13 {
  type MyForm14 (line 128) | struct MyForm14 {
  type BadName2 (line 134) | struct BadName2 {
  type BadName3 (line 140) | struct BadName3 {
  type Validate0 (line 146) | struct Validate0 {
  type Validate1 (line 152) | struct Validate1 {
  type Validate2 (line 158) | struct Validate2 {
  type Validate3 (line 164) | struct Validate3 {
  type Default0 (line 170) | struct Default0 {
  type Default1 (line 176) | struct Default1 {
  type Default2 (line 182) | struct Default2 {
  type Default3 (line 189) | struct Default3 {
  type Default4 (line 195) | struct Default4 {
  type Default5 (line 202) | struct Default5 {
  type Default6 (line 208) | struct Default6 {
  type Another (line 214) | struct Another<T> {
  type AnotherOne (line 220) | struct AnotherOne<T> { // NO ERROR
  function main (line 225) | fn main() { }

FILE: core/codegen/tests/ui-fail/from_form_field.rs
  type Foo1 (line 4) | struct Foo1;
  type Foo2 (line 7) | struct Foo2(usize);
  type Foo3 (line 10) | struct Foo3 {
  type Foo4 (line 15) | enum Foo4 {
  type Foo5 (line 20) | enum Foo5 { }
  type Foo6 (line 23) | enum Foo6<T> {
  type Bar1 (line 28) | enum Bar1 {
  type Bar2 (line 34) | enum Bar2 {
  type Dup1 (line 40) | enum Dup1 {
  type Dup2 (line 47) | enum Dup2 {
  type Dup3 (line 55) | enum Dup3 {
  type Dup4 (line 62) | enum Dup4 {
  type Dup5 (line 71) | enum Dup5 {
  type Dup6 (line 79) | enum Dup6 {
  type Renamed0 (line 86) | struct Renamed0 {
  type Renamed1 (line 93) | struct Renamed1 {
  type Renamed2 (line 101) | struct Renamed2 {
  type Renamed3 (line 108) | struct Renamed3 {
  function main (line 114) | fn main() { }

FILE: core/codegen/tests/ui-fail/from_form_type_errors.rs
  type Unknown (line 3) | struct Unknown;
  type BadType3 (line 6) | struct BadType3 {
  type Foo (line 10) | struct Foo<T>(T);
  type Other (line 13) | struct Other {
  function main (line 17) | fn main() {  }

FILE: core/codegen/tests/ui-fail/from_param.rs
  type Foo1 (line 4) | struct Foo1 {
  type Foo2 (line 9) | struct Foo2 {}
  type Foo3 (line 12) | enum Foo3 {
  type Foo4 (line 18) | struct Foo4(usize);
  function main (line 20) | fn main() {}

FILE: core/codegen/tests/ui-fail/responder-types.rs
  type Thing1 (line 4) | struct Thing1 {
  type Thing2 (line 9) | struct Thing2 {
  type Thing3 (line 15) | struct Thing3 {
  type Thing4 (line 21) | struct Thing4 {
  function foo (line 28) | fn foo() -> usize { 0 }
  function main (line 30) | fn main() {  }

FILE: core/codegen/tests/ui-fail/responder.rs
  type Thing1 (line 4) | struct Thing1;
  type Thing2 (line 7) | struct Thing2();
  type Bar (line 10) | enum Bar { }
  type Foo (line 13) | enum Foo { Bark, }
  type Thing4 (line 16) | struct Thing4<'a, 'b>(&'a str, &'b str);
  type Thing5 (line 19) | struct Thing5<T>(T);
  type Thing6 (line 22) | struct Thing6<T, E>(T, E);
  type Thing7 (line 26) | struct Thing7(());
  type Thing8 (line 30) | struct Thing8(());
  type Thing9 (line 34) | struct Thing9(());
  type Thing10 (line 38) | struct Thing10(());
  type Thing11 (line 42) | struct Thing11(());
  type Thing12 (line 46) | struct Thing12(());
  type Thing13 (line 50) | struct Thing13(());
  type Error (line 53) | enum Error<'r, T> {
  type Error2 (line 63) | enum Error2<'r, T> {
  function main (line 67) | fn main() {}

FILE: core/codegen/tests/ui-fail/route-attribute-general-syntax.rs
  function a0 (line 5) | fn a0() {}
  type S (line 9) | struct S;
  type A (line 12) | enum A {  }
  type Foo (line 15) | trait Foo {  }
  function b0 (line 22) | fn b0() {}
  function b1 (line 25) | fn b1() {}
  function b2 (line 28) | fn b2(foo: usize) {}
  function b3 (line 31) | fn b3() {}
  function b4 (line 34) | fn b4() {}
  function c1 (line 39) | fn c1(_: usize) {}
  function d0 (line 44) | fn d0() {}
  function d1 (line 47) | fn d1() {}
  function d2 (line 50) | fn d2() {}
  function d3 (line 53) | fn d3() {}
  function e0 (line 58) | fn e0() {}
  function e1 (line 61) | fn e1() {}
  function e2 (line 64) | fn e2() {}
  function e3 (line 67) | fn e3() {}
  function e4 (line 70) | fn e4() {}
  function e5 (line 73) | fn e5() {}
  function e6 (line 76) | fn e6() {}
  function e7 (line 79) | fn e7() {}
  function e8 (line 82) | fn e8() {}
  function e9 (line 85) | fn e9() {}
  function e10 (line 88) | fn e10() {}
  function e12 (line 91) | fn e12() {}
  function f0 (line 96) | fn f0() {}
  function f1 (line 99) | fn f1() {}
  function f2 (line 102) | fn f2() {}
  function f3 (line 105) | fn f3() {}
  function f4 (line 108) | fn f4() {}
  function main (line 110) | fn main() {}

FILE: core/codegen/tests/ui-fail/route-path-bad-syntax.rs
  function f0 (line 6) | fn f0() {}
  function f1 (line 9) | fn f1() {}
  function f2 (line 12) | fn f2() {}
  function f3 (line 15) | fn f3() {}
  function f4 (line 18) | fn f4() {}
  function f5 (line 21) | fn f5() {}
  function f6 (line 24) | fn f6() {}
  function g1 (line 29) | fn g1() {}
  function g2 (line 32) | fn g2() {}
  function g3 (line 35) | fn g3() {}
  function g4 (line 38) | fn g4() {}
  function h0 (line 43) | fn h0(_name: usize) {}
  function h1 (line 46) | fn h1() {}
  function h2 (line 49) | fn h2() {}
  function h3 (line 52) | fn h3() {}
  function h4 (line 55) | fn h4() {}
  function i0 (line 61) | fn i0() {}
  function i1 (line 64) | fn i1() {}
  function i2 (line 67) | fn i2() {}
  function i3 (line 70) | fn i3() {}
  function j0 (line 75) | fn j0() {}
  function j1 (line 78) | fn j1() {}
  function j2 (line 81) | fn j2() {}
  function j3 (line 84) | fn j3() {}
  function k0 (line 89) | fn k0(_: usize) {}
  function m0 (line 94) | fn m0() {}
  function m1 (line 97) | fn m1() {}
  function m2 (line 100) | fn m2() {}
  function m3 (line 103) | fn m3() {}
  function n1 (line 108) | fn n1() {}
  function n2 (line 111) | fn n2() {}
  function n3 (line 114) | fn n3() {}
  function main (line 116) | fn main() {  }

FILE: core/codegen/tests/ui-fail/route-type-errors.rs
  type Q (line 3) | struct Q;
  function f0 (line 6) | fn f0(_foo: Q) {}
  function f1 (line 9) | fn f1(_foo: Q) {}
  function f2 (line 12) | fn f2(_foo: Q) {}
  function f3 (line 15) | fn f3(_foo: Q) {}
  function f4 (line 18) | fn f4(_foo: Q) {}
  function f5 (line 21) | fn f5(_a: Q, _foo: Q) {}
  function f6 (line 24) | fn f6(_a: Q, _foo: Q, _good: usize, _bar: Q) {}
  function main (line 26) | fn main() {  }

FILE: core/codegen/tests/ui-fail/route-warnings.rs
  function f0 (line 8) | fn f0() {}
  function f1 (line 11) | fn f1() {}
  function f2 (line 14) | fn f2() {}
  function f3 (line 18) | fn f3() {}
  function g0 (line 23) | fn g0(_foo: rocket::Data<'_>) {}
  function g1 (line 26) | fn g1(_foo: rocket::Data<'_>) {}
  function g2 (line 30) | fn g2(_foo: rocket::Data<'_>) {}
  function main (line 32) | fn main() {

FILE: core/codegen/tests/ui-fail/routes.rs
  function main (line 3) | fn main() {

FILE: core/codegen/tests/ui-fail/typed-uri-bad-type.rs
  type S (line 7) | struct S;
    type Error (line 10) | type Error = ();
    method from_param (line 11) | fn from_param(param: &'a str) -> Result<Self, Self::Error> { Ok(S) }
    method default (line 30) | fn default() -> Option<Self> { None }
    method from_value (line 32) | fn from_value(_: ValueField<'v>) -> Result<Self, Errors<'v>> { Ok(S) }
    method from_data (line 34) | async fn from_data(_: DataField<'v, '_>) -> Result<Self, Errors<'v>> {...
  function simple (line 15) | fn simple(id: usize) {  }
  function not_uri_display (line 18) | fn not_uri_display(id: i32, name: S) {  }
  function not_uri_display_but_unused (line 21) | fn not_uri_display_but_unused(id: i32, name: S) {  }
  function optionals (line 24) | fn optionals(id: Option<i32>, name: Result<String, &str>) {  }
  function simple_q (line 38) | fn simple_q(id: isize) {  }
  function other_q (line 41) | fn other_q(id: usize, rest: S) {  }
  function optionals_q (line 44) | fn optionals_q(id: Option<i32>, name: Result<String, Errors<'_>>) {  }
  function main (line 46) | fn main() {

FILE: core/codegen/tests/ui-fail/typed-uris-bad-params.rs
  function has_one (line 8) | fn has_one(id: i32) {  }
  function has_one_guarded (line 11) | fn has_one_guarded(cookies: &CookieJar<'_>, id: i32) {  }
  function has_two (line 14) | fn has_two(cookies: &CookieJar<'_>, id: i32, name: String) {  }
  function optionals (line 17) | fn optionals(id: Option<i32>, name: Result<String, &str>) {  }
  function ignored (line 20) | fn ignored() {  }
  function main (line 22) | fn main() {

FILE: core/codegen/tests/ui-fail/typed-uris-invalid-syntax.rs
  function index (line 4) | fn index() {  }
  function simple (line 7) | fn simple(_id: i32, _name: String) -> &'static str { "" }
  function main (line 9) | fn main() {

FILE: core/codegen/tests/ui-fail/uri_display.rs
  type Foo1 (line 4) | struct Foo1;
  type Foo2 (line 7) | struct Foo2();
  type Foo3 (line 10) | enum Foo3 { }
  type Foo4 (line 13) | enum Foo4 {
  type Foo5 (line 18) | struct Foo5(String, String);
  type Foo6 (line 21) | struct Foo6 {
  type Foo7 (line 27) | struct Foo7(String, usize);
  type Foo8 (line 30) | struct Foo8;
  type Foo9 (line 33) | enum Foo9 {  }
  type Foo10 (line 36) | struct Foo10 {
  function main (line 40) | fn main() { }

FILE: core/codegen/tests/ui-fail/uri_display_type_errors.rs
  type BadType (line 3) | struct BadType;
  type Bar1 (line 6) | struct Bar1(BadType);
  type Bar2 (line 9) | struct Bar2 {
  type Bar3 (line 14) | struct Bar3 {
  type Bar4 (line 20) | enum Bar4 {
  type Bar5 (line 25) | enum Bar5 {
  type Bar6 (line 32) | enum Bar6 {
  type Baz (line 40) | struct Baz(BadType);
  function main (line 42) | fn main() {  }

FILE: core/codegen/tests/uri_display.rs
  type Foo (line 40) | enum Foo<'r> {
  function uri_display_foo (line 53) | fn uri_display_foo() {
  type Bar (line 74) | struct Bar<'a> {
  function uri_display_bar (line 80) | fn uri_display_bar() {
  type Baz (line 95) | struct Baz<'a> {
  function uri_display_baz (line 102) | fn uri_display_baz() {
  type Bam (line 121) | struct Bam<'a> {
  function uri_display_bam (line 128) | fn uri_display_bam() {
  function uri_display_c_like (line 143) | fn uri_display_c_like() {
  type FooP (line 199) | struct FooP(&'static str);
  type BarP (line 202) | struct BarP<'a>(&'a str);
  type BazP (line 205) | struct BazP<'a, T>(&'a T);
  type BamP (line 208) | struct BamP<T>(T);
  type BopP (line 211) | struct BopP(FooP);
  function uri_display_path (line 214) | fn uri_display_path() {
  function uri_display_serde (line 226) | fn uri_display_serde() {

FILE: core/http/src/ext.rs
  type IntoOwned (line 9) | pub trait IntoOwned {
    method into_owned (line 14) | fn into_owned(self) -> Self::Owned;
    type Owned (line 18) | type Owned = Option<T::Owned>;
    method into_owned (line 21) | fn into_owned(self) -> Self::Owned {
    type Owned (line 27) | type Owned = Vec<T::Owned>;
    method into_owned (line 30) | fn into_owned(self) -> Self::Owned {
    type Owned (line 40) | type Owned = InitCell<T::Owned>;
    method into_owned (line 43) | fn into_owned(self) -> Self::Owned {
    type Owned (line 49) | type Owned = (A::Owned, B::Owned);
    method into_owned (line 52) | fn into_owned(self) -> Self::Owned {
    type Owned (line 58) | type Owned = Cow<'static, B>;
    method into_owned (line 61) | fn into_owned(self) -> <Self as IntoOwned>::Owned {
  type Normalize (line 87) | pub trait Normalize {
    method normalized_str (line 88) | fn normalized_str(&self) -> Cow<'_, str>;
    method normalized_str (line 93) | fn normalized_str(&self) -> Cow<'_, str> {
    method normalized_str (line 98) | fn normalized_str(&self) -> Cow<'_, str> {

FILE: core/http/src/header/accept.rs
  type Accept (line 53) | pub struct Accept(pub(crate) Cow<'static, [QMediaType]>);
    method new (line 102) | pub fn new<T: IntoIterator<Item = M>, M: Into<QMediaType>>(items: T) -...
    method add (line 127) | pub fn add<M: Into<QMediaType>>(&mut self, media_type: M) {
    method preferred (line 151) | pub fn preferred(&self) -> &QMediaType {
    method first (line 194) | pub fn first(&self) -> Option<&QMediaType> {
    method iter (line 221) | pub fn iter(&self) -> impl Iterator<Item=&'_ QMediaType> + '_ {
    method media_types (line 247) | pub fn media_types(&self) -> impl Iterator<Item=&'_ MediaType> + '_ {
    method from (line 256) | fn from(items: T) -> Accept {
    method fmt (line 268) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  type QMediaType (line 57) | pub struct QMediaType(pub MediaType, pub Option<f32>);
    method weight (line 313) | pub fn weight(&self) -> Option<f32> {
    method weight_or (line 332) | pub fn weight_or(&self, default: f32) -> f32 {
    method media_type (line 348) | pub fn media_type(&self) -> &MediaType {
    method from (line 365) | fn from(media_type: MediaType) -> QMediaType {
  method eq (line 262) | fn eq(&self, other: &Accept) -> bool {
  type Err (line 283) | type Err = String;
  method from_str (line 286) | fn from_str(raw: &str) -> Result<Accept, String> {
  function from (line 295) | fn from(val: Accept) -> Self {
  type Item (line 354) | type Item = Self;
  type IntoIter (line 356) | type IntoIter = std::iter::Once<Self>;
  method into_iter (line 358) | fn into_iter(self) -> Self::IntoIter {
  type Target (line 371) | type Target = MediaType;
  method deref (line 374) | fn deref(&self) -> &MediaType {
  function assert_preference (line 384) | fn assert_preference(string: &str, expect: &str) {
  function test_preferred (line 395) | fn test_preferred() {

FILE: core/http/src/header/content_type.rs
  type ContentType (line 43) | pub struct ContentType(pub MediaType);
    method new (line 229) | pub fn new<T, S>(top: T, sub: S) -> ContentType
    method with_params (line 264) | pub fn with_params<K, V, P>(self, parameters: P) -> ContentType
    method media_type (line 284) | pub fn media_type(&self) -> &MediaType {
    method from (line 359) | fn from(media_type: MediaType) -> Self {
    method fmt (line 377) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  method default (line 296) | fn default() -> ContentType {
  type Target (line 302) | type Target = MediaType;
  method deref (line 305) | fn deref(&self) -> &MediaType {
  type Err (line 311) | type Err = String;
  method from_str (line 353) | fn from_str(raw: &str) -> Result<ContentType, String> {
  function from (line 386) | fn from(content_type: ContentType) -> Self {

FILE: core/http/src/header/header.rs
  type Header (line 10) | pub struct Header<'h> {
  function new (line 48) | pub fn new<'a: 'h, 'b: 'h, N, V>(name: N, value: V) -> Header<'h>
  function is_valid_name (line 91) | pub const fn is_valid_name(name: &str) -> bool {
  function is_valid_value (line 155) | pub const fn is_valid_value(val: &str, allow_empty: bool) -> bool {
  function name (line 206) | pub fn name(&self) -> &UncasedStr {
  function value (line 224) | pub fn value(&self) -> &str {
  function fmt (line 231) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  type HeaderMap (line 245) | pub struct HeaderMap<'h> {
  function new (line 261) | pub fn new() -> HeaderMap<'h> {
  function contains (line 280) | pub fn contains<N: AsRef<str>>(&self, name: N) -> bool {
  function len (line 305) | pub fn len(&self) -> usize {
  function is_empty (line 322) | pub fn is_empty(&self) -> bool {
  function get (line 347) | pub fn get(&self, name: &str) -> impl Iterator<Item=&str> {
  function get_one (line 388) | pub fn get_one<'a>(&'a self, name: &str) -> Option<&'a str> {
  function replace (line 447) | pub fn replace<'p: 'h, H: Into<Header<'p>>>(&mut self, header: H) -> bool {
  function replace_raw (line 471) | pub fn replace_raw<'a: 'h, 'b: 'h, N, V>(&mut self, name: N, value: V) -...
  function replace_all (line 499) | pub fn replace_all<'n, 'v: 'h, H>(&mut self, name: H, values: Vec<Cow<'v...
  function add (line 521) | pub fn add<'p: 'h, H: Into<Header<'p>>>(&mut self, header: H) {
  function add_raw (line 545) | pub fn add_raw<'a: 'h, 'b: 'h, N, V>(&mut self, name: N, value: V)
  function add_all (line 577) | pub fn add_all<'n, H>(&mut self, name: H, values: &mut Vec<Cow<'h, str>>)
  function remove (line 603) | pub fn remove(&mut self, name: &str) {
  function remove_all (line 644) | pub fn remove_all(&mut self) -> Vec<Header<'h>> {
  function iter (line 690) | pub fn iter(&self) -> impl Iterator<Item=Header<'_>> {
  function into_iter_raw (line 704) | pub fn into_iter_raw(self) -> impl Iterator<Item=(Uncased<'h>, Vec<Cow<'...
  type Item (line 752) | type Item = Header<'h>;
  type IntoIter (line 754) | type IntoIter = IntoIter<'h>;
  method into_iter (line 756) | fn into_iter(self) -> Self::IntoIter {
  type IntoIter (line 767) | pub struct IntoIter<'h> {
  type Item (line 773) | type Item = Header<'h>;
  method next (line 775) | fn next(&mut self) -> Option<Self::Item> {
  function from (line 790) | fn from(cookie: cookie::Cookie<'_>) -> Header<'static> {
  function from (line 796) | fn from(cookie: &cookie::Cookie<'_>) -> Header<'static> {
  function case_insensitive_add_get (line 806) | fn case_insensitive_add_get() {
  function case_insensitive_multiadd (line 818) | fn case_insensitive_multiadd() {

FILE: core/http/src/header/media_type.rs
  type MediaType (line 50) | pub struct MediaType {
    method new (line 288) | pub fn new<T, S>(top: T, sub: S) -> MediaType
    method with_params (line 324) | pub fn with_params<K, V, P>(mut self, ps: P) -> MediaType
    method const_new (line 353) | pub const fn const_new(
    method new_known (line 367) | pub(crate) const fn new_known(
    method known_source (line 381) | pub(crate) fn known_source(&self) -> Option<&'static str> {
    method top (line 408) | pub fn top(&self) -> &UncasedStr {
    method sub (line 427) | pub fn sub(&self) -> &UncasedStr {
    method specificity (line 456) | pub fn specificity(&self) -> u8 {
    method exact_eq (line 492) | pub fn exact_eq(&self, other: &MediaType) -> bool {
    method params (line 524) | pub fn params(&self) -> impl Iterator<Item=(&'_ UncasedStr, &'_ str)> ...
    method param (line 540) | pub fn param<'a>(&'a self, name: &str) -> Option<&'a str> {
    method fmt (line 581) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  type MediaParams (line 63) | pub(crate) enum MediaParams {
    method extend (line 612) | fn extend<T>(&mut self, iter: T)
  type Source (line 69) | pub(crate) enum Source {
    method from (line 76) | fn from(custom: Cow<'static, str>) -> Source {
    method as_str (line 624) | fn as_str(&self) -> Option<&str> {
  type Err (line 554) | type Err = String;
  method from_str (line 557) | fn from_str(raw: &str) -> Result<MediaType, String> {
  method eq (line 564) | fn eq(&self, other: &MediaType) -> bool {
  method hash (line 573) | fn hash<H: Hasher>(&self, state: &mut H) {
  type Item (line 596) | type Item = Self;
  type IntoIter (line 598) | type IntoIter = std::iter::Once<Self>;
  method into_iter (line 600) | fn into_iter(self) -> Self::IntoIter {
  method default (line 606) | fn default() -> Self {

FILE: core/http/src/header/proxy_proto.rs
  type ProxyProto (line 23) | pub enum ProxyProto<'a> {
  function is_https (line 43) | pub fn is_https(&self) -> bool {
  function from (line 49) | fn from(value: &'a str) -> ProxyProto<'a> {
  function fmt (line 59) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {

FILE: core/http/src/lib.rs
  type HttpVersion (line 46) | pub enum HttpVersion {

FILE: core/http/src/method.rs
  method supports_payload (line 308) | pub const fn supports_payload(self) -> bool {
  type ParseMethodError (line 319) | pub struct ParseMethodError;
    method from (line 324) | fn from(infallible: std::convert::Infallible) -> Self {
    method fmt (line 330) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  type Err (line 336) | type Err = ParseMethodError;
  method from_str (line 339) | fn from_str(s: &str) -> Result<Self, Self::Err> {
  type Error (line 345) | type Error = ParseMethodError;
  method try_from (line 347) | fn try_from(s: &str) -> Result<Self, Self::Error> {
  method as_ref (line 353) | fn as_ref(&self) -> &str {
  method fmt (line 359) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  method eq (line 365) | fn eq(&self, other: &&Method) -> bool {
  function eq (line 371) | fn eq(&self, other: &Method) -> bool {
  method serialize (line 384) | fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Er...
  type DeVisitor (line 389) | struct DeVisitor;
    type Value (line 392) | type Value = Method;
    method expecting (line 394) | fn expecting(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
    method visit_str (line 398) | fn visit_str<E: Error>(self, v: &str) -> Result<Self::Value, E> {
  method deserialize (line 404) | fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D:...

FILE: core/http/src/parse/accept.rs
  type Input (line 8) | type Input<'a> = pear::input::Pear<pear::input::Cursor<&'a str>>;
  type Result (line 9) | type Result<'a, T> = pear::input::Result<T, Input<'a>>;
  function weighted_media_type (line 12) | fn weighted_media_type<'a>(input: &mut Input<'a>) -> Result<'a, QMediaTy...
  function accept (line 33) | fn accept<'a>(input: &mut Input<'a>) -> Result<'a, Accept> {
  function parse_accept (line 38) | pub fn parse_accept(input: &str) -> Result<'_, Accept> {
  function check_does_parse (line 67) | fn check_does_parse() {
  function check_parse_eq (line 82) | fn check_parse_eq() {

FILE: core/http/src/parse/checkers.rs
  function is_whitespace (line 2) | pub fn is_whitespace(&byte: &char) -> bool {
  function is_valid_token (line 7) | pub fn is_valid_token(&c: &char) -> bool {

FILE: core/http/src/parse/indexed.rs
  type IndexedStr (line 13) | pub type IndexedStr<'a> = Indexed<'a, str>;
  type IndexedBytes (line 14) | pub type IndexedBytes<'a> = Indexed<'a, [u8]>;
  type AsPtr (line 16) | pub trait AsPtr {
    method as_ptr (line 17) | fn as_ptr(&self) -> *const u8;
    method as_ptr (line 22) | fn as_ptr(&self) -> *const u8 {
    method as_ptr (line 29) | fn as_ptr(&self) -> *const u8 {
  type Indexed (line 36) | pub enum Indexed<'a, T: ?Sized + ToOwned> {
  function from (line 44) | fn from(e: Extent<A>) -> Self {
  function from (line 51) | fn from(value: Cow<'a, T>) -> Indexed<'a, T> {
  function indices (line 59) | pub fn indices(self) -> (usize, usize) {
  function coerce (line 68) | pub fn coerce<U: ?Sized + ToOwned>(self) -> Indexed<'a, U> {
  function coerce_lifetime (line 77) | pub fn coerce_lifetime<'b>(self) -> Indexed<'b, T> {
  type Owned (line 86) | type Owned = Indexed<'static, T>;
  method into_owned (line 88) | fn into_owned(self) -> Indexed<'static, T> {
  type Output (line 99) | type Output = Indexed<'a, T>;
  method add (line 102) | fn add(self, other: Indexed<'a, T>) -> Indexed<'a, T> {
  function checked_from (line 118) | pub fn checked_from(needle: &T, haystack: &T) -> Option<Indexed<'a, T>> {
  function unchecked_from (line 143) | pub unsafe fn unchecked_from(needle: &T, haystack: &T) -> Indexed<'a, T> {
  function is_indexed (line 154) | pub fn is_indexed(&self) -> bool {
  function is_empty (line 163) | pub fn is_empty(&self) -> bool {
  function into_concrete (line 172) | pub fn into_concrete(self, source: &Option<Cow<'_, T>>) -> Cow<'a, T> {
  function from_cow_source (line 190) | pub fn from_cow_source<'s>(&'s self, source: &'s Option<Cow<'_, T>>) -> ...
  function from_source (line 208) | pub fn from_source<'s>(&'s self, source: Option<&'s T>) -> &'s T {
  method clone (line 221) | fn clone(&self) -> Self {
  method fmt (line 232) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  method len (line 242) | fn len(&self) -> usize {

FILE: core/http/src/parse/media_type.rs
  type Input (line 11) | type Input<'a> = pear::input::Pear<pear::input::Cursor<&'a str>>;
  type Result (line 12) | type Result<'a, T> = pear::input::Result<T, Input<'a>>;
  function quoted_string (line 15) | fn quoted_string<'a>(input: &mut Input<'a>) -> Result<'a, Extent<&'a str...
  function media_param (line 30) | fn media_param<'a>(input: &mut Input<'a>) -> Result<'a, (Extent<&'a str>...
  function media_type (line 41) | pub fn media_type<'a>(input: &mut Input<'a>) -> Result<'a, MediaType> {
  function parse_media_type (line 61) | pub fn parse_media_type(input: &str) -> Result<'_, MediaType> {
  function check_does_parse (line 111) | fn check_does_parse() {
  function check_parse_eq (line 118) | fn check_parse_eq() {
  function check_param_eq (line 137) | fn check_param_eq() {
  function check_params_do_parse (line 206) | fn check_params_do_parse() {
  function test_bad_parses (line 216) | fn test_bad_parses() {

FILE: core/http/src/parse/uri/error.rs
  type Error (line 16) | pub struct Error<'a> {
  function from (line 23) | fn from(inner: ParseError<RawInput<'a>>) -> Self {
  function index (line 42) | pub fn index(&self) -> usize {
  function fmt (line 48) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  type Owned (line 54) | type Owned = Error<'static>;
  method into_owned (line 56) | fn into_owned(self) -> Error<'static> {
  function check_display (line 78) | fn check_display() {

FILE: core/http/src/parse/uri/mod.rs
  type RawInput (line 13) | type RawInput<'a> = pear::input::Pear<pear::input::Cursor<&'a [u8]>>;
  function from_str (line 16) | pub fn from_str(s: &str) -> Result<Uri<'_>, Error<'_>> {
  function origin_from_str (line 21) | pub fn origin_from_str(s: &str) -> Result<Origin<'_>, Error<'_>> {
  function authority_from_str (line 26) | pub fn authority_from_str(s: &str) -> Result<Authority<'_>, Error<'_>> {
  function authority_from_bytes (line 31) | pub fn authority_from_bytes(s: &[u8]) -> Result<Authority<'_>, Error<'_>> {
  function scheme_from_str (line 36) | pub fn scheme_from_str(s: &str) -> Result<&str, Error<'_>> {
  function absolute_from_str (line 42) | pub fn absolute_from_str(s: &str) -> Result<Absolute<'_>, Error<'_>> {
  function asterisk_from_str (line 47) | pub fn asterisk_from_str(s: &str) -> Result<Asterisk, Error<'_>> {
  function reference_from_str (line 52) | pub fn reference_from_str(s: &str) -> Result<Reference<'_>, Error<'_>> {

FILE: core/http/src/parse/uri/parser.rs
  type Result (line 10) | type Result<'a, T> = pear::input::Result<T, RawInput<'a>>;
  function complete (line 22) | pub fn complete<I, P, O>(input: &mut Pear<I>, p: P) -> input::Result<O, I>
  function uri (line 34) | pub fn uri<'a>(input: &mut RawInput<'a>) -> Result<'a, Uri<'a>> {
  function asterisk (line 47) | pub fn asterisk<'a>(input: &mut RawInput<'a>) -> Result<'a, Asterisk> {
  function origin (line 53) | pub fn origin<'a>(input: &mut RawInput<'a>) -> Result<'a, Origin<'a>> {
  function authority (line 59) | pub fn authority<'a>(input: &mut RawInput<'a>) -> Result<'a, Authority<'...
  function scheme (line 84) | pub fn scheme<'a>(input: &mut RawInput<'a>) -> Result<'a, Extent<&'a [u8...
  function absolute (line 94) | pub fn absolute<'a>(input: &mut RawInput<'a>) -> Result<'a, Absolute<'a>> {
  function reference (line 101) | pub fn reference<'a>(
  function hier_part (line 131) | pub fn hier_part<'a>(
  function host (line 145) | fn host<'a>(
  function port (line 155) | fn port<'a>(
  function maybe_port (line 169) | fn maybe_port<'a>(input: &mut RawInput<'a>, bytes: &[u8]) -> Result<'a, ...
  function path (line 191) | fn path<'a>(input: &mut RawInput<'a>) -> Result<'a, Extent<&'a [u8]>> {
  function query (line 196) | fn query<'a>(input: &mut RawInput<'a>) -> Result<'a, Option<Extent<&'a [...
  function fragment (line 201) | fn fragment<'a>(input: &mut RawInput<'a>) -> Result<'a, Option<Extent<&'...

FILE: core/http/src/parse/uri/tables.rs
  function char_table (line 3) | const fn char_table(sets: &[&[u8]]) -> [u8; 256] {
  constant ALPHA (line 23) | const ALPHA: &[u8] = &[
  constant DIGIT (line 31) | const DIGIT: &[u8] = &[
  constant PCT_ENCODED (line 35) | const PCT_ENCODED: &[u8] = &[
  constant SUB_DELIMS (line 40) | const SUB_DELIMS: &[u8] = &[
  constant SCHEME_CHAR (line 44) | const SCHEME_CHAR: [u8; 256] = char_table(&[
  constant UNRESERVED (line 48) | const UNRESERVED: [u8; 256] = char_table(&[
  constant REG_NAME_CHARS (line 52) | const REG_NAME_CHARS: [u8; 256] = char_table(&[
  constant USER_INFO_CHARS (line 56) | const USER_INFO_CHARS: [u8; 256] = char_table(&[
  constant PATH_CHARS (line 60) | pub const PATH_CHARS: [u8; 256] = char_table(&[
  constant QUERY_CHARS (line 68) | const QUERY_CHARS: [u8; 256] = char_table(&[
  function is_pchar (line 77) | pub const fn is_pchar(&c: &u8) -> bool { PATH_CHARS[c as usize] != 0 }
  function is_host_char (line 80) | pub const fn is_host_char(c: &u8) -> bool { is_pchar(c) && *c != b'[' &&...
  function is_scheme_char (line 83) | pub const fn is_scheme_char(&c: &u8) -> bool { SCHEME_CHAR[c as usize] !...
  function is_user_info_char (line 86) | pub const fn is_user_info_char(&c: &u8) -> bool { USER_INFO_CHARS[c as u...
  function is_qchar (line 89) | pub const fn is_qchar(&c: &u8) -> bool { QUERY_CHARS[c as usize] != 0 }
  function is_reg_name_char (line 92) | pub const fn is_reg_name_char(&c: &u8) -> bool { REG_NAME_CHARS[c as usi...
  function test_char_table (line 96) | fn test_char_table(table: &[u8]) {
  function check_tables (line 105) | fn check_tables() {

FILE: core/http/src/parse/uri/tests.rs
  function test_assert_parse_eq (line 74) | fn test_assert_parse_eq() {
  function test_assert_parse_eq_consecutive (line 80) | fn test_assert_parse_eq_consecutive() {
  function test_assert_no_parse (line 89) | fn test_assert_no_parse() {
  function bad_parses (line 94) | fn bad_parses() {
  function test_parse_issue_924_samples (line 111) | fn test_parse_issue_924_samples() {
  function single_byte (line 130) | fn single_byte() {
  function origin (line 149) | fn origin() {
  function authority (line 169) | fn authority() {
  function absolute (line 190) | fn absolute() {
  function reference (line 235) | fn reference() {
  function display (line 268) | fn display() {

FILE: core/http/src/raw_str.rs
  type RawStr (line 51) | pub struct RawStr(str);
    method new (line 97) | pub fn new<S: AsRef<str> + ?Sized>(string: &S) -> &RawStr {
    method from_cow_str (line 116) | pub fn from_cow_str(cow: Cow<'_, str>) -> Cow<'_, RawStr> {
    method into_cow_str (line 138) | pub fn into_cow_str(cow: Cow<'_, RawStr>) -> Cow<'_, str> {
    method _percent_decode (line 146) | fn _percent_decode(&self) -> percent_encoding::PercentDecode<'_> {
    method percent_decode (line 179) | pub fn percent_decode(&self) -> Result<Cow<'_, str>, Utf8Error> {
    method percent_decode_lossy (line 215) | pub fn percent_decode_lossy(&self) -> Cow<'_, str> {
    method _replace_plus (line 225) | fn _replace_plus(&self) -> Cow<'_, str> {
    method percent_encode (line 266) | pub fn percent_encode(&self) -> Cow<'_, RawStr> {
    method percent_encode_bytes (line 284) | pub fn percent_encode_bytes(bytes: &[u8]) -> Cow<'_, RawStr> {
    method url_decode (line 306) | pub fn url_decode(&self) -> Result<Cow<'_, str>, Utf8Error> {
    method url_decode_lossy (line 343) | pub fn url_decode_lossy(&self) -> Cow<'_, str> {
    method html_escape (line 395) | pub fn html_escape(&self) -> Cow<'_, str> {
    method len (line 475) | pub const fn len(&self) -> usize {
    method is_empty (line 494) | pub const fn is_empty(&self) -> bool {
    method as_str (line 513) | pub const fn as_str(&self) -> &str {
    method as_bytes (line 529) | pub const fn as_bytes(&self) -> &[u8] {
    method as_ptr (line 555) | pub const fn as_ptr(&self) -> *const u8 {
    method as_uncased_str (line 574) | pub fn as_uncased_str(&self) -> &UncasedStr {
    method contains (line 602) | pub fn contains<'a, P: Pattern<'a>>(&'a self, pat: P) -> bool {
    method starts_with (line 629) | pub fn starts_with<'a, P: Pattern<'a>>(&'a self, pat: P) -> bool {
    method ends_with (line 656) | pub fn ends_with<'a, P>(&'a self, pat: P) -> bool
    method find (line 685) | pub fn find<'a, P: Pattern<'a>>(&'a self, pat: P) -> Option<usize> {
    method split (line 713) | pub fn split<'a, P>(&'a self, pat: P) -> impl DoubleEndedIterator<Item...
    method split_at_byte (line 768) | pub fn split_at_byte(&self, b: u8) -> (&RawStr, &RawStr) {
    method strip_prefix (line 809) | pub fn strip_prefix<'a, P: Pattern<'a>>(&'a self, prefix: P) -> Option...
    method strip_suffix (line 835) | pub fn strip_suffix<'a, P>(&'a self, suffix: P) -> Option<&'a RawStr>
    method trim (line 859) | pub fn trim(&self) -> &RawStr {
    method parse (line 889) | pub fn parse<F: std::str::FromStr>(&self) -> Result<F, F::Err> {
    method fmt (line 920) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
    method as_ref (line 998) | fn as_ref(&self) -> &str {
    method as_ref (line 1005) | fn as_ref(&self) -> &std::ffi::OsStr {
    method as_ref (line 1019) | fn as_ref(&self) -> &RawStr {
    method as_ref (line 1026) | fn as_ref(&self) -> &[u8] {
    type Output (line 1032) | type Output = RawStr;
    method index (line 1035) | fn index(&self, index: I) -> &Self::Output {
    method borrow (line 1042) | fn borrow(&self) -> &str {
    method fmt (line 1056) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  type Owned (line 54) | type Owned = RawStrBuf;
  method to_owned (line 56) | fn to_owned(&self) -> Self::Owned {
  type RawStrBuf (line 64) | pub struct RawStrBuf(String);
    method into_string (line 78) | pub fn into_string(self) -> String {
    method as_ref (line 1063) | fn as_ref(&self) -> &RawStr {
    method borrow (line 1070) | fn borrow(&self) -> &RawStr {
    type Target (line 1076) | type Target = RawStr;
    method deref (line 1079) | fn deref(&self) -> &Self::Target {
    method fmt (line 1086) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
    method fmt (line 1093) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
    method from (line 1100) | fn from(string: String) -> Self {
    method from (line 1107) | fn from(string: &str) -> Self {
    method from (line 1114) | fn from(raw: &RawStr) -> Self {
  method serialize (line 901) | fn serialize<S>(&self, ser: S) -> Result<S::Ok, S::Error>
  function deserialize (line 909) | fn deserialize<D>(de: D) -> Result<Self, D::Error>
  function from (line 927) | fn from(string: &'a str) -> &'a RawStr {
  function from (line 933) | fn from(raw: &'a RawStr) -> Self {
  function from (line 939) | fn from(raw: RawStrBuf) -> Self {
  function as_ref (line 1012) | fn as_ref(&self) -> &RawStr {
  function borrow (line 1049) | fn borrow(&self) -> &RawStr {
  function can_compare (line 1124) | fn can_compare() {

FILE: core/http/src/status.rs
  type StatusClass (line 5) | pub enum StatusClass {
  type Status (line 116) | pub struct Status {
    method fmt (line 352) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
    method deserialize (line 397) | fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, ...
  method default (line 122) | fn default() -> Self {
  method serialize (line 365) | fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Er...
  type DeVisitor (line 370) | struct DeVisitor;
    type Value (line 373) | type Value = Status;
    method expecting (line 375) | fn expecting(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
    method visit_i64 (line 379) | fn visit_i64<E: Error>(self, v: i64) -> Result<Self::Value, E> {
    method visit_u64 (line 387) | fn visit_u64<E: Error>(self, v: u64) -> Result<Self::Value, E> {

FILE: core/http/src/uri/absolute.rs
  type Absolute (line 94) | pub struct Absolute<'a> {
  function parse (line 126) | pub fn parse(string: &'a str) -> Result<Absolute<'a>, Error<'a>> {
  function parse_owned (line 150) | pub fn parse_owned(string: String) -> Result<Absolute<'static>, Error<'s...
  function scheme (line 175) | pub fn scheme(&self) -> &str {
  function authority (line 195) | pub fn authority(&self) -> Option<&Authority<'a>> {
  function path (line 212) | pub fn path(&self) -> Path<'_> {
  function query (line 229) | pub fn query(&self) -> Option<Query<'_>> {
  function clear_query (line 246) | pub fn clear_query(&mut self) {
  function is_normalized (line 274) | pub fn is_normalized(&self) -> bool {
  function normalize (line 307) | pub fn normalize(&mut self) {
  function into_normalized (line 341) | pub fn into_normalized(mut self) -> Self {
  function set_authority (line 364) | pub fn set_authority(&mut self, authority: Authority<'a>) {
  function with_authority (line 386) | pub fn with_authority(mut self, authority: Authority<'a>) -> Self {
  function raw (line 400) | pub(crate) unsafe fn raw(
  function new (line 418) | pub fn new(
  function const_new (line 430) | pub const fn const_new(
  function set_path (line 455) | pub(crate) fn set_path<P>(&mut self, path: P)
  function set_query (line 462) | pub(crate) fn set_query<Q: Into<Option<Cow<'a, str>>>>(&mut self, query:...
  function fmt (line 472) | fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {

FILE: core/http/src/uri/asterisk.rs
  type Asterisk (line 24) | pub struct Asterisk;
    method parse (line 43) | pub fn parse(string: &str) -> Result<Asterisk, Error<'_>> {
    method parse_owned (line 59) | pub fn parse_owned(string: String) -> Result<Asterisk, Error<'static>> {
    method fmt (line 65) | fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {

FILE: core/http/src/uri/authority.rs
  type Authority (line 47) | pub struct Authority<'a> {
  function raw (line 57) | pub(crate) unsafe fn raw(
  function new (line 73) | pub fn new(
  function const_new (line 83) | pub const fn const_new(user_info: Option<&'a str>, host: &'a str, port: ...
  function parse (line 119) | pub fn parse(string: &'a str) -> Result<Authority<'a>, Error<'a>> {
  function parse_owned (line 142) | pub fn parse_owned(string: String) -> Result<Authority<'static>, Error<'...
  function user_info (line 164) | pub fn user_info(&self) -> Option<&str> {
  function host (line 184) | pub fn host(&self) -> &str {
  function port (line 206) | pub fn port(&self) -> Option<u16> {
  function set_port (line 228) | pub fn set_port<T: Into<Option<u16>>>(&mut self, port: T) {
  method fmt (line 238) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {

FILE: core/http/src/uri/error.rs
  type TryFromUriError (line 9) | pub struct TryFromUriError(pub(crate) ());
    method fmt (line 12) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  type PathError (line 23) | pub enum PathError {
    method fmt (line 33) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {

FILE: core/http/src/uri/fmt/encoding.rs
  type UNSAFE_ENCODE_SET (line 12) | pub struct UNSAFE_ENCODE_SET<P: Part>(PhantomData<P>);
  type EncodeSet (line 14) | pub trait EncodeSet {
    constant SET (line 15) | const SET: AsciiSet;
    constant SET (line 42) | const SET: AsciiSet = PATH_SET
    constant SET (line 47) | const SET: AsciiSet = PATH_SET
    constant SET (line 58) | const SET: AsciiSet = <UNSAFE_ENCODE_SET<Path>>::SET
    constant SET (line 63) | const SET: AsciiSet = <UNSAFE_ENCODE_SET<Query>>::SET
    constant SET (line 75) | const SET: AsciiSet = <ENCODE_SET<Path>>::SET
  function set_from_table (line 18) | const fn set_from_table(table: &'static [u8; 256]) -> AsciiSet {
  constant PATH_SET (line 34) | const PATH_SET: AsciiSet = set_from_table(&PATH_CHARS);
  method default (line 38) | fn default() -> Self { UNSAFE_ENCODE_SET(PhantomData) }
  type ENCODE_SET (line 55) | pub struct ENCODE_SET<P: Part>(PhantomData<P>);
  type DEFAULT_ENCODE_SET (line 70) | pub struct DEFAULT_ENCODE_SET;
  function percent_encode (line 84) | pub fn percent_encode<S: EncodeSet + Default>(string: &RawStr) -> Cow<'_...
  function percent_encode_bytes (line 88) | pub fn percent_encode_bytes<S: EncodeSet + Default>(bytes: &[u8]) -> Cow...

FILE: core/http/src/uri/fmt/formatter.rs
  type Formatter (line 143) | pub struct Formatter<'i, P: Part> {
  function new (line 153) | pub(crate) fn new(inner: &'i mut (dyn Write + 'i)) -> Self {
  function refreshed (line 164) | fn refreshed<F: FnOnce(&mut Self) -> fmt::Result>(&mut self, f: F) -> fm...
  function write_raw (line 202) | pub fn write_raw<S: AsRef<str>>(&mut self, string: S) -> fmt::Result {
  function write_value (line 259) | pub fn write_value<T: UriDisplay<P>>(&mut self, value: T) -> fmt::Result {
  function refresh (line 314) | pub fn refresh(&mut self) {
  function with_prefix (line 320) | fn with_prefix<F>(&mut self, prefix: &str, f: F) -> fmt::Result
  function write_named_value (line 392) | pub fn write_named_value<T: UriDisplay<Query>>(&mut self, name: &str, va...
  function write_str (line 398) | fn write_str(&mut self, s: &str) -> fmt::Result {
  type UriArgumentsKind (line 405) | pub enum UriArgumentsKind<A> {
  type UriQueryArgument (line 412) | pub enum UriQueryArgument<'a> {
  type Void (line 420) | pub struct Void;
  type ValidRoutePrefix (line 424) | pub trait ValidRoutePrefix {
    method append (line 427) | fn append(self, path: Cow<'static, str>, query: Option<Cow<'static, st...
    type Output (line 431) | type Output = Self;
    method append (line 433) | fn append(self, path: Cow<'static, str>, query: Option<Cow<'static, st...
    type Output (line 460) | type Output = Self;
    method append (line 462) | fn append(self, path: Cow<'static, str>, query: Option<Cow<'static, st...
  type ValidRouteSuffix (line 490) | pub trait ValidRouteSuffix<T> {
    method prepend (line 493) | fn prepend(self, prefix: T) -> Self::Output;
  type Output (line 497) | type Output = Self;
  function prepend (line 499) | fn prepend(self, prefix: Origin<'a>) -> Self::Output {
  type Output (line 505) | type Output = Self;
  function prepend (line 507) | fn prepend(self, prefix: Absolute<'a>) -> Self::Output {
  type Output (line 513) | type Output = Origin<'a>;
  function prepend (line 515) | fn prepend(self, mut prefix: Origin<'a>) -> Self::Output {
  type Output (line 527) | type Output = Self;
  function prepend (line 529) | fn prepend(self, mut prefix: Absolute<'a>) -> Self::Output {
  type RouteUriBuilder (line 542) | pub struct RouteUriBuilder {
    method new (line 559) | pub fn new(
    method with_prefix (line 599) | pub fn with_prefix<P: ValidRoutePrefix>(self, p: P) -> PrefixedRouteUr...
    method with_suffix (line 603) | pub fn with_suffix<S>(self, suffix: S) -> SuffixedRouteUri<S::Output>
    method render (line 609) | pub fn render(self) -> Origin<'static> {
  type PrefixedRouteUri (line 549) | pub struct PrefixedRouteUri<T>(T);
  type SuffixedRouteUri (line 553) | pub struct SuffixedRouteUri<T>(T);
  function with_suffix (line 616) | pub fn with_suffix<S: ValidRouteSuffix<T>>(self, suffix: S) -> SuffixedR...
  function render (line 620) | pub fn render(self) -> T {
  function render (line 627) | pub fn render(self) -> T {
  type MyValue (line 637) | struct MyValue;
    method fmt (line 640) | fn fmt(&self, _f: &mut Formatter<'_, Query>) -> std::fmt::Result {
  type MyDisplay (line 645) | struct MyDisplay;
    method fmt (line 648) | fn fmt(&self, formatter: &mut Formatter<'_, Query>) -> std::fmt::Result {
  function check_consistency (line 677) | fn check_consistency() {

FILE: core/http/src/uri/fmt/from_uri_param.rs
  type FromUriParam (line 188) | pub trait FromUriParam<P: Part, T> {
    method from_uri_param (line 195) | fn from_uri_param(param: T) -> Self::Target;
  type Target (line 351) | type Target = &'a Path;
  method from_uri_param (line 354) | fn from_uri_param(param: &'a str) -> &'a Path {
  type Target (line 361) | type Target = &'b Path;
  method from_uri_param (line 364) | fn from_uri_param(param: &'a &'b str) -> &'b Path {
  type Target (line 371) | type Target = T::Target;
  function from_uri_param (line 374) | fn from_uri_param(param: A) -> Self::Target {
  type Target (line 383) | type Target = T::Target;
  function from_uri_param (line 386) | fn from_uri_param(param: A) -> Self::Target {
  type Target (line 394) | type Target = Either<T::Target, U::Target>;
  function from_uri_param (line 396) | fn from_uri_param(param: Either<A, B>) -> Self::Target {
  type Target (line 405) | type Target = Option<T::Target>;
  function from_uri_param (line 408) | fn from_uri_param(param: Option<A>) -> Self::Target {
  type Target (line 414) | type Target = Option<T::Target>;
  function from_uri_param (line 417) | fn from_uri_param(param: Option<A>) -> Self::Target {
  type Target (line 423) | type Target = Result<T::Target, E>;
  function from_uri_param (line 426) | fn from_uri_param(param: Result<A, E>) -> Self::Target {
  type Target (line 432) | type Target = Result<T::Target, E>;
  function from_uri_param (line 435) | fn from_uri_param(param: Result<A, E>) -> Self::Target {

FILE: core/http/src/uri/fmt/part.rs
  type Part (line 25) | pub trait Part: private::Sealed {
    constant KIND (line 28) | const KIND: Kind;
    constant DELIMITER (line 33) | const DELIMITER: char;
    constant KIND (line 75) | const KIND: Kind = Kind::Path;
    constant DELIMITER (line 76) | const DELIMITER: char = '/';
    type Raw (line 77) | type Raw = IndexedStr<'static>;
    constant KIND (line 81) | const KIND: Kind = Kind::Query;
    constant DELIMITER (line 82) | const DELIMITER: char = '&';
    type Raw (line 83) | type Raw = (IndexedStr<'static>, IndexedStr<'static>);
  type Sealed (line 41) | pub trait Sealed {}
  type Kind (line 49) | pub enum Kind { Path, Query }
  type Path (line 61) | pub enum Path {  }
  type Query (line 72) | pub enum Query {  }

FILE: core/http/src/uri/fmt/uri_display.rs
  type UriDisplay (line 291) | pub trait UriDisplay<P: Part> {
    method fmt (line 293) | fn fmt(&self, f: &mut Formatter<'_, P>) -> fmt::Result;
  function fmt (line 298) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  function fmt (line 308) | fn fmt(&self, f: &mut Formatter<'_, P>) -> fmt::Result {
  function fmt (line 315) | fn fmt(&self, f: &mut Formatter<'_, Path>) -> fmt::Result {
  method fmt (line 396) | fn fmt(&self, f: &mut Formatter<'_, P>) -> fmt::Result {
  function fmt (line 404) | fn fmt(&self, f: &mut Formatter<'_, P>) -> fmt::Result {
  function fmt (line 412) | fn fmt(&self, f: &mut Formatter<'_, Path>) -> fmt::Result {
  function fmt (line 420) | fn fmt(&self, f: &mut Formatter<'_, P>) -> fmt::Result {
  function fmt (line 428) | fn fmt(&self, f: &mut Formatter<'_, P>) -> fmt::Result {
  function fmt (line 439) | fn fmt(&self, f: &mut Formatter<'_, P>) -> fmt::Result {
  function fmt (line 447) | fn fmt(&self, f: &mut Formatter<'_, Query>) -> fmt::Result {
  function fmt (line 458) | fn fmt(&self, f: &mut Formatter<'_, Query>) -> fmt::Result {
  function fmt (line 467) | fn fmt(&self, f: &mut Formatter<'_, Query>) -> fmt::Result {
  function fmt (line 473) | fn fmt(&self, f: &mut Formatter<'_, Query>) -> fmt::Result {
  function fmt (line 479) | fn fmt(&self, f: &mut Formatter<'_, Query>) -> fmt::Result {
  function fmt (line 485) | fn fmt(&self, f: &mut Formatter<'_, Query>) -> fmt::Result {
  function fmt (line 503) | fn fmt(&self, f: &mut Formatter<'_, Query>) -> fmt::Result {
  type Ignorable (line 558) | pub trait Ignorable<P: Part> { }
  function assert_ignorable (line 564) | pub fn assert_ignorable<P: Part, T: Ignorable<P>>() {  }
  function uri_display_encoding (line 587) | fn uri_display_encoding() {
  function paths (line 630) | fn paths() {
  type Wrapper (line 643) | struct Wrapper<T>(T);
  type Target (line 646) | type Target = T::Target;
  function from_uri_param (line 649) | fn from_uri_param(param: A) -> Self::Target {
  type Target (line 655) | type Target = usize;
  function from_uri_param (line 658) | fn from_uri_param(param: usize) -> Self::Target {
  function uri_display_encoding_wrapped (line 664) | fn uri_display_encoding_wrapped() {
  function check_ignorables (line 677) | fn check_ignorables() {

FILE: core/http/src/uri/host.rs
  type Host (line 91) | pub struct Host<'a>(Authority<'a>);
  function new (line 110) | pub const fn new(authority: Authority<'a>) -> Self {
  function parse (line 143) | pub fn parse(string: &'a str) -> Result<Host<'a>, Error<'a>> {
  function parse_bytes (line 149) | pub fn parse_bytes(bytes: &'a [u8]) -> Result<Host<'a>, Error<'a>> {
  function parse_owned (line 172) | pub fn parse_owned(string: String) -> Result<Host<'static>, Error<'stati...
  function domain (line 194) | pub fn domain(&self) -> &UncasedStr {
  function port (line 218) | pub fn port(&self) -> Option<u16> {
  function to_authority (line 252) | pub fn to_authority<'h, W>(&self, whitelist: W) -> Option<Authority<'a>>
  function to_absolute (line 290) | pub fn to_absolute<'h, W>(&self, scheme: &'a str, whitelist: W) -> Optio...
  type Owned (line 304) | type Owned = Host<'static>;
  function into_owned (line 306) | fn into_owned(self) -> Host<'static> {
  function from (line 312) | fn from(auth: Authority<'a>) -> Self {
  method fmt (line 318) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {

FILE: core/http/src/uri/origin.rs
  type Origin (line 115) | pub struct Origin<'a> {
  function root (line 124) | pub fn root() -> &'static Origin<'static> {
  function raw (line 131) | pub(crate) unsafe fn raw(
  function new (line 147) | pub fn new<P, Q>(path: P, query: Option<Q>) -> Origin<'a>
  function path_only (line 161) | pub fn path_only<P: Into<Cow<'a, str>>>(path: P) -> Origin<'a> {
  function const_new (line 169) | pub const fn const_new(path: &'a str, query: Option<&'a str>) -> Origin<...
  function set_query (line 186) | pub(crate) fn set_query<Q: Into<Option<Cow<'a, str>>>>(&mut self, query:...
  function parse (line 212) | pub fn parse(string: &'a str) -> Result<Origin<'a>, Error<'a>> {
  function parse_route (line 219) | pub fn parse_route(string: &'a str) -> Result<Origin<'a>, Error<'a>> {
  function parse_owned (line 254) | pub fn parse_owned(string: String) -> Result<Origin<'static>, Error<'sta...
  function path (line 278) | pub fn path(&self) -> Path<'_> {
  function query (line 296) | pub fn query(&self) -> Option<Query<'_>> {
  function map_path (line 331) | pub fn map_path<'s, F, P>(&'s self, f: F) -> Option<Self>
  function clear_query (line 358) | pub fn clear_query(&mut self) {
  function is_normalized (line 384) | pub fn is_normalized(&self) -> bool {
  function _normalize (line 388) | fn _normalize(&mut self, allow_trail: bool) {
  function normalize (line 416) | pub fn normalize(&mut self) {
  function into_normalized (line 436) | pub fn into_normalized(mut self) -> Self {
  function has_trailing_slash (line 459) | pub fn has_trailing_slash(&self) -> bool {
  function is_normalized_nontrailing (line 488) | pub fn is_normalized_nontrailing(&self) -> bool {
  function into_normalized_nontrailing (line 527) | pub fn into_normalized_nontrailing(mut self) -> Self {
  function fmt (line 557) | fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
  function seg_count (line 571) | fn seg_count(path: &str, expected: usize) -> bool {
  function eq_segments (line 587) | fn eq_segments(path: &str, expected: &[&str]) -> bool {
  function send_and_sync (line 598) | fn send_and_sync() {
  function simple_segment_count (line 604) | fn simple_segment_count() {
  function segment_count (line 614) | fn segment_count() {
  function single_segments_match (line 629) | fn single_segments_match() {
  function multi_segments_match (line 646) | fn multi_segments_match() {
  function multi_segments_match_funky_chars (line 661) | fn multi_segments_match_funky_chars() {
  function segment_mismatch (line 666) | fn segment_mismatch() {
  function test_query (line 677) | fn test_query(uri: &str, query: Option<&str>) {
  function query_does_not_exist (line 683) | fn query_does_not_exist() {
  function query_exists (line 693) | fn query_exists() {

FILE: core/http/src/uri/path_query.rs
  type Data (line 14) | pub struct Data<'a, P: Part> {
  function raw (line 20) | pub(crate) fn raw(value: Extent<&'a [u8]>) -> Self {
  function new (line 26) | pub fn new<S: Into<Cow<'a, str>>>(value: S) -> Self {
  type Path (line 36) | pub struct Path<'a> {
  type Query (line 43) | pub struct Query<'a> {
  function decode_to_indexed_str (line 48) | fn decode_to_indexed_str<P: fmt::Part>(
  function raw (line 78) | pub fn raw(&self) -> &'a RawStr {
  function as_str (line 92) | pub fn as_str(&self) -> &'a str {
  function is_normalized (line 100) | pub(crate) fn is_normalized(&self, absolute: bool) -> bool {
  function to_normalized (line 113) | pub(crate) fn to_normalized(self, absolute: bool, trail: bool) -> Data<'...
  function raw_segments (line 171) | pub fn raw_segments(&self) -> impl DoubleEndedIterator<Item = &'a RawStr> {
  function segments (line 216) | pub fn segments(&self) -> Segments<'a, fmt::Path> {
  function raw (line 248) | pub fn raw(&self) -> &'a RawStr {
  function as_str (line 262) | pub fn as_str(&self) -> &'a str {
  function is_normalized (line 267) | pub(crate) fn is_normalized(&self) -> bool {
  function to_normalized (line 272) | pub(crate) fn to_normalized(self) -> Data<'static, fmt::Query> {
  function raw_segments (line 325) | pub fn raw_segments(&self) -> impl Iterator<Item = &'a RawStr> {
  function segments (line 353) | pub fn segments(&self) -> Segments<'a, fmt::Query> {

FILE: core/http/src/uri/reference.rs
  type Reference (line 73) | pub struct Reference<'a> {
  function raw (line 84) | pub(crate) unsafe fn raw(
  function new (line 104) | pub fn new(
  function const_new (line 116) | pub const fn const_new(
  function parse (line 171) | pub fn parse(string: &'a str) -> Result<Reference<'a>, Error<'a>> {
  function parse_owned (line 195) | pub fn parse_owned(string: String) -> Result<Reference<'static>, Error<'...
  function scheme (line 225) | pub fn scheme(&self) -> Option<&str> {
  function authority (line 243) | pub fn authority(&self) -> Option<&Authority<'a>> {
  function path (line 257) | pub fn path(&self) -> Path<'_> {
  function query (line 280) | pub fn query(&self) -> Option<Query<'_>> {
  function fragment (line 298) | pub fn fragment(&self) -> Option<&RawStr> {
  function is_normalized (line 334) | pub fn is_normalized(&self) -> bool {
  function normalize (line 364) | pub fn normalize(&mut self) {
  function into_normalized (line 399) | pub fn into_normalized(mut self) -> Self {
  function set_path (line 405) | pub(crate) fn set_path<P>(&mut self, path: P)
  function with_query_fragment_of (line 412) | pub(crate) fn with_query_fragment_of(mut self, other: Reference<'a>) -> ...
  function from (line 434) | fn from(absolute: Absolute<'a>) -> Self {
  function from (line 447) | fn from(origin: Origin<'a>) -> Self {
  function from (line 460) | fn from(authority: Authority<'a>) -> Self {
  function from (line 476) | fn from(_: Asterisk) -> Self {
  function fmt (line 489) | fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {

FILE: core/http/src/uri/segments.rs
  type Segments (line 36) | pub struct Segments<'a, P: Part> {
  function new (line 45) | pub fn new<'a>(source: &'a RawStr, segments: &'a [P::Raw]) -> Segments<'...
  function num (line 70) | pub fn num(&self) -> usize {
  function is_empty (line 91) | pub fn is_empty(&self) -> bool {
  function skip (line 112) | pub fn skip(mut self, n: usize) -> Self {
  function get (line 135) | pub fn get(&self, n: usize) -> Option<&'a str> {
  function prefix_of (line 172) | pub fn prefix_of(self, other: Segments<'_, Path>) -> bool {
  function to_path_buf (line 217) | pub fn to_path_buf(&self, allow_dotfiles: bool) -> Result<PathBuf, PathE...
  function get (line 271) | pub fn get(&self, n: usize) -> Option<(&'a str, &'a str)> {

FILE: core/http/src/uri/uri.rs
  type Uri (line 36) | pub enum Uri<'a> {
  function parse (line 82) | pub fn parse<T>(string: &'a str) -> Result<Uri<'a>, Error<'a>>
  function parse_any (line 130) | pub fn parse_any(string: &'a str) -> Result<Uri<'a>, Error<'a>> {
  function origin (line 155) | pub fn origin(&self) -> Option<&Origin<'a>> {
  function authority (line 183) | pub fn authority(&self) -> Option<&Authority<'a>> {
  function absolute (line 211) | pub fn absolute(&self) -> Option<&Absolute<'a>> {
  function reference (line 239) | pub fn reference(&self) -> Option<&Reference<'a>> {
  function as_utf8_unchecked (line 247) | pub(crate) unsafe fn as_utf8_unchecked(input: Cow<'_, [u8]>) -> Cow<'_, ...
  type Owned (line 276) | type Owned = Uri<'static>;
  method into_owned (line 278) | fn into_owned(self) -> Uri<'static> {
  method fmt (line 290) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  function normalization (line 497) | fn normalization() {

FILE: core/lib/build.rs
  function main (line 1) | fn main() {

FILE: core/lib/fuzz/targets/collision-matching.rs
  type ArbitraryRequestData (line 11) | struct ArbitraryRequestData<'a> {
  type ArbitraryRouteData (line 18) | struct ArbitraryRouteData<'a> {
  function fmt (line 25) | fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
  function fmt (line 37) | fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
  function into_local_request (line 49) | fn into_local_request(self, client: &'c Client) -> LocalRequest<'c> {
  function into_route (line 61) | fn into_route(self) -> Route {
  type ArbitraryMethod (line 70) | struct ArbitraryMethod(Method);
    method arbitrary (line 83) | fn arbitrary(u: &mut Unstructured<'a>) -> Result<Self> {
    method size_hint (line 87) | fn size_hint(_: usize) -> (usize, Option<usize>) {
  type ArbitraryOrigin (line 72) | struct ArbitraryOrigin<'a>(Origin<'a>);
  type ArbitraryAccept (line 74) | struct ArbitraryAccept(Accept);
    method arbitrary (line 110) | fn arbitrary(u: &mut Unstructured<'a>) -> Result<Self> {
    method size_hint (line 115) | fn size_hint(depth: usize) -> (usize, Option<usize>) {
  type ArbitraryContentType (line 76) | struct ArbitraryContentType(ContentType);
    method arbitrary (line 121) | fn arbitrary(u: &mut Unstructured<'a>) -> Result<Self> {
    method size_hint (line 126) | fn size_hint(depth: usize) -> (usize, Option<usize>) {
  type ArbitraryMediaType (line 78) | struct ArbitraryMediaType(MediaType);
    method arbitrary (line 132) | fn arbitrary(u: &mut Unstructured<'a>) -> Result<Self> {
    method size_hint (line 154) | fn size_hint(_: usize) -> (usize, Option<usize>) {
  type ArbitraryRouteUri (line 80) | struct ArbitraryRouteUri<'a>(RouteUri<'a>);
  function arbitrary (line 93) | fn arbitrary(u: &mut Unstructured<'a>) -> Result<Self> {
  function size_hint (line 104) | fn size_hint(_: usize) -> (usize, Option<usize>) {
  function arbitrary (line 160) | fn arbitrary(u: &mut Unstructured<'a>) -> Result<Self> {
  function size_hint (line 171) | fn size_hint(_: usize) -> (usize, Option<usize>) {
  type TestData (line 176) | type TestData<'a> = (
  function fuzz (line 182) | fn fuzz((route_a, route_b, req): TestData<'_>) {
  function main (line 205) | fn main() {
  function main (line 212) | fn main() {

FILE: core/lib/fuzz/targets/uri-normalization.rs
  function fuzz (line 6) | fn fuzz(data: &str) {

FILE: core/lib/fuzz/targets/uri-parsing.rs
  function fuzz (line 6) | fn fuzz(data: &str) {

FILE: core/lib/fuzz/targets/uri-roundtrip.rs
  function fuzz (line 6) | fn fuzz(data: &str) {

FILE: core/lib/src/catcher/catcher.rs
  type Catcher (line 113) | pub struct Catcher {
    method new (line 178) | pub fn new<S, H>(code: S, handler: H) -> Catcher
    method base (line 217) | pub fn base(&self) -> Path<'_> {
    method rebase (line 254) | pub fn rebase(mut self, mut base: uri::Origin<'_>) -> Self {
    method map_base (line 303) | pub fn map_base<'a, F>(mut self, mapper: F) -> Result<Self, uri::Error...
    method from (line 342) | fn from(info: StaticInfo) -> Catcher {
    method fmt (line 351) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  function rank (line 137) | fn rank(base: Path<'_>) -> isize {
  method default (line 315) | fn default() -> Self {
  type StaticInfo (line 328) | pub struct StaticInfo {

FILE: core/lib/src/catcher/handler.rs
  type Result (line 6) | pub type Result<'r> = std::result::Result<Response<'r>, crate::http::Sta...
  type BoxFuture (line 10) | pub type BoxFuture<'r, T = Result<'r>> = futures::future::BoxFuture<'r, T>;
  type Handler (line 92) | pub trait Handler: Cloneable + Send + Sync + 'static {
    method handle (line 100) | async fn handle<'r>(&self, status: Status, req: &'r Request<'_>) -> Re...
    method handle (line 107) | fn handle<'r, 'life0, 'life1, 'async_trait>(
  function dummy_handler (line 123) | pub fn dummy_handler<'r>(_: Status, _: &'r Request<'_>) -> BoxFuture<'r> {
  type Sealed (line 128) | pub trait Sealed {}
  type Cloneable (line 138) | pub trait Cloneable: private::Sealed {
    method clone_handler (line 140) | fn clone_handler(&self) -> Box<dyn Handler>;
    method clone_handler (line 144) | fn clone_handler(&self) -> Box<dyn Handler> {
  method clone (line 150) | fn clone(&self) -> Box<dyn Handler> {

FILE: core/lib/src/config/cli_colors.rs
  type CliColors (line 13) | pub enum CliColors {
    method fmt (line 39) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
    method deserialize (line 49) | fn deserialize<D: de::Deserializer<'de>>(de: D) -> Result<Self, D::Err...

FILE: core/lib/src/config/config.rs
  type Config (line 53) | pub struct Config {
    method debug_default (line 182) | pub fn debug_default() -> Config {
    method release_default (line 218) | pub fn release_default() -> Config {
    method figment (line 255) | pub fn figment() -> Figment {
    method try_from (line 278) | pub fn try_from<T: Provider>(provider: T) -> Result<Self> {
    method from (line 306) | pub fn from<T: Provider>(provider: T) -> Self {
    constant DEBUG_PROFILE (line 319) | pub const DEBUG_PROFILE: Profile = Profile::const_new("debug");
    constant RELEASE_PROFILE (line 322) | pub const RELEASE_PROFILE: Profile = Profile::const_new("release");
    constant DEFAULT_PROFILE (line 326) | pub const DEFAULT_PROFILE: Profile = Self::DEBUG_PROFILE;
    constant DEFAULT_PROFILE (line 330) | pub const DEFAULT_PROFILE: Profile = Self::RELEASE_PROFILE;
    constant WORKERS (line 336) | pub const WORKERS: &'static str = "workers";
    constant MAX_BLOCKING (line 339) | pub const MAX_BLOCKING: &'static str = "max_blocking";
    constant KEEP_ALIVE (line 342) | pub const KEEP_ALIVE: &'static str = "keep_alive";
    constant IDENT (line 345) | pub const IDENT: &'static str = "ident";
    constant IP_HEADER (line 348) | pub const IP_HEADER: &'static str = "ip_header";
    constant PROXY_PROTO_HEADER (line 351) | pub const PROXY_PROTO_HEADER: &'static str = "proxy_proto_header";
    constant LIMITS (line 354) | pub const LIMITS: &'static str = "limits";
    constant SECRET_KEY (line 357) | pub const SECRET_KEY: &'static str = "secret_key";
    constant TEMP_DIR (line 360) | pub const TEMP_DIR: &'static str = "temp_dir";
    constant LOG_LEVEL (line 363) | pub const LOG_LEVEL: &'static str = "log_level";
    constant LOG_FORMAT (line 366) | pub const LOG_FORMAT: &'static str = "log_format";
    constant SHUTDOWN (line 369) | pub const SHUTDOWN: &'static str = "shutdown";
    constant CLI_COLORS (line 372) | pub const CLI_COLORS: &'static str = "cli_colors";
    constant PARAMETERS (line 375) | pub const PARAMETERS: &'static [&'static str] = &[
    constant PROFILE (line 385) | const PROFILE: &'static str = "profile";
    constant DEPRECATED_KEYS (line 388) | pub(crate) const DEPRECATED_KEYS: &'static [(&'static str, Option<&'st...
    constant KNOWN_SECRET_KEYS (line 395) | pub(crate) const KNOWN_SECRET_KEYS: &'static [&'static str] = &[
  method default (line 160) | fn default() -> Config {
  method metadata (line 402) | fn metadata(&self) -> Metadata {
  method data (line 411) | fn data(&self) -> Result<Map<Profile, Dict>> {
  method profile (line 426) | fn profile(&self) -> Option<Profile> {
  type Error (line 433) | type Error = std::convert::Infallible;
  function from_request (line 435) | async fn from_request(req: &'r Request<'_>) -> request::Outcome<Self, Se...

FILE: core/lib/src/config/http_header.rs
  function deserialize (line 8) | pub(crate) fn deserialize<'de, D>(de: D) -> Result<Option<Uncased<'stati...

FILE: core/lib/src/config/ident.rs
  type Ident (line 78) | pub struct Ident(Option<String>);
    method try_new (line 128) | pub fn try_new<S: Into<String>>(ident: S) -> Result<Ident, String> {
    method none (line 152) | pub const fn none() -> Ident {
    method as_str (line 172) | pub fn as_str(&self) -> Option<&str> {
    method deserialize (line 178) | fn deserialize<D: Deserializer<'de>>(de: D) -> Result<Self, D::Error> {
    method fmt (line 225) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  method default (line 235) | fn default() -> Self {

FILE: core/lib/src/config/secret_key.rs
  type SecretKey (line 71) | pub struct SecretKey {
    method zero (line 78) | pub(crate) fn zero() -> SecretKey {
    method from (line 97) | pub fn from(master: &[u8]) -> SecretKey {
    method derive_from (line 116) | pub fn derive_from(material: &[u8]) -> SecretKey {
    method generate (line 130) | pub fn generate() -> Option<SecretKey> {
    method is_zero (line 145) | pub fn is_zero(&self) -> bool {
    method is_provided (line 164) | pub fn is_provided(&self) -> bool {
    method serialize_zero (line 169) | pub(crate) fn serialize_zero<S>(&self, ser: S) -> Result<S::Ok, S::Error>
    method deserialize (line 193) | fn deserialize<D: de::Deserializer<'de>>(de: D) -> Result<Self, D::Err...
    method fmt (line 248) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
    method fmt (line 261) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  method eq (line 177) | fn eq(&self, other: &Self) -> bool {
  type Error (line 185) | type Error = std::convert::Infallible;
  function from_request (line 187) | async fn from_request(req: &'r Request<'_>) -> Outcome<Self, Self::Error> {

FILE: core/lib/src/config/tests.rs
  function test_figment_is_default (line 10) | fn test_figment_is_default() {
  function test_default_round_trip (line 20) | fn test_default_round_trip() {
  function test_profile_env (line 34) | fn test_profile_env() {
  function test_toml_file (line 53) | fn test_toml_file() {
  function test_cli_colors (line 116) | fn test_cli_colors() {
  function test_profiles_merge (line 211) | fn test_profiles_merge() {
  function test_env_vars_merge (line 250) | fn test_env_vars_merge() {
  function test_precedence (line 304) | fn test_precedence() {
  function test_err_on_non_debug_and_no_secret_key (line 343) | fn test_err_on_non_debug_and_no_secret_key() {
  function test_err_on_non_debug2_and_no_secret_key (line 354) | fn test_err_on_non_debug2_and_no_secret_key() {
  function test_no_err_on_debug_and_no_secret_key (line 364) | fn test_no_err_on_debug_and_no_secret_key() {
  function test_no_err_on_release_and_custom_secret_key (line 379) | fn test_no_err_on_release_and_custom_secret_key() {

FILE: core/lib/src/data/capped.rs
  type N (line 4) | pub struct N {
    method fmt (line 12) | fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
    type Target (line 18) | type Target = u64;
    method deref (line 20) | fn deref(&self) -> &Self::Target {
  type Capped (line 65) | pub struct Capped<T> {
  function new (line 85) | pub fn new(value: T, n: N) -> Self {
  function complete (line 102) | pub fn complete(value: T, len: usize) -> Self {
  function map (line 119) | pub fn map<U, F: FnOnce(T) -> U>(self, f: F) -> Capped<U> {
  function is_empty (line 140) | pub fn is_empty(&self) -> bool {
  function is_complete (line 161) | pub fn is_complete(&self) -> bool {
  function into_inner (line 177) | pub fn into_inner(self) -> T {
  type Target (line 183) | type Target = T;
  function deref (line 185) | fn deref(&self) -> &Self::Target {
  function deref_mut (line 191) | fn deref_mut(&mut self) -> &mut Self::Target {
  function from (line 198) | fn from(value: T) -> Self {
  function respond_to (line 208) | fn respond_to(self, request: &'r Request<'_>) -> response::Result<'o> {

FILE: core/lib/src/data/data.rs
  type Data (line 41) | pub struct Data<'r> {
  function new (line 50) | pub(crate) fn new(stream: Peekable<512, RawReader<'r>>) -> Self {
  function from (line 55) | pub(crate) fn from<S: Into<RawStream<'r>>>(stream: S) -> Data<'r> {
  function local (line 61) | pub(crate) fn local(data: Vec<u8>) -> Data<'r> {
  function open (line 83) | pub fn open(self, limit: ByteUnit) -> DataStream<'r> {
  function peek (line 161) | pub async fn peek(&mut self, num: usize) -> &[u8] {
  function peek_complete (line 180) | pub fn peek_complete(&self) -> bool {
  function chain_transform (line 189) | pub fn chain_transform<T>(&mut self, transform: T) -> &mut Self
  function chain_inspect (line 197) | pub fn chain_inspect<F>(&mut self, f: F) -> &mut Self
  function chain_inplace_map (line 206) | pub fn chain_inplace_map<F>(&mut self, mut f: F) -> &mut Self
  function chain_try_inplace_map (line 215) | pub fn chain_try_inplace_map<F>(&mut self, f: F) -> &mut Self

FILE: core/lib/src/data/data_stream.rs
  type DataStream (line 48) | pub enum DataStream<'r> {
  type TransformReader (line 56) | pub struct TransformReader<'r> {
  type BaseReader (line 63) | pub type BaseReader<'r> = Take<Chain<Cursor<Vec<u8>>, RawReader<'r>>>;
  type RawReader (line 66) | pub type RawReader<'r> = StreamReader<RawStream<'r>, Bytes>;
  type RawStream (line 69) | pub enum RawStream<'r> {
  function base_mut (line 79) | fn base_mut(&mut self) -> &mut BaseReader<'r> {
  function base (line 87) | fn base(&self) -> &BaseReader<'r> {
  function new (line 96) | pub(crate) fn new(
  function base_mut (line 114) | fn base_mut(&mut self) -> &mut BaseReader<'r> {
  function base (line 122) | fn base(&self) -> &BaseReader<'r> {
  function limit_exceeded (line 130) | async fn limit_exceeded(&mut self) -> io::Result<bool> {
  function hint (line 157) | pub fn hint(&self) -> usize {
  function stream_to (line 193) | pub async fn stream_to<W>(mut self, mut writer: W) -> io::Result<N>
  function stream_precise_to (line 218) | pub async fn stream_precise_to<W>(mut self, mut writer: W) -> io::Result...
  function into_bytes (line 241) | pub async fn into_bytes(self) -> io::Result<Capped<Vec<u8>>> {
  function into_string (line 264) | pub async fn into_string(mut self) -> io::Result<Capped<String>> {
  function into_file (line 290) | pub async fn into_file<P: AsRef<Path>>(self, path: P) -> io::Result<Capp...
  method poll_read (line 298) | fn poll_read(
  method poll_read (line 311) | fn poll_read(
  type Item (line 338) | type Item = io::Result<Bytes>;
  method poll_next (line 340) | fn poll_next(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<...
  method size_hint (line 356) | fn size_hint(&self) -> (usize, Option<usize>) {
  function fmt (line 372) | fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
  function from (line 384) | fn from(value: HyperBody) -> Self {
  function from (line 391) | fn from(value: crate::listener::Cancellable<crate::listener::quic::QuicR...
  function from (line 397) | fn from(value: multer::Field<'r>) -> Self {

FILE: core/lib/src/data/from_data.rs
  type Outcome (line 9) | pub type Outcome<'r, T, E = <T as FromData<'r>>::Error>
  type FromData (line 304) | pub trait FromData<'r>: Sized {
    method from_data (line 314) | async fn from_data(req: &'r Request<'_>, data: Data<'r>) -> Outcome<'r...
  type Error (line 321) | type Error = std::io::Error;
  function from_data (line 323) | async fn from_data(req: &'r Request<'_>, data: Data<'r>) -> Outcome<'r, ...
  type Error (line 333) | type Error = std::io::Error;
  function from_data (line 335) | async fn from_data(req: &'r Request<'_>, data: Data<'r>) -> Outcome<'r, ...
  type Error (line 346) | type Error = std::io::Error;
  function from_data (line 348) | async fn from_data(req: &'r Request<'_>, data: Data<'r>) -> Outcome<'r, ...
  type Error (line 359) | type Error = std::io::Error;
  function from_data (line 361) | async fn from_data(req: &'r Request<'_>, data: Data<'r>) -> Outcome<'r, ...
  type Error (line 371) | type Error = std::io::Error;
  function from_data (line 373) | async fn from_data(req: &'r Request<'_>, data: Data<'r>) -> Outcome<'r, ...
  type Error (line 384) | type Error = std::io::Error;
  function from_data (line 386) | async fn from_data(req: &'r Request<'_>, data: Data<'r>) -> Outcome<'r, ...
  type Error (line 396) | type Error = std::convert::Infallible;
  function from_data (line 398) | async fn from_data(_: &'r Request<'_>, data: Data<'r>) -> Outcome<'r, Se...
  type Error (line 405) | type Error = std::convert::Infallible;
  function from_data (line 407) | async fn from_data(req: &'r Request<'_>, data: Data<'r>) -> Outcome<'r, ...
  type Error (line 418) | type Error = std::convert::Infallible;
  function from_data (line 420) | async fn from_data(req: &'r Request<'_>, data: Data<'r>) -> Outcome<'r, ...

FILE: core/lib/src/data/io_stream.rs
  type IoStream (line 25) | pub struct IoStream {
    method from (line 83) | fn from(io: Upgraded) -> Self {
    method inner_mut (line 96) | fn inner_mut(&mut self) -> Pin<&mut dyn AsyncReadWrite> {
    method inner_is_write_vectored (line 103) | fn inner_is_write_vectored(&self) -> bool {
  type IoStreamKind (line 30) | enum IoStreamKind {
  type IoHandler (line 69) | pub trait IoHandler: Send {
    method io (line 71) | async fn io(self: Box<Self>, io: IoStream) -> io::Result<()>;
    method io (line 76) | async fn io(self: Box<Self>, _: IoStream) -> io::Result<()> {
  type AsyncReadWrite (line 89) | pub trait AsyncReadWrite: AsyncRead + AsyncWrite + Unpin { }
  method poll_read (line 111) | fn poll_read(
  method poll_write (line 121) | fn poll_write(
  method poll_flush (line 129) | fn poll_flush(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<io::Re...
  method poll_shutdown (line 133) | fn poll_shutdown(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<io:...
  method poll_write_vectored (line 137) | fn poll_write_vectored(
  method is_write_vectored (line 145) | fn is_write_vectored(&self) -> bool {
  function is_unpin (line 155) | fn is_unpin() {

FILE: core/lib/src/data/limits.rs
  type Limits (line 124) | pub struct Limits {
    constant FORM (line 145) | pub const FORM: ByteUnit = ByteUnit::Kibibyte(32);
    constant DATA_FORM (line 148) | pub const DATA_FORM: ByteUnit = ByteUnit::Mebibyte(2);
    constant FILE (line 151) | pub const FILE: ByteUnit = ByteUnit::Mebibyte(1);
    constant STRING (line 154) | pub const STRING: ByteUnit = ByteUnit::Kibibyte(8);
    constant BYTES (line 157) | pub const BYTES: ByteUnit = ByteUnit::Kibibyte(8);
    constant JSON (line 160) | pub const JSON: ByteUnit = ByteUnit::Mebibyte(1);
    constant MESSAGE_PACK (line 163) | pub const MESSAGE_PACK: ByteUnit = ByteUnit::Mebibyte(1);
    method new (line 179) | pub fn new() -> Self {
    method limit (line 203) | pub fn limit<S: Into<Uncased<'static>>>(mut self, name: S, limit: Byte...
    method get (line 238) | pub fn get<S: AsRef<str>>(&self, name: S) -> Option<ByteUnit> {
    method find (line 285) | pub fn find<S: AsRef<str>, L: AsRef<[S]>>(&self, layers: L) -> Option<...
    method deserialize (line 306) | fn deserialize<'de, D>(de: D) -> Result<Vec<(Uncased<'static>, ByteUni...
  method default (line 131) | fn default() -> Limits {
  type Error (line 317) | type Error = std::convert::Infallible;
  function from_request (line 319) | async fn from_request(req: &'r Request<'_>) -> Outcome<Self, Self::Error> {

FILE: core/lib/src/data/peekable.rs
  type Peekable (line 3) | pub struct Peekable<const N: usize, R> {
  function new (line 10) | pub fn new(reader: R) -> Self {
  function with_buffer (line 14) | pub fn with_buffer(buffer: Vec<u8>, complete: bool, reader: R) -> Self {
  function peek (line 18) | pub async fn peek(&mut self, num: usize) -> &[u8] {

FILE: core/lib/src/data/transform.rs
  type Transform (line 38) | pub trait Transform {
    method transform (line 46) | fn transform(
    method poll_finish (line 59) | fn poll_finish(
    method transform (line 140) | fn transform(mut self: Pin<&mut Self>, buf: &mut TransformBuf<'_, '_>)...
    method transform (line 151) | fn transform(mut self: Pin<&mut Self>, buf: &mut TransformBuf<'_, '_>,...
    method transform (line 205) | fn transform(
    method poll_finish (line 214) | fn poll_finish(
  type TransformBuf (line 110) | pub struct TransformBuf<'a, 'b> {
  function fresh (line 117) | pub fn fresh(&self) -> &[u8] {
  function fresh_mut (line 123) | pub fn fresh_mut(&mut self) -> &mut [u8] {
  function spoil (line 131) | pub fn spoil(&mut self) {
  type Inspect (line 137) | pub struct Inspect(pub(crate) Box<dyn FnMut(&[u8]) + Send + Sync + 'stat...
  type InPlaceMap (line 146) | pub struct InPlaceMap(
  type Target (line 157) | type Target = ReadBuf<'b>;
  method deref (line 159) | fn deref(&self) -> &Self::Target {
  method deref_mut (line 165) | fn deref_mut(&mut self) -> &mut Self::Target {
  type HashTransform (line 199) | pub struct HashTransform<H: Hasher> {
  function chain_hash_transform (line 231) | pub fn chain_hash_transform<H: std::hash::Hasher>(&mut self, hasher: H) ...
  function test_transform_series (line 240) | fn test_transform_series() {

FILE: core/lib/src/erased.rs
  type ErasedRequest (line 26) | pub struct ErasedRequest {
    method new (line 59) | pub fn new(
    method inner (line 80) | pub fn inner(&self) -> &Request<'_> {
    method into_response (line 85) | pub async fn into_response<T, D>(
  method drop (line 34) | fn drop(&mut self) { }
  type ErasedResponse (line 38) | pub struct ErasedResponse {
    method inner (line 130) | pub fn inner(&self) -> &Response<'_> {
    method with_inner_mut (line 135) | pub fn with_inner_mut<'a, T>(
    method make_io_handler (line 143) | pub fn make_io_handler<'a, T: 'static>(
  method drop (line 45) | fn drop(&mut self) { }
  type ErasedIoHandler (line 48) | pub struct ErasedIoHandler {
    method with_inner_mut (line 163) | pub fn with_inner_mut<'a, T: 'a>(
    method take (line 174) | pub fn take<'a>(&'a mut self) -> Box<dyn IoHandler + 'a> {
  method drop (line 55) | fn drop(&mut self) { }
  method poll_read (line 184) | fn poll_read(

FILE: core/lib/src/error.rs
  type Error (line 44) | pub struct Error {
    method new (line 148) | pub(crate) fn new(kind: ErrorKind) -> Error {
    method kind (line 172) | pub fn kind(&self) -> &ErrorKind {
    method report (line 194) | pub fn report<P: Phase>(result: Result<Rocket<P>, Error>) -> process::...
    method from (line 206) | fn from(kind: ErrorKind) -> Self {
    method from (line 212) | fn from(e: figment::Error) -> Self {
    method from (line 218) | fn from(e: io::Error) -> Self {
    method fmt (line 258) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
    method fmt (line 265) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  type ErrorKind (line 57) | pub enum ErrorKind {
    method fmt (line 241) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  type Empty (line 90) | pub struct Empty;
    method fmt (line 271) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
    method fmt (line 277) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  type InvalidOption (line 124) | pub struct InvalidOption<'a> {
  function new (line 133) | pub fn new(value: &'a str, options: &'static [&'static str]) -> Self {
  function fmt (line 139) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  method source (line 224) | fn source(&self) -> Option<&(dyn StdError + 'static)> {
  type ServerError (line 284) | struct ServerError<'a>(&'a (dyn StdError + 'static));
  function fmt (line 287) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  function log_server_error (line 311) | pub(crate) fn log_server_error(error: &(dyn StdError + 'static)) {
  type DisplayHack (line 346) | pub struct DisplayHack<T: ?Sized>(pub T);
  type DefaultDisplay (line 348) | pub trait DefaultDisplay {
    method display (line 349) | fn display(&self) -> impl fmt::Display;
    method display (line 356) | fn display(&self) -> impl fmt::Display {
  function display (line 365) | pub fn display(&self) -> impl fmt::Display + '_ {

FILE: core/lib/src/fairing/ad_hoc.rs
  type AdHoc (line 39) | pub struct AdHoc {
    method on_ignite (line 92) | pub fn on_ignite<F, Fut>(name: &'static str, f: F) -> AdHoc
    method try_on_ignite (line 113) | pub fn try_on_ignite<F, Fut>(name: &'static str, f: F) -> AdHoc
    method on_liftoff (line 133) | pub fn on_liftoff<F: Send + Sync + 'static>(name: &'static str, f: F) ...
    method on_request (line 156) | pub fn on_request<F: Send + Sync + 'static>(name: &'static str, f: F) ...
    method on_response (line 182) | pub fn on_response<F: Send + Sync + 'static>(name: &'static str, f: F)...
    method on_shutdown (line 203) | pub fn on_shutdown<F: Send + Sync + 'static>(name: &'static str, f: F)...
    method config (line 232) | pub fn config<'de, T>() -> AdHoc
    method uri_normalizer (line 315) | pub fn uri_normalizer() -> impl Fairing {
  type Once (line 44) | struct Once<F: ?Sized>(Mutex<Option<Box<F>>>);
  function new (line 47) | fn new(f: Box<F>) -> Self { Once(Mutex::new(Some(f))) }
  function take (line 50) | fn take(&self) -> Box<F> {
  type AdHocKind (line 55) | enum AdHocKind {
  method info (line 405) | fn info(&self) -> Info {
  method on_ignite (line 417) | async fn on_ignite(&self, rocket: Rocket<Build>) -> Result {
  method on_liftoff (line 424) | async fn on_liftoff(&self, rocket: &Rocket<Orbit>) {
  method on_request (line 430) | async fn on_request(&self, req: &mut Request<'_>, data: &mut Data<'_>) {
  method on_response (line 436) | async fn on_response<'r>(&self, req: &'r Request<'_>, res: &mut Response...
  method on_shutdown (line 442) | async fn on_shutdown(&self, rocket: &Rocket<Orbit>) {

FILE: core/lib/src/fairing/fairings.rs
  type Fairings (line 5) | pub struct Fairings {
    method new (line 37) | pub fn new() -> Fairings {
    method active (line 41) | pub fn active(&self) -> impl Iterator<Item = &usize> {
    method unique_active (line 49) | pub fn unique_active(&self) -> impl Iterator<Item = usize> {
    method unique_set (line 60) | pub fn unique_set(&self) -> Vec<&dyn Fairing> {
    method add (line 64) | pub fn add(&mut self, fairing: Box<dyn Fairing>) {
    method append (line 119) | pub fn append(&mut self, others: &mut Fairings) {
    method handle_ignite (line 125) | pub async fn handle_ignite(mut rocket: Rocket<Build>) -> Rocket<Build> {
    method handle_liftoff (line 152) | pub async fn handle_liftoff(&self, rocket: &Rocket<Orbit>) {
    method handle_request (line 158) | pub async fn handle_request(&self, req: &mut Request<'_>, data: &mut D...
    method handle_response (line 165) | pub async fn handle_response<'r>(&self, req: &'r Request<'_>, res: &mu...
    method handle_shutdown (line 172) | pub async fn handle_shutdown(&self, rocket: &Rocket<Orbit>) {
    method audit (line 177) | pub fn audit(&self) -> Result<(), &[Info]> {
    method filter (line 184) | pub fn filter<F: Fairing>(&self) -> impl Iterator<Item = &F> {
    method filter_mut (line 189) | pub fn filter_mut<F: Fairing>(&mut self) -> impl Iterator<Item = &mut ...
    method fmt (line 207) | fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {

FILE: core/lib/src/fairing/info_kind.rs
  type Info (line 26) | pub struct Info {
  type Kind (line 54) | pub struct Kind(usize);
    constant Ignite (line 59) | pub const Ignite: Kind = Kind(1 << 0);
    constant Liftoff (line 62) | pub const Liftoff: Kind = Kind(1 << 1);
    constant Request (line 65) | pub const Request: Kind = Kind(1 << 2);
    constant Response (line 68) | pub const Response: Kind = Kind(1 << 3);
    constant Shutdown (line 71) | pub const Shutdown: Kind = Kind(1 << 4);
    constant Singleton (line 75) | pub const Singleton: Kind = Kind(1 << 5);
    method is (line 97) | pub fn is(self, other: Kind) -> bool {
    method is_exactly (line 117) | pub fn is_exactly(self, other: Kind) -> bool {
    method fmt (line 132) | fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
  type Output (line 123) | type Output = Self;
  method bitor (line 126) | fn bitor(self, rhs: Self) -> Self {

FILE: core/lib/src/fairing/mod.rs
  type Result (line 65) | pub type Result<T = Rocket<Build>, E = Rocket<Build>> = std::result::Res...
  type Fairing (line 428) | pub trait Fairing: Send + Sync + AsAny + 'static {
    method info (line 462) | fn info(&self) -> Info;
    method on_ignite (line 477) | async fn on_ignite(&self, rocket: Rocket<Build>) -> Result { Ok(rocket) }
    method on_liftoff (line 490) | async fn on_liftoff(&self, _rocket: &Rocket<Orbit>) { }
    method on_request (line 504) | async fn on_request(&self, _req: &mut Request<'_>, _data: &mut Data<'_...
    method on_response (line 518) | async fn on_response<'r>(&self, _req: &'r Request<'_>, _res: &mut Resp...
    method on_shutdown (line 533) | async fn on_shutdown(&self, _rocket: &Rocket<Orbit>) { }
    method info (line 544) | fn info(&self) -> Info {
    method on_ignite (line 549) | async fn on_ignite(&self, rocket: Rocket<Build>) -> Result {
    method on_liftoff (line 554) | async fn on_liftoff(&self, rocket: &Rocket<Orbit>) {
    method on_request (line 559) | async fn on_request(&self, req: &mut Request<'_>, data: &mut Data<'_>) {
    method on_response (line 564) | async fn on_response<'r>(&self, req: &'r Request<'_>, res: &mut Respon...
    method on_shutdown (line 569) | async fn on_shutdown(&self, rocket: &Rocket<Orbit>) {
  type AsAny (line 536) | pub trait AsAny: Any {
    method as_any_ref (line 537) | fn as_any_ref(&self) -> &dyn Any;
    method as_any_mut (line 538) | fn as_any_mut(&mut self) -> &mut dyn Any;
    method as_any_ref (line 575) | fn as_any_ref(&self) -> &dyn Any { self }
    method as_any_mut (line 576) | fn as_any_mut(&mut self) -> &mut dyn Any { self }
  function downcast_ref (line 580) | fn downcast_ref<T: Any>(&self) -> Option<&T> {
  function downcast_mut (line 584) | fn downcast_mut<T: Any>(&mut self) -> Option<&mut T> {

FILE: core/lib/src/form/buffer.rs
  type Shareable (line 17) | pub unsafe trait Shareable: std::ops::Deref + Sync + Send + 'static {
    method size (line 19) | fn size(&self) -> usize;
    method size (line 23) | fn size(&self) -> usize { self.len() }
    method size (line 27) | fn size(&self) -> usize { self.len() }
  type SharedStack (line 36) | pub struct SharedStack<T: Shareable> {
  function new (line 46) | pub fn new() -> Self {
  function push (line 55) | pub(crate) fn push<S: Into<T>>(&self, string: S) -> &T::Target {
  function push_owned (line 87) | pub fn push_owned(&self, string: T) -> &T::Target {
  function push_split (line 98) | pub(crate) fn push_split<S: Into<T>>(&self, string: S, n: usize) -> (&T:...
  function push_two (line 107) | pub(crate) fn push_two<V>(&self, a: V, b: V) -> (&T::Target, &T::Target)

FILE: core/lib/src/form/context.rs
  type Contextual (line 45) | pub struct Contextual<'v, T> {
  type Context (line 82) | pub struct Context<'v> {
  function fields (line 107) | pub fn fields(&self) -> impl Iterator<Item = &'v Name> + '_ {
  function field_value (line 132) | pub fn field_value<N: AsRef<Name>>(&self, name: N) -> Option<&'v str> {
  function field_values (line 155) | pub fn field_values<N>(&self, name: N) -> impl Iterator<Item = &'v str> ...
  function errors (line 180) | pub fn errors(&self) -> impl Iterator<Item = &Error<'v>> {
  function field_errors (line 222) | pub fn field_errors<'a, N>(&'a self, name: N) -> impl Iterator<Item = &'...
  function exact_field_errors (line 270) | pub fn exact_field_errors<'a, N>(&'a self, name: N) -> impl Iterator<Ite...
  function status (line 295) | pub fn status(&self) -> Status {
  function push_error (line 318) | pub fn push_error(&mut self, error: Error<'v>) {
  function push_errors (line 348) | pub fn push_errors<E: Into<Errors<'v>>>(&mut self, errors: E) {
  function from (line 354) | fn from(errors: Errors<'f>) -> Self {
  type Context (line 363) | type Context = (<T as FromForm<'v>>::Context, Context<'v>);
  function init (line 365) | fn init(opts: Options) -> Self::Context {
  function push_value (line 369) | fn push_value((ref mut val_ctxt, ctxt): &mut Self::Context, field: Value...
  function push_data (line 374) | async fn push_data((ref mut val_ctxt, ctxt): &mut Self::Context, field: ...
  function push_error (line 379) | fn push_error((_, ref mut ctxt): &mut Self::Context, e: Error<'v>) {
  function finalize (line 383) | fn finalize((val_ctxt, mut context): Self::Context) -> Result<'v, Self> {

FILE: core/lib/src/form/error.rs
  type Errors (line 59) | pub struct Errors<'v>(Vec<Error<'v>>);
  type Error (line 135) | pub struct Error<'v> {
  type ErrorKind (line 167) | pub enum ErrorKind<'v> {
  type Entity (line 220) | pub enum Entity {
    method fmt (line 1000) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
    method default_for (line 1026) | pub const fn default_for(kind: &ErrorKind<'_>) -> Self {
  function new (line 250) | pub fn new() -> Self {
  function with_name (line 273) | pub fn with_name<N: Into<NameBuf<'v>>>(mut self, name: N) -> Self {
  function set_name (line 297) | pub fn set_name<N: Into<NameBuf<'v>>>(&mut self, name: N) {
  function with_value (line 325) | pub fn with_value(mut self, value: &'v str) -> Self {
  function set_value (line 349) | pub fn set_value(&mut self, value: &'v str) {
  function status (line 376) | pub fn status(&self) -> Status {
  type Owned (line 383) | type Owned = Errors<'static>;
  function into_owned (line 385) | fn into_owned(self) -> Self::Owned {
  function fmt (line 391) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  type Target (line 402) | type Target = Vec<Error<'v>>;
  function deref (line 404) | fn deref(&self) -> &Self::Target {
  function deref_mut (line 410) | fn deref_mut(&mut self) -> &mut Self::Target {
  function from (line 417) | fn from(e: T) -> Self {
  function from (line 424) | fn from(v: Vec<Error<'v>>) -> Self {
  type Item (line 430) | type Item = Error<'v>;
  type IntoIter (line 432) | type IntoIter = <Vec<Error<'v>> as IntoIterator>::IntoIter;
  method into_iter (line 434) | fn into_iter(self) -> Self::IntoIter {
  function custom (line 453) | pub fn custom<E>(error: E) -> Self
  function validation (line 470) | pub fn validation<S: Into<Cow<'v, str>>>(msg: S) -> Self {
  function with_entity (line 488) | pub fn with_entity(mut self, entity: Entity) -> Self {
  function set_entity (line 506) | pub fn set_entity(&mut self, entity: Entity) {
  function with_name (line 527) | pub fn with_name<N: Into<NameBuf<'v>>>(mut self, name: N) -> Self {
  function set_name (line 548) | pub fn set_name<N: Into<NameBuf<'v>>>(&mut self, name: N) {
  function with_value (line 571) | pub fn with_value(mut self, value: &'v str) -> Self {
  function set_value (line 592) | pub fn set_value(&mut self, value: &'v str) {
  function is_for (line 630) | pub fn is_for<N: AsRef<Name>>(&self, name: N) -> bool {
  function is_for_exactly (line 682) | pub fn is_for_exactly<N: AsRef<Name>>(&self, name: N) -> bool {
  function status (line 724) | pub fn status(&self) -> Status {
  method serialize (line 741) | fn serialize<S: Serializer>(&self, ser: S) -> Result<S::Ok, S::Error> {
  type Owned (line 752) | type Owned = Error<'static>;
  function into_owned (line 754) | fn into_owned(self) -> Self::Owned {
  type Target (line 765) | type Target = ErrorKind<'v>;
  function deref (line 767) | fn deref(&self) -> &Self::Target {
  function fmt (line 773) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  function from (line 780) | fn from(k: T) -> Self {
  function from (line 788) | fn from(error: multer::Error) -> Self {
  function fmt (line 815) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  type Owned (line 876) | type Owned = ErrorKind<'static>;
  function into_owned (line 878) | fn into_owned(self) -> Self::Owned {
  function eq (line 909) | fn eq(&self, other: &ErrorKind<'b>) -> bool {
  function from (line 933) | fn from((min, max): (Option<u64>, Option<u64>)) -> Self {
  function from (line 939) | fn from(choices: &'static [Cow<'v, str>]) -> Self {
  function from (line 945) | fn from(choices: Vec<Cow<'v, str>>) -> Self {
  function from (line 951) | fn from((start, end): (Option<isize>, Option<isize>)) -> Self {
  function from (line 957) | fn from((start, end): (Option<ByteUnit>, Option<ByteUnit>)) -> Self {
  function from (line 963) | fn from(choices: &'static [Cow<'v, str>; N]) -> Self {
  function from (line 970) | fn from(e: Box<dyn std::error::Error + Send>) -> Self {
  function from (line 976) | fn from((status, e): (Status, Box<dyn std::error::Error + Send>)) -> Self {

FILE: core/lib/src/form/field.rs
  type ValueField (line 12) | pub struct ValueField<'r> {
  type DataField (line 25) | pub struct DataField<'r, 'i> {
  function parse (line 65) | pub fn parse(field: &'v str) -> Self {
  function from_value (line 87) | pub fn from_value(value: &'v str) -> Self {
  function shift (line 109) | pub fn shift(mut self) -> Self {
  function unexpected (line 136) | pub fn unexpected(&self) -> Error<'v> {
  function missing (line 165) | pub fn missing(&self) -> Error<'v> {
  function shift (line 188) | pub fn shift(mut self) -> Self {
  function unexpected (line 210) | pub fn unexpected(&self) -> Error<'v> {
  function from (line 218) | fn from((name, value): (&'a str, &'a str)) -> Self {
  function eq (line 224) | fn eq(&self, other: &ValueField<'b>) -> bool {

FILE: core/lib/src/form/form.rs
  type Form (line 132) | pub struct Form<T>(T);
  function into_inner (line 161) | pub fn into_inner(self) -> T {
  function from (line 168) | fn from(val: T) -> Form<T> {
  function parse (line 199) | pub fn parse(string: &'r str) -> Result<'r, T> {
  function parse_iter (line 230) | pub fn parse_iter<I>(fields: I) -> Result<'r, T>
  function parse_encoded (line 265) | pub fn parse_encoded(string: &RawStr) -> Result<'static, T> {
  function values (line 295) | pub fn values(string: &str) -> impl Iterator<Item = ValueField<'_>> {
  type Target (line 304) | type Target = T;
  method deref (line 306) | fn deref(&self) -> &Self::Target {
  method deref_mut (line 312) | fn deref_mut(&mut self) -> &mut Self::Target {
  type Error (line 319) | type Error = Errors<'r>;
  function from_data (line 321) | async fn from_data(req: &'r Request<'_>, data: Data<'r>) -> Outcome<'r, ...

FILE: core/lib/src/form/from_form.rs
  type FromForm (line 532) | pub trait FromForm<'r>: Send + Sized {
    method init (line 537) | fn init(opts: Options) -> Self::Context;
    method push_value (line 540) | fn push_value(ctxt: &mut Self::Context, field: ValueField<'r>);
    method push_data (line 543) | async fn push_data(ctxt: &mut Self::Context, field: DataField<'r, '_>);
    method push_error (line 548) | fn push_error(_ctxt: &mut Self::Context, _error: Error<'r>) { }
    method finalize (line 552) | fn finalize(ctxt: Self::Context) -> Result<'r, Self>;
    method default (line 561) | fn default(opts: Options) -> Option<Self> {
  type VecContext (line 567) | pub struct VecContext<'v, T: FromForm<'v>> {
  function new (line 576) | fn new(opts: Options) -> Self {
  function shift (line 586) | fn shift(&mut self) {
  function context (line 595) | fn context(&mut self, name: &NameView<'v>) -> &mut T::Context {
  type Context (line 614) | type Context = VecContext<'v, T>;
  function init (line 616) | fn init(opts: Options) -> Self::Context {
  function push_value (line 620) | fn push_value(this: &mut Self::Context, field: ValueField<'v>) {
  function push_data (line 624) | async fn push_data(this: &mut Self::Context, field: DataField<'v, '_>) {
  function finalize (line 628) | fn finalize(mut this: Self::Context) -> Result<'v, Self> {
  type MapContext (line 643) | pub struct MapContext<'v, K, V> where K: FromForm<'v>, V: FromForm<'v> {
  function new (line 659) | fn new(opts: Options) -> Self {
  function ctxt (line 669) | fn ctxt(&mut self, key: &'v str, name: NameView<'v>) -> &mut (K::Context...
  function push (line 682) | fn push(&mut self, name: NameView<'v>) -> Option<Either<&mut K::Context,...
  function push_value (line 723) | fn push_value(&mut self, field: ValueField<'v>) {
  function push_data (line 731) | async fn push_data(&mut self, field: DataField<'v, '_>) {
  function finalize (line 739) | fn finalize<T: std::iter::FromIterator<(K, V)>>(mut self) -> Result<'v, ...
  type Context (line 775) | type Context = MapContext<'v, K, V>;
  function init (line 777) | fn init(opts: Options) -> Self::Context {
  function push_value (line 781) | fn push_value(ctxt: &mut Self::Context, field: ValueField<'v>) {
  function push_data (line 785) | async fn push_data(ctxt: &mut Self::Context, field: DataField<'v, '_>) {
  function finalize (line 789) | fn finalize(this: Self::Context) -> Result<'v, Self> {
  type Context (line 798) | type Context = MapContext<'v, K, V>;
  function init (line 800) | fn init(opts: Options) -> Self::Context {
  function push_value (line 804) | fn push_value(ctxt: &mut Self::Context, field: ValueField<'v>) {
  function push_data (line 808) | async fn push_data(ctxt: &mut Self::Context, field: DataField<'v, '_>) {
  function finalize (line 812) | fn finalize(this: Self::Context) -> Result<'v, Self> {
  type Context (line 819) | type Context = <T as FromForm<'v>>::Context;
  function init (line 821) | fn init(_: Options) -> Self::Context {
  function push_value (line 825) | fn push_value(ctxt: &mut Self::Context, field: ValueField<'v>) {
  function push_data (line 829) | async fn push_data(ctxt: &mut Self::Context, field: DataField<'v, '_>) {
  function finalize (line 833) | fn finalize(this: Self::Context) -> Result<'v, Self> {
  type Context (line 840) | type Context = <T as FromForm<'v>>::Context;
  function init (line 842) | fn init(opts: Options) -> Self::Context {
  function push_value (line 846) | fn push_value(ctxt: &mut Self::Context, field: ValueField<'v>) {
  function push_data (line 850) | async fn push_data(ctxt: &mut Self::Context, field: DataField<'v, '_>) {
  function finalize (line 854) | fn finalize(this: Self::Context) -> Result<'v, Self> {
  type PairContext (line 860) | pub struct PairContext<'v, A: FromForm<'v>, B: FromForm<'v>> {
  function context (line 867) | fn context(
  type Context (line 883) | type Context = PairContext<'v, A, B>;
  function init (line 885) | fn init(opts: Options) -> Self::Context {
  function push_value (line 893) | fn push_value(ctxt: &mut Self::Context, field: ValueField<'v>) {
  function push_data (line 901) | async fn push_data(ctxt: &mut Self::Context, field: DataField<'v, '_>) {
  function finalize (line 909) | fn finalize(mut ctxt: Self::Context) -> Result<'v, Self> {
  type Context (line 924) | type Context = <T as FromForm<'v>>::Context;
  function init (line 926) | fn init(opts: Options) -> Self::Context {
  function push_value (line 930) | fn push_value(ctxt: &mut Self::Context, field: ValueField<'v>) {
  function push_data (line 934) | async fn push_data(ctxt: &mut Self::Context, field: DataField<'v, '_>) {
  function finalize (line 938) | fn finalize(this: Self::Context) -> Result<'v, Self> {

FILE: core/lib/src/form/from_form_field.rs
  type FromFormField (line 182) | pub trait FromFormField<'v>: Send + Sized {
    method from_value (line 187) | fn from_value(field: ValueField<'v>) -> Result<'v, Self> {
    method from_data (line 195) | async fn from_data(field: DataField<'v, '_>) -> Result<'v, Self> {
    method default (line 207) | fn default() -> Option<Self> { None }
  type FromFieldContext (line 211) | pub struct FromFieldContext<'v, T: FromFormField<'v>> {
  function should_push (line 220) | fn should_push(&mut self) -> bool {
  function push (line 225) | fn push(&mut self, name: NameView<'v>, result: Result<'v, T>) {
  type Context (line 240) | type Context = FromFieldContext<'v, T>;
  method init (line 242) | fn init(opts: Options) -> Self::Context {
  method push_value (line 252) | fn push_value(ctxt: &mut Self::Context, field: ValueField<'v>) {
  method push_data (line 259) | async fn push_data(ctxt: &mut FromFieldContext<'v, T>, field: DataField<...
  method finalize (line 265) | fn finalize(ctxt: Self::Context) -> Result<'v, Self> {
  function from_value (line 291) | fn from_value(field: ValueField<'v>) -> Result<'v, Self> {
  function from_data (line 295) | async fn from_data(f: DataField<'v, '_>) -> Result<'v, Self> {
  function from_value (line 312) | fn from_value(field: ValueField<'v>) -> Result<'v, Self> {
  function from_data (line 316) | async fn from_data(f: DataField<'v, '_>) -> Result<'v, Self> {
  function default (line 332) | fn default() -> Option<Self> {
  function from_value (line 336) | fn from_value(field: ValueField<'v>) -> Result<'v, Self> {
  function from_value (line 348) | fn from_value(field: ValueField<'v>) -> Result<'v, Self> {
  function from_data (line 352) | async fn from_data(f: DataField<'v, '_>) -> Result<'v, Self> {
  function from_value (line 369) | fn from_value(field: ValueField<'v>) -> Result<'v, Self> {
  function from_data (line 374) | async fn from_data(field: DataField<'v, '_>) -> Result<'v, Self> {
  method from_value (line 413) | fn from_value(field: ValueField<'v>) -> Result<'v, Self> {
  method from_value (line 422) | fn from_value(field: ValueField<'v>) -> Result<'v, Self> {
  method from_value (line 432) | fn from_value(field: ValueField<'v>) -> Result<'v, Self> {

FILE: core/lib/src/form/lenient.rs
  type Lenient (line 42) | pub struct Lenient<T>(T);
  function into_inner (line 71) | pub fn into_inner(self) -> T {
  type Context (line 78) | type Context = T::Context;
  function init (line 81) | fn init(_: Options) -> Self::Context {
  function push_value (line 86) | fn push_value(ctxt: &mut Self::Context, field: ValueField<'v>) {
  function push_data (line 91) | async fn push_data(ctxt: &mut Self::Context, field: DataField<'v, '_>) {
  function finalize (line 96) | fn finalize(this: Self::Context) -> Result<'v, Self> {
  type Target (line 102) | type Target = T;
  method deref (line 104) | fn deref(&self) -> &Self::Target {
  method deref_mut (line 110) | fn deref_mut(&mut self) -> &mut Self::Target {
  function from (line 117) | fn from(val: T) -> Lenient<T> {
  type Target (line 123) | type Target = T::Target;
  function from_uri_param (line 126) | fn from_uri_param(param: A) -> Self::Target {

FILE: core/lib/src/form/mod.rs
  type Result (line 382) | pub type Result<'v, T> = std::result::Result<T, Errors<'v>>;

FILE: core/lib/src/form/name/buf.rs
  type NameBuf (line 20) | pub struct NameBuf<'v> {
  function split (line 27) | fn split(&self) -> (&Name, &Name) {
  function keys (line 45) | pub fn keys(&self) -> impl Iterator<Item = &Key> {
  function is_empty (line 64) | pub fn is_empty(&self) -> bool {
  type Owned (line 71) | type Owned = NameBuf<'static>;
  function into_owned (line 73) | fn into_owned(self) -> Self::Owned {
  function serialize (line 86) | fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
  function from (line 94) | fn from(nv: NameView<'v>) -> Self {
  function from (line 100) | fn from(name: &'v Name) -> Self {
  function from (line 106) | fn from(name: &'v str) -> Self {
  function from (line 112) | fn from(name: String) -> Self {
  function from (line 119) | fn from((prefix, right): (Option<&'v Name>, Cow<'v, str>)) -> Self {
  function from (line 129) | fn from((prefix, right): (Option<&'v Name>, String)) -> Self {
  function from (line 139) | fn from((prefix, suffix): (Option<&'v Name>, &'v str)) -> Self {
  function from (line 146) | fn from((prefix, suffix): (&'v Name, &'v str)) -> Self {
  function fmt (line 152) | fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
  function fmt (line 167) | fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
  method eq (line 180) | fn eq(&self, other: &Self) -> bool {
  function eq (line 186) | fn eq(&self, other: &N) -> bool {
  method eq (line 192) | fn eq(&self, other: &NameBuf<'_>) -> bool {
  function eq (line 198) | fn eq(&self, other: &NameBuf<'_>) -> bool {
  function eq (line 204) | fn eq(&self, other: &NameBuf<'_>) -> bool {
  function hash (line 212) | fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
  function equivalent (line 218) | fn equivalent(&self, key: &Name) -> bool {
  method equivalent (line 224) | fn equivalent(&self, key: &NameBuf<'_>) -> bool {

FILE: core/lib/src/form/name/key.rs
  type Key (line 29) | pub struct Key(str);
    method new (line 42) | pub fn new<S: AsRef<str> + ?Sized>(string: &S) -> &Key {
    method indices (line 59) | pub fn indices(&self) -> impl Iterator<Item = &str> {
    method as_str (line 73) | pub fn as_str(&self) -> &str {
    method serialize (line 87) | fn serialize<S>(&self, ser: S) -> Result<S::Ok, S::Error>
    type Output (line 103) | type Output = Key;
    method index (line 106) | fn index(&self, index: I) -> &Self::Output {
    method eq (line 112) | fn eq(&self, other: &str) -> bool {
    method fmt (line 143) | fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
  type Target (line 79) | type Target = str;
  method deref (line 81) | fn deref(&self) -> &Self::Target {
  function deserialize (line 95) | fn deserialize<D>(de: D) -> Result<Self, D::Error>
  function eq (line 118) | fn eq(&self, other: &Key) -> bool {
  function from (line 125) | fn from(string: &'a S) -> Self {
  function as_ref (line 131) | fn as_ref(&self) -> &Key {
  method as_ref (line 137) | fn as_ref(&self) -> &Key {

FILE: core/lib/src/form/name/name.rs
  type Name (line 30) | pub struct Name(str);
    method new (line 43) | pub fn new<S: AsRef<str> + ?Sized>(string: &S) -> &Name {
    method keys (line 60) | pub fn keys(&self) -> impl Iterator<Item = &Key> {
    method prefixes (line 96) | pub fn prefixes(&self) -> impl Iterator<Item = &Name> {
    method as_str (line 126) | pub fn as_str(&self) -> &str {
    method serialize (line 132) | fn serialize<S>(&self, ser: S) -> Result<S::Ok, S::Error>
    type Output (line 163) | type Output = Name;
    method index (line 166) | fn index(&self, index: I) -> &Self::Output {
    method eq (line 178) | fn eq(&self, other: &str) -> bool {
    method eq (line 190) | fn eq(&self, other: &&str) -> bool {
    method as_ref (line 214) | fn as_ref(&self) -> &Name {
    method hash (line 222) | fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
    method fmt (line 228) | fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
    method fmt (line 234) | fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
  function deserialize (line 140) | fn deserialize<D>(de: D) -> Result<Self, D::Error>
  function from (line 149) | fn from(string: &'a S) -> Self {
  type Target (line 155) | type Target = str;
  method deref (line 157) | fn deref(&self) -> &Self::Target {
  method eq (line 172) | fn eq(&self, other: &Self) -> bool {
  function eq (line 184) | fn eq(&self, other: &Name) -> bool {
  function eq (line 196) | fn eq(&self, other: &Name) -> bool {
  function as_ref (line 202) | fn as_ref(&self) -> &Name {
  method as_ref (line 208) | fn as_ref(&self) -> &Name {

FILE: core/lib/src/form/name/view.rs
  type NameView (line 79) | pub struct NameView<'v> {
  function new (line 98) | pub fn new<N: Into<&'v Name>>(name: N) -> Self {
  function shift (line 156) | pub fn shift(&mut self) {
  function key (line 210) | pub fn key(&self) -> Option<&'v Key> {
  function key_lossy (line 244) | pub fn key_lossy(&self) -> &'v Key {
  function as_name (line 271) | pub fn as_name(&self) -> &'v Name {
  function parent (line 293) | pub fn parent(&self) -> Option<&'v Name> {
  function source (line 320) | pub fn source(&self) -> &'v Name {
  function is_at_last (line 325) | fn is_at_last(&self) -> bool {
  function exhausted (line 330) | pub(crate) fn exhausted(&self) -> bool {
  function fmt (line 336) | fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
  function fmt (line 342) | fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
  function eq (line 348) | fn eq(&self, other: &NameView<'b>) -> bool {
  function eq (line 354) | fn eq(&self, other: &B) -> bool {
  function hash (line 362) | fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
  function borrow (line 368) | fn borrow(&self) -> &Name {

FILE: core/lib/src/form/options.rs
  type Options (line 5) | pub struct Options {
    constant Lenient (line 13) | pub const Lenient: Self = Options { strict: false };
    constant Strict (line 16) | pub const Strict: Self = Options { strict: true };

FILE: core/lib/src/form/parser.rs
  type Result (line 9) | type Result<'r, T> = std::result::Result<T, Error<'r>>;
  type Field (line 11) | type Field<'r, 'i> = Either<ValueField<'r>, DataField<'r, 'i>>;
  type MultipartParser (line 13) | pub struct MultipartParser<'r, 'i> {
  type RawStrParser (line 20) | pub struct RawStrParser<'r> {
  type Parser (line 25) | pub enum Parser<'r, 'i> {
  function new (line 31) | pub async fn new(
  function from_form (line 47) | async fn from_form(req: &'r Request<'i>, data: Data<'r>) -> Result<'r, P...
  function from_multipart (line 60) | async fn from_multipart(req: &'r Request<'i>, data: Data<'r>) -> Result<...
  function next (line 85) | pub async fn next(&mut self) -> Option<Result<'r, Field<'r, 'i>>> {
  function new (line 94) | pub fn new(buffer: &'r SharedStack<String>, source: &'r RawStr) -> Self {
  type Item (line 100) | type Item = ValueField<'r>;
  method next (line 102) | fn next(&mut self) -> Option<Self::Item> {
  function test_skips_empty (line 139) | fn test_skips_empty() {
  function test_decodes (line 146) | fn test_decodes() {
  function next (line 156) | async fn next(&mut self) -> Option<Result<'r, Field<'r, 'i>>> {

FILE: core/lib/src/form/strict.rs
  type Strict (line 57) | pub struct Strict<T>(T);
  function into_inner (line 86) | pub fn into_inner(self) -> T {
  type Context (line 93) | type Context = T::Context;
  function init (line 96) | fn init(_: Options) -> Self::Context {
  function push_value (line 101) | fn push_value(ctxt: &mut Self::Context, field: ValueField<'v>) {
  function push_data (line 106) | async fn push_data(ctxt: &mut Self::Context, field: DataField<'v, '_>) {
  function finalize (line 111) | fn finalize(this: Self::Context) -> Result<'v, Self> {
  type Target (line 117) | type Target = T;
  method deref (line 119) | fn deref(&self) -> &Self::Target {
  method deref_mut (line 125) | fn deref_mut(&mut self) -> &mut Self::Target {
  function from (line 132) | fn from(val: T) -> Strict<T> {
  type Target (line 138) | type Target = T::Target;
  function from_uri_param (line 141) | fn from_uri_param(param: A) -> Self::Target {

FILE: core/lib/src/form/tests.rs
  function parse (line 5) | fn parse<'v, T: FromForm<'v>>(values: &[&'v str]) -> Result<'v, T> {
  function time (line 66) | fn time() {
  function bool (line 80) | fn bool() {
  function defaults (line 96) | fn defaults() {
  function potpourri (line 123) | fn potpourri() {

FILE: core/lib/src/form/validate.rs
  function eq (line 189) | pub fn eq<'v, A, B>(a: &A, b: B) -> Result<'v, ()>
  function dbg_eq (line 226) | pub fn dbg_eq<'v, A, B>(a: &A, b: B) -> Result<'v, ()>
  function neq (line 266) | pub fn neq<'v, A, B>(a: &A, b: B) -> Result<'v, ()>
  type Len (line 290) | pub trait Len<L> {
    method len (line 292) | fn len(&self) -> L;
    method len_into_u64 (line 295) | fn len_into_u64(len: L) -> u64;
    method zero_len (line 298) | fn zero_len() -> L;
  function len (line 319) | fn len(&self) -> ByteUnit { self.len().into() }
  function len_into_u64 (line 320) | fn len_into_u64(len: ByteUnit) -> u64 { len.into() }
  function zero_len (line 321) | fn zero_len() -> ByteUnit { ByteUnit::from(0) }
  function len (line 325) | fn len(&self) -> L { <T as Len<L>>::len(self) }
  function len_into_u64 (line 326) | fn len_into_u64(len: L) -> u64 { T::len_into_u64(len) }
  function zero_len (line 327) | fn zero_len() -> L { T::zero_len() }
  function len (line 331) | fn len(&self) -> L { self.as_ref().map(|v| v.len()).unwrap_or_else(T::ze...
  function len_into_u64 (line 332) | fn len_into_u64(len: L) -> u64 { T::len_into_u64(len) }
  function zero_len (line 333) | fn zero_len() -> L { T::zero_len() }
  function len (line 337) | fn len(&self) -> L { self.value.len() }
  function len_into_u64 (line 338) | fn len_into_u64(len: L) -> u64 { T::len_into_u64(len) }
  function zero_len (line 339) | fn zero_len() -> L { T::zero_len() }
  function len (line 343) | fn len(&self) -> L { self.as_ref().ok().len() }
  function len_into_u64 (line 344) | fn len_into_u64(len: L) -> u64 { T::len_into_u64(len) }
  function zero_len (line 345) | fn zero_len() -> L { T::zero_len() }
  function len (line 350) | fn len(&self) -> L { self.0.len() }
  function len_into_u64 (line 351) | fn len_into_u64(len: L) -> u64 { T::len_into_u64(len) }
  function zero_len (line 352) | fn zero_len() -> L { T::zero_len() }
  function len (line 357) | fn len(&self) -> L { self.0.len() }
  function len_into_u64 (line 358) | fn len_into_u64(len: L) -> u64 { T::len_into_u64(len) }
  function zero_len (line 359) | fn zero_len() -> L { T::zero_len() }
  function len (line 396) | pub fn len<'v, V, L, R>(value: V, range: R) -> Result<'v, ()>
  type Contains (line 432) | pub trait Contains<I> {
    method contains (line 434) | fn contains(&self, item: I) -> bool;
  function coerce (line 451) | fn coerce<T, const N: usize>(slice: &[T; N]) -> &[T] {
  function contains (line 466) | fn contains(&self, f: F) -> bool {
  method contains (line 472) | fn contains(&self, f: F) -> bool {
  function contains (line 478) | fn contains(&self, item: T) -> bool {
  function contains (line 484) | fn contains(&self, item: I) -> bool {
  function contains (line 490) | fn contains(&self, item: I) -> bool {
  function contains (line 496) | fn contains(&self, item: I) -> bool {
  function contains (line 537) | pub fn contains<'v, V, I>(value: V, item: I) -> Result<'v, ()>
  function dbg_contains (line 576) | pub fn dbg_contains<'v, V, I>(value: V, item: I) -> Result<'v, ()>
  function omits (line 619) | pub fn omits<'v, V, I>(value: V, item: I) -> Result<'v, ()>
  function dbg_omits (line 660) | pub fn dbg_omits<'v, V, I>(value: V, item: I) -> Result<'v, ()>
  function range (line 690) | pub fn range<'v, V, R>(value: &V, range: R) -> Result<'v, ()>
  function one_of (line 742) | pub fn one_of<'v, V, I, R>(value: V, items: R) -> Result<'v, ()>
  function ext (line 790) | pub fn ext<'v>(file: &TempFile<'_>, r#type: ContentType) -> Result<'v, (...
  function with (line 847) | pub fn with<'v, V, F, M>(value: V, f: F, msg: M) -> Result<'v, ()>
  function try_with (line 886) | pub fn try_with<'v, V, F, T, E>(value: V, f: F) -> Result<'v, ()>

FILE: core/lib/src/fs/file_name.rs
  type FileName (line 29) | pub struct FileName(str);
    method new (line 45) | pub fn new<S: AsRef<str> + ?Sized>(string: &S) -> &FileName {
    method as_str (line 112) | pub fn as_str(&self) -> Option<&str> {
    method is_safe (line 191) | pub fn is_safe(&self) -> bool {
    method dangerous_unsafe_unsanitized_raw (line 234) | pub fn dangerous_unsafe_unsanitized_raw(&self) -> &RawStr {
  function from (line 241) | fn from(string: &'a S) -> Self {

FILE: core/lib/src/fs/named_file.rs
  type NamedFile (line 40) | pub struct NamedFile(PathBuf, File);
    method open (line 62) | pub async fn open<P: AsRef<Path>>(path: P) -> io::Result<NamedFile> {
    method open_with (line 71) | pub async fn open_with<P: AsRef<Path>>(path: P, opts: &OpenOptions) ->...
    method file (line 90) | pub fn file(&self) -> &File {
    method file_mut (line 108) | pub fn file_mut(&mut self) -> &mut File {
    method take_file (line 126) | pub fn take_file(self) -> File {
    method path (line 144) | pub fn path(&self) -> &Path {
    method respond_to (line 155) | fn respond_to(self, req: &'r Request<'_>) -> response::Result<'static> {
  type Target (line 168) | type Target = File;
  method deref (line 170) | fn deref(&self) -> &File {
  method deref_mut (line 176) | fn deref_mut(&mut self) -> &mut File {

FILE: core/lib/src/fs/rewrite.rs
  type Rewriter (line 22) | pub trait Rewriter: Send + Sync + 'static {
    method rewrite (line 24) | fn rewrite<'r>(&self, opt: Option<Rewrite<'r>>, req: &'r Request<'_>) ...
    method rewrite (line 134) | fn rewrite<'r>(&self, opt: Option<Rewrite<'r>>, _: &Request<'_>) -> Op...
    method rewrite (line 143) | fn rewrite<'r>(&self, _: Option<Rewrite<'r>>, _: &Request<'_>) -> Opti...
    method rewrite (line 165) | fn rewrite<'r>(&self, opt: Option<Rewrite<'r>>, req: &Request<'_>) -> ...
    method rewrite (line 210) | fn rewrite<'r>(&self, opt: Option<Rewrite<'r>>, _: &Request<'_>) -> Op...
    method rewrite (line 240) | fn rewrite<'r>(&self, f: Option<Rewrite<'r>>, r: &Request<'_>) -> Opti...
    method rewrite (line 246) | fn rewrite<'r>(&self, _: Option<Rewrite<'r>>, _: &Request<'_>) -> Opti...
    method rewrite (line 252) | fn rewrite<'r>(&self, _: Option<Rewrite<'r>>, _: &Request<'_>) -> Opti...
    method rewrite (line 258) | fn rewrite<'r>(&self, _: Option<Rewrite<'r>>, _: &Request<'_>) -> Opti...
  type Rewrite (line 30) | pub enum Rewrite<'r> {
  type File (line 40) | pub struct File<'r> {
  function new (line 49) | pub fn new(path: impl Into<Cow<'r, Path>>) -> Self {
  function checked (line 58) | pub fn checked<P: AsRef<Path>>(path: P) -> Self {
  function map_path (line 71) | pub fn map_path<F, P>(self, f: F) -> Self
  function is_hidden (line 88) | pub fn is_hidden(&self) -> bool {
  function is_visible (line 94) | pub fn is_visible(&self) -> bool {
  type Prefix (line 111) | pub struct Prefix(PathBuf);
    method checked (line 115) | pub fn checked<P: AsRef<Path>>(path: P) -> Self {
    method unchecked (line 128) | pub fn unchecked<P: AsRef<Path>>(path: P) -> Self {
  type TrailingDirs (line 162) | pub struct TrailingDirs;
  type DirIndex (line 192) | pub struct DirIndex {
    method unconditional (line 199) | pub fn unconditional(path: impl AsRef<Path>) -> Self {
    method if_exists (line 204) | pub fn if_exists(path: impl AsRef<Path>) -> Self {
  function from (line 226) | fn from(value: File<'r>) -> Self {
  function from (line 232) | fn from(value: Redirect) -> Self {

FILE: core/lib/src/fs/server.rs
  type FileServer (line 85) | pub struct FileServer {
    constant DEFAULT_RANK (line 92) | const DEFAULT_RANK: isize = 10;
    method new (line 123) | pub fn new<P: AsRef<Path>>(path: P) -> Self {
    method without_index (line 160) | pub fn without_index<P: AsRef<Path>>(path: P) -> Self {
    method identity (line 196) | pub fn identity() -> Self {
    method rank (line 213) | pub fn rank(mut self, rank: isize) -> Self {
    method rewrite (line 242) | pub fn rewrite<R: Rewriter>(mut self, rewriter: R) -> Self {
    method filter (line 268) | pub fn filter<F: Send + Sync + 'static>(self, f: F) -> Self
    method map (line 308) | pub fn map<F: Send + Sync + 'static>(self, f: F) -> Self
    method fmt (line 359) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  function from (line 329) | fn from(server: FileServer) -> Self {
  method handle (line 338) | async fn handle<'r>(&self, req: &'r Request<'_>, data: Data<'r>) -> Outc...
  function open (line 368) | async fn open(self) -> std::io::Result<NamedFile<'r>> {
  type NamedFile (line 384) | struct NamedFile<'r> {
  function respond_to (line 393) | fn respond_to(self, _: &'r Request<'_>) -> response::Result<'r> {

FILE: core/lib/src/fs/temp_file.rs
  type TempFile (line 103) | pub enum TempFile<'v> {
  function persist_to (line 166) | pub async fn persist_to<P>(&mut self, path: P) -> io::Result<()>
  function copy_to (line 238) | pub async fn copy_to<P>(&mut self, path: P) -> io::Result<()>
  function move_copy_to (line 302) | pub async fn move_copy_to<P>(&mut self, path: P) -> io::Result<()>
  function open (line 340) | pub async fn open(&self) -> io::Result<impl AsyncBufRead + '_> {
  function is_empty (line 376) | pub fn is_empty(&self) -> bool {
  function len (line 393) | pub fn len(&self) -> u64 {
  function path (line 424) | pub fn path(&self) -> Option<&Path> {
  function name (line 462) | pub fn name(&self) -> Option<&str> {
  function raw_name (line 477) | pub fn raw_name(&self) -> Option<&FileName> {
  function content_type (line 499) | pub fn content_type(&self) -> Option<&ContentType> {
  function from (line 506) | async fn from<'a>(
  function from_value (line 540) | fn from_value(field: ValueField<'v>) -> Result<Self, Errors<'v>> {
  function from_data (line 545) | async fn from_data(
  type Error (line 554) | type Error = io::Error;
  function from_data (line 556) | async fn from_data(req: &'r Request<'_>, data: Data<'r>) -> data::Outcom...

FILE: core/lib/src/http/cookies.rs
  type CookieJar (line 153) | pub struct CookieJar<'a> {
  type CookieState (line 160) | pub(crate) struct CookieState<'a> {
  type Op (line 167) | enum Op {
    method cookie (line 595) | fn cookie(&self) -> &Cookie<'static> {
  function new (line 173) | pub(crate) fn new(base: Option<cookie::CookieJar>, rocket: &'a Rocket<Or...
  function get (line 203) | pub fn get(&self, name: &str) -> Option<&Cookie<'static>> {
  function get_private (line 229) | pub fn get_private(&self, name: &str) -> Option<Cookie<'static>> {
  function get_pending (line 253) | pub fn get_pending(&self, name: &str) -> Option<Cookie<'static>> {
  function add (line 305) | pub fn add<C: Into<Cookie<'static>>>(&self, cookie: C) {
  function add_private (line 345) | pub fn add_private<C: Into<Cookie<'static>>>(&self, cookie: C) {
  function remove (line 388) | pub fn remove<C: Into<Cookie<'static>>>(&self, cookie: C) {
  function remove_private (line 431) | pub fn remove_private<C: Into<Cookie<'static>>>(&self, cookie: C) {
  function iter (line 456) | pub fn iter(&self) -> impl Iterator<Item=&Cookie<'static>> {
  function reset_delta (line 462) | pub(crate) fn reset_delta(&self) {
  function take_delta_jar (line 468) | pub(crate) fn take_delta_jar(&self) -> cookie::CookieJar {
  function add_original (line 497) | pub(crate) fn add_original(&mut self, cookie: Cookie<'static>) {
  function add_original_private (line 505) | pub(crate) fn add_original_private(&mut self, cookie: Cookie<'static>) {
  function set_defaults (line 516) | fn set_defaults(&self, cookie: &mut Cookie<'static>) {
  function set_removal_defaults (line 535) | fn set_removal_defaults(cookie: &mut Cookie<'static>) {
  function set_private_defaults (line 556) | fn set_private_defaults(&self, cookie: &mut Cookie<'static>) {
  function fmt (line 570) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  method clone (line 585) | fn clone(&self) -> Self {

FILE: core/lib/src/lib.rs
  constant WORKER_PREFIX (line 212) | const WORKER_PREFIX: &str = "rocket-worker";
  function build (line 216) | pub fn build() -> Rocket<Build> {
  function custom (line 222) | pub fn custom<T: figment::Provider>(provider: T) -> Rocket<Build> {
  function async_run (line 228) | pub fn async_run<F, R>(fut: F, workers: usize, sync: usize, force_end: b...
  function async_test (line 249) | pub fn async_test<R>(fut: impl std::future::Future<Output = R>) -> R {
  function async_main (line 255) | pub fn async_main<R>(fut: impl std::future::Future<Output = R> + Send) -...
  function execute (line 352) | pub fn execute<R, F>(future: F) -> R
  function running_within_rocket_async_rt (line 360) | fn running_within_rocket_async_rt() -> impl std::future::Future<Output =...

FILE: core/lib/src/lifecycle.rs
  type RequestToken (line 12) | pub(crate) struct RequestToken;
  function catch_handle (line 14) | async fn catch_handle<Fut, T, F>(name: Option<&str>, run: F) -> Option<T>
  function preprocess (line 54) | pub(crate) async fn preprocess(
  function dispatch (line 91) | pub(crate) async fn dispatch<'r, 's: 'r>(
  function extract_io_handler (line 159) | pub(crate) fn extract_io_handler<'r>(
  function route (line 197) | async fn route<'s, 'r: 's>(
  function dispatch_error (line 234) | pub(crate) async fn dispatch_error<'r, 's: 'r>(
  function invoke_catcher (line 270) | async fn invoke_catcher<'s, 'r: 's>(

FILE: core/lib/src/listener/bind.rs
  type Bind (line 6) | pub trait Bind: Listener + 'static {
    method bind (line 10) | async fn bind(rocket: &Rocket<Ignite>) -> Result<Self, Self::Error>;
    method bind_endpoint (line 12) | fn bind_endpoint(to: &Rocket<Ignite>) -> Result<Endpoint, Self::Error>;

FILE: core/lib/src/listener/bounced.rs
  type Bounced (line 7) | pub struct Bounced<L> {
  type BouncedExt (line 11) | pub trait BouncedExt: Sized {
    method bounced (line 12) | fn bounced(self) -> Bounced<Self> {
  function is_recoverable (line 19) | fn is_recoverable(e: &io::Error) -> bool {
  function accept_next (line 28) | pub async fn accept_next(&self) -> <Self as Listener>::Accept {
  type Accept (line 43) | type Accept = L::Accept;
  type Connection (line 45) | type Connection = L::Connection;
  method accept (line 47) | async fn accept(&self) -> io::Result<Self::Accept> {
  method connect (line 51) | async fn connect(&self, accept: Self::Accept) -> io::Result<Self::Connec...
  method endpoint (line 55) | fn endpoint(&self) -> io::Result<Endpoint> {

FILE: core/lib/src/listener/cancellable.rs
  type State (line 24) | enum State {
  type CancellableExt (line 33) | pub trait CancellableExt: Sized {
    method cancellable (line 34) | fn cancellable(self, stages: Stages) -> Cancellable<Self> {
  function time_out (line 45) | fn time_out() -> io::Error {
  function gone (line 49) | fn gone() -> io::Error {
  function inner (line 54) | pub fn inner(&self) -> Option<&I> {
  type AsyncCancel (line 59) | pub trait AsyncCancel {
    method poll_cancel (line 60) | fn poll_cancel(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<io:...
    method poll_cancel (line 64) | fn poll_cancel(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<io:...
  function poll_with (line 71) | pub fn poll_with<T>(
  method poll_read (line 117) | fn poll_read(
  method poll_write (line 127) | fn poll_write(
  method poll_flush (line 135) | fn poll_flush(
  method poll_shutdown (line 142) | fn poll_shutdown(
  method poll_write_vectored (line 149) | fn poll_write_vectored(
  method is_write_vectored (line 157) | fn is_write_vectored(&self) -> bool {
  type Item (line 163) | type Item = I::Item;
  method poll_next (line 165) | fn poll_next(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<...

FILE: core/lib/src/listener/connection.rs
  type Certificates (line 11) | pub struct Certificates<'r>(Cow<'r, [der::CertificateDer<'r>]>);
  type Connection (line 13) | pub trait Connection: AsyncRead + AsyncWrite + Send + Unpin {
    method endpoint (line 14) | fn endpoint(&self) -> io::Result<Endpoint>;
    method certificates (line 24) | fn certificates(&self) -> Option<Certificates<'_>> { None }
    method server_name (line 26) | fn server_name(&self) -> Option<&str> { None }
    method endpoint (line 30) | fn endpoint(&self) -> io::Result<Endpoint> {
    method certificates (line 37) | fn certificates(&self) -> Option<Certificates<'_>> {
  function into_owned (line 46) | pub fn into_owned(self) -> Certificates<'static> {
  function inner (line 64) | pub(crate) fn inner(&self) -> &[CertificateDer<'r>] {
  function from (line 70) | fn from(value: &'r [CertificateDer<'r>]) -> Self {
  function from (line 76) | fn from(value: Vec<CertificateDer<'static>>) -> Self {
  type CertificateDer (line 88) | pub struct CertificateDer<'r>(PhantomData<&'r [u8]>);
  function into_owned (line 91) | pub fn into_owned(self) -> CertificateDer<'static> {

FILE: core/lib/src/listener/default.rs
  type TlsListener (line 17) | type TlsListener<T> = super::TlsListener<T>;
  type TlsListener (line 18) | type TlsListener<T> = T;
  type UnixListener (line 19) | type UnixListener = super::UnixListener;
  type UnixListener (line 20) | type UnixListener = TcpListener;
  type Listener (line 22) | pub type Listener = Either<
  type DefaultListener (line 59) | pub struct DefaultListener(());
    type Accept (line 85) | type Accept = Connection;
    type Connection (line 86) | type Connection = Connection;
    method accept (line 88) | async fn accept(&self) -> std::io::Result<Connection>  { unreachable!() }
    method connect (line 90) | async fn connect(&self, _: Self::Accept) -> std::io::Result<Connection...
    method endpoint (line 92) | fn endpoint(&self) -> std::io::Result<Endpoint> { unreachable!() }
  type Config (line 63) | struct Config {
  type Connection (line 74) | type Connection = crate::listener::tcp::TcpStream;
  type Error (line 78) | type Error = Error;
  method bind (line 79) | async fn bind(_: &Rocket<Ignite>) -> Result<Self, Error>  { unreachable!...
  method bind_endpoint (line 80) | fn bind_endpoint(_: &Rocket<Ignite>) -> Result<Endpoint, Error> { unreac...
  type DefaultListener (line 96) | pub type DefaultListener = private::Listener;
    type Accept (line 85) | type Accept = Connection;
    type Connection (line 86) | type Connection = Connection;
    method accept (line 88) | async fn accept(&self) -> std::io::Result<Connection>  { unreachable!() }
    method connect (line 90) | async fn connect(&self, _: Self::Accept) -> std::io::Result<Connection...
    method endpoint (line 92) | fn endpoint(&self) -> std::io::Result<Endpoint> { unreachable!() }
  type Error (line 100) | type Error = Error;
  method bind (line 102) | async fn bind(rocket: &Rocket<Ignite>) -> Result<Self, Self::Error> {
  method bind_endpoint (line 128) | fn bind_endpoint(rocket: &Rocket<Ignite>) -> Result<Endpoint, Self::Erro...
  type Error (line 135) | pub enum Error {
    method from (line 144) | fn from(value: figment::Error) -> Self {
    method from (line 150) | fn from(value: std::io::Error) -> Self {
    method from (line 157) | fn from(value: crate::tls::Error) -> Self {
    method from (line 163) | fn from(value: Either<figment::Error, std::io::Error>) -> Self {
    method fmt (line 169) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
    method source (line 181) | fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {

FILE: core/lib/src/listener/endpoint.rs
  type TlsInfo (line 13) | type TlsInfo = Option<Box<crate::tls::TlsConfig>>;
  type TlsInfo (line 14) | type TlsInfo = Option<()>;
  type CustomEndpoint (line 16) | pub trait CustomEndpoint: fmt::Display + fmt::Debug + Sync + Send + Any { }
  type Endpoint (line 43) | pub enum Endpoint {
    method new (line 52) | pub fn new<T: CustomEndpoint>(value: T) -> Endpoint {
    method tcp (line 56) | pub fn tcp(&self) -> Option<net::SocketAddr> {
    method quic (line 64) | pub fn quic(&self) -> Option<net::SocketAddr> {
    method socket_addr (line 72) | pub fn socket_addr(&self) -> Option<net::SocketAddr> {
    method ip (line 81) | pub fn ip(&self) -> Option<IpAddr> {
    method port (line 90) | pub fn port(&self) -> Option<u16> {
    method unix (line 99) | pub fn unix(&self) -> Option<&Path> {
    method tls (line 107) | pub fn tls(&self) -> Option<&Endpoint> {
    method tls_config (line 115) | pub fn tls_config(&self) -> Option<&crate::tls::TlsConfig> {
    method mtls_config (line 123) | pub fn mtls_config(&self) -> Option<&crate::mtls::MtlsConfig> {
    method downcast (line 130) | pub fn downcast<T: 'static>(&self) -> Option<&T> {
    method is_tcp (line 140) | pub fn is_tcp(&self) -> bool {
    method is_quic (line 144) | pub fn is_quic(&self) -> bool {
    method is_unix (line 148) | pub fn is_unix(&self) -> bool {
    method is_tls (line 152) | pub fn is_tls(&self) -> bool {
    method with_tls (line 157) | pub fn with_tls(self, tls: &crate::tls::TlsConfig) -> Endpoint {
    method assume_tls (line 165) | pub fn assume_tls(self) -> Endpoint {
    method fetch (line 180) | pub(crate) fn fetch<T, F>(figment: &Figment, kind: &str, path: &str, f...
    method fmt (line 198) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
    method fmt (line 224) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
    method deserialize (line 262) | fn deserialize<D: de::Deserializer<'de>>(de: D) -> Result<Self, D::Err...
    method eq (line 297) | fn eq(&self, other: &PathBuf) -> bool {
    method eq (line 303) | fn eq(&self, other: &Path) -> bool {
    type Error (line 310) | type Error = std::io::Error;
    method try_from (line 312) | fn try_from(v: tokio::net::unix::SocketAddr) -> Result<Self, Self::Err...
    type Error (line 320) | type Error = AddrParseError;
    method try_from (line 322) | fn try_from(value: &str) -> Result<Self, Self::Error> {
  method default (line 236) | fn default() -> Self {
  type Err (line 242) | type Err = AddrParseError;
  method from_str (line 244) | fn from_str(string: &str) -> Result<Self, Self::Err> {
  method eq (line 284) | fn eq(&self, other: &Self) -> bool {

FILE: core/lib/src/listener/listener.rs
  type Listener (line 8) | pub trait Listener: Sized + Send + Sync {
    method accept (line 14) | async fn accept(&self) -> io::Result<Self::Accept>;
    method connect (line 17) | async fn connect(&self, accept: Self::Accept) -> io::Result<Self::Conn...
    method endpoint (line 19) | fn endpoint(&self) -> io::Result<Endpoint>;
    type Accept (line 23) | type Accept = L::Accept;
    type Connection (line 25) | type Connection = L::Connection;
    method accept (line 27) | async fn accept(&self) -> io::Result<Self::Accept> {
    method connect (line 31) | async fn connect(&self, accept: Self::Accept) -> io::Result<Self::Conn...
    method endpoint (line 35) | fn endpoint(&self) -> io::Result<Endpoint> {
    type Accept (line 41) | type Accept = Either<A::Accept, B::Accept>;
    type Connection (line 43) | type Connection = Either<A::Connection, B::Connection>;
    method accept (line 45) | async fn accept(&self) -> io::Result<Self::Accept> {
    method connect (line 52) | async fn connect(&self, accept: Self::Accept) -> io::Result<Self::Conn...
    method endpoint (line 60) | fn endpoint(&self) -> io::Result<Endpoint> {

FILE: core/lib/src/listener/quic.rs
  type H3Conn (line 43) | type H3Conn = h3::server::Connection<quic_h3::Connection, bytes::Bytes>;
  type QuicListener (line 45) | pub struct QuicListener {
    method bind (line 67) | pub async fn bind(address: SocketAddr, tls: TlsConfig) -> Result<Self,...
    method accept (line 100) | pub async fn accept(&self) -> Option<quic::Connection> {
    method connect (line 106) | pub async fn connect(&self, accept: quic::Connection) -> io::Result<H3...
    method endpoint (line 113) | pub fn endpoint(&self) -> io::Result<Endpoint> {
  type H3Stream (line 51) | pub struct H3Stream(H3Conn, quic::connection::Result<SocketAddr>);
    method accept (line 119) | pub async fn accept(&mut self) -> io::Result<Option<H3Connection>> {
    method fmt (line 200) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  type H3Connection (line 53) | pub struct H3Connection {
    method endpoint (line 161) | pub fn endpoint(&self) -> io::Result<Endpoint> {
    method fmt (line 206) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  type QuicRx (line 61) | pub struct QuicRx(h3::server::RequestStream<quic_h3::RecvStream, Bytes>);
  type QuicTx (line 64) | pub struct QuicTx(h3::server::RequestStream<quic_h3::SendStream<Bytes>, ...
    method send_response (line 138) | pub async fn send_response<S>(&mut self, response: http::Response<S>) ...
    method cancel (line 154) | pub fn cancel(&mut self) {
  type Item (line 178) | type Item = io::Result<Bytes>;
  method poll_next (line 180) | fn poll_next(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Opt...
  method poll_cancel (line 192) | fn poll_cancel(mut self: Pin<&mut Self>, _: &mut Context<'_>) -> Poll<io...

FILE: core/lib/src/listener/tcp.rs
  type Error (line 24) | type Error = Either<figment::Error, io::Error>;
  method bind (line 26) | async fn bind(rocket: &Rocket<Ignite>) -> Result<Self, Self::Error> {
  method bind_endpoint (line 35) | fn bind_endpoint(rocket: &Rocket<Ignite>) -> Result<Endpoint, Self::Erro...
  type Accept (line 52) | type Accept = Self::Connection;
  type Connection (line 54) | type Connection = TcpStream;
  method accept (line 56) | async fn accept(&self) -> io::Result<Self::Accept> {
  method connect (line 63) | async fn connect(&self, conn: Self::Connection) -> io::Result<Self::Conn...
  method endpoint (line 67) | fn endpoint(&self) -> io::Result<Endpoint> {
  method endpoint (line 73) | fn endpoint(&self) -> io::Result<Endpoint> {

FILE: core/lib/src/listener/unix.rs
  type UnixListener (line 25) | pub struct UnixListener {
    method bind (line 32) | pub async fn bind<P: AsRef<Path>>(path: P, reuse: bool) -> io::Result<...
  type Error (line 76) | type Error = Either<figment::Error, io::Error>;
  method bind (line 78) | async fn bind(rocket: &Rocket<Ignite>) -> Result<Self, Self::Error> {
  method bind_endpoint (line 90) | fn bind_endpoint(rocket: &Rocket<Ignite>) -> Result<Endpoint, Self::Erro...
  type Accept (line 99) | type Accept = UnixStream;
  type Connection (line 101) | type Connection = Self::Accept;
  method accept (line 103) | async fn accept(&self) -> io::Result<Self::Accept> {
  method connect (line 107) | async fn connect(&self, accept:Self::Accept) -> io::Result<Self::Connect...
  method endpoint (line 111) | fn endpoint(&self) -> io::Result<Endpoint> {
  method endpoint (line 117) | fn endpoint(&self) -> io::Result<Endpoint> {
  method drop (line 123) | fn drop(&mut self) {

FILE: core/lib/src/local/asynchronous/client.rs
  type Client (line 50) | pub struct Client {
    method _new (line 57) | pub(crate) async fn _new<P: Phase>(
    method _test (line 75) | pub fn _test<T, F>(f: F) -> T
    method _rocket (line 87) | pub(crate) fn _rocket(&self) -> &Rocket<Orbit> {
    method _with_raw_cookies (line 92) | pub(crate) fn _with_raw_cookies<F, T>(&self, f: F) -> T
    method _with_raw_cookies_mut (line 99) | pub(crate) fn _with_raw_cookies_mut<F, T>(&self, f: F) -> T
    method _req (line 106) | fn _req<'c, 'u: 'c, U>(&'c self, method: Method, uri: U) -> LocalReque...
    method _terminate (line 112) | pub(crate) async fn _terminate(self) -> Rocket<Ignite> {
    method fmt (line 124) | fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
  function test_local_client_impl_send_sync (line 132) | fn test_local_client_impl_send_sync() {

FILE: core/lib/src/local/asynchronous/request.rs
  type LocalRequest (line 35) | pub struct LocalRequest<'c> {
  function new (line 44) | pub(crate) fn new<'u: 'c, U>(client: &'c Client, method: Method, uri: U)...
  function override_version (line 68) | pub fn override_version(&mut self, version: HttpVersion) {
  function _request (line 72) | pub(crate) fn _request(&self) -> &Request<'c> {
  function _request_mut (line 76) | pub(crate) fn _request_mut(&mut self) -> &mut Request<'c> {
  function _body_mut (line 80) | pub(crate) fn _body_mut(&mut self) -> &mut Vec<u8> {
  function _dispatch (line 85) | async fn _dispatch(mut self) -> LocalResponse<'c> {
  method clone (line 134) | fn clone(&self) -> Self {
  function fmt (line 145) | fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
  type Target (line 151) | type Target = Request<'c>;
  function deref (line 153) | fn deref(&self) -> &Self::Target {
  function deref_mut (line 159) | fn deref_mut(&mut self) -> &mut Self::Target {

FILE: core/lib/src/local/asynchronous/response.rs
  type LocalResponse (line 55) | pub struct LocalResponse<'c> {
  method drop (line 63) | fn drop(&mut self) { }
  function new (line 67) | pub(crate) fn new<F, O>(req: Request<'c>, f: F) -> impl Future<Output = ...
  function _response (line 112) | pub(crate) fn _response(&self) -> &Response<'_> {
  function _cookies (line 116) | pub(crate) fn _cookies(&self) -> &CookieJar<'_> {
  function _into_string (line 120) | pub(crate) async fn _into_string(mut self) -> io::Result<String> {
  function _into_bytes (line 124) | pub(crate) async fn _into_bytes(mut self) -> io::Result<Vec<u8>> {
  function _into_json (line 129) | async fn _into_json<T>(self) -> Option<T>
  function _into_msgpack (line 136) | async fn _into_msgpack<T>(self) -> Option<T>
  function blocking_read (line 143) | async fn blocking_read<T, F>(mut self, f: F) -> Option<T>
  method poll_read (line 204) | fn poll_read(
  function fmt (line 214) | fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {

FILE: core/lib/src/local/blocking/client.rs
  type Client (line 27) | pub struct Client {
    method _new (line 33) | fn _new<P: Phase>(rocket: Rocket<P>, tracked: bool, secure: bool) -> R...
    method _test (line 48) | pub fn _test<T, F>(f: F) -> T
    method inner (line 58) | pub(crate) fn inner(&self) -> &asynchronous::Client {
    method block_on (line 63) | pub(crate) fn block_on<F, R>(&self, fut: F) -> R
    method _rocket (line 70) | fn _rocket(&self) -> &Rocket<Orbit> {
    method _with_raw_cookies (line 75) | pub(crate) fn _with_raw_cookies<F, T>(&self, f: F) -> T
    method _terminate (line 81) | pub(crate) fn _terminate(mut self) -> Rocket<Ignite> {
    method _req (line 91) | fn _req<'c, 'u: 'c, U>(&'c self, method: Method, uri: U) -> LocalReque...
    method fmt (line 102) | fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
  method drop (line 108) | fn drop(&mut self) {
  function test_not_sync (line 124) | fn test_not_sync() {}

FILE: core/lib/src/local/blocking/request.rs
  type LocalRequest (line 33) | pub struct LocalRequest<'c> {
  function new (line 40) | pub(crate) fn new<'u: 'c, U>(client: &'c Client, method: Method, uri: U)...
  function override_version (line 48) | pub fn override_version(&mut self, version: HttpVersion) {
  function _request (line 53) | fn _request(&self) -> &Request<'c> {
  function _request_mut (line 58) | fn _request_mut(&mut self) -> &mut Request<'c> {
  function _body_mut (line 62) | fn _body_mut(&mut self) -> &mut Vec<u8> {
  function _dispatch (line 66) | fn _dispatch(self) -> LocalResponse<'c> {
  function fmt (line 76) | fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
  type Target (line 82) | type Target = Request<'c>;
  function deref (line 84) | fn deref(&self) -> &Self::Target {
  function deref_mut (line 90) | fn deref_mut(&mut self) -> &mut Self::Target {

FILE: core/lib/src/local/blocking/response.rs
  type LocalResponse (line 52) | pub struct LocalResponse<'c> {
  function _response (line 58) | fn _response(&self) -> &Response<'_> {
  function _cookies (line 62) | pub(crate) fn _cookies(&self) -> &CookieJar<'_> {
  function _into_string (line 66) | fn _into_string(self) -> io::Result<String> {
  function _into_bytes (line 70) | fn _into_bytes(self) -> io::Result<Vec<u8>> {
  function _into_json (line 75) | fn _into_json<T: Send + 'static>(self) -> Option<T>
  function _into_msgpack (line 82) | fn _into_msgpack<T: Send + 'static>(self) -> Option<T>
  function read (line 94) | fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
  function fmt (line 100) | fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {

FILE: core/lib/src/mtls/certificate.rs
  type Certificate (line 103) | pub struct Certificate<'a> {
  type Error (line 112) | type Error = Error;
  function from_request (line 114) | async fn from_request(req: &'r Request<'_>) -> Outcome<Self, Self::Error> {
  function parse (line 129) | fn parse<'r>(chain: &'r [CertificateDer<'r>]) -> Result<Certificate<'r>> {
  function parse_one (line 135) | fn parse_one(raw: &[u8]) -> Result<x509::X509Certificate<'_>> {
  function inner (line 161) | fn inner(&self) -> &x509::TbsCertificate<'a> {
  function serial (line 179) | pub fn serial(&self) -> &bigint::BigUint {
  function version (line 197) | pub fn version(&self) -> u32 {
  function subject (line 218) | pub fn subject(&self) -> &Name<'a> {
  function issuer (line 239) | pub fn issuer(&self) -> &Name<'a> {
  function extensions (line 270) | pub fn extensions(&self) -> &[x509::X509Extension<'a>] {
  function has_serial (line 295) | pub fn has_serial(&self, number: &str) -> Option<bool> {
  function as_bytes (line 321) | pub fn as_bytes(&self) -> &'a [u8] {
  type Target (line 327) | type Target = x509::TbsCertificate<'a>;
  function deref (line 329) | fn deref(&self) -> &Self::Target {

FILE: core/lib/src/mtls/config.rs
  type MtlsConfig (line 62) | pub struct MtlsConfig {
    method from_path (line 95) | pub fn from_path<C: AsRef<std::path::Path>>(ca_certs: C) -> Self {
    method from_bytes (line 117) | pub fn from_bytes(ca_certs: &[u8]) -> Self {
    method mandatory (line 140) | pub fn mandatory(mut self, mandatory: bool) -> Self {
    method ca_certs (line 156) | pub fn ca_certs(&self) -> either::Either<std::path::PathBuf, &[u8]> {
    method ca_certs_reader (line 164) | pub fn ca_certs_reader(&self) -> io::Result<Box<dyn io::BufRead + Sync...
    method load_ca_certs (line 169) | pub(crate) fn load_ca_certs(&self) -> Result<rustls::RootCertStore> {
  function test_mtls_config (line 187) | fn test_mtls_config() {

FILE: core/lib/src/mtls/error.rs
  type Error (line 26) | pub enum Error {
    method fmt (line 45) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
    method from (line 58) | fn from(e: nom::Err<x509::X509Error>) -> Self {
    method source (line 68) | fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {

FILE: core/lib/src/mtls/mod.rs
  type Result (line 44) | pub type Result<T, E = Error> = std::result::Result<T, E>;

FILE: core/lib/src/mtls/name.rs
  type Name (line 17) | pub struct Name<'a>(X509Name<'a>);
  function common_name (line 38) | pub fn common_name(&self) -> Option<&'a str> {
  function common_names (line 63) | pub fn common_names(&self) -> impl Iterator<Item = &'a str> + '_ {
  function email (line 85) | pub fn email(&self) -> Option<&'a str> {
  function emails (line 110) | pub fn emails(&self) -> impl Iterator<Item = &'a str> + '_ {
  function is_empty (line 132) | pub fn is_empty(&self) -> bool {
  type Target (line 138) | type Target = X509Name<'a>;
  method deref (line 140) | fn deref(&self) -> &Self::Target {
  function fmt (line 146) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {

FILE: core/lib/src/outcome.rs
  type Outcome (line 101) | pub enum Outcome<S, E, F> {
  function unwrap (line 128) | pub fn unwrap(self) -> S {
  function expect (line 152) | pub fn expect(self, message: &str) -> S {
  function is_success (line 177) | pub fn is_success(&self) -> bool {
  function is_error (line 199) | pub fn is_error(&self) -> bool {
  function is_forward (line 221) | pub fn is_forward(&self) -> bool {
  function succeeded (line 244) | pub fn succeeded(self) -> Option<S> {
  function failed (line 270) | pub fn failed(self) -> Option<E> {
  function forwarded (line 296) | pub fn forwarded(self) -> Option<F> {
  function success_or (line 324) | pub fn success_or<T>(self, value: T) -> Result<S, T> {
  function success_or_else (line 353) | pub fn success_or_else<T, V: FnOnce() -> T>(self, f: V) -> Result<S, T> {
  function as_ref (line 373) | pub fn as_ref(&self) -> Outcome<&S, &E, &F> {
  function as_mut (line 395) | pub fn as_mut(&mut self) -> Outcome<&mut S, &mut E, &mut F> {
  function map (line 417) | pub fn map<T, M: FnOnce(S) -> T>(self, f: M) -> Outcome<T, E, F> {
  function map_error (line 439) | pub fn map_error<T, M: FnOnce(E) -> T>(self, f: M) -> Outcome<S, T, F> {
  function map_forward (line 461) | pub fn map_forward<T, M: FnOnce(F) -> T>(self, f: M) -> Outcome<S, E, T> {
  function and_then (line 491) | pub fn and_then<T, M: FnOnce(S) -> Outcome<T, E, F>>(self, f: M) -> Outc...
  function error_then (line 521) | pub fn error_then<T, M: FnOnce(E) -> Outcome<S, T, F>>(self, f: M) -> Ou...
  function forward_then (line 551) | pub fn forward_then<T, M: FnOnce(F) -> Outcome<S, E, T>>(self, f: M) -> ...
  function ok_map_forward (line 577) | pub fn ok_map_forward<M>(self, f: M) -> Result<S, E>
  function ok_map_error (line 605) | pub fn ok_map_error<M>(self, f: M) -> Result<S, F>
  function pin (line 621) | pub fn pin(self) -> futures::future::BoxFuture<'a, Self> {
  type IntoOutcome (line 710) | pub trait IntoOutcome<Outcome> {
    method or_error (line 720) | fn or_error(self, error: Self::Error) -> Outcome;
    method or_forward (line 725) | fn or_forward(self, forward: Self::Forward) -> Outcome;
  type Error (line 729) | type Error = E;
  type Forward (line 730) | type Forward = F;
  function or_error (line 733) | fn or_error(self, error: E) -> Outcome<S, E, F> {
  function or_forward (line 741) | fn or_forward(self, forward: F) -> Outcome<S, E, F> {
  type Error (line 750) | type Error = Status;
  type Forward (line 751) | type Forward = (Data<'r>, Status);
  function or_error (line 754) | fn or_error(self, error: Status) -> data::Outcome<'r, T> {
  function or_forward (line 762) | fn or_forward(self, (data, forward): (Data<'r>, Status)) -> data::Outcom...
  type Error (line 771) | type Error = Status;
  type Forward (line 772) | type Forward = Status;
  function or_error (line 775) | fn or_error(self, error: Status) -> request::Outcome<S, E> {
  function or_forward (line 783) | fn or_forward(self, status: Status) -> request::Outcome<S, E> {
  type Error (line 792) | type Error = ();
  type Forward (line 793) | type Forward = (Data<'r>, Status);
  function or_error (line 796) | fn or_error(self, _: ()) -> route::Outcome<'r> {
  function or_forward (line 804) | fn or_forward(self, (data, forward): (Data<'r>, Status)) -> route::Outco...

FILE: core/lib/src/phase.rs
  type Sealed (line 11) | pub trait Sealed {  }
  type Stateful (line 15) | pub trait Stateful: private::Sealed {
    method into_state (line 16) | fn into_state(self) -> State;
    method as_ref (line 17) | fn as_ref(&self) -> StateRef<'_>;
    method as_mut (line 18) | fn as_mut(&mut self) -> StateRefMut<'_>;
  type Phase (line 29) | pub trait Phase: private::Sealed {

FILE: core/lib/src/request/atomic_method.rs
  type AtomicMethod (line 3) | pub struct AtomicMethod(ref_swap::RefSwap<'static, Method>);
    method new (line 7) | pub fn new(value: Method) -> Self {
    method load (line 12) | pub fn load(&self) -> Method {
    method set (line 17) | pub fn set(&mut self, new: Method) {
    method store (line 22) | pub fn store(&self, new: Method) {
  method clone (line 28) | fn clone(&self) -> Self {

FILE: core/lib/src/request/from_param.rs
  type FromParam (line 211) | pub trait FromParam<'a>: Sized {
    method from_param (line 217) | fn from_param(param: &'a str) -> Result<Self, Self::Error>;
  type Error (line 221) | type Error = Empty;
  function from_param (line 224) | fn from_param(param: &'a str) -> Result<&'a str, Self::Error> {
  type Error (line 234) | type Error = Empty;
  method from_param (line 238) | fn from_param(param: &'a str) -> Result<String, Self::Error> {
  type Error (line 279) | type Error = PathError;
  method from_param (line 282) | fn from_param(param: &'a str) -> Result<Self, Self::Error> {
  type Error (line 291) | type Error = std::convert::Infallible;
  function from_param (line 294) | fn from_param(param: &'a str) -> Result<Self, Self::Error> {
  type Error (line 303) | type Error = std::convert::Infallible;
  function from_param (line 306) | fn from_param(param: &'a str) -> Result<Self, Self::Error> {
  type FromSegments (line 332) | pub trait FromSegments<'r>: Sized {
    method from_segments (line 338) | fn from_segments(segments: Segments<'r, Path>) -> Result<Self, Self::E...
  type Error (line 342) | type Error = std::convert::Infallible;
  function from_segments (line 345) | fn from_segments(segments: Self) -> Result<Self, Self::Error> {
  type Error (line 367) | type Error = PathError;
  method from_segments (line 369) | fn from_segments(segments: Segments<'_, Path>) -> Result<Self, Self::Err...
  type Error (line 375) | type Error = std::convert::Infallible;
  function from_segments (line 378) | fn from_segments(segments: Segments<'r, Path>) -> Result<Result<T, T::Er...
  type Error (line 387) | type Error = std::convert::Infallible;
  function from_segments (line 390) | fn from_segments(segments: Segments<'r, Path>) -> Result<Option<T>, Self...
  type Error (line 404) | type Error = (A::Error, B::Error);
  function from_param (line 407) | fn from_param(param: &'v str) -> Result<Self, Self::Error> {

FILE: core/lib/src/request/from_request.rs
  type Outcome (line 13) | pub type Outcome<S, E> = outcome::Outcome<S, (Status, E), Status>;
  type FromRequest (line 380) | pub trait FromRequest<'r>: Sized {
    method from_request (line 390) | async fn from_request(request: &'r Request<'_>) -> Outcome<Self, Self:...
  type Error (line 395) | type Error = Infallible;
  method from_request (line 397) | async fn from_request(request: &'r Request<'_>) -> Outcome<Self, Infalli...
  type Error (line 404) | type Error = Infallible;
  function from_request (line 406) | async fn from_request(request: &'r Request<'_>) -> Outcome<Self, Infalli...
  type Error (line 413) | type Error = Infallible;
  function from_request (line 415) | async fn from_request(request: &'r Request<'_>) -> Outcome<Self, Infalli...
  type Error (line 425) | type Error = Infallible;
  function from_request (line 427) | async fn from_request(request: &'r Request<'_>) -> Outcome<Self, Infalli...
  type Error (line 437) | type Error = Infallible;
  function from_request (line 439) | async fn from_request(request: &'r Request<'_>) -> Outcome<Self, Infalli...
  type Error (line 446) | type Error = Infallible;
  function from_request (line 448) | async fn from_request(request: &'r Request<'_>) -> Outcome<Self, Infalli...
  type Error (line 458) | type Error = Infallible;
  function from_request (line 460) | async fn from_request(request: &'r Request<'_>) -> Outcome<Self, Infalli...
  type Error (line 470) | type Error = Infallible;
  method from_request (line 472) | async fn from_request(request: &'r Request<'_>) -> Outcome<Self, Infalli...
  type Error (line 482) | type Error = std::convert::Infallible;
  function from_request (line 484) | async fn from_request(request: &'r Request<'_>) -> Outcome<Self, Self::E...
  type Error (line 491) | type Error = Infallible;
  function from_request (line 493) | async fn from_request(request: &'r Request<'_>) -> Outcome<Self, Infalli...
  type Error (line 500) | type Error = Infallible;
  method from_request (line 502) | async fn from_request(request: &'r Request<'_>) -> Outcome<Self, Infalli...
  type Error (line 511) | type Error = Infallible;
  function from_request (line 513) | async fn from_request(request: &'r Request<'_>) -> Outcome<Self, Infalli...
  type Error (line 524) | type Error = Infallible;
  function from_request (line 526) | async fn from_request(request: &'r Request<'_>) -> Outcome<Self, Infalli...
  type Error (line 536) | type Error = Infallible;
  function from_request (line 538) | async fn from_request(request: &'r Request<'_>) -> Outcome<Self, Infalli...

FILE: core/lib/src/request/request.rs
  type Request (line 32) | pub struct Request<'r> {
  type ConnectionMeta (line 44) | pub(crate) struct ConnectionMeta {
    method new (line 53) | pub fn new(
  type RequestState (line 66) | pub(crate) struct RequestState<'r> {
  method clone (line 77) | fn clone(&self) -> Self {
  function new (line 93) | pub(crate) fn new<'s: 'r>(
  function version (line 130) | pub fn version(&self) -> Option<HttpVersion> {
  function method (line 148) | pub fn method(&self) -> Method {
  function set_method (line 168) | pub fn set_method(&mut self, method: Method) {
  function uri (line 183) | pub fn uri(&self) -> &Origin<'r> {
  function set_uri (line 208) | pub fn set_uri(&mut self, uri: Origin<'r>) {
  function host (line 300) | pub fn host(&self) -> Option<&Host<'r>> {
  function sni (line 310) | pub fn sni(&mut self) -> Option<&str> {
  function set_host (line 335) | pub fn set_host(&mut self, host: Host<'r>) {
  function remote (line 369) | pub fn remote(&self) -> Option<&Endpoint> {
  function set_remote (line 393) | pub fn set_remote(&mut self, endpoint: Endpoint) {
  function real_ip (line 415) | pub fn real_ip(&self) -> Option<IpAddr> {
  function proxy_proto (line 462) | pub fn proxy_proto(&self) -> Option<ProxyProto<'_>> {
  function context_is_likely_secure (line 502) | pub fn context_is_likely_secure(&self) -> bool {
  function client_ip (line 549) | pub fn client_ip(&self) -> Option<IpAddr> {
  function cookies (line 575) | pub fn cookies(&self) -> &CookieJar<'r> {
  function headers (line 594) | pub fn headers(&self) -> &HeaderMap<'r> {
  function add_header (line 617) | pub fn add_header<'h: 'r, H: Into<Header<'h>>>(&mut self, header: H) {
  function replace_header (line 646) | pub fn replace_header<'h: 'r, H: Into<Header<'h>>>(&mut self, header: H) {
  function content_type (line 668) | pub fn content_type(&self) -> Option<&ContentType> {
  function accept (line 688) | pub fn accept(&self) -> Option<&Accept> {
  function format (line 739) | pub fn format(&self) -> Option<&MediaType> {
  function rocket (line 772) | pub fn rocket(&self) -> &'r Rocket<Orbit> {
  function limits (line 801) | pub fn limits(&self) -> &'r Limits {
  function route (line 819) | pub fn route(&self) -> Option<&'r Route> {
  function guard (line 838) | pub fn guard<'z, 'a, T>(&'a self) -> BoxFuture<'z, Outcome<T, T::Error>>
  function local_cache (line 870) | pub fn local_cache<T, F>(&self, f: F) -> &T
  function local_cache_async (line 904) | pub async fn local_cache_async<'a, T, F>(&'a self, fut: F) -> &'a T
  function param (line 948) | pub fn param<'a, T>(&'a self, n: usize) -> Option<Result<T, T::Error>>
  function segments (line 986) | pub fn segments<'a, T>(&'a self, n: RangeFrom<usize>) -> Result<T, T::Er...
  function query_value (line 1035) | pub fn query_value<'a, T>(&'a self, name: &str) -> Option<form::Result<'...
  function bust_header_cache (line 1057) | fn bust_header_cache(&mut self, header: &Header<'_>, replace: bool) {
  function routed_segment (line 1077) | pub fn routed_segment(&self, n: usize) -> Option<&str> {
  function routed_segments (line 1084) | pub fn routed_segments(&self, range: RangeFrom<usize>) -> Segments<'_, P...
  function query_fields (line 1095) | pub fn query_fields(&self) -> impl Iterator<Item = ValueField<'_>> {
  function set_route (line 1105) | pub(crate) fn set_route(&self, route: &'r Route) {
  function _set_method (line 1110) | pub(crate) fn _set_method(&self, method: Method) {
  function cookies_mut (line 1114) | pub(crate) fn cookies_mut(&mut self) -> &mut CookieJar<'r> {
  function from_hyp (line 1119) | pub(crate) fn from_hyp(
  type RequestError (line 1224) | pub(crate) enum RequestError {
    method fmt (line 1230) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  function fmt (line 1239) | fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {

FILE: core/lib/src/request/tests.rs
  function test_multiple_headers_from_hyp (line 35) | fn test_multiple_headers_from_hyp() {
  function test_multiple_headers_merge_into_one_from_hyp (line 45) | fn test_multiple_headers_merge_into_one_from_hyp() {

FILE: core/lib/src/response/body.rs
  type Body (line 62) | pub struct Body<'r> {
  type AsyncReadSeek (line 72) | pub trait AsyncReadSeek: AsyncRead + AsyncSeek { }
  type SizedBody (line 78) | type SizedBody<'r> = Pin<Box<dyn AsyncReadSeek + Send + 'r>>;
  type UnsizedBody (line 81) | type UnsizedBody<'r> = Pin<Box<dyn AsyncRead + Send + 'r>>;
  type Inner (line 83) | enum Inner<'r> {
  method default (line 95) | fn default() -> Self {
  constant DEFAULT_MAX_CHUNK (line 108) | pub const DEFAULT_MAX_CHUNK: usize = 4096;
  function unsized_none (line 110) | pub(crate) fn unsized_none() -> Self {
  function with_sized (line 118) | pub(crate) fn with_sized<T>(body: T, preset_size: Option<usize>) -> Self
  function with_unsized (line 128) | pub(crate) fn with_unsized<T>(body: T) -> Self
  function set_max_chunk_size (line 138) | pub(crate) fn set_max_chunk_size(&mut self, max_chunk: usize) {
  function strip (line 142) | pub(crate) fn strip(&mut self) {
  function is_none (line 165) | pub fn is_none(&self) -> bool {
  function is_some (line 186) | pub fn is_some(&self) -> bool {
  function preset_size (line 229) | pub fn preset_size(&self) -> Option<usize> {
  function max_chunk_size (line 257) | pub fn max_chunk_size(&self) -> usize {
  function size (line 294) | pub async fn size(&mut self) -> Option<usize> {
  function take (line 332) | pub fn take(&mut self) -> Self {
  function to_bytes (line 358) | pub async fn to_bytes(&mut self) -> io::Result<Vec<u8>> {
  function to_string (line 398) | pub async fn to_string(&mut self) -> io::Result<String> {
  method poll_read (line 407) | fn poll_read(
  function fmt (line 423) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {

FILE: core/lib/src/response/content.rs
  function respond_to (line 81) | fn respond_to(self, req: &'r Request<'_>) -> response::Result<'o> {

FILE: core/lib/src/response/debug.rs
  type Debug (line 68) | pub struct Debug<E>(pub E);
  function from (line 72) | fn from(e: E) -> Self {
  function respond_to (line 78) | fn respond_to(self, _: &'r Request<'_>) -> response::Result<'static> {
  function respond_to (line 87) | fn respond_to(self, _: &'r Request<'_>) -> response::Result<'static> {

FILE: core/lib/src/response/flash.rs
  constant FLASH_COOKIE_NAME (line 11) | const FLASH_COOKIE_NAME: &str = "_flash";
  constant FLASH_COOKIE_DELIM (line 14) | const FLASH_COOKIE_DELIM: char = ':';
  type Flash (line 77) | pub struct Flash<R> {
  type FlashMessage (line 97) | pub type FlashMessage<'a> = crate::response::Flash<&'a CookieJar<'a>>;
  function new (line 114) | pub fn new<K: Into<String>, M: Into<String>>(res: R, kind: K, message: M...
  function success (line 137) | pub fn success<S: Into<String>>(responder: R, message: S) -> Flash<R> {
  function warning (line 155) | pub fn warning<S: Into<String>>(responder: R, message: S) -> Flash<R> {
  function error (line 173) | pub fn error<S: Into<String>>(responder: R, message: S) -> Flash<R> {
  function cookie (line 177) | fn cookie(&self) -> Cookie<'static> {
  function respond_to (line 192) | fn respond_to(self, req: &'r Request<'_>) -> response::Result<'o> {
  function named (line 201) | fn named<S: Into<String>>(kind: S, message: S, req: &'r Request<'_>) -> ...
  function clear_cookie_if_needed (line 211) | fn clear_cookie_if_needed(&self) {
  function into_inner (line 219) | pub fn into_inner(self) -> (String, String) {
  function kind (line 225) | pub fn kind(&self) -> &str {
  function message (line 231) | pub fn message(&self) -> &str {
  type Error (line 244) | type Error = ();
  function from_request (line 246) | async fn from_request(req: &'r Request<'_>) -> request::Outcome<Self, Se...
  method serialize (line 264) | fn serialize<S: Serializer>(&self, ser: S) -> Result<S::Ok, S::Error> {

FILE: core/lib/src/response/mod.rs
  type Result (line 39) | pub type Result<'r> = std::result::Result<Response<'r>, crate::http::Sta...

FILE: core/lib/src/response/redirect.rs
  type Redirect (line 49) | pub struct Redirect(Status, Option<Reference<'static>>);
    method to (line 66) | pub fn to<U: TryInto<Reference<'static>>>(uri: U) -> Redirect {
    method temporary (line 86) | pub fn temporary<U: TryInto<Reference<'static>>>(uri: U) -> Redirect {
    method permanent (line 106) | pub fn permanent<U: TryInto<Reference<'static>>>(uri: U) -> Redirect {
    method found (line 126) | pub fn found<U: TryInto<Reference<'static>>>(uri: U) -> Redirect {
    method moved (line 144) | pub fn moved<U: TryInto<Reference<'static>>>(uri: U) -> Redirect {
    method map_uri (line 148) | pub fn map_uri<U: TryInto<Reference<'static>>>(self, f: impl FnOnce(Re...
    method respond_to (line 160) | fn respond_to(self, _: &'r Request<'_>) -> response::Result<'static> {

FILE: core/lib/src/response/responder.rs
  type Responder (line 293) | pub trait Responder<'r, 'o: 'r> {
    method respond_to (line 305) | fn respond_to(self, request: &'r Request<'_>) -> response::Result<'o>;
  function respond_to (line 311) | fn respond_to(self, _: &'r Request<'_>) -> response::Result<'o> {
  method respond_to (line 322) | fn respond_to(self, _: &'r Request<'_>) -> response::Result<'static> {
  type DerefRef (line 331) | struct DerefRef<T>(T);
  function as_ref (line 334) | fn as_ref(&self) -> &[u8] {
  function respond_to (line 342) | fn respond_to(self, _: &'r Request<'_>) -> response::Result<'static> {
  function respond_to (line 353) | fn respond_to(self, _: &'r Request<'_>) -> response::Result<'static> {
  function respond_to (line 364) | fn respond_to(self, _: &'r Request<'_>) -> response::Result<'o> {
  function respond_to (line 375) | fn respond_to(self, _: &'r Request<'_>) -> response::Result<'static> {
  function respond_to (line 386) | fn respond_to(self, _: &'r Request<'_>) -> response::Result<'static> {
  function respond_to (line 397) | fn respond_to(self, _: &'r Request<'_>) -> response::Result<'static> {
  function respond_to (line 441) | fn respond_to(self, req: &'r Request<'_>) -> response::Result<'o> {
  method respond_to (line 449) | fn respond_to(self, req: &'r Request<'_>) -> response::Result<'static> {
  function respond_to (line 456) | fn respond_to(self, _: &'r Request<'_>) -> response::Result<'static> {
  function respond_to (line 463) | fn respond_to(self, _: &'r Request<'_>) -> response::Result<'static> {
  function respond_to (line 472) | fn respond_to(self, req: &'r Request<'_>) -> response::Result<'o> {
  function respond_to (line 483) | fn respond_to(self, req: &'r Request<'_>) -> response::Result<'o> {
  function respond_to (line 500) | fn respond_to(self, req: &'r Request<'_>) -> response::Result<'o> {
  function respond_to (line 513) | fn respond_to(self, req: &'r Request<'_>) -> response::Result<'o> {
  method respond_to (line 536) | fn respond_to(self, _: &'r Request<'_>) -> response::Result<'static> {

FILE: core/lib/src/response/response.rs
  type Builder (line 71) | pub struct Builder<'r> {
  function new (line 88) | pub fn new(base: Response<'r>) -> Builder<'r> {
  function status (line 107) | pub fn status(&mut self, status: Status) -> &mut Builder<'r> {
  function header (line 134) | pub fn header<'h: 'r, H>(&mut self, header: H) -> &mut Builder<'r>
  function header_adjoin (line 163) | pub fn header_adjoin<'h: 'r, H>(&mut self, header: H) -> &mut Builder<'r>
  function raw_header (line 188) | pub fn raw_header<'a, 'b, N, V>(&mut self, name: N, value: V) -> &mut Bu...
  function raw_header_adjoin (line 214) | pub fn raw_header_adjoin<'a, 'b, N, V>(&mut self, name: N, value: V) -> ...
  function sized_body (line 236) | pub fn sized_body<B, S>(&mut self, size: S, body: B) -> &mut Builder<'r>
  function streamed_body (line 257) | pub fn streamed_body<B>(&mut self, body: B) -> &mut Builder<'r>
  function upgrade (line 299) | pub fn upgrade<P, H>(&mut self, protocol: P, handler: H) -> &mut Builder...
  function max_chunk_size (line 322) | pub fn max_chunk_size(&mut self, size: usize) -> &mut Builder<'r> {
  function merge (line 361) | pub fn merge(&mut self, other: Response<'r>) -> &mut Builder<'r> {
  function join (line 401) | pub fn join(&mut self, other: Response<'r>) -> &mut Builder<'r> {
  function finalize (line 425) | pub fn finalize(&mut self) -> Response<'r> {
  function ok (line 444) | pub fn ok<E>(&mut self) -> Result<Response<'r>, E> {
  type Response (line 483) | pub struct Response<'r> {
  function new (line 509) | pub fn new() -> Response<'r> {
  function build (line 524) | pub fn build() -> Builder<'r> {
  function build_from (line 540) | pub fn build_from(other: Response<'r>) -> Builder<'r> {
  function status (line 559) | pub fn status(&self) -> Status {
  function set_status (line 576) | pub fn set_status(&mut self, status: Status) {
  function content_type (line 594) | pub fn content_type(&self) -> Option<ContentType> {
  function cookies (line 612) | pub fn cookies(&self) -> impl Iterator<Item = Cookie<'_>> {
  function headers (line 636) | pub fn headers(&self) -> &HeaderMap<'r> {
  function set_header_map (line 640) | pub fn set_header_map<'h: 'r>(&mut self, headers: HeaderMap<'h>) {
  function set_header (line 666) | pub fn set_header<'h: 'r, H: Into<Header<'h>>>(&mut self, header: H) -> ...
  function set_raw_header (line 692) | pub fn set_raw_header<'a: 'r, 'b: 'r, N, V>(&mut self, name: N, value: V...
  function adjoin_header (line 721) | pub fn adjoin_header<'h: 'r, H: Into<Header<'h>>>(&mut self, header: H) {
  function adjoin_raw_header (line 745) | pub fn adjoin_raw_header<'a: 'r, 'b: 'r, N, V>(&mut self, name: N, value...
  function remove_header (line 769) | pub fn remove_header(&mut self, name: &str) {
  function body (line 791) | pub fn body(&self) -> &Body<'r> {
  function search_upgrades (line 799) | pub(crate) fn search_upgrades<'a, I: Iterator<Item = &'a str>>(
  function upgrade (line 852) | pub fn upgrade(&mut self, proto: &str) -> Option<&mut (dyn IoHandler + '...
  function body_mut (line 876) | pub fn body_mut(&mut self) -> &mut Body<'r> {
  function strip_body (line 883) | pub(crate) fn strip_body(&mut self) {
  function set_sized_body (line 908) | pub fn set_sized_body<B, S>(&mut self, size: S, body: B)
  function set_streamed_body (line 936) | pub fn set_streamed_body<B>(&mut self, body: B)
  function add_upgrade (line 985) | pub fn add_upgrade<N, H>(&mut self, protocol: N, handler: H)
  function set_max_chunk_size (line 1017) | pub fn set_max_chunk_size(&mut self, size: usize) {
  function merge (line 1052) | pub fn merge(&mut self, other: Response<'r>) {
  function join (line 1097) | pub fn join(&mut self, other: Response<'r>) {
  function fmt (line 1113) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {

FILE: core/lib/src/response/status.rs
  type Created (line 54) | pub struct Created<R>(Cow<'static, str>, Option<R>, Option<u64>);
  function new (line 77) | pub fn new<L: Into<Cow<'static, str>>>(location: L) -> Self {
  function body (line 110) | pub fn body(mut self, responder: R) -> Self {
  function tagged_body (line 142) | pub fn tagged_body(mut self, responder: R) -> Self where R: Hash {
  function respond_to (line 166) | fn respond_to(self, req: &'r Request<'_>) -> response::Result<'o> {
  type NoContent (line 200) | pub struct NoContent;
    method respond_to (line 204) | fn respond_to(self, _: &'r Request<'_>) -> response::Result<'static> {
  type Custom (line 232) | pub struct Custom<R>(pub Status, pub R);
  function respond_to (line 238) | fn respond_to(self, req: &'r Request<'_>) -> response::Result<'o> {
  function respond_to (line 247) | fn respond_to(self, request: &'r Request<'_>) -> response::Result<'o> {

FILE: core/lib/src/response/stream/bytes.rs
  type ByteStream (line 55) | pub struct ByteStream<S>(pub S);
  function from (line 59) | fn from(stream: S) -> Self {
  function respond_to (line 67) | fn respond_to(self, _: &'r Request<'_>) -> response::Result<'r> {

FILE: core/lib/src/response/stream/one.rs
  type One (line 26) | pub struct One<T: Unpin>(Option<T>);
  function from (line 38) | fn from(value: T) -> Self {
  type Item (line 44) | type Item = T;
  method poll_next (line 46) | fn poll_next(

FILE: core/lib/src/response/stream/raw_sse.rs
  type RawLinedEvent (line 42) | pub struct RawLinedEvent {
    method prefarmed (line 96) | fn prefarmed(name: Cow<'static, [u8]>, value: Cow<'static, [u8]>) -> R...
    method one (line 108) | pub fn one<N, V>(name: N, value: V) -> RawLinedEvent
    method many (line 120) | pub fn many<N, V>(name: N, value: V) -> RawLinedEvent
    method raw (line 128) | pub fn raw<V: Into<Cow<'static, str>>>(value: V) -> RawLinedEvent {
  function farm (line 49) | fn farm(cow: Cow<'_, str>) -> Cow<'_, [u8]> {
  function farm_name (line 59) | fn farm_name(cow: Cow<'_, str>) -> Cow<'_, [u8]> {
  function farm_value (line 78) | fn farm_value(cow: Cow<'_, str>) -> Cow<'_, [u8]> {
  type State (line 141) | enum State {
  function advance (line 151) | fn advance<T: AsRef<[u8]> + Unpin>(buf: &mut Take<Cursor<T>>) {
  function skip (line 165) | fn skip<T: AsRef<[u8]> + Unpin>(buf: &mut Take<Cursor<T>>) {
  method poll_read (line 199) | fn poll_read(

FILE: core/lib/src/response/stream/reader.rs
  function one (line 131) | pub fn one(reader: R) -> Self {
  function from (line 137) | fn from(stream: S) -> Self {
  function respond_to (line 145) | fn respond_to(self, _: &'r Request<'_>) -> response::Result<'r> {
  method poll_read (line 155) | fn poll_read(
  function fmt (line 188) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {

FILE: core/lib/src/response/stream/sse.rs
  type Event (line 115) | pub struct Event {
    method new (line 125) | fn new() -> Self {
    method empty (line 140) | pub fn empty() -> Self {
    method json (line 164) | pub fn json<T: serde::Serialize>(data: &T) -> Self {
    method data (line 189) | pub fn data<T: Into<Cow<'static, str>>>(data: T) -> Self {
    method comment (line 207) | pub fn comment<T: Into<Cow<'static, str>>>(data: T) -> Self {
    method retry (line 221) | pub fn retry(period: Duration) -> Self {
    method event (line 242) | pub fn event<T: Into<Cow<'static, str>>>(mut self, event: T) -> Self {
    method id (line 265) | pub fn id<T: Into<Cow<'static, str>>>(mut self, id: T) -> Self {
    method with_data (line 284) | pub fn with_data<T: Into<Cow<'static, str>>>(mut self, data: T) -> Self {
    method with_comment (line 303) | pub fn with_comment<T: Into<Cow<'static, str>>>(mut self, data: T) -> ...
    method with_retry (line 324) | pub fn with_retry(mut self, period: Duration) -> Self {
    method into_stream (line 329) | fn into_stream(self) -> impl Stream<Item = RawLinedEvent> {
    method into_string (line 606) | fn into_string(self) -> String {
  type EventStream (line 488) | pub struct EventStream<S> {
  function heartbeat (line 526) | pub fn heartbeat<H: Into<Option<Duration>>>(mut self, heartbeat: H) -> S...
  function heartbeat_stream (line 531) | fn heartbeat_stream(&self) -> impl Stream<Item = RawLinedEvent> {
  function into_stream (line 538) | fn into_stream(self) -> impl Stream<Item = RawLinedEvent> {
  function into_reader (line 546) | fn into_reader(self) -> impl AsyncRead {
  function from (line 566) | fn from(stream: S) -> Self {
  function respond_to (line 572) | fn respond_to(self, _: &'r Request<'_>) -> response::Result<'r> {
  function into_string (line 617) | fn into_string(self) -> String {
  function test_event_data (line 630) | fn test_event_data() {
  function test_event_fields (line 680) | fn test_event_fields() {
  function test_bad_chars (line 733) | fn test_bad_chars() {
  function test_event_stream (line 745) | fn test_event_stream() {
  function test_heartbeat (line 766) | fn test_heartbeat() {

FILE: core/lib/src/response/stream/text.rs
  type TextStream (line 56) | pub struct TextStream<S>(pub S);
  function from (line 60) | fn from(stream: S) -> Self {
  function respond_to (line 68) | fn respond_to(self, _: &'r Request<'_>) -> response::Result<'r> {

FILE: core/lib/src/rocket.rs
  type Rocket (line 141) | pub struct Rocket<P: Phase>(pub(crate) P::State);
  function build (line 161) | pub fn build() -> Self {
  function custom (line 187) | pub fn custom<T: Provider>(provider: T) -> Self {
  function reconfigure (line 232) | pub fn reconfigure<T: Provider>(mut self, provider: T) -> Self {
  function load (line 243) | fn load<'a, B, T, F, M>(mut self, kind: &str, base: B, items: Vec<T>, m:...
  function mount (line 361) | pub fn mount<'a, B, R>(self, base: B, routes: R) -> Self
  function register (line 400) | pub fn register<'a, B, C>(self, base: B, catchers: C) -> Self
  function manage (line 452) | pub fn manage<T>(self, state: T) -> Self
  function attach (line 489) | pub fn attach<F: Fairing>(mut self, fairing: F) -> Self {
  function ignite (line 536) | pub async fn ignite(mut self) -> Result<Rocket<Ignite>, Error> {
  function config (line 611) | pub fn config(&self) -> &Config {
  function shutdown (line 647) | pub fn shutdown(&self) -> Shutdown {
  function into_orbit (line 651) | pub(crate) fn into_orbit(self, endpoints: Vec<Endpoint>) -> Rocket<Orbit> {
  function _local_launch (line 663) | async fn _local_launch(self, endpoint: Endpoint) -> Rocket<Orbit> {
  function _launch (line 669) | async fn _launch<L: Listener + 'static>(self, listener: L) -> Result<Roc...
  function try_wait_shutdown (line 707) | async fn try_wait_shutdown(self: Arc<Self>) -> Result<Rocket<Ignite>, Ar...
  function deorbit (line 733) | pub(crate) fn deorbit(self) -> Rocket<Ignite> {
  function liftoff (line 744) | pub(crate) async fn liftoff<R: Deref<Target = Self>>(rocket: R) {
  function config (line 777) | pub fn config(&self) -> &Config {
  function endpoints (line 781) | pub fn endpoints(&self) -> impl Iterator<Item = &Endpoint> {
  function shutdown (line 812) | pub fn shutdown(&self) -> Shutdown {
  function routes (line 841) | pub fn routes(&self) -> impl Iterator<Item = &Route> {
  function catchers (line 872) | pub fn catchers(&self) -> impl Iterator<Item = &Catcher> {
  function state (line 892) | pub fn state<T: Send + Sync + 'static>(&self) -> Option<&T> {
  function fairing (line 953) | pub fn fairing<F: Fairing>(&self) -> Option<&F> {
  function fairings (line 1007) | pub fn fairings<F: Fairing>(&self) -> impl Iterator<Item = &F> {
  function fairing_mut (line 1050) | pub fn fairing_mut<F: Fairing>(&mut self) -> Option<&mut F> {
  function fairings_mut (line 1096) | pub fn fairings_mut<F: Fairing>(&mut self) -> impl Iterator<Item = &mut ...
  function figment (line 1120) | pub fn figment(&self) -> &Figment {
  function into_ignite (line 1128) | async fn into_ignite(self) -> Result<Rocket<Ignite>, Error> {
  function local_launch (line 1136) | pub(crate) async fn local_launch(self, e: Endpoint) -> Result<Rocket<Orb...
  function launch (line 1184) | pub async fn launch(self) -> Result<Rocket<Ignite>, Error> {
  function launch_with (line 1188) | pub async fn launch_with<B: Bind>(self) -> Result<Rocket<Ignite>, Error> {
  function try_launch_on (line 1211) | pub async fn try_launch_on<L, F, E>(self, listener: F) -> Result<Rocket<...
  function launch_on (line 1220) | pub async fn launch_on<L>(self, listener: L) -> Result<Rocket<Ignite>, E...
  type Target (line 1229) | type Target = P::State;
  method deref (line 1231) | fn deref(&self) -> &Self::Target {
  method deref_mut (line 1238) | fn deref_mut(&mut self) -> &mut Self::Target {
  function fmt (line 1244) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {

FILE: core/lib/src/route/handler.rs
  type Outcome (line 7) | pub type Outcome<'r> = crate::outcome::Outcome<Response<'r>, Status, (Da...
  type BoxFuture (line 11) | pub type BoxFuture<'r, T = Outcome<'r>> = futures::future::BoxFuture<'r,...
  type Handler (line 137) | pub trait Handler: Cloneable + Send + Sync + 'static {
    method handle (line 148) | async fn handle<'r>(&self, request: &'r Request<'_>, data: Data<'r>) -...
    method handle (line 156) | fn handle<'r, 'life0, 'life1, 'async_trait>(
  function from (line 187) | pub fn from<R: Responder<'r, 'o>>(req: &'r Request<'_>, responder: R) ->...
  function try_from (line 210) | pub fn try_from<R, E>(req: &'r Request<'_>, result: Result<R, E>) -> Out...
  function error (line 236) | pub fn error(code: Status) -> Outcome<'r> {
  function forward (line 256) | pub fn forward(data: Data<'r>, status: Status) -> Outcome<'r> {
  function dummy_handler (line 263) | pub fn dummy_handler<'r>(r: &'r Request<'_>, _: Data<'r>) -> BoxFuture<'...
  type Sealed (line 268) | pub trait Sealed {}
  type Cloneable (line 278) | pub trait Cloneable: private::Sealed {
    method clone_handler (line 280) | fn clone_handler(&self) -> Box<dyn Handler>;
    method clone_handler (line 284) | fn clone_handler(&self) -> Box<dyn Handler> {
  method clone (line 290) | fn clone(&self) -> Box<dyn Handler> {

FILE: core/lib/src/route/route.rs
  type Route (line 164) | pub struct Route {
    method new (line 210) | pub fn new<M: Into<Option<Method>>, H: Handler>(method: M, uri: &str, ...
    method ranked (line 245) | pub fn ranked<M, H, R>(rank: R, method: M, uri: &str, handler: H) -> R...
    method rebase (line 295) | pub fn rebase(mut self, base: uri::Origin<'_>) -> Self {
    method map_base (line 342) | pub fn map_base<'a, F>(mut self, mapper: F) -> Result<Self, uri::Error...
    method fmt (line 352) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
    method from (line 387) | fn from(info: StaticInfo) -> Route {
  type StaticInfo (line 365) | pub struct StaticInfo {

FILE: core/lib/src/route/segment.rs
  type Segment (line 2) | pub struct Segment {
    method from (line 12) | pub fn from(segment: &crate::http::RawStr) -> Self {

FILE: core/lib/src/route/uri.rs
  type RouteUri (line 56) | pub struct RouteUri<'a> {
  type Color (line 68) | pub(crate) enum Color {
  type Metadata (line 78) | pub(crate) struct Metadata {
    method from (line 244) | fn from(base: &Origin<'_>, uri: &Origin<'_>) -> Self {
  type Result (line 93) | type Result<T, E = uri::Error<'static>> = std::result::Result<T, E>;
  function new (line 100) | pub(crate) fn new(base: &str, uri: &str) -> RouteUri<'static> {
  function try_new (line 110) | pub fn try_new(base: &str, uri: &str) -> Result<RouteUri<'static>> {
  function inner (line 163) | pub fn inner(&self) -> &Origin<'a> {
  function base (line 187) | pub fn base(&self) -> Path<'_> {
  function unmounted (line 209) | pub fn unmounted(&self) -> &Origin<'a> {
  function default_rank (line 233) | pub(crate) fn default_rank(&self) -> isize {
  type Target (line 289) | type Target = Origin<'a>;
  function deref (line 291) | fn deref(&self) -> &Self::Target {
  function fmt (line 297) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  function eq (line 303) | fn eq(&self, other: &Origin<'b>) -> bool { self.inner() == other }
  function eq (line 307) | fn eq(&self, other: &str) -> bool { self.inner() == other }
  function eq (line 311) | fn eq(&self, other: &&str) -> bool { self.inner() == *other }
  function test_route_uri_composition (line 327) | fn test_route_uri_composition() {

FILE: core/lib/src/router/collider.rs
  type Collide (line 6) | pub trait Collide<T = Self> {
    method collides_with (line 7) | fn collides_with(&self, other: &T) -> bool;
    method collides_with (line 150) | fn collides_with(&self, other: &Route) -> bool {
    method collides_with (line 157) | fn collides_with(&self, other: &Self) -> bool {
    method collides_with (line 163) | fn collides_with(&self, other: &Self) -> bool {
    method collides_with (line 181) | fn collides_with(&self, other: &Self) -> bool {
    method collides_with (line 187) | fn collides_with(&self, other: &Self) -> bool {
  method collides_with (line 89) | pub fn collides_with(&self, other: &Route) -> bool {
  method collides_with (line 143) | pub fn collides_with(&self, other: &Self) -> bool {
  function methods_collide (line 193) | fn methods_collide(route: &Route, other: &Route) -> bool {
  function formats_collide (line 200) | fn formats_collide(route: &Route, other: &Route) -> bool {
  function dummy_route (line 226) | fn dummy_route(ranked: bool, method: impl Into<Option<Method>>, uri: &'s...
  function non_collisions (line 258) | fn non_collisions() {
  function collisions (line 339) | fn collisions() {
  function mt_mt_collide (line 402) | fn mt_mt_collide(mt1: &str, mt2: &str) -> bool {
  function test_content_type_collisions (line 409) | fn test_content_type_collisions() {
  function r_mt_mt_collide (line 426) | fn r_mt_mt_collide<S1, S2>(m: Method, mt1: S1, mt2: S2) -> bool
  function test_route_content_type_collisions (line 443) | fn test_route_content_type_collisions() {
  function catchers_collide (line 484) | fn catchers_collide<A, B>(a: A, ap: &str, b: B, bp: &str) -> bool
  function catcher_collisions (line 495) | fn catcher_collisions() {
  function catcher_non_collisions (line 504) | fn catcher_non_collisions() {

FILE: core/lib/src/router/matcher.rs
  method matches (line 69) | pub fn matches(&self, request: &Request<'_>) -> bool {
  method matches (line 136) | pub fn matches(&self, status: Status, request: &Request<'_>) -> bool {
  function methods_match (line 142) | fn methods_match(route: &Route, req: &Request<'_>) -> bool {
  function paths_match (line 147) | fn paths_match(route: &Route, req: &Request<'_>) -> bool {
  function queries_match (line 177) | fn queries_match(route: &Route, req: &Request<'_>) -> bool {
  function formats_match (line 204) | fn formats_match(route: &Route, req: &Request<'_>) -> bool {
  function req_matches_route (line 233) | fn req_matches_route(a: &'static str, b: &'static str) -> bool {
  function request_route_matching (line 240) | fn request_route_matching() {
  function req_matches_format (line 296) | fn req_matches_format<S1, S2>(m: Method, mt1: S1, mt2: S2) -> bool
  function test_req_route_mt_collisions (line 318) | fn test_req_route_mt_collisions() {

FILE: core/lib/src/router/router.rs
  type Router (line 10) | pub(crate) struct Router<T>(T);
  type Pending (line 13) | pub struct Pending {
  type Finalized (line 19) | pub struct Finalized {
  type Pair (line 26) | pub type Pair<T> = (T, T);
  type Collisions (line 28) | pub type Collisions = (Vec<Pair<Route>>, Vec<Pair<Catcher>>);
  type Result (line 30) | pub type Result<T, E = Collisions> = std::result::Result<T, E>;
  function new (line 33) | pub fn new() -> Self {
  function finalize (line 37) | pub fn finalize(self) -> Result<Router<Finalized>, Collisions> {
  function route (line 95) | pub fn route<'r, 'a: 'r>(
  function catch (line 109) | pub fn catch<'r>(&self, status: Status, req: &'r Request<'r>) -> Option<...
  type Target (line 129) | type Target = T;
  method deref (line 131) | fn deref(&self) -> &Self::Target {
  method deref_mut (line 137) | fn deref_mut(&mut self) -> &mut Self::Target {
  function make_router (line 150) | fn make_router<I>(routes: I) -> Result<Router<Finalized>, Collisions>
  function router_with_routes (line 162) | fn router_with_routes(routes: &[&'static str]) -> Router<Finalized> {
  function router_with_ranked_routes (line 166) | fn router_with_ranked_routes(routes: &[(isize, &'static str)]) -> Router...
  function rankless_route_collisions (line 170) | fn rankless_route_collisions(routes: &[&'static str]) -> bool {
  function default_rank_route_collisions (line 174) | fn default_rank_route_collisions(routes: &[&'static str]) -> bool {
  function test_rankless_collisions (line 179) | fn test_rankless_collisions() {
  function test_collisions_normalize (line 211) | fn test_collisions_normalize() {
  function test_collisions_query (line 233) | fn test_collisions_query() {
  function test_no_collisions (line 246) | fn test_no_collisions() {
  function test_no_collision_when_ranked (line 267) | fn test_no_collision_when_ranked() {
  function test_collision_when_ranked (line 292) | fn test_collision_when_ranked() {
  function test_collision_when_ranked_query (line 297) | fn test_collision_when_ranked_query() {
  function test_no_collision_when_ranked_query (line 304) | fn test_no_collision_when_ranked_query() {
  function matches (line 313) | fn matches<'a>(router: &'a Router<Finalized>, method: Method, uri: &'a s...
  function route (line 320) | fn route<'a>(router: &'a Router<Finalized>, method: Method, uri: &'a str...
  function test_ok_routing (line 325) | fn test_ok_routing() {
  function test_err_routing (line 367) | fn test_err_routing() {
  function test_default_ranking (line 410) | fn test_default_ranking() {
  function ranked_collisions (line 434) | fn ranked_collisions(routes: &[(isize, &'static str)]) -> bool {
  function test_no_manual_ranked_collisions (line 439) | fn test_no_manual_ranked_collisions() {
  function test_ranked_collisions (line 451) | fn test_ranked_collisions() {
  function test_ranked_routing (line 471) | fn test_ranked_routing() {
  function test_default_ranked_routing (line 546) | fn test_default_ranked_routing() {
  function router_with_catchers (line 578) | fn router_with_catchers(catchers: &[(Option<u16>, &str)]) -> Result<Rout...
  function catcher (line 589) | fn catcher<'a>(r: &'a Router<Finalized>, status: Status, uri: &str) -> O...
  function test_catcher_routing (line 619) | fn test_catcher_routing() {

FILE: core/lib/src/sentinel.rs
  type Sentinel (line 278) | pub trait Sentinel {
    method abort (line 280) | fn abort(rocket: &Rocket<Ignite>) -> bool;
    method abort (line 284) | fn abort(rocket: &Rocket<Ignite>) -> bool {
    method abort (line 297) | fn abort(rocket: &Rocket<Ignite>) -> bool {
    method abort (line 305) | fn abort(rocket: &Rocket<Ignite>) -> bool {
    method abort (line 315) | fn abort(_: &Rocket<Ignite>) -> bool {
  type Sentry (line 332) | pub struct Sentry {
    method type_id (line 367) | pub fn type_id(&self) -> TypeId {
    method type_name (line 382) | pub fn type_name(&self) -> &'static str {
    method fmt (line 428) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  function query (line 389) | pub(crate) fn query<'s>(
  type Resolve (line 472) | pub struct Resolve<T: ?Sized>(std::marker::PhantomData<T>);
  type DefaultSentinel (line 476) | pub trait DefaultSentinel {
    constant SPECIALIZED (line 477) | const SPECIALIZED: bool = false;
    method abort (line 479) | fn abort(_: &Rocket<Ignite>) -> bool { false }
  constant SPECIALIZED (line 487) | pub const SPECIALIZED: bool = true;
  function abort (line 489) | pub fn abort(rocket: &Rocket<Ignite>) -> bool {
  type NotASentinel (line 499) | struct NotASentinel;
  type YesASentinel (line 500) | struct YesASentinel;
    method abort (line 503) | fn abort(_: &crate::Rocket<crate::Ignite>) -> bool {
  function check_can_determine (line 509) | fn check_can_determine() {
  type HasSentinel (line 519) | struct HasSentinel<T>(T);
  function parent_works (line 522) | fn parent_works() {

FILE: core/lib/src/serde/json.rs
  type Json (line 127) | pub struct Json<T>(pub T);
  type Error (line 131) | pub enum Error<'a> {
  function fmt (line 143) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  function source (line 152) | fn source(&self) -> Option<&(dyn error::Error + 'static)> {
  function into_inner (line 171) | pub fn into_inner(self) -> T {
  function from_str (line 177) | fn from_str(s: &'r str) -> Result<Self, Error<'r>> {
  function from_data (line 181) | async fn from_data(req: &'r Request<'_>, data: Data<'r>) -> Result<Self,...
  type Error (line 198) | type Error = Error<'r>;
  function from_data (line 200) | async fn from_data(req: &'r Request<'_>, data: Data<'r>) -> Outcome<'r, ...
  function respond_to (line 219) | fn respond_to(self, req: &'r Request<'_>) -> response::Result<'static> {
  function fmt (line 231) | fn fmt(&self, f: &mut UriFormatter<'_, Query>) -> fmt::Result {
  function from (line 257) | fn from(value: T) -> Self {
  type Target (line 263) | type Target = T;
  method deref (line 266) | fn deref(&self) -> &T {
  method deref_mut (line 273) | fn deref_mut(&mut self) -> &mut T {
  function from (line 279) | fn from(e: Error<'_>) -> Self {
  function from_value (line 289) | fn from_value(field: form::ValueField<'v>) -> Result<Self, form::Errors<...
  function from_data (line 293) | async fn from_data(f: form::DataField<'v, '_>) -> Result<Self, form::Err...
  method respond_to (line 301) | fn respond_to(self, req: &'r Request<'_>) -> response::Result<'static> {
  function from_slice (line 457) | pub fn from_slice<'a, T>(slice: &'a [u8]) -> Result<T, serde_json::error...
  function from_str (line 500) | pub fn from_str<'a, T>(string: &'a str) -> Result<T, serde_json::error::...
  function to_string (line 537) | pub fn to_string<T>(value: &T) -> Result<String, serde_json::error::Error>
  function to_pretty_string (line 576) | pub fn to_pretty_string<T>(value: &T) -> Result<String, serde_json::erro...
  function from_value (line 615) | pub fn from_value<T>(value: Value) -> Result<T, serde_json::error::Error>
  function to_value (line 650) | pub fn to_value<T>(item: T) -> Result<Value, serde_json::error::Error>

FILE: core/lib/src/serde/msgpack.rs
  type MsgPack (line 129) | pub struct MsgPack<T, const COMPACT: bool = false>(pub T);
  type Compact (line 155) | pub type Compact<T> = MsgPack<T, true>;
  function into_inner (line 169) | pub fn into_inner(self) -> T {
  function from_bytes (line 175) | fn from_bytes(buf: &'r [u8]) -> Result<Self, Error> {
  function from_data (line 179) | async fn from_data(req: &'r Request<'_>, data: Data<'r>) -> Result<Self,...
  type Error (line 196) | type Error = Error;
  function from_data (line 198) | async fn from_data(req: &'r Request<'_>, data: Data<'r>) -> Outcome<'r, ...
  function respond_to (line 219) | fn respond_to(self, req: &'r Request<'_>) -> response::Result<'static> {
  function from_data (line 240) | async fn from_data(f: form::DataField<'v, '_>) -> Result<Self, form::Err...
  function from (line 260) | fn from(value: T) -> Self {
  type Target (line 266) | type Target = T;
  method deref (line 269) | fn deref(&self) -> &T {
  method deref_mut (line 276) | fn deref_mut(&mut self) -> &mut T {
  function from_slice (line 314) | pub fn from_slice<'a, T>(v: &'a [u8]) -> Result<T, Error>
  function to_compact_vec (line 349) | pub fn to_compact_vec<T>(value: &T) -> Result<Vec<u8>, rmp_serde::encode...
  function to_vec (line 387) | pub fn to_vec<T>(value: &T) -> Result<Vec<u8>, rmp_serde::encode::Error>

FILE: core/lib/src/serde/uuid.rs
  type Error (line 89) | type Error = Error;
  method from_param (line 94) | fn from_param(param: &'a str) -> Result<Uuid, Self::Error> {
  method from_value (line 101) | fn from_value(field: ValueField<'v>) -> form::Result<'v, Self> {
  function test_from_param (line 111) | fn test_from_param() {
  function test_from_param_invalid (line 118) | fn test_from_param_invalid() {

FILE: core/lib/src/server.rs
  type Result (line 22) | type Result<T, E = crate::Error> = std::result::Result<T, E>;
  function service (line 30) | async fn service<T: for<'a> Into<RawStream<'a>>>(
  function alt_svc (line 74) | pub(crate) fn alt_svc(&self) -> Option<&'static str> {
  function io_handler_task (line 87) | async fn io_handler_task<S>(proto: String, stream: S, mut handler: Erase...
  function listen_and_serve (line 105) | pub(crate) async fn listen_and_serve<L, R>(
  function serve12 (line 147) | pub(crate) async fn serve12<L>(self: Arc<Self>, listener: L) -> Result<()>
  function serve3 (line 202) | async fn serve3(self: Arc<Self>, listener: crate::listener::quic::QuicLi...

FILE: core/lib/src/shield/policy.rs
  type Policy (line 19) | pub trait Policy: Default + Send + Sync + 'static {
    constant NAME (line 41) | const NAME: &'static str;
    method header (line 63) | fn header(&self) -> Header<'static>;
  type Referrer (line 98) | pub enum Referrer {
  method default (line 137) | fn default() -> Referrer {
  function from (line 143) | fn from(referrer: &Referrer) -> Self {
  type ExpectCt (line 176) | pub enum ExpectCt {
  method default (line 198) | fn default() -> ExpectCt {
  function from (line 204) | fn from(expect: &ExpectCt) -> Self {
  type NoSniff (line 225) | pub enum NoSniff {
  method default (line 232) | fn default() -> NoSniff {
  function from (line 238) | fn from(_: &NoSniff) -> Self {
  type Hsts (line 262) | pub enum Hsts {
  method default (line 293) | fn default() -> Hsts {
  function from (line 299) | fn from(hsts: &Hsts) -> Self {
  type Frame (line 336) | pub enum Frame {
  method default (line 350) | fn default() -> Frame {
  function from (line 356) | fn from(frame: &Frame) -> Self {
  type XssFilter (line 371) | pub enum XssFilter {
  method default (line 386) | fn default() -> XssFilter {
  function from (line 392) | fn from(filter: &XssFilter) -> Self {
  type Prefetch (line 413) | pub enum Prefetch {
  function from (line 422) | fn from(prefetch: &Prefetch) -> Self {
  type Permission (line 473) | pub struct Permission(IndexMap<Feature, Vec<Allow>>);
    method allowed (line 511) | pub fn allowed<L>(feature: Feature, allow: L) -> Self
    method blocked (line 527) | pub fn blocked(feature: Feature) -> Self {
    method allow (line 557) | pub fn allow<L>(mut self, feature: Feature, allow: L) -> Self
    method block (line 590) | pub fn block(mut self, feature: Feature) -> Self {
    method get (line 608) | pub fn get(&self, feature: Feature) -> Option<&[Allow]> {
    method iter (line 637) | pub fn iter(&self) -> impl Iterator<Item = (Feature, &[Allow])> {
  method default (line 479) | fn default() -> Self {
  function from (line 643) | fn from(perm: &Permission) -> Self {
  type Allow (line 672) | pub enum Allow {
    method rendered (line 692) | fn rendered(&self) -> Cow<'static, str> {
  type Item (line 720) | type Item = Self;
  type IntoIter (line 722) | type IntoIter = std::iter::Once<Self>;
  method into_iter (line 724) | fn into_iter(self) -> Self::IntoIter {
  type Feature (line 732) | pub enum Feature {
    method as_str (line 832) | pub const fn as_str(self) -> &'static str {
    method fmt (line 882) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {

FILE: core/lib/src/shield/shield.rs
  type Shield (line 64) | pub struct Shield {
    method new (line 112) | pub fn new() -> Self {
    method enable (line 132) | pub fn enable<P: Policy>(mut self, policy: P) -> Self {
    method disable (line 147) | pub fn disable<P: Policy>(mut self) -> Self {
    method is_enabled (line 171) | pub fn is_enabled<P: Policy>(&self) -> bool {
  method clone (line 72) | fn clone(&self) -> Self {
  method default (line 94) | fn default() -> Self {
  method info (line 178) | fn info(&self) -> Info {
  method on_liftoff (line 185) | async fn on_liftoff(&self, rocket: &Rocket<Orbit>) {
  method on_response (line 209) | async fn on_response<'r>(&self, _: &'r Request<'_>, response: &mut Respo...

FILE: core/lib/src/shutdown/config.rs
  type ShutdownConfig (line 156) | pub struct ShutdownConfig {
    method grace (line 225) | pub(crate) fn grace(&self) -> Duration {
    method mercy (line 229) | pub(crate) fn mercy(&self) -> Duration {
    method signal_stream (line 234) | pub(crate) fn signal_stream(&self) -> Option<impl Stream<Item = Sig>> {
    method signal_stream (line 272) | pub(crate) fn signal_stream(&self) -> Option<impl Stream<Item = Sig>> {
  method default (line 211) | fn default() -> Self {

FILE: core/lib/src/shutdown/handle.rs
  type Shutdown (line 68) | pub struct Shutdown {
    method new (line 80) | fn new() -> Self {
    method notify (line 104) | pub fn notify(&self) {
    method notified (line 124) | pub fn notified(&self) -> bool {
    type Error (line 139) | type Error = std::convert::Infallible;
    method from_request (line 142) | async fn from_request(request: &'r Request<'_>) -> Outcome<Self, Self:...
  type Stages (line 73) | pub struct Stages {
    method new (line 148) | pub fn new() -> Self {
    method spawn_listener (line 156) | pub(crate) fn spawn_listener(&self, config: &ShutdownConfig) {
  type Output (line 130) | type Output = ();
  method poll (line 132) | fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Ou...
  function ensure_is_send_sync_clone_unpin (line 190) | fn ensure_is_send_sync_clone_unpin() {

FILE: core/lib/src/shutdown/sig.rs
  type Sig (line 18) | pub enum Sig {
    method as_str (line 42) | pub fn as_str(&self) -> &'static str {
    method fmt (line 59) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {

FILE: core/lib/src/shutdown/tripwire.rs
  type State (line 11) | pub struct State {
  type TripWire (line 17) | pub struct TripWire {
    method fmt (line 48) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
    method new (line 91) | pub fn new() -> Self {
    method trip (line 101) | pub fn trip(&self) {
    method tripped (line 107) | pub fn tripped(&self) -> bool {
  type Target (line 24) | type Target = State;
  method deref (line 26) | fn deref(&self) -> &Self::Target {
  method clone (line 32) | fn clone(&self) -> Self {
  method drop (line 41) | fn drop(&mut self) {
  type Output (line 56) | type Output = ();
  method poll (line 58) | fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Ou...
  method is_terminated (line 85) | fn is_terminated(&self) -> bool {
  function ensure_is_send_sync_clone_unpin (line 117) | fn ensure_is_send_sync_clone_unpin() {
  function simple_trip (line 123) | async fn simple_trip() {
  function no_trip (line 130) | async fn no_trip() {
  function general_trip (line 147) | async fn general_trip() {
  function single_stage_trip (line 162) | async fn single_stage_trip() {
  function staged_trip (line 184) | async fn staged_trip() {

FILE: core/lib/src/state.rs
  type State (line 116) | pub struct State<T: Send + Sync + 'static>(T);
  function get (line 142) | pub fn get<P: Phase>(rocket: &Rocket<P>) -> Option<&State<T>> {
  function from (line 150) | pub fn from(value: &T) -> &State<T> {
  function inner (line 182) | pub fn inner(&self) -> &T {
  function from (line 189) | fn from(reference: &'r T) -> Self {
  type Error (line 196) | type Error = ();
  function from_request (line 199) | async fn from_request(req: &'r Request<'_>) -> request::Outcome<Self, ()> {
  method abort (line 214) | fn abort(rocket: &Rocket<Ignite>) -> bool {
  function fmt (line 228) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  type Target (line 234) | type Target = T;
  method deref (line 237) | fn deref(&self) -> &T {

FILE: core/lib/src/tls/config.rs
  type TlsConfig (line 87) | pub struct TlsConfig {
    method from_paths (line 161) | pub fn from_paths<C, K>(certs: C, key: K) -> Self
    method from_bytes (line 185) | pub fn from_bytes(certs: &[u8], key: &[u8]) -> Self {
    method with_ciphers (line 252) | pub fn with_ciphers<C>(mut self, ciphers: C) -> Self
    method with_preferred_server_cipher_order (line 284) | pub fn with_preferred_server_cipher_order(mut self, prefer_server_orde...
    method with_mutual (line 306) | pub fn with_mutual(mut self, config: crate::mtls::MtlsConfig) -> Self {
    method certs (line 328) | pub fn certs(&self) -> either::Either<std::path::PathBuf, &[u8]> {
    method certs_reader (line 335) | pub fn certs_reader(&self) -> io::Result<Box<dyn io::BufRead + Sync + ...
    method key (line 356) | pub fn key(&self) -> either::Either<std::path::PathBuf, &[u8]> {
    method key_reader (line 363) | pub fn key_reader(&self) -> io::Result<Box<dyn io::BufRead + Sync + Se...
    method ciphers (line 389) | pub fn ciphers(&self) -> impl Iterator<Item = CipherSuite> + '_ {
    method prefer_server_cipher_order (line 412) | pub fn prefer_server_cipher_order(&self) -> bool {
    method mutual (line 437) | pub fn mutual(&self) -> Option<&crate::mtls::MtlsConfig> {
    method server_config (line 444) | pub async fn server_config(&self) -> Result<rustls::server::ServerConf...
    method _server_config (line 454) | pub(crate) fn _server_config(&self) -> Result<rustls::server::ServerCo...
    method validate (line 490) | pub fn validate(&self) -> Result<()> {
    method load_certs (line 497) | pub(crate) fn load_certs(&self) -> Result<Vec<CertificateDer<'static>>> {
    method load_key (line 504) | pub(crate) fn load_key(&self) -> Result<PrivateKeyDer<'static>> {
    method default_crypto_provider (line 532) | pub(crate) fn default_crypto_provider(&self) -> CryptoProvider {
  type CipherSuite (line 113) | pub enum CipherSuite {
    constant DEFAULT_SET (line 564) | pub const DEFAULT_SET: [CipherSuite; 9] = [
    constant TLS_V13_SET (line 581) | pub const TLS_V13_SET: [CipherSuite; 3] = [
    constant TLS_V12_SET (line 589) | pub const TLS_V12_SET: [CipherSuite; 6] = [
    method default_set (line 599) | fn default_set() -> IndexSet<Self> {
  method default (line 136) | fn default() -> Self {
  function to_reader (line 604) | pub(crate) fn to_reader(
  function test_tls_config_from_file (line 629) | fn test_tls_config_from_file() {
  function verify_load_private_keys_of_different_types (line 762) | fn verify_load_private_keys_of_different_types() -> Result<()> {
  function verify_load_certs_of_different_types (line 778) | fn verify_load_certs_of_different_types() -> Result<()> {

FILE: core/lib/src/tls/error.rs
  type Result (line 1) | pub type Result<T, E = Error> = std::result::Result<T, E>;
  type KeyError (line 4) | pub enum KeyError {
    method fmt (line 41) | fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
    method source (line 55) | fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
  type Error (line 12) | pub enum Error {
    method fmt (line 24) | fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
    method source (line 65) | fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
    method from (line 80) | fn from(e: std::io::Error) -> Self {
    method from (line 86) | fn from(e: rustls::Error) -> Self {
    method from (line 92) | fn from(value: rustls::server::VerifierBuilderError) -> Self {
    method from (line 98) | fn from(value: KeyError) -> Self {
    method from (line 104) | fn from(v: std::convert::Infallible) -> Self {
    method from (line 110) | fn from(value: figment::Error) -> Self {

FILE: core/lib/src/tls/listener.rs
  type TlsListener (line 18) | pub struct TlsListener<L> {
  function from (line 27) | pub async fn from(listener: L, config: TlsConfig) -> Result<TlsListener<...
  type Error (line 39) | type Error = Error;
  method bind (line 41) | async fn bind(rocket: &Rocket<Ignite>) -> Result<Self, Self::Error> {
  method bind_endpoint (line 48) | fn bind_endpoint(rocket: &Rocket<Ignite>) -> Result<Endpoint, Self::Erro...
  type Accept (line 60) | type Accept = L::Connection;
  type Connection (line 62) | type Connection = TlsStream<L::Connection>;
  method accept (line 64) | async fn accept(&self) -> io::Result<Self::Accept> {
  method connect (line 68) | async fn connect(&self, conn: L::Connection) -> io::Result<Self::Connect...
  method endpoint (line 80) | fn endpoint(&self) -> io::Result<Endpoint> {
  method endpoint (line 86) | fn endpoint(&self) -> io::Result<Endpoint> {
  method certificates (line 90) | fn certificates(&self) -> Option<Certificates<'_>> {
  method server_name (line 100) | fn server_name(&self) -> Option<&str> {

FILE: core/lib/src/tls/resolver.rs
  type DynResolver (line 13) | pub(crate) struct DynResolver(Arc<dyn Resolver>);
    method extract (line 89) | pub fn extract(rocket: &Rocket<Ignite>) -> Option<Self> {
    method fmt (line 95) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  type Fairing (line 15) | pub struct Fairing<T: ?Sized>(PhantomData<T>);
  type Resolver (line 52) | pub trait Resolver: Send + Sync + 'static {
    method init (line 53) | async fn init(rocket: &Rocket<Build>) -> crate::tls::Result<Self> wher...
    method resolve (line 59) | async fn resolve(&self, hello: ClientHello<'_>) -> Option<Arc<ServerCo...
    method fairing (line 61) | fn fairing() -> Fairing<Self> where Self: Sized {
  function info (line 68) | fn info(&self) -> Info {
  function on_ignite (line 75) | async fn on_ignite(&self, rocket: Rocket<Build>) -> fairing::Result {
  method eq (line 101) | fn eq(&self, _: &Self) -> bool {
  type Target (line 107) | type Target = dyn Resolver;
  method deref (line 109) | fn deref(&self) -> &Self::Target {

FILE: core/lib/src/trace/level.rs
  function serialize (line 6) | pub fn serialize<S: Serializer>(level: &Option<Level>, s: S) -> Result<S...
  function deserialize (line 10) | pub fn deserialize<'de, D: Deserializer<'de>>(de: D) -> Result<Option<Le...

FILE: core/lib/src/trace/mod.rs
  type TraceFormat (line 23) | pub enum TraceFormat {
  function init (line 33) | pub fn init<'a, T: Into<Option<&'a crate::Config>>>(config: T) {

FILE: core/lib/src/trace/subscriber/common.rs
  type FmtKind (line 17) | pub trait FmtKind: Send + Sync + 'static { }
  type RocketFmt (line 24) | pub struct RocketFmt<K: private::FmtKind> {
  function state (line 32) | pub(crate) fn state(&self) -> K {
  function update_state (line 36) | pub(crate) fn update_state<F: FnOnce(&mut K)>(&self, update: F) {
  function new (line 45) | pub fn new(workers: usize, cli_colors: CliColors, level: Option<Level>) ...
  function style (line 61) | pub fn style(&self, metadata: &Metadata<'_>) -> Style {
  function has_message (line 71) | pub(crate) fn has_message(&self, meta: &Metadata<'_>) -> bool {
  function has_data_fields (line 75) | pub(crate) fn has_data_fields(&self, meta: &Metadata<'_>) -> bool {
  function message (line 79) | pub(crate) fn message<'a, F: RecordFields + 'a>(&self,
  function compact_fields (line 110) | pub(crate) fn compact_fields<'a, F: RecordFields + 'a>(
  function print (line 133) | pub(crate) fn print<F: RecordFields>(

FILE: core/lib/src/trace/subscriber/compact.rs
  type Compact (line 20) | pub struct Compact {
  type RequestData (line 26) | pub struct RequestData {
    method new (line 33) | pub fn new<T: RecordFields>(attrs: T) -> Self {
  function request_span_id (line 43) | fn request_span_id(&self) -> Option<Id> {
  function timestamp_for (line 47) | fn timestamp_for(&self, datetime: OffsetDateTime) -> impl fmt::Display {
  function in_debug (line 56) | fn in_debug(&self) -> bool {
  function prefix (line 60) | fn prefix<'a>(&self, meta: &'a Metadata<'_>) -> impl fmt::Display + 'a {
  function chevron (line 75) | fn chevron(&self, meta: &Metadata<'_>) -> Painted<&'static str> {
  function print_compact (line 79) | fn print_compact<F: RecordFields>(&self, m: &Metadata<'_>, data: F) {
  function enabled (line 90) | fn enabled(&self, metadata: &Metadata<'_>, _: Context<'_, S>) -> bool {
  function on_event (line 98) | fn on_event(&self, event: &Event<'_>, ctxt: Context<'_, S>) {
  function on_new_span (line 121) | fn on_new_span(&self, attrs: &Attributes<'_>, id: &Id, ctxt: Context<'_,...
  function on_record (line 138) | fn on_record(&self, id: &Id, values: &Record<'_>, ctxt: Context<'_, S>) {
  function on_enter (line 156) | fn on_enter(&self, id: &Id, ctxt: Context<'_, S>) {
  function on_exit (line 163) | fn on_exit(&self, id: &Id, ctxt: Context<'_, S>) {
  function on_close (line 170) | fn on_close(&self, id: Id, ctxt: Context<'_, S>) {

FILE: core/lib/src/trace/subscriber/dynamic.rs
  type RocketDynFmt (line 17) | pub struct RocketDynFmt {
    method from (line 22) | fn from(value: RocketFmt<Compact>) -> Self {
    method from (line 28) | fn from(value: RocketFmt<Pretty>) -> Self {
    method new (line 41) | pub fn new(config: Option<&Config>) -> Self {
    method init (line 54) | pub(crate) fn init(config: Option<&Config>) {

FILE: core/lib/src/trace/subscriber/pretty.rs
  type Pretty (line 16) | pub struct Pretty {
  function indent (line 21) | fn indent(&self) -> &'static str {
  function marker (line 26) | fn marker(&self) -> &'static str {
  function emoji (line 31) | fn emoji(&self, _emoji: &'static str) -> Painted<&'static str> {
  function prefix (line 36) | fn prefix<'a>(&self, meta: &'a Metadata<'_>) -> impl fmt::Display + 'a {
  function print_pretty (line 46) | fn print_pretty<F: RecordFields>(&self, m: &Metadata<'_>, data: F) {
  function print_fields (line 56) | fn print_fields<F>(&self, metadata: &Metadata<'_>, fields: F)
  function enabled (line 70) | fn enabled(&self, metadata: &Metadata<'_>, _: Context<'_, S>) -> bool {
  function on_event (line 74) | fn on_event(&self, event: &Event<'_>, _: Context<'_, S>) {
  function on_new_span (line 147) | fn on_new_span(&self, attrs: &Attributes<'_>, id: &Id, ctxt: Context<'_,...
  function on_record (line 187) | fn on_record(&self, id: &Id, values: &Record<'_>, ctxt: Context<'_, S>) {
  function on_enter (line 198) | fn on_enter(&self, _: &Id, _: Context<'_, S>) {
  function on_exit (line 202) | fn on_exit(&self, _: &Id, _: Context<'_, S>) {

FILE: core/lib/src/trace/subscriber/request_id.rs
  type RequestIdLayer (line 11) | pub struct RequestIdLayer;
    method current (line 67) | pub fn current() -> Option<RequestId> {
    method on_new_span (line 73) | fn on_new_span(&self, _: &Attributes<'_>, id: &Id, ctxt: Context<'_, S...
    method on_enter (line 80) | fn on_enter(&self, id: &Id, ctxt: Context<'_, S>) {
    method on_exit (line 87) | fn on_exit(&self, id: &Id, ctxt: Context<'_, S>) {
  type RequestId (line 14) | pub struct RequestId(u128);
    method new (line 20) | fn new() -> Self {
    method of (line 41) | pub fn of<R: for<'a> LookupSpan<'a>>(span: &SpanRef<'_, R>) -> Option<...
    method current (line 45) | pub fn current() -> Option<Self> {
    method short (line 49) | fn short(&self) -> u32 {
    method layer (line 57) | pub fn layer() -> RequestIdLayer {
    method fmt (line 96) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
    method fmt (line 102) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
    method fmt (line 108) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  type IdentHasher (line 17) | pub struct IdentHasher(u128);
  method finish (line 114) | fn finish(&self) -> u64 {
  method write (line 118) | fn write(&mut self, bytes: &[u8]) {
  method write_u64 (line 124) | fn write_u64(&mut self, i: u64) {

FILE: core/lib/src/trace/subscriber/visit.rs
  type RecordDisplay (line 9) | pub trait RecordDisplay: RecordFields {
    method find_map_display (line 10) | fn find_map_display<T, F: Fn(&dyn fmt::Display) -> T>(&self, name: &st...
    method record_display (line 11) | fn record_display<F: FnMut(&Field, &dyn fmt::Display)>(&self, f: F);
    method find_map_display (line 57) | fn find_map_display<V, F: Fn(&dyn fmt::Display) -> V>(&self, name: &st...
    method record_display (line 63) | fn record_display<F: FnMut(&Field, &dyn fmt::Display)>(&self, f: F) {
  type Data (line 15) | pub struct Data {
    method new (line 21) | pub fn new<T: RecordFields>(attrs: T) -> Self {
    method get (line 31) | pub fn get(&self, key: &str) -> Option<&str> {
    type Output (line 39) | type Output = str;
    method index (line 41) | fn index(&self, index: &str) -> &Self::Output {
  method record_debug (line 47) | fn record_debug(&mut self, field: &Field, value: &dyn fmt::Debug) {
  method record_str (line 51) | fn record_str(&mut self, field: &Field, value: &str) {

FILE: core/lib/src/trace/traceable.rs
  type Trace (line 13) | pub trait Trace {
    method trace (line 14) | fn trace(&self, level: Level);
    method trace_info (line 16) | fn trace_info(&self) { self.trace(Level::INFO) }
    method trace_warn (line 17) | fn trace_warn(&self) { self.trace(Level::WARN) }
    method trace_error (line 18) | fn trace_error(&self) { self.trace(Level::ERROR) }
    method trace_debug (line 19) | fn trace_debug(&self) { self.trace(Level::DEBUG) }
    method trace_trace (line 20) | fn trace_trace(&self) { self.trace(Level::TRACE) }
    method trace (line 41) | fn trace(&self, level: Level) {
    method trace (line 47) | fn trace(&self, level: Level) {
    method trace (line 79) | fn trace(&self, level: Level) {
    method trace (line 141) | fn trace(&self, level: Level) {
    method trace (line 170) | fn trace(&self, level: Level) {
    method trace (line 187) | fn trace(&self, level: Level) {
    method trace (line 193) | fn trace(&self, level: Level) {
    method trace (line 199) | fn trace(&self, _: Level) {
    method trace (line 220) | fn trace(&self, _: Level) {
    method trace (line 235) | fn trace(&self, level: Level) {
    method trace (line 241) | fn trace(&self, level: Level) {
    method trace (line 258) | fn trace(&self, level: Level) {
    method trace (line 264) | fn trace(&self, level: Level) {
    method trace (line 270) | fn trace(&self, level: Level) {
    method trace (line 280) | fn trace(&self, level: Level) {
    method trace (line 286) | fn trace(&self, level: Level) {
    method trace (line 295) | fn trace(&self, level: Level) {
  type TraceAll (line 23) | pub trait TraceAll: Sized {
    method trace_all (line 24) | fn trace_all(self, level: Level);
    method trace_all_info (line 26) | fn trace_all_info(self) { self.trace_all(Level::INFO) }
    method trace_all_warn (line 27) | fn trace_all_warn(self) { self.trace_all(Level::WARN) }
    method trace_all_error (line 28) | fn trace_all_error(self) { self.trace_all(Level::ERROR) }
    method trace_all_debug (line 29) | fn trace_all_debug(self) { self.trace_all(Level::DEBUG) }
    method trace_all_trace (line 30) | fn trace_all_trace(self) { self.trace_all(Level::TRACE) }
    method trace_all (line 34) | fn trace_all(self, level: Level) {

FILE: core/lib/src/util/chain.rs
  function new (line 20) | pub(crate) fn new(first: T, second: U) -> Self {
  function get_ref (line 27) | pub fn get_ref(&self) -> (Option<&T>, &U) {
  method poll_read (line 33) | fn poll_read(

FILE: core/lib/src/util/join.rs
  function join (line 17) | pub fn join<A: Stream, B: Stream>(a: A, b: B) -> Join<A, B> {
  type Item (line 37) | type Item = T::Item;
  method poll_next (line 39) | fn poll_next(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Opt...
  method size_hint (line 63) | fn size_hint(&self) -> (usize, Option<usize>) {

FILE: core/lib/src/util/mod.rs
  function spawn_inspect (line 13) | pub fn spawn_inspect<E, F, Fut>(or: F, future: Fut)
  type FutureExt (line 28) | pub trait FutureExt: Future + Sized {
    method race (line 30) | async fn race<B: Future>(self, other: B) -> Either<Self::Output, B::Ou...
    method race_io (line 37) | async fn race_io<T, K: Future>(self, trigger: K) -> io::Result<T>
  type Formatter (line 49) | pub struct Formatter<F: Fn(&mut fmt::Formatter<'_>) -> fmt::Result>(pub F);
  function fmt (line 52) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  function fmt (line 58) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {

FILE: core/lib/src/util/reader_stream.rs
  function with_capacity (line 64) | pub fn with_capacity(reader: R, capacity: usize) -> Self {
  type Item (line 75) | type Item = std::io::Result<Bytes>;
  method poll_next (line 77) | fn poll_next(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Opt...
  type Data (line 114) | type Data = bytes::Bytes;
  type Error (line 116) | type Error = std::io::Error;
  function poll_frame (line 118) | fn poll_frame(

FILE: core/lib/src/util/unix.rs
  function lock_exclusive_nonblocking (line 4) | pub fn lock_exclusive_nonblocking<T: AsRawFd>(file: &T) -> io::Result<()> {
  function unlock_nonblocking (line 16) | pub fn unlock_nonblocking<T: AsRawFd>(file: &T) -> io::Result<()> {

FILE: core/lib/tests/absolute-uris-okay-issue-443.rs
  function http (line 6) | fn http() -> Redirect {
  function redirect (line 11) | fn redirect() -> Redirect {
  function redirect_works (line 20) | fn redirect_works() {

FILE: core/lib/tests/adhoc-uri-normalizer.rs
  function foo (line 9) | fn foo() -> &'static str { "foo" }
  function not_bar (line 12) | fn not_bar() -> &'static str { "not_bar" }
  function bar (line 15) | fn bar() -> &'static str { "bar" }
  function baz (line 18) | fn baz(_baz: PathBuf) -> &'static str { "baz" }
  function doggy (line 21) | fn doggy(_baz: PathBuf) -> &'static str { "doggy" }
  function rest (line 24) | fn rest() -> &'static str { "rest" }
  function test_adhoc_normalizer_works_as_expected (line 35) | fn test_adhoc_normalizer_works_as_expected () {

FILE: core/lib/tests/byte-slices-form-field-issue-2148.rs
  type DataForm (line 10) | struct DataForm<'r> {
  function form (line 16) | fn form(form: Form<DataForm<'_>>) -> String {
  function test_from_form_fields_of_multipart_files_into_byte_slices (line 21) | fn test_from_form_fields_of_multipart_files_into_byte_slices() {
  function test_from_form_fields_of_values_into_byte_slices (line 53) | fn test_from_form_fields_of_values_into_byte_slices() {

FILE: core/lib/tests/can-correct-bad-local-uri.rs
  function can_correct_bad_local_uri (line 5) | fn can_correct_bad_local_uri() {

FILE: core/lib/tests/can-launch-tls.rs
  function can_launch_tls (line 9) | async fn can_launch_tls() {

FILE: core/lib/tests/catcher-cookies-1213.rs
  function not_found (line 7) | fn not_found(request: &Request<'_>) -> &'static str {
  function index (line 13) | fn index(cookies: &CookieJar<'_>) -> &'static str {
  function error_catcher_sets_cookies (line 24) | fn error_catcher_sets_cookies() {

FILE: core/lib/tests/conditionally-set-server-header-996.rs
  type HeaderOnly (line 6) | struct HeaderOnly((), Header<'static>);
  function do_not_overwrite (line 9) | fn do_not_overwrite() -> HeaderOnly {
  function use_default (line 14) | fn use_default() { }
  function do_not_overwrite_server_header (line 21) | fn do_not_overwrite_server_header() {

FILE: core/lib/tests/config-proxy-proto-header.rs
  function inspect_proto (line 4) | fn inspect_proto(proto: rocket::http::ProxyProto<'_>) -> String {
  function routes (line 14) | fn routes() -> Vec<Route> {
  function rocket_with_proto_header (line 18) | fn rocket_with_proto_header(header: Option<&'static str>) -> Rocket<Buil...
  function check_proxy_proto_header_works (line 25) | fn check_proxy_proto_header_works() {
  function check_proxy_proto_header_works_again (line 42) | fn check_proxy_proto_header_works_again() {
  function check_default_proxy_proto_header_works (line 62) | fn check_default_proxy_proto_header_works() {
  function check_no_proxy_proto_header_works (line 72) | fn check_no_proxy_proto_header_works() {

FILE: core/lib/tests/config-real-ip-header.rs
  function inspect_ip (line 4) | fn inspect_ip(ip: Option<std::net::IpAddr>) -> String {
  function routes (line 14) | fn routes() -> Vec<Route> {
  function rocket_with_custom_ip_header (line 18) | fn rocket_with_custom_ip_header(header: Option<&'static str>) -> Rocket<...
  function check_real_ip_header_works (line 25) | fn check_real_ip_header_works() {
  function check_real_ip_header_works_again (line 45) | fn check_real_ip_header_works_again() {
  function check_default_real_ip_header_works (line 65) | fn check_default_real_ip_header_works() {
  function check_no_ip_header_works (line 75) | fn check_no_ip_header_works() {

FILE: core/lib/tests/config-secret-key-1500.rs
  function secret_key_in_config_not_zero (line 7) | fn secret_key_in_config_not_zero() {

FILE: core/lib/tests/content-length.rs
  function index (line 5) | fn index() -> String {
  function content_length_header (line 10) | fn content_length_header() {

FILE: core/lib/tests/cookies-private.rs
  function cookie_add_private (line 8) | fn cookie_add_private(jar: &CookieJar<'_>) {
  function cookie_get_private (line 34) | fn cookie_get_private(jar: &CookieJar<'_>) -> String {
  function cookie_get (line 51) | fn cookie_get(jar: &CookieJar<'_>) -> String {
  function rocket (line 69) | fn rocket() -> Rocket<Build> {
  function test_cookie_add_private (line 75) | fn test_cookie_add_private() {
  function test_cookie_get_private (line 88) | fn test_cookie_get_private() {
  function test_cookie_get_ohno (line 102) | fn test_cookie_get_ohno() {

FILE: core/lib/tests/derive-reexports.rs
  type Thing (line 6) | enum Thing {
    method fmt (line 13) | fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
  type ThingForm (line 23) | struct ThingForm {
  type DerivedResponder (line 28) | struct DerivedResponder {
  function index (line 33) | fn index() -> DerivedResponder {
  function number (line 38) | fn number(params: ThingForm) -> DerivedResponder {
  function test_derive_reexports (line 43) | fn test_derive_reexports() {

FILE: core/lib/tests/deserialize-limits-issue-2268.rs
  function deserialize_mixed_case_limits_should_work (line 7) | fn deserialize_mixed_case_limits_should_work() {
  function deserialize_extra_limits_in_config_should_work (line 26) | fn deserialize_extra_limits_in_config_should_work() {

FILE: core/lib/tests/encoded-uris.rs
  function index (line 4) | fn index(value: &str) -> &str {
  function can_route_to_encoded_uri (line 12) | fn can_route_to_encoded_uri() {

FILE: core/lib/tests/fairing_before_head_strip-issue-546.rs
  constant RESPONSE_STRING (line 3) | const RESPONSE_STRING: &'static str = "This is the body. Hello, world!";
  function head (line 6) | fn head() -> &'static str {
  function auto (line 11) | fn auto() -> &'static str {
  function not_auto_handled (line 27) | fn not_auto_handled() {
  function auto_handled (line 51) | fn auto_handled() {

FILE: core/lib/tests/file_server.rs
  function static_root (line 9) | fn static_root() -> &'static Path {
  function rocket (line 13) | fn rocket() -> Rocket<Build> {
  function assert_file_matches (line 96) | fn assert_file_matches(client: &Client, prefix: &str, path: &str, disk_p...
  function assert_file (line 116) | fn assert_file(client: &Client, prefix: &str, path: &str, exists: bool) {
  function assert_all (line 124) | fn assert_all(client: &Client, prefix: &str, paths: &[&str], exist: bool) {
  function test_static_no_index (line 131) | fn test_static_no_index() {
  function test_static_hidden (line 139) | fn test_static_hidden() {
  function test_static_index (line 147) | fn test_static_index() {
  function test_static_all (line 159) | fn test_static_all() {
  function test_alt_roots (line 167) | fn test_alt_roots() {
  function test_allow_special_dotpaths (line 174) | fn test_allow_special_dotpaths() {
  function test_try_index (line 183) | fn test_try_index() {
  function test_ranking (line 190) | fn test_ranking() {
  function test_forwarding (line 204) | fn test_forwarding() {
  function test_redirection (line 230) | fn test_redirection() {
  function test_panic_on_missing_file (line 281) | fn test_panic_on_missing_file() {
  function test_panic_on_missing_dir (line 287) | fn test_panic_on_missing_dir() {
  function test_panic_on_file_not_dir (line 293) | fn test_panic_on_file_not_dir() {

FILE: core/lib/tests/flash-lazy-removes-issue-466.rs
  constant FLASH_MESSAGE (line 6) | const FLASH_MESSAGE: &str = "Hey! I'm a flash message. :)";
  function set (line 9) | fn set() -> Flash<&'static str> {
  function unused (line 14) | fn unused(flash: Option<FlashMessage<'_>>) -> Option<()> {
  function used (line 19) | fn used(flash: Option<FlashMessage<'_>>) -> Option<String> {
  function test (line 28) | fn test() {

FILE: core/lib/tests/form-validation-names.rs
  type Cat (line 8) | struct Cat<'v> {
  type Dog (line 17) | struct Dog<'v> {
  type Person (line 24) | struct Person<'v> {
  function starts_with (line 31) | fn starts_with<'v, S: AsRef<str>>(string: S, prefix: &str) -> Result<(),...
  function errors (line 40) | fn errors<'v, T: FromForm<'v> + Debug + 'v>(string: &'v str) -> Errors<'...
  function test_form_validation_context (line 45) | fn test_form_validation_context() {

FILE: core/lib/tests/form_method-issue-45.rs
  type FormData (line 6) | struct FormData {
  function patch (line 11) | fn patch(form_data: Form<FormData>) -> &'static str {
  function urr (line 17) | fn urr(form_data: Form<FormData>) -> &'static str {
  function vc (line 23) | fn vc(form_data: Form<FormData>) -> &'static str {
  function method_eval (line 34) | fn method_eval() {
  function get_passes_through (line 66) | fn get_passes_through() {

FILE: core/lib/tests/form_value_decoding-issue-82.rs
  function bug (line 6) | fn bug(form_data: Form<String>) -> String {
  function check_decoding (line 16) | fn check_decoding(raw: &str, decoded: &str) {
  function test_proper_decoding (line 28) | fn test_proper_decoding() {

FILE: core/lib/tests/form_value_from_encoded_str-issue-1425.rs
  function test_from_form_value_encoded (line 15) | fn test_from_form_value_encoded() {

FILE: core/lib/tests/forward-includes-status-1560.rs
  type Authenticated (line 6) | struct Authenticated;
    type Error (line 10) | type Error = std::convert::Infallible;
    method from_request (line 12) | async fn from_request(request: &'r Request<'_>) -> request::Outcome<Se...
  type TeapotForward (line 21) | struct TeapotForward;
    type Error (line 25) | type Error = std::convert::Infallible;
    method from_request (line 27) | async fn from_request(_: &'r Request<'_>) -> request::Outcome<Self, Se...
  function auth (line 33) | fn auth(_name: Authenticated) -> &'static str {
  function public (line 38) | fn public() -> &'static str {
  function teapot (line 43) | fn teapot(_teapot: TeapotForward) -> &'static str {
  function auth_needed (line 48) | fn auth_needed(_auth: Authenticated) -> &'static str {
  function catcher (line 53) | fn catcher() -> &'static str {
  function authorized_forwards (line 65) | fn authorized_forwards() {
  function unauthorized_custom_catcher (line 92) | fn unauthorized_custom_catcher() {
  function use_last_forward (line 104) | fn use_last_forward() {

FILE: core/lib/tests/head_handling.rs
  function empty (line 7) | fn empty() -> Status {
  function index (line 12) | fn index() -> &'static str {
  function other (line 17) | fn other() -> RawJson<&'static str> {
  function routes (line 28) | fn routes() -> Vec<Route> {
  function auto_head (line 33) | fn auto_head() {
  function user_head (line 49) | fn user_head() {

FILE: core/lib/tests/http_serde.rs
  type UriContainer (line 10) | struct UriContainer<'a> {
  type UriContainerOwned (line 19) | struct UriContainerOwned {
  type MethodContainer (line 28) | struct MethodContainer {
  type StatusContainer (line 35) | struct StatusContainer {
  function uri_serde (line 42) | fn uri_serde() {
  function uri_serde_round_trip (line 76) | fn uri_serde_round_trip() {
  function method_serde (line 131) | fn method_serde() {
  function status_serde (line 160) | fn status_serde() {

FILE: core/lib/tests/launch-inspect.rs
  function test_inspectable_launch_state (line 4) | async fn test_inspectable_launch_state() -> Result<(), rocket::Error> {
  function test_inspectable_launch_state_in_liftoff (line 18) | async fn test_inspectable_launch_state_in_liftoff() -> Result<(), rocket...
  function test_launch_state_is_well_ordered (line 41) | async fn test_launch_state_is_well_ordered() -> Result<(), rocket::Error> {
  function negative_test_launch_state (line 66) | async fn negative_test_launch_state() {

FILE: core/lib/tests/limits.rs
  function index (line 6) | fn index(form: Form<String>) -> String {
  function rocket_with_forms_limit (line 16) | fn rocket_with_forms_limit(limit: u64) -> Rocket<Build> {
  function large_enough (line 23) | fn large_enough() {
  function just_large_enough (line 34) | fn just_large_enough() {
  function much_too_small (line 45) | fn much_too_small() {
  function contracted (line 56) | fn contracted() {

FILE: core/lib/tests/local-client-access-runtime-in-drop.rs
  type SpawnBlockingOnDrop (line 3) | struct SpawnBlockingOnDrop;
  method drop (line 6) | fn drop(&mut self) {
  function test_access_runtime_in_state_drop (line 12) | fn test_access_runtime_in_state_drop() {

FILE: core/lib/tests/local-client-json.rs
  function int (line 7) | fn int() -> Json<i32> { Json(5) }
  function nil (line 8) | fn nil() -> Json<()> { Json(()) }
  function async_json_works (line 11) | async fn async_json_works() {

FILE: core/lib/tests/local-request-content-type-issue-505.rs
  type HasContentType (line 8) | struct HasContentType;
    type Error (line 12) | type Error = ();
    method from_request (line 14) | async fn from_request(req: &'r Request<'_>) -> request::Outcome<Self, ...
    type Error (line 23) | type Error = ();
    method from_data (line 25) | async fn from_data(req: &'r Request<'_>, data: Data<'r>) -> data::Outc...
  function rg_ct (line 31) | fn rg_ct(ct: Option<HasContentType>) -> &'static str {
  function data_has_ct (line 36) | fn data_has_ct(_ct: HasContentType) -> &'static str {
  function data_no_ct (line 41) | fn data_no_ct() -> &'static str {
  function rocket (line 52) | fn rocket() -> Rocket<Build> {
  function has_no_ct (line 57) | fn has_no_ct() {
  function has_ct (line 72) | fn has_ct() {

FILE: core/lib/tests/local_request_private_cookie-issue-368.rs
  function return_private_cookie (line 6) | fn return_private_cookie(cookies: &CookieJar<'_>) -> Option<String> {
  function private_cookie_is_returned (line 20) | fn private_cookie_is_returned() {
  function regular_cookie_is_not_returned (line 32) | fn regular_cookie_is_not_returned() {

FILE: core/lib/tests/many-cookie-jars-at-once.rs
  function multi_add (line 6) | fn multi_add(jar_a: &CookieJar<'_>, jar_b: &CookieJar<'_>) {
  function multi_get (line 12) | fn multi_get(jar_a: &CookieJar<'_>, jar_b: &CookieJar<'_>, jar_c: &Cooki...
  function rocket (line 26) | fn rocket() -> Rocket<Build> {
  function test_multi_add (line 31) | fn test_multi_add() {
  function test_multi_get (line 41) | fn test_multi_get() {

FILE: core/lib/tests/mapped-base-issue-1262.rs
  function prepend (line 4) | pub fn prepend(prefix: &str, route: Route) -> Route {
  function extend_routes (line 8) | pub fn extend_routes(prefix: &str, routes: Vec<Route>) -> Vec<Route> {
  function b (line 16) | fn b(id: u8) -> String { id.to_string() }
  function routes (line 18) | pub fn routes() -> Vec<rocket::Route> {
  function rocket (line 23) | fn rocket() -> Rocket<Build> {
  function only_prefix (line 32) | fn only_prefix() {
  function prefix_and_base (line 46) | fn prefix_and_base() {

FILE: core/lib/tests/mount_point.rs
  function bad_dynamic_mount (line 3) | fn bad_dynamic_mount() {
  function good_static_mount (line 8) | fn good_static_mount() {

FILE: core/lib/tests/msgpack_encoding.rs
  type Person (line 10) | struct Person<'r> {
  type Gender (line 17) | enum Gender {
  function named (line 24) | fn named(person: MsgPack<Person<'_>>) -> MsgPack<Person<'_>> {
  function compact (line 29) | fn compact(person: MsgPack<Person<'_>>) -> Compact<Person<'_>> {
  function rocket (line 33) | fn rocket() -> Rocket<Build> {
  constant OBJECT (line 38) | const OBJECT: Person<'static> = Person {
  constant COMPACT_BYTES (line 45) | const COMPACT_BYTES: &[u8] = &[
  constant NAMED_BYTES (line 50) | const NAMED_BYTES: &[u8] = &[
  function check_roundtrip (line 56) | fn check_roundtrip() {

FILE: core/lib/tests/multipart-limit.rs
  type Data (line 9) | struct Data<'r> {
  function form (line 14) | fn form<'r>(form: Form<Data<'r>>) -> &'r str {
  function rocket_with_form_data_limit (line 18) | fn rocket_with_form_data_limit(limit: ByteUnit) -> Rocket<Build> {
  function test_multipart_limit (line 26) | fn test_multipart_limit() {

FILE: core/lib/tests/nested-fairing-attaches.rs
  type Counter (line 10) | struct Counter {
  function index (line 16) | fn index(counter: &State<Counter>) -> String {
  function rocket (line 22) | fn rocket() -> Rocket<Build> {
  function test_counts (line 47) | fn test_counts() {

FILE: core/lib/tests/on_launch_fairing_can_inspect_port.rs
  function on_ignite_fairing_can_inspect_port (line 9) | async fn on_ignite_fairing_can_inspect_port() {

FILE: core/lib/tests/panic-handling.rs
  function panic_route (line 9) | fn panic_route() -> &'static str {
  function panic_catcher (line 14) | fn panic_catcher() -> &'static str {
  function ise (line 19) | fn ise() -> &'static str {
  function pre_future_route (line 23) | fn pre_future_route<'r>(_: &'r Request<'_>, _: Data<'r>) -> route::BoxFu...
  function rocket (line 27) | fn rocket() -> Rocket<Build> {
  function catches_route_panic (line 34) | fn catches_route_panic() {
  function catches_catcher_panic (line 43) | fn catches_catcher_panic() {
  function catches_double_panic (line 52) | fn catches_double_panic() {
  function catches_early_route_panic (line 66) | fn catches_early_route_panic() {
  function catches_early_catcher_panic (line 75) | fn catches_early_catcher_panic() {

FILE: core/lib/tests/precise-content-type-matching.rs
  function specified (line 4) | fn specified() -> &'static str {
  function unspecified (line 9) | fn unspecified() -> &'static str {
  function specified_json (line 14) | fn specified_json() -> &'static str {
  function specified_html (line 19) | fn specified_html() -> &'static str {
  function rocket (line 30) | fn rocket() -> Rocket<Build> {
  function exact_match_or_forward (line 57) | fn exact_match_or_forward() {
  function exact_match_or_none (line 64) | fn exact_match_or_none() {

FILE: core/lib/tests/raw-strings-multipart-files-1987.rs
  type Data (line 8) | struct Data<'r> {
  function form (line 15) | fn form(form: Form<Data<'_>>) -> String {
  function test_multipart_raw_strings_from_files (line 20) | fn test_multipart_raw_strings_from_files() {

FILE: core/lib/tests/recursive-singleton-fairing.rs
  type Singleton (line 5) | struct Singleton(Kind, Kind, bool);
  method info (line 9) | fn info(&self) -> Info {
  method on_ignite (line 16) | async fn on_ignite(&self, rocket: Rocket<Build>) -> fairing::Result {
  function recursive_singleton_ok (line 28) | async fn recursive_singleton_ok() {
  function recursive_singleton_bad (line 51) | async fn recursive_singleton_bad() {

FILE: core/lib/tests/redirect_from_catcher-issue-113.rs
  function not_found (line 6) | fn not_found() -> Redirect {
  function error_catcher_redirect (line 16) | fn error_catcher_redirect() {

FILE: core/lib/tests/replace-content-type-518.rs
  function index (line 5) | fn index(_data: rocket::Data<'_>) -> &'static str { "json" }
  function other_index (line 8) | fn other_index(_data: rocket::Data<'_>) -> &'static str { "other" }
  function rocket (line 10) | fn rocket() -> Rocket<Build> {
  function check_fairing_changes_content_type (line 25) | fn check_fairing_changes_content_type() {

FILE: core/lib/tests/responder_lifetime-issue-345.rs
  type SomeState (line 8) | struct SomeState;
  type CustomResponder (line 10) | pub struct CustomResponder<'r, R> {
  function respond_to (line 16) | fn respond_to(self, req: &'r Request<'_>) -> Result<'o> {
  function unit_state (line 22) | fn unit_state(state: &State<SomeState>) -> CustomResponder<'_, ()> {
  function string_state (line 27) | fn string_state(state: &State<SomeState>) -> CustomResponder<'_, String> {

FILE: core/lib/tests/route_guard.rs
  function files (line 8) | fn files(route: &Route, path: PathBuf) -> String {
  function assert_path (line 16) | fn assert_path(client: &Client, path: &str) {
  function check_mount_path (line 22) | fn check_mount_path() {

FILE: core/lib/tests/scoped-uri.rs
  function hello (line 8) | pub fn hello() -> String {
  function hello_name (line 14) | fn hello_name(name: String) -> String {
  function rocket (line 18) | fn rocket() -> Rocket<Build> {
  function test_inner_hello (line 25) | fn test_inner_hello() {
  function test_hello_name (line 32) | fn test_hello_name() {

FILE: core/lib/tests/segments-issues-41-86.rs
  function test (line 6) | fn test(path: Segments<'_, Path>) -> String {
  function two (line 11) | fn two(path: Segments<'_, Path>) -> String {
  function one_two (line 16) | fn one_two(path: Segments<'_, Path>) -> String {
  function none (line 21) | fn none(path: Segments<'_, Path>) -> String {
  function dual (line 26) | fn dual(user: String, path: Segments<'_, Path>) -> String {
  function segments_works (line 35) | fn segments_works() {

FILE: core/lib/tests/sentinel.rs
  function two_states (line 4) | fn two_states(_one: &State<u32>, _two: &State<String>) {}
  function one_state (line 7) | fn one_state<'r>(_three: &'r State<u8>, s: &'r str) -> &'r str { s }
  function state_sentinel_works (line 10) | async fn state_sentinel_works() {
  type Data (line 109) | struct Data;
    type Error (line 113) | type Error = Error;
    method from_data (line 114) | async fn from_data(_: &'r Request<'_>, _: data::Data<'r>) -> data::Out...
  method abort (line 120) | fn abort(rocket: &Rocket<Ignite>) -> bool {
  function with_data (line 126) | fn with_data(_data: Data) {}
  function data_sentinel_works (line 129) | async fn data_sentinel_works() {
  function inner_sentinels_detected (line 148) | fn inner_sentinels_detected() {
  function known_macro_sentinel_works (line 277) | async fn known_macro_sentinel_works() {

FILE: core/lib/tests/session-cookies-issue-1506.rs
  function index (line 6) | fn index(jar: &CookieJar<'_>) {
  function session_cookie_is_session (line 15) | fn session_cookie_is_session() {

FILE: core/lib/tests/shield.rs
  function hello (line 10) | fn hello() { }
  function default_shield (line 40) | fn default_shield() {
  function shield_singleton (line 55) | fn shield_singleton() {
  function default_headers_test (line 72) | fn default_headers_test() {
  function disable_headers_test (line 81) | fn disable_headers_test() {
  function additional_headers_test (line 115) | fn additional_headers_test() {
  function uri_test (line 139) | fn uri_test() {
  function prefetch_test (line 151) | fn prefetch_test() {
  function bad_uri_permission_test (line 170) | fn bad_uri_permission_test() {
  function bad_uri_permission_test2 (line 177) | fn bad_uri_permission_test2() {
  function permission_test (line 183) | fn permission_test() {

FILE: core/lib/tests/shutdown-fairings.rs
  type Flags (line 15) | struct Flags {
  function shutdown_fairing_runs (line 21) | fn shutdown_fairing_runs() {
  function async_shutdown_fairing_runs (line 46) | async fn async_shutdown_fairing_runs() {
  function multiple_shutdown_fairing_runs (line 71) | async fn multiple_shutdown_fairing_runs() {
  function async_slow_shutdown_doesnt_elongate_grace (line 95) | async fn async_slow_shutdown_doesnt_elongate_grace() {
  function background_tasks_dont_prevent_terminate (line 126) | fn background_tasks_dont_prevent_terminate() {

FILE: core/lib/tests/strict_and_lenient_forms.rs
  type MyForm (line 6) | struct MyForm<'r> {
  function strict (line 11) | fn strict<'r>(form: Form<Strict<MyForm<'r>>>) -> &'r str {
  function lenient (line 16) | fn lenient<'r>(form: Form<MyForm<'r>>) -> &'r str {
  constant FIELD_VALUE (line 25) | const FIELD_VALUE: &str = "just_some_value";
  function client (line 27) | fn client() -> Client {
  function test_strict_form (line 32) | fn test_strict_form() {
  function test_lenient_form (line 51) | fn test_lenient_form() {

FILE: core/lib/tests/timer-on-attach.rs
  function test_await_timer_inside_attach (line 2) | async fn test_await_timer_inside_attach() {

FILE: core/lib/tests/tls-config-from-source-1503.rs
  function tls_config_from_source (line 10) | fn tls_config_from_source() {

FILE: core/lib/tests/twice_managed_state.rs
  type A (line 1) | struct A;
  function twice_managed_state (line 5) | fn twice_managed_state() {

FILE: core/lib/tests/typed-uri-docs-redef-issue-1373.rs
  function simple (line 7) | fn simple(id: i32) { }
  function simple (line 13) | fn simple(id: i32) { }

FILE: core/lib/tests/unsound-local-request-1312.rs
  function test_local_request_clone_soundness (line 5) | fn test_local_request_clone_soundness() {

FILE: core/lib/tests/untracked-vs-tracked.rs
  function add (line 6) | fn add(jar: &CookieJar<'_>) {
  function get (line 11) | fn get<'a>(jar: &'a CookieJar<'_>) -> Option<&'a str> {
  function rocket (line 21) | fn rocket() -> Rocket<Build> {
  function test_tracked (line 27) | fn test_tracked() {
  function test_untracked (line 39) | fn test_untracked() {

FILE: core/lib/tests/uri-percent-encoding-issue-808.rs
  constant NAME (line 6) | const NAME: &str = "John[]|\\%@^";
  function hello (line 9) | fn hello(name: String) -> String {
  function raw_redirect (line 14) | fn raw_redirect() -> Redirect {
  function uri_redirect (line 19) | fn uri_redirect() -> Redirect {
  function rocket (line 23) | fn rocket() -> Rocket<Build> {
  function uri_percent_encoding_redirect (line 33) | fn uri_percent_encoding_redirect() {
  function uri_percent_encoding_get (line 49) | fn uri_percent_encoding_get() {

FILE: docs/tests/src/lib.rs
  function client (line 57) | pub fn client(routes: Vec<rocket::Route>) -> rocket::local::blocking::Cl...

FILE: examples/chat/src/main.rs
  type Message (line 16) | struct Message {
  function events (line 27) | async fn events(queue: &State<Sender<Message>>, mut end: Shutdown) -> Ev...
  function post (line 47) | fn post(form: Form<Message>, queue: &State<Sender<Message>>) {
  function rocket (line 53) | fn rocket() -> _ {

FILE: examples/chat/src/tests.rs
  function send_message (line 16) | async fn send_message<'c>(client: &'c Client, message: &Message) -> Loca...
  function gen_string (line 24) | fn gen_string(len: Range<usize>) -> String {
  function messages (line 33) | async fn messages() {
  function bad_messages (line 98) | async fn bad_messages() {

FILE: examples/chat/static/script.js
  function hashColor (line 21) | function hashColor(str) {
  function addRoom (line 33) | function addRoom(name) {
  function changeRoom (line 52) | function changeRoom(name) {
  function addMessage (line 72) | function addMessage(room, username, message, push = false) {
  function subscribe (line 87) | function subscribe(uri) {
  function setConnectedStatus (line 122) | function setConnectedStatus(status) {
  function init (line 128) | function init() {

FILE: examples/config/src/main.rs
  type AppConfig (line 12) | struct AppConfig {
  function read_config (line 18) | fn read_config(rocket_config: &Config, app_config: &State<AppConfig>) ->...
  function rocket (line 26) | fn rocket() -> _ {

FILE: examples/config/src/tests.rs
  function test_config (line 4) | async fn test_config(profile: &str) {
  function test_debug_config (line 29) | async fn test_debug_config() {
  function test_release_config (line 34) | async fn test_release_config() {

FILE: examples/cookies/src/main.rs
  function index (line 12) | fn index() -> RawHtml<&'static str> {
  function rocket (line 17) | fn rocket() -> _ {

FILE: examples/cookies/src/message.rs
  function submit (line 14) | fn submit(cookies: &CookieJar<'_>, message: Form<&str>) -> Redirect {
  function delete (line 20) | fn delete(cookies: &CookieJar<'_>) -> Redirect {
  function index (line 26) | fn index(cookies: &CookieJar<'_>) -> Template {
  function routes (line 32) | pub fn routes() -> Vec<rocket::Route> {

FILE: examples/cookies/src/session.rs
  type Login (line 10) | struct Login<'r> {
  type User (line 16) | struct User(usize);
    type Error (line 20) | type Error = std::convert::Infallible;
    method from_request (line 22) | async fn from_request(request: &'r Request<'_>) -> request::Outcome<Us...
  function index (line 39) | fn index(user: User) -> Template {
  function no_auth_index (line 46) | fn no_auth_index() -> Redirect {
  function login (line 51) | fn login(_user: User) -> Redirect {
  function login_page (line 56) | fn login_page(flash: Option<FlashMessage<'_>>) -> Template {
  function post_login (line 61) | fn post_login(jar: &CookieJar<'_>, login: Form<Login<'_>>) -> Result<Red...
  function logout (line 71) | fn logout(jar: &CookieJar<'_>) -> Flash<Redirect> {
  function routes (line 76) | pub fn routes() -> Vec<rocket::Route> {

FILE: examples/cookies/src/tests.rs
  function user_id_cookie (line 5) | fn user_id_cookie(response: &LocalResponse<'_>) -> Option<Cookie<'static...
  function login (line 14) | fn login(client: &Client, user: &str, pass: &str) -> Option<Cookie<'stat...
  function redirect_logged_out_session (line 24) | fn redirect_logged_out_session() {
  function login_fails (line 37) | fn login_fails() {
  function login_logout_succeeds (line 44) | fn login_logout_succeeds() {
  function test_message (line 77) | fn test_message() {

FILE: examples/databases/db/diesel/migrations/20210329150332_create_posts_table/up.sql
  type posts (line 1) | CREATE TABLE posts (

FILE: examples/databases/db/diesel/mysql-migrations/20210329150332_create_posts_table/up.sql
  type posts (line 1) | CREATE TABLE posts (

FILE: examples/databases/db/sqlx/migrations/20210331024424_create-posts-table.sql
  type posts (line 1) | CREATE TABLE posts (

FILE: examples/databases/src/diesel_mysql.rs
  type Result (line 9) | type Result<T, E = Debug<diesel::result::Error>> = std::result::Result<T...
  type Db (line 13) | struct Db(MysqlPool);
  type Post (line 18) | struct Post {
  function create (line 37) | async fn create(mut db: Connection<Db>, mut post: Json<Post>) -> Result<...
  function list (line 58) | async fn list(mut db: Connection<Db>) -> Result<Json<Vec<Option<i64>>>> {
  function read (line 68) | async fn read(mut db: Connection<Db>, id: i64) -> Option<Json<Post>> {
  function delete (line 78) | async fn delete(mut db: Connection<Db>, id: i64) -> Result<Option<()>> {
  function destroy (line 88) | async fn destroy(mut db: Connection<Db>) -> Result<()> {
  function run_migrations (line 93) | async fn run_migrations(rocket: Rocket<Build>) -> Rocket<Build> {
  function stage (line 116) | pub fn stage() -> AdHoc {

FILE: examples/databases/src/diesel_sqlite.rs
  type Db (line 9) | struct Db(diesel::SqliteConnection);
  type Result (line 11) | type Result<T, E = Debug<diesel::result::Error>> = std::result::Result<T...
  type Post (line 16) | struct Post {
  function create (line 35) | async fn create(db: Db, mut post: Json<Post>) -> Result<Created<Json<Pos...
  function list (line 49) | async fn list(db: Db) -> Result<Json<Vec<Option<i32>>>> {
  function read (line 60) | async fn read(db: Db, id: i32) -> Option<Json<Post>> {
  function delete (line 69) | async fn delete(db: Db, id: i32) -> Result<Option<()>> {
  function destroy (line 80) | async fn destroy(db: Db) -> Result<()> {
  function run_migrations (line 86) | async fn run_migrations(rocket: Rocket<Build>) -> Rocket<Build> {
  function stage (line 99) | pub fn stage() -> AdHoc {

FILE: examples/databases/src/main.rs
  function index (line 14) | fn index() -> Redirect {
  function rocket (line 19) | fn rocket() -> _ {

FILE: examples/databases/src/rusqlite.rs
  type Db (line 11) | struct Db(rusqlite::Connection);
  type Post (line 15) | struct Post {
  type Result (line 22) | type Result<T, E = Debug<rusqlite::Error>> = std::result::Result<T, E>;
  function create (line 25) | async fn create(db: Db, mut post: Json<Post>) -> Result<Created<Json<Pos...
  function list (line 38) | async fn list(db: Db) -> Result<Json<Vec<i64>>> {
  function read (line 49) | async fn read(db: Db, id: i64) -> Option<Json<Post>> {
  function delete (line 59) | async fn delete(db: Db, id: i64) -> Result<Option<()>> {
  function destroy (line 68) | async fn destroy(db: Db) -> Result<()> {
  function init_db (line 74) | async fn init_db(rocket: Rocket<Build>) -> Rocket<Build> {
  function stage (line 91) | pub fn stage() -> AdHoc {

FILE: examples/databases/src/sqlx.rs
  type Db (line 12) | struct Db(sqlx::SqlitePool);
  type Result (line 14) | type Result<T, E = rocket::response::Debug<sqlx::Error>> = std::result::...
  type Post (line 18) | struct Post {
  function create (line 26) | async fn create(mut db: Connection<Db>, mut post: Json<Post>) -> Result<...
  function list (line 41) | async fn list(mut db: Connection<Db>) -> Result<Json<Vec<i64>>> {
  function read (line 52) | async fn read(mut db: Connection<Db>, id: i64) -> Option<Json<Post>> {
  function delete (line 61) | async fn delete(mut db: Connection<Db>, id: i64) -> Result<Option<()>> {
  function destroy (line 70) | async fn destroy(mut db: Connection<Db>) -> Result<()> {
  function run_migrations (line 76) | async fn run_migrations(rocket: Rocket<Build>) -> fairing::Result {
  function stage (line 89) | pub fn stage() -> AdHoc {

FILE: examples/databases/src/tests.rs
  type Post (line 8) | struct Post {
  function test (line 13) | fn test(base: &str, stage: AdHoc) {
  function test_sqlx (line 66) | fn test_sqlx() {
  function test_diesel (line 71) | fn test_diesel() {
  function test_rusqlite (line 76) | fn test_rusqlite() {

FILE: examples/error-handling/src/main.rs
  function hello (line 10) | fn hello(name: &str, age: i8) -> String {
  function forced_error (line 15) | fn forced_error(code: u16) -> Status {
  function general_not_found (line 20) | fn general_not_found() -> content::RawHtml<&'static str> {
  function hello_not_found (line 28) | fn hello_not_found(req: &Request<'_>) -> content::RawHtml<String> {
  function sergio_error (line 36) | fn sergio_error() -> &'static str {
  function default_catcher (line 41) | fn default_catcher(status: Status, req: &Request<'_>) -> status::Custom<...
  function unmanaged (line 48) | fn unmanaged(_u8: &rocket::State<u8>, _string: &rocket::State<String>) { }
  function rocket (line 50) | fn rocket() -> Rocket<Build> {
  function main (line 61) | async fn main() {

FILE: examples/error-handling/src/tests.rs
  function test_hello (line 5) | fn test_hello() {
  function forced_error (line 17) | fn forced_error() {
  function test_hello_invalid_age (line 46) | fn test_hello_invalid_age() {
  function test_hello_sergio (line 68) | fn test_hello_sergio() {

FILE: examples/fairings/src/main.rs
  type Token (line 12) | struct Token(i64);
  type Counter (line 17) | struct Counter {
  method info (line 24) | fn info(&self) -> Info {
  method on_ignite (line 31) | async fn on_ignite(&self, rocket: Rocket<Build>) -> fairing::Result {
  method on_request (line 42) | async fn on_request(&self, request: &mut Request<'_>, _: &mut Data<'_>) {
  function hello (line 52) | fn hello() -> &'static str {
  function token (line 57) | fn token(token: &State<Token>) -> String {
  function rocket (line 62) | fn rocket() -> _ {

FILE: examples/fairings/src/tests.rs
  function rewrite_get_put (line 5) | fn rewrite_get_put() {
  function counts (line 12) | fn counts() {
  function token (line 32) | fn token() {

FILE: examples/forms/src/main.rs
  type Password (line 11) | struct Password<'v> {
  type Rights (line 22) | enum Rights {
  type Category (line 29) | enum Category {
  type Submission (line 39) | struct Submission<'v> {
  type Account (line 55) | struct Account<'v> {
  type Submit (line 65) | struct Submit<'v> {
  function index (line 71) | fn index() -> Template {
  function submit (line 79) | fn submit<'r>(form: Form<Contextual<'r, Submit<'r>>>) -> (Status, Templa...
  function rocket (line 92) | fn rocket() -> _ {

FILE: examples/forms/src/tests.rs
  method fmt (line 8) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  function test_good_forms (line 44) | fn test_good_forms() {
  function check_semantically_invalid_forms (line 123) | fn check_semantically_invalid_forms() {
  function check_structurally_invalid_forms (line 179) | fn check_structurally_invalid_forms() {
  function check_bad_utf8 (line 187) | fn check_bad_utf8() {

FILE: examples/hello/src/main.rs
  type Lang (line 6) | enum Lang {
  type Options (line 15) | struct Options<'r> {
  function world (line 23) | fn world() -> &'static str {
  function mir (line 30) | fn mir() -> &'static str {
  function wave (line 37) | fn wave(name: &str, age: u8) -> String {
  function hello (line 54) | fn hello(lang: Option<Lang>, opt: Options<'_>) -> String {
  function rocket (line 76) | fn rocket() -> _ {

FILE: examples/hello/src/tests.rs
  function hello (line 5) | fn hello() {
  function hello_world (line 42) | fn hello_world() {
  function hello_mir (line 49) | fn hello_mir() {
  function wave (line 56) | fn wave() {

FILE: examples/manual-routing/src/main.rs
  function forward (line 11) | fn forward<'r>(_req: &'r Request, data: Data<'r>) -> route::BoxFuture<'r> {
  function hi (line 15) | fn hi<'r>(req: &'r Request, _: Data<'r>) -> route::BoxFuture<'r> {
  function name (line 19) | fn name<'r>(req: &'r Request, _: Data<'r>) -> route::BoxFuture<'r> {
  function echo_url (line 27) | fn echo_url<'r>(req: &'r Request, _: Data<'r>) -> route::BoxFuture<'r> {
  function upload (line 37) | fn upload<'r>(req: &'r Request, data: Data<'r>) -> route::BoxFuture<'r> {
  function get_upload (line 60) | fn get_upload<'r>(req: &'r Request, _: Data<'r>) -> route::BoxFuture<'r> {
  function not_found_handler (line 65) | fn not_found_handler<'r>(_: Status, req: &'r Request) -> catcher::BoxFut...
  type CustomHandler (line 71) | struct CustomHandler {
    method routes (line 76) | fn routes(data: &'static str) -> Vec<Route> {
    method handle (line 83) | async fn handle<'r>(&self, req: &'r Request<'_>, data: Data<'r>) -> ro...
  function rocket (line 94) | fn rocket() -> _ {

FILE: examples/manual-routing/src/tests.rs
  function test (line 5) | fn test(uri: &str, content_type: ContentType, status: Status, body: Stri...
  function test_forward (line 13) | fn test_forward() {
  function test_name (line 18) | fn test_name() {
  function test_echo (line 26) | fn test_echo() {
  function test_upload (line 32) | fn test_upload() {
  function test_not_found (line 53) | fn test_not_found() {

FILE: examples/pastebin/src/main.rs
  constant HOST (line 17) | const HOST: Absolute<'static> = uri!("http://localhost:8000");
  constant ID_LENGTH (line 18) | const ID_LENGTH: usize = 3;
  function upload (line 21) | async fn upload(paste: Data<'_>) -> io::Result<String> {
  function retrieve (line 28) | async fn retrieve(id: PasteId<'_>) -> Option<RawText<File>> {
  function delete (line 33) | async fn delete(id: PasteId<'_>) -> Option<()> {
  function index (line 38) | fn index() -> &'static str {
  function rocket (line 56) | fn rocket() -> _ {

FILE: examples/pastebin/src/paste_id.rs
  type PasteId (line 9) | pub struct PasteId<'a>(Cow<'a, str>);
  function new (line 16) | pub fn new(size: usize) -> PasteId<'static> {
  function file_path (line 29) | pub fn file_path(&self) -> PathBuf {
  type Error (line 38) | type Error = &'a str;
  function from_param (line 40) | fn from_param(param: &'a str) -> Result<Self, Self::Error> {

FILE: examples/pastebin/src/tests.rs
  function extract_id (line 6) | fn extract_id(from: &str) -> Option<String> {
  function check_index (line 11) | fn check_index() {
  function upload_paste (line 21) | fn upload_paste(client: &Client, body: &str) -> String {
  function download_paste (line 28) | fn download_paste(client: &Client, id: &str) -> Option<String> {
  function delete_paste (line 38) | fn delete_paste(client: &Client, id: &str) {
  function pasting (line 45) | fn pasting() {

FILE: examples/responders/src/main.rs
  constant FILENAME (line 16) | const FILENAME: &str = "big_file.dat";
  function upload (line 20) | async fn upload(mut file: Capped<TempFile<'_>>, config: &Config) -> io::...
  function file (line 26) | async fn file(config: &Config) -> Option<NamedFile> {
  function delete (line 31) | async fn delete(config: &Config) -> Option<()> {
  function many_his (line 45) | fn many_his() -> TextStream![&'static str] {
  function one_hi_per_ms (line 50) | fn one_hi_per_ms(mut shutdown: Shutdown, n: u8) -> TextStream![&'static ...
  function progress_page (line 66) | fn progress_page() -> RawHtml<&'static str> {
  function progress_stream (line 86) | fn progress_stream() -> EventStream![] {
  function redir_root (line 106) | fn redir_root() -> Redirect {
  function redir_login (line 111) | fn redir_login() -> &'static str {
  function maybe_redir (line 116) | fn maybe_redir(name: &str) -> Result<&'static str, Redirect> {
  function xml (line 137) | fn xml() -> content::RawXml<&'static str> {
  function json (line 142) | fn json() -> content::RawJson<&'static str> {
  function not_found (line 147) | fn not_found(request: &Request<'_>) -> content::RawHtml<String> {
  function json_or_msgpack (line 170) | fn json_or_msgpack(kind: &str) -> Either<RawJson<&'static str>, RawMsgPa...
  type StoredData (line 185) | enum StoredData {
  type Kind (line 194) | enum Kind {
  function custom (line 201) | async fn custom(kind: Option<Kind>) -> StoredData {
  function rocket (line 214) | fn rocket() -> _ {

FILE: examples/responders/src/tests.rs
  function test_file (line 10) | fn test_file() {
  function test_many_his (line 34) | fn test_many_his() {
  function test_one_hi_per_second (line 45) | async fn test_one_hi_per_second() {
  function test_redir_root (line 81) | fn test_redir_root() {
  function test_login (line 97) | fn test_login() {
  function test_xml (line 117) | fn test_xml() {
  function test_either (line 140) | fn test_either() {
  function test_custom (line 156) | fn test_custom() {

FILE: examples/serialization/src/json.rs
  type Id (line 9) | type Id = usize;
  type MessageList (line 12) | type MessageList = Mutex<Vec<String>>;
  type Messages (line 13) | type Messages<'r> = &'r State<MessageList>;
  type Message (line 17) | struct Message<'r> {
  function new (line 23) | async fn new(message: Json<Message<'_>>, list: Messages<'_>) -> Value {
  function update (line 31) | async fn update(id: Id, message: Json<Message<'_>>, list: Messages<'_>) ...
  function get (line 42) | async fn get(id: Id, list: Messages<'_>) -> Option<Json<Message<'_>>> {
  function not_found (line 52) | fn not_found() -> Value {
  function stage (line 59) | pub fn stage() -> rocket::fairing::AdHoc {

FILE: examples/serialization/src/main.rs
  function rocket (line 10) | fn rocket() -> _ {

FILE: examples/serialization/src/msgpack.rs
  type Message (line 5) | struct Message<'r> {
  function get (line 11) | fn get(id: usize) -> MsgPack<Message<'static>> {
  function echo (line 16) | fn echo(data: MsgPack<Message<'_>>) -> &str {
  function stage (line 20) | pub fn stage() -> rocket::fairing::AdHoc {

FILE: examples/serialization/src/tests.rs
  type Message (line 7) | struct Message {
    method new (line 13) | fn new(message: impl Into<String>) -> Self {
    method with_id (line 17) | fn with_id(mut self, id: usize) -> Self {
  function json_bad_get_put (line 24) | fn json_bad_get_put() {
  function json_post_get_put_get (line 60) | fn json_post_get_put_get() {
  function msgpack_get (line 94) | fn msgpack_get() {
  function msgpack_post (line 106) | fn msgpack_post() {
  function uuid (line 118) | fn uuid() {

FILE: examples/serialization/src/uuid.rs
  type People (line 8) | struct People(HashMap<Uuid, &'static str>);
  function people (line 11) | fn people(id: Uuid, people: &State<People>) -> Result<String, String> {
  function stage (line 17) | pub fn stage() -> rocket::fairing::AdHoc {

FILE: examples/state/src/main.rs
  function rocket (line 10) | fn rocket() -> _ {

FILE: examples/state/src/managed_hit_count.rs
  type HitCount (line 7) | struct HitCount(AtomicUsize);
  function index (line 10) | fn index(hit_count: &State<HitCount>) -> RawHtml<String> {
  function stage (line 15) | pub fn stage() -> AdHoc {

FILE: examples/state/src/managed_queue.rs
  type Tx (line 5) | struct Tx(flume::Sender<String>);
  type Rx (line 6) | struct Rx(flume::Receiver<String>);
  function push (line 9) | fn push(event: String, tx: &State<Tx>) -> Result<(), Status> {
  function pop (line 14) | fn pop(rx: &State<Rx>) -> Option<String> {
  function stage (line 18) | pub fn stage() -> AdHoc {

FILE: examples/state/src/request_local.rs
  type Atomics (line 9) | pub struct Atomics {
  type Guard1 (line 14) | struct Guard1;
    type Error (line 21) | type Error = ();
    method from_request (line 23) | async fn from_request(req: &'r Request<'_>) -> request::Outcome<Self, ...
  type Guard2 (line 15) | struct Guard2;
    type Error (line 36) | type Error = ();
    method from_request (line 38) | async fn from_request(req: &'r Request<'_>) -> request::Outcome<Self, ...
  type Guard3 (line 16) | struct Guard3;
    type Error (line 46) | type Error = ();
    method from_request (line 48) | async fn from_request(req: &'r Request<'_>) -> request::Outcome<Self, ...
  type Guard4 (line 17) | struct Guard4;
    type Error (line 61) | type Error = ();
    method from_request (line 63) | async fn from_request(req: &'r Request<'_>) -> request::Outcome<Self, ...
  function one_two (line 70) | fn one_two(_g1: Guard1, _g2: Guard2, state: &State<Atomics>) -> String {
  function three_four (line 75) | fn three_four(_g3: Guard3, _g4: Guard4, state: &State<Atomics>) -> String {
  function all (line 80) | fn all(
  function stage (line 90) | pub fn stage() -> AdHoc {

FILE: examples/state/src/tests.rs
  function test_count (line 5) | fn test_count() {
  function test_count_parallel (line 22) | fn test_count_parallel() { test_count() }
  function test_count_parallel_2 (line 23) | fn test_count_parallel_2() { test_count() }
  function test_count_parallel_3 (line 24) | fn test_count_parallel_3() { test_count() }
  function test_count_parallel_4 (line 25) | fn test_count_parallel_4() { test_count() }
  function test_count_parallel_5 (line 26) | fn test_count_parallel_5() { test_count() }
  function test_count_parallel_6 (line 27) | fn test_count_parallel_6() { test_count() }
  function test_count_parallel_7 (line 28) | fn test_count_parallel_7() { test_count() }
  function test_count_parallel_8 (line 29) | fn test_count_parallel_8() { test_count() }
  function test_count_parallel_9 (line 30) | fn test_count_parallel_9() { test_count() }
  function test_queue_push_pop (line 33) | fn test_queue_push_pop() {
  function test_request_local_state (line 50) | fn test_request_local_state() {

FILE: examples/static-files/src/main.rs
  function second (line 12) | pub async fn second(path: PathBuf) -> Option<NamedFile> {
  function rocket (line 23) | fn rocket() -> _ {

FILE: examples/static-files/src/tests.rs
  function test_query_file (line 10) | fn test_query_file<T> (path: &str, file: T, status: Status)
  function read_file_content (line 24) | fn read_file_content(path: &str) -> std::io::Result<Vec<u8>> {
  function test_index_html (line 32) | fn test_index_html() {
  function test_hidden_index_html (line 41) | fn test_hidden_index_html() {
  function test_hidden_file (line 50) | fn test_hidden_file() {
  function test_icon_file (line 59) | fn test_icon_file() {
  function test_invalid_path (line 65) | fn test_invalid_path() {

FILE: examples/templating/src/hbs.rs
  function index (line 9) | pub fn index() -> Redirect {
  function hello (line 14) | pub fn hello(name: &str) -> Template {
  function about (line 23) | pub fn about() -> Template {
  function not_found (line 31) | pub fn not_found(req: &Request<'_>) -> Template {
  function wow_helper (line 37) | fn wow_helper(
  function customize (line 53) | pub fn customize(hbs: &mut Handlebars) {

FILE: examples/templating/src/main.rs
  function index (line 15) | fn index() -> RawHtml<&'static str> {
  function rocket (line 24) | fn rocket() -> _ {

FILE: examples/templating/src/minijinja.rs
  function index (line 9) | pub fn index() -> Redirect {
  function hello (line 14) | pub fn hello(name: &str) -> Template {
  function about (line 26) | pub fn about() -> Template {
  function not_found (line 36) | pub fn not_found(req: &Request<'_>) -> Template {
  function customize (line 47) | pub fn customize(env: &mut Environment) {

FILE: examples/templating/src/tera.rs
  function index (line 7) | pub fn index() -> Redirect {
  function hello (line 12) | pub fn hello(name: &str) -> Template {
  function about (line 21) | pub fn about() -> Template {
  function not_found (line 28) | pub fn not_found(req: &Request<'_>) -> Template {
  function customize (line 34) | pub fn customize(tera: &mut Tera) {

FILE: examples/templating/src/tests.rs
  function test_root (line 7) | fn test_root(kind: &str) {
  function test_name (line 30) | fn test_name(base: &str) {
  function test_404 (line 38) | fn test_404(base: &str) {
  function test_about (line 57) | fn test_about(base: &str) {
  function test_index (line 64) | fn test_index() {
  function hbs (line 73) | fn hbs() {
  function tera (line 81) | fn tera() {
  function minijinja (line 89) | fn minijinja() {

FILE: examples/testing/src/async_required.rs
  function rendezvous (line 6) | async fn rendezvous(barrier: &State<Barrier>) -> &'static str {
  function rocket (line 12) | pub fn rocket() -> Rocket<Build> {
  function test_rendezvous (line 26) | async fn test_rendezvous() {

FILE: examples/testing/src/main.rs
  function hello (line 6) | fn hello() -> &'static str {
  function rocket (line 11) | fn rocket() -> _ {
  function test_hello (line 21) | fn test_hello() {

FILE: examples/tls/src/main.rs
  function mutual (line 14) | fn mutual(cert: Certificate<'_>) -> String {
  function hello (line 19) | fn hello(endpoint: Option<&Endpoint>) -> String {
  function rocket (line 27) | fn rocket() -> _ {

FILE: examples/tls/src/redirector.rs
  type Redirector (line 14) | pub struct Redirector(u16);
    method on (line 35) | pub fn on(port: u16) -> Self {
    method try_launch (line 40) | pub async fn try_launch(self, config: Config) -> Result<Rocket<Ignite>...
  type Config (line 17) | pub struct Config {
  function redirect (line 23) | fn redirect(config: &State<Config>, uri: &Origin<'_>, host: &Host<'_>) -...
  method info (line 56) | fn info(&self) -> Info {
  method on_liftoff (line 64) | async fn on_liftoff(&self, rocket: &Rocket<Orbit>) {

FILE: examples/tls/src/tests.rs
  function cookie (line 8) | fn cookie(jar: &CookieJar<'_>) {
  function hello_mutual (line 17) | fn hello_mutual() {
  function secure_cookies (line 35) | fn secure_cookies() {
  function insecure_cookies (line 52) | fn insecure_cookies() {
  function validate_profiles (line 68) | fn validate_profiles(profiles: &[&str]) {
  function validate_tls_profiles (line 89) | fn validate_tls_profiles() {

FILE: examples/todo/migrations/20160720150332_create_tasks_table/up.sql
  type tasks (line 1) | CREATE TABLE tasks (

FILE: examples/todo/src/main.rs
  type DbConn (line 22) | pub struct DbConn(diesel::SqliteConnection);
  type Context (line 26) | struct Context {
    method err (line 32) | pub async fn err<M: std::fmt::Display>(conn: &DbConn, msg: M) -> Conte...
    method raw (line 39) | pub async fn raw(conn: &DbConn, flash: Option<(String, String)>) -> Co...
  function new (line 54) | async fn new(todo_form: Form<Todo>, conn: DbConn) -> Flash<Redirect> {
  function toggle (line 67) | async fn toggle(id: i32, conn: DbConn) -> Result<Redirect, Template> {
  function delete (line 78) | async fn delete(id: i32, conn: DbConn) -> Result<Flash<Redirect>, Templa...
  function index (line 89) | async fn index(flash: Option<FlashMessage<'_>>, conn: DbConn) -> Template {
  function run_migrations (line 94) | async fn run_migrations(rocket: Rocket<Build>) -> Rocket<Build> {
  function rocket (line 108) | fn rocket() -> _ {

FILE: examples/todo/src/task.rs
  type Task (line 21) | pub struct Task {
    method all (line 34) | pub async fn all(conn: &DbConn) -> QueryResult<Vec<Task>> {
    method insert (line 41) | pub async fn insert(todo: Todo, conn: &DbConn) -> QueryResult<usize> {
    method toggle_with_id (line 49) | pub async fn toggle_with_id(id: i32, conn: &DbConn) -> QueryResult<usi...
    method delete_with_id (line 59) | pub async fn delete_with_id(id: i32, conn: &DbConn) -> QueryResult<usi...
    method delete_all (line 68) | pub async fn delete_all(conn: &DbConn) -> QueryResult<usize> {
  type Todo (line 29) | pub struct Todo {

FILE: examples/todo/src/tests.rs
  function test_index (line 29) | fn test_index() {
  function test_insertion_deletion (line 39) | fn test_insertion_deletion() {
  function test_toggle (line 73) | fn test_toggle() {
  function test_many_insertions (line 96) | fn test_many_insertions() {
  function test_bad_form_submissions (line 133) | fn test_bad_form_submissions() {

FILE: examples/upgrade/src/main.rs
  function echo_stream (line 7) | fn echo_stream(ws: ws::WebSocket) -> ws::Stream!['static] {
  function echo_channel (line 16) | fn echo_channel(ws: ws::WebSocket) -> ws::Channel<'static> {
  function echo_raw (line 34) | fn echo_raw(ws: ws::WebSocket) -> ws::Stream!['static] {
  function rocket (line 39) | fn rocket() -> _ {

FILE: testbench/src/client.rs
  type Client (line 9) | pub struct Client {
    method default (line 14) | pub fn default() -> Client {
    method build (line 20) | pub fn build() -> ClientBuilder {
    method request (line 29) | pub fn request<M>(&self, server: &Server, method: M, url: &str) -> Res...
    method get (line 54) | pub fn get(&self, server: &Server, url: &str) -> Result<RequestBuilder> {
    method post (line 58) | pub fn post(&self, server: &Server, url: &str) -> Result<RequestBuilde...
    method from (line 64) | fn from(client: reqwest::blocking::Client) -> Self {
    type Error (line 70) | type Error = Error;
    method try_from (line 72) | fn try_from(builder: ClientBuilder) -> Result<Self, Self::Error> {

FILE: testbench/src/config.rs
  type RocketExt (line 25) | pub trait RocketExt {
    method default (line 26) | fn default() -> Self;
    method tls_default (line 27) | fn tls_default() -> Self;
    method reconfigure_with_toml (line 28) | fn reconfigure_with_toml(self, toml: &str) -> Self;
    method default (line 32) | fn default() -> Self {
    method tls_default (line 36) | fn tls_default() -> Self {
    method reconfigure_with_toml (line 42) | fn reconfigure_with_toml(self, toml: &str) -> Self {
  function read (line 53) | pub fn read(path: &str) -> Result<Vec<u8>> {
  function cert (line 58) | pub fn cert(path: &str) -> Result<Vec<u8>> {

FILE: testbench/src/lib.rs
  type Result (line 13) | pub type Result<T, E = Error> = std::result::Result<T, E>;
  type Error (line 16) | pub enum Error {

FILE: testbench/src/main.rs
  function main (line 17) | fn main() -> std::process::ExitCode {

FILE: testbench/src/runner.rs
  type Test (line 6) | pub struct Test {
  function run (line 23) | pub fn run() -> std::process::ExitCode {

FILE: testbench/src/server.rs
  type Server (line 19) | pub struct Server {
    method spawn (line 58) | pub fn spawn<T>(ctxt: T, f: fn((Token, T)) -> Launched) -> Result<Server>
    method socket_addr (line 82) | pub fn socket_addr(&self) -> SocketAddr {
    method read_stdout (line 87) | pub fn read_stdout(&mut self) -> Result<String> {
    method read_stderr (line 91) | pub fn read_stderr(&mut self) -> Result<String> {
    method kill (line 95) | pub fn kill(&mut self) -> Result<()> {
    method terminate (line 99) | pub fn terminate(&mut self) -> Result<()> {
    method join (line 106) | pub fn join(&mut self, duration: Duration) -> Result<()> {
  type Message (line 28) | pub enum Message {
  type Token (line 35) | pub struct Token(String);
    method with_launch (line 116) | pub fn with_launch<F, Fut>(self, rocket: Rocket<Build>, launch: F) -> ...
    method launch_with (line 146) | pub fn launch_with<B: Bind>(self, rocket: Rocket<Build>) -> Launched
    method launch (line 152) | pub fn launch(self, rocket: Rocket<Build>) -> Launched {
  type Launched (line 39) | pub struct Launched(());
  function stdio (line 41) | fn stdio() -> Stdio {
  function read (line 47) | fn read<T: Read>(io: Option<T>) -> Result<String> {
  method drop (line 158) | fn drop(&mut self) {

FILE: testbench/src/servers/bind.rs
  function tcp_unix_listener_fail (line 6) | fn tcp_unix_listener_fail() -> Result<()> {

FILE: testbench/src/servers/http_extensions.rs
  function route (line 8) | fn route() -> &'static str {
  function test_http_extensions (line 12) | pub fn test_http_extensions() -> Result<()> {

FILE: testbench/src/servers/ignite_failure.rs
  function test_ignite_failure (line 3) | fn test_ignite_failure() -> Result<()> {

FILE: testbench/src/servers/infinite_stream.rs
  function infinite (line 4) | fn infinite() -> TextStream![&'static str] {
  function test_inifinite_streams_end (line 12) | pub fn test_inifinite_streams_end() -> Result<()> {

FILE: testbench/src/servers/mtls.rs
  function test_mtls (line 3) | fn test_mtls(mandatory: bool) -> Result<()> {

FILE: testbench/src/servers/no_content.rs
  function status (line 9) | fn status(code: u16) -> (Status, &'static [u8]) {
  function test_no_content (line 13) | pub fn test_no_content() -> Result<()> {

FILE: testbench/src/servers/sni_resolver.rs
  type SniResolver (line 25) | struct SniResolver {
  method init (line 32) | async fn init(rocket: &Rocket<Build>) -> rocket::tls::Result<Self> {
  method resolve (line 46) | async fn resolve(&self, hello: ClientHello<'_>) -> Option<Arc<ServerConf...
  function sni_resolver (line 57) | fn sni_resolver() -> Result<()> {
  type CountingResolver (line 90) | struct CountingResolver {
  method init (line 97) | async fn init(rocket: &Rocket<Build>) -> rocket::tls::Result<Self> {
  method resolve (line 104) | async fn resolve(&self, _: ClientHello<'_>) -> Option<Arc<ServerConfig>> {
  function count (line 111) | fn count(counter: &State<Arc<AtomicUsize>>) -> String {
  function counting_resolver (line 115) | fn counting_resolver() -> Result<()> {

FILE: testbench/src/servers/tls.rs
  function hello_world (line 13) | fn hello_world(endpoint: &Endpoint) -> String {
  function test_tls_works (line 17) | fn test_tls_works() -> Result<()> {

FILE: testbench/src/servers/tls_resolver.rs
  type CountingResolver (line 8) | struct CountingResolver {
  method init (line 15) | async fn init(rocket: &Rocket<Build>) -> rocket::tls::Result<Self> {
  method resolve (line 22) | async fn resolve(&self, _: ClientHello<'_>) -> Option<Arc<ServerConfig>> {
  function count (line 29) | fn count(counter: &State<Arc<AtomicUsize>>) -> String {
  function test_tls_resolver (line 33) | fn test_tls_resolver() -> Result<()> {

FILE: testbench/src/servers/tracing.rs
  type UseDisplay (line 14) | struct UseDisplay(&'static str);
    method fmt (line 20) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
    type Error (line 26) | type Error = Self;
    method from_param (line 27) | fn from_param(_: &str) -> Result<Self, Self::Error> { Err(Self("param"...
    type Error (line 37) | type Error = Self;
    method from_request (line 38) | async fn from_request(_: &'r Request<'_>) -> request::Outcome<Self, Se...
    type Error (line 53) | type Error = Self;
    method from_data (line 54) | async fn from_data(_: &'r Request<'_>, _: Data<'r>) -> data::Outcome<'...
    type Error (line 68) | type Error = Self;
    method from_segments (line 69) | fn from_segments(_: Segments<'r, Path>) -> Result<Self, Self::Error> {...
  type UseDebug (line 17) | struct UseDebug;
    type Error (line 31) | type Error = Self;
    method from_param (line 32) | fn from_param(_: &str) -> Result<Self, Self::Error> { Err(Self) }
    type Error (line 45) | type Error = Self;
    method from_request (line 46) | async fn from_request(_: &'r Request<'_>) -> request::Outcome<Self, Se...
    type Error (line 61) | type Error = Self;
    method from_data (line 62) | async fn from_data(_: &'r Request<'_>, _: Data<'r>) -> data::Outcome<'...
    type Error (line 73) | type Error = Self;
    method from_segments (line 74) | fn from_segments(_: Segments<'r, Path>) -> Result<Self, Self::Error> {...
  function test_display_guard_err (line 77) | pub fn test_display_guard_err() -> Result<()> {
  function test_debug_guard_err (line 101) | pub fn test_debug_guard_err() -> Result<()> {