Struct tzfile::Tz

pub struct Tz { /* fields omitted */ }

Time zone parsed from a tz database file.

When a time zone has complex transition rules, a Tz object can be very large and expensive to clone. As every DateTime instant would store a copy of the time zone object, it would be very slow to support DateTime<Tz> directly. Therefore, Tz itself does not implement TimeZone. Rather, you may use one of the following instead:

• &'a Tz — zero cost to clone, but only valid within the lifetime 'a.
• RcTz — uses reference counting (Rc) to support shallow cloning, but is not thread-safe.
• ArcTz — uses atomic reference counting (Arc) to support shallow cloning, slightly more expensive than RcTz but is thread-safe.

Examples

Read the time zone information from the system, and use &Tz as TimeZone.

use chrono::{Utc, TimeZone};
use tzfile::Tz;

let tz = Tz::named("America/New_York")?;
let dt1 = Utc.ymd(2019, 3, 10).and_hms(6, 45, 0);
assert_eq!(dt1.with_timezone(&&tz).to_string(), "2019-03-10 01:45:00 EST");
let dt2 = Utc.ymd(2019, 3, 10).and_hms(7, 15, 0);
assert_eq!(dt2.with_timezone(&&tz).to_string(), "2019-03-10 03:15:00 EDT");

Methods

impl Tz

pub fn parse(_name: &str, source: &[u8]) -> Result<Self, Error>

Parses the content of the tz database file.

This crate can only recognize version 2 and 3 of the tz database. Like chrono, leap second information is ignored. The embedded POSIX TZ string, which describes non-hard-coded transition rules in the far future, is also not handled.

Examples

Read a file into bytes and then parse it.

use tzfile::Tz;

let content = std::fs::read("/usr/share/zoneinfo/Etc/UTC")?;
let tz = Tz::parse(&content)?;

pub fn named(name: &str) -> Result<Self>

Reads and parses a system time zone.

This function is equivalent to reading /usr/share/zoneinfo/{name} and the constructs a time zone via parse().

This function is currently only supported on Unix.

pub fn local() -> Result<Self>

Reads the parses the current local time zone.

This function calls Tz::named($TZ) if the environment variable $TZ is set, otherwise reads and parses /etc/localtime.

This function is currently only supported on Unix.

Trait Implementations

impl Eq for Tz

impl PartialEq<Tz> for Tz

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

This method tests for self and other values to be equal, and is used by ==.

#[must_use]

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

This method tests for !=.

impl From<Utc> for Tz

fn from(_: Utc) -> Self

Performs the conversion.

impl From<FixedOffset> for Tz

fn from(offset: FixedOffset) -> Self

Performs the conversion.

impl Clone for Tz

fn clone(&self) -> Tz

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Tz

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

Formats the value using the given formatter.

impl Hash for Tz

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, 

Feeds a slice of this type into the given [Hasher].

impl<'a> TimeZone for &'a Tz

type Offset = Offset<Self>

An associated offset type. This type is used to store the actual offset in date and time types. The original TimeZone value can be recovered via TimeZone::from_offset.

fn from_offset(offset: &Self::Offset) -> Self

Reconstructs the time zone from the offset.

fn offset_from_utc_datetime(&self, utc: &NaiveDateTime) -> Self::Offset

Creates the offset for given UTC NaiveDateTime. This cannot fail.

fn offset_from_utc_date(&self, utc: &NaiveDate) -> Self::Offset

Creates the offset for given UTC NaiveDate. This cannot fail.

fn offset_from_local_date(&self, local: &NaiveDate) -> LocalResult<Self::Offset>

Creates the offset(s) for given local NaiveDate if possible.

fn offset_from_local_datetime(
    &self,
    local: &NaiveDateTime
) -> LocalResult<Self::Offset>

Creates the offset(s) for given local NaiveDateTime if possible.

fn ymd(&self, year: i32, month: u32, day: u32) -> Date<Self>

Makes a new Date from year, month, day and the current time zone. This assumes the proleptic Gregorian calendar, with the year 0 being 1 BCE.

fn ymd_opt(&self, year: i32, month: u32, day: u32) -> LocalResult<Date<Self>>

Makes a new Date from year, month, day and the current time zone. This assumes the proleptic Gregorian calendar, with the year 0 being 1 BCE.

fn yo(&self, year: i32, ordinal: u32) -> Date<Self>

Makes a new Date from year, day of year (DOY or "ordinal") and the current time zone. This assumes the proleptic Gregorian calendar, with the year 0 being 1 BCE.

fn yo_opt(&self, year: i32, ordinal: u32) -> LocalResult<Date<Self>>

Makes a new Date from year, day of year (DOY or "ordinal") and the current time zone. This assumes the proleptic Gregorian calendar, with the year 0 being 1 BCE.

fn isoywd(&self, year: i32, week: u32, weekday: Weekday) -> Date<Self>

Makes a new Date from ISO week date (year and week number), day of the week (DOW) and the current time zone. This assumes the proleptic Gregorian calendar, with the year 0 being 1 BCE. The resulting Date may have a different year from the input year.

fn isoywd_opt(
    &self,
    year: i32,
    week: u32,
    weekday: Weekday
) -> LocalResult<Date<Self>>

Makes a new Date from ISO week date (year and week number), day of the week (DOW) and the current time zone. This assumes the proleptic Gregorian calendar, with the year 0 being 1 BCE. The resulting Date may have a different year from the input year.

fn timestamp(&self, secs: i64, nsecs: u32) -> DateTime<Self>

Makes a new DateTime from the number of non-leap seconds since January 1, 1970 0:00:00 UTC (aka "UNIX timestamp") and the number of nanoseconds since the last whole non-leap second.

fn timestamp_opt(&self, secs: i64, nsecs: u32) -> LocalResult<DateTime<Self>>

Makes a new DateTime from the number of non-leap seconds since January 1, 1970 0:00:00 UTC (aka "UNIX timestamp") and the number of nanoseconds since the last whole non-leap second.

fn timestamp_millis(&self, millis: i64) -> DateTime<Self>

Makes a new DateTime from the number of non-leap milliseconds since January 1, 1970 0:00:00 UTC (aka "UNIX timestamp").

fn timestamp_millis_opt(&self, millis: i64) -> LocalResult<DateTime<Self>>

Makes a new DateTime from the number of non-leap milliseconds since January 1, 1970 0:00:00 UTC (aka "UNIX timestamp").

fn datetime_from_str(
    &self,
    s: &str,
    fmt: &str
) -> Result<DateTime<Self>, ParseError>

Parses a string with the specified format string and returns a DateTime with the current offset. See the format::strftime module on the supported escape sequences.

fn from_local_date(&self, local: &NaiveDate) -> LocalResult<Date<Self>>

Converts the local NaiveDate to the timezone-aware Date if possible.

fn from_local_datetime(
    &self,
    local: &NaiveDateTime
) -> LocalResult<DateTime<Self>>

Converts the local NaiveDateTime to the timezone-aware DateTime if possible.

fn from_utc_date(&self, utc: &NaiveDate) -> Date<Self>

Converts the UTC NaiveDate to the local time. The UTC is continuous and thus this cannot fail (but can give the duplicate local time).

fn from_utc_datetime(&self, utc: &NaiveDateTime) -> DateTime<Self>

Converts the UTC NaiveDateTime to the local time. The UTC is continuous and thus this cannot fail (but can give the duplicate local time).