Struct deno_core::CoreIsolate

pub struct CoreIsolate { /* fields omitted */ }

A single execution context of JavaScript. Corresponds roughly to the "Web Worker" concept in the DOM. An CoreIsolate is a Future that can be used with Tokio. The CoreIsolate 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 CoreIsolate

pub fn new(startup_data: StartupData<'_>, will_snapshot: bool) -> Self

startup_data defines the snapshot or script used at startup to initialize the isolate.

pub fn with_heap_limits(
    startup_data: StartupData<'_>,
    heap_limits: HeapLimits
) -> Self

This is useful for controlling memory usage of scripts.

See HeapLimits for more details.

Make sure to use add_near_heap_limit_callback to prevent v8 from crashing when reaching the upper limit.

pub fn state(isolate: &Isolate) -> Rc<RefCell<CoreIsolateState>>

pub fn execute(
    &mut self,
    js_filename: &str,
    js_source: &str
) -> Result<(), ErrBox>

Executes traditional JavaScript code (traditional = not ES modules)

ErrBox 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 CoreIsolate::set_js_error_create_fn() has been used.

pub fn snapshot(&mut self) -> StartupData

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

ErrBox 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 CoreIsolate::set_js_error_create_fn() has been used.

pub fn register_op<F>(&mut self, name: &str, op: F) -> OpId where
    F: Fn(&mut CoreIsolateState, &mut [ZeroCopyBuf]) -> Op + 'static, 

Defines the how Deno.core.dispatch() acts. Called whenever Deno.core.dispatch() is called in JavaScript. zero_copy_buf corresponds to the second argument of Deno.core.dispatch().

Requires runtime to explicitly ask for op ids before using any of the ops.

pub fn register_op_json_sync<F>(&mut self, name: &str, op: F) -> OpId where
    F: 'static + Fn(&mut CoreIsolateState, Value, &mut [ZeroCopyBuf]) -> Result<Value, ErrBox>, 

pub fn register_op_json_async<F, Fut>(&mut self, name: &str, op: F) -> OpId where
    Fut: 'static + Future<Output = Result<Value, ErrBox>>,
    F: 'static + Fn(&mut CoreIsolateState, Value, &mut [ZeroCopyBuf]) -> Fut, 

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

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)

Trait Implementations

impl Deref for CoreIsolate

type Target = Isolate

The resulting type after dereferencing.

fn deref(&self) -> &Isolate

Dereferences the value.

impl DerefMut for CoreIsolate

fn deref_mut(&mut self) -> &mut Isolate

Mutably dereferences the value.

impl Drop for CoreIsolate

fn drop(&mut self)

Executes the destructor for this type.

impl Future for CoreIsolate

type Output = Result<(), ErrBox>

The type of value produced on completion.

fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output>

Attempt to resolve the future to a final value, registering the current task for wakeup if the value is not yet available.