Struct PriorityEntry 

pub struct PriorityEntry<K, V> {
    pub key: K,
    pub value: V,
}

Fields

key: K

value: V

Implementations

impl<K, V> PriorityEntry<K, V>

pub fn new(key: K, value: V) -> Self

Examples found in repository

examples/perf_features.rs (line 482)

fn priority_sources(n: usize) -> Vec<PrioritySource<std::vec::IntoIter<PriorityEntry<u64, u64>>>> {
    let per = n / STREAMS;
    (0..STREAMS)
        .map(|s| {
            let stream = (0..per)
                .map(move |i| {
                    let key = ((s + i * STREAMS) as u64) / 2;
                    PriorityEntry::new(key, key)
                })
                .collect::<Vec<_>>()
                .into_iter();
            PrioritySource::new((STREAMS - s) as i32, stream)
        })
        .collect()
}

examples/sample_app.rs (line 216)

fn memtable_wins_the_read() {
    use subms_merge_iterator::{PriorityEntry, PriorityMergeIterator, PrioritySource};
    println!("\n== priority: the memtable is authoritative ==");
    let memtable = PrioritySource::new(
        100,
        PRICE_MEMTABLE
            .iter()
            .map(|&(k, v)| PriorityEntry::new(k, v))
            .collect::<Vec<_>>()
            .into_iter(),
    );
    let flushed = PrioritySource::new(
        10,
        PRICE_FLUSHED
            .iter()
            .map(|&(k, v)| PriorityEntry::new(k, v))
            .collect::<Vec<_>>()
            .into_iter(),
    );

    let view: Vec<(&str, i64)> = PriorityMergeIterator::new([memtable, flushed])
        .map(|e| (e.key, e.value))
        .collect();
    println!("  resolved read view: {view:?}");
    assert_eq!(
        view,
        vec![("AAPL", 152), ("MSFT", 300)],
        "the memtable wins AAPL despite being registered first"
    );
}

Trait Implementations

impl<K: Clone, V: Clone> Clone for PriorityEntry<K, V>

fn clone(&self) -> PriorityEntry<K, V>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<K: Debug, V: Debug> Debug for PriorityEntry<K, V>

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

Formats the value using the given formatter.

impl<K: Eq, V: Eq> Eq for PriorityEntry<K, V>

impl<K: PartialEq, V: PartialEq> PartialEq for PriorityEntry<K, V>

fn eq(&self, other: &PriorityEntry<K, V>) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl<K: PartialEq, V: PartialEq> StructuralPartialEq for PriorityEntry<K, V>