Struct ExactDuration 

pub struct ExactDuration { /* private fields */ }

Exact-precision signed duration.

Internally an i128 of nanoseconds. Range ≈ ±5.4 × 10²¹ yr at 1 ns resolution (i128::MAX ≈ 1.7 × 10³⁸ ns ÷ 3.156 × 10¹⁶ ns/yr ≈ 5.4 × 10²¹ yr).

Construction:

• ExactDuration::ZERO
• ExactDuration::from_nanos
• ExactDuration::from_seconds_and_nanos
• ExactDuration::from_canonical_seconds_nanos (strict canonical form)
• ExactDuration::from_quantity / ExactDuration::try_from_quantity
• ExactDuration::from_seconds_f64_lossy (explicit lossy boundary)

Accessors:

• ExactDuration::as_nanos_i128
• ExactDuration::as_seconds_i64_nanos (panics if seconds outside i64 range)
• ExactDuration::as_seconds_i64_nanos_checked (returns Err on overflow)
• ExactDuration::as_seconds_i64_nanos_saturating (saturates; lossy for extreme values)
• ExactDuration::as_seconds_f64
• ExactDuration::as_quantity

Implementations

impl ExactDuration

pub const ZERO: Self

Zero duration.

pub const NANOSECOND: Self

Smallest representable positive duration (1 ns).

pub const SECOND: Self

One second.

pub const MAX: Self

Maximum representable duration.

pub const MIN: Self

Minimum (most negative) representable duration.

pub const fn from_nanos(nanos: i128) -> Self

Build from a raw nanosecond count.

pub const fn from_seconds_and_nanos( seconds: i64, nanos: i32, ) -> Result<Self, DurationError>

Build from (seconds, nanos) boundary projection.

The fractional nanos is interpreted with the same sign as seconds when seconds != 0; when seconds == 0, nanos carries the sign directly. This matches the unambiguous total result_nanos = seconds * 1e9 + nanos.

Returns DurationError::Overflow if the multiplication overflows.

pub const fn from_canonical_seconds_nanos( seconds: i64, nanos: i32, ) -> Result<Self, DurationError>

Strict canonical constructor: requires nanos ∈ (-1_000_000_000, 1_000_000_000) and that seconds and nanos share the same sign (or nanos == 0).

The full invariant:

• |nanos| < 1_000_000_000
• if seconds > 0, then nanos >= 0
• if seconds < 0, then nanos <= 0
• if seconds == 0, either sign of nanos is valid

Returns DurationError::Overflow if |nanos| >= 1_000_000_000 or if the multiplication overflows, and DurationError::NonCanonical if the sign invariant is violated.

pub fn try_from_quantity<U: TimeUnit>( q: Quantity<U>, ) -> Result<Self, DurationError>

Build from a qtty::Quantity<U> of any time unit. Returns DurationError::NonFinite for NaN/inf inputs and DurationError::Overflow if the value does not fit in i128 ns.

pub fn from_quantity<U: TimeUnit>(q: Quantity<U>) -> Self

Infallible variant for callers that already know the input is finite and in-range. Panics on non-finite or overflowing input. For fallible conversion, use try_from_quantity.

pub fn from_seconds_f64_lossy(seconds: f64) -> Option<Self>

Explicit lossy f64 → ExactDuration boundary. Named so the lossy step is visible in code review. Returns None on non-finite input or when the value does not fit in i128 ns.

pub const fn as_nanos_i128(self) -> i128

Raw signed nanosecond count.

pub const fn as_seconds_i64_nanos_checked( self, ) -> Result<(i64, i32), DurationError>

Exact boundary projection (seconds, nanos) such that seconds * 1_000_000_000 + nanos == self.as_nanos_i128() and nanos ∈ (-1_000_000_000, 1_000_000_000).

Returns DurationError::Overflow when the seconds component does not fit in i64 (i.e. |self| > i64::MAX * 1e9 ns ≈ ±292 billion years).

Use this as the canonical API when the invariant must be preserved. For guaranteed-small durations you may use as_seconds_i64_nanos (panics on overflow).

pub const fn as_seconds_i64_nanos_saturating(self) -> (i64, i32)

Boundary projection (seconds, nanos) that saturates the seconds component to i64::MAX / i64::MIN for extreme values.

