Struct LazyRegex

pub struct LazyRegex<T = LazyLock<Regex>>(pub T);

Transparent wrapper around a type dereferencing to a Regex. Can be used as a separator, or in param validation.

Why a separate type?

A separate type is necessary to circumvent orphaning rules. We want to implement Split and Validate for any type (e.g., LazyLock) that lazily initializes a Regex, since a Regex on its own cannot be initialized in compile time. Similarly, such a type cannot be dereferenced in compile time, which rules out implementing these traits for &'static Regex.

Examples

The easiest way to initialize a wrapper is the lazy_regex! macro.

use smart_config::{de::Delimited, pat::{lazy_regex, LazyRegex}};

static NAME_REGEX: LazyRegex = lazy_regex!(r"^[a-z][-a-z0-9]*$");

#[derive(DescribeConfig, DeserializeConfig)]
struct TestConfig {
    #[config(validate(NAME_REGEX))]
    app: String,
    // The macro also can be inlined!
    #[config(with = Delimited::new(lazy_regex!(ref r"\s*,\s*")))]
    numbers: Vec<u64>,
}

Tuple Fields

0: T

Trait Implementations

impl<T: Debug> Debug for LazyRegex<T>

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

Formats the value using the given formatter.

impl<T> Split for &'static LazyRegex<T>

where T: Deref<Target = Regex> + Send + Sync,

fn split_once<'s>(&self, haystack: &'s str) -> Option<(&'s str, &'s str)>

Splits the given haystack at most once from its start. This generalizes str::split_once().

fn split<'s>(&self, haystack: &'s str) -> impl Iterator<Item = &'s str>

Splits the given haystack. This generalizes str::split().

impl<T> Validate<String> for LazyRegex<T>

where T: Deref<Target = Regex> + Send + Sync + 'static,

Validates that the string matches the provided regex.

Don’t forget to surround the regex with ^$ if you want to match it completely.

fn describe(&self, formatter: &mut Formatter<'_>) -> Result

Describes this validation.

fn validate(&self, target: &String) -> Result<(), ErrorWithOrigin>

Validates a parameter / config.