Struct priority_matrix::PriorityMatrix

pub struct PriorityMatrix<R, C, W>where
    R: Clone + Eq + Hash,
    C: Clone + Eq + Hash,
    W: Clone + Ord,{ /* private fields */ }

The 2-dimensional matrix that supports per-row and per-column maximum key queries.

Implementations

impl<R, C, W> PriorityMatrix<R, C, W>where R: Clone + Eq + Hash, C: Clone + Eq + Hash, W: Clone + Ord,

pub fn new(&self) -> Self

pub fn insert(&mut self, row: R, col: C, weight: W) -> Option<W>

pub fn peek(&self) -> Option<BorrowedEntry<'_, R, C, W>>

Examples found in repository

examples/peek.rs (line 14)

fn main() {
    let matrix: PriorityMatrix<char, &str, i32> = [
        ('a', "alpha", 0),
        ('a', "beta", 3),
        ('b', "alpha", 2),
        ('b', "beta", 1),
    ]
    .into_iter()
    .collect();

    // Get the maximum entry
    let entry = matrix.peek().unwrap();
    assert_eq!(entry.row, &'a');
    assert_eq!(entry.column, &"beta");
    assert_eq!(entry.weight, &3);

    // Get the maximum entry in a row
    let entry = matrix.peek_from_row(&'b').unwrap();
    assert_eq!(entry.row, &'b');
    assert_eq!(entry.column, &"alpha");
    assert_eq!(entry.weight, &2);

    // Get the maximum entry in a column
    let entry = matrix.peek_from_column(&"alpha").unwrap();
    assert_eq!(entry.row, &'b');
    assert_eq!(entry.column, &"alpha");
    assert_eq!(entry.weight, &2);
}

pub fn peek_from_row<'a>( &'a self, row: &'a R ) -> Option<BorrowedEntry<'_, R, C, W>>

Examples found in repository

examples/peek.rs (line 20)

fn main() {
    let matrix: PriorityMatrix<char, &str, i32> = [
        ('a', "alpha", 0),
        ('a', "beta", 3),
        ('b', "alpha", 2),
        ('b', "beta", 1),
    ]
    .into_iter()
    .collect();

    // Get the maximum entry
    let entry = matrix.peek().unwrap();
    assert_eq!(entry.row, &'a');
    assert_eq!(entry.column, &"beta");
    assert_eq!(entry.weight, &3);

    // Get the maximum entry in a row
    let entry = matrix.peek_from_row(&'b').unwrap();
    assert_eq!(entry.row, &'b');
    assert_eq!(entry.column, &"alpha");
    assert_eq!(entry.weight, &2);

    // Get the maximum entry in a column
    let entry = matrix.peek_from_column(&"alpha").unwrap();
    assert_eq!(entry.row, &'b');
    assert_eq!(entry.column, &"alpha");
    assert_eq!(entry.weight, &2);
}

pub fn peek_from_column<'a>( &'a self, col: &'a C ) -> Option<BorrowedEntry<'a, R, C, W>>

Examples found in repository

examples/peek.rs (line 26)

fn main() {
    let matrix: PriorityMatrix<char, &str, i32> = [
        ('a', "alpha", 0),
        ('a', "beta", 3),
        ('b', "alpha", 2),
        ('b', "beta", 1),
    ]
    .into_iter()
    .collect();

    // Get the maximum entry
    let entry = matrix.peek().unwrap();
    assert_eq!(entry.row, &'a');
    assert_eq!(entry.column, &"beta");
    assert_eq!(entry.weight, &3);

    // Get the maximum entry in a row
    let entry = matrix.peek_from_row(&'b').unwrap();
    assert_eq!(entry.row, &'b');
    assert_eq!(entry.column, &"alpha");
    assert_eq!(entry.weight, &2);

    // Get the maximum entry in a column
    let entry = matrix.peek_from_column(&"alpha").unwrap();
    assert_eq!(entry.row, &'b');
    assert_eq!(entry.column, &"alpha");
    assert_eq!(entry.weight, &2);
}

pub fn pop(&mut self) -> Option<OwnedEntry<R, C, W>>

pub fn pop_from_row(&mut self, row: &R) -> Option<OwnedEntry<R, C, W>>

pub fn pop_from_column(&mut self, col: &C) -> Option<OwnedEntry<R, C, W>>

pub fn remove(&mut self, row: &R, col: &C) -> bool

pub fn remove_row(&mut self, row: &R)

pub fn remove_column(&mut self, col: &C)

pub fn remove_row_and_column(&mut self, row: &R, col: &C)

pub fn iter(&self) -> Iter<'_, R, C, W>

Trait Implementations

impl<R, C, W> Clone for PriorityMatrix<R, C, W>where R: Clone + Eq + Hash + Clone, C: Clone + Eq + Hash + Clone, W: Clone + Ord + Clone,

fn clone(&self) -> PriorityMatrix<R, C, W>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<R, C, W> Debug for PriorityMatrix<R, C, W>where R: Clone + Eq + Hash + Debug, C: Clone + Eq + Hash + Debug, W: Clone + Ord + Debug,

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

Formats the value using the given formatter.

impl<R, C, W> Default for PriorityMatrix<R, C, W>where R: Clone + Eq + Hash, C: Clone + Eq + Hash, W: Clone + Ord,

fn default() -> Self

Returns the “default value” for a type.

impl<R, C, W> FromIterator<(R, C, W)> for PriorityMatrix<R, C, W>where R: Clone + Eq + Hash, C: Clone + Eq + Hash, W: Clone + Ord,

fn from_iter<T>(iter: T) -> Selfwhere T: IntoIterator<Item = (R, C, W)>,

Creates a value from an iterator.

impl<R, C, W> IntoIterator for PriorityMatrix<R, C, W>where R: Clone + Eq + Hash, C: Clone + Eq + Hash, W: Clone + Ord,

type Item = (R, C, W)

The type of the elements being iterated over.

type IntoIter = IntoIter<R, C, W>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.