Struct Formatter 

pub(super) struct Formatter<'config, 'fmt, 'tm, 'writer, 'buffer, 'data, 'write, L> {
    pub(super) config: &'config Config<L>,
    pub(super) fmt: &'fmt [u8],
    pub(super) tm: &'tm BrokenDownTime,
    pub(super) wtr: &'writer mut BorrowedWriter<'buffer, 'data, 'write>,
}

Fields

config: &'config Config<L>

fmt: &'fmt [u8]

tm: &'tm BrokenDownTime

wtr: &'writer mut BorrowedWriter<'buffer, 'data, 'write>

Implementations

impl<'config, 'fmt, 'tm, 'writer, 'buffer, 'data, 'write, L: Custom> Formatter<'config, 'fmt, 'tm, 'writer, 'buffer, 'data, 'write, L>

pub(super) fn format(&mut self) -> Result<(), Error>

fn format_one(&mut self, ext: &Extension) -> Result<(), Error>

fn f(&self) -> u8

Returns the byte at the current position of the format string.

Panics

This panics when the entire format string has been consumed.

fn bump_fmt(&mut self) -> bool

Bumps the position of the format string.

This returns true in precisely the cases where self.f() will not panic. i.e., When the end of the format string hasn’t been reached yet.

fn utf8_decode_and_bump(&mut self) -> Result<char, FE>

Decodes a Unicode scalar value from the beginning of fmt and advances the parser accordingly.

If a Unicode scalar value could not be decoded, then an error is returned.

It would be nice to just pass through bytes as-is instead of doing actual UTF-8 decoding, but since the Write trait only represents Unicode-accepting buffers, we need to actually do decoding here.

Errors

Unless lenient parsing is enabled, this returns an error if UTF-8 decoding failed. When lenient parsing is enabled, decoding errors are turned into the Unicode replacement codepoint via the “substitution of maximal subparts” strategy.

Panics

When self.fmt is empty. i.e., Only call this when you know there is some remaining bytes to parse.

fn parse_extension(&mut self) -> Result<Extension, Error>

Parses optional extensions before a specifier directive. That is, right after the %. If any extensions are parsed, the parser is bumped to the next byte. (If no next byte exists, then an error is returned.)

fn parse_flag(&mut self) -> Result<Option<Flag>, Error>

Parses an optional flag. And if one is parsed, the parser is bumped to the next byte. (If no next byte exists, then an error is returned.)

fn parse_width(&mut self) -> Result<Option<u8>, Error>

Parses an optional width that comes after a (possibly absent) flag and before the specifier directive itself. And if a width is parsed, the parser is bumped to the next byte. (If no next byte exists, then an error is returned.)

Note that this is also used to parse precision settings for %f and %.f. In the former case, the width is just re-interpreted as a precision setting. In the latter case, something like %5.9f is technically valid, but the 5 is ignored.

fn parse_colons(&mut self) -> Result<u8, Error>

Parses an optional number of colons (up to 3) immediately before a conversion specifier.

fn write_item(&mut self, ext: &Extension, item: &Item) -> Result<(), Error>

fn fmt_ampm_lower(&self) -> Result<ItemString, Error>

%P

fn fmt_ampm_upper(&self, ext: &Extension) -> Result<ItemString, Error>

%p

fn fmt_american_date(&mut self) -> Result<Item, Error>

%D

fn fmt_clock_nosecs(&mut self) -> Result<Item, Error>

%R

fn fmt_clock_secs(&mut self) -> Result<Item, Error>

%T

fn fmt_iso_date(&mut self) -> Result<Item, Error>

%F

fn fmt_day_zero(&self) -> Result<ItemInteger, Error>

%d

fn fmt_day_space(&self) -> Result<ItemInteger, Error>

%e

fn fmt_hour12_zero(&self) -> Result<ItemInteger, Error>

%I

fn fmt_hour24_zero(&self) -> Result<ItemInteger, Error>

%H

fn fmt_hour12_space(&self) -> Result<ItemInteger, Error>

%l

fn fmt_hour24_space(&self) -> Result<ItemInteger, Error>

%k

fn fmt_minute(&self) -> Result<ItemInteger, Error>

%M

fn fmt_month(&self) -> Result<ItemInteger, Error>

%m

fn fmt_month_full(&self) -> Result<ItemString, Error>

%B

fn fmt_month_abbrev(&self) -> Result<ItemString, Error>

%b, %h

fn fmt_iana_nocolon(&mut self) -> Result<Item, Error>

%Q

fn fmt_iana_colon(&mut self) -> Result<Item, Error>

%:Q

fn fmt_offset_nocolon(&self) -> Result<ItemOffset, Error>

%z

fn fmt_offset_colon(&self) -> Result<ItemOffset, Error>

%:z

fn fmt_offset_colon2(&self) -> Result<ItemOffset, Error>

%::z

fn fmt_offset_colon3(&self) -> Result<ItemOffset, Error>

%:::z

fn fmt_second(&self) -> Result<ItemInteger, Error>

%S

fn fmt_timestamp(&self) -> Result<ItemInteger, Error>

%s

fn fmt_fractional(&self, ext: &Extension) -> Result<Item, Error>

%f

fn fmt_dot_fractional(&self, ext: &Extension) -> Result<Item, Error>

%.f

fn fmt_nanoseconds(&self, ext: &Extension) -> Result<Item, Error>

%N

fn fmt_tzabbrev(&mut self, ext: &Extension) -> Result<Item, Error>

%Z

fn fmt_weekday_full(&self) -> Result<ItemString, Error>

%A

fn fmt_weekday_abbrev(&self) -> Result<ItemString, Error>

%a

fn fmt_weekday_mon(&self) -> Result<ItemInteger, Error>

%u

fn fmt_weekday_sun(&self) -> Result<ItemInteger, Error>

%w

fn fmt_week_sun(&self) -> Result<ItemInteger, Error>

%U

fn fmt_week_iso(&self) -> Result<ItemInteger, Error>

%V

fn fmt_week_mon(&self) -> Result<ItemInteger, Error>

%W

fn fmt_year(&self) -> Result<ItemInteger, Error>

%Y

fn fmt_year2(&self) -> Result<ItemInteger, Error>

%y

fn fmt_century(&self) -> Result<ItemInteger, Error>

%C

fn fmt_iso_week_year(&self) -> Result<ItemInteger, Error>

%G

fn fmt_iso_week_year2(&self) -> Result<ItemInteger, Error>

%g

fn fmt_quarter(&self) -> Result<ItemInteger, Error>

%q

fn fmt_day_of_year(&self) -> Result<ItemInteger, Error>

%j

fn fmt_literal(&self, literal: &'static str) -> Result<ItemString, Error>

%n, %t

fn fmt_datetime(&mut self, ext: &Extension) -> Result<Item, Error>

%c

fn fmt_date(&mut self, ext: &Extension) -> Result<Item, Error>

%x

fn fmt_time(&mut self, ext: &Extension) -> Result<Item, Error>

%X

fn fmt_12hour_time(&mut self, ext: &Extension) -> Result<Item, Error>

%r