FFI Destruct

Generates destructors for structures that contain raw pointers in the FFI.

About

The Destruct derive macro will implement Drop trait and free(drop) memory for structures containing raw pointers. It may be a common procedure for FFI structure memory operations.

Supported types

Both *const and *mut are acceptable. But currently, only single-level pointers are supported.

• * c_char: c-style string, using std::ffi::CString::from_raw() to handle std::ffi::CString::into_raw()
• * <T>: Using std::boxed::Box::from_raw() to handle std::boxed::Box::into_raw()

Example

Provides a structure with several raw pointers that need to be dropped manually. ```rust use ffidestruct::{externc_destructor, Destruct};

// Struct definition here, with deriving Destruct and nullable attributes.

[derive(Destruct)]

pub struct Structure { cstring: *const cchar, // Default is non-null. #[nullable] cstringnullable: *mut c_char,

other: *mut MyStruct,
#[nullable]
other_nullable: *mut MyStruct,

// Non-pointer types are still available, and will not be added to drop().
normal_int: u8,
normal_string: String,

}

// (Optional) The macro here generates the destructor: destructstructure() externc_destructor!(Structure);

fn teststruct() { let mystruct = Structure { cstring: CString::new("Hello").unwrap().intoraw(), cstringnullable: std::ptr::nullmut(), other: Box::intoraw(Box::new(MyStruct { field: CString::new("Hello").unwrap().intoraw(), })), othernullable: std::ptr::null_mut(), };

let my_struct_ptr = Box::into_raw(Box::new(my_struct));
// FFI calling
unsafe {
    destruct_structure(my_struct_ptr);
}

} ```

After expanding the macro: ```rust // derive(Destruct) impl ::std::ops::Drop for Structure { fn drop(&mut self) { unsafe { let _ = ::std::ffi::CString::fromraw( self.cstring as *mut ::std::ffi::cchar, ); if !self.cstringnullable.isnull() { let _ = ::std::ffi::CString::fromraw( self.cstringnullable as *mut ::std::ffi::cchar, ); } let _ = ::std::boxed::Box::fromraw(self.other as *mut TestA); if !self.othernullable.isnull() { let _ = ::std::boxed::Box::fromraw(self.other_nullable as *mut TestA); } } } }

// externcdestructor!() generates snake_case named destructor

[no_mangle]

pub unsafe extern "C" fn destructstructure(ptr: *mut Structure) { if ptr.isnull() { return; } let _ = ::std::boxed::Box::from_raw(ptr); } ```