Struct validus::vstr::Later

#[repr(transparent)]
pub struct Later<R: ValidateString> { /* private fields */ }

Accept now, validate later.

This wrapper accepts all strings, but leaves behind a rule that should be applied later.

To lower a vstr<Later<Rule>> to vstr<Rule>, use VStr::make_strict.

Example

See also: fast_rule.

use validus::prelude::*;
use validus::fast_rule;

struct EmailError;
struct Email;
fast_rule!(Email,
    err = EmailError,
    msg = "no @ symbol",
    |s: &str| s.contains('@')
);

// Here, we start with an email with deferred (postponed) validation.
// Validation of `Later<_>` is infallible.
let v1: &vstr<Later<Email>> = "hi@example.com".validate().unwrap();
// Now, we truly validate it.
let v1: Result<&vstr<Email>, _> = v1.make_strict();
assert!(v1.is_ok());

// So, again, this is going to succeed.
let v2 = "notgood".validate::<Later<Email>>().unwrap();
// But, when we check it, it will fail, since it is not a good email address
// (according to the rule we defined).
let v2 = v2.make_strict();
assert!(v2.is_err());

// With the extension `StrExt`, we can also call `.assume_valid()`
// to skip validation, since we know that `Later<_>` doesn't validate.

let relaxed = "hi@example.com".assume_valid::<Later<Email>>();
assert!(relaxed.check().is_ok()); // This is infallible because `Later<_>` is infallible.
assert!(relaxed.make_strict().is_ok()); // Later<Email> -> Email.

let relaxed = "nonono".assume_valid::<Later<Email>>();
assert!(relaxed.check().is_ok()); // Yup, it is still infallible.
let strict = relaxed.make_strict(); // Now, we made it strict.
assert!(strict.is_err()); // It didn't make it (it was a bad email address.)

Trait Implementations

impl<R: Clone + ValidateString> Clone for Later<R>

fn clone(&self) -> Later<R>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<R: Debug + ValidateString> Debug for Later<R>

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

Formats the value using the given formatter.

impl<R: Default + ValidateString> Default for Later<R>

fn default() -> Later<R>

Returns the “default value” for a type.

impl<R: ValidateString> From<ValidateAll> for Later<R>

fn from(_: ValidateAll) -> Self

Converts to this type from the input type.

impl<R: Hash + ValidateString> Hash for Later<R>

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<R: PartialEq + ValidateString> PartialEq<Later<R>> for Later<R>

fn eq(&self, other: &Later<R>) -> bool

This method tests for self and other values to be equal, and is used by ==.

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

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<R: ValidateString> ValidateString for Later<R>

type Error = Infallible

Explain why the string slice is invalid.

fn validate_str(_: &str) -> Result<(), Self::Error>

Validate a string slice.

impl<R: Copy + ValidateString> Copy for Later<R>

impl<R: Eq + ValidateString> Eq for Later<R>

impl<R: ValidateString> StructuralEq for Later<R>

impl<R: ValidateString> StructuralPartialEq for Later<R>