Struct unc_primitives::utils::MaybeValidated

source ·

pub struct MaybeValidated<T> { /* private fields */ }

Expand description

A data structure for tagging data as already being validated to prevent redundant work.

§Example

struct Foo;
struct Error;

/// Performs expensive validation of `foo`.
fn validate_foo(foo: &Foo) -> Result<bool, Error>;

fn do_stuff(foo: Foo) {
    let foo = MaybeValidated::from(foo);
    do_stuff_with_foo(&foo);
    if foo.validate_with(validate_foo) {
        println!("^_^");
    }
}

fn do_stuff_with_foo(foo: &MaybeValidated<Foo) {
    // …
    if maybe_do_something && foo.validate_with(validate_foo) {
        println!("@_@");
    }
    // …
}

Implementations§

source §

impl<T> MaybeValidated<T>

source

pub fn from_validated(payload: T) -> Self

Creates new MaybeValidated object marking payload as validated. No verification is performed; it’s caller’s responsibility to make sure the payload has indeed been validated.

§Example

use unc_primitives::utils::MaybeValidated;

let value = MaybeValidated::from_validated(42);
assert!(value.is_validated());
assert_eq!(Ok(true), value.validate_with::<(), _>(|_| panic!()));

source

pub fn validate_with<E, F: FnOnce(&T) -> Result<bool, E>>( &self, validator: F ) -> Result<bool, E>

Validates payload with given validator function and returns result of the validation. If payload has already been validated returns Ok(true). Note that this method changes the internal validated flag so it’s probably incorrect to call it with different validator functions.

§Example

use unc_primitives::utils::MaybeValidated;

let value = MaybeValidated::from(42);
assert_eq!(Err(()), value.validate_with(|_| Err(())));
assert_eq!(Ok(false), value.validate_with::<(), _>(|v| Ok(*v == 24)));
assert!(!value.is_validated());
assert_eq!(Ok(true), value.validate_with::<(), _>(|v| Ok(*v == 42)));
assert!(value.is_validated());
assert_eq!(Ok(true), value.validate_with::<(), _>(|_| panic!()));

source

pub fn mark_as_valid(&self)

Marks the payload as valid. No verification is performed; it’s caller’s responsibility to make sure the payload has indeed been validated.

source

pub fn map<U, F: FnOnce(T) -> U>(self, validator: F) -> MaybeValidated

Applies function to the payload (whether it’s been validated or not) and returns new object with result of the function as payload. Validated state is not changed.

§Example

use unc_primitives::utils::MaybeValidated;

let value = MaybeValidated::from(42);
assert_eq!("42", value.map(|v| v.to_string()).into_inner());

source

pub fn as_ref(&self) -> MaybeValidated<&T>

Returns a new object storing reference to this object’s payload. Note that the two objects do not share the validated state so calling validate_with on one of them does not affect the other.

§Example

use unc_primitives::utils::MaybeValidated;

let value = MaybeValidated::from(42);
let value_as_ref = value.as_ref();
assert_eq!(Ok(true), value_as_ref.validate_with::<(), _>(|&&v| Ok(v == 42)));
assert!(value_as_ref.is_validated());
assert!(!value.is_validated());