Struct ArrayMetadataOptions 

pub struct ArrayMetadataOptions { /* private fields */ }

Options for writing array metadata.

Implementations

impl ArrayMetadataOptions

pub fn codec_metadata_options(&self) -> &CodecMetadataOptions

Return the codec options.

pub fn codec_metadata_options_mut(&mut self) -> &mut CodecMetadataOptions

Return a mutable reference to the codec options.

pub fn with_codec_metadata_options( self, codec_metadata_options: CodecMetadataOptions, ) -> Self

Set the codec metadata options.

pub fn set_codec_metadata_options( &mut self, codec_metadata_options: CodecMetadataOptions, ) -> &mut Self

Set the codec metadata options.

pub fn metadata_convert_version(&self) -> MetadataConvertVersion

Get the metadata convert version configuration.

pub fn with_metadata_convert_version( self, convert_version: MetadataConvertVersion, ) -> Self

Set the metadata convert version configuration.

Examples found in repository

examples/zarr_v2_to_v3.rs (line 80)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let store = Arc::new(zarrs_storage::store::MemoryStore::new());

    let serde_json::Value::Object(attributes) = serde_json::json!({
        "foo": "bar",
        "baz": 42,
    }) else {
        unreachable!()
    };

    // Create a Zarr V2 group
    let group_metadata: GroupMetadata = GroupMetadataV2::new()
        .with_attributes(attributes.clone())
        .into();
    let group = Group::new_with_metadata(store.clone(), "/group", group_metadata)?;

    // Store the metadata as V2 and V3
    let convert_group_metadata_to_v3 =
        GroupMetadataOptions::default().with_metadata_convert_version(MetadataConvertVersion::V3);
    group.store_metadata()?;
    group.store_metadata_opt(&convert_group_metadata_to_v3)?;
    println!(
        "group/.zgroup (Zarr V2 group metadata):\n{}\n",
        key_to_str(&store, "group/.zgroup")?
    );
    println!(
        "group/.zattrs (Zarr V2 group attributes):\n{}\n",
        key_to_str(&store, "group/.zattrs")?
    );
    println!(
        "group/zarr.json (Zarr V3 equivalent group metadata/attributes):\n{}\n",
        key_to_str(&store, "group/zarr.json")?
    );
    // println!(
    //     "The equivalent Zarr V3 group metadata is\n{}\n",
    //     group.metadata_opt(&convert_group_metadata_to_v3).to_string_pretty()
    // );

    // Create a Zarr V2 array
    let array_metadata = ArrayMetadataV2::new(
        vec![10, 10],
        vec![NonZeroU64::new(5).unwrap(); 2],
        ">f4".into(), // big endian float32
        FillValueMetadata::from(f32::NAN),
        None,
        None,
    )
    .with_dimension_separator(ChunkKeySeparator::Slash)
    .with_order(ArrayMetadataV2Order::F)
    .with_attributes(attributes.clone());
    let array = zarrs::array::Array::new_with_metadata(
        store.clone(),
        "/group/array",
        array_metadata.into(),
    )?;

    // Store the metadata as V2 and V3
    let convert_array_metadata_to_v3 =
        ArrayMetadataOptions::default().with_metadata_convert_version(MetadataConvertVersion::V3);
    array.store_metadata()?;
    array.store_metadata_opt(&convert_array_metadata_to_v3)?;
    println!(
        "group/array/.zarray (Zarr V2 array metadata):\n{}\n",
        key_to_str(&store, "group/array/.zarray")?
    );
    println!(
        "group/array/.zattrs (Zarr V2 array attributes):\n{}\n",
        key_to_str(&store, "group/array/.zattrs")?
    );
    println!(
        "group/array/zarr.json (Zarr V3 equivalent array metadata/attributes):\n{}\n",
        key_to_str(&store, "group/array/zarr.json")?
    );
    // println!(
    //     "The equivalent Zarr V3 array metadata is\n{}\n",
    //     array.metadata_opt(&convert_array_metadata_to_v3).to_string_pretty()
    // );

    array.store_chunk(&[0, 1], &[0.0f32; 5 * 5])?;

    // Print the keys in the store
    println!("The store contains keys:");
    for key in store.list()? {
        println!("  {}", key);
    }

    Ok(())
}

pub fn set_metadata_convert_version( &mut self, convert_version: MetadataConvertVersion, ) -> &mut Self

