Struct ValordMap

Source

pub struct ValordMap<T, K, V: OrdBy<Target = T>> { /* private fields */ }

Implementations§

Source §

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

Source

pub fn new() -> Self

Examples found in repository ?

examples/people_ord_by_age.rs (line 18)

17fn main() {
18    let mut peoples = ValordMap::new();
19    peoples.insert(
20        1,
21        People {
22            age: 18,
23            name: "qians1".to_string(),
24        },
25    );
26    peoples.insert(
27        2,
28        People {
29            age: 19,
30            name: "qians2".to_string(),
31        },
32    );
33    peoples.insert(
34        3,
35        People {
36            age: 20,
37            name: "qians3".to_string(),
38        },
39    );
40    peoples.insert(
41        4,
42        People {
43            age: 21,
44            name: "qians4".to_string(),
45        },
46    );
47    peoples.insert(
48        5,
49        People {
50            age: 22,
51            name: "qians5".to_string(),
52        },
53    );
54
55    let youngest = peoples.first();
56    assert_eq!(youngest.len(), 1);
57    assert_eq!(
58        youngest[0],
59        (
60            &1,
61            &People {
62                age: 18,
63                name: "qians1".to_string(),
64            }
65        )
66    );
67
68    let oldest = peoples.last();
69    assert_eq!(oldest.len(), 1);
70    assert_eq!(
71        oldest[0],
72        (
73            &5,
74            &People {
75                age: 22,
76                name: "qians5".to_string(),
77            }
78        )
79    );
80
81    peoples
82        .iter_mut()
83        .for_each(|mut people_ref_mut| people_ref_mut.age += 1);
84
85    let youngest = peoples.first();
86    assert_eq!(youngest.len(), 1);
87    assert_eq!(
88        youngest[0],
89        (
90            &1,
91            &People {
92                age: 19,
93                name: "qians1".to_string(),
94            }
95        )
96    );
97
98    let oldest = peoples.last();
99    assert_eq!(oldest.len(), 1);
100    assert_eq!(
101        oldest[0],
102        (
103            &5,
104            &People {
105                age: 23,
106                name: "qians5".to_string(),
107            }
108        )
109    );
110
111    let range: Vec<_> = peoples.range(22..).collect();
112    assert_eq!(range.len(), 2);
113    println!("range: {range:?}");
114
115    let range: Vec<_> = peoples
116        .range_mut(22..)
117        .map(|mut rm_p| {
118            let (k, v) = rm_p.get_mut_with_key();
119            v.age = 30;
120            (*k, v.name.clone(), v.age)
121        })
122        .collect();
123
124    println!("range mut: {range:?}");
125
126    let oldest = peoples.last();
127    assert_eq!(oldest.len(), 2);
128    assert_eq!(oldest[0].1.age, 30,);
129    assert_eq!(oldest[1].1.age, 30);
130    println!("peoples: {:?}", peoples.iter().collect::<Vec<_>>());
131}

Source

pub fn insert(&mut self, key: K, value: V)

insert into ValordMap

§Example

use valord_map::ValordMap;

let mut valord = ValordMap::new();
valord.insert("qians", 1);
valord.insert("tedious", 2);
valord.insert("xuandu", 3);
valord.insert("xuandu", 1);

let sorted_pairs: Vec<_> = valord.iter().collect();

println!("{:?}", sorted_pairs);

assert_eq!(sorted_pairs.len(), 3);
assert_eq!(sorted_pairs[0].1, &1);
assert_eq!(sorted_pairs[1].1, &1);
assert_eq!(sorted_pairs[2], (&"tedious", &2));

Examples found in repository ?

examples/people_ord_by_age.rs (lines 19-25)

