jiff::fmt::strtime::parse

Type Alias ParsedOffsetMinutes

Help

type ParsedOffsetMinutes = ri8<0, { t::SpanZoneOffsetMinutes::MAX }>;

Aliased Type§

struct ParsedOffsetMinutes {
    pub(crate) val: i8,
    pub(crate) min: i8,
    pub(crate) max: i8,
}

Fields§

§val: i8

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: i8

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: i8

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 ParsedOffsetMinutesCopy item path

Aliased Type§

Fields§

Implementations

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

const PRIMITIVE_MIN: i128 = -128i128

const PRIMITIVE_MAX: i128 = 127i128

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: i8

pub(crate) const MAX_REPR: i8

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: i8) -> Error

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

pub(crate) const fn new_const(val: i8) -> 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<i8>) -> Self

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

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

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

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

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

pub(crate) fn vary<const N: usize, const MIN2: i128, const MAX2: i128>( numbers: [Self; N], with: impl Fn([Self; N]) -> ri8<MIN2, MAX2>, ) -> ri8<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]) -> [ri8<MIN2, MAX2>; M], ) -> [ri8<MIN2, MAX2>; M]

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

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

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) -> ri8<-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> ri8<MIN, MAX>

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

Trait Implementations

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

type Output = ri8<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 ri8<MIN2, MAX2>

type Output = ri8<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 ri8<MIN2, MAX2>

type Output = ri8<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 ri8<MIN2, MAX2>

type Output = ri8<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<MIN1, MAX1>> for ri8<MIN2, MAX2>

type Output = ri8<MIN2, MAX2>

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

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

type Output = ri8<MIN1, MAX1>

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

impl<const MIN: i128, const MAX: i128> AddAssign<Constant> for ri8<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 ri8<MIN2, MAX2>

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

Type Alias ParsedOffsetMinutes

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

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