Struct LiteStr 

pub struct LiteStr<const N: usize> {
    pub bytes: [u8; N],
}

A fixed-capacity, stack-allocated buffer that can hold a UTF-8 string.

LiteStr<N> stores its content in a [u8; N] array using C-style nul termination. The logical length is determined by the position of the first b'\0' byte (or N if the buffer is completely filled without a nul).

This type performs no validation during construction. UTF-8 validity is only checked when the content is accessed via [as_str], Debug, or serialization.

Both [new] and [from_bytes] silently truncate input that exceeds the capacity N. This type is intentionally minimal because each LiteStr<N> is monomorphized independently.

.len()

• Byte length: Use as_bytes().len()
• Unicode character count: Use as_str().chars().count()

Fields

bytes: [u8; N]

Implementations

impl<const N: usize> LiteStr<N>

pub const SIZE: usize = N

pub fn new(s: &str) -> Self

Creates a new LiteStr from a &str.

If the input is longer than N bytes, it is truncated at the nearest valid UTF-8 boundary.

pub fn as_str(&self) -> &str

Returns the longest valid UTF-8 prefix of the content as a &str.

• If the data is valid UTF-8, returns it directly.
• If the data starts with invalid bytes, returns a single replacement character (�).
• Otherwise returns only the valid prefix up to the first invalid sequence (everything after the first error is discarded).

This method is infallible and never allocates.

Examples found in repository

examples/readme.rs (line 20)

fn main() -> Result<(), DtErr> {
    // ============================================
    // Parsing
    // ============================================

    // Smart auto-parsing (multi-language + timezone)
    let dt = Dt::from_str_parse("15 mars 2024 à 14:30 [Europe/Paris]", &None)?;
    let s = dt.to_str_rfc9557("Europe/Paris")?;
    assert_eq!("2024-03-15T14:30:00+01:00[Europe/Paris]", s);

    // or with .parse
    let dt: Dt = "1 jan 2000 07:00 [America/New_York] TAI".parse()?; // noon utc
    assert_eq!(Dt::ZERO, dt); // library zero

    // Fast ISO parsing with time scale and no alloc output
    let dt = Dt::from_str_iso("2000-01-01T12:00:00 TAI")?;
    let lite_str: LiteStr<512> = dt.to_str_lite_iso8601()?;
    assert_eq!("2000-01-01T12:00:00+00:00", lite_str.as_str());

    // ============================================
    // Formatting (multi-language, no allocation)
    // ============================================

    let s = dt.to_str_in_tz("%A, %d %B %Y %I:%M%P", "America/New_York", Lang::En)?;
    assert_eq!("Saturday, 01 January 2000 07:00am", s);

    let s = dt.to_str_in_tz("%A, %-d de %B de %Y %H:%M", "America/New_York", Lang::Es)?;
    assert_eq!("Sábado, 1 de enero de 2000 07:00", s);

    // ============================================
    // Duration parsing
    // ============================================

    let span: Dt = Dt::from_str_duration("3 days 12 hours", Lang::En)?;
    let dur = span.to_str_lite_media_duration();
    assert_eq!("3:12:00:00", dur.to_string());

    // ============================================
    // Time scale conversions + round-tripping
    // ============================================

    let dt = Dt::from_ymd(2000, 1, 1, Scale::TAI, 0, 0, 0, 123456789);
    let tt = dt.to(Scale::TT);
    let tdb = tt.to(Scale::TDB);
    let ltc = tdb.to(Scale::LTC);
    let utc = ltc.to(Scale::UTC);
    let tcl = utc.to(Scale::TCL);
    let tcg = tcl.to(Scale::TCG);
    let tai = tcg.to_tai();

    // round trips work for pretty much everything except UTCHist
    assert_eq!(dt, tai);
    let ymd: YmdHms = tai.to_ymd();
    assert_eq!(ymd.attos(), 123456789);

    // ============================================
    // Other conversions
    // ============================================

    // unix
    let dt = Dt::from_ymd(1970, 1, 1, Scale::UTC, 0, 0, 0, 0);
    let unix = dt.to_unix().to_sec_f();
    assert_eq!(unix, 0.0);

    // or to milliseconds
    let unix: i128 = dt.add_ms(1000).to_unix().to_ms();
    assert_eq!(unix, 1000);

    // to and from jd
    let jd = Dt::ZERO.to_jd_f();
    assert_eq!(2451545.0, jd);
    let dt = Dt::from_jd_f(jd, Scale::TAI);
    assert_eq!(0, dt.attos);

    // ============================================
    // Calendar math
    // ============================================

    // calendar math and negative year
    let dt = Dt::from_ymd(-2000, 1, 31, Scale::TAI, 12, 0, 0, 0);
    let ymd = dt.add_mo(1).to_ymd();
    assert_eq!(ymd.day(), 29);

    // Timezone-aware calendar math (respects DST transitions, requires jiff-tz feature)
    let dt = Dt::from_str_iso("2025-03-30T00:30:00Z")?; // Just before London DST start

    // Normal (naive) addition — ignores DST rules
    let normal = dt.add_hr(1);

    // Timezone-aware addition — correctly handles the transition
    let aware = dt.add_hr_tz(1, "Europe/London")?;

    println!("Normal: {}", normal.to_str_rfc9557("Europe/London")?);
    println!("Aware:  {}", aware.to_str_rfc9557("Europe/London")?);

    // ============================================
    // Leap seconds
    // ============================================

    // genuine leap second input round trips
    let dt: Dt = "2015-06-30T23:59:60".parse()?;
    let s = dt.to_str_iso8601();
    assert_eq!("2015-06-30T23:59:60+00:00", s);

    Ok(())
}

pub fn from_bytes(bytes: &[u8]) -> Self

Creates a LiteStr<N> from a byte slice.

Copies up to N bytes from the input and zero-fills the remainder. If bytes.len() > N, the input is silently truncated.

No UTF-8 validation is performed.

pub fn as_bytes(&self) -> &[u8]

Returns the content as a byte slice (up to the first nul byte).

Trait Implementations

impl<const N: usize> Clone for LiteStr<N>

fn clone(&self) -> LiteStr<N>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<const N: usize> Copy for LiteStr<N>

impl<const N: usize> Debug for LiteStr<N>

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

Formats the value using the given formatter.

impl<const N: usize> Default for LiteStr<N>

fn default() -> Self

Returns the “default value” for a type.

impl<'de, const N: usize> Deserialize<'de> for LiteStr<N>

Available on crate feature serde only.

fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<const N: usize> Display for LiteStr<N>

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

Formats the value using the given formatter.

impl<const N: usize> Eq for LiteStr<N>

impl<const N: usize> PartialEq for LiteStr<N>

fn eq(&self, other: &LiteStr<N>) -> bool

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<const N: usize> Serialize for LiteStr<N>

Available on crate feature serde only.

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>

where S: Serializer,

Serialize this value into the given Serde serializer.

impl<const N: usize> StructuralPartialEq for LiteStr<N>

impl<const N: usize> Write for LiteStr<N>

fn write_str(&mut self, s: &str) -> Result

Writes a string slice into this writer, returning whether the write succeeded.

fn write_char(&mut self, c: char) -> Result<(), Error>

Writes a char into this writer, returning whether the write succeeded.

fn write_fmt(&mut self, args: Arguments<'_>) -> Result<(), Error>

Glue for usage of the write! macro with implementors of this trait.