Struct http_types::server::Allow

pub struct Allow { /* fields omitted */ }

List the set of methods supported by a resource.

Specifications

• RFC 7231, section 7.4.1: Allow

Examples

use http_types::{Method, Response};
use http_types::server::Allow;

let mut allow = Allow::new();
allow.insert(Method::Put);
allow.insert(Method::Post);

let mut res = Response::new(200);
allow.apply(&mut res);

let allow = Allow::from_headers(res)?.unwrap();
assert!(allow.contains(Method::Put));
assert!(allow.contains(Method::Post));

Implementations

impl Allow

pub fn new() -> Self

Create a new instance of Allow.

pub fn from_headers(headers: impl AsRef<Headers>) -> Result<Option<Self>>

Create a new instance from headers.

pub fn apply(&self, headers: impl AsMut<Headers>)

Sets the Allow header.

pub fn name(&self) -> HeaderName

Get the HeaderName.

pub fn value(&self) -> HeaderValue

Get the HeaderValue.

pub fn insert(&mut self, method: Method)

Push a method into the set of methods.

pub fn iter(&self) -> Iter<'_>

An iterator visiting all server entries.

pub fn contains(&self, method: Method) -> bool

Returns true if the header contains the Method.

Trait Implementations

impl Debug for Allow

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

Formats the value using the given formatter.

impl IntoIterator for Allow

type Item = Method

The type of the elements being iterated over.

type IntoIter = IntoIter

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<'a> IntoIterator for &'a Allow

type Item = &'a Method

The type of the elements being iterated over.

type IntoIter = Iter<'a>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl ToHeaderValues for Allow

type Iter = IntoIter<HeaderValue>

Returned iterator over header values which this type may correspond to.

fn to_header_values(&self) -> Result<Self::Iter>

Converts this object to an iterator of resolved HeaderValues.