multi_mut/
lib.rs

1use std::borrow::Borrow;
2use std::hash::Hash;
3use std::cmp::Eq;
4use std::collections::HashMap;
5use std::collections::BTreeMap;
6use std::mem::transmute;
7use std::slice::Iter;
8
9fn ref_eq<'a, 'b, T>(thing: &'a T, other: &'b T) -> bool {
10    (thing as *const T) == (other as *const T)
11}
12
13/// Endows HashMap with extension methods that help getting multiple mutable references to the values contained in it.
14/// Runtime-checking is done to ensure that this is safe: the returned mutable references are guaranteed not to alias.
15pub trait HashMapMultiMut {
16    type Value;
17    type Key: Hash + Eq;
18
19    fn get_pair_mut<Q: ?Sized>(&mut self, k_1: &Q, k_2: &Q) -> Option<(&mut Self::Value, &mut Self::Value)>
20        where Self::Key: Borrow<Q>, Q: Hash + Eq;
21
22    fn pair_mut<Q: ?Sized>(&mut self, k_1: &Q, k_2: &Q) -> (&mut Self::Value, &mut Self::Value)
23        where Self::Key: Borrow<Q>, Q: Hash + Eq;
24
25    fn get_triple_mut<Q: ?Sized>(&mut self, k_1: &Q, k_2: &Q, k_3: &Q) -> Option<(&mut Self::Value, &mut Self::Value, &mut Self::Value)>
26        where Self::Key: Borrow<Q>, Q: Hash + Eq;
27
28    fn triple_mut<Q: ?Sized>(&mut self, k_1: &Q, k_2: &Q, k_3: &Q) -> (&mut Self::Value, &mut Self::Value, &mut Self::Value)
29        where Self::Key: Borrow<Q>, Q: Hash + Eq;
30
31    fn multi_mut<'a>(&'a mut self, buffer: &'a mut [*const Self::Value]) -> HashMapMutWrapper<Self::Key, Self::Value>;
32
33    fn iter_multi_mut<'a, Q: ?Sized>(&'a mut self, k: &'a [&'a Q], buffer: &'a mut [*const Self::Value]) -> HashMapMultiMutIter<Q, Self::Key, Self::Value>
34        where Self::Key: Borrow<Q>, Q: Hash + Eq;
35}
36
37impl<K: Hash + Eq, V> HashMapMultiMut for HashMap<K, V> {
38    type Value = V;
39    type Key = K;
40
41    #[allow(mutable_transmutes)]
42    fn get_pair_mut<Q: ?Sized>(&mut self, k_1: &Q, k_2: &Q) -> Option<(&mut V, &mut V)>
43        where K: Borrow<Q>, Q: Hash + Eq
44    {
45
46        let v_1 = self.get(k_1);
47        let v_2 = self.get(k_2);
48
49        match (v_1, v_2) {
50            (Some(v_1), Some(v_2)) => {
51                if ref_eq(v_1, v_2) {
52                    None
53                } else {
54                    unsafe { Some((transmute(v_1), transmute(v_2))) }   // This is safe to do because we checked that v_1 and v_2 don't alias,
55                                                                        // and this function consumed a &mut self, which locks the HashMap so that
56                                                                        // no further aliasing references will be created during the lifetime of these
57                                                                        // references.
58                }
59            },
60            _ => None,
61        }
62    }
63
64    #[allow(mutable_transmutes)]
65    fn pair_mut<Q: ?Sized>(&mut self, k_1: &Q, k_2: &Q) -> (&mut V, &mut V)
66        where K: Borrow<Q>, Q: Hash + Eq
67    {
68
69        let v_1 = &self[k_1];
70        let v_2 = &self[k_2];
71        if ref_eq(v_1, v_2) {
72            panic!("The keys pointed to the same value! Only non-overlapping values can be handled.")
73        } else {
74            unsafe { (transmute(v_1), transmute(v_2)) } // This is safe to do because we checked that v_1 and v_2 don't alias,
75                                                        // and this function consumed a &mut self, which locks the HashMap so that
76                                                        // no further aliasing references will be created during the lifetime of these
77                                                        // references.
78        }
79    }
80
81    #[allow(mutable_transmutes)]
82    fn get_triple_mut<Q: ?Sized>(&mut self, k_1: &Q, k_2: &Q, k_3: &Q) -> Option<(&mut V, &mut V, &mut V)>
83        where K: Borrow<Q>, Q: Hash + Eq
84    {
85
86        let v_1 = self.get(k_1);
87        let v_2 = self.get(k_2);
88        let v_3 = self.get(k_3);
89
90        match (v_1, v_2, v_3) {
91            (Some(v_1), Some(v_2), Some(v_3)) => {
92                if ref_eq(v_1, v_2) || ref_eq(v_2, v_3) || ref_eq(v_1, v_3) {
93                    None
94                } else {
95                    unsafe { Some((transmute(v_1), transmute(v_2), transmute(v_3))) } 
96                        // This is safe to do because we checked that v_1, v_2 and v_3 don't alias,
97                        // and this function consumed a &mut self, which locks the HashMap so that
98                        // no further aliasing references will be created during the lifetime of these
99                        // references.
100                }
101            },
102            _ => None,
103        }
104    }
105
106    #[allow(mutable_transmutes)]
107    fn triple_mut<Q: ?Sized>(&mut self, k_1: &Q, k_2: &Q, k_3: &Q) -> (&mut V, &mut V, &mut V)
108        where K: Borrow<Q>, Q: Hash + Eq
109    {
110
111        let v_1 = &self[k_1];
112        let v_2 = &self[k_2];
113        let v_3 = &self[k_3];
114        if ref_eq(v_1, v_2) || ref_eq(v_2, v_3) || ref_eq(v_1, v_3) {
115            panic!("The keys pointed to the same value! Only non-overlapping values can be handled.")
116        } else {
117            unsafe { (transmute(v_1), transmute(v_2), transmute(v_3)) }
118                // This is safe to do because we checked that v_1, v_2 and v_3 don't alias,
119                // and this function consumed a &mut self, which locks the HashMap so that
120                // no further aliasing references will be created during the lifetime of these
121                // references.
122        }
123    }
124
125    fn multi_mut<'a>(&'a mut self, buffer: &'a mut [*const V]) -> HashMapMutWrapper<K, V>
126    {
127        HashMapMutWrapper { used: 0, map: self, buffer: buffer }
128    }
129
130    fn iter_multi_mut<'a, Q: ?Sized>(&'a mut self, keys: &'a [&'a Q], buffer: &'a mut [*const V]) -> HashMapMultiMutIter<Q, K, V>
131        where K: Borrow<Q>, Q: Hash + Eq
132    {
133        HashMapMultiMutIter { mut_wrapper: self.multi_mut(buffer), keys: keys.into_iter() }
134    }
135
136}
137
138pub struct HashMapMutWrapper<'a, K: 'a, V: 'a>
139        where K: Hash + Eq
140{
141    used: usize,
142    map: &'a mut HashMap<K, V>,
143    buffer: &'a mut [*const V],
144}
145
146impl<'a, K, V> HashMapMutWrapper<'a, K, V>
147        where K: Hash + Eq
148{
149
150    #[allow(mutable_transmutes)]
151    pub fn get_mut<Q: ?Sized>(&mut self, k: &Q) -> Option<&'a mut V>
152        where K: Borrow<Q>, Q: Hash + Eq
153    {
154        if self.used == self.buffer.len() {
155            panic!("Buffer space is depleted!");
156        }
157        let v = if let Some(v) = self.map.get(k) { v } else { return None };    // Note: should we be worried about aliased reads happening in get()?
158                                                                                // after all, there might exist a &mut ref to the value at this point.
159                                                                                // However, get() doesn't probably read through &V, it accesses only &K.
160        let ptr = v as *const V;
161        for old_ptr in &self.buffer[0..self.used] {
162            if ptr == *old_ptr {
163                panic!("No aliased references allowed! This key has been already used.");
164            }
165        }
166        self.buffer[self.used] = ptr;
167        self.used += 1;
168
169        Some(unsafe{ transmute(v) })
170    }
171
172    pub fn mut_ref<Q: ?Sized>(&mut self, k: &Q) -> &'a mut V
173        where K: Borrow<Q>, Q: Hash + Eq {
174            match self.get_mut(k) {
175                Some(v) => v,
176                None => panic!("No such key!"),
177            }
178        }
179}
180
181pub struct HashMapMultiMutIter<'a, Q: ?Sized + 'a, K: 'a, V: 'a>
182        where K: Borrow<Q> + Hash + Eq, Q: Hash + Eq
183{
184    mut_wrapper: HashMapMutWrapper<'a, K, V>,
185    keys: Iter<'a, &'a Q>,
186}
187
188impl<'a, Q: ?Sized, K, V> Iterator for HashMapMultiMutIter<'a, Q, K, V>
189        where K: Borrow<Q> + Hash + Eq, Q: Hash + Eq
190{
191    type Item = &'a mut V;
192
193    #[allow(mutable_transmutes)]
194    fn next(&mut self) -> Option<Self::Item> {
195        if self.mut_wrapper.used == self.mut_wrapper.buffer.len() { return None };
196        match self.keys.next() {
197            Some(q) => { Some(self.mut_wrapper.mut_ref(q)) },   // Why use panicking mut_ref? Since we provide the keys up front with iterator,
198                                                                // it's likely that a non-existant key is a bug.
199            None => None,
200        }
201        
202    } 
203}
204
205
206/* BTreeMap */
207
208/// Endows HashMap with extension methods that help getting multiple mutable references to the values contained in it.
209/// Runtime-checking is done to ensure that this is safe: the returned mutable references are guaranteed not to alias.
210pub trait BTreeMapMultiMut {
211    type Value;
212    type Key: Ord;
213
214    fn get_pair_mut<Q: ?Sized>(&mut self, k_1: &Q, k_2: &Q) -> Option<(&mut Self::Value, &mut Self::Value)>
215        where Self::Key: Borrow<Q>, Q: Ord;
216
217    fn pair_mut<Q: ?Sized>(&mut self, k_1: &Q, k_2: &Q) -> (&mut Self::Value, &mut Self::Value)
218        where Self::Key: Borrow<Q>, Q: Ord;
219
220    fn get_triple_mut<Q: ?Sized>(&mut self, k_1: &Q, k_2: &Q, k_3: &Q) -> Option<(&mut Self::Value, &mut Self::Value, &mut Self::Value)>
221        where Self::Key: Borrow<Q>, Q: Ord;
222
223    fn triple_mut<Q: ?Sized>(&mut self, k_1: &Q, k_2: &Q, k_3: &Q) -> (&mut Self::Value, &mut Self::Value, &mut Self::Value)
224        where Self::Key: Borrow<Q>, Q: Ord;
225
226    fn multi_mut<'a>(&'a mut self, buffer: &'a mut [*const Self::Value]) -> BTreeMapMutWrapper<Self::Key, Self::Value>;
227
228    fn iter_multi_mut<'a, Q: ?Sized>(&'a mut self, k: &'a [&'a Q], buffer: &'a mut [*const Self::Value]) -> BTreeMapMultiMutIter<Q, Self::Key, Self::Value>
229        where Self::Key: Borrow<Q>, Q: Ord;
230}
231
232
233impl<K: Ord, V> BTreeMapMultiMut for BTreeMap<K, V> {
234    type Value = V;
235    type Key = K;
236
237    #[allow(mutable_transmutes)]
238    fn get_pair_mut<Q: ?Sized>(&mut self, k_1: &Q, k_2: &Q) -> Option<(&mut V, &mut V)>
239        where K: Borrow<Q>, Q: Ord
240    {
241
242        let v_1 = self.get(k_1);
243        let v_2 = self.get(k_2);
244
245        match (v_1, v_2) {
246            (Some(v_1), Some(v_2)) => {
247                if ref_eq(v_1, v_2) {
248                    None
249                } else {
250                    unsafe { Some((transmute(v_1), transmute(v_2))) }   // This is safe to do because we checked that v_1 and v_2 don't alias,
251                                                                        // and this function consumed a &mut self, which locks the HashMap so that
252                                                                        // no further aliasing references will be created during the lifetime of these
253                                                                        // references.
254                }
255            },
256            _ => None,
257        }
258    }
259
260    #[allow(mutable_transmutes)]
261    fn pair_mut<Q: ?Sized>(&mut self, k_1: &Q, k_2: &Q) -> (&mut V, &mut V)
262        where K: Borrow<Q>, Q: Ord
263    {
264
265        let v_1 = &self[k_1];
266        let v_2 = &self[k_2];
267        if ref_eq(v_1, v_2) {
268            panic!("The keys pointed to the same value! Only non-overlapping values can be handled.")
269        } else {
270            unsafe { (transmute(v_1), transmute(v_2)) } // This is safe to do because we checked that v_1 and v_2 don't alias,
271                                                        // and this function consumed a &mut self, which locks the HashMap so that
272                                                        // no further aliasing references will be created during the lifetime of these
273                                                        // references.
274        }
275    }
276
277    #[allow(mutable_transmutes)]
278    fn get_triple_mut<Q: ?Sized>(&mut self, k_1: &Q, k_2: &Q, k_3: &Q) -> Option<(&mut V, &mut V, &mut V)>
279        where K: Borrow<Q>, Q: Ord
280    {
281
282        let v_1 = self.get(k_1);
283        let v_2 = self.get(k_2);
284        let v_3 = self.get(k_3);
285
286        match (v_1, v_2, v_3) {
287            (Some(v_1), Some(v_2), Some(v_3)) => {
288                if ref_eq(v_1, v_2) || ref_eq(v_2, v_3) || ref_eq(v_1, v_3) {
289                    None
290                } else {
291                    unsafe { Some((transmute(v_1), transmute(v_2), transmute(v_3))) } 
292                        // This is safe to do because we checked that v_1, v_2 and v_3 don't alias,
293                        // and this function consumed a &mut self, which locks the HashMap so that
294                        // no further aliasing references will be created during the lifetime of these
295                        // references.
296                }
297            },
298            _ => None,
299        }
300    }
301
302    #[allow(mutable_transmutes)]
303    fn triple_mut<Q: ?Sized>(&mut self, k_1: &Q, k_2: &Q, k_3: &Q) -> (&mut V, &mut V, &mut V)
304        where K: Borrow<Q>, Q: Ord
305    {
306
307        let v_1 = &self[k_1];
308        let v_2 = &self[k_2];
309        let v_3 = &self[k_3];
310        if ref_eq(v_1, v_2) || ref_eq(v_2, v_3) || ref_eq(v_1, v_3) {
311            panic!("The keys pointed to the same value! Only non-overlapping values can be handled.")
312        } else {
313            unsafe { (transmute(v_1), transmute(v_2), transmute(v_3)) }
314                // This is safe to do because we checked that v_1, v_2 and v_3 don't alias,
315                // and this function consumed a &mut self, which locks the HashMap so that
316                // no further aliasing references will be created during the lifetime of these
317                // references.
318        }
319    }
320
321    fn multi_mut<'a>(&'a mut self, buffer: &'a mut [*const V]) -> BTreeMapMutWrapper<K, V>
322    {
323        BTreeMapMutWrapper { used: 0, map: self, buffer: buffer }
324    }
325
326    fn iter_multi_mut<'a, Q: ?Sized>(&'a mut self, keys: &'a [&'a Q], buffer: &'a mut [*const V]) -> BTreeMapMultiMutIter<Q, K, V>
327        where K: Borrow<Q>, Q: Ord
328    {
329        BTreeMapMultiMutIter { mut_wrapper: self.multi_mut(buffer), keys: keys.into_iter() }
330    }
331
332}
333
334pub struct BTreeMapMutWrapper<'a, K: 'a, V: 'a>
335        where K: Ord
336{
337    used: usize,
338    map: &'a mut BTreeMap<K, V>,
339    buffer: &'a mut [*const V],
340}
341
342impl<'a, K, V> BTreeMapMutWrapper<'a, K, V>
343        where K: Ord
344{
345
346    #[allow(mutable_transmutes)]
347    pub fn get_mut<Q: ?Sized>(&mut self, k: &Q) -> Option<&'a mut V>
348        where K: Borrow<Q>, Q: Ord
349    {
350        if self.used == self.buffer.len() {
351            panic!("Buffer space is depleted!");
352        }
353        let v = if let Some(v) = self.map.get(k) { v } else { return None };    // Note: should we be worried about aliased reads happening in get()?
354                                                                                // after all, there might exist a &mut ref to the value at this point.
355                                                                                // However, get() doesn't probably read through &V, it accesses only &K.
356        let ptr = v as *const V;
357        for old_ptr in &self.buffer[0..self.used] {
358            if ptr == *old_ptr {
359                panic!("No aliased references allowed! This key has been already used.");
360            }
361        }
362        self.buffer[self.used] = ptr;
363        self.used += 1;
364
365        Some(unsafe{ transmute(v) })
366    }
367
368    pub fn mut_ref<Q: ?Sized>(&mut self, k: &Q) -> &'a mut V
369        where K: Borrow<Q>, Q: Ord {
370            match self.get_mut(k) {
371                Some(v) => v,
372                None => panic!("No such key!"),
373            }
374        }
375}
376
377pub struct BTreeMapMultiMutIter<'a, Q: ?Sized + 'a, K: 'a, V: 'a>
378        where K: Borrow<Q> + Ord, Q: Ord
379{
380    mut_wrapper: BTreeMapMutWrapper<'a, K, V>,
381    keys: Iter<'a, &'a Q>,
382}
383
384impl<'a, Q: ?Sized, K, V> Iterator for BTreeMapMultiMutIter<'a, Q, K, V>
385        where K: Borrow<Q> + Ord, Q: Ord
386{
387    type Item = &'a mut V;
388
389    #[allow(mutable_transmutes)]
390    fn next(&mut self) -> Option<Self::Item> {
391        if self.mut_wrapper.used == self.mut_wrapper.buffer.len() { return None };
392        match self.keys.next() {
393            Some(q) => { Some(self.mut_wrapper.mut_ref(q)) },   // Why use panicking mut_ref? Since we provide the keys up front with iterator,
394                                                                // it's likely that a non-existant key is a bug.
395            None => None,
396        }
397        
398    } 
399}
400
401
402
403
404#[cfg(test)]
405mod tests_hash {
406
407    use std::collections::HashMap;
408    use HashMapMultiMut;
409
410    fn populate_hashmap() -> HashMap<String, String> {
411        let mut map = HashMap::new();
412        map.insert("key_one".into(), "value_one".into());
413        map.insert("key_two".into(), "value_two".into());
414        map.insert("key_three".into(), "value_three".into());
415        map.insert("key_four".into(), "value_four".into());
416        map.insert("key_five".into(), "value_five".into());
417        map.insert("key_six".into(), "value_six".into());
418        map
419    }
420
421    #[test]
422    fn test_pair_success() {
423        let mut map = populate_hashmap();
424        let (one, two): (&mut String, &mut String) = map.get_pair_mut("key_one", "key_two").unwrap();
425        
426        assert_eq!(one, "value_one");
427        assert_eq!(two, "value_two");
428
429        one.push_str("_edited");
430        two.push_str("_edited");
431
432        assert_eq!(one, "value_one_edited");
433        assert_eq!(two, "value_two_edited");
434    }
435
436    #[test]
437    fn test_pair_nonexistent_key() {
438        let mut map = populate_hashmap();
439        assert_eq!(map.get_pair_mut("key_one", "key_hundred"), None);
440    }
441
442    #[test]
443    fn test_pair_overlap() {
444        let mut map = populate_hashmap();
445        assert_eq!(map.get_pair_mut("key_one", "key_one"), None);
446    }
447
448    #[test]
449    fn test_pair_panic_success() {
450        let mut map = populate_hashmap();
451        let (one, two): (&mut String, &mut String) = map.pair_mut("key_one", "key_two");
452        
453        assert_eq!(one, "value_one");
454        assert_eq!(two, "value_two");
455
456        one.push_str("_edited");
457        two.push_str("_edited");
458
459        assert_eq!(one, "value_one_edited");
460        assert_eq!(two, "value_two_edited");
461    }
462
463    #[test]
464    #[should_panic]
465    fn test_pair_panic_nonexistent_key() {
466        let mut map = populate_hashmap();
467        map.pair_mut("key_one", "key_hundred");
468    }
469
470    #[test]
471    #[should_panic]
472    fn test_pair_panic_overlap() {
473        let mut map = populate_hashmap();
474        map.pair_mut("key_one", "key_one");
475    }
476
477    #[test]
478    fn test_triple_success() {
479        let mut map = populate_hashmap();
480        let (one, two, three): (&mut String, &mut String, &mut String) = map.get_triple_mut("key_one", "key_two", "key_three").unwrap();
481        
482        assert_eq!(one, "value_one");
483        assert_eq!(two, "value_two");
484        assert_eq!(three, "value_three");
485
486        one.push_str("_edited");
487        two.push_str("_edited");
488        three.push_str("_edited");
489
490        assert_eq!(one, "value_one_edited");
491        assert_eq!(two, "value_two_edited");
492        assert_eq!(three, "value_three_edited");
493    }
494
495    #[test]
496    fn test_triple_nonexistent_key() {
497        let mut map = populate_hashmap();
498        assert_eq!(map.get_triple_mut("key_one", "key_hundred", "key_three"), None);
499    }
500
501    #[test]
502    fn test_triple_overlap_1() {
503        let mut map = populate_hashmap();
504        assert_eq!(map.get_triple_mut("key_one", "key_two", "key_one"), None);
505    }
506
507    #[test]
508    fn test_triple_overlap_2() {
509        let mut map = populate_hashmap();
510        assert_eq!(map.get_triple_mut("key_two", "key_two", "key_three"), None);
511    }
512
513    #[test]
514    fn test_triple_overlap_3() {
515        let mut map = populate_hashmap();
516        assert_eq!(map.get_triple_mut("key_one", "key_three", "key_three"), None);
517    }
518
519    #[test]
520    fn test_triple_overlap_4() {
521        let mut map = populate_hashmap();
522        assert_eq!(map.get_triple_mut("key_one", "key_one", "key_one"), None);
523    }
524
525    #[test]
526    fn test_triple_panic_success() {
527        let mut map = populate_hashmap();
528        let (one, two, three): (&mut String, &mut String, &mut String) = map.triple_mut("key_one", "key_two", "key_three");
529        
530        assert_eq!(one, "value_one");
531        assert_eq!(two, "value_two");
532        assert_eq!(three, "value_three");
533
534        one.push_str("_edited");
535        two.push_str("_edited");
536        three.push_str("_edited");
537
538        assert_eq!(one, "value_one_edited");
539        assert_eq!(two, "value_two_edited");
540        assert_eq!(three, "value_three_edited");
541    }
542
543    #[test]
544    #[should_panic]
545    fn test_triple_panic_nonexistent_key() {
546        let mut map = populate_hashmap();
547        map.triple_mut("key_one", "key_hundred", "key_three");
548    }
549
550    #[test]
551    #[should_panic]
552    fn test_triple_panic_overlap_1() {
553        let mut map = populate_hashmap();
554        map.triple_mut("key_one", "key_two", "key_one");
555    }
556
557    #[test]
558    #[should_panic]
559    fn test_triple_panic_overlap_2() {
560        let mut map = populate_hashmap();
561        map.triple_mut("key_two", "key_two", "key_three");
562    }
563
564    #[test]
565    #[should_panic]
566    fn test_triple_panic_overlap_3() {
567        let mut map = populate_hashmap();
568        map.triple_mut("key_one", "key_three", "key_three");
569    }
570
571    #[test]
572    #[should_panic]
573    fn test_triple_panic_overlap_4() {
574        let mut map = populate_hashmap();
575        map.triple_mut("key_one", "key_one", "key_one");
576    }
577
578    #[test]
579    fn test_multi_success() {
580        let mut map = populate_hashmap();
581
582        use std::ptr::null;
583
584        let mut buffer = [null(); 3];
585        let mut wrapper = map.multi_mut(&mut buffer);
586        
587        let one = wrapper.get_mut("key_one").unwrap();
588        let two = wrapper.get_mut("key_two").unwrap();
589        let three = wrapper.get_mut("key_three").unwrap();
590
591        assert_eq!(one, "value_one");
592        assert_eq!(two, "value_two");
593        assert_eq!(three, "value_three");
594
595        one.push_str("_edited");
596        two.push_str("_edited");
597        three.push_str("_edited");
598
599        assert_eq!(one, "value_one_edited");
600        assert_eq!(two, "value_two_edited");
601        assert_eq!(three, "value_three_edited");
602    }
603
604    #[test]
605    fn test_multi_ref_success() {
606        let mut map = populate_hashmap();
607
608        use std::ptr::null;
609
610        let mut buffer = [null(); 3];
611        let mut wrapper = map.multi_mut(&mut buffer);
612        
613        let one = wrapper.mut_ref("key_one");
614        let two = wrapper.mut_ref("key_two");
615        let three = wrapper.mut_ref("key_three");
616
617        assert_eq!(one, "value_one");
618        assert_eq!(two, "value_two");
619        assert_eq!(three, "value_three");
620
621        one.push_str("_edited");
622        two.push_str("_edited");
623        three.push_str("_edited");
624
625        assert_eq!(one, "value_one_edited");
626        assert_eq!(two, "value_two_edited");
627        assert_eq!(three, "value_three_edited");
628    }
629
630    #[test]
631    #[should_panic]
632    fn test_multi_over_capacity() {
633        let mut map = populate_hashmap();
634
635        use std::ptr::null;
636
637        let mut buffer = [null(); 3];
638        let mut wrapper = map.multi_mut(&mut buffer);
639        
640        let _one = wrapper.get_mut("key_one").unwrap();
641        let _two = wrapper.get_mut("key_two").unwrap();
642        let _three = wrapper.get_mut("key_three").unwrap();
643        let _four = wrapper.get_mut("key_four").unwrap();
644    }
645
646    #[test]
647    #[should_panic]
648    fn test_multi_same_key() {
649        let mut map = populate_hashmap();
650
651        use std::ptr::null;
652
653        let mut buffer = [null(); 3];
654        let mut wrapper = map.multi_mut(&mut buffer);
655        
656        let _one = wrapper.get_mut("key_one").unwrap();
657        let _two = wrapper.get_mut("key_two").unwrap();
658        let _three = wrapper.get_mut("key_one").unwrap();
659    }
660
661    #[test]
662    fn test_multi_nonexistent() {
663        let mut map = populate_hashmap();
664
665        use std::ptr::null;
666
667        let mut buffer = [null(); 3];
668        let mut wrapper = map.multi_mut(&mut buffer);
669        
670        assert_eq!(wrapper.get_mut("key_hundred"), None);
671    }
672
673    #[test]
674    #[should_panic]
675    fn test_multi_ref_nonexistent() {
676        let mut map = populate_hashmap();
677
678        use std::ptr::null;
679
680        let mut buffer = [null(); 3];
681        let mut wrapper = map.multi_mut(&mut buffer);
682        
683        wrapper.mut_ref("key_hundred");
684    }
685
686    #[test]
687    fn test_multi_iter_success() {
688        let mut map = populate_hashmap();
689
690        use std::ptr::null;
691
692        let mut buffer = [null(); 3];
693        let keys = ["key_one", "key_two", "key_three"];
694        let mut wrapper = map.iter_multi_mut(&keys, &mut buffer);
695        
696        let one = wrapper.next().unwrap();
697        let two = wrapper.next().unwrap();
698        let three = wrapper.next().unwrap();
699
700        assert_eq!(one, "value_one");
701        assert_eq!(two, "value_two");
702        assert_eq!(three, "value_three");
703
704        one.push_str("_edited");
705        two.push_str("_edited");
706        three.push_str("_edited");
707
708        assert_eq!(one, "value_one_edited");
709        assert_eq!(two, "value_two_edited");
710        assert_eq!(three, "value_three_edited");
711    }
712
713    #[test]
714    fn test_multi_iter_over_capacity() {
715        let mut map = populate_hashmap();
716
717        use std::ptr::null;
718
719        let mut buffer = [null(); 3];
720        let keys = ["key_one", "key_two", "key_three"];
721        let mut wrapper = map.iter_multi_mut(&keys, &mut buffer);
722        
723        let _one = wrapper.next().unwrap();
724        let _two = wrapper.next().unwrap();
725        let _three = wrapper.next().unwrap();
726
727        assert_eq!(wrapper.next(), None);
728    }
729
730    #[test]
731    #[should_panic]
732    fn test_multi_iter_same_key() {
733        let mut map = populate_hashmap();
734
735        use std::ptr::null;
736
737        let mut buffer = [null(); 3];
738        let keys = ["key_one", "key_two", "key_one"];
739        let mut wrapper = map.iter_multi_mut(&keys, &mut buffer);
740        
741        let _one = wrapper.next().unwrap();
742        let _two = wrapper.next().unwrap();
743        let _three = wrapper.next().unwrap();
744    }
745
746    #[test]
747    #[should_panic]
748    fn test_multi_iter_nonexistent() {
749        let mut map = populate_hashmap();
750
751        use std::ptr::null;
752
753        let mut buffer = [null(); 3];
754        let keys = ["key_hundred"];
755        let mut wrapper = map.iter_multi_mut(&keys, &mut buffer);
756        
757        wrapper.next();
758    }
759
760}
761
762
763
764
765#[cfg(test)]
766mod tests_btree {
767
768    use std::collections::BTreeMap;
769    use BTreeMapMultiMut;
770
771    fn populate_hashmap() -> BTreeMap<String, String> {
772        let mut map = BTreeMap::new();
773        map.insert("key_one".into(), "value_one".into());
774        map.insert("key_two".into(), "value_two".into());
775        map.insert("key_three".into(), "value_three".into());
776        map.insert("key_four".into(), "value_four".into());
777        map.insert("key_five".into(), "value_five".into());
778        map.insert("key_six".into(), "value_six".into());
779        map
780    }
781
782    #[test]
783    fn test_pair_success() {
784        let mut map = populate_hashmap();
785        let (one, two): (&mut String, &mut String) = map.get_pair_mut("key_one", "key_two").unwrap();
786        
787        assert_eq!(one, "value_one");
788        assert_eq!(two, "value_two");
789
790        one.push_str("_edited");
791        two.push_str("_edited");
792
793        assert_eq!(one, "value_one_edited");
794        assert_eq!(two, "value_two_edited");
795    }
796
797    #[test]
798    fn test_pair_nonexistent_key() {
799        let mut map = populate_hashmap();
800        assert_eq!(map.get_pair_mut("key_one", "key_hundred"), None);
801    }
802
803    #[test]
804    fn test_pair_overlap() {
805        let mut map = populate_hashmap();
806        assert_eq!(map.get_pair_mut("key_one", "key_one"), None);
807    }
808
809    #[test]
810    fn test_pair_panic_success() {
811        let mut map = populate_hashmap();
812        let (one, two): (&mut String, &mut String) = map.pair_mut("key_one", "key_two");
813        
814        assert_eq!(one, "value_one");
815        assert_eq!(two, "value_two");
816
817        one.push_str("_edited");
818        two.push_str("_edited");
819
820        assert_eq!(one, "value_one_edited");
821        assert_eq!(two, "value_two_edited");
822    }
823
824    #[test]
825    #[should_panic]
826    fn test_pair_panic_nonexistent_key() {
827        let mut map = populate_hashmap();
828        map.pair_mut("key_one", "key_hundred");
829    }
830
831    #[test]
832    #[should_panic]
833    fn test_pair_panic_overlap() {
834        let mut map = populate_hashmap();
835        map.pair_mut("key_one", "key_one");
836    }
837
838    #[test]
839    fn test_triple_success() {
840        let mut map = populate_hashmap();
841        let (one, two, three): (&mut String, &mut String, &mut String) = map.get_triple_mut("key_one", "key_two", "key_three").unwrap();
842        
843        assert_eq!(one, "value_one");
844        assert_eq!(two, "value_two");
845        assert_eq!(three, "value_three");
846
847        one.push_str("_edited");
848        two.push_str("_edited");
849        three.push_str("_edited");
850
851        assert_eq!(one, "value_one_edited");
852        assert_eq!(two, "value_two_edited");
853        assert_eq!(three, "value_three_edited");
854    }
855
856    #[test]
857    fn test_triple_nonexistent_key() {
858        let mut map = populate_hashmap();
859        assert_eq!(map.get_triple_mut("key_one", "key_hundred", "key_three"), None);
860    }
861
862    #[test]
863    fn test_triple_overlap_1() {
864        let mut map = populate_hashmap();
865        assert_eq!(map.get_triple_mut("key_one", "key_two", "key_one"), None);
866    }
867
868    #[test]
869    fn test_triple_overlap_2() {
870        let mut map = populate_hashmap();
871        assert_eq!(map.get_triple_mut("key_two", "key_two", "key_three"), None);
872    }
873
874    #[test]
875    fn test_triple_overlap_3() {
876        let mut map = populate_hashmap();
877        assert_eq!(map.get_triple_mut("key_one", "key_three", "key_three"), None);
878    }
879
880    #[test]
881    fn test_triple_overlap_4() {
882        let mut map = populate_hashmap();
883        assert_eq!(map.get_triple_mut("key_one", "key_one", "key_one"), None);
884    }
885
886    #[test]
887    fn test_triple_panic_success() {
888        let mut map = populate_hashmap();
889        let (one, two, three): (&mut String, &mut String, &mut String) = map.triple_mut("key_one", "key_two", "key_three");
890        
891        assert_eq!(one, "value_one");
892        assert_eq!(two, "value_two");
893        assert_eq!(three, "value_three");
894
895        one.push_str("_edited");
896        two.push_str("_edited");
897        three.push_str("_edited");
898
899        assert_eq!(one, "value_one_edited");
900        assert_eq!(two, "value_two_edited");
901        assert_eq!(three, "value_three_edited");
902    }
903
904    #[test]
905    #[should_panic]
906    fn test_triple_panic_nonexistent_key() {
907        let mut map = populate_hashmap();
908        map.triple_mut("key_one", "key_hundred", "key_three");
909    }
910
911    #[test]
912    #[should_panic]
913    fn test_triple_panic_overlap_1() {
914        let mut map = populate_hashmap();
915        map.triple_mut("key_one", "key_two", "key_one");
916    }
917
918    #[test]
919    #[should_panic]
920    fn test_triple_panic_overlap_2() {
921        let mut map = populate_hashmap();
922        map.triple_mut("key_two", "key_two", "key_three");
923    }
924
925    #[test]
926    #[should_panic]
927    fn test_triple_panic_overlap_3() {
928        let mut map = populate_hashmap();
929        map.triple_mut("key_one", "key_three", "key_three");
930    }
931
932    #[test]
933    #[should_panic]
934    fn test_triple_panic_overlap_4() {
935        let mut map = populate_hashmap();
936        map.triple_mut("key_one", "key_one", "key_one");
937    }
938
939    #[test]
940    fn test_multi_success() {
941        let mut map = populate_hashmap();
942
943        use std::ptr::null;
944
945        let mut buffer = [null(); 3];
946        let mut wrapper = map.multi_mut(&mut buffer);
947        
948        let one = wrapper.get_mut("key_one").unwrap();
949        let two = wrapper.get_mut("key_two").unwrap();
950        let three = wrapper.get_mut("key_three").unwrap();
951
952        assert_eq!(one, "value_one");
953        assert_eq!(two, "value_two");
954        assert_eq!(three, "value_three");
955
956        one.push_str("_edited");
957        two.push_str("_edited");
958        three.push_str("_edited");
959
960        assert_eq!(one, "value_one_edited");
961        assert_eq!(two, "value_two_edited");
962        assert_eq!(three, "value_three_edited");
963    }
964
965    #[test]
966    fn test_multi_ref_success() {
967        let mut map = populate_hashmap();
968
969        use std::ptr::null;
970
971        let mut buffer = [null(); 3];
972        let mut wrapper = map.multi_mut(&mut buffer);
973        
974        let one = wrapper.mut_ref("key_one");
975        let two = wrapper.mut_ref("key_two");
976        let three = wrapper.mut_ref("key_three");
977
978        assert_eq!(one, "value_one");
979        assert_eq!(two, "value_two");
980        assert_eq!(three, "value_three");
981
982        one.push_str("_edited");
983        two.push_str("_edited");
984        three.push_str("_edited");
985
986        assert_eq!(one, "value_one_edited");
987        assert_eq!(two, "value_two_edited");
988        assert_eq!(three, "value_three_edited");
989    }
990
991    #[test]
992    #[should_panic]
993    fn test_multi_over_capacity() {
994        let mut map = populate_hashmap();
995
996        use std::ptr::null;
997
998        let mut buffer = [null(); 3];
999        let mut wrapper = map.multi_mut(&mut buffer);
1000        
1001        let _one = wrapper.get_mut("key_one").unwrap();
1002        let _two = wrapper.get_mut("key_two").unwrap();
1003        let _three = wrapper.get_mut("key_three").unwrap();
1004        let _four = wrapper.get_mut("key_four").unwrap();
1005    }
1006
1007    #[test]
1008    #[should_panic]
1009    fn test_multi_same_key() {
1010        let mut map = populate_hashmap();
1011
1012        use std::ptr::null;
1013
1014        let mut buffer = [null(); 3];
1015        let mut wrapper = map.multi_mut(&mut buffer);
1016        
1017        let _one = wrapper.get_mut("key_one").unwrap();
1018        let _two = wrapper.get_mut("key_two").unwrap();
1019        let _three = wrapper.get_mut("key_one").unwrap();
1020    }
1021
1022    #[test]
1023    fn test_multi_nonexistent() {
1024        let mut map = populate_hashmap();
1025
1026        use std::ptr::null;
1027
1028        let mut buffer = [null(); 3];
1029        let mut wrapper = map.multi_mut(&mut buffer);
1030        
1031        assert_eq!(wrapper.get_mut("key_hundred"), None);
1032    }
1033
1034    #[test]
1035    #[should_panic]
1036    fn test_multi_ref_nonexistent() {
1037        let mut map = populate_hashmap();
1038
1039        use std::ptr::null;
1040
1041        let mut buffer = [null(); 3];
1042        let mut wrapper = map.multi_mut(&mut buffer);
1043        
1044        wrapper.mut_ref("key_hundred");
1045    }
1046
1047    #[test]
1048    fn test_multi_iter_success() {
1049        let mut map = populate_hashmap();
1050
1051        use std::ptr::null;
1052
1053        let mut buffer = [null(); 3];
1054        let keys = ["key_one", "key_two", "key_three"];
1055        let mut wrapper = map.iter_multi_mut(&keys, &mut buffer);
1056        
1057        let one = wrapper.next().unwrap();
1058        let two = wrapper.next().unwrap();
1059        let three = wrapper.next().unwrap();
1060
1061        assert_eq!(one, "value_one");
1062        assert_eq!(two, "value_two");
1063        assert_eq!(three, "value_three");
1064
1065        one.push_str("_edited");
1066        two.push_str("_edited");
1067        three.push_str("_edited");
1068
1069        assert_eq!(one, "value_one_edited");
1070        assert_eq!(two, "value_two_edited");
1071        assert_eq!(three, "value_three_edited");
1072    }
1073
1074    #[test]
1075    fn test_multi_iter_over_capacity() {
1076        let mut map = populate_hashmap();
1077
1078        use std::ptr::null;
1079
1080        let mut buffer = [null(); 3];
1081        let keys = ["key_one", "key_two", "key_three"];
1082        let mut wrapper = map.iter_multi_mut(&keys, &mut buffer);
1083        
1084        let _one = wrapper.next().unwrap();
1085        let _two = wrapper.next().unwrap();
1086        let _three = wrapper.next().unwrap();
1087
1088        assert_eq!(wrapper.next(), None);
1089    }
1090
1091    #[test]
1092    #[should_panic]
1093    fn test_multi_iter_same_key() {
1094        let mut map = populate_hashmap();
1095
1096        use std::ptr::null;
1097
1098        let mut buffer = [null(); 3];
1099        let keys = ["key_one", "key_two", "key_one"];
1100        let mut wrapper = map.iter_multi_mut(&keys, &mut buffer);
1101        
1102        let _one = wrapper.next().unwrap();
1103        let _two = wrapper.next().unwrap();
1104        let _three = wrapper.next().unwrap();
1105    }
1106
1107    #[test]
1108    #[should_panic]
1109    fn test_multi_iter_nonexistent() {
1110        let mut map = populate_hashmap();
1111
1112        use std::ptr::null;
1113
1114        let mut buffer = [null(); 3];
1115        let keys = ["key_hundred"];
1116        let mut wrapper = map.iter_multi_mut(&keys, &mut buffer);
1117        
1118        wrapper.next();
1119    }
1120
1121}
multi_mut/lib.rs

multi_mut/
lib.rs
