@nirs4all/formats-wasm 0.2.12 → 0.2.14

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 (90) hide show
  1. package/THIRD_PARTY_NOTICES.md +49 -0
  2. package/nirs4all_formats_wasm.d.ts +4 -4
  3. package/nirs4all_formats_wasm.js +170 -149
  4. package/nirs4all_formats_wasm_bg.wasm +0 -0
  5. package/package.json +4 -2
  6. package/reader-backports/hdf5-reader/Cargo.toml +119 -0
  7. package/reader-backports/hdf5-reader/LICENSE-APACHE +164 -0
  8. package/reader-backports/hdf5-reader/LICENSE-MIT +21 -0
  9. package/reader-backports/hdf5-reader/PROVENANCE.json +80 -0
  10. package/reader-backports/hdf5-reader/README.md +308 -0
  11. package/reader-backports/hdf5-reader/UPSTREAM-Cargo.toml +44 -0
  12. package/reader-backports/hdf5-reader/UPSTREAM-VCS.json +6 -0
  13. package/reader-backports/hdf5-reader/src/attribute_api.rs +847 -0
  14. package/reader-backports/hdf5-reader/src/btree_v1.rs +726 -0
  15. package/reader-backports/hdf5-reader/src/btree_v2.rs +2068 -0
  16. package/reader-backports/hdf5-reader/src/cache.rs +354 -0
  17. package/reader-backports/hdf5-reader/src/checksum.rs +56 -0
  18. package/reader-backports/hdf5-reader/src/chunk_index.rs +423 -0
  19. package/reader-backports/hdf5-reader/src/dataset.rs +4733 -0
  20. package/reader-backports/hdf5-reader/src/datatype_api.rs +497 -0
  21. package/reader-backports/hdf5-reader/src/error.rs +167 -0
  22. package/reader-backports/hdf5-reader/src/extensible_array.rs +1886 -0
  23. package/reader-backports/hdf5-reader/src/filters/deflate.rs +93 -0
  24. package/reader-backports/hdf5-reader/src/filters/fletcher32.rs +52 -0
  25. package/reader-backports/hdf5-reader/src/filters/lz4.rs +178 -0
  26. package/reader-backports/hdf5-reader/src/filters/mod.rs +326 -0
  27. package/reader-backports/hdf5-reader/src/filters/nbit.rs +586 -0
  28. package/reader-backports/hdf5-reader/src/filters/scaleoffset.rs +827 -0
  29. package/reader-backports/hdf5-reader/src/filters/shuffle.rs +99 -0
  30. package/reader-backports/hdf5-reader/src/fixed_array.rs +763 -0
  31. package/reader-backports/hdf5-reader/src/fractal_heap.rs +2029 -0
  32. package/reader-backports/hdf5-reader/src/global_heap.rs +284 -0
  33. package/reader-backports/hdf5-reader/src/group.rs +795 -0
  34. package/reader-backports/hdf5-reader/src/io.rs +413 -0
  35. package/reader-backports/hdf5-reader/src/lib.rs +916 -0
  36. package/reader-backports/hdf5-reader/src/local_heap.rs +261 -0
  37. package/reader-backports/hdf5-reader/src/messages/attribute.rs +304 -0
  38. package/reader-backports/hdf5-reader/src/messages/attribute_info.rs +96 -0
  39. package/reader-backports/hdf5-reader/src/messages/btree_k.rs +36 -0
  40. package/reader-backports/hdf5-reader/src/messages/continuation.rs +46 -0
  41. package/reader-backports/hdf5-reader/src/messages/dataspace.rs +259 -0
  42. package/reader-backports/hdf5-reader/src/messages/datatype.rs +938 -0
  43. package/reader-backports/hdf5-reader/src/messages/external_files.rs +50 -0
  44. package/reader-backports/hdf5-reader/src/messages/fill_value.rs +233 -0
  45. package/reader-backports/hdf5-reader/src/messages/filter_pipeline.rs +147 -0
  46. package/reader-backports/hdf5-reader/src/messages/group_info.rs +103 -0
  47. package/reader-backports/hdf5-reader/src/messages/layout.rs +476 -0
  48. package/reader-backports/hdf5-reader/src/messages/link.rs +170 -0
  49. package/reader-backports/hdf5-reader/src/messages/link_info.rs +127 -0
  50. package/reader-backports/hdf5-reader/src/messages/mod.rs +374 -0
  51. package/reader-backports/hdf5-reader/src/messages/modification_time.rs +83 -0
  52. package/reader-backports/hdf5-reader/src/messages/shared.rs +164 -0
  53. package/reader-backports/hdf5-reader/src/messages/shared_table.rs +67 -0
  54. package/reader-backports/hdf5-reader/src/messages/symbol_table_msg.rs +51 -0
  55. package/reader-backports/hdf5-reader/src/object_header.rs +1749 -0
  56. package/reader-backports/hdf5-reader/src/reference.rs +90 -0
  57. package/reader-backports/hdf5-reader/src/shared_message_table.rs +425 -0
  58. package/reader-backports/hdf5-reader/src/storage.rs +538 -0
  59. package/reader-backports/hdf5-reader/src/superblock.rs +285 -0
  60. package/reader-backports/hdf5-reader/src/symbol_table.rs +277 -0
  61. package/reader-backports/netcdf-reader/Cargo.toml +141 -0
  62. package/reader-backports/netcdf-reader/LICENSE-APACHE +164 -0
  63. package/reader-backports/netcdf-reader/LICENSE-MIT +21 -0
  64. package/reader-backports/netcdf-reader/PROVENANCE.json +55 -0
  65. package/reader-backports/netcdf-reader/README.md +308 -0
  66. package/reader-backports/netcdf-reader/UPSTREAM-Cargo.toml +48 -0
  67. package/reader-backports/netcdf-reader/UPSTREAM-VCS.json +6 -0
  68. package/reader-backports/netcdf-reader/src/cf/axes.rs +419 -0
  69. package/reader-backports/netcdf-reader/src/cf/bounds.rs +108 -0
  70. package/reader-backports/netcdf-reader/src/cf/crs.rs +269 -0
  71. package/reader-backports/netcdf-reader/src/cf/mod.rs +30 -0
  72. package/reader-backports/netcdf-reader/src/cf/time.rs +1122 -0
  73. package/reader-backports/netcdf-reader/src/classic/data.rs +1465 -0
  74. package/reader-backports/netcdf-reader/src/classic/header.rs +1097 -0
  75. package/reader-backports/netcdf-reader/src/classic/mod.rs +240 -0
  76. package/reader-backports/netcdf-reader/src/classic/storage.rs +211 -0
  77. package/reader-backports/netcdf-reader/src/classic/types.rs +93 -0
  78. package/reader-backports/netcdf-reader/src/classic/variable.rs +1162 -0
  79. package/reader-backports/netcdf-reader/src/error.rs +59 -0
  80. package/reader-backports/netcdf-reader/src/lib.rs +1531 -0
  81. package/reader-backports/netcdf-reader/src/masked.rs +173 -0
  82. package/reader-backports/netcdf-reader/src/nc4/attributes.rs +203 -0
  83. package/reader-backports/netcdf-reader/src/nc4/dimensions.rs +139 -0
  84. package/reader-backports/netcdf-reader/src/nc4/groups.rs +308 -0
  85. package/reader-backports/netcdf-reader/src/nc4/mod.rs +572 -0
  86. package/reader-backports/netcdf-reader/src/nc4/types.rs +309 -0
  87. package/reader-backports/netcdf-reader/src/nc4/variables.rs +420 -0
  88. package/reader-backports/netcdf-reader/src/types.rs +18 -0
  89. package/reader-backports/netcdf-reader/src/unpack.rs +113 -0
  90. package/reader-backports/netcdf-reader/src/user_defined.rs +569 -0
