Enum Filter 

pub enum Filter {
    And {
        filters: Vec<Filter>,
    },
    Or {
        filters: Vec<Filter>,
    },
    Not {
        filter: Box<Filter>,
    },
    EqWrapped {
        condition: EqCondition,
    },
    Eq {
        path: String,
        value: Value,
    },
}

A filter predicate for matching events.

Variants

And

Logical AND: all filters must match.

Fields

filters: Vec<Filter>

List of filters that must all match.

Or

Logical OR: at least one filter must match.

Fields

filters: Vec<Filter>

List of filters where at least one must match.

Not

Logical NOT: the inner filter must not match.

Fields

filter: Box<Filter>

The filter to negate.

EqWrapped

Equality match with $eq wrapper: { "$eq": { "path": "...", "value": ... } }

Fields

condition: EqCondition

The equality condition.

Eq

Equality match (shorthand): { "path": "...", "value": ... }

Fields

path: String

Dot-separated path to the field (e.g., “foo.bar.baz”).

value: Value

Value to match against.

Implementations

impl Filter

pub fn and(filters: Vec<Filter>) -> Self

Create an AND filter.

pub fn or(filters: Vec<Filter>) -> Self

Create an OR filter.

pub fn not(filter: Filter) -> Self

Create a NOT filter.

pub fn eq(path: impl Into<String>, value: JsonValue) -> Self

Create an equality filter.

pub fn matches(&self, event: &JsonValue) -> bool

Check if an event matches this filter.

Empty And children are rejected as “matches nothing” rather than “matches everything” — .all() on an empty iterator returns true, which would silently turn an externally- supplied filter JSON like {"and": []} into a universal pass-through. Empty Or naturally returns false via .any() on an empty iterator and keeps its documented “matches nothing” behavior.

pub fn from_json(json: &str) -> Result<Self, Error>

Parse a filter from JSON.

pub fn to_json(&self) -> Result<String, Error>

Convert the filter to JSON.

Trait Implementations

impl Clone for Filter

fn clone(&self) -> Filter

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Filter

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Filter

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for Filter

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

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for Filter