Struct DefaultWorker 

pub struct DefaultWorker(/* private fields */);

Available on crate feature worker only.

A worker implementation that uses the default runtime This is the simplest way to use the worker, as it requires no additional setup It attempts to provide as much functionality as possible from the standard runtime

Please note that it uses serde_json::Value for queries and responses, which comes with a performance cost For a more performant worker, or to use extensions and/or loader caches, you’ll need to implement your own worker

Implementations

impl DefaultWorker

pub fn new(options: DefaultWorkerOptions) -> Result<Self, Error>

Create a new worker instance

Errors

Can fail if the runtime cannot be initialized (usually due to extension issues)

pub fn as_worker(&self) -> &Worker<DefaultWorker>

Get a reference to the underlying worker instance

pub fn eval<T>(&self, code: String) -> Result<T, Error>

where T: DeserializeOwned,

Evaluate a string of javascript code Returns the result of the evaluation

Errors

Can fail a runtime error occurs during evaluation, or if the return value cannot be deserialized into the requested type

pub fn load_main_module(&self, module: Module) -> Result<ModuleId, Error>

Load a module into the worker as the main module Returns the module id of the loaded module

Errors

Can fail if execution of the module fails

pub fn load_module(&self, module: Module) -> Result<ModuleId, Error>

Load a module into the worker as a side module Returns the module id of the loaded module

Errors

Can fail if execution of the module fails

pub fn call_entrypoint<T>( &self, id: ModuleId, args: Vec<Value>, ) -> Result<T, Error>

where T: DeserializeOwned,

Call the entrypoint function in a module Returns the result of the function call The module id must be the id of a module loaded with load_main_module or load_module

Errors

Can fail the module is not found, if there is no entrypoint function, if the entrypoint function returns an error, Or if the return value cannot be deserialized into the requested type

pub fn call_function<T>( &self, module_context: Option<ModuleId>, name: String, args: Vec<Value>, ) -> Result<T, Error>

where T: DeserializeOwned,

Call a function in a module Returns the result of the function call The module id must be the id of a module loaded with load_main_module or load_module

Errors

Can fail if the function is not found, if the function returns an error, Or if the return value cannot be deserialized into the requested type

pub fn get_value<T>( &self, module_context: Option<ModuleId>, name: String, ) -> Result<T, Error>

where T: DeserializeOwned,

Get a value from a module The module id must be the id of a module loaded with load_main_module or load_module

Errors

Can fail if the value is not found or if the value cannot be deserialized into the requested type

Trait Implementations

impl AsRef<Worker<DefaultWorker>> for DefaultWorker

fn as_ref(&self) -> &Worker<DefaultWorker>

Converts this type into a shared reference of the (usually inferred) input type.

impl InnerWorker for DefaultWorker

type Runtime = (Runtime, HashMap<usize, ModuleHandle>)

The type of runtime used by this worker This can just be rustyscript::Runtime if you don’t need to use a custom runtime

type RuntimeOptions = DefaultWorkerOptions

The type of options that can be used to initialize the runtime Cannot be rustyscript::RuntimeOptions because it is not Send

type Query = DefaultWorkerQuery

The type of query that can be sent to the worker This should be an enum that contains all possible queries

type Response = DefaultWorkerResponse

The type of response that can be received from the worker This should be an enum that contains all possible responses

fn init_runtime(options: Self::RuntimeOptions) -> Result<Self::Runtime, Error>

Initialize the runtime used by the worker This should return a new instance of the runtime that will respond to queries

fn handle_query( runtime: &mut Self::Runtime, query: Self::Query, ) -> Self::Response

Handle a query sent to the worker Must always return a response of some kind

fn thread( runtime: Self::Runtime, rx: Receiver<Self::Query>, tx: Sender<Self::Response>, )

The main thread function that will be run by the worker This should handle all incoming queries and send responses back