Struct relay_pattern::TypedPattern

pub struct TypedPattern<C = DefaultPatternConfig> { /* private fields */ }

A Pattern with compile time encoded PatternConfig.

Encoding the pattern configuration allows context dependent serialization and usage of patterns and ensures a consistent usage of configuration options throught the code.

Often repeated configuration can be grouped into custom and importable configurations.

struct MetricConfig;

impl relay_pattern::PatternConfig for MetricConfig {
    const CASE_INSENSITIVE: bool = false;
    // More configuration ...
}

type MetricPattern = relay_pattern::TypedPattern<MetricConfig>;

let pattern = MetricPattern::new("[cd]:foo/bar").unwrap();
assert!(pattern.is_match("c:foo/bar"));

Implementations

impl<C: PatternConfig> TypedPattern<C>

pub fn new(pattern: &str) -> Result<Self, Error>

Creates a new TypedPattern using the provided pattern and config C.

use relay_pattern::{Pattern, TypedPattern, CaseInsensitive};

let pattern = TypedPattern::<CaseInsensitive>::new("foo*").unwrap();
assert!(pattern.is_match("FOOBAR"));

// Equivalent to:
let pattern = Pattern::builder("foo*").case_insensitive(true).build().unwrap();
assert!(pattern.is_match("FOOBAR"));

Methods from Deref<Target = Pattern>

pub fn is_match(&self, haystack: &str) -> bool

Returns true if the pattern matches the passed string.

Trait Implementations

impl<C> AsRef<Pattern> for TypedPattern<C>

fn as_ref(&self) -> &Pattern

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

impl<C: Debug> Debug for TypedPattern<C>

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

Formats the value using the given formatter.

impl<C> Deref for TypedPattern<C>

type Target = Pattern

The resulting type after dereferencing.

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

Dereferences the value.

impl<'de, C: PatternConfig> Deserialize<'de> for TypedPattern<C>

fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<C> From<TypedPattern<C>> for Pattern

fn from(value: TypedPattern<C>) -> Self

Converts to this type from the input type.

impl<C> Serialize for TypedPattern<C>

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>

where S: Serializer,

Serialize this value into the given Serde serializer.