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
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
use crate::{Combine, CombineByKey, Merge, MergeByKey, MergeCombineByKey};
use std::collections::{HashMap, HashSet};
use std::hash::Hash;
impl<T> Combine for Vec<T>
where
T: Clone,
{
fn combine(&mut self, template: &Self) {
self.extend_from_slice(template);
}
}
fn merge_combine<'a, T, F, K>(
this: &mut Vec<T>,
template: &'a Vec<T>,
mut get_key: F,
) -> HashMap<K, &'a T>
where
T: Merge,
F: FnMut(&T) -> K,
K: Hash + Eq,
{
let mut template: HashMap<K, &T> = template.iter().map(|item| (get_key(item), item)).collect();
for item in this.iter_mut() {
let template = {
let key = get_key(item);
match template.remove(&key) {
Some(template) => template,
None => continue,
}
};
item.merge(&template);
}
template
}
impl<T> MergeByKey for Vec<T>
where
T: Merge,
{
type Elem = T;
fn merge_by_key<F, K>(&mut self, template: &Self, get_key: F)
where
F: FnMut(&Self::Elem) -> K,
K: Hash + Eq,
{
merge_combine(self, template, get_key);
}
}
impl<T> CombineByKey for Vec<T>
where
T: Clone,
{
type Elem = T;
fn combine_by_key<F, K>(&mut self, template: &Self, mut get_key: F)
where
F: FnMut(&Self::Elem) -> K,
K: Hash + Eq,
{
self.extend_from_slice(template);
let mut seen = HashSet::new();
self.retain(|item| {
let key = get_key(item);
if seen.contains(&key) {
false
} else {
seen.insert(key);
true
}
});
}
}
impl<T> MergeCombineByKey for Vec<T>
where
T: Merge + Clone,
{
type Elem = T;
fn merge_combine_by_key<F, K>(&mut self, template: &Self, mut get_key: F)
where
F: FnMut(&Self::Elem) -> K,
K: Hash + Eq,
{
let hash_template = merge_combine(self, template, &mut get_key);
for value in template {
if hash_template.contains_key(&get_key(value)) {
self.push(value.clone());
}
}
}
}