17fn main() {
18    let mut peoples = ValordMap::new();
19    peoples.insert(
20        1,
21        People {
22            age: 18,
23            name: "qians1".to_string(),
24        },
25    );
26    peoples.insert(
27        2,
28        People {
29            age: 19,
30            name: "qians2".to_string(),
31        },
32    );
33    peoples.insert(
34        3,
35        People {
36            age: 20,
37            name: "qians3".to_string(),
38        },
39    );
40    peoples.insert(
41        4,
42        People {
43            age: 21,
44            name: "qians4".to_string(),
45        },
46    );
47    peoples.insert(
48        5,
49        People {
50            age: 22,
51            name: "qians5".to_string(),
52        },
53    );
54
55    let youngest = peoples.first();
56    assert_eq!(youngest.len(), 1);
57    assert_eq!(
58        youngest[0],
59        (
60            &1,
61            &People {
62                age: 18,
63                name: "qians1".to_string(),
64            }
65        )
66    );
67
68    let oldest = peoples.last();
69    assert_eq!(oldest.len(), 1);
70    assert_eq!(
71        oldest[0],
72        (
73            &5,
74            &People {
75                age: 22,
76                name: "qians5".to_string(),
77            }
78        )
79    );
80
81    peoples
82        .iter_mut()
83        .for_each(|mut people_ref_mut| people_ref_mut.age += 1);
84
85    let youngest = peoples.first();
86    assert_eq!(youngest.len(), 1);
87    assert_eq!(
88        youngest[0],
89        (
90            &1,
91            &People {
92                age: 19,
93                name: "qians1".to_string(),
94            }
95        )
96    );
97
98    let oldest = peoples.last();
99    assert_eq!(oldest.len(), 1);
100    assert_eq!(
101        oldest[0],
102        (
103            &5,
104            &People {
105                age: 23,
106                name: "qians5".to_string(),
107            }
108        )
109    );
110
111    let range: Vec<_> = peoples.range(22..).collect();
112    assert_eq!(range.len(), 2);
113    println!("range: {range:?}");
114
115    let range: Vec<_> = peoples
116        .range_mut(22..)
117        .map(|mut rm_p| {
118            let (k, v) = rm_p.get_mut_with_key();
119            v.age = 30;
120            (*k, v.name.clone(), v.age)
121        })
122        .collect();
123
124    println!("range mut: {range:?}");
125
126    let oldest = peoples.last();
127    assert_eq!(oldest.len(), 2);
128    assert_eq!(oldest[0].1.age, 30,);
129    assert_eq!(oldest[1].1.age, 30);
130    println!("peoples: {:?}", peoples.iter().collect::<Vec<_>>());
131}

Source

pub fn entry(&mut self, key: K) -> Entry<'_, T, K, V>

Get the given key’s corresponding entry in the map for insertion and/or in-place manipulation

§Examples

use valord_map::ValordMap;

let mut map = ValordMap::new();
map.entry("key").and_modify(|v| *v = "new value").or_insert("value");

assert_eq!(map.get(&"key"), Some(&"value"));

map.entry("key").and_modify(|v| *v = "new value").or_insert("value");

assert_eq!(map.get(&"key"), Some(&"new value"));

Source

pub fn iter(&self) -> impl Iterator<Item = (&K, &V)>

Returns an iterator over the ValordMap. The iterator yields all items from start to end order by value.ord_by().

§Example

use valord_map::ValordMap;

let mut valord = ValordMap::new();
valord.insert("qians", 1);
valord.insert("tedious", 2);
valord.insert("xuandu", 3);
valord.insert("xuandu", 1);

let mut iter = valord.iter();

assert_eq!(iter.next().unwrap().1, &1);
assert_eq!(iter.next().unwrap().1, &1);
assert_eq!(iter.next().unwrap(), (&"tedious", &2));

Examples found in repository ?

examples/people_ord_by_age.rs (line 130)

