Struct DateTimeDefaultUnix

pub struct DateTimeDefaultUnix<Tz, const OFFSET_HOURS: i32 = 0>(/* private fields */)
where
    Tz: TimeZone,
    <Tz as TimeZone>::Offset: Copy;

DateTime with UNIX epoch as default.

use chrono::{Utc, TimeZone};
use datetime_default::DateTimeDefaultUnix;

assert_eq!(
    DateTimeDefaultUnix::<Utc>::default(),
    Utc.datetime_from_str("1970/1/1 00:00:00", "%Y/%m/%d %H:%M:%S").unwrap()
);

Methods from Deref<Target = DateTime<Tz>>

pub const MIN_UTC: DateTime<Utc>

pub const MAX_UTC: DateTime<Utc>

pub fn date(&self) -> Date<Tz>

👎Deprecated since 0.4.23: Use date_naive() instead

Retrieves the date component with an associated timezone.

Unless you are immediately planning on turning this into a DateTime with the same timezone you should use the date_naive method.

NaiveDate is a more well-defined type, and has more traits implemented on it, so should be preferred to Date any time you truly want to operate on dates.

Panics

DateTime internally stores the date and time in UTC with a NaiveDateTime. This method will panic if the offset from UTC would push the local date outside of the representable range of a Date.

pub fn date_naive(&self) -> NaiveDate

Retrieves the date component.

Panics

DateTime internally stores the date and time in UTC with a NaiveDateTime. This method will panic if the offset from UTC would push the local date outside of the representable range of a NaiveDate.

Example

use chrono::prelude::*;

let date: DateTime<Utc> = Utc.with_ymd_and_hms(2020, 1, 1, 0, 0, 0).unwrap();
let other: DateTime<FixedOffset> =
    FixedOffset::east_opt(23).unwrap().with_ymd_and_hms(2020, 1, 1, 0, 0, 0).unwrap();
assert_eq!(date.date_naive(), other.date_naive());

pub fn time(&self) -> NaiveTime

Retrieves the time component.

pub fn timestamp(&self) -> i64

Returns the number of non-leap seconds since January 1, 1970 0:00:00 UTC (aka “UNIX timestamp”).

The reverse operation of creating a DateTime from a timestamp can be performed using from_timestamp or TimeZone::timestamp_opt.

use chrono::{DateTime, TimeZone, Utc};

let dt: DateTime<Utc> = Utc.with_ymd_and_hms(2015, 5, 15, 0, 0, 0).unwrap();
assert_eq!(dt.timestamp(), 1431648000);

assert_eq!(DateTime::from_timestamp(dt.timestamp(), dt.timestamp_subsec_nanos()).unwrap(), dt);

pub fn timestamp_millis(&self) -> i64

Returns the number of non-leap-milliseconds since January 1, 1970 UTC.

Example

use chrono::{NaiveDate, Utc};

let dt = NaiveDate::from_ymd_opt(1970, 1, 1)
    .unwrap()
    .and_hms_milli_opt(0, 0, 1, 444)
    .unwrap()
    .and_local_timezone(Utc)
    .unwrap();
assert_eq!(dt.timestamp_millis(), 1_444);

let dt = NaiveDate::from_ymd_opt(2001, 9, 9)
    .unwrap()
    .and_hms_milli_opt(1, 46, 40, 555)
    .unwrap()
    .and_local_timezone(Utc)
    .unwrap();
assert_eq!(dt.timestamp_millis(), 1_000_000_000_555);

pub fn timestamp_micros(&self) -> i64

Returns the number of non-leap-microseconds since January 1, 1970 UTC.

Example

use chrono::{NaiveDate, Utc};

let dt = NaiveDate::from_ymd_opt(1970, 1, 1)
    .unwrap()
    .and_hms_micro_opt(0, 0, 1, 444)
    .unwrap()
    .and_local_timezone(Utc)
    .unwrap();
assert_eq!(dt.timestamp_micros(), 1_000_444);

let dt = NaiveDate::from_ymd_opt(2001, 9, 9)
    .unwrap()
    .and_hms_micro_opt(1, 46, 40, 555)
    .unwrap()
    .and_local_timezone(Utc)
    .unwrap();
assert_eq!(dt.timestamp_micros(), 1_000_000_000_000_555);

pub fn timestamp_nanos(&self) -> i64

