Struct hidefix::idx::Dataset

pub struct Dataset<'a, const D: usize> {
    pub dtype: Datatype,
    pub dsize: usize,
    pub order: ByteOrder,
    pub chunks: Cow<'a, [Chunk<D>]>,
    pub shape: [u64; D],
    pub chunk_shape: [u64; D],
    pub scaled_dim_sz: [u64; D],
    pub dim_sz: [u64; D],
    pub chunk_dim_sz: [u64; D],
    pub shuffle: bool,
    pub gzip: Option<u8>,
    // some fields omitted
}

A HDF5 dataset (a single variable).

Note to reader implementations: The official HDF5 library uses a 1MB dataset cache by default.

Fields

dtype: Datatype

dsize: usize

order: ByteOrder

chunks: Cow<'a, [Chunk<D>]>

shape: [u64; D]

chunk_shape: [u64; D]

scaled_dim_sz: [u64; D]

dim_sz: [u64; D]

chunk_dim_sz: [u64; D]

shuffle: bool

gzip: Option<u8>

Implementations

impl<const D: usize> Dataset<'_, D>

pub fn index(ds: &Dataset) -> Result<Dataset<'static, D>, Error>

pub fn new<'a, C>(
    dtype: Datatype,
    order: ByteOrder,
    shape: [u64; D],
    chunks: C,
    chunk_shape: [u64; D],
    shuffle: bool,
    gzip: Option<u8>
) -> Result<Dataset<'a, D>, Error> where
    C: Into<Cow<'a, [Chunk<D>]>>, 

#[must_use]pub fn size(&self) -> usize

Number of elements in dataset.

pub fn is_scalar(&self) -> bool

Dataset contains a single scalar value.

pub fn chunk_slices(
    &self,
    indices: Option<&[u64; D]>,
    counts: Option<&[u64; D]>
) -> impl Iterator<Item = (&Chunk<D>, u64, u64)>

Returns an iterator over chunk, offset and size which if joined will make up the specified slice through the variable.

pub fn chunk_at_coord(&self, indices: &[u64]) -> &Chunk<D>

Trait Implementations

impl<'a, const D: usize> Debug for Dataset<'a, D>

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

Formats the value using the given formatter.

impl<'de: 'a, 'a, const D: usize> Deserialize<'de> for Dataset<'a, D>

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error> where
    __D: Deserializer<'de>, 

Deserialize this value from the given Serde deserializer.

impl<'a, const D: usize> Serialize for Dataset<'a, D>

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error> where
    __S: Serializer, 

Serialize this value into the given Serde serializer.