Module uniffi::ffi

Reexport items from other uniffi creates Types that can cross the FFI boundary.

Modules

• callbackinterface
  Callback interfaces are traits specified in UDL which can be implemented by foreign languages.
• ffidefault
  FfiDefault trait
• foreignbytes
• foreigncallbacks
  This module contains code to handle foreign callbacks - C-ABI functions that are defined by a foreign language, then registered with UniFFI. These callbacks are used to implement callback interfaces, async scheduling etc. Foreign callbacks are registered at startup, when the foreign code loads the exported library. For each callback type, we also define a “cell” type for storing the callback.
• foreignexecutor
  Schedule tasks using a foreign executor.
• rustbuffer
• rustcalls
  Low-level support for calling rust functions
• rustfuture
  [RustFuture] represents a Future that can be sent to the foreign code over FFI.

Structs

• ForeignBytes
  Support for reading a slice of foreign-language-allocated bytes over the FFI.
• ForeignCallbackInternals
  Struct to hold a foreign callback.
• ForeignExecutor
  Schedule Rust calls using a foreign executor
• ForeignExecutorHandle
  Opaque handle for a foreign task executor.
• RustBuffer
  Support for passing an allocated-by-Rust buffer of bytes over the FFI.
• RustCallStatus
  Represents the success/error of a rust call
• RustFutureHandle
  Opaque handle for a Rust future that’s stored by the foreign language code
• UnexpectedUniFFICallbackError
  Used when internal/unexpected error happened when calling a foreign callback, for example when a unknown exception is raised

Enums

• CallbackResult
  Result of a foreign callback invocation
• ForeignExecutorCallbackResult
  Result code returned by ForeignExecutorCallback
• RustCallStatusCode
  Result of a FFI call to a Rust function
• RustFuturePoll
  Result code for rust_future_poll. This is passed to the continuation function.
• RustTaskCallbackCode
  Passed to a RustTaskCallback function when the executor invokes them.

Constants

• IDX_CALLBACK_FREE
  The method index used by the Drop trait to communicate to the foreign language side that Rust has finished with it, and it can be deleted from the handle map.

Traits

• FfiDefault

Functions

• foreign_executor_callback_set
  Set the global ForeignExecutorCallback. This is called by the foreign bindings, normally during initialization.
• rust_call
  Handle a scaffolding calls
• rust_future_cancel^⚠
  Cancel a Rust future
• rust_future_complete^⚠
  Complete a Rust future
• rust_future_free^⚠
  Free a Rust future, dropping the strong reference and releasing all references held by the future.
• rust_future_new
  Create a new RustFutureHandle
• rust_future_poll^⚠
  Poll a Rust future
• uniffi_rustbuffer_alloc
• uniffi_rustbuffer_free
• uniffi_rustbuffer_from_bytes
• uniffi_rustbuffer_reserve

Type Aliases

• ForeignCallback
  ForeignCallback is the Rust representation of a foreign language function. It is the basis for all callbacks interfaces. It is registered exactly once per callback interface, at library start up time. Calling this method is only done by generated objects which mirror callback interfaces objects in the foreign language.
• ForeignExecutorCallback
  Callback to schedule a Rust call with a ForeignExecutor. The bindings code registers exactly one of these with the Rust code.
• RustFutureContinuationCallback
  Foreign callback that’s passed to rust_future_poll
• RustTaskCallback
  Callback for a Rust task, this is what the foreign executor invokes