17fn main() {
18    let mut peoples = ValordMap::new();
19    peoples.insert(
20        1,
21        People {
22            age: 18,
23            name: "qians1".to_string(),
24        },
25    );
26    peoples.insert(
27        2,
28        People {
29            age: 19,
30            name: "qians2".to_string(),
31        },
32    );
33    peoples.insert(
34        3,
35        People {
36            age: 20,
37            name: "qians3".to_string(),
38        },
39    );
40    peoples.insert(
41        4,
42        People {
43            age: 21,
44            name: "qians4".to_string(),
45        },
46    );
47    peoples.insert(
48        5,
49        People {
50            age: 22,
51            name: "qians5".to_string(),
52        },
53    );
54
55    let youngest = peoples.first();
56    assert_eq!(youngest.len(), 1);
57    assert_eq!(
58        youngest[0],
59        (
60            &1,
61            &People {
62                age: 18,
63                name: "qians1".to_string(),
64            }
65        )
66    );
67
68    let oldest = peoples.last();
69    assert_eq!(oldest.len(), 1);
70    assert_eq!(
71        oldest[0],
72        (
73            &5,
74            &People {
75                age: 22,
76                name: "qians5".to_string(),
77            }
78        )
79    );
80
81    peoples
82        .iter_mut()
83        .for_each(|mut people_ref_mut| people_ref_mut.age += 1);
84
85    let youngest = peoples.first();
86    assert_eq!(youngest.len(), 1);
87    assert_eq!(
88        youngest[0],
89        (
90            &1,
91            &People {
92                age: 19,
93                name: "qians1".to_string(),
94            }
95        )
96    );
97
98    let oldest = peoples.last();
99    assert_eq!(oldest.len(), 1);
100    assert_eq!(
101        oldest[0],
102        (
103            &5,
104            &People {
105                age: 23,
106                name: "qians5".to_string(),
107            }
108        )
109    );
110
111    let range: Vec<_> = peoples.range(22..).collect();
112    assert_eq!(range.len(), 2);
113    println!("range: {range:?}");
114
115    let range: Vec<_> = peoples
116        .range_mut(22..)
117        .map(|mut rm_p| {
118            let (k, v) = rm_p.get_mut_with_key();
119            v.age = 30;
120            (*k, v.name.clone(), v.age)
121        })
122        .collect();
123
124    println!("range mut: {range:?}");
125
126    let oldest = peoples.last();
127    assert_eq!(oldest.len(), 2);
128    assert_eq!(oldest[0].1.age, 30,);
129    assert_eq!(oldest[1].1.age, 30);
130    println!("peoples: {:?}", peoples.iter().collect::<Vec<_>>());
131}

Source

pub fn rev_iter(&self) -> impl Iterator<Item = (&K, &V)>

Returns an reversesed iterator over the ValordMap. The iterator yields all items from start to end order by value.ord_by().

§Example

use valord_map::ValordMap;

let mut valord = ValordMap::new();
valord.insert("qians", 1);
valord.insert("tedious", 2);
valord.insert("xuandu", 3);
valord.insert("xuandu", 1);

let mut iter = valord.rev_iter();

assert_eq!(iter.next().unwrap(), (&"tedious", &2));
assert_eq!(iter.next().unwrap().1, &1);
assert_eq!(iter.next().unwrap().1, &1);

Source

pub fn iter_mut(&mut self) -> impl Iterator<Item = RawEntry<'_, T, K, V>>

Returns an mut iterator over the ValordMap. The iterator yields all items from start to end order by value.ord_by().

§Example

use valord_map::ValordMap;

let mut valord = ValordMap::new();
valord.insert("qians", 1);
valord.insert("tedious", 2);
valord.insert("xuandu", 3);


let mut iter = valord.iter_mut();

let mut item1 = iter.next().unwrap();
let (k, v) = item1.get_mut_with_key();
assert_eq!(v, &mut 1);
*v = 4;
drop(item1);

assert_eq!(iter.next().unwrap().get_mut_with_key(), (&"tedious", &mut 2));
assert_eq!(iter.next().unwrap().get_mut_with_key(), (&"xuandu", &mut 3));
assert!(iter.next().is_none());
drop(iter);

let max_list = valord.last();
assert_eq!(max_list.len(), 1);
assert_eq!(max_list, vec![(&"qians", &4)]);

Examples found in repository ?

examples/people_ord_by_age.rs (line 82)

