jiff::util::t

Type Alias UnixSeconds

Help

pub(crate) type UnixSeconds = ri64<{ _ }, { _ }>;

Expand description

The range of Unix seconds supported by Jiff.

This range should correspond to the first second of Year::MIN up through (and including) the last second of Year::MAX. Actually computing that is non-trivial, however, it can be computed easily enough using Unix programs like date:

$ TZ=0 date -d 'Mon Jan  1 12:00:00 AM  -9999' +'%s'
date: invalid date ‘Mon Jan  1 12:00:00 AM  -9999’
$ TZ=0 date -d 'Fri Dec 31 23:59:59  9999' +'%s'
253402300799

Well, almost easily enough. date apparently doesn’t support negative years. But it does support negative timestamps:

$ TZ=0 date -d '@-377705116800'
Mon Jan  1 12:00:00 AM  -9999
$ TZ=0 date -d '@253402300799'
Fri Dec 31 11:59:59 PM  9999

With that said, we actually end up restricting the range a bit more than what’s above. Namely, what’s above is what we support for civil datetimes. Because of time zones, we need to choose whether all Timestamp values can be infallibly converted to civil::DateTime values, or whether all civil::DateTime values can be infallibly converted to Timestamp values. I chose the former because getting a civil datetime is important for formatting. If I didn’t choose the former, there would be some instants that could not be formatted. Thus, we make room by shrinking the range of allowed instants by precisely the maximum supported time zone offset.

Aliased Type§

struct UnixSeconds {
    pub(crate) val: i64,
    pub(crate) min: i64,
    pub(crate) max: i64,
}

Fields§

§val: i64

The actual value of the integer.

Callers should not access this directly. There are some very rare cases where algorithms are too difficult to express on ranged integers, and it’s useful to be able to reach inside and access the raw value directly. (For example, the conversions between Unix epoch day and Gregorian date.)

§min: i64

The minimum possible value computed so far.

This value is only present when debug_assertions are enabled. In that case, it is used to ensure the minimum possible value when the integer is actually observed (or converted) is still within the legal range.

Callers should not access this directly. There are some very rare cases where algorithms are too difficult to express on ranged integers, and it’s useful to be able to reach inside and access the raw value directly. (For example, the conversions between Unix epoch day and Gregorian date.)

§max: i64

The maximum possible value computed so far.

This value is only present when debug_assertions are enabled. In that case, it is used to ensure the maximum possible value when the integer is actually observed (or converted) is still within the legal range.

Callers should not access this directly. There are some very rare cases where algorithms are too difficult to express on ranged integers, and it’s useful to be able to reach inside and access the raw value directly. (For example, the conversions between Unix epoch day and Gregorian date.)

Type Alias UnixSecondsCopy item path

Aliased Type§

Fields§

Implementations

impl<const MIN: i128, const MAX: i128> ri64<MIN, MAX>

const PRIMITIVE_MIN: i128 = -9_223_372_036_854_775_808i128

const PRIMITIVE_MAX: i128 = 9_223_372_036_854_775_807i128

const IS_PRIMITIVE: bool

pub(crate) const MIN: i128 = MIN

pub(crate) const MAX: i128 = MAX

pub(crate) const LEN: i128

pub(crate) const MIN_REPR: i64

pub(crate) const MAX_REPR: i64

pub(crate) const MIN_SELF: Self

pub(crate) const MAX_SELF: Self

pub(crate) const MIN_CONST: Constant

pub(crate) const MAX_CONST: Constant

