Struct ArrayBytesVariableLength 

pub struct ArrayBytesVariableLength<'a> { /* private fields */ }

Variable length array bytes composed of bytes and element bytes offsets.

The bytes and offsets are modeled on the Apache Arrow Variable-size Binary Layout.

• The offsets buffer contains length + 1 signed integers (either 32-bit or 64-bit, depending on the data type) usize integers.
• Offsets must be monotonically increasing, that is offsets[j+1] >= offsets[j] for 0 <= j < length, even for null slots. Thus, the bytes represent C-contiguous elements with padding permitted.
• The final offset must be less than or equal to the length of the bytes buffer.

Implementations

impl<'a> ArrayBytesVariableLength<'a>

pub fn new( bytes: impl Into<Cow<'a, [u8]>>, offsets: ArrayBytesOffsets<'a>, ) -> Result<ArrayBytesVariableLength<'a>, ArrayBytesRawOffsetsOutOfBoundsError>

Create a new variable length bytes from bytes and offsets.

Errors

Returns a ArrayBytesRawOffsetsOutOfBoundsError if the last offset is out of bounds of the bytes or if the offsets are not monotonically increasing.

pub unsafe fn new_unchecked( bytes: impl Into<Cow<'a, [u8]>>, offsets: ArrayBytesOffsets<'a>, ) -> ArrayBytesVariableLength<'a>

Create a new variable length bytes from bytes and offsets.

Safety

The last offset must be less than or equal to the length of the bytes.

pub fn bytes(&self) -> &Cow<'a, [u8]>

Get the underlying bytes.

pub fn offsets(&self) -> &ArrayBytesOffsets<'a>

Get the underlying offsets.

pub fn into_parts(self) -> (Cow<'a, [u8]>, ArrayBytesOffsets<'a>)

Consume self and return the bytes and offsets.

Examples found in repository

examples/custom_data_type_variable_size.rs (line 74)

    fn from_array_bytes(
        data_type: &DataType,
        bytes: ArrayBytes<'_>,
    ) -> Result<Vec<Self>, ElementError> {
        Self::validate_data_type(data_type)?;
        let (bytes, offsets) = bytes.into_variable()?.into_parts();

        let mut elements = Vec::with_capacity(offsets.len().saturating_sub(1));
        for (curr, next) in offsets.iter().tuple_windows() {
            let bytes = &bytes[*curr..*next];
            if let Ok(bytes) = <[u8; 4]>::try_from(bytes) {
                let value = f32::from_le_bytes(bytes);
                elements.push(CustomDataTypeVariableSizeElement(Some(value)));
            } else if bytes.is_empty() {
                elements.push(CustomDataTypeVariableSizeElement(None));
            } else {
                panic!()
            }
        }

        Ok(elements)
    }

examples/array_write_read_string.rs (line 96)

fn array_write_read() -> Result<(), Box<dyn std::error::Error>> {
    use std::sync::Arc;

    use zarrs::array::{ArrayBytes, data_type};
    use zarrs::storage::store;

    // Create a store
    // let path = tempfile::TempDir::new()?;
    // let mut store: ReadableWritableListableStorage =
    //     Arc::new(zarrs::filesystem::FilesystemStore::new(path.path())?);
    // let mut store: ReadableWritableListableStorage = Arc::new(
    //     zarrs::filesystem::FilesystemStore::new("zarrs/tests/data/array_write_read.zarr")?,
    // );
    let mut store: ReadableWritableListableStorage = Arc::new(store::MemoryStore::new());
    if let Some(arg1) = std::env::args().collect::<Vec<_>>().get(1)
        && arg1 == "--usage-log"
    {
        let log_writer = Arc::new(std::sync::Mutex::new(
            // std::io::BufWriter::new(
            std::io::stdout(),
            //    )
        ));
        store = Arc::new(UsageLogStorageAdapter::new(store, log_writer, || {
            chrono::Utc::now().format("[%T%.3f] ").to_string()
        }));
    }

    // Create the root group
    zarrs::group::GroupBuilder::new()
        .build(store.clone(), "/")?
        .store_metadata()?;

    // Create a group with attributes
    let group_path = "/group";
    let mut group = zarrs::group::GroupBuilder::new().build(store.clone(), group_path)?;
    group
        .attributes_mut()
        .insert("foo".into(), serde_json::Value::String("bar".into()));
    group.store_metadata()?;

    println!(
        "The group metadata is:\n{}\n",
        group.metadata().to_string_pretty()
    );

    // Create an array
    let array_path = "/group/array";
    let array = zarrs::array::ArrayBuilder::new(
        vec![4, 4], // array shape
        vec![2, 2], // regular chunk shape
        data_type::string(),
        "_",
    )
    // .bytes_to_bytes_codecs(vec![]) // uncompressed
    .dimension_names(["y", "x"].into())
    // .storage_transformers(vec![].into())
    .build(store.clone(), array_path)?;

    // Write array metadata to store
    array.store_metadata()?;

    println!(
        "The array metadata is:\n{}\n",
        array.metadata().to_string_pretty()
    );

    // Write some chunks
    array.store_chunk(
        &[0, 0],
        ArrayD::<&str>::from_shape_vec(vec![2, 2], vec!["a", "bb", "ccc", "dddd"]).unwrap(),
    )?;
    array.store_chunk(
        &[0, 1],
        ArrayD::<&str>::from_shape_vec(vec![2, 2], vec!["4444", "333", "22", "1"]).unwrap(),
    )?;
    let subset_all = array.subset_all();
    let data_all: ArrayD<String> = array.retrieve_array_subset(&subset_all)?;
    println!("store_chunk [0, 0] and [0, 1]:\n{data_all}\n");

    // Write a subset spanning multiple chunks, including updating chunks already written
    let ndarray_subset: Array2<&str> = array![["!", "@@"], ["###", "$$$$"]];
    array.store_array_subset(&[1..3, 1..3], ndarray_subset)?;
    let data_all: ArrayD<String> = array.retrieve_array_subset(&subset_all)?;
    println!("store_array_subset [1..3, 1..3]:\nndarray::ArrayD<String>\n{data_all}");

    // Retrieve bytes directly, convert into a single string allocation, create a &str ndarray
    // TODO: Add a convenience function for this?
    let data_all: ArrayBytes = array.retrieve_array_subset(&subset_all)?;
    let (bytes, offsets) = data_all.into_variable()?.into_parts();
    let string = String::from_utf8(bytes.into_owned())?;
    let elements = offsets
        .iter()
        .tuple_windows()
        .map(|(&curr, &next)| &string[curr..next])
        .collect::<Vec<&str>>();
    let ndarray = ArrayD::<&str>::from_shape_vec(subset_all.shape_usize(), elements)?;
    println!("ndarray::ArrayD<&str>:\n{ndarray}");

    Ok(())
}

Trait Implementations

impl<'a> Clone for ArrayBytesVariableLength<'a>

fn clone(&self) -> ArrayBytesVariableLength<'a>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<'a> Debug for ArrayBytesVariableLength<'a>

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl<'a> From<ArrayBytesVariableLength<'a>> for ArrayBytes<'a>

fn from(value: ArrayBytesVariableLength<'a>) -> ArrayBytes<'a>

Converts to this type from the input type.

impl<'a> PartialEq for ArrayBytesVariableLength<'a>

fn eq(&self, other: &ArrayBytesVariableLength<'a>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<'a> Eq for ArrayBytesVariableLength<'a>

impl<'a> StructuralPartialEq for ArrayBytesVariableLength<'a>