Struct AcceptNoneDenyBad 

#[repr(transparent)]
pub struct AcceptNoneDenyBad<T: HeaderType>(pub Option<T>);

Will accept no value. But will deny if the header is not valid. Such as if it is not valid UTF-8

It wraps the value in an Option

None means the header was not present

use actix_quick_extract::headers::{AcceptNoneDenyBad, Origin};
use actix_web::get;

#[get("/")]
pub async fn index(origin: AcceptNoneDenyBad<Origin>) -> String {
    format!("Your Origin Header is: {:?}", origin.0)
}

Tuple Fields

0: Option<T>

Trait Implementations

impl<T: Clone + HeaderType> Clone for AcceptNoneDenyBad<T>

fn clone(&self) -> AcceptNoneDenyBad<T>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: Debug + HeaderType> Debug for AcceptNoneDenyBad<T>

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

Formats the value using the given formatter.

impl<T: HeaderType> From<AcceptNoneDenyBad<T>> for Option<T>

fn from(value: AcceptNoneDenyBad<T>) -> Self

Converts to this type from the input type.

impl<T: HeaderType> FromRequest for AcceptNoneDenyBad<T>

type Error = ExtractError

The associated error which can be returned.

type Future = Ready<Result<AcceptNoneDenyBad<T>, ExtractError>>

Future that resolves to a Self.

fn from_request(req: &HttpRequest, _: &mut Payload) -> Self::Future

Create a Self from request parts asynchronously.

fn extract(req: &HttpRequest) -> Self::Future

Create a Self from request head asynchronously.

impl<T: Hash + HeaderType> Hash for AcceptNoneDenyBad<T>

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<T: PartialEq + HeaderType> PartialEq for AcceptNoneDenyBad<T>

fn eq(&self, other: &AcceptNoneDenyBad<T>) -> 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<T: Eq + HeaderType> Eq for AcceptNoneDenyBad<T>

impl<T: HeaderType> StructuralPartialEq for AcceptNoneDenyBad<T>