Struct ArcCStr 

pub struct ArcCStr { /* private fields */ }

A thread-safe reference-counted null-terminated string.

The type ArcCStr provides shared ownership of a C-style null-terminated string allocated in the heap. Invoking clone on ArcCStr produces a new pointer to the same value in the heap. When the last ArcCStr pointer to a given string is destroyed, the pointed-to string is also destroyed. Behind the scenes, ArcCStr works much like Arc.

Strings pointed to using ArcCStr are meant to be immutable, and there therefore no mechanism is provided to get a mutable reference to the underlying string, even if there are no other pointers to the string in question.

ArcCStr uses atomic operations for reference counting, so ArcCStrs can be sent freely between threads. In other words, ArcCStr implements cheap Send for strings using the fact that CStr is Sync. ArcCStr tries to minimize the space overhead of this feature by sharing the string data. The disadvantage of this approach is that it requires atomic operations that are more expensive than ordinary memory accesses. Thus, if you have many threads accessing the same data, you may see contention. However, in the common case, using ArcCStr should still be faster than cloning the full string.

ArcCStr automatically dereferences to CStr (via the Deref trait), so you can call CStr’s methods on a value of type ArcCStr. To avoid name clashes with CStr’s methods, the methods of ArcCStr itself are associated functions, called using function-like syntax:

use arccstr::ArcCStr;
use std::convert::TryFrom;
let mut my_arc = ArcCStr::try_from("foobar").unwrap();
ArcCStr::strong_count(&my_arc);

Examples

Sharing some immutable strings between threads:

use std::convert::TryFrom;
use arccstr::ArcCStr;
use std::thread;

let five = ArcCStr::try_from("5").unwrap();

for _ in 0..10 {
    let five = ArcCStr::clone(&five);

    thread::spawn(move || {
        println!("{:?}", five);
    });
}

Implementations

impl ArcCStr

pub fn strong_count(this: &Self) -> usize

Gets the number of pointers to this string.

Safety

This method by itself is safe, but using it correctly requires extra care. Another thread can change the strong count at any time, including potentially between calling this method and acting on the result.

Examples

use std::convert::TryFrom;
use arccstr::ArcCStr;

let five = ArcCStr::try_from("5").unwrap();
let _also_five = ArcCStr::clone(&five);

// This assertion is deterministic because we haven't shared
// the `ArcCStr` between threads.
assert_eq!(2, ArcCStr::strong_count(&five));

pub fn ptr_eq(this: &Self, other: &Self) -> bool

Returns true if the two ArcCStrs point to the same value (not just values that compare as equal).

Examples

use std::convert::TryFrom;
use arccstr::ArcCStr;

let five = ArcCStr::try_from("5").unwrap();
let same_five = ArcCStr::clone(&five);
let other_five = ArcCStr::try_from("5").unwrap();

assert!(ArcCStr::ptr_eq(&five, &same_five));
assert!(!ArcCStr::ptr_eq(&five, &other_five));

Methods from Deref<Target = CStr>

pub fn as_ptr(&self) -> *const i8

Returns the inner pointer to this C string.

The returned pointer will be valid for as long as self is, and points to a contiguous region of memory terminated with a 0 byte to represent the end of the string.

The type of the returned pointer is *const c_char, and whether it’s an alias for *const i8 or *const u8 is platform-specific.

WARNING

The returned pointer is read-only; writing to it (including passing it to C code that writes to it) causes undefined behavior.

It is your responsibility to make sure that the underlying memory is not freed too early. For example, the following code will cause undefined behavior when ptr is used inside the unsafe block:

use std::ffi::{CStr, CString};

// 💀 The meaning of this entire program is undefined,
// 💀 and nothing about its behavior is guaranteed,
// 💀 not even that its behavior resembles the code as written,
// 💀 just because it contains a single instance of undefined behavior!

// 🚨 creates a dangling pointer to a temporary `CString`
// 🚨 that is deallocated at the end of the statement
let ptr = CString::new("Hi!".to_uppercase()).unwrap().as_ptr();

// without undefined behavior, you would expect that `ptr` equals:
dbg!(CStr::from_bytes_with_nul(b"HI!\0").unwrap());

// 🙏 Possibly the program behaved as expected so far,
// 🙏 and this just shows `ptr` is now garbage..., but
// 💀 this violates `CStr::from_ptr`'s safety contract
// 💀 leading to a dereference of a dangling pointer,
// 💀 which is immediate undefined behavior.
// 💀 *BOOM*, you're dead, your entire program has no meaning.
dbg!(unsafe { CStr::from_ptr(ptr) });

This happens because, the pointer returned by as_ptr does not carry any lifetime information, and the CString is deallocated immediately after the expression that it is part of has been evaluated. To fix the problem, bind the CString to a local variable:

use std::ffi::{CStr, CString};

let c_str = CString::new("Hi!".to_uppercase()).unwrap();
let ptr = c_str.as_ptr();

assert_eq!(unsafe { CStr::from_ptr(ptr) }, c"HI!");

pub fn count_bytes(&self) -> usize

Returns the length of self. Like C’s strlen, this does not include the nul terminator.

Note: This method is currently implemented as a constant-time cast, but it is planned to alter its definition in the future to perform the length calculation whenever this method is called.

Examples

assert_eq!(c"foo".count_bytes(), 3);
assert_eq!(c"".count_bytes(), 0);

pub fn is_empty(&self) -> bool

Returns true if self.to_bytes() has a length of 0.

Examples

assert!(!c"foo".is_empty());
assert!(c"".is_empty());

pub fn to_bytes(&self) -> &[u8]

Converts this C string to a byte slice.

The returned slice will not contain the trailing nul terminator that this C string has.

Note: This method is currently implemented as a constant-time cast, but it is planned to alter its definition in the future to perform the length calculation whenever this method is called.

Examples

assert_eq!(c"foo".to_bytes(), b"foo");

pub fn to_bytes_with_nul(&self) -> &[u8]

Converts this C string to a byte slice containing the trailing 0 byte.

This function is the equivalent of CStr::to_bytes except that it will retain the trailing nul terminator instead of chopping it off.

Note: This method is currently implemented as a 0-cost cast, but it is planned to alter its definition in the future to perform the length calculation whenever this method is called.

Examples

assert_eq!(c"foo".to_bytes_with_nul(), b"foo\0");

pub fn bytes(&self) -> Bytes<'_>

🔬This is a nightly-only experimental API. (cstr_bytes)

Iterates over the bytes in this C string.

The returned iterator will not contain the trailing nul terminator that this C string has.

Examples

#![feature(cstr_bytes)]

assert!(c"foo".bytes().eq(*b"foo"));

pub fn to_str(&self) -> Result<&str, Utf8Error>

Yields a &str slice if the CStr contains valid UTF-8.

If the contents of the CStr are valid UTF-8 data, this function will return the corresponding &str slice. Otherwise, it will return an error with details of where UTF-8 validation failed.

Examples

assert_eq!(c"foo".to_str(), Ok("foo"));

pub fn display(&self) -> impl Display

🔬This is a nightly-only experimental API. (cstr_display)

Returns an object that implements Display for safely printing a CStr that may contain non-Unicode data.

Behaves as if self were first lossily converted to a str, with invalid UTF-8 presented as the Unicode replacement character: �.

Examples

#![feature(cstr_display)]

let cstr = c"Hello, world!";
println!("{}", cstr.display());

pub fn as_c_str(&self) -> &CStr

🔬This is a nightly-only experimental API. (str_as_str)

Returns the same string as a string slice &CStr.

This method is redundant when used directly on &CStr, but it helps dereferencing other string-like types to string slices, for example references to Box<CStr> or Arc<CStr>.

pub fn to_string_lossy(&self) -> Cow<'_, str>

Converts a CStr into a Cow<str>.

If the contents of the CStr are valid UTF-8 data, this function will return a Cow::Borrowed(&str) with the corresponding &str slice. Otherwise, it will replace any invalid UTF-8 sequences with U+FFFD REPLACEMENT CHARACTER and return a Cow::Owned(String) with the result.

Examples

Calling to_string_lossy on a CStr containing valid UTF-8. The leading c on the string literal denotes a CStr.

use std::borrow::Cow;

assert_eq!(c"Hello World".to_string_lossy(), Cow::Borrowed("Hello World"));

Calling to_string_lossy on a CStr containing invalid UTF-8:

use std::borrow::Cow;

assert_eq!(
    c"Hello \xF0\x90\x80World".to_string_lossy(),
    Cow::Owned(String::from("Hello �World")) as Cow<'_, str>
);

Trait Implementations

impl AsRef<CStr> for ArcCStr

fn as_ref(&self) -> &CStr

Converts this type into a shared reference of the (usually inferred) input type.

impl Borrow<CStr> for ArcCStr

fn borrow(&self) -> &CStr

Immutably borrows from an owned value.

impl Clone for ArcCStr

fn clone(&self) -> ArcCStr

Makes a clone of the ArcCStr pointer.

This creates another pointer to the same underlying string, increasing the reference count.

Examples

use std::convert::TryFrom;
use arccstr::ArcCStr;

let five = ArcCStr::try_from("5").unwrap();

ArcCStr::clone(&five);

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

Performs copy-assignment from source.

impl Debug for ArcCStr

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

Formats the value using the given formatter.

impl Deref for ArcCStr