17fn main() {
18    let mut peoples = ValordMap::new();
19    peoples.insert(
20        1,
21        People {
22            age: 18,
23            name: "qians1".to_string(),
24        },
25    );
26    peoples.insert(
27        2,
28        People {
29            age: 19,
30            name: "qians2".to_string(),
31        },
32    );
33    peoples.insert(
34        3,
35        People {
36            age: 20,
37            name: "qians3".to_string(),
38        },
39    );
40    peoples.insert(
41        4,
42        People {
43            age: 21,
44            name: "qians4".to_string(),
45        },
46    );
47    peoples.insert(
48        5,
49        People {
50            age: 22,
51            name: "qians5".to_string(),
52        },
53    );
54
55    let youngest = peoples.first();
56    assert_eq!(youngest.len(), 1);
57    assert_eq!(
58        youngest[0],
59        (
60            &1,
61            &People {
62                age: 18,
63                name: "qians1".to_string(),
64            }
65        )
66    );
67
68    let oldest = peoples.last();
69    assert_eq!(oldest.len(), 1);
70    assert_eq!(
71        oldest[0],
72        (
73            &5,
74            &People {
75                age: 22,
76                name: "qians5".to_string(),
77            }
78        )
79    );
80
81    peoples
82        .iter_mut()
83        .for_each(|mut people_ref_mut| people_ref_mut.age += 1);
84
85    let youngest = peoples.first();
86    assert_eq!(youngest.len(), 1);
87    assert_eq!(
88        youngest[0],
89        (
90            &1,
91            &People {
92                age: 19,
93                name: "qians1".to_string(),
94            }
95        )
96    );
97
98    let oldest = peoples.last();
99    assert_eq!(oldest.len(), 1);
100    assert_eq!(
101        oldest[0],
102        (
103            &5,
104            &People {
105                age: 23,
106                name: "qians5".to_string(),
107            }
108        )
109    );
110
111    let range: Vec<_> = peoples.range(22..).collect();
112    assert_eq!(range.len(), 2);
113    println!("range: {range:?}");
114
115    let range: Vec<_> = peoples
116        .range_mut(22..)
117        .map(|mut rm_p| {
118            let (k, v) = rm_p.get_mut_with_key();
119            v.age = 30;
120            (*k, v.name.clone(), v.age)
121        })
122        .collect();
123
124    println!("range mut: {range:?}");
125
126    let oldest = peoples.last();
127    assert_eq!(oldest.len(), 2);
128    assert_eq!(oldest[0].1.age, 30,);
129    assert_eq!(oldest[1].1.age, 30);
130    println!("peoples: {:?}", peoples.iter().collect::<Vec<_>>());
131}

Source

pub fn rev_iter_mut(&mut self) -> impl Iterator<Item = RawEntry<'_, T, K, V>>

Returns an reversesed mut iterator over the ValordMap. The iterator yields all items from start to end order by value.ord_by().

§Example

use valord_map::ValordMap;

let mut valord = ValordMap::new();
valord.insert("qians", 1);
valord.insert("tedious", 2);
valord.insert("xuandu", 3);


let mut iter = valord.rev_iter_mut();

let mut item1 = iter.next().unwrap();
let (k, v) = item1.get_mut_with_key();
assert_eq!(v, &mut 3);
*v = 0;
drop(item1);

assert_eq!(iter.next().unwrap().get_mut_with_key(), (&"tedious", &mut 2));
assert_eq!(iter.next().unwrap().get_mut_with_key(), (&"qians", &mut 1));
assert!(iter.next().is_none());
drop(iter);

let max_list = valord.first();
assert_eq!(max_list.len(), 1);
assert_eq!(max_list, vec![(&"xuandu", &0)]);

Source

pub fn first(&self) -> Vec<(&K, &V)>

Returns the first vector of key-value pairs in the map. The value in this pair is the minimum values in the map.

§Example

use valord_map::ValordMap;

let mut valord = ValordMap::new();
valord.insert("qians", 1);
valord.insert("tedious", 2);
valord.insert("xuandu", 3);
valord.insert("xuandu", 1);

let min_list = valord.first();

assert_eq!(min_list.len(), 2);
assert!(min_list.iter().all(|(_, v)| **v == 1));

Examples found in repository ?

examples/people_ord_by_age.rs (line 55)

