1use chrono::{Datelike, Duration as ChronoDur, NaiveDateTime, NaiveTime};
12
13use crate::{Error, Result};
14
15use super::arith::{add_months, checked_add_dur};
16use super::zone::{add_offset, sub_offset, zone_offset_at, zone_region};
17use super::{civil_epoch_days, range_err, time_to_nanos, utc_time_nanos, Temporal, NANOS_PER_DAY};
18
19fn utc_in_zone(local: NaiveDateTime, zone: &str) -> Option<NaiveDateTime> {
20 let offset = zone_offset_at(zone, local).ok()?;
24 sub_offset(local, offset).ok()
25}
26
27fn as_utc_instant(t: &Temporal, ctx: &Temporal, zone: &str) -> Option<NaiveDateTime> {
30 match t {
31 Temporal::DateTime { utc, .. } => Some(*utc),
32 Temporal::Date(d) => utc_in_zone(d.and_time(NaiveTime::MIN), zone),
33 Temporal::LocalDateTime(dt) => utc_in_zone(*dt, zone),
34 Temporal::LocalTime(tm) => utc_in_zone(wall_dt(ctx)?.date().and_time(*tm), zone),
35 Temporal::Time { time, offset } => {
36 let local = wall_dt(ctx)?.date().and_time(*time);
37 add_offset(local, offset.checked_neg()?).ok()
41 }
42 Temporal::Duration { .. } | Temporal::CivilDate { .. } | Temporal::CivilDateTime { .. } => {
43 None
44 }
45 }
46}
47
48fn wall_dt(t: &Temporal) -> Option<NaiveDateTime> {
49 match t {
50 Temporal::Date(d) => Some(d.and_time(NaiveTime::MIN)),
51 Temporal::LocalDateTime(dt) => Some(*dt),
52 Temporal::CivilDate { .. } | Temporal::CivilDateTime { .. } => None,
53 Temporal::DateTime { utc, offset, .. } => add_offset(*utc, *offset).ok(),
54 _ => None,
55 }
56}
57
58fn utc_dt(t: &Temporal) -> Option<NaiveDateTime> {
59 match t {
60 Temporal::DateTime { utc, .. } => Some(*utc),
61 other => wall_dt(other),
62 }
63}
64
65fn time_nanos_of(t: &Temporal, as_utc: bool) -> Option<i64> {
66 match t {
67 Temporal::LocalTime(tm) => Some(time_to_nanos(*tm)),
68 Temporal::Time { time, offset } => Some(if as_utc {
69 utc_time_nanos(*time, *offset)
70 } else {
71 time_to_nanos(*time)
72 }),
73 Temporal::Date(_) => Some(0),
74 Temporal::LocalDateTime(dt) => Some(time_to_nanos(dt.time())),
75 Temporal::DateTime { utc, offset, .. } => {
76 if as_utc {
77 Some(time_to_nanos(utc.time()))
78 } else {
79 let local = add_offset(*utc, *offset).ok()?;
80 Some(time_to_nanos(local.time()))
81 }
82 }
83 Temporal::Duration { .. } => None,
84 Temporal::CivilDate { .. } => Some(0),
85 Temporal::CivilDateTime { time, .. } => Some(time_to_nanos(*time)),
86 }
87}
88
89fn overshot(da: NaiveDateTime, db: NaiveDateTime, t: NaiveDateTime) -> bool {
92 if db >= da {
93 t > db
94 } else {
95 t < db
96 }
97}
98
99fn nanos_between(da: NaiveDateTime, db: NaiveDateTime) -> i128 {
104 i128::from((db.date() - da.date()).num_days()) * NANOS_PER_DAY
105 + i128::from(time_to_nanos(db.time()))
106 - i128::from(time_to_nanos(da.time()))
107}
108
109struct BetweenFields {
115 months: i64,
116 days: i64,
121 nanos: i128,
122 span_days: i128,
123 span_nanos: i128,
124}
125
126impl BetweenFields {
127 fn from_nanos(nanos: i128) -> Self {
130 Self {
131 months: 0,
132 days: 0,
133 nanos,
134 span_days: 0,
135 span_nanos: nanos,
136 }
137 }
138}
139
140fn shaped_duration(fields: BetweenFields, unit: BetweenUnit) -> Result<Temporal> {
147 let (months, days, nanos) = match unit {
151 BetweenUnit::Full => (fields.months, fields.days, fields.nanos),
152 BetweenUnit::Months => (fields.months, 0, 0),
153 BetweenUnit::Days => (
154 0,
155 i64::try_from(fields.span_days).map_err(|_| range_err())?,
156 0,
157 ),
158 BetweenUnit::Seconds => (0, 0, fields.span_nanos),
159 };
160 Temporal::duration_checked(months, days, nanos)
161}
162
163fn calendar_between(da: NaiveDateTime, db: NaiveDateTime) -> Result<BetweenFields> {
168 let months =
170 i64::from(db.year() - da.year()) * 12 + i64::from(db.month()) - i64::from(da.month());
171 let step = if db >= da { 1 } else { -1 };
172 let mut adj_months = months;
173 let tentative = add_months(da, adj_months)?;
174 if overshot(da, db, tentative) {
175 adj_months -= step;
176 }
177 let after_m = add_months(da, adj_months)?;
178 let days = (db.date() - after_m.date()).num_days();
179 let mut adj_days = days;
180 let after_d = checked_add_dur(after_m, ChronoDur::try_days(adj_days))?;
181 if overshot(da, db, after_d) {
182 adj_days -= step;
183 }
184 let after_d = checked_add_dur(after_m, ChronoDur::try_days(adj_days))?;
185 Ok(BetweenFields {
187 months: adj_months,
188 days: adj_days,
189 nanos: nanos_between(after_d, db),
190 span_days: i128::from((db - da).num_days()),
191 span_nanos: nanos_between(da, db),
192 })
193}
194
195pub fn duration_between(a: &Temporal, b: &Temporal) -> Result<Temporal> {
196 duration_between_unit(a, b, BetweenUnit::Full)
197}
198
199#[derive(Clone, Copy)]
200pub enum BetweenUnit {
201 Full,
202 Months,
203 Days,
204 Seconds,
205}
206
207#[derive(Clone, Copy)]
210struct CivilParts {
211 year: i64,
212 month: u32,
213 day: u32,
214 nanos: i64,
215}
216
217fn civil_parts(t: &Temporal) -> Option<CivilParts> {
218 match t {
219 Temporal::CivilDate { year, month, day } => Some(CivilParts {
220 year: *year,
221 month: *month,
222 day: *day,
223 nanos: 0,
224 }),
225 Temporal::CivilDateTime {
226 year,
227 month,
228 day,
229 time,
230 } => Some(CivilParts {
231 year: *year,
232 month: *month,
233 day: *day,
234 nanos: time_to_nanos(*time),
235 }),
236 Temporal::Date(d) => Some(CivilParts {
237 year: i64::from(d.year()),
238 month: d.month(),
239 day: d.day(),
240 nanos: 0,
241 }),
242 Temporal::LocalDateTime(dt) => Some(CivilParts {
243 year: i64::from(dt.year()),
244 month: dt.month(),
245 day: dt.day(),
246 nanos: time_to_nanos(dt.time()),
247 }),
248 _ => None,
249 }
250}
251
252fn is_civil(t: &Temporal) -> bool {
254 matches!(
255 t,
256 Temporal::CivilDate { .. } | Temporal::CivilDateTime { .. }
257 )
258}
259
260fn civil_parts_pair(a: &Temporal, b: &Temporal) -> Option<(CivilParts, CivilParts)> {
264 if !is_civil(a) && !is_civil(b) {
265 return None;
266 }
267 Some((civil_parts(a)?, civil_parts(b)?))
268}
269
270fn civil_fields(a: CivilParts, b: CivilParts) -> Result<BetweenFields> {
275 let months =
278 (i128::from(b.year) - i128::from(a.year)) * 12 + i128::from(b.month) - i128::from(a.month);
279 let months = i64::try_from(months).map_err(|_| range_err())?;
280 let span_days =
281 civil_epoch_days(b.year, b.month, b.day) - civil_epoch_days(a.year, a.month, a.day);
282 let nanos = i128::from(b.nanos) - i128::from(a.nanos);
283 Ok(BetweenFields {
284 months,
285 days: i64::from(b.day) - i64::from(a.day),
286 nanos,
287 span_days,
288 span_nanos: span_days * NANOS_PER_DAY + nanos,
290 })
291}
292
293fn civil_duration(a: CivilParts, b: CivilParts, unit: BetweenUnit) -> Result<Temporal> {
295 shaped_duration(civil_fields(a, b)?, unit)
296}
297
298enum PairDomain<'a> {
302 Civil { a: CivilParts, b: CivilParts },
305 TimeOnly { as_utc: bool, both_times: bool },
310 Zoned { zone: &'a str, ctx: &'a Temporal },
313 Instant,
315 Wall,
317}
318
319enum OperandShape<'a> {
322 Time { zoned: bool },
325 DateTime { zone: Option<&'a str> },
327 Other,
329}
330
331fn operand_shape(t: &Temporal) -> OperandShape<'_> {
332 match t {
333 Temporal::LocalTime(_) => OperandShape::Time { zoned: false },
334 Temporal::Time { .. } => OperandShape::Time { zoned: true },
335 Temporal::DateTime { zone, .. } => OperandShape::DateTime {
336 zone: zone_region(zone.as_deref()),
337 },
338 Temporal::Date(_)
339 | Temporal::CivilDate { .. }
340 | Temporal::LocalDateTime(_)
341 | Temporal::CivilDateTime { .. }
342 | Temporal::Duration { .. } => OperandShape::Other,
343 }
344}
345
346fn pair_domain<'a>(a: &'a Temporal, b: &'a Temporal) -> PairDomain<'a> {
347 if let Some((a_parts, b_parts)) = civil_parts_pair(a, b) {
348 return PairDomain::Civil {
349 a: a_parts,
350 b: b_parts,
351 };
352 }
353 use OperandShape::*;
354 match (operand_shape(a), operand_shape(b)) {
355 (Time { zoned: za }, Time { zoned: zb }) => PairDomain::TimeOnly {
357 as_utc: za && zb,
358 both_times: true,
359 },
360 (Time { zoned }, DateTime { zone: None }) | (DateTime { zone: None }, Time { zoned }) => {
364 PairDomain::TimeOnly {
365 as_utc: zoned,
366 both_times: false,
367 }
368 }
369 (Time { .. }, Other) | (Other, Time { .. }) => PairDomain::TimeOnly {
371 as_utc: false,
372 both_times: false,
373 },
374 (DateTime { zone: Some(zone) }, _) => PairDomain::Zoned { zone, ctx: a },
377 (_, DateTime { zone: Some(zone) }) => PairDomain::Zoned { zone, ctx: b },
378 (DateTime { zone: None }, DateTime { zone: None }) => PairDomain::Instant,
380 (DateTime { zone: None }, Other) | (Other, DateTime { zone: None }) | (Other, Other) => {
382 PairDomain::Wall
383 }
384 }
385}
386
387fn map_pair<T>(a: &Temporal, b: &Temporal, f: impl Fn(&Temporal) -> Option<T>) -> Result<(T, T)> {
391 let map_one = |t: &Temporal| f(t).ok_or_else(between_err);
392 Ok((map_one(a)?, map_one(b)?))
393}
394
395fn between_err() -> Error {
398 Error::ty("duration.between")
399}
400
401fn calendar_duration(da: NaiveDateTime, db: NaiveDateTime, unit: BetweenUnit) -> Result<Temporal> {
403 shaped_duration(calendar_between(da, db)?, unit)
404}
405
406pub fn duration_between_unit(a: &Temporal, b: &Temporal, unit: BetweenUnit) -> Result<Temporal> {
407 match pair_domain(a, b) {
408 PairDomain::Civil {
409 a: a_parts,
410 b: b_parts,
411 } => civil_duration(a_parts, b_parts, unit),
412 PairDomain::TimeOnly { as_utc, both_times } => {
413 let (a_nanos, b_nanos) = map_pair(a, b, |t| time_nanos_of(t, as_utc))?;
414 if both_times && matches!(unit, BetweenUnit::Months | BetweenUnit::Days) {
418 return Err(Error::ty("Unsupported unit for a pair of times"));
419 }
420 shaped_duration(
421 BetweenFields::from_nanos(i128::from(b_nanos) - i128::from(a_nanos)),
422 unit,
423 )
424 }
425 PairDomain::Zoned { zone, ctx } => {
426 let (da, db) = map_pair(a, b, |t| as_utc_instant(t, ctx, zone))?;
427 calendar_duration(da, db, unit)
428 }
429 PairDomain::Instant => {
430 let (da, db) = map_pair(a, b, utc_dt)?;
431 calendar_duration(da, db, unit)
432 }
433 PairDomain::Wall => {
434 let (da, db) = map_pair(a, b, wall_dt)?;
435 calendar_duration(da, db, unit)
436 }
437 }
438}