Struct CArray

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

A utility type to represent arrays of the parametrized type. Note that the parametrized type should have a C-compatible representation.

Example

use ffi_convert::{CReprOf, AsRust, CDrop, CArray};
use libc::c_char;

pub struct PizzaTopping {
    pub ingredient: String,
}

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

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

let ctoppings = CArray::<CPizzaTopping>::c_repr_of(toppings);

Fields

data_ptr: *const T

Pointer to the first element of the array

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>

impl<T> CDrop for CArray<T>

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

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

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

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.

impl<T> RawPointerConverter<CArray<T>> for CArray<T>

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

Creates a raw pointer from the value and leaks it, you should use Self::from_raw_pointer or Self::drop_raw_pointer to free the value when you’re done with it.

fn into_raw_pointer_mut(self) -> *mut CArray<T>

Creates a mutable raw pointer from the value and leaks it, you should use Self::from_raw_pointer_mut or Self::drop_raw_pointer_mut to free the value when you’re done with it.

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

Takes back control of a raw pointer created by Self::into_raw_pointer.

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

Takes back control of a raw pointer created by Self::into_raw_pointer_mut.

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

Takes back control of a raw pointer created by Self::into_raw_pointer and drop it.

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

Takes back control of a raw pointer created by Self::into_raw_pointer_mut and drops it.