jiff::util::t

Type Alias SpanSecondsOrLower

Help

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

Expand description

The range of allowable seconds and lower in a span, in units of seconds.

This corresponds to when the min/max of seconds, milliseconds, microseconds and nanoseconds are added together in a span. This is useful for describing the limit on the total number of possible seconds when all of these units are combined. This is necessary as part of printing/parsing spans because the ISO 8601 duration format doesn’t support individual millisecond, microsecond and nanosecond components. So they all need to be smushed into seconds and a possible fractional part.

Aliased Type§

struct SpanSecondsOrLower {
    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 SpanSecondsOrLowerCopy 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 SpanSecondsOrLower

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

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