17fn main() {
18    let mut peoples = ValordMap::new();
19    peoples.insert(
20        1,
21        People {
22            age: 18,
23            name: "qians1".to_string(),
24        },
25    );
26    peoples.insert(
27        2,
28        People {
29            age: 19,
30            name: "qians2".to_string(),
31        },
32    );
33    peoples.insert(
34        3,
35        People {
36            age: 20,
37            name: "qians3".to_string(),
38        },
39    );
40    peoples.insert(
41        4,
42        People {
43            age: 21,
44            name: "qians4".to_string(),
45        },
46    );
47    peoples.insert(
48        5,
49        People {
50            age: 22,
51            name: "qians5".to_string(),
52        },
53    );
54
55    let youngest = peoples.first();
56    assert_eq!(youngest.len(), 1);
57    assert_eq!(
58        youngest[0],
59        (
60            &1,
61            &People {
62                age: 18,
63                name: "qians1".to_string(),
64            }
65        )
66    );
67
68    let oldest = peoples.last();
69    assert_eq!(oldest.len(), 1);
70    assert_eq!(
71        oldest[0],
72        (
73            &5,
74            &People {
75                age: 22,
76                name: "qians5".to_string(),
77            }
78        )
79    );
80
81    peoples
82        .iter_mut()
83        .for_each(|mut people_ref_mut| people_ref_mut.age += 1);
84
85    let youngest = peoples.first();
86    assert_eq!(youngest.len(), 1);
87    assert_eq!(
88        youngest[0],
89        (
90            &1,
91            &People {
92                age: 19,
93                name: "qians1".to_string(),
94            }
95        )
96    );
97
98    let oldest = peoples.last();
99    assert_eq!(oldest.len(), 1);
100    assert_eq!(
101        oldest[0],
102        (
103            &5,
104            &People {
105                age: 23,
106                name: "qians5".to_string(),
107            }
108        )
109    );
110
111    let range: Vec<_> = peoples.range(22..).collect();
112    assert_eq!(range.len(), 2);
113    println!("range: {range:?}");
114
115    let range: Vec<_> = peoples
116        .range_mut(22..)
117        .map(|mut rm_p| {
118            let (k, v) = rm_p.get_mut_with_key();
119            v.age = 30;
120            (*k, v.name.clone(), v.age)
121        })
122        .collect();
123
124    println!("range mut: {range:?}");
125
126    let oldest = peoples.last();
127    assert_eq!(oldest.len(), 2);
128    assert_eq!(oldest[0].1.age, 30,);
129    assert_eq!(oldest[1].1.age, 30);
130    println!("peoples: {:?}", peoples.iter().collect::<Vec<_>>());
131}

Source

pub fn first_mut(&mut self) -> Vec<RawEntry<'_, T, K, V>>

Returns the first vector of key-value mut pairs in the map. The value in this pair is the minimum values in the map.

§Example

use valord_map::ValordMap;

let mut valord = ValordMap::new();
valord.insert("qians", 1);
valord.insert("tedious", 2);
valord.insert("xuandu", 3);
valord.insert("xuandu", 1);

let mut min_list = valord.first_mut();
assert_eq!(min_list.len(), 2);
min_list.iter_mut().for_each(|entry| {
    let (_k, v) = entry.get_mut_with_key();
    *v = 0;
});
drop(min_list);

let min_list = valord.first();
assert!(min_list.iter().all(|(_, v)| **v == 0));

Source

pub fn last(&self) -> Vec<(&K, &V)>

Returns the last vector of key-value pairs in the map. The value in this pair is the maximum values in the map.

§Example

use valord_map::ValordMap;

let mut valord = ValordMap::new();
valord.insert("qians", 1);
valord.insert("tedious", 2);
valord.insert("xuandu", 3);
valord.insert("xuandu", 1);

let max_list = valord.last();

assert_eq!(max_list.len(), 1);
assert_eq!(max_list, vec![(&"tedious", &2)]);

Examples found in repository ?

examples/people_ord_by_age.rs (line 68)

17fn main() {
18    let mut peoples = ValordMap::new();
19    peoples.insert(
20        1,
21        People {
22            age: 18,
23            name: "qians1".to_string(),
24        },
25    );
26    peoples.insert(
27        2,
28        People {
29            age: 19,
30            name: "qians2".to_string(),
31        },
32    );
33    peoples.insert(
34        3,
35        People {
36            age: 20,
37            name: "qians3".to_string(),
38        },
39    );
40    peoples.insert(
41        4,
42        People {
43            age: 21,
44            name: "qians4".to_string(),
45        },
46    );
47    peoples.insert(
48        5,
49        People {
50            age: 22,
51            name: "qians5".to_string(),
52        },
53    );
54
55    let youngest = peoples.first();
56    assert_eq!(youngest.len(), 1);
57    assert_eq!(
58        youngest[0],
59        (
60            &1,
61            &People {
62                age: 18,
63                name: "qians1".to_string(),
64            }
65        )
66    );
67
68    let oldest = peoples.last();
69    assert_eq!(oldest.len(), 1);
70    assert_eq!(
71        oldest[0],
72        (
73            &5,
74            &People {
75                age: 22,
76                name: "qians5".to_string(),
77            }
78        )
79    );
80
81    peoples
82        .iter_mut()
83        .for_each(|mut people_ref_mut| people_ref_mut.age += 1);
84
85    let youngest = peoples.first();
86    assert_eq!(youngest.len(), 1);
87    assert_eq!(
88        youngest[0],
89        (
90            &1,
91            &People {
92                age: 19,
93                name: "qians1".to_string(),
94            }
95        )
96    );
97
98    let oldest = peoples.last();
99    assert_eq!(oldest.len(), 1);
100    assert_eq!(
101        oldest[0],
102        (
103            &5,
104            &People {
105                age: 23,
106                name: "qians5".to_string(),
107            }
108        )
109    );
110
111    let range: Vec<_> = peoples.range(22..).collect();
112    assert_eq!(range.len(), 2);
113    println!("range: {range:?}");
114
115    let range: Vec<_> = peoples
116        .range_mut(22..)
117        .map(|mut rm_p| {
118            let (k, v) = rm_p.get_mut_with_key();
119            v.age = 30;
120            (*k, v.name.clone(), v.age)
121        })
122        .collect();
123
124    println!("range mut: {range:?}");
125
126    let oldest = peoples.last();
127    assert_eq!(oldest.len(), 2);
128    assert_eq!(oldest[0].1.age, 30,);
129    assert_eq!(oldest[1].1.age, 30);
130    println!("peoples: {:?}", peoples.iter().collect::<Vec<_>>());
131}

