Struct Valid 

pub struct Valid<T>
where
    T: Validate,
{ /* private fields */ }

A wrapper of T that validate the state of T every time accessing it.

• It validates the state before accessing it, i.e., if when a invalid state is written to it, it won’t panic until next time accessing it.
• The validation is turned on only when debug_assertions is enabled.

An example of defining field a whose value must not exceed 10.

struct Foo { a: u64 }
impl Validate for Foo {
    fn validate(&self) -> Result<(), Box<dyn Error>> {
        less_equal!(self.a, 10);
        Ok(())
    }
}

let f = Valid::new(Foo { a: 20 });
let _x = f.a; // panic: panicked at 'invalid state: expect: self.a(20) <= 10(10) ...

Validation is triggered when:

• Deref or DerefMut is called. This is the major use case.
• Clone is called.
• PartialEq or Eq is called.
• PartialOrd or Ord is called.
• Hash is called.

Validation is not triggered when:

• Copy: Because it is just a byte copy.
• Debug and Display: for being able to examine the value for debugging.

Implementations

impl<T: Validate> Valid<T>

pub fn new(inner: T) -> Self

Create a new Valid<T>.

pub fn enable_validation(&mut self, enabled: bool)

Set whether to validate the state when accessing it.

pub fn is_enabled(&self) -> bool

Get whether to validate the state when accessing it.

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

Return a reference to the wrapped value: Valid<&T>.

pub fn into_inner(self) -> T

Consume self and return the wrapped value.

This does NOT validate the state.

Trait Implementations

impl<T> Clone for Valid<T>

where T: Validate + Clone,

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T> Debug for Valid<T>

where T: Validate + Debug,

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

Formats the value using the given formatter.

impl<T> Default for Valid<T>

where T: Validate + Default,

fn default() -> Self

Returns the “default value” for a type.

impl<T> Deref for Valid<T>

where T: Validate,

type Target = T

The resulting type after dereferencing.

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

Dereferences the value.

impl<T> DerefMut for Valid<T>

where T: Validate,

fn deref_mut(&mut self) -> &mut Self::Target

Mutably dereferences the value.

impl<T> Display for Valid<T>

where T: Validate + Display,

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

Formats the value using the given formatter.

impl<T> Hash for Valid<T>

where T: Validate + Hash,

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> Ord for Valid<T>

where T: Validate + Ord,

fn cmp(&self, other: &Self) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl<T> PartialEq for Valid<T>

where T: Validate + PartialEq,

fn eq(&self, other: &Self) -> 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> PartialOrd for Valid<T>

where T: Validate + PartialOrd,

fn partial_cmp(&self, other: &Self) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

Tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

Tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

Tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl<T> Copy for Valid<T>

where T: Validate + Copy,

impl<T> Eq for Valid<T>

where T: Validate + Eq,