Enum MaybeUntrusted

pub enum MaybeUntrusted<Insecure, Trusted = Insecure> {
    Ok(Trusted),
    Untrusted(UntrustedValue<Insecure>),
}

Represents a value that might be untrusted. See UntrustedValue for more information.

Variants

Ok(Trusted)

Trusted value variant

Untrusted(UntrustedValue<Insecure>)

Untrusted value variant

Implementations

impl<Insecure> MaybeUntrusted<Insecure>

pub fn use_untrusted_value(self) -> Insecure

Be sure that you carefully handle the returned value since it may be controllable by a malicious actor (when it is a MaybeUntrusted::Untrusted).

See the method documentation of the function returning this value

pub fn wrap(value: Insecure, untrusted: bool) -> Self

Wraps the provided value as maybe untrusted, according to given boolean

impl<Insecure, Trusted> MaybeUntrusted<Insecure, Trusted>

pub fn is_untrusted(&self) -> bool

Returns true if the value is untrusted

pub fn is_ok(&self) -> bool

Returns true if the value is not untrusted

pub fn wrap_untrusted(value: Insecure) -> Self

Wraps the provided values as Untrusted

pub fn wrap_ok(value: Trusted) -> Self

Wraps the provided values as Ok

Trait Implementations

impl<Insecure: Clone, Trusted: Clone> Clone for MaybeUntrusted<Insecure, Trusted>

fn clone(&self) -> Self

Clones the value

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

Performs copy-assignment from source.

impl<Insecure, Trusted> From<UntrustedValue<Insecure>> for MaybeUntrusted<Insecure, Trusted>

fn from(value: UntrustedValue<Insecure>) -> Self

Converts an UntrustedValue to a MaybeUntrusted value

impl<E, Insecure: SanitizeValue<Insecure, Error = E>> SanitizeValue<Insecure> for MaybeUntrusted<Insecure>

type Error = E

The error type that is returned in case of a sanitization failure.

fn sanitize_value(self) -> Result<Insecure, Self::Error>

Sanitizes the value.

impl<Insecure, Trusted> SanitizeWith<Insecure, Trusted> for MaybeUntrusted<Insecure, Trusted>

fn sanitize_with<Sanitizer, Error>( self, sanitizer: Sanitizer, ) -> Result<Trusted, Error>

where Sanitizer: FnOnce(Insecure) -> Result<Trusted, Error>,

Sanitizes the value using the provided sanitizer if the value is untrusted.

The sanitizer may transmute the value to a different type. If sanitization fails, an error must be returned.

impl<Insecure: Copy, Trusted: Copy> Copy for MaybeUntrusted<Insecure, Trusted>