👎Deprecated since 0.4.31: use timestamp_nanos_opt() instead

Returns the number of non-leap-nanoseconds since January 1, 1970 UTC.

Panics

An i64 with nanosecond precision can span a range of ~584 years. This function panics on an out of range DateTime.

The dates that can be represented as nanoseconds are between 1677-09-21T00:12:43.145224192 and 2262-04-11T23:47:16.854775807.

pub fn timestamp_nanos_opt(&self) -> Option<i64>

Returns the number of non-leap-nanoseconds since January 1, 1970 UTC.

Errors

An i64 with nanosecond precision can span a range of ~584 years. This function returns None on an out of range DateTime.

The dates that can be represented as nanoseconds are between 1677-09-21T00:12:43.145224192 and 2262-04-11T23:47:16.854775807.

Example

use chrono::{NaiveDate, Utc};

let dt = NaiveDate::from_ymd_opt(1970, 1, 1)
    .unwrap()
    .and_hms_nano_opt(0, 0, 1, 444)
    .unwrap()
    .and_local_timezone(Utc)
    .unwrap();
assert_eq!(dt.timestamp_nanos_opt(), Some(1_000_000_444));

let dt = NaiveDate::from_ymd_opt(2001, 9, 9)
    .unwrap()
    .and_hms_nano_opt(1, 46, 40, 555)
    .unwrap()
    .and_local_timezone(Utc)
    .unwrap();
assert_eq!(dt.timestamp_nanos_opt(), Some(1_000_000_000_000_000_555));

let dt = NaiveDate::from_ymd_opt(1677, 9, 21)
    .unwrap()
    .and_hms_nano_opt(0, 12, 43, 145_224_192)
    .unwrap()
    .and_local_timezone(Utc)
    .unwrap();
assert_eq!(dt.timestamp_nanos_opt(), Some(-9_223_372_036_854_775_808));

let dt = NaiveDate::from_ymd_opt(2262, 4, 11)
    .unwrap()
    .and_hms_nano_opt(23, 47, 16, 854_775_807)
    .unwrap()
    .and_local_timezone(Utc)
    .unwrap();
assert_eq!(dt.timestamp_nanos_opt(), Some(9_223_372_036_854_775_807));

let dt = NaiveDate::from_ymd_opt(1677, 9, 21)
    .unwrap()
    .and_hms_nano_opt(0, 12, 43, 145_224_191)
    .unwrap()
    .and_local_timezone(Utc)
    .unwrap();
assert_eq!(dt.timestamp_nanos_opt(), None);

let dt = NaiveDate::from_ymd_opt(2262, 4, 11)
    .unwrap()
    .and_hms_nano_opt(23, 47, 16, 854_775_808)
    .unwrap()
    .and_local_timezone(Utc)
    .unwrap();
assert_eq!(dt.timestamp_nanos_opt(), None);

pub fn timestamp_subsec_millis(&self) -> u32

Returns the number of milliseconds since the last second boundary.

In event of a leap second this may exceed 999.

pub fn timestamp_subsec_micros(&self) -> u32

Returns the number of microseconds since the last second boundary.

In event of a leap second this may exceed 999,999.

pub fn timestamp_subsec_nanos(&self) -> u32

Returns the number of nanoseconds since the last second boundary

In event of a leap second this may exceed 999,999,999.

pub fn offset(&self) -> &<Tz as TimeZone>::Offset

Retrieves an associated offset from UTC.

pub fn timezone(&self) -> Tz

Retrieves an associated time zone.

pub fn with_timezone<Tz2>(&self, tz: &Tz2) -> DateTime<Tz2>

where Tz2: TimeZone,

Changes the associated time zone. The returned DateTime references the same instant of time from the perspective of the provided time zone.

pub fn fixed_offset(&self) -> DateTime<FixedOffset>

Fix the offset from UTC to its current value, dropping the associated timezone information. This it useful for converting a generic DateTime<Tz: Timezone> to DateTime<FixedOffset>.

pub fn to_utc(&self) -> DateTime<Utc>

Turn this DateTime into a DateTime<Utc>, dropping the offset and associated timezone information.

pub fn naive_utc(&self) -> NaiveDateTime

Returns a view to the naive UTC datetime.

pub fn naive_local(&self) -> NaiveDateTime

Returns a view to the naive local datetime.

Panics

