@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,1122 @@
1
+ //! CF time coordinate decoding.
2
+ //!
3
+ //! Parses time units strings like "days since 1970-01-01 00:00:00" and
4
+ //! converts numeric time values to exact CF calendar date-times.
5
+ //!
6
+ //! Supported calendars:
7
+ //! - standard (mixed Gregorian/Julian)
8
+ //! - proleptic_gregorian
9
+ //! - noleap / 365_day
10
+ //! - all_leap / 366_day
11
+ //! - 360_day
12
+ //! - julian
13
+ //!
14
+ //! Reference: CF Conventions §4.4 "Time Coordinate"
15
+
16
+ use chrono::{DateTime, NaiveDate, Utc};
17
+ use std::fmt;
18
+
19
+ use crate::error::{Error, Result};
20
+ use crate::types::{NcDimension, NcGroup, NcVariable};
21
+
22
+ /// Supported CF calendar types.
23
+ #[derive(Debug, Clone, Copy, PartialEq, Eq)]
24
+ pub enum CfCalendar {
25
+ /// Mixed Gregorian/Julian (default).
26
+ Standard,
27
+ /// Proleptic Gregorian (no Julian transition).
28
+ ProlepticGregorian,
29
+ /// No leap years, every year has 365 days.
30
+ NoLeap,
31
+ /// Every year has 366 days.
32
+ AllLeap,
33
+ /// Every month has 30 days (360 days/year).
34
+ Day360,
35
+ /// Julian calendar.
36
+ Julian,
37
+ }
38
+
39
+ impl CfCalendar {
40
+ /// Parse a calendar name from a CF `calendar` attribute value.
41
+ pub fn parse(s: &str) -> Self {
42
+ match s.trim().to_lowercase().as_str() {
43
+ "standard" | "gregorian" => CfCalendar::Standard,
44
+ "proleptic_gregorian" => CfCalendar::ProlepticGregorian,
45
+ "noleap" | "365_day" => CfCalendar::NoLeap,
46
+ "all_leap" | "366_day" => CfCalendar::AllLeap,
47
+ "360_day" => CfCalendar::Day360,
48
+ "julian" => CfCalendar::Julian,
49
+ _ => CfCalendar::Standard, // Default per CF spec
50
+ }
51
+ }
52
+ }
53
+
54
+ /// Time unit for CF time coordinates.
55
+ #[derive(Debug, Clone, Copy, PartialEq, Eq)]
56
+ pub enum CfTimeUnit {
57
+ Seconds,
58
+ Minutes,
59
+ Hours,
60
+ Days,
61
+ /// Calendar month offsets. Exact decoding currently accepts these only for
62
+ /// integer offsets in the `360_day` calendar.
63
+ Months,
64
+ }
65
+
66
+ /// Calendar date components for a CF date-time.
67
+ #[derive(Debug, Clone, Copy, PartialEq, Eq)]
68
+ pub struct CfDate {
69
+ pub year: i32,
70
+ pub month: u8,
71
+ pub day: u8,
72
+ }
73
+
74
+ impl CfDate {
75
+ pub fn new(year: i32, month: u8, day: u8) -> Self {
76
+ Self { year, month, day }
77
+ }
78
+ }
79
+
80
+ /// Time-of-day components for a CF date-time.
81
+ #[derive(Debug, Clone, Copy, PartialEq, Eq)]
82
+ pub struct CfTimeOfDay {
83
+ pub hour: u8,
84
+ pub minute: u8,
85
+ pub second: u8,
86
+ pub nanosecond: u32,
87
+ }
88
+
89
+ impl CfTimeOfDay {
90
+ pub fn new(hour: u8, minute: u8, second: u8, nanosecond: u32) -> Result<Self> {
91
+ validate_time(hour, minute, second, nanosecond)?;
92
+ Ok(Self {
93
+ hour,
94
+ minute,
95
+ second,
96
+ nanosecond,
97
+ })
98
+ }
99
+ }
100
+
101
+ /// Exact date-time in a CF calendar.
102
+ ///
103
+ /// This type can represent calendar dates that `chrono` cannot, such as
104
+ /// `360_day` February 30 or `all_leap` February 29 in a Gregorian common year.
105
+ #[derive(Debug, Clone, Copy, PartialEq, Eq)]
106
+ pub struct CfDateTime {
107
+ pub calendar: CfCalendar,
108
+ pub year: i32,
109
+ pub month: u8,
110
+ pub day: u8,
111
+ pub hour: u8,
112
+ pub minute: u8,
113
+ pub second: u8,
114
+ pub nanosecond: u32,
115
+ }
116
+
117
+ impl CfDateTime {
118
+ pub fn new(calendar: CfCalendar, date: CfDate, time: CfTimeOfDay) -> Result<Self> {
119
+ validate_date(calendar, date.year, date.month, date.day)?;
120
+ Ok(Self {
121
+ calendar,
122
+ year: date.year,
123
+ month: date.month,
124
+ day: date.day,
125
+ hour: time.hour,
126
+ minute: time.minute,
127
+ second: time.second,
128
+ nanosecond: time.nanosecond,
129
+ })
130
+ }
131
+
132
+ /// Convert to `chrono::DateTime<Utc>` using the same displayed components.
133
+ ///
134
+ /// This succeeds for exact CF date-times whose year/month/day exists in
135
+ /// chrono's proleptic Gregorian calendar. Use [`decode_time_exact`] when
136
+ /// the source calendar itself must be preserved.
137
+ pub fn to_chrono_utc(&self) -> Result<DateTime<Utc>> {
138
+ let date = NaiveDate::from_ymd_opt(self.year, self.month as u32, self.day as u32)
139
+ .ok_or_else(|| {
140
+ Error::InvalidData(format!(
141
+ "CF {:?} date {} cannot be represented as a Gregorian chrono date",
142
+ self.calendar, self
143
+ ))
144
+ })?;
145
+ let datetime = date
146
+ .and_hms_nano_opt(
147
+ self.hour as u32,
148
+ self.minute as u32,
149
+ self.second as u32,
150
+ self.nanosecond,
151
+ )
152
+ .ok_or_else(|| Error::InvalidData(format!("invalid CF time component in {}", self)))?;
153
+ Ok(DateTime::<Utc>::from_naive_utc_and_offset(datetime, Utc))
154
+ }
155
+ }
156
+
157
+ impl fmt::Display for CfDateTime {
158
+ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
159
+ write!(
160
+ f,
161
+ "{:04}-{:02}-{:02} {:02}:{:02}:{:02}",
162
+ self.year, self.month, self.day, self.hour, self.minute, self.second
163
+ )?;
164
+ if self.nanosecond != 0 {
165
+ write!(f, ".{:09}", self.nanosecond)?;
166
+ }
167
+ Ok(())
168
+ }
169
+ }
170
+
171
+ /// Parsed CF time reference.
172
+ #[derive(Debug, Clone)]
173
+ pub struct CfTimeRef {
174
+ pub unit: CfTimeUnit,
175
+ pub epoch: CfDateTime,
176
+ pub calendar: CfCalendar,
177
+ }
178
+
179
+ /// A discovered CF time coordinate backed by a NetCDF coordinate variable.
180
+ #[derive(Debug, Clone)]
181
+ pub struct CfTimeCoordinate<'a> {
182
+ /// The coordinate variable carrying CF time metadata.
183
+ pub variable: &'a NcVariable,
184
+ /// The dimension represented by the coordinate variable.
185
+ pub dimension: &'a NcDimension,
186
+ /// Parsed `units` and `calendar` metadata for decoding values.
187
+ pub time_ref: CfTimeRef,
188
+ }
189
+
190
+ /// Parse a CF time units string like "days since 1970-01-01 00:00:00".
191
+ ///
192
+ /// Format: `<unit> since <date>[ <time>]`
193
+ pub fn parse_time_units(units: &str, calendar: CfCalendar) -> Result<CfTimeRef> {
194
+ let (unit_text, epoch_text) = split_time_units(units)?;
195
+
196
+ let unit = match unit_text.trim().to_lowercase().as_str() {
197
+ "second" | "seconds" | "s" => CfTimeUnit::Seconds,
198
+ "minute" | "minutes" | "min" => CfTimeUnit::Minutes,
199
+ "hour" | "hours" | "hr" | "h" => CfTimeUnit::Hours,
200
+ "day" | "days" | "d" => CfTimeUnit::Days,
201
+ "month" | "months" => CfTimeUnit::Months,
202
+ u => {
203
+ return Err(Error::InvalidData(format!(
204
+ "unsupported CF time unit '{}'",
205
+ u
206
+ )));
207
+ }
208
+ };
209
+
210
+ let epoch = parse_epoch(epoch_text.trim(), calendar)?;
211
+
212
+ Ok(CfTimeRef {
213
+ unit,
214
+ epoch,
215
+ calendar,
216
+ })
217
+ }
218
+
219
+ /// Parse CF time metadata from a variable.
220
+ ///
221
+ /// Returns `Ok(None)` when the variable has no CF time units. Invalid CF time
222
+ /// units return an error so malformed time coordinates are not silently hidden.
223
+ pub fn time_ref_from_variable(var: &NcVariable) -> Result<Option<CfTimeRef>> {
224
+ let Some(units) = var
225
+ .attribute("units")
226
+ .and_then(|attr| attr.value.as_string())
227
+ else {
228
+ return Ok(None);
229
+ };
230
+
231
+ if !units.trim().to_lowercase().contains(" since ") {
232
+ return Ok(None);
233
+ }
234
+
235
+ let calendar = var
236
+ .attribute("calendar")
237
+ .and_then(|attr| attr.value.as_string())
238
+ .map(|value| CfCalendar::parse(&value))
239
+ .unwrap_or(CfCalendar::Standard);
240
+
241
+ parse_time_units(&units, calendar).map(Some)
242
+ }
243
+
244
+ /// Discover CF time coordinate variables in a group.
245
+ ///
246
+ /// Only true coordinate variables are considered. Non-time coordinate variables
247
+ /// are skipped, while malformed time metadata is returned as an error.
248
+ pub fn discover_time_coordinates(group: &NcGroup) -> Result<Vec<CfTimeCoordinate<'_>>> {
249
+ let mut coordinates = Vec::new();
250
+ for variable in group.coordinate_variables() {
251
+ let Some(time_ref) = time_ref_from_variable(variable)? else {
252
+ continue;
253
+ };
254
+ let Some(dimension) = variable.coordinate_dimension() else {
255
+ continue;
256
+ };
257
+ coordinates.push(CfTimeCoordinate {
258
+ variable,
259
+ dimension,
260
+ time_ref,
261
+ });
262
+ }
263
+ Ok(coordinates)
264
+ }
265
+
266
+ /// Discover the CF time coordinate used by a variable, if one exists.
267
+ pub fn discover_variable_time_coordinate<'a>(
268
+ var: &NcVariable,
269
+ group: &'a NcGroup,
270
+ ) -> Result<Option<CfTimeCoordinate<'a>>> {
271
+ for dimension in var.dimensions() {
272
+ let Some(variable) = group.coordinate_variable(&dimension.name) else {
273
+ continue;
274
+ };
275
+ let Some(time_ref) = time_ref_from_variable(variable)? else {
276
+ continue;
277
+ };
278
+ let Some(coordinate_dimension) = variable.coordinate_dimension() else {
279
+ continue;
280
+ };
281
+ return Ok(Some(CfTimeCoordinate {
282
+ variable,
283
+ dimension: coordinate_dimension,
284
+ time_ref,
285
+ }));
286
+ }
287
+
288
+ Ok(None)
289
+ }
290
+
291
+ fn split_time_units(units: &str) -> Result<(&str, &str)> {
292
+ let lower = units.trim().to_lowercase();
293
+ let Some(index) = lower.find(" since ") else {
294
+ return Err(Error::InvalidData(format!(
295
+ "invalid CF time units '{}': expected '<unit> since <date>'",
296
+ units
297
+ )));
298
+ };
299
+ let trimmed = units.trim();
300
+ Ok((&trimmed[..index], &trimmed[index + " since ".len()..]))
301
+ }
302
+
303
+ /// Parse the epoch date/time string in a calendar-aware way.
304
+ fn parse_epoch(s: &str, calendar: CfCalendar) -> Result<CfDateTime> {
305
+ let trimmed = s.trim();
306
+ if trimmed.is_empty() {
307
+ return Err(Error::InvalidData("CF epoch is empty".into()));
308
+ }
309
+
310
+ let (date_part, time_part) = split_epoch_date_time(trimmed);
311
+ let (year, month, day) = parse_date(date_part)?;
312
+ let time = match time_part {
313
+ Some(time) => parse_time_of_day(time)?,
314
+ None => CfTimeOfDay::new(0, 0, 0, 0)?,
315
+ };
316
+
317
+ CfDateTime::new(calendar, CfDate::new(year, month, day), time)
318
+ }
319
+
320
+ /// Decode a numeric time value to an exact CF calendar date-time.
321
+ pub fn decode_time_exact(value: f64, time_ref: &CfTimeRef) -> Result<CfDateTime> {
322
+ let offset = offset_from_value(value, time_ref.unit, time_ref.calendar)?;
323
+ add_offset(time_ref.epoch, offset)
324
+ }
325
+
326
+ /// Decode numeric time values to exact CF calendar date-times.
327
+ pub fn decode_times_exact(values: &[f64], time_ref: &CfTimeRef) -> Result<Vec<CfDateTime>> {
328
+ values
329
+ .iter()
330
+ .map(|&value| decode_time_exact(value, time_ref))
331
+ .collect()
332
+ }
333
+
334
+ /// Decode a numeric time value to a UTC DateTime.
335
+ ///
336
+ /// The calendar arithmetic is exact. Conversion to `chrono::DateTime<Utc>`
337
+ /// succeeds only when the exact CF date also exists in chrono's proleptic
338
+ /// Gregorian calendar, and preserves displayed components rather than the
339
+ /// source calendar. Use [`decode_time_exact`] whenever the decoded calendar
340
+ /// itself matters.
341
+ pub fn decode_time(value: f64, time_ref: &CfTimeRef) -> Result<DateTime<Utc>> {
342
+ decode_time_exact(value, time_ref)?.to_chrono_utc()
343
+ }
344
+
345
+ /// Decode a vector of numeric time values.
346
+ pub fn decode_times(values: &[f64], time_ref: &CfTimeRef) -> Result<Vec<DateTime<Utc>>> {
347
+ values.iter().map(|&v| decode_time(v, time_ref)).collect()
348
+ }
349
+
350
+ /// Decode numeric values using the exact CF time metadata on a variable.
351
+ pub fn decode_time_coordinate_values_exact(
352
+ var: &NcVariable,
353
+ values: &[f64],
354
+ ) -> Result<Option<Vec<CfDateTime>>> {
355
+ let Some(time_ref) = time_ref_from_variable(var)? else {
356
+ return Ok(None);
357
+ };
358
+ decode_times_exact(values, &time_ref).map(Some)
359
+ }
360
+
361
+ /// Decode numeric values using the CF time metadata on a variable.
362
+ pub fn decode_time_coordinate_values(
363
+ var: &NcVariable,
364
+ values: &[f64],
365
+ ) -> Result<Option<Vec<DateTime<Utc>>>> {
366
+ let Some(time_ref) = time_ref_from_variable(var)? else {
367
+ return Ok(None);
368
+ };
369
+ decode_times(values, &time_ref).map(Some)
370
+ }
371
+
372
+ const NANOS_PER_SECOND: i128 = 1_000_000_000;
373
+ const NANOS_PER_MINUTE: i128 = 60 * NANOS_PER_SECOND;
374
+ const NANOS_PER_HOUR: i128 = 60 * NANOS_PER_MINUTE;
375
+ const NANOS_PER_DAY: i128 = 24 * NANOS_PER_HOUR;
376
+
377
+ const COMMON_MONTH_LENGTHS: [u8; 12] = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];
378
+ const LEAP_MONTH_LENGTHS: [u8; 12] = [31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];
379
+ const DAY360_MONTH_LENGTHS: [u8; 12] = [30; 12];
380
+ const STANDARD_LAST_JULIAN: (i32, u8, u8) = (1582, 10, 4);
381
+ const STANDARD_FIRST_GREGORIAN: (i32, u8, u8) = (1582, 10, 15);
382
+
383
+ #[derive(Debug, Clone, Copy)]
384
+ struct CalendarOffset {
385
+ months: i64,
386
+ nanoseconds: i128,
387
+ }
388
+
389
+ fn split_epoch_date_time(s: &str) -> (&str, Option<&str>) {
390
+ if let Some((date, time)) = s.split_once('T') {
391
+ let time = time.trim();
392
+ return (date.trim(), (!time.is_empty()).then_some(time));
393
+ }
394
+
395
+ let mut parts = s.splitn(2, char::is_whitespace);
396
+ let date = parts.next().unwrap_or("").trim();
397
+ let time = parts.next().map(str::trim).filter(|time| !time.is_empty());
398
+ (date, time)
399
+ }
400
+
401
+ fn parse_date(s: &str) -> Result<(i32, u8, u8)> {
402
+ let (year_month, day) = s
403
+ .rsplit_once('-')
404
+ .ok_or_else(|| Error::InvalidData(format!("cannot parse CF epoch date '{}'", s)))?;
405
+ let (year, month) = year_month
406
+ .rsplit_once('-')
407
+ .ok_or_else(|| Error::InvalidData(format!("cannot parse CF epoch date '{}'", s)))?;
408
+
409
+ let year = year
410
+ .parse::<i32>()
411
+ .map_err(|_| Error::InvalidData(format!("cannot parse CF epoch year '{}'", year)))?;
412
+ let month = month
413
+ .parse::<u8>()
414
+ .map_err(|_| Error::InvalidData(format!("cannot parse CF epoch month '{}'", month)))?;
415
+ let day = day
416
+ .parse::<u8>()
417
+ .map_err(|_| Error::InvalidData(format!("cannot parse CF epoch day '{}'", day)))?;
418
+
419
+ Ok((year, month, day))
420
+ }
421
+
422
+ fn parse_time_of_day(s: &str) -> Result<CfTimeOfDay> {
423
+ let parts: Vec<&str> = s.split(':').collect();
424
+ if !(2..=3).contains(&parts.len()) {
425
+ return Err(Error::InvalidData(format!(
426
+ "cannot parse CF epoch time '{}'",
427
+ s
428
+ )));
429
+ }
430
+
431
+ let hour = parts[0]
432
+ .parse::<u8>()
433
+ .map_err(|_| Error::InvalidData(format!("cannot parse CF epoch hour '{}'", parts[0])))?;
434
+ let minute = parts[1]
435
+ .parse::<u8>()
436
+ .map_err(|_| Error::InvalidData(format!("cannot parse CF epoch minute '{}'", parts[1])))?;
437
+
438
+ let (second, nanosecond) = if parts.len() == 3 {
439
+ parse_seconds(parts[2])?
440
+ } else {
441
+ (0, 0)
442
+ };
443
+
444
+ CfTimeOfDay::new(hour, minute, second, nanosecond)
445
+ }
446
+
447
+ fn parse_seconds(s: &str) -> Result<(u8, u32)> {
448
+ let (seconds, fraction) = match s.split_once('.') {
449
+ Some((seconds, fraction)) => (seconds, Some(fraction)),
450
+ None => (s, None),
451
+ };
452
+ let second = seconds
453
+ .parse::<u8>()
454
+ .map_err(|_| Error::InvalidData(format!("cannot parse CF epoch second '{}'", seconds)))?;
455
+ let nanosecond = match fraction {
456
+ Some("") => {
457
+ return Err(Error::InvalidData(format!(
458
+ "cannot parse CF epoch fractional second '{}'",
459
+ s
460
+ )));
461
+ }
462
+ Some(frac) if frac.len() <= 9 && frac.bytes().all(|byte| byte.is_ascii_digit()) => {
463
+ let mut nanos = frac.parse::<u32>().map_err(|_| {
464
+ Error::InvalidData(format!(
465
+ "cannot parse CF epoch fractional second '{}'",
466
+ frac
467
+ ))
468
+ })?;
469
+ for _ in frac.len()..9 {
470
+ nanos *= 10;
471
+ }
472
+ nanos
473
+ }
474
+ Some(frac) => {
475
+ return Err(Error::InvalidData(format!(
476
+ "CF epoch fractional second '{}' exceeds nanosecond precision",
477
+ frac
478
+ )));
479
+ }
480
+ None => 0,
481
+ };
482
+ Ok((second, nanosecond))
483
+ }
484
+
485
+ fn validate_date(calendar: CfCalendar, year: i32, month: u8, day: u8) -> Result<()> {
486
+ if !(1..=12).contains(&month) {
487
+ return Err(Error::InvalidData(format!(
488
+ "invalid {:?} month {}",
489
+ calendar, month
490
+ )));
491
+ }
492
+ let max_day = month_length(calendar, year as i128, month);
493
+ if day == 0 || day > max_day {
494
+ return Err(Error::InvalidData(format!(
495
+ "invalid {:?} date {:04}-{:02}-{:02}",
496
+ calendar, year, month, day
497
+ )));
498
+ }
499
+ if calendar == CfCalendar::Standard
500
+ && compare_ymd((year, month, day), STANDARD_LAST_JULIAN).is_gt()
501
+ && compare_ymd((year, month, day), STANDARD_FIRST_GREGORIAN).is_lt()
502
+ {
503
+ return Err(Error::InvalidData(format!(
504
+ "invalid standard calendar date in Gregorian reform gap {:04}-{:02}-{:02}",
505
+ year, month, day
506
+ )));
507
+ }
508
+ Ok(())
509
+ }
510
+
511
+ fn validate_time(hour: u8, minute: u8, second: u8, nanosecond: u32) -> Result<()> {
512
+ if hour > 23 || minute > 59 || second > 59 || nanosecond >= 1_000_000_000 {
513
+ return Err(Error::InvalidData(format!(
514
+ "invalid CF time {:02}:{:02}:{:02}.{:09}",
515
+ hour, minute, second, nanosecond
516
+ )));
517
+ }
518
+ Ok(())
519
+ }
520
+
521
+ fn offset_from_value(value: f64, unit: CfTimeUnit, calendar: CfCalendar) -> Result<CalendarOffset> {
522
+ if !value.is_finite() {
523
+ return Err(Error::InvalidData(format!(
524
+ "CF time value {} is not finite",
525
+ value
526
+ )));
527
+ }
528
+
529
+ match unit {
530
+ CfTimeUnit::Seconds => Ok(CalendarOffset {
531
+ months: 0,
532
+ nanoseconds: rounded_i128(value * NANOS_PER_SECOND as f64, "CF seconds offset")?,
533
+ }),
534
+ CfTimeUnit::Minutes => Ok(CalendarOffset {
535
+ months: 0,
536
+ nanoseconds: rounded_i128(value * NANOS_PER_MINUTE as f64, "CF minutes offset")?,
537
+ }),
538
+ CfTimeUnit::Hours => Ok(CalendarOffset {
539
+ months: 0,
540
+ nanoseconds: rounded_i128(value * NANOS_PER_HOUR as f64, "CF hours offset")?,
541
+ }),
542
+ CfTimeUnit::Days => Ok(CalendarOffset {
543
+ months: 0,
544
+ nanoseconds: rounded_i128(value * NANOS_PER_DAY as f64, "CF days offset")?,
545
+ }),
546
+ CfTimeUnit::Months => {
547
+ let months = integer_i64(value, "CF month offset")?;
548
+ if calendar != CfCalendar::Day360 {
549
+ return Err(Error::InvalidData(format!(
550
+ "CF month offsets are exact only for the 360_day calendar, got {:?}",
551
+ calendar
552
+ )));
553
+ }
554
+ Ok(CalendarOffset {
555
+ months,
556
+ nanoseconds: 0,
557
+ })
558
+ }
559
+ }
560
+ }
561
+
562
+ fn rounded_i128(value: f64, context: &str) -> Result<i128> {
563
+ if !value.is_finite() || value < i128::MIN as f64 || value > i128::MAX as f64 {
564
+ return Err(Error::InvalidData(format!("{context} is out of range")));
565
+ }
566
+ Ok(value.round() as i128)
567
+ }
568
+
569
+ fn integer_i64(value: f64, context: &str) -> Result<i64> {
570
+ if value.fract() != 0.0 {
571
+ return Err(Error::InvalidData(format!("{context} must be an integer")));
572
+ }
573
+ let integer = rounded_i128(value, context)?;
574
+ i64::try_from(integer).map_err(|_| Error::InvalidData(format!("{context} is out of range")))
575
+ }
576
+
577
+ fn add_offset(epoch: CfDateTime, offset: CalendarOffset) -> Result<CfDateTime> {
578
+ let epoch = if offset.months == 0 {
579
+ epoch
580
+ } else {
581
+ add_months(epoch, offset.months)?
582
+ };
583
+
584
+ add_nanoseconds(epoch, offset.nanoseconds)
585
+ }
586
+
587
+ fn add_months(epoch: CfDateTime, months: i64) -> Result<CfDateTime> {
588
+ let month_index = epoch.year as i128 * 12 + i128::from(epoch.month - 1) + i128::from(months);
589
+ let year = floor_div(month_index, 12);
590
+ let month = (month_index - year * 12 + 1) as u8;
591
+ let year = checked_i32(year, "CF month offset year")?;
592
+
593
+ CfDateTime::new(
594
+ epoch.calendar,
595
+ CfDate::new(year, month, epoch.day),
596
+ CfTimeOfDay::new(epoch.hour, epoch.minute, epoch.second, epoch.nanosecond)?,
597
+ )
598
+ }
599
+
600
+ fn add_nanoseconds(epoch: CfDateTime, nanoseconds: i128) -> Result<CfDateTime> {
601
+ let time_nanos = i128::from(epoch.hour) * NANOS_PER_HOUR
602
+ + i128::from(epoch.minute) * NANOS_PER_MINUTE
603
+ + i128::from(epoch.second) * NANOS_PER_SECOND
604
+ + i128::from(epoch.nanosecond);
605
+ let total_nanos = time_nanos
606
+ .checked_add(nanoseconds)
607
+ .ok_or_else(|| Error::InvalidData("CF time offset exceeds i128 capacity".into()))?;
608
+ let day_delta = floor_div(total_nanos, NANOS_PER_DAY);
609
+ let nanos_of_day = total_nanos - day_delta * NANOS_PER_DAY;
610
+
611
+ let day_number = day_number_from_date(epoch.calendar, epoch.year, epoch.month, epoch.day)?
612
+ .checked_add(day_delta)
613
+ .ok_or_else(|| Error::InvalidData("CF date offset exceeds i128 capacity".into()))?;
614
+ let (year, month, day) = date_from_day_number(epoch.calendar, day_number)?;
615
+ let (hour, minute, second, nanosecond) = split_nanos_of_day(nanos_of_day);
616
+
617
+ CfDateTime::new(
618
+ epoch.calendar,
619
+ CfDate::new(year, month, day),
620
+ CfTimeOfDay::new(hour, minute, second, nanosecond)?,
621
+ )
622
+ }
623
+
624
+ fn split_nanos_of_day(nanos: i128) -> (u8, u8, u8, u32) {
625
+ let hour = nanos / NANOS_PER_HOUR;
626
+ let nanos = nanos - hour * NANOS_PER_HOUR;
627
+ let minute = nanos / NANOS_PER_MINUTE;
628
+ let nanos = nanos - minute * NANOS_PER_MINUTE;
629
+ let second = nanos / NANOS_PER_SECOND;
630
+ let nanosecond = nanos - second * NANOS_PER_SECOND;
631
+ (hour as u8, minute as u8, second as u8, nanosecond as u32)
632
+ }
633
+
634
+ fn day_number_from_date(calendar: CfCalendar, year: i32, month: u8, day: u8) -> Result<i128> {
635
+ validate_date(calendar, year, month, day)?;
636
+ if calendar == CfCalendar::Standard {
637
+ return Ok(standard_day_number(year, month, day));
638
+ }
639
+ Ok(days_before_year(calendar, year as i128)
640
+ + days_before_month(calendar, year as i128, month)
641
+ + i128::from(day - 1))
642
+ }
643
+
644
+ fn date_from_day_number(calendar: CfCalendar, day_number: i128) -> Result<(i32, u8, u8)> {
645
+ match calendar {
646
+ CfCalendar::NoLeap => fixed_year_date(calendar, day_number, 365),
647
+ CfCalendar::AllLeap => fixed_year_date(calendar, day_number, 366),
648
+ CfCalendar::Day360 => day360_date(day_number),
649
+ CfCalendar::Julian => julian_date(day_number),
650
+ CfCalendar::Standard => standard_date(day_number),
651
+ CfCalendar::ProlepticGregorian => gregorian_date(day_number),
652
+ }
653
+ }
654
+
655
+ fn fixed_year_date(
656
+ calendar: CfCalendar,
657
+ day_number: i128,
658
+ days_per_year: i128,
659
+ ) -> Result<(i32, u8, u8)> {
660
+ let year = floor_div(day_number, days_per_year);
661
+ let day_of_year = day_number - year * days_per_year;
662
+ date_from_year_day(calendar, year, day_of_year)
663
+ }
664
+
665
+ fn day360_date(day_number: i128) -> Result<(i32, u8, u8)> {
666
+ let year = floor_div(day_number, 360);
667
+ let day_of_year = day_number - year * 360;
668
+ let month = day_of_year / 30 + 1;
669
+ let day = day_of_year % 30 + 1;
670
+ Ok((
671
+ checked_i32(year, "CF 360_day year")?,
672
+ month as u8,
673
+ day as u8,
674
+ ))
675
+ }
676
+
677
+ fn julian_date(day_number: i128) -> Result<(i32, u8, u8)> {
678
+ let cycle = floor_div(day_number, 1_461);
679
+ let mut day_in_cycle = day_number - cycle * 1_461;
680
+ let mut year = cycle * 4;
681
+
682
+ let day_of_year = if day_in_cycle < 366 {
683
+ day_in_cycle
684
+ } else {
685
+ day_in_cycle -= 366;
686
+ year += 1 + day_in_cycle / 365;
687
+ day_in_cycle % 365
688
+ };
689
+
690
+ date_from_year_day(CfCalendar::Julian, year, day_of_year)
691
+ }
692
+
693
+ fn gregorian_date(day_number: i128) -> Result<(i32, u8, u8)> {
694
+ let cycle = floor_div(day_number, 146_097);
695
+ let day_in_cycle = day_number - cycle * 146_097;
696
+ let mut lo = 0i128;
697
+ let mut hi = 400i128;
698
+ while lo + 1 < hi {
699
+ let mid = (lo + hi) / 2;
700
+ if days_before_gregorian_year(mid) <= day_in_cycle {
701
+ lo = mid;
702
+ } else {
703
+ hi = mid;
704
+ }
705
+ }
706
+
707
+ let year = cycle * 400 + lo;
708
+ let day_of_year = day_in_cycle - days_before_gregorian_year(lo);
709
+ date_from_year_day(CfCalendar::ProlepticGregorian, year, day_of_year)
710
+ }
711
+
712
+ fn standard_date(day_number: i128) -> Result<(i32, u8, u8)> {
713
+ let reform_start = julian_day_number_raw(
714
+ STANDARD_LAST_JULIAN.0,
715
+ STANDARD_LAST_JULIAN.1,
716
+ STANDARD_LAST_JULIAN.2,
717
+ ) + 1;
718
+
719
+ if day_number < reform_start {
720
+ julian_date(day_number)
721
+ } else {
722
+ gregorian_date(day_number - standard_gregorian_offset())
723
+ }
724
+ }
725
+
726
+ fn date_from_year_day(
727
+ calendar: CfCalendar,
728
+ year: i128,
729
+ mut day_of_year: i128,
730
+ ) -> Result<(i32, u8, u8)> {
731
+ let year_i32 = checked_i32(year, "CF decoded year")?;
732
+ for month in 1..=12 {
733
+ let month_len = i128::from(month_length(calendar, year, month));
734
+ if day_of_year < month_len {
735
+ return Ok((year_i32, month, (day_of_year + 1) as u8));
736
+ }
737
+ day_of_year -= month_len;
738
+ }
739
+
740
+ Err(Error::InvalidData(format!(
741
+ "CF day-of-year {} is invalid for {:?} year {}",
742
+ day_of_year, calendar, year
743
+ )))
744
+ }
745
+
746
+ fn days_before_year(calendar: CfCalendar, year: i128) -> i128 {
747
+ match calendar {
748
+ CfCalendar::NoLeap => year * 365,
749
+ CfCalendar::AllLeap => year * 366,
750
+ CfCalendar::Day360 => year * 360,
751
+ CfCalendar::Julian => year * 365 + floor_div(year + 3, 4),
752
+ CfCalendar::Standard | CfCalendar::ProlepticGregorian => days_before_gregorian_year(year),
753
+ }
754
+ }
755
+
756
+ fn days_before_gregorian_year(year: i128) -> i128 {
757
+ year * 365 + floor_div(year + 3, 4) - floor_div(year + 99, 100) + floor_div(year + 399, 400)
758
+ }
759
+
760
+ fn days_before_month(calendar: CfCalendar, year: i128, month: u8) -> i128 {
761
+ (1..month)
762
+ .map(|candidate| i128::from(month_length(calendar, year, candidate)))
763
+ .sum()
764
+ }
765
+
766
+ fn standard_day_number(year: i32, month: u8, day: u8) -> i128 {
767
+ if compare_ymd((year, month, day), STANDARD_LAST_JULIAN).is_le() {
768
+ julian_day_number_raw(year, month, day)
769
+ } else {
770
+ gregorian_day_number_raw(year, month, day) + standard_gregorian_offset()
771
+ }
772
+ }
773
+
774
+ fn standard_gregorian_offset() -> i128 {
775
+ julian_day_number_raw(
776
+ STANDARD_LAST_JULIAN.0,
777
+ STANDARD_LAST_JULIAN.1,
778
+ STANDARD_LAST_JULIAN.2,
779
+ ) + 1
780
+ - gregorian_day_number_raw(
781
+ STANDARD_FIRST_GREGORIAN.0,
782
+ STANDARD_FIRST_GREGORIAN.1,
783
+ STANDARD_FIRST_GREGORIAN.2,
784
+ )
785
+ }
786
+
787
+ fn julian_day_number_raw(year: i32, month: u8, day: u8) -> i128 {
788
+ days_before_year(CfCalendar::Julian, year as i128)
789
+ + days_before_month(CfCalendar::Julian, year as i128, month)
790
+ + i128::from(day - 1)
791
+ }
792
+
793
+ fn gregorian_day_number_raw(year: i32, month: u8, day: u8) -> i128 {
794
+ days_before_year(CfCalendar::ProlepticGregorian, year as i128)
795
+ + days_before_month(CfCalendar::ProlepticGregorian, year as i128, month)
796
+ + i128::from(day - 1)
797
+ }
798
+
799
+ fn month_length(calendar: CfCalendar, year: i128, month: u8) -> u8 {
800
+ let index = usize::from(month - 1);
801
+ match calendar {
802
+ CfCalendar::NoLeap => COMMON_MONTH_LENGTHS[index],
803
+ CfCalendar::AllLeap => LEAP_MONTH_LENGTHS[index],
804
+ CfCalendar::Day360 => DAY360_MONTH_LENGTHS[index],
805
+ CfCalendar::Julian => {
806
+ if is_julian_leap_year(year) {
807
+ LEAP_MONTH_LENGTHS[index]
808
+ } else {
809
+ COMMON_MONTH_LENGTHS[index]
810
+ }
811
+ }
812
+ CfCalendar::Standard | CfCalendar::ProlepticGregorian => {
813
+ if is_gregorian_leap_year(year) {
814
+ LEAP_MONTH_LENGTHS[index]
815
+ } else {
816
+ COMMON_MONTH_LENGTHS[index]
817
+ }
818
+ }
819
+ }
820
+ }
821
+
822
+ fn is_julian_leap_year(year: i128) -> bool {
823
+ year.rem_euclid(4) == 0
824
+ }
825
+
826
+ fn is_gregorian_leap_year(year: i128) -> bool {
827
+ year.rem_euclid(4) == 0 && (year.rem_euclid(100) != 0 || year.rem_euclid(400) == 0)
828
+ }
829
+
830
+ fn checked_i32(value: i128, context: &str) -> Result<i32> {
831
+ i32::try_from(value).map_err(|_| Error::InvalidData(format!("{context} is out of range")))
832
+ }
833
+
834
+ fn compare_ymd(left: (i32, u8, u8), right: (i32, u8, u8)) -> std::cmp::Ordering {
835
+ left.0
836
+ .cmp(&right.0)
837
+ .then_with(|| left.1.cmp(&right.1))
838
+ .then_with(|| left.2.cmp(&right.2))
839
+ }
840
+
841
+ fn floor_div(numerator: i128, denominator: i128) -> i128 {
842
+ debug_assert!(denominator > 0);
843
+ let quotient = numerator / denominator;
844
+ let remainder = numerator % denominator;
845
+ if remainder < 0 {
846
+ quotient - 1
847
+ } else {
848
+ quotient
849
+ }
850
+ }
851
+
852
+ #[cfg(test)]
853
+ mod tests {
854
+ use super::*;
855
+ use crate::types::{NcAttrValue, NcAttribute, NcType};
856
+
857
+ fn attr(name: &str, value: &str) -> NcAttribute {
858
+ NcAttribute {
859
+ name: name.into(),
860
+ value: NcAttrValue::Chars(value.into()),
861
+ }
862
+ }
863
+
864
+ fn coordinate_var(name: &str, size: u64, attrs: Vec<NcAttribute>) -> NcVariable {
865
+ NcVariable {
866
+ name: name.into(),
867
+ dimensions: vec![NcDimension {
868
+ name: name.into(),
869
+ size,
870
+ is_unlimited: false,
871
+ }],
872
+ dtype: NcType::Double,
873
+ attributes: attrs,
874
+ data_offset: 0,
875
+ _data_size: 0,
876
+ is_record_var: false,
877
+ record_size: 0,
878
+ }
879
+ }
880
+
881
+ fn dt(calendar: CfCalendar, date: (i32, u8, u8), time: (u8, u8, u8, u32)) -> CfDateTime {
882
+ CfDateTime::new(
883
+ calendar,
884
+ CfDate::new(date.0, date.1, date.2),
885
+ CfTimeOfDay::new(time.0, time.1, time.2, time.3).unwrap(),
886
+ )
887
+ .unwrap()
888
+ }
889
+
890
+ #[test]
891
+ fn parse_days_since() {
892
+ let tr = parse_time_units("days since 1970-01-01", CfCalendar::Standard).unwrap();
893
+ assert_eq!(tr.unit, CfTimeUnit::Days);
894
+ assert_eq!(
895
+ tr.epoch,
896
+ dt(CfCalendar::Standard, (1970, 1, 1), (0, 0, 0, 0))
897
+ );
898
+ }
899
+
900
+ #[test]
901
+ fn parse_hours_since_with_time() {
902
+ let tr = parse_time_units("hours since 2000-01-01 00:00:00", CfCalendar::Standard).unwrap();
903
+ assert_eq!(tr.unit, CfTimeUnit::Hours);
904
+ assert_eq!(
905
+ tr.epoch,
906
+ dt(CfCalendar::Standard, (2000, 1, 1), (0, 0, 0, 0))
907
+ );
908
+ }
909
+
910
+ #[test]
911
+ fn decode_days() {
912
+ let tr = parse_time_units("days since 1970-01-01", CfCalendar::Standard).unwrap();
913
+ let dt = decode_time(365.0, &tr).unwrap();
914
+ assert_eq!(dt.format("%Y-%m-%d").to_string(), "1971-01-01");
915
+ }
916
+
917
+ #[test]
918
+ fn decode_hours() {
919
+ let tr = parse_time_units("hours since 2000-01-01 00:00:00", CfCalendar::Standard).unwrap();
920
+ let dt = decode_time(24.0, &tr).unwrap();
921
+ assert_eq!(dt.format("%Y-%m-%d").to_string(), "2000-01-02");
922
+ }
923
+
924
+ #[test]
925
+ fn calendar_from_str() {
926
+ assert_eq!(CfCalendar::parse("standard"), CfCalendar::Standard);
927
+ assert_eq!(CfCalendar::parse("noleap"), CfCalendar::NoLeap);
928
+ assert_eq!(CfCalendar::parse("365_day"), CfCalendar::NoLeap);
929
+ assert_eq!(CfCalendar::parse("360_day"), CfCalendar::Day360);
930
+ assert_eq!(
931
+ CfCalendar::parse("proleptic_gregorian"),
932
+ CfCalendar::ProlepticGregorian
933
+ );
934
+ }
935
+
936
+ #[test]
937
+ fn invalid_units() {
938
+ assert!(parse_time_units("invalid", CfCalendar::Standard).is_err());
939
+ assert!(parse_time_units("furlongs since yesterday", CfCalendar::Standard).is_err());
940
+ }
941
+
942
+ #[test]
943
+ fn standard_calendar_uses_gregorian_reform_transition() {
944
+ let tr = parse_time_units("days since 1582-10-04", CfCalendar::Standard).unwrap();
945
+
946
+ let exact = decode_time_exact(1.0, &tr).unwrap();
947
+ assert_eq!(
948
+ exact,
949
+ dt(CfCalendar::Standard, (1582, 10, 15), (0, 0, 0, 0))
950
+ );
951
+ assert!(parse_time_units("days since 1582-10-10", CfCalendar::Standard).is_err());
952
+ }
953
+
954
+ #[test]
955
+ fn parse_360_day_epoch_with_february_30() {
956
+ let tr =
957
+ parse_time_units("days since 2000-02-30 06:30:15.250", CfCalendar::Day360).unwrap();
958
+
959
+ assert_eq!(
960
+ tr.epoch,
961
+ dt(CfCalendar::Day360, (2000, 2, 30), (6, 30, 15, 250_000_000))
962
+ );
963
+ assert!(parse_time_units("days since 2000-02-31", CfCalendar::Day360).is_err());
964
+ }
965
+
966
+ #[test]
967
+ fn noleap_calendar_skips_february_29() {
968
+ let tr = parse_time_units("days since 2000-01-01", CfCalendar::NoLeap).unwrap();
969
+
970
+ let exact = decode_time_exact(59.0, &tr).unwrap();
971
+ assert_eq!(exact, dt(CfCalendar::NoLeap, (2000, 3, 1), (0, 0, 0, 0)));
972
+
973
+ let chrono = decode_time(59.0, &tr).unwrap();
974
+ assert_eq!(chrono.format("%Y-%m-%d").to_string(), "2000-03-01");
975
+ }
976
+
977
+ #[test]
978
+ fn all_leap_calendar_has_february_29_every_year() {
979
+ let tr = parse_time_units("days since 2001-02-28", CfCalendar::AllLeap).unwrap();
980
+
981
+ let exact = decode_time_exact(1.0, &tr).unwrap();
982
+ assert_eq!(exact, dt(CfCalendar::AllLeap, (2001, 2, 29), (0, 0, 0, 0)));
983
+ assert!(decode_time(1.0, &tr).is_err());
984
+ }
985
+
986
+ #[test]
987
+ fn calendar_360_day_uses_uniform_30_day_months() {
988
+ let tr = parse_time_units("hours since 2000-01-30 12:00:00", CfCalendar::Day360).unwrap();
989
+
990
+ let exact = decode_time_exact(12.0, &tr).unwrap();
991
+ assert_eq!(exact, dt(CfCalendar::Day360, (2000, 2, 1), (0, 0, 0, 0)));
992
+
993
+ let feb30 = parse_time_units("days since 2000-01-01", CfCalendar::Day360).unwrap();
994
+ let exact = decode_time_exact(59.0, &feb30).unwrap();
995
+ assert_eq!(exact, dt(CfCalendar::Day360, (2000, 2, 30), (0, 0, 0, 0)));
996
+ assert!(decode_time(59.0, &feb30).is_err());
997
+ }
998
+
999
+ #[test]
1000
+ fn julian_calendar_leap_years_are_exact() {
1001
+ let tr = parse_time_units("days since 1900-02-28", CfCalendar::Julian).unwrap();
1002
+
1003
+ let exact = decode_time_exact(1.0, &tr).unwrap();
1004
+ assert_eq!(exact, dt(CfCalendar::Julian, (1900, 2, 29), (0, 0, 0, 0)));
1005
+ assert!(decode_time(1.0, &tr).is_err());
1006
+
1007
+ let exact = decode_time_exact(2.0, &tr).unwrap();
1008
+ assert_eq!(exact, dt(CfCalendar::Julian, (1900, 3, 1), (0, 0, 0, 0)));
1009
+ }
1010
+
1011
+ #[test]
1012
+ fn negative_offsets_use_calendar_arithmetic() {
1013
+ let tr = parse_time_units("days since 2001-01-01", CfCalendar::NoLeap).unwrap();
1014
+
1015
+ let exact = decode_time_exact(-1.0, &tr).unwrap();
1016
+ assert_eq!(exact, dt(CfCalendar::NoLeap, (2000, 12, 31), (0, 0, 0, 0)));
1017
+ }
1018
+
1019
+ #[test]
1020
+ fn calendar_360_day_integer_month_offsets() {
1021
+ let tr = parse_time_units("months since 2000-01-30", CfCalendar::Day360).unwrap();
1022
+
1023
+ let exact = decode_time_exact(1.0, &tr).unwrap();
1024
+ assert_eq!(exact, dt(CfCalendar::Day360, (2000, 2, 30), (0, 0, 0, 0)));
1025
+
1026
+ assert!(decode_time_exact(0.5, &tr).is_err());
1027
+ let gregorian_months =
1028
+ parse_time_units("months since 2000-01-30", CfCalendar::ProlepticGregorian).unwrap();
1029
+ assert!(decode_time_exact(1.0, &gregorian_months).is_err());
1030
+ }
1031
+
1032
+ #[test]
1033
+ fn time_reference_from_variable_uses_units_and_calendar() {
1034
+ let var = coordinate_var(
1035
+ "time",
1036
+ 3,
1037
+ vec![
1038
+ attr("units", "hours since 2001-01-01 12:00:00"),
1039
+ attr("calendar", "proleptic_gregorian"),
1040
+ ],
1041
+ );
1042
+
1043
+ let time_ref = time_ref_from_variable(&var).unwrap().unwrap();
1044
+ assert_eq!(time_ref.unit, CfTimeUnit::Hours);
1045
+ assert_eq!(time_ref.calendar, CfCalendar::ProlepticGregorian);
1046
+ assert_eq!(
1047
+ time_ref.epoch,
1048
+ dt(CfCalendar::ProlepticGregorian, (2001, 1, 1), (12, 0, 0, 0))
1049
+ );
1050
+ }
1051
+
1052
+ #[test]
1053
+ fn discover_time_coordinates_only_uses_coordinate_variables() {
1054
+ let time = coordinate_var("time", 3, vec![attr("units", "days since 1970-01-01")]);
1055
+ let data_time = NcVariable {
1056
+ name: "data_time".into(),
1057
+ dimensions: vec![NcDimension {
1058
+ name: "obs".into(),
1059
+ size: 3,
1060
+ is_unlimited: false,
1061
+ }],
1062
+ dtype: NcType::Double,
1063
+ attributes: vec![attr("units", "days since 1970-01-01")],
1064
+ data_offset: 0,
1065
+ _data_size: 0,
1066
+ is_record_var: false,
1067
+ record_size: 0,
1068
+ };
1069
+ let group = NcGroup {
1070
+ name: "/".into(),
1071
+ dimensions: vec![time.dimensions()[0].clone()],
1072
+ variables: vec![data_time, time],
1073
+ attributes: vec![],
1074
+ groups: vec![],
1075
+ };
1076
+
1077
+ let times = discover_time_coordinates(&group).unwrap();
1078
+ assert_eq!(times.len(), 1);
1079
+ assert_eq!(times[0].variable.name(), "time");
1080
+ assert_eq!(times[0].dimension.name, "time");
1081
+ }
1082
+
1083
+ #[test]
1084
+ fn discovers_variable_time_coordinate() {
1085
+ let time = coordinate_var("time", 3, vec![attr("units", "hours since 2000-01-01")]);
1086
+ let lat = coordinate_var("lat", 2, vec![attr("units", "degrees_north")]);
1087
+ let temperature = NcVariable {
1088
+ name: "temperature".into(),
1089
+ dimensions: vec![time.dimensions()[0].clone(), lat.dimensions()[0].clone()],
1090
+ dtype: NcType::Float,
1091
+ attributes: vec![],
1092
+ data_offset: 0,
1093
+ _data_size: 0,
1094
+ is_record_var: false,
1095
+ record_size: 0,
1096
+ };
1097
+ let group = NcGroup {
1098
+ name: "/".into(),
1099
+ dimensions: vec![time.dimensions()[0].clone(), lat.dimensions()[0].clone()],
1100
+ variables: vec![lat, time, temperature.clone()],
1101
+ attributes: vec![],
1102
+ groups: vec![],
1103
+ };
1104
+
1105
+ let discovered = discover_variable_time_coordinate(&temperature, &group)
1106
+ .unwrap()
1107
+ .unwrap();
1108
+ assert_eq!(discovered.variable.name(), "time");
1109
+ assert_eq!(discovered.time_ref.unit, CfTimeUnit::Hours);
1110
+ }
1111
+
1112
+ #[test]
1113
+ fn time_coordinate_values_decode_from_units() {
1114
+ let var = coordinate_var("time", 2, vec![attr("units", "days since 1970-01-01")]);
1115
+
1116
+ let decoded = decode_time_coordinate_values(&var, &[0.0, 1.0])
1117
+ .unwrap()
1118
+ .unwrap();
1119
+ assert_eq!(decoded[0].format("%Y-%m-%d").to_string(), "1970-01-01");
1120
+ assert_eq!(decoded[1].format("%Y-%m-%d").to_string(), "1970-01-02");
1121
+ }
1122
+ }