formatjs_temporal 1.0.0

Temporal calendar, date, time and timezone primitives
use crate::calendar_difference::{RelativeAnchor, difference, validate_options};
use crate::{
    CalendarProvider, Duration, Error, Overflow, RoundingMode, TimeZone, ZonedDateTime, ZonedUnit,
};

impl<Z: TimeZone + Clone + PartialEq, C: CalendarProvider> ZonedDateTime<Z, C> {
    pub fn total_duration(&self, duration: Duration, unit: ZonedUnit) -> Result<f64, Error> {
        if unit == ZonedUnit::Day {
            self.validate_duration_day(duration)?;
        }
        if duration.sign() == 0 {
            return Ok(0.0);
        }
        let end = self.checked_add(duration, Overflow::Constrain)?;
        let finish = end.instant().epoch_nanoseconds();
        total(self, finish, unit)
    }
    pub fn round_duration(
        &self,
        duration: Duration,
        largest: ZonedUnit,
        smallest: ZonedUnit,
        increment: u32,
        mode: RoundingMode,
    ) -> Result<Duration, Error> {
        if smallest <= ZonedUnit::Day && largest < smallest && increment != 1 {
            return Err(Error::InvalidRoundingOptions);
        }
        if largest == ZonedUnit::Day {
            self.validate_duration_day(duration)?;
        }
        let end = self.checked_add(duration, Overflow::Constrain)?;
        round(
            self,
            end.instant().epoch_nanoseconds(),
            largest,
            smallest,
            increment,
            mode,
        )
    }

    pub fn compare_durations(
        &self,
        one: Duration,
        two: Duration,
    ) -> Result<core::cmp::Ordering, Error> {
        let left = one.fields();
        let right = two.fields();
        if left[..4] == right[..4] {
            return Ok(one
                .time_nanoseconds(false)?
                .cmp(&two.time_nanoseconds(false)?));
        }
        Ok(self
            .checked_add(one, Overflow::Constrain)?
            .instant()
            .cmp(&self.checked_add(two, Overflow::Constrain)?.instant()))
    }
    fn validate_duration_day(&self, duration: Duration) -> Result<(), Error> {
        let mut fields = duration.fields();
        fields[4..].fill(0);
        let anchor = self.checked_add(Duration::new(fields)?, Overflow::Constrain)?;
        let mut day = [0; 10];
        day[3] = if duration.sign() == 0 {
            1
        } else {
            i128::from(duration.sign())
        };
        anchor.checked_add(Duration::new(day)?, Overflow::Constrain)?;
        Ok(())
    }
}

pub(crate) fn total<A: RelativeAnchor>(
    start: &A,
    finish: i128,
    unit: ZonedUnit,
) -> Result<f64, Error> {
    let origin = start.origin();
    if let Some(time) = unit.time() {
        return Ok(crate::duration::rational_to_f64(
            finish - origin,
            time.nanoseconds(),
        ));
    }
    let difference = difference(
        start,
        finish,
        unit,
        ZonedUnit::Nanosecond,
        1,
        RoundingMode::Trunc,
        false,
    )?;
    let mut count = difference.fields()[unit as usize];
    let mut fields = [0; 10];
    fields[unit as usize] = count;
    let mut a = start.endpoint(fields)?;
    let sign = (finish - origin).signum();
    while (a - finish) * sign > 0 {
        count -= sign;
        fields[unit as usize] = count;
        a = start.endpoint(fields)?;
    }
    if a == finish {
        return Ok(count as f64);
    }
    fields[unit as usize] = count + sign;
    let mut b = start.endpoint(fields)?;
    while (finish - b) * sign >= 0 {
        count += sign;
        a = b;
        if a == finish {
            return Ok(count as f64);
        }
        fields[unit as usize] = count + sign;
        b = start.endpoint(fields)?;
    }
    let span = (b - a) * sign;
    Ok(crate::duration::rational_to_f64(
        count * span + finish - a,
        span,
    ))
}
pub(crate) fn round<A: RelativeAnchor>(
    start: &A,
    finish: i128,
    largest: ZonedUnit,
    smallest: ZonedUnit,
    increment: u32,
    mode: RoundingMode,
) -> Result<Duration, Error> {
    validate_options(largest, smallest, increment)?;
    if smallest <= ZonedUnit::Day && largest < smallest && increment != 1 {
        return Err(Error::InvalidRoundingOptions);
    }
    if smallest == ZonedUnit::Week && largest < ZonedUnit::Week {
        let full = difference(
            start,
            finish,
            largest,
            ZonedUnit::Nanosecond,
            1,
            RoundingMode::Trunc,
            false,
        )?
        .fields();
        let mut fields = [0; 10];
        fields[..2].copy_from_slice(&full[..2]);
        let count = full[2] + full[3] / 7;
        fields[2] = count;
        let a = start.endpoint(fields)?;
        if a == finish {
            return Duration::new(fields);
        }
        let sign = (finish - start.origin()).signum();
        fields[2] = count + sign;
        let b = start.endpoint(fields)?;
        let span = (b - a) * sign;
        fields[2] = crate::rounding::round_duration(count * span + finish - a, span, mode) / span;
        return Duration::new(fields);
    }
    difference(start, finish, largest, smallest, increment, mode, false)
}