pub struct ArcCStr { /* private fields */ }
Expand description
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 ArcCStr
s 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:
#![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 = ArcCStr::clone(&five);
thread::spawn(move || {
println!("{:?}", five);
});
}
Implementations
sourceimpl ArcCStr
impl ArcCStr
sourcepub fn strong_count(this: &Self) -> usize
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
#![feature(try_from)]
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));
sourcepub fn ptr_eq(this: &Self, other: &Self) -> bool
pub fn ptr_eq(this: &Self, other: &Self) -> bool
Returns true if the two ArcCStr
s 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 = 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>
1.0.0 · sourcepub fn as_ptr(&self) -> *const i8
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.
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::CString;
let ptr = CString::new("Hello").expect("CString::new failed").as_ptr();
unsafe {
// `ptr` is dangling
*ptr;
}
This happens because the pointer returned by as_ptr
does not carry any
lifetime information and the CString
is deallocated immediately after
the CString::new("Hello").expect("CString::new failed").as_ptr()
expression is evaluated.
To fix the problem, bind the CString
to a local variable:
use std::ffi::CString;
let hello = CString::new("Hello").expect("CString::new failed");
let ptr = hello.as_ptr();
unsafe {
// `ptr` is valid because `hello` is in scope
*ptr;
}
This way, the lifetime of the CString
in hello
encompasses
the lifetime of ptr
and the unsafe
block.
sourcepub fn is_empty(&self) -> bool
🔬This is a nightly-only experimental API. (cstr_is_empty
)
pub fn is_empty(&self) -> bool
cstr_is_empty
)Returns true
if self.to_bytes()
has a length of 0.
Examples
#![feature(cstr_is_empty)]
use std::ffi::CStr;
let cstr = CStr::from_bytes_with_nul(b"foo\0")?;
assert!(!cstr.is_empty());
let empty_cstr = CStr::from_bytes_with_nul(b"\0")?;
assert!(empty_cstr.is_empty());
1.0.0 · sourcepub fn to_bytes(&self) -> &[u8]ⓘNotable traits for &mut [u8]impl Write for &mut [u8]impl Read for &[u8]
pub fn to_bytes(&self) -> &[u8]ⓘNotable traits for &mut [u8]impl Write for &mut [u8]impl Read for &[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
use std::ffi::CStr;
let cstr = CStr::from_bytes_with_nul(b"foo\0").expect("CStr::from_bytes_with_nul failed");
assert_eq!(cstr.to_bytes(), b"foo");
1.0.0 · sourcepub fn to_bytes_with_nul(&self) -> &[u8]ⓘNotable traits for &mut [u8]impl Write for &mut [u8]impl Read for &[u8]
pub fn to_bytes_with_nul(&self) -> &[u8]ⓘNotable traits for &mut [u8]impl Write for &mut [u8]impl Read for &[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
use std::ffi::CStr;
let cstr = CStr::from_bytes_with_nul(b"foo\0").expect("CStr::from_bytes_with_nul failed");
assert_eq!(cstr.to_bytes_with_nul(), b"foo\0");
1.4.0 · sourcepub fn to_str(&self) -> Result<&str, Utf8Error>
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
use std::ffi::CStr;
let cstr = CStr::from_bytes_with_nul(b"foo\0").expect("CStr::from_bytes_with_nul failed");
assert_eq!(cstr.to_str(), Ok("foo"));
1.4.0 · sourcepub fn to_string_lossy(&self) -> Cow<'_, str>
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(&str)
with the result.
Examples
Calling to_string_lossy
on a CStr
containing valid UTF-8:
use std::borrow::Cow;
use std::ffi::CStr;
let cstr = CStr::from_bytes_with_nul(b"Hello World\0")
.expect("CStr::from_bytes_with_nul failed");
assert_eq!(cstr.to_string_lossy(), Cow::Borrowed("Hello World"));
Calling to_string_lossy
on a CStr
containing invalid UTF-8:
use std::borrow::Cow;
use std::ffi::CStr;
let cstr = CStr::from_bytes_with_nul(b"Hello \xF0\x90\x80World\0")
.expect("CStr::from_bytes_with_nul failed");
assert_eq!(
cstr.to_string_lossy(),
Cow::Owned(String::from("Hello �World")) as Cow<'_, str>
);
Trait Implementations
sourceimpl Clone for ArcCStr
impl Clone for ArcCStr
sourcefn clone(&self) -> 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
#![feature(try_from)]
use std::convert::TryFrom;
use arccstr::ArcCStr;
let five = ArcCStr::try_from("5").unwrap();
ArcCStr::clone(&five);
1.0.0 · sourcefn clone_from(&mut self, source: &Self)
fn clone_from(&mut self, source: &Self)
source
. Read moresourceimpl<'de> Deserialize<'de> for ArcCStr
impl<'de> Deserialize<'de> for ArcCStr
sourcefn deserialize<D>(deserializer: D) -> Result<ArcCStr, D::Error>where
D: Deserializer<'de>,
fn deserialize<D>(deserializer: D) -> Result<ArcCStr, D::Error>where
D: Deserializer<'de>,
sourceimpl Drop for ArcCStr
impl Drop for ArcCStr
sourcefn drop(&mut self)
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
#![feature(try_from)]
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
sourceimpl Ord for ArcCStr
impl Ord for ArcCStr
sourcefn cmp(&self, other: &ArcCStr) -> Ordering
fn cmp(&self, other: &ArcCStr) -> Ordering
Comparison for two ArcCStr
s.
The two are compared by calling cmp()
on their underlying strings.
Examples
#![feature(try_from)]
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()));
1.21.0 · sourcefn max(self, other: Self) -> Selfwhere
Self: Sized,
fn max(self, other: Self) -> Selfwhere
Self: Sized,
1.21.0 · sourcefn min(self, other: Self) -> Selfwhere
Self: Sized,
fn min(self, other: Self) -> Selfwhere
Self: Sized,
1.50.0 · sourcefn clamp(self, min: Self, max: Self) -> Selfwhere
Self: Sized + PartialOrd<Self>,
fn clamp(self, min: Self, max: Self) -> Selfwhere
Self: Sized + PartialOrd<Self>,
sourceimpl PartialEq<ArcCStr> for ArcCStr
impl PartialEq<ArcCStr> for ArcCStr
sourcefn eq(&self, other: &ArcCStr) -> bool
fn eq(&self, other: &ArcCStr) -> bool
Equality for two ArcCStr
s.
Two ArcCStr
s are equal if their underlying strings are equal.
Examples
#![feature(try_from)]
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"));
sourceimpl PartialOrd<ArcCStr> for ArcCStr
impl PartialOrd<ArcCStr> for ArcCStr
sourcefn partial_cmp(&self, other: &ArcCStr) -> Option<Ordering>
fn partial_cmp(&self, other: &ArcCStr) -> Option<Ordering>
Partial comparison for two ArcCStr
s.
The two are compared by calling partial_cmp()
on their underlying strings.
Examples
#![feature(try_from)]
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()));
sourcefn lt(&self, other: &ArcCStr) -> bool
fn lt(&self, other: &ArcCStr) -> bool
Less-than comparison for two ArcCStr
s.
The two are compared by calling <
on their inner values.
Examples
#![feature(try_from)]
use std::convert::TryFrom;
use arccstr::ArcCStr;
let five = ArcCStr::try_from("5").unwrap();
assert!(five < ArcCStr::try_from("6").unwrap());
sourcefn le(&self, other: &ArcCStr) -> bool
fn le(&self, other: &ArcCStr) -> bool
‘Less than or equal to’ comparison for two ArcCStr
s.
The two are compared by calling <=
on their underlying strings.
Examples
#![feature(try_from)]
use std::convert::TryFrom;
use arccstr::ArcCStr;
let five = ArcCStr::try_from("5").unwrap();
assert!(five <= ArcCStr::try_from("5").unwrap());
sourcefn gt(&self, other: &ArcCStr) -> bool
fn gt(&self, other: &ArcCStr) -> bool
Greater-than comparison for two ArcCStr
s.
The two are compared by calling >
on their underlying strings.
Examples
#![feature(try_from)]
use std::convert::TryFrom;
use arccstr::ArcCStr;
let five = ArcCStr::try_from("5").unwrap();
assert!(five > ArcCStr::try_from("4").unwrap());
sourcefn ge(&self, other: &ArcCStr) -> bool
fn ge(&self, other: &ArcCStr) -> bool
‘Greater than or equal to’ comparison for two ArcCStr
s.
The two are compared by calling >=
on their underlying strings.
Examples
#![feature(try_from)]
use std::convert::TryFrom;
use arccstr::ArcCStr;
let five = ArcCStr::try_from("5").unwrap();
assert!(five >= ArcCStr::try_from("5").unwrap());