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

     1
     2
     3
     4
     5
     6
     7
     8
     9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59

    use std::fmt;
    use std::str;

    pub use self::Encoding::{
        Brotli, Chunked, Compress, Deflate, EncodingExt, Gzip, Identity, Trailers,
    };

    /// A value to represent an encoding used in `Transfer-Encoding`
    /// or `Accept-Encoding` header.
    #[derive(Clone, PartialEq, Debug)]
    pub enum Encoding {
        /// The `chunked` encoding.
        Chunked,
        /// The `br` encoding.
        Brotli,
        /// The `gzip` encoding.
        Gzip,
        /// The `deflate` encoding.
        Deflate,
        /// The `compress` encoding.
        Compress,
        /// The `identity` encoding.
        Identity,
        /// The `trailers` encoding.
        Trailers,
        /// Some other encoding that is less common, can be any String.
        EncodingExt(String),
    }

    impl fmt::Display for Encoding {
        fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
            f.write_str(match *self {
                Chunked => "chunked",
                Brotli => "br",
                Gzip => "gzip",
                Deflate => "deflate",
                Compress => "compress",
                Identity => "identity",
                Trailers => "trailers",
                EncodingExt(ref s) => s.as_ref(),
            })
        }
    }

    impl str::FromStr for Encoding {
        type Err = ::error::ParseError;
        fn from_str(s: &str) -> Result<Encoding, ::error::ParseError> {
            match s {
                "chunked" => Ok(Chunked),
                "br" => Ok(Brotli),
                "deflate" => Ok(Deflate),
                "gzip" => Ok(Gzip),
                "compress" => Ok(Compress),
                "identity" => Ok(Identity),
                "trailers" => Ok(Trailers),
                _ => Ok(EncodingExt(s.to_owned())),
            }
        }
    }

# Help

## Keyboard Shortcuts

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

## Search Tricks

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

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

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

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