vortex_array/array/bool/
accessors.rs

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
use vortex_error::VortexResult;

use crate::accessor::ArrayAccessor;
use crate::array::BoolArray;
use crate::validity::Validity;
use crate::IntoArrayVariant;

static TRUE: bool = true;
static FALSE: bool = false;

impl ArrayAccessor<bool> for BoolArray {
    fn with_iterator<F, R>(&self, f: F) -> VortexResult<R>
    where
        F: for<'a> FnOnce(&mut dyn Iterator<Item = Option<&'a bool>>) -> R,
    {
        let bools = self.boolean_buffer();
        match self.validity() {
            Validity::NonNullable | Validity::AllValid => Ok(f(&mut bools
                .iter()
                .map(|b| Some(if b { &TRUE } else { &FALSE })))),
            Validity::AllInvalid => Ok(f(&mut (0..self.len()).map(|_| None))),
            Validity::Array(valid) => {
                let valids = valid.into_bool()?.boolean_buffer();
                let mut iter = valids.iter().zip(bools.iter()).map(|(is_valid, value)| {
                    is_valid.then_some(if value { &TRUE } else { &FALSE })
                });

                Ok(f(&mut iter))
            }
        }
    }
}

#[cfg(test)]
mod test {
    use crate::accessor::ArrayAccessor;
    use crate::array::BoolArray;

    #[test]
    fn test_bool_accesor() {
        let original = vec![Some(true), None, Some(false), None];
        let array = BoolArray::from_iter(original.clone());

        let bool_vec: Vec<Option<bool>> =
            ArrayAccessor::<bool>::with_iterator(&array, |values_iter| {
                values_iter
                    .map(|b| b.cloned())
                    .collect::<Vec<Option<bool>>>()
            })
            .unwrap();
        assert_eq!(bool_vec, original);
    }
}