DateTime internally stores the date and time in UTC with a NaiveDateTime. This method will panic if the offset from UTC would push the local datetime outside of the representable range of a NaiveDateTime.

pub fn years_since(&self, base: DateTime<Tz>) -> Option<u32>

Retrieve the elapsed years from now to the given DateTime.

Errors

Returns None if base > self.

pub fn to_rfc2822(&self) -> String

Returns an RFC 2822 date and time string such as Tue, 1 Jul 2003 10:52:37 +0200.

Panics

Panics if the date can not be represented in this format: the year may not be negative and can not have more than 4 digits.

pub fn to_rfc3339(&self) -> String

Returns an RFC 3339 and ISO 8601 date and time string such as 1996-12-19T16:39:57-08:00.

pub fn to_rfc3339_opts(&self, secform: SecondsFormat, use_z: bool) -> String

Return an RFC 3339 and ISO 8601 date and time string with subseconds formatted as per SecondsFormat.

If use_z is true and the timezone is UTC (offset 0), uses Z as per Fixed::TimezoneOffsetColonZ. If use_z is false, uses Fixed::TimezoneOffsetColon

Examples

let dt = NaiveDate::from_ymd_opt(2018, 1, 26)
    .unwrap()
    .and_hms_micro_opt(18, 30, 9, 453_829)
    .unwrap()
    .and_utc();
assert_eq!(dt.to_rfc3339_opts(SecondsFormat::Millis, false), "2018-01-26T18:30:09.453+00:00");
assert_eq!(dt.to_rfc3339_opts(SecondsFormat::Millis, true), "2018-01-26T18:30:09.453Z");
assert_eq!(dt.to_rfc3339_opts(SecondsFormat::Secs, true), "2018-01-26T18:30:09Z");

let pst = FixedOffset::east_opt(8 * 60 * 60).unwrap();
let dt = pst
    .from_local_datetime(
        &NaiveDate::from_ymd_opt(2018, 1, 26)
            .unwrap()
            .and_hms_micro_opt(10, 30, 9, 453_829)
            .unwrap(),
    )
    .unwrap();
assert_eq!(dt.to_rfc3339_opts(SecondsFormat::Secs, true), "2018-01-26T10:30:09+08:00");

pub fn with_time(&self, time: NaiveTime) -> LocalResult<DateTime<Tz>>

Set the time to a new fixed time on the existing date.

Errors

Returns LocalResult::None if the datetime is at the edge of the representable range for a DateTime, and with_time would push the value in UTC out of range.

Example

use chrono::{Local, NaiveTime};

let noon = NaiveTime::from_hms_opt(12, 0, 0).unwrap();
let today_noon = Local::now().with_time(noon);
let today_midnight = Local::now().with_time(NaiveTime::MIN);

assert_eq!(today_noon.single().unwrap().time(), noon);
assert_eq!(today_midnight.single().unwrap().time(), NaiveTime::MIN);

pub const UNIX_EPOCH: DateTime<Utc>

pub fn format_with_items<'a, I, B>(&self, items: I) -> DelayedFormat<I>

where I: Iterator<Item = B> + Clone, B: Borrow<Item<'a>>,

Formats the combined date and time with the specified formatting items.

pub fn format<'a>(&self, fmt: &'a str) -> DelayedFormat<StrftimeItems<'a>>

Formats the combined date and time per the specified format string.

See the crate::format::strftime module for the supported escape sequences.

Example

use chrono::prelude::*;

let date_time: DateTime<Utc> = Utc.with_ymd_and_hms(2017, 04, 02, 12, 50, 32).unwrap();
let formatted = format!("{}", date_time.format("%d/%m/%Y %H:%M"));
assert_eq!(formatted, "02/04/2017 12:50");

Trait Implementations

impl<Tz, const OFFSET_HOURS: i32> Add<FixedOffset> for DateTimeDefaultUnix<Tz, OFFSET_HOURS>

where Tz: TimeZone, <Tz as TimeZone>::Offset: Copy,

type Output = DateTimeDefaultUnix<Tz, OFFSET_HOURS>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<Tz, const OFFSET_HOURS: i32> Add<TimeDelta> for DateTimeDefaultUnix<Tz, OFFSET_HOURS>

where Tz: TimeZone, <Tz as TimeZone>::Offset: Copy,

