Struct fixedstr::fstr

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

main type: string of size up to const N:

Implementations

impl<const N: usize> fstr<N>

pub fn make(s: &str) -> fstr<N>

creates a new fstr with given &str. If the length of s exceeds N, the extra characters are ignored. This function is also called by several others including fstr::from.

pub fn new() -> fstr<N>

creates an empty string, equivalent to fstr::default()

pub fn len(&self) -> usize

length of the string in bytes, which will be up to the maximum size N. This is a constant-time operation. Note that this value is consistent with str::len

pub fn capacity(&self) -> usize

returns maximum capacity in bytes

pub fn to_string(&self) -> String

converts fstr to an owned string

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

allows returns copy of u8 array underneath the fstr

pub fn to_str(&self) -> &str

converts fstr to &str using std::str::from_utf8

pub fn as_str(&self) -> &str

alias for fstr::to_str

pub fn set(&mut self, i: usize, c: char) -> bool

changes a character at character position i to c. This function requires that c is in the same character class (ascii or unicode) as the char being replaced. It never shuffles the bytes underneath. The function returns true if the change was successful.

pub fn push<'t>(&mut self, s: &'t str) -> &'t str

adds chars to end of current string up to maximum size N of fstr, returns the portion of the push string that was NOT pushed due to capacity, so if “” is returned then all characters were pushed successfully.

pub fn charlen(&self) -> usize

returns the number of characters in the string regardless of character class

pub fn nth(&self, n: usize) -> Option<char>

returns the nth char of the fstr

pub fn nth_ascii(&self, n: usize) -> char

returns the nth byte of the string as a char. This function should only be called on ascii strings. It is designed to be quicker than fstr::nth, and does not check array bounds or check n against the length of the string. Nor does it check if the value returned is within the ascii range.

pub fn is_ascii(&self) -> bool

determines if string is an ascii string

pub fn truncate(&mut self, n: usize)

shortens the fstr in-place (mutates). If n is greater than the current length of the string in chars, this operation will have no effect.

impl<const M: usize> fstr<M>

pub fn resize<const N: usize>(&self) -> fstr<N>

converts an fstr<M> to an fstr<N>. If the length of the string being converted is greater than N, the extra characters will be ignored. This operation produces a copy (non-destructive). Example:

  let s1:fstr<8> = fstr::from("abcdefg");
  let s2:fstr<16> = s1.resize(); 

impl<const N: usize> fstr<N>

pub fn chars(&self) -> Chars<'_>

mimics same function on str

pub fn char_indices(&self) -> CharIndices<'_>

mimics same function on str

pub fn substr(&self, start: usize, end: usize) -> fstr<N>

returns a copy of the portion of the string, string could be truncated if indices are out of range. Similar to slice [start..end]

Trait Implementations

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

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

Returns a copy of the value.

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

Performs copy-assignment from source.

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

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

Formats the value using the given formatter.

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

defaults to empty string

fn default() -> Self

Returns the “default value” for a type.

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

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

Formats the value using the given formatter.

impl<const N: usize> From<&'_ String> for fstr<N>

fn from(s: &String) -> fstr<N>

Converts to this type from the input type.

impl<const N: usize, const M: usize> From<&'_ fstr<M>> for zstr<N>

fn from(s: &fstr<M>) -> zstr<N>

Converts to this type from the input type.

impl<const N: usize> From<&'_ mut String> for fstr<N>

fn from(s: &mut String) -> fstr<N>

Converts to this type from the input type.

impl<const N: usize> From<&'_ mut str> for fstr<N>

fn from(s: &mut str) -> fstr<N>

creates a new fstr with given &str. If the length of s exceeds N, the extra characters are ignored.

impl<const N: usize> From<&'_ str> for fstr<N>

fn from(s: &str) -> fstr<N>

creates a new fstr with given &str. If the length of s exceeds N, the extra characters are ignored.

impl<const N: usize, const M: usize> From<&'_ zstr<M>> for fstr<N>

fn from(s: &zstr<M>) -> fstr<N>

Converts to this type from the input type.

impl<const N: usize> From<String> for fstr<N>

fn from(s: String) -> fstr<N>

Converts to this type from the input type.

impl<const N: usize, const M: usize> From<fstr<M>> for zstr<N>

fn from(s: fstr<M>) -> zstr<N>

Converts to this type from the input type.

impl<const N: usize, const M: usize> From<zstr<M>> for fstr<N>

fn from(s: zstr<M>) -> fstr<N>

Converts to this type from the input type.

impl<const N: usize> Hash for fstr<N>

fn hash<__H: Hasher>(&self, state: &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<IndexType, const N: usize> Index<IndexType> for fstr<N> where
    IndexType: SliceIndex<[u8]>, 

Convert fstr to &u8 slice

type Output = IndexType::Output

The returned type after indexing.

fn index(&self, index: IndexType) -> &Self::Output

Performs the indexing (container[index]) operation.

impl<const N: usize> Ord for fstr<N>

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 N: usize, const M: usize> PartialEq<&'_ fstr<N>> for zstr<M>

fn eq(&self, other: &&fstr<N>) -> 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<'t, const N: usize> PartialEq<&'_ fstr<N>> for &'t str

fn eq(&self, other: &&fstr<N>) -> 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 N: usize> PartialEq<&'_ str> for fstr<N>

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 N: usize> PartialEq<&'_ str> for &fstr<N>

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 N: usize, const M: usize> PartialEq<&'_ zstr<N>> for fstr<M>

fn eq(&self, other: &&zstr<N>) -> 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 N: usize, const M: usize> PartialEq<fstr<N>> for zstr<M>

fn eq(&self, other: &fstr<N>) -> 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 N: usize> PartialEq<fstr<N>> for fstr<N>

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

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

fn ne(&self, other: &fstr<N>) -> bool

This method tests for !=.

impl<'t, const N: usize> PartialEq<fstr<N>> for &'t str

fn eq(&self, other: &fstr<N>) -> 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 N: usize, const M: usize> PartialEq<zstr<N>> for fstr<M>

fn eq(&self, other: &zstr<N>) -> 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 N: usize> PartialOrd<fstr<N>> for fstr<N>

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 N: usize> Copy for fstr<N>

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

impl<const N: usize> StructuralEq for fstr<N>

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