Library for strings of fixed maximum lengths that can be copied and stack-allocated. Certain provided types such as zstr<8> and str8 are smaller in size than a &str on typical systems.

Starting in Version 0.4.0, this crate supports #![no_std], although this feature is not enabled by default. Giving cargo the --no-default-features option will enable no_std and provide only the zstr and tstr types with some reduced functionality.

Recent improvements also include a Flexstr type that uses an internal enum that can be either a fixed-capacity string or an owned String.

Examples

``` let a:str8 = str8::from("abcdef"); //a str8 can hold up to 7 bytes let a2 = a; // copied, not moved let ab = a.substr(1,5); // copies substring to new string asserteq!(ab, "bcde"); // can compare for equality with &str asserteq!(ab.len(),4); println!("str8: {}", &a); // impls Display asserteq!(&a[..3], "abc"); // impls Index for Range types assert!(a = fstr::from(a); // fstr is another fixedstr crate type let azstr:zstr<16> = zstr::from(a); // so is zstr let a32:str32 = a.resize(); // same kind of string but with 31-byte capacity
let mut u = str8::from("aλb"); //unicode support asserteq!(u.nth(1), Some('λ')); // get nth character asserteq!(u.nthascii(3), 'b'); // get nth byte as ascii character assert!(u.set(1,'μ')); // changes a character of the same character class assert!(!u.set(1,'c')); // .set returns false on failure assert!(u.set(2,'c')); asserteq!(u, "aμc"); asserteq!(u.len(),4); // length in bytes asserteq!(u.charlen(),3); // length in chars let mut ac:str16 = a.reallocate().unwrap(); //copies to larger capacity type let remainder = ac.push("ghijklmnopq"); //append up to capacity, returns remainder asserteq!(ac.len(),15); asserteq!(remainder, "pq"); ac.truncate(9); // keep first 9 chars asserteq!(&ac,"abcdefghi"); let (upper,lower) = (str8::make("ABC"), str8::make("abc")); asserteq!(upper, lower.toascii_upper()); // no owned String needed

let c1 = str8::from("abcd"); // string concatenation with + for strN types
let c2 = str8::from("xyz"); let c3 = c1 + c2;
asserteq!(c3,"abcdxyz"); asserteq!(c3.capacity(),15); // type of c3 is str16

let c4 = strformat!(str16,"abc {}{}{}",1,2,3); // impls std::fmt::Write asserteq!(c4,"abc 123"); //strformat! truncates if capacity exceeded let c5 = tryformat!(str8,"abcdef{}","ghijklmn"); assert!(c5.isnone()); // tryformat! returns None if capacity exceeded ```

Consult the documentation for details.