Struct MaybeValidated 

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

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

impl<T> MaybeValidated<T>

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 near_primitives::utils::MaybeValidated;

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

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 near_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!()));

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

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 near_primitives::utils::MaybeValidated;

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

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 near_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());

pub fn is_validated(&self) -> bool

Returns whether the payload has been validated.

pub fn into_inner(self) -> T

Extracts the payload whether or not it’s been validated.

pub fn get_inner(&self) -> &T

Returns a reference to the payload

Trait Implementations

impl<T: Clone> Clone for MaybeValidated<T>

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: Sized> Deref for MaybeValidated<T>

type Target = T

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl<T> From<T> for MaybeValidated<T>

fn from(payload: T) -> Self

Creates new MaybeValidated object marking payload as not validated.