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

      1
      2
      3
      4
      5
      6
      7
      8
      9
     10
     11
     12
     13
     14
     15
     16
     17
     18
     19
     20
     21
     22
     23
     24
     25
     26
     27
     28
     29
     30
     31
     32
     33
     34
     35
     36
     37
     38
     39
     40
     41
     42
     43
     44
     45
     46
     47
     48
     49
     50
     51
     52
     53
     54
     55
     56
     57
     58
     59
     60
     61
     62
     63
     64
     65
     66
     67
     68
     69
     70
     71
     72
     73
     74
     75
     76
     77
     78
     79
     80
     81
     82
     83
     84
     85
     86
     87
     88
     89
     90
     91
     92
     93
     94
     95
     96
     97
     98
     99
    100
    101
    102
    103
    104
    105
    106
    107
    108
    109
    110
    111
    112
    113
    114
    115
    116
    117
    118
    119
    120
    121
    122

    use header::CONTENT_TYPE;
    use mime::{self, Mime};

    header! {
        /// `Content-Type` header, defined in
        /// [RFC7231](http://tools.ietf.org/html/rfc7231#section-3.1.1.5)
        ///
        /// The `Content-Type` header field indicates the media type of the
        /// associated representation: either the representation enclosed in the
        /// message payload or the selected representation, as determined by the
        /// message semantics.  The indicated media type defines both the data
        /// format and how that data is intended to be processed by a recipient,
        /// within the scope of the received message semantics, after any content
        /// codings indicated by Content-Encoding are decoded.
        ///
        /// Although the `mime` crate allows the mime options to be any slice, this crate
        /// forces the use of Vec. This is to make sure the same header can't have more than 1 type. If
        /// this is an issue, it's possible to implement `Header` on a custom struct.
        ///
        /// # ABNF
        ///
        /// ```text
        /// Content-Type = media-type
        /// ```
        ///
        /// # Example values
        ///
        /// * `text/html; charset=utf-8`
        /// * `application/json`
        ///
        /// # Examples
        ///
        /// ```rust
        /// use actix_web::HttpResponse;
        /// use actix_web::http::header::ContentType;
        ///
        /// # fn main() {
        /// let mut builder = HttpResponse::Ok();
        /// builder.set(
        ///     ContentType::json()
        /// );
        /// # }
        /// ```
        ///
        /// ```rust
        /// # extern crate mime;
        /// # extern crate actix_web;
        /// use mime::TEXT_HTML;
        /// use actix_web::HttpResponse;
        /// use actix_web::http::header::ContentType;
        ///
        /// # fn main() {
        /// let mut builder = HttpResponse::Ok();
        /// builder.set(
        ///     ContentType(TEXT_HTML)
        /// );
        /// # }
        /// ```
        (ContentType, CONTENT_TYPE) => [Mime]

        test_content_type {
            test_header!(
                test1,
                vec![b"text/html"],
                Some(HeaderField(TEXT_HTML)));
        }
    }

    impl ContentType {
        /// A constructor  to easily create a `Content-Type: application/json`
        /// header.
        #[inline]
        pub fn json() -> ContentType {
            ContentType(mime::APPLICATION_JSON)
        }

        /// A constructor  to easily create a `Content-Type: text/plain;
        /// charset=utf-8` header.
        #[inline]
        pub fn plaintext() -> ContentType {
            ContentType(mime::TEXT_PLAIN_UTF_8)
        }

        /// A constructor  to easily create a `Content-Type: text/html` header.
        #[inline]
        pub fn html() -> ContentType {
            ContentType(mime::TEXT_HTML)
        }

        /// A constructor  to easily create a `Content-Type: text/xml` header.
        #[inline]
        pub fn xml() -> ContentType {
            ContentType(mime::TEXT_XML)
        }

        /// A constructor  to easily create a `Content-Type:
        /// application/www-form-url-encoded` header.
        #[inline]
        pub fn form_url_encoded() -> ContentType {
            ContentType(mime::APPLICATION_WWW_FORM_URLENCODED)
        }
        /// A constructor  to easily create a `Content-Type: image/jpeg` header.
        #[inline]
        pub fn jpeg() -> ContentType {
            ContentType(mime::IMAGE_JPEG)
        }

        /// A constructor  to easily create a `Content-Type: image/png` header.
        #[inline]
        pub fn png() -> ContentType {
            ContentType(mime::IMAGE_PNG)
        }

        /// A constructor  to easily create a `Content-Type:
        /// application/octet-stream` header.
        #[inline]
        pub fn octet_stream() -> ContentType {
            ContentType(mime::APPLICATION_OCTET_STREAM)
        }
    }

    impl Eq for ContentType {}

# 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`)