type Output = DateTimeDefaultUnix<Tz, OFFSET_HOURS>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<Tz, const OFFSET_HOURS: i32> AddAssign<TimeDelta> for DateTimeDefaultUnix<Tz, OFFSET_HOURS>

where Tz: TimeZone, <Tz as TimeZone>::Offset: Copy,

fn add_assign(&mut self, rhs: Duration)

Performs the += operation.

impl<Tz, const OFFSET_HOURS: i32> Clone for DateTimeDefaultUnix<Tz, OFFSET_HOURS>

where Tz: TimeZone + Clone, <Tz as TimeZone>::Offset: Copy,

fn clone(&self) -> DateTimeDefaultUnix<Tz, OFFSET_HOURS>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<Tz, const OFFSET_HOURS: i32> Datelike for DateTimeDefaultUnix<Tz, OFFSET_HOURS>

where Tz: TimeZone, <Tz as TimeZone>::Offset: Copy,

fn year(&self) -> i32

Returns the year number in the calendar date.

fn month(&self) -> u32

Returns the month number starting from 1.

fn month0(&self) -> u32

Returns the month number starting from 0.

fn day(&self) -> u32

Returns the day of month starting from 1.

fn day0(&self) -> u32

Returns the day of month starting from 0.

fn ordinal(&self) -> u32

Returns the day of year starting from 1.

fn ordinal0(&self) -> u32

Returns the day of year starting from 0.

fn weekday(&self) -> Weekday

Returns the day of week.

fn iso_week(&self) -> IsoWeek

Returns the ISO week.

fn with_year(&self, year: i32) -> Option<DateTimeDefaultUnix<Tz, OFFSET_HOURS>>

Makes a new value with the year number changed, while keeping the same month and day.

fn with_month( &self, month: u32, ) -> Option<DateTimeDefaultUnix<Tz, OFFSET_HOURS>>

Makes a new value with the month number (starting from 1) changed.

fn with_month0( &self, month0: u32, ) -> Option<DateTimeDefaultUnix<Tz, OFFSET_HOURS>>

Makes a new value with the month number (starting from 0) changed.

fn with_day(&self, day: u32) -> Option<DateTimeDefaultUnix<Tz, OFFSET_HOURS>>

Makes a new value with the day of month (starting from 1) changed.

fn with_day0(&self, day0: u32) -> Option<DateTimeDefaultUnix<Tz, OFFSET_HOURS>>

Makes a new value with the day of month (starting from 0) changed.

fn with_ordinal( &self, ordinal: u32, ) -> Option<DateTimeDefaultUnix<Tz, OFFSET_HOURS>>

Makes a new value with the day of year (starting from 1) changed.

fn with_ordinal0( &self, ordinal0: u32, ) -> Option<DateTimeDefaultUnix<Tz, OFFSET_HOURS>>

Makes a new value with the day of year (starting from 0) changed.

fn year_ce(&self) -> (bool, u32)

Returns the absolute year number starting from 1 with a boolean flag, which is false when the year predates the epoch (BCE/BC) and true otherwise (CE/AD).

fn num_days_from_ce(&self) -> i32

Counts the days in the proleptic Gregorian calendar, with January 1, Year 1 (CE) as day 1.

impl<Tz, const OFFSET_HOURS: i32> Debug for DateTimeDefaultUnix<Tz, OFFSET_HOURS>

where Tz: TimeZone + Debug, <Tz as TimeZone>::Offset: Copy,

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

Formats the value using the given formatter.

impl<const OFFSET_HOURS: i32> Default for DateTimeDefaultUnix<FixedOffset, OFFSET_HOURS>

fn default() -> Self

Returns the “default value” for a type.

impl Default for DateTimeDefaultUnix<Local, 0>

fn default() -> Self

Returns the “default value” for a type.

impl Default for DateTimeDefaultUnix<Utc, 0>

fn default() -> Self

Returns the “default value” for a type.

impl<Tz, const OFFSET_HOURS: i32> Deref for DateTimeDefaultUnix<Tz, OFFSET_HOURS>

where Tz: TimeZone, <Tz as TimeZone>::Offset: Copy,

type Target = DateTime<Tz>

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl<Tz, const OFFSET_HOURS: i32> Display for DateTimeDefaultUnix<Tz, OFFSET_HOURS>

where Tz: TimeZone, <Tz as TimeZone>::Offset: Copy + Display,

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

