@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.
- package/THIRD_PARTY_NOTICES.md +49 -0
- package/nirs4all_formats_wasm.d.ts +4 -4
- package/nirs4all_formats_wasm.js +170 -149
- package/nirs4all_formats_wasm_bg.wasm +0 -0
- package/package.json +4 -2
- package/reader-backports/hdf5-reader/Cargo.toml +119 -0
- package/reader-backports/hdf5-reader/LICENSE-APACHE +164 -0
- package/reader-backports/hdf5-reader/LICENSE-MIT +21 -0
- package/reader-backports/hdf5-reader/PROVENANCE.json +80 -0
- package/reader-backports/hdf5-reader/README.md +308 -0
- package/reader-backports/hdf5-reader/UPSTREAM-Cargo.toml +44 -0
- package/reader-backports/hdf5-reader/UPSTREAM-VCS.json +6 -0
- package/reader-backports/hdf5-reader/src/attribute_api.rs +847 -0
- package/reader-backports/hdf5-reader/src/btree_v1.rs +726 -0
- package/reader-backports/hdf5-reader/src/btree_v2.rs +2068 -0
- package/reader-backports/hdf5-reader/src/cache.rs +354 -0
- package/reader-backports/hdf5-reader/src/checksum.rs +56 -0
- package/reader-backports/hdf5-reader/src/chunk_index.rs +423 -0
- package/reader-backports/hdf5-reader/src/dataset.rs +4733 -0
- package/reader-backports/hdf5-reader/src/datatype_api.rs +497 -0
- package/reader-backports/hdf5-reader/src/error.rs +167 -0
- package/reader-backports/hdf5-reader/src/extensible_array.rs +1886 -0
- package/reader-backports/hdf5-reader/src/filters/deflate.rs +93 -0
- package/reader-backports/hdf5-reader/src/filters/fletcher32.rs +52 -0
- package/reader-backports/hdf5-reader/src/filters/lz4.rs +178 -0
- package/reader-backports/hdf5-reader/src/filters/mod.rs +326 -0
- package/reader-backports/hdf5-reader/src/filters/nbit.rs +586 -0
- package/reader-backports/hdf5-reader/src/filters/scaleoffset.rs +827 -0
- package/reader-backports/hdf5-reader/src/filters/shuffle.rs +99 -0
- package/reader-backports/hdf5-reader/src/fixed_array.rs +763 -0
- package/reader-backports/hdf5-reader/src/fractal_heap.rs +2029 -0
- package/reader-backports/hdf5-reader/src/global_heap.rs +284 -0
- package/reader-backports/hdf5-reader/src/group.rs +795 -0
- package/reader-backports/hdf5-reader/src/io.rs +413 -0
- package/reader-backports/hdf5-reader/src/lib.rs +916 -0
- package/reader-backports/hdf5-reader/src/local_heap.rs +261 -0
- package/reader-backports/hdf5-reader/src/messages/attribute.rs +304 -0
- package/reader-backports/hdf5-reader/src/messages/attribute_info.rs +96 -0
- package/reader-backports/hdf5-reader/src/messages/btree_k.rs +36 -0
- package/reader-backports/hdf5-reader/src/messages/continuation.rs +46 -0
- package/reader-backports/hdf5-reader/src/messages/dataspace.rs +259 -0
- package/reader-backports/hdf5-reader/src/messages/datatype.rs +938 -0
- package/reader-backports/hdf5-reader/src/messages/external_files.rs +50 -0
- package/reader-backports/hdf5-reader/src/messages/fill_value.rs +233 -0
- package/reader-backports/hdf5-reader/src/messages/filter_pipeline.rs +147 -0
- package/reader-backports/hdf5-reader/src/messages/group_info.rs +103 -0
- package/reader-backports/hdf5-reader/src/messages/layout.rs +476 -0
- package/reader-backports/hdf5-reader/src/messages/link.rs +170 -0
- package/reader-backports/hdf5-reader/src/messages/link_info.rs +127 -0
- package/reader-backports/hdf5-reader/src/messages/mod.rs +374 -0
- package/reader-backports/hdf5-reader/src/messages/modification_time.rs +83 -0
- package/reader-backports/hdf5-reader/src/messages/shared.rs +164 -0
- package/reader-backports/hdf5-reader/src/messages/shared_table.rs +67 -0
- package/reader-backports/hdf5-reader/src/messages/symbol_table_msg.rs +51 -0
- package/reader-backports/hdf5-reader/src/object_header.rs +1749 -0
- package/reader-backports/hdf5-reader/src/reference.rs +90 -0
- package/reader-backports/hdf5-reader/src/shared_message_table.rs +425 -0
- package/reader-backports/hdf5-reader/src/storage.rs +538 -0
- package/reader-backports/hdf5-reader/src/superblock.rs +285 -0
- package/reader-backports/hdf5-reader/src/symbol_table.rs +277 -0
- package/reader-backports/netcdf-reader/Cargo.toml +141 -0
- package/reader-backports/netcdf-reader/LICENSE-APACHE +164 -0
- package/reader-backports/netcdf-reader/LICENSE-MIT +21 -0
- package/reader-backports/netcdf-reader/PROVENANCE.json +55 -0
- package/reader-backports/netcdf-reader/README.md +308 -0
- package/reader-backports/netcdf-reader/UPSTREAM-Cargo.toml +48 -0
- package/reader-backports/netcdf-reader/UPSTREAM-VCS.json +6 -0
- package/reader-backports/netcdf-reader/src/cf/axes.rs +419 -0
- package/reader-backports/netcdf-reader/src/cf/bounds.rs +108 -0
- package/reader-backports/netcdf-reader/src/cf/crs.rs +269 -0
- package/reader-backports/netcdf-reader/src/cf/mod.rs +30 -0
- package/reader-backports/netcdf-reader/src/cf/time.rs +1122 -0
- package/reader-backports/netcdf-reader/src/classic/data.rs +1465 -0
- package/reader-backports/netcdf-reader/src/classic/header.rs +1097 -0
- package/reader-backports/netcdf-reader/src/classic/mod.rs +240 -0
- package/reader-backports/netcdf-reader/src/classic/storage.rs +211 -0
- package/reader-backports/netcdf-reader/src/classic/types.rs +93 -0
- package/reader-backports/netcdf-reader/src/classic/variable.rs +1162 -0
- package/reader-backports/netcdf-reader/src/error.rs +59 -0
- package/reader-backports/netcdf-reader/src/lib.rs +1531 -0
- package/reader-backports/netcdf-reader/src/masked.rs +173 -0
- package/reader-backports/netcdf-reader/src/nc4/attributes.rs +203 -0
- package/reader-backports/netcdf-reader/src/nc4/dimensions.rs +139 -0
- package/reader-backports/netcdf-reader/src/nc4/groups.rs +308 -0
- package/reader-backports/netcdf-reader/src/nc4/mod.rs +572 -0
- package/reader-backports/netcdf-reader/src/nc4/types.rs +309 -0
- package/reader-backports/netcdf-reader/src/nc4/variables.rs +420 -0
- package/reader-backports/netcdf-reader/src/types.rs +18 -0
- package/reader-backports/netcdf-reader/src/unpack.rs +113 -0
- 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
|
+
}
|