Struct neon::event::EventQueue

pub struct EventQueue { /* fields omitted */ }

Queue for scheduling Rust closures to execute on the JavaScript main thread.

Example

The following example spawns a standard Rust thread to complete a computation and calls back to a JavaScript function asynchronously with the result.

fn async_fibonacci(mut cx: FunctionContext) -> JsResult<JsUndefined> {
    // These types (`f64`, `Root<JsFunction>`, `EventQueue`) may all be sent
    // across threads.
    let n = cx.argument::<JsNumber>(0)?.value(&mut cx);
    let callback = cx.argument::<JsFunction>(1)?.root(&mut cx);
    let queue = cx.queue();

    // Spawn a thread to complete the execution. This will _not_ block the
    // JavaScript event loop.
    std::thread::spawn(move || {
        let result = fibonacci(n);

        // Send a closure as a task to be executed by the JavaScript event
        // queue. This _will_ block the event queue while executing.
        queue.send(move |mut cx| {
            let callback = callback.into_inner(&mut cx);
            let this = cx.undefined();
            let null = cx.null();
            let args = vec![
                cx.null().upcast::<JsValue>(),
                cx.number(result).upcast(),
            ];

            callback.call(&mut cx, this, args)?;

            Ok(())
        });
    });

    Ok(cx.undefined())
}

Implementations

impl EventQueue

pub fn new<'a, C: Context<'a>>(cx: &mut C) -> Self

Creates an unbounded queue for scheduling closures on the JavaScript main thread

pub fn unref<'a, C: Context<'a>>(&mut self, cx: &mut C) -> &mut Self

Allow the Node event loop to exit while this EventQueue exists. Idempotent

pub fn reference<'a, C: Context<'a>>(&mut self, cx: &mut C) -> &mut Self

Prevent the Node event loop from exiting while this EventQueue exists. (Default) Idempotent

pub fn send<F>(&self, f: F) where
    F: FnOnce(TaskContext<'_>) -> NeonResult<()> + Send + 'static, 

Schedules a closure to execute on the JavaScript thread that created this EventQueue Panics if there is a libuv error

pub fn try_send<F>(&self, f: F) -> Result<(), EventQueueError> where
    F: FnOnce(TaskContext<'_>) -> NeonResult<()> + Send + 'static, 

Schedules a closure to execute on the JavaScript thread that created this EventQueue Returns an Error if the task could not be scheduled.

pub fn has_ref(&self) -> bool

Returns a boolean indicating if this EventQueue will prevent the Node event queue from exiting.

Trait Implementations

impl Debug for EventQueue

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.