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 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
, 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; let mut my_arc = ArcCStr::from("foobar"); ArcCStr::strong_count(&my_arc);
Examples
Sharing some immutable strings between threads:
use arccstr::ArcCStr; use std::thread; let five = ArcCStr::from("5"); 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
use arccstr::ArcCStr; let five = ArcCStr::from("5"); 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 ArcCStr
s point to the same value (not
just values that compare as equal).
Examples
use arccstr::ArcCStr; let five = ArcCStr::from("5"); let same_five = five.clone(); let other_five = ArcCStr::from("5"); 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.
Trait Implementations
impl Send for ArcCStr
[src]
impl Sync for ArcCStr
[src]
impl<'a> From<&'a [u8]> for ArcCStr
[src]
impl<'a> From<&'a str> for ArcCStr
[src]
impl From<String> for ArcCStr
[src]
impl From<CString> for ArcCStr
[src]
impl<'a> From<&'a CStr> for ArcCStr
[src]
impl Clone for ArcCStr
[src]
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 arccstr::ArcCStr; let five = ArcCStr::from("5"); five.clone();
fn clone_from(&mut self, source: &Self)
1.0.0
Performs copy-assignment from source
. Read more
impl Deref for ArcCStr
[src]
type Target = CStr
The resulting type after dereferencing
fn deref(&self) -> &Self::Target
The method called to dereference a value
impl Drop for ArcCStr
[src]
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 arccstr::ArcCStr; let foo = ArcCStr::from("foo"); let foo2 = foo.clone(); drop(foo); // "foo" is still in memory drop(foo2); // "foo" is deallocated
impl PartialEq for ArcCStr
[src]
fn eq(&self, other: &ArcCStr) -> bool
Equality for two ArcCStr
s.
Two ArcCStr
s are equal if their underlying strings are equal.
Examples
use arccstr::ArcCStr; let five = ArcCStr::from("5"); assert!(five == ArcCStr::from("5"));
fn ne(&self, other: &ArcCStr) -> bool
Inequality for two ArcCStr
s.
Two ArcCStr
s are unequal if their inner values are unequal.
Examples
use arccstr::ArcCStr; let five = ArcCStr::from("5"); assert!(five != ArcCStr::from("6"));
impl PartialOrd for ArcCStr
[src]
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
use arccstr::ArcCStr; use std::cmp::Ordering; let five = ArcCStr::from("5"); assert_eq!(Some(Ordering::Less), five.partial_cmp(&ArcCStr::from("6")));
fn lt(&self, other: &ArcCStr) -> bool
Less-than comparison for two ArcCStr
s.
The two are compared by calling <
on their inner values.
Examples
use arccstr::ArcCStr; let five = ArcCStr::from("5"); assert!(five < ArcCStr::from("6"));
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
use arccstr::ArcCStr; let five = ArcCStr::from("5"); assert!(five <= ArcCStr::from("5"));
fn gt(&self, other: &ArcCStr) -> bool
Greater-than comparison for two ArcCStr
s.
The two are compared by calling >
on their underlying strings.
Examples
use arccstr::ArcCStr; let five = ArcCStr::from("5"); assert!(five > ArcCStr::from("4"));
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
use arccstr::ArcCStr; let five = ArcCStr::from("5"); assert!(five >= ArcCStr::from("5"));
impl Ord for ArcCStr
[src]
fn cmp(&self, other: &ArcCStr) -> Ordering
Comparison for two ArcCStr
s.
The two are compared by calling cmp()
on their underlying strings.
Examples
use arccstr::ArcCStr; use std::cmp::Ordering; let five = ArcCStr::from("5"); assert_eq!(Ordering::Less, five.cmp(&ArcCStr::from("6")));
impl Eq for ArcCStr
[src]
impl Debug for ArcCStr
[src]
impl Pointer for ArcCStr
[src]
impl Hash for ArcCStr
[src]
fn hash<H: Hasher>(&self, state: &mut H)
Feeds this value into the state given, updating the hasher as necessary.
fn hash_slice<H>(data: &[Self], state: &mut H) where H: Hasher
1.3.0
Feeds a slice of this type into the state provided.