Struct LiteStr 

pub struct LiteStr<const N: usize> { /* private fields */ }

Fixed-capacity, stack-only UTF-8 string stored in a single [u8; N] array.

• The string is stored as raw bytes with C-style nul termination.
• Its logical length is determined at runtime by the position of the first nul byte (b'\0').
• All bytes after the string content are guaranteed to be zero.
• The type guarantees that the prefix up to the first nul is always valid UTF-8 (when constructed through the safe API).
• This type is intentionally kept very lightweight. When you use different sizes (such as LiteStr<16>, LiteStr<32>, LiteStr<64>), Rust creates a full separate copy of the type and all of its methods for each size. This is why it is important to keep the implementation of LiteStr as minimal as possible.

Implementations

impl<const N: usize> LiteStr<N>

pub const SIZE: usize = N

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

Recommended ergonomic constructor – truncates at a UTF-8 boundary if necessary.

pub fn as_str(&self) -> Result<&str, LiteStrErr>

Returns the stored string as &str.

pub fn from_bytes(bytes: &[u8]) -> Result<Self, LiteStrErr>

pub fn to_bytes(&self) -> [u8; N]

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

Returns the stored string as &[u8].

pub fn len(&self) -> usize

Returns the current len of the utf-8.

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> 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> 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> 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.

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

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

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