Struct rhai::module_resolvers::StaticModuleResolver

pub struct StaticModuleResolver(_);

A static module resolution service that serves modules added into it.

Example

use rhai::{Engine, Module};
use rhai::module_resolvers::StaticModuleResolver;

let mut resolver = StaticModuleResolver::new();

let module = Module::new();
resolver.insert("hello", module);

let mut engine = Engine::new();

engine.set_module_resolver(resolver);

Implementations

impl StaticModuleResolver

pub fn new() -> Self

Create a new StaticModuleResolver.

Example

use rhai::{Engine, Module};
use rhai::module_resolvers::StaticModuleResolver;

let mut resolver = StaticModuleResolver::new();

let module = Module::new();
resolver.insert("hello", module);

let mut engine = Engine::new();
engine.set_module_resolver(resolver);

pub fn insert(&mut self, path: impl Into<Identifier>, module: Module)

Add a module keyed by its path.

pub fn remove(&mut self, path: &str) -> Option<Shared<Module>>

Remove a module given its path.

pub fn contains_path(&self, path: &str) -> bool

Does the path exist?

pub fn iter(&self) -> impl Iterator<Item = (&str, &Shared<Module>)>

Get an iterator of all the modules.

pub fn iter_mut(&mut self) -> impl Iterator<Item = (&str, &mut Shared<Module>)>

Get a mutable iterator of all the modules.

pub fn paths(&self) -> impl Iterator<Item = &str>

Get an iterator of all the module paths.

pub fn values(&self) -> impl Iterator<Item = &Shared<Module>>

Get an iterator of all the modules.

pub fn clear(&mut self) -> &mut Self

Remove all modules.

pub fn is_empty(&self) -> bool

Is this StaticModuleResolver empty?

pub fn len(&self) -> usize

Get the number of modules in this StaticModuleResolver.

pub fn merge(&mut self, other: Self) -> &mut Self

Merge another StaticModuleResolver into this. The other StaticModuleResolver is consumed.

Existing modules of the same path name are overwritten.

Trait Implementations

impl AddAssign<StaticModuleResolver> for StaticModuleResolver

fn add_assign(&mut self, rhs: Self)

Performs the += operation.

impl Clone for StaticModuleResolver

fn clone(&self) -> StaticModuleResolver

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for StaticModuleResolver

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

Formats the value using the given formatter.

impl Default for StaticModuleResolver

fn default() -> StaticModuleResolver

Returns the “default value” for a type.

impl IntoIterator for StaticModuleResolver

type Item = (SmartString<LazyCompact>, Rc<Module>)

The type of the elements being iterated over.

type IntoIter = IntoIter<SmartString<LazyCompact>, Rc<Module>>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl ModuleResolver for StaticModuleResolver

fn resolve(
    &self,
    _: &Engine,
    _: Option<&str>,
    path: &str,
    pos: Position
) -> Result<Shared<Module>, Box<EvalAltResult>>

Resolve a module based on a path string.

fn resolve_raw(
    &self,
    engine: &Engine,
    global: &mut GlobalRuntimeState<'_>,
    path: &str,
    pos: Position
) -> Result<Shared<Module>, Box<EvalAltResult>>

Resolve a module based on a path string, given a GlobalRuntimeState.

fn resolve_ast(
    &self,
    engine: &Engine,
    source: Option<&str>,
    path: &str,
    pos: Position
) -> Option<Result<AST, Box<EvalAltResult>>>

Resolve an AST based on a path string.