Struct arccstr::ArcCStr [−] [src]

pub struct ArcCStr { /* fields omitted */ }

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

#![feature(try_from)]
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:

#![feature(try_from)]
use std::convert::TryFrom;
use arccstr::ArcCStr;
use std::thread;

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

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

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

Methods

`impl ArcCStr`
[src]

`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

#![feature(try_from)]
use std::convert::TryFrom;
use arccstr::ArcCStr;

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

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

`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

#![feature(try_from)]
use std::convert::TryFrom;
use arccstr::ArcCStr;

let five = ArcCStr::try_from("5").unwrap();
let same_five = five.clone();
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>

`fn as_ptr(&self) -> *const i8`
1.0.0

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.

WARNING

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

use std::ffi::{CString};

let ptr = CString::new("Hello").unwrap().as_ptr();
unsafe {
    // `ptr` is dangling
    *ptr;
}

This happens because the pointer returned by as_ptr does not carry any lifetime information and the string is deallocated immediately after the CString::new("Hello").unwrap().as_ptr() expression is evaluated. To fix the problem, bind the string to a local variable:

use std::ffi::{CString};

let hello = CString::new("Hello").unwrap();
let ptr = hello.as_ptr();
unsafe {
    // `ptr` is valid because `hello` is in scope
    *ptr;
}

`fn to_bytes(&self) -> &[u8]`
1.0.0

Converts this C string to a byte slice.

This function will calculate the length of this string (which normally requires a linear amount of work to be done) and then return the resulting slice of u8 elements.

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

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.

`fn to_bytes_with_nul(&self) -> &[u8]`
1.0.0

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

This function is the equivalent of to_bytes except that it will retain the trailing nul 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.

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

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

This function will calculate the length of this string and check for UTF-8 validity, and then return the &str if it's valid.

Note: This method is currently implemented to check for validity after a 0-cost cast, but it is planned to alter its definition in the future to perform the length calculation in addition to the UTF-8 check whenever this method is called.

`fn to_string_lossy(&self) -> Cow<str>`
1.4.0

Converts a CStr into a Cow<str>.

This function will calculate the length of this string (which normally requires a linear amount of work to be done) and then return the resulting slice as a Cow<str>, replacing any invalid UTF-8 sequences with U+FFFD REPLACEMENT CHARACTER.

Note: This method is currently implemented to check for validity after a 0-cost cast, but it is planned to alter its definition in the future to perform the length calculation in addition to the UTF-8 check whenever this method is called.

`fn into_c_string(self: Box<CStr>) -> CString`

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

Converts a Box<CStr> into a CString without copying or allocating.

Trait Implementations