Crate str_array 

Provides fixed-size string types StrArray<N> and CStrArray<N>.

StrArray serves as the str equivalent of [u8; N], offering a Deref to &str and ensuring the UTF-8 invariant is always upheld, but with a size known at compile time. This is designed for no_std environments or where strings are always a certain size.

The str_array! macro provides a compile-time-checked way to build StrArray values from string literals and constants.

Similarly, CStrArray and cstr_array! can construct a nul-terminated C string safely on the stack.

Features

• no_std support - disable default features to use
• Optional alloc and std features
• const support
• C string support
• Full test coverage

Examples

use str_array::{str_array, StrArray};

// Create from a literal using the macro. The length is inferred.
let s1 = str_array!("hello");
assert_eq!(s1.len(), 5);
assert_eq!(s1, "hello");

// Or create from a &str with an panicking length check.
let s2: StrArray<12> = StrArray::new(&format!("{s1}, world"));
assert_eq!(core::mem::size_of_val(&s2), 12);
assert_eq!(s2, "hello, world");

// Or create from bytes with a UTF-8 check.
let s3 = StrArray::from_utf8(
    b"\xF0\x9F\xA4\x8C\xF0\x9F\x8F\xBC"
).unwrap();
assert_eq!(s3, "🤌🏼");

// Or define an item with an inferred length.
str_array! {
    static S4: StrArray<_> = "Georgia";
}
assert_eq!(S4.len(), 7);

Modules

error

Macros

cstr_array

Builds CStrArray from constant &CStr.

str_array

Builds StrArray from constant &str.

Structs

CStrArray

Fixed-size CStr stored as an array.

StrArray

Fixed-size str stored as a [u8; N].