Struct hifitime::efmt::format::Format

source ·
pub struct Format { /* private fields */ }
Expand description

Format allows formatting an Epoch with some custom arrangement of the Epoch items. This provides almost all of the options from the 1989 C standard.

Construct a format with Format::from_str (no allocation needed) where the string contains a succession of tokens (each starting with %) and up to two separators between tokens.

Then this format can then be provided to the Formatter for formatting. This is also no-std.

Supported tokens

Any token may be followed by ? to make it optional. For integer values, an optional token will only be printed if its value is non-zero. For time scales, only non-UTC time scale will be printed.

C89 standard tokens

TokenExplanationExampleNotes
%YProleptic Gregorian year, zero-padded to 4 digits2022(1)
%mMonth number, zero-padded to 2 digits03 for MarchN/A
%bMonth name in short formMar for MarchN/A
%BMonth name in long formMarchN/A
%dDay number, zero-padded to 2 digits07 for the 7th day of the monthN/A
%jDay of year, zero-padded to 3 digits059 for 29 February 2000N/A
%AWeekday name in long formMondayN/A
%aWeekday name in short formMon for MondayN/A
%HHour number, zero-padded to 2 digits02 for the 2nd hour of the dayN/A
%MMinute number, zero-padded to 2 digits39 for the 39th minutes of the hourN/A
%SSeconds, zero-padded to 2 digits27 for the 27th second of the minuteN/A
%fSub-seconds, zero-padded to 9 digits000000007 for the 7th nanosecond past the second(2)
%wWeekday in decimal form with C89 standard01 for Dynamical barycentric time(3)
%zOffset timezone if the formatter is provided with an epoch.+15:00 For GMT +15 hours and zero minutesN/A
  • (1): Hifitime supports years from -34668 to 34668. If your epoch is larger than +/- 9999 years, the formatting of the years will show all five digits of the year.
  • (2): Hifitime supports exactly nanosecond precision, and this is not lost when formatting.

Hifitime specific tokens

These are chosen to not conflict with strptime/strfime of the C89 standard. | Token | Explanation | Example | Notes | :– | :– | :– | :– | | %T | Time scale used to represent this date | TDB for Dynamical barycentric time | (3) | | %J | Full day of year as a double | 59.62325231481524 for 29 February 2000 14:57:29 UTC | N/A |

  • (3): Hifitime supports many time scales and these should not be lost when formatting. This is a novelty compared to other time management libraries as most do not have any concept of time scales.

Example

use hifitime::prelude::*;
use hifitime::efmt;
use hifitime::efmt::consts;
use core::str::FromStr;

let bday = Epoch::from_gregorian_utc(2000, 2, 29, 14, 57, 29, 37);

let fmt = efmt::Format::from_str("%Y-%m-%d").unwrap();
assert_eq!(fmt, consts::ISO8601_DATE);

let fmtd_bday = Formatter::new(bday, fmt);
assert_eq!(format!("{fmtd_bday}"), format!("2000-02-29"));

let fmt = Format::from_str("%Y-%m-%dT%H:%M:%S.%f %T").unwrap();
assert_eq!(fmt, consts::ISO8601);

let fmtd_bday = Formatter::new(bday, fmt);
// ISO with the timescale is the default format
assert_eq!(format!("{fmtd_bday}"), format!("{bday}"));

let fmt = Format::from_str("%Y-%j").unwrap();
assert_eq!(fmt, consts::ISO8601_ORDINAL);

let fmt_iso_ord = Formatter::new(bday, consts::ISO8601_ORDINAL);
assert_eq!(format!("{fmt_iso_ord}"), "2000-059");

let fmt = Format::from_str("%A, %d %B %Y %H:%M:%S").unwrap();
assert_eq!(fmt, consts::RFC2822_LONG);

let fmt = Formatter::new(bday, consts::RFC2822_LONG);
assert_eq!(
    format!("{fmt}"),
    format!("Tuesday, 29 February 2000 14:57:29")
);

let fmt = Format::from_str("%a, %d %b %Y %H:%M:%S").unwrap();
assert_eq!(fmt, consts::RFC2822);

let fmt = Formatter::new(bday, consts::RFC2822);
assert_eq!(format!("{fmt}"), format!("Tue, 29 Feb 2000 14:57:29"));

Implementations§

source§

impl Format

source

pub fn parse(&self, s_in: &str) -> Result<Epoch, Errors>

Trait Implementations§

source§

impl Clone for Format

source§

fn clone(&self) -> Format

Returns a copy of the value. Read more
1.0.0 · source§

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

Performs copy-assignment from source. Read more
source§

impl Debug for Format

source§

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

Formats the value using the given formatter. Read more
source§

impl Default for Format

source§

fn default() -> Format

Returns the “default value” for a type. Read more
source§

impl FromStr for Format

§

type Err = ParsingErrors

The associated error which can be returned from parsing.
source§

fn from_str(s: &str) -> Result<Self, Self::Err>

Parses a string s to return a value of this type. Read more
source§

impl PartialEq for Format

source§

fn eq(&self, other: &Format) -> bool

This method tests for self and other values to be equal, and is used by ==.
1.0.0 · source§

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.
source§

impl Copy for Format

source§

impl StructuralPartialEq for Format

Auto Trait Implementations§

Blanket Implementations§

source§

impl<T> Any for T
where T: 'static + ?Sized,

source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
source§

impl<T> Borrow<T> for T
where T: ?Sized,

source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
source§

impl<T> BorrowMut<T> for T
where T: ?Sized,

source§

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
source§

impl<T> From<T> for T

source§

fn from(t: T) -> T

Returns the argument unchanged.

source§

impl<T, U> Into<U> for T
where U: From<T>,

source§

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

source§

impl<T> ToOwned for T
where T: Clone,

§

type Owned = T

The resulting type after obtaining ownership.
source§

fn to_owned(&self) -> T

Creates owned data from borrowed data, usually by cloning. Read more
source§

fn clone_into(&self, target: &mut T)

Uses borrowed data to replace owned data, usually by cloning. Read more
source§

impl<T, U> TryFrom<U> for T
where U: Into<T>,

§

type Error = Infallible

The type returned in the event of a conversion error.
source§

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
source§

impl<T, U> TryInto<U> for T
where U: TryFrom<T>,

§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.