Source

pub fn last_mut(&mut self) -> Vec<RawEntry<'_, T, K, V>>

Returns the last vector of key-value mut pairs in the map. The value in this pair is the minimum values in the map.

§Example

use valord_map::ValordMap;

let mut valord = ValordMap::new();
valord.insert("qians", 1);
valord.insert("tedious", 2);
valord.insert("xuandu", 3);
valord.insert("sheng", 4);

let mut max_list = valord.last_mut();
assert_eq!(max_list.len(), 1);
let (k, v) = max_list[0].get_mut_with_key();
assert_eq!((&k, &v), (&&"sheng", &&mut 4));

*v = 2;
drop(max_list);

let max_list = valord.last();
assert_eq!(max_list.len(), 1);
assert_eq!(max_list, vec![(&"xuandu", &3)]);

Source

pub fn range<R>(&self, range: R) -> impl Iterator<Item = (&K, &V)>
where R: RangeBounds<V::Target>,

get range from ValordMap

§Example

use valord_map::ValordMap;

let mut valord = ValordMap::new();
valord.insert("qians", 1);
valord.insert("tedious", 2);
valord.insert("sheng", 3);
valord.insert("xuandu", 4);
valord.insert("xuandu2", 5);
valord.insert("xuandu3", 6);
assert_eq!(valord.range(4..).last().unwrap(), (&"xuandu3", &6));
assert_eq!(
    valord
        .range(4..)
        .filter(|(_, v)| **v != 6)
        .last()
        .unwrap(),
    (&"xuandu2", &5)
);

Examples found in repository ?

examples/people_ord_by_age.rs (line 111)

17fn main() {
18    let mut peoples = ValordMap::new();
19    peoples.insert(
20        1,
21        People {
22            age: 18,
23            name: "qians1".to_string(),
24        },
25    );
26    peoples.insert(
27        2,
28        People {
29            age: 19,
30            name: "qians2".to_string(),
31        },
32    );
33    peoples.insert(
34        3,
35        People {
36            age: 20,
37            name: "qians3".to_string(),
38        },
39    );
40    peoples.insert(
41        4,
42        People {
43            age: 21,
44            name: "qians4".to_string(),
45        },
46    );
47    peoples.insert(
48        5,
49        People {
50            age: 22,
51            name: "qians5".to_string(),
52        },
53    );
54
55    let youngest = peoples.first();
56    assert_eq!(youngest.len(), 1);
57    assert_eq!(
58        youngest[0],
59        (
60            &1,
61            &People {
62                age: 18,
63                name: "qians1".to_string(),
64            }
65        )
66    );
67
68    let oldest = peoples.last();
69    assert_eq!(oldest.len(), 1);
70    assert_eq!(
71        oldest[0],
72        (
73            &5,
74            &People {
75                age: 22,
76                name: "qians5".to_string(),
77            }
78        )
79    );
80
81    peoples
82        .iter_mut()
83        .for_each(|mut people_ref_mut| people_ref_mut.age += 1);
84
85    let youngest = peoples.first();
86    assert_eq!(youngest.len(), 1);
87    assert_eq!(
88        youngest[0],
89        (
90            &1,
91            &People {
92                age: 19,
93                name: "qians1".to_string(),
94            }
95        )
96    );
97
98    let oldest = peoples.last();
99    assert_eq!(oldest.len(), 1);
100    assert_eq!(
101        oldest[0],
102        (
103            &5,
104            &People {
105                age: 23,
106                name: "qians5".to_string(),
107            }
108        )
109    );
110
111    let range: Vec<_> = peoples.range(22..).collect();
112    assert_eq!(range.len(), 2);
113    println!("range: {range:?}");
114
115    let range: Vec<_> = peoples
116        .range_mut(22..)
117        .map(|mut rm_p| {
118            let (k, v) = rm_p.get_mut_with_key();
119            v.age = 30;
120            (*k, v.name.clone(), v.age)
121        })
122        .collect();
123
124    println!("range mut: {range:?}");
125
126    let oldest = peoples.last();
127    assert_eq!(oldest.len(), 2);
128    assert_eq!(oldest[0].1.age, 30,);
129    assert_eq!(oldest[1].1.age, 30);
130    println!("peoples: {:?}", peoples.iter().collect::<Vec<_>>());
131}

