Struct time::OffsetDateTime[][src]

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.

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]

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]

👎 Deprecated since 0.2.23:

UTC is returned if the local offset cannot be determined

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, IndeterminateOffset>[src]

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.

let now = OffsetDateTime::try_now_local();
assert!(now.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(),
);

If you have a timestamp-nanosecond pair, you can use something along the lines of the following:

let (timestamp, nanos) = (1, 500_000_000);
assert_eq!(
    OffsetDateTime::from_unix_timestamp(timestamp) + Duration::nanoseconds(nanos),
    OffsetDateTime::unix_epoch() + 1.5.seconds()
);

pub fn from_unix_timestamp_nanos(timestamp: i128) -> Self[src]

Construct an OffsetDateTime from the provided Unix timestamp (in nanoseconds).

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

Note that the range of timestamps possible here is far larger than the valid range of dates storable in this crate. It is the user’s responsibility to ensure the timestamp provided as a parameter is valid. No behavior is guaranteed if this parameter would not result in a valid value.

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 unix_timestamp(self) -> i64[src]

Get the Unix timestamp.

assert_eq!(
    date!(1970-01-01)
        .midnight()
        .assume_utc()
        .unix_timestamp(),
    0,
);
assert_eq!(
    date!(1970-01-01)
        .midnight()
        .assume_utc()
        .to_offset(offset!(-1))
        .unix_timestamp(),
    0,
);

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

👎 Deprecated since 0.2.23:

Use OffsetDateTime::unix_timestamp instead

Get the Unix timestamp.

assert_eq!(
    date!(1970-01-01)
        .midnight()
        .assume_utc()
        .timestamp(),
    0,
);
assert_eq!(
    date!(1970-01-01)
        .midnight()
        .assume_utc()
        .to_offset(offset!(-1))
        .timestamp(),
    0,
);

pub fn unix_timestamp_nanos(self) -> i128[src]

Get the Unix timestamp in nanoseconds.

use time::{date, offset, time};
assert_eq!(
    date!(1970-01-01)
        .midnight()
        .assume_utc()
        .unix_timestamp_nanos(),
    0,
);
assert_eq!(
    date!(1970-01-01)
        .with_time(time!(1:00))
        .assume_utc()
        .to_offset(offset!(-1))
        .unix_timestamp_nanos(),
    3_600_000_000_000,
);

pub fn timestamp_nanos(self) -> i128[src]

👎 Deprecated since 0.2.23:

Use OffsetDateTime::unix_timestamp_nanos instead

Get the Unix timestamp in nanoseconds.

use time::{date, offset, time};
assert_eq!(
    date!(1970-01-01)
        .midnight()
        .assume_utc()
        .unix_timestamp_nanos(),
    0,
);
assert_eq!(
    date!(1970-01-01)
        .with_time(time!(1:00))
        .assume_utc()
        .to_offset(offset!(-1))
        .unix_timestamp_nanos(),
    3_600_000_000_000,
);

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, Error>
[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()),
);

Trait Implementations

impl Add<Duration> for OffsetDateTime[src]

type Output = Self

The resulting type after applying the + operator.

impl Add<Duration> for OffsetDateTime[src]

type Output = Self

The resulting type after applying the + operator.

impl AddAssign<Duration> for OffsetDateTime[src]

impl AddAssign<Duration> for OffsetDateTime[src]

impl Clone for OffsetDateTime[src]

impl Copy for OffsetDateTime[src]

impl Debug for OffsetDateTime[src]

impl Display for OffsetDateTime[src]

impl Eq for OffsetDateTime[src]

impl From<SystemTime> for OffsetDateTime[src]

impl Hash for OffsetDateTime[src]

impl Ord for OffsetDateTime[src]

impl PartialEq<OffsetDateTime> for OffsetDateTime[src]

impl PartialEq<SystemTime> for OffsetDateTime[src]

impl PartialOrd<OffsetDateTime> for OffsetDateTime[src]

impl PartialOrd<SystemTime> for OffsetDateTime[src]

impl StructuralEq for OffsetDateTime[src]

impl Sub<Duration> for OffsetDateTime[src]

type Output = Self

The resulting type after applying the - operator.

impl Sub<Duration> for OffsetDateTime[src]

type Output = Self

The resulting type after applying the - operator.

impl Sub<OffsetDateTime> for OffsetDateTime[src]

type Output = Duration

The resulting type after applying the - operator.

impl Sub<SystemTime> for OffsetDateTime[src]

type Output = Duration

The resulting type after applying the - operator.

impl SubAssign<Duration> for OffsetDateTime[src]

impl SubAssign<Duration> for OffsetDateTime[src]

Auto Trait Implementations

impl RefUnwindSafe for OffsetDateTime

impl Send for OffsetDateTime

impl Sync for OffsetDateTime

impl Unpin for OffsetDateTime

impl UnwindSafe for OffsetDateTime

Blanket Implementations

impl<T> Any for T where
    T: 'static + ?Sized
[src]

impl<T> Borrow<T> for T where
    T: ?Sized
[src]

impl<T> BorrowMut<T> for T where
    T: ?Sized
[src]

impl<T> From<T> for T[src]

impl<T, U> Into<U> for T where
    U: From<T>, 
[src]

impl<T> Sealed<T> for T where
    T: ?Sized
[src]

impl<T> ToOwned for T where
    T: Clone
[src]

type Owned = T

The resulting type after obtaining ownership.

impl<T> ToString for T where
    T: Display + ?Sized
[src]

impl<T, U> TryFrom<U> for T where
    U: Into<T>, 
[src]

type Error = Infallible

The type returned in the event of a conversion error.

impl<T, U> TryInto<U> for T where
    U: TryFrom<T>, 
[src]

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.