@nirs4all/formats-wasm 0.2.12 → 0.2.13

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (88) hide show
  1. package/THIRD_PARTY_NOTICES.md +49 -0
  2. package/nirs4all_formats_wasm_bg.wasm +0 -0
  3. package/package.json +4 -2
  4. package/reader-backports/hdf5-reader/Cargo.toml +119 -0
  5. package/reader-backports/hdf5-reader/LICENSE-APACHE +164 -0
  6. package/reader-backports/hdf5-reader/LICENSE-MIT +21 -0
  7. package/reader-backports/hdf5-reader/PROVENANCE.json +80 -0
  8. package/reader-backports/hdf5-reader/README.md +308 -0
  9. package/reader-backports/hdf5-reader/UPSTREAM-Cargo.toml +44 -0
  10. package/reader-backports/hdf5-reader/UPSTREAM-VCS.json +6 -0
  11. package/reader-backports/hdf5-reader/src/attribute_api.rs +847 -0
  12. package/reader-backports/hdf5-reader/src/btree_v1.rs +726 -0
  13. package/reader-backports/hdf5-reader/src/btree_v2.rs +2068 -0
  14. package/reader-backports/hdf5-reader/src/cache.rs +354 -0
  15. package/reader-backports/hdf5-reader/src/checksum.rs +56 -0
  16. package/reader-backports/hdf5-reader/src/chunk_index.rs +423 -0
  17. package/reader-backports/hdf5-reader/src/dataset.rs +4733 -0
  18. package/reader-backports/hdf5-reader/src/datatype_api.rs +497 -0
  19. package/reader-backports/hdf5-reader/src/error.rs +167 -0
  20. package/reader-backports/hdf5-reader/src/extensible_array.rs +1886 -0
  21. package/reader-backports/hdf5-reader/src/filters/deflate.rs +93 -0
  22. package/reader-backports/hdf5-reader/src/filters/fletcher32.rs +52 -0
  23. package/reader-backports/hdf5-reader/src/filters/lz4.rs +178 -0
  24. package/reader-backports/hdf5-reader/src/filters/mod.rs +326 -0
  25. package/reader-backports/hdf5-reader/src/filters/nbit.rs +586 -0
  26. package/reader-backports/hdf5-reader/src/filters/scaleoffset.rs +827 -0
  27. package/reader-backports/hdf5-reader/src/filters/shuffle.rs +99 -0
  28. package/reader-backports/hdf5-reader/src/fixed_array.rs +763 -0
  29. package/reader-backports/hdf5-reader/src/fractal_heap.rs +2029 -0
  30. package/reader-backports/hdf5-reader/src/global_heap.rs +284 -0
  31. package/reader-backports/hdf5-reader/src/group.rs +795 -0
  32. package/reader-backports/hdf5-reader/src/io.rs +413 -0
  33. package/reader-backports/hdf5-reader/src/lib.rs +916 -0
  34. package/reader-backports/hdf5-reader/src/local_heap.rs +261 -0
  35. package/reader-backports/hdf5-reader/src/messages/attribute.rs +304 -0
  36. package/reader-backports/hdf5-reader/src/messages/attribute_info.rs +96 -0
  37. package/reader-backports/hdf5-reader/src/messages/btree_k.rs +36 -0
  38. package/reader-backports/hdf5-reader/src/messages/continuation.rs +46 -0
  39. package/reader-backports/hdf5-reader/src/messages/dataspace.rs +259 -0
  40. package/reader-backports/hdf5-reader/src/messages/datatype.rs +938 -0
  41. package/reader-backports/hdf5-reader/src/messages/external_files.rs +50 -0
  42. package/reader-backports/hdf5-reader/src/messages/fill_value.rs +233 -0
  43. package/reader-backports/hdf5-reader/src/messages/filter_pipeline.rs +147 -0
  44. package/reader-backports/hdf5-reader/src/messages/group_info.rs +103 -0
  45. package/reader-backports/hdf5-reader/src/messages/layout.rs +476 -0
  46. package/reader-backports/hdf5-reader/src/messages/link.rs +170 -0
  47. package/reader-backports/hdf5-reader/src/messages/link_info.rs +127 -0
  48. package/reader-backports/hdf5-reader/src/messages/mod.rs +374 -0
  49. package/reader-backports/hdf5-reader/src/messages/modification_time.rs +83 -0
  50. package/reader-backports/hdf5-reader/src/messages/shared.rs +164 -0
  51. package/reader-backports/hdf5-reader/src/messages/shared_table.rs +67 -0
  52. package/reader-backports/hdf5-reader/src/messages/symbol_table_msg.rs +51 -0
  53. package/reader-backports/hdf5-reader/src/object_header.rs +1749 -0
  54. package/reader-backports/hdf5-reader/src/reference.rs +90 -0
  55. package/reader-backports/hdf5-reader/src/shared_message_table.rs +425 -0
  56. package/reader-backports/hdf5-reader/src/storage.rs +538 -0
  57. package/reader-backports/hdf5-reader/src/superblock.rs +285 -0
  58. package/reader-backports/hdf5-reader/src/symbol_table.rs +277 -0
  59. package/reader-backports/netcdf-reader/Cargo.toml +141 -0
  60. package/reader-backports/netcdf-reader/LICENSE-APACHE +164 -0
  61. package/reader-backports/netcdf-reader/LICENSE-MIT +21 -0
  62. package/reader-backports/netcdf-reader/PROVENANCE.json +55 -0
  63. package/reader-backports/netcdf-reader/README.md +308 -0
  64. package/reader-backports/netcdf-reader/UPSTREAM-Cargo.toml +48 -0
  65. package/reader-backports/netcdf-reader/UPSTREAM-VCS.json +6 -0
  66. package/reader-backports/netcdf-reader/src/cf/axes.rs +419 -0
  67. package/reader-backports/netcdf-reader/src/cf/bounds.rs +108 -0
  68. package/reader-backports/netcdf-reader/src/cf/crs.rs +269 -0
  69. package/reader-backports/netcdf-reader/src/cf/mod.rs +30 -0
  70. package/reader-backports/netcdf-reader/src/cf/time.rs +1122 -0
  71. package/reader-backports/netcdf-reader/src/classic/data.rs +1465 -0
  72. package/reader-backports/netcdf-reader/src/classic/header.rs +1097 -0
  73. package/reader-backports/netcdf-reader/src/classic/mod.rs +240 -0
  74. package/reader-backports/netcdf-reader/src/classic/storage.rs +211 -0
  75. package/reader-backports/netcdf-reader/src/classic/types.rs +93 -0
  76. package/reader-backports/netcdf-reader/src/classic/variable.rs +1162 -0
  77. package/reader-backports/netcdf-reader/src/error.rs +59 -0
  78. package/reader-backports/netcdf-reader/src/lib.rs +1531 -0
  79. package/reader-backports/netcdf-reader/src/masked.rs +173 -0
  80. package/reader-backports/netcdf-reader/src/nc4/attributes.rs +203 -0
  81. package/reader-backports/netcdf-reader/src/nc4/dimensions.rs +139 -0
  82. package/reader-backports/netcdf-reader/src/nc4/groups.rs +308 -0
  83. package/reader-backports/netcdf-reader/src/nc4/mod.rs +572 -0
  84. package/reader-backports/netcdf-reader/src/nc4/types.rs +309 -0
  85. package/reader-backports/netcdf-reader/src/nc4/variables.rs +420 -0
  86. package/reader-backports/netcdf-reader/src/types.rs +18 -0
  87. package/reader-backports/netcdf-reader/src/unpack.rs +113 -0
  88. package/reader-backports/netcdf-reader/src/user_defined.rs +569 -0