Set the metadata convert version configuration.

pub fn include_zarrs_metadata(&self) -> bool

Get the include zarrs metadata configuration.

pub fn with_include_zarrs_metadata(self, include_zarrs_metadata: bool) -> Self

Set the include zarrs metadata configuration.

Examples found in repository

examples/data_type_optional_nested.rs (line 42)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Create an in-memory store
    // let store = Arc::new(zarrs::filesystem::FilesystemStore::new(
    //     "zarrs/tests/data/v3/array_optional_nested.zarr",
    // )?);
    let store = Arc::new(zarrs::storage::store::MemoryStore::new());

    // Build the codec chains for the optional codec
    let array = ArrayBuilder::new(
        vec![4, 4],                                     // 4x4 array
        vec![2, 2],                                     // 2x2 chunks
        data_type::uint8().to_optional().to_optional(), // Optional optional uint8 => Option<Option<u8>>
        FillValue::new_optional_null().into_optional(), // Fill value => Some(None)
    )
    .dimension_names(["y", "x"].into())
    .attributes(
        serde_json::json!({
            "description": r#"A 4x4 array of optional optional uint8 values with some missing data.
The fill value is null on the inner optional layer, i.e. Some(None).
N marks missing (`None`=`null`) values. SN marks `Some(None)`=`[null]` values:
  N  SN   2   3 
  N   5   N   7 
 SN  SN   N   N 
 SN  SN   N   N"#,
        })
        .as_object()
        .unwrap()
        .clone(),
    )
    .build(store.clone(), "/array")?;
    array.store_metadata_opt(
        &zarrs::array::ArrayMetadataOptions::default().with_include_zarrs_metadata(false),
    )?;

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

    // Create some data with missing values
    let data = ndarray::array![
        [None, Some(None), Some(Some(2u8)), Some(Some(3u8))],
        [None, Some(Some(5u8)), None, Some(Some(7u8))],
        [Some(None), Some(None), None, None],
        [Some(None), Some(None), None, None],
    ]
    .into_dyn();

    // Write the data
    array.store_array_subset(&array.subset_all(), data.clone())?;
    println!("Data written to array.");

    // Read back the data
    let data_read: ArrayD<Option<Option<u8>>> = array.retrieve_array_subset(&array.subset_all())?;

    // Verify data integrity
    assert_eq!(data, data_read);

    // Display the data in a grid format
    println!(
        "Data grid. N marks missing (`None`=`null`) values. SN marks `Some(None)`=`[null]` values"
    );
    println!("    0   1   2   3");
    for y in 0..4 {
        print!("{} ", y);
        for x in 0..4 {
            match data_read[[y, x]] {
                Some(Some(value)) => print!("{:3} ", value),
                Some(None) => print!(" SN "),
                None => print!("  N "),
            }
        }
        println!();
    }
    Ok(())
}

