Struct rkyv::ffi::ArchivedCString

#[repr(transparent)]
pub struct ArchivedCString(_);

An archived CString.

Uses a RelPtr to a CStr under the hood.

Implementations

impl ArchivedCString

pub fn as_bytes(&self) -> &[u8]

Returns the contents of this CString as a slice of bytes.

The returned slice does not contain the trailing nul terminator, and it is guaranteed to not have any interior nul bytes. If you need the nul terminator, use as_bytes_with_nul instead.

pub fn as_bytes_with_nul(&self) -> &[u8]

Equivalent to as_bytes except that the returned slice includes the trailing nul terminator.

pub fn as_c_str(&self) -> &CStr

Extracts a CStr slice containing the entire string.

pub fn pin_mut_c_str(self: Pin<&mut Self>) -> Pin<&mut CStr>

Extracts a pinned mutable CStr slice containing the entire string.

pub unsafe fn resolve_from_c_str(
    c_str: &CStr,
    pos: usize,
    resolver: CStringResolver,
    out: *mut Self
)

Resolves an archived C string from the given C string and parameters.

Safety

• pos must be the position of out within the archive
• resolver must be the result of serializing a C string

pub fn serialize_from_c_str<S: Serializer + ?Sized>(
    c_str: &CStr,
    serializer: &mut S
) -> Result<CStringResolver, S::Error>

Serializes a C string.

Methods from Deref<Target = CStr>

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.

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");

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");

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"));

Trait Implementations

impl AsRef<CStr> for ArchivedCString

fn as_ref(&self) -> &CStr

Converts this type into a shared reference of the (usually inferred) input type.

impl Borrow<CStr> for ArchivedCString

fn borrow(&self) -> &CStr

Immutably borrows from an owned value.

impl<C: ArchiveContext + ?Sized> CheckBytes<C> for ArchivedCString where
    C::Error: Error, 

type Error = OwnedPointerError<<<CStr as ArchivePointee>::ArchivedMetadata as CheckBytes<C>>::Error, <CStr as CheckBytes<C>>::Error, <C as Fallible>::Error>

The error that may result from checking the type.

unsafe fn check_bytes<'a>(
    value: *const Self,
    context: &mut C
) -> Result<&'a Self, Self::Error>

Checks whether the given pointer points to a valid value within the given context.

impl Debug for ArchivedCString

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Deref for ArchivedCString

type Target = CStr

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl<'a, D: Fallible + ?Sized> DeserializeWith<ArchivedCString, Cow<'a, CStr>, D> for AsOwned

fn deserialize_with(
    field: &ArchivedCString,
    deserializer: &mut D
) -> Result<Cow<'a, CStr>, D::Error>

Deserializes the field type F using the given deserializer.

impl Hash for ArchivedCString

fn hash<H: Hasher>(&self, state: &mut H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H) where
    H: Hasher, 

Feeds a slice of this type into the given Hasher.

impl Index<RangeFull> for ArchivedCString

type Output = CStr

The returned type after indexing.

fn index(&self, _: RangeFull) -> &Self::Output

Performs the indexing (container[index]) operation.

impl Ord for ArchivedCString

fn cmp(&self, other: &Self) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

Restrict a value to a certain interval.

impl PartialEq<&'_ CStr> for ArchivedCString

fn eq(&self, other: &&CStr) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl PartialEq<ArchivedCString> for ArchivedCString

fn eq(&self, other: &Self) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl PartialEq<ArchivedCString> for &CStr

fn eq(&self, other: &ArchivedCString) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl PartialEq<ArchivedCString> for CString

fn eq(&self, other: &ArchivedCString) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl PartialEq<CString> for ArchivedCString

fn eq(&self, other: &CString) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl PartialOrd<ArchivedCString> for ArchivedCString

fn partial_cmp(&self, other: &Self) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl Eq for ArchivedCString