Struct DataType 

pub struct DataType(/* private fields */);

A data type implementing DataTypeTraits.

Implementations

impl DataType

pub fn new<T>(data_type: T) -> DataType

where T: DataTypeTraits + 'static,

Create a data type.

pub fn from_metadata<'a>( metadata: impl Into<DataTypeMetadata<'a>>, ) -> Result<DataType, PluginCreateError>

Create a data type from metadata.

Errors

Returns PluginCreateError if the metadata is invalid or not associated with a registered codec plugin.

pub fn is<T>(&self) -> bool

where T: 'static,

Returns true if this data type is of type T.

Examples found in repository

examples/custom_data_type_fixed_size.rs (line 107)

    fn validate_data_type(data_type: &DataType) -> Result<(), ElementError> {
        data_type
            .is::<CustomDataTypeFixedSize>()
            .then_some(())
            .ok_or(ElementError::IncompatibleElementType)
    }

examples/custom_data_type_float8_e3m4.rs (line 160)

    fn validate_data_type(data_type: &DataType) -> Result<(), ElementError> {
        data_type
            .is::<CustomDataTypeFloat8e3m4>()
            .then_some(())
            .ok_or(ElementError::IncompatibleElementType)
    }

examples/custom_data_type_variable_size.rs (line 33)

    fn validate_data_type(data_type: &DataType) -> Result<(), ElementError> {
        data_type
            .is::<CustomDataTypeVariableSize>()
            .then_some(())
            .ok_or(ElementError::IncompatibleElementType)
    }

examples/custom_data_type_uint4.rs (line 152)

    fn validate_data_type(data_type: &DataType) -> Result<(), ElementError> {
        // Check if the data type matches our custom data type
        data_type
            .is::<CustomDataTypeUInt4>()
            .then_some(())
            .ok_or(ElementError::IncompatibleElementType)
    }

examples/custom_data_type_uint12.rs (line 150)

    fn validate_data_type(data_type: &DataType) -> Result<(), ElementError> {
        // Check if the data type matches our custom data type
        data_type
            .is::<CustomDataTypeUInt12>()
            .then_some(())
            .ok_or(ElementError::IncompatibleElementType)
    }

pub fn downcast_ref<T>(&self) -> Option<&T>

where T: 'static,

Downcast this data type to type T.

pub fn fixed_size(&self) -> Option<usize>

Returns the size in bytes of a fixed-size data type, otherwise returns None.

pub fn is_fixed(&self) -> bool

Returns true if the data type has a fixed size.

pub fn is_variable(&self) -> bool

Returns true if the data type has a variable size.

pub fn is_optional(&self) -> bool

Returns true if this is an optional data type.

pub fn as_optional(&self) -> Option<&OptionalDataType>

Returns the optional type wrapper if this is an optional data type.

pub fn optional_inner(&self) -> Option<&DataType>

For optional types: returns the inner data type.

Returns None if this is not an optional type.

pub fn to_optional(&self) -> DataType

Wrap this data type in an optional type.

Examples found in repository

examples/data_type_optional_nested.rs (line 22)

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 29)

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(())
}

Trait Implementations

impl BitroundDataTypeExt for DataType

fn codec_bitround( &self, ) -> Result<&dyn BitroundDataTypeTraits, DataTypeCodecError>

Get bitround codec support for this data type.

impl BytesDataTypeExt for DataType

fn codec_bytes(&self) -> Result<&dyn BytesDataTypeTraits, DataTypeCodecError>

Get bytes codec support for this data type.

impl Clone for DataType

fn clone(&self) -> DataType

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for DataType

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

Formats the value using the given formatter.

impl Deref for DataType

type Target = Arc<dyn DataTypeTraits>

The resulting type after dereferencing.

fn deref(&self) -> &<DataType as Deref>::Target

Dereferences the value.

impl Display for DataType

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

Formats the value using the given formatter.

impl ExtensionName for DataType

fn name(&self, version: ZarrVersion) -> Option<Cow<'static, str>>

Get the name for this extension instance for the given Zarr version.

fn name_v3(&self) -> Option<Cow<'static, str>>

Get the name for this extension instance for Zarr V3.

fn name_v2(&self) -> Option<Cow<'static, str>>

Get the name for this extension instance for Zarr V2.

impl FixedScaleOffsetDataTypeExt for DataType

fn codec_fixedscaleoffset( &self, ) -> Result<&dyn FixedScaleOffsetDataTypeTraits, DataTypeCodecError>

Get fixedscaleoffset codec support for this data type.

impl<T> From<Arc<T>> for DataType

where T: DataTypeTraits + 'static,

fn from(data_type: Arc<T>) -> DataType

Converts to this type from the input type.

impl From<Arc<dyn DataTypeTraits>> for DataType

fn from(value: Arc<dyn DataTypeTraits>) -> DataType

Converts to this type from the input type.

impl From<DataType> for ArrayBuilderDataType

fn from(value: DataType) -> Self

Converts to this type from the input type.

impl PackBitsDataTypeExt for DataType

fn codec_packbits( &self, ) -> Result<&dyn PackBitsDataTypeTraits, DataTypeCodecError>

Get packbits codec support for this data type.

impl PartialEq for DataType

fn eq(&self, other: &DataType) -> 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 PcodecDataTypeExt for DataType

fn codec_pcodec(&self) -> Result<&dyn PcodecDataTypeTraits, DataTypeCodecError>

Get pcodec codec support for this data type.

impl ZfpDataTypeExt for DataType

fn codec_zfp(&self) -> Result<&dyn ZfpDataTypeTraits, DataTypeCodecError>

Get zfp codec support for this data type.

impl Eq for DataType