pub(crate) fn error(what: &'static str, given: i64) -> Error

pub(crate) fn new(val: impl TryInto<i64>) -> Option<Self>

pub(crate) const fn new_const(val: i64) -> Option<Self>

pub(crate) fn try_new( what: &'static str, val: impl Into<i64>, ) -> Result<Self, Error>

pub(crate) fn try_new128( what: &'static str, val: impl Into<i128>, ) -> Result<Self, Error>

pub(crate) fn constrain(val: impl Into<i64>) -> Self

pub(crate) const fn new_unchecked(val: i64) -> Self

pub(crate) const fn N<const VAL: i64>() -> Self

pub(crate) const fn N128<const VAL: i128>() -> Self

pub(crate) const fn V<const VAL: i64, const START: i64, const END: i64>() -> Self

pub(crate) const fn contains(val: i64) -> bool

pub(crate) fn vary<const N: usize, const MIN2: i128, const MAX2: i128>( numbers: [Self; N], with: impl Fn([Self; N]) -> ri64<MIN2, MAX2>, ) -> ri64<MIN2, MAX2>

pub(crate) fn vary_many<const N: usize, const M: usize, const MIN2: i128, const MAX2: i128>( numbers: [Self; N], with: impl Fn([Self; N]) -> [ri64<MIN2, MAX2>; M], ) -> [ri64<MIN2, MAX2>; M]

pub(crate) fn get(self) -> i64

pub(crate) const fn get_unchecked(self) -> i64

pub(crate) fn to_error_with_bounds( self, what: &'static str, min: impl Into<i128>, max: impl Into<i128>, ) -> Error

pub(crate) fn abs(self) -> Self

pub(crate) fn signum(self) -> ri64<-1, 1>

pub(crate) fn min(self, other: impl RInto<Self>) -> Self

pub(crate) fn max(self, other: impl RInto<Self>) -> Self

pub(crate) fn clamp(self, min: impl RInto<Self>, max: impl RInto<Self>) -> Self

pub(crate) fn div_ceil(self, rhs: impl RInto<Self>) -> Self

pub(crate) fn div_floor(self, rhs: impl RInto<Self>) -> Self

pub(crate) fn rem_ceil(self, rhs: impl RInto<Self>) -> Self

pub(crate) fn rem_floor(self, rhs: impl RInto<Self>) -> Self

pub(crate) fn try_checked_add( self, what: &'static str, rhs: impl RInto<Self>, ) -> Result<Self, Error>

pub(crate) fn try_checked_sub( self, what: &'static str, rhs: impl RInto<Self>, ) -> Result<Self, Error>

pub(crate) fn try_checked_mul( self, what: &'static str, rhs: impl RInto<Self>, ) -> Result<Self, Error>

pub(crate) fn checked_add(self, rhs: impl RInto<Self>) -> Option<Self>

pub(crate) fn checked_sub(self, rhs: impl RInto<Self>) -> Option<Self>

pub(crate) fn checked_mul(self, rhs: impl RInto<Self>) -> Option<Self>

pub(crate) fn wrapping_add(self, rhs: impl RInto<Self>) -> Self

pub(crate) fn wrapping_sub(self, rhs: impl RInto<Self>) -> Self

pub(crate) fn wrapping_mul(self, rhs: impl RInto<Self>) -> Self

pub(crate) fn saturating_add(self, rhs: impl RInto<Self>) -> Self

pub(crate) fn saturating_sub(self, rhs: impl RInto<Self>) -> Self

pub(crate) fn saturating_mul(self, rhs: impl RInto<Self>) -> Self

pub(crate) fn debug(self) -> RangedDebug<MIN, MAX>

impl<const MIN: i128, const MAX: i128> ri64<MIN, MAX>

pub(crate) fn without_bounds(self) -> ri64<{ _ }, { _ }>

Trait Implementations

impl<const MIN: i128, const MAX: i128> Add<Constant> for ri64<MIN, MAX>

type Output = ri64<MIN, MAX>

fn add(self, rhs: Constant) -> Self::Output

impl<const MIN1: i128, const MAX1: i128, const MIN2: i128, const MAX2: i128> Add<ri128<MIN1, MAX1>> for ri64<MIN2, MAX2>

type Output = ri64<MIN2, MAX2>

fn add(self, rhs: ri128<MIN1, MAX1>) -> Self::Output

impl<const MIN1: i128, const MAX1: i128, const MIN2: i128, const MAX2: i128> Add<ri16<MIN1, MAX1>> for ri64<MIN2, MAX2>

type Output = ri64<MIN2, MAX2>

fn add(self, rhs: ri16<MIN1, MAX1>) -> Self::Output

impl<const MIN1: i128, const MAX1: i128, const MIN2: i128, const MAX2: i128> Add<ri32<MIN1, MAX1>> for ri64<MIN2, MAX2>

type Output = ri64<MIN2, MAX2>

fn add(self, rhs: ri32<MIN1, MAX1>) -> Self::Output

impl<const MIN1: i128, const MAX1: i128, const MIN2: i128, const MAX2: i128> Add<ri64<MIN2, MAX2>> for ri64<MIN1, MAX1>

type Output = ri64<MIN1, MAX1>

fn add(self, rhs: ri64<MIN2, MAX2>) -> Self::Output

impl<const MIN1: i128, const MAX1: i128, const MIN2: i128, const MAX2: i128> Add<ri8<MIN1, MAX1>> for ri64<MIN2, MAX2>

type Output = ri64<MIN2, MAX2>

fn add(self, rhs: ri8<MIN1, MAX1>) -> Self::Output

impl<const MIN: i128, const MAX: i128> AddAssign<Constant> for ri64<MIN, MAX>

fn add_assign(&mut self, rhs: Constant)

impl<const MIN1: i128, const MAX1: i128, const MIN2: i128, const MAX2: i128> AddAssign<ri128<MIN1, MAX1>> for ri64<MIN2, MAX2>

fn add_assign(&mut self, rhs: ri128<MIN1, MAX1>)

Type Alias UnixSeconds

fn hash<H: Hasher>(&self, state: &mut H)

fn hash_slice<H>(data: &[Self], state: &mut H)
where H: Hasher, Self: Sized,