@@ -0,0 +1,240 @@
1
+ //! Classic (CDF-1/2/5) NetCDF file format support.
2
+ //!
3
+ //! This module handles the original NetCDF binary format (CDF-1 classic, CDF-2
4
+ //! 64-bit offset, and CDF-5 64-bit data). All multi-byte values are big-endian.
5
+
6
+ pub mod data;
7
+ pub mod header;
8
+ pub(crate) mod storage;
9
+ pub mod types;
10
+ pub mod variable;
11
+
12
+ use std::fs::File;
13
+ use std::path::Path;
14
+
15
+ use memmap2::Mmap;
16
+
17
+ use crate::error::{Error, Result};
18
+ use crate::types::NcGroup;
19
+ use crate::NcFormat;
20
+
21
+ use storage::ClassicStorage;
22
+
23
+ /// An opened classic-format NetCDF file (CDF-1, CDF-2, or CDF-5).
24
+ pub struct ClassicFile {
25
+ pub(crate) format: NcFormat,
26
+ pub(crate) root_group: NcGroup,
27
+ pub(crate) storage: ClassicStorage,
28
+ pub(crate) numrecs: u64,
29
+ }
30
+
31
+ impl ClassicFile {
32
+ /// Open a classic NetCDF file from disk using memory-mapping.
33
+ pub fn open(path: &Path, format: NcFormat) -> Result<Self> {
34
+ let file = File::open(path)?;
35
+ // SAFETY: read-only mapping; caller must not modify the file concurrently.
36
+ let mmap = unsafe { Mmap::map(&file)? };
37
+ let is_streaming = header::has_streaming_numrecs(&mmap, format);
38
+ let header = header::parse_header(&mmap, format)?;
39
+ let storage = ClassicStorage::from_mmap(mmap);
40
+ let (root_group, numrecs) = finalize_header(header, storage.len(), is_streaming)?;
41
+
42
+ Ok(ClassicFile {
43
+ format,
44
+ root_group,
45
+ storage,
46
+ numrecs,
47
+ })
48
+ }
49
+
50
+ /// Open a classic NetCDF file from in-memory bytes.
51
+ pub fn from_bytes(bytes: &[u8], format: NcFormat) -> Result<Self> {
52
+ let is_streaming = header::has_streaming_numrecs(bytes, format);
53
+ let header = header::parse_header(bytes, format)?;
54
+ let storage = ClassicStorage::from_bytes(bytes.to_vec());
55
+ let (root_group, numrecs) = finalize_header(header, storage.len(), is_streaming)?;
56
+
57
+ Ok(ClassicFile {
58
+ format,
59
+ root_group,
60
+ storage,
61
+ numrecs,
62
+ })
63
+ }
64
+
65
+ /// Open a classic NetCDF file from an existing memory map (avoids double mmap).
66
+ pub fn from_mmap(mmap: Mmap, format: NcFormat) -> Result<Self> {
67
+ let is_streaming = header::has_streaming_numrecs(&mmap, format);
68
+ let header = header::parse_header(&mmap, format)?;
69
+ let storage = ClassicStorage::from_mmap(mmap);
70
+ let (root_group, numrecs) = finalize_header(header, storage.len(), is_streaming)?;
71
+
72
+ Ok(ClassicFile {
73
+ format,
74
+ root_group,
75
+ storage,
76
+ numrecs,
77
+ })
78
+ }
79
+
80
+ /// Open a classic NetCDF file from a random-access storage backend.
81
+ #[cfg(feature = "netcdf4")]
82
+ pub fn from_storage(
83
+ storage: hdf5_reader::storage::DynStorage,
84
+ format: NcFormat,
85
+ ) -> Result<Self> {
86
+ let storage = ClassicStorage::from_range(storage);
87
+ let (header, is_streaming) = parse_header_from_storage(&storage, format)?;
88
+ let (root_group, numrecs) = finalize_header(header, storage.len(), is_streaming)?;
89
+
90
+ Ok(ClassicFile {
91
+ format,
92
+ root_group,
93
+ storage,
94
+ numrecs,
95
+ })
96
+ }
97
+
98
+ /// The file format (Classic, Offset64, or Cdf5).
99
+ pub fn format(&self) -> NcFormat {
100
+ self.format
101
+ }
102
+
103
+ /// The root group containing all dimensions, variables, and global attributes.
104
+ pub fn root_group(&self) -> &NcGroup {
105
+ &self.root_group
106
+ }
107
+
108
+ /// Number of records in the unlimited dimension.
109
+ pub fn numrecs(&self) -> u64 {
110
+ self.numrecs
111
+ }
112
+ }
113
+
114
+ fn finalize_header(
115
+ mut header: header::ClassicHeader,
116
+ storage_len: u64,
117
+ is_streaming: bool,
118
+ ) -> Result<(NcGroup, u64)> {
119
+ reject_unsupported_classic_features(&header)?;
120
+
121
+ if is_streaming {
122
+ header.numrecs = infer_streaming_numrecs(&header, storage_len)?;
123
+ header::apply_unlimited_dimension_size(
124
+ &mut header.dimensions,
125
+ &mut header.variables,
126
+ header.numrecs,
127
+ );
128
+ } else {
129
+ validate_record_extent(&header, storage_len)?;
130
+ }
131
+
132
+ let numrecs = header.numrecs;
133
+ let root_group = NcGroup {
134
+ name: "/".to_string(),
135
+ dimensions: header.dimensions,
136
+ variables: header.variables,
137
+ attributes: header.global_attributes,
138
+ groups: Vec::new(), // Classic format has no sub-groups.
139
+ };
140
+
141
+ Ok((root_group, numrecs))
142
+ }
143
+
144
+ /// Reject headers whose declared record count cannot fit in the file, so a
145
+ /// tiny crafted header cannot drive huge record-buffer allocations later.
146
+ fn validate_record_extent(header: &header::ClassicHeader, storage_len: u64) -> Result<u64> {
147
+ let Some(record_data_start) = header
148
+ .variables
149
+ .iter()
150
+ .filter(|var| var.is_record_var)
151
+ .map(|var| var.data_offset)
152
+ .min()
153
+ else {
154
+ return Ok(0);
155
+ };
156
+
157
+ let record_stride = data::compute_record_stride(&header.variables)?;
158
+ let record_bytes = header
159
+ .numrecs
160
+ .checked_mul(record_stride)
161
+ .and_then(|bytes| bytes.checked_add(record_data_start))
162
+ .ok_or_else(|| {
163
+ Error::InvalidData("classic record data extent overflows u64".to_string())
164
+ })?;
165
+ if record_bytes > storage_len {
166
+ return Err(Error::InvalidData(format!(
167
+ "classic header declares {} records ({record_bytes} bytes) but the file has only \
168
+ {storage_len} bytes",
169
+ header.numrecs
170
+ )));
171
+ }
172
+ Ok(record_bytes)
173
+ }
174
+
175
+ fn infer_streaming_numrecs(header: &header::ClassicHeader, storage_len: u64) -> Result<u64> {
176
+ let Some(record_data_start) = header
177
+ .variables
178
+ .iter()
179
+ .filter(|var| var.is_record_var)
180
+ .map(|var| var.data_offset)
181
+ .min()
182
+ else {
183
+ return Ok(0);
184
+ };
185
+
186
+ let record_stride = data::compute_record_stride(&header.variables)?;
187
+ if record_stride == 0 || storage_len <= record_data_start {
188
+ return Ok(0);
189
+ }
190
+
191
+ Ok((storage_len - record_data_start) / record_stride)
192
+ }
193
+
194
+ fn reject_unsupported_classic_features(header: &header::ClassicHeader) -> Result<()> {
195
+ let has_subfiling_marker = header
196
+ .global_attributes
197
+ .iter()
198
+ .any(|attr| is_subfiling_attribute_name(&attr.name))
199
+ || header.variables.iter().any(|var| {
200
+ var.attributes
201
+ .iter()
202
+ .any(|attr| is_subfiling_attribute_name(&attr.name))
203
+ });
204
+
205
+ if has_subfiling_marker {
206
+ return Err(crate::Error::UnsupportedFeature(
207
+ "PnetCDF subfiling datasets require a virtual multi-file storage adapter".to_string(),
208
+ ));
209
+ }
210
+
211
+ Ok(())
212
+ }
213
+
214
+ fn is_subfiling_attribute_name(name: &str) -> bool {
215
+ let lower = name.to_ascii_lowercase();
216
+ lower.starts_with("_pnetcdf_subfiling") || lower.starts_with("subfiling")
217
+ }
218
+
219
+ #[cfg(feature = "netcdf4")]
220
+ fn parse_header_from_storage(
221
+ storage: &ClassicStorage,
222
+ format: NcFormat,
223
+ ) -> Result<(header::ClassicHeader, bool)> {
224
+ let mut len = storage.initial_header_len();
225
+
226
+ loop {
227
+ let prefix = storage.read_header_prefix(len)?;
228
+ match header::parse_header(prefix.as_ref(), format) {
229
+ Ok(header) => {
230
+ let is_streaming = header::has_streaming_numrecs(prefix.as_ref(), format);
231
+ return Ok((header, is_streaming));
232
+ }
233
+ Err(crate::Error::UnexpectedEof { .. }) if (prefix.len() as u64) < storage.len() => {
234
+ let current = prefix.len().max(1);
235
+ len = current.saturating_mul(2);
236
+ }
237
+ Err(err) => return Err(err),
238
+ }
239
+ }
240
+ }
@@ -0,0 +1,211 @@
1
+ use std::ops::Deref;
2
+ use std::sync::Arc;
3
+
4
+ use memmap2::Mmap;
5
+
6
+ use crate::error::{Error, Result};
7
+
8
+ /// Header prefix read on the first pass for range-backed classic opens.
9
+ #[cfg(feature = "netcdf4")]
10
+ const INITIAL_HEADER_READ: usize = 64 * 1024;
11
+
12
+ #[derive(Clone)]
13
+ enum ClassicStorageBacking {
14
+ Bytes(Arc<[u8]>),
15
+ Mmap(Arc<Mmap>),
16
+ #[cfg(feature = "netcdf4")]
17
+ Range(hdf5_reader::storage::DynStorage),
18
+ }
19
+
20
+ #[derive(Clone)]
21
+ pub(crate) struct ClassicStorage {
22
+ backing: ClassicStorageBacking,
23
+ len: u64,
24
+ }
25
+
26
+ #[cfg(feature = "rayon")]
27
+ #[derive(Clone, Copy, Debug, Eq, PartialEq)]
28
+ pub(crate) enum ClassicStorageKind {
29
+ Bytes,
30
+ Mmap,
31
+ #[cfg(feature = "netcdf4")]
32
+ Range,
33
+ }
34
+
35
+ #[cfg(feature = "rayon")]
36
+ #[derive(Clone, Copy, Debug, Eq, PartialEq)]
37
+ pub(crate) struct ClassicParallelReadPolicy {
38
+ pub(crate) min_bytes: usize,
39
+ pub(crate) target_chunk_bytes: usize,
40
+ }
41
+
42
+ #[cfg(feature = "rayon")]
43
+ impl ClassicParallelReadPolicy {
44
+ const LOCAL_MIN_BYTES: usize = 32 * 1024 * 1024;
45
+ const LOCAL_TARGET_CHUNK_BYTES: usize = 8 * 1024 * 1024;
46
+ // Only referenced by the range-backed (HDF5-storage) arm below, which is
47
+ // itself gated on `netcdf4`; without that feature these would be dead code.
48
+ #[cfg(feature = "netcdf4")]
49
+ const RANGE_MIN_BYTES: usize = 1024 * 1024;
50
+ #[cfg(feature = "netcdf4")]
51
+ const RANGE_TARGET_CHUNK_BYTES: usize = 1024 * 1024;
52
+
53
+ fn for_kind(kind: ClassicStorageKind) -> Self {
54
+ match kind {
55
+ ClassicStorageKind::Bytes | ClassicStorageKind::Mmap => Self {
56
+ min_bytes: Self::LOCAL_MIN_BYTES,
57
+ target_chunk_bytes: Self::LOCAL_TARGET_CHUNK_BYTES,
58
+ },
59
+ #[cfg(feature = "netcdf4")]
60
+ ClassicStorageKind::Range => Self {
61
+ min_bytes: Self::RANGE_MIN_BYTES,
62
+ target_chunk_bytes: Self::RANGE_TARGET_CHUNK_BYTES,
63
+ },
64
+ }
65
+ }
66
+ }
67
+
68
+ #[derive(Clone)]
69
+ pub(crate) enum ClassicBuffer {
70
+ Bytes {
71
+ data: Arc<[u8]>,
72
+ start: usize,
73
+ len: usize,
74
+ },
75
+ Mmap {
76
+ mmap: Arc<Mmap>,
77
+ start: usize,
78
+ len: usize,
79
+ },
80
+ #[cfg(feature = "netcdf4")]
81
+ Range(hdf5_reader::StorageBuffer),
82
+ }
83
+
84
+ impl ClassicStorage {
85
+ pub(crate) fn from_bytes(bytes: Vec<u8>) -> Self {
86
+ let len = bytes.len() as u64;
87
+ Self {
88
+ backing: ClassicStorageBacking::Bytes(Arc::<[u8]>::from(bytes)),
89
+ len,
90
+ }
91
+ }
92
+
93
+ pub(crate) fn from_mmap(mmap: Mmap) -> Self {
94
+ let len = mmap.len() as u64;
95
+ Self {
96
+ backing: ClassicStorageBacking::Mmap(Arc::new(mmap)),
97
+ len,
98
+ }
99
+ }
100
+
101
+ #[cfg(feature = "netcdf4")]
102
+ pub(crate) fn from_range(storage: hdf5_reader::storage::DynStorage) -> Self {
103
+ let len = storage.len();
104
+ Self {
105
+ backing: ClassicStorageBacking::Range(storage),
106
+ len,
107
+ }
108
+ }
109
+
110
+ pub(crate) fn len(&self) -> u64 {
111
+ self.len
112
+ }
113
+
114
+ #[cfg(feature = "rayon")]
115
+ pub(crate) fn kind(&self) -> ClassicStorageKind {
116
+ match &self.backing {
117
+ ClassicStorageBacking::Bytes(_) => ClassicStorageKind::Bytes,
118
+ ClassicStorageBacking::Mmap(_) => ClassicStorageKind::Mmap,
119
+ #[cfg(feature = "netcdf4")]
120
+ ClassicStorageBacking::Range(_) => ClassicStorageKind::Range,
121
+ }
122
+ }
123
+
124
+ #[cfg(feature = "rayon")]
125
+ pub(crate) fn parallel_read_policy(&self) -> ClassicParallelReadPolicy {
126
+ ClassicParallelReadPolicy::for_kind(self.kind())
127
+ }
128
+
129
+ #[cfg(feature = "netcdf4")]
130
+ pub(crate) fn initial_header_len(&self) -> usize {
131
+ usize::try_from(self.len.min(INITIAL_HEADER_READ as u64)).unwrap_or(INITIAL_HEADER_READ)
132
+ }
133
+
134
+ pub(crate) fn read_range(&self, offset: u64, len: usize) -> Result<ClassicBuffer> {
135
+ let needed = u64::try_from(len)
136
+ .map_err(|_| Error::InvalidData("classic range length exceeds u64".to_string()))?;
137
+ let end = offset
138
+ .checked_add(needed)
139
+ .ok_or_else(|| Error::InvalidData("classic byte range exceeds u64".to_string()))?;
140
+ if end > self.len {
141
+ return Err(Error::UnexpectedEof {
142
+ offset,
143
+ needed,
144
+ available: self.len.saturating_sub(offset),
145
+ });
146
+ }
147
+
148
+ match &self.backing {
149
+ ClassicStorageBacking::Bytes(data) => {
150
+ let start = usize::try_from(offset).map_err(|_| {
151
+ Error::InvalidData("classic byte offset exceeds platform usize".to_string())
152
+ })?;
153
+ Ok(ClassicBuffer::Bytes {
154
+ data: data.clone(),
155
+ start,
156
+ len,
157
+ })
158
+ }
159
+ ClassicStorageBacking::Mmap(mmap) => {
160
+ let start = usize::try_from(offset).map_err(|_| {
161
+ Error::InvalidData("classic byte offset exceeds platform usize".to_string())
162
+ })?;
163
+ Ok(ClassicBuffer::Mmap {
164
+ mmap: mmap.clone(),
165
+ start,
166
+ len,
167
+ })
168
+ }
169
+ #[cfg(feature = "netcdf4")]
170
+ ClassicStorageBacking::Range(storage) => {
171
+ Ok(ClassicBuffer::Range(storage.read_range(offset, len)?))
172
+ }
173
+ }
174
+ }
175
+
176
+ #[cfg(feature = "netcdf4")]
177
+ pub(crate) fn read_header_prefix(&self, len: usize) -> Result<ClassicBuffer> {
178
+ let capped = len.min(usize::try_from(self.len).unwrap_or(usize::MAX));
179
+ self.read_range(0, capped)
180
+ }
181
+ }
182
+
183
+ impl ClassicBuffer {
184
+ #[cfg(feature = "netcdf4")]
185
+ pub(crate) fn len(&self) -> usize {
186
+ match self {
187
+ ClassicBuffer::Bytes { len, .. } | ClassicBuffer::Mmap { len, .. } => *len,
188
+ #[cfg(feature = "netcdf4")]
189
+ ClassicBuffer::Range(buffer) => buffer.len(),
190
+ }
191
+ }
192
+ }
193
+
194
+ impl AsRef<[u8]> for ClassicBuffer {
195
+ fn as_ref(&self) -> &[u8] {
196
+ self
197
+ }
198
+ }
199
+
200
+ impl Deref for ClassicBuffer {
201
+ type Target = [u8];
202
+
203
+ fn deref(&self) -> &Self::Target {
204
+ match self {
205
+ ClassicBuffer::Bytes { data, start, len } => &data[*start..*start + *len],
206
+ ClassicBuffer::Mmap { mmap, start, len } => &mmap[*start..*start + *len],
207
+ #[cfg(feature = "netcdf4")]
208
+ ClassicBuffer::Range(buffer) => buffer.as_ref(),
209
+ }
210
+ }
211
+ }
@@ -0,0 +1,93 @@
1
+ //! NC type mapping and helper functions for the classic (CDF-1/2/5) format.
2
+
3
+ use crate::error::{Error, Result};
4
+ use crate::types::NcType;
5
+
6
+ // NetCDF classic type codes (from the binary header).
7
+ pub const NC_BYTE: u32 = 1;
8
+ pub const NC_CHAR: u32 = 2;
9
+ pub const NC_SHORT: u32 = 3;
10
+ pub const NC_INT: u32 = 4;
11
+ pub const NC_FLOAT: u32 = 5;
12
+ pub const NC_DOUBLE: u32 = 6;
13
+ // CDF-5 extended types.
14
+ pub const NC_UBYTE: u32 = 7;
15
+ pub const NC_USHORT: u32 = 8;
16
+ pub const NC_UINT: u32 = 9;
17
+ pub const NC_INT64: u32 = 10;
18
+ pub const NC_UINT64: u32 = 11;
19
+
20
+ /// Convert a classic NC type code to an `NcType`.
21
+ pub fn nc_type_from_code(code: u32) -> Result<NcType> {
22
+ match code {
23
+ NC_BYTE => Ok(NcType::Byte),
24
+ NC_CHAR => Ok(NcType::Char),
25
+ NC_SHORT => Ok(NcType::Short),
26
+ NC_INT => Ok(NcType::Int),
27
+ NC_FLOAT => Ok(NcType::Float),
28
+ NC_DOUBLE => Ok(NcType::Double),
29
+ NC_UBYTE => Ok(NcType::UByte),
30
+ NC_USHORT => Ok(NcType::UShort),
31
+ NC_UINT => Ok(NcType::UInt),
32
+ NC_INT64 => Ok(NcType::Int64),
33
+ NC_UINT64 => Ok(NcType::UInt64),
34
+ _ => Err(Error::InvalidData(format!("unknown NC type code {}", code))),
35
+ }
36
+ }
37
+
38
+ /// Size of one element for a classic NC type code.
39
+ pub fn nc_type_size(code: u32) -> Result<usize> {
40
+ Ok(nc_type_from_code(code)?.size()?)
41
+ }
42
+
43
+ /// Compute the amount of padding needed to reach a 4-byte boundary.
44
+ pub fn padding_to_4(len: usize) -> usize {
45
+ let rem = len % 4;
46
+ if rem == 0 {
47
+ 0
48
+ } else {
49
+ 4 - rem
50
+ }
51
+ }
52
+
53
+ /// Round up to the next 4-byte boundary.
54
+ pub fn pad_to_4(len: usize) -> usize {
55
+ len + padding_to_4(len)
56
+ }
57
+
58
+ #[cfg(test)]
59
+ mod tests {
60
+ use super::*;
61
+
62
+ #[test]
63
+ fn nc_type_codes_map_supported_values() {
64
+ assert_eq!(nc_type_from_code(1).unwrap(), NcType::Byte);
65
+ assert_eq!(nc_type_from_code(2).unwrap(), NcType::Char);
66
+ assert_eq!(nc_type_from_code(3).unwrap(), NcType::Short);
67
+ assert_eq!(nc_type_from_code(4).unwrap(), NcType::Int);
68
+ assert_eq!(nc_type_from_code(5).unwrap(), NcType::Float);
69
+ assert_eq!(nc_type_from_code(6).unwrap(), NcType::Double);
70
+ assert_eq!(nc_type_from_code(7).unwrap(), NcType::UByte);
71
+ assert_eq!(nc_type_from_code(8).unwrap(), NcType::UShort);
72
+ assert_eq!(nc_type_from_code(9).unwrap(), NcType::UInt);
73
+ assert_eq!(nc_type_from_code(10).unwrap(), NcType::Int64);
74
+ assert_eq!(nc_type_from_code(11).unwrap(), NcType::UInt64);
75
+ assert!(nc_type_from_code(0).is_err());
76
+ assert!(nc_type_from_code(12).is_err());
77
+ }
78
+
79
+ #[test]
80
+ fn padding() {
81
+ assert_eq!(padding_to_4(0), 0);
82
+ assert_eq!(padding_to_4(1), 3);
83
+ assert_eq!(padding_to_4(2), 2);
84
+ assert_eq!(padding_to_4(3), 1);
85
+ assert_eq!(padding_to_4(4), 0);
86
+ assert_eq!(padding_to_4(5), 3);
87
+ assert_eq!(pad_to_4(0), 0);
88
+ assert_eq!(pad_to_4(1), 4);
89
+ assert_eq!(pad_to_4(3), 4);
90
+ assert_eq!(pad_to_4(4), 4);
91
+ assert_eq!(pad_to_4(5), 8);
92
+ }
93
+ }