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>, 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> Debug for FormattedTimeZone<'l, T>where T: Debug + TimeZoneInput,

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

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<(), Error>

Formats the value using the given formatter.

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

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

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.