Crate str_array 

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

StrArray serves as the str equivalent of [u8; N]. It provides a Deref to &str and ensures the UTF-8 invariant is always upheld, but has a size known at compile time.

This is useful in some situations:

• Resource-constrained no_std and no-alloc environments.
• Defining UTF-8 strings directly in a stack array or static.
• Types or parameters that require &str of some fixed length.

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 CStr safely on the stack.

Features

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

Examples

use str_array::{str_array, StrArray};

// Create from a constant using the macro. The length is inferred.
let s1 = str_array!("hello");
assert_eq!(s1.len(), 5);
assert_eq!(s1, "hello");
assert!(matches!(s1.into_bytes(), [b'h', b'e', b'l', b'l', b'o']));

// Or create from a runtime &str with an length check.
let s2: StrArray<12> = StrArray::new(&format!("{s1}, world")).unwrap();
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 = "Georgia";
}
assert_eq!(S4.len(), 7);

Modules

error

Error types for array-backed strings.

Macros

cstr_array

Builds CStrArray from constant strings of various types.

str_array

Builds StrArray from constant &str.

Structs

CStrArray

Fixed-size CStr, backed by an array.

StrArray

Fixed-size str, backed by an array.