zarrs 0.23.9

A library for the Zarr storage format for multidimensional arrays and metadata
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

use crate::array::{ArrayBytes, DataType};

use super::{Element, ElementError, ElementOwned};

use ElementError::IncompatibleElementType as IET;

impl<T> Element for Option<T>
where
    T: Element + Default,
{
    fn validate_data_type(data_type: &DataType) -> Result<(), ElementError> {
        let opt = data_type.as_optional().ok_or(IET)?;
        T::validate_data_type(opt.data_type())
    }

    fn to_array_bytes<'a>(
        data_type: &DataType,
        elements: &'a [Self],
    ) -> Result<ArrayBytes<'a>, ElementError> {
        Self::validate_data_type(data_type)?;

        let opt = data_type.as_optional().ok_or(IET)?;

        let num_elements = elements.len();

        // Create validity mask - one byte per element
        let mut mask = Vec::with_capacity(num_elements);

        // Create dense data - all elements, using default/zero for None values
        // We need to use a placeholder value for None elements
        let default_value = T::default();
        let mut dense_elements = Vec::with_capacity(num_elements);

        for element in elements {
            if let Some(value) = element {
                mask.push(1u8);
                dense_elements.push(value.clone());
            } else {
                mask.push(0u8);
                dense_elements.push(default_value.clone());
            }
        }

        // Convert all elements (dense) to ArrayBytes
        let data = T::into_array_bytes(opt.data_type(), dense_elements)?.into_owned();

        // Create optional ArrayBytes by adding mask to the data
        Ok(data.with_optional_mask(mask))
    }

    fn into_array_bytes(
        data_type: &DataType,
        elements: Vec<Self>,
    ) -> Result<ArrayBytes<'static>, ElementError> {
        Ok(Self::to_array_bytes(data_type, &elements)?.into_owned())
    }
}

impl<T> ElementOwned for Option<T>
where
    T: ElementOwned + Clone + Default,
{
    fn from_array_bytes(
        data_type: &DataType,
        bytes: ArrayBytes<'_>,
    ) -> Result<Vec<Self>, ElementError> {
        Self::validate_data_type(data_type)?;

        let opt = data_type.as_optional().ok_or(IET)?;

        // Extract mask and dense data from optional ArrayBytes
        let optional_bytes = bytes.into_optional()?;
        let (data, mask) = optional_bytes.into_parts();

        // Convert the dense inner data to a Vec<T>
        let dense_values = T::from_array_bytes(opt.data_type(), *data)?;

        // Build the result vector using mask to determine Some vs None
        let mut elements = Vec::with_capacity(mask.len());
        for (i, &mask_byte) in mask.iter().enumerate() {
            if mask_byte == 0 {
                // None value
                elements.push(None);
            } else {
                // Some value - take from dense data
                if i >= dense_values.len() {
                    return Err(ElementError::Other(format!(
                        "Not enough dense values for mask at index {i}"
                    )));
                }
                elements.push(Some(dense_values[i].clone()));
            }
        }

        Ok(elements)
    }
}