Struct CStringArray 

#[repr(C)]
pub struct CStringArray {
    pub data: *const *const c_char,
    pub size: usize,
}

A #[repr(C)] mirror of Vec<String> with impls of CReprOf, CDrop and AsRust.

Layout is a (data, size) pair where data is a pointer to a heap-allocated array of *const c_char, each pointing to its own nul-terminated C string allocated by the Rust side. The whole structure is freed via CDrop / Drop.

Strings containing interior NUL bytes cannot be represented and will cause CReprOf::c_repr_of to fail with CReprOfError::StringContainsNullBit.

Example

use ffi_convert::{AsRust, CReprOf};
use ffi_convert_extra_ctypes::CStringArray;

let pizza_names = vec![
    "Diavola".to_string(),
    "Margarita".to_string(),
    "Regina".to_string(),
];
let c_pizza_names = CStringArray::c_repr_of(pizza_names.clone()).unwrap();
assert_eq!(c_pizza_names.size, 3);

// Deep-copy back into owned Rust strings.
let round_tripped: Vec<String> = c_pizza_names.as_rust().unwrap();
assert_eq!(round_tripped, pizza_names);

Fields

data: *const *const c_char

Pointer to the first *const c_char element of the array.

size: usize

Number of elements in the array.

Trait Implementations

impl AsRust<Vec<String>> for CStringArray

fn as_rust(&self) -> Result<Vec<String>, AsRustError>

Return a freshly-allocated Rust value equivalent to self.

impl CDrop for CStringArray

fn do_drop(&mut self) -> Result<(), CDropError>

Release any Rust-owned memory referenced by self. The derived Drop impl calls this and discards the result, so errors raised from a normal drop are not observed.

impl CReprOf<Vec<String>> for CStringArray

fn c_repr_of(input: Vec<String>) -> Result<Self, CReprOfError>

Consume input and return its C-compatible representation.

impl Debug for CStringArray

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

Formats the value using the given formatter.

impl Drop for CStringArray

fn drop(&mut self)

Executes the destructor for this type.

fn pin_drop(self: Pin<&mut Self>)

🔬This is a nightly-only experimental API. (pin_ergonomics)

Execute the destructor for this type, but different to Drop::drop, it requires self to be pinned.

impl RawPointerConverter<CStringArray> for CStringArray

fn into_raw_pointer(self) -> *const CStringArray

Leak the value behind a raw pointer. Pair with Self::from_raw_pointer or Self::drop_raw_pointer to release the allocation.

fn into_raw_pointer_mut(self) -> *mut CStringArray

Leak the value behind a mutable raw pointer. Pair with Self::from_raw_pointer_mut or Self::drop_raw_pointer_mut to release the allocation.

unsafe fn from_raw_pointer_mut( input: *mut CStringArray, ) -> Result<CStringArray, UnexpectedNullPointerError>

Take back ownership of a raw pointer previously produced by Self::into_raw_pointer_mut. Returns UnexpectedNullPointerError if input is null.

unsafe fn from_raw_pointer( input: *const CStringArray, ) -> Result<CStringArray, UnexpectedNullPointerError>

Take back ownership of a raw pointer previously produced by Self::into_raw_pointer. Returns UnexpectedNullPointerError if input is null.

unsafe fn drop_raw_pointer( input: *const T, ) -> Result<(), UnexpectedNullPointerError>

Take back ownership of a pointer produced by Self::into_raw_pointer and drop the value.

unsafe fn drop_raw_pointer_mut( input: *mut T, ) -> Result<(), UnexpectedNullPointerError>

Take back ownership of a pointer produced by Self::into_raw_pointer_mut and drop the value.

impl Sync for CStringArray