Formats the value using the given formatter.

impl<Tz, const OFFSET_HOURS: i32> DurationRound for DateTimeDefaultUnix<Tz, OFFSET_HOURS>

where Tz: TimeZone, <Tz as TimeZone>::Offset: Copy,

type Err = RoundingError

Error that can occur in rounding or truncating

fn duration_round(self, duration: Duration) -> Result<Self, Self::Err>

Return a copy rounded by TimeDelta.

fn duration_trunc(self, duration: Duration) -> Result<Self, Self::Err>

Return a copy truncated by TimeDelta.

impl<Tz, const OFFSET_HOURS: i32> From<DateTime<Tz>> for DateTimeDefaultUnix<Tz, OFFSET_HOURS>

where Tz: TimeZone, <Tz as TimeZone>::Offset: Copy,

fn from(datetime: DateTime<Tz>) -> Self

Converts to this type from the input type.

impl<const OFFSET_HOURS: i32> FromStr for DateTimeDefaultUnix<FixedOffset, OFFSET_HOURS>

type Err = ParseError

The associated error which can be returned from parsing.

fn from_str( s: &str, ) -> ParseResult<DateTimeDefaultUnix<FixedOffset, OFFSET_HOURS>>

Parses a string s to return a value of this type.

impl<const OFFSET_HOURS: i32> FromStr for DateTimeDefaultUnix<Local, OFFSET_HOURS>

type Err = ParseError

The associated error which can be returned from parsing.

fn from_str(s: &str) -> ParseResult<DateTimeDefaultUnix<Local, OFFSET_HOURS>>

Parses a string s to return a value of this type.

impl<const OFFSET_HOURS: i32> FromStr for DateTimeDefaultUnix<Utc, OFFSET_HOURS>

type Err = ParseError

The associated error which can be returned from parsing.

fn from_str(s: &str) -> ParseResult<DateTimeDefaultUnix<Utc, OFFSET_HOURS>>

Parses a string s to return a value of this type.

impl<Tz, const OFFSET_HOURS: i32> Hash for DateTimeDefaultUnix<Tz, OFFSET_HOURS>

where Tz: TimeZone + Hash, <Tz as TimeZone>::Offset: Copy,

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<Tz, const OFFSET_HOURS: i32> Ord for DateTimeDefaultUnix<Tz, OFFSET_HOURS>

where Tz: TimeZone + Ord, <Tz as TimeZone>::Offset: Copy,

fn cmp(&self, other: &DateTimeDefaultUnix<Tz, OFFSET_HOURS>) -> 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<Tz, const OFFSET_HOURS: i32> PartialEq<DateTime<Tz>> for DateTimeDefaultUnix<Tz, OFFSET_HOURS>

where Tz: TimeZone, <Tz as TimeZone>::Offset: Copy,

fn eq(&self, other: &DateTime<Tz>) -> 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<Tz, const OFFSET_HOURS: i32> PartialEq<DateTimeDefaultUnix<Tz, OFFSET_HOURS>> for DateTime<Tz>

where Tz: TimeZone, <Tz as TimeZone>::Offset: Copy,

fn eq(&self, other: &DateTimeDefaultUnix<Tz, OFFSET_HOURS>) -> 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<Tz, const OFFSET_HOURS: i32> PartialEq for DateTimeDefaultUnix<Tz, OFFSET_HOURS>

where Tz: TimeZone + PartialEq, <Tz as TimeZone>::Offset: Copy,

fn eq(&self, other: &DateTimeDefaultUnix<Tz, OFFSET_HOURS>) -> 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<Tz, const OFFSET_HOURS: i32> PartialOrd<DateTime<Tz>> for DateTimeDefaultUnix<Tz, OFFSET_HOURS>

where Tz: TimeZone, <Tz as TimeZone>::Offset: Copy,

fn partial_cmp(&self, other: &DateTime<Tz>) -> 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<Tz, const OFFSET_HOURS: i32> PartialOrd<DateTimeDefaultUnix<Tz, OFFSET_HOURS>> for DateTime<Tz>

where Tz: TimeZone, <Tz as TimeZone>::Offset: Copy,

fn partial_cmp( &self, other: &DateTimeDefaultUnix<Tz, OFFSET_HOURS>, ) -> 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<Tz, const OFFSET_HOURS: i32> PartialOrd for DateTimeDefaultUnix<Tz, OFFSET_HOURS>

