fast_forward/index/
int.rs

1//! This `Index` is well suitable for `IDs` with [`i32`] compatible data types (for example `Primary Keys`).
2//!
3use std::marker::PhantomData;
4
5use super::{
6    indices::KeyIndices,
7    ops::MinMax,
8    store::{Filterable, MetaData, Store},
9    view::Keys,
10};
11
12/// `Key` is from type Into: [`i32`].
13#[derive(Debug)]
14pub struct IntIndex<K = i32, X = usize> {
15    pos_data: Vec<Option<(K, KeyIndices<X>)>>,
16    neg_data: Vec<Option<(K, KeyIndices<X>)>>,
17    min_max_cache: MinMax<K>,
18    _key: PhantomData<K>,
19}
20
21impl<K, X> Filterable for IntIndex<K, X>
22where
23    K: Into<i32> + TryInto<usize> + Copy,
24{
25    type Key = K;
26    type Index = X;
27
28    #[inline]
29    fn get(&self, key: &Self::Key) -> &[X] {
30        let ikey: i32 = (*key).into();
31        match self.data(ikey).get(pos(ikey)) {
32            Some(Some((_, idx))) => idx.as_slice(),
33            _ => &[],
34        }
35    }
36
37    #[inline]
38    fn contains(&self, key: &Self::Key) -> bool {
39        let ikey: i32 = (*key).into();
40        matches!(self.data(ikey).get(pos(ikey)), Some(Some(_)))
41    }
42}
43
44impl<K, X> Store for IntIndex<K, X>
45where
46    K: Into<i32> + TryInto<usize> + Ord + Default + Copy,
47    X: Ord + Clone,
48{
49    fn insert(&mut self, key: K, x: X) {
50        let orig_key = key;
51        let i32key: i32 = key.into();
52        let pos = pos(i32key);
53        let data = self.data_mut(i32key);
54
55        if data.len() <= pos {
56            data.resize(pos + 1, None);
57        }
58
59        match data[pos].as_mut() {
60            Some((_, idx)) => idx.add(x),
61            None => data[pos] = Some((orig_key, KeyIndices::new(x))),
62        }
63
64        self.min_max_cache.new_value(orig_key);
65    }
66
67    fn delete(&mut self, key: K, x: &X) {
68        let orig_key = key;
69        let i32key: i32 = key.into();
70        let data = self.data_mut(i32key);
71
72        if let Some(Some((_, rm_idx))) = data.get_mut(pos(i32key)) {
73            // if the Index is the last, then remove complete Index
74            if rm_idx.remove(x).is_empty() {
75                data[pos(i32key)] = None
76            }
77        }
78
79        if orig_key == self.min_max_cache.min {
80            self.min_max_cache.min = self._find_min();
81        }
82        if orig_key == self.min_max_cache.max {
83            self.min_max_cache.max = self._find_max();
84        }
85    }
86
87    fn with_capacity(capacity: usize) -> Self {
88        IntIndex {
89            pos_data: Vec::with_capacity(capacity),
90            neg_data: Vec::with_capacity(capacity),
91            min_max_cache: MinMax::default(),
92            _key: PhantomData,
93        }
94    }
95}
96
97impl<K, X> IntIndex<K, X> {
98    #[inline]
99    fn data(&self, key: i32) -> &[Option<(K, KeyIndices<X>)>] {
100        if key < 0 {
101            return &self.neg_data;
102        }
103        &self.pos_data
104    }
105
106    #[inline]
107    fn data_mut(&mut self, key: i32) -> &mut Vec<Option<(K, KeyIndices<X>)>> {
108        if key < 0 {
109            return &mut self.neg_data;
110        }
111        &mut self.pos_data
112    }
113}
114
115impl<K> Keys for IntIndex<K>
116where
117    K: Into<i32> + TryInto<usize> + Ord + Default + Copy,
118{
119    type Key = K;
120
121    fn exist(&self, key: &K) -> bool {
122        let key: i32 = (*key).into();
123        matches!(self.data(key).get(pos(key)), Some(Some(_)))
124    }
125
126    fn iter<'a>(&'a self) -> Box<dyn Iterator<Item = &'a Self::Key> + 'a> {
127        Box::new(KeyIntIter::new(&self.neg_data, &self.pos_data))
128    }
129
130    fn from_iter<I>(it: I) -> Self
131    where
132        I: IntoIterator<Item = K>,
133    {
134        fn add_key<K>(view: &mut IntIndex<K>, key: K)
135        where
136            K: Into<i32> + TryInto<usize> + Copy,
137        {
138            let ikey: i32 = key.into();
139            let pos = pos(ikey);
140            let data = view.data_mut(ikey);
141
142            if data.len() <= pos {
143                data.resize(pos + 1, None);
144            }
145
146            data[pos] = Some((key, KeyIndices::empty()))
147        }
148
149        let v = Vec::from_iter(it);
150        let mut view =
151            Self::with_capacity(v.iter().map(|k| pos((*k).into())).max().unwrap_or_default());
152        v.into_iter().for_each(|key| add_key(&mut view, key));
153        view
154    }
155}
156
157#[inline]
158fn pos(key: i32) -> usize {
159    if key < 0 {
160        key.abs().try_into()
161    } else {
162        key.try_into()
163    }
164    .expect("key could not convert into usize")
165}
166
167struct KeyIntIter<'a, K> {
168    pos: &'a [Option<(K, KeyIndices)>],
169    iter: std::slice::Iter<'a, Option<(K, KeyIndices)>>,
170    is_neg: bool,
171}
172
173impl<'a, K> KeyIntIter<'a, K> {
174    fn new(neg: &'a [Option<(K, KeyIndices)>], pos: &'a [Option<(K, KeyIndices)>]) -> Self {
175        Self {
176            pos,
177            is_neg: true,
178            iter: neg.iter(),
179        }
180    }
181}
182
183impl<'a, K> Iterator for KeyIntIter<'a, K> {
184    type Item = &'a K;
185
186    fn next(&mut self) -> Option<Self::Item> {
187        if let Some(opt) = self.iter.by_ref().flatten().next() {
188            return Some(&opt.0);
189        }
190
191        if self.is_neg {
192            self.is_neg = false;
193            self.iter = self.pos.iter();
194
195            if let Some(opt) = self.iter.by_ref().flatten().next() {
196                return Some(&opt.0);
197            }
198        }
199
200        None
201    }
202}
203
204impl<K, X> MetaData for IntIndex<K, X> {
205    type Meta<'m> = IntMeta<'m, K,X> where K: 'm, X:'m;
206
207    fn meta(&self) -> Self::Meta<'_> {
208        IntMeta(self)
209    }
210}
211
212/// Meta data for the IntIndex, like min and max value from the saved Index.
213pub struct IntMeta<'s, K: 's, X>(&'s IntIndex<K, X>);
214
215impl<'s, K, X> IntMeta<'s, K, X>
216where
217    K: 's + Copy,
218{
219    /// Filter for get the smallest (`min`) `Key` which is stored in `IntIndex`.
220    pub const fn min_key(&self) -> K {
221        self.0.min_max_cache.min
222    }
223
224    /// Filter for get the highest (`max`) `Key` which is stored in `IntIndex`.
225    pub const fn max_key(&self) -> K {
226        self.0.min_max_cache.max
227    }
228}
229
230impl<K, X> IntIndex<K, X>
231where
232    K: Default + Copy,
233{
234    /// Find `min` key.
235    fn _find_min(&self) -> K {
236        let n = self
237            .neg_data
238            .iter()
239            .rev()
240            .find_map(|o| o.as_ref().map(|(k, _)| *k));
241
242        if let Some(n) = n {
243            return n;
244        }
245
246        self.pos_data
247            .iter()
248            .find_map(|o| o.as_ref().map(|(k, _)| *k))
249            .unwrap_or_default()
250    }
251
252    /// Find `max` key.
253    fn _find_max(&self) -> K {
254        let p = self
255            .pos_data
256            .iter()
257            .rev()
258            .find_map(|o| o.as_ref().map(|(k, _)| *k));
259
260        if let Some(p) = p {
261            return p;
262        }
263
264        self.neg_data
265            .iter()
266            .find_map(|o| o.as_ref().map(|(k, _)| *k))
267            .unwrap_or_default()
268    }
269}
270
271#[cfg(test)]
272mod tests {
273    use super::*;
274    use crate::index::filter::Filter;
275
276    impl IntIndex<i32> {
277        fn new() -> Self {
278            Self {
279                pos_data: Vec::new(),
280                neg_data: Vec::new(),
281                min_max_cache: MinMax::default(),
282                _key: PhantomData,
283            }
284        }
285    }
286
287    #[test]
288    fn insert_plus() {
289        let mut i = IntIndex::new();
290        i.insert(1, 3);
291        i.insert(2, 4);
292
293        assert!(i.contains(&1));
294        assert!(!i.contains(&3));
295
296        let r = i.get(&2).iter().collect::<Vec<_>>();
297        assert_eq!(vec![&4], r);
298    }
299
300    #[test]
301    fn insert_minus() {
302        let mut i = IntIndex::new();
303        i.insert(-1, 3);
304        i.insert(-2, 4);
305
306        assert!(i.contains(&-1));
307        assert!(!i.contains(&-3));
308
309        let r = i.get(&-2).iter().collect::<Vec<_>>();
310        assert_eq!(vec![&4], r);
311    }
312
313    #[test]
314    fn insert_plus_minus() {
315        let mut i = IntIndex::new();
316        i.insert(1, 3);
317        i.insert(-2, 4);
318        i.insert(3, 8);
319
320        assert!(i.contains(&1));
321        assert!(i.contains(&-2));
322        assert!(i.contains(&3));
323        assert!(!i.contains(&5));
324
325        let r = i.get_many([-2, 3]).collect::<Vec<_>>();
326        assert_eq!(vec![&4, &8], r);
327    }
328
329    #[test]
330    fn delete_plus_minus() {
331        let mut i = IntIndex::new();
332        i.insert(1, 3);
333        i.insert(-2, 4);
334        i.insert(1, 5);
335
336        assert!(i.contains(&1));
337        assert!(i.contains(&-2));
338
339        i.delete(1, &3);
340        assert!(i.contains(&1));
341        assert!(i.contains(&-2));
342
343        i.delete(1, &5);
344        assert!(!i.contains(&1));
345        assert!(i.contains(&-2));
346    }
347
348    #[test]
349    fn filter() {
350        let mut i = IntIndex::with_capacity(4);
351        i.insert(2, 4);
352
353        assert_eq!(i.get(&2), [4]);
354
355        i.insert(1, 3);
356        let f = Filter(&i);
357        assert_eq!([3, 4], (f.eq(&2) | f.eq(&1)));
358    }
359
360    #[test]
361    fn meta() {
362        let mut i = IntIndex::<i8>::with_capacity(3);
363        i.insert(2, 4);
364
365        assert_eq!(2i8, i.meta().min_key());
366        assert_eq!(2i8, i.meta().max_key());
367
368        i.insert(1, 3);
369        assert_eq!(1, i.meta().min_key());
370        assert_eq!(2, i.meta().max_key());
371    }
372
373    #[test]
374    fn index_str() {
375        let mut i = IntIndex::<i8, String>::with_capacity(8);
376        i.insert(1, "Jasmin".into());
377        i.insert(2, "Mario 1".into());
378        i.insert(2, "Mario 2".into());
379        i.insert(-5, "Paul".into());
380
381        assert!(i.contains(&-5));
382
383        for idx in i.get(&1).iter() {
384            assert_eq!(&String::from("Jasmin"), idx);
385        }
386
387        let idxs = i.get(&1);
388        let mut it = idxs.iter();
389        assert_eq!(Some(&"Jasmin".into()), it.next());
390        assert_eq!(None, it.next());
391
392        let idxs = i.get(&2);
393        let mut it = idxs.iter();
394        assert_eq!(Some(&"Mario 1".into()), it.next());
395        assert_eq!(Some(&"Mario 2".into()), it.next());
396        assert_eq!(None, it.next());
397
398        let r = i.get_many([1, -5]).collect::<Vec<_>>();
399        assert_eq!(vec![&String::from("Jasmin"), &String::from("Paul")], r);
400
401        let r = i.get_many([-5, 1]).collect::<Vec<_>>();
402        assert_eq!(vec![&String::from("Paul"), &String::from("Jasmin")], r);
403    }
404
405    mod unique {
406        use super::*;
407
408        #[test]
409        fn empty() {
410            let i = IntIndex::new();
411            assert_eq!(0, i.get(&2).len());
412            assert!(i.pos_data.is_empty());
413            assert!(i.neg_data.is_empty());
414        }
415
416        #[test]
417        fn find_idx_2_usize_pos() {
418            let mut i = IntIndex::new();
419            i.insert(2, 4);
420
421            assert_eq!(i.get(&2), [4]);
422            assert_eq!(3, i.pos_data.len());
423            assert_eq!(0, i.neg_data.len());
424        }
425
426        #[test]
427        fn find_idx_2_usize_neg() {
428            let mut i = IntIndex::new();
429            i.insert(-2, 4);
430
431            assert_eq!(i.get(&-2), [4]);
432            assert_eq!(0, i.pos_data.len());
433            assert_eq!(3, i.neg_data.len());
434        }
435
436        #[test]
437        fn find_idx_2_bool() {
438            let mut i = IntIndex::<bool>::with_capacity(2);
439            i.insert(true, 4);
440
441            assert_eq!(i.get(&true), [4]);
442            assert_eq!(2, i.pos_data.len());
443            assert_eq!(0, i.neg_data.len());
444        }
445
446        #[test]
447        fn find_idx_2_u16() {
448            let mut i = IntIndex::<u16>::with_capacity(2);
449            i.insert(2, 4);
450
451            assert_eq!(i.get(&2), [4]);
452            assert_eq!(3, i.pos_data.len());
453            assert_eq!(0, i.neg_data.len());
454        }
455
456        #[test]
457        fn or_find_idx_3_4() {
458            let mut idx = IntIndex::new();
459            idx.insert(2, 4);
460            idx.insert(4, 8);
461            idx.insert(3, 6);
462
463            let f = Filter(&idx);
464
465            assert_eq!([6, 8], f.eq(&3) | f.eq(&4));
466            assert_eq!([6], f.eq(&3) & f.eq(&3));
467            assert_eq!([6], f.eq(&3) | f.eq(&99));
468            assert_eq!([8], f.eq(&99) | f.eq(&4));
469            assert_eq!([], f.eq(&3) & f.eq(&4));
470
471            idx.insert(99, 0);
472            assert_eq!([0], idx.get(&99));
473        }
474
475        #[test]
476        fn query_and_or() {
477            let mut idx = IntIndex::new();
478            idx.insert(2, 4);
479            idx.insert(4, 8);
480            idx.insert(3, 6);
481
482            let f = Filter(&idx);
483
484            assert_eq!([], f.eq(&3) & f.eq(&2));
485
486            // =3 or =4 and =2 =>
487            // (
488            // (4 and 2 = false) // `and` has higher prio than `or`
489            //  or 3 = true
490            // )
491            // => 3 -> 6
492            assert_eq!([6], f.eq(&3) | f.eq(&4) & f.eq(&2));
493        }
494
495        #[test]
496        fn out_of_bound() {
497            let i = IntIndex::new();
498            assert_eq!(0, i.get(&2).len());
499        }
500
501        #[test]
502        fn with_capacity() {
503            let mut i = IntIndex::<u8>::with_capacity(5);
504            i.insert(1, 4);
505            assert_eq!(2, i.pos_data.len());
506            assert_eq!(5, i.pos_data.capacity());
507            assert_eq!(0, i.neg_data.len());
508            assert_eq!(5, i.neg_data.capacity());
509        }
510
511        #[test]
512        fn find_eq_many_unique() {
513            let l = [0, 1, 2, 3, 4, 5, 6];
514            let i = IntIndex::<u8>::from_list(l);
515
516            assert_eq!(0, i.get_many([]).items_vec(&l).len());
517            assert_eq!(0, i.get_many([9]).items_vec(&l).len());
518            assert_eq!(vec![&2], i.get_many([2]).items_vec(&l));
519            assert_eq!(vec![&6, &2], i.get_many([6, 2]).items_vec(&l));
520            assert_eq!(vec![&6, &2], i.get_many([9, 6, 2]).items_vec(&l));
521            assert_eq!(vec![&5, &6, &2], i.get_many([5, 9, 6, 2]).items_vec(&l));
522
523            assert_eq!(vec![&2, &3, &4, &5, &6], i.get_many(2..=6).items_vec(&l));
524            assert_eq!(vec![&2, &3, &4, &5, &6], i.get_many(2..9).items_vec(&l));
525        }
526
527        #[test]
528        fn contains() {
529            let mut i = IntIndex::<u8>::with_capacity(2);
530            i.insert(5, 5);
531            i.insert(2, 2);
532
533            assert!(i.contains(&5));
534            assert!(!i.contains(&55));
535        }
536
537        #[test]
538        fn min() {
539            let mut idx = IntIndex::<i16>::with_capacity(100);
540            assert_eq!(0, idx.meta().min_key());
541            assert_eq!(0, idx._find_min());
542
543            idx.insert(4, 4);
544            assert_eq!(4, idx.meta().min_key());
545            assert_eq!(4, idx._find_min());
546
547            idx.insert(-2, 8);
548            assert_eq!(-2, idx.meta().min_key());
549            assert_eq!(-2, idx._find_min());
550
551            idx.insert(99, 6);
552            assert_eq!(-2, idx.meta().min_key());
553            assert_eq!(-2, idx._find_min());
554        }
555
556        #[test]
557        fn min_rm() {
558            let mut idx = IntIndex::<u16>::with_capacity(100);
559            idx.insert(4, 4);
560            assert_eq!(4, idx.meta().min_key());
561            assert_eq!(4, idx._find_min());
562
563            idx.insert(2, 8);
564            assert_eq!(2, idx.meta().min_key());
565            assert_eq!(2, idx._find_min());
566
567            idx.delete(2, &8);
568            assert_eq!(4, idx.meta().min_key()); // this cached value is now false
569            assert_eq!(4, idx._find_min()); // this is the correct value
570        }
571
572        #[test]
573        fn max() {
574            let mut idx = IntIndex::<i16>::with_capacity(100);
575            assert_eq!(0, idx.meta().max_key());
576
577            idx.insert(4, 4);
578            assert_eq!(4, idx.meta().max_key());
579
580            idx.insert(-2, 8);
581            assert_eq!(4, idx.meta().max_key());
582
583            idx.insert(99, 6);
584            assert_eq!(99, idx.meta().max_key());
585        }
586
587        #[test]
588        fn update() {
589            let mut idx = IntIndex::new();
590            idx.insert(2, 4);
591
592            assert_eq!(2, idx.meta().min_key());
593            assert_eq!(2, idx.meta().max_key());
594
595            // (old) Key: 99 do not exist, insert a (new) Key 100?
596            idx.update(99, 4, 100);
597            assert_eq!(101, idx.pos_data.len());
598            assert_eq!([4], idx.get(&100));
599
600            // (old) Key 2 exist, but not with Index: 8, insert known Key: 2 with add new Index 8
601            idx.update(2, 8, 2);
602            assert_eq!([4, 8], idx.get(&2));
603
604            // old Key 2 with Index 8 was removed and (new) Key 4 was added with Index 8
605            idx.update(2, 8, 4);
606            assert_eq!([8], idx.get(&4));
607            assert_eq!([4], idx.get(&2));
608
609            assert_eq!(2, idx.meta().min_key());
610            assert_eq!(100, idx.meta().max_key());
611        }
612
613        #[test]
614        fn delete_empty() {
615            let idx = IntIndex::new();
616
617            assert_eq!(0, idx.meta().min_key());
618            assert_eq!(0, idx.meta().max_key());
619        }
620
621        #[test]
622        fn delete_pos() {
623            let mut idx = IntIndex::new();
624            idx.insert(2, 4);
625            idx.insert(2, 3);
626            idx.insert(3, 1);
627
628            assert_eq!(2, idx.meta().min_key());
629            assert_eq!(3, idx.meta().max_key());
630
631            // delete correct Key with wrong Index, nothing happens
632            idx.delete(2, &100);
633            assert_eq!([3, 4], idx.get(&2));
634
635            // delete correct Key with correct Index
636            idx.delete(2, &3);
637            assert_eq!([4], idx.get(&2));
638            assert_eq!(2, idx.meta().min_key());
639            assert_eq!(3, idx.meta().max_key());
640
641            // delete correct Key with last correct Index, Key now longer exist
642            idx.delete(2, &4);
643            assert!(idx.get(&2).is_empty());
644            assert_eq!(3, idx.meta().min_key());
645            assert_eq!(3, idx.meta().max_key());
646
647            idx.insert(2, 4);
648            // remove max key
649            idx.delete(3, &1);
650            assert_eq!(2, idx.meta().max_key());
651        }
652
653        #[test]
654        fn delete_neg() {
655            let mut idx = IntIndex::new();
656            idx.insert(-2, 4);
657            idx.insert(-2, 3);
658            idx.insert(-3, 1);
659
660            assert_eq!(-3, idx.meta().min_key());
661            assert_eq!(-2, idx.meta().max_key());
662
663            idx.delete(-3, &1);
664            assert_eq!(-2, idx.meta().min_key());
665            assert_eq!(-2, idx.meta().max_key());
666
667            idx.insert(-3, 1);
668            assert_eq!(-3, idx.meta().min_key());
669            assert_eq!(-2, idx.meta().max_key());
670
671            idx.delete(-2, &4);
672            idx.delete(-2, &3);
673            assert_eq!(-3, idx.meta().min_key());
674            assert_eq!(-3, idx.meta().max_key());
675        }
676
677        #[test]
678        fn delete_pos_neg() {
679            let mut idx = IntIndex::new();
680            idx.insert(2, 4);
681            idx.insert(-2, 3);
682            idx.insert(-3, 1);
683
684            assert_eq!(-3, idx.meta().min_key());
685            assert_eq!(2, idx.meta().max_key());
686
687            idx.delete(-3, &1);
688            assert_eq!(-2, idx.meta().min_key());
689            assert_eq!(2, idx.meta().max_key());
690
691            idx.insert(-3, 1);
692            assert_eq!(-3, idx.meta().min_key());
693            assert_eq!(2, idx.meta().max_key());
694
695            idx.delete(2, &4);
696            assert_eq!(-3, idx.meta().min_key());
697            assert_eq!(-2, idx.meta().max_key());
698        }
699    }
700
701    mod multi {
702        use super::*;
703
704        #[test]
705        fn empty() {
706            let i = IntIndex::<u8>::with_capacity(2);
707            assert_eq!(0, i.get(&2).len());
708            assert!(i.pos_data.is_empty());
709            assert!(i.neg_data.is_empty());
710        }
711
712        #[test]
713        fn find_idx_2() {
714            let mut i = IntIndex::<u8, i32>::with_capacity(2);
715            i.insert(2, 2);
716            i.insert(2, -2);
717
718            assert_eq!(i.get(&2), [-2, 2]);
719            assert_eq!(3, i.pos_data.len());
720            assert_eq!(0, i.neg_data.len());
721        }
722
723        #[test]
724        fn double_index() {
725            let mut i = IntIndex::new();
726            i.insert(2, 2);
727            i.insert(2, 1);
728            assert_eq!(i.get(&2), [1, 2]);
729
730            i.insert(-2, 2);
731            i.insert(-2, 1);
732            assert_eq!(i.get(&-2), [1, 2]);
733        }
734
735        #[test]
736        fn find_eq_many_unique() {
737            let l = [0, 2, 2, -3, 4, 5, -6];
738            let i = IntIndex::<i8>::from_list(l);
739
740            assert_eq!(0, i.get_many([]).items_vec(&l).len());
741            assert_eq!(0, i.get_many([9]).items_vec(&l).len());
742
743            assert_eq!(vec![&2, &2], i.get_many([2]).items_vec(&l));
744            assert_eq!(vec![&-6, &2, &2], i.get_many([-6, 2]).items_vec(&l));
745            assert_eq!(vec![&-6, &2, &2], i.get_many([9, -6, 2]).items_vec(&l));
746            assert_eq!(
747                vec![&5, &-6, &2, &2],
748                i.get_many([5, 9, -6, 2]).items_vec(&l)
749            );
750        }
751
752        #[test]
753        fn contains() {
754            let mut i = IntIndex::<i8, i8>::with_capacity(3);
755            i.insert(2, 2);
756            i.insert(2, 1);
757            assert!(i.contains(&2));
758            assert!(!i.contains(&55));
759
760            i.insert(-2, -2);
761            i.insert(-2, -1);
762            assert!(i.contains(&-2));
763            assert!(!i.contains(&-55));
764        }
765    }
766
767    mod keys {
768        use super::*;
769
770        #[test]
771        fn empty() {
772            let keys = IntIndex::from_iter(Vec::<i32>::new());
773            assert!(!keys.exist(&1));
774        }
775
776        #[test]
777        fn one() {
778            let keys = IntIndex::from_iter([2i32]);
779            assert!(!keys.exist(&1));
780            assert!(keys.exist(&2));
781
782            let keys = IntIndex::from_iter([-2i32]);
783            assert!(!keys.exist(&-1));
784            assert!(keys.exist(&-2));
785        }
786
787        #[test]
788        fn two() {
789            let keys = IntIndex::from_iter([2i32, -2]);
790            assert!(!keys.exist(&1));
791            assert!(keys.exist(&2));
792            assert!(!keys.exist(&-1));
793            assert!(keys.exist(&-2));
794        }
795
796        #[test]
797        fn keys() {
798            let keys = IntIndex::from_iter([5, 1, 3]);
799            assert_eq!(keys.iter().collect::<Vec<_>>(), vec![&1, &3, &5]);
800
801            let keys = IntIndex::from_iter([5u8, 1, 3]);
802            assert_eq!(keys.iter().collect::<Vec<_>>(), vec![&1, &3, &5]);
803
804            // true is twice, so it will be ignored ones
805            let keys = IntIndex::from_iter([true, false, true]);
806            assert_eq!(keys.iter().collect::<Vec<_>>(), vec![&false, &true]);
807        }
808
809        #[test]
810        fn keys_with_neg() {
811            let keys = IntIndex::from_iter([5, -1, -3]);
812            assert_eq!(keys.iter().collect::<Vec<_>>(), vec![&-1, &-3, &5]);
813
814            let keys = IntIndex::from_iter([-5, -1, -3]);
815            assert_eq!(keys.iter().collect::<Vec<_>>(), vec![&-1, &-3, &-5]);
816
817            let keys = IntIndex::from_iter([-5, 1, 3, 5]);
818            assert_eq!(keys.iter().collect::<Vec<_>>(), vec![&-5, &1, &3, &5]);
819
820            let keys = IntIndex::from_iter([1, 3, 5, -1, -3, -5]);
821            assert_eq!(
822                keys.iter().collect::<Vec<_>>(),
823                vec![&-1, &-3, &-5, &1, &3, &5]
824            );
825        }
826    }
827}
fast_forward/index/int.rs

fast_forward/index/
int.rs
