common-stdx 0.1.18

extension for the std lib, for things i commonly reuse
Documentation 
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
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132

use std::collections::{HashMap, HashSet};

#[derive(Debug, PartialEq, Eq)]
pub struct DualHashMap<K1, K2, V>
where
    K1: std::hash::Hash + Eq + Send + Clone,
    K2: std::hash::Hash + Eq + Send + Clone,
{
    data_map: HashMap<K1, V>,
    sec_key_map: HashMap<K2, HashSet<K1>>,
}

impl<K1, K2, V> DualHashMap<K1, K2, V>
where
    K1: std::hash::Hash + Eq + Send + Clone,
    K2: std::hash::Hash + Eq + Send + Clone,
{
    pub fn new() -> Self {
        DualHashMap {
            data_map: HashMap::new(),
            sec_key_map: HashMap::new(),
        }
    }

    pub fn insert(&mut self, k1: K1, k2: K2, value: V) {
        for set in self.sec_key_map.values_mut() {
            set.remove(&k1);
        }
        self.sec_key_map.retain(|_, set| !set.is_empty());

        self.data_map.insert(k1.clone(), value);
        self.sec_key_map.entry(k2).or_default().insert(k1);
    }

    pub fn get_by_k1(&self, k1: &K1) -> Option<&V> {
        self.data_map.get(k1)
    }

    pub fn get_by_k2(&self, k2: &K2) -> impl Iterator<Item = &V> {
        self.sec_key_map
            .get(k2)
            .into_iter()
            .flat_map(|k1s| k1s.iter())
            .filter_map(|k1| self.data_map.get(k1))
    }

    pub fn get_mut_by_k1(&mut self, k1: &K1) -> Option<&mut V> {
        self.data_map.get_mut(k1)
    }

    pub fn for_each_mut_by_k2<F>(&mut self, k2: &K2, mut f: F)
    where
        F: FnMut(&mut V),
    {
        if let Some(k1s) = self.sec_key_map.get(k2) {
            for k1 in k1s.iter() {
                if let Some(v) = self.data_map.get_mut(k1) {
                    f(v);
                }
            }
        }
    }

    pub fn get_values_mut(&mut self) -> impl Iterator<Item = &mut V> {
        self.data_map.values_mut()
    }
    pub fn get_values(&self) -> impl Iterator<Item = &V> {
        self.data_map.values()
    }
    pub fn get_keys1(&self) -> impl Iterator<Item = &K1> {
        self.data_map.keys()
    }
    pub fn get_keys2(&self) -> impl Iterator<Item = &K2> {
        self.sec_key_map.keys()
    }

    pub fn remove_by_k1(&mut self, k1: &K1) {
        if self.data_map.remove(k1).is_some() {
            for (_, k1_set) in self.sec_key_map.iter_mut() {
                k1_set.remove(k1);
            }
            self.sec_key_map.retain(|_, set| !set.is_empty());
        }
    }

    pub fn remove_by_k2(&mut self, k2: &K2) {
        if let Some(k1s) = self.sec_key_map.remove(k2) {
            for k1 in k1s {
                self.data_map.remove(&k1);
            }
        }
    }

    pub fn contains_k1(&self, k1: &K1) -> bool {
        self.data_map.contains_key(k1)
    }

    pub fn contains_k2(&self, k2: &K2) -> bool {
        self.sec_key_map.contains_key(k2)
    }

    pub fn get_k1s_by_k2(&self, k2: &K2) -> Option<&HashSet<K1>> {
        self.sec_key_map.get(k2)
    }

    pub fn get_k2_by_k1(&self, k1: &K1) -> Option<&K2> {
        for (k2, k1_set) in &self.sec_key_map {
            if k1_set.contains(k1) {
                return Some(k2);
            }
        }
        None
    }

    pub fn len(&self) -> usize {
        self.data_map.len()
    }

    pub fn is_empty(&self) -> bool {
        self.data_map.is_empty()
    }
}

impl<K1, K2, V> Default for DualHashMap<K1, K2, V>
where
    K1: std::hash::Hash + Eq + Send + Clone,
    K2: std::hash::Hash + Eq + Send + Clone,
{
    fn default() -> Self {
        Self::new()
    }
}