Struct Matches 

pub struct Matches { /* private fields */ }

Match set.

This match set implementation is based on a minimal bitset implementation, that allows to efficiently manage and work with match sets and filters. It mustn’t be considered a complete implementation of general purpose bitsets, but only provides the methods we need for efficient matching.

Using a focused implementation allows us to optimize for our specific use case, and avoids yet another dependency to manage.

Implementations

impl Matches

pub fn new() -> Self

Creates a match set.

Examples

use zrx_id::Matches;

// Create match set
let matches = Matches::new();

pub fn with_capacity(capacity: usize) -> Self

Creates a match set with the given capacity.

Examples

use zrx_id::Matches;

// Create match set with capacity
let matches = Matches::with_capacity(128);

pub fn contains(&self, index: usize) -> bool

Returns whether the match set contains the given match.

Panics

Panics if the index is out of bounds.

Examples

use zrx_id::Matches;

// Create match set
let matches = Matches::from_iter([1]);

// Ensure presence of matches
assert_eq!(matches.contains(0), false);
assert_eq!(matches.contains(1), true);

pub fn add(&mut self, index: usize)

Adds a match to the match set.

Examples

use zrx_id::Matches;

// Create match set
let mut matches = Matches::new();

// Add match to set
matches.add(0);

pub fn clear(&mut self)

Clears all matches in the match set.

Examples

use zrx_id::Matches;

// Create match set
let mut matches = Matches::from_iter([0, 1, 2]);

// Remove all matches
matches.clear();
assert!(matches.is_empty());

pub fn union(&mut self, other: &Self)

Computes the union with the given match set.

Examples

use zrx_id::Matches;

// Create two match sets
let mut a = Matches::from_iter([0, 1]);
let mut b = Matches::from_iter([1, 2]);

// Create union of match sets
a.union(&b);
assert_eq!(a, Matches::from_iter([0, 1, 2]));

pub fn intersect(&mut self, other: &Self)

Computes the intersection with the given match set.

Examples

use zrx_id::Matches;

// Create two match sets
let mut a = Matches::from_iter([0, 1]);
let mut b = Matches::from_iter([1, 2]);

// Create intersection of match sets
a.intersect(&b);
assert_eq!(a, Matches::from_iter([1]));

pub fn has_any(&self, other: &Self) -> bool

Returns whether any of the given matches is present.

Examples

use zrx_id::Matches;

// Create two match sets
let mut a = Matches::from_iter([0, 1]);
let mut b = Matches::from_iter([1, 2]);

// Ensure presence of matches
assert!(b.has_any(&a));

pub fn has_all(&self, other: &Self) -> bool

Returns whether the given matches are all present.

Examples

use zrx_id::Matches;

// Create two match sets
let mut a = Matches::from_iter([0, 1]);
let mut b = Matches::from_iter([0, 1, 2]);

// Ensure presence of matches
assert!(b.has_all(&a));

impl Matches

pub fn len(&self) -> usize

Returns the number of matches.

pub fn is_empty(&self) -> bool

Returns whether there are any matches.

Trait Implementations

impl Clone for Matches

fn clone(&self) -> Matches

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Matches

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

Formats the value using the given formatter.

impl Default for Matches

fn default() -> Self

Creates a match set.

Examples

use zrx_id::Matches;

// Create match set
let matches = Matches::default();

impl FromIterator<usize> for Matches

fn from_iter<T>(iter: T) -> Self

where T: IntoIterator<Item = usize>,

Creates a match set from an iterator.

Examples

use zrx_id::Matches;

// Create match set from iterator
let matches = Matches::from_iter([0, 1]);

impl IntoIterator for Matches

fn into_iter(self) -> Self::IntoIter

Creates a consuming iterator over the match set.

Examples

use zrx_id::Matches;

// Create match set from iterator
let mut matches = Matches::from_iter([0, 1]);

// Create iterator over match set
for index in matches {
    println!("{index:?}");
}

type Item = usize

The type of the elements being iterated over.

type IntoIter = IntoIter

Which kind of iterator are we turning this into?

impl PartialEq for Matches

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

impl StructuralPartialEq for Matches