Struct jlrs::ccall::CCall

pub struct CCall<'context> { /* private fields */ }

Interact with Julia from a Rust function called through ccall.

When you call Rust from Julia through ccall, Julia has already been initialized and trying to initialize it again causes a crash. In order to still be able to call Julia from Rust you must create a scope first. You can use this struct to do so. It must never be used outside functions called through ccall, and only once for each ccalled function.

Exceptions must only be thrown indirectly by returning a RustResult.

Implementations

impl<'context> CCall<'context>

pub unsafe fn new(frame: &'context mut StackFrame<0>) -> Self

Create a new CCall

Safety: This function must never be called outside a function called through ccall from Julia and must only be called once during that call.

pub unsafe fn uv_async_send(handle: *mut c_void) -> bool

Wake the task associated with handle.

The handle must be the handle field of a Base.AsyncCondition in Julia. This can be used to call a long-running Rust function from Julia with ccall in another thread and wait for it to complete in Julia without blocking, an example is available in the repository: ccall_with_threads.

This method is only available if the uv feature is enabled.

Safety: the handle must be acquired from an AsyncCondition.

pub fn scope<T, F>(&mut self, func: F) -> JlrsResult<T>where for<'scope> F: FnOnce(GcFrame<'scope>) -> JlrsResult<T>,

Create a GcFrame, call the given closure, and return its result.

pub unsafe fn invoke<T, F>(func: F) -> Twhere T: 'static + CCallReturn, for<'scope> F: FnOnce(GcFrame<'scope>) -> T,

Create an instance of CCall and use it to invoke the provided closure.

Safety: this method must only be called from ccalled functions. The returned data is unrooted and must be returned to Julia immediately.

pub unsafe fn invoke_fallible<T, F>(func: F) -> RustResultRet<T>where T: ConstructType, for<'scope> F: FnOnce(GcFrame<'scope>) -> JlrsResult<RustResultRet<T>>,

Create an instance of CCall and use it to invoke the provided closure.

Safety: this method must only be called from ccalled functions. The returned data is unrooted and must be returned to Julia immediately.

pub unsafe fn stackless_invoke<T, F>(func: F) -> Twhere T: 'static + CCallReturn, for<'scope> F: FnOnce(Unrooted<'scope>) -> T,

Invoke the provided closure.

Safety: this method must only be called from ccalled functions. The returned data is unrooted and must be returned to Julia immediately.

pub unsafe fn throw_exception<F>(self, func: F) -> !where F: for<'scope> FnOnce(&mut GcFrame<'scope>) -> Value<'scope, 'static>,

Create and throw an exception.

This method calls func and throws the result as a Julia exception.

Safety:

Julia exceptions are implemented with setjmp / longjmp. This means that when an exception is thrown, control flow is returned to a catch block by jumping over intermediate stack frames. It’s undefined behaviour to jump over frames that have pending drops, so you must take care to structure your code such that none of the intermediate frames have any pending drops.

pub unsafe fn stackless_scope<T, F>(func: F) -> JlrsResult<T>where for<'scope> F: FnOnce(Unrooted<'scope>) -> JlrsResult<T>,

Create an Unrooted, call the given closure, and return its result.

Unlike CCall::scope this method doesn’t allocate a stack.

Safety: must only be called from a ccalled function that doesn’t need to root any data.

pub fn set_pool_size(&self, size: usize)

Set the size of the internal thread pool.

pub fn dispatch_to_pool<F, T>(func: F) -> Arc<DispatchHandle<T>>where F: FnOnce(Arc<DispatchHandle<T>>) + Send + 'static, T: IntoJulia + Send + Sync + ConstructType,

Dispatch func to a thread pool.

pub fn init_jlrs( &mut self, install_jlrs_core: &InstallJlrsCore, module: Option<Module<'_>> )

This function must be called before jlrs can be used. When the julia_module macro is used this function is called automatically.

A module can be provided to allow setting the size of the internal thread pool from Julia by calling JlrsCore.set_pool_size.

Trait Implementations

impl Drop for CCall<'_>

fn drop(&mut self)

Executes the destructor for this type.