pub type BSFixedString = BSFixedStringInternal<U8>;Expand description
A fixed-length C string.
This type is string-interlaced and reference-shares memory with the same string.
§Encoding
Since this is an FFI type, the encoding is not guaranteed. It may be UTF-8, ANSI,
or some other platform-specific encoding, as it uses char internally.
Therefore, when using this string, it is recommended to convert it to &str
to handle it safely.
Aliased Type§
struct BSFixedString { /* private fields */ }Implementations§
Source§impl BSFixedString
impl BSFixedString
Sourcepub fn new(data: &CStr) -> Self
pub fn new(data: &CStr) -> Self
Creates a new BSFixedString from a &CStr.
§Memory allocation
- If the same string exists inside the allocator, no new memory allocation occurs.
Sourcepub unsafe fn new_unchecked(data: *const c_char) -> Self
pub unsafe fn new_unchecked(data: *const c_char) -> Self
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.
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::CString;
// Do not do this:
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.
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
use std::ffi::CStr;
let cstr = CStr::from_bytes_with_nul(b"foo\0").unwrap();
assert_eq!(cstr.count_bytes(), 3);
let cstr = CStr::from_bytes_with_nul(b"\0").unwrap();
assert_eq!(cstr.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
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());
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
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] ⓘ
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
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");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)]
use std::ffi::CStr;
let cstr = CStr::from_bytes_with_nul(b"foo\0").expect("CStr::from_bytes_with_nul failed");
assert!(cstr.bytes().eq(*b"foo"));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. 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>
);