Struct Accept

pub struct Accept(/* private fields */);

Accept header, defined in RFC7231

The Accept header field can be used by user agents to specify response media types that are acceptable. Accept header fields can be used to indicate that the request is specifically limited to a small set of desired types, as in the case of a request for an in-line image

ABNF

Accept = #( media-range [ accept-params ] )

media-range    = ( "*/*"
                 / ( type "/" "*" )
                 / ( type "/" subtype )
                 ) *( OWS ";" OWS parameter )
accept-params  = weight *( accept-ext )
accept-ext = OWS ";" OWS token [ "=" ( token / quoted-string ) ]

Example values

• audio/*; q=0.2, audio/basic
• text/plain; q=0.5, text/html, text/x-dvi; q=0.8, text/x-c

Examples

use std::iter::FromIterator;
use rama_http_headers::{Accept, specifier::QualityValue, HeaderMapExt};
use rama_http_headers::dep::mime;

let mut headers = rama_http_types::HeaderMap::new();

headers.typed_insert(
    Accept::from_iter(vec![
        QualityValue::new(mime::TEXT_HTML, Default::default()),
    ])
);

use std::iter::FromIterator;
use rama_http_headers::{Accept, specifier::QualityValue, HeaderMapExt};
use rama_http_headers::dep::mime;

let mut headers = rama_http_types::HeaderMap::new();
headers.typed_insert(
    Accept::from_iter(vec![
        QualityValue::new(mime::APPLICATION_JSON, Default::default()),
    ])
);

use std::iter::FromIterator;
use rama_http_headers::{Accept, specifier::QualityValue, HeaderMapExt};
use rama_http_headers::dep::mime;

let mut headers = rama_http_types::HeaderMap::new();

headers.typed_insert(
    Accept::from_iter(vec![
        QualityValue::from(mime::TEXT_HTML),
        QualityValue::from("application/xhtml+xml".parse::<mime::Mime>().unwrap()),
        QualityValue::new(
            mime::TEXT_XML,
            900.into()
        ),
        QualityValue::from("image/webp".parse::<mime::Mime>().unwrap()),
        QualityValue::new(
            mime::STAR_STAR,
            800.into()
        ),
    ])
);

Implementations

impl Accept

pub fn star() -> Accept

A constructor to easily create Accept: */*.

pub fn json() -> Accept

A constructor to easily create Accept: application/json.

pub fn text() -> Accept

A constructor to easily create Accept: text/*.

pub fn image() -> Accept

A constructor to easily create Accept: image/*.

pub fn iter(&self) -> impl Iterator<Item = &QualityValue<Mime>>

Returns an iterator over the quality values

Trait Implementations

impl Clone for Accept

fn clone(&self) -> Accept

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Accept

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl FromIterator<QualityValue<Mime>> for Accept

fn from_iter<T>(iter: T) -> Accept

where T: IntoIterator<Item = QualityValue<Mime>>,

Creates a value from an iterator.

impl HeaderDecode for Accept

fn decode<'i, I>(values: &mut I) -> Result<Accept, Error>

where I: Iterator<Item = &'i HeaderValue>,

Decode this type from an iterator of HeaderValues.

impl HeaderEncode for Accept

fn encode<E>(&self, values: &mut E)

where E: Extend<HeaderValue>,

Encode this type to a HeaderValue, and add it to a container which has HeaderValue type as each element.

fn encode_to_value(&self) -> HeaderValue

Encode this header to HeaderValue.

impl PartialEq for Accept

fn eq(&self, other: &Accept) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl TypedHeader for Accept

fn name() -> &'static HeaderName

The name of this header.

impl Eq for Accept

impl StructuralPartialEq for Accept