[−][src]Struct time::OffsetDateTime

pub struct OffsetDateTime { /* fields omitted */ }

A PrimitiveDateTime with a UtcOffset.

All comparisons are performed using the UTC time.

Implementations

`impl OffsetDateTime`[src]

`pub fn now() -> Self`[src]

Deprecated since 0.2.11:

This function returns a value with an offset of UTC, which is not apparent from its name alone. You should use OffsetDateTime::now_utc() instead.

This is supported on feature="std" only.

Create a new OffsetDateTime with the current date and time in UTC.

assert!(OffsetDateTime::now().year() >= 2019);
assert_eq!(OffsetDateTime::now().offset(), offset!(UTC));

`pub fn now_utc() -> Self`[src]

This is supported on feature="std" only.

Create a new OffsetDateTime with the current date and time in UTC.

assert!(OffsetDateTime::now_utc().year() >= 2019);
assert_eq!(OffsetDateTime::now_utc().offset(), offset!(UTC));

`pub fn now_local() -> Self`[src]

This is supported on feature="std" only.

Create a new OffsetDateTime with the current date and time in the local offset.

assert!(OffsetDateTime::now_local().year() >= 2019);

`pub fn try_now_local() -> Result<Self, IndeterminateOffsetError>`[src]

This is supported on feature="std" only.

Attempt to create a new OffsetDateTime with the current date and time in the local offset. If the offset cannot be determined, an error is returned.

assert!(OffsetDateTime::try_now_local().is_ok());

`pub const fn to_offset(self, offset: UtcOffset) -> Self`[src]

Convert the OffsetDateTime from the current UtcOffset to the provided UtcOffset.

assert_eq!(
    date!(2000-01-01)
        .midnight()
        .assume_utc()
        .to_offset(offset!(-1))
        .year(),
    1999,
);

// Let's see what time Sydney's new year's celebration is in New York
// and Los Angeles.

// Construct midnight on new year's in Sydney. This is equivalent to
// 13:00 UTC.
let sydney = date!(2000-01-01).midnight().assume_offset(offset!(+11));
let new_york = sydney.to_offset(offset!(-5));
let los_angeles = sydney.to_offset(offset!(-8));
assert_eq!(sydney.hour(), 0);
assert_eq!(new_york.hour(), 8);
assert_eq!(los_angeles.hour(), 5);

`pub const fn unix_epoch() -> Self`[src]

Midnight, 1 January, 1970 (UTC).

assert_eq!(
    OffsetDateTime::unix_epoch(),
    date!(1970-01-01)
        .midnight()
        .assume_utc(),
);

`pub fn from_unix_timestamp(timestamp: i64) -> Self`[src]

Create an OffsetDateTime from the provided Unix timestamp.

assert_eq!(
    OffsetDateTime::from_unix_timestamp(0),
    OffsetDateTime::unix_epoch(),
);
assert_eq!(
    OffsetDateTime::from_unix_timestamp(1_546_300_800),
    date!(2019-01-01)
        .midnight()
        .assume_utc(),
);

`pub const fn offset(self) -> UtcOffset`[src]

Get the UtcOffset.

assert_eq!(
    date!(2019-01-01)
        .midnight()
        .assume_utc()
        .offset(),
    offset!(UTC),
);
assert_eq!(
    date!(2019-01-01)
        .midnight()
        .assume_offset(offset!(+1))
        .offset(),
    offset!(+1),
);

`pub fn timestamp(self) -> i64`[src]

Get the Unix timestamp.

assert_eq!(
    PrimitiveDateTime::unix_epoch()
        .assume_utc()
        .timestamp(),
    0,
);
assert_eq!(
    PrimitiveDateTime::unix_epoch()
        .assume_utc()
        .to_offset(offset!(-1))
        .timestamp(),
    0,
);

`pub fn date(self) -> Date`[src]

Get the Date in the stored offset.

assert_eq!(
    date!(2019-01-01)
        .midnight()
        .assume_utc()
        .date(),
    date!(2019-01-01),
);
assert_eq!(
    date!(2019-01-01)
        .midnight()
        .assume_utc()
        .to_offset(offset!(-1))
        .date(),
    date!(2018-12-31),
);

`pub fn time(self) -> Time`[src]

Get the Time in the stored offset.

assert_eq!(
    date!(2019-01-01)
        .midnight()
        .assume_utc()
        .time(),
    time!(0:00)
);
assert_eq!(
    date!(2019-01-01)
        .midnight()
        .assume_utc()
        .to_offset(offset!(-1))
        .time(),
    time!(23:00)
);

