Struct deno_core::JsRuntime[][src]

pub struct JsRuntime { /* fields omitted */ }

A single execution context of JavaScript. Corresponds roughly to the “Web Worker” concept in the DOM. A JsRuntime is a Future that can be used with an event loop (Tokio, async_std). The JsRuntime future completes when there is an error or when all pending ops have completed.

Ops are created in JavaScript by calling Deno.core.dispatch(), and in Rust by implementing dispatcher function that takes control buffer and optional zero copy buffer as arguments. An async Op corresponds exactly to a Promise in JavaScript.

Implementations

impl JsRuntime[src]

pub fn new(options: RuntimeOptions) -> Self[src]

Only constructor, configuration is done through options.

pub fn global_context(&mut self) -> Global<Context>[src]

pub fn v8_isolate(&mut self) -> &mut OwnedIsolate[src]

pub fn op_state(&mut self) -> Rc<RefCell<OpState>>[src]

Returns the runtime’s op state, which can be used to maintain ops and access resources between op calls.

pub fn execute(
    &mut self,
    js_filename: &str,
    js_source: &str
) -> Result<(), AnyError>
[src]

Executes traditional JavaScript code (traditional = not ES modules)

The execution takes place on the current global context, so it is possible to maintain local JS state and invoke this method multiple times.

AnyError can be downcast to a type that exposes additional information about the V8 exception. By default this type is JsError, however it may be a different type if RuntimeOptions::js_error_create_fn has been set.

pub fn snapshot(&mut self) -> StartupData[src]

Takes a snapshot. The isolate should have been created with will_snapshot set to true.

AnyError can be downcast to a type that exposes additional information about the V8 exception. By default this type is JsError, however it may be a different type if RuntimeOptions::js_error_create_fn has been set.

pub fn register_op<F>(&mut self, name: &str, op_fn: F) -> OpId where
    F: Fn(Rc<RefCell<OpState>>, OpPayload<'_, '_, '_>, Option<ZeroCopyBuf>) -> Op + 'static, 
[src]

Registers an op that can be called from JavaScript.

The op mechanism allows to expose Rust functions to the JS runtime, which can be called using the provided name.

This function provides byte-level bindings. To pass data via JSON, the following functions can be passed as an argument for op_fn:

pub fn add_near_heap_limit_callback<C>(&mut self, cb: C) where
    C: FnMut(usize, usize) -> usize + 'static, 
[src]

Registers a callback on the isolate when the memory limits are approached. Use this to prevent V8 from crashing the process when reaching the limit.

Calls the closure with the current heap limit and the initial heap limit. The return value of the closure is set as the new limit.

pub fn remove_near_heap_limit_callback(&mut self, heap_limit: usize)[src]

pub async fn run_event_loop(&mut self) -> Result<(), AnyError>[src]

Runs event loop to completion

This future resolves when:

  • there are no more pending dynamic imports
  • there are no more pending ops

pub fn poll_event_loop(
    &mut self,
    cx: &mut Context<'_>
) -> Poll<Result<(), AnyError>>
[src]

Runs a single tick of event loop

impl JsRuntime[src]

pub fn dyn_mod_evaluate(
    &mut self,
    load_id: ModuleLoadId,
    id: ModuleId
) -> Result<(), AnyError>
[src]

Evaluates an already instantiated ES module.

AnyError can be downcast to a type that exposes additional information about the V8 exception. By default this type is JsError, however it may be a different type if RuntimeOptions::js_error_create_fn has been set.

pub fn mod_evaluate(&mut self, id: ModuleId) -> Receiver<Result<(), AnyError>>[src]

Evaluates an already instantiated ES module.

Returns a receiver handle that resolves when module promise resolves. Implementors must manually call run_event_loop() to drive module evaluation future.

AnyError can be downcast to a type that exposes additional information about the V8 exception. By default this type is JsError, however it may be a different type if RuntimeOptions::js_error_create_fn has been set.

This function panics if module has not been instantiated.

pub async fn load_module(
    &mut self,
    specifier: &ModuleSpecifier,
    code: Option<String>
) -> Result<ModuleId, AnyError>
[src]

Asynchronously load specified module and all of its dependencies

User must call JsRuntime::mod_evaluate with returned ModuleId manually after load is finished.

Trait Implementations

impl Drop for JsRuntime[src]

Auto Trait Implementations

impl !RefUnwindSafe for JsRuntime

impl !Send for JsRuntime

impl !Sync for JsRuntime

impl Unpin for JsRuntime

impl !UnwindSafe for JsRuntime

Blanket Implementations

impl<T> Any for T where
    T: 'static + ?Sized
[src]

impl<T> Borrow<T> for T where
    T: ?Sized
[src]

impl<T> BorrowMut<T> for T where
    T: ?Sized
[src]

impl<T> From<T> for T[src]

impl<T, U> Into<U> for T where
    U: From<T>, 
[src]

impl<T, U> TryFrom<U> for T where
    U: Into<T>, 
[src]

type Error = Infallible

The type returned in the event of a conversion error.

impl<T, U> TryInto<U> for T where
    U: TryFrom<T>, 
[src]

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.