Struct GenericShort 

pub struct GenericShort;

“CT” ⇒ time zone in generic non-location format, short length

Examples

use icu::datetime::input::{Date, DateTime, Time, TimeZone, TimeZoneInfo, UtcOffset};
use icu::datetime::NoCalendarFormatter;
use icu::datetime::fieldsets::zone::GenericShort;
use icu::locale::{locale, subtags::subtag};
use writeable::assert_writeable_eq;

let fmt = NoCalendarFormatter::try_new(
    locale!("en").into(),
    GenericShort
)
.unwrap();

// Time zone info for America/Chicago in the summer
let zone = TimeZone(subtag!("uschi"))
    .with_offset("-05".parse().ok())
    .at_date_time_iso(DateTime{ date: Date::try_new_iso(2022, 8, 29).unwrap(), time: Time::start_of_day() });

assert_writeable_eq!(
    fmt.format(&zone),
    "CT"
);

If a non-location name is not defined, falls back to the location format, which is often significantly longer! This is the case for most zones, as each locale only contains the short names that are used locally and generally understood:

use icu::datetime::input::{Date, DateTime, Time, TimeZone, TimeZoneInfo, UtcOffset};
use icu::datetime::NoCalendarFormatter;
use icu::datetime::fieldsets::zone::GenericShort;
use icu::locale::{locale, subtags::subtag};
use writeable::assert_writeable_eq;

// Time zone info for Asia/Tokyo
let zone = TimeZone(subtag!("jptyo"))
    .with_offset("+09".parse().ok())
    .at_date_time_iso(DateTime{ date: Date::try_new_iso(2022, 1, 29).unwrap(), time: Time::start_of_day() });

let fmt = NoCalendarFormatter::try_new(
    locale!("en").into(),
    GenericShort,
)
.unwrap();

// "JST" is not generally known in American English
assert_writeable_eq!(
    fmt.format(&zone),
    "Japan Time"
);

If the offset doesn’t match one of the valid offsets for the zone, falls back to the localized offset format:

use icu::datetime::input::{Date, DateTime, Time, TimeZone, TimeZoneInfo, UtcOffset};
use icu::datetime::NoCalendarFormatter;
use icu::datetime::fieldsets::zone::GenericShort;
use icu::locale::{locale, subtags::subtag};
use writeable::assert_writeable_eq;

// Time zone info for America/Chicago with a wrong offset
let wrong_offset = TimeZone(subtag!("uschi"))
    .with_offset("-04".parse().ok())
    .at_date_time_iso(DateTime{ date: Date::try_new_iso(2022, 8, 29).unwrap(), time: Time::start_of_day() });

let fmt = NoCalendarFormatter::try_new(
    locale!("en").into(),
    GenericShort,
)
.unwrap();

assert_writeable_eq!(
    fmt.format(&wrong_offset),
    "GMT-4"
);

// This of course always happens for the unknown time zone
let unk = TimeZone::UNKNOWN.with_offset(wrong_offset.offset()).with_zone_name_timestamp(wrong_offset.zone_name_timestamp());

assert_writeable_eq!(
    fmt.format(&unk),
    "GMT-4"
);

Since non-location names might change over time, this time zone style requires a reference time.

use icu::datetime::NoCalendarFormatter;
use icu::datetime::fieldsets::zone::GenericShort;
use icu::datetime::input::TimeZone;
use icu::locale::{locale, subtags::subtag};

let time_zone_basic = TimeZone(subtag!("uschi")).without_offset();

let formatter = NoCalendarFormatter::try_new(
    locale!("en-US").into(),
    GenericShort,
)
.unwrap();

// error[E0271]: type mismatch resolving `<Base as TimeZoneModel>::ZoneNameTimestamp == ZoneNameTimestamp`
formatter.format(&time_zone_basic);

Trait Implementations

impl Clone for GenericShort

fn clone(&self) -> GenericShort

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl DateTimeMarkers for GenericShort

type D = ()

Associated types for date formatting.

type T = ()

Associated types for time formatting.

type Z = GenericShort

Associated types for time zone formatting.

type GluePatternV1 = NeverMarker<GluePattern<'static>>

Marker for loading the date/time glue pattern.

impl DateTimeNamesMarker for GenericShort

type YearNames = ()

type MonthNames = ()

type WeekdayNames = ()

type DayPeriodNames = ()

type ZoneEssentials = TimezoneNamesEssentialsV1

type ZoneLocations = TimezoneNamesLocationsOverrideV1

type ZoneLocationsRoot = TimezoneNamesLocationsRootV1

type ZoneExemplars = ()

type ZoneExemplarsRoot = ()

type ZoneGenericLong = ()

type ZoneGenericShort = TimezoneNamesGenericShortV1

type ZoneStandardLong = ()

type ZoneSpecificLong = ()

type ZoneSpecificShort = ()

type MetazoneLookup = TimezonePeriodsV1

impl Debug for GenericShort

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

Formats the value using the given formatter.

impl GetField<CompositeFieldSet> for GenericShort

fn get_field(&self) -> CompositeFieldSet

Returns the value of this trait’s field T.

impl PartialEq for GenericShort

fn eq(&self, other: &GenericShort) -> 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 ZoneMarkers for GenericShort

type TimeZoneIdInput = TimeZone

Marker for resolving the time zone id input field.

type TimeZoneOffsetInput = Option<UtcOffset>

Marker for resolving the time zone offset input field.

type TimeZoneNameTimestampInput = ZoneNameTimestamp

Marker for resolving the time zone non-location display names, which depend on the datetime.

type EssentialsV1 = TimezoneNamesEssentialsV1

Marker for loading core time zone data.

type LocationsV1 = TimezoneNamesLocationsOverrideV1

Marker for loading location names for time zone formatting

type LocationsRootV1 = TimezoneNamesLocationsRootV1

Marker for loading location names for time zone formatting

type ExemplarCitiesV1 = NeverMarker<ExemplarCities<'static>>

Marker for loading exemplar city names for time zone formatting

type ExemplarCitiesRootV1 = NeverMarker<ExemplarCities<'static>>

Marker for loading exemplar city names for time zone formatting

type GenericLongV1 = NeverMarker<MetazoneGenericNames<'static>>

Marker for loading generic long time zone names.

type GenericShortV1 = TimezoneNamesGenericShortV1

Marker for loading generic short time zone names.

type StandardLongV1 = NeverMarker<MetazoneGenericNames<'static>>

Marker for loading standard long time zone names.

type SpecificLongV1 = NeverMarker<MetazoneSpecificNames<'static>>

Marker for loading specific long time zone names.

type SpecificShortV1 = NeverMarker<MetazoneSpecificNames<'static>>

Marker for loading generic short time zone names.

type MetazonePeriodV1 = TimezonePeriodsV1

Marker for loading metazone periods.

impl Copy for GenericShort

impl Eq for GenericShort

impl StructuralPartialEq for GenericShort

impl UnstableSealed for GenericShort