Struct RegexWrapper 

pub struct RegexWrapper { /* private fields */ }

A lazily compiled Regex.

Examples

use url_cleaner_engine::glue::*;

let regex = RegexWrapper::from("abc");
assert!(regex.get().unwrap().is_match("abc"));

// Trying to set flags like `/.../i` isn't supported by the regex crate, and so isn't supported here.
assert_eq!(RegexWrapper::from("/abc/i").parts().pattern, "/abc/i");

Implementations

impl RegexWrapper

pub fn parts(&self) -> &RegexParts

Gets the RegexParts this uses to compile its Regex.

Examples

use url_cleaner_engine::glue::*;

let regex = RegexWrapper::from(".*=.*");
assert_eq!(regex.parts(), &RegexParts {pattern: ".*=.*".into(), config: Default::default()});

pub fn get_no_compile(&self) -> Option<&Regex>

Get the compiled Regex if it’s been compiled.

Examples

use url_cleaner_engine::glue::*;

let regex = RegexWrapper::from(".*=.*");
assert!(regex.get_no_compile().is_none());
regex.get().unwrap();
assert!(regex.get_no_compile().is_some());

pub fn get(&self) -> Result<&Regex, Error>

Gets the compiled Regex or, if it hasn’t been compiled, compiles it.

Currently, if a call to Self::get returns an error, the next call will attempt to compile the Regex again.

Given this should be pretty rare and the cost of storing the error is pretty high, I choose to consider a reasonable tradeoff.

Errors

If the cache is unset and the call to RegexParts::build returns an error, that error is returned.

Examples

use url_cleaner_engine::glue::*;

let regex = RegexWrapper::from(".*=.*");
assert!(regex.get_no_compile().is_none());
regex.get().unwrap();
assert!(regex.get_no_compile().is_some());

Trait Implementations

impl AsRef<RegexParts> for RegexWrapper

fn as_ref(&self) -> &RegexParts

Converts this type into a shared reference of the (usually inferred) input type.

impl Clone for RegexWrapper

fn clone(&self) -> RegexWrapper

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for RegexWrapper

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for RegexWrapper

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl From<&str> for RegexWrapper

fn from(s: &str) -> Self

Creates a new RegexParts and uses that.

The regex is only compiled later.

impl From<RegexParts> for RegexWrapper

fn from(parts: RegexParts) -> Self

Converts to this type from the input type.

impl From<RegexWrapper> for RegexParts

fn from(value: RegexWrapper) -> Self

Converts to this type from the input type.

impl From<RegexWrapper> for StringMatcher

fn from(value: RegexWrapper) -> Self

Converts to this type from the input type.

impl FromStr for RegexWrapper

fn from_str(s: &str) -> Result<Self, Self::Err>

Creates a new RegexParts and uses that.

The regex is only compiled later.

type Err = Infallible

The associated error which can be returned from parsing.

impl PartialEq for RegexWrapper

fn eq(&self, other: &Self) -> bool

Whether or not self and/or other have their Regex cached is not considered.

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 Serialize for RegexWrapper

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl TryFrom<RegexWrapper> for Regex

fn try_from(value: RegexWrapper) -> Result<Self, Self::Error>

Does not re-compile or clone the Regex if it’s already cached. It simply takes it.

type Error = Error

The type returned in the event of a conversion error.

impl Eq for RegexWrapper