Struct OwnedCStrs 

pub struct OwnedCStrs { /* private fields */ }

A AsCStrArray backed by a collection of owned strings

This struct is a counterpart to BorrowedCStrs that owns the strings themselves instead of borrowing them. OwnedCStrs owns both the allocation for the array of pointers and the Vec of owned strings, ensuring that the pointers remain valid for the lifetime of the OwnedCStrs.

The implementation of FromIterator allows you to create an OwnedCStrs from an iterator of CStrings, which can be useful when you want to create an AsCStrArray from scratch and need to own the strings themselves.

Implementations

impl OwnedCStrs

pub fn new(values: Vec<CString>) -> Self

Creates a new OwnedCStrs from a Vec<CString>.

The given values is stored in the OwnedCStrs for the lifetime of it to keep the strings valid and unmodified. A null-terminated array of pointers to the C-style strings is created from the values and stored in the OwnedCStrs as well. The pointer to the array is returned by the as_ptr method.

pub unsafe fn from_pointers_and_values( pointers: Vec<*const c_char>, values: Vec<CString>, ) -> Self

Creates a new OwnedCStrs from its inner components.

This function directly uses the given pointers as the content of the OwnedCStrs. The pointers is a null-terminated array of pointers to C-style strings that is returned by the as_ptr method. The values is a Vec<CString> stored in the OwnedCStrs for the lifetime of it.

Safety

The caller must ensure that the pointers in the first Vec point to valid C-style strings, and that the Vec is null-terminated (i.e., the last pointer is a null pointer). The strings must remain valid and unmodified for the lifetime of the OwnedCStrs.

This function does not require that the pointers point to strings contained in values. However, if the strings pointed to by pointers are modified or dropped through other means while the OwnedCStrs is alive, it may lead to undefined behavior when the pointers are used. If the strings pointed to by pointers are not contained in values, you should consider using BorrowedCStrs instead, as it supports lifetime-based safety guarantees for the strings.

pub fn into_pointers_and_values(self) -> (Vec<*const c_char>, Vec<CString>)

Consumes the OwnedCStrs and returns the owned array of pointers and values.

This function just returns its inner components. The caller is responsible for ensuring the validity of the returned pointers if they intend to use them. If self was created by OwnedCStrs::new, the C-style strings pointed to by the returned pointers will be valid until the returned values are mutated or dropped.

Trait Implementations

impl AsCStrArray for OwnedCStrs

fn as_ptr(&self) -> *const *const c_char

Returns a pointer to the array of C-style strings.

fn as_mut_ptr(&mut self) -> *const *mut c_char

Returns a pointer to the array of C-style strings.

fn to_vec(&self) -> Vec<CString>

Constructs a Vec<CString> from the array of C-style strings.

impl Clone for OwnedCStrs

Clones an OwnedCStrs by cloning its owned strings and reconstructing the pointer array to point to the new strings.

fn clone(&self) -> Self

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for OwnedCStrs

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

Formats the value using the given formatter.

impl From<Vec<CString>> for OwnedCStrs

Converts a Vec<CString> into an OwnedCStrs. (See OwnedCStrs::new.)

fn from(values: Vec<CString>) -> Self

Converts to this type from the input type.

impl<A> FromIterator<A> for OwnedCStrs

where A: Into<CString>,

Creates an OwnedCStrs from an iterator of values that can be converted into CStrings.

fn from_iter<I: IntoIterator<Item = A>>(iter: I) -> Self

Creates a value from an iterator.