`pub fn year(self) -> i32`[src]

Get the year of the date in the stored offset.

assert_eq!(
    date!(2019-01-01)
        .midnight()
        .assume_utc()
        .year(),
    2019,
);
assert_eq!(
    date!(2019-12-31)
        .with_time(time!(23:00))
        .assume_utc()
        .to_offset(offset!(+1))
        .year(),
    2020,
);
assert_eq!(
    date!(2020-01-01)
        .midnight()
        .assume_utc()
        .year(),
    2020,
);

`pub fn month(self) -> u8`[src]

Get the month of the date in the stored offset. If fetching both the month and day, it is more efficient to use OffsetDateTime::month_day.

The returned value will always be in the range 1..=12.

assert_eq!(
    date!(2019-01-01)
        .midnight()
        .assume_utc()
        .month(),
    1,
);
assert_eq!(
    date!(2019-12-31)
        .with_time(time!(23:00))
        .assume_utc()
        .to_offset(offset!(+1))
        .month(),
    1,
);

`pub fn day(self) -> u8`[src]

Get the day of the date in the stored offset. If fetching both the month and day, it is more efficient to use OffsetDateTime::month_day.

The returned value will always be in the range 1..=31.

assert_eq!(
    date!(2019-01-01)
        .midnight()
        .assume_utc()
        .day(),
    1,
);
assert_eq!(
    date!(2019-12-31)
        .with_time(time!(23:00))
        .assume_utc()
        .to_offset(offset!(+1))
        .day(),
    1,
);

`pub fn month_day(self) -> (u8, u8)`[src]

Get the month and day of the date in the stored offset.

The month component will always be in the range 1..=12; the day component in 1..=31.

assert_eq!(
    date!(2019-01-01)
        .midnight()
        .assume_utc()
        .month_day(),
    (1, 1),
);
assert_eq!(
    date!(2019-12-31)
        .with_time(time!(23:00))
        .assume_utc()
        .to_offset(offset!(+1))
        .month_day(),
    (1, 1),
);

`pub fn ordinal(self) -> u16`[src]

Get the day of the year of the date in the stored offset.

The returned value will always be in the range 1..=366.

assert_eq!(
    date!(2019-01-01)
        .midnight()
        .assume_utc()
        .ordinal(),
    1,
);
assert_eq!(
    date!(2019-12-31)
        .with_time(time!(23:00))
        .assume_utc()
        .to_offset(offset!(+1))
        .ordinal(),
    1,
);

`pub fn iso_year_week(self) -> (i32, u8)`[src]

Get the ISO 8601 year and week number in the stored offset.

assert_eq!(
    date!(2019-01-01)
        .midnight()
        .assume_utc()
        .iso_year_week(),
    (2019, 1),
);
assert_eq!(
    date!(2019-10-04)
        .midnight()
        .assume_utc()
        .iso_year_week(),
    (2019, 40),
);
assert_eq!(
    date!(2020-01-01)
        .midnight()
        .assume_utc()
        .iso_year_week(),
    (2020, 1),
);
assert_eq!(
    date!(2020-12-31)
        .midnight()
        .assume_utc()
        .iso_year_week(),
    (2020, 53),
);
assert_eq!(
    date!(2021-01-01)
        .midnight()
        .assume_utc()
        .iso_year_week(),
    (2020, 53),
);

`pub fn week(self) -> u8`[src]

Get the ISO week number of the date in the stored offset.

The returned value will always be in the range 1..=53.

assert_eq!(
    date!(2019-01-01)
        .midnight()
        .assume_utc()
        .week(),
    1,
);
assert_eq!(
    date!(2020-01-01)
        .midnight()
        .assume_utc()
        .week(),
    1,
);
assert_eq!(
    date!(2020-12-31)
        .midnight()
        .assume_utc()
        .week(),
    53,
);
assert_eq!(
    date!(2021-01-01)
        .midnight()
        .assume_utc()
        .week(),
    53,
);

`pub fn weekday(self) -> Weekday`[src]

Get the weekday of the date in the stored offset.

This current uses Zeller's congruence internally.

assert_eq!(
    date!(2019-01-01)
        .midnight()
        .assume_utc()
        .weekday(),
    Tuesday,
);
assert_eq!(
    date!(2019-02-01)
        .midnight()
        .assume_utc()
        .weekday(),
    Friday,
);
assert_eq!(
    date!(2019-03-01)
        .midnight()
        .assume_utc()
        .weekday(),
    Friday,
);

