pub struct CStrArray<const N: usize> { /* private fields */ }Expand description
Fixed-size CStr stored as an array.
The length N is the number of bytes in the string not including the nul terminator.
Because it has a fixed size, it can be put directly in a static and all
casting operations are constant-time.
Implementations§
Source§impl<const N: usize> CStrArray<N>
impl<const N: usize> CStrArray<N>
Sourcepub const fn new(val: &CStr) -> Self
pub const fn new(val: &CStr) -> Self
Builds a CStrArray<N> from a correct-length val.
This performs a length validation.
If val is a literal or const, consider using cstr_array!
instead, which always builds a CStrArray with the correct N.
Sourcepub const fn new_checked(val: &CStr) -> Result<Self, CStrLenError<N>>
pub const fn new_checked(val: &CStr) -> Result<Self, CStrLenError<N>>
Fallibly builds a StrArray<N> from val.
This returns an Err if val.len() != N.
Sourcepub const unsafe fn new_unchecked(val: &CStr) -> Self
pub const unsafe fn new_unchecked(val: &CStr) -> Self
Sourcepub const fn from_bytes_without_nul(
bytes: &[u8; N],
) -> Result<Self, InteriorNulError>
pub const fn from_bytes_without_nul( bytes: &[u8; N], ) -> Result<Self, InteriorNulError>
Constructs a CStrArray<N> from an array with its byte contents.
Note that this does not include the nul terminator - it is appended automatically.
Sourcepub const unsafe fn from_bytes_without_nul_unchecked(
bytes: &[u8; N],
) -> Result<Self, InteriorNulError>
pub const unsafe fn from_bytes_without_nul_unchecked( bytes: &[u8; N], ) -> Result<Self, InteriorNulError>
Constructs a CStrArray<N> from an array with its byte contents and no checks.
Note that this does not include the nul terminator - it is appended automatically.
§Safety
bytesmust not have any 0 (nul) bytes.
Sourcepub const fn as_c_str(&self) -> &CStr
pub const fn as_c_str(&self) -> &CStr
Borrows this CStrArray as a &CStr.
This is called by Deref.
Sourcepub const fn as_bytes(&self) -> &[u8; N]
pub const fn as_bytes(&self) -> &[u8; N]
Converts this C string to a byte array reference.
The returned slice will not contain the trailing nul terminator that this C string has.
Sourcepub const fn as_bytes_with_nul(&self) -> &[u8] ⓘ
pub const fn as_bytes_with_nul(&self) -> &[u8] ⓘ
Converts this C string to a byte slice containing the trailing 0 byte.
The length of the slice is N + 1.
Sourcepub const fn into_bytes(self) -> [u8; N]
pub const fn into_bytes(self) -> [u8; N]
Consumes self into its underlying array.
Sourcepub const fn count_bytes(&self) -> usize
👎Deprecated: use len
pub const fn count_bytes(&self) -> usize
Returns the fixed length.
This uses the same name as CStr::count_bytes to prevent
it from being called with Deref.
Sourcepub const fn to_bytes(&self) -> &[u8] ⓘ
👎Deprecated: use as_bytes
pub const fn to_bytes(&self) -> &[u8] ⓘ
Converts this C string to a byte slice.
This uses the same name as CStr::to_bytes to prevent
it from being called with Deref.
Sourcepub const fn to_bytes_with_nul(&self) -> &[u8] ⓘ
👎Deprecated: use as_bytes_with_nul
pub const fn to_bytes_with_nul(&self) -> &[u8] ⓘ
Converts this C string to a byte slice.
This uses the same name as CStr::to_bytes_with_nul to prevent
it from being called with Deref.
Methods from Deref<Target = CStr>§
1.0.0 · Sourcepub fn as_ptr(&self) -> *const u8
pub fn as_ptr(&self) -> *const u8
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!");1.79.0 · Sourcepub fn count_bytes(&self) -> usize
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);1.71.0 · Sourcepub fn is_empty(&self) -> bool
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());1.0.0 · Sourcepub fn to_bytes(&self) -> &[u8] ⓘ
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");1.0.0 · Sourcepub fn to_bytes_with_nul(&self) -> &[u8] ⓘ
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");Sourcepub fn bytes(&self) -> Bytes<'_>
🔬This is a nightly-only experimental API. (cstr_bytes)
pub fn bytes(&self) -> Bytes<'_>
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"));Sourcepub fn display(&self) -> impl Display
🔬This is a nightly-only experimental API. (cstr_display)
pub fn display(&self) -> impl Display
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());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(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>
);