Struct icu_datetime::FormattedTimeZone

pub struct FormattedTimeZone<'l, T>
where
    T: TimeZoneInput,
{
    pub(crate) time_zone_format: &'l TimeZoneFormatter,
    pub(crate) time_zone: &'l T,
}

FormattedTimeZone is a intermediate structure which can be retrieved as an output from TimeZoneFormatter.

Fields

time_zone_format: &'l TimeZoneFormatter

time_zone: &'l T

Implementations

impl<'l, T> FormattedTimeZone<'l, T>

where T: TimeZoneInput,

pub fn write_no_fallback<W>(&self, w: &mut W) -> Result<Result, DateTimeError>

where W: Write + ?Sized,

Write time zone with no fallback.

Examples

use icu::datetime::time_zone::TimeZoneFormatter;
use icu::datetime::DateTimeError;
use icu::locid::locale;
use icu::timezone::CustomTimeZone;
use tinystr::tinystr;

let mut tzf =
    TimeZoneFormatter::try_new(&locale!("en").into(), Default::default())
        .unwrap();
let mut buf = String::new();

let mut time_zone = "Z".parse::<CustomTimeZone>().unwrap();
time_zone.time_zone_id = Some(tinystr!(8, "gblon").into());

// There are no non-fallback formats enabled:
assert!(matches!(
    tzf.format(&time_zone).write_no_fallback(&mut buf),
    Err(DateTimeError::UnsupportedOptions)
));
assert!(buf.is_empty());

// Enable a non-fallback format:
tzf.include_generic_location_format().unwrap();
assert!(matches!(
    tzf.format(&time_zone).write_no_fallback(&mut buf),
    Ok(Ok(_))
));
assert_eq!("London Time", buf);

// Errors still occur if the time zone is not supported:
buf.clear();
time_zone.time_zone_id = Some(tinystr!(8, "zzzzz").into());
assert!(matches!(
    tzf.format(&time_zone).write_no_fallback(&mut buf),
    Err(DateTimeError::UnsupportedOptions)
));

// Use the `Writable` trait instead to enable infallible formatting:
writeable::assert_writeable_eq!(tzf.format(&time_zone), "GMT");

Trait Implementations

impl<'l, T> Clone for FormattedTimeZone<'l, T>

where T: TimeZoneInput + Clone,

fn clone(&self) -> FormattedTimeZone<'l, T>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'l, T> Debug for FormattedTimeZone<'l, T>

where T: TimeZoneInput + Debug,

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

Formats the value using the given formatter.

impl<'l, T> Display for FormattedTimeZone<'l, T>

where T: TimeZoneInput,

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

Formats the value using the given formatter.

impl<'l, T> Writeable for FormattedTimeZone<'l, T>

where T: TimeZoneInput,

fn write_to<W: Write + ?Sized>(&self, sink: &mut W) -> Result

Format time zone with fallbacks.

fn write_to_parts<S>(&self, sink: &mut S) -> Result<(), Error>

where S: PartsWrite + ?Sized,

Write bytes and Part annotations to the given sink. Errors from the sink are bubbled up. The default implementation delegates to write_to, and doesn’t produce any Part annotations.

fn writeable_length_hint(&self) -> LengthHint

Returns a hint for the number of UTF-8 bytes that will be written to the sink.

fn write_to_string(&self) -> Cow<'_, str>

Creates a new String with the data from this Writeable. Like ToString, but smaller and faster.

fn writeable_cmp_bytes(&self, other: &[u8]) -> Ordering

Compares the contents of this Writeable to the given bytes without allocating a String to hold the Writeable contents.

impl<'l, T> Copy for FormattedTimeZone<'l, T>

where T: TimeZoneInput + Copy,