conjure_cp_core/utils/
bimap.rs

1use bimap::hash::{Iter, LeftValues, RightValues};
2use bimap::{BiHashMap, Overwritten};
3use derivative::Derivative;
4use funcmap::{FuncMap, TryFuncMap, TypeParam};
5use polyquine::Quine;
6use proc_macro2::TokenStream;
7use quote::quote;
8use serde::{Deserialize, Deserializer, Serialize, Serializer};
9use serde_with::de::DeserializeAsWrap;
10use serde_with::ser::SerializeAsWrap;
11use serde_with::serde_as;
12use serde_with::{DeserializeAs, SerializeAs};
13use std::borrow::Borrow;
14use std::hash::Hash;
15
16#[serde_as]
17#[derive(Debug, Derivative)]
18#[derivative(Clone(bound = "L: Clone + Eq + Hash, R: Clone + Eq + Hash"))]
19#[derivative(Default(bound = "L: Default + Eq + Hash, R: Default + Eq + Hash"))]
20#[derivative(PartialEq(bound = "L: Eq + Hash, R: Eq + Hash"))]
21#[derivative(Eq(bound = "L: Eq + Hash, R: Eq + Hash"))]
22pub struct BiMap<L, R> {
23    inner: BiHashMap<L, R>,
24}
25
26impl<L, R> BiMap<L, R>
27where
28    L: Eq + Hash,
29    R: Eq + Hash,
30{
31    pub fn new() -> Self {
32        Self {
33            inner: BiHashMap::new(),
34        }
35    }
36
37    pub fn with_capacity(capacity: usize) -> Self {
38        Self {
39            inner: BiHashMap::with_capacity(capacity),
40        }
41    }
42
43    pub fn get_by_left<Q>(&self, left: &Q) -> Option<&R>
44    where
45        L: Borrow<Q>,
46        Q: Eq + Hash + ?Sized,
47    {
48        self.inner.get_by_left(left)
49    }
50
51    pub fn get_by_right<Q>(&self, right: &Q) -> Option<&L>
52    where
53        R: Borrow<Q>,
54        Q: Eq + Hash + ?Sized,
55    {
56        self.inner.get_by_right(right)
57    }
58
59    pub fn contains_left<Q>(&self, left: &Q) -> bool
60    where
61        L: Borrow<Q>,
62        Q: Eq + Hash + ?Sized,
63    {
64        self.inner.contains_left(left)
65    }
66
67    pub fn contains_right<Q>(&self, right: &Q) -> bool
68    where
69        R: Borrow<Q>,
70        Q: Eq + Hash + ?Sized,
71    {
72        self.inner.contains_right(right)
73    }
74
75    pub fn remove_by_left<Q>(&mut self, left: &Q) -> Option<(L, R)>
76    where
77        L: Borrow<Q>,
78        Q: Eq + Hash + ?Sized,
79    {
80        self.inner.remove_by_left(left)
81    }
82
83    pub fn remove_by_right<Q>(&mut self, right: &Q) -> Option<(L, R)>
84    where
85        R: Borrow<Q>,
86        Q: Eq + Hash + ?Sized,
87    {
88        self.inner.remove_by_right(right)
89    }
90
91    pub fn insert(&mut self, left: L, right: R) -> Overwritten<L, R> {
92        self.inner.insert(left, right)
93    }
94
95    pub fn insert_no_overwrite(&mut self, left: L, right: R) -> Result<(), (L, R)> {
96        self.inner.insert_no_overwrite(left, right)
97    }
98
99    pub fn retain<F>(&mut self, f: F)
100    where
101        F: FnMut(&L, &R) -> bool,
102    {
103        self.inner.retain(f)
104    }
105
106    pub fn len(&self) -> usize {
107        self.inner.len()
108    }
109
110    pub fn is_empty(&self) -> bool {
111        self.inner.is_empty()
112    }
113
114    pub fn clear(&mut self) {
115        self.inner.clear()
116    }
117
118    pub fn iter(&self) -> Iter<'_, L, R> {
119        self.inner.iter()
120    }
121
122    pub fn left_values(&self) -> LeftValues<'_, L, R> {
123        self.inner.left_values()
124    }
125
126    pub fn right_values(&self) -> RightValues<'_, L, R> {
127        self.inner.right_values()
128    }
129}
130
131impl<L, R> IntoIterator for BiMap<L, R>
132where
133    L: Eq + Hash,
134    R: Eq + Hash,
135{
136    type Item = (L, R);
137    type IntoIter = <BiHashMap<L, R> as IntoIterator>::IntoIter;
138
139    fn into_iter(self) -> Self::IntoIter {
140        self.inner.into_iter()
141    }
142}
143
144impl<L, R> FromIterator<(L, R)> for BiMap<L, R>
145where
146    L: Eq + Hash,
147    R: Eq + Hash,
148{
149    fn from_iter<T: IntoIterator<Item = (L, R)>>(iter: T) -> Self {
150        Self {
151            inner: BiHashMap::from_iter(iter),
152        }
153    }
154}
155
156impl<L, R, const N: usize> From<[(L, R); N]> for BiMap<L, R>
157where
158    L: Eq + Hash,
159    R: Eq + Hash,
160{
161    fn from(v: [(L, R); N]) -> Self {
162        Self::from_iter(v)
163    }
164}
165
166impl<L, R> Serialize for BiMap<L, R>
167where
168    L: Eq + Hash + Serialize,
169    R: Eq + Hash + Serialize,
170{
171    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
172    where
173        S: Serializer,
174    {
175        // Serialize as a list of pairs rather than as a map, so that non-string
176        // key types (e.g. usize) work with JSON serializers.
177        let entries: Vec<(&L, &R)> = self.inner.iter().collect();
178        entries.serialize(serializer)
179    }
180}
181
182impl<'de, L, R> Deserialize<'de> for BiMap<L, R>
183where
184    L: Eq + Hash + Deserialize<'de>,
185    R: Eq + Hash + Deserialize<'de>,
186{
187    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
188    where
189        D: Deserializer<'de>,
190    {
191        let entries: Vec<(L, R)> = Vec::deserialize(deserializer)?;
192        Ok(Self {
193            inner: entries.into_iter().collect(),
194        })
195    }
196}
197
198impl<L, R, LAs, RAs> SerializeAs<BiMap<L, R>> for BiMap<LAs, RAs>
199where
200    L: Eq + Hash,
201    L: Serialize,
202    R: Eq + Hash,
203    LAs: SerializeAs<L>,
204    RAs: SerializeAs<R>,
205{
206    fn serialize_as<S>(source: &BiMap<L, R>, serializer: S) -> Result<S::Ok, S::Error>
207    where
208        S: serde::Serializer,
209    {
210        let entries = source
211            .iter()
212            .map(|(left, right)| {
213                (
214                    SerializeAsWrap::<L, LAs>::new(left),
215                    SerializeAsWrap::<R, RAs>::new(right),
216                )
217            })
218            .collect::<Vec<_>>();
219        entries.serialize(serializer)
220    }
221}
222
223impl<'de, L, R, LAs, RAs> DeserializeAs<'de, BiMap<L, R>> for BiMap<LAs, RAs>
224where
225    L: Eq + Hash,
226    R: Eq + Hash,
227    L: Deserialize<'de>,
228    LAs: DeserializeAs<'de, L>,
229    RAs: DeserializeAs<'de, R>,
230{
231    fn deserialize_as<D>(deserializer: D) -> Result<BiMap<L, R>, D::Error>
232    where
233        D: serde::Deserializer<'de>,
234    {
235        let entries: Vec<(DeserializeAsWrap<L, LAs>, DeserializeAsWrap<R, RAs>)> =
236            Vec::deserialize(deserializer)?;
237
238        Ok(entries
239            .into_iter()
240            .map(|(left, right)| (left.into_inner(), right.into_inner()))
241            .collect())
242    }
243}
244
245impl<L, R, NewL> FuncMap<L, NewL, TypeParam<0>> for BiMap<L, R>
246where
247    L: Eq + Hash,
248    R: Eq + Hash,
249    NewL: Eq + Hash,
250{
251    type Output = BiMap<NewL, R>;
252
253    fn func_map<F>(self, mut f: F) -> Self::Output
254    where
255        F: FnMut(L) -> NewL,
256    {
257        let itr = self.into_iter().map(|(k, v)| (f(k), v));
258        Self::Output::from_iter(itr)
259    }
260}
261
262impl<L, R, NewR> FuncMap<R, NewR, TypeParam<1>> for BiMap<L, R>
263where
264    L: Eq + Hash,
265    R: Eq + Hash,
266    NewR: Eq + Hash,
267{
268    type Output = BiMap<L, NewR>;
269
270    fn func_map<F>(self, mut f: F) -> Self::Output
271    where
272        F: FnMut(R) -> NewR,
273    {
274        let itr = self.into_iter().map(|(k, v)| (k, f(v)));
275        Self::Output::from_iter(itr)
276    }
277}
278
279impl<L, R, NewL> TryFuncMap<L, NewL, TypeParam<0>> for BiMap<L, R>
280where
281    L: Eq + Hash,
282    R: Eq + Hash,
283    NewL: Eq + Hash,
284{
285    type Output = BiMap<NewL, R>;
286
287    fn try_func_map<E, F>(self, mut f: F) -> Result<Self::Output, E>
288    where
289        F: FnMut(L) -> Result<NewL, E>,
290    {
291        let pairs: Result<Vec<(NewL, R)>, E> =
292            self.into_iter().map(|(k, v)| Ok((f(k)?, v))).collect();
293
294        Ok(Self::Output::from_iter(pairs?))
295    }
296}
297
298impl<L, R, NewR> TryFuncMap<R, NewR, TypeParam<1>> for BiMap<L, R>
299where
300    L: Eq + Hash,
301    R: Eq + Hash,
302    NewR: Eq + Hash,
303{
304    type Output = BiMap<L, NewR>;
305
306    fn try_func_map<E, F>(self, mut f: F) -> Result<Self::Output, E>
307    where
308        F: FnMut(R) -> Result<NewR, E>,
309    {
310        let pairs: Result<Vec<(L, NewR)>, E> =
311            self.into_iter().map(|(k, v)| Ok((k, f(v)?))).collect();
312
313        Ok(Self::Output::from_iter(pairs?))
314    }
315}
316
317impl<L: Quine, R: Quine> Quine for BiMap<L, R>
318where
319    L: Eq + Hash,
320    R: Eq + Hash,
321{
322    fn ctor_tokens(&self) -> TokenStream {
323        let inner = self
324            .iter()
325            .map(|item| item.ctor_tokens())
326            .collect::<Vec<_>>();
327        quote! {
328            BiMap::from([#(#inner),*])
329        }
330    }
331}
conjure_cp_core/utils/bimap.rs

conjure_cp_core/utils/
bimap.rs