where Tz: TimeZone + PartialOrd, <Tz as TimeZone>::Offset: Copy,

fn partial_cmp( &self, other: &DateTimeDefaultUnix<Tz, OFFSET_HOURS>, ) -> 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<Tz, const OFFSET_HOURS: i32> Sub<DateTime<Tz>> for DateTimeDefaultUnix<Tz, OFFSET_HOURS>

where Tz: TimeZone, <Tz as TimeZone>::Offset: Copy,

type Output = TimeDelta

The resulting type after applying the - operator.

fn sub(self, rhs: DateTime<Tz>) -> Duration

Performs the - operation.

impl<Tz, const OFFSET_HOURS: i32> Sub<FixedOffset> for DateTimeDefaultUnix<Tz, OFFSET_HOURS>

where Tz: TimeZone, <Tz as TimeZone>::Offset: Copy,

type Output = DateTimeDefaultUnix<Tz, OFFSET_HOURS>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<Tz, const OFFSET_HOURS: i32> Sub<TimeDelta> for DateTimeDefaultUnix<Tz, OFFSET_HOURS>

where Tz: TimeZone, <Tz as TimeZone>::Offset: Copy,

type Output = DateTimeDefaultUnix<Tz, OFFSET_HOURS>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<Tz, const OFFSET_HOURS: i32> Sub for DateTimeDefaultUnix<Tz, OFFSET_HOURS>

where Tz: TimeZone, <Tz as TimeZone>::Offset: Copy,

type Output = TimeDelta

The resulting type after applying the - operator.

fn sub(self, rhs: DateTimeDefaultUnix<Tz, OFFSET_HOURS>) -> Duration

Performs the - operation.

impl<Tz, const OFFSET_HOURS: i32> SubAssign<TimeDelta> for DateTimeDefaultUnix<Tz, OFFSET_HOURS>

where Tz: TimeZone, <Tz as TimeZone>::Offset: Copy,

fn sub_assign(&mut self, rhs: Duration)

Performs the -= operation.

impl<Tz, const OFFSET_HOURS: i32> Timelike for DateTimeDefaultUnix<Tz, OFFSET_HOURS>

where Tz: TimeZone, <Tz as TimeZone>::Offset: Copy,

fn hour(&self) -> u32

Returns the hour number from 0 to 23.

fn minute(&self) -> u32

Returns the minute number from 0 to 59.

fn second(&self) -> u32

Returns the second number from 0 to 59.

fn nanosecond(&self) -> u32

Returns the number of nanoseconds since the whole non-leap second. The range from 1,000,000,000 to 1,999,999,999 represents the leap second.

fn with_hour(&self, hour: u32) -> Option<DateTimeDefaultUnix<Tz, OFFSET_HOURS>>

Makes a new value with the hour number changed.

fn with_minute(&self, min: u32) -> Option<DateTimeDefaultUnix<Tz, OFFSET_HOURS>>

Makes a new value with the minute number changed.

fn with_second(&self, sec: u32) -> Option<DateTimeDefaultUnix<Tz, OFFSET_HOURS>>

Makes a new value with the second number changed.

fn with_nanosecond( &self, nano: u32, ) -> Option<DateTimeDefaultUnix<Tz, OFFSET_HOURS>>

Makes a new value with nanoseconds since the whole non-leap second changed.

fn hour12(&self) -> (bool, u32)

Returns the hour number from 1 to 12 with a boolean flag, which is false for AM and true for PM.

fn num_seconds_from_midnight(&self) -> u32

Returns the number of non-leap seconds past the last midnight.

impl<Tz, const OFFSET_HOURS: i32> Copy for DateTimeDefaultUnix<Tz, OFFSET_HOURS>

where Tz: TimeZone + Copy, <Tz as TimeZone>::Offset: Copy,

impl<Tz, const OFFSET_HOURS: i32> Eq for DateTimeDefaultUnix<Tz, OFFSET_HOURS>

where Tz: TimeZone + Eq, <Tz as TimeZone>::Offset: Copy,

impl<Tz, const OFFSET_HOURS: i32> StructuralPartialEq for DateTimeDefaultUnix<Tz, OFFSET_HOURS>

where Tz: TimeZone, <Tz as TimeZone>::Offset: Copy,