rust-hdf5 0.7.0

//! Pure Rust HDF5 library with full read/write support.
//!
//! This crate provides a high-level API for creating and reading HDF5 files
//! without any C dependencies. It supports contiguous and chunked datasets,
//! deflate compression (with optional shuffle), SWMR streaming, and hyperslab
//! (slice) I/O.
//!
//! # Quick start
//!
//! ## Writing a dataset
//!
//! ```no_run
//! use rust_hdf5::H5File;
//!
//! let file = H5File::create("output.h5").unwrap();
//! let ds = file.new_dataset::<f64>()
//!     .shape(&[100, 200])
//!     .create("matrix")
//!     .unwrap();
//! let data: Vec<f64> = (0..20_000).map(|i| i as f64).collect();
//! ds.write_raw(&data).unwrap();
//! file.close().unwrap();
//! ```
//!
//! ## Reading a dataset
//!
//! ```no_run
//! use rust_hdf5::H5File;
//!
//! let file = H5File::open("output.h5").unwrap();
//! let ds = file.dataset("matrix").unwrap();
//! let data = ds.read_raw::<f64>().unwrap();
//! assert_eq!(data.len(), 20_000);
//! ```
//!
//! ## Chunked + compressed streaming
//!
//! ```no_run
//! use rust_hdf5::H5File;
//!
//! let file = H5File::create("stream.h5").unwrap();
//! let ds = file.new_dataset::<f32>()
//!     .shape(&[0usize, 64])
//!     .chunk(&[1, 64])
//!     .max_shape(&[None, Some(64)])
//!     .deflate(6)
//!     .create("sensor")
//!     .unwrap();
//!
//! for frame in 0..1000u64 {
//!     let vals: Vec<f32> = (0..64).map(|i| (frame * 64 + i) as f32).collect();
//!     let raw: Vec<u8> = vals.iter().flat_map(|v| v.to_le_bytes()).collect();
//!     ds.write_chunk(frame as usize, &raw).unwrap();
//! }
//! ds.extend(&[1000, 64]).unwrap();
//! file.close().unwrap();
//! ```
//!
//! ## Hyperslab (slice) I/O
//!
//! ```no_run
//! use rust_hdf5::H5File;
//!
//! // Write a sub-region
//! let file = H5File::create("slice.h5").unwrap();
//! let ds = file.new_dataset::<i32>()
//!     .shape(&[10usize, 10])
//!     .create("grid")
//!     .unwrap();
//! ds.write_raw(&[0i32; 100]).unwrap();
//! ds.write_slice(&[2, 3], &[3, 4], &[1i32, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]).unwrap();
//! file.close().unwrap();
//!
//! // Read a sub-region
//! let file = H5File::open("slice.h5").unwrap();
//! let ds = file.dataset("grid").unwrap();
//! let region = ds.read_slice::<i32>(&[2, 3], &[3, 4]).unwrap();
//! assert_eq!(region.len(), 12);
//! ```

// The crate reads and writes numeric values by transmuting host-native
// bytes (`H5Type` raw read/write paths) while always declaring a
// little-endian datatype on disk. That is correct only on a little-endian
// host; fail the build loudly on big-endian rather than corrupt data.
#[cfg(target_endian = "big")]
compile_error!("rust-hdf5 currently supports little-endian hosts only");

pub mod format;
pub(crate) mod io;

/// Private rayon thread pool (half the cores by default) for all internal
/// parallelism; only present under the `parallel` feature.
#[cfg(feature = "parallel")]
pub(crate) mod parallel;

/// The run-time SIMD level the filter kernels dispatch on; only present
/// under the `simd` feature.
#[cfg(feature = "simd")]
pub(crate) mod simd;

pub mod attribute;
pub mod dataset;
pub mod error;
pub mod file;
pub mod group;
/// Zero-copy views of a dataset's stored bytes. Requires the `mmap` feature.
#[cfg(feature = "mmap")]
pub mod mapped;
pub mod named_datatype;
pub mod swmr;
pub mod types;

pub use attribute::{AttrShape, H5Attribute};
pub use dataset::{
    AllocTime, ChunkIndex, DatasetAccess, FillTime, FillValue, H5Dataset, ReadNumeric,
    StorageLayout, VirtualView,
};
pub use error::{Hdf5Error, Result};
pub use file::{H5File, H5FileOptions};
pub use format::creation_order::CreationOrder;
pub use format::messages::datatype::{ByteOrder, DatatypeMessage};
pub use format::messages::filter::{Filter, FilterPipeline};
pub use format::messages::superblock_ext::{
    BtreeKMessage, DriverInfoMessage, FileSpaceInfoMessage, FileSpaceStrategy,
    SharedMessageTableMessage,
};
pub use format::messages::virtual_mapping::VirtualMapping;
pub use format::reference::Reference;
pub use format::selection::{
    Hyperslab, HyperslabBlock, PointSelection, RegularHyperslab, Selection,
};
pub use format::storage_kind::{AttributeStorage, LinkStorage};
pub use format::LibverBound;
pub use group::H5Group;
pub use io::locking::{FileLocking, LockMode};
pub use io::reader::ExternalFileSegment;
pub use io::reader::LinkClass;
pub use io::reader::SuperblockExtension;
pub use io::writer::{MAX_COMPACT_DATA, MIN_USERBLOCK};
#[cfg(feature = "mmap")]
pub use mapped::{MappedView, ViewRefusal};
pub use named_datatype::H5NamedDatatype;
pub use types::{Complex32, Complex64, CompoundType, H5Type, HBool, VarLenUnicode};