Lossy / non-canonical for durations outside the i64 seconds range (≈ ±292 billion years). The invariant seconds * 1_000_000_000 + nanos == as_nanos_i128() is not preserved when saturation occurs. Use as_seconds_i64_nanos_checked for exact behaviour.

pub const fn as_seconds_i64_nanos(self) -> (i64, i32)

Boundary projection (seconds, nanos). Panics if the seconds component does not fit in i64.

For durations within ≈ ±292 billion years this never panics in practice. Use as_seconds_i64_nanos_checked to handle the overflow case explicitly.

pub fn as_seconds_f64(self) -> f64

Explicit lossy ExactDuration → f64 seconds boundary.

pub fn from_nanoseconds_i(nanos: Nanosecond) -> Self

Build from a typed qtty::i64::Nanosecond integer quantity.

The i64 value is widened to i128 without loss; this conversion is always exact. For the low-level raw interface, see from_nanos.

pub fn from_seconds_i(seconds: Second) -> Self

Build from a typed qtty::i64::Second integer quantity (whole-second precision).

The second value is multiplied by 1 × 10⁹ and widened to i128 without loss for any i64 input. For sub-second precision use from_canonical_seconds_nanos or from_nanoseconds_i.

pub fn as_nanoseconds_i(self) -> Result<Nanosecond, DurationError>

Project to a typed qtty::i64::Nanosecond integer quantity.

Returns DurationError::Overflow when the stored nanosecond count does not fit in i64 (durations outside ≈ ±292 billion years at 1 ns resolution).

pub fn as_quantity<U: TimeUnit>(self) -> Quantity<U>

Project back into a qtty::Quantity<U>. Lossy in general (f64).

pub const fn is_zero(self) -> bool

True iff exactly zero.

pub const fn is_negative(self) -> bool

True iff strictly negative.

pub const fn checked_abs(self) -> Result<Self, DurationError>

Absolute value. Returns DurationError::Overflow on ExactDuration::MIN (i128::MIN has no representable positive).

pub const fn checked_add(self, rhs: Self) -> Result<Self, DurationError>

Checked addition.

pub const fn checked_sub(self, rhs: Self) -> Result<Self, DurationError>

Checked subtraction.

pub const fn checked_neg(self) -> Result<Self, DurationError>

Checked negation.

pub const fn saturating_add(self, rhs: Self) -> Self

Saturating addition.

pub const fn saturating_sub(self, rhs: Self) -> Self

Saturating subtraction.

pub const fn round_to(self, quantum: ExactDuration) -> Self

Round this duration to the nearest multiple of quantum (banker’s rounding / half-to-even). quantum must be strictly positive; a non-positive quantum returns self unchanged to avoid surprising errors in formatting paths.

pub const fn floor_to(self, quantum: ExactDuration) -> Self

Floor this duration toward negative infinity at quantum.

pub const fn ceil_to(self, quantum: ExactDuration) -> Self

Ceil this duration toward positive infinity at quantum.

Trait Implementations

impl Add for ExactDuration

type Output = ExactDuration

The resulting type after applying the + operator.

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

Performs the + operation.

impl AddAssign for ExactDuration

fn add_assign(&mut self, rhs: Self)

Performs the += operation.

impl Clone for ExactDuration

fn clone(&self) -> ExactDuration

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for ExactDuration

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for ExactDuration

fn default() -> Self

Returns the “default value” for a type.

impl Display for ExactDuration

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Hash for ExactDuration

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

Feeds this value into the given Hasher.

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

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl Neg for ExactDuration

type Output = ExactDuration

The resulting type after applying the - operator.

fn neg(self) -> Self

Performs the unary - operation.

impl Ord for ExactDuration

fn cmp(&self, other: &Self) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl PartialEq for ExactDuration

fn eq(&self, other: &ExactDuration) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialOrd for ExactDuration

fn partial_cmp(&self, other: &Self) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

Tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

Tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

Tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl Sub for ExactDuration

type Output = ExactDuration

The resulting type after applying the - operator.

fn sub(self, rhs: Self) -> Self

Performs the - operation.

impl SubAssign for ExactDuration

fn sub_assign(&mut self, rhs: Self)

Performs the -= operation.

impl Copy for ExactDuration

impl Eq for ExactDuration

impl StructuralPartialEq for ExactDuration