1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
use crate::Counter;
use num_traits::{One, Zero};
use std::hash::{BuildHasher, Hash};
use std::ops::AddAssign;
impl<T, N, S> Extend<T> for Counter<T, N, S>
where
T: Hash + Eq,
N: AddAssign + Zero + One,
S: BuildHasher,
{
/// Extend a `Counter` with an iterator of items.
///
/// ```rust
/// # use counter::Counter;
/// # use std::collections::HashMap;
/// let mut counter = "abbccc".chars().collect::<Counter<_>>();
/// counter.extend("bccddd".chars());
/// let expect = [('a', 1), ('b', 3), ('c', 5), ('d', 3)].iter().cloned().collect::<HashMap<_, _>>();
/// assert_eq!(counter.into_map(), expect);
/// ```
fn extend<I: IntoIterator<Item = T>>(&mut self, iter: I) {
self.update(iter);
}
}
impl<T, N, S> Extend<(T, N)> for Counter<T, N, S>
where
T: Hash + Eq,
N: AddAssign + Zero,
S: BuildHasher,
{
/// Extend a counter with `(item, count)` tuples.
///
/// The counts of duplicate items are summed.
/// ```rust
/// # use counter::Counter;
/// # use std::collections::HashMap;
/// let mut counter = "abbccc".chars().collect::<Counter<_>>();
/// counter.extend([('a', 1), ('b', 2), ('c', 3), ('a', 4)].iter().cloned());
/// let expect = [('a', 6), ('b', 4), ('c', 6)].iter()
/// .cloned().collect::<HashMap<_, _>>();
/// assert_eq!(counter.into_map(), expect);
/// ```
fn extend<I: IntoIterator<Item = (T, N)>>(&mut self, iter: I) {
for (item, item_count) in iter {
let entry = self.map.entry(item).or_insert_with(N::zero);
*entry += item_count;
}
}
}
impl<'a, T: 'a, N: 'a, S> Extend<(&'a T, &'a N)> for Counter<T, N, S>
where
T: Hash + Eq + Clone,
N: AddAssign + Zero + Clone,
S: BuildHasher,
{
/// Extend a counter with `(item, count)` tuples.
///
/// You can extend a `Counter` with another `Counter`:
/// ```rust
/// # use counter::Counter;
/// # use std::collections::HashMap;
/// let mut counter = "abbccc".chars().collect::<Counter<_>>();
/// let another = "bccddd".chars().collect::<Counter<_>>();
/// counter.extend(&another);
/// let expect = [('a', 1), ('b', 3), ('c', 5), ('d', 3)].iter()
/// .cloned().collect::<HashMap<_, _>>();
/// assert_eq!(counter.into_map(), expect);
/// ```
fn extend<I: IntoIterator<Item = (&'a T, &'a N)>>(&mut self, iter: I) {
for (item, item_count) in iter {
let entry = self.map.entry(item.clone()).or_insert_with(N::zero);
*entry += item_count.clone();
}
}
}