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

use std::collections::{HashMap, HashSet};
use std::hash::Hash;
use std::sync::{Arc, Mutex};
/// map 转换
pub fn trans_map<K, V, T>(m: &HashMap<K, V>, vf: fn(v: &V) -> T) -> HashMap<K, T>
where
    K: Eq + Hash + Clone,
{
    let mut ret: HashMap<K, T> = HashMap::new();
    for (k, v) in m {
        ret.insert(k.clone(), vf(v));
    }
    ret
}

pub fn group_by_value<K, V>(m: &HashMap<K, V>) -> HashMap<V, Vec<K>>
where
    V: Eq + Hash + Clone,
    K: Clone,
{
    let mut ret: HashMap<V, Vec<K>> = HashMap::new();
    for (k, v) in m {
        if ret.contains_key(v) {
            let keys = ret.get_mut(v).unwrap();
            keys.push(k.clone());
        } else {
            ret.insert(v.clone(), vec![k.clone()]);
        }
    }
    ret
}

pub fn group_by_value_set<K, V>(m: &HashMap<K, V>) -> HashMap<V, HashSet<K>>
where
    K: Eq + Hash + Clone,
    V: Eq + Hash + Clone,
{
    let mut ret: HashMap<V, HashSet<K>> = HashMap::new();
    for (k, v) in m {
        if ret.contains_key(v) {
            let keys = ret.get_mut(v).unwrap();
            keys.insert(k.clone());
        } else {
            let mut set = HashSet::new();
            set.insert(k.clone());
            ret.insert(v.clone(), set);
        }
    }
    ret
}

pub fn group_by_key<K, V, T>(m: &HashMap<K, V>, kf: fn(k: &K) -> T) -> HashMap<T, HashMap<K, V>>
where
    T: Eq + Hash + Clone,
    K: Eq + Hash + Clone,
    V: Clone,
{
    let mut ret: HashMap<T, HashMap<K, V>> = HashMap::new();
    for (k, v) in m {
        let t = kf(k);
        if ret.contains_key(&t) {
            let keys = ret.get_mut(&t).unwrap();
            keys.insert(k.clone(), v.clone());
        } else {
            let mut rv = HashMap::new();
            rv.insert(k.clone(), v.clone());
            ret.insert(t, rv);
        }
    }
    ret
}

pub fn arc_map<K, V>() -> Arc<Mutex<HashMap<K, V>>> {
    Arc::new(Mutex::new(HashMap::new()))
}

#[test]
fn test_map() {
    let mut m = HashMap::new();
    m.insert("1", "2");
    m.insert("2", "2");
    m.insert("3", "2");
    m.insert("11", "1");
    m.insert("12", "1");
    m.insert("13", "1");

    let v = group_by_value_set(&m);
    println!("{v:#?}");
}