type Target = CStr

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl<'de> Deserialize<'de> for ArcCStr

Available on crate feature serde only.

fn deserialize<D>(deserializer: D) -> Result<ArcCStr, D::Error>

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Drop for ArcCStr

fn drop(&mut self)

Drops the ArcCStr.

This will decrement the reference count. If the reference count reaches zero then we also deallocate the underlying string.

Examples

use std::convert::TryFrom;
use arccstr::ArcCStr;

let foo  = ArcCStr::try_from("foo").unwrap();
let foo2 = ArcCStr::clone(&foo);

drop(foo);    // "foo" is still in memory
drop(foo2);   // "foo" is deallocated

impl<'a> From<&'a CStr> for ArcCStr

fn from(s: &'a CStr) -> Self

Converts to this type from the input type.

impl From<CString> for ArcCStr

fn from(s: CString) -> Self

Converts to this type from the input type.

impl Hash for ArcCStr

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, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl Ord for ArcCStr

fn cmp(&self, other: &ArcCStr) -> Ordering

Comparison for two ArcCStrs.

The two are compared by calling cmp() on their underlying strings.

Examples

use arccstr::ArcCStr;
use std::cmp::Ordering;
use std::convert::TryFrom;

let five = ArcCStr::try_from("5").unwrap();

assert_eq!(Ordering::Less, five.cmp(&ArcCStr::try_from("6").unwrap()));

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl PartialEq for ArcCStr

fn eq(&self, other: &ArcCStr) -> bool

Equality for two ArcCStrs.

Two ArcCStrs are equal if their underlying strings are equal.

Examples

use std::convert::TryFrom;
use arccstr::ArcCStr;

let five = ArcCStr::try_from("5");

assert_eq!(five, ArcCStr::try_from("5"));
assert_ne!(five, ArcCStr::try_from("6"));

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialOrd for ArcCStr

fn partial_cmp(&self, other: &ArcCStr) -> Option<Ordering>

Partial comparison for two ArcCStrs.

The two are compared by calling partial_cmp() on their underlying strings.

Examples

use arccstr::ArcCStr;
use std::cmp::Ordering;
use std::convert::TryFrom;

let five = ArcCStr::try_from("5").unwrap();

assert_eq!(Some(Ordering::Less), five.partial_cmp(&ArcCStr::try_from("6").unwrap()));

fn lt(&self, other: &ArcCStr) -> bool

Less-than comparison for two ArcCStrs.

The two are compared by calling < on their inner values.

Examples

use std::convert::TryFrom;
use arccstr::ArcCStr;

let five = ArcCStr::try_from("5").unwrap();

assert!(five < ArcCStr::try_from("6").unwrap());

fn le(&self, other: &ArcCStr) -> bool

‘Less than or equal to’ comparison for two ArcCStrs.

The two are compared by calling <= on their underlying strings.

Examples

use std::convert::TryFrom;
use arccstr::ArcCStr;

let five = ArcCStr::try_from("5").unwrap();

assert!(five <= ArcCStr::try_from("5").unwrap());

fn gt(&self, other: &ArcCStr) -> bool

Greater-than comparison for two ArcCStrs.

The two are compared by calling > on their underlying strings.

Examples

use std::convert::TryFrom;
use arccstr::ArcCStr;

let five = ArcCStr::try_from("5").unwrap();

assert!(five > ArcCStr::try_from("4").unwrap());

fn ge(&self, other: &ArcCStr) -> bool

‘Greater than or equal to’ comparison for two ArcCStrs.

The two are compared by calling >= on their underlying strings.

Examples

use std::convert::TryFrom;
use arccstr::ArcCStr;

let five = ArcCStr::try_from("5").unwrap();

assert!(five >= ArcCStr::try_from("5").unwrap());

impl Pointer for ArcCStr

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

Formats the value using the given formatter.

impl Serialize for ArcCStr

Available on crate feature serde only.

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>

where S: Serializer,

Serialize this value into the given Serde serializer.

impl<'a> TryFrom<&'a [u8]> for ArcCStr

type Error = FromBytesWithNulError

The type returned in the event of a conversion error.

fn try_from(b: &'a [u8]) -> Result<Self, Self::Error>

Performs the conversion.

impl<'a> TryFrom<&'a str> for ArcCStr

type Error = FromBytesWithNulError

The type returned in the event of a conversion error.

fn try_from(s: &'a str) -> Result<Self, Self::Error>

Performs the conversion.

impl TryFrom<String> for ArcCStr

type Error = FromBytesWithNulError

The type returned in the event of a conversion error.

fn try_from(s: String) -> Result<Self, Self::Error>

Performs the conversion.

impl Eq for ArcCStr

impl Send for ArcCStr

impl Sync for ArcCStr