Struct FilterNode 

pub struct FilterNode {
    pub op: Option<String>,
    pub key: Option<String>,
    pub cmp: Option<String>,
    pub val: Option<String>,
    pub vals: Vec<String>,
    pub nodes: Vec<FilterNode>,
    /* private fields */
}

A filter node that can be a leaf (comparison) or a branch (logical operation).

This structure is designed to be serialized/deserialized from JSON and can be constructed programmatically using the builder pattern.

Design goals:

• Zero allocations during evaluation
• Easy serialization to/from JSON
• Programmatic construction via builder
• Tree structure for complex filters

Performance optimizations:

• HashSet cache for IN/NIN operators with many values (O(1) lookup)
• Arc-wrapped HashSet shared across clones (zero-copy for socket subscriptions)

Fields

op: Option<String>

Logical operator for branch nodes: “and”, “or”, “not” If None or empty, this is a leaf node (comparison)

key: Option<String>

Key for comparison (leaf nodes only)

cmp: Option<String>

Comparison operator for leaf nodes “eq”, “neq”, “in”, “nin”, “ex”, “nex”, “sw”, “ew”, “ct”, “gt”, “gte”, “lt”, “lte”

val: Option<String>

Single value for most comparisons

vals: Vec<String>

Multiple values for set operations (in, nin)

nodes: Vec<FilterNode>

Child nodes for logical operations

Implementations

impl FilterNode

pub fn new_comparison(key: String, cmp: CompareOp, val: String) -> Self

Creates a new leaf node with a comparison operation.

pub fn new_set_comparison( key: String, cmp: CompareOp, vals: Vec<String>, ) -> Self

Creates a new leaf node with a set comparison operation (in/nin).

pub fn new_existence(key: String, cmp: CompareOp) -> Self

Creates a new leaf node with an existence check.

pub fn new_logical(op: LogicalOp, nodes: Vec<FilterNode>) -> Self

Creates a new branch node with a logical operation.

pub fn is_sorted(&self) -> bool

Returns true if the vals vector is sorted and ready for binary search.

pub fn optimize(&mut self)

Optimizes the filter node by sorting vectors for binary search. This avoids the overhead of building HashSets (allocations) while still providing O(log n) lookup performance.

pub fn logical_op(&self) -> Option<LogicalOp>

Returns the logical operator if this is a branch node.

pub fn compare_op(&self) -> CompareOp

Returns the comparison operator if this is a leaf node.

pub fn key(&self) -> &str

Returns the key for leaf node comparisons.

pub fn val(&self) -> &str

Returns the single value for leaf node comparisons.

pub fn vals(&self) -> &[String]

Returns the multiple values for set comparisons.

pub fn nodes(&self) -> &[FilterNode]

Returns the child nodes for logical operations.

pub fn validate(&self) -> Option<String>

Validates the filter node structure.

Returns an error message if the node is invalid, None otherwise.

Trait Implementations

impl Clone for FilterNode

fn clone(&self) -> FilterNode

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for FilterNode

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for FilterNode

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for FilterNode

fn eq(&self, other: &Self) -> 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 FilterNode

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

where __S: Serializer,

Serialize this value into the given Serde serializer.