Struct str_buf::StrBuf

pub struct StrBuf<const N: usize> { /* fields omitted */ }

Stack based string.

It’s size is mem::size_of::<T>() + mem::size_of::<u8>(), but remember that it can be padded. Can store up to u8::max_value() as anything bigger makes a little sense.

Storage is always capped at u8::max_value(), once panic are allowed inside const fn, creating buffer with invalid storage will panic.

When attempting to create new instance from &str it panics on overflow in debug mode.

use str_buf::StrBuf;
use core::mem;
use core::fmt::Write;
use core::convert::TryInto;

type MyStr = StrBuf::<{mem::size_of::<String>()}>;

const CONST_STR: MyStr = MyStr::new().and("hello").and(" ").and("world");

assert_eq!(CONST_STR, "hello world");

assert_eq!(MyStr::capacity(), mem::size_of::<String>());
assert_ne!(mem::size_of::<MyStr>(), mem::size_of::<String>());
assert_eq!(mem::size_of::<StrBuf::<{mem::size_of::<String>() - 1}>>(), mem::size_of::<String>());

let text: MyStr = "test".try_into().expect("To fit string");
assert_eq!("test", text);
assert_eq!(text, "test");
let mut text = MyStr::new();
let _ = write!(text, "test {}", "hello world");
assert_eq!(text.as_str(), "test hello world");
assert_eq!(text.remaining(), MyStr::capacity() - "test hello world".len());

assert_eq!(text.push_str(" or maybe not"), 8); //Overflow!
assert_eq!(text.as_str(), "test hello world or mayb");
assert_eq!(text.push_str(" or maybe not"), 0); //Overflow, damn

text.clear();
assert_eq!(text.push_str(" or maybe not"), 13); //noice
assert_eq!(text.as_str(), " or maybe not");

assert_eq!(text.clone().as_str(), text.as_str());
assert_eq!(text.clone(), text);

Implementations

impl<const N: usize> StrBuf<N>

pub const fn new() -> Self

Creates new instance

pub const unsafe fn from_storage(
    storage: [MaybeUninit<u8>; N],
    cursor: u8
) -> Self

Creates new instance from supplied storage and written size.

It is unsafe, because there is no guarantee that storage is correctly initialized with UTF-8 bytes.

pub const fn from_str(text: &str) -> Self

Creates new instance from existing slice with panic on overflow

pub const fn from_str_checked(text: &str) -> Result<Self, StrBufError>

Creates new instance from existing slice which returns error on overflow

pub const fn as_ptr(&self) -> *const u8

Returns pointer to the beginning of underlying buffer

pub const fn remaining(&self) -> usize

Returns number of bytes left (not written yet)

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

Returns slice to already written data.

pub fn as_mut_slice(&mut self) -> &mut [u8]

Returns mutable slice to already written data.

pub fn as_write_slice(&mut self) -> &mut [MaybeUninit<u8>]

Returns mutable slice with unwritten parts of the buffer.

pub fn clear(&mut self)

Clears the content of buffer.

pub const fn empty(self) -> Self

Returns empty self.

pub unsafe fn truncate(&mut self, cursor: u8)

Shortens the buffer, keeping the first cursor elements.

Does nothing if new cursor is after current position.

Unsafe as it is up to user to consider character boundary

pub const fn capacity() -> usize

Returns buffer overall capacity.

pub const fn len(&self) -> usize

Returns number of bytes written.

pub unsafe fn set_len(&mut self, len: u8)

Sets new length of the string.

pub unsafe fn push_str_unchecked(&mut self, text: &str)

Appends given string without any size checks

pub fn push_str(&mut self, text: &str) -> usize

Appends given string, truncating on overflow, returning number of written bytes

pub const fn and(self, text: &str) -> Self

Appends given string, assuming it fits.

On overflow panics with index out of bounds.

pub const unsafe fn and_unsafe(self, bytes: &[u8]) -> Self

Unsafely appends given bytes, assuming valid utf-8.

On overflow panics with index out of bounds as and.

pub fn as_str(&self) -> &str

Access str from underlying storage

Returns empty if nothing has been written into buffer yet.

Trait Implementations

impl<const S: usize> AsMut<[u8]> for StrBuf<S>

fn as_mut(&mut self) -> &mut [u8]

Performs the conversion.

impl<const S: usize> AsRef<[u8]> for StrBuf<S>

fn as_ref(&self) -> &[u8]

Performs the conversion.

impl<const S: usize> AsRef<str> for StrBuf<S>

fn as_ref(&self) -> &str

Performs the conversion.

impl<const S: usize> Borrow<str> for StrBuf<S>

fn borrow(&self) -> &str

Immutably borrows from an owned value.

impl<const S: usize> Clone for StrBuf<S>

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<const S: usize> Debug for StrBuf<S>

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

Formats the value using the given formatter.

impl<const S: usize> Deref for StrBuf<S>

type Target = str

The resulting type after dereferencing.

fn deref(&self) -> &str

Dereferences the value.

impl<const S: usize> Display for StrBuf<S>

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

Formats the value using the given formatter.

impl<const S: usize> Hash for StrBuf<S>

fn hash<H: Hasher>(&self, hasher: &mut H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H) where
    H: Hasher, 

Feeds a slice of this type into the given Hasher.

impl<const S: usize> Ord for StrBuf<S>

fn cmp(&self, other: &Self) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

Restrict a value to a certain interval.

impl<const S: usize> PartialEq<&'_ str> for StrBuf<S>

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

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

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

This method tests for !=.

impl<const S: usize> PartialEq<StrBuf<S>> for StrBuf<S>

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

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

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

This method tests for !=.

impl<const S: usize> PartialEq<StrBuf<S>> for &str

fn eq(&self, other: &StrBuf<S>) -> bool

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

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

This method tests for !=.

impl<const S: usize> PartialEq<StrBuf<S>> for str

fn eq(&self, other: &StrBuf<S>) -> bool

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

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

This method tests for !=.

impl<const S: usize> PartialEq<str> for StrBuf<S>

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

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

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

This method tests for !=.

impl<const S: usize> PartialOrd<StrBuf<S>> for StrBuf<S>

fn partial_cmp(&self, other: &Self) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

This method tests less than (for self and other) and is used by the < operator.

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

This method tests less than or equal to (for self and other) and is used by the <= operator.

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

This method tests greater than (for self and other) and is used by the > operator.

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

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl<const S: usize> TryFrom<&'_ str> for StrBuf<S>

type Error = StrBufError

The type returned in the event of a conversion error.

fn try_from(text: &str) -> Result<Self, Self::Error>

Performs the conversion.

impl<const S: usize> Write for StrBuf<S>

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 S: usize> Eq for StrBuf<S>