Source

pub fn range_mut<R>( &mut self, range: R, ) -> impl Iterator<Item = RawEntry<'_, T, K, V>>
where R: RangeBounds<V::Target>,

get range mut from ValordMap

§Example

use valord_map::ValordMap;

let mut valord = ValordMap::new();
valord.insert("qians", 1);
valord.insert("tedious", 2);
valord.insert("sheng", 3);
valord.insert("xuandu", 4);
valord.insert("xuandu2", 5);
valord.insert("xuandu3", 6);

let mut range_iter = valord.range_mut(4..);

let mut item1 = range_iter.next().unwrap();
let (k, v) = item1.get_mut_with_key();
assert_eq!(k, &"xuandu");
assert_eq!(v, &mut 4);
*v += 4;
drop(item1);
drop(range_iter);

assert_eq!(
    valord
        .range(4..)
        .last(),
    Some((&"xuandu", &8))
);

Examples found in repository ?

examples/people_ord_by_age.rs (line 116)

17fn main() {
18    let mut peoples = ValordMap::new();
19    peoples.insert(
20        1,
21        People {
22            age: 18,
23            name: "qians1".to_string(),
24        },
25    );
26    peoples.insert(
27        2,
28        People {
29            age: 19,
30            name: "qians2".to_string(),
31        },
32    );
33    peoples.insert(
34        3,
35        People {
36            age: 20,
37            name: "qians3".to_string(),
38        },
39    );
40    peoples.insert(
41        4,
42        People {
43            age: 21,
44            name: "qians4".to_string(),
45        },
46    );
47    peoples.insert(
48        5,
49        People {
50            age: 22,
51            name: "qians5".to_string(),
52        },
53    );
54
55    let youngest = peoples.first();
56    assert_eq!(youngest.len(), 1);
57    assert_eq!(
58        youngest[0],
59        (
60            &1,
61            &People {
62                age: 18,
63                name: "qians1".to_string(),
64            }
65        )
66    );
67
68    let oldest = peoples.last();
69    assert_eq!(oldest.len(), 1);
70    assert_eq!(
71        oldest[0],
72        (
73            &5,
74            &People {
75                age: 22,
76                name: "qians5".to_string(),
77            }
78        )
79    );
80
81    peoples
82        .iter_mut()
83        .for_each(|mut people_ref_mut| people_ref_mut.age += 1);
84
85    let youngest = peoples.first();
86    assert_eq!(youngest.len(), 1);
87    assert_eq!(
88        youngest[0],
89        (
90            &1,
91            &People {
92                age: 19,
93                name: "qians1".to_string(),
94            }
95        )
96    );
97
98    let oldest = peoples.last();
99    assert_eq!(oldest.len(), 1);
100    assert_eq!(
101        oldest[0],
102        (
103            &5,
104            &People {
105                age: 23,
106                name: "qians5".to_string(),
107            }
108        )
109    );
110
111    let range: Vec<_> = peoples.range(22..).collect();
112    assert_eq!(range.len(), 2);
113    println!("range: {range:?}");
114
115    let range: Vec<_> = peoples
116        .range_mut(22..)
117        .map(|mut rm_p| {
118            let (k, v) = rm_p.get_mut_with_key();
119            v.age = 30;
120            (*k, v.name.clone(), v.age)
121        })
122        .collect();
123
124    println!("range mut: {range:?}");
125
126    let oldest = peoples.last();
127    assert_eq!(oldest.len(), 2);
128    assert_eq!(oldest[0].1.age, 30,);
129    assert_eq!(oldest[1].1.age, 30);
130    println!("peoples: {:?}", peoples.iter().collect::<Vec<_>>());
131}

