arccstr

Thread-safe reference-counted null-terminated strings.

This crate provides a space efficient mechanism for storing immutable strings. The best illustration of this is to go over the alternatives:

// &str:
//  - content must be known at compile time
//  + can be shared between threads
//  + space overhead is 2*usize (fat pointer to the string)
let s = "foobar";
// String
//  + can be created at runtime
//  - cannot be shared between threads (except with Clone)
//  - space overhead of 3*usize (Vec capacity and len + pointer to bytes)
//  - accessing string requires two pointer derefs
let s = format!("foobar");
// CString:
//  * mostly same as String
//  * space overhead is 2*usize (uses Box<[u8]> internally)
use std::ffi::CString;
let s = CString::new("foobar").unwrap();
// CStr:
//  + space overhead is just the pointer (1*usize)
//  - hard to construct
//  - generally cannot be shared between threds (lifetime usually not 'static)
use std::ffi::CStr;
let s: &CStr = &*s;
// Arc<String>:
//  + can be created at runtime
//  + can be shared between threads
//  - space overhead is 7*usize:
//     - pointer to Arc
//     - weak count
//     - strong count
//     - pointer to String
//     - String overhead (3*usize)
use std::sync::Arc;
let s = ArcCStr::from(format!("foobar"));
// ArcCStr:
//  + can be created at runtime
//  + can be shared between threads
//  - space overhead is 2*usize (pointer + strong count)
use arccstr::ArcCStr;
let s = ArcCStr::from("foobar");

See the ArcCStr documentation for more details.

Note that this crate requires a nightly build of the compiler as it plays a lot of memory tricks.