Struct UnixEpochDay 

pub struct UnixEpochDay { /* private fields */ }

A civil date represented by a number of days since the Unix epoch (1970-01-01).

The date can be positive (occurs after 1970-01-01) or negative (occurs before 1970-01-01). A zero value corresponds to 1970-01-01.

Unix epoch days can be infallibly converted to and from Date values.

Implementations

impl UnixEpochDay

pub const MIN: UnixEpochDay

The minimum allowed Unix epoch day.

This is guaranteed to be equivalent to Date::MIN when converted to a Gregorian date.

pub const MAX: UnixEpochDay

The maximum allowed Unix epoch day.

This is guaranteed to be equivalent to Date::MAX when converted to a Gregorian date.

pub const fn new(day: i32) -> Result<UnixEpochDay, RangeError>

Creates a new Unix epoch day.

The day given must correspond to a number of days (positive or negative) since the Unix epoch (1970-01-01). A value of 0 corresponds to 1970-01-01.

pub const fn day(self) -> i32

Returns the underlying day value.

This is guaranteed to be in the UnixEpochDays range.

pub const fn weekday(&self) -> Weekday

Returns the day of the week for this epoch day.

pub const fn nth_weekday( self, nth: i32, weekday: Weekday, ) -> Result<Date, RangeError>

Returns the “nth” weekday from this date, not including itself.

The nth parameter can be positive or negative. A positive value computes the “nth” weekday starting at the day after this date and going forwards in time. A negative value computes the “nth” weekday starting at the day before this date and going backwards in time.

For example, if this date’s weekday is a Sunday and the first Sunday is asked for (that is, date.nth_weekday(1, Weekday::Sunday)), then the result is a week from this date corresponding to the following Sunday.

pub const fn checked_add(self, days: i32) -> Result<UnixEpochDay, RangeError>

Add the given number of days to this Unix epoch day.

If this would overflow an i32 or result in an out-of-bounds Unix epoch day, then this returns an error.

pub const fn checked_sub(self, days: i32) -> Result<UnixEpochDay, RangeError>

Subtracts the given number of days from this Unix epoch day.

If this would overflow an i32 or result in an out-of-bounds Unix epoch day, then this returns an error.

pub const fn until(self, other: UnixEpochDay) -> i32

Returns the number of days from this date until other.

This routine never overflows because of the enforced range on UnixEpochDay values.

Example

use jiff_core::civil::date;

let date1 = date(2023, 7, 1).to_unix_epoch_day();
let date2 = date(2024, 7, 1).to_unix_epoch_day();
assert_eq!(366, date1.until(date2));

// The value will be negative when the dates are flipped:
assert_eq!(-366, date2.until(date1));

Example: overflow isn’t possible

Even when using the minimum or maximum values:

use jiff_core::civil::UnixEpochDay;

assert_eq!(7_304_483, UnixEpochDay::MIN.until(UnixEpochDay::MAX));
assert_eq!(-7_304_483, UnixEpochDay::MAX.until(UnixEpochDay::MIN));

pub const fn since(self, other: UnixEpochDay) -> i32

Returns the number of days from this date since other.

This routine never overflows because of the enforced range on UnixEpochDay values.

Example

use jiff_core::civil::date;

let date1 = date(2023, 7, 1).to_unix_epoch_day();
let date2 = date(2024, 7, 1).to_unix_epoch_day();
assert_eq!(366, date2.since(date1));

// The value will be negative when the dates are flipped:
assert_eq!(-366, date1.since(date2));

Example: overflow isn’t possible

Even when using the minimum or maximum values:

use jiff_core::civil::UnixEpochDay;

assert_eq!(7_304_483, UnixEpochDay::MAX.since(UnixEpochDay::MIN));

pub const fn to_date(self) -> Date

Converts this Unix epoch day to a Gregorian date.

Trait Implementations

impl Clone for UnixEpochDay

fn clone(&self) -> UnixEpochDay

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for UnixEpochDay

impl Debug for UnixEpochDay

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

Formats the value using the given formatter.

impl Eq for UnixEpochDay

impl Format for UnixEpochDay

fn format(&self, f: Formatter<'_>)

Writes the defmt representation of self to fmt.

impl Hash for UnixEpochDay

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 Ord for UnixEpochDay

fn cmp(&self, other: &UnixEpochDay) -> 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 UnixEpochDay

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

Equality operator ==.

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

Inequality operator !=.

impl PartialOrd for UnixEpochDay

fn partial_cmp(&self, other: &UnixEpochDay) -> 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 StructuralPartialEq for UnixEpochDay

impl Sub for UnixEpochDay

Returns the number of days between two UnixEpochDay values.

This routine never overflows because of the enforced range on UnixEpochDay values.

Example

use jiff_core::civil::date;

let date1 = date(2023, 7, 1).to_unix_epoch_day();
let date2 = date(2024, 7, 1).to_unix_epoch_day();
assert_eq!(366, date2 - date1);

// The value will be negative when the dates are flipped:
assert_eq!(-366, date1 - date2);

Example: overflow isn’t possible

Even when using the minimum or maximum values:

use jiff_core::civil::UnixEpochDay;

assert_eq!(7_304_483, UnixEpochDay::MAX - UnixEpochDay::MIN);

type Output = i32

The resulting type after applying the - operator.

fn sub(self, rhs: UnixEpochDay) -> i32

Performs the - operation.