Struct RawEntry

pub struct RawEntry<'v, T, K, V>
where
    T: Ord + Clone,
    K: Hash + Eq,
    V: OrdBy<Target = T>,
{ /* private fields */ }

Implementations

impl<'v, T, K, V> RawEntry<'v, T, K, V>

where T: Ord + Clone, K: Hash + Eq, V: OrdBy<Target = T>,

pub fn get_mut_with_key(&mut self) -> (&K, &mut V)

Examples found in repository

examples/people_ord_by_age.rs (line 118)

fn main() {
    let mut peoples = ValordMap::new();
    peoples.insert(
        1,
        People {
            age: 18,
            name: "qians1".to_string(),
        },
    );
    peoples.insert(
        2,
        People {
            age: 19,
            name: "qians2".to_string(),
        },
    );
    peoples.insert(
        3,
        People {
            age: 20,
            name: "qians3".to_string(),
        },
    );
    peoples.insert(
        4,
        People {
            age: 21,
            name: "qians4".to_string(),
        },
    );
    peoples.insert(
        5,
        People {
            age: 22,
            name: "qians5".to_string(),
        },
    );

    let youngest = peoples.first();
    assert_eq!(youngest.len(), 1);
    assert_eq!(
        youngest[0],
        (
            &1,
            &People {
                age: 18,
                name: "qians1".to_string(),
            }
        )
    );

    let oldest = peoples.last();
    assert_eq!(oldest.len(), 1);
    assert_eq!(
        oldest[0],
        (
            &5,
            &People {
                age: 22,
                name: "qians5".to_string(),
            }
        )
    );

    peoples
        .iter_mut()
        .for_each(|mut people_ref_mut| people_ref_mut.age += 1);

    let youngest = peoples.first();
    assert_eq!(youngest.len(), 1);
    assert_eq!(
        youngest[0],
        (
            &1,
            &People {
                age: 19,
                name: "qians1".to_string(),
            }
        )
    );

    let oldest = peoples.last();
    assert_eq!(oldest.len(), 1);
    assert_eq!(
        oldest[0],
        (
            &5,
            &People {
                age: 23,
                name: "qians5".to_string(),
            }
        )
    );

    let range: Vec<_> = peoples.range(22..).collect();
    assert_eq!(range.len(), 2);
    println!("range: {range:?}");

    let range: Vec<_> = peoples
        .range_mut(22..)
        .map(|mut rm_p| {
            let (k, v) = rm_p.get_mut_with_key();
            v.age = 30;
            (*k, v.name.clone(), v.age)
        })
        .collect();

    println!("range mut: {range:?}");

    let oldest = peoples.last();
    assert_eq!(oldest.len(), 2);
    assert_eq!(oldest[0].1.age, 30,);
    assert_eq!(oldest[1].1.age, 30);
    println!("peoples: {:?}", peoples.iter().collect::<Vec<_>>());
}

Trait Implementations

impl<'a, T, K, V> Deref for RawEntry<'a, T, K, V>

where T: Ord + Clone, K: Hash + Eq, V: OrdBy<Target = T>,

type Target = V

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl<'a, T, K, V> DerefMut for RawEntry<'a, T, K, V>

where T: Ord + Clone, K: Hash + Eq, V: OrdBy<Target = T>,

fn deref_mut(&mut self) -> &mut Self::Target

Mutably dereferences the value.

impl<'a, T, K, V> Drop for RawEntry<'a, T, K, V>

where T: Ord + Clone, K: Hash + Eq, V: OrdBy<Target = T>,

fn drop(&mut self)

Executes the destructor for this type.