Struct ffi_closure::Closure

pub struct Closure<T: ?Sized + AsExtern<Cc>, Cc: CallingConvention = C> { /* private fields */ }

A closure that can be sent through an FFI boundary.

Implementations

impl<T: ?Sized + AsExtern<Cc>, Cc: CallingConvention> Closure<T, Cc>

pub fn new<F: IntoExtern<T, Cc>>(f: F) -> Self

Creates a new Closure from a Rust closure.

Example

let mut square = Closure::<dyn FnMut(u32) -> u32>::new(|x| x * x);
assert_eq!(square.call((3,)), 9);

pub unsafe fn from_extern( f: T::Extern, user_data: *mut c_void, destructor: Option<Cc::Destructor> ) -> Self

Creates a new Closure from an external function pointer and user data.

Example

unsafe extern "C" fn square(x: u32, _: *mut c_void) -> u32 {
    return x * x
}

let mut square = unsafe { Closure::<dyn FnMut(u32) -> u32>::from_extern(square, core::ptr::null_mut(), None) };
assert_eq!(square.call((3,)), 9);

pub fn into_parts(self) -> (*mut c_void, T::Extern, Option<Cc::Destructor>)

Returns the parts that form the closure, without droping it. Caller is responsibnle for correct deinitialization of the extracted closure.

pub fn has_destructor(&self) -> bool

Returns true if this closure has a destructor, false otherwise

pub fn user_data(&self) -> *mut c_void

Returns the user data of this Closure

pub fn fn_ptr(&self) -> T::Extern

Returns the function pointer of this Closure

pub fn as_extern_parts(&self) -> (T::Extern, *mut c_void)

Returns the function pointer and user data of this Closure

Example

let mut square = Closure::<dyn FnMut(u32) -> u32>::new(|x| x * x);
let (f, user_data): (unsafe extern "C" fn(u32, *mut c_void) -> u32, *mut c_void) = square.as_extern_parts();
unsafe { assert_eq!(f(3, user_data), 9) }

pub fn call(&mut self, args: T::Args) -> T::Output

Calls the Closure’s function pointer with the provided arguments and it’s user data

Example

let mut square = Closure::<dyn FnMut(u32) -> u32>::new(|x| x * x);
assert_eq!(square.call((3,)), 9);

Trait Implementations

impl<T: ?Sized + AsExtern<Cc>, Cc: CallingConvention> Drop for Closure<T, Cc>

fn drop(&mut self)

Executes the destructor for this type.

impl<T: ?Sized + AsExtern<Cc>, Cc: CallingConvention> FnMut<<T as AsExtern<Cc>>::Args> for Closure<T, Cc>

where T::Args: Tuple,

Available on crate feature nightly only.

extern "rust-call" fn call_mut( &mut self, args: T::Args ) -> Self::Output

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

Performs the call operation.

impl<T: ?Sized + AsExtern<Cc>, Cc: CallingConvention> FnOnce<<T as AsExtern<Cc>>::Args> for Closure<T, Cc>

where T::Args: Tuple,

Available on crate feature nightly only.

type Output = <T as AsExtern<Cc>>::Output

The returned type after the call operator is used.

extern "rust-call" fn call_once(self, args: T::Args) -> Self::Output

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

Performs the call operation.

impl<T: ?Sized + AsExtern<Cc> + Send, Cc: CallingConvention> Send for Closure<T, Cc>

impl<T: ?Sized + AsExtern<Cc> + Sync, Cc: CallingConvention> Sync for Closure<T, Cc>