Struct icu_timezone::CustomTimeZone

pub struct CustomTimeZone {
    pub offset: Option<UtcOffset>,
    pub time_zone_id: TimeZoneBcp47Id,
    pub metazone_id: Option<Option<MetazoneId>>,
    pub zone_variant: Option<ZoneVariant>,
}

A utility type that can hold time zone information.

The UTC offset is used as a final fallback for formatting. The other three fields are used for more human-friendly rendering of the time zone.

This type does not enforce that the four fields are consistent with each other. If they do not represent a real time zone, unexpected results when formatting may occur.

Examples

use icu::timezone::CustomTimeZone;

let tz1 = CustomTimeZone::utc();

let tz2: CustomTimeZone =
    "+05:00".parse().expect("Failed to parse a time zone.");

Fields

offset: Option<UtcOffset>

The UTC offset.

time_zone_id: TimeZoneBcp47Id

The BCP47 time-zone identifier

metazone_id: Option<Option<MetazoneId>>

The CLDR metazone identifier

This is Some(None) if the metazone has been resolved, but the time zone does not have a metazone.

zone_variant: Option<ZoneVariant>

The time variant e.g. daylight or standard

Implementations

impl CustomTimeZone

pub const fn new_with_offset(offset: UtcOffset) -> Self

Creates a new CustomTimeZone with the given UTC offset.

pub const fn new_with_bcp47_id(time_zone_id: TimeZoneBcp47Id) -> Self

Creates a new CustomTimeZone with a given BCP47 time zone identifier.

pub const fn unknown() -> Self

Creates a time zone with no information.

One or more fields must be specified before this time zone is usable.

pub const fn from_parts( offset_eighths_of_hour: i8, time_zone_id: TinyAsciiStr<8>, metazone_id: TinyAsciiStr<4>, zone_variant: TinyAsciiStr<2>, ) -> Self

Creates a time zone infallibly from raw parts.

pub const fn utc() -> Self

Creates a new CustomTimeZone for the UTC time zone.

pub fn from_str(s: &str) -> Self

Parse a CustomTimeZone from a UTF-8 string representing a UTC offset or an IANA time zone identifier.

This is a convenience constructor that uses compiled data. For a custom data provider, use UtcOffset or TimeZoneIdMapper directly.

To parse from an IXDTF string, use CustomZonedDateTime::try_iso_from_str.

✨ Enabled with the compiled_data Cargo feature.

Examples

use icu::timezone::CustomTimeZone;
use icu::timezone::UtcOffset;

let tz0: CustomTimeZone = CustomTimeZone::from_str("Z");
let tz1: CustomTimeZone = CustomTimeZone::from_str("+02");
let tz2: CustomTimeZone = CustomTimeZone::from_str("-0230");
let tz3: CustomTimeZone = CustomTimeZone::from_str("+02:30");

assert_eq!(tz0.offset.map(UtcOffset::to_seconds), Some(0));
assert_eq!(tz1.offset.map(UtcOffset::to_seconds), Some(7200));
assert_eq!(tz2.offset.map(UtcOffset::to_seconds), Some(-9000));
assert_eq!(tz3.offset.map(UtcOffset::to_seconds), Some(9000));

pub fn from_utf8(code_units: &[u8]) -> Self

See Self::from_str

pub fn maybe_calculate_metazone( &mut self, metazone_calculator: &MetazoneCalculator, local_datetime: &DateTime<Iso>, ) -> &mut Self

Infer the metazone ID.

Examples

use icu::calendar::DateTime;
use icu::timezone::MetazoneId;
use icu::timezone::TimeZoneBcp47Id;
use icu::timezone::CustomTimeZone;
use icu::timezone::MetazoneCalculator;
use tinystr::tinystr;

let mzc = MetazoneCalculator::new();
let mut tz = CustomTimeZone::new_with_bcp47_id(TimeZoneBcp47Id(tinystr!(8, "gugum")));
tz.maybe_calculate_metazone(
    &mzc,
    &DateTime::try_new_iso_datetime(1971, 10, 31, 2, 0, 0).unwrap(),
);
assert_eq!(tz.metazone_id.unwrap(), Some(MetazoneId(tinystr!(4, "guam"))));

pub fn maybe_calculate_zone_variant( &mut self, zone_offset_calculator: &ZoneOffsetCalculator, local_datetime: &DateTime<Iso>, ) -> &mut Self

Infer the zone variant.

Examples

use icu::calendar::DateTime;
use icu::timezone::ZoneVariant;
use icu::timezone::TimeZoneBcp47Id;
use icu::timezone::CustomTimeZone;
use icu::timezone::ZoneOffsetCalculator;
use tinystr::tinystr;

let zoc = ZoneOffsetCalculator::new();
let mut tz = CustomTimeZone {
    offset: Some("+10".parse().expect("Failed to parse a UTC offset.")),
    time_zone_id: TimeZoneBcp47Id(tinystr!(8, "gugum")),
    metazone_id: None,
    zone_variant: None,
};
tz.maybe_calculate_zone_variant(
    &zoc,
    &DateTime::try_new_iso_datetime(1971, 10, 31, 2, 0, 0).unwrap(),
);
assert_eq!(tz.zone_variant, Some(ZoneVariant::standard()));

Trait Implementations

impl Clone for CustomTimeZone

fn clone(&self) -> CustomTimeZone

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for CustomTimeZone

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

Formats the value using the given formatter.

impl FromStr for CustomTimeZone

type Err = Infallible

The associated error which can be returned from parsing.

fn from_str(s: &str) -> Result<Self, Self::Err>

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

impl PartialEq for CustomTimeZone

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

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

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

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Copy for CustomTimeZone

impl Eq for CustomTimeZone

impl StructuralPartialEq for CustomTimeZone