examples/data_type_optional.rs (line 48)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Create an in-memory store
    // let store = Arc::new(zarrs::filesystem::FilesystemStore::new(
    //     "zarrs/tests/data/v3/array_optional.zarr",
    // )?);
    let store = Arc::new(zarrs::storage::store::MemoryStore::new());

    // Build the codec chains for the optional codec
    let array = ArrayBuilder::new(
        vec![4, 4],                       // 4x4 array
        vec![2, 2],                       // 2x2 chunks
        data_type::uint8().to_optional(), // Optional uint8
        FillValue::new_optional_null(),   // Null fill value: [0]
    )
    .dimension_names(["y", "x"].into())
    .attributes(
        serde_json::json!({
            "description": r#"A 4x4 array of optional uint8 values with some missing data.
N marks missing (`None`=`null`) values:
 0  N  2  3 
 N  5  N  7 
 8  9  N  N 
12  N  N  N"#,
        })
        .as_object()
        .unwrap()
        .clone(),
    )
    .build(store.clone(), "/array")?;
    array.store_metadata_opt(
        &zarrs::array::ArrayMetadataOptions::default().with_include_zarrs_metadata(false),
    )?;

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

    // Create some data with missing values
    let data = ndarray::array![
        [Some(0u8), None, Some(2u8), Some(3u8)],
        [None, Some(5u8), None, Some(7u8)],
        [Some(8u8), Some(9u8), None, None],
        [Some(12u8), None, None, None],
    ]
    .into_dyn();

    // Write the data
    array.store_array_subset(&array.subset_all(), data.clone())?;

    // Read back the data
    let data_read: ArrayD<Option<u8>> = array.retrieve_array_subset(&array.subset_all())?;

    // Verify data integrity
    assert_eq!(data, data_read);

    // Display the data in a grid format
    println!("Data grid, N marks missing (`None`=`null`) values");
    println!("   0  1  2  3");
    for y in 0..4 {
        print!("{} ", y);
        for x in 0..4 {
            match data_read[[y, x]] {
                Some(value) => print!("{:2} ", value),
                None => print!(" N "),
            }
        }
        println!();
    }

    // Print the raw bytes in all chunks
    println!("Raw bytes in all chunks:");
    let chunk_grid_shape = array.chunk_grid_shape();
    for chunk_y in 0..chunk_grid_shape[0] {
        for chunk_x in 0..chunk_grid_shape[1] {
            let chunk_indices = vec![chunk_y, chunk_x];
            let chunk_key = array.chunk_key(&chunk_indices);
            println!("  Chunk [{}, {}] (key: {}):", chunk_y, chunk_x, chunk_key);

            if let Some(chunk_bytes) = store.get(&chunk_key)? {
                println!("    Size: {} bytes", chunk_bytes.len());

                if chunk_bytes.len() >= 16 {
                    // Parse first 8 bytes as mask size (little-endian u64)
                    let mask_size = u64::from_le_bytes([
                        chunk_bytes[0],
                        chunk_bytes[1],
                        chunk_bytes[2],
                        chunk_bytes[3],
                        chunk_bytes[4],
                        chunk_bytes[5],
                        chunk_bytes[6],
                        chunk_bytes[7],
                    ]) as usize;

                    // Parse second 8 bytes as data size (little-endian u64)
                    let data_size = u64::from_le_bytes([
                        chunk_bytes[8],
                        chunk_bytes[9],
                        chunk_bytes[10],
                        chunk_bytes[11],
                        chunk_bytes[12],
                        chunk_bytes[13],
                        chunk_bytes[14],
                        chunk_bytes[15],
                    ]) as usize;

                    // Display mask size header with raw bytes
                    print!("    Mask size: 0b");
                    for byte in &chunk_bytes[0..8] {
                        print!("{:08b}", byte);
                    }
                    println!(" -> {} bytes", mask_size);

                    // Display data size header with raw bytes
                    print!("    Data size: 0b");
                    for byte in &chunk_bytes[8..16] {
                        print!("{:08b}", byte);
                    }
                    println!(" -> {} bytes", data_size);

                    // Show mask and data sections separately
                    if chunk_bytes.len() >= 16 + mask_size + data_size {
                        let mask_start = 16;
                        let data_start = 16 + mask_size;

                        // Show mask as binary
                        if mask_size > 0 {
                            println!("    Mask (binary):");
                            print!("      ");
                            for byte in &chunk_bytes[mask_start..mask_start + mask_size] {
                                print!("0b{:08b} ", byte);
                            }
                            println!();
                        }

                        // Show data as binary
                        if data_size > 0 {
                            println!("    Data (binary):");
                            print!("      ");
                            for byte in &chunk_bytes[data_start..data_start + data_size] {
                                print!("0b{:08b} ", byte);
                            }
                            println!();
                        }
                    }
                } else {
                    panic!("    Chunk too small to parse headers");
                }
            } else {
                println!("    Chunk missing (fill value chunk)");
            }
        }
    }
    Ok(())
}

pub fn set_include_zarrs_metadata( &mut self, include_zarrs_metadata: bool, ) -> &mut Self

Set the include zarrs metadata configuration.

pub fn convert_aliased_extension_names(&self) -> bool

Return the convert aliased extension names configuration

pub fn with_convert_aliased_extension_names( self, convert_aliased_extension_names: bool, ) -> Self

Set the convert aliased extension names configuration.

pub fn set_convert_aliased_extension_names( &mut self, convert_aliased_extension_names: bool, ) -> &mut Self

Set the convert aliased extension names configuration.

Trait Implementations

impl Clone for ArrayMetadataOptions

fn clone(&self) -> ArrayMetadataOptions

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ArrayMetadataOptions

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

Formats the value using the given formatter.

impl Default for ArrayMetadataOptions

fn default() -> Self

Returns the “default value” for a type.

impl Copy for ArrayMetadataOptions