`pub fn hour(self) -> u8`[src]

Get the clock hour in the stored offset.

The returned value will always be in the range 0..24.

assert_eq!(
    date!(2019-01-01)
        .midnight()
        .assume_utc()
        .hour(),
    0,
);
assert_eq!(
    date!(2019-01-01)
        .with_time(time!(23:59:59))
        .assume_utc()
        .to_offset(offset!(-2))
        .hour(),
    21,
);

`pub fn minute(self) -> u8`[src]

Get the minute within the hour in the stored offset.

The returned value will always be in the range 0..60.

assert_eq!(
    date!(2019-01-01)
        .midnight()
        .assume_utc()
        .minute(),
    0,
);
assert_eq!(
    date!(2019-01-01)
        .with_time(time!(23:59:59))
        .assume_utc()
        .to_offset(offset!(+0:30))
        .minute(),
    29,
);

`pub fn second(self) -> u8`[src]

Get the second within the minute in the stored offset.

The returned value will always be in the range 0..60.

assert_eq!(
    date!(2019-01-01)
        .midnight()
        .assume_utc()
        .second(),
    0,
);
assert_eq!(
    date!(2019-01-01)
        .with_time(time!(23:59:59))
        .assume_utc()
        .to_offset(offset!(+0:00:30))
        .second(),
    29,
);

`pub fn millisecond(self) -> u16`[src]

Get the milliseconds within the second in the stored offset.

The returned value will always be in the range 0..1_000.

assert_eq!(
    date!(2019-01-01)
        .midnight()
        .assume_utc()
        .millisecond(),
    0,
);
assert_eq!(
    date!(2019-01-01)
        .with_time(time!(23:59:59.999))
        .assume_utc()
        .millisecond(),
    999,
);

`pub fn microsecond(self) -> u32`[src]

Get the microseconds within the second in the stored offset.

The returned value will always be in the range 0..1_000_000.

assert_eq!(
    date!(2019-01-01)
        .midnight()
        .assume_utc()
        .microsecond(),
    0,
);
assert_eq!(
    date!(2019-01-01)
        .with_time(time!(23:59:59.999_999))
        .assume_utc()
        .microsecond(),
    999_999,
);

`pub fn nanosecond(self) -> u32`[src]

Get the nanoseconds within the second in the stored offset.

The returned value will always be in the range 0..1_000_000_000.

assert_eq!(
    date!(2019-01-01)
        .midnight()
        .assume_utc()
        .nanosecond(),
    0,
);
assert_eq!(
    date!(2019-01-01)
        .with_time(time!(23:59:59.999_999_999))
        .assume_utc()
        .nanosecond(),
    999_999_999,
);

`impl OffsetDateTime`[src]

Methods that allow formatting the OffsetDateTime.

`pub fn format(self, format: impl Into<Format>) -> String`[src]

Format the OffsetDateTime using the provided string.

assert_eq!(
    date!(2019-01-02)
        .midnight()
        .assume_utc()
        .format("%F %r %z"),
    "2019-01-02 12:00:00 am +0000",
);

`pub fn lazy_format(self, format: impl Into<Format>) -> impl Display`[src]

Format the OffsetDateTime using the provided string.

assert_eq!(
    date!(2019-01-02)
        .midnight()
        .assume_utc()
        .lazy_format("%F %r %z")
        .to_string(),
    "2019-01-02 12:00:00 am +0000",
);

`pub fn parse( s: impl AsRef<str>, format: impl Into<Format> ) -> Result<Self, ParseError>`[src]

Attempt to parse an OffsetDateTime using the provided string.

assert_eq!(
    OffsetDateTime::parse("2019-01-02 00:00:00 +0000", "%F %T %z"),
    Ok(date!(2019-01-02).midnight().assume_utc()),
);
assert_eq!(
    OffsetDateTime::parse("2019-002 23:59:59 +0000", "%Y-%j %T %z"),
    Ok(date!(2019-002).with_time(time!(23:59:59)).assume_utc()),
);
assert_eq!(
    OffsetDateTime::parse("2019-W01-3 12:00:00 pm +0000", "%G-W%V-%u %r %z"),
    Ok(date!(2019-W01-3).with_time(time!(12:00)).assume_utc()),
);