Enum MetadataFilter 

pub enum MetadataFilter {
    Condition(Condition),
    And(Vec<MetadataFilter>),
    Or(Vec<MetadataFilter>),
    Not(Box<MetadataFilter>),
}

A composable filter expression over Metadata.

Filters can be built from primitive Conditions and combined with MetadataFilter::and, MetadataFilter::or, and MetadataFilter::not.

Examples

use qubit_metadata::{Metadata, MetadataFilter};

let mut meta = Metadata::new();
meta.set("env", "prod");
meta.set("version", 2_i64);

let f = MetadataFilter::equal("env", "prod")
    .and(MetadataFilter::greater_equal("version", 1_i64));

assert!(f.matches(&meta));

Variants

Condition(Condition)

A leaf condition.

And(Vec<MetadataFilter>)

All child filters must match.

Or(Vec<MetadataFilter>)

At least one child filter must match.

Not(Box<MetadataFilter>)

The child filter must not match.

Implementations

impl MetadataFilter

pub fn equal<T: Serialize>(key: impl Into<String>, value: T) -> Self

Creates an equality filter: key == value.

pub fn not_equal<T: Serialize>(key: impl Into<String>, value: T) -> Self

Creates a not-equal filter: key != value.

pub fn greater<T: Serialize>(key: impl Into<String>, value: T) -> Self

Creates a greater-than filter: key > value.

pub fn greater_equal<T: Serialize>(key: impl Into<String>, value: T) -> Self

Creates a greater-than-or-equal filter: key >= value.

pub fn less<T: Serialize>(key: impl Into<String>, value: T) -> Self

Creates a less-than filter: key < value.

pub fn less_equal<T: Serialize>(key: impl Into<String>, value: T) -> Self

Creates a less-than-or-equal filter: key <= value.

pub fn exists(key: impl Into<String>) -> Self

Creates an existence filter: the key must be present.

pub fn not_exists(key: impl Into<String>) -> Self

Creates a non-existence filter: the key must be absent.

pub fn in_values<T, I>(key: impl Into<String>, values: I) -> Self

where T: Serialize, I: IntoIterator<Item = T>,

Creates an in-set filter: key ∈ values.

pub fn not_in_values<T, I>(key: impl Into<String>, values: I) -> Self

where T: Serialize, I: IntoIterator<Item = T>,

Creates a not-in-set filter: key ∉ values.

pub fn and(self, other: MetadataFilter) -> Self

Combines self and other with a logical AND.

If self is already an And node the new filter is appended to its children rather than creating a new nested node.

pub fn or(self, other: MetadataFilter) -> Self

Combines self and other with a logical OR.

If self is already an Or node the new filter is appended to its children rather than creating a new nested node.

pub fn not(self) -> Self

Wraps self in a logical NOT.

pub fn matches(&self, meta: &Metadata) -> bool

Returns true if meta satisfies this filter.

Trait Implementations

impl Clone for MetadataFilter

fn clone(&self) -> MetadataFilter

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for MetadataFilter

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for MetadataFilter

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Not for MetadataFilter

type Output = MetadataFilter

The resulting type after applying the ! operator.

fn not(self) -> Self::Output

Performs the unary ! operation.

impl PartialEq for MetadataFilter

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

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 MetadataFilter