Enum Query

pub enum Query {
    Exact(String, bool),
    StartsWith(String, bool),
    Contains(String, bool),
    EndsWith(String, bool),
}

Represents different ways to match input text.

• Exact(String, bool) matches if the text is exactly equal to the query string.
• StartsWith(String, bool) matches if the text starts with the query string.
• Contains(String, bool) matches if the text contains the query string.
• EndsWith(String, bool) matches if the text ends with the query string.

The bool field indicates whether the match should be case-sensitive (true) or case-insensitive (false). By default, it is case-insensitive unless the query string is prefixed with c: (for “case-sensitive”) or i: (for “case-insensitive”).

Variants

Exact(String, bool)

Variant for an exact match. The second parameter specifies if it’s case-sensitive.

StartsWith(String, bool)

Variant for matching if the text starts with the query. The second parameter specifies if it’s case-sensitive.

Contains(String, bool)

Variant for matching if the text contains the query. The second parameter specifies if it’s case-sensitive.

EndsWith(String, bool)

Variant for matching if the text ends with the query. The second parameter specifies if it’s case-sensitive.

Implementations

impl Query

pub fn matches(&self, text: &str) -> bool

Checks whether the given text matches this query.

By default, matches are case-insensitive unless specified otherwise in the query. If case_sensitive is true, the match must respect exact casing.

Arguments

• text - The text to check against the query.

Returns

Returns true if the text matches according to the query variant (respecting case sensitivity), or false otherwise.

Examples

// Case-insensitive exact match example:
let query = Query::from_str("=Hello").unwrap();
assert!(query.matches("hello"));

// Case-sensitive contains example:
let query = Query::from_str("c:ell").unwrap();
assert!(query.matches("Well")); // false
assert!(query.matches("ell"));  // true if text is exactly "ell"

Trait Implementations

impl Clone for Query

fn clone(&self) -> Query

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Query

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

Formats the value using the given formatter.

impl FromStr for Query

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

Parses a string slice into a Query with optional case sensitivity.

The parsing follows a simple syntax:

• Case Sensitivity:

  • If the string starts with "c:", the query is case-sensitive.
  • If it starts with "i:", the query is explicitly case-insensitive.
  • Otherwise, it defaults to case-insensitive.

• Match Variants:

  • If, after removing any c: or i: prefix, the string starts with = => parsed as Exact(...).
  • If it starts with ^ => parsed as StartsWith(...).
  • If it ends with $ => parsed as EndsWith(...).
  • Otherwise, it is parsed as Contains(...).

Whitespace is trimmed, and an empty input results in an error.

Examples

// Case-insensitive exact match
let query = Query::from_str("=Exact").unwrap();
if let Query::Exact(ref s, false) = query {
    assert_eq!(s, "Exact");
} else {
    panic!("Expected case-insensitive Exact variant");
}

// Case-sensitive starts-with match
let query = Query::from_str("c:^Hello").unwrap();
if let Query::StartsWith(ref s, true) = query {
    assert_eq!(s, "Hello");
} else {
    panic!("Expected case-sensitive StartsWith variant");
}

type Err = ()

The associated error which can be returned from parsing.

impl PartialEq for Query

fn eq(&self, other: &Query) -> 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 StructuralPartialEq for Query