Source

pub fn get(&self, key: &K) -> Option<&V>

Get the ref value by given key, or return None if not found

§Example

use valord_map::ValordMap;

let mut valord = ValordMap::new();
valord.insert("key1", 1);
valord.insert("key2", 2);
valord.insert("key3", 3);

let mut val1 = valord.get(&"key2");
let mut val2 = valord.get(&"key4");
assert_eq!(val1.unwrap(), &2);
assert_eq!(val2, None);

Source

pub fn get_mut<'a>(&'a mut self, key: &K) -> Option<RawEntry<'a, T, K, V>>

Get the ref mut value by given key, or return None if not found

§Example

use valord_map::ValordMap;

let mut valord = ValordMap::new();
valord.insert("key1", 1);
valord.insert("key2", 2);
valord.insert("key3", 3);

let mut val = valord.get_mut(&"key2").unwrap();
*val = 4;
drop(val);
assert_eq!(valord.get(&"key2").unwrap(), &4);
assert_eq!(valord.last(), vec![(&"key2", &4)]);

Source

pub fn modify<F>(&mut self, key: &K, op: F) -> bool
where F: Fn(&mut V),

Modify value in map, if exist return true, else return false

§Example

use valord_map::ValordMap;

let mut valord = ValordMap::new();
valord.insert("qians", 1);

assert!(valord.modify(&"qians", |v| *v = 2));
assert_eq!(valord.iter().next().unwrap(), (&"qians", &2));

Source

pub fn remove(&mut self, key: &K) -> Option<V>

remove from ValordMap

§Example

use valord_map::ValordMap;

let mut valord = ValordMap::new();
valord.insert(1, "a");
valord.insert(2, "b");

let removed_value = valord.remove(&1);
assert_eq!(removed_value, Some("a"));
assert_eq!(valord.get(&1), None);

Source

pub fn remove_entry<'a>(&'a mut self, key: &'a K) -> Option<(&K, V)>

Removes a key from the map, returning the stored key and value if the key was previously in the map.

§Example

use valord_map::ValordMap;

let mut valord = ValordMap::new();
valord.insert(1, "a");
valord.insert(2, "b");

let removed_entry = valord.remove_entry(&1);
assert_eq!(removed_entry, Some((&1, "a")));
assert_eq!(valord.get(&1), None);

Source

pub fn len(&self) -> usize

Return the number of key-value pairs in the map.

§Example

use valord_map::ValordMap;

let mut valord = ValordMap::new();
valord.insert(1, "a");
valord.insert(2, "b");
valord.insert(3, "c");
valord.insert(2, "d");

assert_eq!(valord.len(), 3);

let removed_value = valord.remove(&1);
assert_eq!(removed_value, Some("a"));
assert_eq!(valord.len(), 2);

Source

pub fn re_order(&mut self)

Re-order the ValordMap by value.ord_by().

§Example

use std::cell::Cell;
use valord_map::ValordMap;

let mut valord = ValordMap::new();
valord.insert("qians", Cell::new(1));
valord.insert("tedious", Cell::new(2));
valord.insert("xuandu", Cell::new(3));

valord
    .iter()
    .enumerate()
    .for_each(|(i, (_, v))| v.set(5 - i));

assert_eq!(
    valord.iter().collect::<Vec<_>>(),
    vec![
        (&"qians", &Cell::new(5)),
        (&"tedious", &Cell::new(4)),
        (&"xuandu", &Cell::new(3))
    ]
);

valord.re_order();

assert_eq!(
    valord.iter().collect::<Vec<_>>(),
    vec![
        (&"xuandu", &Cell::new(3)),
        (&"tedious", &Cell::new(4)),
        (&"qians", &Cell::new(5)),
    ]
);