Struct icu_datetime::FormattedTimeZone

pub struct FormattedTimeZone<'l, T>where
    T: TimeZoneInput,{ /* private fields */ }

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

Implementations

impl<'l, T> FormattedTimeZone<'l, T>where
    T: TimeZoneInput,

pub fn write_no_fallback<W>(&self, w: &mut W) -> Result<Result, Error>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_unstable(
    &icu_testdata::unstable(),
    &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.load_generic_location_format(&icu_testdata::unstable())
    .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> 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.