@@ -0,0 +1,497 @@
1
+ use crate::error::{ByteOrder, Error, Result};
2
+ use crate::messages::datatype::Datatype;
3
+
4
+ // Re-export types from the datatype message module so users don't need to
5
+ // reach into messages::datatype.
6
+ pub use crate::messages::datatype::{
7
+ CompoundField, EnumMember, ReferenceType, StringEncoding, StringPadding, StringSize, VarLenKind,
8
+ };
9
+
10
+ /// Trait for types that can be read from HDF5 datasets.
11
+ ///
12
+ /// Implemented for primitive numeric types. Users can implement this
13
+ /// for custom types (e.g., compound types).
14
+ pub trait H5Type: Sized + Send + Clone {
15
+ /// The HDF5 datatype that this Rust type corresponds to.
16
+ fn hdf5_type() -> Datatype;
17
+
18
+ /// Decode a single value from raw bytes with the given datatype.
19
+ fn from_bytes(bytes: &[u8], dtype: &Datatype) -> Result<Self>;
20
+
21
+ /// Size of a single element in bytes.
22
+ fn element_size(dtype: &Datatype) -> usize;
23
+
24
+ /// Decode many values at once when the datatype has an efficient bulk path.
25
+ ///
26
+ /// Returning `None` falls back to per-element decoding.
27
+ fn decode_vec(_raw: &[u8], _dtype: &Datatype, _count: usize) -> Option<Result<Vec<Self>>> {
28
+ None
29
+ }
30
+
31
+ /// Whether raw bytes for this datatype can be copied directly into a `Vec<Self>`
32
+ /// without any further decoding or byte swapping.
33
+ fn native_copy_compatible(_dtype: &Datatype) -> bool {
34
+ false
35
+ }
36
+ }
37
+
38
+ /// Read a numeric value from bytes, handling byte-order conversion.
39
+ fn read_numeric<const N: usize>(bytes: &[u8], byte_order: ByteOrder) -> Result<[u8; N]> {
40
+ if bytes.len() < N {
41
+ return Err(Error::InvalidData(format!(
42
+ "expected {} bytes, got {}",
43
+ N,
44
+ bytes.len()
45
+ )));
46
+ }
47
+ let mut arr = [0u8; N];
48
+ arr.copy_from_slice(&bytes[..N]);
49
+
50
+ // Swap bytes if the source endianness doesn't match native
51
+ #[cfg(target_endian = "little")]
52
+ if byte_order == ByteOrder::BigEndian {
53
+ arr.reverse();
54
+ }
55
+ #[cfg(target_endian = "big")]
56
+ if byte_order == ByteOrder::LittleEndian {
57
+ arr.reverse();
58
+ }
59
+
60
+ Ok(arr)
61
+ }
62
+
63
+ fn byte_order_is_native(byte_order: ByteOrder) -> bool {
64
+ #[cfg(target_endian = "little")]
65
+ {
66
+ byte_order == ByteOrder::LittleEndian
67
+ }
68
+ #[cfg(target_endian = "big")]
69
+ {
70
+ byte_order == ByteOrder::BigEndian
71
+ }
72
+ }
73
+
74
+ macro_rules! impl_h5type_int {
75
+ ($ty:ty, $size:literal, $signed:literal) => {
76
+ impl H5Type for $ty {
77
+ fn hdf5_type() -> Datatype {
78
+ Datatype::FixedPoint {
79
+ size: $size,
80
+ signed: $signed,
81
+ byte_order: if cfg!(target_endian = "little") {
82
+ ByteOrder::LittleEndian
83
+ } else {
84
+ ByteOrder::BigEndian
85
+ },
86
+ }
87
+ }
88
+
89
+ fn from_bytes(bytes: &[u8], dtype: &Datatype) -> Result<Self> {
90
+ match dtype {
91
+ Datatype::FixedPoint {
92
+ size,
93
+ signed,
94
+ byte_order,
95
+ } => {
96
+ if *size as usize != std::mem::size_of::<$ty>() || *signed != $signed {
97
+ return Err(Error::TypeMismatch {
98
+ expected: stringify!($ty).into(),
99
+ actual: format!("FixedPoint(size={}, signed={})", size, signed),
100
+ });
101
+ }
102
+ let arr = read_numeric::<$size>(bytes, *byte_order)?;
103
+ Ok(<$ty>::from_ne_bytes(arr))
104
+ }
105
+ _ => Err(Error::TypeMismatch {
106
+ expected: stringify!($ty).into(),
107
+ actual: format!("{:?}", dtype),
108
+ }),
109
+ }
110
+ }
111
+
112
+ fn element_size(_dtype: &Datatype) -> usize {
113
+ $size
114
+ }
115
+
116
+ fn decode_vec(raw: &[u8], dtype: &Datatype, count: usize) -> Option<Result<Vec<Self>>> {
117
+ match dtype {
118
+ Datatype::FixedPoint {
119
+ size,
120
+ signed,
121
+ byte_order,
122
+ } if *size as usize == $size && *signed == $signed => {
123
+ let total_bytes = count.checked_mul($size)?;
124
+ if raw.len() < total_bytes {
125
+ return None;
126
+ }
127
+
128
+ let bytes = &raw[..total_bytes];
129
+ if byte_order_is_native(*byte_order) {
130
+ let mut values = Vec::<$ty>::with_capacity(count);
131
+ // SAFETY: `values` has capacity for `count`
132
+ // elements, `bytes` contains exactly
133
+ // `count * size_of::<$ty>()` bytes, and integer
134
+ // types admit every bit pattern.
135
+ unsafe {
136
+ std::ptr::copy_nonoverlapping(
137
+ bytes.as_ptr(),
138
+ values.as_mut_ptr() as *mut u8,
139
+ total_bytes,
140
+ );
141
+ values.set_len(count);
142
+ }
143
+ Some(Ok(values))
144
+ } else {
145
+ Some(Ok(bytes
146
+ .chunks_exact($size)
147
+ .map(|chunk| {
148
+ let mut arr = [0u8; $size];
149
+ arr.copy_from_slice(chunk);
150
+ arr.reverse();
151
+ <$ty>::from_ne_bytes(arr)
152
+ })
153
+ .collect()))
154
+ }
155
+ }
156
+ _ => None,
157
+ }
158
+ }
159
+
160
+ fn native_copy_compatible(dtype: &Datatype) -> bool {
161
+ matches!(
162
+ dtype,
163
+ Datatype::FixedPoint {
164
+ size,
165
+ signed,
166
+ byte_order,
167
+ } if *size as usize == $size
168
+ && *signed == $signed
169
+ && byte_order_is_native(*byte_order)
170
+ )
171
+ }
172
+ }
173
+ };
174
+ }
175
+
176
+ impl_h5type_int!(i8, 1, true);
177
+ impl_h5type_int!(u8, 1, false);
178
+ impl_h5type_int!(i16, 2, true);
179
+ impl_h5type_int!(u16, 2, false);
180
+ impl_h5type_int!(i32, 4, true);
181
+ impl_h5type_int!(u32, 4, false);
182
+ impl_h5type_int!(i64, 8, true);
183
+ impl_h5type_int!(u64, 8, false);
184
+
185
+ impl H5Type for f32 {
186
+ fn hdf5_type() -> Datatype {
187
+ Datatype::FloatingPoint {
188
+ size: 4,
189
+ byte_order: if cfg!(target_endian = "little") {
190
+ ByteOrder::LittleEndian
191
+ } else {
192
+ ByteOrder::BigEndian
193
+ },
194
+ }
195
+ }
196
+
197
+ fn from_bytes(bytes: &[u8], dtype: &Datatype) -> Result<Self> {
198
+ match dtype {
199
+ Datatype::FloatingPoint { size, byte_order } => {
200
+ if *size != 4 {
201
+ return Err(Error::TypeMismatch {
202
+ expected: "f32".into(),
203
+ actual: format!("FloatingPoint(size={})", size),
204
+ });
205
+ }
206
+ let arr = read_numeric::<4>(bytes, *byte_order)?;
207
+ Ok(f32::from_ne_bytes(arr))
208
+ }
209
+ _ => Err(Error::TypeMismatch {
210
+ expected: "f32".into(),
211
+ actual: format!("{:?}", dtype),
212
+ }),
213
+ }
214
+ }
215
+
216
+ fn element_size(_dtype: &Datatype) -> usize {
217
+ 4
218
+ }
219
+
220
+ fn decode_vec(raw: &[u8], dtype: &Datatype, count: usize) -> Option<Result<Vec<Self>>> {
221
+ match dtype {
222
+ Datatype::FloatingPoint { size, byte_order } if *size == 4 => {
223
+ let total_bytes = count.checked_mul(4)?;
224
+ if raw.len() < total_bytes {
225
+ return None;
226
+ }
227
+
228
+ let bytes = &raw[..total_bytes];
229
+ if byte_order_is_native(*byte_order) {
230
+ let mut values = Vec::<f32>::with_capacity(count);
231
+ // SAFETY: `values` has capacity for `count` elements,
232
+ // `bytes` contains exactly `count * size_of::<f32>()`
233
+ // bytes, and `f32` admits every bit pattern.
234
+ unsafe {
235
+ std::ptr::copy_nonoverlapping(
236
+ bytes.as_ptr(),
237
+ values.as_mut_ptr() as *mut u8,
238
+ total_bytes,
239
+ );
240
+ values.set_len(count);
241
+ }
242
+ Some(Ok(values))
243
+ } else {
244
+ Some(Ok(bytes
245
+ .chunks_exact(4)
246
+ .map(|chunk| {
247
+ let mut arr = [0u8; 4];
248
+ arr.copy_from_slice(chunk);
249
+ arr.reverse();
250
+ f32::from_ne_bytes(arr)
251
+ })
252
+ .collect()))
253
+ }
254
+ }
255
+ _ => None,
256
+ }
257
+ }
258
+
259
+ fn native_copy_compatible(dtype: &Datatype) -> bool {
260
+ matches!(
261
+ dtype,
262
+ Datatype::FloatingPoint { size, byte_order }
263
+ if *size == 4 && byte_order_is_native(*byte_order)
264
+ )
265
+ }
266
+ }
267
+
268
+ impl H5Type for f64 {
269
+ fn hdf5_type() -> Datatype {
270
+ Datatype::FloatingPoint {
271
+ size: 8,
272
+ byte_order: if cfg!(target_endian = "little") {
273
+ ByteOrder::LittleEndian
274
+ } else {
275
+ ByteOrder::BigEndian
276
+ },
277
+ }
278
+ }
279
+
280
+ fn from_bytes(bytes: &[u8], dtype: &Datatype) -> Result<Self> {
281
+ match dtype {
282
+ Datatype::FloatingPoint { size, byte_order } => {
283
+ if *size != 8 {
284
+ return Err(Error::TypeMismatch {
285
+ expected: "f64".into(),
286
+ actual: format!("FloatingPoint(size={})", size),
287
+ });
288
+ }
289
+ let arr = read_numeric::<8>(bytes, *byte_order)?;
290
+ Ok(f64::from_ne_bytes(arr))
291
+ }
292
+ _ => Err(Error::TypeMismatch {
293
+ expected: "f64".into(),
294
+ actual: format!("{:?}", dtype),
295
+ }),
296
+ }
297
+ }
298
+
299
+ fn element_size(_dtype: &Datatype) -> usize {
300
+ 8
301
+ }
302
+
303
+ fn decode_vec(raw: &[u8], dtype: &Datatype, count: usize) -> Option<Result<Vec<Self>>> {
304
+ match dtype {
305
+ Datatype::FloatingPoint { size, byte_order } if *size == 8 => {
306
+ let total_bytes = count.checked_mul(8)?;
307
+ if raw.len() < total_bytes {
308
+ return None;
309
+ }
310
+
311
+ let bytes = &raw[..total_bytes];
312
+ if byte_order_is_native(*byte_order) {
313
+ let mut values = Vec::<f64>::with_capacity(count);
314
+ // SAFETY: `values` has capacity for `count` elements,
315
+ // `bytes` contains exactly `count * size_of::<f64>()`
316
+ // bytes, and `f64` admits every bit pattern.
317
+ unsafe {
318
+ std::ptr::copy_nonoverlapping(
319
+ bytes.as_ptr(),
320
+ values.as_mut_ptr() as *mut u8,
321
+ total_bytes,
322
+ );
323
+ values.set_len(count);
324
+ }
325
+ Some(Ok(values))
326
+ } else {
327
+ Some(Ok(bytes
328
+ .chunks_exact(8)
329
+ .map(|chunk| {
330
+ let mut arr = [0u8; 8];
331
+ arr.copy_from_slice(chunk);
332
+ arr.reverse();
333
+ f64::from_ne_bytes(arr)
334
+ })
335
+ .collect()))
336
+ }
337
+ }
338
+ _ => None,
339
+ }
340
+ }
341
+
342
+ fn native_copy_compatible(dtype: &Datatype) -> bool {
343
+ matches!(
344
+ dtype,
345
+ Datatype::FloatingPoint { size, byte_order }
346
+ if *size == 8 && byte_order_is_native(*byte_order)
347
+ )
348
+ }
349
+ }
350
+
351
+ /// Get the element size from a datatype.
352
+ pub fn dtype_element_size(dtype: &Datatype) -> Result<usize> {
353
+ match dtype {
354
+ Datatype::FixedPoint { size, .. } => Ok(*size as usize),
355
+ Datatype::FloatingPoint { size, .. } => Ok(*size as usize),
356
+ Datatype::String {
357
+ size: StringSize::Fixed(n),
358
+ ..
359
+ } => Ok(*n as usize),
360
+ Datatype::String {
361
+ size: StringSize::Variable,
362
+ ..
363
+ } => Ok(16),
364
+ Datatype::Compound { size, .. } => Ok(*size as usize),
365
+ Datatype::Array { base, dims } => {
366
+ let base_size = dtype_element_size(base)?;
367
+ let count = dims.iter().try_fold(1usize, |acc, &dim| {
368
+ let dim = usize::try_from(dim).map_err(|_| {
369
+ Error::InvalidData(
370
+ "array datatype dimension exceeds platform usize capacity".to_string(),
371
+ )
372
+ })?;
373
+ acc.checked_mul(dim).ok_or_else(|| {
374
+ Error::InvalidData(
375
+ "array datatype element count exceeds platform usize capacity".to_string(),
376
+ )
377
+ })
378
+ })?;
379
+ base_size.checked_mul(count).ok_or_else(|| {
380
+ Error::InvalidData(
381
+ "array datatype byte size exceeds platform usize capacity".to_string(),
382
+ )
383
+ })
384
+ }
385
+ Datatype::Enum { base, .. } => dtype_element_size(base),
386
+ Datatype::VarLen { .. } => Ok(16),
387
+ Datatype::Opaque { size, .. } => Ok(*size as usize),
388
+ Datatype::Reference { size, .. } => Ok(*size as usize),
389
+ Datatype::Bitfield { size, .. } => Ok(*size as usize),
390
+ }
391
+ }
392
+
393
+ #[cfg(test)]
394
+ mod tests {
395
+ use super::*;
396
+
397
+ #[test]
398
+ fn f32_bulk_decode_native_endian() {
399
+ let dtype = <f32 as H5Type>::hdf5_type();
400
+ let raw = [0.5f32.to_ne_bytes(), 1.25f32.to_ne_bytes()].concat();
401
+ let values = <f32 as H5Type>::decode_vec(&raw, &dtype, 2)
402
+ .unwrap()
403
+ .unwrap();
404
+ assert_eq!(values, vec![0.5, 1.25]);
405
+ }
406
+
407
+ #[test]
408
+ fn u32_bulk_decode_big_endian() {
409
+ let dtype = Datatype::FixedPoint {
410
+ size: 4,
411
+ signed: false,
412
+ byte_order: ByteOrder::BigEndian,
413
+ };
414
+ let raw = [1u32.to_be_bytes(), 7u32.to_be_bytes()].concat();
415
+ let values = <u32 as H5Type>::decode_vec(&raw, &dtype, 2)
416
+ .unwrap()
417
+ .unwrap();
418
+ assert_eq!(values, vec![1, 7]);
419
+ }
420
+
421
+ #[test]
422
+ fn integer_from_bytes_rejects_signedness_mismatch() {
423
+ let dtype = Datatype::FixedPoint {
424
+ size: 2,
425
+ signed: false,
426
+ byte_order: ByteOrder::LittleEndian,
427
+ };
428
+
429
+ let err = <i16 as H5Type>::from_bytes(&u16::MAX.to_le_bytes(), &dtype).unwrap_err();
430
+ assert!(matches!(
431
+ err,
432
+ Error::TypeMismatch {
433
+ expected,
434
+ actual
435
+ } if expected == "i16" && actual.contains("signed=false")
436
+ ));
437
+ }
438
+
439
+ #[test]
440
+ fn integer_bulk_decode_rejects_signedness_mismatch() {
441
+ let unsigned_dtype = Datatype::FixedPoint {
442
+ size: 2,
443
+ signed: false,
444
+ byte_order: ByteOrder::LittleEndian,
445
+ };
446
+ let signed_dtype = Datatype::FixedPoint {
447
+ size: 2,
448
+ signed: true,
449
+ byte_order: ByteOrder::LittleEndian,
450
+ };
451
+
452
+ assert!(<i16 as H5Type>::decode_vec(&[0, 0], &unsigned_dtype, 1).is_none());
453
+ assert!(<u16 as H5Type>::decode_vec(&[0, 0], &signed_dtype, 1).is_none());
454
+ }
455
+
456
+ #[test]
457
+ fn integer_native_copy_compatible_rejects_signedness_mismatch() {
458
+ let unsigned_dtype = Datatype::FixedPoint {
459
+ size: 2,
460
+ signed: false,
461
+ byte_order: if cfg!(target_endian = "little") {
462
+ ByteOrder::LittleEndian
463
+ } else {
464
+ ByteOrder::BigEndian
465
+ },
466
+ };
467
+ let signed_dtype = Datatype::FixedPoint {
468
+ size: 2,
469
+ signed: true,
470
+ byte_order: if cfg!(target_endian = "little") {
471
+ ByteOrder::LittleEndian
472
+ } else {
473
+ ByteOrder::BigEndian
474
+ },
475
+ };
476
+
477
+ assert!(!<i16 as H5Type>::native_copy_compatible(&unsigned_dtype));
478
+ assert!(!<u16 as H5Type>::native_copy_compatible(&signed_dtype));
479
+ assert!(<u16 as H5Type>::native_copy_compatible(&unsigned_dtype));
480
+ assert!(<i16 as H5Type>::native_copy_compatible(&signed_dtype));
481
+ }
482
+
483
+ #[test]
484
+ fn dtype_element_size_rejects_array_overflow() {
485
+ let dtype = Datatype::Array {
486
+ base: Box::new(Datatype::FixedPoint {
487
+ size: 8,
488
+ signed: false,
489
+ byte_order: ByteOrder::LittleEndian,
490
+ }),
491
+ dims: vec![u64::MAX, 2],
492
+ };
493
+
494
+ let err = dtype_element_size(&dtype).unwrap_err();
495
+ assert!(err.to_string().contains("array datatype"));
496
+ }
497
+ }
@@ -0,0 +1,167 @@
1
+ /// Errors produced by the HDF5 reader.
2
+ #[derive(Debug, thiserror::Error)]
3
+ pub enum Error {
4
+ #[error("I/O error: {0}")]
5
+ Io(#[from] std::io::Error),
6
+
7
+ #[error("invalid HDF5 magic bytes")]
8
+ InvalidMagic,
9
+
10
+ #[error("unsupported superblock version {0}")]
11
+ UnsupportedSuperblockVersion(u8),
12
+
13
+ #[error("unsupported object header version {0}")]
14
+ UnsupportedObjectHeaderVersion(u8),
15
+
16
+ #[error("unsupported B-tree version {0}")]
17
+ UnsupportedBTreeVersion(u8),
18
+
19
+ #[error("unsupported symbol table node version {0}")]
20
+ UnsupportedSymbolTableNodeVersion(u8),
21
+
22
+ #[error("unsupported local heap version {0}")]
23
+ UnsupportedLocalHeapVersion(u8),
24
+
25
+ #[error("unsupported global heap version {0}")]
26
+ UnsupportedGlobalHeapVersion(u8),
27
+
28
+ #[error("unsupported fractal heap version {0}")]
29
+ UnsupportedFractalHeapVersion(u8),
30
+
31
+ #[error("unsupported dataspace version {0}")]
32
+ UnsupportedDataspaceVersion(u8),
33
+
34
+ #[error("unsupported datatype class {0}")]
35
+ UnsupportedDatatypeClass(u8),
36
+
37
+ #[error("unsupported layout class {0}")]
38
+ UnsupportedLayoutClass(u8),
39
+
40
+ #[error("unsupported layout version {0}")]
41
+ UnsupportedLayoutVersion(u8),
42
+
43
+ #[error("unsupported filter pipeline version {0}")]
44
+ UnsupportedFilterPipelineVersion(u8),
45
+
46
+ #[error("unsupported fill value version {0}")]
47
+ UnsupportedFillValueVersion(u8),
48
+
49
+ #[error("unsupported link message version {0}")]
50
+ UnsupportedLinkVersion(u8),
51
+
52
+ #[error("unsupported link type {0}")]
53
+ UnsupportedLinkType(u8),
54
+
55
+ #[error("unsupported attribute message version {0}")]
56
+ UnsupportedAttributeVersion(u8),
57
+
58
+ #[error("unsupported B-tree v2 record type {0}")]
59
+ UnsupportedBTreeV2RecordType(u8),
60
+
61
+ #[error("unsupported chunk indexing type {0}")]
62
+ UnsupportedChunkIndexType(u8),
63
+
64
+ #[error("unsupported size of offsets: {0}")]
65
+ UnsupportedOffsetSize(u8),
66
+
67
+ #[error("unsupported size of lengths: {0}")]
68
+ UnsupportedLengthSize(u8),
69
+
70
+ #[error("invalid B-tree signature")]
71
+ InvalidBTreeSignature,
72
+
73
+ #[error("invalid symbol table node signature")]
74
+ InvalidSymbolTableNodeSignature,
75
+
76
+ #[error("invalid local heap signature")]
77
+ InvalidLocalHeapSignature,
78
+
79
+ #[error("invalid global heap signature")]
80
+ InvalidGlobalHeapSignature,
81
+
82
+ #[error("invalid fractal heap signature")]
83
+ InvalidFractalHeapSignature,
84
+
85
+ #[error("invalid object header signature")]
86
+ InvalidObjectHeaderSignature,
87
+
88
+ #[error("invalid B-tree v2 signature: {context}")]
89
+ InvalidBTreeV2Signature { context: &'static str },
90
+
91
+ #[error("invalid fixed array signature: {context}")]
92
+ InvalidFixedArraySignature { context: &'static str },
93
+
94
+ #[error("invalid extensible array signature: {context}")]
95
+ InvalidExtensibleArraySignature { context: &'static str },
96
+
97
+ #[error("checksum mismatch: expected {expected:#010x}, got {actual:#010x}")]
98
+ ChecksumMismatch { expected: u32, actual: u32 },
99
+
100
+ #[error("unexpected end of data at offset {offset} (need {needed} bytes, have {available})")]
101
+ UnexpectedEof {
102
+ offset: u64,
103
+ needed: u64,
104
+ available: u64,
105
+ },
106
+
107
+ #[error("offset {0:#x} is out of bounds")]
108
+ OffsetOutOfBounds(u64),
109
+
110
+ #[error("group not found: {0}")]
111
+ GroupNotFound(String),
112
+
113
+ #[error("dataset not found: {0}")]
114
+ DatasetNotFound(String),
115
+
116
+ #[error("attribute not found: {0}")]
117
+ AttributeNotFound(String),
118
+
119
+ #[error("type mismatch: expected {expected}, got {actual}")]
120
+ TypeMismatch { expected: String, actual: String },
121
+
122
+ #[error("unsupported filter: {0}")]
123
+ UnsupportedFilter(String),
124
+
125
+ #[error("decompression error: {0}")]
126
+ DecompressionError(String),
127
+
128
+ #[error("filter pipeline error: {0}")]
129
+ FilterError(String),
130
+
131
+ #[error("invalid data: {0}")]
132
+ InvalidData(String),
133
+
134
+ #[error("slice out of bounds: dimension {dim}, index {index}, size {size}")]
135
+ SliceOutOfBounds { dim: usize, index: u64, size: u64 },
136
+
137
+ #[error("undefined address (0xFFFFFFFFFFFFFFFF)")]
138
+ UndefinedAddress,
139
+
140
+ #[error("{0}")]
141
+ Other(String),
142
+
143
+ #[error("{path}: {source}")]
144
+ Context { path: String, source: Box<Error> },
145
+ }
146
+
147
+ impl Error {
148
+ /// Wrap this error with an object path for additional context.
149
+ pub fn with_context(self, path: impl Into<String>) -> Self {
150
+ Error::Context {
151
+ path: path.into(),
152
+ source: Box::new(self),
153
+ }
154
+ }
155
+ }
156
+
157
+ pub type Result<T> = std::result::Result<T, Error>;
158
+
159
+ pub use hdf5_core::ByteOrder;
160
+
161
+ impl From<hdf5_core::Error> for Error {
162
+ fn from(err: hdf5_core::Error) -> Self {
163
+ match err {
164
+ hdf5_core::Error::InvalidData(message) => Error::InvalidData(message),
165
+ }
166
+ }
167
+ }