Struct CArray 

#[repr(C)]
pub struct CArray<T> {
    pub data_ptr: *const T,
    pub size: usize,
}

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

Layout is a (data_ptr, size) pair. An empty array is represented with a null data_ptr and size == 0.

When U is a primitive numeric type (u8, i8, u16, i16, u32, i32, f32, or f64) the conversion takes a fast path: c_repr_of reuses the input Vec’s buffer directly, and as_rust does a bulk ptr::copy into a new Vec. Otherwise each element is converted individually through its CReprOf / AsRust implementation.

CArray owns the backing buffer and frees it via its Drop impl (by way of CDrop). Do not reconstruct a CArray from a pointer you do not own.

Example

use ffi_convert::{AsRust, CDrop, CReprOf};
use ffi_convert_extra_ctypes::CArray;
use std::ffi::c_char;

pub struct PizzaTopping {
    pub ingredient: String,
}

#[derive(CReprOf, AsRust, CDrop)]
#[target_type(PizzaTopping)]
pub struct CPizzaTopping {
    pub ingredient: *const c_char,
}

let toppings = vec![
    PizzaTopping { ingredient: "Cheese".into() },
    PizzaTopping { ingredient: "Ham".into() },
];

// Rust -> C (the `CArray` now owns the C strings it allocated).
let c_toppings = CArray::<CPizzaTopping>::c_repr_of(toppings).unwrap();
assert_eq!(c_toppings.size, 2);

// C -> Rust (deep copy; `c_toppings` stays valid).
let round_tripped: Vec<PizzaTopping> = c_toppings.as_rust().unwrap();
assert_eq!(round_tripped[0].ingredient, "Cheese");

Fields

data_ptr: *const T

Pointer to the first element, or null when size == 0.

size: usize

Number of elements in the array.

Trait Implementations

impl<U: AsRust<V> + 'static, V> AsRust<Vec<V>> for CArray<U>

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

Return a freshly-allocated Rust value equivalent to self.

impl<T> CDrop for CArray<T>

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<U: CReprOf<V> + CDrop, V: 'static> CReprOf<Vec<V>> for CArray<U>

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

Consume input and return its C-compatible representation.

impl<T: Debug> Debug for CArray<T>

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

Formats the value using the given formatter.

impl<T> Drop for CArray<T>

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<T> RawPointerConverter<CArray<T>> for CArray<T>

fn into_raw_pointer(self) -> *const CArray<T>

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 CArray<T>

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( input: *const CArray<T>, ) -> Result<Self, UnexpectedNullPointerError>

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

unsafe fn from_raw_pointer_mut( input: *mut CArray<T>, ) -> Result<Self, UnexpectedNullPointerError>

Take back ownership of a raw pointer previously produced by Self::into_raw_pointer_mut. 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.