Struct SimpleHandler

pub struct SimpleHandler<E: Executor, EL: ErrorListener> { /* private fields */ }

The simple handler uses a simple thread pool to execute tasks.

Implementations

impl<TP: BaseThreadPool> SimpleHandler<SimpleExecutor<NoOpErrorListener, TP, SimpleAsyncRuntime>, NoOpErrorListener>

pub fn new_simple(thread_pool: TP) -> Self

pub fn thread_pool(&self) -> &TP

pub fn async_runtime(&self) -> &SimpleAsyncRuntime

impl<E: Executor, H: ErrorListener> SimpleHandler<E, H>

pub fn new(executor: E, error_listener: H) -> Self

Create a new default handler.

Trait Implementations

impl<E: Executor, EL: ErrorListener> Handler for SimpleHandler<E, EL>

fn wrap_normal<Rust2DartCodec, PrepareFn, TaskFn>( &self, task_info: TaskInfo, prepare: PrepareFn, )

where PrepareFn: FnOnce() -> TaskFn, TaskFn: FnOnce(TaskContext) -> Result<Rust2DartCodec::Message, Rust2DartCodec::Message> + Send + 'static, Rust2DartCodec: BaseCodec,

Prepares the arguments, executes a Rust function and sets up its return value.

fn wrap_sync<Rust2DartCodec, SyncTaskFn>( &self, task_info: TaskInfo, sync_task: SyncTaskFn, ) -> <Rust2DartCodec::Message as Rust2DartMessageTrait>::WireSyncRust2DartType

where SyncTaskFn: FnOnce() -> Result<Rust2DartCodec::Message, Rust2DartCodec::Message>, Rust2DartCodec: BaseCodec,

Same as [wrap][Handler::wrap], but the Rust function will be called synchronously and need not implement Send.

fn wrap_async<Rust2DartCodec, PrepareFn, TaskFn, TaskRetFut>( &self, task_info: TaskInfo, prepare: PrepareFn, )

where PrepareFn: FnOnce() -> TaskFn, TaskFn: FnOnce(TaskContext) -> TaskRetFut + Send + 'static, TaskRetFut: Future<Output = Result<Rust2DartCodec::Message, Rust2DartCodec::Message>> + TaskRetFutTrait, Rust2DartCodec: BaseCodec,

Same as [wrap][Handler::wrap], but for async Rust.

fn dart_fn_invoke( &self, dart_fn: DartOpaque, args: Vec<DartAbi>, ) -> DartFnFuture<Dart2RustMessageSse>

fn dart_fn_handle_output(&self, call_id: i32, message: Dart2RustMessageSse)